ACloudViewer  3.9.4
A Modern Library for 3D Data Processing
Feature.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 "cloudViewer/t/pipelines/registration/Feature.h"
9 
10 #include <benchmark/benchmark.h>
11 #include <ecvFeature.h>
12 
13 #include "cloudViewer/core/CUDAUtils.h"
14 #include "cloudViewer/data/Dataset.h"
15 #include "cloudViewer/geometry/PointCloud.h"
16 #include "cloudViewer/t/geometry/PointCloud.h"
17 #include "cloudViewer/t/io/PointCloudIO.h"
18 
19 namespace cloudViewer {
20 namespace t {
21 namespace pipelines {
22 namespace registration {
23 
24 data::BunnyMesh pointcloud_ply;
25 static const std::string path = pointcloud_ply.GetPath();
26 
27 void LegacyComputeFPFHFeature(benchmark::State& state,
28  utility::optional<int> max_nn,
29  utility::optional<double> radius,
30  utility::optional<double> ratio_indices) {
31  auto pcd =
32  cloudViewer::io::CreatePointCloudFromFile(path)->UniformDownSample(
33  3);
34  pcd->EstimateNormals();
35 
36  utility::optional<std::vector<size_t>> indices = utility::nullopt;
37  if (ratio_indices.has_value()) {
38  std::vector<size_t> indices_tmp;
39  size_t step = 1.0 / ratio_indices.value();
40  size_t n_indices = pcd->size() / step;
41  indices_tmp.reserve(n_indices);
42  for (size_t index = 0; index < pcd->size(); index += step) {
43  indices_tmp.push_back(index);
44  }
45  indices.emplace(indices_tmp);
46  }
47 
48  for (auto _ : state) {
49  if (max_nn.has_value() && radius.has_value()) {
50  auto fpfh = cloudViewer::utility::ComputeFPFHFeature(
51  *pcd,
52  cloudViewer::geometry::KDTreeSearchParamHybrid(
53  radius.value(), max_nn.value()),
54  indices);
55  } else if (max_nn.has_value() && !radius.has_value()) {
56  auto fpfh = cloudViewer::utility::ComputeFPFHFeature(
57  *pcd,
58  cloudViewer::geometry::KDTreeSearchParamKNN(max_nn.value()),
59  indices);
60  } else if (!max_nn.has_value() && radius.has_value()) {
61  auto fpfh = cloudViewer::utility::ComputeFPFHFeature(
62  *pcd,
63  cloudViewer::geometry::KDTreeSearchParamRadius(
64  radius.value()),
65  indices);
66  }
67  }
68 }
69 
70 void ComputeFPFHFeature(benchmark::State& state,
71  const core::Device& device,
72  const core::Dtype& dtype,
73  utility::optional<int> max_nn,
74  utility::optional<double> radius,
75  utility::optional<double> ratio_indices) {
76  t::geometry::PointCloud pcd;
77  t::io::ReadPointCloud(path, pcd);
78  pcd = pcd.To(device).UniformDownSample(3);
79  pcd.SetPointPositions(pcd.GetPointPositions().To(dtype));
80  pcd.EstimateNormals();
81 
82  utility::optional<core::Tensor> indices = utility::nullopt;
83  if (ratio_indices.has_value()) {
84  std::vector<int64_t> indices_tmp;
85  int64_t step = 1.0 / ratio_indices.value();
86  int64_t n_indices = pcd.GetPointPositions().GetLength() / step;
87  indices_tmp.reserve(n_indices);
88  for (int64_t index = 0; index < pcd.GetPointPositions().GetLength();
89  index += step) {
90  indices_tmp.push_back(index);
91  }
92  indices.emplace(core::Tensor(indices_tmp, {(int)indices_tmp.size()},
93  core::Int64, device));
94  }
95 
96  core::Tensor fpfh;
97  // Warm up.
98  fpfh = t::pipelines::registration::ComputeFPFHFeature(pcd, max_nn, radius,
99  indices);
100 
101  for (auto _ : state) {
102  fpfh = t::pipelines::registration::ComputeFPFHFeature(pcd, max_nn,
103  radius, indices);
104  core::cuda::Synchronize(device);
105  }
106 }
107 
108 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
109  Legacy Hybrid[0.01 | 100],
110  100,
111  0.01,
112  utility::nullopt)
113  ->Unit(benchmark::kMillisecond);
114 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
115  Legacy Hybrid[0.02 | 50],
116  50,
117  0.02,
118  utility::nullopt)
119  ->Unit(benchmark::kMillisecond);
120 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
121  Legacy Hybrid[0.02 | 100],
122  100,
123  0.02,
124  utility::nullopt)
125  ->Unit(benchmark::kMillisecond);
126 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
127  Legacy KNN[50],
128  50,
129  utility::nullopt,
130  utility::nullopt)
131  ->Unit(benchmark::kMillisecond);
132 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
133  Legacy KNN[100],
134  100,
135  utility::nullopt,
136  utility::nullopt)
137  ->Unit(benchmark::kMillisecond);
138 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
139  Legacy Radius[0.01],
140  utility::nullopt,
141  0.01,
142  utility::nullopt)
143  ->Unit(benchmark::kMillisecond);
144 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
145  Legacy Radius[0.02],
146  utility::nullopt,
147  0.02,
148  utility::nullopt)
149  ->Unit(benchmark::kMillisecond);
150 
151 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
152  Legacy Hybrid Indices[0.02 | 50 | null],
153  50,
154  0.02,
155  utility::nullopt)
156  ->Unit(benchmark::kMillisecond);
157 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
158  Legacy Hybrid Indices[0.02 | 50 | 0.0001],
159  50,
160  0.02,
161  0.0001)
162  ->Unit(benchmark::kMillisecond);
163 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
164  Legacy Hybrid Indices[0.02 | 50 | 0.001],
165  50,
166  0.02,
167  0.001)
168  ->Unit(benchmark::kMillisecond);
169 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
170  Legacy Hybrid Indices[0.02 | 50 | 0.01],
171  50,
172  0.02,
173  0.01)
174  ->Unit(benchmark::kMillisecond);
175 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
176  Legacy Hybrid Indices[0.02 | 50 | 0.1],
177  50,
178  0.02,
179  0.1)
180  ->Unit(benchmark::kMillisecond);
181 BENCHMARK_CAPTURE(LegacyComputeFPFHFeature,
182  Legacy Hybrid Indices[0.02 | 50 | 1.0],
183  50,
184  0.02,
185  1.0)
186  ->Unit(benchmark::kMillisecond);
187 
188 #define ENUM_FPFH_METHOD_DEVICE(METHOD_NAME, MAX_NN, RADIUS, INDICES, DEVICE) \
189  BENCHMARK_CAPTURE(ComputeFPFHFeature, METHOD_NAME##_Float32, \
190  core::Device(DEVICE), core::Float32, MAX_NN, RADIUS, \
191  INDICES) \
192  ->Unit(benchmark::kMillisecond); \
193  BENCHMARK_CAPTURE(ComputeFPFHFeature, METHOD_NAME##_Float64, \
194  core::Device(DEVICE), core::Float64, MAX_NN, RADIUS, \
195  INDICES) \
196  ->Unit(benchmark::kMillisecond);
197 
198 ENUM_FPFH_METHOD_DEVICE(
199  CPU[0.01 | 100] Hybrid, 100, 0.01, utility::nullopt, "CPU:0")
200 ENUM_FPFH_METHOD_DEVICE(
201  CPU[0.02 | 50] Hybrid, 50, 0.02, utility::nullopt, "CPU:0")
202 ENUM_FPFH_METHOD_DEVICE(
203  CPU[0.02 | 100] Hybrid, 100, 0.02, utility::nullopt, "CPU:0")
204 ENUM_FPFH_METHOD_DEVICE(
205  CPU[50] KNN, 50, utility::nullopt, utility::nullopt, "CPU:0")
206 ENUM_FPFH_METHOD_DEVICE(
207  CPU[100] KNN, 100, utility::nullopt, utility::nullopt, "CPU:0")
208 ENUM_FPFH_METHOD_DEVICE(
209  CPU[0.01] Radius, utility::nullopt, 0.01, utility::nullopt, "CPU:0")
210 ENUM_FPFH_METHOD_DEVICE(
211  CPU[0.02] Radius, utility::nullopt, 0.02, utility::nullopt, "CPU:0")
212 
213 ENUM_FPFH_METHOD_DEVICE(CPU[0.02 | 50 | null] Hybrid Indices,
214  50,
215  0.02,
216  utility::nullopt,
217  "CPU:0")
218 ENUM_FPFH_METHOD_DEVICE(
219  CPU[0.02 | 50 | 0.0001] Hybrid Indices, 50, 0.02, 0.0001, "CPU:0")
220 ENUM_FPFH_METHOD_DEVICE(
221  CPU[0.02 | 50 | 0.001] Hybrid Indices, 50, 0.02, 0.001, "CPU:0")
222 ENUM_FPFH_METHOD_DEVICE(
223  CPU[0.02 | 50 | 0.01] Hybrid Indices, 50, 0.02, 0.01, "CPU:0")
224 ENUM_FPFH_METHOD_DEVICE(
225  CPU[0.02 | 50 | 0.1] Hybrid Indices, 50, 0.02, 0.1, "CPU:0")
226 ENUM_FPFH_METHOD_DEVICE(
227  CPU[0.02 | 50 | 1.0] Hybrid Indices, 50, 0.02, 1.0, "CPU:0")
228 
229 #ifdef BUILD_CUDA_MODULE
230 ENUM_FPFH_METHOD_DEVICE(
231  CUDA[0.01 | 100] Hybrid, 100, 0.01, utility::nullopt, "CUDA:0")
232 ENUM_FPFH_METHOD_DEVICE(
233  CUDA[0.02 | 50] Hybrid, 50, 0.02, utility::nullopt, "CUDA:0")
234 ENUM_FPFH_METHOD_DEVICE(
235  CUDA[0.02 | 100] Hybrid, 100, 0.02, utility::nullopt, "CUDA:0")
236 ENUM_FPFH_METHOD_DEVICE(
237  CUDA[50] KNN, 50, utility::nullopt, utility::nullopt, "CUDA:0")
238 ENUM_FPFH_METHOD_DEVICE(
239  CUDA[100] KNN, 100, utility::nullopt, utility::nullopt, "CUDA:0")
240 ENUM_FPFH_METHOD_DEVICE(
241  CUDA[0.01] Radius, utility::nullopt, 0.01, utility::nullopt, "CUDA:0")
242 ENUM_FPFH_METHOD_DEVICE(
243  CUDA[0.02] Radius, utility::nullopt, 0.02, utility::nullopt, "CUDA:0")
244 
245 ENUM_FPFH_METHOD_DEVICE(CUDA[0.02 | 50 | null] Hybrid Indices,
246  50,
247  0.02,
248  utility::nullopt,
249  "CUDA:0")
250 ENUM_FPFH_METHOD_DEVICE(
251  CUDA[0.02 | 50 | 0.0001] Hybrid Indices, 50, 0.02, 0.0001, "CUDA:0")
252 ENUM_FPFH_METHOD_DEVICE(
253  CUDA[0.02 | 50 | 0.001] Hybrid Indices, 50, 0.02, 0.001, "CUDA:0")
254 ENUM_FPFH_METHOD_DEVICE(
255  CUDA[0.02 | 50 | 0.01] Hybrid Indices, 50, 0.02, 0.01, "CUDA:0")
256 ENUM_FPFH_METHOD_DEVICE(
257  CUDA[0.02 | 50 | 0.1] Hybrid Indices, 50, 0.02, 0.1, "CUDA:0")
258 ENUM_FPFH_METHOD_DEVICE(
259  CUDA[0.02 | 50 | 1.0] Hybrid Indices, 50, 0.02, 1.0, "CUDA:0")
260 #endif
261 
262 } // namespace registration
263 } // namespace pipelines
264 } // namespace t
265 } // namespace cloudViewer
CUDAUtils.h
Common CUDA utilities.
ENUM_FPFH_METHOD_DEVICE
#define ENUM_FPFH_METHOD_DEVICE(METHOD_NAME, MAX_NN, RADIUS, INDICES, DEVICE)
Definition: Feature.cpp:188
cloudViewer::core::Tensor::GetLength
int64_t GetLength() const
Definition: Tensor.h:1125
cloudViewer::core::Tensor::To
Tensor To(Dtype dtype, bool copy=false) const
Definition: Tensor.cpp:739
cloudViewer::data::BunnyMesh
Data class for BunnyMesh contains the BunnyMesh.ply from the Stanford 3D Scanning Repository.
Definition: Dataset.h:234
cloudViewer::data::BunnyMesh::GetPath
std::string GetPath() const
Path to the BunnyMesh.ply file.
Definition: Dataset.h:239
cloudViewer::geometry::KDTreeSearchParamHybrid
KDTree search parameters for hybrid KNN and radius search.
Definition: ecvKDTreeSearchParam.h:79
cloudViewer::geometry::KDTreeSearchParamKNN
KDTree search parameters for pure KNN search.
Definition: ecvKDTreeSearchParam.h:46
cloudViewer::geometry::KDTreeSearchParamRadius
KDTree search parameters for pure radius search.
Definition: ecvKDTreeSearchParam.h:63
cloudViewer::t::geometry::PointCloud
A point cloud contains a list of 3D points.
Definition: PointCloud.h:82
cloudViewer::t::geometry::PointCloud::EstimateNormals
void EstimateNormals(const utility::optional< int > max_nn=30, const utility::optional< double > radius=utility::nullopt)
Function to estimate point normals. If the point cloud normals exist, the estimated normals are orien...
Definition: PointCloud.cpp:619
cloudViewer::t::geometry::PointCloud::SetPointPositions
void SetPointPositions(const core::Tensor &value)
Set the value of the "positions" attribute. Convenience function.
Definition: PointCloud.h:186
cloudViewer::t::geometry::PointCloud::GetPointPositions
core::Tensor & GetPointPositions()
Get the value of the "positions" attribute. Convenience function.
Definition: PointCloud.h:124
cloudViewer::t::geometry::PointCloud::To
PointCloud To(const core::Device &device, bool copy=false) const
Definition: PointCloud.cpp:112
cloudViewer::t::geometry::PointCloud::UniformDownSample
PointCloud UniformDownSample(size_t every_k_points) const
Downsamples a point cloud by selecting every kth index point and its attributes.
Definition: PointCloud.cpp:345
cloudViewer::utility::optional::emplace
void emplace(Args &&... args)
Definition: Optional.h:410
cloudViewer::utility::optional::has_value
constexpr bool has_value() const noexcept
Definition: Optional.h:440
cloudViewer::utility::optional::value
constexpr T const & value() const &
Definition: Optional.h:465
cloudViewer::core::Int64
const Dtype Int64
Definition: Dtype.cpp:47
cloudViewer::io::CreatePointCloudFromFile
std::shared_ptr< ccPointCloud > CreatePointCloudFromFile(const std::string &filename, const std::string &format, bool print_progress)
Definition: PointCloudIO.cpp:84
cloudViewer::t::io::ReadPointCloud
bool ReadPointCloud(const std::string &filename, geometry::PointCloud &pointcloud, const cloudViewer::io::ReadPointCloudOption &params)
Definition: PointCloudIO.cpp:72
cloudViewer::t::pipelines::registration::path
static const std::string path
Definition: Feature.cpp:25
cloudViewer::t::pipelines::registration::ComputeFPFHFeature
core::Tensor ComputeFPFHFeature(const geometry::PointCloud &input, const utility::optional< int > max_nn, const utility::optional< double > radius, const utility::optional< core::Tensor > &indices)
Definition: Feature.cpp:23
cloudViewer::t::pipelines::registration::LegacyComputeFPFHFeature
void LegacyComputeFPFHFeature(benchmark::State &state, utility::optional< int > max_nn, utility::optional< double > radius, utility::optional< double > ratio_indices)
Definition: Feature.cpp:27
cloudViewer::t::pipelines::registration::BENCHMARK_CAPTURE
BENCHMARK_CAPTURE(LegacyComputeFPFHFeature, Legacy Hybrid[0.01|100], 100, 0.01, utility::nullopt) -> Unit(benchmark::kMillisecond)
cloudViewer::utility::nullopt
constexpr nullopt_t nullopt
Definition: Optional.h:136
cloudViewer::utility::ComputeFPFHFeature
std::shared_ptr< Feature > ComputeFPFHFeature(const ccPointCloud &input, const geometry::KDTreeSearchParam &search_param=geometry::KDTreeSearchParamKNN(), const utility::optional< std::vector< size_t >> &indices=utility::nullopt)
cloudViewer
Generic file read and write utility for python interface.
Definition: AutoSegmentationTools.h:16