kea_camera.hpp

#ifndef _CHRONOPTICS_TOF_KEA_CAMERA_HPP_
#define _CHRONOPTICS_TOF_KEA_CAMERA_HPP_
 
#include <chronoptics/tof/kea_camera.h>
 
#include <chronoptics/tof/camera.hpp>
#include <chronoptics/tof/processing_config.hpp>
#include <chronoptics/tof/camera_config.hpp>
 
namespace chronoptics {
namespace tof {
 
/** The main interface to the kea camera
*/
class KeaCamera : public Camera {
 public:
  /** Construct from pointer */
  KeaCamera(tof_kea_camera_t ptr = nullptr) : Camera(reinterpret_cast<tof_camera_t>(ptr)) {}
 
  /** Construct the kea camera
   * @param processing_config The processing config
   * @param serial The serial number of the camera to connect to, if the camera
   * is available over both usb and gige it will be connected over usb. If an
   * empty string is supplied the camera will connect to the first usb camera,
   * if no usb camera is connected it will connect to the first gige camera that
   * replies (this reply time is random, so you might connect to a different
   * camera each time if you've got multiple cameras connected to your network).
   * If no camera is found with the given serial number a nullptr and error is
   * returned.
   */
  KeaCamera(const ProcessingConfig &processing_config, StringView serial) {
    this->ptr_ = reinterpret_cast<tof_camera_t>(tof_kea_camera_new(*reinterpret_cast<const tof_processing_config_t*>(&processing_config), serial, TOF_ERROR_HANDLER{}));
  }
 
  /** Check whether this kea camera can do on camera processing
   * @return On camera processing capable
   */
  bool on_camera_processing_capable() const {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_on_camera_processing_capable(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Get on camera processing
   * @return True on camera processing, false on host processing
   */
  bool get_on_camera_processing() const {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_get_on_camera_processing(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Set on camera processing
   * @param on_camera_processing True on camera processing, false on host
   * processing
   */
  void set_on_camera_processing(bool on_camera_processing) {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_on_camera_processing(ptr, on_camera_processing, 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 ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_get_delay(ptr, 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 ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_delay(ptr, delay, TOF_ERROR_HANDLER{});
  }
 
  /** Get maximum size of each network packet transmitted
   * @return Packet size in bytes
   */
  uint16_t get_packet_size() const {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_get_packet_size(ptr, 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 ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_packet_size(ptr, size, TOF_ERROR_HANDLER{});
  }
 
  /** Set the camera config
   * @param camera_config Camera config
   */
  void set_camera_config(const CameraConfig &camera_config) {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_camera_config(ptr, *reinterpret_cast<const tof_camera_config_t*>(&camera_config), TOF_ERROR_HANDLER{});
  }
 
  /** Set both the camera and processing config
   * @param camera_config Camera config
   * @param processing_config Processing config
   */
  void set_configurations(const CameraConfig &camera_config, const ProcessingConfig &processing_config) {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_configurations(ptr, *reinterpret_cast<const tof_camera_config_t*>(&camera_config), *reinterpret_cast<const tof_processing_config_t*>(&processing_config), TOF_ERROR_HANDLER{});
  }
 
  /** Get the tof library version running on the camera
   * @return Version
   */
  const char* version() {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_version(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the camera is capable of software trigger
   * @return Software trigger capable
   */
  bool software_trigger_capable() {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_software_trigger_capable(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Software trigger the camera
   */
  void software_trigger() {
    auto ptr = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_software_trigger(ptr, TOF_ERROR_HANDLER{});
  }
 
};
 
/** Simple class containing information about found kea cameras
*/
class DiscoveredKea : public detail::Base<tof_discovered_kea, tof_discovered_kea_delete> {
 public:
  /** Construct from pointer */
  DiscoveredKea(tof_discovered_kea_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** The serial
   * @return Serial
   */
  const char* serial() const {
    return tof_discovered_kea_serial(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Additional information about the discovered camera
   * @return Additional information
   */
  const char* info() const {
    return tof_discovered_kea_info(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
};
 
/** Discover all available kea cameras
 * @return All available kea cameras
 */
inline std::vector<DiscoveredKea> discover_kea_cameras() {
  size_t size = tof_discover_kea_cameras(nullptr, 0, TOF_ERROR_HANDLER{});
  std::vector<DiscoveredKea> vec;
  vec.reserve(size);
  for (size_t i = 0; i < size; i++)
    vec.emplace_back(static_cast<tof_discovered_kea_t>(nullptr));
  auto data = reinterpret_cast<tof_discovered_kea_t*>(vec.data());
  size = tof_discover_kea_cameras(data, vec.size(), TOF_ERROR_HANDLER{});
  return vec;
}
 
} // tof
} // chronoptics
 
#endif