New hdri stitching software

src/aliceVision/image/Sampler.hpp

@@ -430,7 +430,8 @@ struct Sampler2d
     _sampler( dx , coefs_x ) ;
     _sampler( dy , coefs_y ) ;
 
-    typename RealPixel<T>::real_type res(0) ;
+    // Default color constructor init all channels to zero
+    typename RealPixel<T>::real_type res;
 
     // integer position of sample (x,y)
     const int grid_x = static_cast<int>( floor( x ) );

src/aliceVision/image/io.cpp

@@ -74,6 +74,27 @@ std::istream& operator>>(std::istream& in, EImageFileType& imageFileType)
   return in;
 }
 
+bool isSupported(const std::string &ext)
+{
+  static const std::string extensionList = oiio::get_string_attribute("extension_list");
+  std::vector<std::string> supportedExtensions;
+
+  std::vector<std::string> supportedFormat;
+  boost::split(supportedFormat, extensionList, boost::is_any_of(";"), boost::token_compress_on);
+  for(const std::string& format: supportedFormat)
+  {
+    std::vector<std::string> extensions;
+    const std::string str = format.substr(format.find(":")+1);
+    boost::split(extensions, str, boost::is_any_of(","), boost::token_compress_on);
+    for(std::string& extension: extensions)
+      supportedExtensions.push_back(extension.insert(0, "."));
+  }
+
+  const auto start = supportedExtensions.begin();
+  const auto end = supportedExtensions.end();
+  return (std::find(start, end, boost::to_lower_copy(ext)) != end);
+}
+
 // Warning: type conversion problems from string to param value, we may lose some metadata with string maps
 oiio::ParamValueList getMetadataFromMap(const std::map<std::string, std::string>& metadataMap)
 {
@@ -147,6 +168,11 @@ void getBufferFromImage(Image<unsigned char>& image, oiio::ImageBuf& buffer)
   getBufferFromImage(image, oiio::TypeDesc::UINT8, 1, buffer);
 }
 
