ADD: relative parameters, and tuned default values

Author: DamienGilliard

src/diffCheck/registrations/DFGlobalRegistrations.cc

@@ -11,7 +11,10 @@ namespace diffCheck::registrations
         for(int i = 0; i < transforms.size(); i++)
         {
             std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloud = source->Cvt2O3DPointCloud();
-            std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloudAfterTrans = std::make_shared<open3d::geometry::PointCloud>(o3DPointCloud->Transform(transforms[i]));
+
+            std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloudAfterTrans = 
+            std::make_shared<open3d::geometry::PointCloud>(o3DPointCloud->Transform(transforms[i]));
+
             std::shared_ptr<geometry::DFPointCloud> dfPointCloudPtrAfterTrans = std::make_shared<geometry::DFPointCloud>();
             dfPointCloudPtrAfterTrans->Cvt2DFPointCloud(o3DPointCloudAfterTrans);
             std::vector<double> registrationErrors = dfPointCloudPtrAfterTrans->ComputeP2PDistance(target);
@@ -34,9 +37,12 @@ namespace diffCheck::registrations
         std::shared_ptr<open3d::geometry::PointCloud> sourceO3D = source->Cvt2O3DPointCloud();
         std::shared_ptr<open3d::geometry::PointCloud> targetO3D = target->Cvt2O3DPointCloud();
 
+        // voxelize at the scale of the point cloud
         if (voxelise)
         {
-            double absoluteVoxelSize = voxelSize * sourceO3D->GetMaxBound().norm();
+            double absoluteVoxelSize = 
+            voxelSize * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+
             sourceO3D->VoxelDownSample(absoluteVoxelSize);
             targetO3D->VoxelDownSample(absoluteVoxelSize);
         }
@@ -51,24 +57,36 @@ namespace diffCheck::registrations
             targetO3D->EstimateNormals();
         }
 
