CV学习笔记（综合）

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

def extrace_object_demo(image):
    capture=cv.VideoCapture("")  #输入视频地址
    while(True):
        ret,frame=capture.read()
        if ret==False:
            break
        hsv=cv.cvtColor(frame,cv.COLOR_BGR2HSV)  #RGB转换到HSV
        lower_hsv=np.array([37,43,46])
        high_hsv=np.array([77,255,255])

        mask=cv.inRange(hsv,lowerb=lower_hsv,upperb=high_hsv)  #像素值处于（lower_hsv，high_hsv）保留，其他置零
        cv.imshow("video",frame)
        cv.imshow("ss",mask)
        c=cv.waitKey(40)
        if c==27:
            break

def color_space_demo(image):  #常用图像格式转换
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    cv.imshow("gray",gray)
    cv.waitKey(0)
    hsv=cv.cvtColor(image,cv.COLOR_BGR2HSV)
    cv.imshow("hsv",hsv)
    cv.waitKey(0)
    yuv=cv.cvtColor(image,cv.COLOR_BGR2YUV)
    cv.imshow("yuv", yuv)
    cv.waitKey(0)
    ycrcb=cv.cvtColor(image,cv.COLOR_BGR2YCrCb)
    cv.imshow("ycrcb", ycrcb)
    cv.waitKey(0)

def add_demo(m1,m2):   #像素运算，前提是图像形状一致
    dst=cv.add(m1,m2)
    cv.imshow("add_demo",dst)

def substract_demo(m1,m2):  #矩阵像素相减
    dst=cv.subtract(m1,m2)
    cv.imshow("substract_Demo",dst)

def divide_demo(m1,m2):
    dst=cv.divide(m1,m2)  #除法运算
    cv.imshow("divide_demo",dst)

def others(m1,m2):
    h,w=m1.shape[:2]
    img=np.zeros([h,w],np.uint8)
    m,dev=cv.meanStdDev(img)  #计算均值、方差

def logic_demo(m1,m2):
    dst=cv.bitwise_and(m1,m2)  #逻辑与
    cv.imshow(dst)
    dst=cv.bitwise_not(m2)
    cv.imshow(dst)
    dst = cv.bitwise_or(m1, m2)
    cv.imshow(dst)
    dst = cv.bitwise_xor(m1, m2)
    cv.imshow(dst)

def contrast_brightness_demo(image,c,b):
    h,w,ch=image.shape[:2]
    blank=np.zeros([h,w,ch],image.dtype)
    dst=cv.addWeighted(image,c,blank,1-c,b)  # 图像融合（image，权重，image，权重）
    cv.imshow(dst)

def fill_color_demo(image):
    copyImage=image.copy()
    h,w=image.shape[:2]
    print(image.shape)
    mask=np.zeros([h+2,w+2],np.uint8)
    #mask:该版本特有的掩膜。 单通道，8位，在长宽上都比原图像image多2个像素点
    cv.floodFill(copyImage,mask,(30,30),(0,255,255),(100,100,100),(50,50,50),cv.FLOODFILL_FIXED_RANGE)
    # (image, mask, seedPoint起点, newVal填充颜色, loDiff=None, upDiff=None, flags=None)
    #CV_FLOODFILL_FIXED_RANGE 时，待处理的像素点与种子点作比较，在范围之内，则填充此像素
    #CV_FLOODFILL_MASK_ONLY 此位设置填充的对像， 若设置此位，则mask不能为空，此时，函数不填充原始图像img，而是填充掩码图像.
    cv.imshow("fill_color_demo",copyImage)

def fill_binary():
    image=np.zeros([400,400,3],np.uint8)
    image[100:300,100:300,:]=255
    cv.imshow("fill_binary",image)
    mask=np.ones([402,402,1],np.uint8)
    mask[101:301,101:301]=0
    cv.floodFill(image,mask,(200,200),(0,0,255),cv.FLOODFILL_MASK_ONLY)
    # CV_FLOODFILL_MASK_ONLY 此位设置填充的对像， 若设置此位，则mask不能为空，此时，函数不填充原始图像img，而是填充掩码图像.
    cv.imshow("fill ",image)
