abstract-reader.hpp

Go to the documentation of this file.

#ifndef OPENEV_READERS_ABSTRACT_READER_HPP
#define OPENEV_READERS_ABSTRACT_READER_HPP
 
#include "openev/containers/concurrent_queue.hpp"
#include "openev/core/types.hpp"
#include <array>
#include <atomic>
#include <cstddef>
#include <memory>
#include <opencv2/core/types.hpp>
#include <thread>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_ABSTRACT_READER_HPP = true;

class AbstractReader_ {
public:
  AbstractReader_() = default;
  virtual ~AbstractReader_();
  AbstractReader_(const AbstractReader_ &) = delete;
  AbstractReader_(AbstractReader_ &&) noexcept = delete;
  AbstractReader_ &operator=(const AbstractReader_ &) = delete;
  AbstractReader_ &operator=(AbstractReader_ &&) noexcept = delete;

  [[nodiscard]] inline ConcurrentQueue &events(const std::size_t n = 0) {
    if(n == 0 && queue_) {
      return *queue_;
    }
    return fill_(n);
  }

  void prefetch(const std::size_t n);

  [[nodiscard]] inline std::size_t prefetchCapacity() const {
    return level_;
  }

  void reset();

  void setTimeTransform(const TimeType offset, const TimeType scale = 1);

  void setRoi(const cv::Rect &roi);

  [[nodiscard]] inline cv::Rect getRoi() const {
    return roi_;
  }
 
protected:
  virtual std::size_t read_(Event *events, const std::size_t max) = 0;
  virtual void reset_() = 0;
  bool stop_();
 
private:
  std::unique_ptr<ConcurrentQueue> queue_;
  std::thread thread_;
  std::atomic<bool> running_{false};
  std::atomic<bool> finished_{false};
  std::size_t level_{0};
  TimeType timeOffset_{0};
  TimeType timeScale_{1};
  cv::Rect roi_;
 
  static constexpr std::size_t BLOCK = 512;
  std::array<Event, BLOCK> block_;
  std::size_t blockPos_{0};
  std::size_t blockCount_{0};
 
  ConcurrentQueue &fill_(const std::size_t n);
  void readBlock_(const std::size_t max);
  void resize_(const std::size_t capacity);
  void start_();
};
 
} // namespace ev
 
#endif // OPENEV_READERS_ABSTRACT_READER_HPP