ACloudViewer  3.9.4
A Modern Library for 3D Data Processing
dataset.cpp
Go to the documentation of this file.
1 // ----------------------------------------------------------------------------
2 // - CloudViewer: www.cloudViewer.org -
3 // ----------------------------------------------------------------------------
4 // Copyright (c) 2018-2024 www.cloudViewer.org
5 // SPDX-License-Identifier: MIT
6 // ----------------------------------------------------------------------------
7 
8 #include "pybind/data/dataset.h"
9 
10 #include "cloudViewer/data/Dataset.h"
11 #include "pybind/cloudViewer_pybind.h"
12 #include "pybind/docstring.h"
13 
14 namespace cloudViewer {
15 namespace data {
16 
17 template <class DatasetBase = Dataset>
18 class PyDataset : public DatasetBase {
19 public:
20  using DatasetBase::DatasetBase;
21 };
22 
23 template <class DownloadDatasetBase = DownloadDataset>
24 class PyDownloadDataset : public PyDataset<DownloadDatasetBase> {
25 public:
26  using PyDataset<DownloadDatasetBase>::PyDataset;
27 };
28 
29 void pybind_data_classes(py::module& m) {
30  // Dynamic getter/setter functions that always reflect current C++ state
31  m.def(
32  "get_custom_downloads_prefix",
33  []() { return GetCustomDownloadsPrefix(); },
34  "Get the current URL prefix for CloudViewer downloads");
35  m.def(
36  "set_custom_downloads_prefix",
37  [](const std::string& prefix) { SetCustomDownloadsPrefix(prefix); },
38  "Set the URL prefix for CloudViewer downloads", "prefix"_a);
39  m.attr("cloudViewer_downloads_prefix") =
40  py::cast(CloudViewerDownloadsPrefix());
41 
42  // cloudViewer.data.DataDescriptor
43  py::class_<DataDescriptor> data_descriptor(
44  m, "DataDescriptor",
45  "DataDescriptor is a class that describes a data file. It contains "
46  "the URL mirrors to download the file, the MD5 hash of the file, "
47  "and whether to extract the file.");
48  data_descriptor
49  .def(py::init([](const std::vector<std::string>& urls,
50  const std::string& md5,
51  const std::string& extract_in_subdir) {
52  return DataDescriptor{urls, md5, extract_in_subdir};
53  }),
54  "urls"_a, "md5"_a, "extract_in_subdir"_a = "")
55  .def(py::init([](const std::string& url, const std::string& md5,
56  const std::string& extract_in_subdir) {
57  return DataDescriptor{std::vector<std::string>{url}, md5,
58  extract_in_subdir};
59  }),
60  "url"_a, "md5"_a, "extract_in_subdir"_a = "")
61  .def_readonly("urls", &DataDescriptor::urls_,
62  "URL to download the data file.")
63  .def_readonly("md5", &DataDescriptor::md5_,
64  "MD5 hash of the data file.")
65  .def_readonly("extract_in_subdir",
66  &DataDescriptor::extract_in_subdir_,
67  "Subdirectory to extract the file. If empty, the "
68  "file will be extracted in the root extract "
69  "directory of the dataset.");
70 
71  // cloudViewer.data.Dataset
72  py::class_<Dataset, PyDataset<Dataset>, std::shared_ptr<Dataset>> dataset(
73  m, "Dataset", "The base dataset class.");
74  dataset.def(py::init<const std::string&, const std::string&>(), "prefix"_a,
75  "data_root"_a = "")
76  .def_property_readonly(
77  "data_root", &Dataset::GetDataRoot,
78  "Get data root directory. The data root is set at "
79  "construction time or automatically determined.")
80  .def_property_readonly("prefix", &Dataset::GetPrefix,
81  "Get prefix for the dataset.")
82  .def_property_readonly(
83  "download_dir", &Dataset::GetDownloadDir,
84  "Get absolute path to download directory. i.e. "
85  "${data_root}/${download_prefix}/${prefix}")
86  .def_property_readonly(
87  "extract_dir", &Dataset::GetExtractDir,
88  "Get absolute path to extract directory. i.e. "
89  "${data_root}/${extract_prefix}/${prefix}");
90  docstring::ClassMethodDocInject(m, "Dataset", "data_root");
91  docstring::ClassMethodDocInject(m, "Dataset", "prefix");
92  docstring::ClassMethodDocInject(m, "Dataset", "download_dir");
93  docstring::ClassMethodDocInject(m, "Dataset", "extract_dir");
94 
95  // cloudViewer.data.DownloadDataset
96  py::class_<DownloadDataset, PyDownloadDataset<DownloadDataset>,
97  std::shared_ptr<DownloadDataset>, Dataset>
98  single_download_dataset(m, "DownloadDataset",
99  "Single file download dataset class.");
100  single_download_dataset.def(
101  py::init<const std::string&, const DataDescriptor&,
102  const std::string&>(),
103  "prefix"_a, "data_descriptor"_a, "data_root"_a = "");
104 }
105 
106 void pybind_demo_icp_pointclouds(py::module& m) {
107  // cloudViewer.data.DemoICPPointClouds
108  py::class_<DemoICPPointClouds, PyDownloadDataset<DemoICPPointClouds>,
109  std::shared_ptr<DemoICPPointClouds>, DownloadDataset>
110  demo_icp_pointclouds(
111  m, "DemoICPPointClouds",
112  "Data class for `DemoICPPointClouds` contains "
113  "3 point clouds of binary PCD format. This "
114  "dataset is used in CloudViewer for ICP demo.");
115  demo_icp_pointclouds.def(py::init<const std::string&>(), "data_root"_a = "")
116  .def_property_readonly(
117  "paths",
118  [](const DemoICPPointClouds& demo_icp_pointclouds) {
119  return demo_icp_pointclouds.GetPaths();
120  },
121  "List of 3 point cloud paths. Use `paths[0]`, `paths[1]`, "
122  "and `paths[2]` to access the paths.")
123  .def_property_readonly(
124  "transformation_log_path",
125  &DemoICPPointClouds::GetTransformationLogPath,
126  "Path to the transformation metadata log file, containing "
127  "transformation between frame 0 and 1, and frame 1 and 2.");
128  docstring::ClassMethodDocInject(m, "DemoICPPointClouds", "paths");
129  docstring::ClassMethodDocInject(m, "DemoICPPointClouds",
130  "transformation_log_path");
131 }
132 
133 void pybind_demo_colored_icp_pointclouds(py::module& m) {
134  // cloudViewer.data.DemoColoredICPPointClouds
135  py::class_<DemoColoredICPPointClouds,
136  PyDownloadDataset<DemoColoredICPPointClouds>,
137  std::shared_ptr<DemoColoredICPPointClouds>, DownloadDataset>
138  demo_colored_icp_pointclouds(
139  m, "DemoColoredICPPointClouds",
140  "Data class for `DemoColoredICPPointClouds` contains "
141  "2 point clouds of `ply` format. This dataset is used in "
142  "CloudViewer for colored ICP demo.");
143  demo_colored_icp_pointclouds
144  .def(py::init<const std::string&>(), "data_root"_a = "")
145  .def_property_readonly(
146  "paths",
147  [](const DemoColoredICPPointClouds&
148  demo_colored_icp_pointclouds) {
149  return demo_colored_icp_pointclouds.GetPaths();
150  },
151  "List of 2 point cloud paths. Use `paths[0]`, and "
152  "`paths[1]`, to access the paths.");
153  docstring::ClassMethodDocInject(m, "DemoColoredICPPointClouds", "paths");
154 }
155 
156 void pybind_demo_crop_pointcloud(py::module& m) {
157  // cloudViewer.data.DemoCropPointCloud
158  py::class_<DemoCropPointCloud, PyDownloadDataset<DemoCropPointCloud>,
159  std::shared_ptr<DemoCropPointCloud>, DownloadDataset>
160  demo_crop_pointcloud(
161  m, "DemoCropPointCloud",
162  "Data class for `DemoCropPointCloud` contains a point "
163  "cloud, and `cropped.json` (a saved selected polygon "
164  "volume file). This dataset is used in CloudViewer for "
165  "point "
166  "cloud crop demo.");
167  demo_crop_pointcloud.def(py::init<const std::string&>(), "data_root"_a = "")
168  .def_property_readonly("point_cloud_path",
169  &DemoCropPointCloud::GetPointCloudPath,
170  "Path to the example point cloud.")
171  .def_property_readonly(
172  "cropped_json_path",
173  &DemoCropPointCloud::GetCroppedJSONPath,
174  "Path to the saved selected polygon volume file.");
175  docstring::ClassMethodDocInject(m, "DemoCropPointCloud",
176  "point_cloud_path");
177  docstring::ClassMethodDocInject(m, "DemoCropPointCloud",
178  "cropped_json_path");
179 }
180 
181 void pybind_demo_doppler_icp_sequence(py::module& m) {
182  // cloudViewer.data.DemoDopplerICPSequence
183  py::class_<DemoDopplerICPSequence,
184  PyDownloadDataset<DemoDopplerICPSequence>,
185  std::shared_ptr<DemoDopplerICPSequence>, DownloadDataset>
186  demo_doppler_icp_sequence(
187  m, "DemoDopplerICPSequence",
188  "Data class for `DemoDopplerICPSequence` contains an "
189  "example sequence of 100 point clouds with Doppler "
190  "velocity channel and corresponding ground truth poses. "
191  "The sequence was generated using the CARLA simulator.");
192  demo_doppler_icp_sequence
193  .def(py::init<const std::string&>(), "data_root"_a = "")
194  .def_property_readonly(
195  "paths", &DemoDopplerICPSequence::GetPaths,
196  "Returns list of the point cloud paths in the sequence.")
197  .def_property_readonly(
198  "calibration_path",
199  &DemoDopplerICPSequence::GetCalibrationPath,
200  "Path to the calibration metadata file, containing "
201  "transformation between the vehicle and sensor frames and "
202  "the time period.")
203  .def_property_readonly(
204  "trajectory_path",
205  &DemoDopplerICPSequence::GetTrajectoryPath,
206  "Path to the ground truth poses for the entire sequence.");
207  docstring::ClassMethodDocInject(m, "DemoDopplerICPSequence", "paths");
208  docstring::ClassMethodDocInject(m, "DemoDopplerICPSequence",
209  "calibration_path");
210  docstring::ClassMethodDocInject(m, "DemoDopplerICPSequence",
211  "trajectory_path");
212 }
213 
214 void pybind_demo_feature_matching_point_clouds(py::module& m) {
215  // cloudViewer.data.DemoFeatureMatchingPointClouds
216  py::class_<DemoFeatureMatchingPointClouds,
217  PyDownloadDataset<DemoFeatureMatchingPointClouds>,
218  std::shared_ptr<DemoFeatureMatchingPointClouds>, DownloadDataset>
219  demo_feature_matching(
220  m, "DemoFeatureMatchingPointClouds",
221  "Data class for `DemoFeatureMatchingPointClouds` contains "
222  "2 pointcloud fragments and their respective FPFH features "
223  "and L32D features. This dataset is used in CloudViewer "
224  "for "
225  "point cloud feature matching demo.");
226  demo_feature_matching
227  .def(py::init<const std::string&>(), "data_root"_a = "")
228  .def_property_readonly(
229  "point_cloud_paths",
230  &DemoFeatureMatchingPointClouds::GetPointCloudPaths,
231  "List of 2 point cloud paths. Use `point_cloud_paths[0]`, "
232  "and `point_cloud_paths[1]`, to access the paths.")
233  .def_property_readonly(
234  "fpfh_feature_paths",
235  &DemoFeatureMatchingPointClouds::GetFPFHFeaturePaths,
236  "List of 2 saved FPFH feature binary of the respective "
237  "point cloud paths. Use `fpfh_feature_paths[0]`, "
238  "and `fpfh_feature_paths[1]`, to access the paths.")
239  .def_property_readonly(
240  "l32d_feature_paths",
241  &DemoFeatureMatchingPointClouds::GetL32DFeaturePaths,
242  "List of 2 saved L32D feature binary of the respective "
243  "point cloud paths. Use `l32d_feature_paths[0]`, "
244  "and `l32d_feature_paths[1]`, to access the paths.");
245  docstring::ClassMethodDocInject(m, "DemoFeatureMatchingPointClouds",
246  "point_cloud_paths");
247  docstring::ClassMethodDocInject(m, "DemoFeatureMatchingPointClouds",
248  "fpfh_feature_paths");
249  docstring::ClassMethodDocInject(m, "DemoFeatureMatchingPointClouds",
250  "l32d_feature_paths");
251 }
252 
253 void pybind_demo_pose_graph_optimization(py::module& m) {
254  // cloudViewer.data.DemoPoseGraphOptimization
255  py::class_<DemoPoseGraphOptimization,
256  PyDownloadDataset<DemoPoseGraphOptimization>,
257  std::shared_ptr<DemoPoseGraphOptimization>, DownloadDataset>
258  demo_pose_graph_optimization(
259  m, "DemoPoseGraphOptimization",
260  "Data class for `DemoPoseGraphOptimization` contains an "
261  "example fragment pose graph, and global pose graph. This "
262  "dataset is used in CloudViewer for pose graph "
263  "optimization "
264  "demo.");
265  demo_pose_graph_optimization
266  .def(py::init<const std::string&>(), "data_root"_a = "")
267  .def_property_readonly(
268  "pose_graph_fragment_path",
269  &DemoPoseGraphOptimization::GetPoseGraphFragmentPath,
270  "Path to example global pose graph (json).")
271  .def_property_readonly(
272  "pose_graph_global_path",
273  &DemoPoseGraphOptimization::GetPoseGraphGlobalPath,
274  "Path to example fragment pose graph (json).");
275  docstring::ClassMethodDocInject(m, "DemoPoseGraphOptimization",
276  "pose_graph_fragment_path");
277  docstring::ClassMethodDocInject(m, "DemoPoseGraphOptimization",
278  "pose_graph_global_path");
279 }
280 
281 void pybind_demo_custom_visualization(py::module& m) {
282  // cloudViewer.data.DemoCustomVisualization
283  py::class_<DemoCustomVisualization,
284  PyDownloadDataset<DemoCustomVisualization>,
285  std::shared_ptr<DemoCustomVisualization>, DownloadDataset>
286  demo_custom_visualization(
287  m, "DemoCustomVisualization",
288  "Data class for `DemoCustomVisualization` contains an "
289  "example point-cloud, camera trajectory (json file), "
290  "rendering options (json file). This data is used in "
291  "CloudViewer for custom visualization with camera "
292  "trajectory "
293  "demo.");
294  demo_custom_visualization
295  .def(py::init<const std::string&>(), "data_root"_a = "")
296  .def_property_readonly("point_cloud_path",
297  &DemoCustomVisualization::GetPointCloudPath,
298  "Returns path to the point cloud (ply).")
299  .def_property_readonly(
300  "camera_trajectory_path",
301  &DemoCustomVisualization::GetTrajectoryPath,
302  "Returns path to the camera_trajectory.json.")
303  .def_property_readonly(
304  "render_option_path",
305  &DemoCustomVisualization::GetRenderOptionPath,
306  "Returns path to the renderoption.json.");
307  docstring::ClassMethodDocInject(m, "DemoCustomVisualization",
308  "point_cloud_path");
309  docstring::ClassMethodDocInject(m, "DemoCustomVisualization",
310  "camera_trajectory_path");
311  docstring::ClassMethodDocInject(m, "DemoCustomVisualization",
312  "render_option_path");
313 }
314 
315 void pybind_pcd_point_cloud(py::module& m) {
316  // cloudViewer.data.PCDPointCloud
317  py::class_<PCDPointCloud, PyDownloadDataset<PCDPointCloud>,
318  std::shared_ptr<PCDPointCloud>, DownloadDataset>
319  pcd_pointcloud(m, "PCDPointCloud",
320  "Data class for `PCDPointCloud` contains the "
321  "`fragment.pcd` point cloud mesh from the `Redwood "
322  "Living Room` dataset.");
323  pcd_pointcloud.def(py::init<const std::string&>(), "data_root"_a = "")
324  .def_property_readonly("path", &PCDPointCloud::GetPath,
325  "Path to the `pcd` format point cloud.");
326  docstring::ClassMethodDocInject(m, "PCDPointCloud", "path");
327 }
328 
329 void pybind_ply_point_cloud(py::module& m) {
330  // cloudViewer.data.PLYPointCloud
331  py::class_<PLYPointCloud, PyDownloadDataset<PLYPointCloud>,
332  std::shared_ptr<PLYPointCloud>, DownloadDataset>
333  ply_pointcloud(m, "PLYPointCloud",
334  "Data class for `PLYPointCloud` contains the "
335  "`fragment.pcd` point cloud mesh from the `Redwood "
336  "Living Room` dataset.");
337  ply_pointcloud.def(py::init<const std::string&>(), "data_root"_a = "")
338  .def_property_readonly("path", &PLYPointCloud::GetPath,
339  "Path to the `ply` format point cloud.");
340  docstring::ClassMethodDocInject(m, "PLYPointCloud", "path");
341 }
342 
343 void pybind_pts_point_cloud(py::module& m) {
344  // cloudViewer.data.PTSPointCloud
345  py::class_<PTSPointCloud, PyDownloadDataset<PTSPointCloud>,
346  std::shared_ptr<PTSPointCloud>, DownloadDataset>
347  pts_point_cloud(m, "PTSPointCloud",
348  "Data class for `PTSPointCloud` contains a sample "
349  "point-cloud of PTS format.");
350  pts_point_cloud.def(py::init<const std::string&>(), "data_root"_a = "")
351  .def_property_readonly("path", &PTSPointCloud::GetPath,
352  "Path to the PTS format point cloud.");
353  docstring::ClassMethodDocInject(m, "PTSPointCloud", "path");
354 }
355 
356 void pybind_sample_nyu_rgbd_image(py::module& m) {
357  // cloudViewer.data.SampleNYURGBDImage
358  py::class_<SampleNYURGBDImage, PyDownloadDataset<SampleNYURGBDImage>,
359  std::shared_ptr<SampleNYURGBDImage>, DownloadDataset>
360  rgbd_image_nyu(m, "SampleNYURGBDImage",
361  "Data class for `SampleNYURGBDImage` contains a "
362  "color image `NYU_color.ppm` and a depth image "
363  "`NYU_depth.pgm` sample from NYU RGBD dataset.");
364  rgbd_image_nyu.def(py::init<const std::string&>(), "data_root"_a = "")
365  .def_property_readonly("color_path",
366  &SampleNYURGBDImage::GetColorPath,
367  "Path to color image sample.")
368  .def_property_readonly("depth_path",
369  &SampleNYURGBDImage::GetDepthPath,
370  "Path to depth image sample.");
371  docstring::ClassMethodDocInject(m, "SampleNYURGBDImage", "color_path");
372  docstring::ClassMethodDocInject(m, "SampleNYURGBDImage", "depth_path");
373 }
374 
375 void pybind_sample_sun_rgbd_image(py::module& m) {
376  // cloudViewer.data.SampleSUNRGBDImage
377  py::class_<SampleSUNRGBDImage, PyDownloadDataset<SampleSUNRGBDImage>,
378  std::shared_ptr<SampleSUNRGBDImage>, DownloadDataset>
379  rgbd_image_sun(m, "SampleSUNRGBDImage",
380  "Data class for `SampleSUNRGBDImage` contains a "
381  "color image `SUN_color.jpg` and a depth image "
382  "`SUN_depth.png` sample from SUN RGBD dataset.");
383  rgbd_image_sun.def(py::init<const std::string&>(), "data_root"_a = "")
384  .def_property_readonly("color_path",
385  &SampleSUNRGBDImage::GetColorPath,
386  "Path to color image sample.")
387  .def_property_readonly("depth_path",
388  &SampleSUNRGBDImage::GetDepthPath,
389  "Path to depth image sample.");
390  docstring::ClassMethodDocInject(m, "SampleSUNRGBDImage", "color_path");
391  docstring::ClassMethodDocInject(m, "SampleSUNRGBDImage", "depth_path");
392 }
393 
394 void pybind_sample_tum_rgbd_image(py::module& m) {
395  // cloudViewer.data.SampleTUMRGBDImage
396  py::class_<SampleTUMRGBDImage, PyDownloadDataset<SampleTUMRGBDImage>,
397  std::shared_ptr<SampleTUMRGBDImage>, DownloadDataset>
398  rgbd_image_tum(m, "SampleTUMRGBDImage",
399  "Data class for `SampleTUMRGBDImage` contains a "
400  "color image `TUM_color.png` and a depth image "
401  "`TUM_depth.png` sample from TUM RGBD dataset.");
402  rgbd_image_tum.def(py::init<const std::string&>(), "data_root"_a = "")
403  .def_property_readonly("color_path",
404  &SampleTUMRGBDImage::GetColorPath,
405  "Path to color image sample.")
406  .def_property_readonly("depth_path",
407  &SampleTUMRGBDImage::GetDepthPath,
408  "Path to depth image sample.");
409  docstring::ClassMethodDocInject(m, "SampleTUMRGBDImage", "color_path");
410  docstring::ClassMethodDocInject(m, "SampleTUMRGBDImage", "depth_path");
411 }
412 
413 void pybind_sample_redwood_rgbd_images(py::module& m) {
414  // cloudViewer.data.SampleRedwoodRGBDImages
415  py::class_<SampleRedwoodRGBDImages,
416  PyDownloadDataset<SampleRedwoodRGBDImages>,
417  std::shared_ptr<SampleRedwoodRGBDImages>, DownloadDataset>
418  rgbd_dataset_redwood(
419  m, "SampleRedwoodRGBDImages",
420  "Data class for `SampleRedwoodRGBDImages` contains a "
421  "sample set of 5 color and depth images from Redwood RGBD "
422  "dataset living-room1. Additionally it also contains "
423  "camera trajectory log, camera odometry log, rgbd match, "
424  "and point cloud reconstruction obtained using TSDF.");
425  rgbd_dataset_redwood.def(py::init<const std::string&>(), "data_root"_a = "")
426  .def_property_readonly(
427  "color_paths", &SampleRedwoodRGBDImages::GetColorPaths,
428  "List of paths to color image samples of size 5. Use "
429  "`color_paths[0]`, `color_paths[1]` ... `color_paths[4]` "
430  "to access the paths.")
431  .def_property_readonly(
432  "depth_paths", &SampleRedwoodRGBDImages::GetDepthPaths,
433  "List of paths to depth image samples of size 5. Use "
434  "`depth_paths[0]`, `depth_paths[1]` ... `depth_paths[4]` "
435  "to access the paths.")
436  .def_property_readonly(
437  "trajectory_log_path",
438  &SampleRedwoodRGBDImages::GetTrajectoryLogPath,
439  "Path to camera trajectory log file `trajectory.log`.")
440  .def_property_readonly(
441  "odometry_log_path",
442  &SampleRedwoodRGBDImages::GetOdometryLogPath,
443  "Path to camera odometry log file `odometry.log`.")
444  .def_property_readonly(
445  "rgbd_match_path",
446  &SampleRedwoodRGBDImages::GetRGBDMatchPath,
447  "Path to color and depth image match file `rgbd.match`.")
448  .def_property_readonly(
449  "reconstruction_path",
450  &SampleRedwoodRGBDImages::GetReconstructionPath,
451  "Path to pointcloud reconstruction from TSDF.")
452  .def_property_readonly(
453  "camera_intrinsic_path",
454  &SampleRedwoodRGBDImages::GetCameraIntrinsicPath,
455  "Path to pinhole camera intrinsic (json).");
456  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
457  "color_paths");
458  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
459  "depth_paths");
460  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
461  "trajectory_log_path");
462  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
463  "odometry_log_path");
464  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
465  "rgbd_match_path");
466  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
467  "reconstruction_path");
468  docstring::ClassMethodDocInject(m, "SampleRedwoodRGBDImages",
469  "camera_intrinsic_path");
470 }
471 
472 void pybind_sample_fountain_rgbd_images(py::module& m) {
473  // cloudViewer.data.SampleFountainRGBDImages
474  py::class_<SampleFountainRGBDImages,
475  PyDownloadDataset<SampleFountainRGBDImages>,
476  std::shared_ptr<SampleFountainRGBDImages>, DownloadDataset>
477  fountain_rgbd_dataset(
478  m, "SampleFountainRGBDImages",
479  "Data class for `SampleFountainRGBDImages` contains a "
480  "sample set of 33 color and depth images from the "
481  "`Fountain RGBD dataset`. It also contains `camera poses "
482  "at keyframes log` and `mesh reconstruction`. It is used "
483  "in demo of `Color Map Optimization`.");
484  fountain_rgbd_dataset
485  .def(py::init<const std::string&>(), "data_root"_a = "")
486  .def_property_readonly(
487  "color_paths", &SampleFountainRGBDImages::GetColorPaths,
488  "List of paths to color image samples of size 33. Use "
489  "`color_paths[0]`, `color_paths[1]` ... `color_paths[32]` "
490  "to access the paths.")
491  .def_property_readonly(
492  "depth_paths", &SampleFountainRGBDImages::GetDepthPaths,
493  "List of paths to depth image samples of size 33. Use "
494  "`depth_paths[0]`, `depth_paths[1]` ... `depth_paths[32]` "
495  "to access the paths.")
496  .def_property_readonly(
497  "keyframe_poses_log_path",
498  &SampleFountainRGBDImages::GetKeyframePosesLogPath,
499  "Path to camera poses at key frames log file `key.log`.")
500  .def_property_readonly(
501  "reconstruction_path",
502  &SampleFountainRGBDImages::GetReconstructionPath,
503  "Path to mesh reconstruction.");
504  docstring::ClassMethodDocInject(m, "SampleFountainRGBDImages",
505  "color_paths");
506  docstring::ClassMethodDocInject(m, "SampleFountainRGBDImages",
507  "depth_paths");
508  docstring::ClassMethodDocInject(m, "SampleFountainRGBDImages",
509  "keyframe_poses_log_path");
510  docstring::ClassMethodDocInject(m, "SampleFountainRGBDImages",
511  "reconstruction_path");
512 }
513 
514 void pybind_sample_l515_bag(py::module& m) {
515  // cloudViewer.data.SampleL515Bag
516  py::class_<SampleL515Bag, PyDownloadDataset<SampleL515Bag>,
517  std::shared_ptr<SampleL515Bag>, DownloadDataset>
518  sample_l515_bag(m, "SampleL515Bag",
519  "Data class for `SampleL515Bag` contains the "
520  "`SampleL515Bag.bag` file.");
521  sample_l515_bag.def(py::init<const std::string&>(), "data_root"_a = "")
522  .def_property_readonly("path", &SampleL515Bag::GetPath,
523  "Path to the `SampleL515Bag.bag` file.");
524  docstring::ClassMethodDocInject(m, "SampleL515Bag", "path");
525 }
526 
527 void pybind_eagle(py::module& m) {
528  // cloudViewer.data.EaglePointCloud
529  py::class_<EaglePointCloud, PyDownloadDataset<EaglePointCloud>,
530  std::shared_ptr<EaglePointCloud>, DownloadDataset>
531  eagle(m, "EaglePointCloud",
532  "Data class for `EaglePointCloud` contains the "
533  "`EaglePointCloud.ply` file.");
534  eagle.def(py::init<const std::string&>(), "data_root"_a = "")
535  .def_property_readonly("path", &EaglePointCloud::GetPath,
536  "Path to the `EaglePointCloud.ply` file.");
537  docstring::ClassMethodDocInject(m, "EaglePointCloud", "path");
538 }
539 
540 void pybind_armadillo(py::module& m) {
541  // cloudViewer.data.ArmadilloMesh
542  py::class_<ArmadilloMesh, PyDownloadDataset<ArmadilloMesh>,
543  std::shared_ptr<ArmadilloMesh>, DownloadDataset>
544  armadillo(m, "ArmadilloMesh",
545  "Data class for `ArmadilloMesh` contains the "
546  "`ArmadilloMesh.ply` from the `Stanford 3D Scanning "
547  "Repository`.");
548  armadillo.def(py::init<const std::string&>(), "data_root"_a = "")
549  .def_property_readonly("path", &ArmadilloMesh::GetPath,
550  "Path to the `ArmadilloMesh.ply` file.");
551  docstring::ClassMethodDocInject(m, "ArmadilloMesh", "path");
552 }
553 
554 void pybind_bunny(py::module& m) {
555  // cloudViewer.data.BunnyMesh
556  py::class_<BunnyMesh, PyDownloadDataset<BunnyMesh>,
557  std::shared_ptr<BunnyMesh>, DownloadDataset>
558  bunny(m, "BunnyMesh",
559  "Data class for `BunnyMesh` contains the `BunnyMesh.ply` "
560  "from "
561  "the `Stanford 3D Scanning Repository`.");
562  bunny.def(py::init<const std::string&>(), "data_root"_a = "")
563  .def_property_readonly("path", &BunnyMesh::GetPath,
564  "Path to the `BunnyMesh.ply` file.");
565  docstring::ClassMethodDocInject(m, "BunnyMesh", "path");
566 }
567 
568 void pybind_knot(py::module& m) {
569  // cloudViewer.data.KnotMesh
570  py::class_<KnotMesh, PyDownloadDataset<KnotMesh>, std::shared_ptr<KnotMesh>,
571  DownloadDataset>
572  knot(m, "KnotMesh",
573  "Data class for `KnotMesh` contains the `KnotMesh.ply`.");
574  knot.def(py::init<const std::string&>(), "data_root"_a = "")
575  .def_property_readonly("path", &KnotMesh::GetPath,
576  "Path to the `KnotMesh.ply` file.");
577  docstring::ClassMethodDocInject(m, "KnotMesh", "path");
578 }
579 
580 void pybind_monkey(py::module& m) {
581  // cloudViewer.data.MonkeyModel
582  py::class_<MonkeyModel, PyDownloadDataset<MonkeyModel>,
583  std::shared_ptr<MonkeyModel>, DownloadDataset>
584  monkey(m, "MonkeyModel",
585  "Data class for `MonkeyModel` contains a monkey model file, "
586  "along with material and various other texture files. The "
587  "model file can be accessed using `path`, however in order "
588  "to access the paths to the texture files one may use "
589  "path_map[\"filename\"]` method.");
590  monkey.def(py::init<const std::string&>(), "data_root"_a = "")
591  .def_property_readonly(
592  "path",
593  [](const MonkeyModel& monkey) { return monkey.GetPath(); },
594  "Returns the `monkey` model file.")
595  .def_property_readonly("path_map", &MonkeyModel::GetPathMap,
596  "Returns the map of filename to path. Refer "
597  "documentation page for available options.");
598  docstring::ClassMethodDocInject(m, "MonkeyModel", "path");
599  docstring::ClassMethodDocInject(m, "MonkeyModel", "path_map");
600 }
601 
602 void pybind_sword(py::module& m) {
603  // cloudViewer.data.SwordModel
604  py::class_<SwordModel, PyDownloadDataset<SwordModel>,
605  std::shared_ptr<SwordModel>, DownloadDataset>
606  sword(m, "SwordModel",
607  "Data class for `SwordModel` contains a monkey model file, "
608  "along with material and various other texture files. The "
609  "model file can be accessed using `path`, however in order "
610  "to access the paths to the texture files one may use "
611  "path_map[\"filename\"]` method.");
612  sword.def(py::init<const std::string&>(), "data_root"_a = "")
613  .def_property_readonly(
614  "path",
615  [](const SwordModel& sword) { return sword.GetPath(); },
616  "Returns the `sword` model file.")
617  .def_property_readonly("path_map", &SwordModel::GetPathMap,
618  "Returns the map of filename to path. Refer "
619  "documentation page for available options.");
620  docstring::ClassMethodDocInject(m, "SwordModel", "path");
621  docstring::ClassMethodDocInject(m, "SwordModel", "path_map");
622 }
623 
624 void pybind_crate(py::module& m) {
625  // cloudViewer.data.CrateModel
626  py::class_<CrateModel, PyDownloadDataset<CrateModel>,
627  std::shared_ptr<CrateModel>, DownloadDataset>
628  crate(m, "CrateModel",
629  "Data class for `CrateModel` contains a crate model file, "
630  "along with material and various other texture files. The "
631  "model file can be accessed using `path`, however in order "
632  "to access the paths to the texture files one may use "
633  "path_map[\"filename\"]` method.");
634  crate.def(py::init<const std::string&>(), "data_root"_a = "")
635  .def_property_readonly(
636  "path",
637  [](const CrateModel& crate) { return crate.GetPath(); },
638  "Returns the `crate` model file.")
639  .def_property_readonly("path_map", &CrateModel::GetPathMap,
640  "Returns the map of filename to path. Refer "
641  "documentation page for available options.");
642  docstring::ClassMethodDocInject(m, "CrateModel", "path");
643  docstring::ClassMethodDocInject(m, "CrateModel", "path_map");
644 }
645 
646 void pybind_helmet(py::module& m) {
647  // cloudViewer.data.FlightHelmetModel
648  py::class_<FlightHelmetModel, PyDownloadDataset<FlightHelmetModel>,
649  std::shared_ptr<FlightHelmetModel>, DownloadDataset>
650  helmet(m, "FlightHelmetModel",
651  "Data class for `FlightHelmetModel` contains a flight "
652  "helmet GLTF model file, along with material and various "
653  "other texture files. The model file can be accessed using "
654  "`path`, however in order to access the paths to the "
655  "texture files one may use path_map[\"filename\"]` method.");
656  helmet.def(py::init<const std::string&>(), "data_root"_a = "")
657  .def_property_readonly(
658  "path",
659  [](const FlightHelmetModel& helmet) {
660  return helmet.GetPath();
661  },
662  "Returns the `FlightHelmet.gltf` model file.")
663  .def_property_readonly("path_map", &FlightHelmetModel::GetPathMap,
664  "Returns the map of filename to path. Refer "
665  "documentation page for available options.");
666  docstring::ClassMethodDocInject(m, "FlightHelmetModel", "path");
667  docstring::ClassMethodDocInject(m, "FlightHelmetModel", "path_map");
668 }
669 
670 void pybind_avocado(py::module& m) {
671  // cloudViewer.data.AvocadoModel
672  py::class_<AvocadoModel, PyDownloadDataset<AvocadoModel>,
673  std::shared_ptr<AvocadoModel>, DownloadDataset>
674  avocado(m, "AvocadoModel",
675  "Data class for `AvocadoModel` contains a avocado model "
676  "file, "
677  "along with material and PNG format embedded textures.");
678  avocado.def(py::init<const std::string&>(), "data_root"_a = "")
679  .def_property_readonly("path", &AvocadoModel::GetPath,
680  "Path to the `AvocadoModel.glb` file.");
681  docstring::ClassMethodDocInject(m, "AvocadoModel", "path");
682 }
683 
684 void pybind_damaged_helmet(py::module& m) {
685  // cloudViewer.data.DamagedHelmetModel
686  py::class_<DamagedHelmetModel, PyDownloadDataset<DamagedHelmetModel>,
687  std::shared_ptr<DamagedHelmetModel>, DownloadDataset>
688  damaged_helmet(
689  m, "DamagedHelmetModel",
690  "Data class for `DamagedHelmetModel` contains a damaged "
691  "helmet model file, "
692  "along with material and JPG format embedded textures. ");
693  damaged_helmet.def(py::init<const std::string&>(), "data_root"_a = "")
694  .def_property_readonly(
695  "path", &DamagedHelmetModel::GetPath,
696  "Path to the `DamagedHelmetModel.glb` file.");
697  docstring::ClassMethodDocInject(m, "DamagedHelmetModel", "path");
698 }
699 
700 void pybind_metal_texture(py::module& m) {
701  // cloudViewer.data.MetalTexture
702  py::class_<MetalTexture, PyDownloadDataset<MetalTexture>,
703  std::shared_ptr<MetalTexture>, DownloadDataset>
704  metal_texture(m, "MetalTexture",
705  "Data class for `MetalTexture` contains albedo, "
706  "normal, roughness and metallic texture files for "
707  "metal based material.");
708  metal_texture.def(py::init<const std::string&>(), "data_root"_a = "")
709  .def_property_readonly("albedo_texture_path",
710  &MetalTexture::GetAlbedoTexturePath,
711  "Path to albedo color texture image.")
712  .def_property_readonly("normal_texture_path",
713  &MetalTexture::GetNormalTexturePath,
714  "Path to normal texture image.")
715  .def_property_readonly("roughness_texture_path",
716  &MetalTexture::GetRoughnessTexturePath,
717  "Path to roughness texture image.")
718  .def_property_readonly("metallic_texture_path",
719  &MetalTexture::GetMetallicTexturePath,
720  "Path to metallic texture image.")
721  .def_property_readonly("path_map", &MetalTexture::GetPathMap,
722  "Returns the map of filename to path.");
723  docstring::ClassMethodDocInject(m, "MetalTexture", "albedo_texture_path");
724  docstring::ClassMethodDocInject(m, "MetalTexture", "normal_texture_path");
725  docstring::ClassMethodDocInject(m, "MetalTexture",
726  "roughness_texture_path");
727  docstring::ClassMethodDocInject(m, "MetalTexture", "metallic_texture_path");
728  docstring::ClassMethodDocInject(m, "MetalTexture", "path_map");
729 }
730 
731 void pybind_painted_plaster_texture(py::module& m) {
732  // cloudViewer.data.PaintedPlasterTexture
733  py::class_<PaintedPlasterTexture, PyDownloadDataset<PaintedPlasterTexture>,
734  std::shared_ptr<PaintedPlasterTexture>, DownloadDataset>
735  painted_plaster_texture(
736  m, "PaintedPlasterTexture",
737  "Data class for `PaintedPlasterTexture` contains albedo, "
738  "normal and roughness texture files for painted plaster "
739  "based material.");
740  painted_plaster_texture
741  .def(py::init<const std::string&>(), "data_root"_a = "")
742  .def_property_readonly("albedo_texture_path",
743  &PaintedPlasterTexture::GetAlbedoTexturePath,
744  "Path to albedo color texture image.")
745  .def_property_readonly("normal_texture_path",
746  &PaintedPlasterTexture::GetNormalTexturePath,
747  "Path to normal texture image.")
748  .def_property_readonly(
749  "roughness_texture_path",
750  &PaintedPlasterTexture::GetRoughnessTexturePath,
751  "Path to roughness texture image.")
752  .def_property_readonly("path_map",
753  &PaintedPlasterTexture::GetPathMap,
754  "Returns the map of filename to path.");
755  docstring::ClassMethodDocInject(m, "PaintedPlasterTexture",
756  "albedo_texture_path");
757  docstring::ClassMethodDocInject(m, "PaintedPlasterTexture",
758  "normal_texture_path");
759  docstring::ClassMethodDocInject(m, "PaintedPlasterTexture",
760  "roughness_texture_path");
761  docstring::ClassMethodDocInject(m, "PaintedPlasterTexture", "path_map");
762 }
763 
764 void pybind_tiles_texture(py::module& m) {
765  // cloudViewer.data.TilesTexture
766  py::class_<TilesTexture, PyDownloadDataset<TilesTexture>,
767  std::shared_ptr<TilesTexture>, DownloadDataset>
768  tiles_texture(
769  m, "TilesTexture",
770  "Data class for `TilesTexture` contains albedo, normal and "
771  "roughness texture files for tiles based material.");
772  tiles_texture.def(py::init<const std::string&>(), "data_root"_a = "")
773  .def_property_readonly("albedo_texture_path",
774  &TilesTexture::GetAlbedoTexturePath,
775  "Path to albedo color texture image.")
776  .def_property_readonly("normal_texture_path",
777  &TilesTexture::GetNormalTexturePath,
778  "Path to normal texture image.")
779  .def_property_readonly("roughness_texture_path",
780  &TilesTexture::GetRoughnessTexturePath,
781  "Path to roughness texture image.")
782  .def_property_readonly("path_map", &TilesTexture::GetPathMap,
783  "Returns the map of filename to path.");
784  docstring::ClassMethodDocInject(m, "TilesTexture", "albedo_texture_path");
785  docstring::ClassMethodDocInject(m, "TilesTexture", "normal_texture_path");
786  docstring::ClassMethodDocInject(m, "TilesTexture",
787  "roughness_texture_path");
788  docstring::ClassMethodDocInject(m, "TilesTexture", "path_map");
789 }
790 
791 void pybind_terrazzo_texture(py::module& m) {
792  // cloudViewer.data.TerrazzoTexture
793  py::class_<TerrazzoTexture, PyDownloadDataset<TerrazzoTexture>,
794  std::shared_ptr<TerrazzoTexture>, DownloadDataset>
795  terrazzo_texture(
796  m, "TerrazzoTexture",
797  "Data class for `TerrazzoTexture` contains albedo, normal "
798  "and roughness texture files for terrazzo based material.");
799  terrazzo_texture.def(py::init<const std::string&>(), "data_root"_a = "")
800  .def_property_readonly("albedo_texture_path",
801  &TerrazzoTexture::GetAlbedoTexturePath,
802  "Path to albedo color texture image.")
803  .def_property_readonly("normal_texture_path",
804  &TerrazzoTexture::GetNormalTexturePath,
805  "Path to normal texture image.")
806  .def_property_readonly("roughness_texture_path",
807  &TerrazzoTexture::GetRoughnessTexturePath,
808  "Path to roughness texture image.")
809  .def_property_readonly("path_map", &TerrazzoTexture::GetPathMap,
810  "Returns the map of filename to path.");
811  docstring::ClassMethodDocInject(m, "TerrazzoTexture",
812  "albedo_texture_path");
813  docstring::ClassMethodDocInject(m, "TerrazzoTexture",
814  "normal_texture_path");
815  docstring::ClassMethodDocInject(m, "TerrazzoTexture",
816  "roughness_texture_path");
817  docstring::ClassMethodDocInject(m, "TerrazzoTexture", "path_map");
818 }
819 
820 void pybind_wood_texture(py::module& m) {
821  // cloudViewer.data.WoodTexture
822  py::class_<WoodTexture, PyDownloadDataset<WoodTexture>,
823  std::shared_ptr<WoodTexture>, DownloadDataset>
824  wood_texture(
825  m, "WoodTexture",
826  "Data class for `WoodTexture` contains albedo, normal and "
827  "roughness texture files for wood based material.");
828  wood_texture.def(py::init<const std::string&>(), "data_root"_a = "")
829  .def_property_readonly("albedo_texture_path",
830  &WoodTexture::GetAlbedoTexturePath,
831  "Path to albedo color texture image.")
832  .def_property_readonly("normal_texture_path",
833  &WoodTexture::GetNormalTexturePath,
834  "Path to normal texture image.")
835  .def_property_readonly("roughness_texture_path",
836  &WoodTexture::GetRoughnessTexturePath,
837  "Path to roughness texture image.")
838  .def_property_readonly("path_map", &WoodTexture::GetPathMap,
839  "Returns the map of filename to path.");
840  docstring::ClassMethodDocInject(m, "WoodTexture", "albedo_texture_path");
841  docstring::ClassMethodDocInject(m, "WoodTexture", "normal_texture_path");
842  docstring::ClassMethodDocInject(m, "WoodTexture", "roughness_texture_path");
843  docstring::ClassMethodDocInject(m, "WoodTexture", "path_map");
844 }
845 
846 void pybind_wood_floor_texture(py::module& m) {
847  // cloudViewer.data.WoodFloorTexture
848  py::class_<WoodFloorTexture, PyDownloadDataset<WoodFloorTexture>,
849  std::shared_ptr<WoodFloorTexture>, DownloadDataset>
850  wood_floor_texture(m, "WoodFloorTexture",
851  " Data class for `WoodFloorTexture` contains "
852  "albedo, normal and roughness texture files for "
853  "wooden floor based material.");
854  wood_floor_texture.def(py::init<const std::string&>(), "data_root"_a = "")
855  .def_property_readonly("albedo_texture_path",
856  &WoodFloorTexture::GetAlbedoTexturePath,
857  "Path to albedo color texture image.")
858  .def_property_readonly("normal_texture_path",
859  &WoodFloorTexture::GetNormalTexturePath,
860  "Path to normal texture image.")
861  .def_property_readonly("roughness_texture_path",
862  &WoodFloorTexture::GetRoughnessTexturePath,
863  "Path to roughness texture image.")
864  .def_property_readonly("path_map", &WoodFloorTexture::GetPathMap,
865  "Returns the map of filename to path.");
866  docstring::ClassMethodDocInject(m, "WoodFloorTexture",
867  "albedo_texture_path");
868  docstring::ClassMethodDocInject(m, "WoodFloorTexture",
869  "normal_texture_path");
870  docstring::ClassMethodDocInject(m, "WoodFloorTexture",
871  "roughness_texture_path");
872  docstring::ClassMethodDocInject(m, "WoodFloorTexture", "path_map");
873 }
874 
875 void pybind_juneau(py::module& m) {
876  // cloudViewer.data.JuneauImage
877  py::class_<JuneauImage, PyDownloadDataset<JuneauImage>,
878  std::shared_ptr<JuneauImage>, DownloadDataset>
879  juneau(m, "JuneauImage",
880  "Data class for `JuneauImage` contains the "
881  "`JuneauImage.jpg` "
882  "file.");
883  juneau.def(py::init<const std::string&>(), "data_root"_a = "")
884  .def_property_readonly("path", &JuneauImage::GetPath,
885  "Path to the `JuneauImage.jgp` file.");
886  docstring::ClassMethodDocInject(m, "JuneauImage", "path");
887 }
888 
889 void pybind_living_room_point_clouds(py::module& m) {
890  // cloudViewer.data.LivingRoomPointClouds
891  py::class_<LivingRoomPointClouds, PyDownloadDataset<LivingRoomPointClouds>,
892  std::shared_ptr<LivingRoomPointClouds>, DownloadDataset>
893  living_room_point_clouds(
894  m, "LivingRoomPointClouds",
895  "Dataset class for `LivingRoomPointClouds` contains "
896  "57 point clouds of binary PLY format.");
897  living_room_point_clouds
898  .def(py::init<const std::string&>(), "data_root"_a = "")
899  .def_property_readonly(
900  "paths",
901  [](const LivingRoomPointClouds& living_room_point_clouds) {
902  return living_room_point_clouds.GetPaths();
903  },
904  "List of paths to ply point-cloud fragments of size 57. "
905  "Use `paths[0]`, `paths[1]` ... `paths[56]` to access the "
906  "paths.");
907  docstring::ClassMethodDocInject(m, "LivingRoomPointClouds", "paths");
908 }
909 
910 void pybind_office_point_clouds(py::module& m) {
911  // cloudViewer.data.OfficePointClouds
912  py::class_<OfficePointClouds, PyDownloadDataset<OfficePointClouds>,
913  std::shared_ptr<OfficePointClouds>, DownloadDataset>
914  office_point_clouds(
915  m, "OfficePointClouds",
916  "Dataset class for `OfficePointClouds` contains 53 "
917  "point clouds of binary PLY format.");
918  office_point_clouds.def(py::init<const std::string&>(), "data_root"_a = "")
919  .def_property_readonly(
920  "paths",
921  [](const OfficePointClouds& office_point_clouds) {
922  return office_point_clouds.GetPaths();
923  },
924  "List of paths to ply point-cloud fragments of size 53. "
925  "Use `paths[0]`, `paths[1]` ... `paths[52]` to access the "
926  "paths.");
927  docstring::ClassMethodDocInject(m, "OfficePointClouds", "paths");
928 }
929 
930 void pybind_lounge_rgbd_images(py::module& m) {
931  // cloudViewer.data.LoungeRGBDImages
932  py::class_<LoungeRGBDImages, PyDownloadDataset<LoungeRGBDImages>,
933  std::shared_ptr<LoungeRGBDImages>, DownloadDataset>
934  lounge_rgbd_images(
935  m, "LoungeRGBDImages",
936  "Data class for `LoungeRGBDImages` contains a sample set "
937  "of 3000 color and depth images from Stanford Lounge RGBD "
938  "dataset. Additionally it also contains camera trajectory "
939  "log, and mesh reconstruction.");
940  lounge_rgbd_images.def(py::init<const std::string&>(), "data_root"_a = "")
941  .def_property_readonly(
942  "color_paths", &LoungeRGBDImages::GetColorPaths,
943  "List of paths to color image samples of size 3000. Use "
944  "`color_paths[0]`, `color_paths[1]` ... "
945  "`color_paths[2999]` to access the paths.")
946  .def_property_readonly(
947  "depth_paths", &LoungeRGBDImages::GetDepthPaths,
948  "List of paths to depth image samples of size 3000. Use "
949  "`depth_paths[0]`, `depth_paths[1]` ... "
950  "`depth_paths[2999]` to access the paths.")
951  .def_property_readonly(
952  "trajectory_log_path",
953  &LoungeRGBDImages::GetTrajectoryLogPath,
954  "Path to camera trajectory log file `trajectory.log`.")
955  .def_property_readonly("reconstruction_path",
956  &LoungeRGBDImages::GetReconstructionPath,
957  "Path to mesh reconstruction.");
958  docstring::ClassMethodDocInject(m, "LoungeRGBDImages", "color_paths");
959  docstring::ClassMethodDocInject(m, "LoungeRGBDImages", "depth_paths");
960  docstring::ClassMethodDocInject(m, "LoungeRGBDImages",
961  "trajectory_log_path");
962  docstring::ClassMethodDocInject(m, "LoungeRGBDImages",
963  "reconstruction_path");
964 }
965 
966 void pybind_bedroom_rgbd_images(py::module& m) {
967  // cloudViewer.data.BedroomRGBDImages
968  py::class_<BedroomRGBDImages, PyDownloadDataset<BedroomRGBDImages>,
969  std::shared_ptr<BedroomRGBDImages>, DownloadDataset>
970  lounge_rgbd_images(
971  m, "BedroomRGBDImages",
972  "Data class for `BedroomRGBDImages` contains a sample set "
973  "of 21931 color and depth images from Redwood Bedroom RGBD "
974  "dataset. Additionally it also contains camera trajectory "
975  "log, and mesh reconstruction.");
976  lounge_rgbd_images.def(py::init<const std::string&>(), "data_root"_a = "")
977  .def_property_readonly("color_paths",
978  &BedroomRGBDImages::GetColorPaths,
979  "List of paths to color image samples of "
980  "size 21931. Use `color_paths[0]`, "
981  "`color_paths[1]` ... `color_paths[21930]` "
982  "to access the paths.")
983  .def_property_readonly(
984  "depth_paths", &BedroomRGBDImages::GetDepthPaths,
985  "List of paths to depth image samples of size 21931. Use "
986  "`depth_paths[0]`, `depth_paths[1]` ... "
987  "`depth_paths[21930]` to access the paths.")
988  .def_property_readonly(
989  "trajectory_log_path",
990  &BedroomRGBDImages::GetTrajectoryLogPath,
991  "Path to camera trajectory log file `trajectory.log`.")
992  .def_property_readonly("reconstruction_path",
993  &BedroomRGBDImages::GetReconstructionPath,
994  "Path to mesh reconstruction.");
995  docstring::ClassMethodDocInject(m, "BedroomRGBDImages", "color_paths");
996  docstring::ClassMethodDocInject(m, "BedroomRGBDImages", "depth_paths");
997  docstring::ClassMethodDocInject(m, "BedroomRGBDImages",
998  "trajectory_log_path");
999  docstring::ClassMethodDocInject(m, "BedroomRGBDImages",
1000  "reconstruction_path");
1001 }
1002 
1003 void pybind_jackjack_l515_bag(py::module& m) {
1004  // cloudViewer.data.JackJackL515Bag
1005  py::class_<JackJackL515Bag, PyDownloadDataset<JackJackL515Bag>,
1006  std::shared_ptr<JackJackL515Bag>, DownloadDataset>
1007  jackjack_l515_bag(m, "JackJackL515Bag",
1008  "Data class for `SampleL515Bag` contains the "
1009  "`JackJackL515Bag.bag` file.");
1010  jackjack_l515_bag.def(py::init<const std::string&>(), "data_root"_a = "")
1011  .def_property_readonly("path", &JackJackL515Bag::GetPath,
1012  "Path to the `JackJackL515Bag.bag` file.");
1013  docstring::ClassMethodDocInject(m, "JackJackL515Bag", "path");
1014 }
1015 
1016 void pybind_redwood_indoor_living_room1(py::module& m) {
1017  py::class_<RedwoodIndoorLivingRoom1,
1018  PyDownloadDataset<RedwoodIndoorLivingRoom1>,
1019  std::shared_ptr<RedwoodIndoorLivingRoom1>, DownloadDataset>
1020  dataset(m, "RedwoodIndoorLivingRoom1",
1021  R"doc(RedwoodIndoorLivingRoom1 (Augmented ICL-NUIM Dataset)
1022 Data class for `RedwoodIndoorLivingRoom1`, containing dense point
1023 cloud, rgb sequence, clean depth sequence, noisy depth sequence, oni
1024 sequence, and ground-truth camera trajectory. ::
1025 
1026  RedwoodIndoorLivingRoom1
1027  |-- colors
1028  | |-- 00000.jpg
1029  | |-- 00001.jpg
1030  | |-- ...
1031  | '-- 02869.jpg
1032  |-- depth
1033  | |-- 00000.png
1034  | |-- 00001.png
1035  | |-- ...
1036  | '-- 02869.png
1037  |-- depth_noisy
1038  | |-- 00000.png
1039  | |-- 00001.png
1040  | |-- ...
1041  | '-- 02869.png
1042  |-- dist-model.txt
1043  |-- livingroom1.oni
1044  |-- livingroom1-traj.txt
1045  '-- livingroom.ply
1046 )doc");
1047  dataset.def(py::init<const std::string&>(), "data_root"_a = "");
1048  dataset.def_property_readonly("point_cloud_path",
1049  &RedwoodIndoorLivingRoom1::GetPointCloudPath,
1050  "Path to the point cloud.");
1051  dataset.def_property_readonly("color_paths",
1052  &RedwoodIndoorLivingRoom1::GetColorPaths,
1053  "List of paths to color images.");
1054  dataset.def_property_readonly("depth_paths",
1055  &RedwoodIndoorLivingRoom1::GetDepthPaths,
1056  "List of paths to depth images.");
1057  dataset.def_property_readonly("noisy_depth_paths",
1058  &RedwoodIndoorLivingRoom1::GetNoisyDepthPaths,
1059  "List of paths to noisy depth images.");
1060  dataset.def_property_readonly("oni_path",
1061  &RedwoodIndoorLivingRoom1::GetONIPath,
1062  "Path to the oni file.");
1063  dataset.def_property_readonly("trajectory_path",
1064  &RedwoodIndoorLivingRoom1::GetTrajectoryPath,
1065  "Path to the trajectory file.");
1066  dataset.def_property_readonly("noise_model_path",
1067  &RedwoodIndoorLivingRoom1::GetNoiseModelPath,
1068  "Path to the noise model file.");
1069 }
1070 
1071 void pybind_redwood_indoor_living_room2(py::module& m) {
1072  py::class_<RedwoodIndoorLivingRoom2,
1073  PyDownloadDataset<RedwoodIndoorLivingRoom2>,
1074  std::shared_ptr<RedwoodIndoorLivingRoom2>, DownloadDataset>
1075  dataset(m, "RedwoodIndoorLivingRoom2",
1076  R"doc(RedwoodIndoorLivingRoom2 (Augmented ICL-NUIM Dataset)
1077 Data class for `RedwoodIndoorLivingRoom2`, containing dense point
1078 cloud, rgb sequence, clean depth sequence, noisy depth sequence, oni
1079 sequence, and ground-truth camera trajectory. ::
1080 
1081  RedwoodIndoorLivingRoom2
1082  |-- colors
1083  | |-- 00000.jpg
1084  | |-- 00001.jpg
1085  | |-- ...
1086  | '-- 02349.jpg
1087  |-- depth
1088  | |-- 00000.png
1089  | |-- 00001.png
1090  | |-- ...
1091  | '-- 02349.png
1092  |-- depth_noisy
1093  | |-- 00000.png
1094  | |-- 00001.png
1095  | |-- ...
1096  | '-- 02349.png
1097  |-- dist-model.txt
1098  |-- livingroom2.oni
1099  |-- livingroom2-traj.txt
1100  '-- livingroom.ply
1101 )doc");
1102  dataset.def(py::init<const std::string&>(), "data_root"_a = "");
1103  dataset.def_property_readonly("point_cloud_path",
1104  &RedwoodIndoorLivingRoom2::GetPointCloudPath,
1105  "Path to the point cloud.");
1106  dataset.def_property_readonly("color_paths",
1107  &RedwoodIndoorLivingRoom2::GetColorPaths,
1108  "List of paths to color images.");
1109  dataset.def_property_readonly("depth_paths",
1110  &RedwoodIndoorLivingRoom2::GetDepthPaths,
1111  "List of paths to depth images.");
1112  dataset.def_property_readonly("noisy_depth_paths",
1113  &RedwoodIndoorLivingRoom2::GetNoisyDepthPaths,
1114  "List of paths to noisy depth images.");
1115  dataset.def_property_readonly("oni_path",
1116  &RedwoodIndoorLivingRoom2::GetONIPath,
1117  "Path to the oni file.");
1118  dataset.def_property_readonly("trajectory_path",
1119  &RedwoodIndoorLivingRoom2::GetTrajectoryPath,
1120  "Path to the trajectory file.");
1121  dataset.def_property_readonly("noise_model_path",
1122  &RedwoodIndoorLivingRoom2::GetNoiseModelPath,
1123  "Path to the noise model file.");
1124 }
1125 
1126 void pybind_redwood_indoor_office1(py::module& m) {
1127  py::class_<RedwoodIndoorOffice1, PyDownloadDataset<RedwoodIndoorOffice1>,
1128  std::shared_ptr<RedwoodIndoorOffice1>, DownloadDataset>
1129  dataset(m, "RedwoodIndoorOffice1",
1130  R"doc(RedwoodIndoorOffice1 (Augmented ICL-NUIM Dataset)
1131 Data class for `RedwoodIndoorOffice1`, containing dense point
1132 cloud, rgb sequence, clean depth sequence, noisy depth sequence, oni
1133 sequence, and ground-truth camera trajectory. ::
1134 
1135  RedwoodIndoorOffice1
1136  |-- colors
1137  | |-- 00000.jpg
1138  | |-- 00001.jpg
1139  | |-- ...
1140  | '-- 02689.jpg
1141  |-- depth
1142  | |-- 00000.png
1143  | |-- 00001.png
1144  | |-- ...
1145  | '-- 02689.png
1146  |-- depth_noisy
1147  | |-- 00000.png
1148  | |-- 00001.png
1149  | |-- ...
1150  | '-- 02689.png
1151  |-- dist-model.txt
1152  |-- office1.oni
1153  |-- office1-traj.txt
1154  '-- office.ply
1155 )doc");
1156  dataset.def(py::init<const std::string&>(), "data_root"_a = "");
1157  dataset.def_property_readonly("point_cloud_path",
1158  &RedwoodIndoorOffice1::GetPointCloudPath,
1159  "Path to the point cloud.");
1160  dataset.def_property_readonly("color_paths",
1161  &RedwoodIndoorOffice1::GetColorPaths,
1162  "List of paths to color images.");
1163  dataset.def_property_readonly("depth_paths",
1164  &RedwoodIndoorOffice1::GetDepthPaths,
1165  "List of paths to depth images.");
1166  dataset.def_property_readonly("noisy_depth_paths",
1167  &RedwoodIndoorOffice1::GetNoisyDepthPaths,
1168  "List of paths to noisy depth images.");
1169  dataset.def_property_readonly("oni_path", &RedwoodIndoorOffice1::GetONIPath,
1170  "Path to the oni file.");
1171  dataset.def_property_readonly("trajectory_path",
1172  &RedwoodIndoorOffice1::GetTrajectoryPath,
1173  "Path to the trajectory file.");
1174  dataset.def_property_readonly("noise_model_path",
1175  &RedwoodIndoorOffice1::GetNoiseModelPath,
1176  "Path to the noise model file.");
1177 }
1178 
1179 void pybind_redwood_indoor_office2(py::module& m) {
1180  py::class_<RedwoodIndoorOffice2, PyDownloadDataset<RedwoodIndoorOffice2>,
1181  std::shared_ptr<RedwoodIndoorOffice2>, DownloadDataset>
1182  dataset(m, "RedwoodIndoorOffice2",
1183  R"doc(RedwoodIndoorOffice2 (Augmented ICL-NUIM Dataset)
1184 Data class for `RedwoodIndoorOffice2`, containing dense point
1185 cloud, rgb sequence, clean depth sequence, noisy depth sequence, oni
1186 sequence, and ground-truth camera trajectory. ::
1187 
1188  RedwoodIndoorOffice2
1189  |-- colors
1190  | |-- 00000.jpg
1191  | |-- 00001.jpg
1192  | |-- ...
1193  | '-- 02537.jpg
1194  |-- depth
1195  | |-- 00000.png
1196  | |-- 00001.png
1197  | |-- ...
1198  | '-- 02537.png
1199  |-- depth_noisy
1200  | |-- 00000.png
1201  | |-- 00001.png
1202  | |-- ...
1203  | '-- 02537.png
1204  |-- dist-model.txt
1205  |-- office2.oni
1206  |-- office2-traj.txt
1207  '-- office.ply
1208 )doc");
1209  dataset.def(py::init<const std::string&>(), "data_root"_a = "");
1210  dataset.def_property_readonly("point_cloud_path",
1211  &RedwoodIndoorOffice2::GetPointCloudPath,
1212  "Path to the point cloud.");
1213  dataset.def_property_readonly("color_paths",
1214  &RedwoodIndoorOffice2::GetColorPaths,
1215  "List of paths to color images.");
1216  dataset.def_property_readonly("depth_paths",
1217  &RedwoodIndoorOffice2::GetDepthPaths,
1218  "List of paths to depth images.");
1219  dataset.def_property_readonly("noisy_depth_paths",
1220  &RedwoodIndoorOffice2::GetNoisyDepthPaths,
1221  "List of paths to noisy depth images.");
1222  dataset.def_property_readonly("oni_path", &RedwoodIndoorOffice2::GetONIPath,
1223  "Path to the oni file.");
1224  dataset.def_property_readonly("trajectory_path",
1225  &RedwoodIndoorOffice2::GetTrajectoryPath,
1226  "Path to the trajectory file.");
1227  dataset.def_property_readonly("noise_model_path",
1228  &RedwoodIndoorOffice2::GetNoiseModelPath,
1229  "Path to the noise model file.");
1230 }
1231 
1232 void pybind_facets_model(py::module& m) {
1233  // cloudViewer.data.FacetsModel
1234  py::class_<FacetsModel, PyDownloadDataset<FacetsModel>,
1235  std::shared_ptr<FacetsModel>, DownloadDataset>
1236  facets_model(m, "FacetsModel",
1237  "Data class for `FacetsModel` contains the "
1238  "`facets.bin` from the `CloudViewer` project.");
1239  facets_model.def(py::init<const std::string&>(), "data_root"_a = "")
1240  .def_property_readonly("path", &FacetsModel::GetPath,
1241  "Path to the `facets.bin` file.");
1242  docstring::ClassMethodDocInject(m, "FacetsModel", "path");
1243 }
1244 
1245 void pybind_polylines_model(py::module& m) {
1246  // cloudViewer.data.PolylinesModel
1247  py::class_<PolylinesModel, PyDownloadDataset<PolylinesModel>,
1248  std::shared_ptr<PolylinesModel>, DownloadDataset>
1249  polylines_model(m, "PolylinesModel",
1250  "Data class for `PolylinesModel` contains the "
1251  "`polylines.bin` from the `CloudViewer` project.");
1252  polylines_model.def(py::init<const std::string&>(), "data_root"_a = "")
1253  .def_property_readonly("path", &PolylinesModel::GetPath,
1254  "Path to the `polylines.bin` file.");
1255  docstring::ClassMethodDocInject(m, "PolylinesModel", "path");
1256 }
1257 
1258 void pybind_baluster_vase(py::module& m) {
1259  // cloudViewer.data.BalusterVase
1260  py::class_<BalusterVase, PyDownloadDataset<BalusterVase>,
1261  std::shared_ptr<BalusterVase>, DownloadDataset>
1262  baluster_vase(m, "BalusterVase",
1263  "Data class for `BalusterVase` contains the "
1264  "`F1980_baluster_vase.glb` from the `CloudViewer` "
1265  "project.");
1266  baluster_vase.def(py::init<const std::string&>(), "data_root"_a = "")
1267  .def_property_readonly(
1268  "path", &BalusterVase::GetPath,
1269  "Path to the `F1980_baluster_vase.glb` file.");
1270  docstring::ClassMethodDocInject(m, "BalusterVase", "path");
1271 }
1272 
1273 void pybind_data(py::module& m) {
1274  py::module m_submodule = m.def_submodule("data", "Data handling module.");
1275  pybind_data_classes(m_submodule);
1276  // Demo data.
1277  pybind_demo_icp_pointclouds(m_submodule);
1278  pybind_demo_colored_icp_pointclouds(m_submodule);
1279  pybind_demo_crop_pointcloud(m_submodule);
1280  pybind_demo_doppler_icp_sequence(m_submodule);
1281  pybind_demo_feature_matching_point_clouds(m_submodule);
1282  pybind_demo_pose_graph_optimization(m_submodule);
1283  pybind_demo_custom_visualization(m_submodule);
1284  // Sample point cloud data.
1285  pybind_pcd_point_cloud(m_submodule);
1286  pybind_ply_point_cloud(m_submodule);
1287  // RGBD data.
1288  pybind_sample_nyu_rgbd_image(m_submodule);
1289  pybind_sample_sun_rgbd_image(m_submodule);
1290  pybind_sample_tum_rgbd_image(m_submodule);
1291  pybind_sample_redwood_rgbd_images(m_submodule);
1292  pybind_sample_fountain_rgbd_images(m_submodule);
1293  // RealSense Bag file.
1294  pybind_sample_l515_bag(m_submodule);
1295  // Point Cloud data.
1296  pybind_eagle(m_submodule);
1297  // Triangle Mesh data.
1298  pybind_armadillo(m_submodule);
1299  pybind_bunny(m_submodule);
1300  pybind_knot(m_submodule);
1301  // Triangle Model data with PBR material.
1302  pybind_monkey(m_submodule);
1303  pybind_sword(m_submodule);
1304  pybind_crate(m_submodule);
1305  pybind_helmet(m_submodule);
1306  pybind_avocado(m_submodule);
1307  pybind_damaged_helmet(m_submodule);
1308  // Texture images for material.
1309  pybind_metal_texture(m_submodule);
1310  pybind_painted_plaster_texture(m_submodule);
1311  pybind_tiles_texture(m_submodule);
1312  pybind_terrazzo_texture(m_submodule);
1313  pybind_wood_texture(m_submodule);
1314  pybind_wood_floor_texture(m_submodule);
1315  // Image data.
1316  pybind_juneau(m_submodule);
1317  // Point Cloud fragments data.
1318  pybind_living_room_point_clouds(m_submodule);
1319  pybind_office_point_clouds(m_submodule);
1320  pybind_lounge_rgbd_images(m_submodule);
1321  pybind_bedroom_rgbd_images(m_submodule);
1322  pybind_jackjack_l515_bag(m_submodule);
1323  // RedwoodIndoor (Augmented ICL-NUIM Dataset).
1324  pybind_redwood_indoor_living_room1(m_submodule);
1325  pybind_redwood_indoor_living_room2(m_submodule);
1326  pybind_redwood_indoor_office1(m_submodule);
1327  pybind_redwood_indoor_office2(m_submodule);
1328  // Model data.
1329  pybind_facets_model(m_submodule);
1330  pybind_polylines_model(m_submodule);
1331  // Texture mesh data.
1332  pybind_baluster_vase(m_submodule);
1333 }
1334 
1335 } // namespace data
1336 } // namespace cloudViewer
cloudViewer::data::ArmadilloMesh::GetPath
std::string GetPath() const
Path to the ArmadilloMesh.ply file.
Definition: Dataset.h:178
cloudViewer::data::AvocadoModel::GetPath
std::string GetPath() const
Path to the GLB format avocado model.
Definition: Dataset.h:193
cloudViewer::data::BalusterVase::GetPath
std::string GetPath() const
Path to the F1980_baluster_vase.glb file.
Definition: Dataset.h:1309
cloudViewer::data::BedroomRGBDImages::GetTrajectoryLogPath
std::string GetTrajectoryLogPath() const
Path to camera trajectory log file lounge_trajectory.log.
Definition: Dataset.h:215
cloudViewer::data::BedroomRGBDImages::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Returns List of paths to depth image samples of size 21931.
Definition: Dataset.h:211
cloudViewer::data::BedroomRGBDImages::GetReconstructionPath
std::string GetReconstructionPath() const
Path to mesh reconstruction bedroom.ply.
Definition: Dataset.h:217
cloudViewer::data::BedroomRGBDImages::GetColorPaths
std::vector< std::string > GetColorPaths() const
Returns List of paths to color image samples of size 21931.
Definition: Dataset.h:209
cloudViewer::data::BunnyMesh::GetPath
std::string GetPath() const
Path to the BunnyMesh.ply file.
Definition: Dataset.h:239
cloudViewer::data::CrateModel
Data class for CrateModel contains a sword model file, along with material and various other texture ...
Definition: Dataset.h:252
cloudViewer::data::CrateModel::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:264
cloudViewer::data::DamagedHelmetModel::GetPath
std::string GetPath() const
Path to the GLB format damaged helmet model.
Definition: Dataset.h:281
cloudViewer::data::Dataset
Base CloudViewer dataset class.
Definition: Dataset.h:61
cloudViewer::data::Dataset::GetPrefix
const std::string GetPrefix() const
Get prefix for the dataset.
Definition: Dataset.h:84
cloudViewer::data::Dataset::GetDataRoot
const std::string GetDataRoot() const
Get data root directory. The data root is set at construction time or automatically determined.
Definition: Dataset.h:81
cloudViewer::data::Dataset::GetExtractDir
const std::string GetExtractDir() const
Get absolute path to extract directory. i.e. ${data_root}/extract/${prefix}.
Definition: Dataset.h:94
cloudViewer::data::Dataset::GetDownloadDir
const std::string GetDownloadDir() const
Get absolute path to download directory. i.e. ${data_root}/download/${prefix}.
Definition: Dataset.h:88
cloudViewer::data::DemoColoredICPPointClouds
Data class for DemoColoredICPPointClouds contains 2 point clouds of PLY format. This data is used in ...
Definition: Dataset.h:293
cloudViewer::data::DemoCropPointCloud::GetPointCloudPath
std::string GetPointCloudPath() const
Path to example point cloud.
Definition: Dataset.h:318
cloudViewer::data::DemoCropPointCloud::GetCroppedJSONPath
std::string GetCroppedJSONPath() const
Path to saved selected polygon volume file.
Definition: Dataset.h:320
cloudViewer::data::DemoCustomVisualization
Data class for DemoCustomVisualization contains an example point-cloud, camera trajectory (json file)...
Definition: Dataset.h:334
cloudViewer::data::DemoCustomVisualization::GetTrajectoryPath
std::string GetTrajectoryPath() const
Path to the camera_trajectory.json.
Definition: Dataset.h:341
cloudViewer::data::DemoCustomVisualization::GetPointCloudPath
std::string GetPointCloudPath() const
Path to the point cloud (ply).
Definition: Dataset.h:339
cloudViewer::data::DemoCustomVisualization::GetRenderOptionPath
std::string GetRenderOptionPath() const
Path to the renderoption.json.
Definition: Dataset.h:343
cloudViewer::data::DemoDopplerICPSequence
Data class for DemoDopplerICPSequence contains an example sequence of 100 point clouds with Doppler v...
Definition: Dataset.h:355
cloudViewer::data::DemoDopplerICPSequence::GetPaths
std::vector< std::string > GetPaths() const
Returns the list of the point cloud paths in the sequence.
Definition: Dataset.h:360
cloudViewer::data::DemoDopplerICPSequence::GetCalibrationPath
std::string GetCalibrationPath() const
Path to the calibration metadata file, containing transformation between the vehicle and sensor frame...
Definition: Dataset.h:365
cloudViewer::data::DemoDopplerICPSequence::GetTrajectoryPath
std::string GetTrajectoryPath() const
Path to the ground truth poses for the entire sequence.
Definition: Dataset.h:367
cloudViewer::data::DemoFeatureMatchingPointClouds
Data class for DemoFeatureMatchingPointClouds contains 2 point cloud fragments and their respective F...
Definition: Dataset.h:389
cloudViewer::data::DemoFeatureMatchingPointClouds::GetFPFHFeaturePaths
std::vector< std::string > GetFPFHFeaturePaths() const
Returns list of paths to saved FPFH features binary for point clouds, respectively,...
Definition: Dataset.h:399
cloudViewer::data::DemoFeatureMatchingPointClouds::GetL32DFeaturePaths
std::vector< std::string > GetL32DFeaturePaths() const
Returns list of paths to saved L32D features binary for point clouds, respectively,...
Definition: Dataset.h:404
cloudViewer::data::DemoFeatureMatchingPointClouds::GetPointCloudPaths
std::vector< std::string > GetPointCloudPaths() const
Returns list of paths to point clouds, of size 2.
Definition: Dataset.h:394
cloudViewer::data::DemoICPPointClouds
Data class for DemoICPPointClouds contains 3 point clouds of binary PCD format. This data is used in ...
Definition: Dataset.h:423
cloudViewer::data::DemoICPPointClouds::GetTransformationLogPath
std::string GetTransformationLogPath() const
Path to the transformation metadata log file, containing transformation between frame 0 and 1,...
Definition: Dataset.h:434
cloudViewer::data::DemoPoseGraphOptimization
Data class for DemoPoseGraphOptimization contains an example fragment pose graph, and global pose gra...
Definition: Dataset.h:448
cloudViewer::data::DemoPoseGraphOptimization::GetPoseGraphFragmentPath
std::string GetPoseGraphFragmentPath() const
Path to example global pose graph (json).
Definition: Dataset.h:453
cloudViewer::data::DemoPoseGraphOptimization::GetPoseGraphGlobalPath
std::string GetPoseGraphGlobalPath() const
Path to example fragment pose graph (json).
Definition: Dataset.h:457
cloudViewer::data::DownloadDataset
Dataset class with one or more downloaded file.
Definition: Dataset.h:152
cloudViewer::data::EaglePointCloud::GetPath
std::string GetPath() const
Path to the EaglePointCloud.ply file.
Definition: Dataset.h:476
cloudViewer::data::FacetsModel::GetPath
std::string GetPath() const
Path to the facets.bin file.
Definition: Dataset.h:1279
cloudViewer::data::FlightHelmetModel
Data class for FlightHelmetModel contains a flight helmet model file, along with material and various...
Definition: Dataset.h:489
cloudViewer::data::FlightHelmetModel::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:502
cloudViewer::data::JackJackL515Bag::GetPath
std::string GetPath() const
Path to the JackJackL515Bag.bag file.
Definition: Dataset.h:519
cloudViewer::data::JuneauImage::GetPath
std::string GetPath() const
Path to the JuneauImage.jgp file.
Definition: Dataset.h:533
cloudViewer::data::KnotMesh::GetPath
std::string GetPath() const
Path to the KnotMesh.ply file.
Definition: Dataset.h:547
cloudViewer::data::LivingRoomPointClouds
Dataset class for LivingRoomPointClouds contains 57 point clouds of binary PLY format.
Definition: Dataset.h:558
cloudViewer::data::LoungeRGBDImages::GetReconstructionPath
std::string GetReconstructionPath() const
Path to mesh reconstruction lounge.ply.
Definition: Dataset.h:591
cloudViewer::data::LoungeRGBDImages::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Returns List of paths to depth image samples of size 3000.
Definition: Dataset.h:585
cloudViewer::data::LoungeRGBDImages::GetColorPaths
std::vector< std::string > GetColorPaths() const
Returns List of paths to color image samples of size 3000.
Definition: Dataset.h:583
cloudViewer::data::LoungeRGBDImages::GetTrajectoryLogPath
std::string GetTrajectoryLogPath() const
Path to camera trajectory log file lounge_trajectory.log.
Definition: Dataset.h:589
cloudViewer::data::MetalTexture::GetAlbedoTexturePath
std::string GetAlbedoTexturePath() const
Returns the path to albedo color texture image.
Definition: Dataset.h:612
cloudViewer::data::MetalTexture::GetMetallicTexturePath
std::string GetMetallicTexturePath() const
Returns the path to metallic texture image.
Definition: Dataset.h:624
cloudViewer::data::MetalTexture::GetRoughnessTexturePath
std::string GetRoughnessTexturePath() const
Returns the path to roughness texture image.
Definition: Dataset.h:620
cloudViewer::data::MetalTexture::GetNormalTexturePath
std::string GetNormalTexturePath() const
Returns the path to normal texture image.
Definition: Dataset.h:616
cloudViewer::data::MetalTexture::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:629
cloudViewer::data::MonkeyModel
Data class for MonkeyModel contains a monkey model file, along with material and various other textur...
Definition: Dataset.h:644
cloudViewer::data::MonkeyModel::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:656
cloudViewer::data::OfficePointClouds
Dataset class for OfficePointClouds contains 53 point clouds of binary PLY format.
Definition: Dataset.h:669
cloudViewer::data::PCDPointCloud::GetPath
std::string GetPath() const
Path to the pcd format point cloud.
Definition: Dataset.h:693
cloudViewer::data::PLYPointCloud::GetPath
std::string GetPath() const
Path to the PLY format point cloud.
Definition: Dataset.h:708
cloudViewer::data::PTSPointCloud::GetPath
std::string GetPath() const
Path to the PTS format point cloud.
Definition: Dataset.h:723
cloudViewer::data::PaintedPlasterTexture::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:750
cloudViewer::data::PaintedPlasterTexture::GetNormalTexturePath
std::string GetNormalTexturePath() const
Returns the path to normal texture image.
Definition: Dataset.h:741
cloudViewer::data::PaintedPlasterTexture::GetRoughnessTexturePath
std::string GetRoughnessTexturePath() const
Returns the path to roughness texture image.
Definition: Dataset.h:745
cloudViewer::data::PaintedPlasterTexture::GetAlbedoTexturePath
std::string GetAlbedoTexturePath() const
Returns the path to albedo color texture image.
Definition: Dataset.h:737
cloudViewer::data::PolylinesModel::GetPath
std::string GetPath() const
Path to the polylines.bin file.
Definition: Dataset.h:1294
cloudViewer::data::RedwoodIndoorLivingRoom1
Data class for RedwoodIndoorLivingRoom1, containing dense point cloud, rgb sequence,...
Definition: Dataset.h:784
cloudViewer::data::RedwoodIndoorLivingRoom1::GetNoiseModelPath
std::string GetNoiseModelPath() const
Path to the noise model.
Definition: Dataset.h:803
cloudViewer::data::RedwoodIndoorLivingRoom1::GetColorPaths
std::vector< std::string > GetColorPaths() const
Paths to the color images.
Definition: Dataset.h:791
cloudViewer::data::RedwoodIndoorLivingRoom1::GetPointCloudPath
std::string GetPointCloudPath() const
Path to the point cloud.
Definition: Dataset.h:789
cloudViewer::data::RedwoodIndoorLivingRoom1::GetNoisyDepthPaths
std::vector< std::string > GetNoisyDepthPaths() const
Paths to the noisy depth images.
Definition: Dataset.h:795
cloudViewer::data::RedwoodIndoorLivingRoom1::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Paths to the clean depth images.
Definition: Dataset.h:793
cloudViewer::data::RedwoodIndoorLivingRoom1::GetONIPath
std::string GetONIPath() const
Paths to the ONI sequence.
Definition: Dataset.h:799
cloudViewer::data::RedwoodIndoorLivingRoom1::GetTrajectoryPath
std::string GetTrajectoryPath() const
Path to the ground-truth camera trajectory.
Definition: Dataset.h:801
cloudViewer::data::RedwoodIndoorLivingRoom2::GetNoiseModelPath
std::string GetNoiseModelPath() const
Path to the noise model.
Definition: Dataset.h:859
cloudViewer::data::RedwoodIndoorLivingRoom2::GetColorPaths
std::vector< std::string > GetColorPaths() const
Paths to the color images.
Definition: Dataset.h:847
cloudViewer::data::RedwoodIndoorLivingRoom2::GetNoisyDepthPaths
std::vector< std::string > GetNoisyDepthPaths() const
Paths to the noisy depth images.
Definition: Dataset.h:851
cloudViewer::data::RedwoodIndoorLivingRoom2::GetPointCloudPath
std::string GetPointCloudPath() const
Path to the point cloud.
Definition: Dataset.h:845
cloudViewer::data::RedwoodIndoorLivingRoom2::GetTrajectoryPath
std::string GetTrajectoryPath() const
Path to the ground-truth camera trajectory.
Definition: Dataset.h:857
cloudViewer::data::RedwoodIndoorLivingRoom2::GetONIPath
std::string GetONIPath() const
Paths to the ONI sequence.
Definition: Dataset.h:855
cloudViewer::data::RedwoodIndoorLivingRoom2::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Paths to the clean depth images.
Definition: Dataset.h:849
cloudViewer::data::RedwoodIndoorOffice1::GetTrajectoryPath
std::string GetTrajectoryPath() const
Path to the ground-truth camera trajectory.
Definition: Dataset.h:913
cloudViewer::data::RedwoodIndoorOffice1::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Paths to the clean depth images.
Definition: Dataset.h:905
cloudViewer::data::RedwoodIndoorOffice1::GetPointCloudPath
std::string GetPointCloudPath() const
Path to the point cloud.
Definition: Dataset.h:901
cloudViewer::data::RedwoodIndoorOffice1::GetONIPath
std::string GetONIPath() const
Paths to the ONI sequence.
Definition: Dataset.h:911
cloudViewer::data::RedwoodIndoorOffice1::GetNoiseModelPath
std::string GetNoiseModelPath() const
Path to the noise model.
Definition: Dataset.h:915
cloudViewer::data::RedwoodIndoorOffice1::GetNoisyDepthPaths
std::vector< std::string > GetNoisyDepthPaths() const
Paths to the noisy depth images.
Definition: Dataset.h:907
cloudViewer::data::RedwoodIndoorOffice1::GetColorPaths
std::vector< std::string > GetColorPaths() const
Paths to the color images.
Definition: Dataset.h:903
cloudViewer::data::RedwoodIndoorOffice2::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Paths to the clean depth images.
Definition: Dataset.h:961
cloudViewer::data::RedwoodIndoorOffice2::GetTrajectoryPath
std::string GetTrajectoryPath() const
Path to the ground-truth camera trajectory.
Definition: Dataset.h:969
cloudViewer::data::RedwoodIndoorOffice2::GetColorPaths
std::vector< std::string > GetColorPaths() const
Paths to the color images.
Definition: Dataset.h:959
cloudViewer::data::RedwoodIndoorOffice2::GetNoisyDepthPaths
std::vector< std::string > GetNoisyDepthPaths() const
Paths to the noisy depth images.
Definition: Dataset.h:963
cloudViewer::data::RedwoodIndoorOffice2::GetONIPath
std::string GetONIPath() const
Paths to the ONI sequence.
Definition: Dataset.h:967
cloudViewer::data::RedwoodIndoorOffice2::GetPointCloudPath
std::string GetPointCloudPath() const
Path to the point cloud.
Definition: Dataset.h:957
cloudViewer::data::RedwoodIndoorOffice2::GetNoiseModelPath
std::string GetNoiseModelPath() const
Path to the noise model.
Definition: Dataset.h:971
cloudViewer::data::SampleFountainRGBDImages
Data class for SampleFountainRGBDImages contains a sample set of 33 color and depth images from the F...
Definition: Dataset.h:986
cloudViewer::data::SampleFountainRGBDImages::GetColorPaths
std::vector< std::string > GetColorPaths() const
Returns List of paths to color image samples of size 33.
Definition: Dataset.h:991
cloudViewer::data::SampleFountainRGBDImages::GetKeyframePosesLogPath
std::string GetKeyframePosesLogPath() const
Path to camera poses at key frames log file key.log.
Definition: Dataset.h:995
cloudViewer::data::SampleFountainRGBDImages::GetReconstructionPath
std::string GetReconstructionPath() const
Path to mesh reconstruction.
Definition: Dataset.h:999
cloudViewer::data::SampleFountainRGBDImages::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Returns List of paths to depth image samples of size 33.
Definition: Dataset.h:993
cloudViewer::data::SampleL515Bag::GetPath
std::string GetPath() const
Path to the SampleL515Bag.bag file.
Definition: Dataset.h:1015
cloudViewer::data::SampleNYURGBDImage::GetDepthPath
std::string GetDepthPath() const
Path to depth image sample.
Definition: Dataset.h:1033
cloudViewer::data::SampleNYURGBDImage::GetColorPath
std::string GetColorPath() const
Path to color image sample.
Definition: Dataset.h:1031
cloudViewer::data::SampleRedwoodRGBDImages
Data class for SampleRedwoodRGBDImages contains a sample set of 5 color and depth images from Redwood...
Definition: Dataset.h:1047
cloudViewer::data::SampleRedwoodRGBDImages::GetOdometryLogPath
std::string GetOdometryLogPath() const
Path to camera trajectory log file odometry.log.
Definition: Dataset.h:1059
cloudViewer::data::SampleRedwoodRGBDImages::GetTrajectoryLogPath
std::string GetTrajectoryLogPath() const
Path to camera trajectory log file trajectory.log.
Definition: Dataset.h:1057
cloudViewer::data::SampleRedwoodRGBDImages::GetDepthPaths
std::vector< std::string > GetDepthPaths() const
Returns List of paths to depth image samples of size 5.
Definition: Dataset.h:1054
cloudViewer::data::SampleRedwoodRGBDImages::GetReconstructionPath
std::string GetReconstructionPath() const
Path to point cloud reconstruction from TSDF.
Definition: Dataset.h:1063
cloudViewer::data::SampleRedwoodRGBDImages::GetRGBDMatchPath
std::string GetRGBDMatchPath() const
Path to color and depth image match file rgbd.match.
Definition: Dataset.h:1061
cloudViewer::data::SampleRedwoodRGBDImages::GetCameraIntrinsicPath
std::string GetCameraIntrinsicPath() const
Path to pinhole camera intrinsic (json).
Definition: Dataset.h:1065
cloudViewer::data::SampleRedwoodRGBDImages::GetColorPaths
std::vector< std::string > GetColorPaths() const
Returns List of paths to color image samples of size 5.
Definition: Dataset.h:1052
cloudViewer::data::SampleSUNRGBDImage::GetColorPath
std::string GetColorPath() const
Path to color image sample.
Definition: Dataset.h:1096
cloudViewer::data::SampleSUNRGBDImage::GetDepthPath
std::string GetDepthPath() const
Path to depth image sample.
Definition: Dataset.h:1098
cloudViewer::data::SampleTUMRGBDImage::GetColorPath
std::string GetColorPath() const
Path to color image sample.
Definition: Dataset.h:1116
cloudViewer::data::SampleTUMRGBDImage::GetDepthPath
std::string GetDepthPath() const
Path to depth image sample.
Definition: Dataset.h:1118
cloudViewer::data::SwordModel
Data class for SwordModel contains a sword model file, along with material and various other texture ...
Definition: Dataset.h:1133
cloudViewer::data::SwordModel::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:1146
cloudViewer::data::TerrazzoTexture::GetNormalTexturePath
std::string GetNormalTexturePath() const
Returns the path to normal texture image.
Definition: Dataset.h:1166
cloudViewer::data::TerrazzoTexture::GetAlbedoTexturePath
std::string GetAlbedoTexturePath() const
Returns the path to albedo color texture image.
Definition: Dataset.h:1162
cloudViewer::data::TerrazzoTexture::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:1175
cloudViewer::data::TerrazzoTexture::GetRoughnessTexturePath
std::string GetRoughnessTexturePath() const
Returns the path to roughness texture image.
Definition: Dataset.h:1170
cloudViewer::data::TilesTexture::GetNormalTexturePath
std::string GetNormalTexturePath() const
Returns the path to normal texture image.
Definition: Dataset.h:1195
cloudViewer::data::TilesTexture::GetAlbedoTexturePath
std::string GetAlbedoTexturePath() const
Returns the path to albedo color texture image.
Definition: Dataset.h:1191
cloudViewer::data::TilesTexture::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:1204
cloudViewer::data::TilesTexture::GetRoughnessTexturePath
std::string GetRoughnessTexturePath() const
Returns the path to roughness texture image.
Definition: Dataset.h:1199
cloudViewer::data::WoodFloorTexture::GetRoughnessTexturePath
std::string GetRoughnessTexturePath() const
Returns the path to roughness texture image.
Definition: Dataset.h:1228
cloudViewer::data::WoodFloorTexture::GetAlbedoTexturePath
std::string GetAlbedoTexturePath() const
Returns the path to albedo color texture image.
Definition: Dataset.h:1220
cloudViewer::data::WoodFloorTexture::GetNormalTexturePath
std::string GetNormalTexturePath() const
Returns the path to normal texture image.
Definition: Dataset.h:1224
cloudViewer::data::WoodFloorTexture::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:1233
cloudViewer::data::WoodTexture::GetNormalTexturePath
std::string GetNormalTexturePath() const
Returns the path to normal texture image.
Definition: Dataset.h:1253
cloudViewer::data::WoodTexture::GetPathMap
std::unordered_map< std::string, std::string > GetPathMap() const
Returns the map of filename to path. Refer documentation page for available options.
Definition: Dataset.h:1262
cloudViewer::data::WoodTexture::GetRoughnessTexturePath
std::string GetRoughnessTexturePath() const
Returns the path to roughness texture image.
Definition: Dataset.h:1257
cloudViewer::data::WoodTexture::GetAlbedoTexturePath
std::string GetAlbedoTexturePath() const
Returns the path to albedo color texture image.
Definition: Dataset.h:1249
cloudViewer_pybind.h
cloudViewer::data::CloudViewerDownloadsPrefix
std::string CloudViewerDownloadsPrefix()
Definition: Dataset.cpp:49
cloudViewer::data::pybind_demo_pose_graph_optimization
void pybind_demo_pose_graph_optimization(py::module &m)
Definition: dataset.cpp:253
cloudViewer::data::pybind_pts_point_cloud
void pybind_pts_point_cloud(py::module &m)
Definition: dataset.cpp:343
cloudViewer::data::pybind_painted_plaster_texture
void pybind_painted_plaster_texture(py::module &m)
Definition: dataset.cpp:731
cloudViewer::data::pybind_pcd_point_cloud
void pybind_pcd_point_cloud(py::module &m)
Definition: dataset.cpp:315
cloudViewer::data::pybind_ply_point_cloud
void pybind_ply_point_cloud(py::module &m)
Definition: dataset.cpp:329
cloudViewer::data::pybind_crate
void pybind_crate(py::module &m)
Definition: dataset.cpp:624
cloudViewer::data::pybind_sample_sun_rgbd_image
void pybind_sample_sun_rgbd_image(py::module &m)
Definition: dataset.cpp:375
cloudViewer::data::pybind_damaged_helmet
void pybind_damaged_helmet(py::module &m)
Definition: dataset.cpp:684
cloudViewer::data::pybind_living_room_point_clouds
void pybind_living_room_point_clouds(py::module &m)
Definition: dataset.cpp:889
cloudViewer::data::pybind_eagle
void pybind_eagle(py::module &m)
Definition: dataset.cpp:527
cloudViewer::data::pybind_armadillo
void pybind_armadillo(py::module &m)
Definition: dataset.cpp:540
cloudViewer::data::pybind_bedroom_rgbd_images
void pybind_bedroom_rgbd_images(py::module &m)
Definition: dataset.cpp:966
cloudViewer::data::pybind_demo_doppler_icp_sequence
void pybind_demo_doppler_icp_sequence(py::module &m)
Definition: dataset.cpp:181
cloudViewer::data::data_descriptor
static const DataDescriptor data_descriptor
Definition: ArmadilloMesh.cpp:18
cloudViewer::data::pybind_avocado
void pybind_avocado(py::module &m)
Definition: dataset.cpp:670
cloudViewer::data::pybind_redwood_indoor_living_room1
void pybind_redwood_indoor_living_room1(py::module &m)
Definition: dataset.cpp:1016
cloudViewer::data::pybind_sample_redwood_rgbd_images
void pybind_sample_redwood_rgbd_images(py::module &m)
Definition: dataset.cpp:413
cloudViewer::data::pybind_redwood_indoor_office1
void pybind_redwood_indoor_office1(py::module &m)
Definition: dataset.cpp:1076
cloudViewer::data::pybind_helmet
void pybind_helmet(py::module &m)
Definition: dataset.cpp:646
cloudViewer::data::pybind_polylines_model
void pybind_polylines_model(py::module &m)
Definition: dataset.cpp:1145
cloudViewer::data::pybind_knot
void pybind_knot(py::module &m)
Definition: dataset.cpp:568
cloudViewer::data::pybind_redwood_indoor_office2
void pybind_redwood_indoor_office2(py::module &m)
Definition: dataset.cpp:1104
cloudViewer::data::pybind_demo_custom_visualization
void pybind_demo_custom_visualization(py::module &m)
Definition: dataset.cpp:281
cloudViewer::data::pybind_office_point_clouds
void pybind_office_point_clouds(py::module &m)
Definition: dataset.cpp:910
cloudViewer::data::pybind_data_classes
void pybind_data_classes(py::module &m)
Definition: dataset.cpp:29
cloudViewer::data::pybind_jackjack_l515_bag
void pybind_jackjack_l515_bag(py::module &m)
Definition: dataset.cpp:1003
cloudViewer::data::pybind_demo_crop_pointcloud
void pybind_demo_crop_pointcloud(py::module &m)
Definition: dataset.cpp:156
cloudViewer::data::pybind_sample_fountain_rgbd_images
void pybind_sample_fountain_rgbd_images(py::module &m)
Definition: dataset.cpp:472
cloudViewer::data::pybind_tiles_texture
void pybind_tiles_texture(py::module &m)
Definition: dataset.cpp:764
cloudViewer::data::pybind_sample_nyu_rgbd_image
void pybind_sample_nyu_rgbd_image(py::module &m)
Definition: dataset.cpp:356
cloudViewer::data::pybind_terrazzo_texture
void pybind_terrazzo_texture(py::module &m)
Definition: dataset.cpp:791
cloudViewer::data::pybind_redwood_indoor_living_room2
void pybind_redwood_indoor_living_room2(py::module &m)
Definition: dataset.cpp:1046
cloudViewer::data::pybind_facets_model
void pybind_facets_model(py::module &m)
Definition: dataset.cpp:1132
cloudViewer::data::pybind_monkey
void pybind_monkey(py::module &m)
Definition: dataset.cpp:580
cloudViewer::data::pybind_demo_icp_pointclouds
void pybind_demo_icp_pointclouds(py::module &m)
Definition: dataset.cpp:106
cloudViewer::data::pybind_bunny
void pybind_bunny(py::module &m)
Definition: dataset.cpp:554
cloudViewer::data::pybind_wood_texture
void pybind_wood_texture(py::module &m)
Definition: dataset.cpp:820
cloudViewer::data::GetCustomDownloadsPrefix
std::string GetCustomDownloadsPrefix()
Definition: Dataset.cpp:47
cloudViewer::data::pybind_data
void pybind_data(py::module &m)
Definition: dataset.cpp:1173
cloudViewer::data::SetCustomDownloadsPrefix
void SetCustomDownloadsPrefix(const std::string &prefix)
Definition: Dataset.cpp:36
cloudViewer::data::pybind_baluster_vase
void pybind_baluster_vase(py::module &m)
Definition: dataset.cpp:1158
cloudViewer::data::pybind_demo_colored_icp_pointclouds
void pybind_demo_colored_icp_pointclouds(py::module &m)
Definition: dataset.cpp:133
cloudViewer::data::pybind_wood_floor_texture
void pybind_wood_floor_texture(py::module &m)
Definition: dataset.cpp:846
cloudViewer::data::pybind_sword
void pybind_sword(py::module &m)
Definition: dataset.cpp:602
cloudViewer::data::pybind_metal_texture
void pybind_metal_texture(py::module &m)
Definition: dataset.cpp:700
cloudViewer::data::pybind_sample_l515_bag
void pybind_sample_l515_bag(py::module &m)
Definition: dataset.cpp:514
cloudViewer::data::pybind_sample_tum_rgbd_image
void pybind_sample_tum_rgbd_image(py::module &m)
Definition: dataset.cpp:394
cloudViewer::data::pybind_demo_feature_matching_point_clouds
void pybind_demo_feature_matching_point_clouds(py::module &m)
Definition: dataset.cpp:214
cloudViewer::data::pybind_juneau
void pybind_juneau(py::module &m)
Definition: dataset.cpp:875
cloudViewer::data::pybind_lounge_rgbd_images
void pybind_lounge_rgbd_images(py::module &m)
Definition: dataset.cpp:930
cloudViewer::docstring::ClassMethodDocInject
void ClassMethodDocInject(py::module &pybind_module, const std::string &class_name, const std::string &function_name, const std::unordered_map< std::string, std::string > &map_parameter_body_docs)
Definition: docstring.cpp:27
cloudViewer
Generic file read and write utility for python interface.
Definition: AutoSegmentationTools.h:16
cloudViewer::data::DataDescriptor
Infomation about a file to be downloaded.
Definition: Dataset.h:111
cloudViewer::data::DataDescriptor::md5_
std::string md5_
MD5 checksum of the downloaded file.
Definition: Dataset.h:137
cloudViewer::data::DataDescriptor::urls_
std::vector< std::string > urls_
List of URL mirrors.
Definition: Dataset.h:134