Merge branch 'develop' into dev/panoramaFisheye

src/aliceVision/camera/Pinhole.hpp

@@ -60,7 +60,7 @@ class Pinhole : public IntrinsicsScaleOffsetDisto
 
   EINTRINSIC getType() const override
   {
-    return PINHOLE_CAMERA; 
+    return EINTRINSIC::PINHOLE_CAMERA; 
   }
 
   Mat3 K() const

src/aliceVision/camera/PinholeBrown.hpp

@@ -31,7 +31,7 @@ class PinholeBrownT2 : public Pinhole
     PinholeBrownT2* clone() const override { return new PinholeBrownT2(*this); }
     void assign(const IntrinsicBase& other) override { *this = dynamic_cast<const PinholeBrownT2&>(other); }
 
-    EINTRINSIC getType() const override { return PINHOLE_CAMERA_BROWN; }
+    EINTRINSIC getType() const override { return EINTRINSIC::PINHOLE_CAMERA_BROWN; }
 
     ~PinholeBrownT2() override = default;
 };

src/aliceVision/camera/PinholeFisheye.hpp

@@ -37,7 +37,7 @@ class PinholeFisheye : public Pinhole
       *this = dynamic_cast<const PinholeFisheye&>(other);
   }
 
-  EINTRINSIC getType() const override { return PINHOLE_CAMERA_FISHEYE; }
+  EINTRINSIC getType() const override { return EINTRINSIC::PINHOLE_CAMERA_FISHEYE; }
 
   bool isVisibleRay(const Vec3 & ray) const override
   {

src/aliceVision/camera/PinholeFisheye1.hpp

@@ -42,7 +42,7 @@ class PinholeFisheye1 : public Pinhole
       *this = dynamic_cast<const PinholeFisheye1&>(other);
   }
 
-  EINTRINSIC getType() const override { return PINHOLE_CAMERA_FISHEYE1; }
+  EINTRINSIC getType() const override { return EINTRINSIC::PINHOLE_CAMERA_FISHEYE1; }
 
   ~PinholeFisheye1() override = default;
 };

src/aliceVision/camera/PinholeRadial.hpp

@@ -31,7 +31,7 @@ class PinholeRadialK1 : public Pinhole
   PinholeRadialK1* clone() const override { return new PinholeRadialK1(*this); }
   void assign(const IntrinsicBase& other) override { *this = dynamic_cast<const PinholeRadialK1&>(other); }
 
-  EINTRINSIC getType() const override { return PINHOLE_CAMERA_RADIAL1; }
+  EINTRINSIC getType() const override { return EINTRINSIC::PINHOLE_CAMERA_RADIAL1; }
 
   ~PinholeRadialK1() override = default;
 };
@@ -50,7 +50,7 @@ class PinholeRadialK3 : public Pinhole
   PinholeRadialK3* clone() const override { return new PinholeRadialK3(*this); }
   void assign(const IntrinsicBase& other) override { *this = dynamic_cast<const PinholeRadialK3&>(other); }
 
-  EINTRINSIC getType() const override { return PINHOLE_CAMERA_RADIAL3; }
+  EINTRINSIC getType() const override { return EINTRINSIC::PINHOLE_CAMERA_RADIAL3; }
 
   ~PinholeRadialK3() override = default;
 };

src/aliceVision/camera/camera.hpp

@@ -44,7 +44,10 @@ inline std::shared_ptr<IntrinsicBase> createIntrinsic(EINTRINSIC intrinsicType,
       return std::make_shared<EquiDistant>(w, h, focal_length_pix, ppx, ppy);
     case EINTRINSIC::EQUIDISTANT_CAMERA_RADIAL3:
       return std::make_shared<EquiDistantRadialK3>(w, h, focal_length_pix, ppx, ppy);
-    case EINTRINSIC::CAMERA_END:
+    case EINTRINSIC::UNKNOWN:
+    case EINTRINSIC::VALID_PINHOLE:
+    case EINTRINSIC::VALID_EQUIDISTANT:
+    case EINTRINSIC::VALID_CAMERA_MODEL:
       break;
   }
   throw std::out_of_range("Unrecognized Intrinsic Enum");

src/aliceVision/camera/cameraCommon.hpp

@@ -7,40 +7,54 @@
 
 #pragma once
 
+#include <boost/detail/bitmask.hpp>
+#include <boost/algorithm/string.hpp>
+
 #include <string>
 #include <stdexcept>
 #include <algorithm>
