计算机视觉（三）

左手的ㄟ右手 2022-06-03 10:38 419阅读 0赞

1、滤波器

傅里叶变换主要作用反应图像各区域像素变化的幅度。

滤波器（核）矩阵：一组权重集合（内部所有值加和为0），作用在源图像的一个区域（滑动），并由此生成目标图像的一个元素。

高通滤波器（HPF）：检测图像的某个区域，然后根据像素与周围像素的亮度差值来提升该像素的滤波器。如果亮度变化很大，中央像素的亮度会增加（反之则不会）。

（即某个像素比它周围的像素更突出，就会提升它的亮度）

  1. def convolve(input, weights, output=None, mode='reflect', cval=0.0,
  2.              origin=0):       
  4. return _correlate_or_convolve(input, weights, output, mode, cval,
  5.                               origin, True)
  7. input : array_like Input array to filter. weights : array_like Array of weights, same number of dimensions as input output : ndarray, optional The `output` parameter passes an array in which to store the filter output. Output array should have different name as compared to input array to avoid aliasing errors. mode : {'reflect','constant','nearest','mirror', 'wrap'}, optional the `mode` parameter determines how the array borders are handled. For 'constant' mode, values beyond borders are set to be `cval`. Default is 'reflect'. cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0 origin : array_like, optional The `origin` parameter controls the placement of the filter, relative to the centre of the current element of the input. Default of 0 is equivalent to ``(0,)*input.ndim``.
  12. def GaussianBlur(src, ksize, sigmaX, dst=None, sigmaY=None, borderType=None): # real signature unknown; restored from __doc__ """ GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst """ pass

参数1：源图像

参数2：高斯矩阵尺寸

参数3：标准差

高斯矩阵的尺寸越大，标准差越大，处理过的图像模糊程度越大。

自定义卷积核。

  1. from cv2 import *
  2. import numpy as np
  3. from scipy import ndimage
  5. kernel_3x3=np.array([[-1,-1,-1],
  6.                      [-1,8,-1],
  7.                      [-1,-1,-1]])
  9. kernel_5x5=np.array([[-1,-1,-1,-1,-1],
  10.                      [-1,1,2,1,-1],
  11.                      [-1,2,4,2,-1],
  12.                      [-1,1,2,1,-1],
  13.                      [-1,-1,-1,-1,-1]])
  15. img=imread("D:/temp/1.jpg",0)
  16. img1=ndimage.convolve(img,kernel_3x3)# 注：使用ndimage.convolve()时，滤波核的维度应与原始图像的维度相同，故此采用灰度图
  17. img2=ndimage.convolve(img,kernel_5x5)
  19. blurred=GaussianBlur(img,(11,11),0)
  20. g_hpf=img-blurred
  22. imshow('Pic',img)
  23. imshow('3x3',img1)
  24. imshow('5x5',img2)
  25. imshow('g_hpf',g_hpf)
  27. waitKey()
  28. destroyAllWindows()

低通滤波器（LPF）：在像素与周围的亮度差值小于一个特定值时，平滑该像素的亮度，用于去噪和模糊化。如上面的高斯模糊（平滑滤波器）。

2、边缘检测

  1.   OpenCV提供了许多边缘检测滤波函数，包括Laplacian()、Sobel()以及Scharr()。这些滤波函数都会将**非边缘区域转为黑色**，将**边缘区域转为白色或其他饱和的颜色**。但是，这些函数都很容易将噪声错误地识别为边缘。缓解这个问题的方法是在**找到边缘之前对图像进行模糊处理**。OpenCV也提供了许多模糊滤波函数，包括blur()（简单的算术平均）、medianBlur()以及GaussianBlur()。边缘检测滤波函数和模糊滤波函数的参数有很多，但总会有一个ksize参数，它是一个奇数，表示滤波器的宽和高（以像素为单位）。