#fill_binary()
def blur_demo(image):  #均值模糊
    dst=cv.blur(image,(1,3),)
    cv.imshow("blur_demo",dst)

def median_blur_demo(image):   #中值模糊
    dst=cv.medianBlur(image,5)
    cv.imshow("blur_demo", dst)

def clamp(pv):  #限定值函数
    if pv>255:
        return 255
    if pv<0:
        return 0
    else:
        return pv

def gaussion_noise(image):  #高斯噪声
    h,w,c=image.shape
    for row in range(h):
        for col in range(w):
            s=np.random.normal(0,20,3)
            b=image[row,col,0]
            g = image[row, col, 1]
            r = image[row, col, 2]
            image[row,col,0]=clamp(b+s[0])
            image[row, col, 1] = clamp(g + s[1])
            image[row, col, 2] = clamp(r + s[2])
    cv.imshow("gaussion_noise",image)

def bi_demo(image):  #能在保持边界清晰的情况下有效的去除噪音
    dst=cv.bilateralFilter(image,0,100,15)
    # 邻域直径，空间高斯函数标准差，灰度值相似性高斯函数标准差
    cv.imshow("bi_demo",dst)

def shift_demo(image):  #EPF边缘保留滤波
    dst=cv.pyrMeanShiftFiltering(image,10,50)
    #dst=cv.pyrMeanShiftFiltering(src,sp,sr,dst,maxLevel=None,termcrit=None)

    cv.imshow("shift_demo",dst)

def plot_demo(image):   #像素统计成直方图
    plt.hist(image.ravel(),256,[0,256],)  #ravel方法就是以后个降维的作用
    plt.show()

def image_hist(image):
    color=('blue','green','red')
    for i,color in enumerate(color):
        hist=cv.calcHist(image,[i],None,[256],[0,256])
        #（src，channle，mask，灰度级的个数，像素范围）
        plt.plot(hist,color=color)
        plt.xlim([0,256])
    plt.show()

def equalHist_demo(image):  #增强图像
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    dst=cv.equalizeHist(gray)
    cv.imshow("equalHist_demo",dst)

def clahe_demo(image):
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    cv.imshow("gray",gray)
    clahe=cv.createCLAHE(clipLimit=2.0,tileGridSize=(8,8))
    # 直方图均衡化，参数似乎固定，定义一个clach算子
    dst=clahe.apply(gray)#计算
    cv.imshow("clahe_demo",dst)

def create_rgb_hist(image):#有问题
    h,w,c= image.shape
    rgbHist =np.zeros([16*16*16,1],np.float32)
    bsize =256/16
    for row in range(h):
        for col in range(w):
            b = image[row, col, 0]
            g = image[row, col, 1]
            r = image[row, col, 2]
            index = np.int(b/bsize)*16*16 + np.int(g/bsize)*16 + np.int(r/bsize)
            rgbHist[np.int(index),0] =rgbHist[np.int(index),0] + 1
    return rgbHist

def hist_compare(image1,image2):
    hist1=creat_rgb_hist(image1)
    hist2=creat_rgb_hist(image2)
    match1=cv.compareHist(hist1,hist2,cv.HISTCMP_BHATTACHARYYA)
    match2=cv.compareHist(hist1,hist2,cv.HISTCMP_CORREL)
    match3 = cv.compareHist(hist1, hist2, cv.HISTCMP_CHISQR)
    print("巴氏距离：%s，相关性：%s，卡方：%s"%(match1,match2,match3))
    # 巴氏距离：越小越相似# 相关性：越接近于1越相似# 卡方：越小越相似
    cv.imshow("gaussion_noise",image)

