Time-of-Flight Library(ToF) 4.1.3
 
processing_config.hpp
1#ifndef _CHRONOPTICS_TOF_PROCESSING_CONFIG_HPP_
2#define _CHRONOPTICS_TOF_PROCESSING_CONFIG_HPP_
3
4#include <chronoptics/tof/processing_config.h>
5
6#include <chronoptics/tof/base.hpp>
7
8namespace chronoptics {
9namespace tof {
10
11/** The shape of which surrounding pixels are checked in the flying pixel filter
12 */
13enum class FlyingShape {
14 PLUS = 0, /** Four neighboring pixels in a plus shape */
15 BOX = 1, /** All eight neighboring pixels */
16};
17
18/** Mixed pixel sort mode. The mode you want to use depends on your application.
19 */
20enum class MpSortMode {
21 DARKEST = 0, /** Choose darkest path */
22 SHORTEST = 1, /** Return the surface of a translucent object, resolve corners or checkerboard lens flare */
23 BRIGHTEST = 2, /** Mixed pixels between foreground and background, get the best SNR */
24 LONGEST = 3, /** Correct lens flare from close bright objects */
25 AGGRESSOR = 4, /** Correct lens flare */
26 ADAPTIVE_SHORT_V0 = 5, /** Adaptive shortest */
27 ADAPTIVE_SHORT_V1 = 6, /** Adaptive shortest version two */
28 AGGRESSOR_V2 = 7, /** Correct lens flare version two */
29};
30
31/** What kind of binning to do
32 */
33enum class BinningMode {
34 NORMAL = 0, /** Normal binning, a BxB grid averaged to a single pixel */
35 SMART = 1, /** Smart binning, take into account the standard deviation around a chosen pixel. Similar to local means but reduces the image size */
36};
37
38/** In what dimension the xyz is exported
39 */
40enum class XyzDimension {
41 MILLIMETER = 0, /** Export in millimeters */
42 METER = 1, /** Export in meters */
43};
44
45/** Processing that can be done
46*/
47class ProcessingConfig : public detail::Base<tof_processing_config, tof_processing_config_delete> {
48 public:
49 /** Construct from pointer */
50 ProcessingConfig(tof_processing_config_t ptr) {
51 this->ptr_ = ptr;
52 }
53
54 /** Create default processing config
55 */
56 ProcessingConfig() : ProcessingConfig(tof_processing_config_new_default(TOF_ERROR_HANDLER{})) {}
57
58 /** Load processing config from disk
59 * @param file_location Location of processing config
60 */
61 ProcessingConfig(StringView file_location) : ProcessingConfig(tof_processing_config_new_from_disk(file_location, TOF_ERROR_HANDLER{})) {}
62
63 /** Write processing config to disk
64 * @param file_location Location where to save the processing config
65 */
66 void write(StringView file_location) const {
67 return tof_processing_config_write(this->ptr_, file_location, TOF_ERROR_HANDLER{});
68 }
69
70 /** Get whether processing on the gpu is enabled
71 * @return Enabled
72 */
73 bool get_gpu() const {
74 return tof_processing_config_get_gpu(this->ptr_, TOF_ERROR_HANDLER{});
75 }
76
77 /** Set whether processing on the gpu is enabled
78 * @param gpu Enabled
79 */
80 void set_gpu(bool gpu) {
81 return tof_processing_config_set_gpu(this->ptr_, gpu, TOF_ERROR_HANDLER{});
82 }
83
84 /** Get the speed of light. Only change this when operating the camera in a
85 * liquid.
86 * @return Speed of light
87 */
88 float get_speed_of_light() const {
89 return tof_processing_config_get_speed_of_light(this->ptr_, TOF_ERROR_HANDLER{});
90 }
91
92 /** Set the speed of light. Only change this when operating the camera in a
93 * liquid.
94 * @param c Speed of light
95 */
96 void set_speed_of_light(float c) {
97 return tof_processing_config_set_speed_of_light(this->ptr_, c, TOF_ERROR_HANDLER{});
98 }
99
100 /** Get whether the calibration is applied
101 * @return Enabled
102 */
104 return tof_processing_config_get_calibration_enabled(this->ptr_, TOF_ERROR_HANDLER{});
105 }
106
107 /** Set whether the calibration is applied
108 * @param enabled Enabled
109 */
110 void set_calibration_enabled(bool enabled) {
111 return tof_processing_config_set_calibration_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
112 }
113
114 /** Get whether phase unwrapping is enabled
115 * @return Enabled
116 */
118 return tof_processing_config_get_phase_unwrapping_enabled(this->ptr_, TOF_ERROR_HANDLER{});
119 }
120
121 /** Set whether phase unwrapping is enabled
122 * @param enabled Enabled
123 */
124 void set_phase_unwrapping_enabled(bool enabled) {
125 return tof_processing_config_set_phase_unwrapping_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
126 }
127
128 /** Get The maximum distance between ideal location and actual
129 * @return Max offset, range [0, 1]
130 */
132 return tof_processing_config_get_phase_unwrapping_max_offset(this->ptr_, TOF_ERROR_HANDLER{});
133 }
134
135 /** Set The maximum distance between ideal location and actual
136 * @param max_offset Max offset, range [0, 1]
137 */
138 void set_phase_unwrapping_max_offset(double max_offset) {
139 return tof_processing_config_set_phase_unwrapping_max_offset(this->ptr_, max_offset, TOF_ERROR_HANDLER{});
140 }
141
142 /** Get whether basic phase unwrapping is enabled. A simpler phase unwrapping
143 * algorithm which uses the smaller of the two modulation frequencies to
144 * unwrap the larger one. This works well with 15 and 70 MHz for example
145 * @return Enabled
146 */
148 return tof_processing_config_get_basic_phase_unwrapping_enabled(this->ptr_, TOF_ERROR_HANDLER{});
149 }
150
151 /** Set whether basic phase unwrapping is enabled. A simpler phase unwrapping
152 * algorithm which uses the smaller of the two modulation frequencies to
153 * unwrap the larger one. This works well with 15 and 70 MHz for example
154 * @param enabled Enabled
155 */
157 return tof_processing_config_set_basic_phase_unwrapping_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
158 }
159
160 /** Get the max radial offset between the two modulation frequencies.
161 * @return Max offset
162 */
164 return tof_processing_config_get_basic_phase_unwrapping_max_offset(this->ptr_, TOF_ERROR_HANDLER{});
165 }
166
167 /** Set the max radial offset between the two modulation frequencies.
168 * @param offset Max offset
169 */
171 return tof_processing_config_set_basic_phase_unwrapping_max_offset(this->ptr_, offset, TOF_ERROR_HANDLER{});
172 }
173
174 /** Get wether mpi detect is enabled
175 * @return Enabled
176 */
178 return tof_processing_config_get_mpi_detect_enabled(this->ptr_, TOF_ERROR_HANDLER{});
179 }
180
181 /** Set wether mpi detect is enabled
182 * @param enabled Enabled
183 */
184 void set_mpi_detect_enabled(bool enabled) {
185 return tof_processing_config_set_mpi_detect_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
186 }
187
188 /** Get The amplitude ratio value
189 * @return The maximum ratio
190 */
191 float get_mpi_detect_aratio() const {
192 return tof_processing_config_get_mpi_detect_aratio(this->ptr_, TOF_ERROR_HANDLER{});
193 }
194
195 /** Set The amplitude ratio value
196 * @param aratio The maximum ratio
197 */
198 void set_mpi_detect_aratio(float aratio) {
199 return tof_processing_config_set_mpi_detect_aratio(this->ptr_, aratio, TOF_ERROR_HANDLER{});
200 }
201
202 /** Get the phase difference ratio
203 * @return The maximum phase difference
204 */
206 return tof_processing_config_get_mpi_detect_phi_diff(this->ptr_, TOF_ERROR_HANDLER{});
207 }
208
209 /** Set the phase difference ratio
210 * @param phi_diff The maximum phase difference
211 */
212 void set_mpi_detect_phi_diff(float phi_diff) {
213 return tof_processing_config_set_mpi_detect_phi_diff(this->ptr_, phi_diff, TOF_ERROR_HANDLER{});
214 }
215
216 /** Get wether mixed pixel is enabled
217 * @return Enabled
218 */
220 return tof_processing_config_get_mixed_pixel_enabled(this->ptr_, TOF_ERROR_HANDLER{});
221 }
222
223 /** Set wether mixed pixel is enabled
224 * @param enabled Enabled
225 */
226 void set_mixed_pixel_enabled(bool enabled) {
227 return tof_processing_config_set_mixed_pixel_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
228 }
229
230 /** Get location of the mixed pixel look up table file
231 * @return File location
232 */
233 const char* get_mixed_pixel_lut_file() const {
234 return tof_processing_config_get_mixed_pixel_lut_file(this->ptr_, TOF_ERROR_HANDLER{});
235 }
236
237 /** Set location of the mixed pixel look up table file
238 * @param file_location File location
239 */
240 void set_mixed_pixel_lut_file(StringView file_location) {
241 return tof_processing_config_set_mixed_pixel_lut_file(this->ptr_, file_location, TOF_ERROR_HANDLER{});
242 }
243
244 /** Get minimum amplitude that pixel needs to have to apply mixed pixel to it
245 * @return Minimum amplitude
246 */
247 double get_mixed_pixel_amp_min() const {
248 return tof_processing_config_get_mixed_pixel_amp_min(this->ptr_, TOF_ERROR_HANDLER{});
249 }
250
251 /** Set minimum amplitude that pixel needs to have to apply mixed pixel to it
252 * @param amp_min Minimum amplitude
253 */
254 void set_mixed_pixel_amp_min(double amp_min) {
255 return tof_processing_config_set_mixed_pixel_amp_min(this->ptr_, amp_min, TOF_ERROR_HANDLER{});
256 }
257
258 /** Get what output is selected
259 * @return Sort mode
260 */
261 MpSortMode get_mixed_pixel_sort_mode() const {
262 return static_cast<MpSortMode>(tof_processing_config_get_mixed_pixel_sort_mode(this->ptr_, TOF_ERROR_HANDLER{}));
263 }
264
265 /** Set what output is selected
266 * @param sort_mode Sort mode
267 */
268 void set_mixed_pixel_sort_mode(MpSortMode sort_mode) {
269 return tof_processing_config_set_mixed_pixel_sort_mode(this->ptr_, static_cast<tof_mp_sort_mode>(sort_mode), TOF_ERROR_HANDLER{});
270 }
271
272 /** Get the amplitude ratio for detecting MPI
273 * @return Amplitude ratio
274 */
275 double get_mixed_pixel_aratio() const {
276 return tof_processing_config_get_mixed_pixel_aratio(this->ptr_, TOF_ERROR_HANDLER{});
277 }
278
279 /** Set the amplitude ratio for detecting MPI
280 * @param aratio Amplitude ratio
281 */
282 void set_mixed_pixel_aratio(double aratio) {
283 return tof_processing_config_set_mixed_pixel_aratio(this->ptr_, aratio, TOF_ERROR_HANDLER{});
284 }
285
286 /** Get the phase difference for detecting MPI
287 * @return Phase difference
288 */
290 return tof_processing_config_get_mixed_pixel_phi_diff(this->ptr_, TOF_ERROR_HANDLER{});
291 }
292
293 /** Set the phase difference for detecting MPI
294 * @param phi_diff Phase difference
295 */
296 void set_mixed_pixel_phi_diff(double phi_diff) {
297 return tof_processing_config_set_mixed_pixel_phi_diff(this->ptr_, phi_diff, TOF_ERROR_HANDLER{});
298 }
299
300 /** Get the threshold to classify a pixel as an aggressor
301 * @return Aggressor threshold
302 */
304 return tof_processing_config_get_mixed_pixel_aggressor_threshold(this->ptr_, TOF_ERROR_HANDLER{});
305 }
306
307 /** Set the threshold to classify a pixel as an aggressor
308 * @param threshold Aggressor threshold
309 */
310 void set_mixed_pixel_aggressor_threshold(double threshold) {
311 return tof_processing_config_set_mixed_pixel_aggressor_threshold(this->ptr_, threshold, TOF_ERROR_HANDLER{});
312 }
313
314 /** Get the minimum amount of bright pixels before a bright spot is classified
315 * as an aggressor
316 * @return Minimum aggressor size
317 */
319 return tof_processing_config_get_mixed_pixel_min_aggressor_size(this->ptr_, TOF_ERROR_HANDLER{});
320 }
321
322 /** Set the minimum amount of bright pixels before a bright spot is classified
323 * as an aggressor
324 * @param size Minimum aggressor size
325 */
327 return tof_processing_config_set_mixed_pixel_min_aggressor_size(this->ptr_, size, TOF_ERROR_HANDLER{});
328 }
329
330 /** Get the maximum error when using three modulation frequencies
331 * @return The error
332 */
334 return tof_processing_config_get_mixed_pixel_max_error_3f(this->ptr_, TOF_ERROR_HANDLER{});
335 }
336
337 /** Set the maximum error when using three modulation frequencies
338 * @param max_error_3f The error
339 */
340 void set_mixed_pixel_max_error_3f(double max_error_3f) {
341 return tof_processing_config_set_mixed_pixel_max_error_3f(this->ptr_, max_error_3f, TOF_ERROR_HANDLER{});
342 }
343
344 /** Get the maximum amplitude for adaptive sorting
345 * @return Maximum amplitude
346 */
348 return tof_processing_config_get_mixed_pixel_adaptive_amp_max(this->ptr_, TOF_ERROR_HANDLER{});
349 }
350
351 /** Set the maximum amplitude for adaptive sorting
352 * @param adaptive_amp_max Maximum amplitude
353 */
354 void set_mixed_pixel_adaptive_amp_max(double adaptive_amp_max) {
355 return tof_processing_config_set_mixed_pixel_adaptive_amp_max(this->ptr_, adaptive_amp_max, TOF_ERROR_HANDLER{});
356 }
357
358 /** Get the minimum amplitude for adaptive sorting
359 * @return Minimum amplitude
360 */
362 return tof_processing_config_get_mixed_pixel_adaptive_amp_min(this->ptr_, TOF_ERROR_HANDLER{});
363 }
364
365 /** Set the minimum amplitude for adaptive sorting
366 * @param adaptive_amp_min Minimum amplitude
367 */
368 void set_mixed_pixel_adaptive_amp_min(double adaptive_amp_min) {
369 return tof_processing_config_set_mixed_pixel_adaptive_amp_min(this->ptr_, adaptive_amp_min, TOF_ERROR_HANDLER{});
370 }
371
372 /** Get the minimum return amplitude ratio for adaptive sorting
373 * @return Minimum return ratio
374 */
376 return tof_processing_config_get_mixed_pixel_aratio_min(this->ptr_, TOF_ERROR_HANDLER{});
377 }
378
379 /** Set the minimum return amplitude ratio for adaptive sorting
380 * @param aratio_min Minimum return ratio
381 */
382 void set_mixed_pixel_aratio_min(double aratio_min) {
383 return tof_processing_config_set_mixed_pixel_aratio_min(this->ptr_, aratio_min, TOF_ERROR_HANDLER{});
384 }
385
386 /** Get The maximum phase difference before a return is not classified as
387 * aggressor
388 * @return Phase offset before not a aggressor return
389 */
391 return tof_processing_config_get_mixed_pixel_aggressor_phi_offset(this->ptr_, TOF_ERROR_HANDLER{});
392 }
393
394 /** Set The maximum phase difference before a return is not classified as
395 * aggressor
396 * @param aggressor_phi_offset Phase offset before not a aggressor return
397 */
398 void set_mixed_pixel_aggressor_phi_offset(double aggressor_phi_offset) {
399 return tof_processing_config_set_mixed_pixel_aggressor_phi_offset(this->ptr_, aggressor_phi_offset, TOF_ERROR_HANDLER{});
400 }
401
402 /** Get whether hdr is enabled. High dynamic range allows you to separate
403 * depth with high intensity difference. This is mostly useful when the sensor
404 * is being saturated.
405 * @return Enabled
406 */
407 bool get_hdr_enabled() const {
408 return tof_processing_config_get_hdr_enabled(this->ptr_, TOF_ERROR_HANDLER{});
409 }
410
411 /** Set whether hdr is enabled. High dynamic range allows you to separate
412 * depth with high intensity difference. This is mostly useful when the sensor
413 * is being saturated.
414 * @param enabled Enabled
415 */
416 void set_hdr_enabled(bool enabled) {
417 return tof_processing_config_set_hdr_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
418 }
419
420 /** Get whether averaging is enabled. The average process allows you to
421 * average multiple frames together at the cost of frame rate
422 * @return Enabled
423 */
424 bool get_average_enabled() const {
425 return tof_processing_config_get_average_enabled(this->ptr_, TOF_ERROR_HANDLER{});
426 }
427
428 /** Set whether averaging is enabled. The average process allows you to
429 * average multiple frames together at the cost of frame rate
430 * @param enabled Enabled
431 */
432 void set_average_enabled(bool enabled) {
433 return tof_processing_config_set_average_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
434 }
435
436 /** Get the number of frames to average together
437 * @return Number of frames
438 */
439 size_t get_average_nframes() const {
440 return tof_processing_config_get_average_nframes(this->ptr_, TOF_ERROR_HANDLER{});
441 }
442
443 /** Set the number of frames to average together
444 * @param nframes Number of frames
445 */
446 void set_average_nframes(size_t nframes) {
447 return tof_processing_config_set_average_nframes(this->ptr_, nframes, TOF_ERROR_HANDLER{});
448 }
449
450 /** Get whether the temporal filter is enabled. The temporal filter is a
451 * running average as long as the values are within sigma standard deviations
452 * of each other
453 * @return Enabled
454 */
455 bool get_temporal_enabled() const {
456 return tof_processing_config_get_temporal_enabled(this->ptr_, TOF_ERROR_HANDLER{});
457 }
458
459 /** Set whether the temporal filter is enabled. The temporal filter is a
460 * running average as long as the values are within sigma standard deviations
461 * of each other
462 * @param enabled Enabled
463 */
464 void set_temporal_enabled(bool enabled) {
465 return tof_processing_config_set_temporal_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
466 }
467
468 /** Get the number of standard deviations before resetting the running average
469 * @return The standard deviation
470 */
471 double get_temporal_sigma() const {
472 return tof_processing_config_get_temporal_sigma(this->ptr_, TOF_ERROR_HANDLER{});
473 }
474
475 /** Set the number of standard deviations before resetting the running average
476 * @param sigma The standard deviation
477 */
478 void set_temporal_sigma(double sigma) {
479 return tof_processing_config_set_temporal_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
480 }
481
482 /** Get whether to use common data or amplitude data to determine noisiness of
483 * signal
484 * @return Use common
485 */
487 return tof_processing_config_get_temporal_use_common(this->ptr_, TOF_ERROR_HANDLER{});
488 }
489
490 /** Set whether to use common data or amplitude data to determine noisiness of
491 * signal
492 * @param use_common Use common
493 */
494 void set_temporal_use_common(bool use_common) {
495 return tof_processing_config_set_temporal_use_common(this->ptr_, use_common, TOF_ERROR_HANDLER{});
496 }
497
498 /** Get the maximum number of frames to average together
499 * @return Number of frames
500 */
501 size_t get_temporal_nframes() const {
502 return tof_processing_config_get_temporal_nframes(this->ptr_, TOF_ERROR_HANDLER{});
503 }
504
505 /** Set the maximum number of frames to average together
506 * @param nframes Number of frames
507 */
508 void set_temporal_nframes(size_t nframes) {
509 return tof_processing_config_set_temporal_nframes(this->ptr_, nframes, TOF_ERROR_HANDLER{});
510 }
511
512 /** Get whether the gaussian blur is enabled. This is a standard gaussian blur
513 * applied over the depth image
514 * @return Enabled
515 */
516 bool get_gaussian_enabled() const {
517 return tof_processing_config_get_gaussian_enabled(this->ptr_, TOF_ERROR_HANDLER{});
518 }
519
520 /** Set whether the gaussian blur is enabled. This is a standard gaussian blur
521 * applied over the depth image
522 * @param enabled Enabled
523 */
524 void set_gaussian_enabled(bool enabled) {
525 return tof_processing_config_set_gaussian_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
526 }
527
528 /** Get the gaussian region size
529 * @return Region size, 3x3 and 5x5 are supported
530 */
531 size_t get_gaussian_size() const {
532 return tof_processing_config_get_gaussian_size(this->ptr_, TOF_ERROR_HANDLER{});
533 }
534
535 /** Set the gaussian region size
536 * @param size Region size, 3x3 and 5x5 are supported
537 */
538 void set_gaussian_size(size_t size) {
539 return tof_processing_config_set_gaussian_size(this->ptr_, size, TOF_ERROR_HANDLER{});
540 }
541
542 /** Get the gaussian sigma
543 * @return The standard deviation
544 */
545 double get_gaussian_sigma() const {
546 return tof_processing_config_get_gaussian_sigma(this->ptr_, TOF_ERROR_HANDLER{});
547 }
548
549 /** Set the gaussian sigma
550 * @param sigma The standard deviation
551 */
552 void set_gaussian_sigma(double sigma) {
553 return tof_processing_config_set_gaussian_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
554 }
555
556 /** Get whether the median filter is enabled. This is a standard median filter
557 * applied over the depth image
558 * @return Enabled
559 */
560 bool get_median_enabled() const {
561 return tof_processing_config_get_median_enabled(this->ptr_, TOF_ERROR_HANDLER{});
562 }
563
564 /** Set whether the median filter is enabled. This is a standard median filter
565 * applied over the depth image
566 * @param enabled Enabled
567 */
568 void set_median_enabled(bool enabled) {
569 return tof_processing_config_set_median_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
570 }
571
572 /** Get the median region size
573 * @return Region size, 3x3 and 5x5 are supported
574 */
575 size_t get_median_size() const {
576 return tof_processing_config_get_median_size(this->ptr_, TOF_ERROR_HANDLER{});
577 }
578
579 /** Set the median region size
580 * @param size Region size, 3x3 and 5x5 are supported
581 */
582 void set_median_size(size_t size) {
583 return tof_processing_config_set_median_size(this->ptr_, size, TOF_ERROR_HANDLER{});
584 }
585
586 /** Get whether the bilateral filter is enabled. This filter averages the
587 * current pixel with neighboring ones if they're within the specified
588 * standard deviation
589 * @return Enabled
590 */
592 return tof_processing_config_get_bilateral_enabled(this->ptr_, TOF_ERROR_HANDLER{});
593 }
594
595 /** Set whether the bilateral filter is enabled. This filter averages the
596 * current pixel with neighboring ones if they're within the specified
597 * standard deviation
598 * @param enabled Enabled
599 */
600 void set_bilateral_enabled(bool enabled) {
601 return tof_processing_config_set_bilateral_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
602 }
603
604 /** Get the bilateral region size
605 * @return Region size, 3x3 and 5x5 are supported
606 */
607 size_t get_bilateral_size() const {
608 return tof_processing_config_get_bilateral_size(this->ptr_, TOF_ERROR_HANDLER{});
609 }
610
611 /** Set the bilateral region size
612 * @param size Region size, 3x3 and 5x5 are supported
613 */
614 void set_bilateral_size(size_t size) {
615 return tof_processing_config_set_bilateral_size(this->ptr_, size, TOF_ERROR_HANDLER{});
616 }
617
618 /** Get the bilateral standard deviation
619 * @return The standard deviation
620 */
621 double get_bilateral_sigma() const {
622 return tof_processing_config_get_bilateral_sigma(this->ptr_, TOF_ERROR_HANDLER{});
623 }
624
625 /** Set the bilateral standard deviation
626 * @param sigma The standard deviation
627 */
628 void set_bilateral_sigma(double sigma) {
629 return tof_processing_config_set_bilateral_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
630 }
631
632 /** Get Whether the local means filter is enabled.
633 * @return Enabled
634 */
636 return tof_processing_config_get_local_means_enabled(this->ptr_, TOF_ERROR_HANDLER{});
637 }
638
639 /** Set Whether the local means filter is enabled.
640 * @param enabled Enabled
641 */
642 void set_local_means_enabled(bool enabled) {
643 return tof_processing_config_set_local_means_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
644 }
645
646 /** Get The local means region size
647 * @return Region size
648 */
649 size_t get_local_means_size() const {
650 return tof_processing_config_get_local_means_size(this->ptr_, TOF_ERROR_HANDLER{});
651 }
652
653 /** Set The local means region size
654 * @param size Region size
655 */
656 void set_local_means_size(size_t size) {
657 return tof_processing_config_set_local_means_size(this->ptr_, size, TOF_ERROR_HANDLER{});
658 }
659
660 /** Get The local means standard deviation for how close values are
661 * @return The stand deviation
662 */
663 double get_local_means_sigma() const {
664 return tof_processing_config_get_local_means_sigma(this->ptr_, TOF_ERROR_HANDLER{});
665 }
666
667 /** Set The local means standard deviation for how close values are
668 * @param sigma The stand deviation
669 */
670 void set_local_means_sigma(double sigma) {
671 return tof_processing_config_set_local_means_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
672 }
673
674 /** Get whether flying pixel filter is enabled. The flying pixel filters out
675 * pixels when more than x edges are farther than x size away
676 * @return Enabled
677 */
678 bool get_flying_enabled() const {
679 return tof_processing_config_get_flying_enabled(this->ptr_, TOF_ERROR_HANDLER{});
680 }
681
682 /** Set whether flying pixel filter is enabled. The flying pixel filters out
683 * pixels when more than x edges are farther than x size away
684 * @param enabled Enabled
685 */
686 void set_flying_enabled(bool enabled) {
687 return tof_processing_config_set_flying_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
688 }
689
690 /** Get the shape of which surrounding pixels are checked
691 * @return The shape
692 */
693 FlyingShape get_flying_shape() const {
694 return static_cast<FlyingShape>(tof_processing_config_get_flying_shape(this->ptr_, TOF_ERROR_HANDLER{}));
695 }
696
697 /** Set the shape of which surrounding pixels are checked
698 * @param shape The shape
699 */
700 void set_flying_shape(FlyingShape shape) {
701 return tof_processing_config_set_flying_shape(this->ptr_, static_cast<tof_flying_shape>(shape), TOF_ERROR_HANDLER{});
702 }
703
704 /** Get the maximum distance allowed between surrounding pixels
705 * @return Maximum distance
706 */
707 size_t get_flying_distance() const {
708 return tof_processing_config_get_flying_distance(this->ptr_, TOF_ERROR_HANDLER{});
709 }
710
711 /** Set the maximum distance allowed between surrounding pixels
712 * @param distance Maximum distance
713 */
714 void set_flying_distance(size_t distance) {
715 return tof_processing_config_set_flying_distance(this->ptr_, distance, TOF_ERROR_HANDLER{});
716 }
717
718 /** Get the number of edges allowed to be larger than maximum distance
719 * @return Maximum edges
720 */
721 size_t get_flying_edges() const {
722 return tof_processing_config_get_flying_edges(this->ptr_, TOF_ERROR_HANDLER{});
723 }
724
725 /** Set the number of edges allowed to be larger than maximum distance
726 * @param edges Maximum edges
727 */
728 void set_flying_edges(size_t edges) {
729 return tof_processing_config_set_flying_edges(this->ptr_, edges, TOF_ERROR_HANDLER{});
730 }
731
732 /** Get another distance threshold which is scaled by the radial distance
733 * @return What to scale the radial distance by, from 0.0 to 1.0
734 */
736 return tof_processing_config_get_flying_distance_scaled(this->ptr_, TOF_ERROR_HANDLER{});
737 }
738
739 /** Set another distance threshold which is scaled by the radial distance
740 * @param scale What to scale the radial distance by, from 0.0 to 1.0
741 */
742 void set_flying_distance_scaled(float scale) {
743 return tof_processing_config_set_flying_distance_scaled(this->ptr_, scale, TOF_ERROR_HANDLER{});
744 }
745
746 /** Get whether the amplitude threshold filter is enabled. This filter filters
747 * out pixels outside of the specified values
748 * @return Enabled
749 */
751 return tof_processing_config_get_amp_threshold_enabled(this->ptr_, TOF_ERROR_HANDLER{});
752 }
753
754 /** Set whether the amplitude threshold filter is enabled. This filter filters
755 * out pixels outside of the specified values
756 * @param enabled Enabled
757 */
758 void set_amp_threshold_enabled(bool enabled) {
759 return tof_processing_config_set_amp_threshold_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
760 }
761
762 /** Get the minimum amplitude allowed
763 * @return Minimum value
764 */
765 double get_amp_threshold_min() const {
766 return tof_processing_config_get_amp_threshold_min(this->ptr_, TOF_ERROR_HANDLER{});
767 }
768
769 /** Set the minimum amplitude allowed
770 * @param min Minimum value
771 */
772 void set_amp_threshold_min(double min) {
773 return tof_processing_config_set_amp_threshold_min(this->ptr_, min, TOF_ERROR_HANDLER{});
774 }
775
776 /** Get the maximum amplitude allowed
777 * @return Maximum value
778 */
779 double get_amp_threshold_max() const {
780 return tof_processing_config_get_amp_threshold_max(this->ptr_, TOF_ERROR_HANDLER{});
781 }
782
783 /** Set the maximum amplitude allowed
784 * @param max Maximum value
785 */
786 void set_amp_threshold_max(double max) {
787 return tof_processing_config_set_amp_threshold_max(this->ptr_, max, TOF_ERROR_HANDLER{});
788 }
789
790 /** Get whether the distance threshold filter is enabled. This filter filters
791 * out pixels outside of the specified values
792 * @return Enabled
793 */
795 return tof_processing_config_get_dist_threshold_enabled(this->ptr_, TOF_ERROR_HANDLER{});
796 }
797
798 /** Set whether the distance threshold filter is enabled. This filter filters
799 * out pixels outside of the specified values
800 * @param enabled Enabled
801 */
802 void set_dist_threshold_enabled(bool enabled) {
803 return tof_processing_config_set_dist_threshold_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
804 }
805
806 /** Get the minimum distance allowed
807 * @return Minimum value
808 */
809 double get_dist_threshold_min() const {
810 return tof_processing_config_get_dist_threshold_min(this->ptr_, TOF_ERROR_HANDLER{});
811 }
812
813 /** Set the minimum distance allowed
814 * @param min Minimum value
815 */
816 void set_dist_threshold_min(double min) {
817 return tof_processing_config_set_dist_threshold_min(this->ptr_, min, TOF_ERROR_HANDLER{});
818 }
819
820 /** Get the maximum distance allowed
821 * @return Maximum value
822 */
823 double get_dist_threshold_max() const {
824 return tof_processing_config_get_dist_threshold_max(this->ptr_, TOF_ERROR_HANDLER{});
825 }
826
827 /** Set the maximum distance allowed
828 * @param max Maximum value
829 */
830 void set_dist_threshold_max(double max) {
831 return tof_processing_config_set_dist_threshold_max(this->ptr_, max, TOF_ERROR_HANDLER{});
832 }
833
834 /** Get DEPRECATED Use reflectivity threshold instead. whether the amplitude
835 * dot segmentation filter is enabled. This filter is designed to filter out
836 * everything but the dots in cameras with dot illumination. It has also
837 * proved effective at removing shadowing effects in kea
838 * @return Enabled
839 */
841 return tof_processing_config_get_amp_dot_segment_enabled(this->ptr_, TOF_ERROR_HANDLER{});
842 }
843
844 /** Set DEPRECATED Use reflectivity threshold instead. whether the amplitude
845 * dot segmentation filter is enabled. This filter is designed to filter out
846 * everything but the dots in cameras with dot illumination. It has also
847 * proved effective at removing shadowing effects in kea
848 * @param enabled Enabled
849 */
850 void set_amp_dot_segment_enabled(bool enabled) {
851 return tof_processing_config_set_amp_dot_segment_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
852 }
853
854 /** Get DEPRECATED Use reflectivity threshold instead. the minimum corrected
855 * amplitude that is allowed
856 * @return Amplitude threshold
857 */
859 return tof_processing_config_get_amp_dot_segment_threshold(this->ptr_, TOF_ERROR_HANDLER{});
860 }
861
862 /** Set DEPRECATED Use reflectivity threshold instead. the minimum corrected
863 * amplitude that is allowed
864 * @param threshold Amplitude threshold
865 */
866 void set_amp_dot_segment_threshold(float threshold) {
867 return tof_processing_config_set_amp_dot_segment_threshold(this->ptr_, threshold, TOF_ERROR_HANDLER{});
868 }
869
870 /** Get DEPRECATED Use reflectivity modifier instead . the distance after
871 * which amplitude is increased instead of decreased
872 * @return Radial midpoint
873 */
875 return tof_processing_config_get_amp_dot_segment_midpoint(this->ptr_, TOF_ERROR_HANDLER{});
876 }
877
878 /** Set DEPRECATED Use reflectivity modifier instead . the distance after
879 * which amplitude is increased instead of decreased
880 * @param midpoint Radial midpoint
881 */
882 void set_amp_dot_segment_midpoint(float midpoint) {
883 return tof_processing_config_set_amp_dot_segment_midpoint(this->ptr_, midpoint, TOF_ERROR_HANDLER{});
884 }
885
886 /** Get DEPRECATED No replacement implemented. the maximum amount of
887 * correction that can be performed on the distance component
888 * @return Max radial correction
889 */
891 return tof_processing_config_get_amp_dot_segment_max_correction(this->ptr_, TOF_ERROR_HANDLER{});
892 }
893
894 /** Set DEPRECATED No replacement implemented. the maximum amount of
895 * correction that can be performed on the distance component
896 * @param correction Max radial correction
897 */
898 void set_amp_dot_segment_max_correction(float correction) {
899 return tof_processing_config_set_amp_dot_segment_max_correction(this->ptr_, correction, TOF_ERROR_HANDLER{});
900 }
901
902 /** Get whether the common amplitude ratio threshold filter is enabled. This
903 * filter calculates the difference between the amplitude and ir data and you
904 * can set a certain threshold. This is useful to get rid of pixels that are
905 * heavily saturated with sunlight since the difference between amplitude and
906 * total ir light will be large.
907 * @return Enabled
908 */
910 return tof_processing_config_get_common_amp_ratio_enabled(this->ptr_, TOF_ERROR_HANDLER{});
911 }
912
913 /** Set whether the common amplitude ratio threshold filter is enabled. This
914 * filter calculates the difference between the amplitude and ir data and you
915 * can set a certain threshold. This is useful to get rid of pixels that are
916 * heavily saturated with sunlight since the difference between amplitude and
917 * total ir light will be large.
918 * @param enabled Enabled
919 */
920 void set_common_amp_ratio_enabled(bool enabled) {
921 return tof_processing_config_set_common_amp_ratio_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
922 }
923
924 /** Get the maximum allowed ratio
925 * @return The threshold
926 */
928 return tof_processing_config_get_common_amp_ratio_threshold(this->ptr_, TOF_ERROR_HANDLER{});
929 }
930
931 /** Set the maximum allowed ratio
932 * @param threshold The threshold
933 */
934 void set_common_amp_ratio_threshold(float threshold) {
935 return tof_processing_config_set_common_amp_ratio_threshold(this->ptr_, threshold, TOF_ERROR_HANDLER{});
936 }
937
938 /** Get whether the morph erode filter is enabled. The morph erode filter
939 * removes pixels that have no neighboring (correct) pixels.
940 * @return Enabled
941 */
943 return tof_processing_config_get_morph_erode_enabled(this->ptr_, TOF_ERROR_HANDLER{});
944 }
945
946 /** Set whether the morph erode filter is enabled. The morph erode filter
947 * removes pixels that have no neighboring (correct) pixels.
948 * @param enabled Enabled
949 */
950 void set_morph_erode_enabled(bool enabled) {
951 return tof_processing_config_set_morph_erode_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
952 }
953
954 /** Get the shape of the neighboring pixels.
955 * @return The shape
956 */
957 FlyingShape get_morph_erode_shape() const {
958 return static_cast<FlyingShape>(tof_processing_config_get_morph_erode_shape(this->ptr_, TOF_ERROR_HANDLER{}));
959 }
960
961 /** Set the shape of the neighboring pixels.
962 * @param shape The shape
963 */
964 void set_morph_erode_shape(FlyingShape shape) {
965 return tof_processing_config_set_morph_erode_shape(this->ptr_, static_cast<tof_flying_shape>(shape), TOF_ERROR_HANDLER{});
966 }
967
968 /** Get how much to scale the radial value by
969 * @return Radial scale
970 */
971 float get_radial_scale() const {
972 return tof_processing_config_get_radial_scale(this->ptr_, TOF_ERROR_HANDLER{});
973 }
974
975 /** Set how much to scale the radial value by
976 * @param scale Radial scale
977 */
978 void set_radial_scale(float scale) {
979 return tof_processing_config_set_radial_scale(this->ptr_, scale, TOF_ERROR_HANDLER{});
980 }
981
982 /** Get how much to add to the radial value
983 * @return Radial addition
984 */
985 float get_radial_add() const {
986 return tof_processing_config_get_radial_add(this->ptr_, TOF_ERROR_HANDLER{});
987 }
988
989 /** Set how much to add to the radial value
990 * @param addition Radial addition
991 */
992 void set_radial_add(float addition) {
993 return tof_processing_config_set_radial_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
994 }
995
996 /** Get how much to scale the intensity value by
997 * @return Intensity scale
998 */
999 float get_intensity_scale() const {
1000 return tof_processing_config_get_intensity_scale(this->ptr_, TOF_ERROR_HANDLER{});
1001 }
1002
1003 /** Set how much to scale the intensity value by
1004 * @param scale Intensity scale
1005 */
1006 void set_intensity_scale(float scale) {
1007 return tof_processing_config_set_intensity_scale(this->ptr_, scale, TOF_ERROR_HANDLER{});
1008 }
1009
1010 /** Get how much to add to the intensity value
1011 * @return Intensity addition
1012 */
1013 float get_intensity_add() const {
1014 return tof_processing_config_get_intensity_add(this->ptr_, TOF_ERROR_HANDLER{});
1015 }
1016
1017 /** Set how much to add to the intensity value
1018 * @param addition Intensity addition
1019 */
1020 void set_intensity_add(float addition) {
1021 return tof_processing_config_set_intensity_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
1022 }
1023
1024 /** Get how much to scale the reflectivity value by
1025 * @return Reflectivity scale
1026 */
1028 return tof_processing_config_get_reflectivity_scale(this->ptr_, TOF_ERROR_HANDLER{});
1029 }
1030
1031 /** Set how much to scale the reflectivity value by
1032 * @param scale Reflectivity scale
1033 */
1034 void set_reflectivity_scale(float scale) {
1035 return tof_processing_config_set_reflectivity_scale(this->ptr_, scale, TOF_ERROR_HANDLER{});
1036 }
1037
1038 /** Get how much to add to the reflectivity value
1039 * @return Reflectivity addition
1040 */
1041 float get_reflectivity_add() const {
1042 return tof_processing_config_get_reflectivity_add(this->ptr_, TOF_ERROR_HANDLER{});
1043 }
1044
1045 /** Set how much to add to the reflectivity value
1046 * @param addition Reflectivity addition
1047 */
1048 void set_reflectivity_add(float addition) {
1049 return tof_processing_config_set_reflectivity_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
1050 }
1051
1052 /** Get the characterization addition component. The characterization function
1053 * computes the sigma for the temporal and bilateral filter
1054 * @return addition
1055 */
1056 double get_char_add() const {
1057 return tof_processing_config_get_char_add(this->ptr_, TOF_ERROR_HANDLER{});
1058 }
1059
1060 /** Set the characterization addition component. The characterization function
1061 * computes the sigma for the temporal and bilateral filter
1062 * @param addition addition
1063 */
1064 void set_char_add(double addition) {
1065 return tof_processing_config_set_char_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
1066 }
1067
1068 /** Get the characterization multiplication component. The characterization
1069 * function computes the sigma for the temporal and bilateral filter
1070 * @return Multiplication
1071 */
1072 double get_char_mult() const {
1073 return tof_processing_config_get_char_mult(this->ptr_, TOF_ERROR_HANDLER{});
1074 }
1075
1076 /** Set the characterization multiplication component. The characterization
1077 * function computes the sigma for the temporal and bilateral filter
1078 * @param multiplication Multiplication
1079 */
1080 void set_char_mult(double multiplication) {
1081 return tof_processing_config_set_char_mult(this->ptr_, multiplication, TOF_ERROR_HANDLER{});
1082 }
1083
1084 /** Get whether software binning is enabled
1085 * @return Enabled
1086 */
1087 bool get_binning_enabled() const {
1088 return tof_processing_config_get_binning_enabled(this->ptr_, TOF_ERROR_HANDLER{});
1089 }
1090
1091 /** Set whether software binning is enabled
1092 * @param enabled Enabled
1093 */
1094 void set_binning_enabled(bool enabled) {
1095 return tof_processing_config_set_binning_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
1096 }
1097
1098 /** Get the size of the area to bin, 2 would bin a 2x2 area
1099 * @return The bin size
1100 */
1101 size_t get_binning_size() const {
1102 return tof_processing_config_get_binning_size(this->ptr_, TOF_ERROR_HANDLER{});
1103 }
1104
1105 /** Set the size of the area to bin, 2 would bin a 2x2 area
1106 * @param size The bin size
1107 */
1108 void set_binning_size(size_t size) {
1109 return tof_processing_config_set_binning_size(this->ptr_, size, TOF_ERROR_HANDLER{});
1110 }
1111
1112 /** Get the binning mode to use
1113 * @return The binning mode
1114 */
1115 BinningMode get_binning_mode() const {
1116 return static_cast<BinningMode>(tof_processing_config_get_binning_mode(this->ptr_, TOF_ERROR_HANDLER{}));
1117 }
1118
1119 /** Set the binning mode to use
1120 * @param mode The binning mode
1121 */
1122 void set_binning_mode(BinningMode mode) {
1123 return tof_processing_config_set_binning_mode(this->ptr_, static_cast<tof_binning_mode>(mode), TOF_ERROR_HANDLER{});
1124 }
1125
1126 /** Get The maximum standard deviation to use, only used in the smart binning
1127 * mode
1128 * @return The standard deviation
1129 */
1130 float get_binning_sigma() const {
1131 return tof_processing_config_get_binning_sigma(this->ptr_, TOF_ERROR_HANDLER{});
1132 }
1133
1134 /** Set The maximum standard deviation to use, only used in the smart binning
1135 * mode
1136 * @param sigma The standard deviation
1137 */
1138 void set_binning_sigma(float sigma) {
1139 return tof_processing_config_set_binning_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
1140 }
1141
1142 /** Get the dimension of the xyz output
1143 * @return The dimension
1144 */
1145 XyzDimension get_xyz_dimension() const {
1146 return static_cast<XyzDimension>(tof_processing_config_get_xyz_dimension(this->ptr_, TOF_ERROR_HANDLER{}));
1147 }
1148
1149 /** Set the dimension of the xyz output
1150 * @param dimension The dimension
1151 */
1152 void set_xyz_dimension(XyzDimension dimension) {
1153 return tof_processing_config_set_xyz_dimension(this->ptr_, static_cast<tof_xyz_dimension>(dimension), TOF_ERROR_HANDLER{});
1154 }
1155
1156 /** Get whether rigid transformation is enabled
1157 * @return Enabled
1158 */
1160 return tof_processing_config_get_rigid_transformation_enabled(this->ptr_, TOF_ERROR_HANDLER{});
1161 }
1162
1163 /** Set whether rigid transformation is enabled
1164 * @param enabled Enabled
1165 */
1167 return tof_processing_config_set_rigid_transformation_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
1168 }
1169
1170 /** Get the rigid transformation 4x4 matrix
1171 * @return 4x4 transformation matrix
1172 */
1173 std::array<float, 16> get_rigid_transformation_matrix() const {
1174 std::array<float, 16> array;
1175 auto data = tof_processing_config_get_rigid_transformation_matrix(this->ptr_, TOF_ERROR_HANDLER{});
1176 std::copy(data, data + array.size(), array.data());
1177 return array;
1178 }
1179
1180 /** Set the rigid transformation 4x4 matrix
1181 * @param matrix 4x4 transformation matrix
1182 */
1183 void set_rigid_transformation_matrix(const std::array<float, 16> &matrix) {
1184 return tof_processing_config_set_rigid_transformation_matrix(this->ptr_, matrix.data(), TOF_ERROR_HANDLER{});
1185 }
1186
1187 /** Get the radial distance threshold
1188 * @return Enabled
1189 */
1191 return tof_processing_config_get_rad_dist_threshold_enabled(this->ptr_, TOF_ERROR_HANDLER{});
1192 }
1193
1194 /** Set the radial distance threshold
1195 * @param enabled Enabled
1196 */
1198 return tof_processing_config_set_rad_dist_threshold_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
1199 }
1200
1201 /** Get the minimum radial distance
1202 * @return Minimum
1203 */
1205 return tof_processing_config_get_rad_dist_threshold_min(this->ptr_, TOF_ERROR_HANDLER{});
1206 }
1207
1208 /** Set the minimum radial distance
1209 * @param min Minimum
1210 */
1212 return tof_processing_config_set_rad_dist_threshold_min(this->ptr_, min, TOF_ERROR_HANDLER{});
1213 }
1214
1215 /** Get the maximum radial distance
1216 * @return Maximum
1217 */
1219 return tof_processing_config_get_rad_dist_threshold_max(this->ptr_, TOF_ERROR_HANDLER{});
1220 }
1221
1222 /** Set the maximum radial distance
1223 * @param max Maximum
1224 */
1226 return tof_processing_config_set_rad_dist_threshold_max(this->ptr_, max, TOF_ERROR_HANDLER{});
1227 }
1228
1229 /** Get what to divide the final value by such that it is a usable value
1230 * @return Modifier
1231 */
1233 return tof_processing_config_get_reflectivity_modifier(this->ptr_, TOF_ERROR_HANDLER{});
1234 }
1235
1236 /** Set what to divide the final value by such that it is a usable value
1237 * @param modifier Modifier
1238 */
1239 void set_reflectivity_modifier(float modifier) {
1240 return tof_processing_config_set_reflectivity_modifier(this->ptr_, modifier, TOF_ERROR_HANDLER{});
1241 }
1242
1243 /** Get whether reflectivity threshold is enabled. Reflectivity threshold
1244 * filters based on reflectivity.
1245 * @return Enabled
1246 */
1248 return tof_processing_config_get_reflectivity_threshold_enabled(this->ptr_, TOF_ERROR_HANDLER{});
1249 }
1250
1251 /** Set whether reflectivity threshold is enabled. Reflectivity threshold
1252 * filters based on reflectivity.
1253 * @param enabled Enabled
1254 */
1256 return tof_processing_config_set_reflectivity_threshold_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
1257 }
1258
1259 /** Get the minimum reflectivity allowed
1260 * @return Minimum
1261 */
1263 return tof_processing_config_get_reflectivity_threshold_min(this->ptr_, TOF_ERROR_HANDLER{});
1264 }
1265
1266 /** Set the minimum reflectivity allowed
1267 * @param min Minimum
1268 */
1270 return tof_processing_config_set_reflectivity_threshold_min(this->ptr_, min, TOF_ERROR_HANDLER{});
1271 }
1272
1273 /** Get the maximum reflectivity allowed
1274 * @return Maximum
1275 */
1277 return tof_processing_config_get_reflectivity_threshold_max(this->ptr_, TOF_ERROR_HANDLER{});
1278 }
1279
1280 /** Set the maximum reflectivity allowed
1281 * @param max Maximum
1282 */
1284 return tof_processing_config_set_reflectivity_threshold_max(this->ptr_, max, TOF_ERROR_HANDLER{});
1285 }
1286
1287};
1288
1289} // tof
1290} // chronoptics
1291
1292#endif
Processing that can be done.
void set_mixed_pixel_max_error_3f(double max_error_3f)
Set the maximum error when using three modulation frequencies.
float get_amp_dot_segment_midpoint() const
Get DEPRECATED Use reflectivity modifier instead .
size_t get_average_nframes() const
Get the number of frames to average together.
void set_bilateral_size(size_t size)
Set the bilateral region size.
void set_mixed_pixel_enabled(bool enabled)
Set wether mixed pixel is enabled.
size_t get_flying_edges() const
Get the number of edges allowed to be larger than maximum distance.
double get_bilateral_sigma() const
Get the bilateral standard deviation.
void set_hdr_enabled(bool enabled)
Set whether hdr is enabled.
void set_basic_phase_unwrapping_max_offset(double offset)
Set the max radial offset between the two modulation frequencies.
void set_amp_dot_segment_midpoint(float midpoint)
Set DEPRECATED Use reflectivity modifier instead .
bool get_phase_unwrapping_enabled() const
Get whether phase unwrapping is enabled.
void set_morph_erode_enabled(bool enabled)
Set whether the morph erode filter is enabled.
double get_mixed_pixel_adaptive_amp_min() const
Get the minimum amplitude for adaptive sorting.
bool get_hdr_enabled() const
Get whether hdr is enabled.
void set_rad_dist_threshold_max(double max)
Set the maximum radial distance.
void set_rigid_transformation_matrix(const std::array< float, 16 > &matrix)
Set the rigid transformation 4x4 matrix.
void set_temporal_nframes(size_t nframes)
Set the maximum number of frames to average together.
bool get_binning_enabled() const
Get whether software binning is enabled.
void set_amp_threshold_enabled(bool enabled)
Set whether the amplitude threshold filter is enabled.
bool get_mixed_pixel_enabled() const
Get wether mixed pixel is enabled.
float get_intensity_add() const
Get how much to add to the intensity value.
double get_mixed_pixel_aggressor_threshold() const
Get the threshold to classify a pixel as an aggressor.
bool get_gpu() const
Get whether processing on the gpu is enabled.
void set_reflectivity_add(float addition)
Set how much to add to the reflectivity value.
FlyingShape get_flying_shape() const
Get the shape of which surrounding pixels are checked.
bool get_morph_erode_enabled() const
Get whether the morph erode filter is enabled.
float get_radial_add() const
Get how much to add to the radial value.
double get_mixed_pixel_aratio_min() const
Get the minimum return amplitude ratio for adaptive sorting.
std::array< float, 16 > get_rigid_transformation_matrix() const
Get the rigid transformation 4x4 matrix.
void set_temporal_sigma(double sigma)
Set the number of standard deviations before resetting the running average.
double get_temporal_sigma() const
Get the number of standard deviations before resetting the running average.
void set_binning_sigma(float sigma)
Set The maximum standard deviation to use, only used in the smart binning mode.
void set_mixed_pixel_min_aggressor_size(int32_t size)
Set the minimum amount of bright pixels before a bright spot is classified as an aggressor.
void set_common_amp_ratio_threshold(float threshold)
Set the maximum allowed ratio.
bool get_local_means_enabled() const
Get Whether the local means filter is enabled.
void set_local_means_size(size_t size)
Set The local means region size.
void set_basic_phase_unwrapping_enabled(bool enabled)
Set whether basic phase unwrapping is enabled.
void set_reflectivity_modifier(float modifier)
Set what to divide the final value by such that it is a usable value.
void set_temporal_use_common(bool use_common)
Set whether to use common data or amplitude data to determine noisiness of signal.
void set_gaussian_sigma(double sigma)
Set the gaussian sigma.
void set_average_nframes(size_t nframes)
Set the number of frames to average together.
ProcessingConfig()
Create default processing config.
float get_intensity_scale() const
Get how much to scale the intensity value by.
bool get_temporal_use_common() const
Get whether to use common data or amplitude data to determine noisiness of signal.
bool get_common_amp_ratio_enabled() const
Get whether the common amplitude ratio threshold filter is enabled.
double get_char_mult() const
Get the characterization multiplication component.
float get_reflectivity_threshold_max() const
Get the maximum reflectivity allowed.
void set_binning_enabled(bool enabled)
Set whether software binning is enabled.
bool get_rigid_transformation_enabled() const
Get whether rigid transformation is enabled.
void set_mixed_pixel_sort_mode(MpSortMode sort_mode)
Set what output is selected.
float get_reflectivity_scale() const
Get how much to scale the reflectivity value by.
float get_mpi_detect_aratio() const
Get The amplitude ratio value.
double get_gaussian_sigma() const
Get the gaussian sigma.
void set_mixed_pixel_aggressor_phi_offset(double aggressor_phi_offset)
Set The maximum phase difference before a return is not classified as aggressor.
void set_amp_dot_segment_max_correction(float correction)
Set DEPRECATED No replacement implemented.
double get_mixed_pixel_aggressor_phi_offset() const
Get The maximum phase difference before a return is not classified as aggressor.
void set_reflectivity_threshold_max(float max)
Set the maximum reflectivity allowed.
double get_mixed_pixel_adaptive_amp_max() const
Get the maximum amplitude for adaptive sorting.
double get_mixed_pixel_aratio() const
Get the amplitude ratio for detecting MPI.
void set_radial_add(float addition)
Set how much to add to the radial value.
size_t get_gaussian_size() const
Get the gaussian region size.
bool get_flying_enabled() const
Get whether flying pixel filter is enabled.
void set_amp_threshold_max(double max)
Set the maximum amplitude allowed.
void set_amp_dot_segment_threshold(float threshold)
Set DEPRECATED Use reflectivity threshold instead.
void set_char_add(double addition)
Set the characterization addition component.
void set_flying_enabled(bool enabled)
Set whether flying pixel filter is enabled.
void set_char_mult(double multiplication)
Set the characterization multiplication component.
void set_flying_edges(size_t edges)
Set the number of edges allowed to be larger than maximum distance.
double get_phase_unwrapping_max_offset() const
Get The maximum distance between ideal location and actual.
void set_speed_of_light(float c)
Set the speed of light.
void set_flying_distance(size_t distance)
Set the maximum distance allowed between surrounding pixels.
float get_amp_dot_segment_max_correction() const
Get DEPRECATED No replacement implemented.
bool get_temporal_enabled() const
Get whether the temporal filter is enabled.
void set_mpi_detect_enabled(bool enabled)
Set wether mpi detect is enabled.
float get_common_amp_ratio_threshold() const
Get the maximum allowed ratio.
void set_binning_size(size_t size)
Set the size of the area to bin, 2 would bin a 2x2 area.
bool get_bilateral_enabled() const
Get whether the bilateral filter is enabled.
void set_reflectivity_threshold_min(float min)
Set the minimum reflectivity allowed.
size_t get_local_means_size() const
Get The local means region size.
float get_binning_sigma() const
Get The maximum standard deviation to use, only used in the smart binning mode.
bool get_median_enabled() const
Get whether the median filter is enabled.
bool get_amp_threshold_enabled() const
Get whether the amplitude threshold filter is enabled.
float get_mpi_detect_phi_diff() const
Get the phase difference ratio.
void set_amp_threshold_min(double min)
Set the minimum amplitude allowed.
void set_median_enabled(bool enabled)
Set whether the median filter is enabled.
void set_mixed_pixel_aggressor_threshold(double threshold)
Set the threshold to classify a pixel as an aggressor.
void set_reflectivity_scale(float scale)
Set how much to scale the reflectivity value by.
void set_phase_unwrapping_enabled(bool enabled)
Set whether phase unwrapping is enabled.
FlyingShape get_morph_erode_shape() const
Get the shape of the neighboring pixels.
void set_rad_dist_threshold_enabled(bool enabled)
Set the radial distance threshold.
void set_rigid_transformation_enabled(bool enabled)
Set whether rigid transformation is enabled.
MpSortMode get_mixed_pixel_sort_mode() const
Get what output is selected.
BinningMode get_binning_mode() const
Get the binning mode to use.
void set_gaussian_size(size_t size)
Set the gaussian region size.
void set_amp_dot_segment_enabled(bool enabled)
Set DEPRECATED Use reflectivity threshold instead.
int32_t get_mixed_pixel_min_aggressor_size() const
Get the minimum amount of bright pixels before a bright spot is classified as an aggressor.
double get_mixed_pixel_max_error_3f() const
Get the maximum error when using three modulation frequencies.
void set_mixed_pixel_aratio_min(double aratio_min)
Set the minimum return amplitude ratio for adaptive sorting.
void set_local_means_sigma(double sigma)
Set The local means standard deviation for how close values are.
void write(StringView file_location) const
Write processing config to disk.
double get_rad_dist_threshold_min() const
Get the minimum radial distance.
void set_rad_dist_threshold_min(double min)
Set the minimum radial distance.
void set_intensity_scale(float scale)
Set how much to scale the intensity value by.
void set_mixed_pixel_phi_diff(double phi_diff)
Set the phase difference for detecting MPI.
bool get_calibration_enabled() const
Get whether the calibration is applied.
double get_rad_dist_threshold_max() const
Get the maximum radial distance.
float get_flying_distance_scaled() const
Get another distance threshold which is scaled by the radial distance.
void set_temporal_enabled(bool enabled)
Set whether the temporal filter is enabled.
bool get_rad_dist_threshold_enabled() const
Get the radial distance threshold.
void set_local_means_enabled(bool enabled)
Set Whether the local means filter is enabled.
size_t get_binning_size() const
Get the size of the area to bin, 2 would bin a 2x2 area.
float get_reflectivity_modifier() const
Get what to divide the final value by such that it is a usable value.
void set_calibration_enabled(bool enabled)
Set whether the calibration is applied.
double get_mixed_pixel_amp_min() const
Get minimum amplitude that pixel needs to have to apply mixed pixel to it.
void set_xyz_dimension(XyzDimension dimension)
Set the dimension of the xyz output.
void set_common_amp_ratio_enabled(bool enabled)
Set whether the common amplitude ratio threshold filter is enabled.
bool get_average_enabled() const
Get whether averaging is enabled.
void set_radial_scale(float scale)
Set how much to scale the radial value by.
void set_mixed_pixel_amp_min(double amp_min)
Set minimum amplitude that pixel needs to have to apply mixed pixel to it.
void set_phase_unwrapping_max_offset(double max_offset)
Set The maximum distance between ideal location and actual.
void set_dist_threshold_enabled(bool enabled)
Set whether the distance threshold filter is enabled.
double get_dist_threshold_max() const
Get the maximum distance allowed.
void set_flying_distance_scaled(float scale)
Set another distance threshold which is scaled by the radial distance.
void set_morph_erode_shape(FlyingShape shape)
Set the shape of the neighboring pixels.
XyzDimension get_xyz_dimension() const
Get the dimension of the xyz output.
void set_mixed_pixel_adaptive_amp_max(double adaptive_amp_max)
Set the maximum amplitude for adaptive sorting.
bool get_gaussian_enabled() const
Get whether the gaussian blur is enabled.
float get_amp_dot_segment_threshold() const
Get DEPRECATED Use reflectivity threshold instead.
size_t get_flying_distance() const
Get the maximum distance allowed between surrounding pixels.
bool get_mpi_detect_enabled() const
Get wether mpi detect is enabled.
const char * get_mixed_pixel_lut_file() const
Get location of the mixed pixel look up table file.
double get_basic_phase_unwrapping_max_offset() const
Get the max radial offset between the two modulation frequencies.
void set_mixed_pixel_aratio(double aratio)
Set the amplitude ratio for detecting MPI.
ProcessingConfig(StringView file_location)
Load processing config from disk.
bool get_dist_threshold_enabled() const
Get whether the distance threshold filter is enabled.
void set_dist_threshold_min(double min)
Set the minimum distance allowed.
double get_amp_threshold_max() const
Get the maximum amplitude allowed.
bool get_amp_dot_segment_enabled() const
Get DEPRECATED Use reflectivity threshold instead.
void set_mpi_detect_aratio(float aratio)
Set The amplitude ratio value.
double get_local_means_sigma() const
Get The local means standard deviation for how close values are.
void set_reflectivity_threshold_enabled(bool enabled)
Set whether reflectivity threshold is enabled.
void set_median_size(size_t size)
Set the median region size.
void set_mixed_pixel_adaptive_amp_min(double adaptive_amp_min)
Set the minimum amplitude for adaptive sorting.
void set_mpi_detect_phi_diff(float phi_diff)
Set the phase difference ratio.
float get_reflectivity_threshold_min() const
Get the minimum reflectivity allowed.
void set_mixed_pixel_lut_file(StringView file_location)
Set location of the mixed pixel look up table file.
void set_intensity_add(float addition)
Set how much to add to the intensity value.
bool get_reflectivity_threshold_enabled() const
Get whether reflectivity threshold is enabled.
float get_speed_of_light() const
Get the speed of light.
void set_gpu(bool gpu)
Set whether processing on the gpu is enabled.
void set_dist_threshold_max(double max)
Set the maximum distance allowed.
void set_flying_shape(FlyingShape shape)
Set the shape of which surrounding pixels are checked.
ProcessingConfig(tof_processing_config_t ptr)
Construct from pointer.
float get_reflectivity_add() const
Get how much to add to the reflectivity value.
double get_amp_threshold_min() const
Get the minimum amplitude allowed.
void set_binning_mode(BinningMode mode)
Set the binning mode to use.
void set_average_enabled(bool enabled)
Set whether averaging is enabled.
bool get_basic_phase_unwrapping_enabled() const
Get whether basic phase unwrapping is enabled.
void set_bilateral_enabled(bool enabled)
Set whether the bilateral filter is enabled.
double get_mixed_pixel_phi_diff() const
Get the phase difference for detecting MPI.
float get_radial_scale() const
Get how much to scale the radial value by.
double get_char_add() const
Get the characterization addition component.
void set_bilateral_sigma(double sigma)
Set the bilateral standard deviation.
size_t get_median_size() const
Get the median region size.
void set_gaussian_enabled(bool enabled)
Set whether the gaussian blur is enabled.
double get_dist_threshold_min() const
Get the minimum distance allowed.
size_t get_temporal_nframes() const
Get the maximum number of frames to average together.
size_t get_bilateral_size() const
Get the bilateral region size.