abstract-representation.hpp

Go to the documentation of this file.

#ifndef OPENEV_REPRESENTATIONS_ABSTRACT_REPRESENTATION_HPP
#define OPENEV_REPRESENTATIONS_ABSTRACT_REPRESENTATION_HPP
 
#include "openev/core/types.hpp"
#include <array>
#include <cstddef>
#include <limits>
#include <memory>
#include <opencv2/core/hal/interface.h>
#include <opencv2/core/mat.hpp>
#include <opencv2/core/mat.inl.hpp>
#include <opencv2/core/matx.hpp>
#include <opencv2/core/traits.hpp>
#include <opencv2/core/utils/logger.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/viz/types.hpp>
#include <stdint.h>
#include <type_traits>
 
namespace ev {
template <typename T, std::size_t N>
class Array_;
template <typename T>
class Event_;
template <typename T>
class Queue_;
template <typename T>
class Vector_;
 
enum RepresentationOptions : uint8_t {
  NONE = 0b00000000,
  IGNORE_POLARITY = 0b00000001,
  ONLY_IF_POSITIVE = 0b00000010,
  ONLY_IF_NEGATIVE = 0b00000100
};
constexpr bool REPRESENTATION_OPTION_CHECK(const uint8_t a, const RepresentationOptions b) {
  return static_cast<bool>(a & static_cast<uint8_t>(b));
}

template <typename T, typename = void>
struct DataTypeTrait {
  using type = T;
};
 
template <typename T>
struct DataTypeTrait<T, std::void_t<typename T::value_type>> {
  using type = typename T::value_type;
};
 
template <typename T>
class TypeHelper {
public:
  using Type = T;
  using TypeArray = std::array<T, 3>;
  using PrimitiveDataType = typename DataTypeTrait<T>::type;
  using FloatingPointType = typename std::conditional<std::is_same<T, double>::value, double, float>::type;
  using ChannelType = typename cv::Mat_<PrimitiveDataType>;
  static constexpr int NumChannels = cv::DataType<T>::channels;
 
  static constexpr TypeArray initialize() {
    if constexpr(std::is_floating_point_v<PrimitiveDataType>) {
      return TypeArray{repeat(1.0), repeat(-1.0), repeat(0.0)};
    } else {
      if constexpr(NumChannels == 1) {
        constexpr Type white = 255;
        constexpr Type black = 0;
        constexpr Type gray = 128;
        return TypeArray{white, black, gray};
      } else {
        return TypeArray{Type(255, 0, 0), Type(0, 0, 255), Type(0, 0, 0)};
      }
    }
  }
 
  static constexpr Type repeat(const double &value) {
    if constexpr(NumChannels == 1) {
      return static_cast<Type>(value);
    } else {
      Type ret;
      for(int i = 0; i < NumChannels; i++) {
        ret[i] = value;
      }
      return ret;
    }
  }
 
  static constexpr Type convert(const cv::viz::Color &color) {
    if constexpr(NumChannels == 1) {
      return color[0];
    } else {
      Type ret;
      for(int i = 0; i < NumChannels; i++) {
        ret[i] = color[i];
      }
      return ret;
    }
  }
 
  static cv::viz::Color convert(const Type &noncolor) {
    if constexpr(NumChannels == 1) {
      return cv::viz::Color(noncolor);
    } else {
      cv::viz::Color ret;
      for(int i = 0; i < NumChannels; i++) {
        ret[i] = noncolor[i];
      }
      return ret;
    }
  }
};

template <typename T, const RepresentationOptions Options = RepresentationOptions::NONE, typename E = int>
class AbstractRepresentation_ {
public:
  using Type = typename TypeHelper<T>::Type; 

  AbstractRepresentation_() = default;
  virtual ~AbstractRepresentation_() = default;
  AbstractRepresentation_(const AbstractRepresentation_ &) = delete;
  AbstractRepresentation_(AbstractRepresentation_ &&) noexcept = delete;
  AbstractRepresentation_ &operator=(const AbstractRepresentation_ &) = delete;
  AbstractRepresentation_ &operator=(AbstractRepresentation_ &&) noexcept = delete;

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

