reader_base.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2014 University of Edinburgh, Imperial College London, University of Manchester
 * SPDX-FileCopyrightText: 2016-2019 Emanuele Vespa
 * SPDX-FileCopyrightText: 2020-2023 Smart Robotics Lab, Imperial College London, Technical University of Munich
 * SPDX-FileCopyrightText: 2020-2022 Nils Funk
 * SPDX-FileCopyrightText: 2020-2023 Sotiris Papatheodorou
 * SPDX-FileCopyrightText: 2022-2024 Simon Boche
 * SPDX-License-Identifier: MIT
 */
 
#ifndef __READER_BASE_HPP
#define __READER_BASE_HPP
 
#include <Eigen/Geometry>
#include <chrono>
#include <fstream>
#include <se/common/str_utils.hpp>
#include <se/image/image.hpp>
 
namespace se {
 
enum class ReaderType {
    OPENNI,
    RAW,
    TUM,
    INTERIORNET,
    NEWERCOLLEGE,
    LEICA,
    UNKNOWN
};
 
ReaderType string_to_reader_type(const std::string& s);
 
std::string reader_type_to_string(ReaderType t);
 
 
enum class ReaderStatus : int {
    ok = 0,
    skip,
    eof,
    error,
};
 
std::ostream& operator<<(std::ostream& os, const ReaderStatus& s);
 
 
 
class Reader {
    public:
    struct Config {
        ReaderType reader_type = se::ReaderType::RAW;
 
        std::string sequence_path;
 
        std::string ground_truth_file;
 
        float inverse_scale = 0.0f;
 
        float fps = 0.0f;
 
        bool drop_frames = false;
 
        int verbose = 0;
 
        Eigen::Isometry3f T_BL = Eigen::Isometry3f::Identity();
 
        float scan_time_interval = 1.0;
 
        void readYaml(const std::string& filename);
    };
 
 
    Reader(const Config& c);
 
    virtual ~Reader(){};
 
    ReaderStatus nextData(Image<float>& depth_image);
 
    ReaderStatus nextData(Image<float>& depth_image, Eigen::Isometry3f& T_WB);
 
    ReaderStatus nextData(Image<float>& depth_image, Image<RGB>& colour_image);
 
 
    ReaderStatus nextData(Eigen::Vector3f& ray_measurement, Eigen::Isometry3f& T_WB);
 
    ReaderStatus
    nextData(const float batch_interval,
             std::vector<std::pair<Eigen::Isometry3f, Eigen::Vector3f>,
                         Eigen::aligned_allocator<std::pair<Eigen::Isometry3f, Eigen::Vector3f>>>&
                 rayPoseBatch);
 
    ReaderStatus
    nextData(Image<float>& depth_image, Image<RGB>& colour_image, Eigen::Isometry3f& T_WB);
 
    ReaderStatus getPose(Eigen::Isometry3f& T_WB, const size_t frame);
 
    virtual void restart() = 0;
 
    virtual std::string name() const = 0;
 
    bool good() const;
 
    size_t frame() const;
 
    size_t numFrames() const;
 
    Eigen::Vector2i depthImageRes() const;
 
    Eigen::Vector2i colourImageRes() const;
 
    bool isLiveReader() const;
 
    bool hasColour() const;
 
    static ReaderStatus mergeStatus(ReaderStatus status_1, ReaderStatus status_2);
 
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
    protected:
    std::string sequence_path_;
    std::string ground_truth_file_;
    std::ifstream ground_truth_fs_;
    Eigen::Vector2i depth_image_res_;
    Eigen::Vector2i colour_image_res_;
    float fps_;
    double spf_;
    bool drop_frames_;
    int verbose_;
    bool is_live_reader_;
    ReaderStatus status_;
    size_t frame_;
    size_t num_frames_;
    bool has_colour_;
 
 
    ReaderStatus readPose(Eigen::Isometry3f& T_WB, const size_t frame, const char delimiter = ' ');
 
 
    virtual ReaderStatus nextPose(Eigen::Isometry3f& T_WB);
 
    virtual ReaderStatus nextColour(Image<RGB>& colour_image);
 
 
    private:
    size_t ground_truth_frame_;
    char ground_truth_delimiter_;
    std::chrono::steady_clock::time_point prev_frame_timestamp_;
 
    void nextFrame();
 
    virtual ReaderStatus nextRay(Eigen::Vector3f& ray_measurement);
 
    virtual ReaderStatus nextRayBatch(
        const float batch_interval,
        std::vector<std::pair<Eigen::Isometry3f, Eigen::Vector3f>,
                    Eigen::aligned_allocator<std::pair<Eigen::Isometry3f, Eigen::Vector3f>>>&
            rayPoseBatch);
    virtual ReaderStatus nextDepth(Image<float>& depth_image) = 0;
 
    ReaderStatus
    nextDataImpl(Image<float>& depth_image, Image<RGB>* colour_image, Eigen::Isometry3f* T_WB);
};
 
std::ostream& operator<<(std::ostream& os, const Reader::Config& c);
 
} // namespace se
 
static inline std::ostream& operator<<(std::ostream& out, se::Reader* reader)
{
    out << se::str_utils::header_to_pretty_str("READER") << "\n";
    out << se::str_utils::str_to_pretty_str(reader->name(), "Reader type") << "\n";
    out << se::str_utils::str_to_pretty_str(
        ((reader->numFrames() == 0) ? "Unknown" : std::to_string(reader->numFrames())),
        "Number frames")
        << "\n";
    out << "\n";
    return out;
}
 
 
#endif