def hist2d_demo(image):
    hsv=cv.cvtColor(image,cv.COLOR_BGR2HSV)
    hist=cv.calcHist([image],[0,1],None,[180,256],[0,180,0,256])
    # （src，channle，mask，灰度级的个数，像素范围）
    plt.imshow(hist,interpolation='nearest') #一种插值方式
    plt.title("hist2d_demo")
    plt.show()

def back_projection_demo():
    sample=cv.imread("")
    target=cv.imread("")

    roi_hsv=cv.cvtColor(sample,cv.COLOR_BGR2HSV)
    target_hsv=cv.cvtColor(target,cv.COLOR_BGR2HSV)
    cv.imshow("sample",sample)
    cv.imshow("target", target)

    roiHist=cv.calcHist(roi_hsv,[0,1],None,[180,256],[0,180,0,256])
    cv.normalize(roi_hsv,roiHist,0,255,cv.NORM_MINMAX)
    #cv.normalize(src,dst,alpha=range normalization模式的最小值,
    # beta=range normalization模式的最大值，不用于norm normalization(范数归一化)模式。
    # ,norm_type=NORM_MINMAX:数组的数值被平移或缩放到一个指定的范围，线性归一化，一般较常用。
    # ,dtype=,mask=)
    dst=cv.calcBackProject([target_hsv],[0,1],roiHist,[0,180,0,256],1)
    #通道数必须与直方图维度相匹配
    cv.imshow("back_projection_demo",dst)

def template_demo(image1,image2):  #模式匹配
    tpl=cv.imread(image1)  #目标图形
    target=cv.imread(image2)
    methods=[cv.TM_SQDIFF_NORMED,cv.TM_CCOEFF_NORMED,cv.TM_CCORR_NORMED]  #三种计算匹配相似度的算法
    th,tw=tpl.shape[:2]
    for md in methods:
        result=cv.matchTemplate(target,tpl,md)  #计算相似度
        min_val,max_val,min_loc,max_loc=cv.minMaxLoc(result)  #寻找max min位置
        if md==cv.TM_SQDIFF_NORMED:
            tl=min_loc
        else:
            tl=max_loc
        br=[tl[0]+tw,tl[1]+th]
        cv.rectangle(target,tl,br,(0,0,255),2)
        cv.imshow("match"+np.str(md),target)

def threshold(image):
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY|cv.THRESH_OTSU)
    print(ret)
    cv.imshow("threshold",binary)

def local_threshold(image):
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    binary=cv.adaptiveThreshold(gray,255,cv.ADAPTIVE_THRESH_MEAN_C,cv.THRESH_BINARY,25,10)
    cv.imshow("local_threshold",binary)

def pyramid_demo(image):
    level=3
    temp=image.copy()
    pyramid_images=[]
    for i in range(level):
        dst=cv.pyrDown(temp)
        pyramid_images.append(dst)
        cv.imshow("pyrDown_"+str(i),dst)
        temp=dst.copy()
    return pyramid_images

def lapalian_demo(image):
    pyramid_images=pyramid_demo(image)
    level=len(pyramid_images)
    print(level)
    for i in range(level-1,-1,-1):
        if (i-1)<0:
            exappend=cv.pyrUp(pyramid_images[i],dstsize=image.shape[:2])
            lpls=cv.subtract(image,exappend)
            cv.imshow("lapalian_demo_"+str(i),lpls)
        else:
            exappend = cv.pyrUp(pyramid_images[i], dstsize=pyramid_images[i - 1].shape[:2])
            lpls = cv.subtract(pyramid_images[i - 1], exappend)
            cv.imshow("lapalian_demo_" + str(i), lpls)

