Fawkes API Fawkes Development Version
OpenCVStereoParamsInterface.cpp
1
2/***************************************************************************
3 * OpenCVStereoParamsInterface.cpp - Fawkes BlackBoard Interface - OpenCVStereoParamsInterface
4 *
5 * Templated created: Thu Oct 12 10:49:19 2006
6 * Copyright 2013 Tim Niemueller
7 *
8 ****************************************************************************/
9
10/* This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version. A runtime exception applies to
14 * this software (see LICENSE.GPL_WRE file mentioned below for details).
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Library General Public License for more details.
20 *
21 * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
22 */
23
24#include <interfaces/OpenCVStereoParamsInterface.h>
25
26#include <core/exceptions/software.h>
27
28#include <map>
29#include <string>
30#include <cstring>
31#include <cstdlib>
32
33namespace fawkes {
34
35/** @class OpenCVStereoParamsInterface <interfaces/OpenCVStereoParamsInterface.h>
36 * OpenCVStereoParamsInterface Fawkes BlackBoard Interface.
37 *
38 Read and set stereo processing parameters of the OpenCV stereo
39 correspondence matching module.
40
41 * @ingroup FawkesInterfaces
42 */
43
44
45
46/** Constructor */
47OpenCVStereoParamsInterface::OpenCVStereoParamsInterface() : Interface()
48{
49 data_size = sizeof(OpenCVStereoParamsInterface_data_t);
50 data_ptr = malloc(data_size);
51 data = (OpenCVStereoParamsInterface_data_t *)data_ptr;
52 data_ts = (interface_data_ts_t *)data_ptr;
53 memset(data_ptr, 0, data_size);
54 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
55 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
56 add_fieldinfo(IFT_ENUM, "pre_filter_type", 1, &data->pre_filter_type, "PreFilterType", &enum_map_PreFilterType);
57 add_fieldinfo(IFT_UINT32, "pre_filter_size", 1, &data->pre_filter_size);
58 add_fieldinfo(IFT_UINT32, "pre_filter_cap", 1, &data->pre_filter_cap);
59 add_fieldinfo(IFT_UINT32, "sad_window_size", 1, &data->sad_window_size);
60 add_fieldinfo(IFT_INT32, "min_disparity", 1, &data->min_disparity);
61 add_fieldinfo(IFT_UINT32, "num_disparities", 1, &data->num_disparities);
62 add_fieldinfo(IFT_UINT32, "texture_threshold", 1, &data->texture_threshold);
63 add_fieldinfo(IFT_UINT32, "uniqueness_ratio", 1, &data->uniqueness_ratio);
64 add_fieldinfo(IFT_UINT32, "speckle_window_size", 1, &data->speckle_window_size);
65 add_fieldinfo(IFT_UINT32, "speckle_range", 1, &data->speckle_range);
66 add_fieldinfo(IFT_BOOL, "try_smaller_windows", 1, &data->try_smaller_windows);
67 add_messageinfo("SetPreFilterTypeMessage");
68 add_messageinfo("SetPreFilterSizeMessage");
69 add_messageinfo("SetPreFilterCapMessage");
70 add_messageinfo("SetSADWindowSizeMessage");
71 add_messageinfo("SetMinDisparityMessage");
72 add_messageinfo("SetNumDisparitiesMessage");
73 add_messageinfo("SetTextureThresholdMessage");
74 add_messageinfo("SetUniquenessRatioMessage");
75 add_messageinfo("SetSpeckleWindowSizeMessage");
76 add_messageinfo("SetSpeckleRangeMessage");
77 add_messageinfo("SetTrySmallerWindowsMessage");
78 unsigned char tmp_hash[] = {0x3a, 0x8e, 0x8c, 0x21, 0xea, 0x8c, 0x83, 0x29, 0x91, 0xdd, 0x5f, 0x5f, 0x16, 0xbf, 0x5f, 0xa6};
79 set_hash(tmp_hash);
80}
81
82/** Destructor */
83OpenCVStereoParamsInterface::~OpenCVStereoParamsInterface()
84{
85 free(data_ptr);
86}
87/** Convert PreFilterType constant to string.
88 * @param value value to convert to string
89 * @return constant value as string.
90 */
91const char *
92OpenCVStereoParamsInterface::tostring_PreFilterType(PreFilterType value) const
93{
94 switch (value) {
95 case PFT_NORMALIZED_RESPONSE: return "PFT_NORMALIZED_RESPONSE";
96 case PFT_XSOBEL: return "PFT_XSOBEL";
97 default: return "UNKNOWN";
98 }
99}
100/* Methods */
101/** Get pre_filter_type value.
102 * Pre-filtering method.
103 * @return pre_filter_type value
104 */
106OpenCVStereoParamsInterface::pre_filter_type() const
107{
108 return (OpenCVStereoParamsInterface::PreFilterType)data->pre_filter_type;
109}
110
111/** Get maximum length of pre_filter_type value.
112 * @return length of pre_filter_type value, can be length of the array or number of
113 * maximum number of characters for a string
114 */
115size_t
116OpenCVStereoParamsInterface::maxlenof_pre_filter_type() const
117{
118 return 1;
119}
120
121/** Set pre_filter_type value.
122 * Pre-filtering method.
123 * @param new_pre_filter_type new pre_filter_type value
124 */
125void
126OpenCVStereoParamsInterface::set_pre_filter_type(const PreFilterType new_pre_filter_type)
127{
128 set_field(data->pre_filter_type, new_pre_filter_type);
129}
130
131/** Get pre_filter_size value.
132 *
133 Averaging window size: ~5x5..21x21.
134
135 * @return pre_filter_size value
136 */
137uint32_t
138OpenCVStereoParamsInterface::pre_filter_size() const
139{
140 return data->pre_filter_size;
141}
142
143/** Get maximum length of pre_filter_size value.
144 * @return length of pre_filter_size value, can be length of the array or number of
145 * maximum number of characters for a string
146 */
147size_t
148OpenCVStereoParamsInterface::maxlenof_pre_filter_size() const
149{
150 return 1;
151}
152
153/** Set pre_filter_size value.
154 *
155 Averaging window size: ~5x5..21x21.
156
157 * @param new_pre_filter_size new pre_filter_size value
158 */
159void
160OpenCVStereoParamsInterface::set_pre_filter_size(const uint32_t new_pre_filter_size)
161{
162 set_field(data->pre_filter_size, new_pre_filter_size);
163}
164
165/** Get pre_filter_cap value.
166 *
167 The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
168
169 * @return pre_filter_cap value
170 */
171uint32_t
172OpenCVStereoParamsInterface::pre_filter_cap() const
173{
174 return data->pre_filter_cap;
175}
176
177/** Get maximum length of pre_filter_cap value.
178 * @return length of pre_filter_cap value, can be length of the array or number of
179 * maximum number of characters for a string
180 */
181size_t
182OpenCVStereoParamsInterface::maxlenof_pre_filter_cap() const
183{
184 return 1;
185}
186
187/** Set pre_filter_cap value.
188 *
189 The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
190
191 * @param new_pre_filter_cap new pre_filter_cap value
192 */
193void
194OpenCVStereoParamsInterface::set_pre_filter_cap(const uint32_t new_pre_filter_cap)
195{
196 set_field(data->pre_filter_cap, new_pre_filter_cap);
197}
198
199/** Get sad_window_size value.
200 *
201 Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
202
203 * @return sad_window_size value
204 */
205uint32_t
206OpenCVStereoParamsInterface::sad_window_size() const
207{
208 return data->sad_window_size;
209}
210
211/** Get maximum length of sad_window_size value.
212 * @return length of sad_window_size value, can be length of the array or number of
213 * maximum number of characters for a string
214 */
215size_t
216OpenCVStereoParamsInterface::maxlenof_sad_window_size() const
217{
218 return 1;
219}
220
221/** Set sad_window_size value.
222 *
223 Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
224
225 * @param new_sad_window_size new sad_window_size value
226 */
227void
228OpenCVStereoParamsInterface::set_sad_window_size(const uint32_t new_sad_window_size)
229{
230 set_field(data->sad_window_size, new_sad_window_size);
231}
232
233/** Get min_disparity value.
234 * Minimum disparity (can be negative).
235 * @return min_disparity value
236 */
237int32_t
238OpenCVStereoParamsInterface::min_disparity() const
239{
240 return data->min_disparity;
241}
242
243/** Get maximum length of min_disparity value.
244 * @return length of min_disparity value, can be length of the array or number of
245 * maximum number of characters for a string
246 */
247size_t
248OpenCVStereoParamsInterface::maxlenof_min_disparity() const
249{
250 return 1;
251}
252
253/** Set min_disparity value.
254 * Minimum disparity (can be negative).
255 * @param new_min_disparity new min_disparity value
256 */
257void
258OpenCVStereoParamsInterface::set_min_disparity(const int32_t new_min_disparity)
259{
260 set_field(data->min_disparity, new_min_disparity);
261}
262
263/** Get num_disparities value.
264 *
265 Number of disparities (maximum disparity - minimum disparity (> 0)).
266
267 * @return num_disparities value
268 */
269uint32_t
270OpenCVStereoParamsInterface::num_disparities() const
271{
272 return data->num_disparities;
273}
274
275/** Get maximum length of num_disparities value.
276 * @return length of num_disparities value, can be length of the array or number of
277 * maximum number of characters for a string
278 */
279size_t
280OpenCVStereoParamsInterface::maxlenof_num_disparities() const
281{
282 return 1;
283}
284
285/** Set num_disparities value.
286 *
287 Number of disparities (maximum disparity - minimum disparity (> 0)).
288
289 * @param new_num_disparities new num_disparities value
290 */
291void
292OpenCVStereoParamsInterface::set_num_disparities(const uint32_t new_num_disparities)
293{
294 set_field(data->num_disparities, new_num_disparities);
295}
296
297/** Get texture_threshold value.
298 *
299 The disparity is only computed for pixels with textured enough
300 neighborhood.
301
302 * @return texture_threshold value
303 */
304uint32_t
305OpenCVStereoParamsInterface::texture_threshold() const
306{
307 return data->texture_threshold;
308}
309
310/** Get maximum length of texture_threshold value.
311 * @return length of texture_threshold value, can be length of the array or number of
312 * maximum number of characters for a string
313 */
314size_t
315OpenCVStereoParamsInterface::maxlenof_texture_threshold() const
316{
317 return 1;
318}
319
320/** Set texture_threshold value.
321 *
322 The disparity is only computed for pixels with textured enough
323 neighborhood.
324
325 * @param new_texture_threshold new texture_threshold value
326 */
327void
328OpenCVStereoParamsInterface::set_texture_threshold(const uint32_t new_texture_threshold)
329{
330 set_field(data->texture_threshold, new_texture_threshold);
331}
332
333/** Get uniqueness_ratio value.
334 *
335 Accept the computed disparity d* only if
336 SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
337 for any d != d*+/-1 within the search range.
338
339 * @return uniqueness_ratio value
340 */
341uint32_t
342OpenCVStereoParamsInterface::uniqueness_ratio() const
343{
344 return data->uniqueness_ratio;
345}
346
347/** Get maximum length of uniqueness_ratio value.
348 * @return length of uniqueness_ratio value, can be length of the array or number of
349 * maximum number of characters for a string
350 */
351size_t
352OpenCVStereoParamsInterface::maxlenof_uniqueness_ratio() const
353{
354 return 1;
355}
356
357/** Set uniqueness_ratio value.
358 *
359 Accept the computed disparity d* only if
360 SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
361 for any d != d*+/-1 within the search range.
362
363 * @param new_uniqueness_ratio new uniqueness_ratio value
364 */
365void
366OpenCVStereoParamsInterface::set_uniqueness_ratio(const uint32_t new_uniqueness_ratio)
367{
368 set_field(data->uniqueness_ratio, new_uniqueness_ratio);
369}
370
371/** Get speckle_window_size value.
372 *
373 Disparity variation window size.
374
375 * @return speckle_window_size value
376 */
377uint32_t
378OpenCVStereoParamsInterface::speckle_window_size() const
379{
380 return data->speckle_window_size;
381}
382
383/** Get maximum length of speckle_window_size value.
384 * @return length of speckle_window_size value, can be length of the array or number of
385 * maximum number of characters for a string
386 */
387size_t
388OpenCVStereoParamsInterface::maxlenof_speckle_window_size() const
389{
390 return 1;
391}
392
393/** Set speckle_window_size value.
394 *
395 Disparity variation window size.
396
397 * @param new_speckle_window_size new speckle_window_size value
398 */
399void
400OpenCVStereoParamsInterface::set_speckle_window_size(const uint32_t new_speckle_window_size)
401{
402 set_field(data->speckle_window_size, new_speckle_window_size);
403}
404
405/** Get speckle_range value.
406 *
407 Acceptable range of variation in window.
408
409 * @return speckle_range value
410 */
411uint32_t
412OpenCVStereoParamsInterface::speckle_range() const
413{
414 return data->speckle_range;
415}
416
417/** Get maximum length of speckle_range value.
418 * @return length of speckle_range value, can be length of the array or number of
419 * maximum number of characters for a string
420 */
421size_t
422OpenCVStereoParamsInterface::maxlenof_speckle_range() const
423{
424 return 1;
425}
426
427/** Set speckle_range value.
428 *
429 Acceptable range of variation in window.
430
431 * @param new_speckle_range new speckle_range value
432 */
433void
434OpenCVStereoParamsInterface::set_speckle_range(const uint32_t new_speckle_range)
435{
436 set_field(data->speckle_range, new_speckle_range);
437}
438
439/** Get try_smaller_windows value.
440 *
441 If enabled, the results may be more accurate, at the expense of
442 slower processing.
443
444 * @return try_smaller_windows value
445 */
446bool
447OpenCVStereoParamsInterface::is_try_smaller_windows() const
448{
449 return data->try_smaller_windows;
450}
451
452/** Get maximum length of try_smaller_windows value.
453 * @return length of try_smaller_windows value, can be length of the array or number of
454 * maximum number of characters for a string
455 */
456size_t
457OpenCVStereoParamsInterface::maxlenof_try_smaller_windows() const
458{
459 return 1;
460}
461
462/** Set try_smaller_windows value.
463 *
464 If enabled, the results may be more accurate, at the expense of
465 slower processing.
466
467 * @param new_try_smaller_windows new try_smaller_windows value
468 */
469void
470OpenCVStereoParamsInterface::set_try_smaller_windows(const bool new_try_smaller_windows)
471{
472 set_field(data->try_smaller_windows, new_try_smaller_windows);
473}
474
475/* =========== message create =========== */
476Message *
477OpenCVStereoParamsInterface::create_message(const char *type) const
478{
479 if ( strncmp("SetPreFilterTypeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
480 return new SetPreFilterTypeMessage();
481 } else if ( strncmp("SetPreFilterSizeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
482 return new SetPreFilterSizeMessage();
483 } else if ( strncmp("SetPreFilterCapMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
484 return new SetPreFilterCapMessage();
485 } else if ( strncmp("SetSADWindowSizeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
486 return new SetSADWindowSizeMessage();
487 } else if ( strncmp("SetMinDisparityMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
488 return new SetMinDisparityMessage();
489 } else if ( strncmp("SetNumDisparitiesMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
490 return new SetNumDisparitiesMessage();
491 } else if ( strncmp("SetTextureThresholdMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
492 return new SetTextureThresholdMessage();
493 } else if ( strncmp("SetUniquenessRatioMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
494 return new SetUniquenessRatioMessage();
495 } else if ( strncmp("SetSpeckleWindowSizeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
496 return new SetSpeckleWindowSizeMessage();
497 } else if ( strncmp("SetSpeckleRangeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
498 return new SetSpeckleRangeMessage();
499 } else if ( strncmp("SetTrySmallerWindowsMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
500 return new SetTrySmallerWindowsMessage();
501 } else {
502 throw UnknownTypeException("The given type '%s' does not match any known "
503 "message type for this interface type.", type);
504 }
505}
506
507
508/** Copy values from other interface.
509 * @param other other interface to copy values from
510 */
511void
512OpenCVStereoParamsInterface::copy_values(const Interface *other)
513{
514 const OpenCVStereoParamsInterface *oi = dynamic_cast<const OpenCVStereoParamsInterface *>(other);
515 if (oi == NULL) {
516 throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
517 type(), other->type());
518 }
519 memcpy(data, oi->data, sizeof(OpenCVStereoParamsInterface_data_t));
520}
521
522const char *
523OpenCVStereoParamsInterface::enum_tostring(const char *enumtype, int val) const
524{
525 if (strcmp(enumtype, "PreFilterType") == 0) {
526 return tostring_PreFilterType((PreFilterType)val);
527 }
528 throw UnknownTypeException("Unknown enum type %s", enumtype);
529}
530
531/* =========== messages =========== */
532/** @class OpenCVStereoParamsInterface::SetPreFilterTypeMessage <interfaces/OpenCVStereoParamsInterface.h>
533 * SetPreFilterTypeMessage Fawkes BlackBoard Interface Message.
534 *
535
536 */
537
538
539/** Constructor with initial values.
540 * @param ini_pre_filter_type initial value for pre_filter_type
541 */
542OpenCVStereoParamsInterface::SetPreFilterTypeMessage::SetPreFilterTypeMessage(const PreFilterType ini_pre_filter_type) : Message("SetPreFilterTypeMessage")
543{
544 data_size = sizeof(SetPreFilterTypeMessage_data_t);
545 data_ptr = malloc(data_size);
546 memset(data_ptr, 0, data_size);
547 data = (SetPreFilterTypeMessage_data_t *)data_ptr;
549 data->pre_filter_type = ini_pre_filter_type;
550 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
551 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
552 add_fieldinfo(IFT_ENUM, "pre_filter_type", 1, &data->pre_filter_type, "PreFilterType", &enum_map_PreFilterType);
553}
554/** Constructor */
556{
557 data_size = sizeof(SetPreFilterTypeMessage_data_t);
558 data_ptr = malloc(data_size);
559 memset(data_ptr, 0, data_size);
560 data = (SetPreFilterTypeMessage_data_t *)data_ptr;
562 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
563 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
564 add_fieldinfo(IFT_ENUM, "pre_filter_type", 1, &data->pre_filter_type, "PreFilterType", &enum_map_PreFilterType);
565}
566
567/** Destructor */
569{
570 free(data_ptr);
571}
572
573/** Copy constructor.
574 * @param m message to copy from
575 */
577{
578 data_size = m->data_size;
579 data_ptr = malloc(data_size);
580 memcpy(data_ptr, m->data_ptr, data_size);
581 data = (SetPreFilterTypeMessage_data_t *)data_ptr;
583}
584
585/* Methods */
586/** Get pre_filter_type value.
587 * Pre-filtering method.
588 * @return pre_filter_type value
589 */
592{
593 return (OpenCVStereoParamsInterface::PreFilterType)data->pre_filter_type;
594}
595
596/** Get maximum length of pre_filter_type value.
597 * @return length of pre_filter_type value, can be length of the array or number of
598 * maximum number of characters for a string
599 */
600size_t
602{
603 return 1;
604}
605
606/** Set pre_filter_type value.
607 * Pre-filtering method.
608 * @param new_pre_filter_type new pre_filter_type value
609 */
610void
612{
613 set_field(data->pre_filter_type, new_pre_filter_type);
614}
615
616/** Clone this message.
617 * Produces a message of the same type as this message and copies the
618 * data to the new message.
619 * @return clone of this message
620 */
621Message *
623{
625}
626/** @class OpenCVStereoParamsInterface::SetPreFilterSizeMessage <interfaces/OpenCVStereoParamsInterface.h>
627 * SetPreFilterSizeMessage Fawkes BlackBoard Interface Message.
628 *
629
630 */
631
632
633/** Constructor with initial values.
634 * @param ini_pre_filter_size initial value for pre_filter_size
635 */
636OpenCVStereoParamsInterface::SetPreFilterSizeMessage::SetPreFilterSizeMessage(const uint32_t ini_pre_filter_size) : Message("SetPreFilterSizeMessage")
637{
638 data_size = sizeof(SetPreFilterSizeMessage_data_t);
639 data_ptr = malloc(data_size);
640 memset(data_ptr, 0, data_size);
641 data = (SetPreFilterSizeMessage_data_t *)data_ptr;
643 data->pre_filter_size = ini_pre_filter_size;
644 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
645 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
646 add_fieldinfo(IFT_UINT32, "pre_filter_size", 1, &data->pre_filter_size);
647}
648/** Constructor */
650{
651 data_size = sizeof(SetPreFilterSizeMessage_data_t);
652 data_ptr = malloc(data_size);
653 memset(data_ptr, 0, data_size);
654 data = (SetPreFilterSizeMessage_data_t *)data_ptr;
656 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
657 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
658 add_fieldinfo(IFT_UINT32, "pre_filter_size", 1, &data->pre_filter_size);
659}
660
661/** Destructor */
663{
664 free(data_ptr);
665}
666
667/** Copy constructor.
668 * @param m message to copy from
669 */
671{
672 data_size = m->data_size;
673 data_ptr = malloc(data_size);
674 memcpy(data_ptr, m->data_ptr, data_size);
675 data = (SetPreFilterSizeMessage_data_t *)data_ptr;
677}
678
679/* Methods */
680/** Get pre_filter_size value.
681 *
682 Averaging window size: ~5x5..21x21.
683
684 * @return pre_filter_size value
685 */
686uint32_t
688{
689 return data->pre_filter_size;
690}
691
692/** Get maximum length of pre_filter_size value.
693 * @return length of pre_filter_size value, can be length of the array or number of
694 * maximum number of characters for a string
695 */
696size_t
698{
699 return 1;
700}
701
702/** Set pre_filter_size value.
703 *
704 Averaging window size: ~5x5..21x21.
705
706 * @param new_pre_filter_size new pre_filter_size value
707 */
708void
710{
711 set_field(data->pre_filter_size, new_pre_filter_size);
712}
713
714/** Clone this message.
715 * Produces a message of the same type as this message and copies the
716 * data to the new message.
717 * @return clone of this message
718 */
719Message *
721{
723}
724/** @class OpenCVStereoParamsInterface::SetPreFilterCapMessage <interfaces/OpenCVStereoParamsInterface.h>
725 * SetPreFilterCapMessage Fawkes BlackBoard Interface Message.
726 *
727
728 */
729
730
731/** Constructor with initial values.
732 * @param ini_pre_filter_cap initial value for pre_filter_cap
733 */
734OpenCVStereoParamsInterface::SetPreFilterCapMessage::SetPreFilterCapMessage(const uint32_t ini_pre_filter_cap) : Message("SetPreFilterCapMessage")
735{
736 data_size = sizeof(SetPreFilterCapMessage_data_t);
737 data_ptr = malloc(data_size);
738 memset(data_ptr, 0, data_size);
739 data = (SetPreFilterCapMessage_data_t *)data_ptr;
741 data->pre_filter_cap = ini_pre_filter_cap;
742 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
743 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
744 add_fieldinfo(IFT_UINT32, "pre_filter_cap", 1, &data->pre_filter_cap);
745}
746/** Constructor */
748{
749 data_size = sizeof(SetPreFilterCapMessage_data_t);
750 data_ptr = malloc(data_size);
751 memset(data_ptr, 0, data_size);
752 data = (SetPreFilterCapMessage_data_t *)data_ptr;
754 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
755 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
756 add_fieldinfo(IFT_UINT32, "pre_filter_cap", 1, &data->pre_filter_cap);
757}
758
759/** Destructor */
761{
762 free(data_ptr);
763}
764
765/** Copy constructor.
766 * @param m message to copy from
767 */
769{
770 data_size = m->data_size;
771 data_ptr = malloc(data_size);
772 memcpy(data_ptr, m->data_ptr, data_size);
773 data = (SetPreFilterCapMessage_data_t *)data_ptr;
775}
776
777/* Methods */
778/** Get pre_filter_cap value.
779 *
780 The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
781
782 * @return pre_filter_cap value
783 */
784uint32_t
786{
787 return data->pre_filter_cap;
788}
789
790/** Get maximum length of pre_filter_cap value.
791 * @return length of pre_filter_cap value, can be length of the array or number of
792 * maximum number of characters for a string
793 */
794size_t
796{
797 return 1;
798}
799
800/** Set pre_filter_cap value.
801 *
802 The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
803
804 * @param new_pre_filter_cap new pre_filter_cap value
805 */
806void
808{
809 set_field(data->pre_filter_cap, new_pre_filter_cap);
810}
811
812/** Clone this message.
813 * Produces a message of the same type as this message and copies the
814 * data to the new message.
815 * @return clone of this message
816 */
817Message *
819{
821}
822/** @class OpenCVStereoParamsInterface::SetSADWindowSizeMessage <interfaces/OpenCVStereoParamsInterface.h>
823 * SetSADWindowSizeMessage Fawkes BlackBoard Interface Message.
824 *
825
826 */
827
828
829/** Constructor with initial values.
830 * @param ini_sad_window_size initial value for sad_window_size
831 */
832OpenCVStereoParamsInterface::SetSADWindowSizeMessage::SetSADWindowSizeMessage(const uint32_t ini_sad_window_size) : Message("SetSADWindowSizeMessage")
833{
834 data_size = sizeof(SetSADWindowSizeMessage_data_t);
835 data_ptr = malloc(data_size);
836 memset(data_ptr, 0, data_size);
837 data = (SetSADWindowSizeMessage_data_t *)data_ptr;
839 data->sad_window_size = ini_sad_window_size;
840 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
841 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
842 add_fieldinfo(IFT_UINT32, "sad_window_size", 1, &data->sad_window_size);
843}
844/** Constructor */
846{
847 data_size = sizeof(SetSADWindowSizeMessage_data_t);
848 data_ptr = malloc(data_size);
849 memset(data_ptr, 0, data_size);
850 data = (SetSADWindowSizeMessage_data_t *)data_ptr;
852 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
853 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
854 add_fieldinfo(IFT_UINT32, "sad_window_size", 1, &data->sad_window_size);
855}
856
857/** Destructor */
859{
860 free(data_ptr);
861}
862
863/** Copy constructor.
864 * @param m message to copy from
865 */
867{
868 data_size = m->data_size;
869 data_ptr = malloc(data_size);
870 memcpy(data_ptr, m->data_ptr, data_size);
871 data = (SetSADWindowSizeMessage_data_t *)data_ptr;
873}
874
875/* Methods */
876/** Get sad_window_size value.
877 *
878 Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
879
880 * @return sad_window_size value
881 */
882uint32_t
884{
885 return data->sad_window_size;
886}
887
888/** Get maximum length of sad_window_size value.
889 * @return length of sad_window_size value, can be length of the array or number of
890 * maximum number of characters for a string
891 */
892size_t
894{
895 return 1;
896}
897
898/** Set sad_window_size value.
899 *
900 Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
901
902 * @param new_sad_window_size new sad_window_size value
903 */
904void
906{
907 set_field(data->sad_window_size, new_sad_window_size);
908}
909
910/** Clone this message.
911 * Produces a message of the same type as this message and copies the
912 * data to the new message.
913 * @return clone of this message
914 */
915Message *
917{
919}
920/** @class OpenCVStereoParamsInterface::SetMinDisparityMessage <interfaces/OpenCVStereoParamsInterface.h>
921 * SetMinDisparityMessage Fawkes BlackBoard Interface Message.
922 *
923
924 */
925
926
927/** Constructor with initial values.
928 * @param ini_min_disparity initial value for min_disparity
929 */
930OpenCVStereoParamsInterface::SetMinDisparityMessage::SetMinDisparityMessage(const int32_t ini_min_disparity) : Message("SetMinDisparityMessage")
931{
932 data_size = sizeof(SetMinDisparityMessage_data_t);
933 data_ptr = malloc(data_size);
934 memset(data_ptr, 0, data_size);
935 data = (SetMinDisparityMessage_data_t *)data_ptr;
937 data->min_disparity = ini_min_disparity;
938 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
939 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
940 add_fieldinfo(IFT_INT32, "min_disparity", 1, &data->min_disparity);
941}
942/** Constructor */
944{
945 data_size = sizeof(SetMinDisparityMessage_data_t);
946 data_ptr = malloc(data_size);
947 memset(data_ptr, 0, data_size);
948 data = (SetMinDisparityMessage_data_t *)data_ptr;
950 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
951 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
952 add_fieldinfo(IFT_INT32, "min_disparity", 1, &data->min_disparity);
953}
954
955/** Destructor */
957{
958 free(data_ptr);
959}
960
961/** Copy constructor.
962 * @param m message to copy from
963 */
965{
966 data_size = m->data_size;
967 data_ptr = malloc(data_size);
968 memcpy(data_ptr, m->data_ptr, data_size);
969 data = (SetMinDisparityMessage_data_t *)data_ptr;
971}
972
973/* Methods */
974/** Get min_disparity value.
975 * Minimum disparity (can be negative).
976 * @return min_disparity value
977 */
978int32_t
980{
981 return data->min_disparity;
982}
983
984/** Get maximum length of min_disparity value.
985 * @return length of min_disparity value, can be length of the array or number of
986 * maximum number of characters for a string
987 */
988size_t
990{
991 return 1;
992}
993
994/** Set min_disparity value.
995 * Minimum disparity (can be negative).
996 * @param new_min_disparity new min_disparity value
997 */
998void
1000{
1001 set_field(data->min_disparity, new_min_disparity);
1002}
1003
1004/** Clone this message.
1005 * Produces a message of the same type as this message and copies the
1006 * data to the new message.
1007 * @return clone of this message
1008 */
1009Message *
1011{
1013}
1014/** @class OpenCVStereoParamsInterface::SetNumDisparitiesMessage <interfaces/OpenCVStereoParamsInterface.h>
1015 * SetNumDisparitiesMessage Fawkes BlackBoard Interface Message.
1016 *
1017
1018 */
1019
1020
1021/** Constructor with initial values.
1022 * @param ini_num_disparities initial value for num_disparities
1023 */
1024OpenCVStereoParamsInterface::SetNumDisparitiesMessage::SetNumDisparitiesMessage(const uint32_t ini_num_disparities) : Message("SetNumDisparitiesMessage")
1025{
1026 data_size = sizeof(SetNumDisparitiesMessage_data_t);
1027 data_ptr = malloc(data_size);
1028 memset(data_ptr, 0, data_size);
1029 data = (SetNumDisparitiesMessage_data_t *)data_ptr;
1031 data->num_disparities = ini_num_disparities;
1032 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1033 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1034 add_fieldinfo(IFT_UINT32, "num_disparities", 1, &data->num_disparities);
1035}
1036/** Constructor */
1038{
1039 data_size = sizeof(SetNumDisparitiesMessage_data_t);
1040 data_ptr = malloc(data_size);
1041 memset(data_ptr, 0, data_size);
1042 data = (SetNumDisparitiesMessage_data_t *)data_ptr;
1044 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1045 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1046 add_fieldinfo(IFT_UINT32, "num_disparities", 1, &data->num_disparities);
1047}
1048
1049/** Destructor */
1051{
1052 free(data_ptr);
1053}
1054
1055/** Copy constructor.
1056 * @param m message to copy from
1057 */
1059{
1060 data_size = m->data_size;
1061 data_ptr = malloc(data_size);
1062 memcpy(data_ptr, m->data_ptr, data_size);
1063 data = (SetNumDisparitiesMessage_data_t *)data_ptr;
1065}
1066
1067/* Methods */
1068/** Get num_disparities value.
1069 *
1070 Number of disparities (maximum disparity - minimum disparity (> 0)).
1071
1072 * @return num_disparities value
1073 */
1074uint32_t
1076{
1077 return data->num_disparities;
1078}
1079
1080/** Get maximum length of num_disparities value.
1081 * @return length of num_disparities value, can be length of the array or number of
1082 * maximum number of characters for a string
1083 */
1084size_t
1086{
1087 return 1;
1088}
1089
1090/** Set num_disparities value.
1091 *
1092 Number of disparities (maximum disparity - minimum disparity (> 0)).
1093
1094 * @param new_num_disparities new num_disparities value
1095 */
1096void
1098{
1099 set_field(data->num_disparities, new_num_disparities);
1100}
1101
1102/** Clone this message.
1103 * Produces a message of the same type as this message and copies the
1104 * data to the new message.
1105 * @return clone of this message
1106 */
1107Message *
1109{
1111}
1112/** @class OpenCVStereoParamsInterface::SetTextureThresholdMessage <interfaces/OpenCVStereoParamsInterface.h>
1113 * SetTextureThresholdMessage Fawkes BlackBoard Interface Message.
1114 *
1115
1116 */
1117
1118
1119/** Constructor with initial values.
1120 * @param ini_texture_threshold initial value for texture_threshold
1121 */
1122OpenCVStereoParamsInterface::SetTextureThresholdMessage::SetTextureThresholdMessage(const uint32_t ini_texture_threshold) : Message("SetTextureThresholdMessage")
1123{
1124 data_size = sizeof(SetTextureThresholdMessage_data_t);
1125 data_ptr = malloc(data_size);
1126 memset(data_ptr, 0, data_size);
1127 data = (SetTextureThresholdMessage_data_t *)data_ptr;
1129 data->texture_threshold = ini_texture_threshold;
1130 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1131 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1132 add_fieldinfo(IFT_UINT32, "texture_threshold", 1, &data->texture_threshold);
1133}
1134/** Constructor */
1136{
1137 data_size = sizeof(SetTextureThresholdMessage_data_t);
1138 data_ptr = malloc(data_size);
1139 memset(data_ptr, 0, data_size);
1140 data = (SetTextureThresholdMessage_data_t *)data_ptr;
1142 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1143 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1144 add_fieldinfo(IFT_UINT32, "texture_threshold", 1, &data->texture_threshold);
1145}
1146
1147/** Destructor */
1149{
1150 free(data_ptr);
1151}
1152
1153/** Copy constructor.
1154 * @param m message to copy from
1155 */
1157{
1158 data_size = m->data_size;
1159 data_ptr = malloc(data_size);
1160 memcpy(data_ptr, m->data_ptr, data_size);
1161 data = (SetTextureThresholdMessage_data_t *)data_ptr;
1163}
1164
1165/* Methods */
1166/** Get texture_threshold value.
1167 *
1168 The disparity is only computed for pixels with textured enough
1169 neighborhood.
1170
1171 * @return texture_threshold value
1172 */
1173uint32_t
1175{
1176 return data->texture_threshold;
1177}
1178
1179/** Get maximum length of texture_threshold value.
1180 * @return length of texture_threshold value, can be length of the array or number of
1181 * maximum number of characters for a string
1182 */
1183size_t
1185{
1186 return 1;
1187}
1188
1189/** Set texture_threshold value.
1190 *
1191 The disparity is only computed for pixels with textured enough
1192 neighborhood.
1193
1194 * @param new_texture_threshold new texture_threshold value
1195 */
1196void
1198{
1199 set_field(data->texture_threshold, new_texture_threshold);
1200}
1201
1202/** Clone this message.
1203 * Produces a message of the same type as this message and copies the
1204 * data to the new message.
1205 * @return clone of this message
1206 */
1207Message *
1209{
1211}
1212/** @class OpenCVStereoParamsInterface::SetUniquenessRatioMessage <interfaces/OpenCVStereoParamsInterface.h>
1213 * SetUniquenessRatioMessage Fawkes BlackBoard Interface Message.
1214 *
1215
1216 */
1217
1218
1219/** Constructor with initial values.
1220 * @param ini_uniqueness_ratio initial value for uniqueness_ratio
1221 */
1222OpenCVStereoParamsInterface::SetUniquenessRatioMessage::SetUniquenessRatioMessage(const uint32_t ini_uniqueness_ratio) : Message("SetUniquenessRatioMessage")
1223{
1224 data_size = sizeof(SetUniquenessRatioMessage_data_t);
1225 data_ptr = malloc(data_size);
1226 memset(data_ptr, 0, data_size);
1227 data = (SetUniquenessRatioMessage_data_t *)data_ptr;
1229 data->uniqueness_ratio = ini_uniqueness_ratio;
1230 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1231 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1232 add_fieldinfo(IFT_UINT32, "uniqueness_ratio", 1, &data->uniqueness_ratio);
1233}
1234/** Constructor */
1236{
1237 data_size = sizeof(SetUniquenessRatioMessage_data_t);
1238 data_ptr = malloc(data_size);
1239 memset(data_ptr, 0, data_size);
1240 data = (SetUniquenessRatioMessage_data_t *)data_ptr;
1242 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1243 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1244 add_fieldinfo(IFT_UINT32, "uniqueness_ratio", 1, &data->uniqueness_ratio);
1245}
1246
1247/** Destructor */
1249{
1250 free(data_ptr);
1251}
1252
1253/** Copy constructor.
1254 * @param m message to copy from
1255 */
1257{
1258 data_size = m->data_size;
1259 data_ptr = malloc(data_size);
1260 memcpy(data_ptr, m->data_ptr, data_size);
1261 data = (SetUniquenessRatioMessage_data_t *)data_ptr;
1263}
1264
1265/* Methods */
1266/** Get uniqueness_ratio value.
1267 *
1268 Accept the computed disparity d* only if
1269 SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
1270 for any d != d*+/-1 within the search range.
1271
1272 * @return uniqueness_ratio value
1273 */
1274uint32_t
1276{
1277 return data->uniqueness_ratio;
1278}
1279
1280/** Get maximum length of uniqueness_ratio value.
1281 * @return length of uniqueness_ratio value, can be length of the array or number of
1282 * maximum number of characters for a string
1283 */
1284size_t
1286{
1287 return 1;
1288}
1289
1290/** Set uniqueness_ratio value.
1291 *
1292 Accept the computed disparity d* only if
1293 SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
1294 for any d != d*+/-1 within the search range.
1295
1296 * @param new_uniqueness_ratio new uniqueness_ratio value
1297 */
1298void
1300{
1301 set_field(data->uniqueness_ratio, new_uniqueness_ratio);
1302}
1303
1304/** Clone this message.
1305 * Produces a message of the same type as this message and copies the
1306 * data to the new message.
1307 * @return clone of this message
1308 */
1309Message *
1311{
1313}
1314/** @class OpenCVStereoParamsInterface::SetSpeckleWindowSizeMessage <interfaces/OpenCVStereoParamsInterface.h>
1315 * SetSpeckleWindowSizeMessage Fawkes BlackBoard Interface Message.
1316 *
1317
1318 */
1319
1320
1321/** Constructor with initial values.
1322 * @param ini_speckle_window_size initial value for speckle_window_size
1323 */
1324OpenCVStereoParamsInterface::SetSpeckleWindowSizeMessage::SetSpeckleWindowSizeMessage(const uint32_t ini_speckle_window_size) : Message("SetSpeckleWindowSizeMessage")
1325{
1326 data_size = sizeof(SetSpeckleWindowSizeMessage_data_t);
1327 data_ptr = malloc(data_size);
1328 memset(data_ptr, 0, data_size);
1329 data = (SetSpeckleWindowSizeMessage_data_t *)data_ptr;
1331 data->speckle_window_size = ini_speckle_window_size;
1332 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1333 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1334 add_fieldinfo(IFT_UINT32, "speckle_window_size", 1, &data->speckle_window_size);
1335}
1336/** Constructor */
1338{
1339 data_size = sizeof(SetSpeckleWindowSizeMessage_data_t);
1340 data_ptr = malloc(data_size);
1341 memset(data_ptr, 0, data_size);
1342 data = (SetSpeckleWindowSizeMessage_data_t *)data_ptr;
1344 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1345 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1346 add_fieldinfo(IFT_UINT32, "speckle_window_size", 1, &data->speckle_window_size);
1347}
1348
1349/** Destructor */
1351{
1352 free(data_ptr);
1353}
1354
1355/** Copy constructor.
1356 * @param m message to copy from
1357 */
1359{
1360 data_size = m->data_size;
1361 data_ptr = malloc(data_size);
1362 memcpy(data_ptr, m->data_ptr, data_size);
1363 data = (SetSpeckleWindowSizeMessage_data_t *)data_ptr;
1365}
1366
1367/* Methods */
1368/** Get speckle_window_size value.
1369 *
1370 Disparity variation window size.
1371
1372 * @return speckle_window_size value
1373 */
1374uint32_t
1376{
1377 return data->speckle_window_size;
1378}
1379
1380/** Get maximum length of speckle_window_size value.
1381 * @return length of speckle_window_size value, can be length of the array or number of
1382 * maximum number of characters for a string
1383 */
1384size_t
1386{
1387 return 1;
1388}
1389
1390/** Set speckle_window_size value.
1391 *
1392 Disparity variation window size.
1393
1394 * @param new_speckle_window_size new speckle_window_size value
1395 */
1396void
1398{
1399 set_field(data->speckle_window_size, new_speckle_window_size);
1400}
1401
1402/** Clone this message.
1403 * Produces a message of the same type as this message and copies the
1404 * data to the new message.
1405 * @return clone of this message
1406 */
1407Message *
1409{
1411}
1412/** @class OpenCVStereoParamsInterface::SetSpeckleRangeMessage <interfaces/OpenCVStereoParamsInterface.h>
1413 * SetSpeckleRangeMessage Fawkes BlackBoard Interface Message.
1414 *
1415
1416 */
1417
1418
1419/** Constructor with initial values.
1420 * @param ini_speckle_range initial value for speckle_range
1421 */
1422OpenCVStereoParamsInterface::SetSpeckleRangeMessage::SetSpeckleRangeMessage(const uint32_t ini_speckle_range) : Message("SetSpeckleRangeMessage")
1423{
1424 data_size = sizeof(SetSpeckleRangeMessage_data_t);
1425 data_ptr = malloc(data_size);
1426 memset(data_ptr, 0, data_size);
1427 data = (SetSpeckleRangeMessage_data_t *)data_ptr;
1429 data->speckle_range = ini_speckle_range;
1430 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1431 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1432 add_fieldinfo(IFT_UINT32, "speckle_range", 1, &data->speckle_range);
1433}
1434/** Constructor */
1436{
1437 data_size = sizeof(SetSpeckleRangeMessage_data_t);
1438 data_ptr = malloc(data_size);
1439 memset(data_ptr, 0, data_size);
1440 data = (SetSpeckleRangeMessage_data_t *)data_ptr;
1442 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1443 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1444 add_fieldinfo(IFT_UINT32, "speckle_range", 1, &data->speckle_range);
1445}
1446
1447/** Destructor */
1449{
1450 free(data_ptr);
1451}
1452
1453/** Copy constructor.
1454 * @param m message to copy from
1455 */
1457{
1458 data_size = m->data_size;
1459 data_ptr = malloc(data_size);
1460 memcpy(data_ptr, m->data_ptr, data_size);
1461 data = (SetSpeckleRangeMessage_data_t *)data_ptr;
1463}
1464
1465/* Methods */
1466/** Get speckle_range value.
1467 *
1468 Acceptable range of variation in window.
1469
1470 * @return speckle_range value
1471 */
1472uint32_t
1474{
1475 return data->speckle_range;
1476}
1477
1478/** Get maximum length of speckle_range value.
1479 * @return length of speckle_range value, can be length of the array or number of
1480 * maximum number of characters for a string
1481 */
1482size_t
1484{
1485 return 1;
1486}
1487
1488/** Set speckle_range value.
1489 *
1490 Acceptable range of variation in window.
1491
1492 * @param new_speckle_range new speckle_range value
1493 */
1494void
1496{
1497 set_field(data->speckle_range, new_speckle_range);
1498}
1499
1500/** Clone this message.
1501 * Produces a message of the same type as this message and copies the
1502 * data to the new message.
1503 * @return clone of this message
1504 */
1505Message *
1507{
1509}
1510/** @class OpenCVStereoParamsInterface::SetTrySmallerWindowsMessage <interfaces/OpenCVStereoParamsInterface.h>
1511 * SetTrySmallerWindowsMessage Fawkes BlackBoard Interface Message.
1512 *
1513
1514 */
1515
1516
1517/** Constructor with initial values.
1518 * @param ini_try_smaller_windows initial value for try_smaller_windows
1519 */
1520OpenCVStereoParamsInterface::SetTrySmallerWindowsMessage::SetTrySmallerWindowsMessage(const bool ini_try_smaller_windows) : Message("SetTrySmallerWindowsMessage")
1521{
1522 data_size = sizeof(SetTrySmallerWindowsMessage_data_t);
1523 data_ptr = malloc(data_size);
1524 memset(data_ptr, 0, data_size);
1525 data = (SetTrySmallerWindowsMessage_data_t *)data_ptr;
1527 data->try_smaller_windows = ini_try_smaller_windows;
1528 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1529 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1530 add_fieldinfo(IFT_BOOL, "try_smaller_windows", 1, &data->try_smaller_windows);
1531}
1532/** Constructor */
1534{
1535 data_size = sizeof(SetTrySmallerWindowsMessage_data_t);
1536 data_ptr = malloc(data_size);
1537 memset(data_ptr, 0, data_size);
1538 data = (SetTrySmallerWindowsMessage_data_t *)data_ptr;
1540 enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1541 enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1542 add_fieldinfo(IFT_BOOL, "try_smaller_windows", 1, &data->try_smaller_windows);
1543}
1544
1545/** Destructor */
1547{
1548 free(data_ptr);
1549}
1550
1551/** Copy constructor.
1552 * @param m message to copy from
1553 */
1555{
1556 data_size = m->data_size;
1557 data_ptr = malloc(data_size);
1558 memcpy(data_ptr, m->data_ptr, data_size);
1559 data = (SetTrySmallerWindowsMessage_data_t *)data_ptr;
1561}
1562
1563/* Methods */
1564/** Get try_smaller_windows value.
1565 *
1566 If enabled, the results may be more accurate, at the expense of
1567 slower processing.
1568
1569 * @return try_smaller_windows value
1570 */
1571bool
1573{
1574 return data->try_smaller_windows;
1575}
1576
1577/** Get maximum length of try_smaller_windows value.
1578 * @return length of try_smaller_windows value, can be length of the array or number of
1579 * maximum number of characters for a string
1580 */
1581size_t
1583{
1584 return 1;
1585}
1586
1587/** Set try_smaller_windows value.
1588 *
1589 If enabled, the results may be more accurate, at the expense of
1590 slower processing.
1591
1592 * @param new_try_smaller_windows new try_smaller_windows value
1593 */
1594void
1596{
1597 set_field(data->try_smaller_windows, new_try_smaller_windows);
1598}
1599
1600/** Clone this message.
1601 * Produces a message of the same type as this message and copies the
1602 * data to the new message.
1603 * @return clone of this message
1604 */
1605Message *
1607{
1609}
1610/** Check if message is valid and can be enqueued.
1611 * @param message Message to check
1612 * @return true if the message is valid, false otherwise.
1613 */
1614bool
1616{
1617 const SetPreFilterTypeMessage *m0 = dynamic_cast<const SetPreFilterTypeMessage *>(message);
1618 if ( m0 != NULL ) {
1619 return true;
1620 }
1621 const SetPreFilterSizeMessage *m1 = dynamic_cast<const SetPreFilterSizeMessage *>(message);
1622 if ( m1 != NULL ) {
1623 return true;
1624 }
1625 const SetPreFilterCapMessage *m2 = dynamic_cast<const SetPreFilterCapMessage *>(message);
1626 if ( m2 != NULL ) {
1627 return true;
1628 }
1629 const SetSADWindowSizeMessage *m3 = dynamic_cast<const SetSADWindowSizeMessage *>(message);
1630 if ( m3 != NULL ) {
1631 return true;
1632 }
1633 const SetMinDisparityMessage *m4 = dynamic_cast<const SetMinDisparityMessage *>(message);
1634 if ( m4 != NULL ) {
1635 return true;
1636 }
1637 const SetNumDisparitiesMessage *m5 = dynamic_cast<const SetNumDisparitiesMessage *>(message);
1638 if ( m5 != NULL ) {
1639 return true;
1640 }
1641 const SetTextureThresholdMessage *m6 = dynamic_cast<const SetTextureThresholdMessage *>(message);
1642 if ( m6 != NULL ) {
1643 return true;
1644 }
1645 const SetUniquenessRatioMessage *m7 = dynamic_cast<const SetUniquenessRatioMessage *>(message);
1646 if ( m7 != NULL ) {
1647 return true;
1648 }
1649 const SetSpeckleWindowSizeMessage *m8 = dynamic_cast<const SetSpeckleWindowSizeMessage *>(message);
1650 if ( m8 != NULL ) {
1651 return true;
1652 }
1653 const SetSpeckleRangeMessage *m9 = dynamic_cast<const SetSpeckleRangeMessage *>(message);
1654 if ( m9 != NULL ) {
1655 return true;
1656 }
1657 const SetTrySmallerWindowsMessage *m10 = dynamic_cast<const SetTrySmallerWindowsMessage *>(message);
1658 if ( m10 != NULL ) {
1659 return true;
1660 }
1661 return false;
1662}
1663
1664/// @cond INTERNALS
1665EXPORT_INTERFACE(OpenCVStereoParamsInterface)
1666/// @endcond
1667
1668
1669} // end namespace fawkes
Base class for all Fawkes BlackBoard interfaces.
Definition: interface.h:80
const char * type() const
Get type of interface.
Definition: interface.cpp:652
void * data_ptr
Pointer to local memory storage.
Definition: interface.h:244
void set_field(FieldT &field, DataT &data)
Set a field, set data_changed to true and update data_changed accordingly.
Definition: interface.h:304
Base class for all messages passed through interfaces in Fawkes BlackBoard.
Definition: message.h:44
void add_fieldinfo(interface_fieldtype_t type, const char *name, size_t length, void *value, const char *enumtype=0, const interface_enum_map_t *enum_map=0)
Add an entry to the info list.
Definition: message.cpp:435
void * data_ptr
Pointer to memory that contains local data.
Definition: message.h:146
message_data_ts_t * data_ts
data timestamp aliasing pointer
Definition: message.h:156
unsigned int data_size
Size of memory needed to hold all data.
Definition: message.h:147
SetMinDisparityMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_min_disparity() const
Get maximum length of min_disparity value.
void set_min_disparity(const int32_t new_min_disparity)
Set min_disparity value.
SetNumDisparitiesMessage Fawkes BlackBoard Interface Message.
void set_num_disparities(const uint32_t new_num_disparities)
Set num_disparities value.
size_t maxlenof_num_disparities() const
Get maximum length of num_disparities value.
SetPreFilterCapMessage Fawkes BlackBoard Interface Message.
void set_pre_filter_cap(const uint32_t new_pre_filter_cap)
Set pre_filter_cap value.
size_t maxlenof_pre_filter_cap() const
Get maximum length of pre_filter_cap value.
SetPreFilterSizeMessage Fawkes BlackBoard Interface Message.
void set_pre_filter_size(const uint32_t new_pre_filter_size)
Set pre_filter_size value.
size_t maxlenof_pre_filter_size() const
Get maximum length of pre_filter_size value.
SetPreFilterTypeMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_pre_filter_type() const
Get maximum length of pre_filter_type value.
void set_pre_filter_type(const PreFilterType new_pre_filter_type)
Set pre_filter_type value.
PreFilterType pre_filter_type() const
Get pre_filter_type value.
SetSADWindowSizeMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_sad_window_size() const
Get maximum length of sad_window_size value.
void set_sad_window_size(const uint32_t new_sad_window_size)
Set sad_window_size value.
SetSpeckleRangeMessage Fawkes BlackBoard Interface Message.
void set_speckle_range(const uint32_t new_speckle_range)
Set speckle_range value.
size_t maxlenof_speckle_range() const
Get maximum length of speckle_range value.
SetSpeckleWindowSizeMessage Fawkes BlackBoard Interface Message.
void set_speckle_window_size(const uint32_t new_speckle_window_size)
Set speckle_window_size value.
size_t maxlenof_speckle_window_size() const
Get maximum length of speckle_window_size value.
SetTextureThresholdMessage Fawkes BlackBoard Interface Message.
void set_texture_threshold(const uint32_t new_texture_threshold)
Set texture_threshold value.
size_t maxlenof_texture_threshold() const
Get maximum length of texture_threshold value.
SetTrySmallerWindowsMessage Fawkes BlackBoard Interface Message.
void set_try_smaller_windows(const bool new_try_smaller_windows)
Set try_smaller_windows value.
size_t maxlenof_try_smaller_windows() const
Get maximum length of try_smaller_windows value.
SetUniquenessRatioMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_uniqueness_ratio() const
Get maximum length of uniqueness_ratio value.
void set_uniqueness_ratio(const uint32_t new_uniqueness_ratio)
Set uniqueness_ratio value.
OpenCVStereoParamsInterface Fawkes BlackBoard Interface.
PreFilterType
The type used for the pre-filter to come up with the features for the correspondence matching.
@ PFT_NORMALIZED_RESPONSE
Normalized response filter.
virtual bool message_valid(const Message *message) const
Check if message is valid and can be enqueued.
Fawkes library namespace.
@ IFT_UINT32
32 bit unsigned integer field
Definition: types.h:43
@ IFT_INT32
32 bit integer field
Definition: types.h:42
@ IFT_BOOL
boolean field
Definition: types.h:37
@ IFT_ENUM
field with interface specific enum type
Definition: types.h:50
Timestamp data, must be present and first entries for each interface data structs!...
Definition: message.h:152