[人工智能]python图片信息-2cv2-高阶处理

一：cv2图片间运算

单个通道值用一个无符号字节(numpy.uint8)表示，其值范围在0-255以内，若是图像像素通道值超出范围时，OpenCV的饱和运算机制会将小于0的通道值置为0，大于255的置为255。但这种机制在某些状况下会致使图像像素通道值大范围的被置为255或0

1> 相加

1. 源码解析

add(src1, src2, dst=None, mask=None, dtype=None)
rc1, src2：需要相加的两副大小和通道数相等的图像或一副图像和一个标量（标量即单一的数值）
 dst：可选参数，输出结果保存的变量，默认值为None，如果为非None，输出图像保存到dst对应实参中，其大小和通道数与输入图像相同，图像的深度（即图像像素的位数）由dtype参数或输入图像确认
 mask：图像掩膜，可选参数，为8位单通道的灰度图像，用于指定要更改的输出图像数组的元素，即输出图像像素只有mask对应位置元素不为0的部分才输出，否则该位置像素的所有通道分量都设置为0
 dtype：可选参数，输出图像数组的深度，即图像单个像素值的位数（如RGB用三个字节表示，则为24位）。
 返回值：相加的结果图像

import cv2
from matplotlib import pyplot as plt

img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img1 = cv2.flip(img1,0)#翻转图像
img2 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img = cv2.add(img1,img2)
plt.subplot(131),plt.imshow(img1),plt.title('img1')
plt.subplot(132),plt.imshow(img2),plt.title('img2')
plt.subplot(133),plt.imshow(img),plt.title('imgadd')
plt.show()

如图：

