abstract-dataset.hpp

Go to the documentation of this file.

#ifndef OPENEV_DATASETS_ABSTRACT_DATASET_HPP
#define OPENEV_DATASETS_ABSTRACT_DATASET_HPP
 
#include "openev/containers/concurrent_queue.hpp"
#include "openev/core/frames.hpp"
#include "openev/core/imu.hpp"
#include "openev/readers/abstract-reader.hpp"
#include <cstddef>
#include <functional>
#include <memory>
#include <opencv2/core/types.hpp>
#include <string>
#include <vector>
 
namespace ev {
[[maybe_unused]] constexpr bool USING_ABSTRACT_DATASET_HPP = true;

class AbstractDataset {
public:
  using Progress = std::function<void(double, double)>;
 
  AbstractDataset() = default;
  virtual ~AbstractDataset() = default;
  AbstractDataset(const AbstractDataset &) = delete;
  AbstractDataset(AbstractDataset &&) noexcept = default;
  AbstractDataset &operator=(const AbstractDataset &) = delete;
  AbstractDataset &operator=(AbstractDataset &&) noexcept = default;

  [[nodiscard]] virtual std::string name() const = 0;

  [[nodiscard]] virtual std::string shortname() const = 0;

  [[nodiscard]] virtual std::vector<std::string> sequences() const = 0;

  [[nodiscard]] virtual std::string url(const std::string &sequence) const = 0;

  [[nodiscard]] virtual cv::Size sensorSize(const std::string &sequence) const = 0;

  [[nodiscard]] virtual std::string cameraName(const std::string &sequence) const = 0;

  [[nodiscard]] static std::string cacheDirectory();

  void setDirectory(const std::string &directory);

  [[nodiscard]] std::string directory() const;

  [[nodiscard]] std::string path(const std::string &sequence) const;

  [[nodiscard]] bool isAvailable(const std::string &sequence) const;

  bool download(const std::string &sequence, const Progress &progress = nullptr);

  bool open(const std::string &sequence, const Progress &progress = nullptr);

  void close();

  [[nodiscard]] inline bool isOpen() const {
    return reader_ != nullptr;
  }

  [[nodiscard]] inline const std::string &sequence() const {
    return sequence_;
  }

  [[nodiscard]] inline ConcurrentQueue &events(const std::size_t n = 0) {
    return reader_->events(n);
  }

  inline void prefetch(const std::size_t n) {
    reader_->prefetch(n);
  }

  [[nodiscard]] inline std::size_t prefetchCapacity() const {
    return reader_->prefetchCapacity();
  }

  inline void setRoi(const cv::Rect &roi) {
    reader_->setRoi(roi);
  }

  [[nodiscard]] inline cv::Rect getRoi() const {
    const cv::Rect roi = reader_->getRoi();
    return roi.empty() ? cv::Rect(cv::Point(0, 0), sensorSize(sequence_)) : roi;
  }

  inline void reset() {
    reader_->reset();
  }

  [[nodiscard]] inline const FrameFileVector &frames() const {
    return frames_;
  }

  [[nodiscard]] inline const ImuVector &imu() const {
    return imu_;
  }

  [[nodiscard]] inline const std::string &error() const {
    return error_;
  }
 
protected:
  [[nodiscard]] virtual bool isComplete_(const std::string &path) const = 0;
  virtual void load_(const std::string &sequence) = 0;
  void assign_(std::unique_ptr<AbstractReader_> reader, FrameFileVector frames, ImuVector imu);
  std::string error_;
 
private:
  std::string directory_;
  std::string sequence_;
  std::unique_ptr<AbstractReader_> reader_;
  FrameFileVector frames_;
  ImuVector imu_;
};
 
} // namespace ev
 
#endif // OPENEV_DATASETS_ABSTRACT_DATASET_HPP