6#ifndef OPENEV_REPRESENTATIONS_ABSTRACT_REPRESENTATION_HPP
7#define OPENEV_REPRESENTATIONS_ABSTRACT_REPRESENTATION_HPP
14#include <opencv2/core/hal/interface.h>
15#include <opencv2/core/mat.hpp>
16#include <opencv2/core/mat.inl.hpp>
17#include <opencv2/core/matx.hpp>
18#include <opencv2/core/traits.hpp>
19#include <opencv2/imgproc.hpp>
20#include <opencv2/viz/types.hpp>
26template <
typename T, std::
size_t N>
36enum RepresentationOptions : uint8_t {
38 IGNORE_POLARITY = 0b00000001,
39 ONLY_IF_POSITIVE = 0b00000010,
40 ONLY_IF_NEGATIVE = 0b00000100
42constexpr bool REPRESENTATION_OPTION_CHECK(
const uint8_t a,
const RepresentationOptions b) {
43 return static_cast<bool>(a &
static_cast<uint8_t
>(b));
47template <
typename T,
typename =
void>
53struct DataTypeTrait<T, std::void_t<typename T::value_type>> {
54 using type =
typename T::value_type;
61 using TypeArray = std::array<T, 3>;
62 using PrimitiveDataType =
typename DataTypeTrait<T>::type;
63 using FloatingPointType =
typename std::conditional<std::is_same<T, double>::value, double,
float>::type;
64 using ChannelType =
typename cv::Mat_<PrimitiveDataType>;
65 static constexpr int NumChannels = cv::DataType<T>::channels;
67 static constexpr TypeArray initialize() {
68 if constexpr(std::is_floating_point_v<PrimitiveDataType>) {
69 return TypeArray{repeat(1.0), repeat(-1.0), repeat(0.0)};
71 if constexpr(NumChannels == 1) {
72 constexpr Type white = 255;
73 constexpr Type black = 0;
74 constexpr Type gray = 128;
75 return TypeArray{white, black, gray};
77 return TypeArray{Type(255, 0, 0), Type(0, 0, 255), Type(0, 0, 0)};
82 static constexpr Type repeat(
const double &value) {
83 if constexpr(NumChannels == 1) {
84 return static_cast<Type
>(value);
87 for(
int i = 0; i < NumChannels; i++) {
94 static constexpr Type convert(
const cv::viz::Color &color) {
95 if constexpr(NumChannels == 1) {
99 for(
int i = 0; i < NumChannels; i++) {
106 static cv::viz::Color convert(
const Type &noncolor) {
107 if constexpr(NumChannels == 1) {
108 return cv::viz::Color(noncolor);
111 for(
int i = 0; i < NumChannels; i++) {
112 ret[i] = noncolor[i];
123template <
typename T, const RepresentationOptions Options = RepresentationOptions::NONE,
typename E =
int>
126 using Type =
typename TypeHelper<T>::Type;
132 [[nodiscard]]
inline std::size_t
count()
const {
return count_; }
139 if(tLimits_[MIN] == DBL_MAX || tLimits_[MAX] == DBL_MIN) {
142 return tLimits_[MAX] - tLimits_[MIN];
150 if(tLimits_[MIN] == DBL_MAX || tLimits_[MAX] == DBL_MIN) {
153 return 0.5 * (tLimits_[MAX] + tLimits_[MIN]);
166 void clear(
const cv::Mat &background);
181 template <std::
size_t N>
253 inline void setColor(
const bool polarity,
const cv::viz::Color &color) {
254 setValue(polarity, TypeHelper<T>::convert(color));
262 inline void setColor(
const cv::viz::Color &color) {
263 setValue(TypeHelper<T>::convert(color));
273 inline void setColors(
const cv::viz::Color &positive,
const cv::viz::Color &negative,
const cv::viz::Color &reset) {
274 setValues(TypeHelper<T>::convert(positive), TypeHelper<T>::convert(negative), TypeHelper<T>::convert(reset));
283 if constexpr(TypeHelper<T>::NumChannels == 1) {
284 ev::logger::error(
"setColorMap: Colormap can only be used with 3-channel representations");
286 colormap_ = std::make_unique<cv::ColormapTypes>(cm);
288 constexpr std::array<uchar, 3> aux1_data = {0, 128, 255};
289 cv::Mat aux1(1, 3, CV_8UC1,
const_cast<uchar *
>(aux1_data.data()));
291 cv::applyColorMap(aux1, aux3, *colormap_);
293 if constexpr(REPRESENTATION_OPTION_CHECK(Options, RepresentationOptions::IGNORE_POLARITY)) {
294 V_ON = aux3.at<cv::Vec3b>(0, 2);
295 V_RESET = aux3.at<cv::Vec3b>(0, 0);
297 V_ON = aux3.at<cv::Vec3b>(0, 2);
298 V_OFF = aux3.at<cv::Vec3b>(0, 0);
299 V_RESET = aux3.at<cv::Vec3b>(0, 1);
307 enum : uint8_t { MIN,
310 Type V_ON = TypeHelper<T>::initialize()[0];
311 Type V_OFF = TypeHelper<T>::initialize()[1];
312 Type V_RESET = TypeHelper<T>::initialize()[2];
314 double timeOffset_{0};
315 std::array<double, 2> tLimits_{DBL_MAX, DBL_MIN};
316 std::size_t count_{0};
317 std::unique_ptr<cv::ColormapTypes> colormap_;
319 virtual void clear_() = 0;
320 virtual void clear_(
const cv::Mat &background) = 0;
321 virtual bool insert_(
const Event_<E> &e) = 0;
328#include "openev/representations/abstract-representation.tpp"
This is an auxiliary class. This class cannot be instanced.
Definition abstract-representation.hpp:124
double midTime() const
Calculate the midpoint time between the oldest and the newest event.
Definition abstract-representation.hpp:149
void setColors(const cv::viz::Color &positive, const cv::viz::Color &negative, const cv::viz::Color &reset)
Set colors for ON, OFF, and non-activated pixels. For more information, please refer here.
Definition abstract-representation.hpp:273
void clear()
Remove all events from the representation.
bool insert(const Vector_< E > &vector)
Insert a vector of events in the representation.
void setColor(const cv::viz::Color &color)
Set colors for non-activated pixels (background). For more information, please refer here.
Definition abstract-representation.hpp:262
typename TypeHelper< T >::Type Type
Definition abstract-representation.hpp:126
bool insert(const Event_< E > &e)
Insert one event in the representation.
void setColor(const bool polarity, const cv::viz::Color &color)
Set colors for ON and OFF pixels. For more information, please refer here.
Definition abstract-representation.hpp:253
void setColormap(const cv::ColormapTypes cm)
Set colormap for the representation.
Definition abstract-representation.hpp:282
double duration() const
Time difference between the oldest and the newest event integrated in the representation.
Definition abstract-representation.hpp:138
std::size_t count() const
Number of events integrated in the representation.
Definition abstract-representation.hpp:132
void setValue(const bool polarity, const Type &value)
Set values for ON and OFF pixels.
Definition abstract-representation.hpp:213
bool insert(const Array_< E, N > &array)
Insert an array of events in the representation.
bool insert(Queue_< E > &queue, const bool keep_events_in_queue=false)
Insert a queue of events in the representation.
void setValues(const Type &positive, const Type &negative, const Type &reset)
Set values for ON, OFF, and non-activated pixels.
Definition abstract-representation.hpp:239
void setTimeOffset(const Event_< E > &e)
Set time offset.
Definition abstract-representation.hpp:204
void clear(const cv::Mat &background)
Remove all events from the representation and add a background image.
void setValue(const Type &value)
Set value for non-activated pixels (background).
Definition abstract-representation.hpp:227
This class extends std::array to implement event arrays. For more information, please refer here.
Definition array.hpp:22
This class extends cv::Point_<T> for event data. For more information, please refer here.
Definition types.hpp:55
double t
Definition types.hpp:57
This class extends std::queue to implement event queues. For more information, please refer here.
Definition queue.hpp:20
This class extends std::vector to implement event vectors. For more information, please refer here.
Definition vector.hpp:20
void error(const char *message, const bool assert_condition=false)
Log message at error level.
Definition logger.hpp:38