　　这里使用medianBlur()作为模糊函数，它对去除数字化的视频噪声非常有效，特别是去除彩色图像的噪声；使用Laplacian()作为边缘检测函数，它会产生明显的边缘线条，灰度图像更是如此。在使用medianBlur()函数之后，将要使用Laplacian()函数之前，需要将图像从BGR色彩空间转为灰度色彩空间。

　　在得到Laplacian()函数的结果之后，需要将其转换成黑色边缘和白色背景的图像。然后将其归一化（使它的像素值在0到1之间），并乘以源图像以便能将边缘变黑。

  1. #coding:utf-8
  2. from cv2 import *
  3. import numpy
  5. import distutils
  7. def strokeEdges(src,dst,blurksize=7,edgeksize=5):
  8.     if blurksize>=3:
  9.         blurredsrc=medianBlur(src,blurksize)
  10.         graysrc=cvtColor(blurredsrc,COLOR_BGR2GRAY)
  11.     else:
  12.         graysrc=cvtColor(src,COLOR_BGR2GRAY)  #灰度图
  13.     Laplacian(graysrc,CV_8U,graysrc,ksize=edgeksize)
  14.     #归一化
  15.     normalizedInverseAlpha=(1.0/255)*(255-graysrc)
  16.     channels=split(src) #分离通道
  18.     for channel in channels:
  19.         channel[:]=channel*normalizedInverseAlpha
  20.     merge(channels,dst)
  21.     return dst
  23. img0=imread("D:/temp/1.jpg",1)
  24. dst=img0
  25. dst=filters.strokeEdges(img0,dst,blurksize=7,edgeksize=5)
  27. imshow('dst',dst) #合并通道
  29. 注意，核的大小可由strokeEdges()函数的参数来指定。blurKsize参数会 作为medianBlur()含糊的ksize参数，edgeKsize参数会作为Laplacian()函数的ksize参数。对于作者的摄像头，将blurKsize值设为7，将edgeKsize值设为5会得到最好的效果。但对于较大的ksize（比如7），使用medianBlur()的代价很高。如果在使用strokeEdges()函数时遇到性能问题，可试着减小blurKsize的值。要关闭模糊效果，可以将blurKsize的值设为3以下 。

Distutils包是标准Python库的一部分；主要特点有两个：
（1）是让用户觉得安装新模块、包和工具的过程是简单、一致又轻松的；
（2）是让开发者觉得创建这些新模块、包和工具的分发包是简单、一致又轻松的；

3、Canny边缘检测

Canny边缘检测算法有5个步骤：使用高斯滤波器对图像进行去噪、计算梯度、在边缘上使用非最大抑制(NMS)、在检测到的边缘上使用双阈值去除假阳性(false positive)，最后还会分析所有的边缘及其之间的连接，以保留真正的边缘并消除不明显的边缘。

参考：http://blog.csdn.net/m0\_37264397/article/details/70314025

  1. def Canny(image, threshold1, threshold2, edges=None, apertureSize=None, L2gradient=None): # real signature unknown; restored from __doc__ """ Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) -> edges """ pass
  3. from cv2 import *
  4. import numpy as np
  6. img=imread("D:/temp/1.jpg",0)
  7. imwrite('canny.jpg',Canny(img,200,300))
  8. imshow('canny',imread('canny.jpg'))
  9. waitKey()
  10. destroyAllWindows()

4、轮廓检测

