HDF5Reader.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <highfive/H5Easy.hpp>
#include <highfive/H5File.hpp>
#include <memory>
#include <string>
#include <vector>
 
#include <vulcan/io/TelemetrySchema.hpp>
 
namespace vulcan::io {

class HDF5Reader {
  public:
    explicit HDF5Reader(const std::string &filename)
        : impl_(std::make_unique<Impl>(filename)) {}
 
    ~HDF5Reader() = default;
 
    // Non-copyable, movable
    HDF5Reader(const HDF5Reader &) = delete;
    HDF5Reader &operator=(const HDF5Reader &) = delete;
    HDF5Reader(HDF5Reader &&) noexcept = default;
    HDF5Reader &operator=(HDF5Reader &&) noexcept = default;

    TelemetrySchema schema() const { return impl_->schema(); }

    size_t frame_count() const { return impl_->frame_count(); }

    std::vector<double> times() const { return impl_->times(); }

    std::vector<double> read_double(const std::string &signal) const {
        return impl_->read_double(signal);
    }

    std::vector<int32_t> read_int32(const std::string &signal) const {
        return impl_->read_int32(signal);
    }

    std::vector<int64_t> read_int64(const std::string &signal) const {
        return impl_->read_int64(signal);
    }

    std::vector<double> read_double(const std::string &signal, size_t start,
                                    size_t count) const {
        return impl_->read_double_slice(signal, start, count);
    }

    std::vector<Eigen::Vector3d> read_vec3(const std::string &signal) const {
        auto x = read_double(signal + ".x");
        auto y = read_double(signal + ".y");
        auto z = read_double(signal + ".z");
 
        std::vector<Eigen::Vector3d> result;
        result.reserve(x.size());
        for (size_t i = 0; i < x.size(); ++i) {
            result.emplace_back(x[i], y[i], z[i]);
        }
        return result;
    }

    std::vector<Eigen::Quaterniond> read_quat(const std::string &signal) const {
        auto w = read_double(signal + ".w");
        auto x = read_double(signal + ".x");
        auto y = read_double(signal + ".y");
        auto z = read_double(signal + ".z");
 
        std::vector<Eigen::Quaterniond> result;
        result.reserve(w.size());
        for (size_t i = 0; i < w.size(); ++i) {
            result.emplace_back(w[i], x[i], y[i], z[i]);
        }
        return result;
    }

    std::vector<std::string> signal_names() const {
        return impl_->signal_names();
    }
 
  private:
    struct Impl {
        HighFive::File file;
        mutable std::optional<TelemetrySchema> cached_schema;
 
        explicit Impl(const std::string &filename)
            : file(filename, HighFive::File::ReadOnly) {}
 
        TelemetrySchema schema() const {
            if (!cached_schema) {
                auto metadata = file.getGroup("metadata");
                std::string json;
                metadata.getAttribute("schema").read(json);
                cached_schema = TelemetrySchema::from_json(json);
            }
            return *cached_schema;
        }
 
        size_t frame_count() const {
            return file.getDataSet("time").getDimensions()[0];
        }
 
        std::vector<double> times() const {
            std::vector<double> result;
            file.getDataSet("time").read(result);
            return result;
        }
 
        std::vector<double> read_double(const std::string &signal) const {
            std::vector<double> result;
            file.getDataSet("signals/" + signal).read(result);
            return result;
        }
 
        std::vector<int32_t> read_int32(const std::string &signal) const {
            std::vector<int32_t> result;
            file.getDataSet("signals/" + signal).read(result);
            return result;
        }
 
        std::vector<int64_t> read_int64(const std::string &signal) const {
            std::vector<int64_t> result;
            file.getDataSet("signals/" + signal).read(result);
            return result;
        }
 
        std::vector<double> read_double_slice(const std::string &signal,
                                              size_t start,
                                              size_t count) const {
            auto ds = file.getDataSet("signals/" + signal);
            std::vector<double> result(count);
            ds.select({start}, {count}).read(result);
            return result;
        }
 
        std::vector<std::string> signal_names() const {
            auto signals = file.getGroup("signals");
            return signals.listObjectNames();
        }
    };
 
    std::unique_ptr<Impl> impl_;
};
 
} // namespace vulcan::io