opencv基础代码,基本上都有了,以后可以用来翻一翻,clion环境,c++

//#include <opencv2/opencv.hpp>
//using namespace cv;
//
//int main() {
//    Mat srcImage = imread("/home/arthur/Documents/Project/cvdemo/test.jpg");
//    imshow("test",srcImage);
//    waitKey(0);
//}
/*






*/

//----------------------------------腐蚀------------------------------------------------------
//#include <opencv2/highgui/highgui.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//int main() {
//    Mat srcImage = imread("/home/arthur/Documents/Project/cvdemo/3.jpg");
//    imshow("ori", srcImage);
//    Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));//????
//    Mat dstImage;
//    erode(srcImage, dstImage, element);//腐蚀
//    imshow("dst", dstImage);
//    waitKey(0);
//
//    return 0;
//}
/*






*/
//-------------------------------------均值滤波---------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//using namespace cv;
//
//int main( )
//{
//
//    Mat srcImage=imread("/home/arthur/Documents/Project/cvdemo/4.jpg");
//
//    imshow( "src", srcImage );
//
//    Mat dstImage;
//    blur( srcImage, dstImage, Size(7, 7));//均值滤波
//
//    imshow( "dst" ,dstImage );
//
//    waitKey( 0 );
//}
/*






*/
//------------------------------------canny----------------------------------------------------
#include <opencv2/opencv.hpp>//????
//#include "opencv2/highgui/highgui.hpp"
//#include<opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//int main( )
//{
//    Mat srcImage = imread("/home/arthur/Documents/Project/cvdemo/5.jpg");
//    imshow("src", srcImage);
//    Mat dstImage,edge,grayImage;
//
//    dstImage.create( srcImage.size(), srcImage.type() );
//
//    cvtColor( srcImage, grayImage, COLOR_BGR2GRAY );
//
//    blur( grayImage, edge, Size(3,3) );//均值滤波
//
//    Canny( edge, edge, 3, 9,3 );//canny
//
//    imshow("edge", edge);
//
//    waitKey(0);
//
//    return 0;
//}
/*






*/
//---------------------------------视频-------------------------------------------------------
//#include <opencv2/opencv.hpp>
//using namespace cv;
//
//int main( )
//{
//    VideoCapture capture("/home/arthur/Documents/Project/OpenCVProject/cvdemo/1.avi");
//
//    while(1)
//    {
//        Mat frame;
//        capture>>frame;//????
//
//        if (frame.empty())
//        {
//            break;
//        }
//
//        imshow("avi",frame);//????
//        waitKey(10);
//    }
//    return 0;
//}
/*






*/
//---------------------------------摄像头-------------------------------------------------------
#include <opencv2/opencv.hpp>
//using namespace cv;
//
//int main( )
//{
//    VideoCapture capture(0);
//    while(1)
//    {
//        Mat frame;
//        capture>>frame;
//        imshow("",frame);
//        waitKey(30);
//    }
//    return 0;
//}
/*






*/
//----------------------------------------/home/arthur/Downloads/opencv-3.4.7/samples/cpp官方例子
#include <opencv2/opencv.hpp>
//using namespace cv;
//
//int main()
//{
//    Mat image0 = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/6.jpg",1);
    namedWindow("name",WINDOW_AUTOSIZE);
//    imshow("name", image0);
//
//    waitKey();
//}

/*




*/
//---------------------------------【createAlphaMat( )函数】-------------------------------------------------------
//#include <vector>
//#include <stdio.h>
//#include <iostream>
//#include<opencv2/opencv.hpp>
//using namespace cv;
//using namespace std;
//
--------------------------------【createAlphaMat( )函数】--------------------------------
		描述:创建带alpha通道的Mat
-------------------------------------------------------------------------------------------------
//void createAlphaMat(Mat &mat)
//{
//    for(int i = 0; i < mat.rows; ++i) {
//        for(int j = 0; j < mat.cols; ++j) {
//            Vec4b&rgba = mat.at<Vec4b>(i, j);
//            rgba[0]= UCHAR_MAX;
//            rgba[1]= saturate_cast<uchar>((float (mat.cols - j)) / ((float)mat.cols) *UCHAR_MAX);
//            rgba[2]= saturate_cast<uchar>((float (mat.rows - i)) / ((float)mat.rows) *UCHAR_MAX);
//            rgba[3]= saturate_cast<uchar>(0.5 * (rgba[1] + rgba[2]));
//        }
//    }
//}
//
//int main( )
//{
//    //创建带alpha通道的Mat
//    Mat mat(480, 640, CV_8UC4);
//    createAlphaMat(mat);
//
//    vector<int>compression_params;
//    //此句代码的OpenCV2版为:
//    //compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);
//    //此句代码的OpenCV3版为:
//    compression_params.push_back(IMWRITE_PNG_COMPRESSION);
//    compression_params.push_back(9);
//    //显示图片
//    try{
//        imwrite("/home/arthur/Documents/Project/OpenCVProject/cvdemo/7.jpg", mat, compression_params);
//        imshow("生成的png图",mat);
//        fprintf(stdout,"PNG图片文件的alpha数据保存完毕~\n可以在工程目录下查看由imwrite函数生成的图片\n");
//        waitKey(0);
//    }
//    catch(runtime_error& ex) {
//        fprintf(stderr,"图像转换成PNG格式发生错误:%s\n", ex.what());
//        return 1;
//    }
//    imshow("name", imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/7.jpg"));
//    cout << "readnmae" << endl;
//    waitKey(0);
//    return 0;
//}
/*





*/
//#include <opencv2/opencv.hpp>
//#include <opencv2/highgui/highgui.hpp>
//using namespace cv;
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME "【滑动条的创建&线性混合示例】"        //为窗口标题定义的宏
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量声明
-----------------------------------------------------------------------------------------------
//const int g_nMaxAlphaValue = 100;//Alpha值的最大值
//int g_nAlphaValueSlider;//滑动条对应的变量
//double g_dAlphaValue;
//double g_dBetaValue;
//
声明存储图像的变量
//Mat g_srcImage1;
//Mat g_srcImage2;
//Mat g_dstImage;
//
//
-----------------------------------【on_Trackbar( )函数】--------------------------------
		描述:响应滑动条的回调函数
------------------------------------------------------------------------------------------
//void on_Trackbar( int, void* )
//{
//    //求出当前alpha值相对于最大值的比例
//    g_dAlphaValue = (double) g_nAlphaValueSlider/g_nMaxAlphaValue ;
//    //则beta值为1减去alpha值
//    g_dBetaValue = ( 1.0 - g_dAlphaValue );
//
//    //根据alpha和beta值进行线性混合
//    addWeighted( g_srcImage1, g_dAlphaValue, g_srcImage2, g_dBetaValue, 0.0, g_dstImage);
//
//    //显示效果图
//    imshow( WINDOW_NAME, g_dstImage );
//}
//
//
-----------------------------【ShowHelpText( )函数】--------------------------------------
		描述:输出帮助信息
-------------------------------------------------------------------------------------------------
-----------------------------------【ShowHelpText( )函数】----------------------------------
		描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//
--------------------------------------【main( )函数】-----------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//
//    //加载图像 (两图像的尺寸需相同)
//    g_srcImage1 = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/1.jpg");
//    g_srcImage2 = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/2.jpg");
//    if( !g_srcImage1.data ) { printf("读取第一幅图片错误,请确定目录下是否有imread函数指定图片存在~! \n"); return -1; }
//    if( !g_srcImage2.data ) { printf("读取第二幅图片错误,请确定目录下是否有imread函数指定图片存在~!\n"); return -1; }
//
//    //设置滑动条初值为70
//    g_nAlphaValueSlider = 70;
//
//    //创建窗体
//    namedWindow(WINDOW_NAME, 1);
//
//    //在创建的窗体中创建一个滑动条控件
//    char TrackbarName[50];
//    sprintf( TrackbarName, "透明值 %d", g_nMaxAlphaValue );
//
//    createTrackbar( TrackbarName, WINDOW_NAME, &g_nAlphaValueSlider, g_nMaxAlphaValue, on_Trackbar );
//
//    //结果在回调函数中显示
//    on_Trackbar(g_dAlphaValue, 0);
//
//    //按任意键退出
//    waitKey(0);
//
//    return 0;
//}
/*








*/
//#include <opencv2/opencv.hpp>
//using namespace cv;
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME "【程序窗口】"        //为窗口标题定义的宏
//
//
-----------------------------------【全局函数声明部分】------------------------------------
		描述:全局函数的声明
------------------------------------------------------------------------------------------------
//void on_MouseHandle(int event, int x, int y, int flags, void* param);
//void DrawRectangle( cv::Mat& img, cv::Rect box );
//
-----------------------------------【全局变量声明部分】-----------------------------------
		描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//Rect g_rectangle;
//bool g_bDrawingBox = false;//是否进行绘制
//RNG g_rng(12345);
//
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-------------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //【0】改变console字体颜色
//    system("color 9F");
//
//    //【1】准备参数
//    g_rectangle = Rect(-1,-1,0,0);
//    Mat srcImage(600, 800,CV_8UC3), tempImage;
//    srcImage.copyTo(tempImage);
//    g_rectangle = Rect(-1,-1,0,0);
//    srcImage = Scalar::all(0);
//
//    //【2】设置鼠标操作回调函数
//    namedWindow( WINDOW_NAME );
//    setMouseCallback(WINDOW_NAME,on_MouseHandle,(void*)&srcImage);
//
//    //【3】程序主循环,当进行绘制的标识符为真时,进行绘制
//    while(1)
//    {
//        srcImage.copyTo(tempImage);//拷贝源图到临时变量
//        if( g_bDrawingBox ) DrawRectangle( tempImage, g_rectangle );//当进行绘制的标识符为真,则进行绘制
//        imshow( WINDOW_NAME, tempImage );
//        if( waitKey( 10 ) == 27 ) break;//按下ESC键,程序退出
//    }
//    return 0;
//}
//
//
//
--------------------------------【on_MouseHandle( )函数】-----------------------------
		描述:鼠标回调函数,根据不同的鼠标事件进行不同的操作
-----------------------------------------------------------------------------------------------
//void on_MouseHandle(int event, int x, int y, int flags, void* param)
//{
//
//    Mat& image = *(cv::Mat*) param;
//    switch( event)
//    {
//        //鼠标移动消息
//        case EVENT_MOUSEMOVE:
//        {
//            if( g_bDrawingBox )//如果是否进行绘制的标识符为真,则记录下长和宽到RECT型变量中
//            {
//                g_rectangle.width = x-g_rectangle.x;
//                g_rectangle.height = y-g_rectangle.y;
//            }
//        }
//            break;
//
//            //左键按下消息
//        case EVENT_LBUTTONDOWN:
//        {
//            g_bDrawingBox = true;
//            g_rectangle =Rect( x, y, 0, 0 );//记录起始点
//        }
//            break;
//
//            //左键抬起消息
//        case EVENT_LBUTTONUP:
//        {
//            g_bDrawingBox = false;//置标识符为false
//            //对宽和高小于0的处理
//            if( g_rectangle.width < 0 )
//            {
//                g_rectangle.x += g_rectangle.width;
//                g_rectangle.width *= -1;
//            }
//
//            if( g_rectangle.height < 0 )
//            {
//                g_rectangle.y += g_rectangle.height;
//                g_rectangle.height *= -1;
//            }
//            //调用函数进行绘制
//            DrawRectangle( image, g_rectangle );
//        }
//            break;
//
//    }
//}
//
//
//
-----------------------------------【DrawRectangle( )函数】------------------------------
		描述:自定义的矩形绘制函数
-----------------------------------------------------------------------------------------------
//void DrawRectangle( cv::Mat& img, cv::Rect box )
//{
//    cv::rectangle(img,box.tl(),box.br(),cv::Scalar(g_rng.uniform(0, 255), g_rng.uniform(0,255), g_rng.uniform(0,255)));//随机颜色
//}
/*














*/
//-----------------------------------【头文件包含部分】---------------------------------------
//	描述:包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
//#include <opencv2/core/core.hpp>
//#include <opencv2/highgui/highgui.hpp>
//#include "opencv2/imgproc/imgproc.hpp"
//#include <iostream>
//
-----------------------------------【命名空间声明部分】---------------------------------------
	描述:包含程序所使用的命名空间
