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/frames.hpp"
#include "openev/core/imu.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 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