【OpenCV】3h精通OpenCV

最新推荐文章于 2023-04-19 10:37:40 发布

不断进步的咸鱼

最新推荐文章于 2023-04-19 10:37:40 发布

阅读量1.8k

点赞数 10

分类专栏： OpenCV3 文章标签： opencv

本文链接：https://blog.csdn.net/qq_36926037/article/details/107656530

版权

OpenCV3 专栏收录该内容

41 篇文章 15 订阅

订阅专栏

项目源码：https://github.com/murtazahassan/Learn-OpenCV-in-3-hours

一、读取图片和网络摄像头

1.1 图片读取

import cv2 

#读取图像，参数为图像路径
img=cv2.imread('D:\Project\Opencv\Learning02\image01.jpg')

#显示图像，两个参数，窗口名称、图像
cv2.imshow('image window',img)
cv2.waitKey(1000)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

1.2 视频读取

1.1.1 读取视频文件

import cv2
#读取视频

#创建视频捕获对象capture:参数为 视频所在路径
cap=cv2.VideoCapture('D:\Project\Opencv\Learning02\WeChat_20200707183819.mp4')
while True:
    ret, frame = cap.read()
    cv2.imshow('video image',frame)
    if cv2.waitKey(1)&0xFF==ord('q'):#结束循环
        break

在这里插入图片描述

1.1.2 读取网络摄像头

import cv2
#读取网络摄像头

#创建视频捕获对象capture:参数为数字，0代表默认摄像头，若有多个摄像头则选择其他数字与之对应
cap=cv2.VideoCapture(0)

#设置：第一个参数是想要调节的属性的ID，后的调节的大小
cap.set(3,640)# 宽度640
cap.set(4,480)# 高度480
cap.set(10,100)#设置亮度,增加100

while True:
    ret, frame = cap.read()
    cv2.imshow('video image',frame)
    if cv2.waitKey(1)&0xFF==ord('q'):#结束循环
        break

二、OpenCV基础功能

import cv2
import numpy as np

#读取图像
img=cv2.imread('D:\Project\Opencv\Learning02\image01.png')

#灰度变换
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
cv2.imshow('gray image',gray)

#图像模糊
blur=cv2.GaussianBlur(gray,(7,7),0)#图像、内核大小、sigma
cv2.imshow('blur image',blur)

# 边缘检测
canny=cv2.Canny(gray,100,255)#图像、阈值1、阈值2
cv2.imshow('Canny image',canny)

#膨胀
kernel=np.ones((5,5),np.uint8)#对象的类型为8位无符号整数既范围为0-255
dilate=cv2.dilate(canny,(3,3),kernel,iterations=3)#图像，内核大小
cv2.imshow('dilate image',dilate)

#腐蚀
erode=cv2.erode(canny,kernel,iterations=3)
cv2.imshow('erode image',dilate)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

三、调整、裁剪图像

图片的坐标表示：
在这里插入图片描述

3.1 调整图像大小

import cv2
import numpy as np

#读取图像
img=cv2.imread('D:\Project\Opencv\Learning02\image01.jpg')
cv2.imshow('image',img)

#显示原图大小
print(img.shape)#(750, 500,3)分别代表高、宽、深度

#调整图像大小
resize_img=cv2.resize(img,(500,500))#原图，想要调整的大小
cv2.imshow('resize image',resize_img)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

3.2 裁剪图像

import cv2
import numpy as np

#读取图像
img=cv2.imread('D:\Project\Opencv\Learning02\image01.jpg')
cv2.imshow('image',img)

#显示原图大小
print(img.shape)#(750, 500,3)分别代表高、宽、深度

#裁剪图像
crop_img=img[0:500,:]
cv2.imshow('crop image',crop_img)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

四、在图像上绘制形状和文本

4.1 图像上绘制形状

import cv2
import numpy as np

#创建三通道图像
img=np.zeros((400,400,3),np.uint8)
cv2.imshow('oringin image',img)


#绘制线条
cv2.line(img,(0,0),(img.shape[1],img.shape[0]),(255,0,0),3)#参数图像、线起点坐标、线终点坐标、线颜色、线条宽度
cv2.imshow('line image',img)

#绘制矩形
cv2.rectangle(img,(0,0),(int(img.shape[1]/2),int(img.shape[0]/2)),(0,255,0),cv2.FILLED)#参数图像、左上坐标、右下坐标、颜色、线条宽度/填充
cv2.imshow('rectangle image',img)


