matrices.hpp

Go to the documentation of this file.

#ifndef OPENEV_CORE_MATRICES_HPP
#define OPENEV_CORE_MATRICES_HPP
 
#include "openev/core/stats.hpp"
#include "openev/core/types.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <limits>
#include <opencv2/core/hal/interface.h>
#include <opencv2/core/mat.hpp>
#include <opencv2/core/mat.inl.hpp>
#include <opencv2/core/traits.hpp>
#include <ostream>
#include <type_traits>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_MATRICES_HPP = true;

template <typename T>
class Event_;
 
namespace Mat {
template <typename T>
class Mat_ : public cv::Mat_<T>, public Stats_<Mat_<T>> {
  static_assert(std::is_arithmetic_v<T>, "ev::Mat_: the pixel type must be arithmetic.");
 
public:
  using cv::Mat_<T>::Mat_;

  Mat_() = default;
  Mat_(const int rows, const int cols) : cv::Mat_<T>(rows, cols, static_cast<T>(0)) {}
  explicit Mat_(const cv::Size size) : cv::Mat_<T>(size, static_cast<T>(0)) {}

  void updateStats(const Event &e) {
    if(count_ == 0) {
      first_ = e.t;
    }
    last_ = e.t;
    count_++;
  }

  [[nodiscard]] std::size_t count() const {
    return count_;
  }

  [[nodiscard]] TimeType firstTimestamp() const {
    return first_;
  }

  [[nodiscard]] TimeType lastTimestamp() const {
    return last_;
  }

  inline void resetStats() {
    first_ = 0;
    last_ = 0;
    count_ = 0;
  }

  inline void clear() {
    if(cv::Mat_<T>::empty()) {
      return;
    }
    if(cv::Mat_<T>::isContinuous()) {
      std::memset(cv::Mat_<T>::data, 0, cv::Mat_<T>::total() * cv::Mat_<T>::elemSize());
      return;
    }
    cv::Mat_<T>::setTo(0);
  }
 
private:
  TimeType first_{0};
  TimeType last_{0};
  std::size_t count_{0};
};

template <typename Tb>
class Binary_ : public Mat_<Tb> {
  static_assert(std::is_integral_v<Tb>, "ev::Binary_: the pixel type must be integral.");
 
public:
  using Mat_<Tb>::Mat_;

  template <typename T>
  inline Tb insert(const Event_<T> &e) {
    return set(e.x, e.y);
  }

  template <typename T>
  inline Tb emplace(const T x, const T y) {
    return set(x, y);
  }
 
  static constexpr Tb ON = std::numeric_limits<Tb>::max(); 
  static constexpr Tb OFF = static_cast<Tb>(0);            
 
  friend std::ostream &operator<<(std::ostream &os, const Binary_ &binary) {
    os << "Binary " << binary.cols << "x" << binary.rows;
    return os;
  }
 
private:
  template <typename T>
  inline Tb set(const T x, const T y) {
    if constexpr(std::is_floating_point_v<T>) {
      return *(this->template ptr<Tb>(round_(y)) + round_(x)) = ON;
    } else {
      return *(this->template ptr<Tb>(y) + x) = ON;
    }
  }
};
using Binary = Binary_<uchar>;

template <typename Tb>
class Ternary_ : public Mat_<Tb> {
  static_assert(std::is_integral_v<Tb> && std::is_signed_v<Tb>, "ev::Ternary_: the pixel type must be signed, otherwise NEGATIVE and ZERO are both zero.");
 
public:
  using Mat_<Tb>::Mat_;

  template <typename T>
  inline Tb insert(const Event_<T> &e) {
    return set(e.x, e.y, e.p);
  }

  template <typename T>
  inline Tb emplace(const T x, const T y, const bool p) {
    return set(x, y, p);
  }
 
  static constexpr Tb POSITIVE = std::numeric_limits<Tb>::max(); 
  static constexpr Tb ZERO = static_cast<Tb>(0);                 
  static constexpr Tb NEGATIVE = std::numeric_limits<Tb>::min(); 
 
  friend std::ostream &operator<<(std::ostream &os, const Ternary_ &ternary) {
    os << "Ternary " << ternary.cols << "x" << ternary.rows;
    return os;
  }
 
private:
  static constexpr Tb VALUE[2]{NEGATIVE, POSITIVE};
 
  template <typename T>
  inline Tb set(const T x, const T y, const bool p) {
    if constexpr(std::is_floating_point_v<T>) {
      return *(this->template ptr<Tb>(round_(y)) + round_(x)) = VALUE[p];
    } else {
      return *(this->template ptr<Tb>(y) + x) = VALUE[p];
    }
  }
};
using Ternary = Ternary_<signed char>;

class Time : public Mat_<TimeType> {
public:
  using Mat_<TimeType>::Mat_;

  template <typename T>
  inline TimeType insert(const Event_<T> &e) {
    return set(e.x, e.y, e.t);
  }

  template <typename T>
  inline TimeType emplace(const T x, const T y, const TimeType t) {
    return set(x, y, t);
  }
 
  friend std::ostream &operator<<(std::ostream &os, const Time &time) {
    os << "Time " << time.cols << "x" << time.rows;
    return os;
  }
 
private:
  template <typename T>
  inline TimeType set(const T x, const T y, const TimeType t) {
    if constexpr(std::is_floating_point_v<T>) {
      return *(this->ptr<TimeType>(round_(y)) + round_(x)) = t;
    } else {
      return *(this->ptr<TimeType>(y) + x) = t;
    }
  }
};

class Polarity : public Mat_<PolarityType> {
public:
  using Mat_<PolarityType>::Mat_;

  template <typename T>
  inline PolarityType insert(const Event_<T> &e) {
    return set(e.x, e.y, e.p);
  }

  template <typename T>
  inline PolarityType emplace(const T x, const T y, const PolarityType p) {
    return set(x, y, p);
  }
 
  friend std::ostream &operator<<(std::ostream &os, const Polarity &polarity) {
    os << "Polarity " << polarity.cols << "x" << polarity.rows;
    return os;
  }
 
private:
  template <typename T>
  inline PolarityType set(const T x, const T y, const PolarityType p) {
    if constexpr(std::is_floating_point_v<T>) {
      return *(this->ptr<PolarityType>(round_(y)) + round_(x)) = p;
    } else {
      return *(this->ptr<PolarityType>(y) + x) = p;
    }
  }
};

class Counter : public Mat_<CounterType> {
public:
  using Mat_<CounterType>::Mat_;

  template <typename T>
  inline CounterType insert(const Event_<T> &e) {
    return set(e.x, e.y, e.p);
  }

  template <typename T>
  inline CounterType emplace(const T x, const T y, const bool p) {
    return set(x, y, p);
  }
 
  friend std::ostream &operator<<(std::ostream &os, const Counter &counter) {
    os << "Counter " << counter.cols << "x" << counter.rows;
    return os;
  }
 
private:
  static constexpr CounterType INCREMENT[2]{-1, +1};
 
  template <typename T>
  inline CounterType set(const T x, const T y, const bool p) {
    if constexpr(std::is_floating_point_v<T>) {
      return *(this->ptr<CounterType>(round_(y)) + round_(x)) += INCREMENT[p];
    } else {
      return *(this->ptr<CounterType>(y) + x) += INCREMENT[p];
    }
  }
};
} // namespace Mat
} // namespace ev
 
#endif // OPENEV_CORE_MATRICES_HPP