csf_camera.hpp

#ifndef _CHRONOPTICS_TOF_CSF_CAMERA_HPP_
#define _CHRONOPTICS_TOF_CSF_CAMERA_HPP_
 
#include <chronoptics/tof/csf_camera.h>
 
#include <chronoptics/tof/camera.hpp>
#include <chronoptics/tof/processing_config.hpp>
#include <chronoptics/tof/data.hpp>
 
namespace chronoptics {
namespace tof {
 
/** The csf camera class contains all the logic to generate a stream of depth
 * data from a csf file
*/
class CsfCamera : public Camera {
 public:
  /** Construct from pointer */
  CsfCamera(tof_csf_camera_t ptr = nullptr) : Camera(reinterpret_cast<tof_camera_t>(ptr)) {}
 
  /** Construct a csf camera from a csf file
   * @param processing_config A processing config
   * @param file_location File location of the csf file
   */
  CsfCamera(const ProcessingConfig &processing_config, StringView file_location) {
    this->ptr_ = reinterpret_cast<tof_camera_t>(tof_csf_camera_new(*reinterpret_cast<const tof_processing_config_t*>(&processing_config), file_location, TOF_ERROR_HANDLER{}));
  }
 
  /** Get frames at the specified position
   * @param frame_nr Which set of frames to process
   * @return Data frames
   */
  std::vector<Data> get_frames_at(size_t frame_nr) {
    auto ptr = reinterpret_cast<tof_csf_camera_t>(this->ptr_);
    size_t size = tof_csf_camera_get_frames_at(ptr, frame_nr, 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_csf_camera_get_frames_at(ptr, frame_nr, data, vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the location (count) of the current frame
   * @return The currenc frame location
   */
  size_t get_current_frame() const {
    auto ptr = reinterpret_cast<tof_csf_camera_t>(this->ptr_);
    return tof_csf_camera_get_current_frame(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Get the amount of frame lists this csf file can open/generate
   * @return The number of frames in the csf file
   */
  size_t get_frame_number() const {
    auto ptr = reinterpret_cast<tof_csf_camera_t>(this->ptr_);
    return tof_csf_camera_get_frame_number(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Get the FPS If the FPS is greater than 0 the time between subsequent
   * function calls to get_frames or get_frames_at will be limited to the FPS
   * This is done by sleeping on the next call to get_frames() if the time
   * between calls is smaller than the time duration dictated by the fps.
 
   * @return The frames per second
   */
  size_t get_fps() const {
    auto ptr = reinterpret_cast<tof_csf_camera_t>(this->ptr_);
    return tof_csf_camera_get_fps(ptr, TOF_ERROR_HANDLER{});
  }
 
  /** Set the FPS If the FPS is greater than 0 the time between subsequent
   * function calls to get_frames or get_frames_at will be limited to the FPS
   * This is done by sleeping on the next call to get_frames() if the time
   * between calls is smaller than the time duration dictated by the fps.
 
   * @param fps The frames per second
   */
  void set_fps(size_t fps) {
    auto ptr = reinterpret_cast<tof_csf_camera_t>(this->ptr_);
    return tof_csf_camera_set_fps(ptr, fps, TOF_ERROR_HANDLER{});
  }
 
};
 
} // tof
} // chronoptics
 
#endif