abstract-camera.hpp

Go to the documentation of this file.

#ifndef OPENEV_DEVICES_ABSTRACT_CAMERA_HPP
#define OPENEV_DEVICES_ABSTRACT_CAMERA_HPP
 
#include "openev/containers/queue.hpp"
#include "openev/containers/vector.hpp"
#include <atomic>
#include <math.h>
#include <opencv2/core/mat.hpp>
#include <opencv2/core/mat.inl.hpp>
#include <opencv2/core/types.hpp>
#include <ostream>
#include <queue>
#include <stdint.h>
#include <vector>
 
typedef struct caer_device_handle {
  uint16_t deviceType;
} *caerDeviceHandle;
 
namespace ev {
 
namespace unit {
template <typename T>
constexpr double us(const T x) { return static_cast<double>(x) * 1e-6; }
} // namespace unit
 
constexpr double EARTH_GRAVITY = 9.80665;
constexpr double DEG2RAD = M_PI / 180.0;
constexpr double SCALE_16B_8B = 1.0 / 256.0;
 
struct BiasValue {
  uint8_t coarse;
  uint8_t fine;
  [[nodiscard]] friend std::ostream &operator<<(std::ostream &os, const struct BiasValue &value) {
    os << "Coarse: " << static_cast<int>(value.coarse) << ", Fine: " << static_cast<int>(value.fine);
    return os;
  }
} __attribute__((aligned(2)));

class StampedMat : public cv::Mat {
public:
  double t;
};
using StampedMatVector = std::vector<StampedMat>;
using StampedMatQueue = std::queue<StampedMat>;

struct xyz_t {
  double x{0};
  double y{0};
  double z{0};
 
  [[nodiscard]] bool empty() const {
    return x == 0 && y == 0 && z == 0;
  }
 
  void release() {
    x = y = z = 0;
  }
 
  friend std::ostream &operator<<(std::ostream &os, const xyz_t &xyz) {
    os << "(" << xyz.x << ", " << xyz.y << ", " << xyz.z << ")";
    return os;
  }
} __attribute__((aligned(32)));

struct Imu {
  double t{0};
  xyz_t linear_acceleration;
  xyz_t angular_velocity;
 
  [[nodiscard]] bool empty() const {
    return t == 0 && linear_acceleration.empty() && angular_velocity.empty();
  }
 
  void release() {
    t = 0;
    linear_acceleration.release();
    angular_velocity.release();
  }
 
  friend std::ostream &operator<<(std::ostream &os, const Imu &imu) {
    os << "t: " << imu.t << ", acc: " << imu.linear_acceleration << ", gyr: " << imu.angular_velocity;
    return os;
  }
} __attribute__((aligned(128)));
using ImuVector = std::vector<Imu>;
using ImuQueue = std::queue<Imu>;

class AbstractCamera {
public:
  AbstractCamera() = default;
  ~AbstractCamera();
  AbstractCamera(const AbstractCamera &) = delete;
  AbstractCamera(AbstractCamera &&) noexcept = delete;
  AbstractCamera &operator=(const AbstractCamera &) = delete;
  AbstractCamera &operator=(AbstractCamera &&) noexcept = delete;

  inline void setTimeOffset(const double offset) {
    timeOffset_ = offset;
  }

  void start();

  void stop();

  [[nodiscard]] cv::Size getSensorSize() const;

  [[nodiscard]] cv::Rect_<uint16_t> getRoi() const;

  bool setRoi(const cv::Rect_<uint16_t> &roi);

  BiasValue getBias(const int8_t config_bias, const uint8_t name) const;

  bool setBias(const int8_t config_bias, const uint8_t name, const BiasValue &value);

  void flush(const double msec) const;

  virtual bool getData(Vector &events) = 0;

  virtual bool getData(Queue &events) = 0;
 
protected:
  std::atomic<bool> running_{false};
  caerDeviceHandle deviceHandler_{nullptr};
  double timeOffset_{0};
  cv::Rect_<uint16_t> roi_;
 
  virtual void init() = 0;
};
 
} // namespace ev
 
#endif // OPENEV_DEVICES_ABSTRACT_CAMERA_HPP