user_config.hpp

#ifndef _CHRONOPTICS_TOF_USER_CONFIG_HPP_
#define _CHRONOPTICS_TOF_USER_CONFIG_HPP_
 
#include <chronoptics/tof/user_config.h>
 
#include <chronoptics/tof/camera_config.hpp>
#include <chronoptics/tof/camera.hpp>
 
namespace chronoptics {
namespace tof {
 
/** The integration time as fixed presets
 */
enum class IntegrationTime {
  SHORT = 0, /** 250 us */
  MEDIUM = 1, /** 500 us */
  LONG = 2, /** 1000us */
};
 
/** The different imaging environments
 */
enum class ImagingEnvironment {
  INSIDE = 0, /** Inside buildings */
  SUNLIGHT = 1, /** When bright sunlight is present */
};
 
/** The optimization of the camera configuration
 */
enum class Strategy {
  BALANCED = 0, /** The balanced configuration */
  SPEED = 1, /** Optimize for moving objects */
  ACCURACY = 2, /** Optimize for high accuracy */
};
 
/** Simple interface for camera configuration generation
*/
class UserConfig : public detail::Base<tof_user_config, tof_user_config_delete> {
 public:
  /** Construct from pointer */
  UserConfig(tof_user_config_t ptr) {
    this->ptr_ = ptr;
  }
 
  /** Create default user config
   */
  UserConfig() {
    this->ptr_ = tof_user_config_new_default(TOF_ERROR_HANDLER{});
  }
 
  /** Convert to a camera configuration
   * @param camera The camera
   * @return The camera configuration
   */
  CameraConfig to_camera_config(Camera &camera) const {
    CameraConfig new_camera_config(static_cast<tof_camera_config_t>(nullptr));
    auto ptr = reinterpret_cast<tof_camera_config_t*>(&new_camera_config);
    *ptr = tof_user_config_to_camera_config(this->ptr_, *reinterpret_cast<tof_camera_t*>(&camera), TOF_ERROR_HANDLER{});
    return new_camera_config;
  }
 
  /** Get the camera operating environment
   * @return Imaging environment
   */
  ImagingEnvironment get_environment() const {
    return static_cast<ImagingEnvironment>(tof_user_config_get_environment(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set the camera operating environment
   * @param imaging_environment Imaging environment
   */
  void set_environment(ImagingEnvironment imaging_environment) {
    return tof_user_config_set_environment(this->ptr_, static_cast<tof_imaging_environment>(imaging_environment), TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum distance photons reflect from
   * @return Maximum distance in meters
   */
  float get_max_distance() const {
    return tof_user_config_get_max_distance(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the maximum distance photons reflect from
   * @param max_distance Maximum distance in meters
   */
  void set_max_distance(float max_distance) {
    return tof_user_config_set_max_distance(this->ptr_, max_distance, TOF_ERROR_HANDLER{});
  }
 
  /** Get the depth frame rate
   * @return The depth fps
   */
  float get_fps() const {
    return tof_user_config_get_fps(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the depth frame rate
   * @param fps The depth fps
   */
  void set_fps(float fps) {
    return tof_user_config_set_fps(this->ptr_, fps, TOF_ERROR_HANDLER{});
  }
 
  /** Get if lens flare is expected in the scene
   * @return if lens flare is present
   */
  bool get_lens_flare() const {
    return tof_user_config_get_lens_flare(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set if lens flare is expected in the scene
   * @param lens_flare if lens flare is present
   */
  void set_lens_flare(bool lens_flare) {
    return tof_user_config_set_lens_flare(this->ptr_, lens_flare, TOF_ERROR_HANDLER{});
  }
 
  /** Get if there are translucent objects in the scene
   * @return If translucent objects
   */
  bool get_translucent() const {
    return tof_user_config_get_translucent(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set if there are translucent objects in the scene
   * @param translucent If translucent objects
   */
  void set_translucent(bool translucent) {
    return tof_user_config_set_translucent(this->ptr_, translucent, TOF_ERROR_HANDLER{});
  }
 
  /** Get high dynamic range enabled. Enable this when pixel saturation occurs.
   * This will only happen for retroreflectors or reflective objects close
   * (<20cm) to the camera
   * @return Enable high dynamic range
   */
  bool get_hdr() const {
    return tof_user_config_get_hdr(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set high dynamic range enabled. Enable this when pixel saturation occurs.
   * This will only happen for retroreflectors or reflective objects close
   * (<20cm) to the camera
   * @param hdr Enable high dynamic range
   */
  void set_hdr(bool hdr) {
    return tof_user_config_set_hdr(this->ptr_, hdr, TOF_ERROR_HANDLER{});
  }
 
  /** Get the integration time
   * @return The integration time
   */
  IntegrationTime get_integration_time() const {
    return static_cast<IntegrationTime>(tof_user_config_get_integration_time(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set the integration time
   * @param int_time The integration time
   */
  void set_integration_time(IntegrationTime int_time) {
    return tof_user_config_set_integration_time(this->ptr_, static_cast<tof_integration_time>(int_time), TOF_ERROR_HANDLER{});
  }
 
  /** Get what the configuration is being optimized for
   * @return The user configuration strategy
   */
  Strategy get_strategy() const {
    return static_cast<Strategy>(tof_user_config_get_strategy(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Set what the configuration is being optimized for
   * @param strategy The user configuration strategy
   */
  void set_strategy(Strategy strategy) {
    return tof_user_config_set_strategy(this->ptr_, static_cast<tof_strategy>(strategy), TOF_ERROR_HANDLER{});
  }
 
  /** Get The camera channel, increment to support multi-camera usage
   * @return The channel number, set to 0, otherwise increment with number of
   * cameras.
   */
  int32_t get_channel() const {
    return tof_user_config_get_channel(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set The camera channel, increment to support multi-camera usage
   * @param channel The channel number, set to 0, otherwise increment with
   * number of cameras.
   */
  void set_channel(int32_t channel) {
    return tof_user_config_set_channel(this->ptr_, channel, TOF_ERROR_HANDLER{});
  }
 
};
 
/** Check whether hdr is possible with current camera config
 * @param config The camera config to check
 * @return Whether hdr is possible
 */
inline bool hdr_possible(CameraConfig &config) {
  return tof_hdr_possible(*reinterpret_cast<tof_camera_config_t*>(&config), TOF_ERROR_HANDLER{});
}
 
/** Check whether phase unwrap is possible with current camera config
 * @param config The camera config to check
 * @return Whether phase unwrap is possible
 */
inline bool phase_unwrap_possible(CameraConfig &config) {
  return tof_phase_unwrap_possible(*reinterpret_cast<tof_camera_config_t*>(&config), TOF_ERROR_HANDLER{});
}
 
/** Generate processing config based on camera configuration and calibration.
 * @param camera A camera
 */
inline void apply_default_processing_config(Camera &camera) {
  return tof_apply_default_processing_config(*reinterpret_cast<tof_camera_t*>(&camera), TOF_ERROR_HANDLER{});
}
 
} // tof
} // chronoptics
 
#endif