-----------------------------------------------------------------------------------------------
//using namespace std;
//using namespace cv;
//
//
-----------------------------------【全局函数声明部分】--------------------------------------
	描述:全局函数声明
-----------------------------------------------------------------------------------------------
//static void ContrastAndBright(int, void *);
//
-----------------------------------【全局变量声明部分】--------------------------------------
	描述:全局变量声明
-----------------------------------------------------------------------------------------------
//int g_nContrastValue; //对比度值
//int g_nBrightValue;  //亮度值
//Mat g_srcImage,g_dstImage;
-----------------------------------【main( )函数】--------------------------------------------
	描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main(   )
//{
//    //改变控制台前景色和背景色
//    system("color 2F");
//
//    // 读入用户提供的图像
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/8.jpg");
//    if( !g_srcImage.data ) { printf("读取g_srcImage图片错误~! \n"); return false; }
//    g_dstImage = Mat::zeros( g_srcImage.size(), g_srcImage.type() );
//
//    //设定对比度和亮度的初值
//    g_nContrastValue=80;
//    g_nBrightValue=80;
//
//    //创建窗口
//    namedWindow("【效果图窗口】", 1);
//
//    //创建轨迹条
//    createTrackbar("对比度:", "【效果图窗口】",&g_nContrastValue, 300,ContrastAndBright );
//    createTrackbar("亮   度:", "【效果图窗口】",&g_nBrightValue, 200,ContrastAndBright );
//
//    //调用回调函数
//    ContrastAndBright(g_nContrastValue,0);
//    ContrastAndBright(g_nBrightValue,0);
//
//    //输出一些帮助信息
//    cout<<endl<<"\t运行成功,请调整滚动条观察图像效果\n\n"
//        <<"\t按下“q”键时,程序退出\n";
//
//    //按下“q”键时,程序退出
//    while(char(waitKey(1)) != 'q') {}
//    return 0;
//}
//
//
//
//
-----------------------------【ContrastAndBright( )函数】------------------------------------
	描述:改变图像对比度和亮度值的回调函数
-----------------------------------------------------------------------------------------------
//static void ContrastAndBright(int, void *)
//{
//
//    // 创建窗口
//    namedWindow("【原始图窗口】", 1);
//
//    // 三个for循环,执行运算 g_dstImage(i,j) = a*g_srcImage(i,j) + b
//    for( int y = 0; y < g_srcImage.rows; y++ )
//    {
//        for( int x = 0; x < g_srcImage.cols; x++ )
//        {
//            for( int c = 0; c < 3; c++ )
//            {
//                g_dstImage.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( (g_nContrastValue*0.01)*( g_srcImage.at<Vec3b>(y,x)[c] ) + g_nBrightValue );
//            }
//        }
//    }
//
//    // 显示图像
//    imshow("【原始图窗口】", g_srcImage);
//    imshow("【效果图窗口】", g_dstImage);
//}
/*









*/

//---------------------------------【头文件、命名空间包含部分】-----------------------------
//		描述:包含程序所使用的头文件和命名空间
//-------------------------------------------------------------------------------------------------
//#include "opencv2/core/core.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//#include "opencv2/highgui/highgui.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
//
--------------------------------------【main( )函数】-----------------------------------------
          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-------------------------------------------------------------------------------------------------
//int main( )
//{
//    //【1】以灰度模式读取原始图像并显示
//    Mat srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/11.tif", 0);
//    if(!srcImage.data ) { printf("读取图片错误,请确定目录下是否有imread函数指定图片存在~! \n"); return false; }
//    imshow("原始图像" , srcImage);
//
//
//    //【2】将输入图像延扩到最佳的尺寸,边界用0补充
//    int m = getOptimalDFTSize( srcImage.rows );
//    int n = getOptimalDFTSize( srcImage.cols );
//    //将添加的像素初始化为0.
//    Mat padded;
//    copyMakeBorder(srcImage, padded, 0, m - srcImage.rows, 0, n - srcImage.cols, BORDER_CONSTANT, Scalar::all(0));
//    cout << "srcSize:" << srcImage.size()  << endl;
//    cout << padded.size() << endl;
//    //【3】为傅立叶变换的结果(实部和虚部)分配存储空间。
//    //将planes数组组合合并成一个多通道的数组complexI
//    Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
//    Mat complexI;
//    merge(planes, 2, complexI);
//
//    //【4】进行就地离散傅里叶变换
//    dft(complexI, complexI);
//    cout << complexI.size() << endl;
//    //【5】将复数转换为幅值,即=> log(1 + sqrt(Re(DFT(I))^2 + Im(DFT(I))^2))
//    split(complexI, planes); // 将多通道数组complexI分离成几个单通道数组,planes[0] = Re(DFT(I)), planes[1] = Im(DFT(I))
//    magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude计算二维矢量的幅值
//    Mat magnitudeImage = planes[0];
//    //【6】进行对数尺度(logarithmic scale)缩放
//    magnitudeImage += Scalar::all(1);
//    imshow("beforelog",magnitudeImage);
//    log(magnitudeImage, magnitudeImage);//求自然对数
//    normalize(magnitudeImage, magnitudeImage, 0, 1, NORM_MINMAX);
//    imshow("afterlognor", magnitudeImage);
//    //【7】剪切和重分布幅度图象限
//    //若有奇数行或奇数列,进行频谱裁剪
//    magnitudeImage = magnitudeImage(Rect(0, 0, magnitudeImage.cols & -2, magnitudeImage.rows & -2));
//    //重新排列傅立叶图像中的象限,使得原点位于图像中心
//    int cx = magnitudeImage.cols/2;
//    int cy = magnitudeImage.rows/2;
//    Mat q0(magnitudeImage, Rect(0, 0, cx, cy));   // ROI区域的左上
//    Mat q1(magnitudeImage, Rect(cx, 0, cx, cy));  // ROI区域的右上
//    Mat q2(magnitudeImage, Rect(0, cy, cx, cy));  // ROI区域的左下
//    Mat q3(magnitudeImage, Rect(cx, cy, cx, cy)); // ROI区域的右下
//    //交换象限(左上与右下进行交换)
//    Mat tmp;
//    q0.copyTo(tmp);
//    q3.copyTo(q0);
//    tmp.copyTo(q3);
//    //交换象限(右上与左下进行交换)
//    q1.copyTo(tmp);
//    q2.copyTo(q1);
//    tmp.copyTo(q2);
//
//    //【8】归一化,用0到1之间的浮点值将矩阵变换为可视的图像格式
//    //此句代码的OpenCV2版为:
//    //normalize(magnitudeImage, magnitudeImage, 0, 1, CV_MINMAX);
//    //此句代码的OpenCV3版为:
//    normalize(magnitudeImage, magnitudeImage, 0, 1, NORM_MINMAX);
//
//    //【9】显示效果图
//    imshow("频谱幅值", magnitudeImage);
//    waitKey();
//
//    return 0;
//}

/*








*/

//--------------------------------------【程序说明】-------------------------------------------
//		程序说明:《OpenCV3编程入门》OpenCV3版书本配套示例程序37
//		程序描述:五种图像滤波综合示例
//		开发测试所用操作系统: Windows 7 64bit
//		开发测试所用IDE版本:Visual Studio 2010
//		开发测试所用OpenCV版本:	3.0 beta
//		2014年11月 Created by @浅墨_毛星云
//		2014年12月 Revised by @浅墨_毛星云
//------------------------------------------------------------------------------------------------

//-----------------------------------【头文件包含部分】---------------------------------------
//		描述:包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
//#include <opencv2/core/core.hpp>
//#include <opencv2/highgui/highgui.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//#include <iostream>
//
-----------------------------------【命名空间声明部分】---------------------------------------
		描述:包含程序所使用的命名空间
-----------------------------------------------------------------------------------------------
//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 *);			//双边滤波器
//
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main(   )
//{
//    system("color 4F");
//
//    // 载入原图
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/12.jpg", 1 );
//    if( !g_srcImage.data ) { printf("读取srcImage错误~! \n"); return false; }
//
//    //克隆原图到四个Mat类型中
//    g_dstImage1 = g_srcImage.clone( );
//    g_dstImage2 = g_srcImage.clone( );
//    g_dstImage3 = g_srcImage.clone( );
//    g_dstImage4 = g_srcImage.clone( );
//    g_dstImage5 = g_srcImage.clone( );
//
//    //显示原图
//    namedWindow("【<0>原图窗口】", 1);
//    imshow("【<0>原图窗口】",g_srcImage);
//
//
//    //=================【<1>方框滤波】=========================
//    //创建窗口
//    namedWindow("【<1>方框滤波】", 1);
//    //创建轨迹条
//    createTrackbar("内核值:", "【<1>方框滤波】",&g_nBoxFilterValue, 50,on_BoxFilter );
//    on_MeanBlur(g_nBoxFilterValue,0);
//    imshow("【<1>方框滤波】", g_dstImage1);
//    //=====================================================
//
//
//    //=================【<2>均值滤波】==========================
//    //创建窗口
//    namedWindow("【<2>均值滤波】", 1);
//    //创建轨迹条
//    createTrackbar("内核值:", "【<2>均值滤波】",&g_nMeanBlurValue, 50,on_MeanBlur );
//    on_MeanBlur(g_nMeanBlurValue,0);
//    //======================================================
//
//
//    //=================【<3>高斯滤波】===========================
//    //创建窗口
//    namedWindow("【<3>高斯滤波】", 1);
//    //创建轨迹条
//    createTrackbar("内核值:", "【<3>高斯滤波】",&g_nGaussianBlurValue, 50,on_GaussianBlur );
//    on_GaussianBlur(g_nGaussianBlurValue,0);
//    //=======================================================
//
//
//    //=================【<4>中值滤波】===========================
//    //创建窗口
//    namedWindow("【<4>中值滤波】", 1);
//    //创建轨迹条
//    createTrackbar("参数值:", "【<4>中值滤波】",&g_nMedianBlurValue, 50,on_MedianBlur );
//    on_MedianBlur(g_nMedianBlurValue,0);
//    //=======================================================
//
//
//    //=================【<5>双边滤波】===========================
//    //创建窗口
//    namedWindow("【<5>双边滤波】", 1);
//    //创建轨迹条
//    createTrackbar("参数值:", "【<5>双边滤波】",&g_nBilateralFilterValue, 50,on_BilateralFilter);
//    on_BilateralFilter(g_nBilateralFilterValue,0);
//    //=======================================================
//
//
//    //输出一些帮助信息
//    cout<<endl<<"\t运行成功,请调整滚动条观察图像效果~\n\n"
//        <<"\t按下“q”键时,程序退出。\n";
//    while(char(waitKey(1)) != 'q') {}
//
//    return 0;
//}
//
-----------------------------【on_BoxFilter( )函数】------------------------------------
		描述:方框滤波操作的回调函数
-----------------------------------------------------------------------------------------------
//static void on_BoxFilter(int, void *)
//{
//    //方框滤波操作
//    boxFilter( g_srcImage, g_dstImage1, -1,Size( g_nBoxFilterValue+1, g_nBoxFilterValue+1));
//    //显示窗口
//    imshow("【<1>方框滤波】", g_dstImage1);
//}
//
-----------------------------【on_MeanBlur( )函数】------------------------------------
		描述:均值滤波操作的回调函数
-----------------------------------------------------------------------------------------------
//static void on_MeanBlur(int, void *)
//{
//    blur( g_srcImage, g_dstImage2, Size( g_nMeanBlurValue+1, g_nMeanBlurValue+1), Point(-1,-1));
//    imshow("【<2>均值滤波】", g_dstImage2);
//
//}
//
-----------------------------【on_GaussianBlur( )函数】------------------------------------
		描述:高斯滤波操作的回调函数
-----------------------------------------------------------------------------------------------
//static void on_GaussianBlur(int, void *)
//{
//    GaussianBlur( g_srcImage, g_dstImage3, Size( g_nGaussianBlurValue*2+1, g_nGaussianBlurValue*2+1 ), 0, 0);
//    imshow("【<3>高斯滤波】", g_dstImage3);
//}
//
//
-----------------------------【on_MedianBlur( )函数】------------------------------------
		描述:中值滤波操作的回调函数
-----------------------------------------------------------------------------------------------
//static void on_MedianBlur(int, void *)
//{
//    medianBlur ( g_srcImage, g_dstImage4, g_nMedianBlurValue*2+1 );
//    imshow("【<4>中值滤波】", g_dstImage4);
//}
//
//
-----------------------------【on_BilateralFilter( )函数】------------------------------------
		描述:双边滤波操作的回调函数
