[multiview] Addition of 10 points relative pose solver

.travis.yml

@@ -104,7 +104,7 @@ script:
       fi
       cd $GT_TEST_SOURCE
       git checkout 1828a5076ccca86fd523c92a768f1d518dfdbb91 # checkout a specific commit to ensure repeatability
-      python EvaluationLauncher.py -s "$ALICEVISION_BUILD/$BUILD_SYSTEM-$BUILD_PROCESSOR" -i Benchmarking_Camera_Calibration_2008/ -o ${GT_TEST_OUTPUT} -r ${GT_TEST_RESULTS} --limit 3
+      python EvaluationLauncher.py -s "$ALICEVISION_BUILD/$BUILD_SYSTEM-$BUILD_PROCESSOR" -i Benchmarking_Camera_Calibration_2008/ -o ${GT_TEST_OUTPUT} -r ${GT_TEST_RESULTS} -v --limit 3
       cat ${GT_TEST_RESULTS}
       # Return to root and remove GT huge files to avoid cache problems
       cd $TRAVIS_BUILD_DIR

src/aliceVision/camera/CMakeLists.txt

@@ -1,24 +1,23 @@
 # Headers
 set(camera_files_headers
-	camera.hpp
-	cameraCommon.hpp
-	cameraUndistortImage.hpp
-	IntrinsicBase.hpp
-	IntrinsicInitMode.hpp
-	Pinhole.hpp
-	PinholeBrown.hpp
-	PinholeFisheye.hpp
-	PinholeFisheye1.hpp
-	PinholeRadial.hpp
+    camera.hpp
+    cameraCommon.hpp
+    cameraUndistortImage.hpp
+    IntrinsicBase.hpp
+    IntrinsicInitMode.hpp
+    Pinhole.hpp
+    PinholeBrown.hpp
+    PinholeFisheye.hpp
+    PinholeFisheye1.hpp
+    PinholeRadial.hpp
 )
 
 alicevision_add_interface(aliceVision_camera
   SOURCES ${camera_files_headers}
   LINKS
+    aliceVision_numeric
     aliceVision_geometry
-    aliceVision_multiview
     aliceVision_image
-    aliceVision_numeric
     aliceVision_stl
     aliceVision_system
 )

src/aliceVision/camera/Pinhole.hpp

@@ -8,10 +8,10 @@
 #pragma once
 
 #include <aliceVision/numeric/numeric.hpp>
+#include <aliceVision/numeric/projection.hpp>
+#include <aliceVision/geometry/Pose3.hpp>
 #include <aliceVision/camera/cameraCommon.hpp>
 #include <aliceVision/camera/IntrinsicBase.hpp>
-#include <aliceVision/geometry/Pose3.hpp>
-#include <aliceVision/multiview/projection.hpp>
 
 #include <vector>
 #include <sstream>
@@ -106,7 +106,7 @@ class Pinhole : public IntrinsicBase
   virtual Mat34 get_projective_equivalent(const geometry::Pose3 & pose) const
   {
     Mat34 P;
-    P_From_KRt(K(), pose.rotation(), pose.translation(), &P);
+    P_from_KRt(K(), pose.rotation(), pose.translation(), &P);
     return P;
   }
 

src/aliceVision/geometry/frustumIntersection_test.cpp

@@ -9,7 +9,7 @@
 #include "aliceVision/geometry/Frustum.hpp"
 
 #include "aliceVision/multiview/NViewDataSet.hpp"
-#include "aliceVision/multiview/projection.hpp"
+#include "aliceVision/numeric/projection.hpp"
 
 #include <iostream>
 

src/aliceVision/geometry/rigidTransformation3D.cpp

@@ -126,13 +126,13 @@ void Refine_RTS(const Mat &x1,
   }
 }
 