2. cv2.addWeighted(）融合

import cv2
from matplotlib import pyplot as plt

img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img1 = cv2.flip(img1,0)#翻转图像
img2 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img = cv2.addWeighted(img1, 0.6, img2, 0.4, 0)
plt.subplot(131),plt.imshow(img1),plt.title('img1')
plt.subplot(132),plt.imshow(img2),plt.title('img2')
plt.subplot(133),plt.imshow(img),plt.title('imgadd融合')
plt.show()
===========================
重叠后的像素表示： img10.6 + img20.4 + 0 ，0表示重叠的偏置项,当两个预值都为1 时，效果同cv2.add是一样的

3. 三种场景

相同大小和通道数的两个图像数组相加处理
dst(I)=saturate(src1(I)+src2(I))if mask(I)≠0
即目标图像的每个像素，在mask对应位置的值不为0的情况下，该像素每个通道的值等于src1和src2同样位置像素通道的值相加（饱和）。对saturate和src1(I)的理解请参考《opencv图像处理学习随笔：帮助文档运算公式中saturate的含义》

一个图像数组和一个标量相加
dst(I)=saturate(src1(I)+src2)if mask(I)≠0
即目标图像的每个像素，在mask对应位置的值不为0的情况下，该像素每个通道的值等于src1图像的每个像素的每个通道值与标量各值相加（数字化的常量会转成一个代表BGRA的四元组，首元素为该数字值，其他元素为0；如果是四元组则分别相加。下同）

一个标量和一个图像数组相加
dst(I)=saturate(src1+src2(I))if mask(I)≠0
即目标图像的每个像素，在mask对应位置的值不为0的情况下，该像素每个通道的值等于src2图像的每个像素的每个通道值与标量相加;标量还可以用一个与另一个参数对应图像数组的通道数相等元素个数的变量

2> cv2.subtract 减法语法

1.源码解析

subtract(src1, src2, dst=None, mask=None, dtype=None)
============================================
src1：作为被减数的图像数组或一个标量
 src2：作为减数的图像数组或一个标量
 dst：可选参数，输出结果保存的变量，默认值为None，如果为非None，输出图像保存到dst对应实参中，其大小和通道数与输入图像相同，图像的深度（即图像像素的位数）由dtype参数或输入图像确
 mask：图像掩膜，可选参数，为8位单通道的灰度图像，用于指定要更改的输出图像数组的元素，即输出图像像素只有mask对应位置元素不为0的部分才输出，否则该位置像素的所有通道分量都设置为0
 dtype：可选参数，输出图像数组的深度，即图像单个像素值的位数（如RGB用三个字节表示，则为24位）。
 返回值：相减的结果图像

demo

import cv2
from matplotlib import pyplot as plt

img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img1 = cv2.flip(img1,0)#翻转图像
img2 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img = cv2.subtract(img1,img2)
plt.subplot(131),plt.imshow(img1),plt.title('img1')
plt.subplot(132),plt.imshow(img2),plt.title('img2')
plt.subplot(133),plt.imshow(img),plt.title('imgsubtract')
plt.show()

2. 其他四种场景

两个图像矩阵相减, 要求两个矩阵必须有相同大小和通道数
dst(I)=saturate(src1(I)?src2(I))if mask(I)≠0
1个图像矩阵和1个标量相减, 要求src2是标量或者与src1的通道数相同的元素个数，经实际测试应该是一个四元组，如果src1是3通道的，则按通道顺序依次与该四元组的前3个元素相减
dst(I)=saturate(src1(I)?src2)if mask(I)≠0
1个标量和一个图像数组相减, 要求src1是标量或者与src1的通道数相同的元素个数
dst(I)=saturate(src1?src2(I))if mask(I)≠0
在给定值减去矩阵的SubRS情况下，为1个标量和一个图像数组相减的反向差，老猿认为这是第二种场景的一种特殊解读
dst(I)=saturate(src2?src1(I))if mask(I)≠0

3> 乘法

demo

import cv2
from matplotlib import pyplot as plt

img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img1 = cv2.flip(img1,0)#翻转图像
img2 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img = cv2.multiply(img1,img2)
plt.subplot(131),plt.imshow(img1),plt.title('img1')
plt.subplot(132),plt.imshow(img2),plt.title('img2')
plt.subplot(133),plt.imshow(img),plt.title('imgsubtract')
plt.show()

4> 除法

直接上图

3> 均值&方差

1. 均值

import cv2
from matplotlib import pyplot as plt

img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img1 = cv2.flip(img1,0)#翻转图像

(mean , stddv) = cv2.meanStdDev(img1)
print(mean, stddv)
==========================
[[151.67696566]
 [105.14957755]
 [134.47842882]] [[76.64146669]
 [68.60690013]
 [83.47075964]]

4> 逻辑运算

1. 与

import cv2
from matplotlib import pyplot as plt

img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img1 = cv2.flip(img1,0)#翻转图像
img2 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
img =cv2.bitwise_and(img1, img2)
plt.subplot(131),plt.imshow(img1),plt.title('img1')
plt.subplot(132),plt.imshow(img2),plt.title('img2')
plt.subplot(133),plt.imshow(img),plt.title('imgbitwise_and')
plt.show()

任何数值N 与 数值0(二进制为 0000 0000) 进行按位与操作，都会得到数值0
任何数值N 与 数值255(二进制为 1111 1111) 进行按位与操作，都会得到数值N本身
任何数值N 与 其本身进行按位与操作，都会得到数值N 本身

2.或、非、异或

逻辑与运算 cv2.bitwise_add(img1, img2)
逻辑或运算 cv2.bitwise_or(img1, img2)
逻辑非运算 cv2.bitwise_not(img1, img2)
逻辑异或运算 cv2.bitwise_xor(img1, img2)

二：cv2 绘制图像

1> 线段cv2.line()

line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None)
img：原图
pt1, pt2 ：笔划起点的点坐标 由两个点会自动填充为线段

import cv2
import numpy as np