def sobel_demo(image):
    grad_x=cv.Scharr(image,cv.CV_32F,1,0)
    grad_y = cv.Scharr(image, cv.CV_32F, 0, 1)
    gradx=cv.convertScaleAbs(grad_x)
    grady=cv.convertScaleAbs(grad_y)
    cv.imshow("grad_x",gradx)
    cv.imshow("grad_y", grady)

    gradxy=cv.addWeighted(grad_x,0.5,grad_y,0.5,0)
    cv.imshow("gradxy",gradxy)

def lapalian_demo(image):
    dst=cv.Laplacian(image,cv.CV_32F)
    lpls=cv.convertScaleAbs(dst)
    cv.imshow("lapalian_demo",lpls)

#Canny算法：高斯模糊、灰度转换、计算梯度、非最大信号抑制、高低阈值输出二值图像
def edge_demo(image):
    blurred=cv.GaussianBlur(image,(3,3),0)
    gray=cv.cvtColor(blurred,cv.COLOR_BGR2GRAY)
    xgrad=cv.Sobel(gray,cv.CV_16SC1,1,0)
    ygrad = cv.Sobel(gray, cv.CV_16SC1, 0, 1)
    edge_output=cv.Canny(xgrad,ygrad,50,150)
    cv.imshow("edge_demo",edge_output)

    dst=cv.bitwise_and(image,image,mask=edge_output)
    cv.imshow("color",dst)
    return edge_output

