Dataset.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2023 www.open3d.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "open3d/utility/Eigen.h"
 
namespace open3d {
namespace data {
 
std::string LocateDataRoot();
 
std::string Open3DDownloadsPrefix();
 
class Dataset {
public:
    Dataset(const std::string& prefix, const std::string& data_root = "");
 
    virtual ~Dataset() {}
 
    const std::string GetDataRoot() const { return data_root_; }
 
    const std::string GetPrefix() const { return prefix_; }
 
    const std::string GetDownloadDir() const {
        return GetDataRoot() + "/download/" + GetPrefix();
    }
 
    const std::string GetExtractDir() const {
        return GetDataRoot() + "/extract/" + GetPrefix();
    }
 
protected:
    std::string data_root_;
 
    std::string prefix_;
 
    void CheckPathsExist(const std::vector<std::string>& paths) const;
};
 
struct DataDescriptor {
    DataDescriptor(const std::vector<std::string>& urls,
                   const std::string& md5,
                   const std::string& extract_in_subdir = "")
        : urls_(urls), md5_(md5), extract_in_subdir_(extract_in_subdir) {}
 
    DataDescriptor(const std::string& url,
                   const std::string& md5,
                   const std::string& extract_in_subdir = "")
        : DataDescriptor(
                  std::vector<std::string>{url}, md5, extract_in_subdir) {}
 
    std::vector<std::string> urls_;
 
    std::string md5_;
 
    std::string extract_in_subdir_ = "";
};
 
class DownloadDataset : public Dataset {
public:
    DownloadDataset(const std::string& prefix,
                    const DataDescriptor& data_descriptor,
                    const std::string& data_root = "");
 
    DownloadDataset(const std::string& prefix,
                    const std::vector<DataDescriptor>& data_descriptors,
                    const std::string& data_root = "");
 