newImageInfo = (500,500,3)  #绘制画布-500像素长，500像素宽，就是x,y轴长度，然后 “3” 指的是RGB三色通道
dst = np.zeros(newImageInfo, np.uint8)
cv2.line(dst, (100, 200), (100, 400), (255, 0, 255), 20, cv2.LINE_4)  # 第一竖
cv2.line(dst, (100, 200), (400, 200), (255, 0, 255), 20, cv2.LINE_4)  # 第二横
cv2.line(dst, (400, 200), (400, 400), (255, 0, 255), 20, cv2.LINE_4)  # 第三折
cv2.line(dst, (100, 300), (400, 300), (255, 0, 255), 20, cv2.LINE_4)  # 第四横
cv2.line(dst, (250, 200), (250, 400), (255, 0, 255), 20, cv2.LINE_4)  # 第五竖
cv2.line(dst, (100, 400), (400, 400), (255, 0, 255), 20, cv2.LINE_4)  # 第六横
# 前两个（）中的为笔划起点的点坐标 20 为两个点会自动填充为线段
cv2.imshow('dst',dst)
cv2.waitKey(0)

2> 圆

1. 正圆

image = cv2.circle(img, center, radius, color, thickness=None, lineType=None, shift=None)

import cv2
import numpy as np
newImageInfo = (500,500,3)  #绘制画布-500像素长，500像素宽，就是x,y轴长度，然后 “3” 指的是RGB三色通道
dst = np.zeros(newImageInfo, np.uint8)
center=(250,250)
radius= 150
dst = cv2.circle(dst, center, radius,[255,0,255], 2, cv2.LINE_AA)  # 第一竖
cv2.imshow('dst',dst)
cv2.waitKey(0)

2. 椭圆

import cv2
import numpy as np
newImageInfo = (500,500,3)  #绘制画布-500像素长，500像素宽，就是x,y轴长度，然后 “3” 指的是RGB三色通道
dst = np.zeros(newImageInfo, np.uint8)
center=(200,200)
axes= (200, 100)
angle = 30
startAngle = 0
endAngle = 0
dst = cv2.ellipse(dst,(256,256),(100,50),0,0,180,255,-1)
cv2.imshow('dst',dst)
cv2.waitKey(0)
==============================
ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness=None, lineType=None, shift=None)
img 		要在上面画线段的图像
center 		椭圆圆的圆心坐标(x,y)
axes 		椭圆的轴长  (长轴长度的一半, 短轴长度的一半)
angle 		椭圆沿水平方向逆时针旋转的角度
startAngle	沿长轴顺时针方向开始显示的角度
endAngle	沿长轴顺时针结束显示的角度
color
thickness 	线段的粗细	cv.FILLED
lineType    线段的类型	产生线的算法
shift 		坐标精确到小数点后第几位

3> 矩形

import cv2
import numpy as np
newImageInfo = (500,500,3)  #绘制画布-500像素长，500像素宽，就是x,y轴长度，然后 “3” 指的是RGB三色通道
dst = np.zeros(newImageInfo, np.uint8)
c1=(100,150)
c2=(400,450)
img=cv2.rectangle(dst, c1, c2, [225, 0, 255], 2, cv2.LINE_AA)
cv2.imshow('dst',img)
cv2.waitKey(0)
======================
img 		要在上面画线段的图像
pt1 		矩形的左上顶点(x,y)
pt2 		矩形的右下顶点(x,y)
color 		线段的颜色
thickness 	线段的粗细	thickness=-1为填充颜色
lineType    线段的类型	产生线的算法
shift 		坐标精确到小数点后第几位

4> 多边形

import cv2
import numpy as np
newImageInfo = (500,500,3)  #绘制画布-500像素长，500像素宽，就是x,y轴长度，然后 “3” 指的是RGB三色通道
dst = np.zeros(newImageInfo, np.uint8)
pts = np.array([[100,50],[200,300],[370,405],[500,100]], np.int32) #四个顶点
pts = pts.reshape((-1,1,2))
img= cv2.polylines(dst, [pts], isClosed=True, color=(255, 255, 0), thickness=2)  # 多边形
cv2.imshow('dst',img)
cv2.waitKey(0)
===================
img 		要在上面画线段的图像
pts 		矢量的列表   pts.shape=(len,1,2)
isClosed 	true代表形成一个封闭的多边形,false代表只是连接各顶点，而非封闭
color
thickness 	线段的粗细	cv.FILLED
lineType    线段的类型	产生线的算法
shift 		坐标精确到小数点后第几位

