python opencv虚拟现实 opencv python tutorial

Opencv 霍夫变换检测圆

---

霍夫变换概念以及简单图形检测：

原文 下面附重点摘要(个人观点)

• 在OpenCV中，支持两种两种不同的霍夫直线变换，the Standard Hough Transform(SHT,标准霍夫变换)和Progressive Probability Hough Transform(PPHT，渐进概率式霍夫变换)。

（一）标准霍夫变换

函数cv2.HoughLines()返回值实际上是一个二维数据矩阵，表述的就是上述的($\rho$ ,$\theta$)，其中$\rho$的单位是像素长度（即直线到图像原点直线的距离，从上述图b中可以看出），$\theta$的单位是弧度，函数有四个参数输入：

通过调整边缘检测算子Canny阈值参数和标准霍夫变换阈值参数，来获取较好的检测效果。

• 第一个参数，是需要进行检测的灰度图
• 第二、三参数分别是 $\rho$ 和$\theta$的精确度，可以理解为步长。
• 第四个参数为阈值T，认为当累加器中的值高于所设定的阈值T时，才认为是一条直线。
  代码举例

# 标准霍夫变换
img = cv2.imread('malu.jpg')
house = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 获取灰度图
edges = cv2.Canny(house, 50, 200)
lines = cv2.HoughLines(edges, 1, np.pi/180, 260)  # 霍夫变换返回的就是极坐标系中的两个参数  rho和theta
print(np.shape(lines))
lines = lines[:, 0, :]  # 将数据转换到二维
for rho, theta in lines:
    a = np.cos(theta)
    b = np.sin(theta)
    # 从图b中可以看出x0 = rho x cos(theta)
    #               y0 = rho x sin(theta)
    x0 = a*rho
    y0 = b*rho
    # 由参数空间向实际坐标点转换
    x1 = int(x0 + 1000*(-b))
    y1 = int(y0 + 1000*a)
    x2 = int(x0 - 1000*(-b))
    y2 = int(y0 - 1000*a)
    cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 1)
