types.hpp

Go to the documentation of this file.

#ifndef OPENEV_CORE_TYPES_HPP
#define OPENEV_CORE_TYPES_HPP
 
#include "openev/core/undistortion.hpp"
#include "openev/utils/logger.hpp"
#include <array>
#include <cmath>
#include <cstdint>
#include <iosfwd>
#include <opencv2/core/base.hpp>
#include <opencv2/core/matx.hpp>
#include <opencv2/core/types.hpp>
#include <ostream>
#include <string>
#include <vector>
 
namespace ev {
class UndistortMap;
}
 
namespace ev {
constexpr bool POSITIVE = true;  
constexpr bool NEGATIVE = false; 
 
enum class Stereo : char {
  LEFT = 'L',
  RIGHT = 'R'
};
 
enum DistanceTypes : uint8_t {
  DISTANCE_NORM_INF = cv::NORM_INF,
  DISTANCE_NORM_L1 = cv::NORM_L1,
  DISTANCE_NORM_L2 = cv::NORM_L2,
  DISTANCE_NORM_L2SQR = cv::NORM_L2SQR,
  DISTANCE_NORM_MANHATTAN = DISTANCE_NORM_L1,
  DISTANCE_NORM_EUCLIDEAN = DISTANCE_NORM_L2,
  DISTANCE_FLAG_SPATIAL = 0b00010000,
  DISTANCE_FLAG_TEMPORAL = 0b00100000,
  DISTANCE_FLAG_SPATIOTEMPORAL = 0b01000000,
  DISTANCE_FLAG_3D = DISTANCE_FLAG_SPATIOTEMPORAL,
  DISTANCE_FLAG_2D = DISTANCE_FLAG_SPATIAL,
};

template <typename T>
class Event_ : public cv::Point_<T> {
public:
  double t; 
  bool 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 double t, const bool p) : cv::Point_<T>(x, y), t{t}, p{p} {};

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

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

  Event_<T> &operator=(const cv::Point_<T> &p) {
    Event_<T>::x = p.x;
    Event_<T>::y = 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 operator cv::Point_<U>() const {
    return {static_cast<U>(Event_<T>::x), static_cast<U>(Event_<T>::y)};
  }

  template <typename U>
  [[nodiscard]] inline 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 & 0x0F);
    }
    if(static_cast<bool>(type & DISTANCE_FLAG_SPATIAL) || !static_cast<bool>(type & 0xF0)) {
      return cv::norm(cv::Matx<T, 2, 1>(Event_<T>::x - e.x, Event_<T>::y - e.y), type & 0x0F);
    }
    if(static_cast<bool>(type & DISTANCE_FLAG_TEMPORAL)) {
      return Event_<T>::t - e.t;
    }
    logger::error("Bad distance option");
    return 0.0;
  }

  inline bool undistort(const UndistortMap &map) {
    return map(*this);
  }

  std::array<double, 4> bilinearVoting() const {
    const double dx = this->x - static_cast<int>(this->x);
    const double dy = this->y - static_cast<int>(this->y);
    if(dx == 0 && dy == 0) {
      return {1, 0, 0, 0};
    }
    if(dx == 0) {
      return {(1 - dy), 0, dy, 0};
    }
    if(dy == 0) {
      return {(1 - dx), dx, 0, 0};
    }
    return {(1 - dx) * (1 - dy), dx * (1 - dy), (1 - dx) * dy, dx * dy};
  }

  [[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:
  double weight{1};            
  double depth{0};             
  Stereo stereo{Stereo::LEFT}; 

  std::vector<AugmentedEvent_<int>> bilinearVoting() const {
    const double dx = this->x - static_cast<int>(this->x);
    const double dy = this->y - static_cast<int>(this->y);
    if(dx == 0 && dy == 0) {
      return {static_cast<AugmentedEvent_<int>>(*this)};
    }
    if(dx == 0) {
      AugmentedEvent_<int> e1(static_cast<int>(this->x), static_cast<int>(this->y), this->t, this->p);
      AugmentedEvent_<int> e3(static_cast<int>(this->x), 1 + static_cast<int>(this->y), this->t, this->p);
      e1.weight = (1 - dy);
      e3.weight = dy;
      return {e1, e3};
    }
    if(dy == 0) {
      AugmentedEvent_<int> e1(static_cast<int>(this->x), static_cast<int>(this->y), this->t, this->p);
      AugmentedEvent_<int> e2(1 + static_cast<int>(this->x), static_cast<int>(this->y), this->t, this->p);
      e1.weight = (1 - dx);
      e2.weight = dx;
      return {e1, e2};
    }
    AugmentedEvent_<int> e1(static_cast<int>(this->x), static_cast<int>(this->y), this->t, this->p);
    AugmentedEvent_<int> e2(1 + static_cast<int>(this->x), static_cast<int>(this->y), this->t, this->p);
    AugmentedEvent_<int> e3(static_cast<int>(this->x), 1 + static_cast<int>(this->y), this->t, this->p);
    AugmentedEvent_<int> e4(1 + static_cast<int>(this->x), 1 + static_cast<int>(this->y), this->t, this->p);
    e1.weight = (1 - dx) * (1 - dy);
    e2.weight = dx * (1 - dy);
    e3.weight = (1 - dx) * dy;
    e4.weight = dx * dy;
    return {e1, e2, e3, e4};
  }

  [[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 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{radius} {}

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

  template <typename Te>
  [[nodiscard]] inline bool contains(const Event_<Te> &e) const {
    return 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