OpenCV3常用函数及功能汇总

//-----------------------------------【头文件包含部分】--------------------------------------
//            描述：包含程序所依赖的头文件
//-----------------------------------------------------------------------------------------------

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
//#include "opencv2/xfeature2d.hpp"


//-----------------------------------【命名空间声明部分】--------------------------------------
//            描述：命名空间声明
//-----------------------------------------------------------------------------------------------
using namespace std ;
using namespace cv ;



//-----------------------------------【全局变量声明部分】--------------------------------------
//            描述：全局变量声明
//-----------------------------------------------------------------------------------------------
Mat g_srcImage,g_dstImage1,g_dstImage2,g_dstImage3,g_dstImage4,g_dstImage5 ;
int g_nBoxFilterValue = 6 ; //方框滤波内核值
int g_nMeanBlurValue = 10 ; //均值滤波内核值
int g_nGaussianBlurValue = 6 ; //高斯滤波内核值
int g_nMedianBlurValue = 10 ; //中值滤波参数值
int g_nBilateralFilterValue = 10 ; //双边滤波参数值



//-----------------------------------【全局函数声明部分】--------------------------------------
//            描述：全局函数声明
//-----------------------------------------------------------------------------------------------
//轨迹条回调函数
static void on_BoxFilter(int, void *) ;     //方框滤波
static void on_MeanBlur(int , void *) ;     //均值快滤波
static void on_GaussianBlur(int, void *) ;  //高斯滤波器
static void on_MedianBlur(int, void *) ;    //中值滤波器
static void on_BilateralFilter(int, void *) ;   //双边滤波器


/*===================================================================
 * // 说明
 * 平滑处理-五种滤波函数
 *
 * 1.方框滤波-boxFilter()函数 |线性
 * 2.均值滤波-blur()函数 |线性
 * 3.高斯滤波-GaussianBlur() |线性
 * 4.中值滤波-medianBlur()函数
 * 5.双边滤波-bilateralFilter()函数
 *
 *
 * 形态学图像处理
 * /功能：消除噪声;分割除独立元素,在图像中连接相邻的元素;求找图像中的明显极大值或极小值;求出图像的梯度
 * 1.膨胀-dilate()函数 求局部最大值 与核进行卷积
 * 2.腐蚀-erode()函数  求局部最小值 与核进行卷积
 * (膨胀就是图像中的高亮部分进行膨胀,领域扩张,效果图拥有比原图更大的高亮区域)
 * (腐蚀就是原图中的高亮部分被腐蚀,领域被蚕食,效果图拥有比原图更小的高亮区域)
 *
 * 图像运算
 * 1.开运算 先腐蚀后膨胀 消除平滑边界和小像素物体 dst = open(src,element) = dilate(erode(src,element))
 * 2.闭运算 先膨胀后腐蚀 排除黑色区域 dst = close(src,element) = erode(dilate(src,elemnt))
 * 3.顶帽运算 原图-开运算 效果：突出比原图轮廓周围更明亮的区域 作用：可做背景提取
 * 4.黑帽运算 效果：突出比原图轮廓周围的区域更暗的区域 作用：用来分离比邻近点暗一些的斑块
 * 5.形态学梯度
 *
 * 边缘检测算子
 * 1.canndy :Canny(src,src,3, 9,3)多级边缘检测算法 低错误率/高定位性/最小响应
 * 2.sobel算子： 主要用作边缘检测的离散微分算子,用以计算图像灰度函数的近似梯度。
 * 3.laplacian函数： 主要是利用sobel算子的运算。它通过加上sobel算子运算出的图像x方向和y方向上的导数
 *
 * 图像金字塔
 * 1.resize调整图像大小：
 * resize(src,dst,dst.size()) ;     //指定dsize=dst.size()
 * resize(src,dst,Size(),0.5,0.5) ; //指定fx和fy,让函数计算除目标图像的大小
 *
 * opencv霍夫变换
 *     1.霍夫线变换 H
 *     (1)标准霍夫变换 => 由HoughLines函数调用
 *     (2)多尺度霍夫变换 => 由HoughLines函数调用
 *     (3)累计概率霍夫变换 => 由HoughLinesP函数调用
 *
 *     2.霍夫圆变换
 *  重映射示例 remap
 *  SURF算法
 *  Harris角点检测
 *
 * *****************************************************************************/




