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