-bool ACRansac_FindRTS(const Mat &x1,
-                             const Mat &x2,
-                             double &S,
-                             Vec3 &t,
-                             Mat3 &R,
-                             std::vector<std::size_t> &vec_inliers,
-                             bool refine)
+bool ACRansac_FindRTS(const Mat& x1,
+                      const Mat& x2,
+                      double& S,
+                      Vec3& t,
+                      Mat3& R,
+                      std::vector<std::size_t>& vec_inliers,
+                      bool refine)
 {
   assert(3 == x1.rows());
   assert(3 <= x1.cols());
@@ -142,19 +142,17 @@ bool ACRansac_FindRTS(const Mat &x1,
   const std::size_t numIterations = 1024;
   const double dPrecision = std::numeric_limits<double>::infinity();
 
-  Mat4 RTS;
+  typedef geometry::RTSSolver SolverT;
+  typedef ACKernelAdaptor_PointsRegistrationSRT<SolverT, geometry::RTSSquaredResidualError> KernelT;
 
-  typedef geometry::RTSSolver SolverType;
-  typedef ACKernelAdaptor_PointsRegistrationSRT<
-          SolverType,
-          geometry::RTSSquaredResidualError> KernelType;
+  const KernelT kernel = KernelT(x1, x2);
 
-  KernelType kernel = KernelType(x1, x2);
-  // Robust estimation of the Projection matrix and its precision
-  const std::pair<double, double> ACRansacOut =
-          robustEstimation::ACRANSAC(kernel, vec_inliers, numIterations, &RTS, dPrecision);
+  robustEstimation::MatrixModel<Mat4> RTS;
 
-  const bool good = decomposeRTS(RTS, S, t, R);
+  // robust estimation of the Projection matrix and its precision
+  const std::pair<double, double> ACRansacOut = robustEstimation::ACRANSAC(kernel, vec_inliers, numIterations, &RTS, dPrecision);
+
+  const bool good = decomposeRTS(RTS.getMatrix(), S, t, R);
 
   // return if it is not good or refine is not required
   if(!good || !refine)

src/aliceVision/geometry/rigidTransformation3D.hpp

@@ -9,6 +9,7 @@
 
 #include <aliceVision/numeric/numeric.hpp>
 #include <aliceVision/numeric/LMFunctor.hpp>
+#include <aliceVision/robustEstimation/ISolver.hpp>
 
 namespace aliceVision {
 namespace geometry {
@@ -149,31 +150,46 @@ void Refine_RTS(const Mat &x1,
 /**
  * @brief the Solver to use for ACRansac
  */
-struct RTSSolver
+class RTSSolver : public robustEstimation::ISolver<robustEstimation::MatrixModel<Mat4>>
 {
+public:
 
-  enum
+  /**
+   * @brief Return the minimum number of required samples
+   * @return minimum number of required samples
+   */
+  inline std::size_t getMinimumNbRequiredSamples() const override
   {
-    MINIMUM_SAMPLES = 3
-  };
+    return 3;
+  }
 
-  enum
+  /**
+   * @brief Return the maximum number of models
+   * @return maximum number of models
+   */
+  inline std::size_t getMaximumNbModels() const override
   {
-    MAX_MODELS = 1
-  };
-
-  // Solve the RTS problem
-  static void Solve(const Mat &pts1, const Mat &pts2, std::vector<Mat4> *models)
+    return 1;
+  }
+
+  // solve the RTS problem
+  inline void solve(const Mat& pts1, const Mat& pts2, std::vector<robustEstimation::MatrixModel<Mat4>>& models) const
+  {
+    models.push_back( robustEstimation::MatrixModel<Mat4>(Eigen::umeyama(pts1, pts2, true)) );
+  }
+
+  void solve(const Mat& x1, const Mat& x2, std::vector<robustEstimation::MatrixModel<Mat4>>& models, const std::vector<double>& weights) const override
   {
-    models->push_back(Eigen::umeyama(pts1, pts2, true));
+     throw std::logic_error("RTSSolver does not support problem solving with weights.");
   }
 
-  // Compute the residual of the transformation 
-  static double Error(const Mat4 &RTS, const Vec3 & pt1, const Vec3 & pt2)
+  // compute the residual of the transformation
+  inline double error(const robustEstimation::MatrixModel<Mat4>& RTS, const Vec3& pt1, const Vec3& pt2)
   {
-    const Mat3 &RS = RTS.topLeftCorner<3, 3>();
-    const Vec3 &t = RTS.topRightCorner<3, 1>();
-    return (pt2 - (RS*pt1 + t)).norm();
+    const Mat4& matrixRTS = RTS.getMatrix();
+    const Mat3& RS = matrixRTS.topLeftCorner<3, 3>();
+    const Vec3& t = matrixRTS.topRightCorner<3, 1>();
+    return(pt2 - (RS*pt1 + t)).norm();
   }
 };
 
@@ -183,31 +199,31 @@ struct RTSSolver
  */
 struct RTSSquaredResidualError 
 {
-  // Return the squared error
-  static double Error(const Mat4 &RTS, const Vec3 & pt1, const Vec3 & pt2)
+  // return the squared error
+  inline double error(const robustEstimation::MatrixModel<Mat4>& RTS, const Vec3& pt1, const Vec3& pt2) const
   {
-    const Mat3 &RS = RTS.topLeftCorner<3, 3>();
-    const Vec3 &t = RTS.topRightCorner<3, 1>();
+    const Mat4& matrixRTS = RTS.getMatrix();
+    const Mat3& RS = matrixRTS.topLeftCorner<3, 3>();
+    const Vec3& t = matrixRTS.topRightCorner<3, 1>();
     return (pt2 - (RS*pt1 + t)).squaredNorm();
   }
 };
 
 /**
  * @brief The kernel to use for ACRansac
  */
-template <typename SolverArg,
-typename ErrorArg,
-typename ModelArg = Mat4>
+template <typename SolverT_, typename ErrorT_, typename ModelT_ = robustEstimation::MatrixModel<Mat4>>
 class ACKernelAdaptor_PointsRegistrationSRT
 {
 public:
-  typedef SolverArg Solver;
-  typedef ModelArg Model;
-  typedef ErrorArg ErrorT;
-
-  ACKernelAdaptor_PointsRegistrationSRT(const Mat & xA,
-                                        const Mat & xB) :
-             x1_(xA), x2_(xB), logalpha0_(log10(M_PI)) //@todo  WTF?
+  using SolverT = SolverT_;
+  using ModelT = ModelT_;
+  using ErrorT = ErrorT_;
+
+  ACKernelAdaptor_PointsRegistrationSRT(const Mat& xA, const Mat& xB)
+    : x1_(xA)
+    , x2_(xB)
+    , _logalpha0(log10(M_PI)) //@todo  WTF?
   {
     assert(3 == x1_.rows());
     assert(x1_.rows() == x2_.rows());
@@ -216,40 +232,51 @@ class ACKernelAdaptor_PointsRegistrationSRT
     // @todo normalize points?
   }
 
-  enum
+  /**
+   * @brief Return the minimum number of required samples
+   * @return minimum number of required samples
+   */
+  inline std::size_t getMinimumNbRequiredSamples() const
   {
-    MINIMUM_SAMPLES = Solver::MINIMUM_SAMPLES
-  };
+    return _kernelSolver.getMinimumNbRequiredSamples();
+  }
 
-  enum
+  /**
+   * @brief Return the maximum number of models
+   * @return maximum number of models
+   */
+  inline std::size_t getMaximumNbModels() const
   {
-    MAX_MODELS = Solver::MAX_MODELS
-  };
+    return _kernelSolver.getMaximumNbModels();
+  }
 
-  void Fit(const std::vector<size_t> &samples, std::vector<Model> *models) const
+  void fit(const std::vector<std::size_t>& samples, std::vector<ModelT>& models) const
   {
     const Mat x1 = ExtractColumns(x1_, samples);
     const Mat x2 = ExtractColumns(x2_, samples);
-    Solver::Solve(x1, x2, models);
+    _kernelSolver.solve(x1, x2, models);
   }
 
-  double Error(size_t sample, const Model &model) const
+  double error(std::size_t sample, const ModelT& model) const
   {
-    return Square(ErrorT::Error(model, x1_.col(sample), x2_.col(sample)));
+    return Square(_errorEstimator.error(model, x1_.col(sample), x2_.col(sample)));
   }
 
-  void Errors(const Model & model, std::vector<double> & vec_errors) const
+  void errors(const ModelT& model, std::vector<double> & vec_errors) const
   {
     vec_errors.resize(x1_.cols());
-    for(size_t sample = 0; sample < x1_.cols(); ++sample)
-      vec_errors[sample] = Square(ErrorT::Error(model, x1_.col(sample), x2_.col(sample)));
+    for(std::size_t sample = 0; sample < x1_.cols(); ++sample)
+      vec_errors[sample] = error(sample,model);
   }
 
-  size_t NumSamples() const { return static_cast<size_t> (x1_.cols()); }
+  std::size_t nbSamples() const
+  {
+    return static_cast<std::size_t> (x1_.cols());
+  }
 
-  void Unnormalize(Model * model) const { } //-- Do nothing, no normalization 
+  void unnormalize(ModelT& model) const { } //-- Do nothing, no normalization
 
-  double logalpha0() const { return logalpha0_; }
+  double logalpha0() const { return _logalpha0; }
 
   double multError() const { return 1.;}
 
@@ -260,8 +287,11 @@ class ACKernelAdaptor_PointsRegistrationSRT
   double unormalizeError(double val) const { return sqrt(val); }
 
 private:
-  Mat x1_, x2_;       // Normalized input data
-  double logalpha0_;  // Alpha0 is used to make the error scale invariant
+  Mat x1_, x2_;       // normalized input data
+  double _logalpha0;  // alpha0 is used to make the error scale invariant
+
+  SolverT _kernelSolver;
+  ErrorT _errorEstimator;
 };
 
 /**