#绘制圆
cv2.circle(img,(int(img.shape[1]/2),int(img.shape[0]/2)),40,(0,0,255),3)#图像，圆心坐标，半径,颜色，线条宽度/填充
cv2.imshow('circle image',img)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

4.2 图像上绘制文本

import cv2
import numpy as np

#创建三通道图像
img=np.zeros((400,400,3),np.uint8)
cv2.imshow('oringin image',img)

#绘制文本
cv2.putText(img,'we write',(200,200),cv2.FONT_HERSHEY_COMPLEX,1,(0,0,255),)#图像、文本内容，绘制开始点，字体,比例尺，颜色，线宽度
cv2.imshow('putText01 image',img)
cv2.putText(img,'we write',(200,200),cv2.FONT_HERSHEY_COMPLEX,1.5,(0,255,0),)#图像、文本内容，绘制开始点，字体,比例尺，颜色，线宽度
cv2.imshow('putText02 image',img)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

五、透视变换

import cv2
import numpy as np


img=cv2.imread(r'D:\Project\Opencv\Learning02\image02.png')
cv2.imshow('oringin image',img)

#定义四个点
width,height=250,350
pts1=np.float32([[98,189],[252,161],[135,419],[307,381]])
pts2=np.float32([[0,0],[width,0],[0,height],[width,height]])

#转换矩阵
matrix=cv2.getPerspectiveTransform(pts1,pts2)

#转换后的图像
img_output=cv2.warpPerspective(img,matrix,(width,height))
cv2.imshow("warp image",img_output)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

六、图像拼接

import cv2
import numpy as np

img=cv2.imread(r'D:\Project\Opencv\Learning02\image01.png')
cv2.imshow('oringin image',img)

# #图像结合，水平(两图必须有相同的通道数)
# hor=np.hstack((img,img))
# cv2.imshow("horizontal image",hor)
# #图像结合，垂直(两图必须有相同的通道数)
# ver=np.vstack((img,img))
# cv2.imshow("vertical image",ver)

"""函数能实现横向和垂直拼接，并且不要求通道数相同"""
def stackImages(scale,imgArray):
    rows = len(imgArray)
    cols = len(imgArray[0])
    rowsAvailable = isinstance(imgArray[0], list)
    width = imgArray[0][0].shape[1]
    height = imgArray[0][0].shape[0]
    if rowsAvailable:
        for x in range ( 0, rows):
            for y in range(0, cols):
                if imgArray[x][y].shape[:2] == imgArray[0][0].shape [:2]:
                    imgArray[x][y] = cv2.resize(imgArray[x][y], (0, 0), None, scale, scale)
                else:
                    imgArray[x][y] = cv2.resize(imgArray[x][y], (imgArray[0][0].shape[1], imgArray[0][0].shape[0]), None, scale, scale)
                if len(imgArray[x][y].shape) == 2: imgArray[x][y]= cv2.cvtColor( imgArray[x][y], cv2.COLOR_GRAY2BGR)
        imageBlank = np.zeros((height, width, 3), np.uint8)
        hor = [imageBlank]*rows
        hor_con = [imageBlank]*rows
        for x in range(0, rows):
            hor[x] = np.hstack(imgArray[x])
        ver = np.vstack(hor)
    else:
        for x in range(0, rows):
            if imgArray[x].shape[:2] == imgArray[0].shape[:2]:
                imgArray[x] = cv2.resize(imgArray[x], (0, 0), None, scale, scale)
            else:
                imgArray[x] = cv2.resize(imgArray[x], (imgArray[0].shape[1], imgArray[0].shape[0]), None,scale, scale)
            if len(imgArray[x].shape) == 2: imgArray[x] = cv2.cvtColor(imgArray[x], cv2.COLOR_GRAY2BGR)
        hor= np.hstack(imgArray)
        ver = hor
    return ver

imgGray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
imgStack = stackImages(0.5,([img,imgGray,img],[img,img,img]))
cv2.imshow('stack image',imgStack)

cv2.waitKey(0)#0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

七、颜色检测

import cv2
import numpy as np

#颜色检测原理：通过定义的颜色值范围（定义色相、饱和度等值的限制），检测图像中包含此种颜色的区域
#颜色检测难点:不能确定颜色值（H,S,V）的最大值最小值范围，我们需要使用跟踪杆（trackbar），不断调节H，S，V的各个值，找到最佳颜色最小值和最大值。

