[mesh] Texturing: Multi-band blending

src/aliceVision/mesh/CMakeLists.txt

@@ -7,7 +7,6 @@ set(mesh_files_headers
   MeshEnergyOpt.hpp
   meshPostProcessing.hpp
   meshVisibility.hpp
-  MultiBandBlending.hpp
   Texturing.hpp
   UVAtlas.hpp
 )
@@ -20,7 +19,6 @@ set(mesh_files_sources
   MeshEnergyOpt.cpp
   meshPostProcessing.cpp
   meshVisibility.cpp
-  MultiBandBlending.cpp
   Texturing.cpp
   UVAtlas.cpp
 )

src/aliceVision/mesh/Texturing.cpp

@@ -14,8 +14,8 @@
 #include <aliceVision/mvsData/Color.hpp>
 #include <aliceVision/mvsData/geometry.hpp>
 #include <aliceVision/mvsData/Pixel.hpp>
+#include <aliceVision/mvsData/Image.hpp>
 #include <aliceVision/imageIO/image.hpp>
-#include <aliceVision/mesh/MultiBandBlending.hpp>
 
 #include <geogram/basic/common.h>
 #include <geogram/basic/geometry_nd.h>
@@ -488,9 +488,8 @@ void Texturing::generateTexturesSubSet(const mvsUtils::MultiViewParams& mp,
         Image camImg(imgPtr->data, imgPtr->getWidth(), imgPtr->getHeight());
 
         //Calculate laplacianPyramid
-        MultiBandBlending multiBandBlending;
         std::vector<Image> pyramidL; //laplacian pyramid
-        multiBandBlending.laplacianDownscalePyramid(pyramidL, camImg, texParams.nbBand, texParams.multiBandDownscale);
+        camImg.laplacianPyramid(pyramidL, texParams.nbBand, texParams.multiBandDownscale);
 
         // for each output texture file
         for(const auto& c : cameraContributions)

src/aliceVision/mvsData/CMakeLists.txt

@@ -24,6 +24,7 @@ set(mvsData_files_headers
 # Sources
 set(mvsData_files_sources
   jetColorMap.cpp
+  Image.cpp
   imageIO.cpp
   geometry.cpp
   geometryTriTri.cpp
@@ -39,7 +40,9 @@ alicevision_add_library(aliceVision_mvsData
     aliceVision_system
     ${ZLIB_LIBRARIES}
     ${Boost_FILESYSTEM_LIBRARY}
+    ${OPENIMAGEIO_LIBRARIES}
   PUBLIC_INCLUDE_DIRS
     ${ZLIB_INCLUDE_DIR}
     ${Boost_INCLUDE_DIR}
+    ${OPENIMAGEIO_INCLUDE_DIRS}
 )

src/aliceVision/mvsData/Image.cpp

@@ -0,0 +1,87 @@
+// This file is part of the AliceVision project.
+// Copyright (c) 2019 AliceVision contributors.
+// This Source Code Form is subject to the terms of the Mozilla Public License,
+// v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at https://mozilla.org/MPL/2.0/.
+
+#include "Image.hpp"
+
+#include <aliceVision/imageIO/image.hpp>
+
+
+namespace aliceVision{
+
+
+void Image::imageDiff(Image& inImgDownscaled, Image& outImg, unsigned int downscale)
+{
+    outImg.resize(_width, _height);
+    for(int i = 0; i < _width*_height; ++i)
+    {
+        Point2d pix(i%_width, static_cast<int>(i/_width));
+        Point2d pixd = pix/downscale;
+
+        outImg._img[i] = _img[i] - inImgDownscaled.getInterpolateColor(pixd);
+    }
+
+}
+
+void Image::laplacianPyramid(std::vector<Image>& out_pyramidL, int nbBand, unsigned int downscale)
+{
+    assert(nbBand >= 1);
+
+    Image img(*this);
+    int outW = static_cast<int>(img.width()/downscale);
+    int outH = static_cast<int>(img.height()/downscale);
+
+    Image imgDownscaled(outW, outH);
+    out_pyramidL.resize(nbBand);
+
+    //Create Laplacian pyramid
+    for(int b = 0; b < nbBand-1; ++b)
+    {
+        imageIO::resizeImage(img.width(), img.height(), static_cast<int>(downscale), img.data(), imgDownscaled.data(), "gaussian");
+        img.imageDiff(imgDownscaled, out_pyramidL[b], downscale);
+        img.swap(imgDownscaled);
+
+        outW = static_cast<int>(outW/downscale);
+        outH = static_cast<int>(outH/downscale);
+        imgDownscaled.resize(outW, outH);
+
+    }
+    out_pyramidL[nbBand-1] = img;
+
+    for(std::size_t i = 0; i < out_pyramidL.size(); ++i)
+        ALICEVISION_LOG_DEBUG("laplacianDownscalePyramid: Size level " << i << " : " << out_pyramidL[i].width() << "x" << out_pyramidL[i].height());
+}
+
+Color Image::getInterpolateColor(const Point2d& pix) const
+{
+    const int xp = std::min(static_cast<int>(pix.x), _width-2);
+    const int yp = std::min(static_cast<int>(pix.y), _height-2);
+
+    // precision to 4 decimal places
+    const float ui = pix.x - static_cast<float>(xp);
+    const float vi = pix.y - static_cast<float>(yp);
+
+    const Color lu = _img.at( yp * _width + xp   );
+    const Color ru = _img.at( yp * _width + (xp+1) );
+    const Color rd = _img.at( (yp+1) * _width + (xp+1) );
+    const Color ld = _img.at( (yp+1) * _width + xp );
+
+    // bilinear interpolation of the pixel intensity value
+    const Color u = lu + (ru - lu) * ui;
+    const Color d = ld + (rd - ld) * ui;
+    const Color out = u + (d - u) * vi;
+    return out;
+}
+
+Color Image::getNearestPixelColor(const Point2d& pix) const
+{
+    const int xp = std::min(static_cast<int>(pix.x), _width-1);
+    const int yp = std::min(static_cast<int>(pix.y), _height-1);
+    const Color lu = _img.at( yp * _width + xp   );
+    return lu;
+}
+
+
+}

src/aliceVision/mvsData/Image.hpp

@@ -8,7 +8,6 @@
 
 #include <aliceVision/mvsData/Color.hpp>
 #include <aliceVision/mvsData/StaticVector.hpp>
-#include <aliceVision/mvsUtils/ImagesCache.hpp>
 #include <aliceVision/mvsData/Point2d.hpp>
 
 #include <algorithm>
@@ -19,15 +18,11 @@ class Image
 {
 private:
     std::vector<Color> _img;
-    int _width = 0;
-    int _height = 0;
+    int _width{0};
+    int _height{0};
 
 public:
-    Image()
-    {
-        _width = 0;
-        _height = 0;
-    }
+    Image() = default;
 
     Image(int width, int height)
         : _width(width)
@@ -36,12 +31,8 @@ class Image
         _img.resize(width*height);
     }
 
-    Image(Color* data, int  width, int  height)
+    Image(Color* data, int  width, int  height) : Image(width, height)
     {
-        _width = width;
-        _height = height;
-        _img.resize(_width * _height);
-
         for(int i = 0; i < _width*_height; ++i)
             _img[i] = data[i];
     }
@@ -80,35 +71,6 @@ class Image
         return *this;
     }
 
-    //outImg = inImga - inImgb
-    static void imageDiff(const Image& inImga, const Image& inImgb, Image& outImg)
-    {
-        if(inImga._width != inImgb._width || inImga._height != inImgb._height)
-            throw std::runtime_error("Incompatible image sizes");
-
-        outImg.resize(inImga._width, inImga._height);
-        for(int i = 0; i < inImga._width*inImga._height; ++i)
-        {
-            outImg._img[i] = inImga._img.at(i) - inImgb._img.at(i);
-        }
-    }
-
-    static void imageDownscaleDiff(Image& inImga, Image& inImgb, Image& outImg, unsigned int downscale)
-    {
-        //inImga = largest image
-        if(inImga.height() < inImgb.height())
-            inImga.swap(inImgb);
-
-        outImg.resize(inImga._width, inImga._height);
-        for(int i = 0; i < inImga._width*inImga._height; ++i)
-        {
-            Point2d pix(i%inImga.width(), static_cast<int>(i/inImga.width()));
-            Point2d pixd = pix/downscale;
-
-            outImg._img[i] = inImga._img[i] - inImgb.getInterpolateColor(pixd);
-        }
-
-    }
 
     int width() const { return _width; }
     int height() const { return _height; }
@@ -119,38 +81,27 @@ class Image
     const Color& operator[](std::size_t index) const { return _img[index]; }
     Color& operator[](std::size_t index) { return _img[index]; }
 
-    Color getInterpolateColor(const Point2d& pix) const
-    {
-        const int xp = std::min(static_cast<int>(pix.x), _width-2);
-        const int yp = std::min(static_cast<int>(pix.y), _height-2);
-
-        // precision to 4 decimal places
-        const float ui = pix.x - static_cast<float>(xp);
-        const float vi = pix.y - static_cast<float>(yp);
-
-        const Color lu = _img.at( yp * _width + xp   );
-        const Color ru = _img.at( yp * _width + (xp+1) );
-        const Color rd = _img.at( (yp+1) * _width + (xp+1) );
-        const Color ld = _img.at( (yp+1) * _width + xp );
-
-        // bilinear interpolation of the pixel intensity value
-        const Color u = lu + (ru - lu) * ui;
-        const Color d = ld + (rd - ld) * ui;
-        const Color out = u + (d - u) * vi;
-        return out;
-    }
-
-    Color getNearestPixelColor(const Point2d& pix) const
-    {
-        const int xp = std::min(static_cast<int>(pix.x), _width-1);
-        const int yp = std::min(static_cast<int>(pix.y), _height-1);
-        const Color lu = _img.at( yp * _width + xp   );
-        return lu;
-    }
-};
+    Color getInterpolateColor(const Point2d& pix) const;
+    Color getNearestPixelColor(const Point2d& pix) const;
 
+    /**
+     * @brief Calculate the difference between images of different sizes
+     * @param [inImgDownscaled] the smaller image
+     * @param [outImg] the difference
+     * @param [downscale] the downscale coefficient between image sizes
+     */
+    void imageDiff(Image& inImgDownscaled, Image& outImg, unsigned int downscale);
 
-}
+    /**
+    * @brief Calculate the laplacian pyramid of a given image,
+    *        ie. its decomposition in frequency bands
+    * @param [out_pyramidL] the laplacian pyramid
+    * @param [nbBand] the number of frequency bands
+    * @param [downscale] the downscale coefficient between floors of the pyramid
+    */
+    void laplacianPyramid(std::vector<Image>& out_pyramidL, int nbBand, unsigned int downscale);
 
 
+};
 
+}

src/samples/CMakeLists.txt

@@ -10,7 +10,6 @@ add_subdirectory(featuresRepeatability)
 # add_subdirectory(imageData)
 add_subdirectory(imageDescriberMatches)
 add_subdirectory(kvldFilter)
-add_subdirectory(multiBandBlending)
 add_subdirectory(robustEssential)
 add_subdirectory(robustEssentialBA)
 add_subdirectory(robustEssentialSpherical)