opencv使用记录
/*2017-1-14*/
/*视频的读取。。。*/
int g_n=0;
void on_change(int pos,void *)//看来void*不能省!
{
printf("g_n id %d\n",pos);
}
int main()
{
//结构体第一个字母都是大写，函数小写
//打开视频文件：其实就是建立一个VideoCapture结构
VideoCapture capture("E:\\vedio\\01.avi");
//检测是否正常打开:成功打开时，isOpened返回ture
if(!capture.isOpened())
cout<<"fail to open!"<<endl;
//获取整个帧数
//capture.get（宏）可以获取各种属性信息
long total = capture.get(CV_CAP_PROP_FRAME_COUNT);
cout<<"视频"<<total<<"帧"<<endl;
namedWindow("视频",1);
createTrackbar("position","视频",&g_n,total,&on_change);
on_change(g_n,0);
Mat frame;
while(capture.read(frame)){
//frame 保存当前读取帧文件,会保存读取信息，读到结尾会返回NULL
imshow("car",frame);
char c = waitKey(1);//这一步很重要，不然看不到视频内容，延时30ms(每秒30帧)
while( c ==' '){//可以使用空格暂停
c=waitKey(0);
}
}
capture.release();
waitKey(0);
return 0;
}
/*
Mat这个类有两部分数据。
一个是matrixheader，这部分的大小是固定的，包含矩阵的大小，存储的方式，矩阵存储的地址等等。
另一个部分是一个指向矩阵包含像素值的指针。
*/
/*，使用矩阵为Mat赋值的时候，位数一定要匹配，CV_8U是8位，而一个int有4个字节，*/
int main()
{
char data[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
//尼玛，我说怎么搜到的程序上有使用char定义数组给Mat赋值的，这TMD位数不匹配，所以用char
Mat M = Mat(1, 18, CV_8U, data);
//CV_8U是8位，而一个int有4个字节，这是不是说明，
//这样成立的话，是不是说明，即使是64位的编译器，一个字节也是8位（废话！！）
//Mat M(3,3,CV_8UC2);
//M=(Mat_<int>(3,3) <<);
// for(int y=0;y<M.rows;y++){
// for(int x=0;x<M.cols;x++){
// int value = M.at<int>(y,x);
// printf("%2d",value);
// }
// cout<<endl;
// }
cout<<sizeof(int)<<endl;
cout<<M<<endl;
waitKey(0);
return 0;
}
/* 函数 M.channels() M.ptr() 分别返回M的通道数和行地址
尽管M是以两个通道类型保存的数据，并且二维矩阵，但是，返回指针任然是一维，行式存储
*/
char* p =(char *)M.ptr(0);//ptr<>()函数返回第i行的地址
cout<<(int)++data[2]<<endl;
//尽管M是以两个通道类型保存的数据，并且二维矩阵，但是，返回指针任然是一维，行式存储
//只能通过逐步移动指针，访问同一元素的不同通道的值
//不做强制转换，就会输出字符，看来上面是自动强制了
/*2017-1-16*/
/*分离通道，看来，使用*/char* p =(char *)M.ptr(0)/*返回的行地址，增加也是以单个字节为单位*/
int main()
{
Mat M=imread("E:\\visio\\1.jpg",1);
Mat rtemp=Mat::zeros(M.size(),CV_8UC1);
Mat gtemp=Mat::zeros(M.size(),CV_8UC1);
Mat btemp=Mat::zeros(M.size(),CV_8UC1);
for(int i=0;i<M.rows;i++){
char* data = M.ptr<char>(i);
for(int j=0;j<M.cols;j++){
rtemp.at<uchar>(i,j) = (data+3*j)[0];
gtemp.at<uchar>(i,j) = (data+3*j)[1];
btemp.at<uchar>(i,j) = (data+3*j)[2];
}
}
imshow("Rtongdao",rtemp);
imshow("Gtongdao",gtemp);
imshow("Btongdao",btemp);
waitKey(0);
}
//彩色版本 并且使用 Vec3b
//template<typename_Tp, int n> class Vec : public Matx<_Tp, n, 1> {...};
typedef Vec<uchar, 3> Vec3b;
//其实这句就是定义一个uchar类型的数组，长度为3
Mat rtemp=Mat::zeros(M.size(),CV_8UC3);
Mat gtemp=Mat::zeros(M.size(),CV_8UC3);
Mat btemp=Mat::zeros(M.size(),CV_8UC3);
for(int i=0;i<M.rows;i++){
char* data = M.ptr<char>(i);
char* bdata = btemp.ptr<char>(i);
char* gdata = gtemp.ptr<char>(i);
char* rdata = rtemp.ptr<char>(i);
for(int j=0;j<M.cols;j++){
(bdata+3*j)[0] = (data+3*j)[0];
gtemp.at<Vec3b>(i,j)[1]=(data+3*j)[1];
////其实这句就是定义一个uchar类型的数组，长度为3
(rdata+3*j)[2] = (data+3*j)[2];
}
}
/*绘制一维直方图*/
int main()
{
//【1】载入原图并显示
Mat srcImage = imread("E:\\visio\\1.jpg", 1);
imshow("原图",srcImage);
if(!srcImage.data) {cout << "fail to load image" << endl; return 0;}
Mat btemp(srcImage.size(),CV_8UC1);
Mat gtemp(srcImage.size(),CV_8UC1);
Mat rtemp(srcImage.size(),CV_8UC1);
vector<Mat> channel;
//创建mat为元素的可变数组；
split(srcImage,channel);
//使用split函数分离通道为三个元素，存放到channles[]
btemp = channel.at(0);
gtemp = channel.at(1);
rtemp = channel.at(2);
imshow("b",btemp);
imshow("g",gtemp);
imshow("r",rtemp);
//【2】定义变量
MatND bdstHist,gdstHist,rdstHist;
int dims = 1;//几维直方图
float hranges[] = {0, 255};//范围数组
const float *ranges[] = {hranges};// 这里需要为const类型，几维，从这取几个范围，元素是数组
int size[] = {256};//每一维度尺寸的大小，几维，就有几个尺寸,里面的元素是数
int channels = 0;
//【3】计算图像的直方图
calcHist(&btemp, 1, &channels, Mat(), bdstHist, dims, size, ranges);
calcHist(>emp, 1, &channels, Mat(), gdstHist, dims, size, ranges);
calcHist(&rtemp, 1, &channels, Mat(), rdstHist, dims, size, ranges);
int scale = 5;//可以根据用户的需求调节显示图像
Mat bdstImage(256 , 64*scale, CV_8U, Scalar(0));//保存白色高度，8位的，单通道图像
Mat gdstImage(256 , 64*scale, CV_8U, Scalar(0));
Mat rdstImage(256 , 64*scale, CV_8U, Scalar(0));
//【4】获取最大值和最小值
double bminValue = 0,gminValue = 0,rminValue = 0;
double bmaxValue = 0,gmaxValue = 0,rmaxValue = 0;
minMaxLoc(bdstHist,&bminValue, &bmaxValue, 0, 0);
minMaxLoc(gdstHist,&gminValue, &gmaxValue, 0, 0);
minMaxLoc(rdstHist,&rminValue, &rmaxValue, 0, 0);
//【5】绘制出直方图
int hpt = 64 ;
for(int i = 0; i < 256; i++)//有256组，所以要画256次
{
float binValue = bdstHist.at<float>(i);//获取对应直方柱的值
//感觉当Mat.at<>()[],,如果对象的元素是单通道，不需要[],当元素为数组vec3b，需要[]
int realValue = saturate_cast<int>(binValue * hpt/bmaxValue);
//是加是减，乘除，都会超出一个像素灰度值的范围
//当运算完之后，结果为负，则转为0，结果超出255，则为255。
rectangle(bdstImage,//对角两个点，画矩形
Point(i*scale, 64 - 1), //原点在左上角，所以点在下水平轴上
Point((i+1)*scale - 3, 64 - realValue), // -3，应该是柱与柱之间测间隔。
Scalar(255));// scalar(255),边框填充白色
}
for(int i = 0; i < 256; i++)
{
float binValue = gdstHist.at<float>(i);
int realValue = saturate_cast<int>(binValue * hpt/gmaxValue);
rectangle(gdstImage,
Point(i*scale, 64 - 1),
Point((i+1)*scale - 3, 64 - realValue),
Scalar(255));
}
for(int i = 0; i < 256; i++)
{
float binValue = rdstHist.at<float>(i);
int realValue = saturate_cast<int>(binValue * hpt/rmaxValue);
rectangle(rdstImage,
Point(i*scale, 64 - 1),
Point((i+1)*scale - 3, 64 - realValue),
Scalar(255));
}
imshow("一维直方图b", bdstImage);
imshow("一维直方图g", gdstImage);
imshow("一维直方图r", rdstImage);
waitKey(0);
return 0;
}
/*以灰度图像加载图像是通过公式Y=0.2..*b+0.5*g+0.1..*r=R=G=B计算*/
/*RGB颜色空间中，对角线上，没有颜色，只有亮度，即当R=G=B*/
/*色相(Hue)：指物体传导或反射的波长。定义各种颜色，取值范围0度-360度，直径两端，是互补色（混在一起是白色）
饱和度(Saturation)：又称色度，是指色彩的强度或纯度。越靠近内轴，似乎就掺了白色，变得淡了
亮度 (brightness/Intensity)：是指颜色的相对明暗度（可以理解为光照），通常以 0% (黑色) 到 100% (白色) 的百分比来衡量。
*/
/*没必要value非得定义成char，定义成int完全能覆盖，CV-8U所有数值 */
/*当Mat型数据的元素是，三通道时，使用（vec3b）访问时可以使用下标定位 hsvImage.at<Vec3b>(i,j)[1]*/
int value;
for(int i=0;i<hsvImage.rows;i++){
for(int j=0;j<hsvImage.cols;j++)
{
value = hsvImage.at<Vec3b>(i,j)[1];//当char被赋值170时可能已经发生了溢出，
cout<<value<<" "; //所以之后无论怎么处理都挽回不了，
}
}
// imshow("hsv",hsvImage);
cout<<endl<<format(srcImage,"python")<<endl<<endl;
cout<<format(hsvImage,"python");
/*srcImage.copyTo(hsvImage);//这个函数应该是把数据类型也改了 */
/*copy的使用*/
C++: void Mat::copyTo(OutputArray m) const
C++: void Mat::copyTo(OutputArray m, InputArray mask) const
/*一般情况下使用第一种复制的方法，目的矩阵和数据矩阵大小需要相同
（一半设置为图像的感兴趣区域，用来赋值LOGO）
第二种使用方式，有一个mask(只需要单通道)，
mask需要与数据矩阵等大，其非零区域表明需要使用的地方，零的不会用来复制，所以目的矩阵的对应区域不变
*/
/*2016-1-18*/
/*
cvConvertScale(IplImage*,IplImage*,1.0,0)函数似乎只能使用IplImage=cvLoadImage加载的图像才能运行；
在Mat数据类型中有个函数convertTo()函数，如下，也可以转换数据类型
*/
/*
使用cout显示的方式，不如使用循环指针访问得到的真实
*/
/*
保存HSV格式的图像，图像数据只能用char大小的数据
*/
int main(int argc, char** argv)
{
char data[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};
Mat src2 = Mat(3, 2, CV_8UC3, data);
Mat src3;
src2.convertTo(src3,CV_32FC3,1.0,0.1);
float value[3];
for(int i=0;i<src3.rows;i++){
for(int j=0;j<src3.cols;j++)
{
value[0] = src3.at<Vec3f>(i,j)[0];
value[1] = src3.at<Vec3f>(i,j)[1];
value[2] = src3.at<Vec3f>(i,j)[2];
cout<<"<"<<value[0]<<" "<<value[1]<<" "<<value[2]<<endl;
}
}
//保存HSV格式的图像，图像数据只能用char大小的数据
hsvImage.convertTo(hsvImage,CV_8UC3,(1.0/360)*255,0);
imshow("hsv",hsvImage);
cout<<endl<<format(src3,"python");
imshow("jieguo",src3);
getchar();
return 0;
}
/*
自定义结构体元素，进行腐蚀操作：如果B的原点平移到点(x,y)，那么B将完全包含于X中。输入的二值图像只包含黑色(0)和白色(255)像素，因此结构元素覆盖的图像区域中有黑色像素，则锚点所在像素(x,y)将会被替换成黑色0，否则替换成白色255。而物体的边界通常会有黑色像素，所以腐蚀相当于收缩边界。
另一种理解，腐蚀就是把当前像素替换成所定义的像素集中的最小像素值。
*/
int main()
{
char data[20][20]={0};
for(int i=3;i<8;i++){
for(int j=4;j<10;j++){
data[i][j]=255;
}
}
for(int i=8;i<16;i++){
for(int j=2;j<8;j++){
data[i][j]=255;
}
}
Mat srcImage(20,20, CV_8UC1, data);
cout<<format(srcImage,"python");
//使用自定义结构元素进行腐蚀的正确姿势，
//网上说自己定义麻烦，确实自己赋值结构元素是有点麻烦，
//自定义一个有“形状”的mat，erode 自动可以判断其他参数
char vaule[16]={ 0,0,0,0,
0,0,1,0,
0,1,1,0,
0,0,0,0};
Mat element(4,4,CV_8UC1,vaule);
Mat result(srcImage.size(),CV_8UC1,Scalar::all(0));
erode(srcImage,result,element);//默认腐蚀操作一次
cout<<endl<<endl<<format(result,"python");
waitKey(0);
return 0;
}
/*2016-1-17*/
/*轮廓提取
1、提取前应该先使用边缘算子处理，才能提取到单根轮廓
2、看来转为灰度图，保存的通道也是 cvtColor
3、vector<Vec4i> hierarchy;保存轮廓关系一维数组，元素是4个数
vector< vector<Point> > contours;保存轮廓数据的“二维数组”，元素是点
4、//hierarchy[][]后一个轮廓、前一个轮廓、内嵌轮廓，父轮廓的contours数组索引编号（行）
5、反过来用（y,x）srcImage.at<Vec3b>(y,x)[2]=255;//对对，这样使用是先返回行，对应于坐标是y
*/
int main()
{
Mat srcImage=imread("E:/visio/lunkuo.jpg");
//cvtColor(srcImage,srcImage,CV_BGR2GRAY,0);
//这就是单通道了，看来转为灰度图，保存的通道也是 1
imshow("jiegou",srcImage);
// cout<<format(srcImage,"python")<<endl;
Mat gimage;
GaussianBlur(srcImage,gimage,Size(3,3),0);//高斯模糊
// imshow("GAUSS Image",gimage);//这里还是彩色的
Mat cimage;
Canny(gimage,cimage,100,250); //图像处理之Canny 边缘检测 1
// imshow("Cann Image",cimage);
// cout<<format(image,"python")<<endl;//这里已经变成单通道了
Mat lunkuo=Mat::zeros(srcImage.size(),CV_8UC3); //绘制
vector<Vec4i> hierarchy;
vector< vector<Point> > contours;
//第二个参数：contours，定义为“vector<vector<Point>> contours”，
//是一个向量，并且是一个双重向量，向量
//内每个元素保存了一组由连续的Point点构成的点的集合的向量，每一组Point点集就是一个轮廓。
//有多少轮廓，向量contours就有多少元素。
//使用cvFindContours的返回值为int型,指检测出来的轮廓的个数
findContours(cimage,contours,hierarchy,1,CV_CHAIN_APPROX_NONE);//没有返回值
//只有以第四种模式寻找轮廓，hierarchy的数组，才能完全被附上应有的值！
int idx = 0;
int i=0;
for( ; idx<contours.size(); idx++){
for(int j=0;j<contours[idx].size();j++){
int x=contours[idx][j].x,y=contours[idx][j].y;
if(idx % 2 == 0) lunkuo.at<Vec3b>(y,x)[2]=255;
if(idx % 2 != 0) lunkuo.at<Vec3b>(y,x)[1]=255;
//除了模式0之外，
//1，2，3模式每一个轮廓都有两个存储数组，仅有几个点有差别，8个轮廓共16个数组
// Scalar color(0,0,255 );
// drawContours( lunkuo, contours, idx, color, 1, 8, hierarchy );
// 使用drawContours,可以顺便给线复颜色值，idx是contour数组的行变量，
// 应该还不至于操作父子结构。。之后的参数掠过
}
imshow("lunkuo",lunkuo);
}
// imshow("lunkuo",lunkuo);
/* 模式2-1 查找所有轮廓，全部输出
for(i=0;i<contours.size();i++)
{
//contours[i]代表的是第i个轮廓，
//contours[i].size()代表的是第i个轮廓上所有的像素点数
for(int j=0;j<contours[i].size();j++)
{
//绘制出contours向量内所有的像素点
//这里要想画在原图上，要画gimage,因为gimage已经与原图像不一样了
//并且原图像画边界的部分是白色，都是255，所以会有截断似乎
//还有一种办法，更改原图像
int x=contours[i][j].x,y=contours[i][j].y;
//还有一种办法，更改原图像 ，数组的话还不能整体赋值呢，就先一步一步操作吧
//这里居然要反过来用，像素点（x，y），，这里要输入（y,x）
//不然就使用Point point（x,y）,,srcImage.at<Vec3b>(p)[]
srcImage.at<Vec3b>(y,x)[2]=255;//对对，这样使用是先返回行，对应于坐标是y
srcImage.at<Vec3b>(y,x)[0]=0; //那么使用的时候，也得反着用
srcImage.at<Vec3b>(y,x)[1]=0;
}
//输出hierarchy向量内容
cout<<"向量hierarchy的第" <<i<<" 个元素内容为："<<endl
<<hierarchy[i]<<endl<<endl;
}
imshow("lunkuo",srcImage);
*/
/* 模式 RETR_EXTERNAL==0 只查找最外层轮廓，
轮廓保存数组，仍然是二维，尽管只保存一个轮廓
没有使用层次关系 hierarchy
for(int i=0;i<contours.size();i++)
{
//contours[i]代表的是第i个轮廓，contours[i].size()代表的是第i个轮廓上所有的像素点数
for(int j=0;j<contours[i].size();j++)
{
//绘制出contours向量内所有的像素点
Point P=Point(contours[i][j].x,contours[i][j].y);
lunkuo.at<uchar>(P)=255;
}
//输出hierarchy向量内容
char ch[256];
sprintf(ch,"%d",i);
string str=ch;
//hierarchy[][]后一个轮廓、前一个轮廓、内嵌轮廓的索引编号，父轮廓、应该是contours的行号
cout<<"向量hierarchy的第" <<str<<" 个元素内容为："<<endl<<hierarchy[i]<<endl<<endl;
}
imshow("lunkuo",lunkuo);
*/
waitKey(0);
return 0;
}
/*2017-1-19*/
//图像的细化，先有原图得到灰度图cvtColor
//在有灰度图得到二值化threshold
//由程序中判断边缘点的方法将其记录到edg，再由索引表八连通图的方法判断是否为删除点，记录到delete,之后删除
//之后再有边缘函数fincontours试试..........
void deletecontours(Mat &srcImage)
{
unsigned char deletemark[256] = {
0,0,0,0,0,0,0,1, 0,0,1,1,0,0,1,1,
0,0,0,0,0,0,0,0, 0,0,1,1,1,0,1,1,
0,0,0,0,0,0,0,0, 1,0,0,0,1,0,1,1,
0,0,0,0,0,0,0,0, 1,0,1,1,1,0,1,1,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0, 1,0,0,0,1,0,1,1,
1,0,0,0,0,0,0,0, 1,0,1,1,1,0,1,1,
0,0,1,1,0,0,1,1, 0,0,0,1,0,0,1,1,
0,0,0,0,0,0,0,0, 0,0,0,1,0,0,1,1,
1,1,0,1,0,0,0,1, 0,0,0,0,0,0,0,0,
1,1,0,1,0,0,0,1, 1,1,0,0,1,0,0,0,
0,1,1,1,0,0,1,1, 0,0,0,1,0,0,1,1,
0,0,0,0,0,0,0,0, 0,0,0,0,0,1,1,1,
1,1,1,1,0,0,1,1, 1,1,0,0,1,1,0,0,
1,1,1,1,0,0,1,1, 1,1,0,0,1,1,0,0
};//索引表
Mat image;
Mat copyImage;
cvtColor(srcImage,image,CV_BGR2GRAY);
threshold(image, copyImage, 128, 1, THRESH_BINARY);//这样，像素点就变成0 1 //image = image * 255 显示图像
// cout<<endl<<endl<<format(copyImage,"python");
//仅使用最外一层轮廓，不用做预处理，并且只有一层
vector<Point> edg;
vector<Point> detele;
bool flag = true;
int times = 0;
int sum;
char vaule[8] = { 0 };
while( flag ) {
times++;
flag = false;
int number0=0;
//记得之前使用一种函数，返回的是行号 注意像素点的表示（行号，列号）
//若想之后正确使用，一开始就得按照规矩来
for(int i=1;i<copyImage.rows-1;i++){
for(int j=1;j<copyImage.cols-1;j++){
int x=i,y=j;
if( copyImage.at<char>(x,y) == 1 ){
vaule[0] = copyImage.at<char>(x-1,y-1);
vaule[1] = copyImage.at<char>(x-1,y);
vaule[2] = copyImage.at<char>(x-1,y+1);
vaule[3] = copyImage.at<char>(x,y+1);
vaule[4] = copyImage.at<char>(x+1,y+1);
vaule[5] = copyImage.at<char>(x+1,y);
vaule[6] = copyImage.at<char>(x+1,y-1);
vaule[7] = copyImage.at<char>(x,y-1);
sum = vaule[0] & vaule[1] & vaule[2] & vaule[3] & vaule[4] & vaule[5] & vaule[6] & vaule[7];
if(sum == 0) {
edg.push_back(Point (x,y));
}
}
}
}
for(int i=0 ; i<edg.size() ; i++){
int x,y;
x = edg[i].x;
y = edg[i].y;
vaule[0] = copyImage.at<char>(x-1,y-1);
vaule[1] = copyImage.at<char>(x-1,y);
vaule[2] = copyImage.at<char>(x-1,y+1);
vaule[3] = copyImage.at<char>(x,y+1);
vaule[4] = copyImage.at<char>(x+1,y+1);
vaule[5] = copyImage.at<char>(x+1,y);
vaule[6] = copyImage.at<char>(x+1,y-1);
vaule[7] = copyImage.at<char>(x,y-1);
//由于字符转换int使得数值变成0了估计！！！！！！！！！！！！！
vaule[1]*=2;
vaule[2]*=4;
vaule[3]*=8;
vaule[4]*=16;
vaule[5]*=32;
vaule[6]*=64;
vaule[7]*=128;
sum = vaule[0] + vaule[1] + vaule[2] + vaule[3] + vaule[4] + vaule[5] + vaule[6] + vaule[7] ;
//若发现该点是可删除点,即立即删除.删除会影响到以后的判断，故先做标记
if(deletemark[sum] == 1){
detele.push_back(Point (x,y));//vertor的插入
}
}
if(detele.size() > 0)//vector的成员函数.size（）
flag = true;
for(int i=0;i<detele.size();i++){
int x,y;
x=detele[i].x,y=detele[i].y;
copyImage.at<char>(x,y)=0;
}
cout<<endl<<"time"<<times<<endl;
detele.clear();
edg.clear();
}
imshow("jieguo",copyImage*255);
}
/*2017-2-2*/
/*
hu矩
质量中心的简称，它同作用于质点系上的力系无关。设?n个质点组成的质点系?，其各质点的质量分别为m1，m2，…，mn。若用?r1?，r2，……，rn分别表示质点系中各质点相对某固定点的矢径，rc?表示质心的矢径，则有rc=（m1r1+m2r2+……+mnrn)/(m1+m2+……+mn)。当物体具有连续分布的质量时，质心C的矢径?rc=∫ρrdτ/∫ρdτ，式中ρ为体（或面、线）密度；dτ为相当于ρ的体（或面?、线）元?；积分在具有分布密度ρ的整个物质体（或面、线）上进行。由牛顿运动定律或质点系的动量定理，可推导出质心运动定理：质心的运动和一个位于质心的质点的运动相同，
中心矩具有平移不变性，它与中心做差了
归一化中心矩，应该具有缩放平移不变性
Hu矩具有平移，缩放，旋转不变性，应该是综合了好多矩的向量
中心矩是20 11 02开始，，因为00就是p+q 00 ；01 10中心矩不存在
*/
int main()
{
char data[100]={0};
for(int i=3;i<6;i++){
for(int j=3;j<6;j++)
data[10*i+j]=255;
}
Mat srcImage= Mat(10, 10, CV_8U, data);
Moments mts=moments(srcImage,2);//2是非零的意思，会将图像中大于零的都认为1
//这应该是库中的函数，可以直接使用，计算各阶矩（原点矩，中心矩）0，1，2
double hu[7];
HuMoments(mts, hu);//只需要接受各阶矩，计算得到hu矩，存入hu数组
for (int i=0; i<7; i++)
{
cout << log(abs(hu[i])) <<endl;
}
}
/*2017-2-3*/
/*
resylt = matchShapes(contours[],contours [],1 ) 函数的使用方法，输入比较的边缘数组，比较方法1 2 3、
返回值是个浮点数，显示比较距离，越小越相似
其内部还是先计算出两个图像的hu矩，然后通过一些数学方法计算两个hu矩之间的差距
*/
int main()
{
Mat srcImage0=imread("E:/visio/dev/xin.JPG");
Canny(srcImage0,srcImage0,100,250);
//即使看似很规整，还是直接检测最外层轮廓，还是会检测到前一个后一个的关系，不是继承
Mat srcImage1=imread("E:\\visio\\dev\\youxin.JPG");
Canny(srcImage1,srcImage1,100,250);
Mat lunkuo0=Mat::zeros(srcImage0.size(),CV_8U); //绘制
Mat lunkuo1=Mat::zeros(srcImage1.size(),CV_8U); //绘制
vector<Vec4i> hierarchy;
vector< vector<Point> > contours0;
vector< vector<Point> > contours1;
findContours(srcImage0,contours0,hierarchy,0,CV_CHAIN_APPROX_NONE);//没有返回值
findContours(srcImage1,contours1,hierarchy,0,CV_CHAIN_APPROX_NONE);//没有返回值
drawContours( lunkuo0, contours0, 0, 255, 1, 8 );
drawContours( lunkuo1, contours1, 0, 255, 1, 8 );
//通过上面的边缘检测之后，一幅图才能寻找出一个边缘。
imshow("lunkuo0",lunkuo0);
imshow("lunkuo1",lunkuo1);
double result;
result=matchShapes(contours0[0],contours1[0],1,0);
//比较方法的宏定义有三个，只是这里竟然输入的是边缘数组，而不是二值化图像，1，2，3
//使用这种方法，比较结果不能提钱限定只能从总的比较结果中选取一个最小的
cout<<result<<endl;
waitKey(0);
}
/*matchTempate()模版匹配到的使用*/
//计算一个二维矩阵中最大值最小值，以及他们的位置
minMaxLoc( //取出矩阵中最大最小值
const CvArr* arr,//目标矩阵
double* min_val,//最小值
double* max_val,//最大值
CvPoint* min_loc = NULL,//最小值位置
CvPoint* max_loc = NULL,//最大值位置
const CvArr* mask = NULL//掩膜，以便做区域操作
);
int main()
{
Mat srcImage=imread("zong.jpg");
Mat temp=imread("ling.jpg");
int srcw=srcImage.rows,srch=srcImage.cols,tempw=temp.rows,temph=temp.rows;
int resultw=srcw-tempw+1;//储存匹配结果的矩阵，按照上述原理，应该的长度和宽度就是这样
int resulth=srch-temph+1;
Mat result(resultw,resulth,CV_8U,Scalar::all(0));
//结果矩阵，保存着匹配信息，估计之后需要能够对矩阵计算的相关函数
matchTemplate(srcImage,temp,result,1);
//这个函数类型为void,
//使用一个与temp大小的框，遍历原图像，然后对比temple(对比方法6中)
//有6种比较计算方法，估计也是计算矩，不同的方法，result中值的大小意义不同
double min,max;
Point minpoint,maxpoint,rightpoint;
minMaxLoc(result,&min,&max,&minpoint,&maxpoint,Mat());
//查找矩阵中最大值最小值，及其他们的位置
rightpoint=minpoint;//使用了第一种方法，最小值表示最相似
rectangle(srcImage,rightpoint,Point(rightpoint.x+tempw,rightpoint.y+temph),Scalar(0,0,255));
//画矩形函数，输入图像，座上，右下点，颜色（使用了构造函数，构造了一个每名的量）
imshow("jieguo",srcImage);
waitKey(0);
}
//上面的版本只能实现在众多图像中匹配一个最相似的结果，并不能识别
//比模版大的相似对象（由匹配原理），后者，多个与模版大小相同（只能圈出一个最相似的，识别多个需要设计，视频的最后一节）
//由于这个方法并不能很好的实现刀闸的识别，所以，识别多个的项目就先放一放
/*2017-2-13*/
/*
仿照houghcircles的思想改写的检测圆形曲线，但结果似乎并不好，发现大多说的图像经过处理后
半径很小的圆，往往峰值很大，这也学是因为半径越小，其边缘越能近似到同一个（半径）圆心
半径大的，却能近似到几个有那么一点点差别的圆心，从而导致峰值分散，不能与半径小的圆相比
*/
int main()
{
Mat src=imread(".//刀闸图片//data.jpg");
int radius=50;//定义半径范围
float interval=1;//定义角度范围
Mat result;
src.copyTo(result);
cvtColor(src,src,CV_RGB2GRAY);
GaussianBlur(src,src,Size(3,3),0);
Canny(src,src,100,250);
imshow("src",src);
//三维矩阵，下标为各种圆（不同半径时以各个像素为圆心），值代表有多少像素点在它上面
vector<vector<vector<int> > > count(radius,vector<vector<int> >(src.rows,vector<int>(src.cols)));
//只知道这样创建不知道为什么？
int x0,y0;
for(int k=1;k<radius;k++){
for(int i=0;i<src.rows;i++){
for(int j=0;j<src.cols;j++){
unsigned char color = src.at<uchar>(i,j);
if(color > 0){//如果是前景点
for (int theta = 0; theta < (1 / interval) * 360; theta++){
//计算圆心的方法也是独特，就是图中转换后的圆（以点代圆）
double t = ( (1 / interval) * theta * CV_PI ) / 180;
x0 = (int)cvRound(j - k * cos(t));//对一个double型的数进行四舍五入
y0 = (int)cvRound(i - k * sin(t));
//计算圆心。k是半径,这里是根据r计算a,b（圆心），因为r有界可做外层循环。
if (x0 < src.cols && x0 > 0 && y0 < src.rows && y0 > 0){
count[k][y0][x0]++;
}
}
}
}
}
}
int max = 0;
int r = 0;
int x = 0, y = 0;
for(int k=1;k<50;k++){
for(int i=0;i<src.rows;i++){
for(int j=0;j<src.cols;j++){
if (count[k][i][j] > max){
max = count[k][i][j];
x = j;
y = i;
r = k;
}
}
}
}
cout << x << endl;
cout << y << endl;
cout << r << endl;
cout<<"峰值"<<max<<endl;
Point point;
point.x = x;
point.y = y;
//画圆
circle(result, point, r, Scalar(0, 0, 255));
imshow("yuan",result);
waitKey(0);
return 0;
}
/*霍夫圆检测函数*/ HoughCircles(src,circles,CV_HOUGH_GRADIENT,1,3,100,45,0,0);
//8位图，存储变量，检测方法，步长（确定累加器的大小，越大，累加器空间越小）
//圆心之间可合并的最大距离，canny检测因子，判断累加器阈值大小已确定那些点是圆心
//半径的最小，最大
//总之效果并不好用
vector<Vec3f> circles;
HoughCircles(src,circles,CV_HOUGH_GRADIENT,1,3,100,45,0,0);
for(int i=0;i<circles.size();i++){
Point center(cvRound(circles[i][0]),cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
//绘制圆心
circle(result,center,3,Scalar(0,0,255),-1,8,0);
//绘制轮廓
circle(result,center,radius,Scalar(155,50,255),3,8,0);
}
cout<<circles.size()<<endl;
/*直线检测*/
Mat src=imread(".//刀闸图片//01.jpg",1);//"./"此文件夹
Mat edg;
//霍夫直线检测，可以检测出直线，，，，，转换了参数空间
Canny(src,edg,50,100);
imshow("edg",edg);
vector<Vec4i> lines;
HoughLinesP(edg,lines,1,CV_PI/180,150,50,10);
//输入二值化图像，存储空间，（转化后）半径的步长，角度的步长，阈值（待定直线），
//最小直线阈值（小于该值，则不被认为是一条直线），阈值（两条直线间隙大于该值，则被认为是两条线段，否则是一条。）
for(int i=0;i<lines.size();i++){ //这种使用方法要学会
Vec4i l=lines[i];
line(src,Point(l[0],l[i]),Point(l[2],l[3]),Scalar(0,0,255));
}
imshow("jieguo",src);
/*2017-2-15*/
/*Moravec角点检测算法*/
//输入二值化图像，存储角点坐标指针，角点阈值（有计算方式确定）
int getMoravec(Mat& src,Point* corners , float threshold)
{
int winsize=5;//窗口的大小 即 5*5 win[5,5]
int halfwinsize=winsize/2;
Mat diffDst(src.size(),CV_32FC1,Scalar::all(0));
int conersCount=0;
int x,y;
for (y=halfwinsize ; y<src.rows-halfwinsize ; y++)//先y(行)，每次移动一个像素
{
for (x=halfwinsize;x<src.cols-halfwinsize; x++)//后x（列）,从第一个浮动框的中点开始
{
float reaction[4],minVal;
reaction[0]=0;
reaction[1]=0;
reaction[2]=0;
reaction[3]=0;//应该是记录四个方向的差值
int i;
//在我们的算法中,(u,v)的取值是((1,0),(1,1),(0,1),(-1,1).//上半平面,每隔45度，取一个角
//当然，你自己可以改成(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1) 8种情况
//0
for (i=-halfwinsize;i<halfwinsize;i++)//-2 -1 0 -1
{//当然要加，要计算所有框内的差值平方和
reaction[0]+= pow(src.at<uchar>(y,x+i)-src.at<uchar>(y,x+i+1),2);
}
//45
for (i=-halfwinsize;i<halfwinsize;i++)//-2 -1 0 -1
{
reaction[1]+= pow(src.at<uchar>(y+i,x+i)-src.at<uchar>(y+i+1,x+i+1),2);
}
//90
for (i=-halfwinsize;i<halfwinsize;i++)//-2 -1 0 -1
{
reaction[2]+= pow(src.at<uchar>(y+i,x)-src.at<uchar>(y+i+1,x),2);
}
//-45
for (i=-halfwinsize;i<halfwinsize;i++)//-2 -1 0 -1
{
reaction[3]+= pow(src.at<uchar>(y+i,x-i)-src.at<uchar>(x-i-1),2);
}
//-----------------------------
//取最小值
minVal=reaction[0];
minVal=reaction[1]<minVal?reaction[1]:minVal;
minVal=reaction[2]<minVal?reaction[2]:minVal;
minVal=reaction[3]<minVal?reaction[3]:minVal;
//将最小值保存在准备好的模版中，且与原图对应像素
diffDst.at<float>(y,x)=minVal;
}
}
//获取角点坐标 判断当前点的局部极大值!!! 对对 局部区域最大值
for (y=halfwinsize;y<src.rows-halfwinsize;y+=halfwinsize){
for (x=halfwinsize;x<src.cols-halfwinsize;x+=halfwinsize){
float max=0;
int flag=0;
Point maxLoc;//保存最大值的位置
maxLoc.x=-1;//初始化
maxLoc.y=-1;
//在局部区域里面找最大值！
for (int winy=-halfwinsize;winy<halfwinsize;winy++){
for (int winx=-halfwinsize;winx<halfwinsize;winx++){
float value;
value= diffDst.at<float>(y+winy,x+winx);//取像素点的值
if (value>max){
max=value;
flag=1;//存在候选角点，还没设置阈值
maxLoc.x=x+winx;
maxLoc.y=y+winy;
}
}
}
if (flag==1 && max>threshold){
corners[conersCount].x=maxLoc.x;
corners[conersCount].y=maxLoc.y;
conersCount++;
}
}
}
return conersCount;
}
/*2017-2-17*/
/*
.h文件，与相应的.cpp文件的使用
感觉只能在项目文件中使用这种方法两节两个.cpp文件（主文件通过.h使用另一个.cpp ）
1、原理上并不要求这两个文件（.h .cpp）同名，但为了使用方便，一半设置为同名
2、.cpp里可以只用各种函数，没有主函数，因为在一个整体中只要又一个函数入口就行了
3、但是即使是非主的.cpp文件也需要他自己编译通过所需的库的头文件引用
4、根据文本替代远离的.h文件在主文件的位置也有讲究，例如若.h文件中使用了Mat，
那么他在主文件中的位置须在命名空间的后面，
不然，根据文本替代原理，编译器不会识别.h文件中的陌生符号
*/
/*输出字符到文本文件*/
#include <fstream>
ofstream outfile("data.txt");//打开
outfile<<"下标从小到大";
for(int i=0;i<256;i++){
outfile<<","<<(int)result[i];
}
outfile.close();关闭
/*可视化编程，滑动小框*/
for(int i=0;i<contours.size();i++){
for(int j=0;j<contours[i].size();j++){
int x,y;
x=contours[i][j].x;
y=contours[i][j].y;
int sum[2];
//则以此点为中心，考察一个框
Mat temp;
src.copyTo(temp);
circle(temp, Point(x,y),round,Scalar(255));
imshow("temp",temp);
waitKey(100);
}
}
//Point像素点坐标访问，X是横向的坐标轴是
//at(i,j)，矩阵数据访问，i是行号
Point point(10,100);
srcImage.at<uchar>(point.x,point.y)=255;//x,y==>行，列
cout<<point.x<<" "<<point.y<<endl;
srcImage.at<uchar>(50,100)=255;//同上，先行后列
//这种用法很特殊，，似乎自己做了转换
point.x=20;
point.y=100;
srcImage.at<uchar>(point)=255;//这样使用x,y就代表 列，行了
Mat m=Mat::zeros(200,200,CV_8UC3);
Point point(10,100);
circle(m,point,1,Scalar(0,0,255));//使用point的数据，x列，y行
circle(m,Point(20,100),1,Scalar(0,0,255));//同上，x列，y行
cout<<point.x;//或者说对于Point来讲，point.x就是cols
m.at<Vec3b>(10,100)[2]=255; //因为这里（i，j）并不是代表像素点的坐标，而是cols号
imshow("jieguo",m);
//多边形逼近
Mat lunkuo=Mat::zeros(srcImage.size(),CV_8UC3); //绘制
vector<Vec4i> hierarchy;
vector< vector<Point> > contours;
findContours(srcImage,contours,hierarchy,0,CV_CHAIN_APPROX_NONE);//没有返回值
vector<vector<Point> > approxPoint(contours.size());
for (int i = 0; i < (int)contours.size(); i++){
approxPolyDP(contours[i], approxPoint[i], 3, true);
}
for(int i=0;i<approxPoint.size();i++){
drawContours(lunkuo, approxPoint, i, Scalar(255, 255, 255), 1);
}
imshow("black",lunkuo);
//角度计算
double=atan(y/x);
//计算在不在圆里面，是带入公式
｛x1-x｝^2+{y1-y}^2==r
/*2017-2-18*/
/*卷积*/
//有的图像处理方法是把象素的颜色（灰度）值变换为周围图像颜色（灰度）值的调和（周围象素颜色（灰度）值乘以一个权重值求和，效果会使得图像效果变得朦胧），这个过程也符合卷积的物理意义（一组值乘以他们相应的“权重”系数的和）,所以这个处理也被称为卷积。
/*2017-2-19*/
/*
1、关于h文件的引用，没主函数的cpp文件也需要引入相关的系统库，才能通过编译
or*///将所有需要的引入库都写在这里h文件中是可以的，，但，，
//不将所有的库都写在这里的原因是，
//并不知道那个函数所需要引入那个库，
//倒不如，每个函数的库，他自己负责引入
//这里这样写只是证明这样写是可以的，并不建议这样写！
/**.h文件*/
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>
#include <stack>
#include <opencv2/opencv.hpp>
#include <iostream>
using namespace std;
using namespace cv;
Scalar icvprGetRandomColor();
void icvprCcaByTwoPass(const Mat& _binImg, Mat& _lableImg);
void icvprCcaBySeedFill(const Mat& _binImg, Mat& _lableImg);
void icvprLabelColor(const Mat& _labelImg, Mat& _colorLabelImg);
/*
2、防止h文件引用自己
*/
/*2017-2-20*/
//goodFeatureToTrack()函数
/*
1、//eig是最小特征值矩阵，并不是二值化矩阵，对其膨胀效果不同
//默认用3*3的核膨胀，膨胀之后，除了局部最大值点和原来相同，其它非局部最大值点被
//3*3邻域内的最大值点取代，如不理解，可看一下灰度图像的膨胀原理
dilate( eig, tmp, Mat() );
2、Size imgsize = image.size(); //？还有这个类型？！
3、vector<const float*> tmpCorners; //这里使用指针，是要访问他在内存中的真正地址，？指向浮点数的地址？
4、//size_t类型
//而数组下标的正确类型则是size_t，是标准C库中定义的一种类型，应为unsigned int
size_t i, j
5、eig.data
返回eig内存块的首地址？还有eig.data这样的使用法？
角点在原图像中的行？eig.step也许是一行的大小吧？
*/
oid cv::goodFeaturesToTrack(InputArray _image,
OutputArray _corners,
int maxCorners,
double qualityLevel,
double minDistance,
InputArray _mask,
int blockSize,
bool useHarrisDetector,
double harrisK
)
{
//如果需要对_image全图操作，则给_mask传入cv::Mat()，否则传入感兴趣区域
Mat image = _image.getMat(), mask = _mask.getMat();
CV_Assert( qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0 ); //对参数有一些基本要求
CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()) );
Mat eig, tmp; //eig存储每个像素协方差矩阵的最小特征值，tmp用来保存经膨胀后的eig
//？协方差矩阵 大概就是可以表征角的特点的一个矩阵吧？
//？注意计算完之后，eig就变成float类型的了？
if( useHarrisDetector )
cornerHarris( image, eig, blockSize, 3, harrisK ); //blockSize是计算2*2协方差矩阵的窗口大小，sobel算子窗口为3，harrisK是计算Harris角点时需要的值
else
cornerMinEigenVal( image, eig, blockSize, 3 ); //计算每个像素对应的协方差矩阵的最小特征值，保存在eig中
double maxVal = 0;
minMaxLoc( eig, 0, &maxVal, 0, 0, mask ); //只有一个最大值（最小值）没保存，maxVal保存了eig的最大值
threshold( eig, eig, maxVal*qualityLevel, 0, THRESH_TOZERO );
//阈值设置为 maxVal乘以qualityLevel（图像质量水平），
//大于此阈值的保持不变，小于此阈值的都设为0
//eig是最小特征值矩阵，并不是二值化矩阵，对其膨胀效果不同
//默认用3*3的核膨胀，膨胀之后，除了局部最大值点和原来相同，其它非局部最大值点被
//3*3邻域内的最大值点取代，如不理解，可看一下灰度图像的膨胀原理
dilate( eig, tmp, Mat() ); //tmp中保存了膨胀之后的eig，？保存膨胀之后的干什么？
Size imgsize = image.size(); //？还有这个类型？！
vector<const float*> tmpCorners; //存放粗选出的角点地址，？指向浮点数的地址？
//这里使用指针，是要访问他在内存中的真正地址
for( int y = 1; y < imgsize.height - 1; y++ )//从第二行开始，到倒数第二行
{
const float* eig_data = (const float*)eig.ptr(y); //获得eig第y行的首地址
const float* tmp_data = (const float*)tmp.ptr(y); //获得tmp第y行的首地址
const uchar* mask_data = mask.data ? mask.ptr(y) : 0;
for( int x = 1; x < imgsize.width - 1; x++ ){
float val = eig_data[x];
if( val != 0 && val == tmp_data[x] && (!mask_data || mask_data[x]) )
//val == tmp_data[x]说明这是局部极大值
tmpCorners.push_back(eig_data + x);
//保存其位置 ？eig_data已经是y行首地址了？
}
}
//-----------此分割线以上是根据特征值粗选出的角点，我们称之为弱角点----------//
//----------此分割线以下还要根据minDistance进一步筛选角点，仍然能存活下来的我们称之为强角点----------//
//tmpCorners，数组 保存弱角点的 内存像素地址
sort( tmpCorners, greaterThanPtr<float>() ); //按特征值降序排列，注意这一步很重要，后面的很多编程思路都是建立在这个降序排列的基础上
vector<Point2f> corners;
//size_t类型
//而数组下标的正确类型则是size_t，是标准C库中定义的一种类型，应为unsigned int
size_t i, j, total = tmpCorners.size(), ncorners = 0;
//下面的程序有点稍微难理解，需要自己仔细想想
//minDistance是传入参数
if(minDistance >= 1){
int w = image.cols;
int h = image.rows;
const int cell_size = cvRound(minDistance); //向最近的整数取整
/* 这里根据cell_size构建了一个矩形窗口grid(虽然下面的grid定义的是vector<vector>，而并不是我们这里说的矩形窗口，但为了便于理解,还是将grid想象成一个 grid_width*grid_height 的矩形窗口比较好)，
除以cell_size说明grid窗口里相差一个像素相当于_image里相差minDistance个像素，至于为什么加上cell_size - 1后面会讲
*/
//w,h是整个图像的，所以grid_width的大小也是对于整个图像的
const int grid_width = (w + cell_size - 1) / cell_size;
const int grid_height = (h + cell_size - 1) / cell_size;
//vector里面是vector，grid用来保存获得的强角点坐标，？注意grid中保存的是坐标，但为什么是Point2f?
std::vector<std::vector<Point2f> > grid(grid_width*grid_height);
minDistance *= minDistance;//平方，方面后面计算，省的开根号
for( i = 0; i < total; i++ ) // 刚刚粗选的弱角点，都要到这里来接收新一轮的考验
{
int ofs = (int)( (const uchar*)tmpCorners[i] - eig.data ); //tmpCorners中保存了角点的地址，eig.data返回eig内存块的首地址？还有eig.data这样的使用法？
int y = (int)(ofs / eig.step); //角点在原图像中的行？eig.step也许是一行的大小吧？
int x = (int)((ofs - y*eig.step)/sizeof(float)); //在原图像中的列
bool good = true;//先认为当前角点就是强角点
int x_cell = x / cell_size;//x_cell，y_cell是角点（y,x）在grid中的对应坐标
int y_cell = y / cell_size;//全部图像分成若干个 grid，，这个x_cell,y_cell处于的grid的坐标
//现在知道为什么前面grid_width定义时要加上cell_size - 1了吧，这是为了使得（y,x）在grid中的4邻域像素都存在，也就是说(y_cell，x_cell）不会成为边界像素 // (y_cell，x_cell）的4邻域像素
int x1 = x_cell - 1;
int y1 = y_cell - 1;
int x2 = x_cell + 1;
int y2 = y_cell + 1;
// boundary check，再次确认x1,y1,x2或y2不会超出grid边界
x1 = std::max(0, x1); //比较0和x1的大小
y1 = std::max(0, y1);
x2 = std::min(grid_width-1, x2);
y2 = std::min(grid_height-1, y2);
//记住grid中相差一个像素，相当于_image中相差了minDistance个像素
for( int yy = y1; yy <= y2; yy++ ){ // 行
for( int xx = x1; xx <= x2; xx++ ){ //列
vector <Point2f> &m = grid[yy*grid_width + xx]; //grid中元素的是Point2f引用
//如果(y_cell，x_cell)的4邻域像素，
//也就是(y,x)的minDistance邻域像素中已有被保留的强角点
if( m.size() ){//m指向一个坐标点
for(j = 0; j < m.size(); j++){ //当前角点周围的强角点都拉出来跟当前角点比一比
float dx = x - m[j].x;
float dy = y - m[j].y;
//注意如果(y,x)的minDistance邻域像素中已有被保留的强角点，则说明该强角点是在(y,x)之前就被测试过的，又因为tmpCorners中已按照特征值降序排列（特征值越大说明角点越好），这说明先测试的一定是更好的角点，也就是已保存的强角点一定好于当前角点，所以这里只要比较距离，如果距离满足条件，可以立马扔掉当前测试的角点
//也就是在一定范围内，只保留一个角点，就是强角点，只不过这里用的转变思想很好啊
if( dx*dx + dy*dy < minDistance ){
good = false;
goto break_out;
}
}
}
} // 列
} //行
break_out:
if(good)
{
// printf("%d: %d %d -> %d %d, %d, %d -- %d %d %d %d, %d %d, c=%d\n",
// i,x, y, x_cell, y_cell, (int)minDistance, cell_size,x1,y1,x2,y2, grid_width,grid_height,c);
grid[y_cell*grid_width + x_cell].push_back(Point2f((float)x, (float)y));
//再从grid中转变会原来图像中的坐标点
corners.push_back(Point2f((float)x, (float)y));
++ncorners;
if( maxCorners > 0 && (int)ncorners == maxCorners ) //由于前面已按降序排列，当ncorners超过maxCorners的时候跳出循环直接忽略tmpCorners中剩下的角点，反正剩下的角点越来越弱
break;
}
}
}
else //除了像素本身，没有哪个邻域像素能与当前像素满足minDistance < 1,因此直接保存粗选的角点
{
for( i = 0; i < total; i++ )
{
int ofs = (int)((const uchar*)tmpCorners[i] - eig.data);
int y = (int)(ofs / eig.step); //粗选的角点在原图像中的行
int x = (int)((ofs - y*eig.step)/sizeof(float)); //在图像中的列
corners.push_back(Point2f((float)x, (float)y));
++ncorners;
if( maxCorners > 0 && (int)ncorners == maxCorners )
break;
}
}
Mat(corners).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);
}
/*
使用Harris（）函数找角点
1、还是使用轮库图查找效果明显一点，只是为什么平滑区域，检测出来的值这么大
2、首先使用normlize()函数，将float的矩阵归一化到0-255 float（）,
convertScaleAbs在转化到CV8U,减少了之后的计算量
3、根据赋值 = -数 的原理想 +=才是另一种
*/
#include "harris2.h"
/*
对输入的图像使用Harris检测，src
之后对于设置的局部框进行抑制，thresh
减少了连续角点的出现
*/
void cornerHarris_demo( Mat& src,int size, int thresh)
{
Mat dst, dst_norm;
dst = Mat::zeros( src.size(), CV_32FC1 );
//harris函数的参数设置
int blockSize = 3;
int apertureSize = 3;
double k = 0.04;
/// Detecting corners
cornerHarris( src, dst, blockSize, apertureSize, k, BORDER_DEFAULT );
///这一步仅仅是为了好让其能够转换成到CV8U
normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
//归一化函数，结果仍是float型
convertScaleAbs(dst_norm,dst_norm,1,0);
imshow("dst_norm",dst_norm);
Mat show=Mat::zeros(src.size(),CV_8UC3);
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
findContours(src, contours, hierarchy, 0, CV_CHAIN_APPROX_NONE);
drawContours(show, contours, -1, Scalar(255,255,255), 1, 8, hierarchy);
//根据Harris函数计算得到的矩阵，进行阈值判断
// for( int j = 0; j < dst_norm.rows ; j++ ){
// for( int i = 0; i < dst_norm.cols; i++ ){
// if( (int) dst_norm.at<float>(j,i) > thresh ){
// circle( show, Point( i, j ), 1, Scalar(0,0,255));
// }
// }
// }
//另一个版本的阈值抑制
//(20*20)的窗口
//设定局部抑制时的窗口，也就是21的窗口有一个极大值点并且设定，变相的减少连续点
//同时进行阈值抑制
for( int i = size ; i < dst_norm.rows-size ; i+=size ){
for( int j = size ; j < dst_norm.cols-size ; j+=size ){
int max=0;
Point point;
for(int u = -size;u<size;u++){//根据赋值 = -数 的原理想 +=才是另一种
for(int v =-size;v<size;v++){
if(max < dst_norm.at<uchar>(i+u,j+v)){
max = dst_norm.at<uchar>(i+u,j+v);
point.y = i+u;
point.x = j+v;
}
}
}
if(max > thresh) circle( show, point, 1, Scalar(0,0,255) );
}
}
//画出角点
imshow( "result", show );
}
/*2017-3-17*/
//加一个括号 初始化为零
bufferGray2= new uchar[m_width*m_height]();
/*2017-3-28*/
/*CvTermCriteria 迭代算法的终止准则 */
#define CV_TERMCRIT_ITER 1
#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER
#define CV_TERMCRIT_EPS 2
typedef struct CvTermCriteria
{
int type; /* CV_TERMCRIT_ITER 和CV_TERMCRIT_EPS二值之一，或者二者的组合 */
int max_iter; /* 最大迭代次数 */
double epsilon; /* 结果的精确性 */
}
//得尽快将opencv 的矩阵的使用方法熟悉
//1、指定随机数种子
RNG rng(100);
rng.fill
//2、从整个数据集中取出前[0,89]行
//注：*Range的范围是[a,b)
Mat trainClass = trainData.rowRange(0,nLinearSamples);
//取出第一列
Mat c = trainClass.colRange(0,1);
//2017-4-6
//使用canny算子，在查找轮廓，会造成轮廓数据混乱，每个轮廓会走两遍，并且有差别
Canny(srcImage,srcImage,100,250);
//2017-12-12
积分直方图：http://blog.csdn.net/linear_luo/article/details/52725358
梯度直方图：https://www.leiphone.com/news/201708/ZKsGd2JRKr766wEd.html
输出是最好的输入，记录并不止是以防忘记！