+#include <vector>
+#include <string>
 
 namespace aliceVision {
 namespace camera {
 
 enum EINTRINSIC
 {
-  PINHOLE_CAMERA = 0,          // no distortion
-  PINHOLE_CAMERA_RADIAL1 = 1,  // radial distortion K1
-  PINHOLE_CAMERA_RADIAL3 = 2,  // radial distortion K1,K2,K3
-  PINHOLE_CAMERA_BROWN = 3,    // radial distortion K1,K2,K3, tangential distortion T1,T2
-  PINHOLE_CAMERA_FISHEYE = 4,  // a simple Fish-eye distortion model with 4 distortion coefficients
-  PINHOLE_CAMERA_FISHEYE1 = 5, // a simple Fish-eye distortion model with 1 distortion coefficient
-  EQUIDISTANT_CAMERA = 6,
-  EQUIDISTANT_CAMERA_RADIAL3 = 7,
-  CAMERA_END
+    UNKNOWN = (1u << 0),
+    PINHOLE_CAMERA = (1u << 1),          // no distortion
+    PINHOLE_CAMERA_RADIAL1 = (1u << 2),  // radial distortion K1
+    PINHOLE_CAMERA_RADIAL3 = (1u << 3),  // radial distortion K1,K2,K3
+    PINHOLE_CAMERA_BROWN = (1u << 4),    // radial distortion K1,K2,K3, tangential distortion T1,T2
+    PINHOLE_CAMERA_FISHEYE = (1u << 5),  // a simple Fish-eye distortion model with 4 distortion coefficients
+    PINHOLE_CAMERA_FISHEYE1 = (1u << 6), // a simple Fish-eye distortion model with 1 distortion coefficient
+    EQUIDISTANT_CAMERA = (1u << 7),      // an equidistant model
+    EQUIDISTANT_CAMERA_RADIAL3 = (1u << 8),  // an equidistant model with radial distortion
+    VALID_PINHOLE = PINHOLE_CAMERA | PINHOLE_CAMERA_RADIAL1 | PINHOLE_CAMERA_RADIAL3 | PINHOLE_CAMERA_BROWN |
+                    PINHOLE_CAMERA_FISHEYE | PINHOLE_CAMERA_FISHEYE1,
+    VALID_EQUIDISTANT = EQUIDISTANT_CAMERA | EQUIDISTANT_CAMERA_RADIAL3,
+    VALID_CAMERA_MODEL = VALID_PINHOLE | VALID_EQUIDISTANT,
 };
 
+BOOST_BITMASK(EINTRINSIC)
+
 inline std::string EINTRINSIC_enumToString(EINTRINSIC intrinsic)
 {
   switch(intrinsic)
   {
-    case PINHOLE_CAMERA:          return "pinhole";
-    case PINHOLE_CAMERA_RADIAL1:  return "radial1";
-    case PINHOLE_CAMERA_RADIAL3:  return "radial3";
-    case PINHOLE_CAMERA_BROWN:    return "brown";
-    case PINHOLE_CAMERA_FISHEYE:  return "fisheye4";
-    case PINHOLE_CAMERA_FISHEYE1: return "fisheye1";
-    case EQUIDISTANT_CAMERA:      return "equidistant";
-    case EQUIDISTANT_CAMERA_RADIAL3:      return "equidistant_r3";
-    case CAMERA_END:
-      break;
+      case EINTRINSIC::PINHOLE_CAMERA: return "pinhole";
+      case EINTRINSIC::PINHOLE_CAMERA_RADIAL1: return "radial1";
+      case EINTRINSIC::PINHOLE_CAMERA_RADIAL3: return "radial3";
+      case EINTRINSIC::PINHOLE_CAMERA_BROWN: return "brown";
+      case EINTRINSIC::PINHOLE_CAMERA_FISHEYE: return "fisheye4";
+      case EINTRINSIC::PINHOLE_CAMERA_FISHEYE1: return "fisheye1";
+      case EINTRINSIC::EQUIDISTANT_CAMERA: return "equidistant";
+      case EINTRINSIC::EQUIDISTANT_CAMERA_RADIAL3: return "equidistant_r3";
+      case EINTRINSIC::UNKNOWN:
+      case EINTRINSIC::VALID_PINHOLE:
+      case EINTRINSIC::VALID_EQUIDISTANT:
+      case EINTRINSIC::VALID_CAMERA_MODEL:
+          break;
   }
   throw std::out_of_range("Invalid Intrinsic Enum");
 }
@@ -50,48 +64,61 @@ inline EINTRINSIC EINTRINSIC_stringToEnum(const std::string& intrinsic)
   std::string type = intrinsic;
   std::transform(type.begin(), type.end(), type.begin(), ::tolower); //tolower
 
-  if(type == "pinhole")  return PINHOLE_CAMERA;
-  if(type == "radial1")  return PINHOLE_CAMERA_RADIAL1;
-  if(type == "radial3")  return PINHOLE_CAMERA_RADIAL3;
-  if(type == "brown")    return PINHOLE_CAMERA_BROWN;
-  if(type == "fisheye4") return PINHOLE_CAMERA_FISHEYE;
-  if(type == "fisheye1") return PINHOLE_CAMERA_FISHEYE1;
-  if(type == "equidistant") return EQUIDISTANT_CAMERA;
-  if(type == "equidistant_r3") return EQUIDISTANT_CAMERA_RADIAL3;
+  if(type == "pinhole") return EINTRINSIC::PINHOLE_CAMERA;
+  if(type == "radial1") return EINTRINSIC::PINHOLE_CAMERA_RADIAL1;
+  if(type == "radial3") return EINTRINSIC::PINHOLE_CAMERA_RADIAL3;
+  if(type == "brown") return EINTRINSIC::PINHOLE_CAMERA_BROWN;
+  if(type == "fisheye4") return EINTRINSIC::PINHOLE_CAMERA_FISHEYE;
+  if(type == "fisheye1") return EINTRINSIC::PINHOLE_CAMERA_FISHEYE1;
+  if(type == "equidistant") return EINTRINSIC::EQUIDISTANT_CAMERA;
+  if(type == "equidistant_r3") return EINTRINSIC::EQUIDISTANT_CAMERA_RADIAL3;
 
   throw std::out_of_range(intrinsic);
 }
 
+inline std::ostream& operator<<(std::ostream& os, EINTRINSIC e)
+{
+    return os << EINTRINSIC_enumToString(e);
+}
+
+inline std::istream& operator>>(std::istream& in, EINTRINSIC& e)
+{
+    std::string token;
+    in >> token;
+    e = EINTRINSIC_stringToEnum(token);
+    return in;
+}
+
 // Return if the camera type is a valid enum
 inline bool isValid(EINTRINSIC eintrinsic)
 {
-  return eintrinsic >= PINHOLE_CAMERA && eintrinsic < CAMERA_END;
+    return EINTRINSIC::VALID_CAMERA_MODEL & eintrinsic;
 }
 
 inline bool isPinhole(EINTRINSIC eintrinsic)
 {
-  switch (eintrinsic) {
-  case PINHOLE_CAMERA:
-  case PINHOLE_CAMERA_RADIAL1:
-  case PINHOLE_CAMERA_RADIAL3:
-  case PINHOLE_CAMERA_BROWN:
-  case PINHOLE_CAMERA_FISHEYE:
-  case PINHOLE_CAMERA_FISHEYE1:
-    return true;
-  default:
-    return false;
-  }
+    return EINTRINSIC::VALID_PINHOLE & eintrinsic;
 }
 
 inline bool isEquidistant(EINTRINSIC eintrinsic)
 {
-  switch (eintrinsic) {
-  case EQUIDISTANT_CAMERA:
-  case EQUIDISTANT_CAMERA_RADIAL3:
-    return true;
-  default:
-    return false;
-  }
+    return EINTRINSIC::VALID_EQUIDISTANT & eintrinsic;
+}
+
+inline EINTRINSIC EINTRINSIC_parseStringToBitmask(const std::string& str, const std::string& joinChar = ",")
+{   
+    std::vector<std::string> intrinsicsVec;
+    boost::split(intrinsicsVec, str, boost::is_any_of(joinChar));
+    if(!intrinsicsVec.size())
+    {
+        throw std::invalid_argument("'" + str + "'can't be parsed to EINTRINSIC Bitmask."); 
+    }
+    EINTRINSIC mask = EINTRINSIC_stringToEnum(intrinsicsVec[0]);
+    for(const std::string& intrinsic : intrinsicsVec)
+    {
+        mask |= EINTRINSIC_stringToEnum(intrinsic);
+    }
+    return mask;
 }
 
 } // namespace camera