  [[nodiscard]] inline TimeType duration() const {
    if(tLimits_[MIN] == std::numeric_limits<TimeType>::max() || tLimits_[MAX] == std::numeric_limits<TimeType>::min()) {
      return -1;
    }
    return tLimits_[MAX] - tLimits_[MIN];
  }

  [[nodiscard]] inline TimeType midTime() const {
    if(tLimits_[MIN] == std::numeric_limits<TimeType>::max() || tLimits_[MAX] == std::numeric_limits<TimeType>::min()) {
      return -1;
    }
    return 0.5f * (tLimits_[MAX] + tLimits_[MIN]);
  }

  void clear();

  void clear(const cv::Mat &background);

  bool insert(const Event_<E> &e);

  template <std::size_t N>
  bool insert(const Array_<E, N> &array);

  bool insert(const Vector_<E> &vector);

  bool insert(Queue_<E> &queue, const bool keep_events_in_queue = false);

  void setTimeOffset(const Event_<E> &e) {
    timeOffset_ = -e.t;
  }

  inline void setValue(const bool polarity, const Type &value) {
    if(polarity) {
      V_ON = value;
    } else {
      V_OFF = value;
    }
    colormap_ = nullptr;
    this->clear();
  }

  inline void setValue(const Type &value) {
    V_RESET = value;
    colormap_ = nullptr;
    this->clear();
  }

  inline void setValues(const Type &positive, const Type &negative, const Type &reset) {
    V_ON = positive;
    V_OFF = negative;
    V_RESET = reset;
    colormap_ = nullptr;
    this->clear();
  }

  inline void setColor(const bool polarity, const cv::viz::Color &color) {
    setValue(polarity, TypeHelper<T>::convert(color));
  }

  inline void setColor(const cv::viz::Color &color) {
    setValue(TypeHelper<T>::convert(color));
  }

  inline void setColors(const cv::viz::Color &positive, const cv::viz::Color &negative, const cv::viz::Color &reset) {
    setValues(TypeHelper<T>::convert(positive), TypeHelper<T>::convert(negative), TypeHelper<T>::convert(reset));
  }

  inline void setColormap(const cv::ColormapTypes cm) {
    if constexpr(TypeHelper<T>::NumChannels == 1) {
      CV_LOG_ERROR(nullptr, "setColorMap: Colormap can only be used with 3-channel representations");
    } else {
      colormap_ = std::make_unique<cv::ColormapTypes>(cm);
 
      constexpr std::array<uchar, 3> aux1_data = {0, 128, 255};
      cv::Mat aux1(1, 3, CV_8UC1, const_cast<uchar *>(aux1_data.data()));
      cv::Mat aux3;
      cv::applyColorMap(aux1, aux3, *colormap_);
 
      if constexpr(REPRESENTATION_OPTION_CHECK(Options, RepresentationOptions::IGNORE_POLARITY)) {
        V_ON = aux3.at<cv::Vec3b>(0, 2);
        V_RESET = aux3.at<cv::Vec3b>(0, 0);
      } else {
        V_ON = aux3.at<cv::Vec3b>(0, 2);
        V_OFF = aux3.at<cv::Vec3b>(0, 0);
        V_RESET = aux3.at<cv::Vec3b>(0, 1);
      }
      this->clear();
    }
  }
 
protected:
  enum : uint8_t { MIN,
                   MAX };
 
  Type V_ON = TypeHelper<T>::initialize()[0];
  Type V_OFF = TypeHelper<T>::initialize()[1];
  Type V_RESET = TypeHelper<T>::initialize()[2];
 
  TimeType timeOffset_{0};
  std::array<TimeType, 2> tLimits_{std::numeric_limits<TimeType>::max(), std::numeric_limits<TimeType>::min()};
  std::size_t count_{0};
  std::unique_ptr<cv::ColormapTypes> colormap_;
 
  virtual void clear_() = 0;
  virtual void clear_(const cv::Mat &background) = 0;
  virtual bool insert_(const Event_<E> &e) = 0;
};
 
} // namespace ev

#include "openev/representations/abstract-representation.tpp"
 
#endif // OPENEV_REPRESENTATIONS_ABSTRACT_REPRESENTATION_HPP