//-----------------------------------【全局函数声明部分】--------------------------------------
//            描述：全局函数声明
//-----------------------------------------------------------------------------------------------
int main() {

    //===========================[载入图像]====================================
    Mat img = imread("/home/allen/pic/girl.jpg") ;
    Mat dst1 = img.clone() ;
    Mat dst2 = img.clone() ;
    Mat srcImage = imread("/home/allen/pic/girl.jpg") ;


    //===========================[图像相关]====================================
    //Mat对象创建
    Mat out_boxFilter ;       //方框滤波
    Mat out_blur    ;         //均值滤波
    Mat out_GaussianBlur ;    //高斯滤波
    Mat out_medianBlur ;      //中值滤波
    Mat out_bilateralFilter ; //双边滤波

    //膨胀 or 腐蚀|操作-获取自定义核
    Mat element = getStructuringElement(MORPH_RECT,Size(15,15)) ;
    Mat img_dilate ;    //膨胀
    Mat img_erode ;     //腐蚀

    Mat img_open ; //开运算
    Mat img_close ; //闭运算

    //canny边缘检测
    Mat dstImage,edge,grayImage ;
    dstImage.create(srcImage.size(),srcImage.type()) ;
    cvtColor(srcImage,grayImage,COLOR_BGR2GRAY) ;
    blur(grayImage,edge,Size(3,3)) ;

    //sobel算子
    Mat grad_x, grad_y ; //创建grad_x, grad_y矩阵
    Mat abs_grad_x, abs_grad_y,dst ;

    Mat src_sobel = imread("/home/allen/pic/girl.jpg") ;
    Sobel(src_sobel,grad_x,CV_16S,1,0,3,1,1,BORDER_DEFAULT) ;   //求x方向梯度
    convertScaleAbs(grad_x,abs_grad_x) ;
    Sobel(src_sobel,grad_y,CV_16S,0,1,3,1,1,BORDER_DEFAULT) ;   //求y方向梯度
    convertScaleAbs(grad_y,abs_grad_y) ;
    addWeighted(abs_grad_x,0.5,abs_grad_y,0.5,0,dst) ;//合并梯度

    //laplacian()函数
    Mat src_lap,src_gray,dst_lap,abs_lap ;
    src_lap = imread("/home/allen/pic/girl.jpg") ;
    GaussianBlur(src_lap,src_lap,Size(3,3),0, 0,BORDER_DEFAULT) ; //高斯滤波消除噪声
    cvtColor(src_lap,src_gray,COLOR_BGR2GRAY) ; //zhuanhaun为灰度图
    Laplacian(src_gray,dst_lap,CV_16S,3,1,0,BORDER_DEFAULT) ; //使用laplacian函数
    convertScaleAbs(dst_lap,abs_lap) ; //计算绝对值,并将结果转换为8位

    //Scharr()函数
    Mat src_sch,grad1_x,grad1_y ;
    Mat abs_grad1_x,abs_grad1_y,dst_sch ;
    src_sch = imread("/home/allen/pic/girl.jpg") ;
    Scharr(src_sch,grad1_x,CV_16S,1,0,1,0,BORDER_DEFAULT) ;
    convertScaleAbs(grad1_x,abs_grad1_x) ;
    Scharr(src_sch,grad1_y,CV_16S,0,1,1,0,BORDER_DEFAULT) ;
    convertScaleAbs(grad1_y,abs_grad1_y) ;
    addWeighted(abs_grad1_x,0.5,abs_grad1_y,0.5,0,dst_sch) ;

    //resize调整图像大小
    Mat src_Image = imread("/home/allen/pic/girl.jpg") ;
    Mat tmpImage,dstImage1,dstImage2 ;  //临时变量与目标图像的定义
    tmpImage = src_Image ; //将原始图赋给临时变量
    resize(tmpImage,dstImage1,Size(tmpImage.cols/2,tmpImage.rows/2),(0,0),(0,0),3) ;
    resize(tmpImage,dstImage2,Size(tmpImage.cols*2,tmpImage.rows*2),(0,0),(0,0),3) ;

    //pyrUp()进行向上取样操作并模糊
    pyrUp( tmpImage, dstImage, Size( tmpImage.cols*2, tmpImage.rows*2 ) );
    //PyrDown()向下采样并模糊
    pyrDown(tmpImage,dstImage,Size(tmpImage.cols/2,tmpImage.rows/2)) ;


    //=================================HoughLine()霍夫线变换=================================
//    Mat srcImage_lines = imread("/home/allen/pic/chess.jpg");  //工程目录下应该有一张名为1.jpg的素材图
//    Mat midImage,dstImage_lines ;//临时变量和目标图的定义
//    //【2】进行边缘检测和转化为灰度图
//    Canny(srcImage_lines ,midImage, 50, 200, 3);//进行一此canny边缘检测
//    cvtColor(midImage,dstImage_lines, COLOR_GRAY2BGR);//转化边缘检测后的图为灰度图
//    //【3】进行霍夫线变换
//    vector<Vec2f> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
//    HoughLines(midImage, lines, 1, CV_PI/180, 150, 0, 0 );
//    //【4】依次在图中绘制出每条线段
//    for( size_t i = 0; i < lines.size(); i++ )
//    {
//        float rho = lines[i][0], theta = lines[i][1];
//        Point pt1, pt2;
//        double a = cos(theta), b = sin(theta);
//        double x0 = a*rho, y0 = b*rho;
//        pt1.x = cvRound(x0 + 1000*(-b));
//        pt1.y = cvRound(y0 + 1000*(a));
//        pt2.x = cvRound(x0 - 1000*(-b));
//        pt2.y = cvRound(y0 - 1000*(a));
//        line( dstImage_lines, pt1, pt2, Scalar(55,100,195), 1, LINE_AA);
//    }



    //=================================HoughLineP()函数 霍夫线变换=================================
//    Mat srcImage_lines = imread("/home/allen/pic/chess.jpg");  //工程目录下应该有一张名为1.jpg的素材图
//    Mat midImage_p,dstImage_lines;//临时变量和目标图的定义
//
//    //【2】进行边缘检测和转化为灰度图
//    Canny(srcImage_lines, midImage_p, 50, 200, 3);//进行一此canny边缘检测
//    cvtColor(midImage_p,dstImage_lines,COLOR_GRAY2BGR);//转化边缘检测后的图为灰度图
//
//    //【3】进行霍夫线变换
//    vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
//    HoughLinesP(midImage_p, lines, 1, CV_PI/180, 80, 50, 10 );
//
//    //【4】依次在图中绘制出每条线段
//    for( size_t i = 0; i < lines.size(); i++ )
//    {
//        Vec4i l = lines[i];
//        line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(186,88,255), 1, LINE_AA);
//    }



    //=================================HoughCircle()函数 霍夫线变换=================================
//    Mat srcImage_circle = imread("/home/allen/pic/circle.jpg");
//    Mat midImage_circle,dstImage_circle;//临时变量和目标图的定义
//
//    //【2】显示原始图
//    imshow("【原始图】", srcImage_circle);
//
//    //【3】转为灰度图，进行图像平滑
//    cvtColor(srcImage_circle,midImage_circle, COLOR_BGR2GRAY);//转化边缘检测后的图为灰度图
//    GaussianBlur( midImage_circle, midImage_circle, Size(9, 9), 2, 2 );
//
//    //【4】进行霍夫圆变换
//    vector<Vec3f> circles;
//    HoughCircles( midImage_circle, circles,HOUGH_GRADIENT,1.5, 10, 200, 100, 0, 0 );
//
//    //【5】依次在图中绘制出圆
//    for( size_t i = 0; i < circles.size(); i++ )
//    {
//        Point center(cvRound(circles[i][0]),cvRound(circles[i][1]));
//        int radius = cvRound(circles[i][2]);
//        //绘制圆心
//        circle( srcImage, center, 3, Scalar(0,255,0), -1, 8, 0 );
//        //绘制圆轮廓
//        circle( srcImage, center, radius, Scalar(155,50,255), 3, 8, 0 );
//    }
//
//    //【6】显示效果图
//    imshow("【效果图】", srcImage_circle);



//=================================重映射=================================
//    Mat srcImage_remap,dstImage_remap ;
//    Mat map_x,map_y ;
//
//    srcImage_remap = imread("/home/allen/pic/girl.jpg") ;
//    imshow("原始图",srcImage_remap) ;
//    dstImage_remap.create(srcImage_remap.size(),srcImage_remap.type()) ;
//    map_x.create(srcImage_remap.size(),CV_32FC1) ;
//    map_y.create(srcImage_remap.size(),CV_32FC1) ;
//    for (int j = 0; j < srcImage_remap.rows; j++)
//    {
//        for (int i = 0; i < srcImage_remap.cols; i++)
//        {
//            map_x.at<float>(j,i) = static_cast<float>(i) ;
//            map_y.at<float>(j,i) = static_cast<float>(srcImage_remap.rows - j) ;
//        }
//    }
//    remap(srcImage_remap,dstImage_remap,map_x,map_y,INTER_LINEAR,BORDER_CONSTANT, Scalar(0,0, 0)) ;
//    imshow( "【程序窗口】", dstImage_remap );


    //=================================Harris角点检测=================================
//    Mat img_harris = imread("/home/allen/pic/gegirl.jpg", 0);
//    imshow("原始图", img_harris);
//
//    //进行Harris角点检测找出角点
//    Mat cornerStrength;
//    cornerHarris(img_harris, cornerStrength, 2, 3, 0.01);
//
//    //对灰度图进行阈值操作，得到二值图并显示
//    Mat harrisCorner;
//    threshold(cornerStrength, harrisCorner, 0.00001, 255, THRESH_BINARY);
//    imshow("角点检测后的二值效果图", harrisCorner);



    //===========================[图像操作]====================================
    //五种滤波函数
//    boxFilter(img,out_boxFilter,-1,Size(5,5)) ;   //方框滤波
//    blur(img,out_blur,Size(7,7)) ;                //均值滤波
//    GaussianBlur(img,out_GaussianBlur,Size(5,5),0,0) ;  //高斯滤波
//    medianBlur(img,out_medianBlur,7) ;                  //中值滤波
//    bilateralFilter(img,out_bilateralFilter,25,25*2,25/2) ;    //双边滤波
//    //形态学操作
//    dilate(img,img_dilate,element) ;    //膨胀操作
//    erode(img,img_erode,element) ;      //腐蚀操作
//
//    morphologyEx(img,img,MORPH_OPEN,element) ; //开运算
//    morphologyEx(img,img,MORPH_CLOSE,element) ; //闭运算
//    morphologyEx(img,img,MORPH_GRADIENT,element) ; //形态学梯度
//    morphologyEx(dst1,img,MORPH_TOPHAT,element) ; //顶帽运算
//    morphologyEx(img,img,MORPH_BLACKHAT,element) ; //黑帽运算
//    morphologyEx(img,img,MORPH_ERODE,element) ; //mor腐蚀
//    morphologyEx(img,img,MORPH_DILATE,element) ; //mor腐蚀

//    Canny(edge,edge,3, 9,3) ; //canny边缘检测




    //===========================[图像显示]====================================
    //创建窗口
//    namedWindow("[原图]") ;
//    namedWindow("") ;
//    namedWindow("方框滤波") ;
//    namedWindow("均值滤波") ;
//    namedWindow("高斯滤波") ;
//    namedWindow("中值滤波") ;
//    namedWindow("双边滤波") ;
//    namedWindow("膨胀") ;
//    namedWindow("腐蚀") ;
//    namedWindow("开运算") ;
//    namedWindow("闭运算") ;
//    namedWindow("形态学梯度") ;
//    namedWindow("顶帽运算") ;
//    namedWindow("黑帽运算") ;
//    namedWindow("Canny边缘检测") ;
//    namedWindow("sobel算子") ;


    //窗口显示
//    imshow("[原图]",dst1) ; //原图
//    imshow("方框滤波",out_boxFilter) ;  //方框滤波
//    imshow("均值滤波",out_blur) ;       //均值滤波
//    imshow("高斯滤波",out_GaussianBlur) ;   //高斯滤波
//    imshow("中值滤波",out_medianBlur) ;     //中值滤波
//    imshow("双边滤波",out_bilateralFilter) ; //双边滤波

//    imshow("膨胀",img_dilate) ;    //膨胀
//    imshow("腐蚀",img_erode)  ;    //腐蚀
//    imshow("开运算",img) ;         //开运算
//    imshow("闭运算",img) ;         //闭运算
//    imshow("形态学梯度",img) ;      //形态学梯度
//    imshow("顶帽运算",img) ;       //顶帽运算
//    imshow("黑帽运算",img) ;       //黑帽运算

//    imshow("Canny边缘检测",edge) ; //Canny边缘检测
//    imshow("sobel算子X方向",abs_grad_x) ;     //sobel算子X方向
//    imshow("sobel算子Y方向",abs_grad_y) ;     //sobel算子Y方向
//    imshow("sobel算子整体方向",dst) ;          //sobel算子整体方向
//    imshow("laplacian变换",abs_lap) ;         //laplacian函数
//    imshow("scharr函数x方向",abs_grad1_x) ;     //scharr函数x方向
//    imshow("scharr函数y方向",abs_grad1_y) ;     //scharr函数y方向
//    imshow("合并梯度后scharr",dst_sch) ;         //显示scharr整体效果图

//    imshow("size调整图像大小/2",dstImage1) ;  //resize调整大小/2
//    imshow("size调整图像大小*2",dstImage2) ;  //resize调整大小*2
//    imshow("pyrup效果图",dstImage) ;   //pyrUp效果图
//    imshow("pyrdown",dstImage)  ;   //pyrDown效果图


//    imshow("HoughLine原始图",srcImage_lines) ; //霍夫线变换的原始图
//    imshow("边缘检测后的图",midImage) ;    //canny效果图
//    imshow("霍夫线变换效果图",dstImage_lines) ; //霍夫线变换后的效果图

//    imshow("【原始图】", srcImage_lines); //显示原始图
//    imshow("【边缘检测后的图】", midImage_p); //边缘检测后的图
//    imshow("【效果图】", dstImage_lines); //【7】显示效果图

//    imshow("【效果图】", srcImage_circle); //霍夫圆变换



    //===========================[结尾处理]====================================
    waitKey(0) ;
    cout << endl << "\t按下'q'键时,程序退出～!\n" ;
    while (char(waitKey(1))!='q'){}
    return 0 ;

}