processing_config.hpp

#ifndef _CHRONOPTICS_TOF_PROCESSING_CONFIG_HPP_
#define _CHRONOPTICS_TOF_PROCESSING_CONFIG_HPP_
 
#include <chronoptics/tof/processing_config.h>
 
#include <chronoptics/tof/base.hpp>
 
namespace chronoptics {
namespace tof {
 
/** The shape of which surrounding pixels are checked in the flying pixel filter
 */
enum class FlyingShape {
  PLUS = 0, /** Four neighboring pixels in a plus shape */
  BOX = 1, /** All eight neighboring pixels */
};
 
/** Mixed pixel sort mode. The mode you want to use depends on your application.
 */
enum class MpSortMode {
  DARKEST = 0, /** Choose darkest path */
  SHORTEST = 1, /** Return the surface of a translucent object, resolve corners or checkerboard lens flare */
  BRIGHTEST = 2, /** Mixed pixels between foreground and background, get the best SNR */
  LONGEST = 3, /** Correct lens flare from close bright objects */
  AGGRESSOR = 4, /** Correct lens flare */
  ADAPTIVE_SHORT_V0 = 5, /** Adaptive shortest */
  ADAPTIVE_SHORT_V1 = 6, /** Adaptive shortest version two */
  AGGRESSOR_V2 = 7, /** Correct lens flare version two */
};
 
/** What kind of binning to do
 */
enum class BinningMode {
  NORMAL = 0, /** Normal binning, a BxB grid averaged to a single pixel */
  SMART = 1, /** Smart binning, take into account the standard deviation around a chosen pixel. Similar to local means but reduces the image size */
};
 
/** In what dimension the xyz is exported
 */
enum class XyzDimension {
  MILLIMETER = 0, /** Export in millimeters */
  METER = 1, /** Export in meters */
};
 
/** Processing that can be done
*/
class ProcessingConfig : public detail::Base<tof_processing_config, tof_processing_config_delete> {
 public:
  /** Construct from pointer */
  ProcessingConfig(tof_processing_config_t ptr) {
    this->ptr_ = ptr;
  }
 
  /** Create default processing config
   */
  ProcessingConfig() {
    this->ptr_ = tof_processing_config_new_default(TOF_ERROR_HANDLER{});
  }
 
