opencv-python笔记

1. 图像读取与显示

1通道灰色图像：

3通道：蓝 (B)、绿 (G)、红 (R)

4通道：蓝 (B)、绿 (G)、红 (R)、透明

HSV 颜色空间

• Hue（色调、色相）
• Saturation（饱和度、色彩纯净度）
• Value（明度）

1. 图像色彩空间转换

import cv2 as cv

def readdemo():
    image = cv.imread("dog1.jpeg")
    #BGR图像转灰度图像
    gray = cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    #BGR图像转hsv图像
    hsv = cv.cvtColor(image,cv.COLOR_BGR2HSV)
    #hsv图像转BGR图像
    hsv = cv.cvtColor(hsv,cv.COLOR_HSV2BGR)
cv.imshow("gray",gray)
cv.imshow("hsv",hsv)
cv.waitKey(10)
cv.destoryAllWindows()

if __name__=="__main__":
    readdemo()

1. 图像对象的创建与赋值

import cv2 as cv
import numpy as np

def readdemo():
    image = cv.imread("dog1.jpeg")
    print(image.shape)
    """
    构建一个与image相似的数据，相当于
    H,S,V=image.shape
    blank = np.zeros((H,S,V),dtype=uint8)
    """
    blank = np.zeros_like(image)
    #截取image部分
    image1 = image[120:300,200:500,:]
    blank[120:300,200:500,:] = image1
    cv.imshow("input",image)
    cv.imshow("blank",blank)
    cv.waitKey(0)
    cv.destroyAllWindows()

if __name__=="__main__":
    readdemo()

1. 图像像素的读写操作

import cv2 as cv
import numpy as np

def readdemo():
    image = cv.imread("dog1.jpeg")
    h,s,v = image.shape
    # blank = np.zeros_like((h,s,v),dtype=uint8)
    cv.imshow("input",image)
    for row in range(h):
        for col in range(s):
            b,g,r = image[row,col]
            image[row][col]=[255-b,255-g,255-r]
    cv.imshow("out",image)
    cv.waitKey(0)
    cv.destroyAllWindows()

if __name__=="__main__":
    readdemo()

1. 图像像素的算术操作

import cv2 as cv
import numpy as np

def readdemo():
    image = cv.imread("dog1.jpeg")
    h,s,v = image.shape
    blank = np.zeros_like(image)
    blank[:,:,:] = [80,80,80]
    cv.imshow("input",image)
    # 图像的加法
    blank1 = cv.add(blank,image)
    cv.imshow("blank1",blank1)
    # 图像的减法
    blank2 = cv.subtract(blank,image)
    cv.imshow("blank2",blank2)
    # 图像的除法
    blank[:,:,:] = [2,2,2]
    blank3 = cv.divide(image,blank)
    cv.imshow("blank3",blank3)
    # 图像的乘法
    blank[:,:,:] = [2,2,2]
    blank4 = cv.multiply(image,blank)
    cv.imshow("blank4",blank4)


    cv.waitKey(0)
    cv.destroyAllWindows()

if __name__=="__main__":
    readdemo()

1. TrackBar/滚动条操作演示-调整图像亮度

import cv2 as cv
import numpy as np

def nothing(x):
    print(x)
def readdemo():
    image = cv.imread("dog1.jpeg")
    cv.namedWindow("input",cv.WINDOW_AUTOSIZE)
    cv.createTrackbar("adjust_light","input",0,100,nothing)
    cv.imshow("input",image)
    blank = np.zeros_like(image)
    while True:
        pos = cv.getTrackbarPos("adjust_light","input")
        blank[:,:,:] = [pos,pos,pos]
        blank1 = cv.add(blank,image)
        cv.imshow("blank1",blank1)
        c = cv.waitKey(1)
        if c==27:
            break
    cv.destroyAllWindows()

if __name__=="__main__":
    readdemo()

1. TrackBar/滚动条操作演示-参数传递与调整亮度与对比度

