OpenCV —— 图像变换

将一副图像转变成另一种表现形式 ，比如，傅里叶变换将图像转换成频谱分量

卷积 —— 变换的基础

cvFilter2D  源图像 src 和目标图像 dst 大小应该相同

注意：卷积核的系数应该是浮点类型的，必须用 CV_32F 来初始化矩阵

cvFilter2D 函数内部处理边界 —— cvCopyMakeBorder （将特定的图像轻微变大，然后以一种方式填充图像边界）

梯度和Sobel导数

sobel 算子包含任意阶的微分以及融合偏导   大核对导数有更好的逼近，小核对噪声更加敏感

如果源图像src是8位的，为避免溢出，目标图像的深度必须是 IPL_DEPTH_16S

Scharr 滤波器

拉普拉斯变换 —— 二次导数  cvLaplace() —— 沿X轴Y轴的二次导数的和（周围是更高值的单点或者小块会使函数值最大化）

目标图像必须是16位（有符号）或者32位（浮点）图像

应用：检测团块，边缘检测 —— 原始图像的边缘位于拉普拉斯的值等于0的地方

Canny 算子  —— 首先在x和y方向求一阶导数，然后组合为4个方向的导数，这些方向导数达到局部最大值的点就是组成边缘的候选点；将独立的候选像素拼装成轮廓（应用滞后性阈值）

cvCanny —— 推荐的上下限阈值比例为2：1或3：1

霍夫变换 —— 二值图像中的任何点都可能是一些候选直线集合的一部分 

OpenCV 支持两种不同形式的霍夫变换：标准霍夫变换（SHT），累计概率霍夫变换（PPHT）—— 减少计算时间

霍夫圆变换

#include <cv.h>
#include <highgui.h>
#include <math.h>

int main(int argc,char** argv)
{
    IplImage* img=cvLoadImage("circle.jpg",CV_LOAD_IMAGE_GRAYSCALE);
    CvMemStorage* storage=cvCreateMemStorage(0);

    cvSmooth(img,img,CV_GAUSSIAN,5,5);

    CvSeq* results=cvHoughCircles(img,storage,CV_HOUGH_GRADIENT,2,img->width/10);

    for (int i=0;i<results->total;i++)
    {
        float* p=(float*)cvGetSeqElem(results,i);
        CvPoint pt=cvPoint(cvRound(p[0]),cvRound(p[1]));

        cvCircle(img,pt,cvRound(p[2]),CV_RGB(0xff,0xff,0x00));
    }

    cvNamedWindow("w1");
    cvShowImage("w1",img);
    cvWaitKey();

    cvReleaseMemStorage(&storage);
    cvDestroyAllWindows();

    return 0;
}

重映射

cvRemap（）  —— 用于矫正失真的标定或立体图像（涉及到插值问题）

仿射变换，透视变换

一个平面内的任意平行四边形ABCD可以被仿射为另一个平行四边形 ，仿射变换是透视变换的子集

稠密仿射变换 —— 图像扭曲必须进行一些插值运算以使输出的图像平滑   cvWarpAffine    cvGetQuadrangleSubPix

仿射映射矩阵的计算  ——  cvGetAffineTransform （两个包含三个点的数组，定义了两个平行四边形）

// 首先利用 cvGetAffineTransform 计算变换矩阵，接下来做一次仿射变换

#include <cv.h>
#include <highgui.h>

int main(int argc,char** argv)
{
    CvPoint2D32f srcTri[3],dstTri[3];
    CvMat* rot_mat=cvCreateMat(2,3,CV_32FC1);
    CvMat* warp_mat=cvCreateMat(2,3,CV_32FC1);
    IplImage *src,*dst;

    src=cvLoadImage("wukong.jpg",CV_LOAD_IMAGE_UNCHANGED);
    dst=cvCloneImage(src);
    dst->origin=src->origin;
    cvZero(dst);

    srcTri[0].x=0;
    srcTri[0].y=0;
    srcTri[1].x=src->width-1;
    srcTri[1].y=0;
    srcTri[2].x=0;
    srcTri[3].y=src->height-1;

    dstTri[0].x=src->width*0.0;
    dstTri[0].y=src->height*0.33;
    dstTri[0].x=src->width*0.85;
    dstTri[0].y=src->height*0.25;
    dstTri[0].x=src->width*0.15;
    dstTri[0].y=src->height*0.7;

    cvGetAffineTransform(srcTri,dstTri,warp_mat);
    cvWarpAffine(src,dst,warp_mat);
    cvCopy(dst,src);

    CvPoint2D32f center=cvPoint2D32f(src->width/2,src->height/2);
    double angle=-50.0;
    double scale=0.6;
    cv2DRotationMatrix(center,angle,scale,rot_mat);

    cvWarpAffine(src,dst,rot_mat);
    cvNamedWindow("w1");
    cvNamedWindow("w2");
    cvShowImage("w1",dst);
    cvShowImage("w2",src);
    cvWaitKey();

    cvReleaseImage(&dst);
    cvReleaseMat(&rot_mat);
    cvReleaseMat(&warp_mat);
    cvDestroyAllWindows();

    return 0;
}

稀疏仿射变换

cvTransform（）

---

透视变换

密集透视变换    cvWarpPerspective()

计算透视映射矩阵  cvGetPerspectiveTransform

// 透视变换 

/**/
#include <cv.h>
#include <highgui.h>