-----------------------------------------------------------------------------------------------
//static void on_BilateralFilter(int, void *)
//{
//    bilateralFilter ( g_srcImage, g_dstImage5, g_nBilateralFilterValue, g_nBilateralFilterValue*2, g_nBilateralFilterValue/2 );
//    imshow("【<5>双边滤波】", g_dstImage5);
//}
/*







*/

//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include <opencv2/highgui/highgui.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace std;
//using namespace cv;
//
//
-----------------------------------【全局变量声明部分】-----------------------------------
		描述:全局变量声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage, g_dstImage;//原始图和效果图
//int g_nElementShape = MORPH_RECT;//元素结构的形状
//
变量接收的TrackBar位置参数
//int g_nMaxIterationNum = 10;
//int g_nOpenCloseNum = 0;
//int g_nErodeDilateNum = 0;
//int g_nTopBlackHatNum = 0;
//
//
//
-----------------------------------【全局函数声明部分】--------------------------------------
		描述:全局函数声明
-----------------------------------------------------------------------------------------------
//static void on_OpenClose(int, void*);//回调函数
//static void on_ErodeDilate(int, void*);//回调函数
//static void on_TopBlackHat(int, void*);//回调函数
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main( )
//{
//    //改变console字体颜色
//    system("color 2F");
//
//    //载入原图
//    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/13.jpg");
//    if( !g_srcImage.data ) { printf("Oh,no,读取srcImage错误~! \n"); return false; }
//
//    //显示原始图
//    namedWindow("【原始图】");
//    imshow("【原始图】", g_srcImage);
//
//    //创建三个窗口
//    namedWindow("【开运算/闭运算】",1);
//    namedWindow("【腐蚀/膨胀】",1);
//    namedWindow("【顶帽/黑帽】",1);
//
//    //参数赋值
//    g_nOpenCloseNum=9;
//    g_nErodeDilateNum=9;
//    g_nTopBlackHatNum=2;
//
//    //分别为三个窗口创建滚动条
//    createTrackbar("迭代值", "【开运算/闭运算】",&g_nOpenCloseNum,g_nMaxIterationNum*2+1,on_OpenClose);
//    createTrackbar("迭代值", "【腐蚀/膨胀】",&g_nErodeDilateNum,g_nMaxIterationNum*2+1,on_ErodeDilate);
//    createTrackbar("迭代值", "【顶帽/黑帽】",&g_nTopBlackHatNum,g_nMaxIterationNum*2+1,on_TopBlackHat);
//
//    //轮询获取按键信息
//    while(1)
//    {
//        int c;
//
//        //执行回调函数
//        on_OpenClose(g_nOpenCloseNum, 0);
//        on_ErodeDilate(g_nErodeDilateNum, 0);
//        on_TopBlackHat(g_nTopBlackHatNum,0);
//
//        //获取按键
//        c = waitKey(0);
//
//        //按下键盘按键Q或者ESC,程序退出
//        if( (char)c == 'q'||(char)c == 27 )
//            break;
//        //按下键盘按键1,使用椭圆(Elliptic)结构元素结构元素MORPH_ELLIPSE
//        if( (char)c == 49 )//键盘按键1的ASII码为49
//            g_nElementShape = MORPH_ELLIPSE;
//            //按下键盘按键2,使用矩形(Rectangle)结构元素MORPH_RECT
//        else if( (char)c == 50 )//键盘按键2的ASII码为50
//            g_nElementShape = MORPH_RECT;
//            //按下键盘按键3,使用十字形(Cross-shaped)结构元素MORPH_CROSS
//        else if( (char)c == 51 )//键盘按键3的ASII码为51
//            g_nElementShape = MORPH_CROSS;
//            //按下键盘按键space,在矩形、椭圆、十字形结构元素中循环
//        else if( (char)c == ' ' )
//            g_nElementShape = (g_nElementShape + 1) % 3;
//    }
//
//    return 0;
//}
//
//
-----------------------------------【on_OpenClose( )函数】----------------------------------
		描述:【开运算/闭运算】窗口的回调函数
-----------------------------------------------------------------------------------------------
//static void on_OpenClose(int, void*)
//{
//    //偏移量的定义
//    int offset = g_nOpenCloseNum - g_nMaxIterationNum;//偏移量
//    int Absolute_offset = offset > 0 ? offset : -offset;//偏移量绝对值
//    //自定义核
//    Mat element = getStructuringElement(g_nElementShape, Size(Absolute_offset*2+1, Absolute_offset*2+1), Point(Absolute_offset, Absolute_offset) );
//    //进行操作
//    if( offset < 0 )
//        //此句代码的OpenCV2版为:
//        //morphologyEx(g_srcImage, g_dstImage, CV_MOP_OPEN, element);
//        //此句代码的OpenCV3版为:
//        morphologyEx(g_srcImage, g_dstImage, MORPH_OPEN, element);
//    else
//        //此句代码的OpenCV2版为:
//        //morphologyEx(g_srcImage, g_dstImage, CV_MOP_CLOSE, element);
//        //此句代码的OpenCV3版为:
//        morphologyEx(g_srcImage, g_dstImage, MORPH_CLOSE, element);
//
//
//
//    //显示图像
//    imshow("【开运算/闭运算】",g_dstImage);
//}
//
//
-----------------------------------【on_ErodeDilate( )函数】----------------------------------
		描述:【腐蚀/膨胀】窗口的回调函数
-----------------------------------------------------------------------------------------------
//static void on_ErodeDilate(int, void*)
//{
//    //偏移量的定义
//    int offset = g_nErodeDilateNum - g_nMaxIterationNum;	//偏移量
//    int Absolute_offset = offset > 0 ? offset : -offset;//偏移量绝对值
//    //自定义核
//    Mat element = getStructuringElement(g_nElementShape, Size(Absolute_offset*2+1, Absolute_offset*2+1), Point(Absolute_offset, Absolute_offset) );
//    //进行操作
//    if( offset < 0 )
//        erode(g_srcImage, g_dstImage, element);
//    else
//        dilate(g_srcImage, g_dstImage, element);
//    //显示图像
//    imshow("【腐蚀/膨胀】",g_dstImage);
//}
//
//
-----------------------------------【on_TopBlackHat( )函数】--------------------------------
		描述:【顶帽运算/黑帽运算】窗口的回调函数
----------------------------------------------------------------------------------------------
//static void on_TopBlackHat(int, void*)
//{
//    //偏移量的定义
//    int offset = g_nTopBlackHatNum - g_nMaxIterationNum;//偏移量
//    int Absolute_offset = offset > 0 ? offset : -offset;//偏移量绝对值
//    //自定义核
//    Mat element = getStructuringElement(g_nElementShape, Size(Absolute_offset*2+1, Absolute_offset*2+1), Point(Absolute_offset, Absolute_offset) );
//    //进行操作
//    if( offset < 0 )
//        morphologyEx(g_srcImage, g_dstImage, MORPH_TOPHAT , element);
//    else
//        morphologyEx(g_srcImage, g_dstImage, MORPH_BLACKHAT, element);
//    //显示图像
//    imshow("【顶帽/黑帽】",g_dstImage);
//}
/*











*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/imgproc/imgproc.hpp"
//#include "opencv2/highgui/highgui.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
      描述:全局变量声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage, g_dstImage, g_grayImage, g_maskImage;//定义原始图、目标图、灰度图、掩模图
//int g_nFillMode = 1;//漫水填充的模式
//int g_nLowDifference = 20, g_nUpDifference = 20;//负差最大值、正差最大值
//int g_nConnectivity = 4;//表示floodFill函数标识符低八位的连通值
//int g_bIsColor = true;//是否为彩色图的标识符布尔值
//bool g_bUseMask = false;//是否显示掩膜窗口的布尔值
//int g_nNewMaskVal = 255;//新的重新绘制的像素值
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
      描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第50个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf("\n\n\t欢迎来到漫水填充示例程序~");
//    printf("\n\n\t本示例根据鼠标选取的点搜索图像中与之颜色相近的点,并用不同颜色标注。");
//
//    printf( "\n\n\t按键操作说明: \n\n"
//            "\t\t鼠标点击图中区域- 进行漫水填充操作\n"
//            "\t\t键盘按键【ESC】- 退出程序\n"
//            "\t\t键盘按键【1】-  切换彩色图/灰度图模式\n"
//            "\t\t键盘按键【2】- 显示/隐藏掩膜窗口\n"
//            "\t\t键盘按键【3】- 恢复原始图像\n"
//            "\t\t键盘按键【4】- 使用空范围的漫水填充\n"
//            "\t\t键盘按键【5】- 使用渐变、固定范围的漫水填充\n"
//            "\t\t键盘按键【6】- 使用渐变、浮动范围的漫水填充\n"
//            "\t\t键盘按键【7】- 操作标志符的低八位使用4位的连接模式\n"
//            "\t\t键盘按键【8】- 操作标志符的低八位使用8位的连接模式\n\n" 	);
//}
//
//
-----------------------------------【onMouse( )函数】--------------------------------------
      描述:鼠标消息onMouse回调函数
---------------------------------------------------------------------------------------------
//static void onMouse( int event, int x, int y, int, void* )
//{
//    // 若鼠标左键没有按下,便返回
//    //此句代码的OpenCV2版为:
//    //if( event != CV_EVENT_LBUTTONDOWN )
//    //此句代码的OpenCV3版为:
//    if( event != EVENT_LBUTTONDOWN )
//        return;
//
//    //-------------------【<1>调用floodFill函数之前的参数准备部分】---------------
//    Point seed = Point(x,y);
//    int LowDifference = g_nFillMode == 0 ? 0 : g_nLowDifference;//空范围的漫水填充,此值设为0,否则设为全局的g_nLowDifference
//    int UpDifference = g_nFillMode == 0 ? 0 : g_nUpDifference;//空范围的漫水填充,此值设为0,否则设为全局的g_nUpDifference
//
//    //标识符的0~7位为g_nConnectivity,8~15位为g_nNewMaskVal左移8位的值,16~23位为CV_FLOODFILL_FIXED_RANGE或者0。
//    //此句代码的OpenCV2版为:
//    //int flags = g_nConnectivity + (g_nNewMaskVal << 8) +(g_nFillMode == 1 ? CV_FLOODFILL_FIXED_RANGE : 0);
//    //此句代码的OpenCV3版为:
//    int flags = g_nConnectivity + (g_nNewMaskVal << 8) +(g_nFillMode == 1 ? FLOODFILL_FIXED_RANGE : 0);
//
//    //随机生成bgr值
//    int b = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
//    int g = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
//    int r = (unsigned)theRNG() & 255;//随机返回一个0~255之间的值
//    Rect ccomp;//定义重绘区域的最小边界矩形区域
//
//    Scalar newVal = g_bIsColor ? Scalar(b, g, r) : Scalar(r*0.299 + g*0.587 + b*0.114);//在重绘区域像素的新值,若是彩色图模式,取Scalar(b, g, r);若是灰度图模式,取Scalar(r*0.299 + g*0.587 + b*0.114)
//
//    Mat dst = g_bIsColor ? g_dstImage : g_grayImage;//目标图的赋值
//    int area;
//
//    //--------------------【<2>正式调用floodFill函数】-----------------------------
//    if( g_bUseMask )
//    {
//        //此句代码的OpenCV2版为:
//        //threshold(g_maskImage, g_maskImage, 1, 128, CV_THRESH_BINARY);
//        //此句代码的OpenCV3版为:
//        threshold(g_maskImage, g_maskImage, 1, 128, THRESH_BINARY);
//        area = floodFill(dst, g_maskImage, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference),
//                         Scalar(UpDifference, UpDifference, UpDifference), flags);
//        imshow( "mask", g_maskImage );
//    }
//    else
//    {
//        area = floodFill(dst, seed, newVal, &ccomp, Scalar(LowDifference, LowDifference, LowDifference),
//                         Scalar(UpDifference, UpDifference, UpDifference), flags);
//    }
//
//    imshow("效果图", dst);
//    cout << area << " 个像素被重绘\n";
//}
//
//
-----------------------------------【main( )函数】--------------------------------------------
      描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //改变console字体颜色
//    system("color 2F");
//
//    //载入原图
//    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/14.jpg", 1);
//
//    if( !g_srcImage.data ) { printf("读取图片image0错误~! \n"); return false; }
//
//    //显示帮助文字
//    ShowHelpText();
//
//    g_srcImage.copyTo(g_dstImage);//拷贝源图到目标图
//    cvtColor(g_srcImage, g_grayImage, COLOR_BGR2GRAY);//转换三通道的image0到灰度图
//    g_maskImage.create(g_srcImage.rows+2, g_srcImage.cols+2, CV_8UC1);//利用image0的尺寸来初始化掩膜mask
//
//    //此句代码的OpenCV2版为:
//    //namedWindow( "效果图",CV_WINDOW_AUTOSIZE );
//    //此句代码的OpenCV2版为:
//    namedWindow( "效果图",WINDOW_AUTOSIZE );
//
//
//    //创建Trackbar
//    createTrackbar( "负差最大值", "效果图", &g_nLowDifference, 255, 0 );
//    createTrackbar( "正差最大值" ,"效果图", &g_nUpDifference, 255, 0 );
//
//    //鼠标回调函数
//    setMouseCallback( "效果图", onMouse, 0 );
//
//    //循环轮询按键
//    while(1)
//    {
//        //先显示效果图
//        imshow("效果图", g_bIsColor ? g_dstImage : g_grayImage);
//
//        //获取键盘按键
//        int c = waitKey(0);
//        //判断ESC是否按下,若按下便退出
//        if( (c & 255) == 27 )
//        {
//            cout << "程序退出...........\n";
//            break;
//        }
//
//        //根据按键的不同,进行各种操作
//        switch( (char)c )
//        {
//            //如果键盘“1”被按下,效果图在在灰度图,彩色图之间互换
//            case '1':
//                if( g_bIsColor )//若原来为彩色,转为灰度图,并且将掩膜mask所有元素设置为0
//                {
//                    cout << "键盘“1”被按下,切换彩色/灰度模式,当前操作为将【彩色模式】切换为【灰度模式】\n";
//                    cvtColor(g_srcImage, g_grayImage, COLOR_BGR2GRAY);
//                    g_maskImage = Scalar::all(0);	//将mask所有元素设置为0
//                    g_bIsColor = false;	//将标识符置为false,表示当前图像不为彩色,而是灰度
//                }
//                else//若原来为灰度图,便将原来的彩图image0再次拷贝给image,并且将掩膜mask所有元素设置为0
//                {
//                    cout << "键盘“1”被按下,切换彩色/灰度模式,当前操作为将【彩色模式】切换为【灰度模式】\n";
//                    g_srcImage.copyTo(g_dstImage);
//                    g_maskImage = Scalar::all(0);
//                    g_bIsColor = true;//将标识符置为true,表示当前图像模式为彩色
//                }
//                break;
//                //如果键盘按键“2”被按下,显示/隐藏掩膜窗口
//            case '2':
//                if( g_bUseMask )
//                {
//                    destroyWindow( "mask" );
//                    g_bUseMask = false;
//                }
//                else
//                {
//                    namedWindow( "mask", 0 );
//                    g_maskImage = Scalar::all(0);
//                    imshow("mask", g_maskImage);
//                    g_bUseMask = true;
//                }
//                break;
//                //如果键盘按键“3”被按下,恢复原始图像
//            case '3':
//                cout << "按键“3”被按下,恢复原始图像\n";
//                g_srcImage.copyTo(g_dstImage);
//                cvtColor(g_dstImage, g_grayImage, COLOR_BGR2GRAY);
//                g_maskImage = Scalar::all(0);
//                break;
//                //如果键盘按键“4”被按下,使用空范围的漫水填充
//            case '4':
//                cout << "按键“4”被按下,使用空范围的漫水填充\n";
//                g_nFillMode = 0;
//                break;
//                //如果键盘按键“5”被按下,使用渐变、固定范围的漫水填充
//            case '5':
//                cout << "按键“5”被按下,使用渐变、固定范围的漫水填充\n";
//                g_nFillMode = 1;
//                break;
//                //如果键盘按键“6”被按下,使用渐变、浮动范围的漫水填充
//            case '6':
//                cout << "按键“6”被按下,使用渐变、浮动范围的漫水填充\n";
//                g_nFillMode = 2;
//                break;
//                //如果键盘按键“7”被按下,操作标志符的低八位使用4位的连接模式
//            case '7':
//                cout << "按键“7”被按下,操作标志符的低八位使用4位的连接模式\n";
//                g_nConnectivity = 4;
//                break;
//                //如果键盘按键“8”被按下,操作标志符的低八位使用8位的连接模式
//            case '8':
//                cout << "按键“8”被按下,操作标志符的低八位使用8位的连接模式\n";
//                g_nConnectivity = 8;
//                break;
//        }
//    }
//
//    return 0;
//}
/*











*/
//#include "opencv2/imgproc/imgproc.hpp"
//#include "opencv2/highgui/highgui.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
-----------------------------------【宏定义部分】--------------------------------------------
		描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME "【程序窗口】"        //为窗口标题定义的宏
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//int g_nThresholdValue = 100;
//int g_nThresholdType = 3;
//Mat g_srcImage, g_grayImage, g_dstImage;
//
-----------------------------------【全局函数声明部分】--------------------------------------
		描述:全局函数的声明
