Dataset.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// The MIT License (MIT)
//
// Copyright (c) 2018-2021 www.open3d.org
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// ----------------------------------------------------------------------------

#pragma once

#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

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 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