import cv2 as cv
import numpy as np

def nothing(x):
    print(x)
def readdemo():
    image = cv.imread("dog1.jpeg")
    cv.namedWindow("input",cv.WINDOW_AUTOSIZE)
    cv.createTrackbar("light","input",0,100,nothing)
    cv.createTrackbar("constract","input",100,200,nothing)
    cv.imshow("input",image)
    blank = np.zeros_like(image)
    while True:
        light = cv.getTrackbarPos("light","input")
        constract = cv.getTrackbarPos("constract","input")/100
        blank1 = cv.addWeighted(image,constract,blank,0.5,light)
        cv.imshow("blank1",blank1)
        c = cv.waitKey(1)
        if c==27:
            break
    cv.destroyAllWindows()

if __name__=="__main__":
    readdemo()

1. 键盘响应操作

import cv2 as cv
import numpy as np


def readdemo():
    image = cv.imread("dog1.jpeg")
    cv.namedWindow("input",cv.WINDOW_AUTOSIZE)
    cv.imshow("input",image)
    blank = np.zeros_like(image)
    while True:
        c = cv.waitKey(1)
        
        if c==49:#代表按键1
            gray = cv.cvtColor(image,cv.COLOR_BGR2GRAY)
            cv.imshow("result",gray)
        if c==50:#代表按键2
            hsv = cv.cvtColor(image,cv.COLOR_BGR2HSV)
            cv.imshow("result",hsv)
        if c==51:#代表按键3
            invert = cv.bitwise_not(image)
            cv.imshow("result", invert)
    cv.destroyAllWindows()

if __name__=="__main__":
    readdemo()

按1后的效果图：

按2后的效果图：

按3后的效果图：

1. OpenCV自带颜色表操作

import cv2 as cv
import numpy as np


def color_table_demo():
    color_map = [cv.COLORMAP_AUTUMN,
                 cv.COLORMAP_BONE,
                 cv.COLORMAP_JET,
                 cv.COLORMAP_WINTER,
                 cv.COLORMAP_RAINBOW,
                 cv.COLORMAP_OCEAN,
                 cv.COLORMAP_SUMMER,
                 cv.COLORMAP_SPRING,
                 cv.COLORMAP_COOL,
                 cv.COLORMAP_PINK,
                 cv.COLORMAP_HOT,
                 cv.COLORMAP_PARULA,
                 cv.COLORMAP_MAGMA,
                #  cv.COLORMAR_INFERNO,
                 cv.COLORMAP_PLASMA,
                 cv.COLORMAP_VIRIDIS,
                 cv.COLORMAP_CIVIDIS,
                 cv.COLORMAP_TWILIGHT,
                 cv.COLORMAP_TWILIGHT_SHIFTED]
    
    image = cv.imread("dog1.jpeg")
    cv.namedWindow("input",cv.WINDOW_AUTOSIZE)
    cv.imshow("input",image)
    index = 0

    while True:
        dst = cv.applyColorMap(image,color_map[index%18])
        index +=1
        cv.imshow("result",dst)
        c = cv.waitKey(400)
        if c==27:
            break
    cv.destroyAllWindows()

if __name__=="__main__":
    color_table_demo()

注意：在OpenCV 4.x版本中，COLORMAR_INFERNO属性已经被移除。如果你需要使用这个属性，可以尝试降级到OpenCV 3.x版本。

1. 图像像素的逻辑操作

import cv2 as cv
import numpy as np


