persistent_queue.hpp

#ifndef OPENEV_CONTAINERS_PERSISTENT_QUEUE_HPP
#define OPENEV_CONTAINERS_PERSISTENT_QUEUE_HPP
 
#include "openev/containers/queue.hpp"
#include "openev/core/types.hpp"
#include <cstddef>
#include <opencv2/core/types.hpp>
 
namespace ev {
constexpr bool USING_PERSISTENT_QUEUE_HPP = true;

template <typename T>
class PersistentQueue_ : public Queue_<T> {
  using Queue_<T>::Queue_;
  using ResultType = TimeType;
 
public:
  [[nodiscard]] inline Event_<ResultType> mean() {
    const std::size_t n = Queue_<T>::size();
    ResultType x{0};
    ResultType y{0};
    ResultType t{0};
    ResultType p{0};
 
    for(int i = 0; i < n; i++) {
      const Event_<T> &e = Queue_<T>::front();
      x += e.x;
      y += e.y;
      t += e.t;
      p += e.p;
      Queue_<T>::pop();
      Queue_<T>::emplace(e);
    }
 
    return {x / n, y / n, t / n, p / n > 0.5};
  }

  [[nodiscard]] inline cv::Point_<ResultType> meanPoint() {
    const std::size_t n = Queue_<T>::size();
    ResultType x{0};
    ResultType y{0};
 
    for(int i = 0; i < n; i++) {
      const Event_<T> &e = Queue_<T>::front();
      x += e.x;
      y += e.y;
      Queue_<T>::pop();
      Queue_<T>::emplace(e);
    }
 
    return {x / n, y / n};
  }

  [[nodiscard]] inline ResultType meanTime() {
    const std::size_t n = Queue_<T>::size();
    ResultType t{0};
 
    for(int i = 0; i < n; i++) {
      t += Queue_<T>::front().t;
      Queue_<T>::emplace(Queue_<T>::front());
      Queue_<T>::pop();
    }
 
    return t / n;
  }
};
using PersistentQueuei = PersistentQueue_<int>;    
using PersistentQueuel = PersistentQueue_<long>;   
using PersistentQueuef = PersistentQueue_<float>;  
using PersistentQueued = PersistentQueue_<double>; 
using PersistentQueue = PersistentQueuei;          
} // namespace ev
 
#endif // OPENEV_CONTAINERS_PERSISTENT_QUEUE_HPP