types.hpp

Go to the documentation of this file.

#ifndef OPENEV_CORE_TYPES_HPP
#define OPENEV_CORE_TYPES_HPP
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <iosfwd>
#include <opencv2/core/base.hpp>
#include <opencv2/core/matx.hpp>
#include <opencv2/core/types.hpp>
#include <opencv2/core/utils/logger.hpp>
#include <ostream>
#include <string>
#include <type_traits>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_TYPES_HPP = true;

template <typename T>
[[nodiscard]] inline int round_(const T x) {
  const double value = x;
  return static_cast<int>(value + std::copysign(0.5, value));
}
 
using TimeType = double;
using PolarityType = bool;
using WeightType = float;
using DepthType = float;
using CounterType = int16_t;
 
constexpr PolarityType POSITIVE = static_cast<PolarityType>(true);  
constexpr PolarityType NEGATIVE = static_cast<PolarityType>(false); 

enum class Stereo : char {
  LEFT = 'L', 
  RIGHT = 'R' 
};

enum DistanceTypes : uint8_t {
  DISTANCE_NORM_INF = static_cast<uint8_t>(cv::NORM_INF),
  DISTANCE_NORM_L1 = static_cast<uint8_t>(cv::NORM_L1),
  DISTANCE_NORM_L2 = static_cast<uint8_t>(cv::NORM_L2),
  DISTANCE_NORM_L2SQR = static_cast<uint8_t>(cv::NORM_L2SQR),
  DISTANCE_NORM_MANHATTAN = DISTANCE_NORM_L1,
  DISTANCE_NORM_EUCLIDEAN = DISTANCE_NORM_L2,
  DISTANCE_FLAG_SPATIAL = static_cast<uint8_t>(0b00010000),        
  DISTANCE_FLAG_TEMPORAL = static_cast<uint8_t>(0b00100000),       
  DISTANCE_FLAG_SPATIOTEMPORAL = static_cast<uint8_t>(0b01000000), 
  DISTANCE_FLAG_3D = DISTANCE_FLAG_SPATIOTEMPORAL,                 
  DISTANCE_FLAG_2D = DISTANCE_FLAG_SPATIAL,                        
};

template <typename T>
class Event_ : public cv::Point_<T> {
  static_assert(std::is_arithmetic_v<T>, "ev::Event_: the coordinate type must be arithmetic.");
 
public:
  TimeType t;     
  PolarityType p; 

  Event_() : cv::Point_<T>(), t{0}, p{POSITIVE} {};

  ~Event_() = default;

  Event_(const Event_<T> &) = default;

  Event_(Event_<T> &&) noexcept = default;

  Event_(const T x, const T y) : cv::Point_<T>(x, y), t{0}, p{POSITIVE} {};

  explicit Event_(const cv::Point_<T> &pt) : cv::Point_<T>(pt), t{0}, p{POSITIVE} {};

  Event_(const T x, const T y, const TimeType t, const PolarityType p) : cv::Point_<T>(x, y), t{t}, p{p} {};

  Event_(const cv::Point_<T> &pt, const TimeType t, const PolarityType p) : cv::Point_<T>(pt), t{t}, p{p} {};

  Event_<T> &operator=(const Event_<T> &) = default;

  template <typename U>
  Event_<T> &operator=(const Event_<U> &e) {
    Event_<T>::x = static_cast<T>(e.x);
    Event_<T>::y = static_cast<T>(e.y);
    Event_<T>::t = static_cast<TimeType>(e.t);
    Event_<T>::p = static_cast<PolarityType>(e.p);
    return *this;
  }

  Event_<T> &operator=(const cv::Point3_<T> &p) {
    Event_<T>::x = static_cast<T>(p.x);
    Event_<T>::y = static_cast<T>(p.y);
    Event_<T>::t = static_cast<TimeType>(p.z);
    return *this;
  }

  Event_<T> &operator=(const cv::Point_<T> &p) {
    Event_<T>::x = static_cast<T>(p.x);
    Event_<T>::y = static_cast<T>(p.y);
    return *this;
  }