在计算机视觉中，轮廓检测不仅用来检测图像或者视频帧中物体的轮廓，而且还有其他操作与轮廓检测有关。如：计算多边形边界、形状逼近和计算感兴趣区域。这是与图像数据交互时的简单操作，因为NumPy中的矩形区域可以使用数组切片(slice)来定义。在物体检测（包括人脸）和物体跟踪时会大量使用。 

  1. def threshold(src, thresh, maxval, type, dst=None): # real signature unknown; restored from __doc__ """ threshold(src, thresh, maxval, type[, dst]) -> retval, dst """ pass
  3. threshold()简单阈值
  4. 　　这个函数有四个参数，第一个原图像，第二个进行分类的阈值，第三个是高于（低于）阈值时赋予的新值，第四个是一个方法选择参数，常用的有： 
  5. 　　　　cv2.THRESH_BINARY（黑白二值） 
  6. 　　　　cv2.THRESH_BINARY_INV（黑白二值反转） 
  7. 　　　　cv2.THRESH_TRUNC （得到的图像为多像素值） 
  8. 　　　　cv2.THRESH_TOZERO 
  9. 　　　　cv2.THRESH_TOZERO_INV 
  10.    该函数有两个返回值，第一个retVal（得到的阈值（在后面一个方法中会用到）），第二个就是阈值化后的图像。
  15. def findContours(image, mode, method, contours=None, hierarchy=None, offset=None): # real signature unknown; restored from __doc__ """ findContours(image, mode, method[, contours[, hierarchy[, offset]]]) -> image, contours, hierarchy """ pass
  17. findContours()函数有三个参数：输入图像、层次类型和轮廓逼近方法。
  18. 　　这个函数会修改输入图像，因此建议使用原始图像的一份拷贝（如：通过img.copy()来作为输入图像）。
  19. 　　由函数返回的层次树相当重要：cv2.RETR_TREE参数会得到图像中轮廓的整体层次结构，以此来建立轮廓之间的“关系”。如果只想得到最外面的轮廓，可使用cv2.RETR_EXTERNAL。这对消除包含在其他轮廓中的轮廓很有用（如在大多数情形下，不需要检测一个目标包含在另一个与之相同的目标里面）
  20. 　　findContours()函数有三个返回值：修改后的图像、图像的轮廓以及它们的层次。使用轮廓来画出图像的彩色版本（即把轮廓画成绿色），并显示出来。
  25. 画出轮廓：
  27. def drawContours(image, contours, contourIdx, color, thickness=None, lineType=None, hierarchy=None, maxLevel=None, offset=None): # real signature unknown; restored from __doc__ """ drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> image """ pass
  32. from cv2 import *
  33. import  numpy as np
  35. img=np.zeros((200,200),dtype=np.uint8)# 创建一个200x200大小的黑色空白图像
  36. img[50:150,50:150]=255                # 在图像的中央放置一个白色方块
  38. ret,thresh=threshold(img,127,255,0) #对图像进行二值化操作
  39. image,contours,hieraracy=findContours(thresh,RETR_TREE,CHAIN_APPROX_SIMPLE)# 寻找轮廓
  40. color=cvtColor(img,COLOR_GRAY2BGR)# 颜色空间转换
  42. img=drawContours(color,contours,-1,(0,0,255),2)# 画出轮廓，-1,表示所有轮廓，画笔颜色为(0, 0, 255)，即Red，粗细为3
  43. imshow('contours',color)
  44. waitKey()
  45. destroyAllWindows()

5. 边界框、最小矩形区域和最小闭圆的轮廓

