Update exportImages to handle potential large scale changes

Author: Fabien Servant

src/aliceVision/camera/IntrinsicScaleOffsetDisto.cpp

@@ -15,6 +15,11 @@ std::shared_ptr<IntrinsicScaleOffsetDisto> IntrinsicScaleOffsetDisto::cast(std::
 }
 
 bool IntrinsicScaleOffsetDisto::operator==(const IntrinsicBase& otherBase) const
+{
+    return equalTo(otherBase, false);
+}
+
+bool IntrinsicScaleOffsetDisto::equalTo(const IntrinsicBase& otherBase, bool ignoreDistortion) const
 {
     if (!IntrinsicScaleOffset::operator==(otherBase))
     {
@@ -26,6 +31,11 @@ bool IntrinsicScaleOffsetDisto::operator==(const IntrinsicBase& otherBase) const
         return false;
     }
 
+    if (ignoreDistortion)
+    {
+        return true;
+    }
+
     const IntrinsicScaleOffsetDisto& other = static_cast<const IntrinsicScaleOffsetDisto&>(otherBase);
 
     if (_distortionInitializationMode != other._distortionInitializationMode)

src/aliceVision/camera/IntrinsicScaleOffsetDisto.hpp

@@ -63,8 +63,21 @@ class IntrinsicScaleOffsetDisto : public IntrinsicScaleOffset
 
     void assign(const IntrinsicBase& other) override { *this = dynamic_cast<const IntrinsicScaleOffsetDisto&>(other); }
 
+    /**
+    * @brief compare to another intrinsic object
+    * @param otherBase an intrinsic object to compare to.
+    * @return true if both objects are considered equal
+    */
     bool operator==(const IntrinsicBase& otherBase) const override;
 
+    /**
+    * @brief compare to another intrinsic object
+    * @param otherBase an intrinsic object to compare to.
+    * @param ignoreDistortion ignore difference in distortion.
+    * @return true if both objects are considered equal
+    */
+    bool equalTo(const IntrinsicBase& otherBase, bool ignoreDistortion) const;
+
     void setDistortionObject(std::shared_ptr<Distortion> object) { _pDistortion = object; }
 
     bool hasDistortion() const override { return _pDistortion != nullptr || _pUndistortion != nullptr; }

src/software/utils/main_exportImages.cpp

@@ -12,6 +12,8 @@
 #include <aliceVision/image/Image.hpp>
 #include <aliceVision/image/io.hpp>
 #include <aliceVision/image/Sampler.hpp>
+#include <aliceVision/image/remap.hpp>
+#include <aliceVision/camera/IntrinsicScaleOffsetDisto.hpp>
 #include <boost/program_options.hpp>
 
 // These constants define the current software version.
@@ -96,8 +98,7 @@ void ImageIntrinsicsTransform(const image::Image<T>& imageIn,
         yOffset = roi.ybegin;
     }
 
-    image_ud.resize(widthRoi, heightRoi, true, fillcolor);
-    const image::Sampler2d<image::SamplerLinear> sampler;
+    image::Image<Vec2> map(widthRoi, heightRoi);
 
 #pragma omp parallel for
     for (int y = 0; y < heightRoi; ++y)
@@ -108,15 +109,41 @@ void ImageIntrinsicsTransform(const image::Image<T>& imageIn,
 
             // compute coordinates with distortion
             const Vec3 intermediate = intrinsicOutput.backProjectUnit(undisto_pix);
-            const Vec2 disto_pix = intrinsicSource.project(intermediate.homogeneous(), true);
+            map(y, x) = intrinsicSource.project(intermediate.homogeneous(), true);
+        }
+    }
 
-            // pick pixel if it is in the image domain
-            if (imageIn.contains(disto_pix(1), disto_pix(0)))
-            {
-                image_ud(y, x) = sampler(imageIn, disto_pix(1), disto_pix(0));
-            }
+    remapInter(imageIn, map, fillcolor, image_ud);
+}
+
+bool isFullComputeNeeded(const camera::IntrinsicBase & source, const camera::IntrinsicBase & dest)
+{
+    // Is the output undistorted
+    if (dest.hasDistortion())
+    {
+        return true;
+    }
+    
+    // Do we need to cast to a different intrinsic type ?
+    if (source.getType() != dest.getType())
+    {
+        return true;
+    }
+
+    // Are the "non distortion" parameters equal ?
+    try
+    {
+        const auto& isod = dynamic_cast<const camera::IntrinsicScaleOffsetDisto&>(source);
+        if (!isod.equalTo(dest, true))
+        {
+            return true;
         }
     }
+    catch (const std::bad_cast& e)
+    {
+    }
+                
+    return false;
 }
 
 template<typename T>
@@ -260,17 +287,18 @@ bool processImage(const std::string& dstFileName,
         roi = convertRodToRoi(outputIntrinsic, rod);
     }
 
-    bool shortCut = (sourceIntrinsic.getType() == outputIntrinsic.getType()) &&
-                    (outputIntrinsic.hasDistortion() == false);
-    if (shortCut)
+    // Guess if we can accelerate stuff
+    if (isFullComputeNeeded(sourceIntrinsic, outputIntrinsic))
     {
-        // undistort the image and save it
-        ImageRemoveDistortion(image, sourceIntrinsic, outputIntrinsic, image_ud, image::RGBAfColor(0.0), rod);
+        // Transform the image and save it
+        ALICEVISION_LOG_INFO("Using full complex transform.");
+        ImageIntrinsicsTransform(image, sourceIntrinsic, outputIntrinsic, image_ud, image::RGBAfColor(0.0), rod);
     }
     else 
     {
-        // Transform the image and save it
-        ImageIntrinsicsTransform(image, sourceIntrinsic, outputIntrinsic, image_ud, image::RGBAfColor(0.0), rod);
+        // undistort the image and save it
+        ALICEVISION_LOG_INFO("Using Simplified undistortion transform.");
+        ImageRemoveDistortion(image, sourceIntrinsic, outputIntrinsic, image_ud, image::RGBAfColor(0.0), rod);
     }
 
     //Write the result