def line_detection_demo(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    edges = cv.Canny(gray, 50, 150, apertureSize=3)
    lines = cv.HoughLines(edges, 1, np.pi/180, 200)
    print(type(lines))
    # 函数将通过步长为1的半径和步长为π/180的角来搜索所有可能的直线
    for line in lines:
        rho, theta = line[0]  # line[0]存储的是点到直线的极径和极角，其中极角是弧度表示的
        a = np.cos(theta)   # theta是弧度
        b = np.sin(theta)
        x0 = a * rho
        y0 = b * rho
        x1 = int(x0 + 1000 * (-b))  # 直线起点横坐标
        y1 = int(y0 + 1000 * (a))   # 直线起点纵坐标
        x2 = int(x0 - 1000 * (-b))  # 直线终点横坐标
        y2 = int(y0 - 1000 * (a))   # 直线终点纵坐标
        cv.line(image, (x1, y1), (x2, y2), (0,255, 0), 2)
    cv.imshow("image_lines", image)

def line_detect_possoble(image):  #直线检测
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    edges = cv.Canny(gray, 50, 150, apertureSize=3)
    lines = cv.HoughLinesP(edges, 1, np.pi / 180, 100,minLineLength=50,maxLineGap=10)
    for line in lines:
        # print(lines)
        x1,y1,x2,y2=line[0]
        cv.line(image, (x1, y1), (x2, y2), (0,255, 0), 2)
    cv.imshow("line_detect_possoble",image)

def detect_circles_demo(image):
    cv.pyrMeanShiftFiltering(image,10,100)
    cimage = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    circles = cv.HoughCircles(cimage,cv.HOUGH_GRADIENT,1,20,param1=50,param2=30)
    circles=np.uint16(np.around(circles))
    for i in circles[0,:]:
        cv.circle(image,(i[0],i[1]),i[2],(0,0,255),2)
        cv.circle(image,(i[0],i[1]),2,(255,0,0),2)
    cv.imshow("detect_circles_demo",image)

def contours_demo(image):  #边缘检测
    # gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    # ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY|cv.THRESH_OTSU)

    # binary=edge_demo(image)

    contours, hierarchy=cv.findContours(binary,cv.RETR_EXTERNAL,cv.CHAIN_APPROX_SIMPLE)
    for i,contours in enumerate(contours):
        #print(contours)
        cv.drawContours(image,contours,-1,(0,0,255),2)#填充2-》-1
        # 第三个参数指定绘制轮廓list中的哪条轮廓，如果是 - 1，则绘制其中的所有轮廓
        print(i)
    cv.imshow("contours_demo",image)

def measure_object(image):
    dst=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    ret,binary=cv.threshold(dst,0,255,cv.THRESH_BINARY|cv.THRESH_OTSU)
    # ret：True或False，代表有没有读到图片；
    # dst：binary 目标图像；
    cv.imshow("threshold",binary)
    gray_rgb=cv.cvtColor(binary,cv.COLOR_GRAY2RGB)
    contours, hierarchy = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    # cv2.RETR_EXTERNAL表示只检测外轮廓 .RETR_LIST检测的轮廓不建立等级关系
    # cv2.CHAIN_APPROX_NONE存储所有的轮廓点，相邻的两个点的像素位置差不超过1
    # cv2.CHAIN_APPROX_SIMPLE压缩水平方向，垂直方向，对角线方向的元素，只保留该方向的终点坐标
    # cv2.findContours()函数返回两个值，一个是轮廓本身，还有一个是每条轮廓对应的属性。
    for i, contour in enumerate(contours):
        area=cv.contourArea(contour) #计算轮廓面积
        x,y,w,h=cv.boundingRect(contour)#得出轮廓的个点坐标
        rate=min(w,h)/max(contour)
        print(rate)
        mm=cv.moments(contour)

        cx = mm["m10"] / mm["m00"]#图像重心坐标（cx，cy）
        cy = mm["m01"] / mm["m00"]
        cv.circle(image,(np.int(cx),np.int(cy)),3,(0,0,255),-1)
        cv.rectangle(image,(x,y),(x+2,y+h),(0,0,255),2)
        approx=cv.approxPolyDP(contour,4,True)#把一个连续光滑曲线折线化
        # curve：输入曲线，数据类型可以为vector < Point >。
        # approxCurve：输出折线，数据类型可以为vector < Point >。
        # epsilon：判断点到相对应的line
        # 的距离的阈值。（距离大于此阈值则舍弃，小于此阈值则保留，epsilon越小，折线的形状越“接近”曲线。）
        # closed：曲线是否闭合的标志位。
        print(approx.shape)
        if approx.shape[0]>10:
            cv.drawContours(gray_rgb,contours,i,(0,0,255),2)
        if approx.shape[0]>6:
            cv.drawContours(gray_rgb,contours,i,(255,0,255),2)
    cv.imshow("measure_object",image)

def erode_demo(image):#腐蚀
    print(image.shape)
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel=cv.getStructuringElement(cv.MORPH_RECT,(3,3))
    dst=cv.erode(binary,kernel)
    cv.imshow("erode_demo",dst)

def dilate_demo(image):#膨胀
    print(image.shape)
    gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel=cv.getStructuringElement(cv.MORPH_RECT,(3,3))
    dst=cv.dilate(binary,kernel)
    cv.imshow("dilate_demo",dst)

def open_demo(image):   #开运算：先腐蚀后膨胀，开运算可以用来消除小的块，纤细点处分离物体，并在平滑较大的物体边界的同事不明显的改变其面积
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel=cv.getStructuringElement(cv.MORPH_RECT,(5,5))
    binary=cv.morphologyEx(binary,cv.MORPH_OPEN,kernel)
    cv.imshow("open_demo",binary)

def close_demo(image):#闭运算：先膨胀后腐蚀，消除小型的黑洞，
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel=cv.getStructuringElement(cv.MORPH_RECT,(15,15))
    binary=cv.morphologyEx(binary,cv.MORPH_CLOSE,kernel)
    cv.imshow("close_demo",binary)

def top_hat_demo(image):#顶帽：原图像与开操作差值图像
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    kernel=cv.getStructuringElement(cv.MORPH_RECT,(5,5))
    # 返回指定形状和尺寸的结构元素。
    # 这个函数的第一个参数表示内核的形状，有三种形状可以选择。
    # 矩形：MORPH_RECT;
    # 交叉形：MORPH_CROSS;
    # 椭圆形：MORPH_ELLIPSE;

    dst=cv.morphologyEx(gray,cv.MORPH_TOPHAT,kernel)#进行各类形态学的变化
    # src传入的图片
    # op进行变化的方式
    # kernel表示方框的大小

    cimage=np.array([gray.shape,np.uint8])#提升亮度
    cimage=100
    cv.add(dst,cimage)

    cv.imshow("top_hat_demo",dst)


def hat_gray_demo(image):  # 灰帽
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))  # 改变第一个参数即可进行其他形态学操作
    dst = cv.morphologyEx(binary, cv.MORPH_TOPHAT, kernel)
    cv.imshow("top_hat_demo", dst)