  Event_<T> &operator=(Event_<T> &&) noexcept = default;

  [[nodiscard]] inline bool operator==(const Event_<T> &e) const {
    return (Event_<T>::x == e.x) && (Event_<T>::y == e.y) && (t == e.t) && (p == e.p);
  }

  [[nodiscard]] inline bool operator==(const cv::Point_<T> &pt) const {
    return (Event_<T>::x == pt.x) && (Event_<T>::y == pt.y);
  }

  [[nodiscard]] inline bool operator==(const cv::Point3_<T> &pt) const {
    return (Event_<T>::x == pt.x) && (Event_<T>::y == pt.y) && (Event_<T>::t == pt.z);
  }

  [[nodiscard]] inline bool operator<(const Event_<T> &e) const {
    return Event_<T>::t < e.t;
  }

  template <typename U>
  [[nodiscard]] inline explicit operator cv::Point_<U>() const {
    return {static_cast<U>(Event_<T>::x), static_cast<U>(Event_<T>::y)};
  }

  template <typename U>
  [[nodiscard]] inline explicit operator cv::Point3_<U>() const {
    return {static_cast<U>(Event_<T>::x), static_cast<U>(Event_<T>::y), static_cast<U>(Event_<T>::t)};
  }

  [[nodiscard]] inline double distance(const Event_<T> &e, const uint8_t type = DISTANCE_NORM_L2 | DISTANCE_FLAG_SPATIAL) const {
    if(static_cast<bool>(type & DISTANCE_FLAG_SPATIOTEMPORAL)) {
      return cv::norm(cv::Matx<T, 3, 1>(Event_<T>::x - e.x, Event_<T>::y - e.y, Event_<T>::t - e.t), type & 0x0FU);
    }
    if(static_cast<bool>(type & DISTANCE_FLAG_SPATIAL) || !static_cast<bool>(type & 0xF0U)) {
      return cv::norm(cv::Matx<T, 2, 1>(Event_<T>::x - e.x, Event_<T>::y - e.y), type & 0x0FU);
    }
    if(static_cast<bool>(type & DISTANCE_FLAG_TEMPORAL)) {
      return Event_<T>::t - e.t;
    }
    CV_Error(cv::Error::StsBadArg, "ev::Event_::distance: Bad distance option.");
  }

  [[nodiscard]] friend std::ostream &operator<<(std::ostream &os, const Event_<T> &e) {
    os << std::string("(" + std::to_string(e.x) + "," + std::to_string(e.y) + ") " + std::to_string(e.t) + (e.p ? " [+]" : " [-]"));
    return os;
  }
};
using Eventi = Event_<int>;    
using Eventl = Event_<long>;   
using Eventf = Event_<float>;  
using Eventd = Event_<double>; 
using Event = Eventi;          

template <typename T>
class AugmentedEvent_ : public Event_<T> {
  using Event_<T>::Event_;
 
public:
  WeightType weight{1};        
  DepthType depth{0};          
  Stereo stereo{Stereo::LEFT}; 

  [[nodiscard]] friend std::ostream &operator<<(std::ostream &os, const AugmentedEvent_<T> &e) {
    os << std::string("(" + std::to_string(e.x) + "," + std::to_string(e.y) + ") " + std::to_string(e.t) + (e.p ? " [+]" : " [-]"));
    os << " w=" + std::to_string(e.weight);
    os << " d=" + std::to_string(e.depth);
    os << " s=" + (e.stereo == Stereo::LEFT ? std::string("LEFT") : std::string("RIGHT"));
    return os;
  }
};
using AugmentedEventi = AugmentedEvent_<int>;    
using AugmentedEventl = AugmentedEvent_<long>;   
using AugmentedEventf = AugmentedEvent_<float>;  
using AugmentedEventd = AugmentedEvent_<double>; 
using AugmentedEvent = AugmentedEventi;          

template <typename T>
using Size2_ = cv::Size_<T>;
using Size2i = Size2_<int>;    
using Size2l = Size2_<long>;   
using Size2f = Size2_<float>;  
using Size2d = Size2_<double>; 
using Size2 = Size2i;          
using Size = Size2;            

