• STM32实现霍夫圆检测

    本文要讨论的问题来源于工程实际，摄像头去拍圆形标记点得到一张图像，已知标记圆的半径范围(rmin,rmax)，需要识别出圆心坐标和半径。采用霍夫圆变换可以很好的实现这个功能，且具有广泛的适应性（就是指在大多数情况下都能识别出圆，成功率高）。基本思路是先对圆进行边缘检测，然后对于边缘检测图像进行霍夫圆检测。

    1 霍夫圆检测算法原理

    假设圆的坐标假设为：

    (x-x_{_{c}})^{2}+(y-y_{c})^{2}=r^{2}

    现在已知圆上的一系列点(xi,yi)，则可知圆心（xc,yc）也位于以(xi,yi)为圆心，半径为r的圆上，以这一系列点为圆心画一系列半径为r的圆，则圆心(xc,yc)将位于这些圆的交点上。如下图所示：

     霍夫圆检测的思路就是，对于其中的每一个半径r，做如下处理：

    （1）建立一个投票数组SumArr[height][width]，其中height为图像高度，width为图像宽度

    （2）遍历边缘图像，对其中的每一个边缘点(xi,yi),求出以(xi,yi)为圆心，以r为半径的圆周上的所有像素点，将这些像素点的投票数加1，用伪代码表示为：

    1. for(theta=0;theta<360;theta+=step)
    2. {
    3.     angle = theta*PI/180;
    4.     cx=xi-r*cos(angle);
    5.     cy=xi-r*sin(angle);
    6.     if(cx>=0 && cx<width && cy>=0 && cy<height) 
    7.         sumArr[cy][cx] ++;//坐标点(cx,cy)是潜在的圆心,将其投票数增1
    8. }

    (3)统计sumArr数组中的最大值，这个最大值对应的坐标即图中半径为r的圆所在的圆心。

    (4)遍历半径范围(rmin,rmax)，对于其中每一个半径r,既然可以求出它所对应的投票数candidate,圆心(xc,yc)，取其中投票数最大值对应的半径，即为识别出来的圆半径r,其对应的圆心即为识别出来的圆心。

    2 canny边沿检测算法

    边沿检测算法使用canny边缘检测算法，通过计算图像梯度，

     梯度向量大小

    由于开平方和根号计算较慢，可以用|gx|+|gy|来代替

    计算梯度用sobel算子，sobel算子有俩个：

     将图中的每个像素和sobel算子1和算子2做卷积，求出gx和gy，进而求出梯度值M(x,y)，利用梯度值来进行滤波。代码实现为：

    1. def convolution(img,y,x,width,height,sobel):
    2.     value = [0]*9
    3.     if y-1>=0 and x-1>=0 and y-1<height and x-1<width:
    4.         value[0] = img[y-1][x-1]
    5.     if y-1>=0 and y-1<height:
    6.         value[1] = img[y-1][x]
    7.     if y-1>=0 and y-1<height and x+1<width:
    8.         value[2] = img[y-1][x+1]
    9.     if x-1>=0:
    10.         value[3] = img[y][x-1]
    11.     value[4] = img[y][x]
    12.     if x+1<width:
    13.         value[5] = img[y][x+1]
    14.     if y+1<height and x-1>=0:
    15.         value[6] = img[y+1][x-1]
    16.     if y+1<height:
    17.         value[7] = img[y+1][x]
    18.     if y+1<height and x+1<width:
    19.         value[8] = img[y+1][x+1]
    20.     out = abs(value[0]*sobel[0]+value[1]*sobel[1]+value[2]*sobel[2]+\
    21.         value[3]*sobel[3]+value[4]*sobel[4]+value[5]*sobel[5]+\
    22.         value[6]*sobel[6]+value[7]*sobel[7]+value[8]*sobel[8])
    23.     return int(out)
    24.  
    25. def mycanny(img,minVal,maxVal):
    26.     sobel1 = [-1,-2,-1,0,0,0,1,2,1]
    27.     sobel2 = [-1,0,1,-2,0,2,-1,0,1]
    28.     width = img.shape[1]
    29.     height = img.shape[0]
    30.     out = numpy.zeros(img.shape,dtype=numpy.uint8)
    31.     for y in range(height):
    32.         for x in range(width):
    33.             gx = convolution(img,y,x,width,height,sobel1)
    34.             gy = convolution(img,y,x,width,height,sobel2)
    35.             temp = gx+gy
    36.             if temp <0:
    37.                 temp = 0
    38.             elif temp>255:
    39.                 temp = 255
    40.             if temp<200:
    41.                 out[y][x] = img[y][x]
    42.             else:
    43.                 out[y][x] = temp
    44.     return out

    2 程序实现步骤

    (1) 对原图像进行灰度化处理

    (2) 对灰度图进行canny边缘检测

     (3) 进行圆霍夫检测

    1. def findCir_R(img,r):
    2.     width = img.shape[1]
    3.     height = img.shape[0]
    4.     sumArr = [0]*(width*height)
    5.     for y in range(height):
    6.         for x in range(width):
    7.             if img[y][x] != 255:
    8.                 continue
    9.             for a in range(0,360,10):
    10.                 theta = a*math.pi/180
    11.                 cx = int(x- r*math.cos(theta)) 
    12.                 cy = int(y-r*math.sin(theta))
    13.                 if cx>0 and cx<width and cy>0 and cy<height:
    14.                     sumArr[cy*width+cx] = sumArr[cy*width+cx]+1
    15.     maxVal = 0
    16.     cirX = 0
    17.     cirY = 0
    18.     for y in range(height):
    19.         for x in range(width):
    20.             if sumArr[y*width+x] > maxVal:
    21.                 maxVal = sumArr[y*width+x]
    22.                 cirX = x
    23.                 cirY = y
    24.     return maxVal,cirX,cirY
    25.  
    26. def findCir(img,rmin,rmax):
    27.     maxVal = 0
    28.     cirX = 0
    29.     cirY = 0
    30.     radius = 0
    31.     for r in range(rmin,rmax+1,1):
    32.         value,cx,cy = findCir_R(img,r)
    33.         if value > maxVal:
    34.             maxVal = value
    35.             cirX = cx
    36.             cirY = cy
    37.             radius = r
    38.     return cirX,cirY,radius

    所有代码:

    1. import cv2
    2. import numpy
    3. import os
    4. import math
    5.  
    6. def show_img(window,img):
    7.     cv2.namedWindow(window,0)
    8.     cv2.resizeWindow(window,int(img.shape[1]),int(img.shape[0]))
    9.     cv2.imshow(window,img)
    10.  
    11. def findCir_R(img,r):
    12.     width = img.shape[1]
    13.     height = img.shape[0]
    14.     sumArr = [0]*(width*height)
    15.     for y in range(height):
    16.         for x in range(width):
    17.             if img[y][x] != 255:
    18.                 continue
    19.             for a in range(0,360,10):
    20.                 theta = a*math.pi/180
    21.                 cx = int(x- r*math.cos(theta)) 
    22.                 cy = int(y-r*math.sin(theta))
    23.                 if cx>0 and cx<width and cy>0 and cy<height:
    24.                     sumArr[cy*width+cx] = sumArr[cy*width+cx]+1
    25.     maxVal = 0
    26.     cirX = 0
    27.     cirY = 0
    28.     for y in range(height):
    29.         for x in range(width):
    30.             if sumArr[y*width+x] > maxVal:
    31.                 maxVal = sumArr[y*width+x]
    32.                 cirX = x
    33.                 cirY = y
    34.     return maxVal,cirX,cirY
    35.  
    36. def findCir(img,rmin,rmax):
    37.     maxVal = 0
    38.     cirX = 0
    39.     cirY = 0
    40.     radius = 0
    41.     for r in range(rmin,rmax+1,1):
    42.         value,cx,cy = findCir_R(img,r)
    43.         if value > maxVal:
    44.             maxVal = value
    45.             cirX = cx
    46.             cirY = cy
    47.             radius = r
    48.     return cirX,cirY,radius
    49.  
    50. def convolution(img,y,x,width,height,sobel):
    51.     value = [0]*9
    52.     if y-1>=0 and x-1>=0 and y-1<height and x-1<width:
    53.         value[0] = img[y-1][x-1]
    54.     if y-1>=0 and y-1<height:
    55.         value[1] = img[y-1][x]
    56.     if y-1>=0 and y-1<height and x+1<width:
    57.         value[2] = img[y-1][x+1]
    58.     if x-1>=0:
    59.         value[3] = img[y][x-1]
    60.     value[4] = img[y][x]
    61.     if x+1<width:
    62.         value[5] = img[y][x+1]
    63.     if y+1<height and x-1>=0:
    64.         value[6] = img[y+1][x-1]
    65.     if y+1<height:
    66.         value[7] = img[y+1][x]
    67.     if y+1<height and x+1<width:
    68.         value[8] = img[y+1][x+1]
    69.     out = abs(value[0]*sobel[0]+value[1]*sobel[1]+value[2]*sobel[2]+\
    70.         value[3]*sobel[3]+value[4]*sobel[4]+value[5]*sobel[5]+\
    71.         value[6]*sobel[6]+value[7]*sobel[7]+value[8]*sobel[8])
    72.     return int(out)
    73.  
    74. def mycanny(img,minVal,maxVal):
    75.     sobel1 = [-1,-2,-1,0,0,0,1,2,1]
    76.     sobel2 = [-1,0,1,-2,0,2,-1,0,1]
    77.     width = img.shape[1]
    78.     height = img.shape[0]
    79.     out = numpy.zeros(img.shape,dtype=numpy.uint8)
    80.     for y in range(height):
    81.         for x in range(width):
    82.             gx = convolution(img,y,x,width,height,sobel1)
    83.             gy = convolution(img,y,x,width,height,sobel2)
    84.             temp = gx+gy
    85.             if temp <0:
    86.                 temp = 0
    87.             elif temp>255:
    88.                 temp = 255
    89.             if temp<200:
    90.                 out[y][x] = img[y][x]
    91.             else:
    92.                 out[y][x] = temp
    93.     return out
    94.  
    95. img = cv2.imread("D:/pic/cir22.jpg")
    96. show_img("source",img)
    97.  
    98. gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    99. show_img('gray',gray)
    100.  
    101. #canny = cv2.Canny(img, 200, 400) 
    102. canny = mycanny(gray, 20, 100) 
    103. show_img('canny',canny)
    104. #cv2.waitKey(0)
    105.  
    106. cx,cy,r = findCir(canny,15,30)
    107. print(cx,cy,r)
    108.  
    109. pic = img.copy()
    110. cv2.circle(pic,(cx,cy),r,(0,0,255))
    111. show_img("result",pic)
    112.  
    113. cv2.waitKey(0)

    程序运行效果：

    相比前面文章 《STM32识别圆——色块追踪法》，霍夫圆检测算法识别成功率更高。但是这个算法在进行canny边缘检测时需要额外开辟一块和原图一样大小空间的数组用来存储canny结果，在进行霍夫圆检测时需要开辟投票统计数组sumArr。相比色块追踪法需要消耗更多内存，还需要消耗更多的运算时间。色块追踪法的优势是消耗内存少，运算速度快，但是识别成功率低于霍夫法。

  • 相关阅读:
    模型对象CSS2DObject始终在画布的左上角（问题解决）
    解密Spring Cloud LoadBalancer：实现高效负载均衡的魔法密卷（二）
    scratch绘制正方形 电子学会图形化编程scratch等级考试二级真题和答案解析2022年6月
    Scala配置和Spark配置以及Scala一些函数的用法（附带词频统计实例）
    大家都在用的福昕阅读器 foxit 你还不知道吗? 祛除水印&PDF转换&全功能解锁…
    powerlevel10k 颜色和图标的自定义设置
    【C标准库】详解feof函数与EOF
    Linux中磁盘管理
    一个 nginx 通过不同域名映射多个前端项目
    网页自动跳转到其他页面，点击浏览器返回箭头，回不到原来页面的问题
  • 原文地址：https://blog.csdn.net/liuzhijun301/article/details/125527882