"""颜色检测的步骤：1.找的合适的颜色范围（H/S/V）2.使用颜色范围创建颜色检测蒙版。3.使用蒙版检测原图像想要得到的颜色区域"""

#创建一个新窗口，调整窗口大小
cv2.namedWindow('trackBars')
cv2.resizeWindow('trackBars',640,240)
'''(1)创建跟踪杆，寻找H/S/V的最佳值范围'''
#创建跟踪杆（trackbar）:#参数：trackbar的名称，放置该trackbar的窗口，初始值（当前值），最大值，调用函数（该函数每次在轨道上发生任何变化时都会运行）
def empty(a):
    pass
#初始跟踪杆，不断调整，找到能够检测到想要的颜色的H/S/V最佳范围值，本例值为0 19 110 241 154 255
# cv2.createTrackbar('hue min','trackBars',0,179,empty)#色相
# cv2.createTrackbar('hue max','trackBars',179,179,empty)#色相
# cv2.createTrackbar('sat min','trackBars',0,255,empty)#饱和度
# cv2.createTrackbar('sat max','trackBars',255,255,empty)#饱和度
# cv2.createTrackbar('val min','trackBars',0,255,empty)#明度
# cv2.createTrackbar('val max','trackBars',255,255,empty)#明度
#
# #用最佳范围值初始化跟踪杆19 19 112 241 154 255
cv2.createTrackbar('hue min','trackBars',0,179,empty)#色相
cv2.createTrackbar('hue max','trackBars',19,179,empty)#色相
cv2.createTrackbar('sat min','trackBars',110,255,empty)#饱和度
cv2.createTrackbar('sat max','trackBars',241,255,empty)#饱和度
cv2.createTrackbar('val min','trackBars',154,255,empty)#明度
cv2.createTrackbar('val max','trackBars',255,255,empty)#明度

while True:
    img = cv2.imread(r'D:\Project\Opencv\Learning02\image04.png')
    imgHSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # 图像转HSV空间

    # 读取跟踪栏（trackbar）将其应用于图像
    h_min=cv2.getTrackbarPos('hue min','trackBars')#trackbar的名称，trackbar所在窗口
    h_max = cv2.getTrackbarPos('hue max', 'trackBars')
    s_min = cv2.getTrackbarPos('sat min', 'trackBars')
    s_max = cv2.getTrackbarPos('sat max', 'trackBars')
    v_min = cv2.getTrackbarPos('val min', 'trackBars')
    v_max = cv2.getTrackbarPos('val max', 'trackBars')
    print(h_max,h_max,s_min,s_max,v_min,v_max)
    
    '''(2)利用颜色值范围，创建mask(蒙版)'''
    #创建mask掩码
    lower=np.array([h_min,s_min,v_min])
    upper=np.array([h_max,s_max,v_max])
    mask=cv2.inRange(imgHSV,lower,upper)#图像，最小值，最大值

    #调整各trackbar，找到最佳mask（能够检测出想要物体的）#本例中mask对应的值分别为0 19 110 241 154 255
    
    '''(3)使用mask蒙版进行颜色检测'''
    #用mask得到作为原图蒙版检测到想要物体
    imgResult=cv2.bitwise_and(img,img,mask=mask)#将两个图像加在一起创建信息图像。参数：原始图像，新图像，蒙版

    cv2.imshow('oringin image', img)
    # cv2.imshow("HSV image", imgHSV)
    cv2.imshow("mask image", mask)
    cv2.imshow("result image", imgResult)
    cv2.waitKey(1)  # 0代表无限延迟，数值代表延迟多少毫秒

在这里插入图片描述

八、轮廓、形状检测

import cv2
import numpy as np