int main(int argc,char** argv)
{
    CvPoint2D32f srcQuad[4],dstQuad[4];
    CvMat *warp_matrix=cvCreateMat(3,3,CV_32FC1);
    IplImage *src,*dst;

    src=cvLoadImage("wukong.jpg",CV_LOAD_IMAGE_GRAYSCALE);
    dst=cvCloneImage(src);
    dst->origin=src->origin;
    cvZero(dst);

    srcQuad[0].x=0;
    srcQuad[0].y=0;
    srcQuad[1].x=src->width-1;
    srcQuad[1].y=0;
    srcQuad[2].x=0;
    srcQuad[2].y=src->height-1;
    srcQuad[3].x=src->width-1;
    srcQuad[3].y=src->height-1;

    dstQuad[0].x=src->width*0.05;
    dstQuad[0].y=src->height*0.33;
    dstQuad[1].x=src->width*0.9;
    dstQuad[1].y=src->height*0.25;
    dstQuad[2].x=src->width*0.2;
    dstQuad[2].y=src->height*0.7;
    dstQuad[3].x=src->width*0.8;
    dstQuad[3].y=src->height*0.9;

    cvGetPerspectiveTransform(srcQuad,dstQuad,warp_matrix);

    cvWarpPerspective(src,dst,warp_matrix);
    cvNamedWindow("w1");
    cvShowImage("w1",dst);
    cvWaitKey();

    cvReleaseImage(&dst);
    cvReleaseMat(&warp_matrix);
    cvDestroyAllWindows();

    return 0;
}

稀疏透视变换   cvPerspectiveTransform

透视变换实际上是一个嵌入在三维空间的二维平面上的实际映射点映射回一个不同的二维子空间

---

cvCartToPolar  cvPolarToCart 

笛卡尔空间和极行或径向空间之间进行映射

对数极坐标变换 —— 人的视觉系统 —— 是对物体视场的一种不变表示     cvLogPolar

#include <cv.h>
#include <highgui.h>

int main(int argc,char** argv)
{
    IplImage* src;
    double M=40;    // 缩放比例

    src=cvLoadImage("wukong.jpg",CV_LOAD_IMAGE_GRAYSCALE);
    IplImage* dst=cvCreateImage(cvGetSize(src),8,1);
    IplImage* src2=cvCreateImage(cvGetSize(src),8,1);

    cvLogPolar(src,dst,cvPoint2D32f(src->width/2,src->height/2),M,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS);
    cvLogPolar(dst,src2,cvPoint2D32f(src->width/2,src->height/2),M,CV_INTER_LINEAR|CV_WARP_INVERSE_MAP);

    cvNamedWindow("w1",1);
    cvShowImage("w1",dst);
    cvNamedWindow("w2",1);
    cvShowImage("w2",src2);

    cvWaitKey();
    cvReleaseImage(&dst);
    cvReleaseImage(&src2);
    cvDestroyAllWindows();

    return 0;
}

---

离散傅里叶变换 DFT

OpenCV 中实现了快速傅里叶变换，cvDFT 可以计算输入是一维或二维数组时的FFT

输入数组和输出数组必须是浮点类型并且通常是单通道或是双通道的

cvMulSpectrums 频谱乘法

#include <cv.h>
#include <highgui.h>

    
void speedy_convolution(const CvMat* A,const CvMat* B,CvMat* C)
{
    // 创建两个对于DFT算法维数最佳的新数组
    int dft_M=cvGetOptimalDFTSize(A->rows+B->rows-1);
    int dft_N=cvGetOptimalDFTSize(A->cols+B->cols-1);

    CvMat* dft_A = cvCreateMat(dft_M,dft_N,A->type);
    CvMat* dft_B=cvCreateMat(dft_M,dft_N,B->type);
    CvMat temp;

    cvGetSubRect(dft_A,&temp,cvRect(0,0,A->cols,A->rows));
    cvCopy(A,&temp);
    cvGetSubRect(dft_A,&temp,cvRect(A->cols,0,dft_A->cols-A->cols,A->rows));
    cvZero(&temp);

    cvDFT(dft_A,dft_A,CV_DXT_FORWARD,A->rows);
    
    cvGetSubRect(dft_B,&temp,cvRect(0,0,B->cols,B->rows));
    cvCopy(B,&temp);
    cvGetSubRect(dft_B,&temp,cvRect(B->cols,0,dft_B->cols-B->cols,B->rows));
    cvZero(&temp);

    cvDFT(dft_B,dft_B,CV_DXT_FORWARD,B->rows);

    // 所有频谱元素相乘
    cvMulSpectrums(dft_A,dft_B,dft_A,0);

    cvDFT(dft_A,dft_A,CV_DXT_INV_SCALE,C->rows);    // 反变换
    cvGetSubRect(dft_A,&temp,cvRect(0,0,C->cols,C->rows));
    cvCopy(&temp,C);

    cvReleaseMat(dft_A);
    cvReleaseMat(dft_B);
}

---

离散余弦变换 DCT

类似于DFT，但所有系数都是实数  cvDCT

积分图像 —— 积分图像中的任意一点（x，y）的值是指从图像的左上角到这个点的所构成的矩形区域内所有点的灰度值之和

cvIntegral（） —— 可以实现子区域的快速求和 —— 快速模糊，梯度估计，计算均值和标准差

距离变换 —— 定义一幅新图像，该图像中的每个输出像素被设成于输入像素0像素最近的距离   cvDistTransform()

输出图像必须是32位浮点类型图像

直方图均衡化

将直方图范围拉伸  ———— 映射函数应该是一个累计分布函数

cvEualizeHist（），原始图像以及目标图像必须是单通道，大小相同的8位图像。对于彩色图像，必须先将每个通道分开，再分别进行处理