cac
/
iec104
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
multi_conns
main
nr_sim
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '05fcaeac89'
${ noResults }
iec104/src/HTTestOpencv.cpp

1849 lines
57 KiB
C++
Raw Blame History Unescape Escape

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

/****************************************************************************
** File name : HTOpencvImg.cpp
** Description : define 104 worker thread group
** Create date : 2018.09.01
** Auther by : Liuyx
** Version info : V1.0.01
** Copyrigth By: xi'an huatek, Inc Co., Ltd
** Update record:
** DATE AUTHER DESC
** -------------------------------------------------------------------------
** 2018.09.01 Liuyx first build
****************************************************************************/
#include "HTGlobal.h"
#include "HTTestOpencv.h"
using namespace cv;
static const char *_FILE_ = "HTTestOpencv.cpp";
#ifndef ERROR
#define ERROR -1
#endif
string hehe[100] = { "time_0.jpg", "time_1.jpg", "time_2.jpg", "time_3.jpg", "time_4.jpg",
"time_5.jpg", "time_6.jpg", "time_7.jpg", "time_8.jpg", "time_9.jpg", };
//-----------------------------------------------------------------------------
//平面几何相关函数http://www.cnblogs.com/zjutlitao/p/3243883.html
//-----------------------------------------------------------------------------
// file exist
bool isExistFile(const char *filename)
{
FILE *fp = NULL;
fp = fopen(filename, "rb");
if (fp == NULL) return false;
fclose(fp);
return true;
}
////求向量的夹角
//double Angle(Point A, Point B)
//{
// return acos(Dot(A, B) / Length(A) / Length(B));
//}
//
////点到直线的距离
//double DistanceToLine(Point P, Point A, Point B)
//{
// Point v1 = B - A, v2 = P - A;
// return fabs(Cross(v1, v2)) / Length(v1);//如果不加绝对值是带有方向的距离
//}
//度数转换
double DegreeTrans(double theta)
{
double res = theta / CV_PI * 180;
return res;
}
//逆时针旋转图像degree角度（原尺寸）
void rotateImage(Mat src, Mat& img_rotate, double degree)
{
//旋转中心为图像中心
Point2f center;
center.x = float(src.cols / 2.0);
center.y = float(src.rows / 2.0);
int length = 0;
length = (int)sqrt(src.cols*src.cols + src.rows*src.rows);
//计算二维旋转的仿射变换矩阵
Mat M = getRotationMatrix2D(center, degree, 1);
warpAffine(src, img_rotate, M, Size(length, length), 1, 0, Scalar(255, 255, 255));//仿射变换，背景色填充为白色
showImg("旋转后:", img_rotate);
}
//通过霍夫变换计算角度
//
double CalcDegree(const Mat &srcImage, Mat &dst)
{
Mat midImage, dstImage;
Canny(srcImage, midImage, 50, 200, 3);
cvtColor(midImage, dstImage, CV_GRAY2BGR);
//通过霍夫变换检测直线
vector<Vec2f> lines;
HoughLines(midImage, lines, 1, CV_PI / 180, 300, 0, 0);//第5个参数就是阈值，阈值越大，检测精度越高
//cout << lines.size() << endl;
//由于图像不同，阈值不好设定，因为阈值设定过高导致无法检测直线，阈值过低直线太多，速度很慢
//所以根据阈值由大到小设置了三个阈值，如果经过大量试验后，可以固定一个适合的阈值。
if (!lines.size())
{
HoughLines(midImage, lines, 1, CV_PI / 180, 200, 0, 0);
}
//cout << lines.size() << endl;
if (!lines.size())
{
HoughLines(midImage, lines, 1, CV_PI / 180, 150, 0, 0);
}
//cout << lines.size() << endl;
if (!lines.size())
{
cout << "没有检测到直线！" << endl;
return -1;
}
float sum = 0;
//依次画出每条线段
for (size_t i = 0; i < lines.size(); i++)
{
float rho = lines[i][0];
float theta = lines[i][1];
Point pt1, pt2;
//cout << theta << endl;
double a = cos(theta), b = sin(theta);
double x0 = a * rho, y0 = b * rho;
pt1.x = cvRound(x0 + 1000 * (-b));
pt1.y = cvRound(y0 + 1000 * (a));
pt2.x = cvRound(x0 - 1000 * (-b));
pt2.y = cvRound(y0 - 1000 * (a));
//只选角度最小的作为旋转角度
sum += theta;
line(dstImage, pt1, pt2, Scalar(55, 100, 195), 1, CV_AA); //Scalar函数用于调节线段颜色
showImg("直线探测效果图", dstImage);
}
float average = sum / lines.size(); //对所有角度求平均，这样做旋转效果会更好
cout << "average theta:" << average << endl;
double angle = DegreeTrans(average) - 90;
rotateImage(dstImage, dst, angle);
showImg("直线探测效果图2", dstImage);
return angle;
}
// 图片矫正
void ImageRecify(const char* pInFileName)
{
double degree;
Mat src = imread(pInFileName);
showImg("原始图", src);
int srcWidth, srcHight;
srcWidth = src.cols;
srcHight = src.rows;
cout << srcWidth << " " << srcHight << endl;
Mat dst;
src.copyTo(dst);
//倾斜角度矫正
degree = CalcDegree(src, dst);
if (degree == ERROR)
{
cout << "矫正失败！" << endl;
return;
}
rotateImage(src, dst, degree);
cout << "angle:" << degree << endl;
showImg("旋转调整后", dst);
Mat resulyImage = dst(Rect(0, 0, srcWidth, srcHight));
showImg("裁剪之后", resulyImage);
//imwrite("recified.jpg", resulyImage);
}
/****************倾斜校正子程序*****************/
//函数名称：IplImage *Rotate(IplImage *RowImage）
//功能：对每行数字进行倾斜校正
//入口参数：行图像RowImage
//出口参数：旋转后的图像RotateRow
//https://blog.csdn.net/ZhtSunday/article/details/52094745
/********************************************/
void ImgRotate(const char *img_file)
{
IplImage * RowImage = cvLoadImage(img_file);
//建立储存边缘检测结果图像canImage
IplImage *canImage = cvCreateImage(cvGetSize(RowImage), IPL_DEPTH_8U, 1);
//进行边缘检测
cvCanny(RowImage, canImage, 30, 200, 3);
//进行hough变换
CvMemStorage *storage = cvCreateMemStorage();
CvSeq *lines = NULL;
lines = cvHoughLines2(canImage, storage, CV_HOUGH_STANDARD, 1, CV_PI / 180, 20, 0, 0);
//统计与竖直夹角<30度的直线个数以及其夹角和
int numLine = 0;
float sumAng = 0.0;
for (int i = 0; i < lines->total; i++)
{
float *line = (float *)cvGetSeqElem(lines, i);
float theta = line[1]; //获取角度 为弧度制
if (theta < 30 * CV_PI / 180 || (CV_PI - theta) < 30 * CV_PI / 180)
{
numLine++;
sumAng = sumAng + theta;
}
}
//计算出平均倾斜角，anAng为角度制
double avAng = ((sumAng / numLine) * 180) / CV_PI;
//获取二维旋转的仿射变换矩阵
CvPoint2D32f center;
center.x = float(RowImage->width / 2.0);
center.y = float(RowImage->height / 2.0);
float m[6];
CvMat M = cvMat(2, 3, CV_32F, m);
cv2DRotationMatrix(center, avAng, 1, &M);
//建立输出图像RotateRow
double a = sin(sumAng / numLine);
double b = cos(sumAng / numLine);
int width_rotate = int(RowImage->height*fabs(a) + RowImage->width*fabs(b));
int height_rotate = int(RowImage->width*fabs(a) + RowImage->height*fabs(b));
IplImage *RotateRow = cvCreateImage(cvSize(width_rotate, height_rotate), IPL_DEPTH_8U, 1);
//变换图像，并用黑色填充其余值
m[2] += (width_rotate - RowImage->width) / 2;
m[5] += (height_rotate - RowImage->height) / 2;
cvWarpAffine(RowImage, RotateRow, &M, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); // 这有异常报出
//释放
cvReleaseImage(&canImage);
cvReleaseMemStorage(&storage);
cvNamedWindow("Roter:");
cvShowImage("Roter", RotateRow);
return; // RotateRow;
}
//旋转图像内容不变，尺寸相应变大
//https ://blog.csdn.net/xiaowei_cqu/article/details/7616044
IplImage* rotateImage1(IplImage* img, int degree) {
double angle = degree * CV_PI / 180.; // 弧度
double a = sin(angle), b = cos(angle);
int width = img->width;
int height = img->height;
int width_rotate = int(height * fabs(a) + width * fabs(b));
int height_rotate = int(width * fabs(a) + height * fabs(b));
//旋转数组map
// [ m0 m1 m2 ] ===> [ A11 A12 b1 ]
// [ m3 m4 m5 ] ===> [ A21 A22 b2 ]
float map[6];
CvMat map_matrix = cvMat(2, 3, CV_32F, map);
// 旋转中心
CvPoint2D32f center = cvPoint2D32f(width / 2, height / 2);
cv2DRotationMatrix(center, degree, 1.0, &map_matrix);
map[2] += (width_rotate - width) / 2;
map[5] += (height_rotate - height) / 2;
IplImage* img_rotate = cvCreateImage(cvSize(width_rotate, height_rotate), 8, 3);
//对图像做仿射变换
//CV_WARP_FILL_OUTLIERS - 填充所有输出图像的象素。
//如果部分象素落在输入图像的边界外，那么它们的值设定为 fillval.
//CV_WARP_INVERSE_MAP - 指定 map_matrix 是输出图像到输入图像的反变换，
cvWarpAffine(img, img_rotate, &map_matrix, CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS, cvScalarAll(0));
return img_rotate;
}
//旋转图像内容不变，尺寸相应变大
//https ://blog.csdn.net/xiaowei_cqu/article/details/7616044
IplImage* rotateImage2(IplImage* img, int degree)
{
double angle = degree * CV_PI / 180.;
double a = sin(angle), b = cos(angle);
int width = img->width, height = img->height;
//旋转后的新图尺寸
int width_rotate = int(height * fabs(a) + width * fabs(b));
int height_rotate = int(width * fabs(a) + height * fabs(b));
IplImage* img_rotate = cvCreateImage(cvSize(width_rotate, height_rotate), img->depth, img->nChannels);
cvZero(img_rotate);
//保证原图可以任意角度旋转的最小尺寸
int tempLength = (int)(sqrt((double)width * width + (double)height *height) + 10);
int tempX = (tempLength + 1) / 2 - width / 2;
int tempY = (tempLength + 1) / 2 - height / 2;
IplImage* temp = cvCreateImage(cvSize(tempLength, tempLength), img->depth, img->nChannels);
cvZero(temp);
//将原图复制到临时图像tmp中心
cvSetImageROI(temp, cvRect(tempX, tempY, width, height));
cvCopy(img, temp, NULL);
cvResetImageROI(temp);
//旋转数组map
// [ m0 m1 m2 ] ===> [ A11 A12 b1 ]
// [ m3 m4 m5 ] ===> [ A21 A22 b2 ]
double m[6];
int w = temp->width;
int h = temp->height;
m[0] = b;
m[1] = a;
m[3] = -m[1];
m[4] = m[0];
// 将旋转中心移至图像中间
m[2] = w * 0.5f;
m[5] = h * 0.5f;
CvMat M = cvMat(2, 3, CV_32F, m);
cvGetQuadrangleSubPix(temp, img_rotate, &M);
cvReleaseImage(&temp);
return img_rotate;
}
// 仿照matlab，自适应求高低两个门限
// https://blog.csdn.net/debug__boy/article/details/8179730
void _AdaptiveFindThreshold(CvMat *dx, CvMat *dy, double *low, double *high)
{
CvSize size;
IplImage *imge = 0;
int i, j;
CvHistogram *hist;
int hist_size = 255;
float range_0[] = { 0, 256 };
float* ranges[] = { range_0 };
double PercentOfPixelsNotEdges = 0.7;
size = cvGetSize(dx);
imge = cvCreateImage(size, IPL_DEPTH_32F, 1);
// 计算边缘的强度, 并存于图像中
float maxv = 0;
for (i = 0; i < size.height; i++)
{
const short* _dx = (short*)(dx->data.ptr + dx->step*i);
const short* _dy = (short*)(dy->data.ptr + dy->step*i);
float* _image = (float *)(imge->imageData + imge->widthStep*i);
for (j = 0; j < size.width; j++)
{
_image[j] = (float)(abs(_dx[j]) + abs(_dy[j]));
maxv = maxv < _image[j] ? _image[j] : maxv;
}
}
if (maxv == 0) {
*high = 0;
*low = 0;
cvReleaseImage(&imge);
return;
}
// 计算直方图
range_0[1] = maxv;
hist_size = (int)(hist_size > maxv ? maxv : hist_size);
hist = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1);
cvCalcHist(&imge, hist, 0, NULL);
int total = (int)(size.height * size.width * PercentOfPixelsNotEdges);
float sum = 0;
int icount = hist->mat.dim[0].size;
float *h = (float*)cvPtr1D(hist->bins, 0);
for (i = 0; i < icount; i++)
{
sum += h[i];
if (sum > total)
break;
}
// 计算高低门限
*high = (i + 1) * maxv / hist_size;
*low = *high * 0.4;
cvReleaseImage(&imge);
cvReleaseHist(&hist);
}
// 根据图片，自动获取边缘高低阈值
// https://blog.csdn.net/debug__boy/article/details/8179730
//void AdaptiveFindThreshold(const CvArr* image, double *low, double *high, int aperture_size)
void AdaptiveFindThreshold(cv::Mat& image, double *low, double *high, int aperture_size)
{
//cv::Mat src = cv::cvarrToMat(image);
const int cn = image.channels();
cv::Mat dx(image.rows, image.cols, CV_16SC(cn));
cv::Mat dy(image.rows, image.cols, CV_16SC(cn));
cv::Sobel(image, dx, CV_16S, 1, 0, aperture_size, 1, 0, cv::BORDER_REPLICATE);
cv::Sobel(image, dy, CV_16S, 0, 1, aperture_size, 1, 0, cv::BORDER_REPLICATE);
CvMat _dx = dx, _dy = dy;
_AdaptiveFindThreshold(&_dx, &_dy, low, high);
}
// 识别仪表盘读数
double dReadPointerParserImg(const char *img_file)
{
int i = 0;
if (!img_file && strlen(img_file) <= 0) {
return -1;
}
//src-->gray-->dst(src为原图；gaus是经过高斯模糊平滑后的图，gray是gaus经canny提取边缘的图，
//用于下面霍夫变换；dst是最终结果图，要在gray灰度图的基础上变为彩色图才能呈现画线效果）
Mat src, gray, dst, srcImage;
src = imread(img_file); //读取图片到mat
// showImg("原始图", src);
srcImage = src;
/*
// 霍夫圆变换
cvtColor(srcImage, midImage, CV_BGR2GRAY); // 转为灰度图
GaussianBlur(midImage, midImage, Size(9, 9), 2, 2); // 模糊
vector<Vec3f> circles;
HoughCircles(midImage, circles, CV_HOUGH_GRADIENT, 1, 30, 115, 90, 0, 0);
printf("HoughCircles return resault == %d\n", circles.size());
*/
// 霍夫圆变换
cvtColor(src, gray, CV_BGR2GRAY); //转为单通道的灰度图
GaussianBlur(gray, gray, Size(9, 9), 2, 2); // 高斯模糊平滑
//储存检测圆的容器
std::vector<Vec3f> circles;
//调用Hough变换检测圆
//参数为：待检测图像gray，检测结果circles，检测方法（这个参数唯一）,累加器的分辨率2，
//两个圆间的距离50，canny门限的上限（下限自动设为上限的一半），圆心所需要的最小的投票数，最大和最小半径
HoughCircles(gray, circles, CV_HOUGH_GRADIENT, 1, 30, 115, 90, 0, 0);
printf("HoughCircles return resault == %d\n", (int)circles.size());
if (circles.size() <= 0) {
printf("HoughCircles return resault == %d\n", (int)circles.size());
return -1;
}
//找出圆盘（因为最大的不一定是的，所以加了几个限制条件）
int pos = 0;
int max = -1;
for (size_t i = 0; i < circles.size(); i++)
{
Vec3f f = circles[i];
if (f[2] > max && f[0] + f[2] < gray.rows && f[0] - f[2] >= 0 && f[1] + f[2] < gray.cols && f[1] - f[2]>0)
{
max = (int)f[2];
pos = i;
}
}
//Point center;
//if (circles.size() > 0) {
// 找到圆心
Point center((int)circles[pos][0], (int)circles[pos][1]);
// 找到的半径
int radius = (int)circles[pos][2];
// 绘制圆心
circle(src, center, 3, Scalar(0, 255, 0), -1, 8, 0);
// 绘制圆轮廓
circle(src, center, radius, Scalar(255), 2);
//}
// 效果图
//showImg("霍夫圆变换", src);
/*******************************************************************************/
// 霍夫线变换
Canny(src, gray, 100, 300, 3); // 边缘检测
cvtColor(gray, dst, CV_GRAY2BGR); // 转为RGB图
vector<Vec4i> lines;
// 检测直线，最小投票为100，线条不短于50，间隙不小于10
HoughLinesP(gray, lines, 1, CV_PI / 180, 100, 50, 10);
printf("HoughLinesP return resault == %d\n", (int)lines.size());
list<MyLine> list_MyLine;
for (size_t i = 0; i < lines.size(); i++)
{
Vec4i l = lines[i];
Point A(l[0], l[1]), B(l[2], l[3]);
if (DistancetoSegment(center, A, B) < 30)//根据圆心到指针的距离阈值滤掉其他线段
{
bool down = (A.y + B.y - 2 * center.y > 0);//判断长的在过圆心的水平线上部还是下部
if (A.x == B.x) //斜率为无穷的情况
{
list_MyLine.push_back(MyLine(i, 90 + (down ? 180 : 0), (int)Length(Point(A.x - B.x, A.y - B.y))));
}
else if (A.y == B.y) //水平的情况
{
list_MyLine.push_back(MyLine(i, A.x + B.x - 2 * center.x > 0 ? 0 : 180, (int)Length(Point(A.x - B.x, A.y - B.y))));
}
else
{
if (down) {
if (A.y > center.y)
list_MyLine.push_back(MyLine(i, 360 - (int)(atan2(A.y - B.y, A.x - B.x) * 180 / PI), (int)Length(Point(A.x - B.x, A.y - B.y))));
else
list_MyLine.push_back(MyLine(i, 360 - (int)(atan2(B.y - A.y, B.x - A.x) * 180 / PI), (int)Length(Point(A.x - B.x, A.y - B.y))));
}
else {
if (A.y < center.y)
list_MyLine.push_back(MyLine(i, abs((int)(atan2(A.y - B.y, A.x - B.x) * 180 / PI)), (int)Length(Point(A.x - B.x, A.y - B.y))));
else
list_MyLine.push_back(MyLine(i, abs((int)(atan2(B.y - A.y, B.x - A.x) * 180 / PI)), (int)Length(Point(A.x - B.x, A.y - B.y))));
}
}
//line(dst, A, B, Scalar(0, 0, i * 20 + 40), 2, CV_AA);
line(dst, A, B, Scalar(186, 88, 255), 1, CV_AA);
}
}
//根据角度区分所属指针
int now_k, pre_k = 720;//当前线段的角度和前一个线段的角度
int num = 0;//指针数（可能为2或3）
int Du[3] = { 0 };//3个指针的度数（每组的平均）
int Le[3] = { 0 };//Le[i]=Le_ping[i]*0.2+le_max[i]*0.8;
int Le_ping[3] = { 0 };//3个指针的长度（每组的平均）
int Le_max[3] = { 0 };//3个指针的长度（每组区最大的）
int t_num = 0;//每组的数量（求平均用）
MyLine now_Line;
list_MyLine.push_back(MyLine(99, 888, 0));//向其中插入一个右边界这样方便处理
list_MyLine.sort();
while (!list_MyLine.empty())
{
now_Line = list_MyLine.front();
now_k = now_Line.k;
if (abs(now_k - pre_k) > 10)//两个角度之差小于10°的算是同一类
{
if (num != 0) //对本组的度数和长度求平均
{
Du[num - 1] /= t_num;
Le_ping[num - 1] /= t_num;
Le[num - 1] = (int)(Le_ping[num - 1] * 0.2 + Le_max[num - 1] * 0.8);
}
if (now_k == 888) break;//右边界直接跳出
t_num = 0;//重新统计下一组
num++;//组数增加1
cout << "---------------------------\n";//输出分割线
}
t_num++;//组内多一条线
Du[num - 1] += now_Line.k;
Le_ping[num - 1] += now_Line.l;
if (now_Line.l > Le_max[num - 1]) Le_max[num - 1] = now_Line.l;
now_Line.print();
list_MyLine.pop_front();
pre_k = now_k;
}
cout << "---------------------------\n\n";
cout << "---------------------------\n";
int t;
for (int i = 0; i < num - 1; i++)
{
for (int j = i + 1; j < num; j++)
{
if (Le[i] > Le[j])
{
t = Le[i], Le[i] = Le[j], Le[j] = t;
t = Du[i], Du[i] = Du[j], Du[j] = t;
}//if end
}//for end
}//for end
char s[3][10] = { "point1:", "point2:", "point3:" };
for (int i = 0; i < num; i++)
printf("%s k: %3d° l: %3d\n", s[i], Du[i], Le[i]);
cout << "---------------------------\n";
if (num == 1)
printf("read is: %5.2f\n", (float)abs(((360 - Du[0] + 90) % 360 / 30)));
if (num == 2)
printf("read is: %5.2f %5.2f\n", (float)((360 - Du[0] + 90) % 360 / 30), (float)((360 - Du[1] + 90) % 360 / 6));
else if (num == 3)
printf("read is: %5.2f %5.2f %5.2f\n", (float)((360 - Du[0] + 90) % 360 / 30), (float)((360 - Du[1] + 90) % 360 / 6), (float)((360 - Du[2] + 90) % 360 / 6));
cout << "---------------------------\n";
showImg("src", src);
showImg("dst", dst);
return 0;
}
// 霍夫圆、线变换
double dReadValue(const char *img_file)
{
Mat srcImage = imread(img_file);
Mat midImage, dstImage;
// 显示原始图
//showImg("原始图", srcImage);
// 霍夫圆变换
cvtColor(srcImage, midImage, CV_BGR2GRAY); // 转为灰度图
GaussianBlur(midImage, dstImage, Size(9, 9), 2, 2); // 模糊
vector<Vec3f> circles;
HoughCircles(midImage, circles, CV_HOUGH_GRADIENT, 1, 30, 115, 90, 0, 0);
printf("HoughCircles return resault == %d\n", (int)circles.size());
// 找出圆盘
int pos = 0;
int max = -1;
for (size_t i = 0; i < circles.size(); i++)
{
Vec3f f = circles[i];
if (f[2] > max && f[0] + f[2] < midImage.rows && f[0] - f[2] >= 0 && f[1] + f[2] < midImage.cols && f[1] - f[2] > 0)
{
max = (int)f[2];
pos = i;
}
}
if (circles.size() > 0)
{
// 找到圆心
Point center((int)circles[pos][0], (int)circles[pos][1]);
// 找到的半径
int radius = (int)circles[pos][2];
// 绘制圆心
circle(srcImage, center, 3, Scalar(0, 255, 0), -1, 8, 0);
// 绘制圆轮廓
circle(srcImage, center, radius, Scalar(255), 2);
}
// 效果图
//showImg("霍夫圆变换", srcImage);
// 霍夫线变换
Canny(srcImage, midImage, 100, 300, 3); // 边缘检测
cvtColor(midImage, dstImage, CV_GRAY2BGR); // 转为灰度图
vector<Vec4i> lines;
// 检测直线，最小投票为100，线条不短于50，间隙不小于10
HoughLinesP(midImage, lines, 1, CV_PI / 180, 100, 50, 10);
printf("HoughLinesP return resault == %d\n", (int)lines.size());
for (size_t i = 0; i < lines.size(); i++)
{
Vec4i l = lines[i];
Point pt1(l[0], l[1]);
Point pt2(l[2], l[3]);
line(dstImage, pt1, pt2, Scalar(186, 88, 255), 1, CV_AA);
}
// showImg("边缘检测图", midImage);
//showImg("霍夫线变换", dstImage);
return 0;
}
//******************双阈值处理*************************
//第一个参数imageInput输入和输出的的Sobel梯度幅值图像；
//第二个参数lowThreshold是低阈值
//第三个参数highThreshold是高阈值
// 指定一个低阈值A，一个高阈值B，一般取B为图像整体灰度级分布的70%，且B为1.5到2倍大小的A；
// 灰度值大于B的，置为255，灰度值小于A的，置为0；
//******************************************************
void DoubleThreshold(Mat &imageIput, double lowThreshold, double highThreshold)
{
for (int i = 0; i < imageIput.rows; i++)
{
for (int j = 0; j < imageIput.cols; j++)
{
//printf("[%d:%d] = %d\n", i, j, imageIput.at<uchar>(i, j));
if (imageIput.at<uchar>(i, j) > highThreshold)
{
imageIput.at<uchar>(i, j) = 255;
}
if (imageIput.at<uchar>(i, j) < lowThreshold)
{
imageIput.at<uchar>(i, j) = 0;
}
}
}
}
/*
生成高斯卷积核 kernel
*/
void Gaussian_kernel(int kernel_size, int sigma, Mat &kernel)
{
double pi = 3.1415926f;
int m = kernel_size / 2;
kernel = Mat(kernel_size, kernel_size, CV_32FC1);
float s = (float)(2 * sigma*sigma);
for (int i = 0; i < kernel_size; i++)
{
for (int j = 0; j < kernel_size; j++)
{
int x = i - m;
int y = j - m;
double w = exp(-(x*x + y * y) / s);
kernel.at<int>(i, j) = (int)(w / (pi*s));
}
}
}
/*
计算梯度值和方向
imageSource 原始灰度图
imageX X方向梯度图像
imageY Y方向梯度图像
gradXY 该点的梯度幅值
pointDirection 梯度方向角度
*/
void GradDirection(const Mat imageSource, Mat &imageX, Mat &imageY, Mat &gradXY, Mat &theta)
{
imageX = Mat::zeros(imageSource.size(), CV_32SC1);
imageY = Mat::zeros(imageSource.size(), CV_32SC1);
gradXY = Mat::zeros(imageSource.size(), CV_32SC1);
theta = Mat::zeros(imageSource.size(), CV_32SC1);
int rows = imageSource.rows;
int cols = imageSource.cols;
int stepXY = imageX.step;
int step = imageSource.step;
/*
Mat.step参数指图像的一行实际占用的内存长度，
因为opencv中的图像会对每行的长度自动补齐（8的倍数），
编程时尽量使用指针，指针读写像素是速度最快的，使用at函数最慢。
*/
uchar *PX = imageX.data;
uchar *PY = imageY.data;
uchar *P = imageSource.data;
uchar *XY = gradXY.data;
for (int i = 1; i < rows - 1; i++)
{
for (int j = 1; j < cols - 1; j++)
{
int a00 = P[(i - 1)*step + j - 1];
int a01 = P[(i - 1)*step + j];
int a02 = P[(i - 1)*step + j + 1];
int a10 = P[i*step + j - 1];
int a11 = P[i*step + j];
int a12 = P[i*step + j + 1];
int a20 = P[(i + 1)*step + j - 1];
int a21 = P[(i + 1)*step + j];
int a22 = P[(i + 1)*step + j + 1];
double gradY = double(a02 + 2 * a12 + a22 - a00 - 2 * a10 - a20);
double gradX = double(a00 + 2 * a01 + a02 - a20 - 2 * a21 - a22);
//PX[i*stepXY + j*(stepXY / step)] = abs(gradX);
//PY[i*stepXY + j*(stepXY / step)] = abs(gradY);
imageX.at<int>(i, j) = (int)abs(gradX);
imageY.at<int>(i, j) = (int)abs(gradY);
if (gradX == 0)
{
gradX = 0.000000000001;
}
theta.at<int>(i, j) = (int)(atan(gradY / gradX)*57.3);
theta.at<int>(i, j) = (theta.at<int>(i, j) + 360) % 360;
gradXY.at<int>(i, j) = (int)sqrt(gradX*gradX + gradY * gradY);
//XY[i*stepXY + j*(stepXY / step)] = sqrt(gradX*gradX + gradY*gradY);
}
}
convertScaleAbs(imageX, imageX);
convertScaleAbs(imageY, imageY);
convertScaleAbs(gradXY, gradXY);
}
/*
局部非极大值抑制
沿着该点梯度方向，比较前后两个点的幅值大小，若该点大于前后两点，则保留，
若该点小于前后两点任意一点，则置为0；
imageInput 输入得到梯度图像
imageOutput 输出的非极大值抑制图像
theta 每个像素点的梯度方向角度
imageX X方向梯度
imageY Y方向梯度
*/
void NonLocalMaxValue(const Mat imageInput, Mat &imageOutput, const Mat &theta, const Mat &imageX, const Mat &imageY)
{
imageOutput = imageInput.clone();
int cols = imageInput.cols;
int rows = imageInput.rows;
for (int i = 1; i < rows - 1; i++)
{
for (int j = 1; j < cols - 1; j++)
{
if (0 == imageInput.at<uchar>(i, j))continue;
int g00 = imageInput.at<uchar>(i - 1, j - 1);
int g01 = imageInput.at<uchar>(i - 1, j);
int g02 = imageInput.at<uchar>(i - 1, j + 1);
int g10 = imageInput.at<uchar>(i, j - 1);
int g11 = imageInput.at<uchar>(i, j);
int g12 = imageInput.at<uchar>(i, j + 1);
int g20 = imageInput.at<uchar>(i + 1, j - 1);
int g21 = imageInput.at<uchar>(i + 1, j);
int g22 = imageInput.at<uchar>(i + 1, j + 1);
int direction = theta.at<int>(i, j); //该点梯度的角度值
int g1 = 0;
int g2 = 0;
int g3 = 0;
int g4 = 0;
double tmp1 = 0.0; //保存亚像素点插值得到的灰度数
double tmp2 = 0.0;
double weight = fabs((double)imageY.at<uchar>(i, j) / (double)imageX.at<uchar>(i, j));
if (weight == 0)weight = 0.0000001;
if (weight > 1)
{
weight = 1 / weight;
}
if ((0 <= direction && direction < 45) || 180 <= direction && direction < 225)
{
tmp1 = g10 * (1 - weight) + g20 * (weight);
tmp2 = g02 * (weight)+g12 * (1 - weight);
}
if ((45 <= direction && direction < 90) || 225 <= direction && direction < 270)
{
tmp1 = g01 * (1 - weight) + g02 * (weight);
tmp2 = g20 * (weight)+g21 * (1 - weight);
}
if ((90 <= direction && direction < 135) || 270 <= direction && direction < 315)
{
tmp1 = g00 * (weight)+g01 * (1 - weight);
tmp2 = g21 * (1 - weight) + g22 * (weight);
}
if ((135 <= direction && direction < 180) || 315 <= direction && direction < 360)
{
tmp1 = g00 * (weight)+g10 * (1 - weight);
tmp2 = g12 * (1 - weight) + g22 * (weight);
}
if (imageInput.at<uchar>(i, j) < tmp1 || imageInput.at<uchar>(i, j) < tmp2)
{
imageOutput.at<uchar>(i, j) = 0;
}
}
}
}
/*
连接处理:
灰度值介于A和B之间的，考察该像素点临近的8像素是否有灰度值为255的，
若没有255的，表示这是一个孤立的局部极大值点，予以排除，置为0；
若有255的，表示这是一个跟其他边缘有“接壤”的可造之材，置为255，
之后重复执行该步骤，直到考察完之后一个像素点。
其中的邻域跟踪算法，从值为255的像素点出发找到周围满足要求的点，把满足要求的点设置为255，
然后修改i,j的坐标值，i,j值进行回退，在改变后的i,j基础上继续寻找255周围满足要求的点。
当所有连接255的点修改完后，再把所有上面所说的局部极大值点置为0；（算法可以继续优化）。
参数1，imageInput：输入和输出的梯度图像
参数2，lowTh:低阈值
参数3，highTh:高阈值
*/
void DoubleThresholdLink(Mat &imageInput, double lowTh, double highTh)
{
int cols = imageInput.cols;
int rows = imageInput.rows;
for (int i = 1; i < rows - 1; i++)
{
for (int j = 1; j < cols - 1; j++)
{
double pix = imageInput.at<uchar>(i, j);
if (pix != 255)continue;
bool change = false;
for (int k = -1; k <= 1; k++)
{
for (int u = -1; u <= 1; u++)
{
if (k == 0 && u == 0)continue;
double temp = imageInput.at<uchar>(i + k, j + u);
if (temp >= lowTh && temp <= highTh)
{
imageInput.at<uchar>(i + k, j + u) = 255;
change = true;
}
}
}
if (change)
{
if (i > 1)i--;
if (j > 2)j -= 2;
}
}
}
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
if (imageInput.at<uchar>(i, j) != 255)
{
imageInput.at<uchar>(i, j) = 0;
}
}
}
}
/*
Canny边缘检测主要包括：
图像的灰度化；
图像的高斯滤波，来平滑图像，同时消除和降低图像噪声的影响；
计算出每一个像素点位置的梯度（X方向梯度、Y方向梯度、已经该点的梯度幅值）和方向角度；Y方向和X方向梯度的比值，得出梯度方向，X梯度的平方和+Y梯度的平方和的值，再进行求平方得到该点的梯度幅值。（Sobel算子等）
局部非极大值抑制处理；梯度方向垂直于边缘方向，在梯度方向上进行非极大值抑制可以细化边缘，在梯度方向上比较该点前后两个点的梯度的大小，如果大于两个点则保留，小于任意一个点则置为0。
双阈值处理和连接处理；指定高低阈值，然后高阈值直接赋值为255，低阈值为0，中间的值进行连接处理。如果中间的值八邻域内有255，则该值也变为255，也就是说255往周围进行扩张，收集边缘加闭合边缘。
*/
int HTCanny(char *filename)
{
Mat image = imread(filename, 0);
showImg("origin image", image);
//转换为灰度图
Mat grayImage;
//cvtColor(image, grayImage, CV_RGB2GRAY);
cvtColor(image, grayImage, CV_GRAY2BGR);
imshow("灰度图", grayImage);
//计算XY方向梯度
Mat imageX, imageY, imageXY;
Mat theta;
GradDirection(grayImage, imageX, imageY, imageXY, theta);
imshow("计算XY方向梯度", imageXY);
//对梯度幅值进行非极大值抑制
Mat localImage;
NonLocalMaxValue(imageXY, localImage, theta, imageX, imageY);
imshow("对梯度幅值进行非极大值抑制", localImage);
//双阈值算法检测和边缘连接
DoubleThreshold(localImage, 30, 100);
DoubleThresholdLink(localImage, 30, 100);
imshow("双阈值算法检测和边缘连接", localImage);
Mat temMat;
vector<Vec4i> lines2;
Canny(image, temMat, 30, 100);
HoughLinesP(temMat, lines2, 1, CV_PI / 180, 50, 30, 10);
printf("lines2 = %d\n", (int)lines2.size());
for (size_t i = 0; i < lines2.size(); i++)
{
Vec4i l = lines2[i];
Point A(l[0], l[1]), B(l[2], l[3]);
line(temMat, A, B, Scalar(255, 0, 0), 2, CV_AA);
}
imshow("线条监测", temMat);
waitKey(0);
return 0;
}
/************************************************************************/
//////////////////////////////////////////////////////////////////
//函数功能：用向量来做COSα=两向量之积/两向量模的乘积求两条线段夹角
//输入： 线段3个点坐标pt1,pt2,pt0,最后一个参数为公共点
//输出： 线段夹角，单位为角度
//////////////////////////////////////////////////////////////////
double angle(CvPoint* pt1, CvPoint* pt2, CvPoint* pt0)
{
double dx1 = pt1->x - pt0->x;
double dy1 = pt1->y - pt0->y;
double dx2 = pt2->x - pt0->x;
double dy2 = pt2->y - pt0->y;
double angle_line = (dx1*dx2 + dy1 * dy2) / sqrt((dx1*dx1 + dy1 * dy1)*(dx2*dx2 + dy2 * dy2) + 1e-10);//余弦值
return acos(angle_line) * 180 / 3.141592653;
}
//////////////////////////////////////////////////////////////////
//函数功能：采用多边形检测，通过约束条件寻找矩形
//输入： img 原图像
// storage 存储
// minarea，maxarea 检测矩形的最小/最大面积
// minangle,maxangle 检测矩形边夹角范围，单位为角度
//输出： 矩形序列
//////////////////////////////////////////////////////////////////
CvSeq* findSquares4(IplImage* img, CvMemStorage* storage, int minarea, int maxarea, int minangle, int maxangle, int(&temp)[30])
{
CvSeq* contours;//边缘
int N = 6; //阈值分级
CvSize sz = cvSize(img->width & -2, img->height & -2);
IplImage* timg = cvCloneImage(img);//拷贝一次img
IplImage* gray = cvCreateImage(sz, 8, 1); //img灰度图
IplImage* pyr = cvCreateImage(cvSize(sz.width / 2, sz.height / 2), 8, 3); //金字塔滤波3通道图像中间变量
IplImage* tgray = cvCreateImage(sz, 8, 1);;
CvSeq* result;
double s, t;
int sk = 0;
CvSeq* squares = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvPoint), storage);
cvSetImageROI(timg, cvRect(0, 0, sz.width, sz.height));
//金字塔滤波
cvPyrDown(timg, pyr, 7);
cvPyrUp(pyr, timg, 7);
//在3个通道中寻找矩形
for (int c = 0; c < 3; c++) //对3个通道分别进行处理
{
cvSetImageCOI(timg, c + 1);
cvCopy(timg, tgray, 0); //依次将BGR通道送入tgray
for (int l = 0; l < N; l++)
{
//不同阈值下二值化
cvThreshold(tgray, gray, 75, 250, CV_THRESH_BINARY);
cvShowImage("111", gray);
cvFindContours(gray, storage, &contours, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0));
while (contours)
{ //多边形逼近
result = cvApproxPoly(contours, sizeof(CvContour), storage, CV_POLY_APPROX_DP, cvContourPerimeter(contours)*0.02, 0);
//如果是凸四边形并且面积在范围内
if (result->total == 4 && fabs(cvContourArea(result, CV_WHOLE_SEQ)) > minarea && fabs(cvContourArea(result, CV_WHOLE_SEQ)) < maxarea && cvCheckContourConvexity(result))
{
s = 0;
//判断每一条边
for (int i = 0; i < 5; i++)
{
if (i >= 2)
{ //角度
t = fabs(angle((CvPoint*)cvGetSeqElem(result, i), (CvPoint*)cvGetSeqElem(result, i - 2), (CvPoint*)cvGetSeqElem(result, i - 1)));
s = s > t ? s : t;
}
}
//这里的S为直角判定条件 单位为角度
if (s > minangle && s < maxangle)
{
for (int i = 0; i < 4; i++)
cvSeqPush(squares, (CvPoint*)cvGetSeqElem(result, i));
CvRect rect = cvBoundingRect(contours, 1); // 获取矩形边界框
CvPoint p1;
p1 = cvPoint(rect.x + rect.width / 2, rect.y + rect.height / 2); //矩形中心坐标
std::cout << "X:" << p1.x << "Y：" << p1.y << std::endl;
}
}
contours = contours->h_next;
}
}
std::cout << "圆的数量是" << sk << std::endl;
temp[26] = sk;
sk = 0;
}
cvReleaseImage(&gray);
cvReleaseImage(&pyr);
cvReleaseImage(&tgray);
cvReleaseImage(&timg);
return squares;
}
//////////////////////////////////////////////////////////////////
//函数功能：画出所有矩形
//输入： img 原图像
// squares 矩形序列
// wndname 窗口名称
//输出： 图像中标记矩形
//////////////////////////////////////////////////////////////////
void drawSquares(IplImage* img, CvSeq* squares, const char* wndname)
{
CvSeqReader reader;
IplImage* cpy = cvCloneImage(img);
CvPoint pt[4];
int i;
cvStartReadSeq(squares, &reader, 0);
for (i = 0; i < squares->total; i += 4)
{
CvPoint* rect = pt;
int count = 4;
memcpy(pt, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
memcpy(pt + 1, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
memcpy(pt + 2, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
memcpy(pt + 3, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
//cvPolyLine( cpy, &rect, &count, 1, 1, CV_RGB(0,255,0), 3, CV_AA, 0 );
cvPolyLine(cpy, &rect, &count, 1, 1, CV_RGB(rand() & 255, rand() & 255, rand() & 255), 1, CV_AA, 0);//彩色绘制
}
cvShowImage("22", cpy);
cvReleaseImage(&cpy);
}
void SendMessageOne(char *rtsp_url)
{
String rtsp_addr = rtsp_url;
VideoCapture capture(rtsp_addr);
//开起摄像头
//capture.open(0);
Mat edges; //定义转化的灰度图
const char* winn = "1111";
if (!capture.isOpened())
{
namedWindow("【效果图】", CV_WINDOW_NORMAL);
}
while (1)
{
int Y = 0, J = 0;
Mat frame;
capture >> frame;
IplImage img0 = frame;
//Mat E = frame(Range(1, 320), Range(1, 240));
Mat E = frame(Range(1, 160), Range(1, 240));
cvtColor(frame, edges, CV_BGR2GRAY);
//高斯滤波
GaussianBlur(edges, edges, Size(7, 7), 2, 2);
std::vector<Vec3f> circles;//存储每个圆的位置信息
//霍夫圆
HoughCircles(edges, circles, CV_HOUGH_GRADIENT, 1.5, 5, 100, 240, 0, 50);
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]);
//std::cout << "圆的X是" << circles[i][0] << "圆的Y是" << circles[i][1] << std:: endl;
//绘制圆轮廓
circle(frame, center, radius, Scalar(155, 50, 255), 3, 8, 0);
int R = frame.at<Vec3b>(cvRound(circles[i][1]), cvRound(circles[i][0]))[2];//R
int G = frame.at<Vec3b>(cvRound(circles[i][1]), cvRound(circles[i][0]))[1];//G
int B = frame.at<Vec3b>(cvRound(circles[i][1]), cvRound(circles[i][0]))[0];//B
int num = R + G + B;
std::cout << "圆心颜色是" << num << std::endl;
}
imshow("【效果图】", frame);
if ('q' == waitKey(30)) break;
}
}
/**************************************************/
using namespace cv;
using namespace std;
cv::Mat img;
bool select_flag = false;
cv::Rect m_select;
cv::Point origin;
int ROI_count;
void onMouseRectPicking(int event, int x, int y, int, void*)
{
if (select_flag)
{
m_select.x = MIN(origin.x, x);//不一定要等鼠标弹起才计算矩形框，而应该在鼠标按下开始到弹起这段时间实时计算所选矩形框
m_select.y = MIN(origin.y, y);
m_select.width = abs(x - origin.x);//算矩形宽度和高度
m_select.height = abs(y - origin.y);
m_select &= cv::Rect(0, 0, img.cols, img.rows);//保证所选矩形框在视频显示区域之内
}
if (event == CV_EVENT_LBUTTONDOWN)
{
select_flag = true; //鼠标按下的标志赋真值
origin = cv::Point(x, y); //保存下来单击捕捉到的点
m_select = cv::Rect(x, y, 0, 0); //这里一定要初始化，宽和高为(0,0)是因为在opencv中Rect矩形框类内的点是包含左上角那个点的，但是不含右下角那个点
}
else if (event == CV_EVENT_LBUTTONUP)
{
select_flag = false;
ROI_count++;
}
}
// 鼠标选取区域，实现截图功能并保持图片
void vCutPicture(char *filename)
{
img = imread(filename);
bool stop = false;
cv::namedWindow("capframe", CV_WINDOW_AUTOSIZE);
cv::setMouseCallback("capframe", onMouseRectPicking, 0);
char pic_name[40];
ROI_count = 0;
while (!stop)
{
img = imread(filename);
cv::rectangle(img, m_select, cv::Scalar(255, 0, 0), 2, 8, 0); // 画矩形框
cv::imshow("capframe", img);
if ((m_select.x != 0) && (m_select.y != 0) && (m_select.width != 0) && (m_select.height != 0))
{
sprintf(pic_name, "ROI_%d.jpg", ROI_count);
Mat ROI = img(m_select);
imshow("ROI_WIN", ROI);
imwrite(pic_name, ROI);
}
char key = cv::waitKey(30);
if (key == 'q') stop = true;
}
waitKey(0);
return;
}
//////////////////////////////////
//检测直线方法
int iCheckLine(char *filename)
{
int i;
IplImage* src = cvLoadImage(filename, 0);
IplImage* dst;
IplImage* color_dst;
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* lines = 0;
if (!src) return -1;
dst = cvCreateImage(cvGetSize(src), 8, 1);
color_dst = cvCreateImage(cvGetSize(src), 8, 3);
cvCanny(src, dst, 50, 200, 3);
cvCvtColor(dst, color_dst, CV_GRAY2BGR);
#if 0
lines = cvHoughLines2(dst, storage, CV_HOUGH_STANDARD, 1, CV_PI / 180, 100, 0, 0);
for (i = 0; i < MIN(lines->total, 100); i++)
{
float* line = (float*)cvGetSeqElem(lines, i);
float rho = line[0];
float theta = line[1];
CvPoint pt1, pt2;
double a = cos(theta), b = sin(theta);
double x0 = a * rho, y0 = b * rho;
pt1.x = cvRound(x0 + 1000 * (-b));
pt1.y = cvRound(y0 + 1000 * (a));
pt2.x = cvRound(x0 - 1000 * (-b));
pt2.y = cvRound(y0 - 1000 * (a));
cvLine(color_dst, pt1, pt2, CV_RGB(255, 0, 0), 3, CV_AA, 0);
}
#else
lines = cvHoughLines2(dst, storage, CV_HOUGH_PROBABILISTIC, 1, CV_PI / 180, 50, 50, 10);
for (i = 0; i < lines->total; i++)
{
CvPoint* line = (CvPoint*)cvGetSeqElem(lines, i);
cvLine(color_dst, line[0], line[1], CV_RGB(255, 0, 0), 3, CV_AA, 0);
}
#endif
cvNamedWindow("Source", 1);
cvShowImage("Source", src);
cvNamedWindow("Hough", 1);
cvShowImage("Hough", color_dst);
cvReleaseMemStorage(&storage);
cvWaitKey(0);
return 0;
}
//检测圆方法
int iCheckCircles(char *filename)
{
IplImage* img;
if (img = cvLoadImage(filename, 1))
{
IplImage* gray = cvCreateImage(cvGetSize(img), 8, 1);
CvMemStorage* storage = cvCreateMemStorage(0);
cvCvtColor(img, gray, CV_BGR2GRAY);
cvSmooth(gray, gray, CV_GAUSSIAN, 9, 9); // smooth it, otherwise a lot of false circles may be detected
CvSeq* circles = cvHoughCircles(gray, storage, CV_HOUGH_GRADIENT, 2, gray->height / 5, 200, 100);
int i;
for (i = 0; i < circles->total; i++)
{
float* p = (float*)cvGetSeqElem(circles, i);
cvCircle(img, cvPoint(cvRound(p[0]), cvRound(p[1])), 3, CV_RGB(0, 255, 0), -1, 8, 0);
cvCircle(img, cvPoint(cvRound(p[0]), cvRound(p[1])), cvRound(p[2]), CV_RGB(0, 255, 0), 3, 8, 0);
}
cvNamedWindow("circles", 1);
cvShowImage("circles", img);
cvReleaseImage(&gray);
cvReleaseMemStorage(&storage);
}
return 0;
}
//检测矩形代码：
/*
在程序里找寻矩形
*/
#ifdef _CH_
#pragma package <opencv>
#endif
IplImage* imgfx = 0;
CvMemStorage* storage = 0;
static const char* names[] = { "pic1.png", "pic2.png", "pic3.png", "pic4.png", "pic5.png", "pic6.png", 0 };
int thresh = 50;
// helper function:
// finds a cosine of angle between vectors
// from pt0->pt1 and from pt0->pt2
//double angle(CvPoint* pt1, CvPoint* pt2, CvPoint* pt0)
//{
// double dx1 = pt1->x - pt0->x;
// double dy1 = pt1->y - pt0->y;
// double dx2 = pt2->x - pt0->x;
// double dy2 = pt2->y - pt0->y;
// return (dx1*dx2 + dy1*dy2) / sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
//}
// returns sequence of squares detected on the image.
// the sequence is stored in the specified memory storage
CvSeq* findSquares4(IplImage* img, CvMemStorage* storage)
{
CvSeq* contours;
int i, c, l, N = 11;
CvSize sz = cvSize(img->width & -2, img->height & -2);
IplImage* timg = cvCloneImage(img); // make a copy of input image
IplImage* gray = cvCreateImage(sz, 8, 1);
IplImage* pyr = cvCreateImage(cvSize(sz.width / 2, sz.height / 2), 8, 3);
IplImage* tgray;
CvSeq* result;
double s, t;
// create empty sequence that will contain points -
// 4 points per square (the square's vertices)
CvSeq* squares = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvPoint), storage);
// select the maximum ROI in the image
// with the width and height divisible by 2
cvSetImageROI(timg, cvRect(0, 0, sz.width, sz.height));
// down-scale and upscale the image to filter out the noise
cvPyrDown(timg, pyr, 7);
cvPyrUp(pyr, timg, 7);
tgray = cvCreateImage(sz, 8, 1);
// find squares in every color plane of the image
for (c = 0; c < 3; c++)
{
// extract the c-th color plane
cvSetImageCOI(timg, c + 1);
cvCopy(timg, tgray, 0);
// try several threshold levels
for (l = 0; l < N; l++)
{
// hack: use Canny instead of zero threshold level.
// Canny helps to catch squares with gradient shading  
if (l == 0)
{
// apply Canny. Take the upper threshold from slider
// and set the lower to 0 (which forces edges merging)
cvCanny(tgray, gray, 0, thresh, 5);
// dilate canny output to remove potential
// holes between edge segments
cvDilate(gray, gray, 0, 1);
}
else
{
// apply threshold if l!=0:
//     tgray(x,y) = gray(x,y) < (l+1)*255/N ? 255 : 0
cvThreshold(tgray, gray, (l + 1) * 255 / N, 255, CV_THRESH_BINARY);
}
// find contours and store them all as a list
cvFindContours(gray, storage, &contours, sizeof(CvContour),
CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0));
// test each contour
while (contours)
{
// approximate contour with accuracy proportional
// to the contour perimeter
result = cvApproxPoly(contours, sizeof(CvContour), storage,
CV_POLY_APPROX_DP, cvContourPerimeter(contours)*0.02, 0);
// square contours should have 4 vertices after approximation
// relatively large area (to filter out noisy contours)
// and be convex.
// Note: absolute value of an area is used because
// area may be positive or negative - in accordance with the
// contour orientation
if (result->total == 4 &&
fabs(cvContourArea(result, CV_WHOLE_SEQ)) > 1000 &&
cvCheckContourConvexity(result))
{
s = 0;
for (i = 0; i < 5; i++)
{
// find minimum angle between joint
// edges (maximum of cosine)
if (i >= 2)
{
t = fabs(angle(
(CvPoint*)cvGetSeqElem(result, i),
(CvPoint*)cvGetSeqElem(result, i - 2),
(CvPoint*)cvGetSeqElem(result, i - 1)));
s = s > t ? s : t;
}
}
// if cosines of all angles are small
// (all angles are ~90 degree) then write quandrange
// vertices to resultant sequence
if (s < 0.3)
for (i = 0; i < 4; i++)
cvSeqPush(squares,
(CvPoint*)cvGetSeqElem(result, i));
}
// take the next contour
contours = contours->h_next;
}
}
}
// release all the temporary images
cvReleaseImage(&gray);
cvReleaseImage(&pyr);
cvReleaseImage(&tgray);
cvReleaseImage(&timg);
return squares;
}
// the function draws all the squares in the image
void drawSquares(IplImage* img, CvSeq* squares)
{
CvSeqReader reader;
IplImage* cpy = cvCloneImage(img);
int i;
CvPoint pt[4];
// initialize reader of the sequence
cvStartReadSeq(squares, &reader, 0);
// read 4 sequence elements at a time (all vertices of a square)
for (i = 0; i < squares->total; i += 4)
{
CvPoint* rect = pt;
int count = 4;
// read 4 vertices
memcpy(pt, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
memcpy(pt + 1, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
memcpy(pt + 2, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
memcpy(pt + 3, reader.ptr, squares->elem_size);
CV_NEXT_SEQ_ELEM(squares->elem_size, reader);
// draw the square as a closed polyline
cvPolyLine(cpy, &rect, &count, 1, 1, CV_RGB(255, 255, 255), 3, CV_AA, 0);
}
// show the resultant image
cvShowImage("Square Detection Demo", cpy);
cvReleaseImage(&cpy);
}
void on_trackbar(int a)
{
if (imgfx)
drawSquares(imgfx, findSquares4(imgfx, storage));
}
// 检测矩形
int iCheckFangXiang(char *filename)
{
IplImage* img0 = 0;
int c;
// create memory storage that will contain all the dynamic data
storage = cvCreateMemStorage(0);
// load i-th image
img0 = cvLoadImage(filename, 1);
cvShowImage("原图", img0);
if (!img0)
{
printf("Couldn't load %s/n", filename);
return 0;
}
imgfx = cvCloneImage(img0);
// create window and a trackbar (slider) with parent "image" and set callback
// (the slider regulates upper threshold, passed to Canny edge detector)
//cvNamedWindow("Square Detection Demo1"，1);
cvCreateTrackbar("canny thresh", "Square Detection Demo2", &thresh, 1000, on_trackbar);
// force the image processing
on_trackbar(0);
// wait for key.
// Also the function cvWaitKey takes care of event processing
c = cvWaitKey(0);
// release both images
cvReleaseImage(&imgfx);
cvReleaseImage(&img0);
// clear memory storage - reset free space position
cvClearMemStorage(storage);
cvDestroyWindow("Square Detection Demo3");
return 0;
}
///////////////////////////////////////////////////////////////////////////////////
double Angles(Point cen, Point first, Point second)
{
double M_PIs = 3.1415926535897;
double ma_x = first.x - cen.x;
double ma_y = first.y - cen.y;
double mb_x = second.x - cen.x;
double mb_y = second.y - cen.y;
double v1 = (ma_x * mb_x) + (ma_y * mb_y);
double ma_val = sqrt(ma_x * ma_x + ma_y * ma_y);
double mb_val = sqrt(mb_x * mb_x + mb_y * mb_y);
double cosM = v1 / (ma_val * mb_val);
double angleAMB = acos(cosM) * 180 / M_PIs;
return angleAMB;
}
/************************************************************************
*函数名： get_point_angle
*
*函数作用： 已知2个坐标点，求从 0------->x 逆时针需旋转多少角度到该位置
*
* |
* |
* |
* |
*------------------------------------> x
* | 0
* |
* |
* |
* v
* y
*
*函数参数：
*CvPoint2D32f pointO - 起点
*CvPoint2D32f pointA - 终点
*
*函数返回值：
*double 向量OA，从 0------->x 逆时针需旋转多少角度到该位置
**************************************************************************/
double get_point_angles(CvPoint pointO, CvPoint pointA)
{
double angle = 0;
CvPoint point;
double temp;
point = cvPoint((pointA.x - pointO.x), (pointA.y - pointO.y));
if ((0 == point.x) && (0 == point.y))
{
return 0;
}
if (0 == point.x)
{
angle = 90;
return angle;
}
if (0 == point.y)
{
angle = 0;
return angle;
}
temp = fabsf(float(point.y) / float(point.x));
temp = atan(temp);
temp = temp * 180 / CV_PI;
if ((0 < point.x) && (0 < point.y))
{
angle = 360 - temp;
return angle;
}
if ((0 > point.x) && (0 < point.y))
{
angle = 360 - (180 - temp);
return angle;
}
if ((0 < point.x) && (0 > point.y))
{
angle = temp;
return angle;
}
if ((0 > point.x) && (0 > point.y))
{
angle = 180 - temp;
return angle;
}
printf("sceneDrawing :: getAngle error!");
return -1;
}
Mat src, src_gray;
Mat dst, detected_edges;
int edgeThresh = 1;
int lowThreshold = 77;
int max_lowThreshold = 100;
int ratio = 3;
int kernel_size = 3;
vector<Vec3f> circles;
Point g_Center(0, 0);
int g_radius = 0;
/**
* @函数 CannyThreshold
* @简介： trackbar 交互回调 - Canny阈值输入比例1:3
*/
void CannyThreshold(int, void*)
{
int radius = 0;
int iMaxLimit = 0;
double min = 0;
string window_name = "Edge Map";
/// 使用 3x3内核降噪
//while (lowThreshold > 0) {
blur(src_gray, detected_edges, Size(3, 3));
/// 运行Canny算子
Canny(detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size);
//printf("LowThresold : %d -- %d \n", lowThreshold, lowThreshold*ratio);
/// 使用 Canny算子输出边缘作为掩码显示原图像,声明一个三通道图像，像素值全为0，用来将霍夫变换检测出的圆画在上面
dst = Scalar::all(0);
src.copyTo(dst, detected_edges);
HoughCircles(detected_edges, circles, CV_HOUGH_GRADIENT,
1, //dp,累加器图像的分辨率,增大则分辨率变小
100, // 100, //minDist,很重要的一个参数，告诉两个圆之间的距离的最小距离，如果已知一副图像，可以先行计
//算出符合自己需要的两个圆之间的最小距离。
150, //param1,canny算法的阈值上限，下限为一半（即100以上为边缘点，50以下抛弃，中间视是否相连而定）
100, //param2,决定成圆的多寡 ，一个圆上的像素超过这个阈值，则成圆，否则丢弃
230, //minRadius,最小圆半径，这个可以通过图片确定你需要的圆的区间范围
460 //maxRadius,最大圆半径
);
//imshow(window_name, dst);
// if (circles.size() <= 0) {
// lowThreshold--;
// continue;
//}
// break;
//}
if (circles.size() <= 0) {
printf("Can not circles, return, thred=%d\n", lowThreshold);
return;
}
for (size_t i = 0; i < circles.size(); i++)//把霍夫变换检测出的圆画出来
{
Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
radius = cvRound(circles[i][2]);
g_Center = center;
g_radius = radius;
line(dst, center, center, Scalar(0, 0, 255), 8);
//circle(dst, center, 0, Scalar(0, 255, 0), -1, 8, 0);
int a = cvRound(circles[i][0]);
int b = cvRound(circles[i][1]);
circle(dst, center, radius, Scalar(255, 0, 0), 2);
//printf("low=%.4f max=%d\n", lowThreshold, iMaxLimit);
printf("No%d - {%d} %4d %dx%d %d %d %d\n", i + 1, lowThreshold,
(int)circles.size(), a, b, radius, dst.cols, dst.rows);
//在控制台输出圆心坐标和半径
}
imshow(window_name, dst);
#if 1
// 找线段
vector<Vec4i> lines2;
int Len = 0, iCirLen = 0;
HoughLinesP(detected_edges, lines2, 1, CV_PI / 180, 50, 50, 10);
double vv = 0.0f;
double fmin = 26.0f;
int p = 0;
//while (p <= 0) {
// min++;
for (int n = 0; n < (int)lines2.size(); n++)
{
// minangle = 60 maxangle = 320 最大刻度量 10，theta = 220
Point A(lines2[n][0], lines2[n][1]), B(lines2[n][2], lines2[n][3]); // 一条线段的2头坐标点
Point C((int)circles[0][0], (int)circles[0][1]); // 圆心点坐标
double vv = DistancetoSegment(C, A, B);
Len = (int)Length(Point(A.x - B.x, A.y - B.y));
//printf("Len=%d vv = %.4f\n", Len, vv);
if (Len > 150 && vv < fmin) {
fmin = vv;
line(dst, A, B, Scalar(0, 255, 0), 2, CV_AA);
printf("OK_Len=%d vv = %.4f\n", Len, vv);
imshow(window_name, dst);
}
//iCirLen = (int)Length(Point((int)C.x - B.x, (int)C.y - B.y));
//if (Len > g_radius) // && vv < 13.0f) {
//if (Len > 100 && vv < 10.0f) {
// line(dst, A, B, Scalar(0, 255, 0), 2, CV_AA);
// min = vv;
// p = n;
// //
// //int x_angle = B.x - A.x;
// //int y_angle = A.y - B.y;
// //if (x_angle <= 0) continue;
// //double theta = atan(tan(y_angle / x_angle));
// //double final_theta = 0;
// //// 左右分
// ////if ((x_angle > 0 && y_angle > 0) || (x_angle > 0 && y_angle < 0))
// //// final_theta = 270 - theta;
// ////if ((x_angle < 0 && y_angle >0) || (x_angle < 0 && y_angle < 0))
// //// final_theta = 90 - theta;
// ////上下分
// //if ((x_angle > 0 && y_angle > 0) || (x_angle < 0 && y_angle > 0))
// // final_theta = 360 - theta;
// //if ((x_angle > 0 && y_angle <0) || (x_angle < 0 && y_angle < 0))
// // final_theta = 180 - theta;
// // minangle = 48, maxangle = 320 最大刻度量 10
// double du = get_point_angles(B, A);
// //double val = (final_theta - 48) * 1.6f / (270 - 24);
// //double val = dGetReadValueOfYZFTH(du, 360, Len);
// double val = (du * 10) / (270);
// //printf_s(" = %.2f° %.2f %.2f %.2f %.2f [%d]\n", Angles(C, B, A), val, final_theta, theta, vv, Len);
// //printf_s(" = %.2f° %.2f %.2f %.2f %.2f [%d]\n", get_point_angles(B,A), val, final_theta, theta, vv, Len);
// printf(" = %.2f° [%.2f] %.2f [%d]\n", get_point_angles(B, A), val, vv, Len);
//}
}
printf("OK_Len=%d vv = %.4f\n", Len, fmin);
//}
#endif
imshow(window_name, dst);
}
// 检测线段
void vHoughLines(int, void*)
{
string window_name = "Edge Map";
// 找线段
vector<Vec4i> lines2;
int Len = 0, iCirLen = 0;
HoughLinesP(detected_edges, lines2, 1, CV_PI / 180, 50, 50, 10);
for (int n = 0; n < (int)lines2.size(); n++)
{
// minangle = 60 maxangle = 320 最大刻度量 10，theta = 220
Point A(lines2[n][0], lines2[n][1]), B(lines2[n][2], lines2[n][3]); // 一条线段的2头坐标点
Point C((int)circles[0][0], (int)circles[0][1]); // 圆心点坐标
double vv = DistancetoSegment(C, A, B);
Len = (int)Length(Point(A.x - B.x, A.y - B.y));
iCirLen = (int)Length(Point((int)C.x - B.x, (int)C.y - B.y));
if (Len > g_radius && vv < 10.0f) {
line(dst, A, B, Scalar(0, 255, 0), 2, CV_AA);
//
int x_angle = B.x - C.x;
int y_angle = C.y - B.y;
if (x_angle <= 0) continue;
double theta = atan(tan(y_angle / x_angle));
double final_theta = 0;
// 左右分
//if ((x_angle > 0 && y_angle > 0) || (x_angle > 0 && y_angle < 0))
// final_theta = 270 - theta;
//if ((x_angle < 0 && y_angle >0) || (x_angle < 0 && y_angle < 0))
// final_theta = 90 - theta;
//上下分
if ((x_angle > 0 && y_angle > 0) || (x_angle < 0 && y_angle > 0))
final_theta = 360 - theta;
if ((x_angle > 0 && y_angle < 0) || (x_angle < 0 && y_angle < 0))
final_theta = 180 - theta;
double val = (final_theta - 60) * 10 / (320 - 60);
//double val = (final_theta - 48) * 10 / (270 - 24);
printf("%.2f %.2f %.2f %.2f %.2f\n", Angles(C, A, B), val, final_theta, theta, vv);
}
}
imshow(window_name, dst);
}
// 滑动窗口检测图片圆和线段
void HTImgAnalys(const char *img_file)
{
char *window_name = NULL;
/// 装载图像
src = imread(img_file);
//AdaptiveFindThreshold(src, (double*)&lowThreshold, (double*)&max_lowThreshold, 3);
//AdaptiveFindThreshold(src, &lowThreshold, &max_lowThreshold, 3);
printf("lowThreshold = %f max_lowThreshold=%f\n", lowThreshold, max_lowThreshold);
window_name = (char*)img_file;
if (!src.data)
{
perror("error");
return;
}
printf("width x higth = %dx%d\n", src.cols, src.rows);
printf("No. Ltld Htld cirs center radius w_cols h_rows Angles value final_theta theta vv Len\n");
// 创建与src同类型和大小的矩阵(dst)
dst.create(src.size(), src.type());
// 原图像转换为灰度图像
cvtColor(src, src_gray, CV_BGR2GRAY);
// 创建显示窗口
namedWindow(window_name, CV_WINDOW_AUTOSIZE);
// 创建trackbar
createTrackbar("Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold);
// createTrackbar("Min Threshold:", window_name, (int*)&low, max, CannyThreshold);
// 显示图像
CannyThreshold(0, 0);
//vHoughLines(0, 0);
// 等待用户反应
waitKey(0);
dst.release();
}
// 上海自动化仪表股份有限公司OCr17Ni12Mo2压力表，min~max=0-1.6MPa
void vInitPress_OCR17NI12MO2_16()
{
// radio, du, val
float initdu = 225.0f; //max 315-1.6, 225-0.0
float du = 225.0f;
float val = 0;
int i = 0;
for (i = 0; i < 80; i++)
{
printf("{%d,%.2f,%.2f},\n", 183, du, val);
du -= 5.40f;
if (du < 0) du = 360 - du;
val += 0.05f;
}
printf("{%d,%.2f,%.2f},\n", 180, du, val);
}
// 上海自动化仪表股份有限公司OCr17Ni12Mo2压力表，min~max=0-2.5MPa
void vInitPress_OCR17NI12MO2_25()
{
}
Reference in New Issue View Git Blame Copy Permalink