Time-of-Flight Library(ToF)  3.2.2
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
7 extern "C" {
8 #endif
9 
10 /** The shape of which surrounding pixels are checked in the flying pixel
11  * filter
12  */
13 enum tof_flying_shape {
14  TOF_FLYING_SHAPE_PLUS = 0, /** Four neighboring pixels in a plus shape */
15  TOF_FLYING_SHAPE_BOX = 1, /** All eight neighboring pixels */
16 };
17 
18 /** Mixed pixel sort mode. The mode you want to use depends on your
19  * application.
20  */
21 enum tof_mp_sort_mode {
22  TOF_MP_SORT_MODE_DARKEST = 0, /** Choose darkest path */
23  TOF_MP_SORT_MODE_SHORTEST = 1, /** Return the surface of a translucent object, resolve corners or checkerboard lens flare */
24  TOF_MP_SORT_MODE_BRIGHTEST = 2, /** Mixed pixels between foreground and background, get the best SNR */
25  TOF_MP_SORT_MODE_LONGEST = 3, /** Correct lens flare from close bright objects */
26  TOF_MP_SORT_MODE_AGGRESSOR = 4, /** Correct lens flare */
27  TOF_MP_SORT_MODE_ADAPTIVE_SHORT_V0 = 5, /** Adaptive shortest */
28  TOF_MP_SORT_MODE_ADAPTIVE_SHORT_V1 = 6, /** Adaptive shortest version two */
29  TOF_MP_SORT_MODE_AGGRESSOR_V2 = 7, /** Correct lens flare version two */
30 };
31 
32 /** What kind of binning to do
33  */
34 enum tof_binning_mode {
35  TOF_BINNING_MODE_NORMAL = 0, /** Normal binning, a BxB grid averaged to a single pixel */
36  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 */
37 };
38 
39 /** Processing that can be done
40  */
41 typedef struct tof_processing_config* tof_processing_config_t;
42 
43 /** Destruct tof_processing_config */
44 TOF_EXPORT void tof_processing_config_delete(tof_processing_config_t ptr);
45 
46 /** Create default processing config
47  * @param ptr Pointer to class
48  * @param error Pointer to error
49  * @return New object
50  */
51 TOF_EXPORT tof_processing_config_t tof_processing_config_new_default(tof_error_t *error);
52 
53 /** Load processing config from disk
54  * @param ptr Pointer to class
55  * @param file_location Location of processing config
56  * @param error Pointer to error
57  * @return New object
58  */
59 TOF_EXPORT tof_processing_config_t tof_processing_config_new_from_disk(const char* file_location, tof_error_t *error);
60 
61 /** Write processing config to disk
62  * @param ptr Pointer to class
63  * @param file_location Location where to save the processing config
64  * @param error Pointer to error
65  */
66 TOF_EXPORT void tof_processing_config_write(const tof_processing_config_t ptr, const char* file_location, tof_error_t *error);
67 
68 /** Get whether processing on the gpu is enabled
69  * @param ptr Pointer to class
70  * @param error Pointer to error
71  * @return Enabled
72  */
73 TOF_EXPORT bool tof_processing_config_get_gpu(const tof_processing_config_t ptr, tof_error_t *error);
74 
75 /** Set whether processing on the gpu is enabled
76  * @param ptr Pointer to class
77  * @param gpu Enabled
78  * @param error Pointer to error
79  */
80 TOF_EXPORT void tof_processing_config_set_gpu(tof_processing_config_t ptr, bool gpu, tof_error_t *error);
81 
82 /** Get whether the calibration is applied
83  * @param ptr Pointer to class
84  * @param error Pointer to error
85  * @return Enabled
86  */
87 TOF_EXPORT bool tof_processing_config_get_calibration_enabled(const tof_processing_config_t ptr, tof_error_t *error);
88 
89 /** Set whether the calibration is applied
90  * @param ptr Pointer to class
91  * @param enabled Enabled
92  * @param error Pointer to error
93  */
94 TOF_EXPORT void tof_processing_config_set_calibration_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
95 
96 /** Get whether phase unwrapping is enabled
97  * @param ptr Pointer to class
98  * @param error Pointer to error
99  * @return Enabled
100  */
101 TOF_EXPORT bool tof_processing_config_get_phase_unwrapping_enabled(const tof_processing_config_t ptr, tof_error_t *error);
102 
103 /** Set whether phase unwrapping is enabled
104  * @param ptr Pointer to class
105  * @param enabled Enabled
106  * @param error Pointer to error
107  */
108 TOF_EXPORT void tof_processing_config_set_phase_unwrapping_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
109 
110 /** Get The maximum distance between ideal location and actual
111  * @param ptr Pointer to class
112  * @param error Pointer to error
113  * @return Max offset, range [0, 1]
114  */
115 TOF_EXPORT double tof_processing_config_get_phase_unwrapping_max_offset(const tof_processing_config_t ptr, tof_error_t *error);
116 
117 /** Set The maximum distance between ideal location and actual
118  * @param ptr Pointer to class
119  * @param max_offset Max offset, range [0, 1]
120  * @param error Pointer to error
121  */
122 TOF_EXPORT void tof_processing_config_set_phase_unwrapping_max_offset(tof_processing_config_t ptr, double max_offset, tof_error_t *error);
123 
124 /** Get wether mixed pixel is enabled
125  * @param ptr Pointer to class
126  * @param error Pointer to error
127  * @return Enabled
128  */
129 TOF_EXPORT bool tof_processing_config_get_mixed_pixel_enabled(const tof_processing_config_t ptr, tof_error_t *error);
130 
131 /** Set wether mixed pixel is enabled
132  * @param ptr Pointer to class
133  * @param enabled Enabled
134  * @param error Pointer to error
135  */
136 TOF_EXPORT void tof_processing_config_set_mixed_pixel_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
137 
138 /** Get location of the mixed pixel look up table file
139  * @param ptr Pointer to class
140  * @param error Pointer to error
141  * @return File location
142  */
143 TOF_EXPORT const char* tof_processing_config_get_mixed_pixel_lut_file(const tof_processing_config_t ptr, tof_error_t *error);
144 
145 /** Set location of the mixed pixel look up table file
146  * @param ptr Pointer to class
147  * @param file_location File location
148  * @param error Pointer to error
149  */
150 TOF_EXPORT void tof_processing_config_set_mixed_pixel_lut_file(tof_processing_config_t ptr, const char* file_location, tof_error_t *error);
151 
152 /** Get minimum amplitude that pixel needs to have to apply mixed pixel to it
153  * @param ptr Pointer to class
154  * @param error Pointer to error
155  * @return Minimum amplitude
156  */
157 TOF_EXPORT double tof_processing_config_get_mixed_pixel_amp_min(const tof_processing_config_t ptr, tof_error_t *error);
158 
159 /** Set minimum amplitude that pixel needs to have to apply mixed pixel to it
160  * @param ptr Pointer to class
161  * @param amp_min Minimum amplitude
162  * @param error Pointer to error
163  */
164 TOF_EXPORT void tof_processing_config_set_mixed_pixel_amp_min(tof_processing_config_t ptr, double amp_min, tof_error_t *error);
165 
166 /** Get what output is selected
167  * @param ptr Pointer to class
168  * @param error Pointer to error
169  * @return Sort mode
170  */
171 TOF_EXPORT enum tof_mp_sort_mode tof_processing_config_get_mixed_pixel_sort_mode(const tof_processing_config_t ptr, tof_error_t *error);
172 
173 /** Set what output is selected
174  * @param ptr Pointer to class
175  * @param sort_mode Sort mode
176  * @param error Pointer to error
177  */
178 TOF_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);
179 
180 /** Get the amplitude ratio for detecting MPI
181  * @param ptr Pointer to class
182  * @param error Pointer to error
183  * @return Amplitude ratio
184  */
185 TOF_EXPORT double tof_processing_config_get_mixed_pixel_aratio(const tof_processing_config_t ptr, tof_error_t *error);
186 
187 /** Set the amplitude ratio for detecting MPI
188  * @param ptr Pointer to class
189  * @param aratio Amplitude ratio
190  * @param error Pointer to error
191  */
192 TOF_EXPORT void tof_processing_config_set_mixed_pixel_aratio(tof_processing_config_t ptr, double aratio, tof_error_t *error);
193 
194 /** Get the phase difference for detecting MPI
195  * @param ptr Pointer to class
196  * @param error Pointer to error
197  * @return Phase difference
198  */
199 TOF_EXPORT double tof_processing_config_get_mixed_pixel_phi_diff(const tof_processing_config_t ptr, tof_error_t *error);
200 
201 /** Set the phase difference for detecting MPI
202  * @param ptr Pointer to class
203  * @param phi_diff Phase difference
204  * @param error Pointer to error
205  */
206 TOF_EXPORT void tof_processing_config_set_mixed_pixel_phi_diff(tof_processing_config_t ptr, double phi_diff, tof_error_t *error);
207 
208 /** Get the threshold to classify a pixel as an aggressor
209  * @param ptr Pointer to class
210  * @param error Pointer to error
211  * @return Aggressor threshold
212  */
213 TOF_EXPORT double tof_processing_config_get_mixed_pixel_aggressor_threshold(const tof_processing_config_t ptr, tof_error_t *error);
214 
215 /** Set the threshold to classify a pixel as an aggressor
216  * @param ptr Pointer to class
217  * @param threshold Aggressor threshold
218  * @param error Pointer to error
219  */
220 TOF_EXPORT void tof_processing_config_set_mixed_pixel_aggressor_threshold(tof_processing_config_t ptr, double threshold, tof_error_t *error);
221 
222 /** Get the size of the morphological filter to remove small bright pixels
223  * @param ptr Pointer to class
224  * @param error Pointer to error
225  * @return Minimum aggressor size
226  */
227 TOF_EXPORT int32_t tof_processing_config_get_mixed_pixel_min_aggressor_size(const tof_processing_config_t ptr, tof_error_t *error);
228 
229 /** Set the size of the morphological filter to remove small bright pixels
230  * @param ptr Pointer to class
231  * @param size Minimum aggressor size
232  * @param error Pointer to error
233  */
234 TOF_EXPORT void tof_processing_config_set_mixed_pixel_min_aggressor_size(tof_processing_config_t ptr, int32_t size, tof_error_t *error);
235 
236 /** Get The maximum error when using three modulation frequencies
237  * @param ptr Pointer to class
238  * @param error Pointer to error
239  * @return The error
240  */
241 TOF_EXPORT double tof_processing_config_get_mixed_pixel_max_error_3f(const tof_processing_config_t ptr, tof_error_t *error);
242 
243 /** Set The maximum error when using three modulation frequencies
244  * @param ptr Pointer to class
245  * @param max_error_3f The error
246  * @param error Pointer to error
247  */
248 TOF_EXPORT void tof_processing_config_set_mixed_pixel_max_error_3f(tof_processing_config_t ptr, double max_error_3f, tof_error_t *error);
249 
250 /** Get The maximum amplitude for adaptive sorting
251  * @param ptr Pointer to class
252  * @param error Pointer to error
253  * @return Maximum amplitude
254  */
255 TOF_EXPORT double tof_processing_config_get_mixed_pixel_adaptive_amp_max(const tof_processing_config_t ptr, tof_error_t *error);
256 
257 /** Set The maximum amplitude for adaptive sorting
258  * @param ptr Pointer to class
259  * @param adaptive_amp_max Maximum amplitude
260  * @param error Pointer to error
261  */
262 TOF_EXPORT void tof_processing_config_set_mixed_pixel_adaptive_amp_max(tof_processing_config_t ptr, double adaptive_amp_max, tof_error_t *error);
263 
264 /** Get The minimum amplitude for adaptive sorting
265  * @param ptr Pointer to class
266  * @param error Pointer to error
267  * @return Minimum amplitude
268  */
269 TOF_EXPORT double tof_processing_config_get_mixed_pixel_adaptive_amp_min(const tof_processing_config_t ptr, tof_error_t *error);
270 
271 /** Set The minimum amplitude for adaptive sorting
272  * @param ptr Pointer to class
273  * @param adaptive_amp_min Minimum amplitude
274  * @param error Pointer to error
275  */
276 TOF_EXPORT void tof_processing_config_set_mixed_pixel_adaptive_amp_min(tof_processing_config_t ptr, double adaptive_amp_min, tof_error_t *error);
277 
278 /** Get The minimum return amplitude ratio for adaptive sorting
279  * @param ptr Pointer to class
280  * @param error Pointer to error
281  * @return Minimum return ratio
282  */
283 TOF_EXPORT double tof_processing_config_get_mixed_pixel_aratio_min(const tof_processing_config_t ptr, tof_error_t *error);
284 
285 /** Set The minimum return amplitude ratio for adaptive sorting
286  * @param ptr Pointer to class
287  * @param aratio_min Minimum return ratio
288  * @param error Pointer to error
289  */
290 TOF_EXPORT void tof_processing_config_set_mixed_pixel_aratio_min(tof_processing_config_t ptr, double aratio_min, tof_error_t *error);
291 
292 /** Get The maximum phase difference before a return is not classified as
293  * aggressor
294  * @param ptr Pointer to class
295  * @param error Pointer to error
296  * @return Phase offset before not a aggressor return
297  */
298 TOF_EXPORT double tof_processing_config_get_mixed_pixel_aggressor_phi_offset(const tof_processing_config_t ptr, tof_error_t *error);
299 
300 /** Set The maximum phase difference before a return is not classified as
301  * aggressor
302  * @param ptr Pointer to class
303  * @param aggressor_phi_offset Phase offset before not a aggressor return
304  * @param error Pointer to error
305  */
306 TOF_EXPORT void tof_processing_config_set_mixed_pixel_aggressor_phi_offset(tof_processing_config_t ptr, double aggressor_phi_offset, tof_error_t *error);
307 
308 /** Get whether hdr is enabled. High dynamic range allows you to separate depth
309  * with high intensity difference. This is mostly useful when the sensor is
310  * being saturated.
311  * @param ptr Pointer to class
312  * @param error Pointer to error
313  * @return Enabled
314  */
315 TOF_EXPORT bool tof_processing_config_get_hdr_enabled(const tof_processing_config_t ptr, tof_error_t *error);
316 
317 /** Set whether hdr is enabled. High dynamic range allows you to separate depth
318  * with high intensity difference. This is mostly useful when the sensor is
319  * being saturated.
320  * @param ptr Pointer to class
321  * @param enabled Enabled
322  * @param error Pointer to error
323  */
324 TOF_EXPORT void tof_processing_config_set_hdr_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
325 
326 /** Get whether averaging is enabled. The average process allows you to average
327  * multiple frames together at the cost of frame rate
328  * @param ptr Pointer to class
329  * @param error Pointer to error
330  * @return Enabled
331  */
332 TOF_EXPORT bool tof_processing_config_get_average_enabled(const tof_processing_config_t ptr, tof_error_t *error);
333 
334 /** Set whether averaging is enabled. The average process allows you to average
335  * multiple frames together at the cost of frame rate
336  * @param ptr Pointer to class
337  * @param enabled Enabled
338  * @param error Pointer to error
339  */
340 TOF_EXPORT void tof_processing_config_set_average_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
341 
342 /** Get the number of frames to average together
343  * @param ptr Pointer to class
344  * @param error Pointer to error
345  * @return Number of frames
346  */
347 TOF_EXPORT size_t tof_processing_config_get_average_nframes(const tof_processing_config_t ptr, tof_error_t *error);
348 
349 /** Set the number of frames to average together
350  * @param ptr Pointer to class
351  * @param nframes Number of frames
352  * @param error Pointer to error
353  */
354 TOF_EXPORT void tof_processing_config_set_average_nframes(tof_processing_config_t ptr, size_t nframes, tof_error_t *error);
355 
356 /** Get whether the temporal filter is enabled. The temporal filter is a running
357  * average as long as the values are within sigma standard deviations of each
358  * other
359  * @param ptr Pointer to class
360  * @param error Pointer to error
361  * @return Enabled
362  */
363 TOF_EXPORT bool tof_processing_config_get_temporal_enabled(const tof_processing_config_t ptr, tof_error_t *error);
364 
365 /** Set whether the temporal filter is enabled. The temporal filter is a running
366  * average as long as the values are within sigma standard deviations of each
367  * other
368  * @param ptr Pointer to class
369  * @param enabled Enabled
370  * @param error Pointer to error
371  */
372 TOF_EXPORT void tof_processing_config_set_temporal_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
373 
374 /** Get the number of standard deviations before resetting the running average
375  * @param ptr Pointer to class
376  * @param error Pointer to error
377  * @return The standard deviation
378  */
379 TOF_EXPORT double tof_processing_config_get_temporal_sigma(const tof_processing_config_t ptr, tof_error_t *error);
380 
381 /** Set the number of standard deviations before resetting the running average
382  * @param ptr Pointer to class
383  * @param sigma The standard deviation
384  * @param error Pointer to error
385  */
386 TOF_EXPORT void tof_processing_config_set_temporal_sigma(tof_processing_config_t ptr, double sigma, tof_error_t *error);
387 
388 /** Get the maximum number of frames to average together
389  * @param ptr Pointer to class
390  * @param error Pointer to error
391  * @return Number of frames
392  */
393 TOF_EXPORT size_t tof_processing_config_get_temporal_nframes(const tof_processing_config_t ptr, tof_error_t *error);
394 
395 /** Set the maximum number of frames to average together
396  * @param ptr Pointer to class
397  * @param nframes Number of frames
398  * @param error Pointer to error
399  */
400 TOF_EXPORT void tof_processing_config_set_temporal_nframes(tof_processing_config_t ptr, size_t nframes, tof_error_t *error);
401 
402 /** Get whether the gaussian blur is enabled. This is a standard gaussian blur
403  * applied over the depth image
404  * @param ptr Pointer to class
405  * @param error Pointer to error
406  * @return Enabled
407  */
408 TOF_EXPORT bool tof_processing_config_get_gaussian_enabled(const tof_processing_config_t ptr, tof_error_t *error);
409 
410 /** Set whether the gaussian blur is enabled. This is a standard gaussian blur
411  * applied over the depth image
412  * @param ptr Pointer to class
413  * @param enabled Enabled
414  * @param error Pointer to error
415  */
416 TOF_EXPORT void tof_processing_config_set_gaussian_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
417 
418 /** Get the gaussian region size
419  * @param ptr Pointer to class
420  * @param error Pointer to error
421  * @return Region size, 3x3 and 5x5 are supported
422  */
423 TOF_EXPORT size_t tof_processing_config_get_gaussian_size(const tof_processing_config_t ptr, tof_error_t *error);
424 
425 /** Set the gaussian region size
426  * @param ptr Pointer to class
427  * @param size Region size, 3x3 and 5x5 are supported
428  * @param error Pointer to error
429  */
430 TOF_EXPORT void tof_processing_config_set_gaussian_size(tof_processing_config_t ptr, size_t size, tof_error_t *error);
431 
432 /** Get the gaussian sigma
433  * @param ptr Pointer to class
434  * @param error Pointer to error
435  * @return The standard deviation
436  */
437 TOF_EXPORT double tof_processing_config_get_gaussian_sigma(const tof_processing_config_t ptr, tof_error_t *error);
438 
439 /** Set the gaussian sigma
440  * @param ptr Pointer to class
441  * @param sigma The standard deviation
442  * @param error Pointer to error
443  */
444 TOF_EXPORT void tof_processing_config_set_gaussian_sigma(tof_processing_config_t ptr, double sigma, tof_error_t *error);
445 
446 /** Get whether the median filter is enabled. This is a standard median filter
447  * applied over the depth image
448  * @param ptr Pointer to class
449  * @param error Pointer to error
450  * @return Enabled
451  */
452 TOF_EXPORT bool tof_processing_config_get_median_enabled(const tof_processing_config_t ptr, tof_error_t *error);
453 
454 /** Set whether the median filter is enabled. This is a standard median filter
455  * applied over the depth image
456  * @param ptr Pointer to class
457  * @param enabled Enabled
458  * @param error Pointer to error
459  */
460 TOF_EXPORT void tof_processing_config_set_median_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
461 
462 /** Get the median region size
463  * @param ptr Pointer to class
464  * @param error Pointer to error
465  * @return Region size, 3x3 and 5x5 are supported
466  */
467 TOF_EXPORT size_t tof_processing_config_get_median_size(const tof_processing_config_t ptr, tof_error_t *error);
468 
469 /** Set the median region size
470  * @param ptr Pointer to class
471  * @param size Region size, 3x3 and 5x5 are supported
472  * @param error Pointer to error
473  */
474 TOF_EXPORT void tof_processing_config_set_median_size(tof_processing_config_t ptr, size_t size, tof_error_t *error);
475 
476 /** Get whether the bilateral filter is enabled. This filter averages the
477  * current pixel with neighboring ones if they're within the specified standard
478  * deviation
479  * @param ptr Pointer to class
480  * @param error Pointer to error
481  * @return Enabled
482  */
483 TOF_EXPORT bool tof_processing_config_get_bilateral_enabled(const tof_processing_config_t ptr, tof_error_t *error);
484 
485 /** Set whether the bilateral filter is enabled. This filter averages the
486  * current pixel with neighboring ones if they're within the specified standard
487  * deviation
488  * @param ptr Pointer to class
489  * @param enabled Enabled
490  * @param error Pointer to error
491  */
492 TOF_EXPORT void tof_processing_config_set_bilateral_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
493 
494 /** Get the bilateral region size
495  * @param ptr Pointer to class
496  * @param error Pointer to error
497  * @return Region size, 3x3 and 5x5 are supported
498  */
499 TOF_EXPORT size_t tof_processing_config_get_bilateral_size(const tof_processing_config_t ptr, tof_error_t *error);
500 
501 /** Set the bilateral region size
502  * @param ptr Pointer to class
503  * @param size Region size, 3x3 and 5x5 are supported
504  * @param error Pointer to error
505  */
506 TOF_EXPORT void tof_processing_config_set_bilateral_size(tof_processing_config_t ptr, size_t size, tof_error_t *error);
507 
508 /** Get the bilateral standard deviation
509  * @param ptr Pointer to class
510  * @param error Pointer to error
511  * @return The standard deviation
512  */
513 TOF_EXPORT double tof_processing_config_get_bilateral_sigma(const tof_processing_config_t ptr, tof_error_t *error);
514 
515 /** Set the bilateral standard deviation
516  * @param ptr Pointer to class
517  * @param sigma The standard deviation
518  * @param error Pointer to error
519  */
520 TOF_EXPORT void tof_processing_config_set_bilateral_sigma(tof_processing_config_t ptr, double sigma, tof_error_t *error);
521 
522 /** Get Whether the local means filter is enabled.
523  * @param ptr Pointer to class
524  * @param error Pointer to error
525  * @return Enabled
526  */
527 TOF_EXPORT bool tof_processing_config_get_local_means_enabled(const tof_processing_config_t ptr, tof_error_t *error);
528 
529 /** Set Whether the local means filter is enabled.
530  * @param ptr Pointer to class
531  * @param enabled Enabled
532  * @param error Pointer to error
533  */
534 TOF_EXPORT void tof_processing_config_set_local_means_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
535 
536 /** Get The local means region size
537  * @param ptr Pointer to class
538  * @param error Pointer to error
539  * @return Region size
540  */
541 TOF_EXPORT size_t tof_processing_config_get_local_means_size(const tof_processing_config_t ptr, tof_error_t *error);
542 
543 /** Set The local means region size
544  * @param ptr Pointer to class
545  * @param size Region size
546  * @param error Pointer to error
547  */
548 TOF_EXPORT void tof_processing_config_set_local_means_size(tof_processing_config_t ptr, size_t size, tof_error_t *error);
549 
550 /** Get The local means standard deviation for how close values are
551  * @param ptr Pointer to class
552  * @param error Pointer to error
553  * @return The stand deviation
554  */
555 TOF_EXPORT double tof_processing_config_get_local_means_sigma(const tof_processing_config_t ptr, tof_error_t *error);
556 
557 /** Set The local means standard deviation for how close values are
558  * @param ptr Pointer to class
559  * @param sigma The stand deviation
560  * @param error Pointer to error
561  */
562 TOF_EXPORT void tof_processing_config_set_local_means_sigma(tof_processing_config_t ptr, double sigma, tof_error_t *error);
563 
564 /** Get whether flying pixel filter is enabled. The flying pixel filters out
565  * pixels when more than x edges are farther than x size away
566  * @param ptr Pointer to class
567  * @param error Pointer to error
568  * @return Enabled
569  */
570 TOF_EXPORT bool tof_processing_config_get_flying_enabled(const tof_processing_config_t ptr, tof_error_t *error);
571 
572 /** Set whether flying pixel filter is enabled. The flying pixel filters out
573  * pixels when more than x edges are farther than x size away
574  * @param ptr Pointer to class
575  * @param enabled Enabled
576  * @param error Pointer to error
577  */
578 TOF_EXPORT void tof_processing_config_set_flying_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
579 
580 /** Get the shape of which surrounding pixels are checked
581  * @param ptr Pointer to class
582  * @param error Pointer to error
583  * @return The shape
584  */
585 TOF_EXPORT enum tof_flying_shape tof_processing_config_get_flying_shape(const tof_processing_config_t ptr, tof_error_t *error);
586 
587 /** Set the shape of which surrounding pixels are checked
588  * @param ptr Pointer to class
589  * @param shape The shape
590  * @param error Pointer to error
591  */
592 TOF_EXPORT void tof_processing_config_set_flying_shape(tof_processing_config_t ptr, enum tof_flying_shape shape, tof_error_t *error);
593 
594 /** Get the maximum distance allowed between surrounding pixels
595  * @param ptr Pointer to class
596  * @param error Pointer to error
597  * @return Maximum distance
598  */
599 TOF_EXPORT size_t tof_processing_config_get_flying_distance(const tof_processing_config_t ptr, tof_error_t *error);
600 
601 /** Set the maximum distance allowed between surrounding pixels
602  * @param ptr Pointer to class
603  * @param distance Maximum distance
604  * @param error Pointer to error
605  */
606 TOF_EXPORT void tof_processing_config_set_flying_distance(tof_processing_config_t ptr, size_t distance, tof_error_t *error);
607 
608 /** Get the number of edges allowed to be larger than maximum distance
609  * @param ptr Pointer to class
610  * @param error Pointer to error
611  * @return Maximum edges
612  */
613 TOF_EXPORT size_t tof_processing_config_get_flying_edges(const tof_processing_config_t ptr, tof_error_t *error);
614 
615 /** Set the number of edges allowed to be larger than maximum distance
616  * @param ptr Pointer to class
617  * @param edges Maximum edges
618  * @param error Pointer to error
619  */
620 TOF_EXPORT void tof_processing_config_set_flying_edges(tof_processing_config_t ptr, size_t edges, tof_error_t *error);
621 
622 /** Get whether the amplitude threshold filter is enabled. This filter filters
623  * out pixels outside of the specified values
624  * @param ptr Pointer to class
625  * @param error Pointer to error
626  * @return Enabled
627  */
628 TOF_EXPORT bool tof_processing_config_get_amp_threshold_enabled(const tof_processing_config_t ptr, tof_error_t *error);
629 
630 /** Set whether the amplitude threshold filter is enabled. This filter filters
631  * out pixels outside of the specified values
632  * @param ptr Pointer to class
633  * @param enabled Enabled
634  * @param error Pointer to error
635  */
636 TOF_EXPORT void tof_processing_config_set_amp_threshold_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
637 
638 /** Get the minimum amplitude allowed
639  * @param ptr Pointer to class
640  * @param error Pointer to error
641  * @return Minimum value
642  */
643 TOF_EXPORT double tof_processing_config_get_amp_threshold_min(const tof_processing_config_t ptr, tof_error_t *error);
644 
645 /** Set the minimum amplitude allowed
646  * @param ptr Pointer to class
647  * @param min Minimum value
648  * @param error Pointer to error
649  */
650 TOF_EXPORT void tof_processing_config_set_amp_threshold_min(tof_processing_config_t ptr, double min, tof_error_t *error);
651 
652 /** Get the maximum amplitude allowed
653  * @param ptr Pointer to class
654  * @param error Pointer to error
655  * @return Maximum value
656  */
657 TOF_EXPORT double tof_processing_config_get_amp_threshold_max(const tof_processing_config_t ptr, tof_error_t *error);
658 
659 /** Set the maximum amplitude allowed
660  * @param ptr Pointer to class
661  * @param max Maximum value
662  * @param error Pointer to error
663  */
664 TOF_EXPORT void tof_processing_config_set_amp_threshold_max(tof_processing_config_t ptr, double max, tof_error_t *error);
665 
666 /** Get whether the distance threshold filter is enabled. This filter filters
667  * out pixels outside of the specified values
668  * @param ptr Pointer to class
669  * @param error Pointer to error
670  * @return Enabled
671  */
672 TOF_EXPORT bool tof_processing_config_get_dist_threshold_enabled(const tof_processing_config_t ptr, tof_error_t *error);
673 
674 /** Set whether the distance threshold filter is enabled. This filter filters
675  * out pixels outside of the specified values
676  * @param ptr Pointer to class
677  * @param enabled Enabled
678  * @param error Pointer to error
679  */
680 TOF_EXPORT void tof_processing_config_set_dist_threshold_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
681 
682 /** Get the minimum distance allowed
683  * @param ptr Pointer to class
684  * @param error Pointer to error
685  * @return Minimum value
686  */
687 TOF_EXPORT double tof_processing_config_get_dist_threshold_min(const tof_processing_config_t ptr, tof_error_t *error);
688 
689 /** Set the minimum distance allowed
690  * @param ptr Pointer to class
691  * @param min Minimum value
692  * @param error Pointer to error
693  */
694 TOF_EXPORT void tof_processing_config_set_dist_threshold_min(tof_processing_config_t ptr, double min, tof_error_t *error);
695 
696 /** Get the maximum distance allowed
697  * @param ptr Pointer to class
698  * @param error Pointer to error
699  * @return Maximum value
700  */
701 TOF_EXPORT double tof_processing_config_get_dist_threshold_max(const tof_processing_config_t ptr, tof_error_t *error);
702 
703 /** Set the maximum distance allowed
704  * @param ptr Pointer to class
705  * @param max Maximum value
706  * @param error Pointer to error
707  */
708 TOF_EXPORT void tof_processing_config_set_dist_threshold_max(tof_processing_config_t ptr, double max, tof_error_t *error);
709 
710 /** Get how much to scale the radial value by
711  * @param ptr Pointer to class
712  * @param error Pointer to error
713  * @return Radial scale
714  */
715 TOF_EXPORT float tof_processing_config_get_radial_scale(const tof_processing_config_t ptr, tof_error_t *error);
716 
717 /** Set how much to scale the radial value by
718  * @param ptr Pointer to class
719  * @param scale Radial scale
720  * @param error Pointer to error
721  */
722 TOF_EXPORT void tof_processing_config_set_radial_scale(tof_processing_config_t ptr, float scale, tof_error_t *error);
723 
724 /** Get how much to add to the radial value
725  * @param ptr Pointer to class
726  * @param error Pointer to error
727  * @return Radial addition
728  */
729 TOF_EXPORT float tof_processing_config_get_radial_add(const tof_processing_config_t ptr, tof_error_t *error);
730 
731 /** Set how much to add to the radial value
732  * @param ptr Pointer to class
733  * @param addition Radial addition
734  * @param error Pointer to error
735  */
736 TOF_EXPORT void tof_processing_config_set_radial_add(tof_processing_config_t ptr, float addition, tof_error_t *error);
737 
738 /** Get how much to scale the intensity value by
739  * @param ptr Pointer to class
740  * @param error Pointer to error
741  * @return Intensity scale
742  */
743 TOF_EXPORT float tof_processing_config_get_intensity_scale(const tof_processing_config_t ptr, tof_error_t *error);
744 
745 /** Set how much to scale the intensity value by
746  * @param ptr Pointer to class
747  * @param scale Intensity scale
748  * @param error Pointer to error
749  */
750 TOF_EXPORT void tof_processing_config_set_intensity_scale(tof_processing_config_t ptr, float scale, tof_error_t *error);
751 
752 /** Get how much to add to the intensity value
753  * @param ptr Pointer to class
754  * @param error Pointer to error
755  * @return Intensity addition
756  */
757 TOF_EXPORT float tof_processing_config_get_intensity_add(const tof_processing_config_t ptr, tof_error_t *error);
758 
759 /** Set how much to add to the intensity value
760  * @param ptr Pointer to class
761  * @param addition Intensity addition
762  * @param error Pointer to error
763  */
764 TOF_EXPORT void tof_processing_config_set_intensity_add(tof_processing_config_t ptr, float addition, tof_error_t *error);
765 
766 /** Get the characterization addition component. The characterization function
767  * computes the sigma for the temporal and bilateral filter
768  * @param ptr Pointer to class
769  * @param error Pointer to error
770  * @return addition
771  */
772 TOF_EXPORT double tof_processing_config_get_char_add(const tof_processing_config_t ptr, tof_error_t *error);
773 
774 /** Set the characterization addition component. The characterization function
775  * computes the sigma for the temporal and bilateral filter
776  * @param ptr Pointer to class
777  * @param addition addition
778  * @param error Pointer to error
779  */
780 TOF_EXPORT void tof_processing_config_set_char_add(tof_processing_config_t ptr, double addition, tof_error_t *error);
781 
782 /** Get the characterization multiplication component. The characterization
783  * function computes the sigma for the temporal and bilateral filter
784  * @param ptr Pointer to class
785  * @param error Pointer to error
786  * @return Multiplication
787  */
788 TOF_EXPORT double tof_processing_config_get_char_mult(const tof_processing_config_t ptr, tof_error_t *error);
789 
790 /** Set the characterization multiplication component. The characterization
791  * function computes the sigma for the temporal and bilateral filter
792  * @param ptr Pointer to class
793  * @param multiplication Multiplication
794  * @param error Pointer to error
795  */
796 TOF_EXPORT void tof_processing_config_set_char_mult(tof_processing_config_t ptr, double multiplication, tof_error_t *error);
797 
798 /** Get whether software binning is enabled
799  * @param ptr Pointer to class
800  * @param error Pointer to error
801  * @return Enabled
802  */
803 TOF_EXPORT bool tof_processing_config_get_binning_enabled(const tof_processing_config_t ptr, tof_error_t *error);
804 
805 /** Set whether software binning is enabled
806  * @param ptr Pointer to class
807  * @param enabled Enabled
808  * @param error Pointer to error
809  */
810 TOF_EXPORT void tof_processing_config_set_binning_enabled(tof_processing_config_t ptr, bool enabled, tof_error_t *error);
811 
812 /** Get the size of the area to bin, 2 would bin a 2x2 area
813  * @param ptr Pointer to class
814  * @param error Pointer to error
815  * @return The bin size
816  */
817 TOF_EXPORT size_t tof_processing_config_get_binning_size(const tof_processing_config_t ptr, tof_error_t *error);
818 
819 /** Set the size of the area to bin, 2 would bin a 2x2 area
820  * @param ptr Pointer to class
821  * @param size The bin size
822  * @param error Pointer to error
823  */
824 TOF_EXPORT void tof_processing_config_set_binning_size(tof_processing_config_t ptr, size_t size, tof_error_t *error);
825 
826 /** Get the binning mode to use
827  * @param ptr Pointer to class
828  * @param error Pointer to error
829  * @return The binning mode
830  */
831 TOF_EXPORT enum tof_binning_mode tof_processing_config_get_binning_mode(const tof_processing_config_t ptr, tof_error_t *error);
832 
833 /** Set the binning mode to use
834  * @param ptr Pointer to class
835  * @param mode The binning mode
836  * @param error Pointer to error
837  */
838 TOF_EXPORT void tof_processing_config_set_binning_mode(tof_processing_config_t ptr, enum tof_binning_mode mode, tof_error_t *error);
839 
840 /** Get The maximum standard deviation to use, only used in the smart binning
841  * mode
842  * @param ptr Pointer to class
843  * @param error Pointer to error
844  * @return The standard deviation
845  */
846 TOF_EXPORT float tof_processing_config_get_binning_sigma(const tof_processing_config_t ptr, tof_error_t *error);
847 
848 /** Set The maximum standard deviation to use, only used in the smart binning
849  * mode
850  * @param ptr Pointer to class
851  * @param sigma The standard deviation
852  * @param error Pointer to error
853  */
854 TOF_EXPORT void tof_processing_config_set_binning_sigma(tof_processing_config_t ptr, float sigma, tof_error_t *error);
855 
856 #ifdef __cplusplus
857 }
858 #endif
859 
860 #endif