WIP: GlobalRegistration methods now static

Author: DamienGilliard

…c/diffCheck/registration/registration.cc …Check/registration/globalregistration.ccsrc/diffCheck/registration/registration.cc renamed to src/diffCheck/registration/globalregistration.cc src/diffCheck/registration/registration.cc renamed to src/diffCheck/registration/globalregistration.cc

@@ -1,8 +1,8 @@
-#include "registration.hh"
+#include "globalregistration.hh"
 
 namespace diffCheck::registration
 {
-    std::vector<double> Registration::ComputeP2PDistance(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
+    std::vector<double> GlobalRegistration::ComputeP2PDistance(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
     {
         std::vector<double> errors;
         auto O3DSourcePointCloud = source->Cvt2O3DPointCloud();
@@ -13,7 +13,7 @@ namespace diffCheck::registration
         distances = O3DSourcePointCloud->ComputePointCloudDistance(*O3DTargetPointCloud);
         return distances;
     }
-    open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
+    open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
         {
         std::shared_ptr<open3d::geometry::PointCloud> sourceO3D = source->Cvt2O3DPointCloud();
         std::shared_ptr<open3d::geometry::PointCloud> targetO3D = target->Cvt2O3DPointCloud();
@@ -39,7 +39,7 @@ namespace diffCheck::registration
         return result;
     }
 
-    open3d::pipelines::registration::RegistrationResult Registration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
+    open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
     {
         std::shared_ptr<open3d::geometry::PointCloud> sourceO3D = source->Cvt2O3DPointCloud();
         std::shared_ptr<open3d::geometry::PointCloud> targetO3D = target->Cvt2O3DPointCloud();
@@ -68,7 +68,7 @@ namespace diffCheck::registration
         return result;
     }
 
-    open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
+    open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
     {
         std::shared_ptr<open3d::geometry::PointCloud> sourceO3D = source->Cvt2O3DPointCloud();
         std::shared_ptr<open3d::geometry::PointCloud> targetO3D = target->Cvt2O3DPointCloud();
@@ -94,7 +94,7 @@ namespace diffCheck::registration
         return result;
     }
 
-    open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
+    open3d::pipelines::registration::RegistrationResult GlobalRegistration::O3DRansacOnFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target)
     {
         std::shared_ptr<open3d::geometry::PointCloud> sourceO3D = source->Cvt2O3DPointCloud();
         std::shared_ptr<open3d::geometry::PointCloud> targetO3D = target->Cvt2O3DPointCloud();

…c/diffCheck/registration/registration.hh …Check/registration/globalregistration.hhsrc/diffCheck/registration/registration.hh renamed to src/diffCheck/registration/globalregistration.hh src/diffCheck/registration/registration.hh renamed to src/diffCheck/registration/globalregistration.hh

@@ -3,13 +3,14 @@
 #include "diffCheck.hh"
 #include <open3d/pipelines/registration/Registration.h>
 
-namespace diffCheck::registration{
+namespace diffCheck::registration
+{
 
-class Registration
+class GlobalRegistration //Must convert to static class
 {
     public:
 
-    std::vector<double> ComputeP2PDistance(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
+    static std::vector<double> ComputeP2PDistance(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
 
     /*
     Documentation on Fast Point Feature Historigrams: https://pcl.readthedocs.io/projects/tutorials/en/latest/fpfh_estimation.html
@@ -25,14 +26,14 @@ class Registration
 
     Quite important for us: the resultant hyperspace is dependent on the quality of the surface normal estimations at each point (if pc noisy, historigram different).
     */
-    open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
+    static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
 
     /*
     Very little information on this registration method compared to the previous one.
     If I understand correctly, this method finds keypoints in the FPFH hyperspaces of the source and target point clouds and then tries to match them.
     https://pcl.readthedocs.io/projects/tutorials/en/latest/correspondence_grouping.html 
     */ 
-    open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
+    static open3d::pipelines::registration::RegistrationResult O3DFastGlobalRegistrationBasedOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
     /*
     Ransac registration based on correspondence:
     Correspondances are computed between the source and target point clouds.
@@ -42,15 +43,12 @@ class Registration
     In practice, Open3D gives little information about the feature correspondence
 
     */
-    open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
+    static open3d::pipelines::registration::RegistrationResult O3DRansacOnCorrespondence(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
     /*
     Ransac registration based on Feature Matching
     https://www.open3d.org/docs/release/tutorial/pipelines/global_registration.html#RANSAC
     */
-    open3d::pipelines::registration::RegistrationResult Registration::O3DRansacOnFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
-
-    
+    static open3d::pipelines::registration::RegistrationResult O3DRansacOnFeatureMatching(std::shared_ptr<geometry::DFPointCloud> source, std::shared_ptr<geometry::DFPointCloud> target);
 
-    
 };
 }

src/diffCheckApp.cc

@@ -31,7 +31,7 @@ int main()
   // add noise to dfPointCloudPtr
   for (int i = 0; i < dfPointCloudPtr->Points.size(); i++)
   {
-    dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01;
+    dfPointCloudPtr->Points[i] += Eigen::Vector3d::Random() * 0.01 ;
   }
 
   std::vector<double> timesFGRFeatureMatching;
@@ -76,55 +76,52 @@ int iterations = 50;
   dfPointCloudPtrAfterTrans_3->Cvt2DFPointCloud(o3DPointCloudAfterTrans);
   dfPointCloudPtrAfterTrans_4->Cvt2DFPointCloud(o3DPointCloudAfterTrans);
 
-
-  std::shared_ptr<diffCheck::registration::Registration> reg = std::make_shared<diffCheck::registration::Registration>();
-
   // Testing the Fast Global Registration on Feature Matching method
   std::shared_ptr<diffCheck::geometry::DFPointCloud> dfPointCloudPtrAfterReg_1 = std::make_shared<diffCheck::geometry::DFPointCloud>();
   clock_t start_1 = clock();
-  auto result_1 = reg->O3DFastGlobalRegistrationFeatureMatching(dfPointCloudPtrAfterTrans_1, dfPointCloudPtr);
+  auto result_1 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_1, dfPointCloudPtr);
   double _intermediate_time_1 = (clock() - start_1) / (double) CLOCKS_PER_SEC;
   timesFGRFeatureMatching.push_back(_intermediate_time_1);
   Eigen::Matrix<double, 4, 4> transformation = result_1.transformation_;
   std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloudPtrAfterReg_1 = std::make_shared<open3d::geometry::PointCloud>(dfPointCloudPtrAfterTrans_1->Cvt2O3DPointCloud()->Transform(transformation));
   dfPointCloudPtrAfterReg_1->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_1);
-  std::vector<double> errors_1 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_1, dfPointCloudPtrGroundTruth);
+  std::vector<double> errors_1 =  diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_1, dfPointCloudPtrGroundTruth);
   errorsFGRFeatureMatching.push_back(std::accumulate(errors_1.begin(), errors_1.end(), 0.0) / errors_1.size());
 
   // Testing the Fast Global Registration on Correspondance method
   std::shared_ptr<diffCheck::geometry::DFPointCloud> dfPointCloudPtrAfterReg_2 = std::make_shared<diffCheck::geometry::DFPointCloud>();
   clock_t start_2 = clock();
-  auto result_2 = reg->O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_2, dfPointCloudPtr);
+  auto result_2 = diffCheck::registration::GlobalRegistration::O3DFastGlobalRegistrationBasedOnCorrespondence(dfPointCloudPtrAfterTrans_2, dfPointCloudPtr);
   double _intermediate_time_2 = (clock() - start_2) / (double) CLOCKS_PER_SEC;
   timesFGRCorrespondance.push_back(_intermediate_time_2);
   Eigen::Matrix<double, 4, 4> transformation_2 = result_2.transformation_;
   std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloudPtrAfterReg_2 = std::make_shared<open3d::geometry::PointCloud>(dfPointCloudPtrAfterTrans_2->Cvt2O3DPointCloud()->Transform(transformation_2));
   dfPointCloudPtrAfterReg_2->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_2);
-  std::vector<double> errors_2 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_2, dfPointCloudPtrGroundTruth);
+  std::vector<double> errors_2 =  diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_2, dfPointCloudPtrGroundTruth);
   errorsFGRCorrespondance.push_back(std::accumulate(errors_2.begin(), errors_2.end(), 0.0) / errors_2.size());
 
   // Testing the Ransac registration based on correspondance method
   std::shared_ptr<diffCheck::geometry::DFPointCloud> dfPointCloudPtrAfterReg_3 = std::make_shared<diffCheck::geometry::DFPointCloud>();
   clock_t start_3 = clock();
