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-2022 Smart Robotics Lab, Imperial College London, Technical University of Munich
 * SPDX-FileCopyrightText: 2020-2022 Nils Funk
 * SPDX-FileCopyrightText: 2020-2022 Sotiris Papatheodorou
 * SPDX-License-Identifier: MIT
 */

#ifndef __READER_BASE_HPP
#define __READER_BASE_HPP

#include <Eigen/Dense>
#include <chrono>
#include <cstdint>
#include <fstream>
#include <string>

#include "se/common/str_utils.hpp"
#include "se/image/image.hpp"



namespace se {

enum class ReaderType {
    OPENNI,
    RAW,
    TUM,
    INTERIORNET,
    NEWERCOLLEGE,
    UNKNOWN
};

ReaderType string_to_reader_type(const std::string& s);

std::string reader_type_to_string(ReaderType t);



struct ReaderConfig {
    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;

    void readYaml(const std::string& filename);
};

std::ostream& operator<<(std::ostream& os, const ReaderConfig& c);



enum class ReaderStatus : int {
    ok = 0,
    skip,
    eof,
    error,
};

std::ostream& operator<<(std::ostream& os, const ReaderStatus& s);



class Reader {
    public:
    Reader(const ReaderConfig& c);

    virtual ~Reader(){};

    ReaderStatus nextData(Image<float>& depth_image);

    ReaderStatus nextData(Image<float>& depth_image, Image<uint32_t>& rgba_image);

    ReaderStatus
    nextData(Image<float>& depth_image, Image<uint32_t>& rgba_image, Eigen::Matrix4f& T_WB);

    ReaderStatus getPose(Eigen::Matrix4f& 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 RGBAImageRes() const;

    bool isLiveReader() 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 rgba_image_res_;
    float fps_;
    double spf_;
    bool drop_frames_;
    int verbose_;
    bool is_live_reader_;
    ReaderStatus status_;
    size_t frame_;
    size_t num_frames_;


    ReaderStatus readPose(Eigen::Matrix4f& T_WB, const size_t frame, const char delimiter = ' ');


    ReaderStatus nextPose(Eigen::Matrix4f& T_WB);

    private:
    size_t ground_truth_frame_;
    char ground_truth_delimiter_;
    std::chrono::steady_clock::time_point prev_frame_timestamp_;

    void nextFrame();

    virtual ReaderStatus nextDepth(Image<float>& depth_image) = 0;

    virtual ReaderStatus nextRGBA(Image<uint32_t>& rgba_image) = 0;
};

} // namespace se

static 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