+void getBufferFromImage(Image<RGBAfColor>& image, oiio::ImageBuf& buffer)
+{
+  getBufferFromImage(image, oiio::TypeDesc::FLOAT, 4, buffer);
+}
+
 void getBufferFromImage(Image<RGBAColor>& image, oiio::ImageBuf& buffer)
 {
   getBufferFromImage(image, oiio::TypeDesc::UINT8, 4, buffer);
@@ -348,6 +374,11 @@ void readImage(const std::string& path, Image<unsigned char>& image, EImageColor
   readImage(path, oiio::TypeDesc::UINT8, 1, image, imageColorSpace);
 }
 
+void readImage(const std::string& path, Image<RGBAfColor>& image, EImageColorSpace imageColorSpace)
+{
+  readImage(path, oiio::TypeDesc::FLOAT, 4, image, imageColorSpace);
+}
+
 void readImage(const std::string& path, Image<RGBAColor>& image, EImageColorSpace imageColorSpace)
 {
   readImage(path, oiio::TypeDesc::UINT8, 4, image, imageColorSpace);
@@ -368,6 +399,11 @@ void writeImage(const std::string& path, const Image<unsigned char>& image, EIma
   writeImage(path, oiio::TypeDesc::UINT8, 1, image, imageColorSpace, metadata);
 }
 
+void writeImage(const std::string& path, const Image<RGBAfColor>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata)
+{
+  writeImage(path, oiio::TypeDesc::FLOAT, 4, image, imageColorSpace, metadata);
+}
+
 void writeImage(const std::string& path, const Image<RGBAColor>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata)
 {
   writeImage(path, oiio::TypeDesc::UINT8, 4, image, imageColorSpace, metadata);

src/aliceVision/image/io.hpp

@@ -13,6 +13,7 @@
 #include <OpenImageIO/paramlist.h>
 #include <OpenImageIO/imagebuf.h>
 
+#include <boost/algorithm/string.hpp>
 #include <string>
 
 namespace oiio = OIIO;
@@ -78,6 +79,13 @@ std::ostream& operator<<(std::ostream& os, EImageFileType imageFileType);
  */
 std::istream& operator>>(std::istream& in, EImageFileType& imageFileType);
 
+/**
+ * @brief Check if input image extension is supported by openImageIO ie exists in extension_list from imageio.h
+ * @param[in] ext - image extension
+ * @return true if valid extension
+ */
+bool isSupported(const std::string &ext);
+
 /**
  * @brief convert a metadata string map into an oiio::ParamValueList
  * @param[in] metadataMap string map
@@ -117,6 +125,7 @@ void readImageMetadata(const std::string& path, int& width, int& height, std::ma
  */
 void getBufferFromImage(Image<float>& image, oiio::ImageBuf& buffer);
 void getBufferFromImage(Image<unsigned char>& image, oiio::ImageBuf& buffer);
+void getBufferFromImage(Image<RGBAfColor>& image, oiio::ImageBuf& buffer);
 void getBufferFromImage(Image<RGBAColor>& image, oiio::ImageBuf& buffer);
 void getBufferFromImage(Image<RGBfColor>& image, oiio::ImageBuf& buffer);
 void getBufferFromImage(Image<RGBColor>& image, oiio::ImageBuf& buffer);
@@ -129,6 +138,7 @@ void getBufferFromImage(Image<RGBColor>& image, oiio::ImageBuf& buffer);
  */
 void readImage(const std::string& path, Image<float>& image, EImageColorSpace imageColorSpace);
 void readImage(const std::string& path, Image<unsigned char>& image, EImageColorSpace imageColorSpace);
+void readImage(const std::string& path, Image<RGBAfColor>& image, EImageColorSpace imageColorSpace);
 void readImage(const std::string& path, Image<RGBAColor>& image, EImageColorSpace imageColorSpace);
 void readImage(const std::string& path, Image<RGBfColor>& image, EImageColorSpace imageColorSpace);
 void readImage(const std::string& path, Image<RGBColor>& image, EImageColorSpace imageColorSpace);
@@ -139,6 +149,7 @@ void readImage(const std::string& path, Image<RGBColor>& image, EImageColorSpace
  * @param[in] image The output image buffer
  */
 void writeImage(const std::string& path, const Image<unsigned char>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata = oiio::ParamValueList());
+void writeImage(const std::string& path, const Image<RGBAfColor>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata = oiio::ParamValueList());
 void writeImage(const std::string& path, const Image<RGBAColor>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata = oiio::ParamValueList());
 void writeImage(const std::string& path, const Image<RGBfColor>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata = oiio::ParamValueList());
 void writeImage(const std::string& path, const Image<RGBColor>& image, EImageColorSpace imageColorSpace, const oiio::ParamValueList& metadata = oiio::ParamValueList());

src/aliceVision/image/pixelTypes.hpp

@@ -21,8 +21,8 @@ namespace aliceVision
     template <typename T>
     class Rgb : public Eigen::Matrix<T, 3, 1, 0, 3, 1>
     {
-      typedef Eigen::Matrix<T, 3, 1, 0, 3, 1> Base;
-      typedef T TBase;
+      using Base = Eigen::Matrix<T, 3, 1, 0, 3, 1>;
+      using TBase = T;
     public:
 
       //------------------------------
@@ -177,17 +177,17 @@ namespace aliceVision
     };
 
     /// Instantiation for unsigned char color component
-    typedef Rgb<unsigned char> RGBColor;
+    using RGBColor = Rgb<unsigned char>;
     /// Instantiation for float color component
-    typedef Rgb<float> RGBfColor;
+    using RGBfColor = Rgb<float>;
 
     /**
     * @brief RGBA templated pixel type
     */
     template <typename T>
     class Rgba : public Eigen::Matrix<T, 4, 1, 0, 4, 1>
     {
-      typedef Eigen::Matrix<T, 4, 1, 0, 4, 1> Base;
+      using Base = Eigen::Matrix<T, 4, 1, 0, 4, 1>;
     public:
 
       //------------------------------
@@ -199,10 +199,9 @@ namespace aliceVision
       * @param blue component value
       * @param alpha component value
       */
-      inline Rgba( const T red, const T green, const T blue, const T alpha = static_cast<T>( 1 ) )
+      inline Rgba( const T red, const T green, const T blue, const T alpha = T(1) )
         : Base( red, green, blue, alpha )
       {
-
       }
 
       /**
@@ -212,29 +211,38 @@ namespace aliceVision
       explicit inline Rgba( const Base& val )
         : Base( val )
       {
-
       }
 
       /**
-      * @brief RGB constructor with default alpha value
+      * @brief RGBA constructor with default alpha value to 1
       * @param val Value to set in each RGB component
       * @note This is equivalent to RGBA( val , val , val , 1 )
       */
-      explicit inline Rgba( const T val = 0 )
-        : Base( val, val, val, static_cast<T>( 1 ) )
+      explicit inline Rgba( const T val )
+        : Base( val, val, val, T(1) )
       {
+      }
 
+      /**
+       * @brief Default RGBA constructor set all channels to zero (including the alpha channel)
+       * @warning The alpha channel is initialized to 0.
+       *          It is used in generic/templated code like "sampler"
+       *          which creates an empty color and accumulate color contributions.
+       */
+      explicit inline Rgba()
+        : Base( T(0), T(0), T(0), T(0) )
+      {
       }
 
       /**
       * @brief Copy constructor
       * @param val Source RGBA value
       */
-      inline Rgba( const RGBColor & val )
-        : Base( val.r(), val.g(), val.b(), static_cast<T>( 1 ) )
+      inline Rgba( const RGBColor & val, const T alpha = 1 )
+        : Base( val.r(), val.g(), val.b(), alpha )
       {
-
       }
+
       //-- construction method
       //------------------------------
 
@@ -362,7 +370,11 @@ namespace aliceVision
                      T( ( Z )( *this )( 3 ) * val ) );
       }
     };
-    typedef Rgba<unsigned char> RGBAColor;
+
+    /// Instantiation for unsigned char color component
+    using RGBAColor = Rgba<unsigned char>;
+    /// Instantiation for float color component
+    using RGBAfColor = Rgba<float>;
 
     const RGBColor WHITE( 255, 255, 255 );
     const RGBColor BLACK( 0, 0, 0 );

src/aliceVision/sfm/CMakeLists.txt

@@ -14,6 +14,7 @@ set(sfm_files_headers
   pipeline/pairwiseMatchesIO.hpp
   pipeline/RelativePoseInfo.hpp
   pipeline/structureFromKnownPoses/StructureEstimationFromKnownPoses.hpp
+	pipeline/panorama/ReconstructionEngine_panorama.hpp
   pipeline/regionsIO.hpp
   utils/alignment.hpp
   utils/statistics.hpp
@@ -41,6 +42,7 @@ set(sfm_files_sources
   pipeline/RigSequence.cpp
   pipeline/RelativePoseInfo.cpp
   pipeline/structureFromKnownPoses/StructureEstimationFromKnownPoses.cpp
+	pipeline/panorama/ReconstructionEngine_panorama.cpp
   pipeline/regionsIO.cpp
   utils/alignment.cpp
   utils/statistics.cpp

src/aliceVision/sfm/pipeline/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_subdirectory(sequential)
 add_subdirectory(global)
+add_subdirectory(panorama)
 

src/aliceVision/sfm/pipeline/RelativePoseInfo.cpp

@@ -102,16 +102,22 @@ bool robustRelativePose(
     max_iteration_count, &relativePose_info.essential_matrix, relativePose_info.initial_residual_tolerance);
   relativePose_info.found_residual_precision = acRansacOut.first;
 
-  if (relativePose_info.vec_inliers.size() < SolverType::MINIMUM_SAMPLES * ALICEVISION_MINIMUM_SAMPLES_COEF )  
+  if (relativePose_info.vec_inliers.size() < SolverType::MINIMUM_SAMPLES * ALICEVISION_MINIMUM_SAMPLES_COEF )
+  {
+    ALICEVISION_LOG_INFO("robustRelativePose: no sufficient coverage (the model does not support enough samples): " << relativePose_info.vec_inliers.size());
     return false; // no sufficient coverage (the model does not support enough samples)
+  }
 
   // estimation of the relative poses
   Mat3 R;
   Vec3 t;
   if (!estimate_Rt_fromE(
     K1, K2, x1, x2,
     relativePose_info.essential_matrix, relativePose_info.vec_inliers, &R, &t))
+  {
+    ALICEVISION_LOG_INFO("robustRelativePose: cannot find a valid [R|t] couple that makes the inliers in front of the camera.");
     return false; // cannot find a valid [R|t] couple that makes the inliers in front of the camera.
+  }
 
   // Store [R|C] for the second camera, since the first camera is [Id|0]
   relativePose_info.relativePose = geometry::Pose3(R, -R.transpose() * t);

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

@@ -27,12 +27,15 @@ bool GlobalSfMRotationAveragingSolver::Run(
   ERotationAveragingMethod eRotationAveragingMethod,
   ERelativeRotationInferenceMethod eRelativeRotationInferenceMethod,
   const RelativeRotations& relativeRot_In,
+  const double max_angular_error,
   HashMap<IndexT, Mat3>& map_globalR
 ) const
 {
   RelativeRotations relativeRotations = relativeRot_In;
   // We work on a copy, since inference can remove some relative motions
 
+  ALICEVISION_LOG_DEBUG("GlobalSfMRotationAveragingSolver: A) relativeRotations.size(): " << relativeRotations.size());
+
   //-> Test there is only one graph and at least 3 camera?
   switch(eRelativeRotationInferenceMethod)
   {
@@ -42,9 +45,13 @@ bool GlobalSfMRotationAveragingSolver::Run(
       // Triplet inference (test over the composition error)
       //-------------------
       PairSet pairs = getPairs(relativeRotations);
+      ALICEVISION_LOG_DEBUG("GlobalSfMRotationAveragingSolver: pairs.size(): " << pairs.size());
+
       std::vector< graph::Triplet > vec_triplets = graph::tripletListing(pairs);
-      //-- Rejection triplet that are 'not' identity rotation (error to identity > 5°)
-      TripletRotationRejection(5.0f, vec_triplets, relativeRotations);
+      ALICEVISION_LOG_DEBUG("GlobalSfMRotationAveragingSolver: vec_triplets.size(): " << vec_triplets.size());
+
+      //-- Rejection triplet that are 'not' identity rotation (error to identity > max_angular_error)
+      TripletRotationRejection(max_angular_error, vec_triplets, relativeRotations);
 
       pairs = getPairs(relativeRotations);
       const std::set<IndexT> set_remainingIds = graph::CleanGraph_KeepLargestBiEdge_Nodes<PairSet, IndexT>(pairs);
@@ -75,6 +82,9 @@ bool GlobalSfMRotationAveragingSolver::Run(
   //- B. solve global rotation computation
   bool bSuccess = false;
   std::vector<Mat3> vec_globalR(_reindexForward.size());
+
+  ALICEVISION_LOG_DEBUG("GlobalSfMRotationAveragingSolver: B) vec_globalR.size(): " << vec_globalR.size());
+
   switch(eRotationAveragingMethod)
   {
     case ROTATION_AVERAGING_L2:
@@ -84,11 +94,16 @@ bool GlobalSfMRotationAveragingSolver::Run(
         _reindexForward.size(),
         relativeRotations,
         vec_globalR);
+
+      ALICEVISION_LOG_DEBUG("rotationAveraging::l2::L2RotationAveraging: success: " << bSuccess);
       //- Non linear refinement of the global rotations
       if (bSuccess)
+      {
         bSuccess = rotationAveraging::l2::L2RotationAveraging_Refine(
           relativeRotations,
           vec_globalR);
+        ALICEVISION_LOG_DEBUG("rotationAveraging::l2::L2RotationAveraging_Refine: success: " << bSuccess);
+      }
 
       // save kept pairs (restore original pose indices using the backward reindexing)
       for(RelativeRotations::iterator iter = relativeRotations.begin();  iter != relativeRotations.end(); ++iter)
@@ -110,6 +125,7 @@ bool GlobalSfMRotationAveragingSolver::Run(
       bSuccess = rotationAveraging::l1::GlobalRotationsRobust(
         relativeRotations, vec_globalR, nMainViewID, 0.0f, &vec_inliers);
 
+      ALICEVISION_LOG_DEBUG("rotationAveraging::l1::GlobalRotationsRobust: success: " << bSuccess);
       ALICEVISION_LOG_DEBUG("inliers: " << vec_inliers);
 
       // save kept pairs (restore original pose indices using the backward reindexing)
@@ -170,6 +186,8 @@ void GlobalSfMRotationAveragingSolver::TripletRotationRejection(
     const graph::Triplet & triplet = vec_triplets[i];
     const IndexT I = triplet.i, J = triplet.j , K = triplet.k;
 
+    ALICEVISION_LOG_DEBUG("GlobalSfMRotationAveragingSolver::TripletRotationRejection: i: " << i << ", (" << I << ", " << J << ", " << K << ").");
+
     //-- Find the three relative rotations
     const Pair ij(I,J), ji(J,I);
     const Mat3 RIJ = (map_relatives.count(ij)) ?
@@ -206,6 +224,10 @@ void GlobalSfMRotationAveragingSolver::TripletRotationRejection(
       else
         map_relatives_validated[ik] = map_relatives.at(ik);
     }
+    else
+    {
+      ALICEVISION_LOG_DEBUG("GlobalSfMRotationAveragingSolver::TripletRotationRejection: i: " << i << ", angularErrorDegree: " << angularErrorDegree << ", max_angular_error: " << max_angular_error);
+    }
   }
   map_relatives = std::move(map_relatives_validated);