New LDR2HDR software

src/aliceVision/hdr/DebevecCalibrate.cpp

@@ -53,7 +53,7 @@ void DebevecCalibrate::process(const std::vector< std::vector< image::Image<imag
       std::vector<T> tripletList;
       tripletList.reserve(2 * nbPoints*nbImages + 1 + 3 * channelQuantization);
 
-      std::cout << "filling A and b matrices" << std::endl;
+//      std::cout << "filling A and b matrices" << std::endl;
 
       // include the data-fitting equations
       for(unsigned int j=0; j<nbImages; ++j)
@@ -101,10 +101,10 @@ void DebevecCalibrate::process(const std::vector< std::vector< image::Image<imag
       Vec x = solver.solve(b);
       if(solver.info() != Eigen::Success)  return; // solving failed
 
-      std::cout << "system solved" << std::endl;
+//      std::cout << "system solved" << std::endl;
 
-      double relative_error = (A*x - b).norm() / b.norm();
-      std::cout << "relative error is : " << relative_error << std::endl;
+//      double relative_error = (A*x - b).norm() / b.norm();
+//      std::cout << "relative error is : " << relative_error << std::endl;
 
       for(std::size_t k=0; k<channelQuantization; ++k)
         response.setValue(k, channel, x(k));

src/aliceVision/hdr/GrossbergCalibrate.cpp

@@ -70,7 +70,7 @@ void GrossbergCalibrate::process(const std::vector< std::vector< image::Image<im
             Mat A = Mat::Zero(nbPoints*(nbImages-1), _dimension);
             Vec b = Vec::Zero(nbPoints*(nbImages-1));
 
-            std::cout << "filling A and b matrices" << std::endl;
+//            std::cout << "filling A and b matrices" << std::endl;
 
             for(unsigned int j=0; j<nbImages-1; ++j)
             {
@@ -107,24 +107,24 @@ void GrossbergCalibrate::process(const std::vector< std::vector< image::Image<im
                 }
             }
 
-            std::cout << "solving Ax=b system" << std::endl;
+//            std::cout << "solving Ax=b system" << std::endl;
 
             // solve the system using QR decomposition
             Eigen::HouseholderQR<Mat> solver(A);
             Vec c = solver.solve(b);
 
-            std::cout << "system solved" << std::endl;
+//            std::cout << "system solved" << std::endl;
 
-            double relative_error = (A*c - b).norm() / b.norm();
-            std::cout << "relative error is : " << relative_error << std::endl;
+//            double relative_error = (A*c - b).norm() / b.norm();
+//            std::cout << "relative error is : " << relative_error << std::endl;
 
             for(unsigned int i=0; i<_dimension; ++i)
             {
               std::vector<double> temp_hCurve = hCurves[i];
               for(auto &value : temp_hCurve)
                 value *= c(i);
 
-              std::cout << c(i) << std::endl;
+//              std::cout << c(i) << std::endl;
 
               std::transform(response.getCurve(channel).begin(), response.getCurve(channel).end(), temp_hCurve.begin(), response.getCurve(channel).begin(), std::plus<float>());
             }

src/aliceVision/hdr/RobertsonCalibrate.cpp

@@ -86,21 +86,21 @@ void RobertsonCalibrate::process(const std::vector< std::vector< image::Image<im
 
   for(std::size_t iter = 0; iter < _maxIteration; ++iter)
   {
-    std::cout << "--> iteration : "<< iter << std::endl;
+//    std::cout << "--> iteration : "<< iter << std::endl;
 
-    std::cout << "1) compute radiance "<< std::endl;
+//    std::cout << "1) compute radiance "<< std::endl;
     //initialize radiance
     for(std::size_t g = 0; g < ldrImageGroups.size(); ++g)
     {
       merge.process(ldrImageGroups[g], times[g], weight, response, _radiance[g], targetTime, threshold, true);
     }
 
-    std::cout << "2) initialization new response "<< std::endl;
+//    std::cout << "2) initialization new response "<< std::endl;
     //initialize new response
     rgbCurve newResponse = rgbCurve(channelQuantization);
     newResponse.setZero();
 
-    std::cout << "3) compute new response "<< std::endl;
+//    std::cout << "3) compute new response "<< std::endl;
     //compute new response
     for(unsigned int g = 0; g < ldrImageGroups.size(); ++g)
     {
@@ -133,11 +133,11 @@ void RobertsonCalibrate::process(const std::vector< std::vector< image::Image<im
     //dividing the response by the cardinal curve
     newResponse *= card;
 
-    std::cout << "4) normalize response"<< std::endl;
+//    std::cout << "4) normalize response"<< std::endl;
     //normalization
     newResponse.normalize();
 
-    std::cout << "5) compute difference"<< std::endl;
+//    std::cout << "5) compute difference"<< std::endl;
     //calculate difference between the old response and the new one
     rgbCurve responseDiff = newResponse - response;
     responseDiff.setAllAbsolute();
@@ -147,14 +147,14 @@ void RobertsonCalibrate::process(const std::vector< std::vector< image::Image<im
     //update the response
     response = newResponse;
 
-    std::cout << "6) check end condition"<< std::endl;
+//    std::cout << "6) check end condition"<< std::endl;
     //check end condition
     if(diff < _threshold)
     {
         std::cout << "[BREAK] difference < threshold " << std::endl;
         break;
     }
-    std::cout << "-> difference is " << diff << std::endl;
+//    std::cout << "-> difference is " << diff << std::endl;
   }
 }
 

src/aliceVision/hdr/hdrMerge.cpp

@@ -25,8 +25,6 @@ void hdrMerge::process(const std::vector< image::Image<image::RGBfColor> > &imag
                               const float threshold,
                               bool robCalibrate)
 {
-  std::cout << "hdr merge" << std::endl;
-
   //checks
   assert(!response.isEmpty());
   assert(!images.empty());

src/aliceVision/hdr/rgbCurve.cpp

@@ -171,7 +171,7 @@ void rgbCurve::normalize()
             midValue = curve[middle];
         }
 
-        std::cout << "-> middle [" << middle << "]: " << midValue <<std::endl;
+//        std::cout << "-> middle [" << middle << "]: " << midValue <<std::endl;
         const float coefficient = 1 / midValue;
 
         for(auto &value : curve)

src/aliceVision/hdr/rgbCurve.hpp

@@ -99,6 +99,13 @@ class rgbCurve
    */
   rgbCurve(const std::string &path);
 
+  void resize(std::size_t newSize)
+  {
+    for(auto &curve : _data)
+      curve.resize(newSize);
+    assert(getSize() == newSize);
+  }
+
   /**
    * @brief set curves to zero
    */