//#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);
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