　　可用OpenCV的cv2.findContours函数找到不规则的、歪斜的以及旋转的形状。现实的应用会对目标的边界框、最小矩形面积、最小闭圆特别感兴趣。

  1. 高斯金字塔用来向下采样 def pyrDown(src, dst=None, dstsize=None, borderType=None): # real signature unknown; restored from __doc__ """ pyrDown(src[, dst[, dstsize[, borderType]]]) -> dst """ pass 从一个高分辨率图像变成低分辨率图 3个参数：
  4.     tmp: 当前图像，初始化为原图像 src 。
  5.     dst: 目的图像( 显示图像，为输入图像的一半)
  6.     Size( tmp.cols/2, tmp.rows/2 ) :目的图像大小， 既然我们是向下采样
  7.    def pyrUp(src, dst=None, dstsize=None, borderType=None): # real signature unknown; restored from __doc__ """ pyrUp(src[, dst[, dstsize[, borderType]]]) -> dst """ pass 
  8.  http://blog.csdn.net/m0_37264397/article/details/70303128
  10. def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): # real signature unknown; restored from __doc__ """ rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> img """ pass
  12. def boundingRect(points): # real signature unknown; restored from __doc__ """ boundingRect(points) -> retval """ pass
  17.    points：输入点集。
  18.    返回最小正矩形。
  20. 最小矩形区域
  22. def minAreaRect(points): # real signature unknown; restored from __doc__ """ minAreaRect(points) -> retval """ pass
  • points：输入点集。

  • 返回最小斜矩形。

    1. def boxPoints(box, points=None): # real signature unknown; restored from __doc__ """ boxPoints(box[, points]) -> points """ pass

    寻找盒子的顶点 

  1.     def minEnclosingCircle(points): # real signature unknown; restored from __doc__ """ minEnclosingCircle(points) -> center, radius """ pass
  3.  *  points：输入点集。
  4.  *  center：圆心。
  5.  *  radius：半径。
  6.  *  对给定的 2D 点集，寻找最小面积的包围圆形  
  9. 如下，在摄像（动态图像）中寻找轮廓（动态）。
  11.     from cv2 import *
  12.     import numpy as np
  14.     videocapture=VideoCapture(0)
  15.     success,franme=videocapture.read()
  16.     while success:
  17.         # image=pyrDown(franme)#下采样降维
  18.         image=pyrUp(franme)#上采样升维
  19.         ret,thresh=threshold(cvtColor(image.copy(),COLOR_BGR2GRAY),127,255,THRESH_BINARY)
  21.         #findContours()函数有三个返回值：修改后的图像、图像的轮廓以及它们的层次。
  22.         img,contiours,hier=findContours(thresh,RETR_EXTERNAL,CHAIN_APPROX_SIMPLE)
  24.         #遍历轮廓中的像素点
  25.         for c in contiours:
  26.             # 现计算出一个简单的边界框
  27.             x,y,w,h=boundingRect(c)
  29.             rectangle(image,(x,y),(x+w,y+h),(0,255,0),2)# 将轮廓信息转换成(x, y)坐标，并加上矩形的高度和宽度
  31.             rect=minAreaRect(c) # 画出矩形
  33.             box=boxPoints(rect)# 计算包围目标的最小矩形区域
  35.             # 注：OpenCV没有函数能直接从轮廓信息中计算出最小矩形顶点的坐标。所以需要计算出最小矩形区域，
  36.             # 然后计算这个矩形的顶点。由于计算出来的顶点坐标是浮点型，但是所得像素的坐标值是整数（不能获取像素的一部分）
  37.             box=np.int0(box)
  39.             # 所以需要做一个转换
  40.             drawContours(image,[box],0,(0,0,255),3)# 画出该矩形
  42.             #圈出目标
  43.             (x,y),radius=minEnclosingCircle(c)
  45.             center=(int(x),int(y)) # 会返回一个二元组，第一个元素为圆心的坐标组成的元组，第二个元素为圆的半径值。
  47.             radius=int(radius)
  49.             image=circle(image,center,radius,(0,0,255),2)
  51.         drawContours(image, contiours, -1, (255, 0, 0), 1)
  53.         imshow('contious', image)
  54.         waitKey(10)
  55.         success, franme = videocapture.read()
  58. **6、凸轮廓与Douglas-Peucker算法**
  60. 　　大多数处理轮廓的时候，物体的形状（包括凸形状）都是变化多样的。凸形状内部的任意两点之间的连线都在该形状里面。
  62. 　　cv2.approxPloyDP是一个OpenCV函数，它用来计算近似的多边形框。该函数有三个参数：
  64. 　　第一个参数为“轮廓”；
  66. 　　第二个参数为“ε值”，它表示源轮廓与近似多边形的最大差值（这个值越小，近似多边形与源轮廓越接近）；
  68. 　　第三个参数为“布尔标记”，它表示这个多边形是否闭合。
  70. 　　ε值对获取有用的轮廓非常重要。是为所得到的近似多边形周长与源轮廓周长之间的最大差值，这个差值越小，近似多边形与源轮廓就越相似。
  72. 　　可通过OpenCV的cv2.arcLength函数来得到轮廓的周长信息。
  77. ### ArcLength ###
  79. 计算轮廓周长或曲线长度
  81.     double cvArcLength( const void* curve, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1 );
  85. curve
  87. 曲线点集序列或数组
  89. slice
  91. 曲线的起始点，缺省是计算整个曲线的长度
  93. is\_closed
  95. 表示曲线是否闭合，有三种情况：
  97.  *  is\_closed=0 - 假设曲线不闭合
  98.  *  is\_closed>0 - 假设曲线闭合
  99.  *  is\_closed<0 - 若曲线是序列，检查 ((CvSeq\*)curve)->flags 中的标识 CV\_SEQ\_FLAG\_CLOSED 来确定曲线是否闭合。否则 (曲线由点集的数组 (CvMat\*) 表示) 假设曲线不闭合。
  101. 函数 cvArcLength通过依次计算序列点之间的线段长度，并求和来得到曲线的长度。
  103.     def approxPolyDP(curve, epsilon, closed, approxCurve=None): # real signature unknown; restored from __doc__ """ approxPolyDP(curve, epsilon, closed[, approxCurve]) -> approxCurve """ pass
  105.     http://blog.csdn.net/qq_18343569/article/details/47999257
  107.     opencv提供了convexHull()函数来查找图像中物体的凸包，起函数定义如下： void cv::convexHull (   InputArray  points,
  108.                             OutputArray     hull,
  109.                             bool    clockwise = false,
  110.                             bool    returnPoints = true 
  111.     )
  114.            1
  115.            2
  116.            3
  117.            4
  118.            5
  119.           def convexHull(points, hull=None, clockwise=None, returnPoints=None): # real signature unknown; restored from __doc__ """ convexHull(points[, hull[, clockwise[, returnPoints]]]) -> hull """ pass 参数解释 
  120.     points:输入的二维点集，Mat类型数据即可 
  121.     hull:输出参数，用于输出函数调用后找到的凸包 
  122.     clockwise:操作方向，当标识符为真时，输出凸包为顺时针方向，否则为逆时针方向。 
  123.     returnPoints:操作标识符，默认值为true，此时返回各凸包的各个点，否则返回凸包各点的指数，当输出数组时std::vector时，此标识被忽略。
  125. C++ code:http://blog.csdn.net/keith\_bb/article/details/70194073
  127.     from cv2 import *
  128.     import numpy as np
  130.     videocapture=VideoCapture(0)
  131.     success,franme=videocapture.read()
  132.     while success:
  133.         # image=pyrDown(franme)#下采样降维
  134.         # image=pyrUp(franme)#上采样升维
  135.         image=franme
  136.         #对图像进行二值化
  137.         ret,thresh=threshold(cvtColor(image.copy(),COLOR_BGR2GRAY),100,255,THRESH_BINARY)
  139.         #findContours()函数有三个返回值：修改后的图像、图像的轮廓以及它们的层次。
  140.         img,contiours,hier=findContours(thresh,RETR_EXTERNAL,CHAIN_APPROX_NONE)
  142.         #遍历轮廓中的像素点
  143.         for c in contiours:
  144.             epsilon=0.01*arcLength(c,True)
  146.             approx=approxPolyDP(c,epsilon,True)
  148.             #寻找凸包
  149.             hull=convexHull(c)
  150.             drawContours(image,approx, -1, (0,0,255), 3)
  151.             drawContours(image, hull, -1, (0, 0, 255), 3)
  153.         imshow('contious', image)
  154.         waitKey(10)
  155.         success, franme = videocapture.read()
  157.     destroyAllWindows()
  162. **7、 直线和圆检测**
  164. 　　Hough变换是直线和形状检测背后的理论基础。
  166. **绘制直线　**　
  168. 　　函数为：cv2.line（img,Point pt1,Point pt2,color,thickness=1,line\_type=8 shift=0） 
  170. 　　有值的代表有默认值，不用给也行。可以看到这个函数主要接受参数为两个点的坐标，线的颜色（彩色图像的话颜色就是一个1\*3的数组）
  172.     直线检测 　　　　直线检测可通过HoughLines和HoughLinesP函数来完成，它们仅有的差别是：第一个函数使用标准的Hough变换，第二个函数使用概率Hough变换。 HoughLinesP函数之所以成为概率版本的Hough变换是因为它只通过分析点的子集并估计这些点都属于一条直线的概率，这是标准Hough变换的优化版本，该函数的计算代价会少一些，执行会变得更快。
  174.     def HoughLinesP(image, rho, theta, threshold, lines=None, minLineLength=None, maxLineGap=None): # real signature unknown; restored from __doc__ """ HoughLinesP(image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]) -> lines """ pass
  176. 第一个参数：输入灰度图像
  178. 第二个参数：输出检测的线条  
  181. 第三个参数：极径  
  184. 第四个参数：极角
  186. 第五个参数：累加平面阈值  
  189. 第六个参数：最低线段长度  
  192. 第七个参数：点点之间的最大距离
  197. 参考：http://blog.csdn.net/m0\_37264397/article/details/72729423
  199.     def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None): # real signature unknown; restored from __doc__ """ line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> img """ pass
  201.     Demo：
  203.     from cv2 import *
  204.     import numpy as np
  206.     image=imread("D:/temp/1.jpg")
  207.     gray=cvtColor(image,COLOR_BGR2GRAY)
  208.     edge=Canny(gray,50,120)
  209.     minLineLength=20
  210.     maxLineGap=5
  211.     lines=HoughLinesP(edge,1,np.pi/180,100,minLineLength,maxLineGap)
  212.     for x1,y1,x2,y2 in lines[0]:
  213.         line(image,(x1,y1),(x2,y2),(0,255,0),2)
  215.     imshow('edge',edge)
  216.     imshow('line',image)
  217.     waitKey()
  218.     destroyAllWindows()
  220. HoughLines函数会接收一个由Canny边缘检测滤波器处理过的单通道二值图像，不一定需要Canny滤波器，但是一个经过去噪并只有边缘的图像当作Hough变换的输入会很不错。
  222. HoughLinesP的参数：
  224. 　　　　需要处理的参数；
  226. 　　　　线段的几何表示rho和theta，一般分别取1和np.pi/180；
  228. 　　　　阈值，低于该阈值的直线会被忽略，Hough变换可以理解为投票箱和投票数之间的关系，每一个投票箱代表一个直线，投票数达到阈值的直线会被保留，其他的会被删除。
  230. 　　　　minLineLength和maxLineGap　
  232. 问题：
  234.     https://stackoverflow.com/questions/16144015/python-typeerror-nonetype-object-has-no-attribute-getitem#comment23064755_16144015
  236.     from cv2 import *
  237.     import numpy as np
  239.     videocapture=VideoCapture(0)
  241.     ret,image=videocapture.read()
  242.     while ret:
  243.         img=image
  244.         gray=cvtColor(image,COLOR_BGR2GRAY)
  246.         edge=Canny(gray,50,120)
  247.         minLineLength=20
  248.         maxLineGap=5
  249.         lines = (edge, 1, np.pi/180, 20, np.array([]), 10)[0]
  251.         for l in lines:
  252.             line(image, (l[0],l[1]), (l[2],l[3]), (0, 255, 0), 2)
  253.         imshow('line', image)
  254.         imshow('edge',edge)
  255.         imshow('image',img)
  256.         waitKey(10)
  257.         ret, image = videocapture.read()
  258.     destroyAllWindows()
  260. ** **
  262. **圆检测**
  264. 　　　　OpenCV的HoughCircles函数可用来检测圆，它与使用HoughLines函数类似。像用来决定删除或保留直线的两个参数minLineLength和maxLineGap一样，HoughCircles有一个圆心间的最小距离和圆的最小及最大半径。
  266.     def medianBlur(src, ksize, dst=None): # real signature unknown; restored from __doc__ """ medianBlur(src, ksize[, dst]) -> dst """ pass
  268.     def HoughCircles(image, method, dp, minDist, circles=None, param1=None, param2=None, minRadius=None, maxRadius=None): # real signature unknown; restored from __doc__ """ HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) -> circles """ pass
  270.    http://blog.csdn.net/m0\_37264397/article/details/72729423  
  273. Demo1：
  275.     from cv2 import *
  276.     import numpy as np
  278.     image=imread("D:/temp/a2.jpg")
  279.     gray=cvtColor(image,COLOR_BGR2GRAY)
  280.     img=medianBlur(gray,5)
  281.     # cimg=cvtColor(img,COLOR_BGR2GRAY)
  282.     circles=HoughCircles(img,HOUGH_GRADIENT,1,120,param1=100,param2=30,minRadius=0,maxRadius=0)
  283.     circles=np.uint16(np.around(circles))
  284.     for i in circles[0,:]:
  285.         circle(image,(i[0],i[1]),i[2],(0,255,0),2)
  286.         circle(image,(i[0],i[1]),2,(0,0,255),3)
  288.     imshow('image',image)
  290.     waitKey()
  291.     destroyAllWindows()
  296. Demo2：  
  299.     from cv2 import *
  300.     import numpy as np
  302.     videocapture=VideoCapture(0)
  303.     ret,image=videocapture.read()
  305.     while ret:
  306.         gray=cvtColor(image,COLOR_BGR2GRAY)
  307.         img=medianBlur(gray,5)
  308.         cimg=cvtColor(img,COLOR_GRAY2BGR)
  309.         circles = HoughCircles(img, HOUGH_GRADIENT, 1, 120, param1=100, param2 = 30, minRadius = 0,  maxRadius = 0)
  310.         circles = np.uint16(np.around(circles))
  312.         for i in circles[0, :]:
  313.             circle(image, (i[0], i[1]), i[2], (0, 255, 0), 2)
  314.             circle(image, (i[0], i[1]), 2, (0, 0, 255), 3)
  318.         imshow('image',image)
  319.         waitKey(10)
  320.         ret, image = videocapture.read()
  321.     destroyAllWindows()
  324. 运行出现：AttributeError: 'NoneType' object has no attribute 'rint'，暂未解决。

发表评论

表情：
评论列表 （有 0 条评论，419人围观）

还没有评论，来说两句吧...

相关阅读

    相关 计算机视觉（三）

    1、滤波器 傅里叶变换主要作用反应图像各区域像素变化的幅度。 滤波器（核）矩阵：一组权重集合（内部所有值加和为0），作用在源图像的一个区域（滑动），并由此生成目标图像的一个

    左手的ㄟ右手左手的ㄟ右手/ 0 赞/ 419 阅读

    相关 计算机视觉（二）

    1、捕获摄像头的帧 　　VideoCapture类可以获得摄像头的帧流。但对摄像头而言，通常不是用视频的文件名来构造VideoCapture类，而是需要传递摄像头的设备索引(

    快来打我*快来打我*/ 0 赞/ 376 阅读

    相关 计算机视觉三大顶级国际会议

    与所有其它学术领域都不同，计算机科学使用会议而不是期刊作为发表研究成果的主要方式。目前国外计算机界评价学术水平主要看在顶级学术会议上发表的论文。特别是在机器学习、计算机视觉和人

    心已赠人心已赠人/ 0 赞/ 531 阅读