Time-of-Flight Library(ToF) 4.1.4
 
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 DEPRECATED Use reflectivity threshold instead. whether the amplitude dot
840 * segmentation filter is enabled. This filter is designed to filter out
841 * everything but the dots in cameras with dot illumination. It has also proved
842 * effective at removing shadowing effects in 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 DEPRECATED Use reflectivity threshold instead. whether the amplitude dot
850 * segmentation filter is enabled. This filter is designed to filter out
851 * everything but the dots in cameras with dot illumination. It has also proved
852 * effective at removing shadowing effects in 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 DEPRECATED Use reflectivity threshold instead. the minimum corrected
860 * amplitude that is allowed
861 * @param ptr Pointer to class
862 * @param error Pointer to error
863 * @return Amplitude threshold
864 */
865TOF_EXPORT float tof_processing_config_get_amp_dot_segment_threshold(tof_processing_config_ct ptr, tof_error_t *error);
866
867/** Set DEPRECATED Use reflectivity threshold instead. the minimum corrected
868 * amplitude that is allowed
869 * @param ptr Pointer to class
870 * @param threshold Amplitude threshold
871 * @param error Pointer to error
872 */
873TOF_EXPORT void tof_processing_config_set_amp_dot_segment_threshold(tof_processing_config_t ptr, float threshold, tof_error_t *error);
874
875/** Get DEPRECATED Use reflectivity modifier instead . the distance after which
876 * amplitude is increased instead of decreased
877 * @param ptr Pointer to class
878 * @param error Pointer to error
879 * @return Radial midpoint
880 */
881TOF_EXPORT float tof_processing_config_get_amp_dot_segment_midpoint(tof_processing_config_ct ptr, tof_error_t *error);
882
883/** Set DEPRECATED Use reflectivity modifier instead . the distance after which
884 * amplitude is increased instead of decreased
885 * @param ptr Pointer to class
886 * @param midpoint Radial midpoint
887 * @param error Pointer to error
888 */
889TOF_EXPORT void tof_processing_config_set_amp_dot_segment_midpoint(tof_processing_config_t ptr, float midpoint, tof_error_t *error);
890
891/** Get DEPRECATED No replacement implemented. the maximum amount of correction
892 * that can be performed on the distance component
893 * @param ptr Pointer to class
894 * @param error Pointer to error
895 * @return Max radial correction
896 */
897TOF_EXPORT float tof_processing_config_get_amp_dot_segment_max_correction(tof_processing_config_ct ptr, tof_error_t *error);
898
899/** Set DEPRECATED No replacement implemented. the maximum amount of correction
900 * that can be performed on the distance component
901 * @param ptr Pointer to class
902 * @param correction Max radial correction
903 * @param error Pointer to error
904 */
905TOF_EXPORT void tof_processing_config_set_amp_dot_segment_max_correction(tof_processing_config_t ptr, float correction, tof_error_t *error);
906
907/** Get whether the common amplitude ratio threshold filter is enabled. This
908 * filter calculates the difference between the amplitude and ir data and you
909 * can set a certain threshold. This is useful to get rid of pixels that are
910 * heavily saturated with sunlight since the difference between amplitude and
911 * total ir light will be large.
912 * @param ptr Pointer to class
913 * @param error Pointer to error
914 * @return Enabled
915 */
916TOF_EXPORT bool tof_processing_config_get_common_amp_ratio_enabled(tof_processing_config_ct ptr, tof_error_t *error);
917
918/** Set whether the common amplitude ratio threshold filter is enabled. This
919 * filter calculates the difference between the amplitude and ir data and you
920 * can set a certain threshold. This is useful to get rid of pixels that are
921 * heavily saturated with sunlight since the difference between amplitude and
922 * total ir light will be large.
923 * @param ptr Pointer to class
924 * @param enabled Enabled
925 * @param error Pointer to error
926 */
927TOF_EXPORT void tof_processing_config_set_common_amp_ratio_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
928
929/** Get the maximum allowed ratio
930 * @param ptr Pointer to class
931 * @param error Pointer to error
932 * @return The threshold
933 */
934TOF_EXPORT float tof_processing_config_get_common_amp_ratio_threshold(tof_processing_config_ct ptr, tof_error_t *error);
935
936/** Set the maximum allowed ratio
937 * @param ptr Pointer to class
938 * @param threshold The threshold
939 * @param error Pointer to error
940 */
941TOF_EXPORT void tof_processing_config_set_common_amp_ratio_threshold(tof_processing_config_t ptr, float threshold, tof_error_t *error);
942
943/** Get whether the morph erode filter is enabled. The morph erode filter
944 * removes pixels that have no neighboring (correct) pixels.
945 * @param ptr Pointer to class
946 * @param error Pointer to error
947 * @return Enabled
948 */
949TOF_EXPORT bool tof_processing_config_get_morph_erode_enabled(tof_processing_config_ct ptr, tof_error_t *error);
950
951/** Set whether the morph erode filter is enabled. The morph erode filter
952 * removes pixels that have no neighboring (correct) pixels.
953 * @param ptr Pointer to class
954 * @param enabled Enabled
955 * @param error Pointer to error
956 */
957TOF_EXPORT void tof_processing_config_set_morph_erode_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
958
959/** Get the shape of the neighboring pixels.
960 * @param ptr Pointer to class
961 * @param error Pointer to error
962 * @return The shape
963 */
964TOF_EXPORT enum tof_flying_shape tof_processing_config_get_morph_erode_shape(tof_processing_config_ct ptr, tof_error_t *error);
965
966/** Set the shape of the neighboring pixels.
967 * @param ptr Pointer to class
968 * @param shape The shape
969 * @param error Pointer to error
970 */
971TOF_EXPORT void tof_processing_config_set_morph_erode_shape(tof_processing_config_t ptr, enum tof_flying_shape shape, tof_error_t *error);
972
973/** Get how much to scale the radial value by
974 * @param ptr Pointer to class
975 * @param error Pointer to error
976 * @return Radial scale
977 */
978TOF_EXPORT float tof_processing_config_get_radial_scale(tof_processing_config_ct ptr, tof_error_t *error);
979
980/** Set how much to scale the radial value by
981 * @param ptr Pointer to class
982 * @param scale Radial scale
983 * @param error Pointer to error
984 */
985TOF_EXPORT void tof_processing_config_set_radial_scale(tof_processing_config_t ptr, float scale, tof_error_t *error);
986
987/** Get how much to add to the radial value
988 * @param ptr Pointer to class
989 * @param error Pointer to error
990 * @return Radial addition
991 */
992TOF_EXPORT float tof_processing_config_get_radial_add(tof_processing_config_ct ptr, tof_error_t *error);
993
994/** Set how much to add to the radial value
995 * @param ptr Pointer to class
996 * @param addition Radial addition
997 * @param error Pointer to error
998 */
999TOF_EXPORT void tof_processing_config_set_radial_add(tof_processing_config_t ptr, float addition, tof_error_t *error);
1000
1001/** Get how much to scale the intensity value by
1002 * @param ptr Pointer to class
1003 * @param error Pointer to error
1004 * @return Intensity scale
1005 */
1006TOF_EXPORT float tof_processing_config_get_intensity_scale(tof_processing_config_ct ptr, tof_error_t *error);
1007
1008/** Set how much to scale the intensity value by
1009 * @param ptr Pointer to class
1010 * @param scale Intensity scale
1011 * @param error Pointer to error
1012 */
1013TOF_EXPORT void tof_processing_config_set_intensity_scale(tof_processing_config_t ptr, float scale, tof_error_t *error);
1014
1015/** Get how much to add to the intensity value
1016 * @param ptr Pointer to class
1017 * @param error Pointer to error
1018 * @return Intensity addition
1019 */
1020TOF_EXPORT float tof_processing_config_get_intensity_add(tof_processing_config_ct ptr, tof_error_t *error);
1021
1022/** Set how much to add to the intensity value
1023 * @param ptr Pointer to class
1024 * @param addition Intensity addition
1025 * @param error Pointer to error
1026 */
1027TOF_EXPORT void tof_processing_config_set_intensity_add(tof_processing_config_t ptr, float addition, tof_error_t *error);
1028
1029/** Get how much to scale the reflectivity value by
1030 * @param ptr Pointer to class
1031 * @param error Pointer to error
1032 * @return Reflectivity scale
1033 */
1034TOF_EXPORT float tof_processing_config_get_reflectivity_scale(tof_processing_config_ct ptr, tof_error_t *error);
1035
1036/** Set how much to scale the reflectivity value by
1037 * @param ptr Pointer to class
1038 * @param scale Reflectivity scale
1039 * @param error Pointer to error
1040 */
1041TOF_EXPORT void tof_processing_config_set_reflectivity_scale(tof_processing_config_t ptr, float scale, tof_error_t *error);
1042
1043/** Get how much to add to the reflectivity value
1044 * @param ptr Pointer to class
1045 * @param error Pointer to error
1046 * @return Reflectivity addition
1047 */
1048TOF_EXPORT float tof_processing_config_get_reflectivity_add(tof_processing_config_ct ptr, tof_error_t *error);
1049
1050/** Set how much to add to the reflectivity value
1051 * @param ptr Pointer to class
1052 * @param addition Reflectivity addition
1053 * @param error Pointer to error
1054 */
1055TOF_EXPORT void tof_processing_config_set_reflectivity_add(tof_processing_config_t ptr, float addition, tof_error_t *error);
1056
1057/** Get the characterization addition component. The characterization function
1058 * computes the sigma for the temporal and bilateral filter
1059 * @param ptr Pointer to class
1060 * @param error Pointer to error
1061 * @return addition
1062 */
1063TOF_EXPORT double tof_processing_config_get_char_add(tof_processing_config_ct ptr, tof_error_t *error);
1064
1065/** Set the characterization addition component. The characterization function
1066 * computes the sigma for the temporal and bilateral filter
1067 * @param ptr Pointer to class
1068 * @param addition addition
1069 * @param error Pointer to error
1070 */
1071TOF_EXPORT void tof_processing_config_set_char_add(tof_processing_config_t ptr, double addition, tof_error_t *error);
1072
1073/** Get the characterization multiplication component. The characterization
1074 * function computes the sigma for the temporal and bilateral filter
1075 * @param ptr Pointer to class
1076 * @param error Pointer to error
1077 * @return Multiplication
1078 */
1079TOF_EXPORT double tof_processing_config_get_char_mult(tof_processing_config_ct ptr, tof_error_t *error);
1080
1081/** Set the characterization multiplication component. The characterization
1082 * function computes the sigma for the temporal and bilateral filter
1083 * @param ptr Pointer to class
1084 * @param multiplication Multiplication
1085 * @param error Pointer to error
1086 */
1087TOF_EXPORT void tof_processing_config_set_char_mult(tof_processing_config_t ptr, double multiplication, tof_error_t *error);
1088
1089/** Get whether software binning is enabled
1090 * @param ptr Pointer to class
1091 * @param error Pointer to error
1092 * @return Enabled
1093 */
1094TOF_EXPORT bool tof_processing_config_get_binning_enabled(tof_processing_config_ct ptr, tof_error_t *error);
1095
1096/** Set whether software binning is enabled
1097 * @param ptr Pointer to class
1098 * @param enabled Enabled
1099 * @param error Pointer to error
1100 */
1101TOF_EXPORT void tof_processing_config_set_binning_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
1102
1103/** Get the size of the area to bin, 2 would bin a 2x2 area
1104 * @param ptr Pointer to class
1105 * @param error Pointer to error
1106 * @return The bin size
1107 */
1108TOF_EXPORT size_t tof_processing_config_get_binning_size(tof_processing_config_ct ptr, tof_error_t *error);
1109
1110/** Set the size of the area to bin, 2 would bin a 2x2 area
1111 * @param ptr Pointer to class
1112 * @param size The bin size
1113 * @param error Pointer to error
1114 */
1115TOF_EXPORT void tof_processing_config_set_binning_size(tof_processing_config_t ptr, size_t size, tof_error_t *error);
1116
1117/** Get the binning mode to use
1118 * @param ptr Pointer to class
1119 * @param error Pointer to error
1120 * @return The binning mode
1121 */
1122TOF_EXPORT enum tof_binning_mode tof_processing_config_get_binning_mode(tof_processing_config_ct ptr, tof_error_t *error);
1123
1124/** Set the binning mode to use
1125 * @param ptr Pointer to class
1126 * @param mode The binning mode
1127 * @param error Pointer to error
1128 */
1129TOF_EXPORT void tof_processing_config_set_binning_mode(tof_processing_config_t ptr, enum tof_binning_mode mode, tof_error_t *error);
1130
1131/** Get The maximum standard deviation to use, only used in the smart binning
1132 * mode
1133 * @param ptr Pointer to class
1134 * @param error Pointer to error
1135 * @return The standard deviation
1136 */
1137TOF_EXPORT float tof_processing_config_get_binning_sigma(tof_processing_config_ct ptr, tof_error_t *error);
1138
1139/** Set The maximum standard deviation to use, only used in the smart binning
1140 * mode
1141 * @param ptr Pointer to class
1142 * @param sigma The standard deviation
1143 * @param error Pointer to error
1144 */
1145TOF_EXPORT void tof_processing_config_set_binning_sigma(tof_processing_config_t ptr, float sigma, tof_error_t *error);
1146
1147/** Get the dimension of the xyz output
1148 * @param ptr Pointer to class
1149 * @param error Pointer to error
1150 * @return The dimension
1151 */
1152TOF_EXPORT enum tof_xyz_dimension tof_processing_config_get_xyz_dimension(tof_processing_config_ct ptr, tof_error_t *error);
1153
1154/** Set the dimension of the xyz output
1155 * @param ptr Pointer to class
1156 * @param dimension The dimension
1157 * @param error Pointer to error
1158 */
1159TOF_EXPORT void tof_processing_config_set_xyz_dimension(tof_processing_config_t ptr, enum tof_xyz_dimension dimension, tof_error_t *error);
1160
1161/** Get whether rigid transformation is enabled
1162 * @param ptr Pointer to class
1163 * @param error Pointer to error
1164 * @return Enabled
1165 */
1166TOF_EXPORT bool tof_processing_config_get_rigid_transformation_enabled(tof_processing_config_ct ptr, tof_error_t *error);
1167
1168/** Set whether rigid transformation is enabled
1169 * @param ptr Pointer to class
1170 * @param enabled Enabled
1171 * @param error Pointer to error
1172 */
1173TOF_EXPORT void tof_processing_config_set_rigid_transformation_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
1174
1175/** Get the rigid transformation 4x4 matrix
1176 * @param ptr Pointer to class
1177 * @param error Pointer to error
1178 * @return[16] 4x4 transformation matrix
1179 */
1180TOF_EXPORT const float* tof_processing_config_get_rigid_transformation_matrix(tof_processing_config_ct ptr, tof_error_t *error);
1181
1182/** Set the rigid transformation 4x4 matrix
1183 * @param ptr Pointer to class
1184 * @param matrix[16] 4x4 transformation matrix
1185 * @param error Pointer to error
1186 */
1187TOF_EXPORT void tof_processing_config_set_rigid_transformation_matrix(tof_processing_config_t ptr, const float* matrix, tof_error_t *error);
1188
1189/** Get the radial distance threshold
1190 * @param ptr Pointer to class
1191 * @param error Pointer to error
1192 * @return Enabled
1193 */
1194TOF_EXPORT bool tof_processing_config_get_rad_dist_threshold_enabled(tof_processing_config_ct ptr, tof_error_t *error);
1195
1196/** Set the radial distance threshold
1197 * @param ptr Pointer to class
1198 * @param enabled Enabled
1199 * @param error Pointer to error
1200 */
1201TOF_EXPORT void tof_processing_config_set_rad_dist_threshold_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
1202
1203/** Get the minimum radial distance
1204 * @param ptr Pointer to class
1205 * @param error Pointer to error
1206 * @return Minimum
1207 */
1208TOF_EXPORT double tof_processing_config_get_rad_dist_threshold_min(tof_processing_config_ct ptr, tof_error_t *error);
1209
1210/** Set the minimum radial distance
1211 * @param ptr Pointer to class
1212 * @param min Minimum
1213 * @param error Pointer to error
1214 */
1215TOF_EXPORT void tof_processing_config_set_rad_dist_threshold_min(tof_processing_config_t ptr, double min, tof_error_t *error);
1216
1217/** Get the maximum radial distance
1218 * @param ptr Pointer to class
1219 * @param error Pointer to error
1220 * @return Maximum
1221 */
1222TOF_EXPORT double tof_processing_config_get_rad_dist_threshold_max(tof_processing_config_ct ptr, tof_error_t *error);
1223
1224/** Set the maximum radial distance
1225 * @param ptr Pointer to class
1226 * @param max Maximum
1227 * @param error Pointer to error
1228 */
1229TOF_EXPORT void tof_processing_config_set_rad_dist_threshold_max(tof_processing_config_t ptr, double max, tof_error_t *error);
1230
1231/** Get what to divide the final value by such that it is a usable value
1232 * @param ptr Pointer to class
1233 * @param error Pointer to error
1234 * @return Modifier
1235 */
1236TOF_EXPORT float tof_processing_config_get_reflectivity_modifier(tof_processing_config_ct ptr, tof_error_t *error);
1237
1238/** Set what to divide the final value by such that it is a usable value
1239 * @param ptr Pointer to class
1240 * @param modifier Modifier
1241 * @param error Pointer to error
1242 */
1243TOF_EXPORT void tof_processing_config_set_reflectivity_modifier(tof_processing_config_t ptr, float modifier, tof_error_t *error);
1244
1245/** Get whether reflectivity threshold is enabled. Reflectivity threshold
1246 * filters based on reflectivity.
1247 * @param ptr Pointer to class
1248 * @param error Pointer to error
1249 * @return Enabled
1250 */
1251TOF_EXPORT bool tof_processing_config_get_reflectivity_threshold_enabled(tof_processing_config_ct ptr, tof_error_t *error);
1252
1253/** Set whether reflectivity threshold is enabled. Reflectivity threshold
1254 * filters based on reflectivity.
1255 * @param ptr Pointer to class
1256 * @param enabled Enabled
1257 * @param error Pointer to error
1258 */
1259TOF_EXPORT void tof_processing_config_set_reflectivity_threshold_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
1260
1261/** Get the minimum reflectivity allowed
1262 * @param ptr Pointer to class
1263 * @param error Pointer to error
1264 * @return Minimum
1265 */
1266TOF_EXPORT float tof_processing_config_get_reflectivity_threshold_min(tof_processing_config_ct ptr, tof_error_t *error);
1267
1268/** Set the minimum reflectivity allowed
1269 * @param ptr Pointer to class
1270 * @param min Minimum
1271 * @param error Pointer to error
1272 */
1273TOF_EXPORT void tof_processing_config_set_reflectivity_threshold_min(tof_processing_config_t ptr, float min, tof_error_t *error);
1274
1275/** Get the maximum reflectivity allowed
1276 * @param ptr Pointer to class
1277 * @param error Pointer to error
1278 * @return Maximum
1279 */
1280TOF_EXPORT float tof_processing_config_get_reflectivity_threshold_max(tof_processing_config_ct ptr, tof_error_t *error);
1281
1282/** Set the maximum reflectivity allowed
1283 * @param ptr Pointer to class
1284 * @param max Maximum
1285 * @param error Pointer to error
1286 */
1287TOF_EXPORT void tof_processing_config_set_reflectivity_threshold_max(tof_processing_config_t ptr, float max, tof_error_t *error);
1288
1289#ifdef __cplusplus
1290}
1291#endif
1292
1293#endif