cv2.imshow('img', img)
cv2.imshow('edges', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

（二）渐进概率式霍夫变换

函数cv2.HoughLinesP()是一种概率直线检测，从原理上讲hough变换是一个耗时耗力的算法，尤其是对每一个点的计算，即便经过了canny转换，但有的时候点的数量依然很庞大，这时候采取一种概率挑选机制，不是所有的点都进行计算，而是随机的选取一些点来进行计算，这样的话在阈值设置上也需要降低一些。

与标准霍夫变换函数相比，在参数的输入上多了两个参数：minLineLengh(线的最短长度，比这个线段短的都忽略掉)和maxLineGap(两条直线之间的最大间隔，小于此值，就认为是一条直线)。

这个函数的输出直接是直线点的坐标位置，这样可以省去一系列for循环中的由参数空间到图像的实际坐标点的转换。

img = cv2.imread('house1.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 50, 250)
lines = cv2.HoughLinesP(edges, 1, np.pi/180, 30, minLineLength=60, maxLineGap=10)
lines = lines[:, 0, :]
for x1, y1, x2, y2 in lines:
    cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 1)
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

（三）利用霍夫变换检测圆环

圆的数学的数学表达式为：

(x-x₀)²+(y-y₀)²=r²

所以一个圆的确定需要三个参数，那么就需要三层循环来实现，从而把图像上的所有点映射到三维空间上。寻找参数空间累加器的最大（或者大于某一阈值）的值。那么理论上圆的检测将比直线更耗时，然而OpenCV对其进行了优化，用了霍夫梯度法。

cv2.HoughCircles(image, method, dp, minDist, circles, param1, param2, minRadius, maxRadius)

param1和param2就是\rho和\theta的精确度，最后两个参数是所要检测的圆的最大最小半径，不能盲目的检测，否则浪费时间和空间。输出就是三个参数空间矩阵。

利用霍夫检测对印章进行定位：

img = cv2.imread('yinzhang.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow('img_yuantu', img)
gaussian = cv2.GaussianBlur(gray, (3, 3), 0)
circles1 = cv2.HoughCircles(gaussian, cv2.HOUGH_GRADIENT, 1, 100, param1=100, param2=30, minRadius=15, maxRadius=80)
print(np.shape(circles1))             # hough_gradient 霍夫梯度法
circles = circles1[0, :, :]
circles = np.uint16(np.around(circles))
for i in circles[:]:
    cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 3)
    cv2.circle(img, (i[0], i[1]), 2, (255, 0, 255), 10)
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

---

C++语言
opencv中霍夫变换函数：

void HoughCircles(InputArray image,OutputArray circles, int method, double dp, double minDist, double param1=100,double param2=100, int minRadius=0, int maxRadius=0 )

• 第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的灰度单通道图像。
• 第二个参数，InputArray类型的circles，经过调用HoughCircles函数后此参数存储了检测到的圆的输出矢量，每个矢量由包含了3个元素的浮点（vec3d）矢量(x, y, radius)表示。
• 第三个参数，int类型的method，即使用的检测方法，目前OpenCV中就霍夫梯度法一种可以使用，它的标识符为CV_HOUGH_GRADIENT，在此参数处填这个标识符即可。
• 第四个参数，double类型的dp，用来检测圆心的累加器图像的分辨率于输入图像之比的倒数，且此参数允许创建一个比输入图像分辨率低的累加器。上述文字不好理解的话，来看例子吧。例如，如果dp= 1时，累加器和输入图像具有相同的分辨率。如果dp=2，累加器便有输入图像一半那么大的宽度和高度。
• 第五个参数，double类型的minDist，为霍夫变换检测到的圆的圆心之间的最小距离，即让我们的算法能明显区分的两个不同圆之间的最小距离。这个参数如果太小的话，多个相邻的圆可能被错误地检测成了一个重合的圆。反之，这个参数设置太大的话，某些圆就不能被检测出来了。
• 第六个参数，double类型的param1，有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示传递给canny边缘检测算子的高阈值，而低阈值为高阈值的一半。
• 第七个参数，double类型的param2，也有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示在检测阶段圆心的累加器阈值。它越小的话，就可以检测到更多根本不存在的圆，而它越大的话，能通过检测的圆就更加接近完美的圆形了。
• 第八个参数，int类型的minRadius,有默认值0，表示圆半径的最小值。
• 第九个参数，int类型的maxRadius,也有默认值0，表示圆半径的最大值。

#include <iostream>
#include <opencv2/opencv.hpp>
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include <vector>
#include <boost/concept_check.hpp>
using namespace std;
using namespace cv;
 
int main(int argc, char **argv) {
    Mat src = imread("board.jpg");
    imshow("1",src);
    if(src.empty())
    {
        cout << "can not open "  << endl;
        return -1;
    }
    Mat cimg;
    medianBlur(src, src, 5);
    cvtColor(src,cimg,COLOR_BGR2GRAY);
   GaussianBlur(cimg, cimg, Size(9, 9), 2, 2);
  //   medianBlur(cimg, cimg, 5);
    Canny(cimg,cimg,10,250,5);
    imshow("canny",cimg);
   vector<Vec3f> circles;
  HoughCircles(cimg, circles, HOUGH_GRADIENT, 1, 30,100, 30, 10, 120  );
  
   for (size_t i = 0; i < circles.size(); i++)
    {
            Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
            int radius = cvRound(circles[i][2]);
            //绘制圆心  
            circle(src, center, 3, Scalar(0, 255, 0), -1, 8, 0);
            //绘制圆轮廓  
            circle(src, center, radius, Scalar(155, 50, 255), 3, 8, 0);
     }
   imshow("图片",src);
    cv::waitKey(0);
    return 0;
}

原文
上述对于图片检测还需细调参数

python版本：

1.dp，用来检测圆心的累加器图像的分辨率于输入图像之比的倒数，且此参数允许创建一个比输入图像分辨率低的累加器。上述文字不好理解的话，来看例子吧。例如，如果dp= 1时，累加器和输入图像具有相同的分辨率。如果dp=2，累加器便有输入图像一半那么大的宽度和高度。

2.minDist，为霍夫变换检测到的圆的圆心之间的最小距离，即让我们的算法能明显区分的两个不同圆之间的最小距离。这个参数如果太小的话，多个相邻的圆可能被错误地检测成了一个重合的圆。反之，这个参数设置太大的话，某些圆就不能被检测出来了。

3.param1，有默认值100。它是method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法，它表示传递给canny边缘检测算子的高阈值，而低阈值为高阈值的一半。

4.param2，也有默认值100。它是method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法，它表示在检测阶段圆心的累加器阈值。它越小的话，就可以检测到更多根本不存在的圆，而它越大的话，能通过检测的圆就更加接近完美的圆形了。

5.minRadius，默认值0，表示圆半径的最小值。

6.maxRadius，也有默认值0，表示圆半径的最大值。

# -*- coding: utf-8 -*-
"""
Created on Tue Sep 26 23:15:39 2017
@author: tina
"""
import cv2
import numpy as np
import matplotlib.pyplot as plt
 
img = cv2.imread('C:\\Users\\tina\\Pictures\\ahh\\ball.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
 
plt.subplot(121),plt.imshow(gray,'gray')
plt.xticks([]),plt.yticks([])
 
circles1 = cv2.HoughCircles(gray,cv2.HOUGH_GRADIENT,1,
600,param1=100,param2=30,minRadius=80,maxRadius=97)
circles = circles1[0,:,:]
circles = np.uint16(np.around(circles))
for i in circles[:]: 
    cv2.circle(img,(i[0],i[1]),i[2],(255,0,0),5)
    cv2.circle(img,(i[0],i[1]),2,(255,0,255),10)
    cv2.rectangle(img,(i[0]-i[2],i[1]+i[2]),(i[0]+i[2],i[1]-i[2]),(255,255,0),5)
    
print("圆心坐标",i[0],i[1])
plt.subplot(122),plt.imshow(img)
plt.xticks([]),plt.yticks([])