camera_config.hpp

#ifndef _CHRONOPTICS_TOF_CAMERA_CONFIG_HPP_
#define _CHRONOPTICS_TOF_CAMERA_CONFIG_HPP_
 
#include <chronoptics/tof/camera_config.h>
 
#include <chronoptics/tof/processing_config.hpp>
 
namespace chronoptics {
namespace tof {
 
/** ToF cameras made by Chronoptics
 */
enum class CameraType {
  OPT8241 = 1, /** Original Moa and first generation Kea camera with opt sensor */
  OPT8241_EXT = 4, /** First generation Kea camera with opt sensor and external modulation */
  MLX75027 = 6, /** Newer generation Kea cameras with mlx sensor */
};
 
/** Operating mode of the cameras' sensor
 */
enum class SensorMode {
  NORMAL = 0, /** Normal mode ToF sensor mod (A - B) */
  COMMON = 1, /** Common mode (A + B) */
  EXTERNAL_DEMOD = 4, /** Use external demodulation */
  EXTERNAL_SIGNAL = 5, /** Use the light source as an input */
  TAP_A = 8, /** Only tap a is read out */
  TAP_B = 9, /** Only tap b is read out */
  TAP_AB = 10, /** Both A and B tap are read out, this means double the data transmission */
};
 
/** Region of interest
*/
class Roi : public detail::Base<tof_roi, tof_roi_delete> {
 public:
  /** Construct from pointer */
  Roi(tof_roi_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** Get the number of rows in the image sensor
   * @return Number of rows
   */
  int32_t sensor_rows() const {
    return tof_roi_sensor_rows(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of columns in the image sensor
   * @return Number of columsn
   */
  int32_t sensor_cols() const {
    return tof_roi_sensor_cols(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the row offset in pixels
   * @return Row offset
   */
  int32_t get_row_offset() const {
    return tof_roi_get_row_offset(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the row offset in pixels
   * @param row_offset Row offset
   */
  void set_row_offset(int32_t row_offset) {
    return tof_roi_set_row_offset(this->ptr_, row_offset, TOF_ERROR_HANDLER{});
  }
 
  /** Get the column offset in pixels
   * @return Column offset
   */
  int32_t get_col_offset() const {
    return tof_roi_get_col_offset(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the column offset in pixels
   * @param col_offset Column offset
   */
  void set_col_offset(int32_t col_offset) {
    return tof_roi_set_col_offset(this->ptr_, col_offset, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of rows in the output image
   * @return Image rows
   */
  int32_t get_img_rows() const {
    return tof_roi_get_img_rows(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the number of rows in the output image
   * @param img_rows Image rows
   */
  void set_img_rows(int32_t img_rows) {
    return tof_roi_set_img_rows(this->ptr_, img_rows, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of columns in the output image
   * @return Image columns
   */
  int32_t get_img_cols() const {
    return tof_roi_get_img_cols(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the number of columns in the output image
   * @param img_cols Image columns
   */
  void set_img_cols(int32_t img_cols) {
    return tof_roi_set_img_cols(this->ptr_, img_cols, TOF_ERROR_HANDLER{});
  }
 
};
 
/** This class allows you to view/edit the camera settings
*/
class CameraConfig : public detail::Base<tof_camera_config, tof_camera_config_delete> {
 public:
  /** Construct from pointer */
  CameraConfig(tof_camera_config_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** Read camera config from disk
   * @param file_location Location of camera config on disk
   */
  CameraConfig(StringView file_location) {
    this->ptr_ = tof_camera_config_new_from_disk(file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Write camera config to disk
   * @param file_location Location to save camera config to
   */
  void write(StringView file_location) const {
    return tof_camera_config_write(this->ptr_, file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Get the camera type
   * @return Camera type
   */
  CameraType get_type() const {
    return static_cast<CameraType>(tof_camera_config_get_type(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Reset camera config to default
   */
  void reset() {
    return tof_camera_config_reset(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the amount of frames in the config. Having multiple frames allows you
   * to configure different modulation frequencies or integration times per
   * frame.
   * @return Frame size
   */
  size_t frame_size() const {
    return tof_camera_config_frame_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Add a default frame to the camera config
   */
  void add_frame() {
    return tof_camera_config_add_frame(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Generate default processing config from camera configuration
   * @return The default processing config
   */
  ProcessingConfig default_processing() const {
    ProcessingConfig new_processing_config(static_cast<tof_processing_config_t>(nullptr));
    auto ptr = reinterpret_cast<tof_processing_config_t*>(&new_processing_config);
    *ptr = tof_camera_config_default_processing(this->ptr_, TOF_ERROR_HANDLER{});
    return new_processing_config;
  }
 
  /** Erase specified frame
   * @param frame Frame number
   */
  void erase_frame(size_t frame) {
    return tof_camera_config_erase_frame(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Get the phase shifts. Value ranges from 0.0 to 1.0 which translates to 0-2
   * pi
   * @param frame Frame number
   * @return Phase shifts
   */
  std::vector<float> get_phase_shifts(size_t frame) const {
    size_t size = tof_camera_config_get_phase_shifts(this->ptr_, frame, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<float> vec(size);
    size = tof_camera_config_get_phase_shifts(this->ptr_, frame, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Set the phase shifts. Value ranges from 0.0 to 1.0 which translates to 0-2
   * pi
   * @param frame Frame number
   * @param phase_shifts Phase shifts
   */
  void set_phase_shifts(size_t frame, const std::vector<float> &phase_shifts) {
    return tof_camera_config_set_phase_shifts(this->ptr_, frame, phase_shifts.data(), phase_shifts.size(), TOF_ERROR_HANDLER{});
  }
 
  /** Get the integration time
   * @param frame Frame number
   * @return Integration time in micro seconds
   */
  std::vector<uint32_t> get_integration_time(size_t frame) const {
    size_t size = tof_camera_config_get_integration_time(this->ptr_, frame, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<uint32_t> vec(size);
    size = tof_camera_config_get_integration_time(this->ptr_, frame, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Set the integration time
   * @param frame Frame number
   * @param integration_time Integration time in micro seconds
   */
  void set_integration_time(size_t frame, const std::vector<uint32_t> &integration_time) {
    return tof_camera_config_set_integration_time(this->ptr_, frame, integration_time.data(), integration_time.size(), TOF_ERROR_HANDLER{});
  }
 
  /** Get the mode to set the camera's depth sensor to
   * @param frame Frame number
   * @return Sensor mode
   */
  SensorMode get_sensor_mode(size_t frame) const {
    return static_cast<SensorMode>(tof_camera_config_get_sensor_mode(this->ptr_, frame, TOF_ERROR_HANDLER{}));
  }
 
  /** Set the mode to set the camera's depth sensor to
   * @param frame Frame number
   * @param sensor_mode Sensor mode
   */
  void set_sensor_mode(size_t frame, SensorMode sensor_mode) {
    return tof_camera_config_set_sensor_mode(this->ptr_, frame, static_cast<tof_sensor_mode>(sensor_mode), TOF_ERROR_HANDLER{});
  }
 
  /** Get the modulation frequency
   * @param frame Frame number
   * @return Modulation frequency in MHz
   */
  float get_modulation_frequency(size_t frame) const {
    return tof_camera_config_get_modulation_frequency(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set the modulation frequency
   * @param frame Frame number
   * @param modulation_frequency Modulation frequency in MHz
   */
  void set_modulation_frequency(size_t frame, float modulation_frequency) {
    return tof_camera_config_set_modulation_frequency(this->ptr_, frame, modulation_frequency, TOF_ERROR_HANDLER{});
  }
 
  /** Get the duty cycle
   * @param frame Frame number
   * @return Duty cycle 0.0 to 1.0
   */
  float get_duty_cycle(size_t frame) const {
    return tof_camera_config_get_duty_cycle(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set the duty cycle
   * @param frame Frame number
   * @param duty_cycle Duty cycle 0.0 to 1.0
   */
  void set_duty_cycle(size_t frame, float duty_cycle) {
    return tof_camera_config_set_duty_cycle(this->ptr_, frame, duty_cycle, TOF_ERROR_HANDLER{});
  }
 
  /** Get the region of interest
   * @param frame Frame number
   * @return Region of interest
   */
  Roi get_roi(size_t frame) const {
    Roi new_roi(static_cast<tof_roi_t>(nullptr));
    auto ptr = reinterpret_cast<tof_roi_t*>(&new_roi);
    *ptr = tof_camera_config_get_roi(this->ptr_, frame, TOF_ERROR_HANDLER{});
    return new_roi;
  }
 
  /** Set the region of interest
   * @param frame Frame number
   * @param roi Region of interest
   */
  void set_roi(size_t frame, Roi &roi) {
    return tof_camera_config_set_roi(this->ptr_, frame, *reinterpret_cast<tof_roi_t*>(&roi), TOF_ERROR_HANDLER{});
  }
 
  /** Get the amount of binning
   * @param frame Frame number
   * @return Amount of binning 0=none, 1=x2, 2=x4, 3=x8
   */
  uint8_t get_binning(size_t frame) const {
    return tof_camera_config_get_binning(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set the amount of binning
   * @param frame Frame number
   * @param binning Amount of binning 0=none, 1=x2, 2=x4, 3=x8
   */
  void set_binning(size_t frame, uint8_t binning) {
    return tof_camera_config_set_binning(this->ptr_, frame, binning, TOF_ERROR_HANDLER{});
  }
 
  /** Get is the image flipped
   * @param frame Frame number
   * @return Image is flipped
   */
  bool get_flip(size_t frame) const {
    return tof_camera_config_get_flip(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set is the image flipped
   * @param frame Frame number
   * @param flip Image is flipped
   */
  void set_flip(size_t frame, bool flip) {
    return tof_camera_config_set_flip(this->ptr_, frame, flip, TOF_ERROR_HANDLER{});
  }
 
  /** Get is the image mirrored
   * @param frame Frame number
   * @return Image is mirrored
   */
  bool get_mirror(size_t frame) const {
    return tof_camera_config_get_mirror(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set is the image mirrored
   * @param frame Frame number
   * @param mirror Image is mirrored
   */
  void set_mirror(size_t frame, bool mirror) {
    return tof_camera_config_set_mirror(this->ptr_, frame, mirror, TOF_ERROR_HANDLER{});
  }
 
  /** Get the image sensor gain
   * @return Image sensor gain
   */
  float get_gain() const {
    return tof_camera_config_get_gain(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the image sensor gain
   * @param gain Image sensor gain
   */
  void set_gain(float gain) {
    return tof_camera_config_set_gain(this->ptr_, gain, TOF_ERROR_HANDLER{});
  }
 
  /** Get the kind of camera synchronization
   * @return The kind of sync mode. 0 waits for the vsync pulse before starting
   * the next frame. 1 optional vsync 2 is no frame syncing
   */
  int32_t get_sync_mode() const {
    return tof_camera_config_get_sync_mode(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the kind of camera synchronization
   * @param sync_mode The kind of sync mode. 0 waits for the vsync pulse before
   * starting the next frame. 1 optional vsync 2 is no frame syncing
   */
  void set_sync_mode(int32_t sync_mode) {
    return tof_camera_config_set_sync_mode(this->ptr_, sync_mode, TOF_ERROR_HANDLER{});
  }
 
  /** Get the maximum integration time possible
   * @param frame Frame number
   * @return Maximum integration time in micro seconds
   */
  std::vector<uint32_t> maximum_integration_time(size_t frame) {
    size_t size = tof_camera_config_maximum_integration_time(this->ptr_, frame, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<uint32_t> vec(size);
    size = tof_camera_config_maximum_integration_time(this->ptr_, frame, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the DAC gain
   * @return The DAC gain
   */
  std::vector<uint16_t> get_dac() const {
    size_t size = tof_camera_config_get_dac(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<uint16_t> vec(size);
    size = tof_camera_config_get_dac(this->ptr_, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Set the DAC gain
   * @param dac The DAC gain
   */
  void set_dac(const std::vector<uint16_t> &dac) {
    return tof_camera_config_set_dac(this->ptr_, dac.data(), dac.size(), TOF_ERROR_HANDLER{});
  }
 
  /** Get the mipi speed for the MLX75027
   * @return The mipi speed. Can only be the values 300, 600, 704, 800 and 960
   */
  int32_t get_mlx_mipi_speed() const {
    return tof_camera_config_get_mlx_mipi_speed(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the mipi speed for the MLX75027
   * @param mipi_speed The mipi speed. Can only be the values 300, 600, 704, 800
   * and 960
   */
  void set_mlx_mipi_speed(int32_t mipi_speed) {
    return tof_camera_config_set_mlx_mipi_speed(this->ptr_, mipi_speed, TOF_ERROR_HANDLER{});
  }
 
  /** Get the preheat time
   * @param frame Frame number
   * @return The preheat time
   */
  uint32_t get_mlx_preheat(size_t frame) const {
    return tof_camera_config_get_mlx_preheat(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set the preheat time
   * @param frame Frame number
   * @param preheat The preheat time
   */
  void set_mlx_preheat(size_t frame, uint32_t preheat) {
    return tof_camera_config_set_mlx_preheat(this->ptr_, frame, preheat, TOF_ERROR_HANDLER{});
  }
 
  /** Get enable preheat
   * @param frame Frame number
   * @return Enable preheating
   */
  bool get_mlx_preheat_enable(size_t frame) const {
    return tof_camera_config_get_mlx_preheat_enable(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set enable preheat
   * @param frame Frame number
   * @param enable Enable preheating
   */
  void set_mlx_preheat_enable(size_t frame, bool enable) {
    return tof_camera_config_set_mlx_preheat_enable(this->ptr_, frame, enable, TOF_ERROR_HANDLER{});
  }
 
  /** Set the Nios hex for the keaB cameras
   * @param file_location File location of the nios hex file
   */
  void set_opt_kea_nios_hex(StringView file_location) {
    return tof_camera_config_set_opt_kea_nios_hex(this->ptr_, file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Get the opt8241 number of sub and quad frames
   * @return Number of subs and quads respectively
   */
  std::array<int32_t, 2> get_opt_kea_sub_quad() const {
    std::array<int32_t, 2> array;
    auto data = tof_camera_config_get_opt_kea_sub_quad(this->ptr_, TOF_ERROR_HANDLER{});
    std::copy(data, data + array.size(), array.data());
    return array;
  }
 
  /** Set the opt8241 number of sub and quad frames
   * @param subs_quads Number of subs and quads respectively
   */
  void set_opt_kea_sub_quad(const std::array<int32_t, 2> &subs_quads) {
    return tof_camera_config_set_opt_kea_sub_quad(this->ptr_, subs_quads.data(), TOF_ERROR_HANDLER{});
  }
 
  /** Get the processing configuration for when the depth is calculated on
   * camera
   * @return The pipeline processing to be done on camera
   */
  ProcessingConfig get_processing() const {
    ProcessingConfig new_processing_config(static_cast<tof_processing_config_t>(nullptr));
    auto ptr = reinterpret_cast<tof_processing_config_t*>(&new_processing_config);
    *ptr = tof_camera_config_get_processing(this->ptr_, TOF_ERROR_HANDLER{});
    return new_processing_config;
  }
 
  /** Set the processing configuration for when the depth is calculated on
   * camera
   * @param processing The pipeline processing to be done on camera
   */
  void set_processing(ProcessingConfig &processing) {
    return tof_camera_config_set_processing(this->ptr_, *reinterpret_cast<tof_processing_config_t*>(&processing), TOF_ERROR_HANDLER{});
  }
 
  /** Get the time this depth frame will take. This is useful when you want a
   * steady but lower framerate.
   * @param frame Frame number
   * @return Frame time in micro seconds
   */
  uint32_t get_frame_time(size_t frame) const {
    return tof_camera_config_get_frame_time(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set the time this depth frame will take. This is useful when you want a
   * steady but lower framerate.
   * @param frame Frame number
   * @param frame_time Frame time in micro seconds
   */
  void set_frame_time(size_t frame, uint32_t frame_time) {
    return tof_camera_config_set_frame_time(this->ptr_, frame, frame_time, TOF_ERROR_HANDLER{});
  }
 
  /** Get phase offset for illumination and sensor. The phase offsets are two
   * floating point values corresponding to the phase delay for the illumination
   * and sensor respectively. The values should be between 0.0 and 1.0 where 0.0
   * is no phase offset and 1.0 is 360 degree phase offset
   * @param frame Frame number
   * @return Image is mirrored
   */
  std::array<float, 2> get_global_phase_offset(size_t frame) const {
    std::array<float, 2> array;
    auto data = tof_camera_config_get_global_phase_offset(this->ptr_, frame, TOF_ERROR_HANDLER{});
    std::copy(data, data + array.size(), array.data());
    return array;
  }
 
  /** Set phase offset for illumination and sensor. The phase offsets are two
   * floating point values corresponding to the phase delay for the illumination
   * and sensor respectively. The values should be between 0.0 and 1.0 where 0.0
   * is no phase offset and 1.0 is 360 degree phase offset
   * @param frame Frame number
   * @param phase_offset Image is mirrored
   */
  void set_global_phase_offset(size_t frame, const std::array<float, 2> &phase_offset) {
    return tof_camera_config_set_global_phase_offset(this->ptr_, frame, phase_offset.data(), TOF_ERROR_HANDLER{});
  }
 
  /** Get the illumination mode
   * @param frame Frame number
   * @return Illumination mode. 0 is actively modulating, 2 is active low
   * (illumination disabled) and 3 is active high
   */
  uint8_t get_illumination_mode(size_t frame) const {
    return tof_camera_config_get_illumination_mode(this->ptr_, frame, TOF_ERROR_HANDLER{});
  }
 
  /** Set the illumination mode
   * @param frame Frame number
   * @param illumination_mode Illumination mode. 0 is actively modulating, 2 is
   * active low (illumination disabled) and 3 is active high
   */
  void set_illumination_mode(size_t frame, uint8_t illumination_mode) {
    return tof_camera_config_set_illumination_mode(this->ptr_, frame, illumination_mode, TOF_ERROR_HANDLER{});
  }
 
  /** Get the image offsets. This configuration is only for sensors with column
   * phase offsets.
   * @param frame Frame number
   * @return The image offset per column in 0.0 to 1.0
   */
  std::vector<float> get_image_offsets(size_t frame) const {
    size_t size = tof_camera_config_get_image_offsets(this->ptr_, frame, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<float> vec(size);
    size = tof_camera_config_get_image_offsets(this->ptr_, frame, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Set the image offsets. This configuration is only for sensors with column
   * phase offsets.
   * @param frame Frame number
   * @param image_offsets The image offset per column in 0.0 to 1.0
   */
  void set_image_offsets(size_t frame, const std::vector<float> &image_offsets) {
    return tof_camera_config_set_image_offsets(this->ptr_, frame, image_offsets.data(), image_offsets.size(), TOF_ERROR_HANDLER{});
  }
 
  /** Get the width of the rgb sensor
   * @return Width in pixels
   */
  size_t get_rgb_width() {
    return tof_camera_config_get_rgb_width(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the height of the rgb sensor
   * @return Height in pixels
   */
  size_t get_rgb_height() {
    return tof_camera_config_get_rgb_height(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
};
 
} // tof
} // chronoptics
 
#endif