def hat_binary_demo(image):  # 灰帽
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(dst, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))  # 改变第一个参数即可进行其他形态学操作
    dst = cv.morphologyEx(binary, cv.MORPH_GRADIENT, kernel)
    cv.imshow("top_hat_demo", dst)

#基于距离的分水岭算法：灰度、二值、距离变换、寻找种子、生成marker、分水岭变换、输出
def watershed_demo(src):
   # print(src.shape)
    blurred = cv.pyrMeanShiftFiltering(src, 10, 100) #边缘保留滤波去噪
    # 灰度二值化
    gray = cv.cvtColor(blurred, cv.COLOR_BGR2GRAY) #转化为灰度图
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU) #二值化
    cv.imshow("binary-image", binary)

    # 形态学操作
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3)) #构造结构
    mb = cv.morphologyEx(binary, cv.MORPH_OPEN, kernel, iterations=2)
    sure_bg = cv.dilate(mb, kernel, iterations=3)
    cv.imshow("mor-opt", sure_bg)

    # 距离转换
    dist = cv.distanceTransform(mb, cv.DIST_L2, 3)#距离变化（提取出我们确信它们是硬币的区域）
    dist_output = cv.normalize(dist, 0, 1.0, cv.NORM_MINMAX)#归一化
    dist_output1 = np.uint8(dist_output)


    ret, surface = cv.threshold(dist, dist.max()*0.6, 255, cv.THRESH_BINARY)

    surface_fg = np.uint8(surface)#将float类型转化为uint
    cv.imshow("surface-bin", surface_fg)
    unknown = cv.subtract(sure_bg, surface_fg)#除种子以外的区域（剩下的区域是我们不知道的区域，无论是硬币还是背景.分水岭算法应该找到它）
    ret, markers = cv.connectedComponents(surface_fg)
    #求连通区域（创建标记：它是一个与原始图像相同大小的数组，但使用int32数据类型，并对其内部的区域进行标记.）
    # watershed transform 分水岭变换
    markers = markers + 1 # Add one to all labels so that sure background is not 0, but 1
    markers[unknown==255] = 0 #  mark the region of unknown with zero
    markers = cv.watershed(src, markers=markers)
    src[markers==-1] = [0, 0, 255]#标记
    cv.imshow("result", src)

def face_detect_demo(image):
    cv.CascadeClassifier()


src = cv.imread("E:\\BaiduNetdiskDownload\\opencv-python\\coins.jpg")
cv.namedWindow("imput image",cv.WINDOW_AUTOSIZE)
cv.imshow("imput image",src)

watershed_demo(src)
#threshold(src)

# b,g,r=cv.split(src)
# cv.imshow("blue",b)
##ROI操作
# face=src[50:250,100:300]
# gray=cv.cvtColor(face,cv.COLOR_BGR2GRAY)
# backface=cv.cvtColor(gray,cv.COLOR_GRAY2RGB)
# src[50:250,100:300]=backface
# cv.imshow("a",src)

#fill_color_demo(src)
# src[:,:,0]=0
# src=cv.merge([b,g,r])
#blur_demo(src)

cv.waitKey(0)
# color_space_demo(src)
cv.destroyAllWindows()

本文地址：https://blog.csdn.net/weixin_46612732/article/details/107311143