-  auto result_3 = reg->O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans_3, dfPointCloudPtr);
+  auto result_3 = diffCheck::registration::GlobalRegistration::O3DRansacOnCorrespondence(dfPointCloudPtrAfterTrans_3, dfPointCloudPtr);
   double _intermediate_time_3 = (clock() - start_3) / (double) CLOCKS_PER_SEC;
   timesRansacCorrespondance.push_back(_intermediate_time_3);
   Eigen::Matrix<double, 4, 4> transformation_3 = result_3.transformation_;
   std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloudPtrAfterReg_3 = std::make_shared<open3d::geometry::PointCloud>(dfPointCloudPtrAfterTrans_3->Cvt2O3DPointCloud()->Transform(transformation_3));
   dfPointCloudPtrAfterReg_3->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_3);
-  std::vector<double> errors_3 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_3, dfPointCloudPtrGroundTruth);
+  std::vector<double> errors_3 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_3, dfPointCloudPtrGroundTruth);
   errorsRansacCorrespondance.push_back(std::accumulate(errors_3.begin(), errors_3.end(), 0.0) / errors_3.size());
 
   // Testing the Ransac registration based on Feature Matching method
   std::shared_ptr<diffCheck::geometry::DFPointCloud> dfPointCloudPtrAfterReg_4 = std::make_shared<diffCheck::geometry::DFPointCloud>();
   clock_t start_4 = clock();