src/aliceVision/sfm/BundleAdjustmentCeres.cpp

@@ -40,17 +40,17 @@ ceres::CostFunction* createCostFunctionFromIntrinsics(const IntrinsicBase* intri
 {
   switch(intrinsicPtr->getType())
   {
-    case PINHOLE_CAMERA:
+    case EINTRINSIC::PINHOLE_CAMERA:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_Pinhole, 2, 3, 6, 3>(new ResidualErrorFunctor_Pinhole(observation));
-    case PINHOLE_CAMERA_RADIAL1:
+    case EINTRINSIC::PINHOLE_CAMERA_RADIAL1:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeRadialK1, 2, 4, 6, 3>(new ResidualErrorFunctor_PinholeRadialK1(observation));
-    case PINHOLE_CAMERA_RADIAL3:
+    case EINTRINSIC::PINHOLE_CAMERA_RADIAL3:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeRadialK3, 2, 6, 6, 3>(new ResidualErrorFunctor_PinholeRadialK3(observation));
-    case PINHOLE_CAMERA_BROWN:
+    case EINTRINSIC::PINHOLE_CAMERA_BROWN:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeBrownT2, 2, 8, 6, 3>(new ResidualErrorFunctor_PinholeBrownT2(observation));
-    case PINHOLE_CAMERA_FISHEYE:
+    case EINTRINSIC::PINHOLE_CAMERA_FISHEYE:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeFisheye, 2, 7, 6, 3>(new ResidualErrorFunctor_PinholeFisheye(observation));
-    case PINHOLE_CAMERA_FISHEYE1:
+    case EINTRINSIC::PINHOLE_CAMERA_FISHEYE1:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeFisheye1, 2, 4, 6, 3>(new ResidualErrorFunctor_PinholeFisheye1(observation));
     default:
       throw std::logic_error("Cannot create cost function, unrecognized intrinsic type in BA.");
@@ -67,17 +67,17 @@ ceres::CostFunction* createRigCostFunctionFromIntrinsics(const IntrinsicBase* in
 {
   switch(intrinsicPtr->getType())
   {
-    case PINHOLE_CAMERA:
+    case EINTRINSIC::PINHOLE_CAMERA:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_Pinhole, 2, 3, 6, 6, 3>(new ResidualErrorFunctor_Pinhole(observation));
-    case PINHOLE_CAMERA_RADIAL1:
+    case EINTRINSIC::PINHOLE_CAMERA_RADIAL1:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeRadialK1, 2, 4, 6, 6, 3>(new ResidualErrorFunctor_PinholeRadialK1(observation));
-    case PINHOLE_CAMERA_RADIAL3:
+    case EINTRINSIC::PINHOLE_CAMERA_RADIAL3:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeRadialK3, 2, 6, 6, 6, 3>(new ResidualErrorFunctor_PinholeRadialK3(observation));
-    case PINHOLE_CAMERA_BROWN:
+    case EINTRINSIC::PINHOLE_CAMERA_BROWN:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeBrownT2, 2, 8, 6, 6, 3>(new ResidualErrorFunctor_PinholeBrownT2(observation));
-    case PINHOLE_CAMERA_FISHEYE:
+    case EINTRINSIC::PINHOLE_CAMERA_FISHEYE:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeFisheye, 2, 7, 6, 6, 3>(new ResidualErrorFunctor_PinholeFisheye(observation));
-    case PINHOLE_CAMERA_FISHEYE1:
+    case EINTRINSIC::PINHOLE_CAMERA_FISHEYE1:
       return new ceres::AutoDiffCostFunction<ResidualErrorFunctor_PinholeFisheye1, 2, 4, 6, 6, 3>(new ResidualErrorFunctor_PinholeFisheye1(observation));
     default:
       throw std::logic_error("Cannot create rig cost function, unrecognized intrinsic type in BA.");
@@ -100,13 +100,13 @@ ceres::CostFunction* createConstraintsCostFunctionFromIntrinsics(const Intrinsic
 
   switch(intrinsicPtr->getType())
   {
-    case PINHOLE_CAMERA:
+    case EINTRINSIC::PINHOLE_CAMERA:
       return new ceres::AutoDiffCostFunction<ResidualErrorConstraintFunctor_Pinhole, 2, 3, 6, 6>(new ResidualErrorConstraintFunctor_Pinhole(observation_first.homogeneous(), observation_second.homogeneous()));
-    case PINHOLE_CAMERA_RADIAL1:
+    case EINTRINSIC::PINHOLE_CAMERA_RADIAL1:
       return new ceres::AutoDiffCostFunction<ResidualErrorConstraintFunctor_PinholeRadialK1, 2, 4, 6, 6>(new ResidualErrorConstraintFunctor_PinholeRadialK1(observation_first.homogeneous(), observation_second.homogeneous()));
-    case PINHOLE_CAMERA_RADIAL3:
+    case EINTRINSIC::PINHOLE_CAMERA_RADIAL3:
       return new ceres::AutoDiffCostFunction<ResidualErrorConstraintFunctor_PinholeRadialK3, 2, 6, 6, 6>(new ResidualErrorConstraintFunctor_PinholeRadialK3(observation_first.homogeneous(), observation_second.homogeneous()));
-    case PINHOLE_CAMERA_FISHEYE:
+    case EINTRINSIC::PINHOLE_CAMERA_FISHEYE:
       return new ceres::AutoDiffCostFunction<ResidualErrorConstraintFunctor_PinholeFisheye, 2, 7, 6, 6>(new ResidualErrorConstraintFunctor_PinholeFisheye(observation_first.homogeneous(), observation_second.homogeneous()));
     case EQUIDISTANT_CAMERA:
       return new ceres::AutoDiffCostFunction<ResidualErrorConstraintFunctor_Equidistant, 2, 3, 6, 6>(new ResidualErrorConstraintFunctor_Equidistant(observation_first.homogeneous(), observation_second.homogeneous(), radius));

src/aliceVision/sfm/bundleAdjustment_test.cpp

@@ -45,7 +45,7 @@ BOOST_AUTO_TEST_CASE(BUNDLE_ADJUSTMENT_EffectiveMinimization_Pinhole)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA);
+  SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA);
 
   const double dResidual_before = RMSE(sfmData);
 
@@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE(BUNDLE_ADJUSTMENT_EffectiveMinimization_PinholeRadialK1)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA_RADIAL1);
+  SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA_RADIAL1);
 
   const double dResidual_before = RMSE(sfmData);
 
@@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE(BUNDLE_ADJUSTMENT_EffectiveMinimization_PinholeRadialK3)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA_RADIAL3);
+  SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA_RADIAL3);
 
   const double dResidual_before = RMSE(sfmData);
 
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(BUNDLE_ADJUSTMENT_EffectiveMinimization_PinholeBrownT2)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA_BROWN);
+  SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA_BROWN);
 
   const double dResidual_before = RMSE(sfmData);
 
