opencv:图像变换

最新推荐文章于 2024-05-04 14:49:56 发布

虚极守静

最新推荐文章于 2024-05-04 14:49:56 发布

阅读量410

点赞数

分类专栏： opencv入门文章标签： opencv

本文链接：https://blog.csdn.net/qq_29450163/article/details/54982591

版权

opencv入门专栏收录该内容

31 篇文章 0 订阅

订阅专栏

一、卷积

void cvFilter2D(const CvArr* src,CvArr* dst,const CvMat* kernel);
//扩大图像的边界
void cvCopyMakeBorder(const CvArr* src,CvArr* dst,CvPoint offset,int bordertype,CvScalar value = cvScalarAll(0));

二、梯度和Sobel导数

cvSobel(const CvArr* src,CvArr* dst,int xorder,int yorder,int aperture_size = 3);

三、拉普拉斯变换

void cvLaplace(const CvArr* src,CvArr* dst,int apertureSize = 3);

四、Canny算子

void cvCanny(const CvArr* edges,double lowThresh,double highThresh,int apertureSize = 3);

五、霍夫变换
1·霍夫线变换

CvSeq* cvHoughLines2(CvArr* image,void* line_storage,int method,double rho,double theta,int threshold,double param1 = 0,double param2 = 0);

2·霍夫圆变换

CvSeq* cvHoughCircles(CvArr* image,void* circle_storage,int method,double dp,double min_dist,double param1 = 100,double param2 = 300,int min_radius = 0,int max_radius = 0);

六、重映射

void cvRemap(const CvArr* src,CvArr* dst,const CvArr* mapx,const CvArr* mapy,int flags = CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS,CvScalar fillval = cvScalarAll(0));

标志位的值及意义
CV_INTER_NN 最近邻
CV_INTER_LINEAR 双线性（默认）
CV_INTER_AREA 像素区域重新采样
CV_INTER_CUBIC 双三次插值

七、几何转换
1·基于2x3矩阵进行的变换，也叫仿射变换

//稠密仿射变换
void cvWarpAffine(const CvArr* src,CvArr* dst,const CvMat* map_matrix,int flags = CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS,CvScalar fillval = cvScalrAll(0));
void cvGetQuadrangleSubPix(const CvArr* src,CvArr* dst,const CvMat* map_matrix);
//仿射映射矩阵的计算
CvMat* cvGetAffineTransform(const CvPoint2D32f* pts_src,const CvPoint2d32f* pts_dst,CvMat* map_matrix);
CvMat* cv2DRotationMatrix(CvPoint2D32f center,double angle,double scale,CvMat* map_matrix);
//稀疏仿射变换
void cvTransform(const CvArr* stc,CvArr* dst,const CvMat* transmat,const CvMat* shiftvec = NULL);

#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;
    if ((src = cvLoadImage("E:/opencv/lena.png")) != 0)
    {
         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[2].y = src->height - 1;
         dstTri[0].x = src->width*0.0;
         dstTri[0].y = src->height*0.33;
         dstTri[1].x = src->width*0.85;
         dstTri[1].y = src->height*0.25;
         dstTri[2].x = src->width*0.15;
         dstTri[2].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("Affine_Transform",1);
         cvShowImage("Affine_Transform",dst);
         cvWaitKey(0);
    }
    cvReleaseImage(&dst);
    cvReleaseMat(&rot_mat);
    cvReleaseMat(&warp_mat);
    return 0;

}

2·基于3x3矩阵进行的变换，也叫透视变换或者单应性变换

//稠密透视变换
void cvWarpPerspective(const CvArr* src,CvArr* dst,const CvMat* map_matrix,int flags = CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS,CvScalar fillval = cvScalarAll(0));
CvMat* cvGetPerspectiveTransform(const CvPoint2D32f* pts_src,const CvPoint2D32f* pts_dst,CvMat* map_matrix);
//稀疏透视变换
void cvPerspectiveTransform(const CvArr* src,CvArr* dst,const CvMat* mat);

