deque.hpp

Go to the documentation of this file.

#ifndef OPENEV_CONTAINERS_DEQUE_HPP
#define OPENEV_CONTAINERS_DEQUE_HPP
 
#include "openev/containers/array.hpp"
#include "openev/containers/vector.hpp"
#include "openev/core/types.hpp"
#include <cstddef>
#include <deque>
#include <numeric>
#include <opencv2/core/types.hpp>
#include <utility>
 
namespace ev {
#ifndef OPENEV_ARRAY_HPP
template <typename T, std::size_t N>
class Array_;
#endif
 
#ifndef OPENEV_VECTOR_HPP
template <typename T>
class Vector_;
#endif

template <typename T>
class Deque_ : public std::deque<Event_<T>> {
  using std::deque<Event_<T>>::deque;
 
public:
  inline void push_back(const Event_<T> &e) {
    std::deque<Event_<T>>::push_back(e);
  }

  template <std::size_t N>
  inline void push_back(const Array_<T, N> &array) {
    std::deque<Event_<T>>::insert(std::deque<Event_<T>>::end(), array.begin(), array.end());
  }

  inline void push_back(const Vector_<T> &vector) {
    std::deque<Event_<T>>::insert(std::deque<Event_<T>>::end(), vector.begin(), vector.end());
  }

  [[nodiscard]] inline double duration() const {
    return std::deque<Event_<T>>::back().t - std::deque<Event_<T>>::front().t;
  }

  [[nodiscard]] inline double rate() const {
    return std::deque<Event_<T>>::size() / duration();
  }

  [[nodiscard]] Eventd mean() {
    const double x = std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.x; }) / std::deque<Event_<T>>::size();
    const double y = std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.y; }) / std::deque<Event_<T>>::size();
    const double t = std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.t; }) / std::deque<Event_<T>>::size();
    const double p = std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.p; }) / std::deque<Event_<T>>::size();
    return {x, y, t, p > 0.5};
  }

  [[nodiscard]] inline cv::Point2d meanPoint() {
    const double x = std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.x; }) / std::deque<Event_<T>>::size();
    const double y = std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.y; }) / std::deque<Event_<T>>::size();
    return {x, y};
  }

  [[nodiscard]] inline double meanTime() {
    return std::accumulate(std::deque<Event_<T>>::begin(), std::deque<Event_<T>>::end(), 0.0, [](double sum, const Event_<T> &e) { return sum + e.t; }) / std::deque<Event_<T>>::size();
  }

  [[nodiscard]] inline double midTime() const {
    return 0.5 * (std::deque<Event_<T>>::front().t + std::deque<Event_<T>>::back().t);
  }
};
using Dequei = Deque_<int>;    
using Dequel = Deque_<long>;   
using Dequef = Deque_<float>;  
using Dequed = Deque_<double>; 
using Deque = Dequei;          
} // namespace ev
 
#endif // OPENEV_CONTAINERS_DEQUE_HPP