Ex3：霍夫变换算法实现A4纸直线检测和硬币圆形检测(使用CImg库)
A4纸直线检测
输入图像
普通 A 4 打印纸，上面可能有手写笔记或者打印内容，但是拍照时可能角度不正。
输出图像
- 图像的边缘
- 计算 A4 纸边缘的各直线方程
- 提取 A4 纸的四个角点
如下图：由于原图太大，这里我截图放上来
代码文件
A4纸直线检测网上可以找到很多相关的内容，这里我就不做算法解释了，直接贴上代码。
Hough.h文件：
#include "CImg.h"
#include Hough.cpp文件：
#include "Hough.h"
Hough::Hough(CImg<float> srcImg, double sigma, double gradient_threshold, double vot_threshold, double peak_dis) {
this->result = srcImg;
this->sigma = sigma;
this->gradient_threshold = gradient_threshold;
this->vote_threshold = vot_threshold;
this->peak_dis = peak_dis;
this->x_min = 0;
this->x_max = srcImg._width - 1; // 图像宽度
this->y_min = 0;
this->y_max = srcImg._height - 1; // 图像高度
}
CImg<float> Hough::houghProcess(CImg<float> srcImg) {
this->src = RGBtoGray(srcImg); // 转灰度图
this->blurred_img = src.get_blur(sigma); // 高斯滤波平滑
this->houghspace = initHoughSpace(); // 初始化霍夫空间
findPeaks(); // 找出霍夫空间中直线经过最多的点
drawLines(); // 寻找并画出直线
drawIntersections(); // 寻找并画出直线交点
return result;
}
// 转灰度图
CImg<float> Hough::RGBtoGray(const CImg<float>& srcImg) {
CImg<float> grayImage = CImg<float>(srcImg._width, srcImg._height, 1, 1, 0);
cimg_forXY(grayImage, x, y) {
grayImage(x, y, 0) = (int)round((double)srcImg(x, y, 0, 0) * 0.299 +
(double)srcImg(x, y, 0, 1) * 0.587 +
(double)srcImg(x, y, 0, 2) * 0.114);
}
return grayImage;
}
// 初始化霍夫空间
CImg<float> Hough::initHoughSpace() {
// sobel算子
CImg<float> sobelx(3, 3, 1, 1, 0);
CImg<float> sobely(3, 3, 1, 1, 0);
sobelx(0, 0) = -1, sobely(0, 0) = 1;
sobelx(0, 1) = 0, sobely(0, 1) = 2;
sobelx(0, 2) = 1, sobely(0, 2) = 1;
sobelx(1, 0) = -2, sobely(1, 0) = 0;
sobelx(1, 1) = 0, sobely(1, 1) = 0;
sobelx(1, 2) = 2, sobely(1, 2) = 0;
sobelx(2, 0) = -1, sobely(2, 0) = -1;
sobelx(2, 1) = 0, sobely(2, 1) = -2;
sobelx(2, 2) = 1, sobely(2, 2) = -1;
CImg<float> gradient_x = blurred_img;
gradient_x = gradient_x.get_convolve(sobelx); // 计算x方向上的梯度
CImg<float> gradient_y = blurred_img;
gradient_y = gradient_y.get_convolve(sobely); // 计算y方向上的梯度
int maxp = (int)sqrt(src._width*src._width + src._height*src._height);
CImg<float> hough_space(360, maxp, 1, 1, 0); // 初始化hough space
cimg_forXY(src, i, j) {
double grad = sqrt(gradient_x(i, j)*gradient_x(i, j) + gradient_y(i, j)*gradient_y(i, j));
if (grad > gradient_threshold) {
src(i, j) = grad;
cimg_forX(hough_space, alpha) {
double theta = ((double)alpha*cimg::PI) / 180;
int p = (int)(i*cos(theta) + j*sin(theta));
if (p >= 0 && p < maxp) {
hough_space(alpha, p)++; // 累加矩阵
}
}
}
}
return hough_space;
}
// 投票算法找出霍夫空间中直线经过最多的点
void Hough::findPeaks() {
peaks.clear();
cimg_forXY(houghspace, theta, p) {
if (houghspace(theta, p) > vote_threshold) {
bool flag = true;
double alpha = (double)theta*cimg::PI / 180;
// y的范围
const int y0 = ((double)p / (sin(alpha))) - double(x_min)*(1 / tan(alpha));
const int y1 = ((double)p / (sin(alpha))) - double(x_max)*(1 / tan(alpha));
// x的范围
const int x0 = ((double)p / (cos(alpha))) - double(y_min)*(tan(alpha));
const int x1 = ((double)p / (cos(alpha))) - double(y_max)*(tan(alpha));
if (x0 >= x_min && x0 <= x_max || x1 >= x_min && x1 <= x_max ||
y0 >= y_min && y0 <= y_max || y1 >= y_min && y1 <= y_max) {
for (int i = 0; i < peaks.size(); i++) {
if (sqrt((peaks[i].x - theta)*(peaks[i].x - theta)
+ (peaks[i].y - p)*(peaks[i].y - p)) < peak_dis) {
flag = false;
if (peaks[i].cnt < houghspace(theta, p)) {
Point temp(theta, p, houghspace(theta, p));
peaks[i] = temp;
}
}
}
if (flag) {
Point temp(theta, p, houghspace(theta, p));
peaks.push_back(temp);
}
}
}
}
}
// 寻找并画出直线
void Hough::drawLines() {
lines.clear();
for (int i = 0; i < peaks.size(); i++) {
double theta = double(peaks[i].x)*cimg::PI / 180;
double k = -cos(theta) / sin(theta); // 直线斜率
double b = double(peaks[i].y) / sin(theta);
Line templine(k, b);
lines.push_back(templine);
cout << "Line " << i << ": y = " << k << "x + " << b << endl;
}
const double lines_color[] = { 255, 0, 0 };
for (int i = 0; i < lines.size(); i++) {
const int x0 = (double)(y_min - lines[i].b) / lines[i].k;
const int x1 = (double)(y_max - lines[i].b) / lines[i].k;
const int y0 = x_min*lines[i].k + lines[i].b;
const int y1 = x_max*lines[i].k + lines[i].b;
if (abs(lines[i].k) > 1) {
result.draw_line(x0, y_min, x1, y_max, lines_color);
}
else {
result.draw_line(x_min, y0, x_max, y1, lines_color);
}
}
}
// 寻找并画出直线交点
void Hough::drawIntersections() {
intersections.clear();
int k = 0;
for (int i = 0; i < lines.size(); i++) {
for (int j = i + 1; j < lines.size(); j++) {
double k0 = lines[i].k;
double k1 = lines[j].k;
double b0 = lines[i].b;
double b1 = lines[j].b;
double x = (b1 - b0) / (k0 - k1);
double y = (k0*b1 - k1*b0) / (k0 - k1);
if (x >= 0 && x < src._width && y >= 0 && y < src._height) {
Point tempPoint(x, y, 0);
intersections.push_back(tempPoint);
cout << "Intersection " << k++ << ": x = " << x << ", y = " << y << endl;
}
}
}
const double intersections_color[] = { 255, 0, 0 };
for (int i = 0; i < intersections.size(); i++) {
result.draw_circle(intersections[i].x, intersections[i].y, 50, intersections_color);
}
}main.cpp文件：
#include "Hough.cpp"
int main() {
CImg<float> src("2.bmp");
// args: src sigma gradient_threshold vote_threshold peak_dis
Hough hough(src, 10.5f, 30, 1000, 60);
CImg<float> result = hough.houghProcess(src);
result.display();
result.save("result/2.bmp");
return 0;
}编译运行指示
可以在main.cpp文件中修改要输入的bmp图像，然后在cmd中运行如下命令：
g++ -o main.exe main.cpp -O2 -lgdi32进行编译，最后再运行main.exe得到结果。
硬币圆形检测
输出图像
- 图像的边缘
- 把图像中边缘拟合成圆, 圆周像素用红色像素标出
- 输出图像中硬币的数量
如下图：由于图片太大，这里我是截图放上来的
代码文件
说实话，这个比较难，在作业ddl我并没做出来，所以我“犯规了”，用了python版本的opencv圆形霍夫变换函数进行检测，但调参（半径范围）也是一件比较痛苦的事情2333。
后面有大佬在作业ddl后完成了CImg检测圆形硬币这部分工作，献上我的膝盖。
Python版本：
运行指示：
在cmd中运行如下命令：
python circle_hough_transform.py 1.bmp
也可以修改文件名，改用其他文件，例如2.bmp
circle_hough_transform.py文件：
import sys
import cv2 as cv
import numpy as np
def main(argv):
default_file = "2.bmp"
filename = argv[0] if len(argv) > 0 else default_file
# Loads an image
src = cv.imread(filename, cv.IMREAD_COLOR)
# Check if image is loaded fine
if src is None:
print ('Error opening image!')
print ('Usage: hough_circle.py [image_name -- default ' + default_file + '] \n')
return -1
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
gray = cv.medianBlur(gray, 5)
rows = gray.shape[0]
"""
各张图的最小半径minRadius和最大半径maxRadius
1.bmp: 150 230
2.bmp: 190 230
3.bmp: 146 230
4.bmp: 146 200
5.bmp: 480 525
6.bmp: 40 60
"""
circles = cv.HoughCircles(gray, cv.HOUGH_GRADIENT, 1, rows / 8,
param1=100, param2=30,
minRadius=40, maxRadius=60)
if circles is not None:
circles = np.uint16(np.around(circles))
print("硬币数量：", circles.shape[1])
for i in circles[0, :]:
center = (i[0], i[1])
print("圆心：", center)
# circle center
cv.circle(src, center, 1, (0, 0, 255), 6)
# circle outline
radius = i[2]
print("半径：", radius)
cv.circle(src, center, radius, (0, 0, 255), 3)
cv.imshow("detected circles", src)
cv.imwrite("result/" + filename, src);
cv.waitKey(0)
return 0
if __name__ == "__main__":
main(sys.argv[1:])CImg版本
在Ex2作业（可见我前面的文章）的基础上进行修改，在这里我只把霍夫变换的代码给出来，代码包含了直线检测和圆形检测，只需要修改一下传入参数即可，全部代码文件可见github地址：
EdgeDetect.h文件：
#pragma once
#ifndef EDGE_DETECT_H
#define EDGE_DETECT_H
#include int , int>> lines; // 检测到的直线集合
vector<int> lineWeight; // 累加矩阵
vector<int> sortLineWeight; // 从大到小排序的累加矩阵
CImg<float> edge; // 边缘直线
int circleNumber; // 检测圆个数
int minRadius; // 圆周最小半径
int maxRadius; // 圆周最大半径
vectorint , int>> circles; // 检测到的圆心集合
vectorint , int>> voteSet; // 投票集合
vectorint , int>> center; // 存放累加值最大的圆心对应坐标
vector<int> circleWeight; // 累加矩阵
vector<int> sortCircleWeight; // 从大到小排序的累加矩阵
};
#endif // !EDGE_DETECT_H
EdgeDetect.cpp文件：
#include "EdgeDetect.h"
#include "CANNY.h"
#include int , int>> result; // 存放累加值最大的边缘直线对应斜率和截距
for (int i = 0; i < pointNumber; i++) {
int weight = sortLineWeight[i], index;
vector<int>::iterator iter = find(lineWeight.begin(), lineWeight.end(), weight);
index = iter - lineWeight.begin();
result.push_back(lines[index]);
}
for (int i = 0; i < result.size(); i++) {
int theta = result[i].first, p = result[i].second;
/*根据theta和p求出斜率和截距*/
cimg_forXY(edge, x, y) {
int x0 = x - width / 2, y0 = height / 2 - y;
if (p == (int)(x0 * setCos[theta] + y0 * setSin[theta])) {
edge(x, y) += 255.0 / 2;
outputImage(x, y, 0, 2) = 255;
}
}
}
}
/*描绘所检测出的角点*/
void EdgeDetect::drawPoint() {
unsigned char red[3] = { 255, 0, 0 };
for (int y = 0; y < outputImage._height - 1; y++) {
for (int x = 0; x < outputImage._width - 1; x++) {
int arr[4];
arr[0] = edge(x, y);
arr[1] = edge(x + 1, y);
arr[2] = edge(x, y + 1);
arr[3] = edge(x + 1, y + 1);
if (arr[0] + arr[1] + arr[2] + arr[3] >= 255.0 * 3 / 2) {
outputImage.draw_circle(x, y, 3, red);
}
}
}
outputImage.display("Point Detect");
}
/*霍夫圆变换*/
void EdgeDetect::houghCirclesTransform(CImg<float>& img, int minR, int maxR) {
int width = img._width, height = img._height, max = 0;
for (int r = minR; r < maxR; r += 5) {
max = 0;
houghImage = CImg<float>(width, height);
houghImage.fill(0);
cimg_forXY(img, x, y) {
int value = img(x, y);
if (value != 0) {
for (int i = 0; i < thetaSize; i++) {
int x0 = x - r * setCos[i];
int y0 = y - r * setSin[i];
/*进行voting投票*/
if (x0 > 0 && x0 < width && y0 > 0 && y0 < height) {
houghImage(x0, y0)++;
}
}
}
}
/*每次遍历完r后，找到hough里面的最大投票数，这个投票数表示当前r的吻合程度，然后用投票数最大的r作为最好的r*/
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
if (houghImage(x, y) > max) {
max = houghImage(x, y);
}
}
}
voteSet.push_back(make_pair(max, r));
}
sort(voteSet.begin(), voteSet.end(), [](const pair<int, int>& x, const pair<int, int>& y) -> int {
return x.first > y.first;
});
for (int i = 0; i < circleNumber; i++) {
houghImage = CImg<float>(width, height);
houghImage.fill(0);
cimg_forXY(img, x, y) {
int value = img(x, y);
if (value != 0) {
for (int j = 0; j < thetaSize; j++) {
int x0 = x - voteSet[i].second * setCos[j];
int y0 = y - voteSet[i].second * setSin[j];
/*进行voting投票*/
if (x0 > 0 && x0 < width && y0 > 0 && y0 < height) {
houghImage(x0, y0)++;
}
}
}
}
cout << "The radius is " << voteSet[i].second << endl;
houghCirclesDetect();
drawCircle(voteSet[i].second);
}
outputImage.display("Circle Detect");
}
void EdgeDetect::houghCirclesDetect() {
/*将霍夫图像中所有不为0的点对应圆心的坐标存入数组*/
cimg_forXY(houghImage, x, y) {
if (houghImage(x, y) != 0) {
circles.push_back(make_pair(x, y));
circleWeight.push_back(houghImage(x, y));
}
}
}
void EdgeDetect::drawCircle(int r) {
int width = image._width, height = image._height, count = 0;
unsigned char red[3] = { 255, 0, 0 };
sortCircleWeight = circleWeight;
sort(sortCircleWeight.begin(), sortCircleWeight.end(), greater<int>()); // 将累加矩阵从大到小进行排序
while (1) {
int weight = sortCircleWeight[count], index;
vector<int>::iterator iter = find(circleWeight.begin(), circleWeight.end(), weight);
index = iter - circleWeight.begin();
int a = circles[index].first, b = circles[index].second;
count++;
int i;
for (i = 0; i < center.size(); i++) {
if (sqrt(pow((center[i].first - a), 2) + pow((center[i].second - b), 2)) < minRadius) {
break; // 判断检测出来的圆心坐标是否跟已检测的圆心坐标的距离，如果距离过小，默认是同个圆
}
}
if (i == center.size()) {
center.push_back(make_pair(a, b));
outputImage.draw_circle(a, b, r, red, 5.0f, 1);
break;
}
}
}main.cpp文件：
#include "EdgeDetect.cpp"
#include "CANNY.cpp"
#include 编译运行指示
在cmd窗口下使用如下命令进行编译：
g++ -std=c++11 -o main.exe main.cpp -O2 -lgdi32
然后再运行main.exe得到结果。
完。