#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;
    if ((src = cvLoadImage("E:/opencv/lena.png")) != 0)
    {
         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].y = 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].y = src->width*0.8;
         dstQuad[3].y = src->height*0.9;

        cvGetPerspectiveTransform(srcQuad,dstQuad,warp_matrix);
         cvWarpPerspective(src,dst,warp_matrix);

         cvNamedWindow("Affine_Transform",1);
         cvShowImage("Affine_Transform",dst);
         cvWaitKey(0);
    }
    cvReleaseImage(&dst);
    cvReleaseMat(&warp_matrix);

    return 0;

}

3.坐标转换

//笛卡尔坐标到极坐标
void cvCartToPolar(const CvArr* x,const CvArr* y,CvArr* magnitude,CvArr* angle = NULL,int angle_in_degrees = 0);
//极坐标到笛卡尔坐标
void cvPolarToCart(const CvArr* magnitude,const CvArr* angle,CvArr* x,CvArr* y,int angle_in_degrees = 0);
//对数极坐标转换
void cvLogPolar(const CvArr* src,CvArr* dst,CvPoint2D32f center,double m,int flags = CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS);

#include "cv.h"
#include "highgui.h"

int main(int argc,char** argv)
{
    IplImage* src;
    double M;
    if((src = cvLoadImage("E:/opencv/lena.png")) != 0)
    {
         M = 10;
         IplImage* dst = cvCreateImage(cvGetSize(src),8,3);
         IplImage* src2 = cvCreateImage(cvGetSize(src),8,3);

        cvLogPolar(src,dst,cvPoint2D32f(src->width/4,src->height/2),M,CV_INTER_LINEAR+
             CV_WARP_FILL_OUTLIERS);
        cvLogPolar(dst,src2,cvPoint2D32f(src->width/4,src->height/2),M,CV_INTER_LINEAR |
             CV_WARP_INVERSE_MAP);
         cvNamedWindow("Example6_4");
         cvShowImage("Example6_4",dst);
         cvNamedWindow("2");
         cvShowImage("2",src2);
         cvWaitKey(0);

    }
    return 0;
}

八、离散傅里叶变换(DFT)

void cvDFT(const CvArr* src,CvArr* dst,int flags,int nonzero_rows = 0);
//频谱乘法
void cvMulSpectrums(const CvArr* src1,const CvArr* src2,CvArr* dst,int flags);

#include "cv.h"
#include "highgui.h"

void speedy_conv(const CvMat* A,const CvMat* B,CvMat* C)
{
    int dft_M = cvGetOptimalDFTSize(A->rows+B->rows-1);
    int dft_N = cvGetOptimalDFTSize(A->rows+B->rows-1);

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

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

    cvDFT(dft_A,dft_A,CV_DXT_FORWARD,A->rows);
    cvGetSubRect(dft_B,&tmp,cvRect(0,0,B->cols,B->rows));
    cvCopy(B,&tmp);
    cvGetSubRect(dft_B,&tmp,cvRect(B->cols,0,dft_B->cols-B->cols,B->rows));
    cvZero(&tmp);
    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,&tmp,cvRect(0,0,C->cols,C->rows));
    cvCopy(&tmp,C);
    cvReleaseMat(&dft_A);
    cvReleaseMat(&dft_B);

}
int main(int argc,char** argv)
{

}

九、离散余弦变换(DCT)

void cvDCT(const CvArr* src,CvArr* dst,int flags);

十、积分图像

void cvIntegral(const CvArr* image,CvArr* sum,Cvarr* sqsum = NULL,CvArr* tilted_sum = NULL);

十一、距离变换

void cvDistTransfrorm(const CvArr* src,CvArr* dst,int distance_type = CV_DIST_L2,int mask_size = 3,const float* kernel = NULL,CvArr* labels = NULL);

cvDistTransform()中可能采用的距离准则

CV_DIST_L2
CV_DIST_L1
CV_DIST_L12
CV_DIST_FAIR
CV_DIST_WELSCH
CV_DIST_USER

十二、直方图均衡化

void cvEqualizeHist(const CvArr* src,CvArr* dst);

虚极守静

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录