5> 获取text字体cv2.getTextSize&putText

import cv2
import numpy as np
newImageInfo = (500,1000,3)  #绘制画布-500像素长，500像素宽，就是x,y轴长度，然后 “3” 指的是RGB三色通道
dst = np.zeros(newImageInfo, np.uint8)
text='testdemo'

t_size,_ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, fontScale=2, thickness=3) # 字体尺寸
x1y1=(100,100)# 矩形左上角
x2y2=x1y1[0]+t_size[0],x1y1[1]+t_size[1]# 矩形右下角
x3y3= x1y1[0],x1y1[1]+t_size[1]# 字体尺寸==矩形尺寸，相当于矩形左下角

# putText的输入坐标是左下点  故y2=x1y1[1]-t_size[1]
img= cv2.rectangle(dst, x1y1, x2y2, [255, 255, 255], -1, cv2.LINE_AA)
img = cv2.putText(dst,text,x3y3,cv2.FONT_HERSHEY_SIMPLEX,3,[0, 0, 0], thickness=3, lineType=cv2.LINE_AA)
cv2.imshow('dst',img)
cv2.waitKey(0)
====================
text		需要写入的文本
fontFace	字体类型
fontScale 	字体大小
thickness	字体粗细
返回参数
retval    字体的长、宽
baseLine  基线的高度

三：cv2.threshold()图像二值化

1> 二值化含义

将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的黑白效果的过程；
用意：
图像的二值化使图像中数据量大为减少，从而能凸显出目标的轮廓

2> 全局阈值-cv2.threshold()

import cv2

img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
#二值化处理
ret,im_fixed=cv2.threshold(img,100,255,cv2.THRESH_BINARY)
cv2.imshow('image',im_fixed)
cv2.waitKey(0)

threshold(src, thresh, maxval, type, dst=None)
**.src ：**源图像,必须是单通道 2
thresh： 分类阈值
maxval ：高于（低于）阈值时赋予的新值
type ：阈值处理模式

3> cv2.adaptiveThreshold（） 自适应阈值

自适应阈值可以看成一种局部性的阈值，通过规定一个区域大小，比较这个点与区域大小里面像素点的平均值（或者其他特征）的大小关系确定这个像素点是属于黑或者白（如果是二值情况）

adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C, dst=None)

**src:**原始图像
**maxValue:**像素值上限
**adaptiveMethod:**自适应方法Adaptive Method:
**thresholdType：**值的赋值方法：只有cv2.THRESH_BINARY 和cv2.THRESH_BINARY_INV
**blockSize：**Block size:规定领域大小（一个正方形的领域），计算邻域时的领邻域大小，必须为奇数;当blockSize越大，参与计算阈值的区域也越大，细节轮廓就变得越少，整体轮廓越粗越明显
**C：**常数C，阈值等于均值或者加权值减去这个常数,得到的就是最终阈值。当C越大，每个像素点的N*N邻域计算出的阈值就越小，中心点大于这个阈值的可能性也就越大，设置成255的概率就越大，整体图像白色像素就越多，反之亦然。

import cv2 as cv
from matplotlib import pyplot as plt

def threshold_adaptive(image):

    img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    # 中值滤波
    img = cv.medianBlur(img, 5)

    ret, th1 = cv.threshold(img, 127, 255, cv.THRESH_BINARY)
    # 11 为 Block size, 2 为 C 值
    th2 = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 11, 2)
    th3 = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2)

    titles = ['Original Image', 'Global Threshold (v = 127)', 'Adaptive Mean Threshold', 'Adaptive Gaussian Threshold']
    images = [img, th1, th2, th3]

    for i in range(4):
        plt.subplot(2, 2, i + 1), plt.imshow(images[i], 'gray')
        plt.title(titles[i])
        plt.xticks([]), plt.yticks([])

    plt.show()

