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