data.hpp

#ifndef _CHRONOPTICS_TOF_DATA_HPP_
#define _CHRONOPTICS_TOF_DATA_HPP_
 
#include <chronoptics/tof/data.h>
 
#include <chronoptics/tof/stream.hpp>
 
namespace chronoptics {
namespace tof {
 
/** The different matrix types
 */
enum class MatType {
  UINT8 = 0, /** A single unsigned byte */
  INT8 = 1, /** A single signed byte */
  UINT16 = 2, /** Two unsigned bytes */
  INT16 = 3, /** Two signed bytes */
  INT32 = 4, /** Four signed bytes */
  FLOAT = 5, /** Four bytes floating point value */
  DOUBLE = 6, /** Eight bytes floating point value */
  FLOAT_4 = 29, /** Four bytes floating point value with four channels */
  FLOAT_8 = 61, /** Four bytes floating point value with eight channels */
};
 
// Function signature of callback that's called after a tof_data object is destructed containing a user pointer
using user_pointer_destructed_fn = std::function<void(uint8_t*, size_t)>;
constexpr auto user_pointer_destructed_cb_handler = &detail::callback_handler<void, uint8_t*, size_t>;
 
/** This is the class that contains depth or image data
*/
class Data : public detail::Base<tof_data, tof_data_delete> {
 public:
  /** Construct from pointer */
  Data(tof_data_t ptr = nullptr) {
    this->ptr_ = ptr;
  }
 
  /** Get pointer to data
   * @return 
   */
  void* data() const {
    return tof_data_data(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get size of the data
   * @return The size
   */
  size_t size() const {
    return tof_data_size(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get user data that will get saved to csf file
   * @return Set user data
   */
  uint64_t get_user_data() const {
    return tof_data_get_user_data(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Set user data that will get saved to csf file
   * @param user_data Set user data
   */
  void set_user_data(uint64_t user_data) {
    return tof_data_set_user_data(this->ptr_, user_data, TOF_ERROR_HANDLER{});
  }
 
  /** Get the matrix type
   * @return The matrix type
   */
  MatType mat_type() const {
    return static_cast<MatType>(tof_data_mat_type(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Get the number of rows
   * @return Number of rows
   */
  int32_t rows() const {
    return tof_data_rows(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the number of columns
   * @return Number of columns
   */
  int32_t cols() const {
    return tof_data_cols(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** The frame counter
   * @return Frame count
   */
  uint16_t frame_count() const {
    return tof_data_frame_count(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the frame type
   * @return The frame type
   */
  FrameType frame_type() const {
    return static_cast<FrameType>(tof_data_frame_type(this->ptr_, TOF_ERROR_HANDLER{}));
  }
 
  /** Get the frame id
   * @return The frame id
   */
  uint32_t frame_id() const {
    return tof_data_frame_id(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the modulation frequency of the frame
   * @return The modulation frequency
   */
  float modulation_frequency() const {
    return tof_data_modulation_frequency(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the integration time of the frame
   * @return The integration time
   */
  uint32_t integration_time() const {
    return tof_data_integration_time(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get a bit array of the processing performed on the frame
   * @return A bit array
   */
  uint32_t process() const {
    return tof_data_process(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the scale used for integer frames, to get the original value divide by
   * scale
   * @return The scale
   */
  float scale() const {
    return tof_data_scale(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the addition used for integer frames, to get the original value
   * substract the addition
   * @return The addition
   */
  float addition() const {
    return tof_data_addition(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Get the temperature of various parts of the camera
   * @return Temperatures
   */
  std::vector<float> temperatures() const {
    size_t size = tof_data_temperatures(this->ptr_, nullptr, 0, TOF_ERROR_HANDLER{});
    std::vector<float> vec(size);
    size = tof_data_temperatures(this->ptr_, vec.data(), vec.size(), TOF_ERROR_HANDLER{});
    return vec;
  }
 
  /** Get the synchronization count
   * @return Sync count
   */
  uint8_t sync_count() const {
    return tof_data_sync_count(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** Check whether the data uses a pointer supplied by the user
   * @return Data allocated by user
   */
  bool user_allocated() const {
    return tof_data_user_allocated(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** The user data that was given in the add_user_pointer function
   * @return User pointer
   */
  void* user_pointer() const {
    return tof_data_user_pointer(this->ptr_, TOF_ERROR_HANDLER{});
  }
 
  /** The acceleration measured by the imu
   * @return Acceleration, x y z
   */
  std::array<int16_t, 3> acceleration() const {
    std::array<int16_t, 3> array;
    auto data = tof_data_acceleration(this->ptr_, TOF_ERROR_HANDLER{});
    std::copy(data, data + array.size(), array.data());
    return array;
  }
 
  /** The angular velocity measured by the imu
   * @return Angular velocity, x y z
   */
  std::array<int16_t, 3> angular_velocity() const {
    std::array<int16_t, 3> array;
    auto data = tof_data_angular_velocity(this->ptr_, TOF_ERROR_HANDLER{});
    std::copy(data, data + array.size(), array.data());
    return array;
  }
 
// Custom code
 
  /** Get the data at location p, templated because the data type can differ.
  * @param pos Location of the data to get
  * @returns Data of type T
  */
  template <typename T>
  const T& at(size_t pos) const {
    auto non_const = const_cast<tof::Data*>(this);
    return reinterpret_cast<const T*>(non_const->data())[pos];
  }
 
  /** Get the data at location p, templated because the data type can differ.
  * @param pos Location of the data to get
  * @returns Data of type T
  */
  template <typename T>
  T& at(size_t pos) {
    return reinterpret_cast<T*>(data())[pos];
  }
 
  /** Return iterator to beginning, templated because the data type can differ.
  * @returns Begin iterator to T
  */
  template <typename T>
  const T* begin() const {
    auto non_const = const_cast<tof::Data*>(this);
    return reinterpret_cast<const T*>(non_const->data());
  }
 
  /** Return iterator to beginning, templated because the data type can differ.
  * @returns Begin iterator to T
  */
  template <typename T>
  T* begin() {
    return reinterpret_cast<T*>(data());
  }
 
  /** Return iterator to end, templated because the data type can differ.
  * @returns End iterator to T
  */
  template <typename T>
  const T* end() const {
    auto non_const = const_cast<tof::Data*>(this);
    return reinterpret_cast<const T*>(non_const->data()) + rows() * cols();
  }
 
  /** Return iterator to end, templated because the data type can differ.
  * @returns End iterator to T
  */
  template <typename T>
  T* end() {
    return reinterpret_cast<T*>(data()) + rows() * cols();
  }
};
 
} // tof
} // chronoptics
 
#endif