def main():
    path = r'F:\I\Work_referrd_info\some.jpg'
    img = cv.imread(path)
    threshold_adaptive(img)
if __name__ == '__main__':
    main()

四：cv2.VideoCapture()视频功能

截图视屏中每个多少秒的帧数的图片

import cv2
import os
def  main():
    input_path = r'F:\I\Work_referrd_info'   # 第一个输入参数是包含视频片段的路径
    frame_interval = 60 # 第二个输入参数是设定每隔多少帧截取一帧
    filename = r'vido.mp4'#视频文件
    video_prefix = input_path.split(os.sep)[-1]# 获取文件夹名称
    frame_path = r'{}\frames'.format(input_path)# 建立一个新的文件夹frames
    print(frame_path)
    if not os.path.exists(frame_path):
        os.mkdir(frame_path)
    cap = cv2.VideoCapture() # 初始化一个VideoCapture对象
    filepath = os.sep.join([input_path, filename])# 读取文件
    cap.open(filepath)# VideoCapture::open函数可以从文件获取视频
    n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))# 获取视频帧数
    print(n_frames)
    # 同样为了避免视频头几帧质量低下，黑屏或者无关等
    for i in range(42):
        cap.read()
    for i in range(n_frames):
        ret, frame = cap.read()
        # 每隔frame_interval帧进行一次截屏操作
        if i % frame_interval == 0:
            imagename = '{}_{}_{:0>6d}.jpg'.format(video_prefix, filename.split('.')[0], i)
            imagepath = os.sep.join([frame_path, imagename])
            try:
                if frame.shape[2] == 3 :
                    print('exported {}!'.format(imagepath))
                    cv2.imwrite(imagepath, frame)
                else:
                    print('error {}!'.format(imagepath))
            except Exception as e:
                print(e)
    # 执行结束释放资源
    cap.release()

if __name__ == '__main__':
     main()

cap = cv2.VideoCapture() ：初始化一个VideoCapture对象
cap.open(filepath)：VideoCapture::open函数可以从文件获取视频
int(cap.get(cv2.CAP_PROP_FRAME_COUNT))： 获取视频帧数
if i % frame_interval == 0： 对视频帧数遍历，符合帧数进入循环
cv2.imwrite(imagepath, frame)： 重新写入文件
cap.release()： 释放摄像头

其中ret, frame = cap.read()： ret 返回读取信息成功或失败，frame 帧数图片信息矩阵；
判断是否读取成功可用ret 做依据！
修改代码内容

            if ret == True :
                print('exported {}!'.format(imagepath))
                cv2.imwrite(imagepath, frame)
            else:
                print('error {}!'.format(imagepath))

五：色调，明暗，直方图和Gamma曲线

1> 图形平均色调（H），饱和度（S），明度（V）

import cv2
from matplotlib import pyplot as plt
import numpy as np
img1 = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
hsv = cv2.cvtColor(img1, cv2.COLOR_RGB2HSV)
H, S, V = cv2.split(hsv)
print(H, S, V)

## 明度（V）
v = V.ravel()[np.flatnonzero(V)]   #亮度非零的值
average_v  = sum(v)/len(v)
print('明度（V）',average_v)
## 饱和度（S）
s = S.ravel()[np.flatnonzero(S)]
average_s  = sum(s)/len(s)
print('饱和度（S）',average_s)
## 色调（H）
h = H.ravel()[np.flatnonzero(H)]
average_h  = sum(h)/len(h)
print('色调（H）',average_h)

2> 统计直方图函数 calcHist

1. 源码解析