-----------------------------------------------------------------------------------------------
//static void ShowHelpText( );//输出帮助文字
//void on_Threshold( int, void* );//回调函数
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( )
//{
//    //【0】改变console字体颜色
//    system("color 1F");
//
//    //【0】显示欢迎和帮助文字
//    ShowHelpText( );
//
//    //【1】读入源图片
//    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/15.jpg");
//    if(!g_srcImage.data ) { printf("读取图片错误,请确定目录下是否有imread函数指定的图片存在~! \n"); return false; }
//    imshow("原始图",g_srcImage);
//
//    //【2】存留一份原图的灰度图
//    cvtColor( g_srcImage, g_grayImage, COLOR_RGB2GRAY );
//
//    //【3】创建窗口并显示原始图
//    namedWindow( WINDOW_NAME, WINDOW_AUTOSIZE );
//
//    //【4】创建滑动条来控制阈值
//    createTrackbar( "模式",
//                    WINDOW_NAME, &g_nThresholdType,
//                    4, on_Threshold );
//
//    createTrackbar( "参数值",
//                    WINDOW_NAME, &g_nThresholdValue,
//                    255, on_Threshold );
//
//    //【5】初始化自定义的阈值回调函数
//    on_Threshold( 0, 0 );
//
//    // 【6】轮询等待用户按键,如果ESC键按下则退出程序
//    while(1)
//    {
//        int key;
//        key = waitKey( 20 );
//        if( (char)key == 27 ){ break; }
//    }
//
//}
//
-----------------------------------【on_Threshold( )函数】------------------------------------
		描述:自定义的阈值回调函数
-----------------------------------------------------------------------------------------------
//void on_Threshold( int, void* )
//{
//    //调用阈值函数
//    threshold(g_grayImage,g_dstImage,g_nThresholdValue,255,g_nThresholdType);
//
//    //更新效果图
//    imshow( WINDOW_NAME, g_dstImage );
//}
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
      描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第55个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf(	"\n\t欢迎来到【基本阈值操作】示例程序~\n\n");
//    printf(	"\n\t按键操作说明: \n\n"
//               "\t\t键盘按键【ESC】- 退出程序\n"
//               "\t\t滚动条模式0- 二进制阈值\n"
//               "\t\t滚动条模式1- 反二进制阈值\n"
//               "\t\t滚动条模式2- 截断阈值\n"
//               "\t\t滚动条模式3- 反阈值化为0\n"
//               "\t\t滚动条模式4- 阈值化为0\n"  );
//}
/*










*/
//-----------------------------------【头文件包含部分】---------------------------------------
//            描述:包含程序所依赖的头文件
//----------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include<opencv2/highgui/highgui.hpp>
//#include<opencv2/imgproc/imgproc.hpp>
//
-----------------------------------【命名空间声明部分】---------------------------------------
            描述:包含程序所使用的命名空间
-----------------------------------------------------------------------------------------------
//using namespace cv;
-----------------------------------【main( )函数】--------------------------------------------
            描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main( )
