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;
  }
 
  /** 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;
  }
 
  /** 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;
  }
 
  /** Whether output frame types have been set
   * @return Output frame types set
   */
  bool output_frame_types_set() {
    return tof_camera_output_frame_types_set(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** 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;
  }
 
};
 
/** A persistent ip data structure
*/
class PersistentIp : public detail::Base<tof_persistent_ip, tof_persistent_ip_delete> {
 public:
  /** Construct from pointer */
  PersistentIp(tof_persistent_ip_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** Create persistent ip
   * @param ip IP address
   * @param netmask Netmask
   * @param gateway Gateway
   * @param enabled Enable or disable persistent ip
   */
  PersistentIp(StringView ip, StringView netmask, StringView gateway, bool enabled) : PersistentIp(tof_persistent_ip_new(ip, netmask, gateway, enabled, TOF_ERROR_HANDLER{})) {}
 
  /** Get the IP address
   * @return the IP address
   */
  const char* get_ip() const {
    return tof_persistent_ip_get_ip(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the IP address
   * @param ip the IP address
   */
  void set_ip(StringView ip) {
    return tof_persistent_ip_set_ip(this->ptr_, ip, TOF_ERROR_HANDLER{});
  }
 
  /** Get the netmask
   * @return The netmask
   */
  const char* get_netmask() const {
    return tof_persistent_ip_get_netmask(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the netmask
   * @param netmask The netmask
   */
  void set_netmask(StringView netmask) {
    return tof_persistent_ip_set_netmask(this->ptr_, netmask, TOF_ERROR_HANDLER{});
  }
 
  /** Get the gateway
   * @return The gateway
   */
  const char* get_gateway() const {
    return tof_persistent_ip_get_gateway(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set the gateway
   * @param gateway The gateway
   */
  void set_gateway(StringView gateway) {
    return tof_persistent_ip_set_gateway(this->ptr_, gateway, TOF_ERROR_HANDLER{});
  }
 
  /** Get if persistent ip is enabled
   * @return Is enabled
   */
  bool get_enabled() const {
    return tof_persistent_ip_get_enabled(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set if persistent ip is enabled
   * @param enabled Is enabled
   */
  void set_enabled(bool enabled) {
    return tof_persistent_ip_set_enabled(this->ptr_, enabled, TOF_ERROR_HANDLER{});
  }
 
};
 
/** Functions shared across all live cameras
*/
class LiveCamera : public Camera {
 public:
  /** Construct from pointer */
  LiveCamera(tof_live_camera_t ptr = nullptr) : Camera(reinterpret_cast<tof_camera_t>(ptr)) {}
 
  /** Get the tof library version running on the camera
   * @return Version
   */
  const char* version() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_version(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the camera is capable of updating remotely
   * @return Remote update capable
   */
  bool remote_update_capable() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_remote_update_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Update the camera remotely. After uploading the update file the function
   * will return. If a correct update file was uploaded, the camera will flash
   * the update and reboot. This generally takes about a minute. The camera can
   * also be updated via a web interface by visiting the ip address of the
   * camera on port 8080, for example http://192.168.1.208:8080
   * @param file_location Location of the update file
   */
  void remote_update(StringView file_location) {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_remote_update(this_class, file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Whether the camera is capable of setting persistent ip
   * @return Persistent ip capable
   */
  bool persistent_ip_capable() const {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_persistent_ip_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Get the current persistent ip settings
   * @return Persistent IP
   */
  PersistentIp get_persistent_ip() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    PersistentIp new_persistent_ip(static_cast<tof_persistent_ip_t>(nullptr));
    auto ptr = reinterpret_cast<tof_persistent_ip_t*>(&new_persistent_ip);
    *ptr = tof_live_camera_get_persistent_ip(this_class, TOF_ERROR_HANDLER{});
    return new_persistent_ip;
  }
 
  /** Set the persistent ip settings. To activate persistent ip settings run
   * apply_persistent_ip. 
   * @param persistent_ip The persistent ip
   */
  void set_persistent_ip(const PersistentIp &persistent_ip) {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_set_persistent_ip(this_class, *reinterpret_cast<const tof_persistent_ip_t*>(&persistent_ip), TOF_ERROR_HANDLER{});
  }
 
  /** Whether the camera is capable of applying the persistent ip
   * @return Capable
   */
  bool apply_persistent_ip_capable() const {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_apply_persistent_ip_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Apply persistent ip by rebooting the camera, power cycling the camera is
   * discouraged because the applied ip settings might not stick.
   */
  void apply_persistent_ip() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_apply_persistent_ip(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the camera is capable of software trigger
   * @return Software trigger capable
   */
  bool software_trigger_capable() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_software_trigger_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Software trigger the camera
   */
  void software_trigger() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_software_trigger(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Get delay between network packets
   * @return The delay, depending on the camera software it is in nanoseconds or
   * in cpu instruction
   */
  uint32_t get_delay() const {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_get_delay(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Set delay between network packets
   * @param delay The delay, depending on the camera software it is in
   * nanoseconds or in cpu instruction
   */
  void set_delay(uint32_t delay) {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_set_delay(this_class, delay, TOF_ERROR_HANDLER{});
  }
 
  /** Get maximum size of each network packet transmitted
   * @return Packet size in bytes
   */
  uint16_t get_packet_size() const {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_get_packet_size(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Set maximum size of each network packet transmitted
   * @param size Packet size in bytes
   */
  void set_packet_size(uint16_t size) {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_set_packet_size(this_class, size, TOF_ERROR_HANDLER{});
  }
 
  /** Whether the camera is capable of returning temperatures
   * @return Capable
   */
  bool get_temperatures_capable() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_get_temperatures_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Get the current on camera temperatures
   * @return Temperatures
   */
  std::vector<float> get_temperatures() {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    size_t size = tof_live_camera_get_temperatures(this_class, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<float> vec(size);
    size = tof_live_camera_get_temperatures(this_class, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get voltage level on given pin
   * @param pin Pin
   * @return Voltage 3.3V
   */
  bool get_gpio(size_t pin) {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_get_gpio(this_class, pin, TOF_ERROR_HANDLER{});
  }
 
  /** Set voltage level on given pin
   * @param pin Pin
   * @param level Voltage level
   */
  void set_gpio(size_t pin, bool level) {
    auto this_class = reinterpret_cast<tof_live_camera_t>(this->ptr_);
    return tof_live_camera_set_gpio(this_class, pin, level, TOF_ERROR_HANDLER{});
  }
 
};
 
} // tof
} // chronoptics
 
#endif