space-time.hpp

Go to the documentation of this file.

#ifndef OPENEV_REPRESENTATIONS_SPACE_TIME_HPP
#define OPENEV_REPRESENTATIONS_SPACE_TIME_HPP
 
#include "openev/representations/abstract-representation.hpp"
#include "openev/representations/event-image.hpp"
#include <opencv2/core/hal/interface.h>
#include <opencv2/core/mat.hpp>
#include <opencv2/core/matx.hpp>
#include <opencv2/core/types.hpp>
#include <opencv2/viz/types.hpp>
#include <vector>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_SPACE_TIME_HPP = true;

template <typename T>
class Event_;

template <typename T, const RepresentationOptions Options = RepresentationOptions::NONE, typename E = int>
class SpaceTime_ : public EventImage_<T, Options, E> {
public:
  static constexpr double DEFAULT_YAW = 30.0;
  static constexpr double DEFAULT_PITCH = 20.0;
  static constexpr double DEFAULT_DEPTH = 1.0;
  static constexpr double DISTANCE = 2.5;
  static constexpr int MARGIN = 2;
  static constexpr double LABEL_SCALE = 0.35;
  static constexpr double DEFAULT_AXES_LENGTH = 0.25;
  static constexpr double DEFAULT_FADE = 0.8;

  explicit SpaceTime_(const cv::Size canvas, const cv::Size sensor = cv::Size());

  void setView(const double yaw, const double pitch);

  void setDepth(const double depth);

  inline void showAxes(const bool state, const double length = DEFAULT_AXES_LENGTH) {
    axes_ = state;
    axesLength_ = std::clamp(length, 0.0, 1.0);
  }

  inline void fadeWithDepth(const bool state, const double strength = DEFAULT_FADE) {
    fade_ = state;
    fadeStrength_ = std::clamp(strength, 0.0, 1.0);
  }

  inline void setAxesValue(const typename TypeHelper<T>::Type &value) {
    axesValue_ = value;
  }

  inline void setAxesColor(const cv::viz::Color &color) {
    axesValue_ = TypeHelper<T>::convert(color);
  }

  [[nodiscard]] inline double yaw() const {
    return yaw_;
  }

  [[nodiscard]] inline double pitch() const {
    return pitch_;
  }

  [[nodiscard]] inline cv::Size sensorSize() const {
    return sensor_;
  }

  [[nodiscard]] cv::Point2d project(const Event_<E> &e, const double age) const;

  cv::Mat &render();
 
private:
  cv::Size sensor_;
  double yaw_{DEFAULT_YAW};
  double pitch_{DEFAULT_PITCH};
  double depth_{DEFAULT_DEPTH};
  cv::Matx33d rotation_;
  double scale_{1};
  cv::Point2d center_;
  std::vector<Event_<E>> events_;
  cv::Mat frame_;
  cv::Mat backdrop_;
  bool axes_{false};
  double axesLength_{DEFAULT_AXES_LENGTH};
  bool fade_{false};
  double fadeStrength_{DEFAULT_FADE};
  typename TypeHelper<T>::Type axesValue_ = TypeHelper<T>::convert(cv::viz::Color::white());
 
  void fit_();
  void warp_();
  void drawAxes_();
  [[nodiscard]] typename TypeHelper<T>::Type faded_(const typename TypeHelper<T>::Type &value, const cv::Point &pixel, const double age) const;
  [[nodiscard]] cv::Point2d corner_(const double x, const double y, const double age) const;
  [[nodiscard]] cv::Point2d project_(const cv::Point3d &point) const;
 
  [[nodiscard]] cv::Size frameSize_() const override {
    return sensor_;
  }
 
  void clear_() override;
  void clear_(const cv::Mat &background) override;
  bool insert_(const Event_<E> &e) override;
};
using SpaceTime1b = SpaceTime_<uchar>;     
using SpaceTime3b = SpaceTime_<cv::Vec3b>; 
using SpaceTime1s = SpaceTime_<short>;     
using SpaceTime3s = SpaceTime_<cv::Vec3s>; 
using SpaceTime1w = SpaceTime_<ushort>;    
using SpaceTime3w = SpaceTime_<cv::Vec3w>; 
using SpaceTime1i = SpaceTime_<int>;       
using SpaceTime3i = SpaceTime_<cv::Vec3i>; 
using SpaceTime1f = SpaceTime_<float>;     
using SpaceTime3f = SpaceTime_<cv::Vec3f>; 
using SpaceTime1d = SpaceTime_<double>;    
using SpaceTime3d = SpaceTime_<cv::Vec3d>; 
using SpaceTime1 = SpaceTime1b;            
using SpaceTime3 = SpaceTime3b;            
using SpaceTime = SpaceTime1;              
} // namespace ev

#include "openev/representations/space-time.tpp"
 
#endif // OPENEV_REPRESENTATIONS_SPACE_TIME_HPP