//{
//    //【0】创建 grad_x 和 grad_y 矩阵
//    Mat grad_x, grad_y;
//    Mat abs_grad_x, abs_grad_y,dst;
//
//    //【1】载入原始图
//    Mat src = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/16.jpg");  //工程目录下应该有一张名为1.jpg的素材图
//
//    //【2】显示原始图
//    imshow("【原始图】sobel边缘检测", src);
//
//    //【3】求 X方向梯度
//    Sobel( src, grad_x, CV_16S, 1, 0, 3, 1, 1, BORDER_DEFAULT );
//    convertScaleAbs( grad_x, abs_grad_x );
//    imshow("【效果图】 X方向Sobel", abs_grad_x);
//
//    //【4】求Y方向梯度
//    Sobel( src, grad_y, CV_16S, 0, 1, 3, 1, 1, BORDER_DEFAULT );
//    convertScaleAbs( grad_y, abs_grad_y );
//    imshow("【效果图】Y方向Sobel", abs_grad_y);
//
//    //【5】合并梯度(近似)
//    addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dst );
//    imshow("【效果图】整体方向Sobel", dst);
//
//    waitKey(0);
//    return 0;
//}
/*









*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include <opencv2/highgui/highgui.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量声明
-----------------------------------------------------------------------------------------------
原图,原图的灰度版,目标图
//Mat g_srcImage, g_srcGrayImage,g_dstImage;
//
Canny边缘检测相关变量
//Mat g_cannyDetectedEdges;
//int g_cannyLowThreshold=1;//TrackBar位置参数
//
Sobel边缘检测相关变量
//Mat g_sobelGradient_X, g_sobelGradient_Y;
//Mat g_sobelAbsGradient_X, g_sobelAbsGradient_Y;
//int g_sobelKernelSize=1;//TrackBar位置参数
//
Scharr滤波器相关变量
//Mat g_scharrGradient_X, g_scharrGradient_Y;
//Mat g_scharrAbsGradient_X, g_scharrAbsGradient_Y;
//
//
-----------------------------------【全局函数声明部分】--------------------------------------
		描述:全局函数声明
-----------------------------------------------------------------------------------------------
//static void ShowHelpText( );
//static void on_Canny(int, void*);//Canny边缘检测窗口滚动条的回调函数
//static void on_Sobel(int, void*);//Sobel边缘检测窗口滚动条的回调函数
//void Scharr( );//封装了Scharr边缘检测相关代码的函数
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //改变console字体颜色
//    system("color 2F");
//
//    //显示欢迎语
//    ShowHelpText();
//
//    //载入原图
//    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/16.jpg");
//    if( !g_srcImage.data ) { printf("Oh,no,读取srcImage错误~! \n"); return false; }
//
//    //显示原始图
//    namedWindow("【原始图】");
//    imshow("【原始图】", g_srcImage);
//
//    // 创建与src同类型和大小的矩阵(dst)
//    g_dstImage.create( g_srcImage.size(), g_srcImage.type() );
//
//    // 将原图像转换为灰度图像
//    cvtColor( g_srcImage, g_srcGrayImage, COLOR_BGR2GRAY );
//
//    // 创建显示窗口
//    namedWindow( "【效果图】Canny边缘检测", WINDOW_AUTOSIZE );
//    namedWindow( "【效果图】Sobel边缘检测", WINDOW_AUTOSIZE );
//
//    // 创建trackbar
//    createTrackbar( "参数值:", "【效果图】Canny边缘检测", &g_cannyLowThreshold, 120, on_Canny );
//    createTrackbar( "参数值:", "【效果图】Sobel边缘检测", &g_sobelKernelSize, 3, on_Sobel );
//
//    // 调用回调函数
//    on_Canny(0, 0);
//    on_Sobel(0, 0);
//
//    //调用封装了Scharr边缘检测代码的函数
//    Scharr( );
//
//    //轮询获取按键信息,若按下Q,程序退出
//    while((char(waitKey(1)) != 'q')) {}
//
//    return 0;
//}
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
		描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第60个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf( "\n\n\t运行成功,请调整滚动条观察图像效果~\n\n"
//            "\t按下“q”键时,程序退出。\n");
//}
//
//
-----------------------------------【on_Canny( )函数】----------------------------------
		描述:Canny边缘检测窗口滚动条的回调函数
-----------------------------------------------------------------------------------------------
//void on_Canny(int, void*)
//{
//    // 先使用 3x3内核来降噪
//    blur( g_srcGrayImage, g_cannyDetectedEdges, Size(3,3) );
//
//    // 运行我们的Canny算子
//    Canny( g_cannyDetectedEdges, g_cannyDetectedEdges, g_cannyLowThreshold, g_cannyLowThreshold*3, 3 );
//
//    //先将g_dstImage内的所有元素设置为0
//    g_dstImage = Scalar::all(0);
//
//    //使用Canny算子输出的边缘图g_cannyDetectedEdges作为掩码,来将原图g_srcImage拷到目标图g_dstImage中
//    g_srcImage.copyTo( g_dstImage, g_cannyDetectedEdges);
//
//    //显示效果图
//    imshow( "【效果图】Canny边缘检测", g_dstImage );
//}
//
//
//
-----------------------------------【on_Sobel( )函数】----------------------------------
		描述:Sobel边缘检测窗口滚动条的回调函数
-----------------------------------------------------------------------------------------
//void on_Sobel(int, void*)
//{
//    // 求 X方向梯度
//    Sobel( g_srcImage, g_sobelGradient_X, CV_16S, 1, 0, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
//    convertScaleAbs( g_sobelGradient_X, g_sobelAbsGradient_X );//计算绝对值,并将结果转换成8位
//
//    // 求Y方向梯度
//    Sobel( g_srcImage, g_sobelGradient_Y, CV_16S, 0, 1, (2*g_sobelKernelSize+1), 1, 1, BORDER_DEFAULT );
//    convertScaleAbs( g_sobelGradient_Y, g_sobelAbsGradient_Y );//计算绝对值,并将结果转换成8位
//
//    // 合并梯度
//    addWeighted( g_sobelAbsGradient_X, 0.5, g_sobelAbsGradient_Y, 0.5, 0, g_dstImage );
//
//    //显示效果图
//    imshow("【效果图】Sobel边缘检测", g_dstImage);
//
//}
//
//
-----------------------------------【Scharr( )函数】----------------------------------
		描述:封装了Scharr边缘检测相关代码的函数
-----------------------------------------------------------------------------------------
//void Scharr( )
//{
//    // 求 X方向梯度
//    Scharr( g_srcImage, g_scharrGradient_X, CV_16S, 1, 0, 1, 0, BORDER_DEFAULT );
//    convertScaleAbs( g_scharrGradient_X, g_scharrAbsGradient_X );//计算绝对值,并将结果转换成8位
//
//    // 求Y方向梯度
//    Scharr( g_srcImage, g_scharrGradient_Y, CV_16S, 0, 1, 1, 0, BORDER_DEFAULT );
//    convertScaleAbs( g_scharrGradient_Y, g_scharrAbsGradient_Y );//计算绝对值,并将结果转换成8位
//
//    // 合并梯度
//    addWeighted( g_scharrAbsGradient_X, 0.5, g_scharrAbsGradient_Y, 0.5, 0, g_dstImage );
//
//    //显示效果图
//    imshow("【效果图】Scharr滤波器", g_dstImage);
//}
/*










*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main( )
//{
//    //【1】载入原始图和Mat变量定义
//    Mat srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/17.jpg");  //工程目录下应该有一张名为1.jpg的素材图
//    Mat midImage,dstImage;//临时变量和目标图的定义
//    cout << CV_VERSION << endl << CV_MAJOR_VERSION << endl << CV_MINOR_VERSION;
//    //【2】进行边缘检测和转化为灰度图
//    Canny(srcImage, midImage, 50, 200, 3);//进行一此canny边缘检测
//    cvtColor(midImage,dstImage, 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;
//        cout << "x0  " << x0 << "  y0  " << y0 << endl;
//        pt1.x = cvRound(x0 + 1000*(-b));
//        pt1.y = cvRound(y0 + 1000*(a));
//        pt2.x = cvRound(x0 - 1000*(-b));
//        pt2.y = cvRound(y0 - 1000*(a));
//        //此句代码的OpenCV2版为:
//        //line( dstImage, pt1, pt2, Scalar(55,100,195), 1, CV_AA);
//        //此句代码的OpenCV3版为:
//        line( dstImage, pt1, pt2, Scalar(55,100,195), 1, CV_AA);
//    }
//
//    //【5】显示原始图
//    imshow("【原始图】", srcImage);
//
//    //【6】边缘检测后的图
//    imshow("【边缘检测后的图】", midImage);
//
//    //【7】显示效果图
//    imshow("【效果图】", dstImage);
//
//    waitKey(0);
//
//    return 0;
//}
/*









*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始
-------------------------------------------------------------------------------------------------
//int main( )
//{
//    //【1】载入原始图和Mat变量定义
//    Mat srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/17.jpg");  //工程目录下应该有一张名为1.jpg的素材图
//    Mat midImage,dstImage;//临时变量和目标图的定义
//
//    //【2】进行边缘检测和转化为灰度图
//    Canny(srcImage, midImage, 50, 200, 3);//进行一此canny边缘检测
//    cvtColor(midImage,dstImage, COLOR_GRAY2BGR);//转化边缘检测后的图为灰度图
//
//    //【3】进行霍夫线变换
//    vector<Vec4i> lines;//定义一个矢量结构lines用于存放得到的线段矢量集合
//    HoughLinesP(midImage, lines, 1, CV_PI/180, 80, 50, 10 );
//
//    //【4】依次在图中绘制出每条线段
//    for( size_t i = 0; i < lines.size(); i++ )
//    {
//        Vec4i l = lines[i];
//        //此句代码的OpenCV2版为:
//        //line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(186,88,255), 1, CV_AA);
//        //此句代码的OpenCV3版为:
//        line( dstImage, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(186,88,255), 1, CV_AA);
//    }
//
//    //【5】显示原始图
//    imshow("【原始图】", srcImage);
//
//    //【6】边缘检测后的图
//    imshow("【边缘检测后的图】", midImage);
//
//    //【7】显示效果图
//    imshow("【效果图】", dstImage);
//
//    waitKey(0);
//
//    return 0;
//}
/*







*/
//---------------------------------【头文件、命名空间包含部分】-------------------------------
//          描述:包含程序所使用的头文件和命名空间
//----------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//using namespace std;
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始
-----------------------------------------------------------------------------------------------
//int main( )
//{
//    //【1】载入原始图、Mat变量定义
//    Mat srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/18.jpg");  //工程目录下应该有一张名为1.jpg的素材图
//    Mat midImage,dstImage;//临时变量和目标图的定义
//
//    //【2】显示原始图
//    imshow("【原始图】", srcImage);
//
//    //【3】转为灰度图并进行图像平滑
//    cvtColor(srcImage,midImage, COLOR_BGR2GRAY);//转化边缘检测后的图为灰度图
//    GaussianBlur( midImage, midImage, Size(9, 9), 2, 2 );
//
//    //【4】进行霍夫圆变换
//    vector<Vec3f> circles;
//    HoughCircles( midImage, circles, CV_HOUGH_GRADIENT,1.5, 10, 200, 60, 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);
//
//    waitKey(0);
//
//    return 0;
//}
/*










*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【宏定义部分】--------------------------------------------
		描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME1 "【原始图窗口】"			//为窗口标题定义的宏
//#define WINDOW_NAME2 "【轮廓图】"					//为窗口标题定义的宏
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage;
//Mat g_grayImage;
//int g_nThresh = 80;
//int g_nThresh_max = 255;
//RNG g_rng(12345);
//Mat g_cannyMat_output;
//vector<vector<Point>> g_vContours;
//vector<Vec4i> g_vHierarchy;
//
//
-----------------------------------【全局函数声明部分】--------------------------------------
		描述:全局函数的声明
-----------------------------------------------------------------------------------------------
//static void ShowHelpText( );
//void on_ThreshChange(int, void* );
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //【0】改变console字体颜色
//    system("color 1F");
//
//    //【0】显示欢迎和帮助文字
//    ShowHelpText( );
//
//    // 加载源图像
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/19.jpg", 1 );
//    if(!g_srcImage.data ) { printf("读取图片错误,请确定目录下是否有imread函数指定的图片存在~! \n"); return false; }
//
//    // 转成灰度并模糊化降噪
//    cvtColor( g_srcImage, g_grayImage, COLOR_BGR2GRAY );
//    blur( g_grayImage, g_grayImage, Size(3,3) );
//
//    // 创建窗口
//    namedWindow( WINDOW_NAME1, WINDOW_AUTOSIZE );
//    imshow( WINDOW_NAME1, g_srcImage );
//
//    //创建滚动条并初始化
//    createTrackbar( "canny阈值", WINDOW_NAME1, &g_nThresh, g_nThresh_max, on_ThreshChange );
//    on_ThreshChange( 0, 0 );
//
//    waitKey(0);
//    return(0);
//}
//
-----------------------------------【on_ThreshChange( )函数】------------------------------
      描述:回调函数
----------------------------------------------------------------------------------------------
//void on_ThreshChange(int, void* )
//{
//
//    // 用Canny算子检测边缘
//    Canny( g_grayImage, g_cannyMat_output, g_nThresh, g_nThresh*2, 3 );
//
//    // 寻找轮廓
//    findContours( g_cannyMat_output, g_vContours, g_vHierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) );
//
//    // 绘出轮廓
//    Mat drawing = Mat::zeros( g_cannyMat_output.size(), CV_8UC3 );
//    for( int i = 0; i< g_vContours.size(); i++ )
//    {
//        Scalar color = Scalar( g_rng.uniform(0, 255), g_rng.uniform(0,255), g_rng.uniform(0,255) );//任意值
//        drawContours( drawing, g_vContours, i, color, 2, 8, g_vHierarchy, 0, Point() );
//    }
//
//    // 显示效果图
//    imshow( WINDOW_NAME2, drawing );
//}
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
      描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第70个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf(   "\n\n\t欢迎来到【在图形中寻找轮廓】示例程序~\n\n");
//    printf(   "\n\n\t按键操作说明: \n\n"
//              "\t\t键盘按键任意键- 退出程序\n\n"
//              "\t\t滑动滚动条-改变阈值\n" );
//}
/*









*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【宏定义部分】--------------------------------------------
		描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME1 "【原始图】"					//为窗口标题定义的宏
//#define WINDOW_NAME2 "【图像轮廓】"        //为窗口标题定义的宏
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage; Mat g_grayImage;
//int g_nThresh = 100;
//int g_nMaxThresh = 255;
//RNG g_rng(12345);
//Mat g_cannyMat_output;
//vector<vector<Point> > g_vContours;
//vector<Vec4i> g_vHierarchy;
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//void on_ThreshChange(int, void* );
//static void ShowHelpText( );
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //【0】改变console字体颜色
//    system("color 9F");
//
//    ShowHelpText();
//    // 读入原图像, 返回3通道图像数据
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/20.jpg", 1 );
//
//    // 把原图像转化成灰度图像并进行平滑
//    cvtColor( g_srcImage, g_grayImage, COLOR_BGR2GRAY );
//    blur( g_grayImage, g_grayImage, Size(3,3) );
//
//    // 创建新窗口
//    namedWindow( WINDOW_NAME1, WINDOW_AUTOSIZE );
//    imshow( WINDOW_NAME1, g_srcImage );
//
//    //创建滚动条并进行初始化
//    createTrackbar( " 阈值", WINDOW_NAME1, &g_nThresh, g_nMaxThresh, on_ThreshChange );
//    on_ThreshChange( 0, 0 );
//
//    waitKey(0);
//    return(0);
//}
//
-----------------------------------【on_ThreshChange( )函数】-------------------------------
		描述:回调函数
-----------------------------------------------------------------------------------------------
//void on_ThreshChange(int, void* )
//{
//    // 使用Canndy检测边缘
//    Canny( g_grayImage, g_cannyMat_output, g_nThresh, g_nThresh*2, 3 );
//
//    // 找到轮廓
//    findContours( g_cannyMat_output, g_vContours, g_vHierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0, 0) );
//
//    // 计算矩
//    vector<Moments> mu(g_vContours.size() );
//    for(unsigned int i = 0; i < g_vContours.size(); i++ )
//    { mu[i] = moments( g_vContours[i], false ); }
//
//    //  计算中心矩
//    vector<Point2f> mc( g_vContours.size() );
//    for( unsigned int i = 0; i < g_vContours.size(); i++ )
//    { mc[i] = Point2f( static_cast<float>(mu[i].m10/mu[i].m00), static_cast<float>(mu[i].m01/mu[i].m00 )); }
//
//    // 绘制轮廓
//    Mat drawing = Mat::zeros( g_cannyMat_output.size(), CV_8UC3 );
//    for( unsigned int i = 0; i< g_vContours.size(); i++ )
//    {
//        Scalar color = Scalar( g_rng.uniform(0, 255), g_rng.uniform(0,255), g_rng.uniform(0,255) );//随机生成颜色值
//        drawContours( drawing, g_vContours, i, color, 2, 8, g_vHierarchy, 0, Point() );//绘制外层和内层轮廓
//        circle( drawing, mc[i], 4, color, -1, 8, 0 );;//绘制圆
//    }
//
//    // 显示到窗口中
//    namedWindow( WINDOW_NAME2, WINDOW_AUTOSIZE );
//    imshow( WINDOW_NAME2, drawing );
//
//    // 通过m00计算轮廓面积并且和OpenCV函数比较
//    printf("\t 输出内容: 面积和轮廓长度\n");
//    for(unsigned  int i = 0; i< g_vContours.size(); i++ )
//    {
//        printf(" >通过m00计算出轮廓[%d]的面积: (M_00) = %.2f \n OpenCV函数计算出的面积=%.2f , 长度: %.2f \n\n", i, mu[i].m00, contourArea(g_vContours[i]), arcLength( g_vContours[i], true ) );
//        Scalar color = Scalar( g_rng.uniform(0, 255), g_rng.uniform(0,255), g_rng.uniform(0,255) );
//        drawContours( drawing, g_vContours, i, color, 2, 8, g_vHierarchy, 0, Point() );
//        circle( drawing, mc[i], 4, color, -1, 8, 0 );
//    }
//}
//
//
-----------------------------------【ShowHelpText( )函数】-----------------------------
		 描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第76个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//}
/*











*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/imgproc/imgproc.hpp"
//#include "opencv2/highgui/highgui.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME1 "【程序窗口1】"        //为窗口标题定义的宏
//#define WINDOW_NAME2 "【分水岭算法效果图】"        //为窗口标题定义的宏
//
-----------------------------------【全局函变量声明部分】--------------------------------------
		描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//Mat g_maskImage, g_srcImage;
//Point prevPt(-1, -1);
//
-----------------------------------【全局函数声明部分】--------------------------------------
		描述:全局函数的声明
-----------------------------------------------------------------------------------------------
//static void ShowHelpText();
//static void on_Mouse( int event, int x, int y, int flags, void* );
//
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //【0】改变console字体颜色
//    system("color 6F");
//
//    //【0】显示帮助文字
//    ShowHelpText( );
//
//    //【1】载入原图并显示,初始化掩膜和灰度图
//    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/21.jpg", 1);
//    imshow( WINDOW_NAME1, g_srcImage );
//    Mat srcImage,grayImage;
//    g_srcImage.copyTo(srcImage);
//    cvtColor(g_srcImage, g_maskImage, COLOR_BGR2GRAY);
//    cvtColor(g_maskImage, grayImage, COLOR_GRAY2BGR);
//    g_maskImage = Scalar::all(0);
//
//    //【2】设置鼠标回调函数
//    setMouseCallback( WINDOW_NAME1, on_Mouse, 0 );
//
//    //【3】轮询按键,进行处理
//    while(1)
//    {
//        //获取键值
//        int c = waitKey(0);
//
//        //若按键键值为ESC时,退出
//        if( (char)c == 27 )
//            break;
//
//        //按键键值为2时,恢复源图
//        if( (char)c == '2' )
//        {
//            g_maskImage = Scalar::all(0);
//            srcImage.copyTo(g_srcImage);
//            imshow( "image", g_srcImage );
//        }
//
//        //若检测到按键值为1或者空格,则进行处理
//        if( (char)c == '1' || (char)c == ' ' )
//        {
//            //定义一些参数
//            int i, j, compCount = 0;
//            vector<vector<Point> > contours;
//            vector<Vec4i> hierarchy;
//
//            //寻找轮廓
//            findContours(g_maskImage, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE);
//
//            //轮廓为空时的处理
//            if( contours.empty() )
//                continue;
//
//            //拷贝掩膜
//            Mat maskImage(g_maskImage.size(), CV_32S);
//            maskImage = Scalar::all(0);
//
//            //循环绘制出轮廓
//            for( int index = 0; index >= 0; index = hierarchy[index][0], compCount++ )
//                drawContours(maskImage, contours, index, Scalar::all(compCount+1), -1, 8, hierarchy, INT_MAX);
//
//            //compCount为零时的处理
//            if( compCount == 0 )
//                continue;
//
//            //生成随机颜色
//            vector<Vec3b> colorTab;
//            for( i = 0; i < compCount; i++ )
//            {
//                int b = theRNG().uniform(0, 255);
//                int g = theRNG().uniform(0, 255);
//                int r = theRNG().uniform(0, 255);
//
//                colorTab.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
//            }
//
//            //计算处理时间并输出到窗口中
//            double dTime = (double)getTickCount();
//            watershed( srcImage, maskImage );
//            dTime = (double)getTickCount() - dTime;
//            printf( "\t处理时间 = %gms\n", dTime*1000./getTickFrequency() );
//
//            //双层循环,将分水岭图像遍历存入watershedImage中
//            Mat watershedImage(maskImage.size(), CV_8UC3);
//            for( i = 0; i < maskImage.rows; i++ )
//                for( j = 0; j < maskImage.cols; j++ )
//                {
//                    int index = maskImage.at<int>(i,j);
//                    if( index == -1 )
//                        watershedImage.at<Vec3b>(i,j) = Vec3b(255,255,255);
//                    else if( index <= 0 || index > compCount )
//                        watershedImage.at<Vec3b>(i,j) = Vec3b(0,0,0);
//                    else
//                        watershedImage.at<Vec3b>(i,j) = colorTab[index - 1];
//                }
//
//            //混合灰度图和分水岭效果图并显示最终的窗口
//            watershedImage = watershedImage*0.5 + grayImage*0.5;
//            imshow( WINDOW_NAME2, watershedImage );
//        }
//    }
//
//    return 0;
//}
//
//
-----------------------------------【onMouse( )函数】---------------------------------------
		描述:鼠标消息回调函数
-----------------------------------------------------------------------------------------------
//static void on_Mouse( int event, int x, int y, int flags, void* )
//{
//    //处理鼠标不在窗口中的情况
//    if( x < 0 || x >= g_srcImage.cols || y < 0 || y >= g_srcImage.rows )
//        return;
//
//    //处理鼠标左键相关消息
//    if( event == EVENT_LBUTTONUP || !(flags & EVENT_FLAG_LBUTTON) )
//        prevPt = Point(-1,-1);
//    else if( event == EVENT_LBUTTONDOWN )
//        prevPt = Point(x,y);
//
//        //鼠标左键按下并移动,绘制出白色线条
//    else if( event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON) )
//    {
//        Point pt(x, y);
//        if( prevPt.x < 0 )
//            prevPt = pt;
//        line( g_maskImage, prevPt, pt, Scalar::all(255), 5, 8, 0 );
//        line( g_srcImage, prevPt, pt, Scalar::all(255), 5, 8, 0 );
//        prevPt = pt;
//        imshow(WINDOW_NAME1, g_srcImage);
//    }
//}
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
      描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第77个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf(  "\n\n\n\t欢迎来到【分水岭算法】示例程序~\n\n");
//    printf(  "\t请先用鼠标在图片窗口中标记出大致的区域,\n\n\t然后再按键【1】或者【SPACE】启动算法。"
//             "\n\n\t按键操作说明: \n\n"
//             "\t\t键盘按键【1】或者【SPACE】- 运行的分水岭分割算法\n"
//             "\t\t键盘按键【2】- 恢复原始图片\n"
//             "\t\t键盘按键【ESC】- 退出程序\n\n\n");
//}
/*










*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//#include "opencv2/photo/photo.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
----------------------------------------------------------------------------------------------
//#define WINDOW_NAME0 "【原始图参考】"        //为窗口标题定义的宏
//#define WINDOW_NAME1 "【原始图】"        //为窗口标题定义的宏
//#define WINDOW_NAME2 "【修补后的效果图】"        //为窗口标题定义的宏
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
          描述:全局变量声明
-----------------------------------------------------------------------------------------------
//Mat srcImage0,srcImage1, inpaintMask;
//Point previousPoint(-1,-1);//原来的点坐标
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
          描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText( )
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第78个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf("\n\n\n\t欢迎来到【图像修复】示例程序~\n");
//    printf(  "\n\t请在进行图像修复操作之前,在【原始图】窗口中进行适量的绘制"
//             "\n\n\t按键操作说明: \n\n"
//             "\t\t【鼠标左键】-在图像上绘制白色线条\n\n"
//             "\t\t键盘按键【ESC】- 退出程序\n\n"
//             "\t\t键盘按键【1】或【SPACE】-进行图像修复操作 \n\n"   );
//}
//
//
-----------------------------------【On_Mouse( )函数】--------------------------------
          描述:响应鼠标消息的回调函数
----------------------------------------------------------------------------------------------
//static void On_Mouse( int event, int x, int y, int flags, void* )
//{
//    //鼠标左键弹起消息
//    if( event == EVENT_LBUTTONUP || !(flags & EVENT_FLAG_LBUTTON) )
//        previousPoint = Point(-1,-1);
//        //鼠标左键按下消息
//    else if( event == EVENT_LBUTTONDOWN )
//        previousPoint = Point(x,y);
//        //鼠标按下并移动,进行绘制
//    else if( event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON) )
//    {
//        Point pt(x,y);
//        if( previousPoint.x < 0 )
//            previousPoint = pt;
//        //绘制白色线条
//        line( inpaintMask, previousPoint, pt, Scalar::all(255), 5, 8, 0 );
//        line( srcImage1, previousPoint, pt, Scalar::all(255), 5, 8, 0 );
//        previousPoint = pt;
//        imshow(WINDOW_NAME1, srcImage1);
//    }
//}
//
//
--------------------------------------【main( )函数】-----------------------------------------
          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //改变console字体颜色
//    system("color 2F");
//
//    //显示帮助文字
//    ShowHelpText();
//
//    //载入原始图并进行掩膜的初始化
//    Mat srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/22.jpg", -1);
//    if(!srcImage.data ) { printf("读取图片错误,请确定目录下是否有imread函数指定图片存在~! \n"); return false; }
//    srcImage0 = srcImage.clone();
//    srcImage1 = srcImage.clone();
//    inpaintMask = Mat::zeros(srcImage1.size(), CV_8U);
//
//    //显示原始图参考
//    imshow(WINDOW_NAME0, srcImage0);
//    //显示原始图
//    imshow(WINDOW_NAME1, srcImage1);
//    //设置鼠标回调消息
//    setMouseCallback( WINDOW_NAME1, On_Mouse, 0 );
//
//    //轮询按键,根据不同的按键进行处理
//    while (1)
//    {
//        //获取按键键值
//        char c = (char)waitKey();
//
//        //键值为ESC,程序退出
//        if( c == 27 )
//            break;
//
//        //键值为2,恢复成原始图像
//        if( c == '2' )
//        {
//            inpaintMask = Scalar::all(0);
//            srcImage.copyTo(srcImage1);
//            imshow(WINDOW_NAME1, srcImage1);
//        }
//
//        //键值为1或者空格,进行图像修补操作
//        if( c == '1' || c == ' ' )
//        {
//            Mat inpaintedImage;
//            inpaint(srcImage1, inpaintMask, inpaintedImage, 3, INPAINT_TELEA);
//            imshow(WINDOW_NAME2, inpaintedImage);
//        }
//    }
//
//    return 0;
//}
/*











*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
//
//
-----------------------------------【ShowHelpText( )函数】-----------------------------
		 描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第79个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//}
//
//
--------------------------------------【main( )函数】-----------------------------------------
          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( )
//{
//
//    //【1】载入源图,转化为HSV颜色模型
//    Mat srcImage, hsvImage;
//    srcImage=imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/23.jpg");
//    cvtColor(srcImage,hsvImage, COLOR_BGR2HSV);
//
//    system("color 2F");
//    ShowHelpText();
//
//    //【2】参数准备
//    //将色调量化为30个等级,将饱和度量化为32个等级
//    int hueBinNum = 30;//色调的直方图直条数量
//    int saturationBinNum = 32;//饱和度的直方图直条数量
//    int histSize[ ] = {hueBinNum, saturationBinNum};
//    // 定义色调的变化范围为0到179
//    float hueRanges[] = { 0, 180 };
//    //定义饱和度的变化范围为0(黑、白、灰)到255(纯光谱颜色)
//    float saturationRanges[] = { 0, 256 };
//    const float* ranges[] = { hueRanges, saturationRanges };
//    MatND dstHist;
//    //参数准备,calcHist函数中将计算第0通道和第1通道的直方图
//    int channels[] = {0, 1};
//
//    //【3】正式调用calcHist,进行直方图计算
//    calcHist( &hsvImage,//输入的数组
//              1, //数组个数为1
//              channels,//通道索引
//              Mat(), //不使用掩膜
//              dstHist, //输出的目标直方图
//              2, //需要计算的直方图的维度为2
//              histSize, //存放每个维度的直方图尺寸的数组
//              ranges,//每一维数值的取值范围数组
//              true, // 指示直方图是否均匀的标识符,true表示均匀的直方图
//              false );//累计标识符,false表示直方图在配置阶段会被清零
//
//    //【4】为绘制直方图准备参数
//    double maxValue=0;//最大值
//    minMaxLoc(dstHist, 0, &maxValue, 0, 0);//查找数组和子数组的全局最小值和最大值存入maxValue中
//    cout << dstHist.size() << endl;
//    int scale = 10;
//    Mat histImg = Mat::zeros(saturationBinNum*scale, hueBinNum*10, CV_8UC3);
//
//    //【5】双层循环,进行直方图绘制
//    for( int hue = 0; hue < hueBinNum; hue++ )
//        for( int saturation = 0; saturation < saturationBinNum; saturation++ )
//        {
//            float binValue = dstHist.at<float>(hue, saturation);//直方图组距的值
//            int intensity = cvRound(binValue*255/maxValue);//强度
//
//            //正式进行绘制
//            rectangle( histImg, Point(hue*scale, saturation*scale),
//                       Point( (hue+1)*scale - 1, (saturation+1)*scale - 1),
//                       Scalar::all(intensity),CV_FILLED );
//        }
//
//    //【6】显示效果图
//    imshow( "素材图", srcImage );
//    imshow( "H-S 直方图", histImg );
//
//    waitKey();
//}
/*






*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/imgproc/imgproc.hpp"
//#include "opencv2/highgui/highgui.hpp"
//using namespace cv;
//
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME1 "【原始图】"        //为窗口标题定义的宏
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
          描述:全局变量声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage; Mat g_hsvImage; Mat g_hueImage;
//int g_bins = 30;//直方图组距
//
-----------------------------------【全局函数声明部分】--------------------------------------
          描述:全局函数声明
-----------------------------------------------------------------------------------------------
//static void ShowHelpText();
//void on_BinChange(int, void* );
//
--------------------------------------【main( )函数】-----------------------------------------
          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( )
//{
//    //【0】改变console字体颜色
//    system("color 6F");
//
//    //【0】显示帮助文字
//    ShowHelpText();
//
//    //【1】读取源图像,并转换到 HSV 空间
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/24.jpg", 1 );
//    if(!g_srcImage.data ) { printf("读取图片错误,请确定目录下是否有imread函数指定图片存在~! \n"); return false; }
//    cvtColor( g_srcImage, g_hsvImage, COLOR_BGR2HSV );
//
//    //【2】分离 Hue 色调通道
//    g_hueImage.create( g_hsvImage.size(), g_hsvImage.depth() );
//    int ch[ ] = { 0, 0 };
//    mixChannels( &g_hsvImage, 1, &g_hueImage, 1, ch, 1 );
//
//    //【3】创建 Trackbar 来输入bin的数目
//    namedWindow( WINDOW_NAME1 , WINDOW_AUTOSIZE );
//    createTrackbar("色调组距 ", WINDOW_NAME1 , &g_bins, 180, on_BinChange );
//    on_BinChange(0, 0);//进行一次初始化
//
//    //【4】显示效果图
//    imshow( WINDOW_NAME1 , g_srcImage );
//
//    // 等待用户按键
//    waitKey(0);
//    return 0;
//}
//
//
-----------------------------------【on_HoughLines( )函数】--------------------------------
          描述:响应滑动条移动消息的回调函数
---------------------------------------------------------------------------------------------
//void on_BinChange(int, void* )
//{
//    //【1】参数准备
//    MatND hist;
//    int histSize = MAX( g_bins, 2 );
//    float hue_range[] = { 0, 180 };
//    const float* ranges = { hue_range };
//
//    //【2】计算直方图并归一化
//    calcHist( &g_hueImage, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false );
//    normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
//
//    //【3】计算反向投影
//    MatND backproj;
//    calcBackProject( &g_hueImage, 1, 0, hist, backproj, &ranges, 1, true );
//
//    //【4】显示反向投影
//    imshow( "反向投影图", backproj );
//
//    //【5】绘制直方图的参数准备
//    int w = 400; int h = 400;
//    int bin_w = cvRound( (double) w / histSize );
//    Mat histImg = Mat::zeros( w, h, CV_8UC3 );
//
//    //【6】绘制直方图
//    for( int i = 0; i < g_bins; i ++ )
//    { rectangle( histImg, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( hist.at<float>(i)*h/255.0 ) ), Scalar( 100, 123, 255 ), -1 ); }
//
//    //【7】显示直方图窗口
//    imshow( "直方图", histImg );
//}
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
          描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV3版的第83个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//
//    //输出一些帮助信息
//    printf("\n\n\t欢迎来到【反向投影】示例程序\n\n");
//    printf("\n\t请调整滑动条观察图像效果\n\n");
//
//}
/*









*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//using namespace cv;
//
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME1 "【原始图片】"        //为窗口标题定义的宏
//#define WINDOW_NAME2 "【匹配窗口】"        //为窗口标题定义的宏
//
-----------------------------------【全局变量声明部分】------------------------------------
          描述:全局变量的声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage; Mat g_templateImage; Mat g_resultImage;
//int g_nMatchMethod;
//int g_nMaxTrackbarNum = 5;
//
-----------------------------------【全局函数声明部分】--------------------------------------
          描述:全局函数的声明
-----------------------------------------------------------------------------------------------
//void on_Matching( int, void* );
//static void ShowHelpText( );
//
//
-----------------------------------【main( )函数】--------------------------------------------
          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main(  )
//{
//    //【0】改变console字体颜色
//    system("color 1F");
//
//    //【0】显示帮助文字
//    ShowHelpText();
//
//    //【1】载入原图像和模板块
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/25.jpg", 1 );
//    g_templateImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/26.jpg", 1 );
//
//    //【2】创建窗口
//    namedWindow( WINDOW_NAME1, CV_WINDOW_AUTOSIZE );
//    namedWindow( WINDOW_NAME2, CV_WINDOW_AUTOSIZE );
//
//    //【3】创建滑动条并进行一次初始化
//    createTrackbar( "方法", WINDOW_NAME1, &g_nMatchMethod, g_nMaxTrackbarNum, on_Matching );
//    on_Matching( 0, 0 );
//
//    waitKey(0);
//    return 0;
//
//}
//
-----------------------------------【on_Matching( )函数】--------------------------------
          描述:回调函数
-------------------------------------------------------------------------------------------
//void on_Matching( int, void* )
//{
//    //【1】给局部变量初始化
//    Mat srcImage;
//    g_srcImage.copyTo( srcImage );
//
//    //【2】初始化用于结果输出的矩阵
//    int resultImage_rows = g_srcImage.rows - g_templateImage.rows + 1;
//    int resultImage_cols = g_srcImage.cols - g_templateImage.cols + 1;
//    g_resultImage.create(resultImage_rows, resultImage_cols, CV_32FC1);
//
//    //【3】进行匹配和标准化
//    matchTemplate( g_srcImage, g_templateImage, g_resultImage, g_nMatchMethod );
//    normalize( g_resultImage, g_resultImage, 0, 1, NORM_MINMAX, -1, Mat() );
//
//    //【4】通过函数 minMaxLoc 定位最匹配的位置
//    double minValue; double maxValue; Point minLocation; Point maxLocation;
//    Point matchLocation;
//    minMaxLoc( g_resultImage, &minValue, &maxValue, &minLocation, &maxLocation, Mat() );
//
//    //【5】对于方法 SQDIFF 和 SQDIFF_NORMED, 越小的数值有着更高的匹配结果. 而其余的方法, 数值越大匹配效果越好
//    if( g_nMatchMethod  == CV_TM_SQDIFF || g_nMatchMethod == CV_TM_SQDIFF_NORMED )
//    { matchLocation = minLocation; }
//    else
//    { matchLocation = maxLocation; }
//
//    //【6】绘制出矩形,并显示最终结果
//    rectangle( srcImage, matchLocation, Point( matchLocation.x + g_templateImage.cols , matchLocation.y + g_templateImage.rows ), Scalar(0,0,255), 2, 8, 0 );
//    rectangle( g_resultImage, matchLocation, Point( matchLocation.x + g_templateImage.cols , matchLocation.y + g_templateImage.rows ), Scalar(0,0,255), 2, 8, 0 );
//
//    imshow( WINDOW_NAME1, srcImage );
//    imshow( WINDOW_NAME2, g_resultImage );
//
//}
//
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
          描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV2版的第84个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//    //输出一些帮助信息
//    printf("\t欢迎来到【模板匹配】示例程序~\n");
//    printf("\n\n\t请调整滑动条观察图像效果\n\n");
//    printf(  "\n\t滑动条对应的方法数值说明: \n\n"
//             "\t\t方法【0】- 平方差匹配法(SQDIFF)\n"
//             "\t\t方法【1】- 归一化平方差匹配法(SQDIFF NORMED)\n"
//             "\t\t方法【2】- 相关匹配法(TM CCORR)\n"
//             "\t\t方法【3】- 归一化相关匹配法(TM CCORR NORMED)\n"
//             "\t\t方法【4】- 相关系数匹配法(TM COEFF)\n"
//             "\t\t方法【5】- 归一化相关系数匹配法(TM COEFF NORMED)\n" );
//}
/*









*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include <opencv2/imgproc/imgproc.hpp>
//using namespace cv;
//
//int main()
//{
//    //以灰度模式载入图像并显示
//    Mat srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/27.jpg", 0);
//    imshow("原始图", srcImage);
//
//    //进行Harris角点检测找出角点
//    Mat cornerStrength;
//    cornerHarris(srcImage, cornerStrength, 2, 3, 0.01);
//
//    //对灰度图进行阈值操作,得到二值图并显示
//    Mat harrisCorner;
//    threshold(cornerStrength, harrisCorner, 0.00001, 255, THRESH_BINARY);
//    imshow("角点检测后的二值效果图", harrisCorner);
//
//    waitKey(0);
//    return 0;
//}
/*







*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include <opencv2/opencv.hpp>
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//using namespace cv;
//using namespace std;
//
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
------------------------------------------------------------------------------------------------
//#define WINDOW_NAME1 "【程序窗口1】"        //为窗口标题定义的宏
//#define WINDOW_NAME2 "【程序窗口2】"        //为窗口标题定义的宏
//
-----------------------------------【全局变量声明部分】--------------------------------------
		描述:全局变量声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage, g_srcImage1,g_grayImage;
//int thresh = 30; //当前阈值
//int max_thresh = 175; //最大阈值
//
//
-----------------------------------【全局函数声明部分】--------------------------------------
		描述:全局函数声明
-----------------------------------------------------------------------------------------------
//void on_CornerHarris( int, void* );//回调函数
//static void ShowHelpText();
//
-----------------------------------【main( )函数】--------------------------------------------
		描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main( int argc, char** argv )
//{
//    //【0】改变console字体颜色
//    system("color 3F");
//
//    //【0】显示帮助文字
//    ShowHelpText();
//
//    //【1】载入原始图并进行克隆保存
//    g_srcImage = imread( "/home/arthur/Documents/Project/OpenCVProject/cvdemo/28.jpg", 1 );
//    if(!g_srcImage.data ) { printf("读取图片错误,请确定目录下是否有imread函数指定的图片存在~! \n"); return false; }
//    imshow("原始图",g_srcImage);
//    g_srcImage1=g_srcImage.clone( );
//
//    //【2】存留一张灰度图
//    cvtColor( g_srcImage1, g_grayImage, CV_BGR2GRAY );
//
//    //【3】创建窗口和滚动条
//    namedWindow( WINDOW_NAME1, CV_WINDOW_AUTOSIZE );
//    createTrackbar( "阈值: ", WINDOW_NAME1, &thresh, max_thresh, on_CornerHarris );
//
//    //【4】调用一次回调函数,进行初始化
//    on_CornerHarris( 0, 0 );
//
//    waitKey(0);
//    return(0);
//}
//
-----------------------------------【on_HoughLines( )函数】--------------------------------
		描述:回调函数
----------------------------------------------------------------------------------------------
//
//void on_CornerHarris( int, void* )
//{
//    //---------------------------【1】定义一些局部变量-----------------------------
//    Mat dstImage;//目标图
//    Mat normImage;//归一化后的图
//    Mat scaledImage;//线性变换后的八位无符号整型的图
//
//    //---------------------------【2】初始化---------------------------------------
//    //置零当前需要显示的两幅图,即清除上一次调用此函数时他们的值
//    dstImage = Mat::zeros( g_srcImage.size(), CV_32FC1 );
//    g_srcImage1=g_srcImage.clone( );
//
//    //---------------------------【3】正式检测-------------------------------------
//    //进行角点检测
//    cornerHarris( g_grayImage, dstImage, 2, 3, 0.04, BORDER_DEFAULT );
//    imshow("dstImage", dstImage);
//    // 归一化与转换
//    normalize( dstImage, normImage, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
    convertScaleAbs( normImage, normImage );//将归一化后的图线性变换成8位无符号整型
//    imshow("normImage", normImage);
//    convertScaleAbs( normImage, scaledImage );//将归一化后的图线性变换成8位无符号整型
//    imshow("scaledImage", scaledImage);
//    //---------------------------【4】进行绘制-------------------------------------
//    // 将检测到的,且符合阈值条件的角点绘制出来
//    for( int j = 0; j < normImage.rows ; j++ )
//    { for( int i = 0; i < normImage.cols; i++ )
//        {
//            if( (int) normImage.at<float>(j,i) > thresh+80 )
//            {
//                circle( g_srcImage1, Point( i, j ), 5,  Scalar(10,10,255), 2, 8, 0 );
//                circle( scaledImage, Point( i, j ), 5,  Scalar(0,10,255), 2, 8, 0 );
//            }
//        }
//    }
//    //---------------------------【4】显示最终效果---------------------------------
//    imshow( WINDOW_NAME1, g_srcImage1 );
//    imshow( WINDOW_NAME2, scaledImage );
//
//}
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
		描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText()
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV2版的第86个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//    //输出一些帮助信息
//    printf("\n\n\n\t【欢迎来到Harris角点检测示例程序~】\n\n");
//    printf("\n\t请调整滚动条观察图像效果~\n\n");
//}
/*








*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
//#include "opencv2/highgui/highgui.hpp"
//#include "opencv2/imgproc/imgproc.hpp"
//#include <iostream>
//using namespace cv;
//using namespace std;
//
-----------------------------------【宏定义部分】--------------------------------------------
  描述:定义一些辅助宏
----------------------------------------------------------------------------------------------
//#define WINDOW_NAME "【Shi-Tomasi角点检测】"        //为窗口标题定义的宏
//
//
//
-----------------------------------【全局变量声明部分】--------------------------------------
          描述:全局变量声明
-----------------------------------------------------------------------------------------------
//Mat g_srcImage, g_grayImage;
//int g_maxCornerNumber = 33;
//int g_maxTrackbarNumber = 1000;
//RNG g_rng(12345);//初始化随机数生成器
//
//
-----------------------------【on_GoodFeaturesToTrack( )函数】----------------------------
          描述:响应滑动条移动消息的回调函数
----------------------------------------------------------------------------------------------
//void on_GoodFeaturesToTrack( int, void* )
//{
//    //【1】对变量小于等于1时的处理
//    if( g_maxCornerNumber <= 1 ) { g_maxCornerNumber = 1; }
//
//    //【2】Shi-Tomasi算法(goodFeaturesToTrack函数)的参数准备
//    vector<Point2f> corners;
//    double qualityLevel = 0.01;//角点检测可接受的最小特征值
//    double minDistance = 10;//角点之间的最小距离
//    int blockSize = 3;//计算导数自相关矩阵时指定的邻域范围
//    double k = 0.04;//权重系数
//    Mat copy = g_srcImage.clone();	//复制源图像到一个临时变量中,作为感兴趣区域
//
//    //【3】进行Shi-Tomasi角点检测
//    goodFeaturesToTrack( g_grayImage,//输入图像
//                         corners,//检测到的角点的输出向量
//                         g_maxCornerNumber,//角点的最大数量
//                         qualityLevel,//角点检测可接受的最小特征值
//                         minDistance,//角点之间的最小距离
//                         Mat(),//感兴趣区域
//                         blockSize,//计算导数自相关矩阵时指定的邻域范围
//                         false,//不使用Harris角点检测
//                         k );//权重系数
//
//
//    //【4】输出文字信息
//    cout<<"\t>此次检测到的角点数量为:"<<corners.size()<<endl;
//
//    //【5】绘制检测到的角点
//    int r = 4;
//    for( int i = 0; i < corners.size(); i++ )
//    {
//        //以随机的颜色绘制出角点
//        circle( copy, corners[i], r, Scalar(g_rng.uniform(0,255), g_rng.uniform(0,255),
//                                            g_rng.uniform(0,255)), -1, 8, 0 );
//    }
//
//    //【6】显示(更新)窗口
//    imshow( WINDOW_NAME, copy );
//}
//
//
-----------------------------------【ShowHelpText( )函数】----------------------------------
          描述:输出一些帮助信息
----------------------------------------------------------------------------------------------
//static void ShowHelpText( )
//{
//    //输出欢迎信息和OpenCV版本
//    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
//    printf("\n\n\t\t\t此为本书OpenCV2版的第87个配套示例程序\n");
//    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
//    printf("\n\n  ----------------------------------------------------------------------------\n");
//    //输出一些帮助信息
//    printf("\n\n\n\t欢迎来到【Shi-Tomasi角点检测】示例程序\n");
//    printf("\n\t请调整滑动条观察图像效果\n\n");
//
//}
//
//
--------------------------------------【main( )函数】-----------------------------------------
          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
-----------------------------------------------------------------------------------------------
//int main(  )
//{
//    //【0】改变console字体颜色
//    system("color 2F");
//
//    //【0】显示帮助文字
//    ShowHelpText();
//
//    //【1】载入源图像并将其转换为灰度图
//    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/29.jpg", 1 );
//    cvtColor( g_srcImage, g_grayImage, CV_BGR2GRAY );
//
//    //【2】创建窗口和滑动条,并进行显示和回调函数初始化
//    namedWindow( WINDOW_NAME, CV_WINDOW_AUTOSIZE );
//    createTrackbar( "最大角点数", WINDOW_NAME, &g_maxCornerNumber, g_maxTrackbarNumber, on_GoodFeaturesToTrack );
//    imshow( WINDOW_NAME, g_srcImage );
//    on_GoodFeaturesToTrack( 0, 0 );
//
//    waitKey(0);
//    return(0);
//}
/*









*/
//---------------------------------【头文件、命名空间包含部分】----------------------------
//		描述:包含程序所使用的头文件和命名空间
//------------------------------------------------------------------------------------------------
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
using namespace cv;
using namespace std;