# 定义一个函数bitwise_demo，用于演示位运算
def bitwise_demo():
    # 读取图片dog1.jpeg，并将其赋值给src
    src = cv.imread("dog1.jpeg")
    # 创建一个名为input的窗口，并设置大小自动适应
    cv.namedWindow("input",cv.WINDOW_AUTOSIZE)
    # 将src显示到窗口input中
    cv.imshow("input",src)
    # 创建一个大小与src相同的零矩阵，并将其赋值给b1
    b1 = np.zeros_like(src)
    # 将b1显示到窗口b1中
    cv.imshow("b1",b1)

    # 使用位与运算，将src和b1进行位与运算，并将结果赋值给bitwise_and
    bitwise_and = cv.bitwise_and(src,b1)
    # 使用位或运算，将src和b1进行位或运算，并将结果赋值给bitwise_or
    bitwise_or = cv.bitwise_or(src,b1)
    # 将bitwise_and显示到窗口bitwise_and中
    cv.imshow("bitwise_and",bitwise_and)
    # 将bitwise_or显示到窗口bitwise_or中
    cv.imshow("bitwise_or",bitwise_or)
    # 等待按键，如果按下ESC键，则销毁所有窗口，并结束程序
    c = cv.waitKey(0)
    if c==27:
        cv.destroyAllWindows()


if __name__=="__main__":
    bitwise_demo()
    

1. 通道分离与合并

import cv2 as cv
import numpy as np



#通道分离
def split2():
    #读取图片
    image= cv.imread("lena.jpg")
    #显示图片
    cv.imshow("input",image)
    b,g,r= cv.split(image)
    #显示蓝色通道
    cv.imshow("b1",b)
    #显示绿色通道
    cv.imshow("b2",g)
    #显示红色通道
    cv.imshow("b3",r)
    #等待按键
    c = cv.waitKey(0)
    #判断按键是否为ESC
    if c==27:
        #销毁窗口
        cv.destroyAllWindows()

#通道分离
def split1():
    #读取图片
    b= cv.imread("lena.jpg")
    #显示图片
    cv.imshow("input",b)
    #显示蓝色通道
    cv.imshow("b1",b[:,:,0])
    #显示绿色通道
    cv.imshow("b2",b[:,:,1])
    #显示红色通道
    cv.imshow("b3",b[:,:,2])
    #等待按键
    c = cv.waitKey(0)
    #判断按键是否为ESC
    if c==27:
        #销毁窗口
        cv.destroyAllWindows()

#通道融合及转变换
def merge1():
    #读取图片
    image= cv.imread("lena.jpg")
    #显示图片
    cv.imshow("input",image)
    #显示图片
    cv.imshow("input",image)
    #将b通道转换为bgr三通道
    b,g,r= cv.split(image)
    bgr = cv.merge([b,g,r])
    rbg = cv.merge([r,b,g])
    #显示图片
    cv.imshow("bgr",bgr)
    cv.imshow("rbg",rbg)
    #等待按键
    c = cv.waitKey(0)
    #判断按键是否为ESC
    if c==27:
        cv.destroyAllWindows()
#通道融合及转变换
def merge2():
    #读取图片
    image= cv.imread("lena.jpg")
    #显示图片
    cv.imshow("input",image)
    #创建一个全0的图片
    b = np.zeros_like(image)
    #显示全0图片
    cv.imshow("b",b)
    #将图片b的通道0和1调换位置
    cv.mixChannels([image],[b],fromTo=[0,1,1,0,2,2])
    #显示调换后的图片
    cv.imshow("out",b)
    #等待按键
    c = cv.waitKey(0)
    #判断按键是否为ESC
    if c==27:
        cv.destroyAllWindows()

if __name__=="__main__":
    merge2()
    

1. 图像色彩空间转换

import cv2 as cv
import numpy as np


#利用色彩空间抠图
#定义一个函数color_space，用于处理图片的颜色空间
def color_space():
    #读取图片
    image= cv.imread("greenback.png")
    #显示图片
    cv.imshow("input",image)
    #将图片从BGR转换为HSV
    hsv = cv.cvtColor(image,cv.COLOR_BGR2HSV)
    #显示HSV图片
    cv.imshow("hsv",hsv)
    #将HSV图片中的颜色范围设置为35-77，43-255，46-255
    mask = cv.inRange(hsv, (35, 43, 46), (77, 255, 255))
    #显示mask图片
    cv.imshow("mask",mask)
    #将mask图片取反
    cv.bitwise_not(mask,mask)
    #将图片和mask图片进行按位与操作
    result = cv.bitwise_and(image,image,mask=mask)
    #显示结果图片
    cv.imshow("result",result)
    #等待按键，如果按下ESC键，则关闭所有窗口
    c = cv.waitKey(0)
    if c==27:
        cv.destroyAllWindows()
   


