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