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{}));
  }
 
  /** Construct the kea camera with a processing config generated by
   * default_processing from the camera 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(StringView serial) {
    this->ptr_ = reinterpret_cast<tof_camera_t>(tof_kea_camera_new_simple(serial, TOF_ERROR_HANDLER{}));
  }
 
  /** Construct the kea camera with the given processing and camera config.
   * @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.
   * @param camera_config The camera config
   */
  KeaCamera(const ProcessingConfig &processing_config, StringView serial, const CameraConfig &camera_config) {
    this->ptr_ = reinterpret_cast<tof_camera_t>(tof_kea_camera_new_both_configs(*reinterpret_cast<const tof_processing_config_t*>(&processing_config), serial, *reinterpret_cast<const tof_camera_config_t*>(&camera_config), 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 this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_on_camera_processing_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Get on camera processing
   * @return True on camera processing, false on host processing
   */
  bool get_on_camera_processing() const {
    auto this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_get_on_camera_processing(this_class, 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 this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_on_camera_processing(this_class, 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 this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_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_kea_camera_t>(this->ptr_);
    return tof_kea_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_kea_camera_t>(this->ptr_);
    return tof_kea_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_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_packet_size(this_class, size, TOF_ERROR_HANDLER{});
  }
 
  /** Set the camera config
   * @param camera_config Camera config
   */
  void set_camera_config(const CameraConfig &camera_config) {
    auto this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_camera_config(this_class, *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 this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_configurations(this_class, *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 this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_version(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_kea_camera_t>(this->ptr_);
    return tof_kea_camera_software_trigger_capable(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Software trigger the camera
   */
  void software_trigger() {
    auto this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_software_trigger(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_kea_camera_t>(this->ptr_);
    return tof_kea_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_kea_camera_t>(this->ptr_);
    return tof_kea_camera_remote_update(this_class, file_location, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether camera supports multiple configurations
   * @return Multiple configurations possible
   */
  bool multiple_configurations_possible() const {
    auto this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_multiple_configurations_possible(this_class, TOF_ERROR_HANDLER{});
  }
 
  /** Set multiple configurations
   * @param camera_configs Camera configurations
   * @param pro_configs Processing configurations
   */
  void set_multiple_configurations(const std::vector<CameraConfig> &camera_configs, const std::vector<ProcessingConfig> &pro_configs) {
    auto this_class = reinterpret_cast<tof_kea_camera_t>(this->ptr_);
    return tof_kea_camera_set_multiple_configurations(this_class, reinterpret_cast<const tof_camera_config_t*>(camera_configs.data()), camera_configs.size(), reinterpret_cast<const tof_processing_config_t*>(pro_configs.data()), pro_configs.size(), 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;
}
 
/** Construct a kea camera using the gige interface. This could be useful in two
 * cases. The first is when the camera is connected with both usb and ethernet
 * but you want to use ethernet. The second is when for some reason the default
 * maximum packet size is too large.
 * @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.
 * @param packet_size The packet size to use for communication over ethernet
 * @return A kea camera
 */
inline KeaCamera create_kea_camera_gige(const ProcessingConfig &processing_config, StringView serial, uint16_t packet_size = 1472) {
  KeaCamera new_kea_camera(static_cast<tof_kea_camera_t>(nullptr));
  auto ptr = reinterpret_cast<tof_kea_camera_t*>(&new_kea_camera);
  *ptr = tof_create_kea_camera_gige(*reinterpret_cast<const tof_processing_config_t*>(&processing_config), serial, packet_size, TOF_ERROR_HANDLER{});
  return new_kea_camera;
}
 
} // tof
} // chronoptics
 
#endif