if __name__=="__main__":
    color_space()
    

1. 图像像素值统计

利用均值方差统计可以筛选空白图片，方差为0 说明无有效信息

import cv2 as cv
import numpy as np

#像素统计、均值及方差
def pixel_stat():
    #读取图片
    image= cv.imread("lena.jpg")
    #显示图片
    cv.imshow("input",image)
    #统计图片中的像素个数
    px_count = np.size(image)
    #统计图片中的像素平均值
    px_mean = np.mean(image)
    #统计图片中的像素方差
    px_var = np.var(image)
    print("像素总个数：",px_count)
    print("像素总平均值：",px_mean)
    print("像素总方差：",px_var)
    mean,dev = cv.meanStdDev(image)
    print("每个通道像素平均值：",mean)
    print("每个通道像素方差：",dev)
    c = cv.waitKey(0)
    if c==27:
        cv.destroyAllWindows()


if __name__=="__main__":
    pixel_stat()

1. 图像几何形状绘制

#绘制几何图形
def draw_geometry():

    #创建一个640*480的黑色图片
    image = np.zeros((480,640,3),np.uint8)
    #绘制一个矩形cv.rectangle(image,左上角坐标,右下角坐标,颜色,线宽,linetype,shift)
    cv.rectangle(image,(100,100),(400,400),(0,255,0),4,8,0)
    #绘制一个圆形cv.circle(图像数据名,圆心位置,半径,颜色,线宽,linetype,shift)
    cv.circle(image,(300,200),150,(0,0,255),2,3,0)
    #绘制一条直线
    cv.line(image,(100,100),(400,400),(255,0,0),4,8,0)
    #绘制一个文本，文本不能出现中文
    cv.putText(image,"face:99%",(200,200),cv.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2,8)
    cv.imshow("circle",image)

    c = cv.waitKey(0)
    if c==27:
        cv.destroyAllWindows()
    



if __name__=="__main__":
    draw_geometry()

1. 随机数与随机颜色

import cv2 as cv
import numpy as np
#绘制几何图形
def random_color():
    b = np.zeros((512,512,3),np.uint8)
    while True:
        xx = np.random.randint(0,512,2,dtype=np.int)
        yy = np.random.randint(0,512,2,dtype=np.int)
        brg = np.random.randint(0,255,3,dtype=np.int32)
        cv.line(b,(xx[0],yy[0]),(xx[1],yy[1]),(np.int(brg[0]),np.int(brg[1]),np.int(brg[2])),1,8,0)
        cv.imshow("input",b)
        c = cv.waitKey(1)
        if c==27:
            cv.destroyAllWindows()
            break 


if __name__=="__main__":
    random_color()

1. 多边形填充与绘制

import cv2 as cv
import numpy as np

def polyline_drawing_demo():
    canvas = np.zeros((512,512,3), dtype=np.uint8)
    pts = np.array([[100,100],[350,100],[450,280],[320,450],[80, 400]], dtype=np.int32)

    #绘制
    cv.polylines(canvas,[pts],True,(0,255,0),2,8,0)
    cv.imshow("polyline", canvas)
    #填充
    cv.fillPoly(canvas,[pts],(0,0,255),8,0)
    cv.imshow("fillPoly", canvas)
    
    #绘制+填充
    cv.drawContours(canvas, [pts],-1,(255,0,0),-1)
    cv.imshow("drawContours", canvas)
    c = cv.waitKey(0)
    if c==27:
        cv.destroyAllWindows() 


if __name__=="__main__":
    polyline_drawing_demo()

1. 鼠标操作与响应

import cv2 as cv
import numpy as np