@@ -125,7 +125,7 @@ BOOST_AUTO_TEST_CASE(BUNDLE_ADJUSTMENT_EffectiveMinimization_PinholeFisheye)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA_FISHEYE);
+  SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA_FISHEYE);
 
   const double dResidual_before = RMSE(sfmData);
 
@@ -145,8 +145,8 @@ BOOST_AUTO_TEST_CASE(LOCAL_BUNDLE_ADJUSTMENT_EffectiveMinimization_Pinhole_Camer
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA);
-  SfMData sfmData_notRefined = getInputScene(d, config, PINHOLE_CAMERA); // used to compate which parameters are refined.
+  SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA);
+  SfMData sfmData_notRefined = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA); // used to compate which parameters are refined.
 
   // Transform the views scheme
   //          v0 - v3

src/aliceVision/sfm/pipeline/global/globalSfM_test.cpp

@@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(GLOBAL_SFM_RotationAveragingL2_TranslationAveragingL1)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  const SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA);
+  const SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA);
 
   // Remove poses and structure
   SfMData sfmData2 = sfmData;
@@ -96,7 +96,7 @@ BOOST_AUTO_TEST_CASE(GLOBAL_SFM_RotationAveragingL1_TranslationAveragingL1)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  const SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA);
+  const SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA);
 
   // Remove poses and structure
   SfMData sfmData2 = sfmData;
@@ -146,7 +146,7 @@ BOOST_AUTO_TEST_CASE(GLOBAL_SFM_RotationAveragingL2_TranslationAveragingL2_Chord
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  const SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA);
+  const SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA);
 
   // Remove poses and structure
   SfMData sfmData2 = sfmData;
@@ -196,7 +196,7 @@ BOOST_AUTO_TEST_CASE(GLOBAL_SFM_RotationAveragingL2_TranslationAveragingSoftL1)
   const NViewDataSet d = NRealisticCamerasRing(nviews, npoints, config);
 
   // Translate the input dataset to a SfMData scene
-  const SfMData sfmData = getInputScene(d, config, PINHOLE_CAMERA);
+  const SfMData sfmData = getInputScene(d, config, EINTRINSIC::PINHOLE_CAMERA);
 
   // Remove poses and structure
   SfMData sfmData2 = sfmData;