//-----------------------------------【宏定义部分】--------------------------------------------
//  描述:定义一些辅助宏
//----------------------------------------------------------------------------------------------
#define WINDOW_NAME "【亚像素级角点检测】"        //为窗口标题定义的宏


//-----------------------------------【全局变量声明部分】--------------------------------------
//          描述:全局变量声明
//-----------------------------------------------------------------------------------------------
Mat g_srcImage, g_grayImage;
int g_maxCornerNumber = 33;
int g_maxTrackbarNumber = 500;
RNG g_rng(12345);//初始化随机数生成器


//-----------------------------【on_GoodFeaturesToTrack( )函数】----------------------------
//          描述:响应滑动条移动消息的回调函数
//----------------------------------------------------------------------------------------------
void on_GoodFeaturesToTrack( int, void* )
{
    //【1】对变量小于等于1时的处理
    if( g_maxCornerNumber <= 1 ) { g_maxCornerNumber = 1; }

    //【2】Shi-Tomasi算法(goodFeaturesToTrack函数)的参数准备
    vector<Point2f> corners;
    double qualityLevel = 0.01;//角点检测可接受的最小特征值
    double minDistance = 10;//角点之间的最小距离
    int blockSize = 3;//计算导数自相关矩阵时指定的邻域范围
    double k = 0.04;//权重系数
    Mat copy = g_srcImage.clone();	//复制源图像到一个临时变量中,作为感兴趣区域

    //【3】进行Shi-Tomasi角点检测
    goodFeaturesToTrack( g_grayImage,//输入图像
                         corners,//检测到的角点的输出向量
                         g_maxCornerNumber,//角点的最大数量
                         qualityLevel,//角点检测可接受的最小特征值
                         minDistance,//角点之间的最小距离
                         Mat(),//感兴趣区域
                         blockSize,//计算导数自相关矩阵时指定的邻域范围
                         false,//不使用Harris角点检测
                         k );//权重系数

    //【4】输出文字信息
    cout<<"\n\t>-------------此次检测到的角点数量为:"<<corners.size()<<endl;

    //【5】绘制检测到的角点
    int r = 4;
    for( unsigned int i = 0; i < corners.size(); i++ )
    {
        //以随机的颜色绘制出角点
        circle( copy, corners[i], r, Scalar(g_rng.uniform(0,255), g_rng.uniform(0,255),
                                            g_rng.uniform(0,255)), -1, 8, 0 );
    }

    //【6】显示(更新)窗口
    imshow( WINDOW_NAME, copy );

    //【7】亚像素角点检测的参数设置
    Size winSize = Size( 5, 5 );
    Size zeroZone = Size( -1, -1 );
    TermCriteria criteria = TermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 40, 0.001 );

    //【8】计算出亚像素角点位置
    cornerSubPix( g_grayImage, corners, winSize, zeroZone, criteria );

    //【9】输出角点信息
    for( int i = 0; i < corners.size(); i++ )
    { cout<<" \t>>精确角点坐标["<<i<<"]  ("<<corners[i].x<<","<<corners[i].y<<")"<<endl; }


}