x1 = -1
x2 = -1
y1 = -1
y2 = -1

# b1=np.zeros((512,512,3),np.uint8)
image = cv.imread("lena.jpg")
b1 = image.copy()
def mouse_drawing(event,x,y,flags,param):
    global x1,x2,y1,y2,b1
    if event==cv.EVENT_LBUTTONDOWN:
        x1 = x
        y1 = y
    if event==cv.EVENT_MOUSEMOVE:
        if x1<0 and y1<0:
            return
        x2 = x
        y2 = y
        if x2-x1>0 and y2-y1>0:
            b1[:,:,]=image[:,:,:]
            cv.rectangle(b1,(x1,y1),(x2,y2),(0,255,0),1,8,0)
    if event==cv.EVENT_LBUTTONUP:
        x2 = x
        y2 = y
        if x2-x1<0 and y2-y1>0:
            b1[:,:,]=0
            cv.rectangle(b1,(x1,y1),(x2,y2),(0,255,0),1,8,0)
        x1 = -1
        x2 = -1
        y1 = -1
        y2 = -1



def mouse_draw_demo():
    cv.namedWindow("mouse drawing",cv.WINDOW_AUTOSIZE)
    cv.setMouseCallback("mouse drawing",mouse_drawing)
    while True:
        cv.imshow("mouse drawing",b1)
        c = cv.waitKey(10)
        if c==27:
            cv.destroyAllWindows()
            break

if __name__=="__main__":
    mouse_draw_demo()

1. 图像像素类型转换及归一化

只能显示0-1的浮点数和0-255的uint8

import cv2 as cv
import numpy as np

def numlize_demo():
    image = cv.imread("lena.jpg")
    cv.namedWindow("lena",cv.WINDOW_AUTOSIZE)
    print(image/255.0)
    cv.imshow("lena",image/255.0)
    result = np.zeros_like(image,dtype=np.float32)
    cv.normalize(np.float32(image),result,0,1,cv.NORM_MINMAX,dtype = cv.CV_32F)
    cv.imshow("result",result)
    cv.imshow("result1",np.uint8(result*255))
    cv.waitKey(0)
    cv.destroyAllWindows()



if __name__=="__main__":
    numlize_demo()

1. 图像放缩与插值

import cv2 as cv
import numpy as np

# 定义一个函数resize_demo，用于演示图像的缩放
def resize_demo():
    # 读取图像
    image = cv.imread("lena.jpg")
    # 获取图像的宽、高和通道数
    w,h,c = image.shape
    # 使用cv.resize函数对图像进行缩放，参数interpolation指定插值方式
    dst = cv.resize(image,(int(w*2),int(h*2)),interpolation=cv.INTER_CUBIC)
    # 显示缩放后的图像
    cv.imshow("result",dst)
    # 使用cv.resize函数对图像进行缩放，参数fx和fy指定缩放比例，interpolation指定插值方式
    dst1 = cv.resize(image,(0,0),fx=0.75,fy=0.75,interpolation=cv.INTER_CUBIC)
    # 显示缩放后的图像
    cv.imshow("result1",dst1)
    # 等待按键按下
    cv.waitKey(0)
    # 销毁所有窗口
    cv.destroyAllWindows()



if __name__=="__main__":
    resize_demo()

1. 图像翻转

import cv2 as cv
import numpy as np

# 定义一个函数flip_demo，用于演示图像的翻转
def flip_demo():
    # 读取图像
    # 读取图像
    image = cv.imread("lena.jpg")
    # 显示图像
    cv.imshow("input",image)
    # 0上下翻转,1左右翻转,-1对角线翻转
    dst = cv.flip(image,-1)
    # 显示翻转后的图像
    cv.imshow("flip",dst)

    # 等待按键按下
    cv.waitKey(0)
    # 销毁所有窗口
    cv.destroyAllWindows()



if __name__=="__main__":
    flip_demo()

1. 图像旋转

【参考链接】经验 | OpenCV图像旋转的原理与技巧