#轮廓检测
def getContours():
    img = cv2.imread(r'D:\Project\Opencv\Learning02\image05.png')
    # 灰度转换
    imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 高斯平滑/模糊
    imgBlur = cv2.GaussianBlur(imgGray, (7, 7), 1)
    # 边缘检测
    imgCanny = cv2.Canny(imgBlur, 50, 50)  # 图像，阈值1，阈值2

    """"""
    img_cnt=img.copy()
    """轮廓检测"""
    cloneImage,contours,Heriachy=cv2.findContours(imgCanny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)#参数：图像，检索模式(RETR_EXTERNAL是检索外部轮廓)，检索方法
    #轮廓保存在countours中

    for cnt in contours:
        """（1）计算轮廓区域面积"""
        area=cv2.contourArea(cnt)#求轮廓面积
        print('面积:',area)

        if area>10:
            """（2）绘制轮廓"""
            cv2.drawContours(img_cnt, cnt, -1, (255, 0, 0), 3)  # 图像，轮廓，轮廓索引（因为绘制所有的轮廓，所以是-1）,颜色，线宽度

            '''（3）计算轮廓曲线长度'''
            peri=cv2.arcLength(cnt,True)#轮廓，封闭轮廓（True）
            print('周长',peri)

            '''（4）计算角点'''
            approx=cv2.approxPolyDP(cnt,0.02*peri,True)#图像，0.02*周长，封闭轮廓（True）
            print('角点:',approx,'角点个数：',len(approx))#根据每个闭合角点的个数就可以判断轮廓是什么形状

            """(5)绘制外接矩形：根据角点"""

            x,y,w,h=cv2.boundingRect(approx)#根据角点得到边界矩形的左上角和宽和高
            cv2.rectangle(img_cnt,(x,y),(x+w,y+h),(0,255,0),2)#绘制矩形，之前学习过

            '''(6)图形分类'''
            objCor = len(approx)
            if objCor==3:
                ObjectType='Tri'
            elif objCor==4:
                ObjectType='Rec'
            else:
                ObjectType = 'Cir'
            # 绘制文本：图像，内容，起始点，字体，比例尺，颜色，缩放字体
            cv2.putText(img_cnt,'{}'.format(ObjectType),(x+(w//2),y+(h//2)),cv2.FONT_HERSHEY_COMPLEX,0.5,(0,0,0),2)


    cv2.imshow('Contours image', img_cnt)
    cv2.imshow('oringin image', img)
    cv2.imshow('gray image', imgGray)
    cv2.imshow('Canny image', imgCanny)


getContours()
cv2.waitKey(0)

在这里插入图片描述

九、人脸检测

opencv提供了一些默认的cascade，如果你想检测不同的东西，例车牌号，眼睛全身等，你可以下载这些级联。https://github.com/opencv/opencv/tree/master/data/haarcascades

import cv2
import numpy as np

#添加级联,该xml是网址上下载的
faceCascade=cv2.CascadeClassifier(r'D:\Project\Opencv\Learning02\haarcascade_frontalface_default.xml')

#读取原图
img = cv2.imread(r'D:\Project\Opencv\Learning02\image01.png')
#灰度转换
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#人脸检测
faces=faceCascade.detectMultiScale(imgGray,1.1,4)#图像，比例因子、最小邻域

#为面孔创建边界框
for (x,y,w,h) in faces:
    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
    
cv2.imshow('face',img)
cv2.waitKey(0)

在这里插入图片描述

十、实战

10.1 虚拟绘画

需要找到颜色

import cv2
import numpy as np
frameWidth = 640
frameHeight = 480
cap = cv2.VideoCapture(0)
cap.set(3, frameWidth)
cap.set(4, frameHeight)
cap.set(10,150)

#想要检测的颜色
myColors = [[5,107,0,19,255,255],
            [133,56,0,159,156,255],
            [57,76,0,100,255,255],
            [90,48,0,118,255,255]]
#想要绘制的颜色
myColorValues = [[51,153,255],          ## BGR
                 [255,0,255],
                 [0,255,0],
                 [255,0,0]]
#绘制的点的列表
myPoints =  []  ## [x , y , colorId ]

"""获取想要绘制的，及对应的颜色"""
def findColor(img,myColors,myColorValues):
    imgHSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    count = 0
    newPoints=[]
    for color in myColors:
        lower = np.array(color[0:3])
        upper = np.array(color[3:6])
        mask = cv2.inRange(imgHSV,lower,upper)#找到想要检测的颜色所在区域
        
        x,y=getContours(mask)#想要绘制的点
        
        cv2.circle(imgResult,(x,y),15,myColorValues[count],cv2.FILLED)#将点绘制在图上
        if x!=0 and y!=0:
            newPoints.append([x,y,count])#将点添加到 newPoints列表中，count为想要绘制颜色的编号
        count +=1  
    return newPoints#返回想要绘制的点的集合【x,y,颜色序号】
def getContours(img):
    cloneImage,contours,Heriachy = cv2.findContours(img,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)#发现边缘
    x,y,w,h = 0,0,0,0
    for cnt in contours:
        area = cv2.contourArea(cnt)
        if area>500:
            #cv2.drawContours(imgResult, cnt, -1, (255, 0, 0), 3)
            peri = cv2.arcLength(cnt,True)
            approx = cv2.approxPolyDP(cnt,0.02*peri,True)
            x, y, w, h = cv2.boundingRect(approx)#轮廓的外接矩形
    return x+w//2,y#轮廓外接矩形顶边的中点

"""把点绘制在画布上"""
def drawOnCanvas(myPoints,myColorValues):
    for point in myPoints:
        cv2.circle(imgResult, (point[0], point[1]), 10, myColorValues[point[2]], cv2.FILLED)


while True:
    success, img = cap.read()
    imgResult = img.copy()
    
    newPoints = findColor(img, myColors,myColorValues)#想要绘制的点
    if len(newPoints)!=0:
        for newP in newPoints:
            myPoints.append(newP)
    if len(myPoints)!=0:
        drawOnCanvas(myPoints,myColorValues)#将点绘制在画布上

    cv2.imshow("Result", imgResult)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

10.2 纸张扫描

import cv2
import numpy as np

"""图像预处理"""
def preProcessing(img):
    imgGray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)#转换为灰度图
    imgBlur = cv2.GaussianBlur(imgGray,(5,5),1)#高斯模糊
    imgCanny = cv2.Canny(imgBlur,200,200)#边缘检测
    kernel = np.ones((5,5))#结构元素
    imgDial = cv2.dilate(imgCanny,kernel,iterations=2)#膨胀
    imgThres = cv2.erode(imgDial,kernel,iterations=1)#腐蚀
    return imgThres

'''获取最大轮廓角点'''
def getContours(img):
    biggest = np.array([])
    maxArea = 0
    #轮廓检测
    cloneImage,contours,Heriachy= cv2.findContours(img,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)
    for cnt in contours:
        #轮廓内面积
        area = cv2.contourArea(cnt)
        if area>5000:
            #计算周长
            peri = cv2.arcLength(cnt,True)
            #计算角点
            approx = cv2.approxPolyDP(cnt,0.02*peri,True)
            #判断轮廓是否为矩形
            if area >maxArea and len(approx) == 4:
                biggest = approx#获取最大的那个矩形框
                maxArea = area#最大面积值更新

    #绘制轮廓（biggest仅仅包含矩形的轮廓）
    cv2.drawContours(imgContour, biggest, -1, (255, 0, 0), 20)
    return biggest#返回最大轮廓

'''矩形角点的重新处理：按照一定的顺序排列（左上，右上，左下，右下）'''
def reorder (myPoints):
    myPoints = myPoints.reshape((4,2))#四个角点
    myPointsNew = np.zeros((4,1,2),np.int32)

    #点按照一定的顺序重新排列
    add = myPoints.sum(1)#将点进行x+y计算，
    myPointsNew[0] = myPoints[np.argmin(add)] #和最小的点为左上角点
    myPointsNew[3] = myPoints[np.argmax(add)]#和最大的点为右下角点

    diff = np.diff(myPoints,axis=1)#将点进行x-y差异计算
    myPointsNew[1]= myPoints[np.argmin(diff)]#差异最小的点为右上
    myPointsNew[2] = myPoints[np.argmax(diff)]#差异最大的点为左下

    return myPointsNew

'''鸟瞰转换'''
def getWarp(img,biggest):#参数：图像，四个角点

    #矩阵角点的处理，按照一个统一顺序排列
    biggest = reorder(biggest)

    # 点1
    pts1 = np.float32(biggest)
    # 点2
    pts2 = np.float32([[0, 0], [widthImg, 0], [0, heightImg], [widthImg, heightImg]])

    #转换矩阵
    matrix = cv2.getPerspectiveTransform(pts1, pts2)
    #鸟瞰图
    imgOutput = cv2.warpPerspective(img, matrix, (widthImg, heightImg))

    #得到的鸟瞰图，边缘有其他背景，所以裁剪边缘，，并将裁剪后的图像，重新调整为原来窗口大小。
    imgCropped = imgOutput[20:imgOutput.shape[0]-20,20:imgOutput.shape[1]-20]
    imgCropped = cv2.resize(imgCropped,(widthImg,heightImg))

    return imgCropped#返回鸟瞰图

'''图像堆叠显示'''
def stackImages(scale,imgArray):
    rows = len(imgArray)
    cols = len(imgArray[0])
    rowsAvailable = isinstance(imgArray[0], list)
    width = imgArray[0][0].shape[1]
    height = imgArray[0][0].shape[0]
    if rowsAvailable:
        for x in range ( 0, rows):
            for y in range(0, cols):
                if imgArray[x][y].shape[:2] == imgArray[0][0].shape [:2]:
                    imgArray[x][y] = cv2.resize(imgArray[x][y], (0, 0), None, scale, scale)
                else:
                    imgArray[x][y] = cv2.resize(imgArray[x][y], (imgArray[0][0].shape[1], imgArray[0][0].shape[0]), None, scale, scale)
                if len(imgArray[x][y].shape) == 2: imgArray[x][y]= cv2.cvtColor( imgArray[x][y], cv2.COLOR_GRAY2BGR)
        imageBlank = np.zeros((height, width, 3), np.uint8)
        hor = [imageBlank]*rows
        hor_con = [imageBlank]*rows
        for x in range(0, rows):
            hor[x] = np.hstack(imgArray[x])
        ver = np.vstack(hor)
    else:
        for x in range(0, rows):
            if imgArray[x].shape[:2] == imgArray[0].shape[:2]:
                imgArray[x] = cv2.resize(imgArray[x], (0, 0), None, scale, scale)
            else:
                imgArray[x] = cv2.resize(imgArray[x], (imgArray[0].shape[1], imgArray[0].shape[0]), None,scale, scale)
            if len(imgArray[x].shape) == 2: imgArray[x] = cv2.cvtColor(imgArray[x], cv2.COLOR_GRAY2BGR)
        hor= np.hstack(imgArray)
        ver = hor
    return ver

#创建视频捕获对象
cap = cv2.VideoCapture(1)
cap.set(10,150)
while True:
    # 读取视频帧
    success, img = cap.read()

    # 调整图像大小
    widthImg = 540
    heightImg = 640
    img = cv2.resize(img,(widthImg,heightImg))

    # 复制图像
    imgContour = img.copy()

    #图像预处理
    imgThres = preProcessing(img)

    #获取轮廓的角点
    biggest = getContours(imgThres)

    if biggest.size !=0:
        #鸟瞰转换
        imgWarped=getWarp(img,biggest)
        imageArray = ([imgContour, imgWarped])
        cv2.imshow("ImageWarped", imgWarped)
    else:
        imageArray = ([imgContour, img])

    #图像堆叠显示
    stackedImages = stackImages(0.6,imageArray)
    cv2.imshow("WorkFlow", stackedImages)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

10.3 车牌检测器

import cv2

frameWidth = 640
frameHeight = 480
#下载级联xml下载地址https://github.com/opencv/opencv/tree/master/data/haarcascades
nPlateCascade = cv2.CascadeClassifier("D:\Project\Opencv\Learning02\haarcascade_russian_plate_number.xml")
minArea = 200
color = (255,0,255)

#读取视频
cap = cv2.VideoCapture("video path")
cap.set(3, frameWidth)
cap.set(4, frameHeight)
cap.set(10,150)
count = 0

while True:
    success, img = cap.read()#视频帧读取
    imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)#灰度处理

    #车牌检测
    numberPlates = nPlateCascade.detectMultiScale(imgGray, 1.1, 10)
    for (x, y, w, h) in numberPlates:
        area = w*h
        if area >minArea:
            #绘制矩形
            cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 255), 2)
            #绘制文字
            cv2.putText(img,"Number Plate",(x,y-5),cv2.FONT_HERSHEY_COMPLEX_SMALL,1,color,2)
            imgRoi = img[y:y+h,x:x+w]
            cv2.imshow("ROI", imgRoi)

    cv2.imshow("Result", img)

    if cv2.waitKey(1) & 0xFF == ord('s'):
        cv2.imwrite("Resources/Scanned/NoPlate_"+str(count)+".jpg",imgRoi)
        cv2.rectangle(img,(0,200),(640,300),(0,255,0),cv2.FILLED)
        cv2.putText(img,"Scan Saved",(150,265),cv2.FONT_HERSHEY_DUPLEX,2,(0,0,255),2)
        cv2.imshow("Result",img)
        cv2.waitKey(500)
        count +=1