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  data->pre_filter_type = new_pre_filter_type;
129  data_changed = true;
130 }
131 
132 /** Get pre_filter_size value.
133  *
134  Averaging window size: ~5x5..21x21.
135 
136  * @return pre_filter_size value
137  */
138 uint32_t
139 OpenCVStereoParamsInterface::pre_filter_size() const
140 {
141  return data->pre_filter_size;
142 }
143 
144 /** Get maximum length of pre_filter_size value.
145  * @return length of pre_filter_size value, can be length of the array or number of
146  * maximum number of characters for a string
147  */
148 size_t
149 OpenCVStereoParamsInterface::maxlenof_pre_filter_size() const
150 {
151  return 1;
152 }
153 
154 /** Set pre_filter_size value.
155  *
156  Averaging window size: ~5x5..21x21.
157 
158  * @param new_pre_filter_size new pre_filter_size value
159  */
160 void
161 OpenCVStereoParamsInterface::set_pre_filter_size(const uint32_t new_pre_filter_size)
162 {
163  data->pre_filter_size = new_pre_filter_size;
164  data_changed = true;
165 }
166 
167 /** Get pre_filter_cap value.
168  *
169  The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
170 
171  * @return pre_filter_cap value
172  */
173 uint32_t
174 OpenCVStereoParamsInterface::pre_filter_cap() const
175 {
176  return data->pre_filter_cap;
177 }
178 
179 /** Get maximum length of pre_filter_cap value.
180  * @return length of pre_filter_cap value, can be length of the array or number of
181  * maximum number of characters for a string
182  */
183 size_t
184 OpenCVStereoParamsInterface::maxlenof_pre_filter_cap() const
185 {
186  return 1;
187 }
188 
189 /** Set pre_filter_cap value.
190  *
191  The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
192 
193  * @param new_pre_filter_cap new pre_filter_cap value
194  */
195 void
196 OpenCVStereoParamsInterface::set_pre_filter_cap(const uint32_t new_pre_filter_cap)
197 {
198  data->pre_filter_cap = new_pre_filter_cap;
199  data_changed = true;
200 }
201 
202 /** Get sad_window_size value.
203  *
204  Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
205 
206  * @return sad_window_size value
207  */
208 uint32_t
209 OpenCVStereoParamsInterface::sad_window_size() const
210 {
211  return data->sad_window_size;
212 }
213 
214 /** Get maximum length of sad_window_size value.
215  * @return length of sad_window_size value, can be length of the array or number of
216  * maximum number of characters for a string
217  */
218 size_t
219 OpenCVStereoParamsInterface::maxlenof_sad_window_size() const
220 {
221  return 1;
222 }
223 
224 /** Set sad_window_size value.
225  *
226  Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
227 
228  * @param new_sad_window_size new sad_window_size value
229  */
230 void
231 OpenCVStereoParamsInterface::set_sad_window_size(const uint32_t new_sad_window_size)
232 {
233  data->sad_window_size = new_sad_window_size;
234  data_changed = true;
235 }
236 
237 /** Get min_disparity value.
238  * Minimum disparity (can be negative).
239  * @return min_disparity value
240  */
241 int32_t
242 OpenCVStereoParamsInterface::min_disparity() const
243 {
244  return data->min_disparity;
245 }
246 
247 /** Get maximum length of min_disparity value.
248  * @return length of min_disparity value, can be length of the array or number of
249  * maximum number of characters for a string
250  */
251 size_t
252 OpenCVStereoParamsInterface::maxlenof_min_disparity() const
253 {
254  return 1;
255 }
256 
257 /** Set min_disparity value.
258  * Minimum disparity (can be negative).
259  * @param new_min_disparity new min_disparity value
260  */
261 void
262 OpenCVStereoParamsInterface::set_min_disparity(const int32_t new_min_disparity)
263 {
264  data->min_disparity = new_min_disparity;
265  data_changed = true;
266 }
267 
268 /** Get num_disparities value.
269  *
270  Number of disparities (maximum disparity - minimum disparity (> 0)).
271 
272  * @return num_disparities value
273  */
274 uint32_t
275 OpenCVStereoParamsInterface::num_disparities() const
276 {
277  return data->num_disparities;
278 }
279 
280 /** Get maximum length of num_disparities value.
281  * @return length of num_disparities value, can be length of the array or number of
282  * maximum number of characters for a string
283  */
284 size_t
285 OpenCVStereoParamsInterface::maxlenof_num_disparities() const
286 {
287  return 1;
288 }
289 
290 /** Set num_disparities value.
291  *
292  Number of disparities (maximum disparity - minimum disparity (> 0)).
293 
294  * @param new_num_disparities new num_disparities value
295  */
296 void
297 OpenCVStereoParamsInterface::set_num_disparities(const uint32_t new_num_disparities)
298 {
299  data->num_disparities = new_num_disparities;
300  data_changed = true;
301 }
302 
303 /** Get texture_threshold value.
304  *
305  The disparity is only computed for pixels with textured enough
306  neighborhood.
307 
308  * @return texture_threshold value
309  */
310 uint32_t
311 OpenCVStereoParamsInterface::texture_threshold() const
312 {
313  return data->texture_threshold;
314 }
315 
316 /** Get maximum length of texture_threshold value.
317  * @return length of texture_threshold value, can be length of the array or number of
318  * maximum number of characters for a string
319  */
320 size_t
321 OpenCVStereoParamsInterface::maxlenof_texture_threshold() const
322 {
323  return 1;
324 }
325 
326 /** Set texture_threshold value.
327  *
328  The disparity is only computed for pixels with textured enough
329  neighborhood.
330 
331  * @param new_texture_threshold new texture_threshold value
332  */
333 void
334 OpenCVStereoParamsInterface::set_texture_threshold(const uint32_t new_texture_threshold)
335 {
336  data->texture_threshold = new_texture_threshold;
337  data_changed = true;
338 }
339 
340 /** Get uniqueness_ratio value.
341  *
342  Accept the computed disparity d* only if
343  SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
344  for any d != d*+/-1 within the search range.
345 
346  * @return uniqueness_ratio value
347  */
348 uint32_t
349 OpenCVStereoParamsInterface::uniqueness_ratio() const
350 {
351  return data->uniqueness_ratio;
352 }
353 
354 /** Get maximum length of uniqueness_ratio value.
355  * @return length of uniqueness_ratio value, can be length of the array or number of
356  * maximum number of characters for a string
357  */
358 size_t
359 OpenCVStereoParamsInterface::maxlenof_uniqueness_ratio() const
360 {
361  return 1;
362 }
363 
364 /** Set uniqueness_ratio value.
365  *
366  Accept the computed disparity d* only if
367  SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
368  for any d != d*+/-1 within the search range.
369 
370  * @param new_uniqueness_ratio new uniqueness_ratio value
371  */
372 void
373 OpenCVStereoParamsInterface::set_uniqueness_ratio(const uint32_t new_uniqueness_ratio)
374 {
375  data->uniqueness_ratio = new_uniqueness_ratio;
376  data_changed = true;
377 }
378 
379 /** Get speckle_window_size value.
380  *
381  Disparity variation window size.
382 
383  * @return speckle_window_size value
384  */
385 uint32_t
386 OpenCVStereoParamsInterface::speckle_window_size() const
387 {
388  return data->speckle_window_size;
389 }
390 
391 /** Get maximum length of speckle_window_size value.
392  * @return length of speckle_window_size value, can be length of the array or number of
393  * maximum number of characters for a string
394  */
395 size_t
396 OpenCVStereoParamsInterface::maxlenof_speckle_window_size() const
397 {
398  return 1;
399 }
400 
401 /** Set speckle_window_size value.
402  *
403  Disparity variation window size.
404 
405  * @param new_speckle_window_size new speckle_window_size value
406  */
407 void
408 OpenCVStereoParamsInterface::set_speckle_window_size(const uint32_t new_speckle_window_size)
409 {
410  data->speckle_window_size = new_speckle_window_size;
411  data_changed = true;
412 }
413 
414 /** Get speckle_range value.
415  *
416  Acceptable range of variation in window.
417 
418  * @return speckle_range value
419  */
420 uint32_t
421 OpenCVStereoParamsInterface::speckle_range() const
422 {
423  return data->speckle_range;
424 }
425 
426 /** Get maximum length of speckle_range value.
427  * @return length of speckle_range value, can be length of the array or number of
428  * maximum number of characters for a string
429  */
430 size_t
431 OpenCVStereoParamsInterface::maxlenof_speckle_range() const
432 {
433  return 1;
434 }
435 
436 /** Set speckle_range value.
437  *
438  Acceptable range of variation in window.
439 
440  * @param new_speckle_range new speckle_range value
441  */
442 void
443 OpenCVStereoParamsInterface::set_speckle_range(const uint32_t new_speckle_range)
444 {
445  data->speckle_range = new_speckle_range;
446  data_changed = true;
447 }
448 
449 /** Get try_smaller_windows value.
450  *
451  If enabled, the results may be more accurate, at the expense of
452  slower processing.
453 
454  * @return try_smaller_windows value
455  */
456 bool
457 OpenCVStereoParamsInterface::is_try_smaller_windows() const
458 {
459  return data->try_smaller_windows;
460 }
461 
462 /** Get maximum length of try_smaller_windows value.
463  * @return length of try_smaller_windows value, can be length of the array or number of
464  * maximum number of characters for a string
465  */
466 size_t
467 OpenCVStereoParamsInterface::maxlenof_try_smaller_windows() const
468 {
469  return 1;
470 }
471 
472 /** Set try_smaller_windows value.
473  *
474  If enabled, the results may be more accurate, at the expense of
475  slower processing.
476 
477  * @param new_try_smaller_windows new try_smaller_windows value
478  */
479 void
480 OpenCVStereoParamsInterface::set_try_smaller_windows(const bool new_try_smaller_windows)
481 {
482  data->try_smaller_windows = new_try_smaller_windows;
483  data_changed = true;
484 }
485 
486 /* =========== message create =========== */
487 Message *
488 OpenCVStereoParamsInterface::create_message(const char *type) const
489 {
490  if ( strncmp("SetPreFilterTypeMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
491  return new SetPreFilterTypeMessage();
492  } else if ( strncmp("SetPreFilterSizeMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
493  return new SetPreFilterSizeMessage();
494  } else if ( strncmp("SetPreFilterCapMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
495  return new SetPreFilterCapMessage();
496  } else if ( strncmp("SetSADWindowSizeMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
497  return new SetSADWindowSizeMessage();
498  } else if ( strncmp("SetMinDisparityMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
499  return new SetMinDisparityMessage();
500  } else if ( strncmp("SetNumDisparitiesMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
501  return new SetNumDisparitiesMessage();
502  } else if ( strncmp("SetTextureThresholdMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
503  return new SetTextureThresholdMessage();
504  } else if ( strncmp("SetUniquenessRatioMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
505  return new SetUniquenessRatioMessage();
506  } else if ( strncmp("SetSpeckleWindowSizeMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
507  return new SetSpeckleWindowSizeMessage();
508  } else if ( strncmp("SetSpeckleRangeMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
509  return new SetSpeckleRangeMessage();
510  } else if ( strncmp("SetTrySmallerWindowsMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
511  return new SetTrySmallerWindowsMessage();
512  } else {
513  throw UnknownTypeException("The given type '%s' does not match any known "
514  "message type for this interface type.", type);
515  }
516 }
517 
518 
519 /** Copy values from other interface.
520  * @param other other interface to copy values from
521  */
522 void
523 OpenCVStereoParamsInterface::copy_values(const Interface *other)
524 {
525  const OpenCVStereoParamsInterface *oi = dynamic_cast<const OpenCVStereoParamsInterface *>(other);
526  if (oi == NULL) {
527  throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
528  type(), other->type());
529  }
530  memcpy(data, oi->data, sizeof(OpenCVStereoParamsInterface_data_t));
531 }
532 
533 const char *
534 OpenCVStereoParamsInterface::enum_tostring(const char *enumtype, int val) const
535 {
536  if (strcmp(enumtype, "PreFilterType") == 0) {
537  return tostring_PreFilterType((PreFilterType)val);
538  }
539  throw UnknownTypeException("Unknown enum type %s", enumtype);
540 }
541 
542 /* =========== messages =========== */
543 /** @class OpenCVStereoParamsInterface::SetPreFilterTypeMessage <interfaces/OpenCVStereoParamsInterface.h>
544  * SetPreFilterTypeMessage Fawkes BlackBoard Interface Message.
545  *
546 
547  */
548 
549 
550 /** Constructor with initial values.
551  * @param ini_pre_filter_type initial value for pre_filter_type
552  */
553 OpenCVStereoParamsInterface::SetPreFilterTypeMessage::SetPreFilterTypeMessage(const PreFilterType ini_pre_filter_type) : Message("SetPreFilterTypeMessage")
554 {
555  data_size = sizeof(SetPreFilterTypeMessage_data_t);
556  data_ptr = malloc(data_size);
557  memset(data_ptr, 0, data_size);
558  data = (SetPreFilterTypeMessage_data_t *)data_ptr;
560  data->pre_filter_type = ini_pre_filter_type;
561  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
562  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
563  add_fieldinfo(IFT_ENUM, "pre_filter_type", 1, &data->pre_filter_type, "PreFilterType", &enum_map_PreFilterType);
564 }
565 /** Constructor */
567 {
568  data_size = sizeof(SetPreFilterTypeMessage_data_t);
569  data_ptr = malloc(data_size);
570  memset(data_ptr, 0, data_size);
571  data = (SetPreFilterTypeMessage_data_t *)data_ptr;
573  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
574  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
575  add_fieldinfo(IFT_ENUM, "pre_filter_type", 1, &data->pre_filter_type, "PreFilterType", &enum_map_PreFilterType);
576 }
577 
578 /** Destructor */
580 {
581  free(data_ptr);
582 }
583 
584 /** Copy constructor.
585  * @param m message to copy from
586  */
588 {
589  data_size = m->data_size;
590  data_ptr = malloc(data_size);
591  memcpy(data_ptr, m->data_ptr, data_size);
592  data = (SetPreFilterTypeMessage_data_t *)data_ptr;
594 }
595 
596 /* Methods */
597 /** Get pre_filter_type value.
598  * Pre-filtering method.
599  * @return pre_filter_type value
600  */
603 {
604  return (OpenCVStereoParamsInterface::PreFilterType)data->pre_filter_type;
605 }
606 
607 /** Get maximum length of pre_filter_type value.
608  * @return length of pre_filter_type value, can be length of the array or number of
609  * maximum number of characters for a string
610  */
611 size_t
613 {
614  return 1;
615 }
616 
617 /** Set pre_filter_type value.
618  * Pre-filtering method.
619  * @param new_pre_filter_type new pre_filter_type value
620  */
621 void
623 {
624  data->pre_filter_type = new_pre_filter_type;
625 }
626 
627 /** Clone this message.
628  * Produces a message of the same type as this message and copies the
629  * data to the new message.
630  * @return clone of this message
631  */
632 Message *
634 {
636 }
637 /** @class OpenCVStereoParamsInterface::SetPreFilterSizeMessage <interfaces/OpenCVStereoParamsInterface.h>
638  * SetPreFilterSizeMessage Fawkes BlackBoard Interface Message.
639  *
640 
641  */
642 
643 
644 /** Constructor with initial values.
645  * @param ini_pre_filter_size initial value for pre_filter_size
646  */
647 OpenCVStereoParamsInterface::SetPreFilterSizeMessage::SetPreFilterSizeMessage(const uint32_t ini_pre_filter_size) : Message("SetPreFilterSizeMessage")
648 {
649  data_size = sizeof(SetPreFilterSizeMessage_data_t);
650  data_ptr = malloc(data_size);
651  memset(data_ptr, 0, data_size);
652  data = (SetPreFilterSizeMessage_data_t *)data_ptr;
654  data->pre_filter_size = ini_pre_filter_size;
655  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
656  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
657  add_fieldinfo(IFT_UINT32, "pre_filter_size", 1, &data->pre_filter_size);
658 }
659 /** Constructor */
661 {
662  data_size = sizeof(SetPreFilterSizeMessage_data_t);
663  data_ptr = malloc(data_size);
664  memset(data_ptr, 0, data_size);
665  data = (SetPreFilterSizeMessage_data_t *)data_ptr;
667  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
668  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
669  add_fieldinfo(IFT_UINT32, "pre_filter_size", 1, &data->pre_filter_size);
670 }
671 
672 /** Destructor */
674 {
675  free(data_ptr);
676 }
677 
678 /** Copy constructor.
679  * @param m message to copy from
680  */
682 {
683  data_size = m->data_size;
684  data_ptr = malloc(data_size);
685  memcpy(data_ptr, m->data_ptr, data_size);
686  data = (SetPreFilterSizeMessage_data_t *)data_ptr;
688 }
689 
690 /* Methods */
691 /** Get pre_filter_size value.
692  *
693  Averaging window size: ~5x5..21x21.
694 
695  * @return pre_filter_size value
696  */
697 uint32_t
699 {
700  return data->pre_filter_size;
701 }
702 
703 /** Get maximum length of pre_filter_size value.
704  * @return length of pre_filter_size value, can be length of the array or number of
705  * maximum number of characters for a string
706  */
707 size_t
709 {
710  return 1;
711 }
712 
713 /** Set pre_filter_size value.
714  *
715  Averaging window size: ~5x5..21x21.
716 
717  * @param new_pre_filter_size new pre_filter_size value
718  */
719 void
721 {
722  data->pre_filter_size = new_pre_filter_size;
723 }
724 
725 /** Clone this message.
726  * Produces a message of the same type as this message and copies the
727  * data to the new message.
728  * @return clone of this message
729  */
730 Message *
732 {
734 }
735 /** @class OpenCVStereoParamsInterface::SetPreFilterCapMessage <interfaces/OpenCVStereoParamsInterface.h>
736  * SetPreFilterCapMessage Fawkes BlackBoard Interface Message.
737  *
738 
739  */
740 
741 
742 /** Constructor with initial values.
743  * @param ini_pre_filter_cap initial value for pre_filter_cap
744  */
745 OpenCVStereoParamsInterface::SetPreFilterCapMessage::SetPreFilterCapMessage(const uint32_t ini_pre_filter_cap) : Message("SetPreFilterCapMessage")
746 {
747  data_size = sizeof(SetPreFilterCapMessage_data_t);
748  data_ptr = malloc(data_size);
749  memset(data_ptr, 0, data_size);
750  data = (SetPreFilterCapMessage_data_t *)data_ptr;
752  data->pre_filter_cap = ini_pre_filter_cap;
753  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
754  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
755  add_fieldinfo(IFT_UINT32, "pre_filter_cap", 1, &data->pre_filter_cap);
756 }
757 /** Constructor */
759 {
760  data_size = sizeof(SetPreFilterCapMessage_data_t);
761  data_ptr = malloc(data_size);
762  memset(data_ptr, 0, data_size);
763  data = (SetPreFilterCapMessage_data_t *)data_ptr;
765  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
766  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
767  add_fieldinfo(IFT_UINT32, "pre_filter_cap", 1, &data->pre_filter_cap);
768 }
769 
770 /** Destructor */
772 {
773  free(data_ptr);
774 }
775 
776 /** Copy constructor.
777  * @param m message to copy from
778  */
780 {
781  data_size = m->data_size;
782  data_ptr = malloc(data_size);
783  memcpy(data_ptr, m->data_ptr, data_size);
784  data = (SetPreFilterCapMessage_data_t *)data_ptr;
786 }
787 
788 /* Methods */
789 /** Get pre_filter_cap value.
790  *
791  The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
792 
793  * @return pre_filter_cap value
794  */
795 uint32_t
797 {
798  return data->pre_filter_cap;
799 }
800 
801 /** Get maximum length of pre_filter_cap value.
802  * @return length of pre_filter_cap value, can be length of the array or number of
803  * maximum number of characters for a string
804  */
805 size_t
807 {
808  return 1;
809 }
810 
811 /** Set pre_filter_cap value.
812  *
813  The output of pre-filtering is clipped by [-pre_filter_cap,pre_filter_cap].
814 
815  * @param new_pre_filter_cap new pre_filter_cap value
816  */
817 void
819 {
820  data->pre_filter_cap = new_pre_filter_cap;
821 }
822 
823 /** Clone this message.
824  * Produces a message of the same type as this message and copies the
825  * data to the new message.
826  * @return clone of this message
827  */
828 Message *
830 {
832 }
833 /** @class OpenCVStereoParamsInterface::SetSADWindowSizeMessage <interfaces/OpenCVStereoParamsInterface.h>
834  * SetSADWindowSizeMessage Fawkes BlackBoard Interface Message.
835  *
836 
837  */
838 
839 
840 /** Constructor with initial values.
841  * @param ini_sad_window_size initial value for sad_window_size
842  */
843 OpenCVStereoParamsInterface::SetSADWindowSizeMessage::SetSADWindowSizeMessage(const uint32_t ini_sad_window_size) : Message("SetSADWindowSizeMessage")
844 {
845  data_size = sizeof(SetSADWindowSizeMessage_data_t);
846  data_ptr = malloc(data_size);
847  memset(data_ptr, 0, data_size);
848  data = (SetSADWindowSizeMessage_data_t *)data_ptr;
850  data->sad_window_size = ini_sad_window_size;
851  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
852  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
853  add_fieldinfo(IFT_UINT32, "sad_window_size", 1, &data->sad_window_size);
854 }
855 /** Constructor */
857 {
858  data_size = sizeof(SetSADWindowSizeMessage_data_t);
859  data_ptr = malloc(data_size);
860  memset(data_ptr, 0, data_size);
861  data = (SetSADWindowSizeMessage_data_t *)data_ptr;
863  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
864  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
865  add_fieldinfo(IFT_UINT32, "sad_window_size", 1, &data->sad_window_size);
866 }
867 
868 /** Destructor */
870 {
871  free(data_ptr);
872 }
873 
874 /** Copy constructor.
875  * @param m message to copy from
876  */
878 {
879  data_size = m->data_size;
880  data_ptr = malloc(data_size);
881  memcpy(data_ptr, m->data_ptr, data_size);
882  data = (SetSADWindowSizeMessage_data_t *)data_ptr;
884 }
885 
886 /* Methods */
887 /** Get sad_window_size value.
888  *
889  Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
890 
891  * @return sad_window_size value
892  */
893 uint32_t
895 {
896  return data->sad_window_size;
897 }
898 
899 /** Get maximum length of sad_window_size value.
900  * @return length of sad_window_size value, can be length of the array or number of
901  * maximum number of characters for a string
902  */
903 size_t
905 {
906  return 1;
907 }
908 
909 /** Set sad_window_size value.
910  *
911  Correspondence using Sum of Absolute Difference (SAD) window size (5x5..21x21).
912 
913  * @param new_sad_window_size new sad_window_size value
914  */
915 void
917 {
918  data->sad_window_size = new_sad_window_size;
919 }
920 
921 /** Clone this message.
922  * Produces a message of the same type as this message and copies the
923  * data to the new message.
924  * @return clone of this message
925  */
926 Message *
928 {
930 }
931 /** @class OpenCVStereoParamsInterface::SetMinDisparityMessage <interfaces/OpenCVStereoParamsInterface.h>
932  * SetMinDisparityMessage Fawkes BlackBoard Interface Message.
933  *
934 
935  */
936 
937 
938 /** Constructor with initial values.
939  * @param ini_min_disparity initial value for min_disparity
940  */
941 OpenCVStereoParamsInterface::SetMinDisparityMessage::SetMinDisparityMessage(const int32_t ini_min_disparity) : Message("SetMinDisparityMessage")
942 {
943  data_size = sizeof(SetMinDisparityMessage_data_t);
944  data_ptr = malloc(data_size);
945  memset(data_ptr, 0, data_size);
946  data = (SetMinDisparityMessage_data_t *)data_ptr;
948  data->min_disparity = ini_min_disparity;
949  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
950  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
951  add_fieldinfo(IFT_INT32, "min_disparity", 1, &data->min_disparity);
952 }
953 /** Constructor */
955 {
956  data_size = sizeof(SetMinDisparityMessage_data_t);
957  data_ptr = malloc(data_size);
958  memset(data_ptr, 0, data_size);
959  data = (SetMinDisparityMessage_data_t *)data_ptr;
961  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
962  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
963  add_fieldinfo(IFT_INT32, "min_disparity", 1, &data->min_disparity);
964 }
965 
966 /** Destructor */
968 {
969  free(data_ptr);
970 }
971 
972 /** Copy constructor.
973  * @param m message to copy from
974  */
976 {
977  data_size = m->data_size;
978  data_ptr = malloc(data_size);
979  memcpy(data_ptr, m->data_ptr, data_size);
980  data = (SetMinDisparityMessage_data_t *)data_ptr;
982 }
983 
984 /* Methods */
985 /** Get min_disparity value.
986  * Minimum disparity (can be negative).
987  * @return min_disparity value
988  */
989 int32_t
991 {
992  return data->min_disparity;
993 }
994 
995 /** Get maximum length of min_disparity value.
996  * @return length of min_disparity value, can be length of the array or number of
997  * maximum number of characters for a string
998  */
999 size_t
1001 {
1002  return 1;
1003 }
1004 
1005 /** Set min_disparity value.
1006  * Minimum disparity (can be negative).
1007  * @param new_min_disparity new min_disparity value
1008  */
1009 void
1011 {
1012  data->min_disparity = new_min_disparity;
1013 }
1014 
1015 /** Clone this message.
1016  * Produces a message of the same type as this message and copies the
1017  * data to the new message.
1018  * @return clone of this message
1019  */
1020 Message *
1022 {
1024 }
1025 /** @class OpenCVStereoParamsInterface::SetNumDisparitiesMessage <interfaces/OpenCVStereoParamsInterface.h>
1026  * SetNumDisparitiesMessage Fawkes BlackBoard Interface Message.
1027  *
1028 
1029  */
1030 
1031 
1032 /** Constructor with initial values.
1033  * @param ini_num_disparities initial value for num_disparities
1034  */
1035 OpenCVStereoParamsInterface::SetNumDisparitiesMessage::SetNumDisparitiesMessage(const uint32_t ini_num_disparities) : Message("SetNumDisparitiesMessage")
1036 {
1037  data_size = sizeof(SetNumDisparitiesMessage_data_t);
1038  data_ptr = malloc(data_size);
1039  memset(data_ptr, 0, data_size);
1040  data = (SetNumDisparitiesMessage_data_t *)data_ptr;
1042  data->num_disparities = ini_num_disparities;
1043  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1044  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1045  add_fieldinfo(IFT_UINT32, "num_disparities", 1, &data->num_disparities);
1046 }
1047 /** Constructor */
1049 {
1050  data_size = sizeof(SetNumDisparitiesMessage_data_t);
1051  data_ptr = malloc(data_size);
1052  memset(data_ptr, 0, data_size);
1053  data = (SetNumDisparitiesMessage_data_t *)data_ptr;
1055  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1056  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1057  add_fieldinfo(IFT_UINT32, "num_disparities", 1, &data->num_disparities);
1058 }
1059 
1060 /** Destructor */
1062 {
1063  free(data_ptr);
1064 }
1065 
1066 /** Copy constructor.
1067  * @param m message to copy from
1068  */
1070 {
1071  data_size = m->data_size;
1072  data_ptr = malloc(data_size);
1073  memcpy(data_ptr, m->data_ptr, data_size);
1074  data = (SetNumDisparitiesMessage_data_t *)data_ptr;
1076 }
1077 
1078 /* Methods */
1079 /** Get num_disparities value.
1080  *
1081  Number of disparities (maximum disparity - minimum disparity (> 0)).
1082 
1083  * @return num_disparities value
1084  */
1085 uint32_t
1087 {
1088  return data->num_disparities;
1089 }
1090 
1091 /** Get maximum length of num_disparities value.
1092  * @return length of num_disparities value, can be length of the array or number of
1093  * maximum number of characters for a string
1094  */
1095 size_t
1097 {
1098  return 1;
1099 }
1100 
1101 /** Set num_disparities value.
1102  *
1103  Number of disparities (maximum disparity - minimum disparity (> 0)).
1104 
1105  * @param new_num_disparities new num_disparities value
1106  */
1107 void
1109 {
1110  data->num_disparities = new_num_disparities;
1111 }
1112 
1113 /** Clone this message.
1114  * Produces a message of the same type as this message and copies the
1115  * data to the new message.
1116  * @return clone of this message
1117  */
1118 Message *
1120 {
1122 }
1123 /** @class OpenCVStereoParamsInterface::SetTextureThresholdMessage <interfaces/OpenCVStereoParamsInterface.h>
1124  * SetTextureThresholdMessage Fawkes BlackBoard Interface Message.
1125  *
1126 
1127  */
1128 
1129 
1130 /** Constructor with initial values.
1131  * @param ini_texture_threshold initial value for texture_threshold
1132  */
1133 OpenCVStereoParamsInterface::SetTextureThresholdMessage::SetTextureThresholdMessage(const uint32_t ini_texture_threshold) : Message("SetTextureThresholdMessage")
1134 {
1135  data_size = sizeof(SetTextureThresholdMessage_data_t);
1136  data_ptr = malloc(data_size);
1137  memset(data_ptr, 0, data_size);
1138  data = (SetTextureThresholdMessage_data_t *)data_ptr;
1140  data->texture_threshold = ini_texture_threshold;
1141  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1142  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1143  add_fieldinfo(IFT_UINT32, "texture_threshold", 1, &data->texture_threshold);
1144 }
1145 /** Constructor */
1147 {
1148  data_size = sizeof(SetTextureThresholdMessage_data_t);
1149  data_ptr = malloc(data_size);
1150  memset(data_ptr, 0, data_size);
1151  data = (SetTextureThresholdMessage_data_t *)data_ptr;
1153  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1154  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1155  add_fieldinfo(IFT_UINT32, "texture_threshold", 1, &data->texture_threshold);
1156 }
1157 
1158 /** Destructor */
1160 {
1161  free(data_ptr);
1162 }
1163 
1164 /** Copy constructor.
1165  * @param m message to copy from
1166  */
1168 {
1169  data_size = m->data_size;
1170  data_ptr = malloc(data_size);
1171  memcpy(data_ptr, m->data_ptr, data_size);
1172  data = (SetTextureThresholdMessage_data_t *)data_ptr;
1174 }
1175 
1176 /* Methods */
1177 /** Get texture_threshold value.
1178  *
1179  The disparity is only computed for pixels with textured enough
1180  neighborhood.
1181 
1182  * @return texture_threshold value
1183  */
1184 uint32_t
1186 {
1187  return data->texture_threshold;
1188 }
1189 
1190 /** Get maximum length of texture_threshold value.
1191  * @return length of texture_threshold value, can be length of the array or number of
1192  * maximum number of characters for a string
1193  */
1194 size_t
1196 {
1197  return 1;
1198 }
1199 
1200 /** Set texture_threshold value.
1201  *
1202  The disparity is only computed for pixels with textured enough
1203  neighborhood.
1204 
1205  * @param new_texture_threshold new texture_threshold value
1206  */
1207 void
1209 {
1210  data->texture_threshold = new_texture_threshold;
1211 }
1212 
1213 /** Clone this message.
1214  * Produces a message of the same type as this message and copies the
1215  * data to the new message.
1216  * @return clone of this message
1217  */
1218 Message *
1220 {
1222 }
1223 /** @class OpenCVStereoParamsInterface::SetUniquenessRatioMessage <interfaces/OpenCVStereoParamsInterface.h>
1224  * SetUniquenessRatioMessage Fawkes BlackBoard Interface Message.
1225  *
1226 
1227  */
1228 
1229 
1230 /** Constructor with initial values.
1231  * @param ini_uniqueness_ratio initial value for uniqueness_ratio
1232  */
1233 OpenCVStereoParamsInterface::SetUniquenessRatioMessage::SetUniquenessRatioMessage(const uint32_t ini_uniqueness_ratio) : Message("SetUniquenessRatioMessage")
1234 {
1235  data_size = sizeof(SetUniquenessRatioMessage_data_t);
1236  data_ptr = malloc(data_size);
1237  memset(data_ptr, 0, data_size);
1238  data = (SetUniquenessRatioMessage_data_t *)data_ptr;
1240  data->uniqueness_ratio = ini_uniqueness_ratio;
1241  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1242  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1243  add_fieldinfo(IFT_UINT32, "uniqueness_ratio", 1, &data->uniqueness_ratio);
1244 }
1245 /** Constructor */
1247 {
1248  data_size = sizeof(SetUniquenessRatioMessage_data_t);
1249  data_ptr = malloc(data_size);
1250  memset(data_ptr, 0, data_size);
1251  data = (SetUniquenessRatioMessage_data_t *)data_ptr;
1253  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1254  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1255  add_fieldinfo(IFT_UINT32, "uniqueness_ratio", 1, &data->uniqueness_ratio);
1256 }
1257 
1258 /** Destructor */
1260 {
1261  free(data_ptr);
1262 }
1263 
1264 /** Copy constructor.
1265  * @param m message to copy from
1266  */
1268 {
1269  data_size = m->data_size;
1270  data_ptr = malloc(data_size);
1271  memcpy(data_ptr, m->data_ptr, data_size);
1272  data = (SetUniquenessRatioMessage_data_t *)data_ptr;
1274 }
1275 
1276 /* Methods */
1277 /** Get uniqueness_ratio value.
1278  *
1279  Accept the computed disparity d* only if
1280  SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
1281  for any d != d*+/-1 within the search range.
1282 
1283  * @return uniqueness_ratio value
1284  */
1285 uint32_t
1287 {
1288  return data->uniqueness_ratio;
1289 }
1290 
1291 /** Get maximum length of uniqueness_ratio value.
1292  * @return length of uniqueness_ratio value, can be length of the array or number of
1293  * maximum number of characters for a string
1294  */
1295 size_t
1297 {
1298  return 1;
1299 }
1300 
1301 /** Set uniqueness_ratio value.
1302  *
1303  Accept the computed disparity d* only if
1304  SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)
1305  for any d != d*+/-1 within the search range.
1306 
1307  * @param new_uniqueness_ratio new uniqueness_ratio value
1308  */
1309 void
1311 {
1312  data->uniqueness_ratio = new_uniqueness_ratio;
1313 }
1314 
1315 /** Clone this message.
1316  * Produces a message of the same type as this message and copies the
1317  * data to the new message.
1318  * @return clone of this message
1319  */
1320 Message *
1322 {
1324 }
1325 /** @class OpenCVStereoParamsInterface::SetSpeckleWindowSizeMessage <interfaces/OpenCVStereoParamsInterface.h>
1326  * SetSpeckleWindowSizeMessage Fawkes BlackBoard Interface Message.
1327  *
1328 
1329  */
1330 
1331 
1332 /** Constructor with initial values.
1333  * @param ini_speckle_window_size initial value for speckle_window_size
1334  */
1335 OpenCVStereoParamsInterface::SetSpeckleWindowSizeMessage::SetSpeckleWindowSizeMessage(const uint32_t ini_speckle_window_size) : Message("SetSpeckleWindowSizeMessage")
1336 {
1337  data_size = sizeof(SetSpeckleWindowSizeMessage_data_t);
1338  data_ptr = malloc(data_size);
1339  memset(data_ptr, 0, data_size);
1340  data = (SetSpeckleWindowSizeMessage_data_t *)data_ptr;
1342  data->speckle_window_size = ini_speckle_window_size;
1343  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1344  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1345  add_fieldinfo(IFT_UINT32, "speckle_window_size", 1, &data->speckle_window_size);
1346 }
1347 /** Constructor */
1349 {
1350  data_size = sizeof(SetSpeckleWindowSizeMessage_data_t);
1351  data_ptr = malloc(data_size);
1352  memset(data_ptr, 0, data_size);
1353  data = (SetSpeckleWindowSizeMessage_data_t *)data_ptr;
1355  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1356  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1357  add_fieldinfo(IFT_UINT32, "speckle_window_size", 1, &data->speckle_window_size);
1358 }
1359 
1360 /** Destructor */
1362 {
1363  free(data_ptr);
1364 }
1365 
1366 /** Copy constructor.
1367  * @param m message to copy from
1368  */
1370 {
1371  data_size = m->data_size;
1372  data_ptr = malloc(data_size);
1373  memcpy(data_ptr, m->data_ptr, data_size);
1374  data = (SetSpeckleWindowSizeMessage_data_t *)data_ptr;
1376 }
1377 
1378 /* Methods */
1379 /** Get speckle_window_size value.
1380  *
1381  Disparity variation window size.
1382 
1383  * @return speckle_window_size value
1384  */
1385 uint32_t
1387 {
1388  return data->speckle_window_size;
1389 }
1390 
1391 /** Get maximum length of speckle_window_size value.
1392  * @return length of speckle_window_size value, can be length of the array or number of
1393  * maximum number of characters for a string
1394  */
1395 size_t
1397 {
1398  return 1;
1399 }
1400 
1401 /** Set speckle_window_size value.
1402  *
1403  Disparity variation window size.
1404 
1405  * @param new_speckle_window_size new speckle_window_size value
1406  */
1407 void
1409 {
1410  data->speckle_window_size = new_speckle_window_size;
1411 }
1412 
1413 /** Clone this message.
1414  * Produces a message of the same type as this message and copies the
1415  * data to the new message.
1416  * @return clone of this message
1417  */
1418 Message *
1420 {
1422 }
1423 /** @class OpenCVStereoParamsInterface::SetSpeckleRangeMessage <interfaces/OpenCVStereoParamsInterface.h>
1424  * SetSpeckleRangeMessage Fawkes BlackBoard Interface Message.
1425  *
1426 
1427  */
1428 
1429 
1430 /** Constructor with initial values.
1431  * @param ini_speckle_range initial value for speckle_range
1432  */
1433 OpenCVStereoParamsInterface::SetSpeckleRangeMessage::SetSpeckleRangeMessage(const uint32_t ini_speckle_range) : Message("SetSpeckleRangeMessage")
1434 {
1435  data_size = sizeof(SetSpeckleRangeMessage_data_t);
1436  data_ptr = malloc(data_size);
1437  memset(data_ptr, 0, data_size);
1438  data = (SetSpeckleRangeMessage_data_t *)data_ptr;
1440  data->speckle_range = ini_speckle_range;
1441  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1442  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1443  add_fieldinfo(IFT_UINT32, "speckle_range", 1, &data->speckle_range);
1444 }
1445 /** Constructor */
1447 {
1448  data_size = sizeof(SetSpeckleRangeMessage_data_t);
1449  data_ptr = malloc(data_size);
1450  memset(data_ptr, 0, data_size);
1451  data = (SetSpeckleRangeMessage_data_t *)data_ptr;
1453  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1454  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1455  add_fieldinfo(IFT_UINT32, "speckle_range", 1, &data->speckle_range);
1456 }
1457 
1458 /** Destructor */
1460 {
1461  free(data_ptr);
1462 }
1463 
1464 /** Copy constructor.
1465  * @param m message to copy from
1466  */
1468 {
1469  data_size = m->data_size;
1470  data_ptr = malloc(data_size);
1471  memcpy(data_ptr, m->data_ptr, data_size);
1472  data = (SetSpeckleRangeMessage_data_t *)data_ptr;
1474 }
1475 
1476 /* Methods */
1477 /** Get speckle_range value.
1478  *
1479  Acceptable range of variation in window.
1480 
1481  * @return speckle_range value
1482  */
1483 uint32_t
1485 {
1486  return data->speckle_range;
1487 }
1488 
1489 /** Get maximum length of speckle_range value.
1490  * @return length of speckle_range value, can be length of the array or number of
1491  * maximum number of characters for a string
1492  */
1493 size_t
1495 {
1496  return 1;
1497 }
1498 
1499 /** Set speckle_range value.
1500  *
1501  Acceptable range of variation in window.
1502 
1503  * @param new_speckle_range new speckle_range value
1504  */
1505 void
1507 {
1508  data->speckle_range = new_speckle_range;
1509 }
1510 
1511 /** Clone this message.
1512  * Produces a message of the same type as this message and copies the
1513  * data to the new message.
1514  * @return clone of this message
1515  */
1516 Message *
1518 {
1520 }
1521 /** @class OpenCVStereoParamsInterface::SetTrySmallerWindowsMessage <interfaces/OpenCVStereoParamsInterface.h>
1522  * SetTrySmallerWindowsMessage Fawkes BlackBoard Interface Message.
1523  *
1524 
1525  */
1526 
1527 
1528 /** Constructor with initial values.
1529  * @param ini_try_smaller_windows initial value for try_smaller_windows
1530  */
1531 OpenCVStereoParamsInterface::SetTrySmallerWindowsMessage::SetTrySmallerWindowsMessage(const bool ini_try_smaller_windows) : Message("SetTrySmallerWindowsMessage")
1532 {
1533  data_size = sizeof(SetTrySmallerWindowsMessage_data_t);
1534  data_ptr = malloc(data_size);
1535  memset(data_ptr, 0, data_size);
1536  data = (SetTrySmallerWindowsMessage_data_t *)data_ptr;
1538  data->try_smaller_windows = ini_try_smaller_windows;
1539  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1540  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1541  add_fieldinfo(IFT_BOOL, "try_smaller_windows", 1, &data->try_smaller_windows);
1542 }
1543 /** Constructor */
1545 {
1546  data_size = sizeof(SetTrySmallerWindowsMessage_data_t);
1547  data_ptr = malloc(data_size);
1548  memset(data_ptr, 0, data_size);
1549  data = (SetTrySmallerWindowsMessage_data_t *)data_ptr;
1551  enum_map_PreFilterType[(int)PFT_NORMALIZED_RESPONSE] = "PFT_NORMALIZED_RESPONSE";
1552  enum_map_PreFilterType[(int)PFT_XSOBEL] = "PFT_XSOBEL";
1553  add_fieldinfo(IFT_BOOL, "try_smaller_windows", 1, &data->try_smaller_windows);
1554 }
1555 
1556 /** Destructor */
1558 {
1559  free(data_ptr);
1560 }
1561 
1562 /** Copy constructor.
1563  * @param m message to copy from
1564  */
1566 {
1567  data_size = m->data_size;
1568  data_ptr = malloc(data_size);
1569  memcpy(data_ptr, m->data_ptr, data_size);
1570  data = (SetTrySmallerWindowsMessage_data_t *)data_ptr;
1572 }
1573 
1574 /* Methods */
1575 /** Get try_smaller_windows value.
1576  *
1577  If enabled, the results may be more accurate, at the expense of
1578  slower processing.
1579 
1580  * @return try_smaller_windows value
1581  */
1582 bool
1584 {
1585  return data->try_smaller_windows;
1586 }
1587 
1588 /** Get maximum length of try_smaller_windows value.
1589  * @return length of try_smaller_windows value, can be length of the array or number of
1590  * maximum number of characters for a string
1591  */
1592 size_t
1594 {
1595  return 1;
1596 }
1597 
1598 /** Set try_smaller_windows value.
1599  *
1600  If enabled, the results may be more accurate, at the expense of
1601  slower processing.
1602 
1603  * @param new_try_smaller_windows new try_smaller_windows value
1604  */
1605 void
1607 {
1608  data->try_smaller_windows = new_try_smaller_windows;
1609 }
1610 
1611 /** Clone this message.
1612  * Produces a message of the same type as this message and copies the
1613  * data to the new message.
1614  * @return clone of this message
1615  */
1616 Message *
1618 {
1620 }
1621 /** Check if message is valid and can be enqueued.
1622  * @param message Message to check
1623  * @return true if the message is valid, false otherwise.
1624  */
1625 bool
1627 {
1628  const SetPreFilterTypeMessage *m0 = dynamic_cast<const SetPreFilterTypeMessage *>(message);
1629  if ( m0 != NULL ) {
1630  return true;
1631  }
1632  const SetPreFilterSizeMessage *m1 = dynamic_cast<const SetPreFilterSizeMessage *>(message);
1633  if ( m1 != NULL ) {
1634  return true;
1635  }
1636  const SetPreFilterCapMessage *m2 = dynamic_cast<const SetPreFilterCapMessage *>(message);
1637  if ( m2 != NULL ) {
1638  return true;
1639  }
1640  const SetSADWindowSizeMessage *m3 = dynamic_cast<const SetSADWindowSizeMessage *>(message);
1641  if ( m3 != NULL ) {
1642  return true;
1643  }
1644  const SetMinDisparityMessage *m4 = dynamic_cast<const SetMinDisparityMessage *>(message);
1645  if ( m4 != NULL ) {
1646  return true;
1647  }
1648  const SetNumDisparitiesMessage *m5 = dynamic_cast<const SetNumDisparitiesMessage *>(message);
1649  if ( m5 != NULL ) {
1650  return true;
1651  }
1652  const SetTextureThresholdMessage *m6 = dynamic_cast<const SetTextureThresholdMessage *>(message);
1653  if ( m6 != NULL ) {
1654  return true;
1655  }
1656  const SetUniquenessRatioMessage *m7 = dynamic_cast<const SetUniquenessRatioMessage *>(message);
1657  if ( m7 != NULL ) {
1658  return true;
1659  }
1660  const SetSpeckleWindowSizeMessage *m8 = dynamic_cast<const SetSpeckleWindowSizeMessage *>(message);
1661  if ( m8 != NULL ) {
1662  return true;
1663  }
1664  const SetSpeckleRangeMessage *m9 = dynamic_cast<const SetSpeckleRangeMessage *>(message);
1665  if ( m9 != NULL ) {
1666  return true;
1667  }
1668  const SetTrySmallerWindowsMessage *m10 = dynamic_cast<const SetTrySmallerWindowsMessage *>(message);
1669  if ( m10 != NULL ) {
1670  return true;
1671  }
1672  return false;
1673 }
1674 
1675 /// @cond INTERNALS
1676 EXPORT_INTERFACE(OpenCVStereoParamsInterface)
1677 /// @endcond
1678 
1679 
1680 } // end namespace fawkes
void set_pre_filter_size(const uint32_t new_pre_filter_size)
Set pre_filter_size value.
void * data_ptr
Pointer to memory that contains local data.
Definition: message.h:124
SetSADWindowSizeMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_uniqueness_ratio() const
Get maximum length of uniqueness_ratio value.
Base class for all messages passed through interfaces in Fawkes BlackBoard.
Definition: message.h:44
size_t maxlenof_try_smaller_windows() const
Get maximum length of try_smaller_windows value.
void set_uniqueness_ratio(const uint32_t new_uniqueness_ratio)
Set uniqueness_ratio value.
void set_speckle_range(const uint32_t new_speckle_range)
Set speckle_range value.
size_t maxlenof_min_disparity() const
Get maximum length of min_disparity value.
Fawkes library namespace.
size_t maxlenof_sad_window_size() const
Get maximum length of sad_window_size value.
Timestamp data, must be present and first entries for each interface data structs! This leans on time...
Definition: message.h:129
size_t maxlenof_pre_filter_cap() const
Get maximum length of pre_filter_cap value.
SetPreFilterTypeMessage Fawkes BlackBoard Interface Message.
SetPreFilterSizeMessage Fawkes BlackBoard Interface Message.
Base class for all Fawkes BlackBoard interfaces.
Definition: interface.h:79
size_t maxlenof_num_disparities() const
Get maximum length of num_disparities value.
void set_sad_window_size(const uint32_t new_sad_window_size)
Set sad_window_size value.
PreFilterType pre_filter_type() const
Get pre_filter_type value.
SetTextureThresholdMessage Fawkes BlackBoard Interface Message.
message_data_ts_t * data_ts
data timestamp aliasing pointer
Definition: message.h:133
unsigned int data_size
Size of memory needed to hold all data.
Definition: message.h:125
SetTrySmallerWindowsMessage Fawkes BlackBoard Interface Message.
SetSpeckleRangeMessage Fawkes BlackBoard Interface Message.
void set_pre_filter_cap(const uint32_t new_pre_filter_cap)
Set pre_filter_cap value.
const char * type() const
Get type of interface.
Definition: interface.cpp:651
SetSpeckleWindowSizeMessage Fawkes BlackBoard Interface Message.
void set_num_disparities(const uint32_t new_num_disparities)
Set num_disparities value.
size_t maxlenof_pre_filter_size() const
Get maximum length of pre_filter_size value.
size_t maxlenof_pre_filter_type() const
Get maximum length of pre_filter_type value.
OpenCVStereoParamsInterface Fawkes BlackBoard Interface.
SetPreFilterCapMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_texture_threshold() const
Get maximum length of texture_threshold value.
SetUniquenessRatioMessage Fawkes BlackBoard Interface Message.
void set_texture_threshold(const uint32_t new_texture_threshold)
Set texture_threshold value.
32 bit integer field
Definition: types.h:41
void set_min_disparity(const int32_t new_min_disparity)
Set min_disparity value.
void set_pre_filter_type(const PreFilterType new_pre_filter_type)
Set pre_filter_type value.
PreFilterType
The type used for the pre-filter to come up with the features for the correspondence matching...
virtual bool message_valid(const Message *message) const
Check if message is valid and can be enqueued.
SetNumDisparitiesMessage Fawkes BlackBoard Interface Message.
SetMinDisparityMessage Fawkes BlackBoard Interface Message.
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:436
boolean field
Definition: types.h:36
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.
32 bit unsigned integer field
Definition: types.h:42
void set_try_smaller_windows(const bool new_try_smaller_windows)
Set try_smaller_windows value.
field with interface specific enum type
Definition: types.h:49
size_t maxlenof_speckle_range() const
Get maximum length of speckle_range value.