[multiview] Addition of 10 points relative pose solver

.travis.yml

@@ -107,8 +107,8 @@ script:
         git clone --branch master https://github.com/alicevision/SfM_quality_evaluation.git $GT_TEST_SOURCE;
       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
+      git checkout 203e55c6e70de5f79496407961eb10b15deece4b # 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} -v --limit 3
       cat ${GT_TEST_RESULTS}
       # Return to root and remove GT huge files to avoid cache problems
       cd $TRAVIS_BUILD_DIR

src/CMakeLists.txt

@@ -278,6 +278,7 @@ if(BUILD_SHARED_LIBS)
   # Force BOOST to use dynamic libraries (avoid link error with boost program_options)
   # https://lists.boost.org/boost-users/2009/11/54015.php
   add_definitions(-DBOOST_ALL_DYN_LINK)
+  add_definitions(-DBOOST_TEST_DYN_LINK)
 else()
   set(Boost_USE_STATIC_LIBS ON)
 endif()

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 override
   {
     Mat34 P;
-    P_From_KRt(K(), pose.rotation(), pose.translation(), &P);
+    P_from_KRt(K(), pose.rotation(), pose.translation(), &P);
     return P;
   }
 

src/aliceVision/feature/svgVisualization.cpp

@@ -60,6 +60,69 @@ float getStrokeEstimate(const std::pair<size_t,size_t> & imgSize)
   return std::max(std::max(imgSize.first, imgSize.second) / float(2200), 2.0f);
 }
 
+inline void drawMatchesSideBySide(svg::svgDrawer& svgStream,
+                           const feature::PointFeature &L,
+                           const feature::PointFeature &R,
+                           std::size_t offset,
+                           float radiusLeft,
+                           float radiusRight,
+                           float strokeLeft,
+                           float strokeRight,
+                           const svg::svgStyle& lineStyle,
+                           const svg::svgStyle& leftStyle,
+                           const svg::svgStyle& rightStyle)
+{
+    const float xRight = R.x() + offset;
+    svgStream.drawLine(L.x(), L.y(), xRight, R.y(), lineStyle);
+    svgStream.drawCircle(L.x(), L.y(), radiusLeft, leftStyle);
+    svgStream.drawCircle(xRight, R.y(), radiusRight, rightStyle);
+}
+
+inline void drawMatchesSideBySide(svg::svgDrawer& svgStream,
+                           const std::vector<feature::PointFeature>& keypointsLeft,
+                           const std::vector<feature::PointFeature>& keypointsRight,
+                           std::size_t offset,
+                           float radiusLeft,
+                           float radiusRight,
+                           float strokeLeft,
+                           float strokeRight,
+                           const svg::svgStyle& lineStyle,
+                           const svg::svgStyle& leftStyle,
+                           const svg::svgStyle& rightStyle,
+                           const matching::IndMatches& matches)
+{
+    for (const matching::IndMatch &m : matches)
+    {
+        const feature::PointFeature &L = keypointsLeft[m._i];
+        const feature::PointFeature &R = keypointsRight[m._j];
+        drawMatchesSideBySide(svgStream, L, R,  offset, radiusLeft, radiusRight, strokeLeft, strokeRight, lineStyle, leftStyle, rightStyle);
+    }
+}
+
+inline void drawInliersSideBySide(svg::svgDrawer& svgStream,
+                           const std::vector<feature::PointFeature>& keypointsLeft,
+                           const std::vector<feature::PointFeature>& keypointsRight,
+                           std::size_t offset,
+                           float radiusLeft,
+                           float radiusRight,
+                           float strokeLeft,
+                           float strokeRight,
+                           const svg::svgStyle& lineStyle,
+                           const svg::svgStyle& leftStyle,
+                           const svg::svgStyle& rightStyle,
+                           const matching::IndMatches& matches,
+                           std::vector<size_t>& inliers)
+{
+    for (const auto &idx : inliers)
+    {
+        const auto currMatch = matches[idx];
+        const feature::PointFeature &L = keypointsLeft[currMatch._i];
+        const feature::PointFeature &R = keypointsRight[currMatch._j];
+
+        drawMatchesSideBySide(svgStream, L, R,  offset, radiusLeft, radiusRight, strokeLeft, strokeRight, lineStyle, leftStyle, rightStyle);
+    }
+}
+
 void drawMatchesSideBySide(const std::string& imagePathLeft,
                            const std::pair<size_t,size_t>& imageSizeLeft,
                            const std::vector<feature::PointFeature>& keypointsLeft,
@@ -115,10 +178,10 @@ void drawMatchesSideBySide(const std::string& imagePathLeft,
 
 void drawHomographyMatches(const std::string& imagePathLeft,
                            const std::pair<size_t,size_t>& imageSizeLeft,
-                           const std::vector<feature::PointFeature>& siofeatures_I,
+                           const std::vector<feature::PointFeature>& features_I,
                            const std::string& imagePathRight,
                            const std::pair<size_t,size_t>& imageSizeRight,
-                           const std::vector<feature::PointFeature>& siofeatures_J,
+                           const std::vector<feature::PointFeature>& features_J,
                            const std::vector<std::pair<Mat3, matching::IndMatches>>& homographiesAndMatches,
                            const matching::IndMatches& putativeMatches,
                            const std::string& outFilename)
@@ -132,13 +195,13 @@ void drawHomographyMatches(const std::string& imagePathLeft,
   svgStream.drawImage(imagePathLeft, imageSizeLeft.first, imageSizeLeft.second);
   svgStream.drawImage(imagePathRight, imageSizeRight.first, imageSizeRight.second, offset);
 
-// draw little white dots representing putative matches
+  // draw little white dots representing putative matches
   for (const auto& match : putativeMatches)
   {
     const float radius{1.f};
     const float strokeSize{2.f};
-    const feature::PointFeature &fI = siofeatures_I.at(match._i);
-    const feature::PointFeature &fJ = siofeatures_J.at(match._j);
+    const feature::PointFeature &fI = features_I.at(match._i);
+    const feature::PointFeature &fJ = features_J.at(match._j);
     const svg::svgStyle style = svg::svgStyle().stroke("white", strokeSize);
 
     svgStream.drawCircle(fI.x(), fI.y(), radius, style);
@@ -158,8 +221,8 @@ void drawHomographyMatches(const std::string& imagePathLeft,
 
       for (const auto &match : bestMatchesId)
       {
-        const feature::PointFeature &fI = siofeatures_I.at(match._i);
-        const feature::PointFeature &fJ = siofeatures_J.at(match._j);
+        const feature::PointFeature &fI = features_I.at(match._i);
+        const feature::PointFeature &fJ = features_J.at(match._j);
 
         const svg::svgStyle style = svg::svgStyle().stroke(color, strokeSize);
 
@@ -183,7 +246,6 @@ void drawHomographyMatches(const std::string& imagePathLeft,
     return;
   }
   svgFile.close();
-
 }
 
 void saveMatches2SVG(const std::string &imagePathLeft,

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;
+  using SolverT = geometry::RTSSolver;
+  using KernelT = ACKernelAdaptor_PointsRegistrationSRT<SolverT, geometry::RTSSquaredResidualError>;
 
-  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)