import cv2 as cv
import numpy as np
from PIL import Image

#无填充旋转
def rotation1_demo():
    src = cv.imread("lena.jpg")
    h, w, c= src.shape
    #定义矩阵
    m=np.zeros((2,3),dtype=np.float32)
    #定义角度
    alpha = np.cos(np.pi / 4.0)
    beta = np.sin(np.pi / 4.0)
    print("alpha : ",alpha)
    #初始化矩阵
    m[0,0] = alpha
    m[1,1] = alpha
    m[0,1] = beta
    m[1,0] = -beta
    cx = w/ 2
    cy = h/ 2
    tx = (1-alpha)*cx - beta*cy
    ty = beta*cx +(1-alpha)*cy
    m[0,2]= tx
    m[1,2]= ty
    #执行旋转
    dst =cv.warpAffine(src, m,(w,h))
    cv.imshow( "rotate-center-demo1", dst)
    cv.waitKey(0)
    cv.destroyAllWindows()

#有填充旋转
def rotation2_demo():
    src = cv.imread("lena.jpg")
    h, w, c= src.shape
    #定义矩阵
    m=np.zeros((2,3),dtype=np.float32)
    #定义角度
    alpha = np.cos(np.pi / 4.0)
    beta = np.sin(np.pi / 4.0)
    print("alpha : ",alpha)
    #初始化矩阵
    m[0,0] = alpha
    m[1,1] = alpha
    m[0,1] = beta
    m[1,0] = -beta
    cx = w/ 2
    cy = h/ 2
    tx=(1-alpha)*cx - beta*cy
    ty = beta*cx +(1-alpha)*cy
    m[0,2]= tx
    m[1,2]= ty
    # change with full size
    bound_w = int(h * np.abs(beta) + w * np.abs(alpha))
    bound_h = int(h * np.abs(alpha) + w * np.abs(beta))

    # 添加中心位置迁移
    m[0, 2] += bound_w / 2 - cx
    m[1, 2] += bound_h / 2 - cy
    dst = cv.warpAffine(src, m, (bound_w, bound_h))
    cv.imshow("rotate without cropping", dst)
    cv.waitKey(0)
    cv.destroyAllWindows()

#或者利用PIL旋转达成以上效果
def rotation3_demo():
    src = Image.open("lena.jpg")
    src.rotate(45).save("lena_rotate.jpg")
    src.rotate(45).show()
    src.rotate(45, expand=True).save("lena_rotate_expand1.jpg")
    src.rotate(45, expand=True).show()
    

if __name__=="__main__":
    rotation3_demo()

1. 视频文件/摄像头使用

import cv2 as cv
import numpy as np

def video_demo():
    # 创建视频捕获对象
    cap = cv.VideoCapture(0)
    # 循环读取视频帧
    while True:
        # 读取视频帧
        ret, frame = cap.read()
        # 将帧水平翻转
        frame = cv.flip(frame, 1)
        # 如果读取到视频帧
        if ret:
            # 将帧显示出来
            cv.imshow("video", frame)
            # 等待按键，如果按下ESC键，则退出循环
            c = cv.waitKey(10)
            if c == 27: 
                break

    # 销毁所有窗口
    cv.destroyAllWindows()

if __name__=="__main__":
    # 调用视频演示函数
    video_demo()

1. 视频处理与保存

文件超过2G可能会出现问题

import cv2 as cv
import numpy as np

