ACloudViewer  3.9.4
A Modern Library for 3D Data Processing
option_utils.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 "pipelines/option_utils.h"
9 
10 namespace cloudViewer {
11 
12 OptionsParser::OptionsParser() {
13  argc_ = 0;
14  argv_ = nullptr;
15  reset();
16 }
17 
18 bool OptionsParser::parseOptions(int& argc, char**& argv) {
19  // First, put all options without a section and then those with a
20  // section. This is necessary as otherwise older Boost versions will
21  // write the options without a section in between other sections and
22  // therefore the errors will be assigned to the wrong section if read
23  // later.
24 
25  ReleaseOptions(argc, argv);
26  unsigned long capacity = 2 * getParametersCount() + 1;
27  if (capacity == 0) {
28  return false;
29  }
30 
31  // add application name
32  argv = new char*[capacity];
33  SetValue("options", 0, argv);
34  argc = 1;
35 
36  // add other optinons
37  for (const auto& option : options_bool_) {
38  SetValue("--" + option.first, argc, argv);
39  argc += 1;
40  bool bool_flag = *option.second;
41  if (bool_flag)
42  SetValue("true", argc, argv);
43  else
44  SetValue("false", argc, argv);
45  argc += 1;
46  }
47 
48  for (const auto& option : options_int_) {
49  SetValue("--" + option.first, argc, argv);
50  argc += 1;
51  SetValue(std::to_string(*option.second), argc, argv);
52  argc += 1;
53  }
54 
55  for (const auto& option : options_double_) {
56  SetValue("--" + option.first, argc, argv);
57  argc += 1;
58  SetValue(std::to_string(*option.second), argc, argv);
59  argc += 1;
60  }
61 
62  for (const auto& option : options_string_) {
63  SetValue("--" + option.first, argc, argv);
64  argc += 1;
65  SetValue(*option.second, argc, argv);
66  argc += 1;
67  }
68 
69  if (argc == 0 || !argv) return false;
70 
71  return true;
72 }
73 
74 void OptionsParser::reset() {
75  releaseOptions();
76  options_bool_.clear();
77  options_int_.clear();
78  options_double_.clear();
79  options_string_.clear();
80 }
81 
82 void OptionsParser::addExtractionOptions(
83  const colmap::ImageReaderOptions& image_reader_options,
84  const colmap::SiftExtractionOptions& sift_extraction_options) {
85  registerOption("ImageReader.mask_path", &image_reader_options.mask_path);
86  registerOption("ImageReader.camera_model",
87  &image_reader_options.camera_model);
88  registerOption("ImageReader.single_camera",
89  &image_reader_options.single_camera);
90  registerOption("ImageReader.single_camera_per_folder",
91  &image_reader_options.single_camera_per_folder);
92  registerOption("ImageReader.single_camera_per_image",
93  &image_reader_options.single_camera_per_image);
94  registerOption("ImageReader.existing_camera_id",
95  &image_reader_options.existing_camera_id);
96  registerOption("ImageReader.camera_params",
97  &image_reader_options.camera_params);
98  registerOption("ImageReader.default_focal_length_factor",
99  &image_reader_options.default_focal_length_factor);
100  registerOption("ImageReader.camera_mask_path",
101  &image_reader_options.camera_mask_path);
102 
103  registerOption("SiftExtraction.num_threads",
104  &sift_extraction_options.num_threads);
105  registerOption("SiftExtraction.use_gpu", &sift_extraction_options.use_gpu);
106  registerOption("SiftExtraction.gpu_index",
107  &sift_extraction_options.gpu_index);
108  registerOption("SiftExtraction.max_image_size",
109  &sift_extraction_options.max_image_size);
110  registerOption("SiftExtraction.max_num_features",
111  &sift_extraction_options.max_num_features);
112  registerOption("SiftExtraction.first_octave",
113  &sift_extraction_options.first_octave);
114  registerOption("SiftExtraction.num_octaves",
115  &sift_extraction_options.num_octaves);
116  registerOption("SiftExtraction.octave_resolution",
117  &sift_extraction_options.octave_resolution);
118  registerOption("SiftExtraction.peak_threshold",
119  &sift_extraction_options.peak_threshold);
120  registerOption("SiftExtraction.edge_threshold",
121  &sift_extraction_options.edge_threshold);
122  registerOption("SiftExtraction.estimate_affine_shape",
123  &sift_extraction_options.estimate_affine_shape);
124  registerOption("SiftExtraction.max_num_orientations",
125  &sift_extraction_options.max_num_orientations);
126  registerOption("SiftExtraction.upright", &sift_extraction_options.upright);
127  registerOption("SiftExtraction.domain_size_pooling",
128  &sift_extraction_options.domain_size_pooling);
129  registerOption("SiftExtraction.dsp_min_scale",
130  &sift_extraction_options.dsp_min_scale);
131  registerOption("SiftExtraction.dsp_max_scale",
132  &sift_extraction_options.dsp_max_scale);
133  registerOption("SiftExtraction.dsp_num_scales",
134  &sift_extraction_options.dsp_num_scales);
135 }
136 
137 void OptionsParser::addMatchingOptions(
138  const colmap::SiftMatchingOptions& sift_matching_options) {
139  registerOption("SiftMatching.num_threads",
140  &sift_matching_options.num_threads);
141  registerOption("SiftMatching.use_gpu", &sift_matching_options.use_gpu);
142  registerOption("SiftMatching.gpu_index", &sift_matching_options.gpu_index);
143  registerOption("SiftMatching.max_ratio", &sift_matching_options.max_ratio);
144  registerOption("SiftMatching.max_distance",
145  &sift_matching_options.max_distance);
146  registerOption("SiftMatching.cross_check",
147  &sift_matching_options.cross_check);
148  registerOption("SiftMatching.max_error", &sift_matching_options.max_error);
149  registerOption("SiftMatching.max_num_matches",
150  &sift_matching_options.max_num_matches);
151  registerOption("SiftMatching.confidence",
152  &sift_matching_options.confidence);
153  registerOption("SiftMatching.max_num_trials",
154  &sift_matching_options.max_num_trials);
155  registerOption("SiftMatching.min_inlier_ratio",
156  &sift_matching_options.min_inlier_ratio);
157  registerOption("SiftMatching.min_num_inliers",
158  &sift_matching_options.min_num_inliers);
159  registerOption("SiftMatching.multiple_models",
160  &sift_matching_options.multiple_models);
161  registerOption("SiftMatching.guided_matching",
162  &sift_matching_options.guided_matching);
163 }
164 
165 void OptionsParser::addExhaustiveMatchingOptions(
166  const colmap::SiftMatchingOptions& sift_matching_options,
167  const colmap::ExhaustiveMatchingOptions& exhaustive_matching_options) {
168  addMatchingOptions(sift_matching_options);
169  registerOption("ExhaustiveMatching.block_size",
170  &exhaustive_matching_options.block_size);
171 }
172 
173 void OptionsParser::addSequentialMatchingOptions(
174  const colmap::SiftMatchingOptions& sift_matching_options,
175  const colmap::SequentialMatchingOptions& sequential_matching_options) {
176  addMatchingOptions(sift_matching_options);
177 
178  registerOption("SequentialMatching.overlap",
179  &sequential_matching_options.overlap);
180  registerOption("SequentialMatching.quadratic_overlap",
181  &sequential_matching_options.quadratic_overlap);
182  registerOption("SequentialMatching.loop_detection",
183  &sequential_matching_options.loop_detection);
184  registerOption("SequentialMatching.loop_detection_period",
185  &sequential_matching_options.loop_detection_period);
186  registerOption("SequentialMatching.loop_detection_num_images",
187  &sequential_matching_options.loop_detection_num_images);
188  registerOption(
189  "SequentialMatching.loop_detection_num_nearest_neighbors",
190  &sequential_matching_options.loop_detection_num_nearest_neighbors);
191  registerOption("SequentialMatching.loop_detection_num_checks",
192  &sequential_matching_options.loop_detection_num_checks);
193  registerOption(
194  "SequentialMatching.loop_detection_num_images_after_verification",
195  &sequential_matching_options
196  .loop_detection_num_images_after_verification);
197  registerOption(
198  "SequentialMatching.loop_detection_max_num_features",
199  &sequential_matching_options.loop_detection_max_num_features);
200  registerOption("SequentialMatching.vocab_tree_path",
201  &sequential_matching_options.vocab_tree_path);
202 }
203 
204 void OptionsParser::addVocabTreeMatchingOptions(
205  const colmap::SiftMatchingOptions& sift_matching_options,
206  const colmap::VocabTreeMatchingOptions& vocab_tree_matching_options) {
207  addMatchingOptions(sift_matching_options);
208 
209  registerOption("VocabTreeMatching.num_images",
210  &vocab_tree_matching_options.num_images);
211  registerOption("VocabTreeMatching.num_nearest_neighbors",
212  &vocab_tree_matching_options.num_nearest_neighbors);
213  registerOption("VocabTreeMatching.num_checks",
214  &vocab_tree_matching_options.num_checks);
215  registerOption("VocabTreeMatching.num_images_after_verification",
216  &vocab_tree_matching_options.num_images_after_verification);
217  registerOption("VocabTreeMatching.max_num_features",
218  &vocab_tree_matching_options.max_num_features);
219  registerOption("VocabTreeMatching.vocab_tree_path",
220  &vocab_tree_matching_options.vocab_tree_path);
221  registerOption("VocabTreeMatching.match_list_path",
222  &vocab_tree_matching_options.match_list_path);
223 }
224 
225 void OptionsParser::addSpatialMatchingOptions(
226  const colmap::SiftMatchingOptions& sift_matching_options,
227  const colmap::SpatialMatchingOptions& spatial_matching_options) {
228  addMatchingOptions(sift_matching_options);
229 
230  registerOption("SpatialMatching.is_gps", &spatial_matching_options.is_gps);
231  registerOption("SpatialMatching.ignore_z",
232  &spatial_matching_options.ignore_z);
233  registerOption("SpatialMatching.max_num_neighbors",
234  &spatial_matching_options.max_num_neighbors);
235  registerOption("SpatialMatching.max_distance",
236  &spatial_matching_options.max_distance);
237 }
238 
239 void OptionsParser::addTransitiveMatchingOptions(
240  const colmap::SiftMatchingOptions& sift_matching_options,
241  const colmap::TransitiveMatchingOptions& transitive_matching_options) {
242  addMatchingOptions(sift_matching_options);
243 
244  registerOption("TransitiveMatching.batch_size",
245  &transitive_matching_options.batch_size);
246  registerOption("TransitiveMatching.num_iterations",
247  &transitive_matching_options.num_iterations);
248 }
249 
250 void OptionsParser::addMapperOptions(
251  const colmap::IncrementalMapperOptions& incremental_mapper_options) {
252  registerOption("Mapper.min_num_matches",
253  &incremental_mapper_options.min_num_matches);
254  registerOption("Mapper.ignore_watermarks",
255  &incremental_mapper_options.ignore_watermarks);
256  registerOption("Mapper.multiple_models",
257  &incremental_mapper_options.multiple_models);
258  registerOption("Mapper.max_num_models",
259  &incremental_mapper_options.max_num_models);
260  registerOption("Mapper.max_model_overlap",
261  &incremental_mapper_options.max_model_overlap);
262  registerOption("Mapper.min_model_size",
263  &incremental_mapper_options.min_model_size);
264  registerOption("Mapper.init_image_id1",
265  &incremental_mapper_options.init_image_id1);
266  registerOption("Mapper.init_image_id2",
267  &incremental_mapper_options.init_image_id2);
268  registerOption("Mapper.init_num_trials",
269  &incremental_mapper_options.init_num_trials);
270  registerOption("Mapper.extract_colors",
271  &incremental_mapper_options.extract_colors);
272  registerOption("Mapper.num_threads",
273  &incremental_mapper_options.num_threads);
274  registerOption("Mapper.min_focal_length_ratio",
275  &incremental_mapper_options.min_focal_length_ratio);
276  registerOption("Mapper.max_focal_length_ratio",
277  &incremental_mapper_options.max_focal_length_ratio);
278  registerOption("Mapper.max_extra_param",
279  &incremental_mapper_options.max_extra_param);
280  registerOption("Mapper.ba_refine_focal_length",
281  &incremental_mapper_options.ba_refine_focal_length);
282  registerOption("Mapper.ba_refine_principal_point",
283  &incremental_mapper_options.ba_refine_principal_point);
284  registerOption("Mapper.ba_refine_extra_params",
285  &incremental_mapper_options.ba_refine_extra_params);
286  registerOption("Mapper.ba_min_num_residuals_for_cpu_multi_threading",
287  &incremental_mapper_options
288  .ba_min_num_residuals_for_cpu_multi_threading);
289  registerOption("Mapper.ba_local_num_images",
290  &incremental_mapper_options.ba_local_num_images);
291  registerOption("Mapper.ba_local_function_tolerance",
292  &incremental_mapper_options.ba_local_function_tolerance);
293  registerOption("Mapper.ba_local_max_num_iterations",
294  &incremental_mapper_options.ba_local_max_num_iterations);
295 #ifdef PBA_ENABLED
296  registerOption("Mapper.ba_global_use_pba",
297  &incremental_mapper_options.ba_global_use_pba);
298  registerOption("Mapper.ba_global_pba_gpu_index",
299  &incremental_mapper_options.ba_global_pba_gpu_index);
300 #endif
301  registerOption("Mapper.ba_global_images_ratio",
302  &incremental_mapper_options.ba_global_images_ratio);
303  registerOption("Mapper.ba_global_points_ratio",
304  &incremental_mapper_options.ba_global_points_ratio);
305  registerOption("Mapper.ba_global_images_freq",
306  &incremental_mapper_options.ba_global_images_freq);
307  registerOption("Mapper.ba_global_points_freq",
308  &incremental_mapper_options.ba_global_points_freq);
309  registerOption("Mapper.ba_global_function_tolerance",
310  &incremental_mapper_options.ba_global_function_tolerance);
311  registerOption("Mapper.ba_global_max_num_iterations",
312  &incremental_mapper_options.ba_global_max_num_iterations);
313  registerOption("Mapper.ba_global_max_refinements",
314  &incremental_mapper_options.ba_global_max_refinements);
315  registerOption("Mapper.ba_global_max_refinement_change",
316  &incremental_mapper_options.ba_global_max_refinement_change);
317  registerOption("Mapper.ba_local_max_refinements",
318  &incremental_mapper_options.ba_local_max_refinements);
319  registerOption("Mapper.ba_local_max_refinement_change",
320  &incremental_mapper_options.ba_local_max_refinement_change);
321  registerOption("Mapper.snapshot_path",
322  &incremental_mapper_options.snapshot_path);
323  registerOption("Mapper.snapshot_images_freq",
324  &incremental_mapper_options.snapshot_images_freq);
325  registerOption("Mapper.fix_existing_images",
326  &incremental_mapper_options.fix_existing_images);
327 
328  // IncrementalMapper.
329  registerOption("Mapper.init_min_num_inliers",
330  &incremental_mapper_options.mapper.init_min_num_inliers);
331  registerOption("Mapper.init_max_error",
332  &incremental_mapper_options.mapper.init_max_error);
333  registerOption("Mapper.init_max_forward_motion",
334  &incremental_mapper_options.mapper.init_max_forward_motion);
335  registerOption("Mapper.init_min_tri_angle",
336  &incremental_mapper_options.mapper.init_min_tri_angle);
337  registerOption("Mapper.init_max_reg_trials",
338  &incremental_mapper_options.mapper.init_max_reg_trials);
339  registerOption("Mapper.abs_pose_max_error",
340  &incremental_mapper_options.mapper.abs_pose_max_error);
341  registerOption("Mapper.abs_pose_min_num_inliers",
342  &incremental_mapper_options.mapper.abs_pose_min_num_inliers);
343  registerOption(
344  "Mapper.abs_pose_min_inlier_ratio",
345  &incremental_mapper_options.mapper.abs_pose_min_inlier_ratio);
346  registerOption("Mapper.filter_max_reproj_error",
347  &incremental_mapper_options.mapper.filter_max_reproj_error);
348  registerOption("Mapper.filter_min_tri_angle",
349  &incremental_mapper_options.mapper.filter_min_tri_angle);
350  registerOption("Mapper.max_reg_trials",
351  &incremental_mapper_options.mapper.max_reg_trials);
352  registerOption("Mapper.local_ba_min_tri_angle",
353  &incremental_mapper_options.mapper.local_ba_min_tri_angle);
354 
355  // IncrementalTriangulator.
356  registerOption("Mapper.tri_max_transitivity",
357  &incremental_mapper_options.triangulation.max_transitivity);
358  registerOption(
359  "Mapper.tri_create_max_angle_error",
360  &incremental_mapper_options.triangulation.create_max_angle_error);
361  registerOption(
362  "Mapper.tri_continue_max_angle_error",
363  &incremental_mapper_options.triangulation.continue_max_angle_error);
364  registerOption(
365  "Mapper.tri_merge_max_reproj_error",
366  &incremental_mapper_options.triangulation.merge_max_reproj_error);
367  registerOption("Mapper.tri_complete_max_reproj_error",
368  &incremental_mapper_options.triangulation
369  .complete_max_reproj_error);
370  registerOption("Mapper.tri_complete_max_transitivity",
371  &incremental_mapper_options.triangulation
372  .complete_max_transitivity);
373  registerOption(
374  "Mapper.tri_re_max_angle_error",
375  &incremental_mapper_options.triangulation.re_max_angle_error);
376  registerOption("Mapper.tri_re_min_ratio",
377  &incremental_mapper_options.triangulation.re_min_ratio);
378  registerOption("Mapper.tri_re_max_trials",
379  &incremental_mapper_options.triangulation.re_max_trials);
380  registerOption("Mapper.tri_min_angle",
381  &incremental_mapper_options.triangulation.min_angle);
382  registerOption(
383  "Mapper.tri_ignore_two_view_tracks",
384  &incremental_mapper_options.triangulation.ignore_two_view_tracks);
385 }
386 
387 void OptionsParser::addImagePairsMatchingOptions(
388  const colmap::SiftMatchingOptions& sift_matching_options,
389  const colmap::ImagePairsMatchingOptions& image_pairs_matching_options) {
390  addMatchingOptions(sift_matching_options);
391 
392  registerOption("ImagePairsMatching.block_size",
393  &image_pairs_matching_options.block_size);
394 }
395 
396 void OptionsParser::addBundleAdjustmentOptions(
397  const colmap::BundleAdjustmentOptions& bundle_adjustment_options) {
398  registerOption(
399  "BundleAdjustment.max_num_iterations",
400  &bundle_adjustment_options.solver_options.max_num_iterations);
401  registerOption("BundleAdjustment.max_linear_solver_iterations",
402  &bundle_adjustment_options.solver_options
403  .max_linear_solver_iterations);
404  registerOption(
405  "BundleAdjustment.function_tolerance",
406  &bundle_adjustment_options.solver_options.function_tolerance);
407 
408  registerOption(
409  "BundleAdjustment.gradient_tolerance",
410  &bundle_adjustment_options.solver_options.gradient_tolerance);
411  registerOption(
412  "BundleAdjustment.parameter_tolerance",
413  &bundle_adjustment_options.solver_options.parameter_tolerance);
414 
415  registerOption("BundleAdjustment.refine_focal_length",
416  &bundle_adjustment_options.refine_focal_length);
417  registerOption("BundleAdjustment.refine_principal_point",
418  &bundle_adjustment_options.refine_principal_point);
419  registerOption("BundleAdjustment.refine_extra_params",
420  &bundle_adjustment_options.refine_extra_params);
421  registerOption("BundleAdjustment.refine_extrinsics",
422  &bundle_adjustment_options.refine_extrinsics);
423 }
424 
425 void OptionsParser::addPatchMatchStereoOptions(
426  const colmap::mvs::PatchMatchOptions& patch_match_options) {
427  registerOption("PatchMatchStereo.max_image_size",
428  &patch_match_options.max_image_size);
429  registerOption("PatchMatchStereo.gpu_index",
430  &patch_match_options.gpu_index);
431  registerOption("PatchMatchStereo.depth_min",
432  &patch_match_options.depth_min);
433  registerOption("PatchMatchStereo.depth_max",
434  &patch_match_options.depth_max);
435  registerOption("PatchMatchStereo.window_radius",
436  &patch_match_options.window_radius);
437  registerOption("PatchMatchStereo.window_step",
438  &patch_match_options.window_step);
439  registerOption("PatchMatchStereo.sigma_spatial",
440  &patch_match_options.sigma_spatial);
441 
442  registerOption("PatchMatchStereo.sigma_color",
443  &patch_match_options.sigma_color);
444  registerOption("PatchMatchStereo.num_samples",
445  &patch_match_options.num_samples);
446  registerOption("PatchMatchStereo.ncc_sigma",
447  &patch_match_options.ncc_sigma);
448  registerOption("PatchMatchStereo.min_triangulation_angle",
449  &patch_match_options.min_triangulation_angle);
450  registerOption("PatchMatchStereo.incident_angle_sigma",
451  &patch_match_options.incident_angle_sigma);
452  registerOption("PatchMatchStereo.num_iterations",
453  &patch_match_options.num_iterations);
454  registerOption("PatchMatchStereo.geom_consistency",
455  &patch_match_options.geom_consistency);
456 
457  registerOption("PatchMatchStereo.geom_consistency_regularizer",
458  &patch_match_options.geom_consistency_regularizer);
459  registerOption("PatchMatchStereo.geom_consistency_max_cost",
460  &patch_match_options.geom_consistency_max_cost);
461  registerOption("PatchMatchStereo.filter", &patch_match_options.filter);
462  registerOption("PatchMatchStereo.filter_min_ncc",
463  &patch_match_options.filter_min_ncc);
464  registerOption("PatchMatchStereo.filter_min_triangulation_angle",
465  &patch_match_options.filter_min_triangulation_angle);
466  registerOption("PatchMatchStereo.filter_min_num_consistent",
467  &patch_match_options.filter_min_num_consistent);
468  registerOption("PatchMatchStereo.filter_geom_consistency_max_cost",
469  &patch_match_options.filter_geom_consistency_max_cost);
470  registerOption("PatchMatchStereo.cache_size",
471  &patch_match_options.cache_size);
472  registerOption("PatchMatchStereo.allow_missing_files",
473  &patch_match_options.allow_missing_files);
474  registerOption("PatchMatchStereo.write_consistency_graph",
475  &patch_match_options.write_consistency_graph);
476 }
477 
478 void OptionsParser::addStereoFusionOptions(
479  const colmap::mvs::StereoFusionOptions& stereo_fusion_options) {
480  registerOption("StereoFusion.mask_path", &stereo_fusion_options.mask_path);
481  registerOption("StereoFusion.num_threads",
482  &stereo_fusion_options.num_threads);
483  registerOption("StereoFusion.max_image_size",
484  &stereo_fusion_options.max_image_size);
485  registerOption("StereoFusion.min_num_pixels",
486  &stereo_fusion_options.min_num_pixels);
487  registerOption("StereoFusion.max_num_pixels",
488  &stereo_fusion_options.max_num_pixels);
489  registerOption("StereoFusion.max_traversal_depth",
490  &stereo_fusion_options.max_traversal_depth);
491  registerOption("StereoFusion.max_reproj_error",
492  &stereo_fusion_options.max_reproj_error);
493  registerOption("StereoFusion.max_depth_error",
494  &stereo_fusion_options.max_depth_error);
495  registerOption("StereoFusion.max_normal_error",
496  &stereo_fusion_options.max_normal_error);
497  registerOption("StereoFusion.check_num_images",
498  &stereo_fusion_options.check_num_images);
499  registerOption("StereoFusion.cache_size",
500  &stereo_fusion_options.cache_size);
501  registerOption("StereoFusion.use_cache", &stereo_fusion_options.use_cache);
502 }
503 
504 void OptionsParser::addPoissonMeshingOptions(
505  const colmap::mvs::PoissonMeshingOptions& poisson_meshing_options) {
506  registerOption("PoissonMeshing.point_weight",
507  &poisson_meshing_options.point_weight);
508  registerOption("PoissonMeshing.depth", &poisson_meshing_options.depth);
509  registerOption("PoissonMeshing.color", &poisson_meshing_options.color);
510  registerOption("PoissonMeshing.trim", &poisson_meshing_options.trim);
511  registerOption("PoissonMeshing.num_threads",
512  &poisson_meshing_options.num_threads);
513 }
514 
515 void OptionsParser::addDelaunayMeshingOptions(
516  const colmap::mvs::DelaunayMeshingOptions& delaunay_meshing_options) {
517  registerOption("DelaunayMeshing.max_proj_dist",
518  &delaunay_meshing_options.max_proj_dist);
519  registerOption("DelaunayMeshing.max_depth_dist",
520  &delaunay_meshing_options.max_depth_dist);
521  registerOption("DelaunayMeshing.visibility_sigma",
522  &delaunay_meshing_options.visibility_sigma);
523  registerOption("DelaunayMeshing.distance_sigma_factor",
524  &delaunay_meshing_options.distance_sigma_factor);
525  registerOption("DelaunayMeshing.quality_regularization",
526  &delaunay_meshing_options.quality_regularization);
527  registerOption("DelaunayMeshing.max_side_length_factor",
528  &delaunay_meshing_options.max_side_length_factor);
529  registerOption("DelaunayMeshing.max_side_length_percentile",
530  &delaunay_meshing_options.max_side_length_percentile);
531  registerOption("DelaunayMeshing.num_threads",
532  &delaunay_meshing_options.num_threads);
533 }
534 
535 } // namespace cloudViewer
cloudViewer::OptionsParser::addDelaunayMeshingOptions
void addDelaunayMeshingOptions(const colmap::mvs::DelaunayMeshingOptions &delaunay_meshing_options)
Definition: option_utils.cpp:515
cloudViewer::OptionsParser::ReleaseOptions
static void ReleaseOptions(int argc, char **argv)
Definition: option_utils.h:117
cloudViewer::OptionsParser::addBundleAdjustmentOptions
void addBundleAdjustmentOptions(const colmap::BundleAdjustmentOptions &bundle_adjustment_options)
Definition: option_utils.cpp:396
cloudViewer::OptionsParser::addExtractionOptions
void addExtractionOptions(const colmap::ImageReaderOptions &image_reader_options, const colmap::SiftExtractionOptions &sift_extraction_options)
Definition: option_utils.cpp:82
cloudViewer::OptionsParser::addStereoFusionOptions
void addStereoFusionOptions(const colmap::mvs::StereoFusionOptions &stereo_fusion_options)
Definition: option_utils.cpp:478
cloudViewer::OptionsParser::addSequentialMatchingOptions
void addSequentialMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options, const colmap::SequentialMatchingOptions &sequential_matching_options)
Definition: option_utils.cpp:173
cloudViewer::OptionsParser::addMapperOptions
void addMapperOptions(const colmap::IncrementalMapperOptions &incremental_mapper_options)
Definition: option_utils.cpp:250
cloudViewer::OptionsParser::addImagePairsMatchingOptions
void addImagePairsMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options, const colmap::ImagePairsMatchingOptions &image_pairs_matching_options)
Definition: option_utils.cpp:387
cloudViewer::OptionsParser::addExhaustiveMatchingOptions
void addExhaustiveMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options, const colmap::ExhaustiveMatchingOptions &exhaustive_matching_options)
Definition: option_utils.cpp:165
cloudViewer::OptionsParser::addPoissonMeshingOptions
void addPoissonMeshingOptions(const colmap::mvs::PoissonMeshingOptions &poisson_meshing_options)
Definition: option_utils.cpp:504
cloudViewer::OptionsParser::registerOption
void registerOption(const std::string &name, const T *option)
Definition: option_utils.h:43
cloudViewer::OptionsParser::addVocabTreeMatchingOptions
void addVocabTreeMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options, const colmap::VocabTreeMatchingOptions &vocab_tree_matching_options)
Definition: option_utils.cpp:204
cloudViewer::OptionsParser::addSpatialMatchingOptions
void addSpatialMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options, const colmap::SpatialMatchingOptions &spatial_matching_options)
Definition: option_utils.cpp:225
cloudViewer::OptionsParser::addTransitiveMatchingOptions
void addTransitiveMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options, const colmap::TransitiveMatchingOptions &transitive_matching_options)
Definition: option_utils.cpp:239
cloudViewer::OptionsParser::SetValue
static void SetValue(const std::string &value, int argc_, char **argv_)
Definition: option_utils.h:128
cloudViewer::OptionsParser::addMatchingOptions
void addMatchingOptions(const colmap::SiftMatchingOptions &sift_matching_options)
Definition: option_utils.cpp:137
cloudViewer::OptionsParser::addPatchMatchStereoOptions
void addPatchMatchStereoOptions(const colmap::mvs::PatchMatchOptions &patch_match_options)
Definition: option_utils.cpp:425
cloudViewer
Generic file read and write utility for python interface.
Definition: CloudViewerConfig.cpp:12
patch::to_string
std::string to_string(const T &n)
Definition: Common.h:20
option_utils.h
colmap::BundleAdjustmentOptions::solver_options
ceres::Solver::Options solver_options
Definition: bundle_adjustment.h:140
colmap::IncrementalMapperOptions::triangulation
IncrementalTriangulator::Options triangulation
Definition: incremental_mapper.h:120
colmap::IncrementalMapperOptions::mapper
IncrementalMapper::Options mapper
Definition: incremental_mapper.h:119
colmap::SiftExtractionOptions::gpu_index
std::string gpu_index
Definition: sift.h:32
colmap::SiftMatchingOptions::gpu_index
std::string gpu_index
Definition: sift.h:109