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{});
  }
 
};
 
/** 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