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 
33 namespace 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 */
47 OpenCVStereoParamsInterface::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 */
83 OpenCVStereoParamsInterface::~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  */
91 const char *
92 OpenCVStereoParamsInterface::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  */
106 OpenCVStereoParamsInterface::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  */
115 size_t
116 OpenCVStereoParamsInterface::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  */
125 void
126 OpenCVStereoParamsInterface::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  */
137 uint32_t
138 OpenCVStereoParamsInterface::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  */
147 size_t
148 OpenCVStereoParamsInterface::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  */
159 void
160 OpenCVStereoParamsInterface::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  */
171 uint32_t
172 OpenCVStereoParamsInterface::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  */
181 size_t
182 OpenCVStereoParamsInterface::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  */
193 void
194 OpenCVStereoParamsInterface::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  */
205 uint32_t
206 OpenCVStereoParamsInterface::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  */
215 size_t
216 OpenCVStereoParamsInterface::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  */
227 void
228 OpenCVStereoParamsInterface::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  */
237 int32_t
238 OpenCVStereoParamsInterface::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  */
247 size_t
248 OpenCVStereoParamsInterface::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  */
257 void
258 OpenCVStereoParamsInterface::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  */
269 uint32_t
270 OpenCVStereoParamsInterface::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  */
279 size_t
280 OpenCVStereoParamsInterface::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  */
291 void
292 OpenCVStereoParamsInterface::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  */
304 uint32_t
305 OpenCVStereoParamsInterface::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  */
314 size_t
315 OpenCVStereoParamsInterface::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  */
327 void
328 OpenCVStereoParamsInterface::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  */
341 uint32_t
342 OpenCVStereoParamsInterface::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  */
351 size_t
352 OpenCVStereoParamsInterface::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  */
365 void
366 OpenCVStereoParamsInterface::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  */
377 uint32_t
378 OpenCVStereoParamsInterface::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  */
387 size_t
388 OpenCVStereoParamsInterface::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  */
399 void
400 OpenCVStereoParamsInterface::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  */
411 uint32_t
412 OpenCVStereoParamsInterface::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  */
421 size_t
422 OpenCVStereoParamsInterface::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  */
433 void
434 OpenCVStereoParamsInterface::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  */
446 bool
447 OpenCVStereoParamsInterface::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  */
456 size_t
457 OpenCVStereoParamsInterface::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  */
469 void
470 OpenCVStereoParamsInterface::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 =========== */
476 Message *
477 OpenCVStereoParamsInterface::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  */
511 void
512 OpenCVStereoParamsInterface::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 
522 const char *
523 OpenCVStereoParamsInterface::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  */
542 OpenCVStereoParamsInterface::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  */
600 size_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  */
610 void
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  */
621 Message *
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  */
636 OpenCVStereoParamsInterface::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  */
686 uint32_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  */
696 size_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  */
708 void
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  */
719 Message *
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  */
734 OpenCVStereoParamsInterface::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  */
784 uint32_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  */
794 size_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  */
806 void
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  */
817 Message *
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  */
832 OpenCVStereoParamsInterface::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  */
882 uint32_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  */
892 size_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  */
904 void
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  */
915 Message *
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  */
930 OpenCVStereoParamsInterface::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  */
978 int32_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  */
988 size_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  */
998 void
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  */
1009 Message *
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  */
1024 OpenCVStereoParamsInterface::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  */
1074 uint32_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  */
1084 size_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  */
1096 void
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  */
1107 Message *
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  */
1122 OpenCVStereoParamsInterface::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  */
1173 uint32_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  */
1183 size_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  */
1196 void
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  */
1207 Message *
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  */
1222 OpenCVStereoParamsInterface::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  */
1274 uint32_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  */
1284 size_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  */
1298 void
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  */
1309 Message *
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  */
1324 OpenCVStereoParamsInterface::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  */
1374 uint32_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  */
1384 size_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  */
1396 void
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  */
1407 Message *
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  */
1422 OpenCVStereoParamsInterface::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  */
1472 uint32_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  */
1482 size_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  */
1494 void
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  */
1505 Message *
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  */
1520 OpenCVStereoParamsInterface::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  */
1571 bool
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  */
1581 size_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  */
1594 void
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  */
1605 Message *
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  */
1614 bool
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
1665 EXPORT_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