opencv3图像处理_vs2015 opencv 加载图像 处理图像 - CSDN
  • openCV3图像处理

    2019-03-06 10:37:51
    图像读取方式: 1、cv2.imread() 2、cv2.pyrUp(cv2.imread(‘0221.png’, cv2.IMREAD_UNCHANGED)) cv2.pyrDown:对图像进行高斯平滑,然后再降采样(将图像尺寸行和列方向缩减一半), 若不指定第三个参数,则默认...

    处理前图片预设
    图像读取方式:
    1、cv2.imread()
    2、cv2.pyrUp(cv2.imread(‘0221.png’, cv2.IMREAD_UNCHANGED))

    cv2.pyrDown:对图像进行高斯平滑,然后再降采样(将图像尺寸行和列方向缩减一半),
    若不指定第三个参数,则默认按照 Size((src.cols+1)/2, (src.rows+1)/2)计算
    
    cv2.pyrUp:对图像进行升采样(将图像尺寸行和列方向增大一倍),然后再进行高斯平滑,
    若不指定第三个参数,则默认按照  Size(src.cols*2, (src.rows*2)计算
    

    **傅里叶变换:**把最明亮的像素放在图像中央,然后逐渐变暗,在边缘上的像素最暗。从而发现图像中有多少个亮像素和暗像素,以及它们分布的百分比。
    高通滤波器(HPF):检测图像的某个区域,然后根据像素与周围像素的亮度差值来提升该像素的亮度。

    **边缘检测滤波函数:**Laplacian()/Spbel()/Scharr()/Canny()
    原理:将非边缘区域转换为黑色,将边缘区域转换为白色或其他饱和颜色
    最常用:cv2.Canny(img, 200, 300)

    模糊滤波函数:
    blur()/medianBlur()/GaussianBlur()
    原理:找到边缘之前的图像进行像素平均(模糊处理)
    边缘滤波处理后的毛发

    sobel算子梯度检测:
    用Sobel算子计算x,y方向上的梯度,之后在x方向上减去y方向上的梯度,通过这个减法,我们留下具有高水平梯度和低垂直梯度的图像区域。
    gradX = cv2.Sobel(gray, cv2.CV_32F, dx=1, dy=0, ksize=-1)
    gradY = cv2.Sobel(gray, cv2.CV_32F, dx=0, dy=1, ksize=-1)
    # subtract the y-gradient from the x-gradient
    gradient = cv2.subtract(gradX, gradY)
    gradient = cv2.convertScaleAbs(gradient)
    sobel算子梯度检测后的毛发
    一组简单的绘制图像轮廓方法:

    def draw_contours():
        img = cv2.pyrUp(cv2.imread('0221.png', cv2.IMREAD_UNCHANGED))
        # 转换成灰度图后进行二值化处理
        ret, thresh = cv2.threshold(cv2.cvtColor(img.copy(), cv2.COLOR_BGR2GRAY), 127, 255, cv2.THRESH_BINARY)
        image, contours, hier = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)    # 查找轮廓
        '''
        RETR_LIST 从解释的角度来看,这中应是最简单的。它只是提取所有的轮廓,而不去创建任何父子关系。 
        RETR_EXTERNAL 如果你选择这种模式的话,只会返回最外边的的轮廓,所有的子轮廓都会被忽略掉。 
        RETR_CCOMP 在这种模式下会返回所有的轮廓并将轮廓分为两级组织结构。 
        RETR_TREE 这种模式下会返回所有轮廓,并且创建一个完整的组织结构列表。
        cv2.CHAIN_APPROX_NONE 表示边界所有点都会被储存
        cv2.CHAIN_APPROX_SIMPLE 会压缩轮廓,将轮廓上冗余点去掉
        '''
        for c in contours:
            x, y, w, h = cv2.boundingRect(c)    # 计算边界框
            cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)  # 画矩形
            # 转换最小轮廓的坐标后再绘图
        rect = cv2.minAreaRect(c)
        box = cv2.boxPoints(rect)
        box = numpy.int0(box)
        cv2.drawContours(img, [box], 0, (0, 0, 255), 3)
    
    (x, y), radius = cv2.minEnclosingCircle(c)
    '''minEnclosingCircle返回值为:(圆心坐标, 圆半径)'''
    center = (int(x), int(y))
    radius = int(radius)
        img = cv2.circle(img, center, radius, (0, 255, 0), 1)   # 画圆
    
    cv2.drawContours(img, contours, -1, (255, 0, 0), 1)  # 绘制轮廓
    cv2.imshow('countours', img)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    结果:
    图片轮廓绘制

    注意:

    # 转换最小轮廓的坐标后再绘图
    rect = cv2.minAreaRect(c)
    box = cv2.boxPoints(rect)
    box = numpy.int0(box)
    cv2.drawContours(img, [box], 0, (0, 0, 255), 3)
    

    在这里插入图片描述
    凸轮廓与Douglas-Peucker算法????
    经典的Douglas-Peucker算法步骤如下:
    (1)在曲线首尾两点A,B之间连接一条直线AB,该直线为曲线的弦;
    (2)得到曲线上离该直线段距离最大的点C,计算其与AB的距离d;
    (3)比较该距离与预先给定的阈值threshold的大小,如果小于threshold,则该直线段作为曲线的近似,该段曲线处理完毕。
    (4)如果距离大于阈值,则用C将曲线分为两段AC和BC,并分别对两段取信进行1~3的处理。
    (5)当所有曲线都处理完毕时,依次连接各个分割点形成的折线,即可以作为曲线的近似。

    直线检测:

    def hough_lines():
        img = cv2.imread('F:\GIT\AITEST\BASICS\gray_29.jpg')
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 50, 120)
        minLineLength = 20
        maxLineGap = 5
        lines = cv2.HoughLinesP(edges, 1, numpy.pi/180, 100, minLineLength, maxLineGap)
        '''
        HoughLines与HoughLinesP区别:
        HoughLines使用标准的Hough变换
        HoughLinesP使用概率Hough变换,HoughLines的优化版,执行速度更快
        参数:
        一、表示需要处理的对象
        二、线段的几何表示th0/theta,一般分别取1和np.pi/180
        三、阈值,低于该阈值的线会被忽略
        四、最小直线长(更短的直线会被消除)和最大线段间隙(一条线段的间隙长度大于这个值会被视为俩条分开的线段)
        '''
        for x1, y1, x2, y2 in lines[0]:
            cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.imshow('edges', edges)
        cv2.imshow('lines', img)
        cv2.waitKey()
        cv2.destroyAllWindows()
    

    圆检测

    def hough_circles():
        planets = cv2.imread('F:\GIT\AITEST\BASICS\hough_circle.png')
        gray_img = cv2.cvtColor(planets, cv2.COLOR_BGR2GRAY)
        img = cv2.medianBlur(gray_img, 5)
        # img2 = cv2.Canny(img.copy(), 50, 120)
        circles = cv2.HoughCircles(img, cv2.HOUGH_GRADIENT, 1, 300, param1=100, param2=30, minRadius=0, maxRadius=0)
        '''
        HoughCircles()参数:
        image:8位单通道图像(灰度图)
        method:检测方法
        dp:累加器分辨率与图像分辨率的反比,dp值越大,累加器数组越小
        minDist:检测到的圆中心之间的最小距离
        param1:用于处理边缘检测的梯度值方法
        param2:cv2.HOUGH_GRADIENT方法的累加器阈值。阈值越小,检测到的圈子越多
        minRadius:半径的最小大小(以像素为单位)
        maxRadius:半径的最大大小(以像素为单位)
        '''
        circles = numpy.uint16(numpy.around(circles))
    
        for i in circles[0,:]:
            cv2.circle(planets, (i[0], i[1]), i[2], (0, 255, 0), 2)
            cv2.circle(planets, (i[0], i[1]), 2, (0, 0, 255), 3)
        cv2.imwrite('planets_circles.jpg', planets)
        cv2.imshow('houghcircles', planets)
        cv2.waitKey()
        cv2.destroyAllWindows()
    

    多边形检测:
    approxPloyDP函数结合cv2.findContours函数???

    高级形态学变换:
    开运算:
    先腐蚀,再膨胀,可清除一些小东西(亮的),放大局部低亮度的区域
    闭运算:
    先膨胀,再腐蚀,可清除小黑点
    形态学梯度:
    膨胀图与腐蚀图之差,提取物体边缘
    顶帽:
    原图像-开运算图,突出原图像中比周围亮的区域
    黑帽:
    闭运算图-原图像,突出原图像中比周围暗的区域

    视觉检测:
    StereoSGBM算法
    GrabCut算法
    步骤:
    1、在图片中定义一个或多个物体的矩形
    2、矩形外的区域自动认为是背景
    3、对矩形区域,用背景中的数据来区别它里面的前景和背景区域
    4、用高斯混合模型来对背景和前景建模,并将未定义的像素标记为可能的前景或背景
    5、图像中的每个像素都被看做通过虚拟边与周围像素相连接,而每条边都有一个属于前景或背景的概率,者给予它与周围像素颜色上的相似性

    在这里插入图片描述
    6、节点完成连接后,若节点之间的边属于不同终端,则会切断它们之间的边
    在这里插入图片描述

    展开全文
  • 1.有一个小游戏,就给出两张内容几乎差不多全部相同的图像,让大家在最快的时间内找出两个图像中有几处不同地方,我这里试着用OpenCV实现这个功能。 2.我的编程环境是Windows 7 64位,IDE是VS2015,配置了OpenCV3.3...

    前言

    1.有一个小游戏,就给出两张内容几乎差不多全部相同的图像,让大家在最快的时间内找出两个图像中有几处不同地方,我这里试着用OpenCV实现这个功能。
    2.我的编程环境是Windows 7 64位,IDE是VS2015,配置了OpenCV3.3与OpenCV_Contrib,实现语言是C++。是于如果配置以上的环境,可以看我之前写的博文。

    一、资源准备

    可以在网上搜《图片大找茬》,然后下载两张相似的图像,但图像的大小必须一样。下面是我指用的两张图像。如果不一样,就用resize()这个函数去调整两张图像的尺寸。

    在这里插入图片描述
    在这里插入图片描述

    二、代码演示

    1.这里用到的是OpenCV图像基本运算,两图相减。使用的API是subtract()。
    代码是传入两张图像

    void imageSubtract(Mat &image1, Mat &image2)
    {
    	if ((image1.rows != image2.rows) || (image1.cols != image2.cols))
    	{
    		if (image1.rows > image2.rows)
    		{
    			resize(image1, image1, image2.size(), 0, 0, INTER_LINEAR);
    		}
    		else if (image1.rows < image2.rows)
    		{
    			resize(image2, image2, image1.size(), 0, 0, INTER_LINEAR);
    		}
    	}
    
    	Mat image1_gary, image2_gary;
    	if (image1.channels() != 1)
    	{
    		cvtColor(image1, image1_gary, COLOR_BGR2GRAY);
    	}
    	if (image2.channels() != 1)
    	{
    		cvtColor(image2, image2_gary, COLOR_BGR2GRAY);
    	}
    
    	Mat frameDifference, absFrameDifferece;
    	Mat previousGrayFrame = image2_gary.clone();
    	//图1减图2
    	subtract(image1_gary, image2_gary, frameDifference, Mat(), CV_16SC1);
    
    	//取绝对值
    	absFrameDifferece = abs(frameDifference);
    
    	//位深的改变
    	absFrameDifferece.convertTo(absFrameDifferece, CV_8UC1, 1, 0);
    	imshow("absFrameDifferece", absFrameDifferece);
    	Mat segmentation;
    	
    	//阈值处理(这一步很关键,要调好二值化的值)
    	threshold(absFrameDifferece, segmentation,100, 255, THRESH_BINARY);
    
    	//中值滤波
    	medianBlur(segmentation, segmentation, 3);
    
    	//形态学处理(开闭运算)
    	//形态学处理用到的算子
    	Mat morphologyKernel = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));
    	morphologyEx(segmentation, segmentation, MORPH_CLOSE, morphologyKernel, Point(-1, -1), 2, BORDER_REPLICATE);
    
    	//显示二值化图片
    	imshow("segmentation", segmentation);
    
    	//找边界
    	vector< vector<Point> > contours;
    	vector<Vec4i> hierarchy;
    	findContours(segmentation, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));//CV_RETR_TREE
    	vector< vector<Point> > contours_poly(contours.size());
    
    	vector<Rect> boundRect;
    	boundRect.clear();
    
    	for (int index = 0; index < contours.size(); index++)
    	{
    		approxPolyDP(Mat(contours[index]), contours_poly[index], 3, true);
    		Rect rect = boundingRect(Mat(contours_poly[index]));
    		rectangle(image2, rect, Scalar(0, 255, 0), 2);
    	}
    	imshow("效果图", image2);
    }
    

    2.运行效果
    在这里插入图片描述

    结语

    1.例子很简单,但是这个方法用到移动目标追踪的上去,就是两帧差。
    2.关于工程的源码,运行程序时的bug,都可以加这个群(487350510)互相讨论学习。

    展开全文
  • 先在此处先声明,后面学习python+opencv图像处理时均参考这位博主的博文https://blog.csdn.net/u011321546/article/category/7495016/2?,我只是复现和稍微修改一下代码,加深自己印象的同时也督促自己好好学习图像...

      先在此处先声明,后面学习python+opencv图像处理时均参考这位博主的博文https://blog.csdn.net/u011321546/article/category/7495016/2?,我只是复现和稍微修改一下代码,加深自己印象的同时也督促自己好好学习图像处理,在这里再一次感谢这位博主的博文。

     

      配置好所有环境后,开始利用python3+opencv3进行图像处理第一步。

      读取和显示一张图片:

    复制代码

    import cv2 as cv
    src=cv.imread('E:\imageload\example.png')       
    cv.namedWindow('input_image', cv.WINDOW_AUTOSIZE)
    cv.imshow('input_image', src)
    cv.waitKey(0)
    cv.destroyAllWindows()

    复制代码

      输出效果:

      

      代码解释:

      src=cv.imread('E:\imageload\example.png')   

      #读取这个路径的图片     注意这里的路径必须全是英文,不能有中文       但是分隔符\是随意的,还可以是 /   \\    // 形式的 (在python3至少是这样)

     

      cv.namedWindow('input_image', cv.WINDOW_AUTOSIZE) 

       #namedWindow函数,用于创建一个窗口        默认值为WINDOW_AUTOSIZE,所以一般情况下,这个函数我们填第一个变量就可以了。其实这一行代码没有也可以正常显示的(下面imshow会显示)

     

      cv.imshow('input_image', src) 

      #在指定的窗口中显示一幅图像

                

      cv.waitKey(0)           

      #   参数=0: (也可以是小于0的数值)一直显示,不会有返回值      若在键盘上按下一个键即会消失 ,则会返回一个按键对应的ascii码值       

        参数>0:显示多少毫秒        超过这个指定时间则返回-1

     

      cv.destroyAllWindows() 

       #删除建立的全部窗口,释放资源

     

      注意:若同时使用namedWindow和imshow函数,则两个函数的第一个参数名字必须相同

       重要一点:在pycahrm里一定要把Project Encoding设置为utf-8,否则在新建的py文件里注释中文字符时,Pycharm运行会报错

      

      

      当然如果已经新建了py文件,要避免报错的话,应该在代码第一行注释:#encoding=gbk

      

    展开全文
  • 学习opencv3

    2020-07-30 23:33:28
    这个是学习opencv3的英文版本,带有目录的,如果想要使用opencv来做图像处理,机器视觉入门的话还是不错的材料,只不过是英文版本的
  • OpenCV3进行图像处理

    2020-03-29 15:44:04
    高通滤波器(HPF)是检测图像的某个区域,跟后根据像素和周围像素的亮度差值来提升(boost)该像素的滤波器。 遇到的问题:第一次运行该程序时还出现了 ImportError: DLL load failed: 找不到指定的模块。 问题原因...

    1. 高通滤波器

    高通滤波器(HPF)是检测图像的某个区域,跟后根据像素和周围像素的亮度差值来提升(boost)该像素的滤波器。
    遇到的问题:第一次运行该程序时还出现了 ImportError: DLL load failed: 找不到指定的模块。
    问题原因是numpy没找到支持blas的库。

    解决办法:

    https://www.lfd.uci.edu/~gohlke/pythonlibs/

    下载与自己python版本对应的 numpy+mkl

    pip install 此安装文件

    import cv2
    import numpy as np
    from scipy import ndimage
    
    kernel_3x3 = np.array([[-1, -1, -1],
                       [-1,  8, -1],
                       [-1, -1, -1]])
    
    kernel_5x5 = np.array([[-1, -1, -1, -1, -1],
                           [-1,  1,  2,  1, -1],
                           [-1,  2,  4,  2, -1],
                           [-1,  1,  2,  1, -1],
                           [-1, -1, -1, -1, -1]])
    
    img = cv2.imread("D:\Algorithm\Learning_OpenCV_3_Computer_Vision_with_Python_Second_Edition_Code\Learning_OpenCV_3_Computer_Vision_with_Python_Second_Edition_Code\Chapter 3_Code\gg.jpeg", 0)
    #用特定的核对图像进行 卷积(convolve)
    k3 = ndimage.convolve(img, kernel_3x3)
    k5 = ndimage.convolve(img, kernel_5x5)
    
    blurred = cv2.GaussianBlur(img, (17,17), 0)
    g_hpf = img - blurred
    
    cv2.imshow("3x3", k3)
    cv2.imshow("5x5", k5)
    cv2.imshow("g_hpf", g_hpf)
    cv2.waitKey()
    cv2.destroyAllWindows()
    
    

    在这里插入图片描述在这里插入图片描述在这里插入图片描述
    Kernel:核是一组权重的集合,应用在源图像的一个区域,并由此生成目标图像的一个像素。
    这些滤波器中的值加起来位1,则不改变图像的亮度:若滤波器中的值加起来为0,则会的到一个边缘检测核,把边缘转为白色, 把非边缘区域转为黑色。

    2. Canny算法边缘检测

    Canny边缘检测算法分为五个步骤:使用高斯滤波器降噪、计算梯度、在边缘上使用非最大抑制(NMS)、在检测到的边缘上使用双(double)阈值去除假阳性(false positive)、分析所有边缘及其它们之间的连接以保留真正的边缘并消除不明显的边缘。

    import cv2
    import numpy as np
    
    img = cv2.imread("D:\Algorithm\Learning_OpenCV_3_Computer_Vision_with_Python_Second_Edition_Code\Learning_OpenCV_3_Computer_Vision_with_Python_Second_Edition_Code\Chapter 3_Code\gg.jpeg")
    cv2.imwrite("canny.jpg", cv2.Canny(img, 100, 300))
    cv2.imshow("canny", cv2.imread("canny.jpg"))
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    效果如图:在这里插入图片描述Canny边缘检测算法的两个阈值的动态调整可参考Canny Edge Detection Auto Thresholding
    canny函数

    (1)若某一像素位置的幅值超过高阈值,该像素被保留为边缘像素。
    (2)若某一像素位置的幅值小于低阈值,该像素被排除。
    (3)若某一像素位置的幅值在两个阈值之间,该像素仅仅在连接到一个高于高阈值的像素时被保留。
    cv2.Canny(inputArray,outputArray,double threshold1,double threshold2,int apertureSize=3,bool L2gradient=false)
    第一个参数,输入图像,且需为单通道8位图像。
    第二个参数,输出的边缘图。
    第三个参数,第一个滞后性阈值。用于边缘连接。
    第四个参数,第二个滞后性阈值。用于控制强边缘的初始段,高低阈值比在2:1到3:1之间。
    第五个参数,表明应用sobel算子的孔径大小,默认值为3。
    第六个参数,bool类型L2gradient,一个计算图像梯度幅值的标识,默认值false。**

    3.直线检测(HoughLines函数和HoughLinesP函数)

    HoughLines函数成为标准的霍夫变换,HoughLinesP函数则是概率版本的霍夫变换(只分析点的子集并估计这些点都属于一条直线的概率,比标准霍夫变换执行的更快)。

    #coding:utf-8
    import cv2
    import numpy as np
    
    img = cv2.imread("D:\Algorithm\Learning_OpenCV_3_Computer_Vision_with_Python_Second_Edition_Code\Learning_OpenCV_3_Computer_Vision_with_Python_Second_Edition_Code\Chapter 3_Code\gg.jpeg")
    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray,50,120)
    minLineLength = 20
    maxLineGap = 5
    lines = cv2.HoughLinesP(edges,1,np.pi/180,20,minLineLength,maxLineGap)
    #以下部分为HoughLinesP函数的参数说明:
    ##需要处理的图像。
    ##线段的几何表示rho和theta,一般分别取1和np.pi/180。
    ##阈值。一般小于该值则会被忽略。
    ##最小直线长度和最大线段间距。
    for x1,y1,x2,y2 in lines[0]:
      cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)
    
    cv2.imshow("edges", edges)
    cv2.imshow("lines", img)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    效果如图:
    在这里插入图片描述在这段代码当中,HoughLines函数的调用、最小直线长度选择和最大线段间隙的设置都非常重要。HoughLines函数会接收一个又Canny边缘检测滤波器处理过的单通道二值图像。不一定使用Canny滤波器,但是一个经过降噪且只有边缘的图像当作Hough变换的输入会更好。一般采用Canny滤波器。

    4.圆检测

    OpenCV的HoughCircles函数用来检测圆,跟直线检测方法类似。与minLineLength和maxLineGap这两个参数类似,HoughCircles有一个圆心间的最小距离和圆的最小及最大半径。

    #coding:utf-8
    import cv2
    import numpy as np
    
    planets = cv2.imread('D:\Algorithm\planet.jpg')
    gray_img = cv2.cvtColor(planets, cv2.COLOR_BGR2GRAY)
    img = cv2.medianBlur(gray_img, 5)
    cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)
    
    circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,1,120,
                                param1=100,param2=30,minRadius=0,maxRadius=0)
    
    circles = np.uint16(np.around(circles))
    
    for i in circles[0,:]:
        # 画圆
        cv2.circle(planets,(i[0],i[1]),i[2],(0,255,0),2)
        # 画圆心
        cv2.circle(planets,(i[0],i[1]),2,(0,0,255),3)
    
    cv2.imwrite("planets_circles.jpg", planets)
    cv2.imshow("HoughCirlces", planets)
    cv2.waitKey()
    cv2.destroyAllWindows()
    
    

    运行后如图
    在这里插入图片描述
    注意:

    1.OpenCV的霍夫圆变换函数原型为:HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) -> circles

    image参数表示8位单通道灰度输入图像矩阵。

    method参数表示圆检测方法,目前唯一实现的方法是HOUGH_GRADIENT。

    dp参数表示累加器与原始图像相比的分辨率的反比参数。例如,如果dp = 1,则累加器具有与输入图像相同的分辨率。如果dp=2,累加器分辨率是元素图像的一半,宽度和高度也缩减为原来的一半。

    minDist参数表示检测到的两个圆心之间的最小距离。如果参数太小,除了真实的一个圆圈之外,可能错误地检测到多个相邻的圆圈。如果太大,可能会遗漏一些圆圈。

    circles参数表示检测到的圆的输出向量,向量内第一个元素是圆的横坐标,第二个是纵坐标,第三个是半径大小

    param1参数表示Canny边缘检测的高阈值,低阈值会被自动置为高阈值的一半。

    param2参数表示圆心检测的累加阈值,参数值越小,可以检测越多的假圆圈,但返回的是与较大累加器值对应的圆圈。

    minRadius参数表示检测到的圆的最小半径。

    maxRadius参数表示检测到的圆的最大半径。

    2.OpenCV画圆的circle函数原型:circle(img, center, radius, color[, thickness[, lineType[, shift]]]) -> img

    img参数表示源图像。

    center参数表示圆心坐标。

    radius参数表示圆的半径。

    color参数表示设定圆的颜色。

    thickness参数:如果是正数,表示圆轮廓的粗细程度。如果是负数,表示要绘制实心圆。

    lineType参数表示圆线条的类型。

    shift参数表示圆心坐标和半径值中的小数位数。

    5. 轮廓检测

    通过轮廓检测可以计算多边形边界、形状逼近和计算感兴趣区域,在Numpy中矩形区域可以通过数组切片来定义。
    首先介绍用Numpy创建纯白色背景的过程:

    #coding:utf-8
    import cv2 as cv
    import numpy as np
     #因为zero函数创建的数组是一个全0数组,是一个全黑的背景,要是每个像素都是255那就是白色背景啦
     
    def create_image():
        img = np.zeros([400, 400, 3], np.uint8)
        img[:, :, 0] = np.zeros([400, 400]) + 255
        img[:, :, 1] = np.ones([400, 400]) + 255
        img[:, :, 2] = np.ones([400, 400]) * 255
        cv.imshow("iamge", img)
        img2 = np.zeros([400, 400, 3], np.uint8)+255
        cv.imshow("iamge2", img2)
        cv.waitKey(0)
     
    create_image()
    

    再创建简单的形状通过轮廓检测算法去识别图像轮廓:

    #coding:utf-8
    import cv2
    import numpy as np
    
    #先创建一个200*200的黑色空白图像
    img = np.zeros((200, 200), dtype=np.uint8)
    #在图像中心放置一个白色方块
    img[50:150, 50:150] = 255
    
    ret, thresh = cv2.threshold(img, 127, 255, 0)
    #调用findContours()函数对图像进行二值化操作
    image, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    color = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
    img = cv2.drawContours(color, contours, -1, (255,0,0), 2)
    cv2.imshow("contours", color)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    findContours()函数有三个参数:输入图像、层次类型和轮廓逼近方法,同时也有三个返回值:修改后的图像、图像轮廓以及它们的层次。使用轮廓来画出图像的彩色版本并将其显示出来。
    findContours()函数会修改原图像,因此建议使用img.copy()对原图像进行拷贝来作为输入图像。
    findContours()函数会返回一个层次树。cv2.RETR_TREE参数会得到图像中轮廓的整体层次结构,以此来建立轮廓之间的“关系“。如果只想得到最外面的轮廓,可使用cv2.RETR_EXTERNAL。这对消除包含在其他轮廓中的轮廓很有用(比如在大多数情况下不需要检测一个目标包含在另一个与之相同的目标里面)。

    展开全文
  • 虽然单单要做车牌号识别的话不需要特别多种类的图像处理,但是我们不能只是为了这么一个目标去学习,所以这次就讲一些OpenCV里基本的图像处理,大家以后可以根据需求使用不同的图像处理。 一、图像显示 这一步在...
  • 目录 ...初学OpenCV图像处理的小伙伴肯定对什么高斯函数、滤波处理、阈值二值化等特性非常头疼,这里给各位分享一个小项目,可通过摄像头实时动态查看各类图像处理的特点,也可对各位调参、测试...
  • 颜色空间的分类,和不同类型颜色空间的用途,参考上一篇博客 ...opencv提供了cvtColor()函数来实现这些功能。首先看一下cvtColor函数定义: void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0 );
  • OpenCV 3.3 Python 3 Windows 7以上版本 二、环境配置  Python3 和 PyCharm的安装这里就不详述的,只需到对应的官方网站下载安装即可,需注意的是Python 要安装Python3以上版本。 注意:Python 3 安装完后,...
  • OpenCV3源代码文件夹sources:     • 3rdparty: 包含第三方库,如用视频解码用的 ffmpeg、jpg、png、tiff 等图片的解码库。 • apps: 包含进行 Haar 分类器训练的工具,OpenCV 进行人脸检测便是基于 Haar ...
  • 图像载入 imread() 图像显示 imshow() 图像保存 imwrite()
  • 仿射变换仿射变换(Affine Transformation或 Affine Map),又称仿射映射,是指在几何中,一个向量空间进行一次线性变换并接上一个平移,变换为另一个向量空间的过程。它保持了二维图形的“平直性”(即:直线经过...
  • Python+OpenCV3.3图像处理视频培训课程:该教程基于Python3.6+OpenCV新版本3.3.0详细讲述Python OpenCV图像处理部分内容,包括opencv人脸识别、人脸检测、数字验证码识别等内容。是Python开发者学习图像知识与应用...
  • 图像处理的仿射变换和透视变换仿射变换和透视变换更直观的叫法可以叫做“平面变换”和“空间变换”。一个是二维坐标(x,y),一个是三维坐标(x,y,z)仿射变换:二维平面的变换 ; 线性变换 ;已知3对坐标点就可以求得...
  • Python+OpenCV3.3图像处理视频培训课程:该教程基于Python3.6+OpenCV新版本3.3.0详细讲述Python OpenCV图像处理部分内容,包括opencv人脸识别、人脸检测、数字验证码识别等内容。是Python开发者学习图像知识与应用...
  • findContours函数原型(opencv3.2帮助文档) void cv::findContours ( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset = Poi...
  • OpenCV是学习数字图像处理的好工具,本专栏拟打算从对OpenCV源码的学习来研究数字图像处理中的基本操作。我开设本专栏不为别的,只希望能系统地学习OpenCV,并把我支离破碎的数字图像处理知识好好理一理。当然,最终...
  • 基于OpenCV最新版本OpenCV4开始,从基础开始,详解OpenCV核心模块Core、Imgproc、video analysis核心API与相关知识点,讲解从图像组成,像素操作开始,一步一步教你如何写代码,如何用API解决实际问题,从图像处理到...
  • OpenCV3.2 Java图像处理视频培训课程:基于OpenCV新版本3.2.0详细讲述Java OpenCV图像处理部分内容,包括Mat对象使用、图像读写、 基于常用核心API讲述基本原理、使用方法、参数、代码演示、图像处理思路与流程讲授...
  • 统计图像的直方图 ,绘制直方图
1 2 3 4 5 ... 20
收藏数 73,719
精华内容 29,487
关键字:

opencv3图像处理