template <typename T>
class Size3_ : public cv::Size_<T> {
public:
  T length; 

  Size3_() : cv::Size_<T>(), length{0} {};

  Size3_(T w, T h, T l) : cv::Size_<T>(w, h), length{l} {};

  [[nodiscard]] inline bool empty() const {
    return cv::Size_<T>::width <= 0 || cv::Size_<T>::height <= 0 || length <= 0;
  }

  [[nodiscard]] inline T volume() const {
    return cv::Size_<T>::width * cv::Size_<T>::height * length;
  }
};
using Size3i = Size3_<int>;    
using Size3l = Size3_<long>;   
using Size3f = Size3_<float>;  
using Size3d = Size3_<double>; 
using Size3 = Size3i;          

template <typename T>
using Rect2_ = cv::Rect_<T>;
using Rect2i = Rect2_<int>;    
using Rect2l = Rect2_<long>;   
using Rect2f = Rect2_<float>;  
using Rect2d = Rect2_<double>; 
using Rect2 = Rect2i;          
using Rect = Rect2;            

template <typename T>
class Rect3_ : public cv::Rect_<T> {
public:
  T t;      
  T length; 

  Rect3_() : cv::Rect_<T>(), t{0}, length{0} {};

  Rect3_(const T x, const T y, const T t, const T w, const T h, const T l) : cv::Rect_<T>(x, y, w, h), t{t}, length{l} {};

  Rect3_(const Rect2_<T> &rect, const T t, const T l) : cv::Rect_<T>(rect), t{t}, length{l} {};

  Rect3_(const cv::Point3_<T> &pt, const Size3_<T> sz) : cv::Rect_<T>(cv::Point_<T>(pt.x, pt.y), cv::Size_<T>(sz.width, sz.height)), t{pt.z}, length{sz.length} {};

  Rect3_(const cv::Point3_<T> &pt1, const cv::Point3_<T> &pt2) : cv::Rect_<T>(cv::Point_<T>(pt1.x, pt1.y), cv::Size_<T>(pt2.x - pt1.x, pt2.y - pt1.y)), t{pt1.z}, length{pt2.z - pt1.z} {};

  [[nodiscard]] inline bool empty() const {
    return Rect3_<T>::width <= 0 || Rect3_<T>::height <= 0 || length <= 0;
  }

  template <typename Te>
  [[nodiscard]] inline bool contains(const Event_<Te> &e) const {
    return cv::Rect_<T>::contains(e) && e.t >= t && e.t < t + length;
  }

  [[nodiscard]] inline Size3_<T> size() const {
    return Size3_<T>(Rect3_<T>::width, Rect3_<T>::height, length);
  }

  [[nodiscard]] inline T volume() const {
    return Rect3_<T>::width * Rect3_<T>::height * length;
  }
};
using Rect3i = Rect3_<int>;    
using Rect3l = Rect3_<long>;   
using Rect3f = Rect3_<float>;  
using Rect3d = Rect3_<double>; 
using Rect3 = Rect3i;          

template <typename T>
struct alignas(16) Circ_ {
  cv::Point_<T> center;
  T radius;

  Circ_() : center{0, 0}, radius{0} {};

  Circ_(const cv::Point_<T> center, const T radius) : center{center}, radius{std::max(radius, static_cast<T>(0))} {}

  [[nodiscard]] inline bool empty() const {
    return radius <= 0;
  }

  template <typename Te>
  [[nodiscard]] inline bool contains(const Event_<Te> &e) const {
    return !empty() && pow(center.x - e.x, 2) + pow(center.y - e.y, 2) <= radius * radius;
  }

  [[nodiscard]] inline cv::Size size() const {
    return {radius, radius};
  }

  [[nodiscard]] inline double area() const {
    return M_PI * radius * radius;
  }
};
using Circi = Circ_<int>;    
using Circl = Circ_<long>;   
using Circf = Circ_<float>;  
using Circd = Circ_<double>; 
using Circ = Circi;          
 
} // namespace ev
 
#endif // OPENEV_CORE_TYPES_HPP