grid.hpp

Go to the documentation of this file.

#ifndef OPENEV_CONTAINERS_GRID_HPP
#define OPENEV_CONTAINERS_GRID_HPP
 
#include "openev/core/types.hpp"
#include <cstddef>
#include <opencv2/core/base.hpp>
#include <opencv2/core/types.hpp>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_GRID_HPP = true;

template <typename Container, typename = void>
struct has_push_back_ : std::false_type {};
template <typename Container>
struct has_push_back_<Container, std::void_t<decltype(std::declval<Container &>().push_back(std::declval<const typename Container::value_type &>()))>> : std::true_type {};
 
template <typename Container, typename = void>
struct has_push_ : std::false_type {};
template <typename Container>
struct has_push_<Container, std::void_t<decltype(std::declval<Container &>().push(std::declval<const typename Container::value_type &>()))>> : std::true_type {};
 
template <typename Container, typename = void>
struct has_clear_ : std::false_type {};
template <typename Container>
struct has_clear_<Container, std::void_t<decltype(std::declval<Container &>().clear())>> : std::true_type {};

template <typename Container>
class Grid_ {
  static_assert(has_push_back_<Container>::value || has_push_<Container>::value, "ev::Grid_: the container must offer push_back() or push().");
 
public:
  using EventType = typename Container::value_type; 
  using T = typename EventType::value_type;         

  template <typename... Args>
  explicit Grid_(const cv::Size sensor, const cv::Size cells, Args &&...args) : sensor_{sensor}, shape_{cells}, prototype_(std::forward<Args>(args)...) {
    if(sensor.width <= 0 || sensor.height <= 0) {
      CV_Error(cv::Error::StsBadArg, "ev::Grid_: the sensor size must be positive.");
    }
    if(cells.width <= 0 || cells.height <= 0 || cells.width > sensor.width || cells.height > sensor.height) {
      CV_Error(cv::Error::StsBadArg, "ev::Grid_: the number of cells must be positive and not exceed the sensor size.");
    }
    cell_ = cv::Size((sensor.width + cells.width - 1) / cells.width, (sensor.height + cells.height - 1) / cells.height);
    cells_.assign(static_cast<std::size_t>(cells.width) * static_cast<std::size_t>(cells.height), prototype_);
  }

  inline bool insert(const EventType &e) {
    const cv::Point c = cell(e);
    if(c.x < 0) {
      return false;
    }
    push_(cells_[index_(c)], e);
    return true;
  }

  [[nodiscard]] inline cv::Point cell(const EventType &e) const {
    int x = 0;
    int y = 0;
    if constexpr(std::is_floating_point_v<T>) {
      x = round_(e.x);
      y = round_(e.y);
    } else {
      x = static_cast<int>(e.x);
      y = static_cast<int>(e.y);
    }
    if(x < 0 || y < 0 || x >= sensor_.width || y >= sensor_.height) {
      return {-1, -1};
    }
    return {x / cell_.width, y / cell_.height};
  }

  [[nodiscard]] inline Container &operator()(const int row, const int col) {
    return cells_[index_({col, row})];
  }

  [[nodiscard]] inline const Container &operator()(const int row, const int col) const {
    return cells_[index_({col, row})];
  }

  [[nodiscard]] inline Container &operator()(const cv::Point c) {
    return cells_[index_(c)];
  }

  [[nodiscard]] inline const Container &operator()(const cv::Point c) const {
    return cells_[index_(c)];
  }

  inline void clear() {
    if constexpr(has_clear_<Container>::value) {
      for(Container &cell : cells_) {
        cell.clear();
      }
    } else {
      cells_.assign(cells_.size(), prototype_);
    }
  }

  [[nodiscard]] inline int rows() const {
    return shape_.height;
  }

  [[nodiscard]] inline int cols() const {
    return shape_.width;
  }

  [[nodiscard]] inline cv::Size size() const {
    return shape_;
  }

  [[nodiscard]] inline cv::Size cellSize() const {
    return cell_;
  }

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

  [[nodiscard]] inline auto begin() {
    return cells_.begin();
  }
 
  [[nodiscard]] inline auto end() {
    return cells_.end();
  }
 
  [[nodiscard]] inline auto begin() const {
    return cells_.begin();
  }
 
  [[nodiscard]] inline auto end() const {
    return cells_.end();
  }
 
private:
  cv::Size sensor_;
  cv::Size shape_;
  cv::Size cell_;
  Container prototype_;
  std::vector<Container> cells_;
 
  [[nodiscard]] inline std::size_t index_(const cv::Point c) const {
    return (static_cast<std::size_t>(c.y) * static_cast<std::size_t>(shape_.width)) + static_cast<std::size_t>(c.x);
  }
 
  static inline void push_(Container &container, const EventType &e) {
    if constexpr(has_push_<Container>::value) {
      container.push(e);
    } else {
      container.push_back(e);
    }
  }
};
} // namespace ev
 
#endif // OPENEV_CONTAINERS_GRID_HPP