def video_demo():
   # 创建视频捕获对象
    cap = cv.VideoCapture("./0.1-Flask介绍与安装.mp4")
    # 获取视频帧的宽、高、帧率
    w = cap.get(cv.CAP_PROP_FRAME_WIDTH)
    h = cap.get(cv.CAP_PROP_FRAME_HEIGHT)
    fps = cap.get(cv.CAP_PROP_FPS)
    print(w, h, fps)
    # out = cv.VideoWriter("./0.1-Flask介绍与安装_out.mp4", cv.VideoWriter_fourcc('P','M','I','1'), fps, (int(w), int(h)),True)
    out = cv.VideoWriter("./out.mp4", cv.CAP_ANY,np.int(cap.get(cv.CAP_PROP_FOURCC)), fps, (np.int(w), np.int(h)),True)
    # 创建视频写入对象，编码格式为MP4，帧率为fps，宽为w，高为h，为真表示写入
    out = cv.VideoWriter("./0.1-Flask介绍与安装_out.mp4", cv.VideoWriter_fourcc('P','M','I','1'), fps, (int(w), int(h)),True)
    # 循环读取视频帧
    while True:
        # 读取视频帧
        ret, frame = cap.read()
        # 如果读取到视频帧
        if ret is not True:
            break
            # 将帧显示出来
        cv.imshow("video", frame)
        # 将帧写入视频写入对象
        out.write(frame)
        #等待按键，如果按下ESC键，则退出循环
        c = cv.waitKey(10)
        if c == 27: 
            cv.destroyAllWindows()
            break
    # 释放视频写入对象
    out.release()
    # 释放视频捕获对象
    cap.release()

if __name__=="__main__":
    # 调用视频演示函数
    video_demo()

1. 图像直方图

import cv2 as cv
from matplotlib import pyplot as plt
import numpy as np

def image_hist_demo():
    # 加载图像
    image = cv.imread("./lena.jpg")
    # 显示图像
    cv.imshow("input", image)
    # 定义颜色列表
    color = ['blue','green','red']
    # 遍历颜色列表
    for i,color in enumerate(color):
        # 计算图像中每个通道的直方图
        hist = cv.calcHist([image], [i], None, [256], [0,256])
        # 打印直方图
        print(hist)
        # 绘制直方图
        plt.plot(hist, color=color)
        # 设置x轴范围
        plt.xlim([0,256])
    # 显示直方图
    plt.show()
    # 等待按键
    cv.waitKey(0)
    # 销毁窗口
    cv.destroyAllWindows()
if __name__=="__main__":
    image_hist_demo()

1. 二维直方图

反向投影、对象跟踪

import cv2 as cv
from matplotlib import pyplot as plt
import numpy as np

def image_hist2d_demo():
    image = cv.imread("./lena.jpg")
    # 将图像从BGR转换为HSV
    hsv = cv.cvtColor(image, cv.COLOR_BGR2HSV)
    # 计算HSV图像的直方图，第一个参数为HSV图像，第二个参数为通道，第三个参数为bin的个数，第四个参数为范围
    hist = cv.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
    # 将直方图的尺寸调整为600*400
    dst = cv.resize(hist, (600, 400))
    # 将直方图归一化，第一个参数为直方图，第二个参数为归一化的最大值，第三个参数为归一化的最小值，第四个参数为归一化的类型
    cv.normalize(dst, dst, 0, 255, cv.NORM_MINMAX)
    # 将HSV图像显示出来
    cv.imshow("image", image)
    # 将直方图转换为彩色图，第一个参数为uint8类型的直方图，第二个参数为颜色映射
    dst = cv.applyColorMap(np.uint8(dst), cv.COLORMAP_JET)
    # 将彩色图显示出来
    cv.imshow("hist", dst)
    # 将彩色图显示出来，第一个参数为彩色图，第二个参数为插值方式
    plt.imshow(dst, interpolation='nearest')
    # 设置标题
    plt.title('2D Histogram')
    # 显示图片
    plt.show()
    # 等待按键
    cv.waitKey(0)
    # 销毁所有窗口
    cv.destroyAllWindows()

if __name__=="__main__":
    image_hist2d_demo()

1. 直方图均衡化

提升对比度

import cv2 as cv

