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 "openev/core/types.hpp"
#include <atomic>
#include <cstddef>
#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 <string>
#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;

class StampedMat : public cv::Mat {
public:
  TimeType t{0};
 
  using cv::Mat::copyTo;

  void copyTo(StampedMat &dst) const {
    cv::Mat::copyTo(dst);
    dst.t = t;
  }

  void release() {
    cv::Mat::release();
    t = 0;
  }
};
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;
  }
};

struct Imu {
  TimeType 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;
  }
};
using ImuVector = std::vector<Imu>;
using ImuQueue = std::queue<Imu>;

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

  virtual void start() = 0;

  void stop();

  [[nodiscard]] bool isOpen() const {
    return deviceHandler_ != nullptr;
  }

  [[nodiscard]] virtual bool hasAps() const = 0;

  [[nodiscard]] virtual bool hasImu() const = 0;

  [[nodiscard]] virtual cv::Size getSensorSize() const = 0;

  [[nodiscard]] virtual std::string getSerialNumber() const = 0;

  [[nodiscard]] uint64_t getResetTime() const {
    return resetTime_;
  }

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

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

  void setDefectivePixels(const std::string &defective_pixels_file);

  void setContainerInterval(const uint32_t usec);

  void setContainerSize(const uint32_t n);

  bool getData(Vector &events);

  bool getData(Queue &events);

  bool getData(StampedMat &frame);

  bool getData(StampedMatVector &frames);

  bool getData(StampedMatQueue &frames);

  bool getData(Imu &imu);

  bool getData(ImuVector &imu);

  bool getData(ImuQueue &imu);

  bool getData(Vector &events, StampedMat &frame);

  bool getData(Vector &events, StampedMatVector &frames);

  bool getData(Queue &events, StampedMatQueue &frames);

  bool getData(Vector &events, Imu &imu);

  bool getData(Vector &events, ImuVector &imu);

  bool getData(Queue &events, ImuQueue &imu);

  bool getData(Vector &events, StampedMat &frame, Imu &imu);

  bool getData(Vector &events, StampedMatVector &frame, ImuVector &imu);

  bool getData(Queue &events, StampedMatQueue &frame, ImuQueue &imu);

  std::size_t getEventRaw(std::vector<uint64_t> &data);

  std::size_t getEventRaw(uint64_t *&data, const bool allow_realloc = true);

  void flush(const double usec) const;
 
protected:
  template <typename T1, typename T2, typename T3>
  bool getData_([[maybe_unused]] T1 *dvs, [[maybe_unused]] T2 *aps, [[maybe_unused]] T3 *imu);
 
  template <typename T>
  std::size_t getEventRaw_(T &data, [[maybe_unused]] const bool allow_realloc);
 
  void interpolate_(cv::Mat &frame) const;

  virtual std::size_t setDvsFilterPixels([[maybe_unused]] const std::vector<cv::Point> &pixels) {
    return 0;
  }
 
  std::atomic<bool> running_{false};
  bool hasDefectivePixels_{false};
  cv::Mat hotPixels_;
  std::vector<cv::Point> saturatedPixels_;
  caerDeviceHandle deviceHandler_{nullptr};
  uint64_t resetTime_{0};
  cv::Rect_<uint16_t> roi_;
  bool filterRoiInSoftware_{false};
};
 
} // namespace ev
 
#endif // OPENEV_DEVICES_ABSTRACT_CAMERA_HPP