queue.hpp

Go to the documentation of this file.

#ifndef OPENEV_CONTAINERS_QUEUE_HPP
#define OPENEV_CONTAINERS_QUEUE_HPP
 
#include "openev/containers/array.hpp"
#include "openev/containers/vector.hpp"
#include "openev/core/types.hpp"
#include <cstddef>
#include <opencv2/core/types.hpp>
#include <queue>
#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 Queue_ : public std::queue<Event_<T>> {
  using std::queue<Event_<T>>::queue;
 
public:
  inline void push(const Event_<T> &e) {
    std::queue<Event_<T>>::push(e);
  }

  template <std::size_t N>
  inline void push(const Array_<T, N> &array) {
    for(const Event_<T> &e : array) {
      std::queue<Event_<T>>::emplace(std::move(e));
    }
  }

  inline void push(const Vector_<T> &vector) {
    for(const Event_<T> &e : vector) {
      std::queue<Event_<T>>::emplace(std::move(e));
    }
  }

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

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

  [[nodiscard]] Eventd mean() {
    const std::size_t n = std::queue<Event_<T>>::size();
    double x{0};
    double y{0};
    double t{0};
    double p{0};
 
    while(!std::queue<Event_<T>>::empty()) {
      const Event_<T> &e = std::queue<Event_<T>>::front();
      x += e.x;
      y += e.y;
      t += e.t;
      p += e.p;
      std::queue<Event_<T>>::pop();
    }
 
    return {x / n, y / n, t / n, p / n > 0.5};
  }

  [[nodiscard]] inline cv::Point2d meanPoint() {
    const std::size_t n = std::queue<Event_<T>>::size();
    double x{0};
    double y{0};
 
    while(!std::queue<Event_<T>>::empty()) {
      const Event_<T> &e = std::queue<Event_<T>>::front();
      x += e.x;
      y += e.y;
      std::queue<Event_<T>>::pop();
    }
 
    return {x / n, y / n};
  }

  [[nodiscard]] inline double meanTime() {
    const std::size_t n = std::queue<Event_<T>>::size();
    double t{0};
 
    while(!std::queue<Event_<T>>::empty()) {
      t += std::queue<Event_<T>>::front().t;
      std::queue<Event_<T>>::pop();
    }
 
    return t / n;
  }

  [[nodiscard]] inline double midTime() const {
    return 0.5 * (std::queue<Event_<T>>::front().t + std::queue<Event_<T>>::back().t);
  }
};
using Queuei = Queue_<int>;    
using Queuel = Queue_<long>;   
using Queuef = Queue_<float>;  
using Queued = Queue_<double>; 
using Queue = Queuei;          
} // namespace ev
 
#endif // OPENEV_CONTAINERS_QUEUE_HPP