# 定义一个函数image_eqhist_demo，用于演示直方图均衡化
def image_eqhist_demo():
    # 读取图片，并转换为灰度图
    image = cv.imread("./dog.png",cv.IMREAD_GRAYSCALE)
    # 显示输入图片
    cv.imshow("input",image)
    # 对图片进行直方图均衡化
    result = cv.equalizeHist(image)
    # 显示直方图均衡后的图片
    cv.imshow("equalHist",result)
    cv.waitKey(0)
    cv.destroyAllWindows()

if __name__=="__main__":
    image_eqhist_demo()

1. 图像卷积操作

抑制高低噪声

import cv2 as cv

def conv_demo():
    # 加载图片
    image = cv.imread("./dog.png")
    # 显示图片
    cv.imshow("input", image)
    # 对图片进行模糊处理
    result = cv.blur(image, (15, 15), 0)
    # 显示模糊后的图片
    cv.imshow("output", result)
    # 等待按键按下
    cv.waitKey(0)
    # 销毁所有窗口
    cv.destroyAllWindows()

if __name__=="__main__":
    conv_demo()

1. 高斯模糊

import cv2 as cv

def Gaussian_conv_demo():
    # 加载图片
    image = cv.imread("./dog.png")
    # 显示图片
    cv.imshow("input", image)
    # 对图片进行高斯模糊处理,高斯核函数必须为奇数如：（15，15）
    result1 = cv.GaussianBlur(image, (15, 15), 0)
    result2 = cv.GaussianBlur(image, (0, 0), 15)
    # 显示模糊后的图片
    cv.imshow("output1", result1)
    cv.imshow("output2", result2)
    # 等待按键按下
    cv.waitKey(0)
    # 销毁所有窗口
    cv.destroyAllWindows()

if __name__=="__main__":
    Gaussian_conv_demo()

1. 高斯双边模糊

效果类似于ps磨皮

import cv2 as cv

def Gaussian_conv_demo():
    # 加载图片
    image = cv.imread("./dog.png")
    # 显示图片
    cv.imshow("input", image)
    result = cv.bilateralFilter(image, 0, 100, 15)
    cv.imshow("output", result)
    # 等待按键按下
    cv.waitKey(0)
    # 销毁所有窗口
    cv.destroyAllWindows()

if __name__=="__main__":
    Gaussian_conv_demo()

1. 案例:实时人脸检测

import cv2 as cv

model_bin = "D:/pytorch/test/opencv_tutorial_data-master/models/face_detector/opencv_face_detector_uint8.pb"
config_text = "D:/pytorch/test/opencv_tutorial_data-master/models/face_detector/opencv_face_detector.pbtxt"

def video_detection():
    # load tensorflow model
    net = cv.dnn.readNetFromTensorflow(model_bin, config=config_text)
    capture = cv.VideoCapture("D:/pytorch/test/opencv_tutorial_data-master/images/example_dsh.mp4")

    # 人脸检测
    while True:
        e1 = cv.getTickCount()
        ret, frame = capture.read()
        if ret is not True:
            break
        h, w, c = frame.shape
        blobImage = cv.dnn.blobFromImage(frame, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False)
        net.setInput(blobImage)
        cvOut = net.forward()

        # Put efficiency information.
        t, _ = net.getPerfProfile()
        label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())

        # 绘制检测矩形
        for detection in cvOut[0,0,:,:]:
            score = float(detection[2])
            objIndex = int(detection[1])
            if score > 0.5:
                left = detection[3]*w
                top = detection[4]*h
                right = detection[5]*w
                bottom = detection[6]*h

                # 绘制
                cv.rectangle(frame, (int(left), int(top)), (int(right), int(bottom)), (255, 0, 0), thickness=2)
                cv.putText(frame, "score:%.2f"%score, (int(left), int(top)), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
        e2 = cv.getTickCount()
        fps = cv.getTickFrequency() / (e2 - e1)
        cv.putText(frame, label + (" FPS: %.2f"%fps), (10, 50), cv.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2)
        cv.imshow('face-detection-demo', frame)
        c = cv.waitKey(1)
        if c == 27:
            break
    cv.destroyAllWindows()


if __name__ == "__main__":
    video_detection()