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