學習OpenCV——Laplacian圖像融合

網上看到一個很有意思的利用opencv實現圖像融合的方法：

1.設計一個mask（一半全1，一半全0），並計算level層的gaussion_mask[i]；

2.計算兩幅圖像每一層的Laplacian[i]，並與gaussion_mask[i]相乘，合成一幅result_lapacian[i]；

3.對兩幅圖像不斷求prydown，並把最高層保存在gaussion[i],與gaussion_mask[i]相乘，合成一幅result_gaussion;

4,對result_gaussion不斷求pryup，每一層都與result_lapacian[i]合成，最後得到原圖像大小的融合圖像。

#include "opencv2/opencv.hpp"
using namespace cv;

/************************************************************************/
/* 說明：
*金字塔從下到上依次爲 [0,1，...，level-1] 層
*blendMask 爲圖像的掩模
*maskGaussianPyramid爲金字塔每一層的掩模
*resultLapPyr 存放每層金字塔中直接用左右兩圖Laplacian變換拼成的圖像
*/
/************************************************************************/


class LaplacianBlending {
private:
    Mat_<Vec3f> left;
    Mat_<Vec3f> right;
    Mat_<float> blendMask;

    vector<Mat_<Vec3f> > leftLapPyr,rightLapPyr,resultLapPyr;//Laplacian Pyramids
    Mat leftHighestLevel, rightHighestLevel, resultHighestLevel;
    vector<Mat_<Vec3f> > maskGaussianPyramid; //masks are 3-channels for easier multiplication with RGB

    int levels;

    void buildPyramids() {
        buildLaplacianPyramid(left,leftLapPyr,leftHighestLevel);
        buildLaplacianPyramid(right,rightLapPyr,rightHighestLevel);
        buildGaussianPyramid();
    }

    void buildGaussianPyramid() {//金字塔內容爲每一層的掩模
        assert(leftLapPyr.size()>0);

        maskGaussianPyramid.clear();
        Mat currentImg;
        cvtColor(blendMask, currentImg, CV_GRAY2BGR);//store color img of blend mask into maskGaussianPyramid
        maskGaussianPyramid.push_back(currentImg); //0-level

        currentImg = blendMask;
        for (int l=1; l<levels+1; l++) {
            Mat _down;
            if (leftLapPyr.size() > l)
                pyrDown(currentImg, _down, leftLapPyr[l].size());
            else
                pyrDown(currentImg, _down, leftHighestLevel.size()); //lowest level

            Mat down;
            cvtColor(_down, down, CV_GRAY2BGR);
            maskGaussianPyramid.push_back(down);//add color blend mask into mask Pyramid
            currentImg = _down;
        }
    }

    void buildLaplacianPyramid(const Mat& img, vector<Mat_<Vec3f> >& lapPyr, Mat& HighestLevel) {
        lapPyr.clear();
        Mat currentImg = img;
        for (int l=0; l<levels; l++) {
            Mat down,up;
            pyrDown(currentImg, down);
            pyrUp(down, up,currentImg.size());
            Mat lap = currentImg - up;
            lapPyr.push_back(lap);
            currentImg = down;
        }
        currentImg.copyTo(HighestLevel);
    }

    Mat_<Vec3f> reconstructImgFromLapPyramid() {
        //將左右laplacian圖像拼成的resultLapPyr金字塔中每一層
        //從上到下插值放大並相加，即得blend圖像結果
        Mat currentImg = resultHighestLevel;
        for (int l=levels-1; l>=0; l--) {
            Mat up;

            pyrUp(currentImg, up, resultLapPyr[l].size());
            currentImg = up + resultLapPyr[l];
        }
        return currentImg;
    }

    void blendLapPyrs() {
        //獲得每層金字塔中直接用左右兩圖Laplacian變換拼成的圖像resultLapPyr
        resultHighestLevel = leftHighestLevel.mul(maskGaussianPyramid.back()) +
            rightHighestLevel.mul(Scalar(1.0,1.0,1.0) - maskGaussianPyramid.back());
        for (int l=0; l<levels; l++) {
            Mat A = leftLapPyr[l].mul(maskGaussianPyramid[l]);
            Mat antiMask = Scalar(1.0,1.0,1.0) - maskGaussianPyramid[l];
            Mat B = rightLapPyr[l].mul(antiMask);
            Mat_<Vec3f> blendedLevel = A + B;

            resultLapPyr.push_back(blendedLevel);
        }
    }

public:
    LaplacianBlending(const Mat_<Vec3f>& _left, const Mat_<Vec3f>& _right, const Mat_<float>& _blendMask, int _levels)://construct function, used in LaplacianBlending lb(l,r,m,4);
      left(_left),right(_right),blendMask(_blendMask),levels(_levels)
      {
          assert(_left.size() == _right.size());
          assert(_left.size() == _blendMask.size());
          buildPyramids();  //construct Laplacian Pyramid and Gaussian Pyramid
          blendLapPyrs();   //blend left & right Pyramids into one Pyramid
      };

      Mat_<Vec3f> blend() {
          return reconstructImgFromLapPyramid();//reconstruct Image from Laplacian Pyramid
      }
};

Mat_<Vec3f> LaplacianBlend(const Mat_<Vec3f>& l, const Mat_<Vec3f>& r, const Mat_<float>& m) {
    LaplacianBlending lb(l,r,m,4);
    return lb.blend();
}

int main() {
    Mat l8u = imread("left.png");
    Mat r8u = imread("right.png");

    imshow("left",l8u);
    imshow("right",r8u);

    Mat_<Vec3f> l; l8u.convertTo(l,CV_32F,1.0/255.0);//Vec3f表示有三個通道，即 l[row][column][depth]
    Mat_<Vec3f> r; r8u.convertTo(r,CV_32F,1.0/255.0);
    /*****************    void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;******************/
    /* Performs linear transformation on every source array element:
    dst(x,y,c) = scale*src(x,y,alpha)+beta.
    Arbitrary combination of input and output array depths are allowed
    (number of channels must be the same), thus the function can be used
    for type conversion */

    //create blend mask matrix m
    Mat_<float> m(l.rows,l.cols,0.0);                 //將m全部賦值爲0
    m(Range::all(),Range(0,m.cols/2)) = 1.0;    //取m全部行&[0,m.cols/2]列，賦值爲1.0

    Mat_<Vec3f> blend = LaplacianBlend(l, r, m);
    imshow("blended",blend);

    waitKey(0);
    return 0;
}