abstract-container.hpp

Go to the documentation of this file.

#ifndef OPENEV_CONTAINERS_ABSTRACT_CONTAINER_HPP
#define OPENEV_CONTAINERS_ABSTRACT_CONTAINER_HPP
 
#include "openev/core/types.hpp"
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <opencv2/core/base.hpp>
#include <opencv2/core/types.hpp>
#include <type_traits>
#include <vector>
 
namespace ev {
template <typename Container, typename T>
class AbstractContainer_ {
public:
  using ResultType = TimeType;

  [[nodiscard]] inline ResultType duration() const {
    check_("duration");
    return self_().back().t - self_().front().t;
  }

  [[nodiscard]] inline ResultType rate() const {
    check_("rate");
    const ResultType span = duration();
    if(span == 0) {
      CV_Error(cv::Error::StsDivByZero, "ev::AbstractContainer_::rate: the events span no time.");
    }
    return static_cast<ResultType>(self_().size()) / span;
  }

  [[nodiscard]] inline ResultType midTime() const {
    check_("midTime");
    return 0.5 * (self_().front().t + self_().back().t);
  }

  [[nodiscard]] inline Event_<ResultType> mean() const {
    check_("mean");
    ResultType x{0};
    ResultType y{0};
    ResultType t{0};
    ResultType p{0};
    for(const Event_<T> &e : self_()) {
      x += e.x;
      y += e.y;
      t += e.t;
      p += e.p;
    }
    const auto n = static_cast<ResultType>(self_().size());
    return {x / n, y / n, t / n, p / n > 0.5};
  }

  [[nodiscard]] inline cv::Point_<ResultType> meanPoint() const {
    check_("meanPoint");
    ResultType x{0};
    ResultType y{0};
    for(const Event_<T> &e : self_()) {
      x += e.x;
      y += e.y;
    }
    const auto n = static_cast<ResultType>(self_().size());
    return {x / n, y / n};
  }

  [[nodiscard]] inline ResultType meanTime() const {
    check_("meanTime");
    ResultType t{0};
    for(const Event_<T> &e : self_()) {
      t += e.t;
    }
    return t / static_cast<ResultType>(self_().size());
  }

  [[nodiscard]] inline ResultType entropy() const {
    check_("entropy");
    std::vector<cv::Point> pixels;
    pixels.reserve(self_().size());
    for(const Event_<T> &e : self_()) {
      pixels.push_back(pixel_(e));
    }
    return entropy_(pixels);
  }
 
protected:
  [[nodiscard]] inline const Container &self_() const {
    return static_cast<const Container &>(*this);
  }
 
  inline void check_(const char *statistic) const {
    if(self_().empty()) {
      CV_Error(cv::Error::StsError, std::string("ev::AbstractContainer_::") + statistic + ": the container is empty.");
    }
  }
 
  [[nodiscard]] inline static cv::Point pixel_(const Event_<T> &e) {
    if constexpr(std::is_floating_point_v<T>) {
      return {static_cast<int>(std::lround(e.x)), static_cast<int>(std::lround(e.y))};
    } else {
      return {static_cast<int>(e.x), static_cast<int>(e.y)};
    }
  }
 
  [[nodiscard]] inline static ResultType entropy_(const std::vector<cv::Point> &pixels) {
    constexpr uint64_t MAX_AREA_PER_EVENT = 32;
    const ResultType n = static_cast<ResultType>(pixels.size());
 
    int left = INT_MAX;
    int right = INT_MIN;
    int top = INT_MAX;
    int bottom = INT_MIN;
    for(const cv::Point &pixel : pixels) {
      left = std::min(left, pixel.x);
      right = std::max(right, pixel.x);
      top = std::min(top, pixel.y);
      bottom = std::max(bottom, pixel.y);
    }
 
    const auto width = static_cast<uint64_t>(static_cast<int64_t>(right) - static_cast<int64_t>(left) + 1);
    const auto height = static_cast<uint64_t>(static_cast<int64_t>(bottom) - static_cast<int64_t>(top) + 1);
 
    ResultType h{0};
    if(width <= (MAX_AREA_PER_EVENT * pixels.size()) / height) {
      std::vector<uint32_t> counts(width * height, 0);
      for(const cv::Point &pixel : pixels) {
        counts[(static_cast<uint64_t>(pixel.y - top) * width) + static_cast<uint64_t>(pixel.x - left)]++;
      }
      for(const uint32_t count : counts) {
        if(count > 0) {
          const ResultType p = static_cast<ResultType>(count) / n;
          h -= p * std::log2(p);
        }
      }
    } else {
      std::vector<uint64_t> keys;
      keys.reserve(pixels.size());
      for(const cv::Point &pixel : pixels) {
        keys.push_back((static_cast<uint64_t>(static_cast<uint32_t>(pixel.y)) << 32U) | static_cast<uint32_t>(pixel.x));
      }
      std::sort(keys.begin(), keys.end());
 
      std::size_t run = 1;
      for(std::size_t i = 1; i <= keys.size(); i++) {
        if(i == keys.size() || keys[i] != keys[i - 1]) {
          const ResultType p = static_cast<ResultType>(run) / n;
          h -= p * std::log2(p);
          run = 1;
        } else {
          run++;
        }
      }
    }
    return h;
  }
};
} // namespace ev
 
#endif // OPENEV_CONTAINERS_ABSTRACT_CONTAINER_HPP