-        double absoluteRadiusKDTreeSearch = radiusKDTreeSearch * sourceO3D->GetMaxBound().norm();
-        std::shared_ptr<open3d::pipelines::registration::Feature> sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D,
-                                                                                                                                           open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
-        std::shared_ptr<open3d::pipelines::registration::Feature> targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D,
-                                                                                                                                           open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
-        std::shared_ptr<open3d::pipelines::registration::FastGlobalRegistrationOption> option = std::make_shared<open3d::pipelines::registration::FastGlobalRegistrationOption>();
+        double absoluteRadiusKDTreeSearch = 
+        radiusKDTreeSearch * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+
+        std::shared_ptr<open3d::pipelines::registration::Feature> sourceFPFHFeatures = 
+        open3d::pipelines::registration::ComputeFPFHFeature(
+            *sourceO3D,
+            open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
+
+        std::shared_ptr<open3d::pipelines::registration::Feature> targetFPFHFeatures =
+        open3d::pipelines::registration::ComputeFPFHFeature(
+            *targetO3D,
+            open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
+
+        std::shared_ptr<open3d::pipelines::registration::FastGlobalRegistrationOption> option = 
+        std::make_shared<open3d::pipelines::registration::FastGlobalRegistrationOption>();
+
         option->maximum_correspondence_distance_ = maxCorrespondenceDistance;
         option->iteration_number_ = iterationNumber;
         option->maximum_tuple_count_ = maxTupleCount;
 
-        open3d::pipelines::registration::RegistrationResult result = open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(
+        
+        open3d::pipelines::registration::RegistrationResult result = 
+        open3d::pipelines::registration::FastGlobalRegistrationBasedOnFeatureMatching(
             *sourceO3D,
             *targetO3D,
             *sourceFPFHFeatures,
             *targetFPFHFeatures,
             *option);
         diffCheck::transformation::DFTransformation transformation = 
-            diffCheck::transformation::DFTransformation(result.transformation_);
+        diffCheck::transformation::DFTransformation(result.transformation_);
 
         return transformation;
     }
@@ -94,9 +112,12 @@ namespace diffCheck::registrations
         open3d::pipelines::registration::TransformationEstimationPointToPoint transformationEstimation = 
             open3d::pipelines::registration::TransformationEstimationPointToPoint(isTEstimatePt2Pt);
 
+        // voxelize at the scale of the point cloud
         if (voxelise)
         {
-            double absoluteVoxelSize = voxelSize * (sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+            double absoluteVoxelSize = 
+            voxelSize * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+
             sourceO3D->VoxelDownSample(absoluteVoxelSize);
             targetO3D->VoxelDownSample(absoluteVoxelSize);
         }
@@ -111,22 +132,43 @@ namespace diffCheck::registrations
             targetO3D->EstimateNormals();
         }
 
-        double absoluteRadiusKDTreeSearch = radiusKDTreeSearch * sourceO3D->GetMaxBound().norm();
-        std::shared_ptr<open3d::pipelines::registration::Feature> sourceFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*sourceO3D,
-                                                                                                                                           open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
-        std::shared_ptr<open3d::pipelines::registration::Feature> targetFPFHFeatures = open3d::pipelines::registration::ComputeFPFHFeature(*targetO3D,
-                                                                                                                                           open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
+        // convert the relative values to absolute ones
+        double absoluteRadiusKDTreeSearch = 
+        radiusKDTreeSearch * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+
+        double absoluteCorrespodenceCheckerDistance = 
+        correspondenceCheckerDistance * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+
+        double absoluteMaxCorrespondenceDistance =
+        maxCorrespondenceDistance * std::abs(sourceO3D->GetMaxBound().norm() - sourceO3D->GetMinBound().norm());
+
+        std::shared_ptr<open3d::pipelines::registration::Feature> sourceFPFHFeatures = 
+        open3d::pipelines::registration::ComputeFPFHFeature(
+            *sourceO3D,
+            open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
+
+        std::shared_ptr<open3d::pipelines::registration::Feature> targetFPFHFeatures = 
+        open3d::pipelines::registration::ComputeFPFHFeature(
+            *targetO3D,
+            open3d::geometry::KDTreeSearchParamHybrid(absoluteRadiusKDTreeSearch, maxNeighborKDTreeSearch));
+
         std::vector<std::reference_wrapper<const open3d::pipelines::registration::CorrespondenceChecker>> correspondanceChecker;
-        open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(correspondenceCheckerDistance);
-        open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength checkerOnEdgeLength = open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength(similarityThreshold);
+        
+        open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance checkerOnDistance = 
+        open3d::pipelines::registration::CorrespondenceCheckerBasedOnDistance(absoluteCorrespodenceCheckerDistance);
+
+        open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength checkerOnEdgeLength = 
+        open3d::pipelines::registration::CorrespondenceCheckerBasedOnEdgeLength(similarityThreshold);
         correspondanceChecker.push_back(checkerOnDistance);
 
-        auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(*sourceO3D,
+        
+        auto result = open3d::pipelines::registration::RegistrationRANSACBasedOnFeatureMatching(
+            *sourceO3D,
             *targetO3D,
             *sourceFPFHFeatures,
             *targetFPFHFeatures,
             true,
-            maxCorrespondenceDistance,
+            absoluteMaxCorrespondenceDistance,
             transformationEstimation,
             ransacN,
             correspondanceChecker,

src/diffCheck/registrations/DFGlobalRegistrations.hh

@@ -20,8 +20,8 @@ namespace diffCheck::registrations
         * 
         * @param source the source diffCheck point cloud
         * @param target the target diffCheck point cloud
-        * @param voxelSize the size of the voxels used to downsample the point clouds. A higher value will result in a more coarse point cloud (less resulting points).
-        * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise.
+        * @param voxelSize the size of the voxels used to downsample the point clouds. It is expressed relative to the point cloud size (0.01 means voxelSize = 1% of maxSize(pointCloud). A higher value will result in a more coarse point cloud (less resulting points).
+        * @param radiusKDTreeSearch  the radius used to search for neighbors in the KDTree.it is expressed relative to the point cloud size (0.01 means radiusKDTreeSearch = 1% of maxSize(pointCloud). It is used for the calculation of FPFHFeatures
         * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures. A higher value will result in heavier computation but potentially more precise.
         * @param maxCorrespondenceDistance the maximum distance between correspondences. A higher value will result in more correspondences, but potentially include wrong ones.
         * @param iterationNumber the number of iterations to run the RanSaC registration algorithm. A higher value will take more time to compute but increases the chances of finding a good transformation. As parameter of the FastGlobalRegistrationOption options 
@@ -37,11 +37,11 @@ namespace diffCheck::registrations
             std::shared_ptr<geometry::DFPointCloud> source, 
             std::shared_ptr<geometry::DFPointCloud> target,
             bool voxelize = true,
-            double voxelSize = 0.01,
-            double radiusKDTreeSearch = 0.05,
-            int maxNeighborKDTreeSearch = 20,
-            double maxCorrespondenceDistance = 10,
-            int iterationNumber = 64,
+            double voxelSize = 0.005,
+            double radiusKDTreeSearch = 0.1,
+            int maxNeighborKDTreeSearch = 50,
+            double maxCorrespondenceDistance = 0.05,
+            int iterationNumber = 128,
             int maxTupleCount = 1000);
         /**
         * @brief Ransac registration based on Feature Matching using (Fast) Point Feature Histograms (FPFH) on the source and target point clouds
@@ -54,10 +54,10 @@ namespace diffCheck::registrations
         * @param voxelSize the size of the voxels used to downsample the point clouds. It is expressed relative to the point cloud size (0.01 means voxelSize = 1% of maxSize(pointCloud). A higher value will result in a more coarse point cloud (less resulting points).
         * @param radiusKDTreeSearch the radius used to search for neighbors in the KDTree.it is expressed relative to the point cloud size (0.01 means radiusKDTreeSearch = 1% of maxSize(pointCloud). It is used for the calculation of FPFHFeatures
         * @param maxNeighborKDTreeSearch the maximum number of neighbors to search for in the KDTree. It is used for the calculation of FPFHFeatures
-        * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones.
+        * @param maxCorrespondenceDistance the maximum distance between correspondences in the FPFH space. A higher value will result in more correspondences, but potentially include wrong ones. It is exprimed in relative values (it is scaled by the size of the bounding box of the poinnt cloud).
         * @param isTEstimatePt2Pt the transformation estimation method to use. By default, it uses a point to point transformation estimation. If true it will scale and deform the cloud.
         * @param ransacN the number of points to sample in the source point cloud. A higher value can result in a more precise transformation, but will take more time to compute.
-        * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model.
+        * @param correspondenceCheckersDistance the maximum distance between correspondances in the FPFH space before testing a RanSaC model. It is exprimed in relative values (it is scaled by the size of the bounding box of the poinnt cloud).
         * @param similarityThreshold the threshold for the ransac check based on edge length to consider a model as inlier. A higher value will be stricter, discarding more ransac models. 
         * @param ransacMaxIteration the maximum number of iterations to run the Ransac algorithm. A higher value will take more time to compute but increases the chances of finding a good transformation.
         * @param ransacConfidenceThreshold the threshold for the convergence criteria of the ransac models. A higher value will be stricter, discarding more ransac models.
@@ -69,14 +69,14 @@ namespace diffCheck::registrations
             std::shared_ptr<geometry::DFPointCloud> source,
             std::shared_ptr<geometry::DFPointCloud> target,
             bool voxelize = true,
-            double voxelSize = 0.01,
-            double radiusKDTreeSearch = 0.05,
+            double voxelSize = 0.005,
+            double radiusKDTreeSearch = 0.1,
             int maxNeighborKDTreeSearch  = 50,
             double maxCorrespondenceDistance = 0.05,
             bool isTEstimatePt2Pt = false,
             int ransacN = 3,
             double correspondenceCheckerDistance = 0.05,
-            double similarityThreshold = 0.95,
+            double similarityThreshold = 0.9,
             int ransacMaxIteration = 100000,
             double ransacConfidenceThreshold = 0.999);