-  auto result_4 = reg->O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans_4, dfPointCloudPtr);
+  auto result_4 = diffCheck::registration::GlobalRegistration::O3DRansacOnFeatureMatching(dfPointCloudPtrAfterTrans_4, dfPointCloudPtr);
   double _intermediate_time_4 = (clock() - start_4) / (double) CLOCKS_PER_SEC;
   timesRansacFeatureMatching.push_back(_intermediate_time_4);
   Eigen::Matrix<double, 4, 4> transformation_4 = result_4.transformation_;
   std::shared_ptr<open3d::geometry::PointCloud> o3DPointCloudPtrAfterReg_4 = std::make_shared<open3d::geometry::PointCloud>(dfPointCloudPtrAfterTrans_4->Cvt2O3DPointCloud()->Transform(transformation_4));
   dfPointCloudPtrAfterReg_4->Cvt2DFPointCloud(o3DPointCloudPtrAfterReg_4);
-  std::vector<double> errors_4 = reg->ComputeP2PDistance(dfPointCloudPtrAfterReg_4, dfPointCloudPtrGroundTruth);
+  std::vector<double> errors_4 = diffCheck::registration::GlobalRegistration::ComputeP2PDistance(dfPointCloudPtrAfterReg_4, dfPointCloudPtrGroundTruth);
   errorsRansacFeatureMatching.push_back(std::accumulate(errors_4.begin(), errors_4.end(), 0.0) / errors_4.size());
 
   std::cout<<"Iteration: "<<i<<" "<<std::flush;
@@ -166,11 +163,7 @@ int iterations = 50;
     fileErrors<<errorsFGRFeatureMatching[i]<<","<<errorsFGRCorrespondance[i]<<","<<errorsRansacCorrespondance[i]<<","<<errorsRansacFeatureMatching[i]<<std::endl;
     fileTimes<<timesFGRFeatureMatching[i]<<","<<timesFGRCorrespondance[i]<<","<<timesRansacCorrespondance[i]<<","<<timesRansacFeatureMatching[i]<<std::endl;
   }
-
-  
-
-
-  
-
+  fileErrors.close();
+  fileTimes.close();
   return 0;
 }