残差金字塔实现

简介

　　本篇是对残差金字塔实现的笔记。

基本原理

　　简单理解，它就是预测图像和原始图像之间的差值。

图像金字塔

　　首先我们知道，图像金字塔的实现，就是对原图像进行采样，获得低分辨率的新图像。接着对新图像继续采样，或者更低分辨率的下一张图像。依次不断迭代，进而最后得到一张最低分辨率的采样图像，依次往下，分辨率逐渐加大直到原图。如下图所示：
               

残差金字塔

　　在进行图像金子塔采样时候，一般会先对原图像做一次高斯之类的滤波。然后获得新图像的width和height都为原图像的1/2。接着将新图像放大为原图像的相同size。原图像减去新图像的差值就得到当前的残差图像，依次迭代下去，便得到对应的残差金字塔。
    本例的效果图如下：
               

    注意，图像直方图的最小图没有对应的残差图，将最小图的width和height都放大一倍之后，和对应的残差图相加。接着继续往前面迭代，直到迭代完所有残差图像之后，变复原了原图像。

具体范例

　　这里是一个先生成残差金字塔，接着再利用该残差金字塔复原回原图像的例子。

总体框架

src1[0] = imread(argv[1]);
width[0] = src1[0].rows;
height[0] = src1[0].cols;
 
getPyramid();
picRecover();

　　打开原图像保存在src1[0]中，接着调用getPyramid来生成残差金字塔。最后函数picRecover来复原图像。

残差金字塔生成

Mat mySub(Mat src1, Mat src2){
    IplImage ip1, ip2, ip3;  
    CvScalar s1, s2; 
    Mat dst;
    int i, j;
 
    dst = Mat(src1.rows, src1.cols, CV_32FC3);
    ip1 = src1;
    ip2 = src2;
    ip3 = dst;
 
    for(i=0; i<src1.cols; i++){
        for(j=0; j<src1.rows; j++){
            s1 = cvGet2D(&ip1, j, i);
            s2 = cvGet2D(&ip2, j, i);
            s1.val[0] = s1.val[0] - s2.val[0];
            s1.val[1] = s1.val[1] - s2.val[1];
            s1.val[2] = s1.val[2] - s2.val[2];
            cvSet2D(&ip3, j, i, s1);
        }
    }
    return dst;
}
void getPyramid(void){
    GaussianBlur(src1[0], dst[0], Size(g_nGaussianBlurValue*2+1,g_nGaussianBlurValue*2+1), 0, 0);
    width[1]  = width[0] / 2;
    height[1] = height[0] / 2;
    resize(dst[0], src1[1], Size(height[1], width[1]));
    resize(src1[1], tmp, Size(height[0], width[0]));
    mask[0] = mySub(src1[0], tmp);
     
    GaussianBlur(src1[1], dst[1], Size(g_nGaussianBlurValue*2+1,g_nGaussianBlurValue*2+1), 0, 0);
    width[2]  = width[1] / 2;
    height[2] = height[1] / 2;
    resize(dst[1], src1[2], Size(height[2], width[2]));
    resize(src1[2], tmp, Size(height[1], width[1]));
    mask[1] = mySub(src1[1], tmp);
 
    GaussianBlur(src1[2], dst[2], Size(g_nGaussianBlurValue*2+1,g_nGaussianBlurValue*2+1), 0, 0);
    width[3]  = width[2] / 2;
    height[3] = height[2] / 2;
    resize(dst[2], src1[3], Size(height[3], width[3]));
    resize(src1[3], tmp, Size(height[2], width[2]));
    mask[2] = mySub(src1[2], tmp);
}

　　1、首先将原图像进行高斯滤波，结果保存到dst[0]中；将dst[0]进行缩放，存储到src1[1]中；src1[1]图像放大回原图像的size,存储到tmp中；用原图像src[0] - tmp，获取到第一级的残差图像。注意这里默认的图像格式是CV_8UC3，所以不能够用它们直接相减，否则如果相减的像素结果为负数时候，将会被默认存储为0，导致最后的残差金字塔无法正常的复原图像。

　　2.重复迭代上面的操作2次，最后获得对应的4层图像金字塔，存储到src1数组中，3层残差金字塔图像，存储到mask数组中。
　　

原始图像复原

Mat myAdd(Mat src1, Mat src2){
    IplImage ip1, ip2, ip3;  
    CvScalar s1, s2; 
    int i, j;
    Mat dst;
    src1.copyTo(dst);
    ip1 = src1;
    ip2 = src2;
    ip3 = dst;
 
    for(i=0; i<src1.cols; i++){
        for(j=0; j<src1.rows; j++){
            s1 = cvGet2D(&ip1, j, i);
            s2 = cvGet2D(&ip2, j, i);
            s1.val[0] = s1.val[0] + s2.val[0];
            s1.val[1] = s1.val[1] + s2.val[1];
            s1.val[2] = s1.val[2] + s2.val[2];
            cvSet2D(&ip3, j, i, s1);
        }
    }
    return dst;
}
 
void picRecover(void){
    resize(src1[3], tmp, Size(height[2], width[2]));
    dst[2] = myAdd(tmp, mask[2]);
 
    resize(dst[2], tmp, Size(height[1], width[1]));
    dst[1] = myAdd(tmp, mask[1]);
 
    resize(dst[1], tmp, Size(height[0], width[0]));
    dst[0] = myAdd(tmp, mask[0]);
}

　　在函数picRecover中，就是利用图像金字塔src1和残差金字塔mask，来复原图像src1[0] 到dst[0]中。首先从图像金字塔最高层开始，将src1[3]放到到和src1[2]相同的size，存储到tmp中，接着将tmp和对已的残差图像mask[2]相加，结果存储到dst[2]中，这里dst[2]的图像就和src[2]的图像一致了。
　　继续迭代下去，最终获得图像dst[0]的结果和原图像src1[0]中的图像相一致。