    virtual ~DownloadDataset() {}
 
protected:
    bool HasDownloaded(const DataDescriptor& data_descriptor) const;
    std::vector<DataDescriptor> data_descriptors_;
};
 
class ArmadilloMesh : public DownloadDataset {
public:
    ArmadilloMesh(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class AvocadoModel : public DownloadDataset {
public:
    AvocadoModel(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class BedroomRGBDImages : public DownloadDataset {
public:
    BedroomRGBDImages(const std::string& data_root = "");
 
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
 
    std::string GetTrajectoryLogPath() const { return trajectory_log_path_; }
    std::string GetReconstructionPath() const { return reconstruction_path_; }
 
private:
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
 
    std::string trajectory_log_path_;
    std::string reconstruction_path_;
};
 
class BunnyMesh : public DownloadDataset {
public:
    BunnyMesh(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class CrateModel : public DownloadDataset {
public:
    CrateModel(const std::string& data_root = "");
 
    std::string GetPath(const std::string filename = "crate_model") const {
        return map_filename_to_path_.at(filename);
    }
 
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class DamagedHelmetModel : public DownloadDataset {
public:
    DamagedHelmetModel(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class DemoColoredICPPointClouds : public DownloadDataset {
public:
    DemoColoredICPPointClouds(const std::string& data_root = "");
 
    std::vector<std::string> GetPaths() const { return paths_; }
    std::string GetPaths(size_t index) const;
 
private:
    // List of path to PCD point-cloud fragments.
    std::vector<std::string> paths_;
};
 
class DemoCropPointCloud : public DownloadDataset {
public:
    DemoCropPointCloud(const std::string& data_root = "");
 
    std::string GetPointCloudPath() const { return point_cloud_path_; }
    std::string GetCroppedJSONPath() const { return cropped_json_path_; }
 
private:
    // Path to example point cloud.
    std::string point_cloud_path_;
    // Path to saved selected polygon volume file.
    std::string cropped_json_path_;
};
 
class DemoCustomVisualization : public DownloadDataset {
public:
    DemoCustomVisualization(const std::string& data_root = "");
 
    std::string GetPointCloudPath() const { return point_cloud_path_; }
    std::string GetTrajectoryPath() const { return camera_trajectory_path_; }
    std::string GetRenderOptionPath() const { return render_option_path_; }
 
private:
    std::string point_cloud_path_;
    std::string camera_trajectory_path_;
    std::string render_option_path_;
};
 
class DemoDopplerICPSequence : public DownloadDataset {
public:
    DemoDopplerICPSequence(const std::string& data_root = "");
 
    std::vector<std::string> GetPaths() const { return paths_; }
    std::string GetPath(std::size_t index) const;
    std::string GetCalibrationPath() const { return calibration_path_; }
    std::string GetTrajectoryPath() const { return trajectory_path_; }
    bool GetCalibration(Eigen::Matrix4d& calibration, double& period) const;
    std::vector<std::pair<double, Eigen::Matrix4d>> GetTrajectory() const;
 
private:
    std::vector<std::string> paths_;
    std::string calibration_path_;
    std::string trajectory_path_;
};
 
class DemoFeatureMatchingPointClouds : public DownloadDataset {
public:
    DemoFeatureMatchingPointClouds(const std::string& data_root = "");
 
    std::vector<std::string> GetPointCloudPaths() const {
        return point_cloud_paths_;
    }
    std::vector<std::string> GetFPFHFeaturePaths() const {
        return fpfh_feature_paths_;
    }
    std::vector<std::string> GetL32DFeaturePaths() const {
        return l32d_feature_paths_;
    }
 
private:
    std::vector<std::string> point_cloud_paths_;
    std::vector<std::string> fpfh_feature_paths_;
    std::vector<std::string> l32d_feature_paths_;
};
 
class DemoICPPointClouds : public DownloadDataset {
public:
    DemoICPPointClouds(const std::string& data_root = "");
 
    std::vector<std::string> GetPaths() const { return paths_; }
    std::string GetPaths(size_t index) const;
    std::string GetTransformationLogPath() const {
        return transformation_log_path_;
    }
 
private:
    // List of path to PCD point-cloud fragments.
    std::vector<std::string> paths_;
    std::string transformation_log_path_;
};
 
class DemoPoseGraphOptimization : public DownloadDataset {
public:
    DemoPoseGraphOptimization(const std::string& data_root = "");
 
    std::string GetPoseGraphFragmentPath() const {
        return pose_graph_fragment_path_;
    }
    std::string GetPoseGraphGlobalPath() const {
        return pose_graph_global_path_;
    }
 
private:
    std::string pose_graph_fragment_path_;
    std::string pose_graph_global_path_;
};
 
class EaglePointCloud : public DownloadDataset {
public:
    EaglePointCloud(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class FlightHelmetModel : public DownloadDataset {
public:
    FlightHelmetModel(const std::string& data_root = "");
 
    std::string GetPath(const std::string filename = "flight_helmet") const {
        return map_filename_to_path_.at(filename);
    }
 
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class JackJackL515Bag : public DownloadDataset {
public:
    JackJackL515Bag(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class JuneauImage : public DownloadDataset {
public:
    JuneauImage(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class KnotMesh : public DownloadDataset {
public:
    KnotMesh(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class LivingRoomPointClouds : public DownloadDataset {
public:
    LivingRoomPointClouds(const std::string& data_root = "");
 
    std::vector<std::string> GetPaths() const { return paths_; }
    std::string GetPaths(size_t index) const;
 
private:
    std::vector<std::string> paths_;
};
 
class LoungeRGBDImages : public DownloadDataset {
public:
    LoungeRGBDImages(const std::string& data_root = "");
 
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
 
    std::string GetTrajectoryLogPath() const { return trajectory_log_path_; }
    std::string GetReconstructionPath() const { return reconstruction_path_; }
 
private:
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
 
    std::string trajectory_log_path_;
    std::string reconstruction_path_;
};
 
class MetalTexture : public DownloadDataset {
public:
    MetalTexture(const std::string& data_root = "");
    std::string GetAlbedoTexturePath() const {
        return map_filename_to_path_.at("albedo");
    }
    std::string GetNormalTexturePath() const {
        return map_filename_to_path_.at("normal");
    }
    std::string GetRoughnessTexturePath() const {
        return map_filename_to_path_.at("roughness");
    }
    std::string GetMetallicTexturePath() const {
        return map_filename_to_path_.at("metallic");
    }
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class MonkeyModel : public DownloadDataset {
public:
    MonkeyModel(const std::string& data_root = "");
 
    std::string GetPath(const std::string filename = "monkey_model") const {
        return map_filename_to_path_.at(filename);
    }
 
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class OfficePointClouds : public DownloadDataset {
public:
    OfficePointClouds(const std::string& data_root = "");
 
    std::vector<std::string> GetPaths() const { return paths_; }
    std::string GetPaths(size_t index) const;
 
private:
    std::vector<std::string> paths_;
};
 
class PCDPointCloud : public DownloadDataset {
public:
    PCDPointCloud(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class PLYPointCloud : public DownloadDataset {
public:
    PLYPointCloud(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class PTSPointCloud : public DownloadDataset {
public:
    PTSPointCloud(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class PaintedPlasterTexture : public DownloadDataset {
public:
    PaintedPlasterTexture(const std::string& data_root = "");
    std::string GetAlbedoTexturePath() const {
        return map_filename_to_path_.at("albedo");
    }
    std::string GetNormalTexturePath() const {
        return map_filename_to_path_.at("normal");
    }
    std::string GetRoughnessTexturePath() const {
        return map_filename_to_path_.at("roughness");
    }
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class RedwoodIndoorLivingRoom1 : public DownloadDataset {
public:
    RedwoodIndoorLivingRoom1(const std::string& data_root = "");
 
    std::string GetPointCloudPath() const { return point_cloud_path_; }
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
    std::vector<std::string> GetNoisyDepthPaths() const {
        return noisy_depth_paths_;
    }
    std::string GetONIPath() const { return oni_path_; }
    std::string GetTrajectoryPath() const { return trajectory_path_; }
    std::string GetNoiseModelPath() const { return noise_model_path_; }
 
private:
    std::string point_cloud_path_;
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
    std::vector<std::string> noisy_depth_paths_;
    std::string oni_path_;
    std::string trajectory_path_;
    std::string noise_model_path_;
};
 
class RedwoodIndoorLivingRoom2 : public DownloadDataset {
public:
    RedwoodIndoorLivingRoom2(const std::string& data_root = "");
 
    std::string GetPointCloudPath() const { return point_cloud_path_; }
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
    std::vector<std::string> GetNoisyDepthPaths() const {
        return noisy_depth_paths_;
    }
    std::string GetONIPath() const { return oni_path_; }
    std::string GetTrajectoryPath() const { return trajectory_path_; }
    std::string GetNoiseModelPath() const { return noise_model_path_; }
 
private:
    std::string point_cloud_path_;
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
    std::vector<std::string> noisy_depth_paths_;
    std::string oni_path_;
    std::string trajectory_path_;
    std::string noise_model_path_;
};
 
class RedwoodIndoorOffice1 : public DownloadDataset {
public:
    RedwoodIndoorOffice1(const std::string& data_root = "");
 
    std::string GetPointCloudPath() const { return point_cloud_path_; }
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
    std::vector<std::string> GetNoisyDepthPaths() const {
        return noisy_depth_paths_;
    }
    std::string GetONIPath() const { return oni_path_; }
    std::string GetTrajectoryPath() const { return trajectory_path_; }
    std::string GetNoiseModelPath() const { return noise_model_path_; }
 
private:
    std::string point_cloud_path_;
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
    std::vector<std::string> noisy_depth_paths_;
    std::string oni_path_;
    std::string trajectory_path_;
    std::string noise_model_path_;
};
 
class RedwoodIndoorOffice2 : public DownloadDataset {
public:
    RedwoodIndoorOffice2(const std::string& data_root = "");
 
    std::string GetPointCloudPath() const { return point_cloud_path_; }
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
    std::vector<std::string> GetNoisyDepthPaths() const {
        return noisy_depth_paths_;
    }
    std::string GetONIPath() const { return oni_path_; }
    std::string GetTrajectoryPath() const { return trajectory_path_; }
    std::string GetNoiseModelPath() const { return noise_model_path_; }
 
private:
    std::string point_cloud_path_;
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
    std::vector<std::string> noisy_depth_paths_;
    std::string oni_path_;
    std::string trajectory_path_;
    std::string noise_model_path_;
};
 
class SampleFountainRGBDImages : public DownloadDataset {
public:
    SampleFountainRGBDImages(const std::string& data_root = "");
 
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
    std::string GetKeyframePosesLogPath() const {
        return keyframe_poses_log_path_;
    }
    std::string GetReconstructionPath() const { return reconstruction_path_; }
 
private:
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
    std::string keyframe_poses_log_path_;
    std::string reconstruction_path_;
};
 
class SampleL515Bag : public DownloadDataset {
public:
    SampleL515Bag(const std::string& data_root = "");
 
    std::string GetPath() const { return path_; }
 
private:
    std::string path_;
};
 
class SampleNYURGBDImage : public DownloadDataset {
public:
    SampleNYURGBDImage(const std::string& data_root = "");
 
    std::string GetColorPath() const { return color_path_; }
    std::string GetDepthPath() const { return depth_path_; }
 
private:
    std::string color_path_;
    std::string depth_path_;
};
 
// Additionally it also contains camera trajectory log, camera odometry log,
// rgbd match, and point cloud reconstruction obtained using TSDF.
class SampleRedwoodRGBDImages : public DownloadDataset {
public:
    SampleRedwoodRGBDImages(const std::string& data_root = "");
 
    std::vector<std::string> GetColorPaths() const { return color_paths_; }
    std::vector<std::string> GetDepthPaths() const { return depth_paths_; }
 
    std::string GetTrajectoryLogPath() const { return trajectory_log_path_; }
    std::string GetOdometryLogPath() const { return odometry_log_path_; }
    std::string GetRGBDMatchPath() const { return rgbd_match_path_; }
    std::string GetReconstructionPath() const { return reconstruction_path_; }
    std::string GetCameraIntrinsicPath() const {
        return camera_intrinsic_path_;
    }
 
private:
    std::vector<std::string> color_paths_;
    std::vector<std::string> depth_paths_;
 
    std::string trajectory_log_path_;
    std::string odometry_log_path_;
    std::string rgbd_match_path_;
    std::string reconstruction_path_;
    std::string camera_intrinsic_path_;
};
 
class SampleSUNRGBDImage : public DownloadDataset {
public:
    SampleSUNRGBDImage(const std::string& data_root = "");
 
    std::string GetColorPath() const { return color_path_; }
    std::string GetDepthPath() const { return depth_path_; }
 
private:
    std::string color_path_;
    std::string depth_path_;
};
 
class SampleTUMRGBDImage : public DownloadDataset {
public:
    SampleTUMRGBDImage(const std::string& data_root = "");
 
    std::string GetColorPath() const { return color_path_; }
    std::string GetDepthPath() const { return depth_path_; }
 
private:
    std::string color_path_;
    std::string depth_path_;
};
 
class SwordModel : public DownloadDataset {
public:
    SwordModel(const std::string& data_root = "");
 
    std::string GetPath(const std::string filename = "sword_model") const {
        return map_filename_to_path_.at(filename);
    }
 
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class TerrazzoTexture : public DownloadDataset {
public:
    TerrazzoTexture(const std::string& data_root = "");
    std::string GetAlbedoTexturePath() const {
        return map_filename_to_path_.at("albedo");
    }
    std::string GetNormalTexturePath() const {
        return map_filename_to_path_.at("normal");
    }
    std::string GetRoughnessTexturePath() const {
        return map_filename_to_path_.at("roughness");
    }
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class TilesTexture : public DownloadDataset {
public:
    TilesTexture(const std::string& data_root = "");
    std::string GetAlbedoTexturePath() const {
        return map_filename_to_path_.at("albedo");
    }
    std::string GetNormalTexturePath() const {
        return map_filename_to_path_.at("normal");
    }
    std::string GetRoughnessTexturePath() const {
        return map_filename_to_path_.at("roughness");
    }
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class WoodFloorTexture : public DownloadDataset {
public:
    WoodFloorTexture(const std::string& data_root = "");
    std::string GetAlbedoTexturePath() const {
        return map_filename_to_path_.at("albedo");
    }
    std::string GetNormalTexturePath() const {
        return map_filename_to_path_.at("normal");
    }
    std::string GetRoughnessTexturePath() const {
        return map_filename_to_path_.at("roughness");
    }
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
class WoodTexture : public DownloadDataset {
public:
    WoodTexture(const std::string& data_root = "");
    std::string GetAlbedoTexturePath() const {
        return map_filename_to_path_.at("albedo");
    }
    std::string GetNormalTexturePath() const {
        return map_filename_to_path_.at("normal");
    }
    std::string GetRoughnessTexturePath() const {
        return map_filename_to_path_.at("roughness");
    }
    std::unordered_map<std::string, std::string> GetPathMap() const {
        return map_filename_to_path_;
    }
 
private:
    std::unordered_map<std::string, std::string> map_filename_to_path_;
};
 
}  // namespace data
}  // namespace open3d