  /** Load processing config from disk
   * @param file_location Location of processing config
   */
  ProcessingConfig(StringView file_location) {
    this->ptr_ = tof_processing_config_new_from_disk(file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Write processing config to disk
   * @param file_location Location where to save the processing config
   */
  void write(StringView file_location) const {
    return tof_processing_config_write(this->ptr_, file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether processing on the gpu is enabled
   * @return Enabled
   */
  bool get_gpu() const {
    return tof_processing_config_get_gpu(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether processing on the gpu is enabled
   * @param gpu Enabled
   */
  void set_gpu(bool gpu) {
    return tof_processing_config_set_gpu(this->ptr_, gpu, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the calibration is applied
   * @return Enabled
   */
  bool get_calibration_enabled() const {
    return tof_processing_config_get_calibration_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the calibration is applied
   * @param enabled Enabled
   */
  void set_calibration_enabled(bool enabled) {
    return tof_processing_config_set_calibration_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether phase unwrapping is enabled
   * @return Enabled
   */
  bool get_phase_unwrapping_enabled() const {
    return tof_processing_config_get_phase_unwrapping_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether phase unwrapping is enabled
   * @param enabled Enabled
   */
  void set_phase_unwrapping_enabled(bool enabled) {
    return tof_processing_config_set_phase_unwrapping_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get The maximum distance between ideal location and actual
   * @return Max offset, range [0, 1]
   */
  double get_phase_unwrapping_max_offset() const {
    return tof_processing_config_get_phase_unwrapping_max_offset(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The maximum distance between ideal location and actual
   * @param max_offset Max offset, range [0, 1]
   */
  void set_phase_unwrapping_max_offset(double max_offset) {
    return tof_processing_config_set_phase_unwrapping_max_offset(this->ptr_, max_offset, TOF_ERROR_HANDLER{});
  }
 
  /** Get wether mpi detect is enabled
   * @return Enabled
   */
  bool get_mpi_detect_enabled() const {
    return tof_processing_config_get_mpi_detect_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set wether mpi detect is enabled
   * @param enabled Enabled
   */
  void set_mpi_detect_enabled(bool enabled) {
    return tof_processing_config_set_mpi_detect_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get The amplitude ratio value
   * @return The maximum ratio
   */
  float get_mpi_detect_aratio() const {
    return tof_processing_config_get_mpi_detect_aratio(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The amplitude ratio value
   * @param aratio The maximum ratio
   */
  void set_mpi_detect_aratio(float aratio) {
    return tof_processing_config_set_mpi_detect_aratio(this->ptr_, aratio, TOF_ERROR_HANDLER{});
  }
 
  /** Get the phase difference ratio
   * @return The maximum phase difference
   */
  float get_mpi_detect_phi_diff() const {
    return tof_processing_config_get_mpi_detect_phi_diff(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the phase difference ratio
   * @param phi_diff The maximum phase difference
   */
  void set_mpi_detect_phi_diff(float phi_diff) {
    return tof_processing_config_set_mpi_detect_phi_diff(this->ptr_, phi_diff, TOF_ERROR_HANDLER{});
  }
 
  /** Get wether mixed pixel is enabled
   * @return Enabled
   */
  bool get_mixed_pixel_enabled() const {
    return tof_processing_config_get_mixed_pixel_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set wether mixed pixel is enabled
   * @param enabled Enabled
   */
  void set_mixed_pixel_enabled(bool enabled) {
    return tof_processing_config_set_mixed_pixel_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get location of the mixed pixel look up table file
   * @return File location
   */
  const char* get_mixed_pixel_lut_file() const {
    return tof_processing_config_get_mixed_pixel_lut_file(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set location of the mixed pixel look up table file
   * @param file_location File location
   */
  void set_mixed_pixel_lut_file(StringView file_location) {
    return tof_processing_config_set_mixed_pixel_lut_file(this->ptr_, file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Get minimum amplitude that pixel needs to have to apply mixed pixel to it
   * @return Minimum amplitude
   */
  double get_mixed_pixel_amp_min() const {
    return tof_processing_config_get_mixed_pixel_amp_min(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set minimum amplitude that pixel needs to have to apply mixed pixel to it
   * @param amp_min Minimum amplitude
   */
  void set_mixed_pixel_amp_min(double amp_min) {
    return tof_processing_config_set_mixed_pixel_amp_min(this->ptr_, amp_min, TOF_ERROR_HANDLER{});
  }
 
  /** Get what output is selected
   * @return Sort mode
   */
  MpSortMode get_mixed_pixel_sort_mode() const {
    return static_cast<MpSortMode>(tof_processing_config_get_mixed_pixel_sort_mode(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set what output is selected
   * @param sort_mode Sort mode
   */
  void set_mixed_pixel_sort_mode(MpSortMode sort_mode) {
    return tof_processing_config_set_mixed_pixel_sort_mode(this->ptr_, static_cast<tof_mp_sort_mode>(sort_mode), TOF_ERROR_HANDLER{});
  }
 
  /** Get the amplitude ratio for detecting MPI
   * @return Amplitude ratio
   */
  double get_mixed_pixel_aratio() const {
    return tof_processing_config_get_mixed_pixel_aratio(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the amplitude ratio for detecting MPI
   * @param aratio Amplitude ratio
   */
  void set_mixed_pixel_aratio(double aratio) {
    return tof_processing_config_set_mixed_pixel_aratio(this->ptr_, aratio, TOF_ERROR_HANDLER{});
  }
 
  /** Get the phase difference for detecting MPI
   * @return Phase difference
   */
  double get_mixed_pixel_phi_diff() const {
    return tof_processing_config_get_mixed_pixel_phi_diff(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the phase difference for detecting MPI
   * @param phi_diff Phase difference
   */
  void set_mixed_pixel_phi_diff(double phi_diff) {
    return tof_processing_config_set_mixed_pixel_phi_diff(this->ptr_, phi_diff, TOF_ERROR_HANDLER{});
  }
 
  /** Get the threshold to classify a pixel as an aggressor
   * @return Aggressor threshold
   */
  double get_mixed_pixel_aggressor_threshold() const {
    return tof_processing_config_get_mixed_pixel_aggressor_threshold(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the threshold to classify a pixel as an aggressor
   * @param threshold Aggressor threshold
   */
  void set_mixed_pixel_aggressor_threshold(double threshold) {
    return tof_processing_config_set_mixed_pixel_aggressor_threshold(this->ptr_, threshold, TOF_ERROR_HANDLER{});
  }
 
  /** Get the minimum amount of bright pixels before a bright spot is classified
   * as an aggressor
   * @return Minimum aggressor size
   */
  int32_t get_mixed_pixel_min_aggressor_size() const {
    return tof_processing_config_get_mixed_pixel_min_aggressor_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the minimum amount of bright pixels before a bright spot is classified
   * as an aggressor
   * @param size Minimum aggressor size
   */
  void set_mixed_pixel_min_aggressor_size(int32_t size) {
    return tof_processing_config_set_mixed_pixel_min_aggressor_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum error when using three modulation frequencies
   * @return The error
   */
  double get_mixed_pixel_max_error_3f() const {
    return tof_processing_config_get_mixed_pixel_max_error_3f(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum error when using three modulation frequencies
   * @param max_error_3f The error
   */
  void set_mixed_pixel_max_error_3f(double max_error_3f) {
    return tof_processing_config_set_mixed_pixel_max_error_3f(this->ptr_, max_error_3f, TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum amplitude for adaptive sorting
   * @return Maximum amplitude
   */
  double get_mixed_pixel_adaptive_amp_max() const {
    return tof_processing_config_get_mixed_pixel_adaptive_amp_max(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum amplitude for adaptive sorting
   * @param adaptive_amp_max Maximum amplitude
   */
  void set_mixed_pixel_adaptive_amp_max(double adaptive_amp_max) {
    return tof_processing_config_set_mixed_pixel_adaptive_amp_max(this->ptr_, adaptive_amp_max, TOF_ERROR_HANDLER{});
  }
 
  /** Get the minimum amplitude for adaptive sorting
   * @return Minimum amplitude
   */
  double get_mixed_pixel_adaptive_amp_min() const {
    return tof_processing_config_get_mixed_pixel_adaptive_amp_min(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the minimum amplitude for adaptive sorting
   * @param adaptive_amp_min Minimum amplitude
   */
  void set_mixed_pixel_adaptive_amp_min(double adaptive_amp_min) {
    return tof_processing_config_set_mixed_pixel_adaptive_amp_min(this->ptr_, adaptive_amp_min, TOF_ERROR_HANDLER{});
  }
 
  /** Get the minimum return amplitude ratio for adaptive sorting
   * @return Minimum return ratio
   */
  double get_mixed_pixel_aratio_min() const {
    return tof_processing_config_get_mixed_pixel_aratio_min(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the minimum return amplitude ratio for adaptive sorting
   * @param aratio_min Minimum return ratio
   */
  void set_mixed_pixel_aratio_min(double aratio_min) {
    return tof_processing_config_set_mixed_pixel_aratio_min(this->ptr_, aratio_min, TOF_ERROR_HANDLER{});
  }
 
  /** Get The maximum phase difference before a return is not classified as
   * aggressor
   * @return Phase offset before not a aggressor return
   */
  double get_mixed_pixel_aggressor_phi_offset() const {
    return tof_processing_config_get_mixed_pixel_aggressor_phi_offset(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The maximum phase difference before a return is not classified as
   * aggressor
   * @param aggressor_phi_offset Phase offset before not a aggressor return
   */
  void set_mixed_pixel_aggressor_phi_offset(double aggressor_phi_offset) {
    return tof_processing_config_set_mixed_pixel_aggressor_phi_offset(this->ptr_, aggressor_phi_offset, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether hdr is enabled. High dynamic range allows you to separate
   * depth with high intensity difference. This is mostly useful when the sensor
   * is being saturated.
   * @return Enabled
   */
  bool get_hdr_enabled() const {
    return tof_processing_config_get_hdr_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether hdr is enabled. High dynamic range allows you to separate
   * depth with high intensity difference. This is mostly useful when the sensor
   * is being saturated.
   * @param enabled Enabled
   */
  void set_hdr_enabled(bool enabled) {
    return tof_processing_config_set_hdr_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether averaging is enabled. The average process allows you to
   * average multiple frames together at the cost of frame rate
   * @return Enabled
   */
  bool get_average_enabled() const {
    return tof_processing_config_get_average_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether averaging is enabled. The average process allows you to
   * average multiple frames together at the cost of frame rate
   * @param enabled Enabled
   */
  void set_average_enabled(bool enabled) {
    return tof_processing_config_set_average_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of frames to average together
   * @return Number of frames
   */
  size_t get_average_nframes() const {
    return tof_processing_config_get_average_nframes(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the number of frames to average together
   * @param nframes Number of frames
   */
  void set_average_nframes(size_t nframes) {
    return tof_processing_config_set_average_nframes(this->ptr_, nframes, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the temporal filter is enabled. The temporal filter is a
   * running average as long as the values are within sigma standard deviations
   * of each other
   * @return Enabled
   */
  bool get_temporal_enabled() const {
    return tof_processing_config_get_temporal_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the temporal filter is enabled. The temporal filter is a
   * running average as long as the values are within sigma standard deviations
   * of each other
   * @param enabled Enabled
   */
  void set_temporal_enabled(bool enabled) {
    return tof_processing_config_set_temporal_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of standard deviations before resetting the running average
   * @return The standard deviation
   */
  double get_temporal_sigma() const {
    return tof_processing_config_get_temporal_sigma(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the number of standard deviations before resetting the running average
   * @param sigma The standard deviation
   */
  void set_temporal_sigma(double sigma) {
    return tof_processing_config_set_temporal_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum number of frames to average together
   * @return Number of frames
   */
  size_t get_temporal_nframes() const {
    return tof_processing_config_get_temporal_nframes(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum number of frames to average together
   * @param nframes Number of frames
   */
  void set_temporal_nframes(size_t nframes) {
    return tof_processing_config_set_temporal_nframes(this->ptr_, nframes, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the gaussian blur is enabled. This is a standard gaussian blur
   * applied over the depth image
   * @return Enabled
   */
  bool get_gaussian_enabled() const {
    return tof_processing_config_get_gaussian_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the gaussian blur is enabled. This is a standard gaussian blur
   * applied over the depth image
   * @param enabled Enabled
   */
  void set_gaussian_enabled(bool enabled) {
    return tof_processing_config_set_gaussian_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the gaussian region size
   * @return Region size, 3x3 and 5x5 are supported
   */
  size_t get_gaussian_size() const {
    return tof_processing_config_get_gaussian_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the gaussian region size
   * @param size Region size, 3x3 and 5x5 are supported
   */
  void set_gaussian_size(size_t size) {
    return tof_processing_config_set_gaussian_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get the gaussian sigma
   * @return The standard deviation
   */
  double get_gaussian_sigma() const {
    return tof_processing_config_get_gaussian_sigma(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the gaussian sigma
   * @param sigma The standard deviation
   */
  void set_gaussian_sigma(double sigma) {
    return tof_processing_config_set_gaussian_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the median filter is enabled. This is a standard median filter
   * applied over the depth image
   * @return Enabled
   */
  bool get_median_enabled() const {
    return tof_processing_config_get_median_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the median filter is enabled. This is a standard median filter
   * applied over the depth image
   * @param enabled Enabled
   */
  void set_median_enabled(bool enabled) {
    return tof_processing_config_set_median_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the median region size
   * @return Region size, 3x3 and 5x5 are supported
   */
  size_t get_median_size() const {
    return tof_processing_config_get_median_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the median region size
   * @param size Region size, 3x3 and 5x5 are supported
   */
  void set_median_size(size_t size) {
    return tof_processing_config_set_median_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the bilateral filter is enabled. This filter averages the
   * current pixel with neighboring ones if they're within the specified
   * standard deviation
   * @return Enabled
   */
  bool get_bilateral_enabled() const {
    return tof_processing_config_get_bilateral_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the bilateral filter is enabled. This filter averages the
   * current pixel with neighboring ones if they're within the specified
   * standard deviation
   * @param enabled Enabled
   */
  void set_bilateral_enabled(bool enabled) {
    return tof_processing_config_set_bilateral_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the bilateral region size
   * @return Region size, 3x3 and 5x5 are supported
   */
  size_t get_bilateral_size() const {
    return tof_processing_config_get_bilateral_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the bilateral region size
   * @param size Region size, 3x3 and 5x5 are supported
   */
  void set_bilateral_size(size_t size) {
    return tof_processing_config_set_bilateral_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get the bilateral standard deviation
   * @return The standard deviation
   */
  double get_bilateral_sigma() const {
    return tof_processing_config_get_bilateral_sigma(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the bilateral standard deviation
   * @param sigma The standard deviation
   */
  void set_bilateral_sigma(double sigma) {
    return tof_processing_config_set_bilateral_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
  }
 
  /** Get Whether the local means filter is enabled.
   * @return Enabled
   */
  bool get_local_means_enabled() const {
    return tof_processing_config_get_local_means_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set Whether the local means filter is enabled.
   * @param enabled Enabled
   */
  void set_local_means_enabled(bool enabled) {
    return tof_processing_config_set_local_means_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get The local means region size
   * @return Region size
   */
  size_t get_local_means_size() const {
    return tof_processing_config_get_local_means_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The local means region size
   * @param size Region size
   */
  void set_local_means_size(size_t size) {
    return tof_processing_config_set_local_means_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get The local means standard deviation for how close values are
   * @return The stand deviation
   */
  double get_local_means_sigma() const {
    return tof_processing_config_get_local_means_sigma(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The local means standard deviation for how close values are
   * @param sigma The stand deviation
   */
  void set_local_means_sigma(double sigma) {
    return tof_processing_config_set_local_means_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether flying pixel filter is enabled. The flying pixel filters out
   * pixels when more than x edges are farther than x size away
   * @return Enabled
   */
  bool get_flying_enabled() const {
    return tof_processing_config_get_flying_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether flying pixel filter is enabled. The flying pixel filters out
   * pixels when more than x edges are farther than x size away
   * @param enabled Enabled
   */
  void set_flying_enabled(bool enabled) {
    return tof_processing_config_set_flying_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the shape of which surrounding pixels are checked
   * @return The shape
   */
  FlyingShape get_flying_shape() const {
    return static_cast<FlyingShape>(tof_processing_config_get_flying_shape(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set the shape of which surrounding pixels are checked
   * @param shape The shape
   */
  void set_flying_shape(FlyingShape shape) {
    return tof_processing_config_set_flying_shape(this->ptr_, static_cast<tof_flying_shape>(shape), TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum distance allowed between surrounding pixels
   * @return Maximum distance
   */
  size_t get_flying_distance() const {
    return tof_processing_config_get_flying_distance(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum distance allowed between surrounding pixels
   * @param distance Maximum distance
   */
  void set_flying_distance(size_t distance) {
    return tof_processing_config_set_flying_distance(this->ptr_, distance, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of edges allowed to be larger than maximum distance
   * @return Maximum edges
   */
  size_t get_flying_edges() const {
    return tof_processing_config_get_flying_edges(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the number of edges allowed to be larger than maximum distance
   * @param edges Maximum edges
   */
  void set_flying_edges(size_t edges) {
    return tof_processing_config_set_flying_edges(this->ptr_, edges, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the amplitude threshold filter is enabled. This filter filters
   * out pixels outside of the specified values
   * @return Enabled
   */
  bool get_amp_threshold_enabled() const {
    return tof_processing_config_get_amp_threshold_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the amplitude threshold filter is enabled. This filter filters
   * out pixels outside of the specified values
   * @param enabled Enabled
   */
  void set_amp_threshold_enabled(bool enabled) {
    return tof_processing_config_set_amp_threshold_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the minimum amplitude allowed
   * @return Minimum value
   */
  double get_amp_threshold_min() const {
    return tof_processing_config_get_amp_threshold_min(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the minimum amplitude allowed
   * @param min Minimum value
   */
  void set_amp_threshold_min(double min) {
    return tof_processing_config_set_amp_threshold_min(this->ptr_, min, TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum amplitude allowed
   * @return Maximum value
   */
  double get_amp_threshold_max() const {
    return tof_processing_config_get_amp_threshold_max(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum amplitude allowed
   * @param max Maximum value
   */
  void set_amp_threshold_max(double max) {
    return tof_processing_config_set_amp_threshold_max(this->ptr_, max, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether the distance threshold filter is enabled. This filter filters
   * out pixels outside of the specified values
   * @return Enabled
   */
  bool get_dist_threshold_enabled() const {
    return tof_processing_config_get_dist_threshold_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether the distance threshold filter is enabled. This filter filters
   * out pixels outside of the specified values
   * @param enabled Enabled
   */
  void set_dist_threshold_enabled(bool enabled) {
    return tof_processing_config_set_dist_threshold_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the minimum distance allowed
   * @return Minimum value
   */
  double get_dist_threshold_min() const {
    return tof_processing_config_get_dist_threshold_min(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the minimum distance allowed
   * @param min Minimum value
   */
  void set_dist_threshold_min(double min) {
    return tof_processing_config_set_dist_threshold_min(this->ptr_, min, TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum distance allowed
   * @return Maximum value
   */
  double get_dist_threshold_max() const {
    return tof_processing_config_get_dist_threshold_max(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum distance allowed
   * @param max Maximum value
   */
  void set_dist_threshold_max(double max) {
    return tof_processing_config_set_dist_threshold_max(this->ptr_, max, TOF_ERROR_HANDLER{});
  }
 
  /** Get how much to scale the radial value by
   * @return Radial scale
   */
  float get_radial_scale() const {
    return tof_processing_config_get_radial_scale(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set how much to scale the radial value by
   * @param scale Radial scale
   */
  void set_radial_scale(float scale) {
    return tof_processing_config_set_radial_scale(this->ptr_, scale, TOF_ERROR_HANDLER{});
  }
 
  /** Get how much to add to the radial value
   * @return Radial addition
   */
  float get_radial_add() const {
    return tof_processing_config_get_radial_add(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set how much to add to the radial value
   * @param addition Radial addition
   */
  void set_radial_add(float addition) {
    return tof_processing_config_set_radial_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
  }
 
  /** Get how much to scale the intensity value by
   * @return Intensity scale
   */
  float get_intensity_scale() const {
    return tof_processing_config_get_intensity_scale(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set how much to scale the intensity value by
   * @param scale Intensity scale
   */
  void set_intensity_scale(float scale) {
    return tof_processing_config_set_intensity_scale(this->ptr_, scale, TOF_ERROR_HANDLER{});
  }
 
  /** Get how much to add to the intensity value
   * @return Intensity addition
   */
  float get_intensity_add() const {
    return tof_processing_config_get_intensity_add(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set how much to add to the intensity value
   * @param addition Intensity addition
   */
  void set_intensity_add(float addition) {
    return tof_processing_config_set_intensity_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
  }
 
  /** Get the characterization addition component. The characterization function
   * computes the sigma for the temporal and bilateral filter
   * @return addition
   */
  double get_char_add() const {
    return tof_processing_config_get_char_add(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the characterization addition component. The characterization function
   * computes the sigma for the temporal and bilateral filter
   * @param addition addition
   */
  void set_char_add(double addition) {
    return tof_processing_config_set_char_add(this->ptr_, addition, TOF_ERROR_HANDLER{});
  }
 
  /** Get the characterization multiplication component. The characterization
   * function computes the sigma for the temporal and bilateral filter
   * @return Multiplication
   */
  double get_char_mult() const {
    return tof_processing_config_get_char_mult(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the characterization multiplication component. The characterization
   * function computes the sigma for the temporal and bilateral filter
   * @param multiplication Multiplication
   */
  void set_char_mult(double multiplication) {
    return tof_processing_config_set_char_mult(this->ptr_, multiplication, TOF_ERROR_HANDLER{});
  }
 
  /** Get whether software binning is enabled
   * @return Enabled
   */
  bool get_binning_enabled() const {
    return tof_processing_config_get_binning_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether software binning is enabled
   * @param enabled Enabled
   */
  void set_binning_enabled(bool enabled) {
    return tof_processing_config_set_binning_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the size of the area to bin, 2 would bin a 2x2 area
   * @return The bin size
   */
  size_t get_binning_size() const {
    return tof_processing_config_get_binning_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the size of the area to bin, 2 would bin a 2x2 area
   * @param size The bin size
   */
  void set_binning_size(size_t size) {
    return tof_processing_config_set_binning_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get the binning mode to use
   * @return The binning mode
   */
  BinningMode get_binning_mode() const {
    return static_cast<BinningMode>(tof_processing_config_get_binning_mode(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set the binning mode to use
   * @param mode The binning mode
   */
  void set_binning_mode(BinningMode mode) {
    return tof_processing_config_set_binning_mode(this->ptr_, static_cast<tof_binning_mode>(mode), TOF_ERROR_HANDLER{});
  }
 
  /** Get The maximum standard deviation to use, only used in the smart binning
   * mode
   * @return The standard deviation
   */
  float get_binning_sigma() const {
    return tof_processing_config_get_binning_sigma(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The maximum standard deviation to use, only used in the smart binning
   * mode
   * @param sigma The standard deviation
   */
  void set_binning_sigma(float sigma) {
    return tof_processing_config_set_binning_sigma(this->ptr_, sigma, TOF_ERROR_HANDLER{});
  }
 
  /** Get the dimension of the xyz output
   * @return The dimension
   */
  XyzDimension get_xyz_dimension() const {
    return static_cast<XyzDimension>(tof_processing_config_get_xyz_dimension(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set the dimension of the xyz output
   * @param dimension The dimension
   */
  void set_xyz_dimension(XyzDimension dimension) {
    return tof_processing_config_set_xyz_dimension(this->ptr_, static_cast<tof_xyz_dimension>(dimension), TOF_ERROR_HANDLER{});
  }
 
  /** Get whether rigid transformation is enabled
   * @return Enabled
   */
  bool get_rigid_transformation_enabled() const {
    return tof_processing_config_get_rigid_transformation_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set whether rigid transformation is enabled
   * @param enabled Enabled
   */
  void set_rigid_transformation_enabled(bool enabled) {
    return tof_processing_config_set_rigid_transformation_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
  /** Get the rigid transformation 4x4 matrix
   * @return 4x4 transformation matrix
   */
  std::array<float, 16> get_rigid_transformation_matrix() const {
    std::array<float, 16> array;
    auto data = tof_processing_config_get_rigid_transformation_matrix(this->ptr_, TOF_ERROR_HANDLER{});
    std::copy(data, data + array.size(), array.data());
    return array;
  }
 
  /** Set the rigid transformation 4x4 matrix
   * @param matrix 4x4 transformation matrix
   */
  void set_rigid_transformation_matrix(const std::array<float, 16> &matrix) {
    return tof_processing_config_set_rigid_transformation_matrix(this->ptr_, matrix.data(), TOF_ERROR_HANDLER{});
  }
 
};
 
} // tof
} // chronoptics
 
#endif