calcHist(images, channels, mask, histSize, ranges, hist=None, accumulate=None)
=========================================================
images : 原始图像
channels : 指定通道
通道编号需要用中括号括起来
输入图像是灰度图时，它的值为[0]
彩色图像可以使[0],[1],[2]分别对应通道B，G，R。
mask : 掩码图像
统计整幅图像的直方图，设为None。
统计图像某一部分的直方图时，需要掩码图像
生成掩码图像
mask = np.zeros(image.shape, np.uint8)
mask[200:400, 200:400] = 255
histSize : BINS的数量
ranges : 像素值返回RANGE
像素值范围，例如：[0, 255]
accumulate : 累计标识
默认值为false
如果被设置为true,则直方图在开始分配时不会被清零
该参数允许从多个对象中计算单个直方图，或者用户实施更新直方图
多个直方图的累计结果，用户对一组图像计算直方图
返回值
hist : 直方图
使用pyplot绘制

2.calcHist生成单chennel灰度图像直方图**

使用calcHist生成灰度图像直方图

import cv2
from matplotlib import pyplot as plt
import numpy as np
img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
hist = cv2.calcHist([img], [1], None, [256], [0, 255])
print(type(hist))
print(hist.size)
print(hist.shape)

plt.plot(hist, color="r")
plt.show()
==================
<class 'numpy.ndarray'>
256
(256, 1)

3. 三个channel 的直方图

三个channel 的直方图

import cv2
from matplotlib import pyplot as plt
import numpy as np
img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
color_list = ['r','b','g']
for i in range(3):
    hist = cv2.calcHist([img], [i], None, [256], [0, 255])
    plt.plot(hist, color=color_list[i])
plt.show()

4. 绘制掩码直方图

import numpy as np
img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg', cv2.IMREAD_GRAYSCALE)
mask = np.zeros(img.shape, np.uint8)
mask[200:400, 200:400] = 255

histMI = cv2.calcHist([img], [0], mask, [256], [0, 255])
histImage = cv2.calcHist([img], [0], None, [256], [0, 255])

plt.plot(histImage)
plt.plot(histMI)
plt.show()

绘制掩码直方图和整图直方图对比

4. 生成掩膜图像

import cv2
from matplotlib import pyplot as plt
import numpy as np
img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg', 0)
img = cv2.flip(img,0)
mask = np.zeros(img.shape, np.uint8)
mask[200:400, 200:400] = 255
img2 = cv2.bitwise_and(img, mask)
cv2.imshow("original", img)
cv2.imshow("mask", mask)
cv2.imshow("img2", img2)
cv2.waitKey()

5. 图像直方图均衡化equalizeHist

import cv2
from matplotlib import pyplot as plt
import numpy as np
img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg', 0)

equ = cv2.equalizeHist(img)

plt.subplot(221)
plt.imshow(img, plt.cm.gray)
plt.axis('off')

plt.subplot(222)
plt.hist(img.ravel(), 256)

plt.subplot(223)
plt.imshow(equ, plt.cm.gray)
plt.axis('off')

plt.subplot(224)
plt.hist(equ.ravel(), 256)

plt.show()

6. pyplot显示彩色图像

import cv2
from matplotlib import pyplot as plt
import numpy as np
img = cv2.imread(r'F:\I\Work_referrd_info\some.jpg')
b,g,r = cv2.split(img)
img2 = cv2.merge([r, g, b])

plt.subplot(121),plt.imshow(img),plt.axis('off')

plt.subplot(122),plt.imshow(img2),plt.axis('off')

plt.show()

7. 应用

理论基础
前提： 如果一幅图像占有全部可能的灰度级，并且均匀分布。
结论： 该图像具有高对比度和多变的灰度色调
外观： 图像细节丰富，质量更高
算法
计算累计直方图
将累计直方图进行区间转换
在累计直方图中，概率相近的原始值，会被处理为相同的值
应用场合
医疗图像处理
车牌识别
人脸识别

六：名词解释

1> 阈值

阙值主要在某些图像处理软件中又称为临界值，或者是差值，
阙值处理：是指提出图像内像素高于一定值或者低于一定值的像素点；cv2中cv2.threshold(),cv2.adaptiveThreshold（）处理图像的像素点；

七： CV2 图像高阶处理

CV2 图像高阶处理-3
https://blog.csdn.net/weixin_42914706/article/details/124222782

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