//-----------------------------------【ShowHelpText( )函数】----------------------------------
//          描述:输出一些帮助信息
//----------------------------------------------------------------------------------------------
static void ShowHelpText( )
{
    //输出欢迎信息和OpenCV版本
    printf("\n\n\t\t\t非常感谢购买《OpenCV3编程入门》一书!\n");
    printf("\n\n\t\t\t此为本书OpenCV2版的第88个配套示例程序\n");
    printf("\n\n\t\t\t   当前使用的OpenCV版本为:" CV_VERSION );
    printf("\n\n  ----------------------------------------------------------------------------\n");
    //输出一些帮助信息
    printf("\n\t欢迎来到【亚像素级角点检测】示例程序\n\n");
    printf("\n\t请调整滑动条观察图像效果\n\n");

}


//--------------------------------------【main( )函数】-----------------------------------------
//          描述:控制台应用程序的入口函数,我们的程序从这里开始执行
//-----------------------------------------------------------------------------------------------
int main(  )
{
    //【0】改变console字体颜色
    system("color 2F");

    //【0】显示帮助文字
    ShowHelpText();

    //【1】载入源图像并将其转换为灰度图
    g_srcImage = imread("/home/arthur/Documents/Project/OpenCVProject/cvdemo/30.jpg", 1 );
    cvtColor( g_srcImage, g_grayImage, CV_BGR2GRAY );

    //【2】创建窗口和滑动条,并进行显示和回调函数初始化
    namedWindow( WINDOW_NAME, CV_WINDOW_AUTOSIZE );
    createTrackbar( "最大角点数", WINDOW_NAME, &g_maxCornerNumber, g_maxTrackbarNumber, on_GoodFeaturesToTrack );
    imshow( WINDOW_NAME, g_srcImage );
    on_GoodFeaturesToTrack( 0, 0 );

    waitKey(0);
    return(0);
}








 

参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:编程工作室 设计师:CSDN官方博客 返回首页

打赏作者

Arthur-Ji

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值