camera.hpp

#ifndef _CHRONOPTICS_TOF_CAMERA_HPP_
#define _CHRONOPTICS_TOF_CAMERA_HPP_
 
#include <chronoptics/tof/camera.h>
 
#include <chronoptics/tof/stream.hpp>
#include <chronoptics/tof/processing_config.hpp>
#include <chronoptics/tof/data.hpp>
#include <chronoptics/tof/camera_config.hpp>
#include <chronoptics/tof/calibration.hpp>
 
namespace chronoptics {
namespace tof {
 
/** The main interface to the depth cameras
*/
class Camera : public detail::Base<tof_camera, tof_camera_delete> {
 public:
  /** Construct from pointer */
  Camera(tof_camera_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** Start streaming of the camera
   */
  void start() {
    return tof_camera_start(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Stop streaming of the camera
   */
  void stop() {
    return tof_camera_stop(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the camera is streaming
   * @return Is streaming
   */
  bool is_streaming() const {
    return tof_camera_is_streaming(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the camera is still connected
   * @return Is connected
   */
  bool is_connected() const {
    return tof_camera_is_connected(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the different output streams the camera can provide
   * @return The streams
   */
  std::vector<Stream> get_stream_list() const {
    size_t size = tof_camera_get_stream_list(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<Stream> vec;
    vec.reserve(size);
    for (size_t i = 0; i < size; i++)
      vec.emplace_back(static_cast<tof_stream_t>(nullptr));
    auto data = reinterpret_cast<tof_stream_t*>(vec.data());
    size = tof_camera_get_stream_list(this->ptr_, data, vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Set the streams that you want to get from the camera
   * @param streams The wanted streams
   */
  void set_stream_list(const std::vector<Stream> &streams) {
    return tof_camera_set_stream_list(this->ptr_, reinterpret_cast<const tof_stream_t*>(streams.data()), streams.size(), TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the stream list is set
   * @return Is stream list set
   */
  bool is_stream_list_set() const {
    return tof_camera_is_stream_list_set(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the stream list that is set on the camera
   * @return The currently set streams
   */
  std::vector<Stream> get_set_stream_list() {
    size_t size = tof_camera_get_set_stream_list(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<Stream> vec;
    vec.reserve(size);
    for (size_t i = 0; i < size; i++)
      vec.emplace_back(static_cast<tof_stream_t>(nullptr));
    auto data = reinterpret_cast<tof_stream_t*>(vec.data());
    size = tof_camera_get_set_stream_list(this->ptr_, data, vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the processing config of the camera
   * @return The processing config
   */
  ProcessingConfig get_process_config() 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_get_process_config(this->ptr_, TOF_ERROR_HANDLER{});
    return new_processing_config;
  }
 
  /** Set the processing config of the camera
   * @param config The processing config
   */
  void set_process_config(ProcessingConfig &config) {
    return tof_camera_set_process_config(this->ptr_, *reinterpret_cast<tof_processing_config_t*>(&config), TOF_ERROR_HANDLER{});
  }
 
  /** Check if the camera has frames available
   * @return Has frames available
   */
  bool has_frames() const {
    return tof_camera_has_frames(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get data frames from camera
   * @return Data frames
   */
  std::vector<Data> get_frames() {
    size_t size = tof_camera_get_frames(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<Data> vec;
    vec.reserve(size);
    for (size_t i = 0; i < size; i++)
      vec.emplace_back(static_cast<tof_data_t>(nullptr));
    auto data = reinterpret_cast<tof_data_t*>(vec.data());
    size = tof_camera_get_frames(this->ptr_, data, vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Clear the circular buffer used to store frames
   */
  void clear_buffer() {
    return tof_camera_clear_buffer(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the circular buffer size
   * @return The maximum number of sets of frames that is stored before the
   * oldest is overwritten
   */
  size_t get_buffer_size() const {
    return tof_camera_get_buffer_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the circular buffer size
   * @param size The maximum number of sets of frames that is stored before the
   * oldest is overwritten
   */
  void set_buffer_size(size_t size) {
    return tof_camera_set_buffer_size(this->ptr_, size, TOF_ERROR_HANDLER{});
  }
 
  /** Get the currently active camera config
   * @return The camera config
   */
  CameraConfig get_camera_config() 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_camera_get_camera_config(this->ptr_, TOF_ERROR_HANDLER{});
    return new_camera_config;
  }
 
  /** Get the serial number of the current camera
   * @return The serial
   */
  const char* get_serial() const {
    return tof_camera_get_serial(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get calibration from the camera
   * @return The calibration
   */
  Calibration get_calibration() const {
    Calibration new_calibration(static_cast<tof_calibration_t>(nullptr));
    auto ptr = reinterpret_cast<tof_calibration_t*>(&new_calibration);
    *ptr = tof_camera_get_calibration(this->ptr_, TOF_ERROR_HANDLER{});
    return new_calibration;
  }
 
  /** Get the amount of user pointers that can be stored
   * @return The capacity
   */
  size_t get_user_pointer_capacity() const {
    return tof_camera_get_user_pointer_capacity(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the amount of user pointers that can be stored
   * @param capacity The capacity
   */
  void set_user_pointer_capacity(size_t capacity) {
    return tof_camera_set_user_pointer_capacity(this->ptr_, capacity, TOF_ERROR_HANDLER{});
  }
 
  /** Add a pointer that will be filled with the specified data type. This
   * method allows you to fill data straight into your own data type without any
   * additional copying.
   * @param pointer The pointer to the data to write into
   * @param capacity The amount of data the pointer can hold
   * @param callback Callback that will be called when pointer is no longer in
   * use
   * @param frame_type The frame type that will be filled into the pointer
   */
  void add_user_pointer(uint8_t* pointer, size_t capacity, user_pointer_destructed_fn &callback, FrameType frame_type) {
    return tof_camera_add_user_pointer(this->ptr_, pointer, capacity, user_pointer_destructed_cb_handler, &callback, static_cast<tof_frame_type>(frame_type), TOF_ERROR_HANDLER{});
  }
 
  /** Add a pointer that will be filled with the specified data type. This
   * method allows you to fill data straight into your own data type without any
   * additional copying.
   * @param pointer The pointer to the data to write into
   * @param capacity The amount of data the pointer can hold
   * @param callback Callback that will be called when pointer is no longer in
   * use
   * @param callback_user_data User data that will be passed back when the function pointer is called
   * @param frame_type The frame type that will be filled into the pointer
   */
  void add_user_pointer(uint8_t* pointer, size_t capacity, tof_user_pointer_destructed_t callback, void* callback_user_data, FrameType frame_type) {
    return tof_camera_add_user_pointer(this->ptr_, pointer, capacity, callback, callback_user_data, static_cast<tof_frame_type>(frame_type), TOF_ERROR_HANDLER{});
  }
 
  /** Clear all user pointers in memory
   */
  void clear_user_pointers() {
    return tof_camera_clear_user_pointers(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the currently set configuration index
   * @return config index
   */
  uint32_t config_index() const {
    return tof_camera_config_index(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Switch to a different config in real time, depending on configuration and
   * camera, this can take 100-300ms
   * @param config_index Config index to switch to
   */
  void switch_config(uint32_t config_index) {
    return tof_camera_switch_config(this->ptr_, config_index, TOF_ERROR_HANDLER{});
  }
 
  /** Get the frame types that this camera can output
   * @return Possible frame types
   */
  std::vector<FrameType> possible_frame_types() const {
    size_t size = tof_camera_possible_frame_types(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<FrameType> vec(size);
    size = tof_camera_possible_frame_types(this->ptr_, reinterpret_cast<tof_frame_type*>(vec.data()), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the frame types the camera should output
   * @return Output frame types
   */
  std::vector<FrameType> get_output_frame_types() const {
    size_t size = tof_camera_get_output_frame_types(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<FrameType> vec(size);
    size = tof_camera_get_output_frame_types(this->ptr_, reinterpret_cast<tof_frame_type*>(vec.data()), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Set the frame types the camera should output
   * @param output_frame_types Output frame types
   */
  void set_output_frame_types(const std::vector<FrameType> &output_frame_types) {
    return tof_camera_set_output_frame_types(this->ptr_, reinterpret_cast<const tof_frame_type*>(output_frame_types.data()), output_frame_types.size(), TOF_ERROR_HANDLER{});
  }
 
  /** Check if multiple configurations are set. Switch config can only be used
   * when this is the case.
   * @return Is set
   */
  bool has_multiple_configurations() const {
    return tof_camera_has_multiple_configurations(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get all the set camera configurations
   * @return Multiple camera configurations
   */
  std::vector<CameraConfig> get_multiple_camera_configurations() const {
    size_t size = tof_camera_get_multiple_camera_configurations(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<CameraConfig> vec;
    vec.reserve(size);
    for (size_t i = 0; i < size; i++)
      vec.emplace_back(static_cast<tof_camera_config_t>(nullptr));
    auto data = reinterpret_cast<tof_camera_config_t*>(vec.data());
    size = tof_camera_get_multiple_camera_configurations(this->ptr_, data, vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get all the set processing configurations
   * @return Multiple processing configurations
   */
  std::vector<ProcessingConfig> get_multiple_processing_configurations() const {
    size_t size = tof_camera_get_multiple_processing_configurations(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<ProcessingConfig> vec;
    vec.reserve(size);
    for (size_t i = 0; i < size; i++)
      vec.emplace_back(static_cast<tof_processing_config_t>(nullptr));
    auto data = reinterpret_cast<tof_processing_config_t*>(vec.data());
    size = tof_camera_get_multiple_processing_configurations(this->ptr_, data, vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the name for each configuration
   * @return Names
   */
  std::vector<const char*> get_multiple_names() const {
    size_t size = tof_camera_get_multiple_names(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<const char*> vec(size);
    size = tof_camera_get_multiple_names(this->ptr_, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the description for each configuration
   * @return Descriptions
   */
  std::vector<const char*> get_multiple_descriptions() const {
    size_t size = tof_camera_get_multiple_descriptions(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<const char*> vec(size);
    size = tof_camera_get_multiple_descriptions(this->ptr_, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
};
 
/** Select the streams you want to get from the camera
 * @param camera A camera
 * @param frame_types The frame types to select
 * @return The amount of selected streams
 */
inline size_t select_streams(const Camera &camera, const std::vector<FrameType> &frame_types) {
  return tof_select_streams(*reinterpret_cast<const tof_camera_t*>(&camera), reinterpret_cast<const tof_frame_type*>(frame_types.data()), frame_types.size(), TOF_ERROR_HANDLER{});
}
 
/** Select the streams you want to get from the camera with the specified
 * modulation frequency
 * @param camera A camera
 * @param frame_types The frame types to select
 * @param mod_freq The modulation frequency to select
 * @return The amount of selected streams
 */
inline size_t select_streams_mod_freq(const Camera &camera, const std::vector<FrameType> &frame_types, float mod_freq) {
  return tof_select_streams_mod_freq(*reinterpret_cast<const tof_camera_t*>(&camera), reinterpret_cast<const tof_frame_type*>(frame_types.data()), frame_types.size(), mod_freq, TOF_ERROR_HANDLER{});
}
 
} // tof
} // chronoptics
 
#endif