16000字+|Python图像处理|OpenCV-Python图像处理（读取显示、绘制矩形直线椭圆圆形文本、多顶点绘制多边形、鼠标事件、调色板、边框绘制，像素操作，缩放平移旋转仿射、直方图、角点）

Python图像处理|OpenCV-Python图像视觉处理

1、OpenCV-Python读取显示图片

import cv2 as cv
# 打印OpenCV版本
print(cv.__version__)
# 加载彩色灰度图像
img = cv.imread('111.jpg', 0)
# 显示图像
cv.imshow('image', img)
# 等待按键，使得窗口可以被关闭
cv.waitKey(0)
# 关闭所有打开的窗口
cv.destroyAllWindows()

2、OpenCV-Python保存图片（按‘s’键保存）

import cv2 as cv
img = cv.imread('111.jpg',0)  # 读取图像为灰度图像
cv.imshow('image',img)  # 显示图像
k = cv.waitKey(0)  # 等待按键
if k == 27:         # 如果按键是ESC
    cv.destroyAllWindows()  # 关闭所有窗口
elif k == ord('s'): # 如果按键是s
    cv.imwrite('new.png',img)  # 保存图像
    cv.destroyAllWindows()  # 关闭所有窗口

3、OpenCV-Python读取图片并使用matplotlib显示图片

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('111.jpg',0)
plt.imshow(img, cmap = 'gray', interpolation = 'bicubic')
plt.xticks([]), plt.yticks([])  # 隐藏 x 轴和 y 轴上的刻度值
plt.show()
 

4、OpenCV-Python绘图——画直线

import numpy as np
import cv2 as cv

# 创建黑色的图像
img = cv.imread('111.jpg',1)

# 绘制一条厚度为5的蓝色对角线
cv.line(img,(0,0),(511,511),(255,0,0),5)

# 显示图像
cv.imshow('image',img)
cv.waitKey(0)

 

5、OpenCV-Python绘图——绘制矩形、直线、椭圆、圆形、文本、多顶点绘制多边形

import numpy as np
import cv2 as cv

# 创建一个512x512像素、3个通道的黑色图像
img = np.zeros((512, 512, 3), np.uint8)

# 绘制一条厚度为5的蓝色对角线
cv.line(img, (0, 0), (511, 511), (255, 0, 0), 5)

# 绘制一个绿色的矩形框，起始点为(384,0)，宽度为128，高度为384
cv.rectangle(img, (384, 0), (510, 128), (0, 255, 0), 3)

# 绘制一个红色的圆形，位置为(447, 63)，半径为63
cv.circle(img, (447, 63), 63, (0, 0, 255), -1)

# 绘制一个绿色的椭圆，中心位置为(256, 256)，长轴长度为100，短轴长度为50
#cv.ellipse(img, (256, 256), (100, 50), 0, 0, 180, 255, -1)
cv.ellipse(img, (256, 256), (100, 50), 0, 0, 360,(0, 255, 0) , -1)

# 构建一个四边形的顶点数组，每个顶点由x和y坐标构成
pts = np.array([[10, 5], [20, 30], [70, 20], [50, 10]], np.int32)
# 将顶点数组重塑为适合绘制多边形的形状
pts = pts.reshape((-1, 1, 2))
# 绘制多边形，设置线段颜色为亮黄色
cv.polylines(img, [pts], True, (0, 255, 255))

# 设置字体和文本属性
font = cv.FONT_HERSHEY_SIMPLEX
# 在图像上写下文本，文本为'OpenCV'，位置为(10, 500)，字体大小为4，文本颜色为白色
cv.putText(img, 'OpenCV', (10, 500), font, 4, (255, 255, 255), 2, cv.LINE_AA)

#显示图像
cv.imshow('image', img)
cv.waitKey(0)

这段代码使用OpenCV库在numpy创建的512x512像素彩色图像上绘制了一系列形状和文本，并最终显示该图像。

1. 创建图像：

img = np.zeros((512, 512, 3), np.uint8)

这里，np.zeros是numpy中的函数，用于创建一个指定大小且所有元素都为0的数组。这里的参数(512, 512, 3)表示创建一个512x512像素的三维数组，其中第三维代表RGB三个颜色通道，所以这是一个彩色图像。np.uint8指定了数组中元素的数据类型，这里是无符号8位整数，适合存储每个颜色通道的值（0-255）。

2. 绘制蓝色对角线：

cv.line(img, (0, 0), (511, 511), (255, 0, 0), 5)

cv.line是OpenCV中的函数，用于在图像上画线。

• img 是目标图像。
• (0, 0) 和 (511, 511) 分别是线段的起点和终点坐标。
• (255, 0, 0) 是RGB三元组，定义了线条的颜色（此处为蓝色）。
• 5 是线条的宽度。

3. 绘制绿色矩形框：

cv.rectangle(img, (384, 0), (510, 128), (0, 255, 0), 3)

cv.rectangle函数用于绘制矩形。

• (384, 0) 是矩形左上角坐标。
• (510, 128) 是矩形右下角坐标。
• (0, 255, 0) 定义矩形边框颜色为绿色。
• 3 指定矩形边框的线条宽度。

4. 绘制红色圆形：

cv.circle(img, (447, 63), 63, (0, 0, 255), -1)

cv.circle函数用于绘制圆形。

• (447, 63) 是圆心坐标。
• 63 是圆的半径。
• (0, 0, 255) 设置圆形边框颜色为红色。
• -1 表示填充整个圆形，若设置为非负数，则表示线条宽度。

5. 绘制绿色椭圆：

cv.ellipse(img, (256, 256), (100, 50), 0, 0, 180, (0,255,0), -1)

cv.ellipse函数用于绘制椭圆。

• (256, 256) 是椭圆中心点坐标。
• (100, 50) 是长轴和短轴的半轴长度。
• 0 和 0 分别是椭圆旋转角度的起始和结束角度（由于两者相等，意味着椭圆不旋转）。
• 180 是绘制的角度范围，即顺时针或逆时针绘制多少度。
• 255 设置椭圆边框颜色为黄色。
• -1 同样表示填充整个椭圆。

6. 绘制多边形：

pts = np.array([[10, 5], [20, 30], [70, 20], [50, 10]], np.int32)
pts = pts.reshape((-1, 1, 2))
cv.polylines(img, [pts], True, (0, 255, 255))

首先创建一个多边形顶点数组pts，包含四组二维坐标。然后重塑此数组以适应cv.polylines函数的要求。

• cv.polylines用于绘制一系列折线或多边形。
• img 是目标图像。
• [pts] 是一个包含多边形顶点坐标的列表，此处只包含一个四边形。
• True 表示封闭多边形（连接最后一个点到第一个点）。
• (0, 255, 255) 设置线条颜色为亮黄色。

7. 添加文本：

font = cv.FONT_HERSHEY_SIMPLEX
cv.putText(img, 'OpenCV', (10, 500), font, 4, (255, 255, 255), 2, cv.LINE_AA)

• cv.putText函数用于在图像上添加文本。
• img 是目标图像。
• ‘OpenCV’ 是要写入的文本内容。
• (10, 500) 是文本左上角的起始坐标。
• font 是设置字体样式，这里使用SIMPLEX字体。
• 4 是字体大小。
• (255, 255, 255) 设置文本颜色为白色。
• 2 是文本线条宽度。
• cv.LINE_AA 表示使用反走样算法绘制文本。

8. 显示图像：

cv.imshow('image', img)
cv.waitKey(0)

• cv.imshow函数用于显示图像窗口，'image’是窗口标题，img是要显示的图像。
• cv.waitKey(0)会暂停程序运行并等待用户按键，当用户按下任意键后关闭图像窗口。0表示无限期等待。6、OpenCV-Python读取显示图片

6、OpenCV-Python鼠标回调函数（鼠标左键双击画圆）

# 导入numpy库并赋予别名np，numpy是一个强大的用于处理数组和矩阵的Python库
import numpy as np

# 导入opencv库并赋予别名cv，opencv是一个开源的计算机视觉和机器学习软件库
import cv2 as cv

# 定义一个名为draw_circle的鼠标回调函数，该函数在OpenCV中响应特定的鼠标事件
# 参数说明：
# - event：当前发生的鼠标事件类型（如左键点击、双击等）
# - x, y：鼠标当前所在的图像坐标位置
# - flags：标志位，一般在此场景下无需关注具体值
# - param：用户自定义参数，此处未使用
def draw_circle(event, x, y, flags, param):
    if event == cv.EVENT_LBUTTONDBLCLK:  # 检查是否为鼠标左键双击事件
        # 使用cv.circle函数在img图像上绘制一个圆圈
        # 参数说明：
        # - img：目标图像
        # - (x, y)：圆心坐标
        # - 100：圆的半径
        # - (255, 0, 0)：圆的颜色，RGB格式，表示红色
        # - -1：线宽，设置为-1表示填充整个圆
        cv.circle(img, (x, y), 100, (255, 0, 0), -1)

# 创建一个512x512像素、三通道（红绿蓝）的黑色图像，数据类型为无符号8位整数
img = np.zeros((512, 512, 3), np.uint8)

# 创建一个名为'image'的OpenCV窗口，用于显示图像
cv.namedWindow('image')

# 设置'maple'窗口的鼠标回调函数为draw_circle，这样当鼠标在该窗口内产生事件时，就会调用draw_circle函数进行处理
cv.setMouseCallback('image', draw_circle)

# 进入无限循环，持续显示图像
while(1):
    # 在'image'窗口中显示当前的img图像
    cv.imshow('image', img)

    # 等待用户按键，若等待20ms后检测到有按键按下，则返回按键的ASCII码
    # 如果按下的键是Esc键（ASCII码为27），则退出循环
    if cv.waitKey(20) & 0xFF == 27:
        break

# 销毁所有已创建的OpenCV窗口
cv.destroyAllWindows()

7、OpenCV-Python调色板

import numpy as np
import cv2 as cv

# 导入numpy库，用np作为别名，用于处理数组和矩阵操作
# 导入OpenCV库，用cv作为别名，用于图像和视频处理

# 定义一个空函数，该函数在本例中用于接收trackbar位置变化的回调，但不做任何处理
def nothing(x):
    pass

# 创建一个300像素高、512像素宽、三通道（彩色）的黑色图像，并将其数据类型设置为无符号8位整型
img = np.zeros((300,512,3), np.uint8)

# 使用cv2创建一个名为'image'的窗口以显示图像
cv.namedWindow('image')

# 创建颜色轨迹栏：参数分别为trackbar名称、关联的窗口名称、初始值、最大值和回调函数
# 这里分别创建了三个颜色通道（红、绿、蓝）的trackbar，范围从0到255
cv.createTrackbar('R','image',0,255,nothing)
cv.createTrackbar('G','image',0,255,nothing)
cv.createTrackbar('B','image',0,255,nothing)

# 创建一个开关trackbar，其标签是文本形式的"0 : OFF \n1 : ON"，表示两种状态
switch = '0 : OFF \n1 : ON'
cv.createTrackbar(switch, 'image',0,1,nothing)   # 开关trackbar取值范围为0或1，初始值为0

while(1):  # 进入无限循环，直到用户按下指定按键退出
    # 在已命名的窗口'image'中显示当前图像
    cv.imshow('image',img)

    # 等待用户按键，时间间隔为1ms，&0xFF用于获取ASCII码
    k = cv.waitKey(1) & 0xFF

    # 按下ESC键（ASCII码27）时退出循环
    if k == 27:
        break

    # 获取各trackbar的当前位置
    r = cv.getTrackbarPos('R','image')   # 获取红色trackbar的位置
    g = cv.getTrackbarPos('G','image')   # 获取绿色trackbar的位置
    b = cv.getTrackbarPos('B','image')   # 获取蓝色trackbar的位置
    s = cv.getTrackbarPos(switch,'image')   # 获取开关trackbar的位置

    # 根据开关的状态设置图像颜色
    if s == 0:
        img[:] = 0   # 如果开关为OFF（0），则将图像重置为黑色
    else:
        img[:] = [b,g,r]   # 如果开关为ON（非0），则将图像设置为当前RGB轨道上的颜色值

# 关闭所有由cv2创建的窗口
cv.destroyAllWindows()

8、OpenCV-Python使用cv.copyMakeBorder绘制边框

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

# 定义颜色BLUE为红色（BGR格式）
BLUE = [255, 0, 0]

# 使用cv2.imread函数读取图像文件'111.jpg'，并将其赋值给变量img1
img1 = cv.imread('111.jpg')

# cv2.copyMakeBorder函数用于在原始图像周围添加边界
# 参数说明：
#   img1：输入的原始图像
#   top, bottom, left, right: 分别表示上、下、左、右需要增加边界的像素数，此处均为10像素
#   borderType: 边界填充模式
#       cv.BORDER_REPLICATE: 重复边缘像素值进行扩展
#       cv.BORDER_REFLECT: 使用镜像的方式扩展边界（对于最边缘的像素，会先翻转然后复制）
#       cv.BORDER_REFLECT_101: 类似于REFLECT，但最外侧的像素不会被翻转
#       cv.BORDER_WRAP: 类似于图像环绕扩展，从另一端获取像素进行补充
#       cv.BORDER_CONSTANT: 使用指定的颜色值进行填充
#   value: 当borderType为cv.BORDER_CONSTANT时，该参数有效，用于设置填充的颜色。此处设置为BLUE

replicate = cv.copyMakeBorder(img1, 10, 10, 10, 10, cv.BORDER_REPLICATE)
reflect = cv.copyMakeBorder(img1, 10, 10, 10, 10, cv.BORDER_REFLECT)
reflect101 = cv.copyMakeBorder(img1, 10, 10, 10, 10, cv.BORDER_REFLECT_101)
wrap = cv.copyMakeBorder(img1, 10, 10, 10, 10, cv.BORDER_WRAP)
constant = cv.copyMakeBorder(img1, 10, 10, 10, 10, cv.BORDER_CONSTANT, value=BLUE)

# 使用matplotlib库中的pyplot模块来显示处理后的图像
# subplot函数用于将图形窗口划分为多个子区域
# imshow函数用于显示图像，'gray'参数表示以灰度模式显示
# title函数用于设置当前子图的标题

plt.subplot(231), plt.imshow(img1, 'gray'), plt.title('ORIGINAL')
plt.subplot(232), plt.imshow(replicate, 'gray'), plt.title('REPLICATE')
plt.subplot(233), plt.imshow(reflect, 'gray'), plt.title('REFLECT')
plt.subplot(234), plt.imshow(reflect101, 'gray'), plt.title('REFLECT_101')
plt.subplot(235), plt.imshow(wrap, 'gray'), plt.title('WRAP')
plt.subplot(236), plt.imshow(constant, 'gray'), plt.title('CONSTANT')

# show函数用于展示所有已经绘制好的图像
plt.show()

 

9、图片的基本属性操作（操作像素）

# 导入numpy库，并用np作为别名
import numpy as np

# 导入OpenCV库，并用cv作为别名
import cv2 as cv

# 使用cv.imread函数读取指定路径的图片，返回一个numpy数组表示图像数据
img = cv.imread('111.jpg')

# numpy数组切片操作，获取图像中坐标为(100, 100)处像素点的所有通道（RGB）值
px = img[100, 100]

# 打印该像素点的所有通道值
print(px)

# 获取图像中坐标为(100, 100)处像素点蓝色通道的具体数值
blue = img[100, 100, 0]  # 在OpenCV中，通道顺序是BGR

# 打印该像素点蓝色通道的数值
print(blue)

# 将图像中坐标为(100, 100)处像素点的颜色设置为白色，即R、G、B通道值均为255
img[100, 100] = [255, 255, 255]

# 打印修改后坐标为(100, 100)处像素点的新颜色值
print(img[100, 100])

# numpy数组的.item()方法用于获取指定索引处的单个元素值
# 这里尝试获取图像中坐标为(10, 10, 2)处像素点

# 获取图片中坐标为(10, 10, 2)的像素值
img.item(10, 10, 2)

# 设置图片中坐标为(10, 10, 2)的像素值为100
img.itemset((10, 10, 2), 100)

# 获取修改后的像素值
img.item(10, 10, 2)

# 打印像素值
print(img.item(10, 10, 2))

10、OpenCV-Python缩放

import numpy as np
# 导入numpy库，用于处理数组和矩阵操作

import cv2 as cv
# 导入OpenCV库，并将其别名为cv，用于图像处理和计算机视觉任务

# 读取图像文件 '111.jpg' 并以BGR格式存储在img变量中
img = cv.imread('111.jpg')

# 调用cv.resize()函数对图片进行缩放：
# - img: 待缩放的输入图像
# - None: 表示输出图像的尺寸将根据给定的缩放因子自动计算
# - fx=2, fy=2: 分别为宽度和高度的缩放因子，表示图像将放大两倍
# - interpolation=cv.INTER_CUBIC: 指定插值方法为CUBIC插值，用于决定如何计算新像素点的值
res = cv.resize(img,None,fx=2, fy=2, interpolation = cv.INTER_CUBIC)

# 或者，另一种方式来指定输出图像的尺寸：
# 获取原图像的高度和宽度
height, width = img.shape[:2]
# 计算放大两倍后的新的尺寸
new_width, new_height = 2*width, 2*height
# 使用新尺寸对图像进行缩放
res = cv.resize(img,(new_width, new_height), interpolation = cv.INTER_CUBIC)

# 显示调整大小后的图像，窗口标题为'image'
cv.imshow('image',res)

# 等待用户按键（任意键），若按键值为0则继续执行，否则退出显示
cv.waitKey(0)

# 关闭所有由cv.imshow()打开的图像窗口
cv.destroyAllWindows()

这段Python代码执行了以下操作：

导入numpy库，它在处理多维数组和矩阵运算方面非常高效，常用于图像处理中的数据计算。

导入OpenCV库，并使用别名cv。OpenCV是一个专门用于计算机视觉和图像处理的库，提供了大量的图像、视频读取、显示、处理等功能。

使用cv.imread()函数读取名为’111.jpg’的图像文件，并将其以BGR（蓝色、绿色、红色）格式存储在img变量中。

调用cv.resize()函数对img图像进行缩放：

第一个参数img是需要缩放的原始图像。

第二个参数None表示输出图像的尺寸将根据给定的缩放因子自动计算。

fx=2, fy=2分别指定了宽度和高度的缩放因子，因此图像会被放大两倍。

interpolation=cv.INTER_CUBIC指定了插值方法为CUBIC插值，该方法在放大图像时提供较好的平滑效果，通过计算像素点周围临近像素的值来决定新像素点的值。

另一种指定输出图像尺寸的方式是：

首先获取原图像的高度和宽度，即img.shape[:2]。

然后基于原尺寸计算出放大两倍后的新的尺寸。

最后再次调用cv.resize()函数，这次直接指定输出图像的新尺寸。

使用cv.imshow(‘image’, res)展示调整大小后的图像，窗口标题为’image’。

cv.waitKey(0)函数会暂停程序执行，等待用户按键。若用户按下任意键且其ASCII码不为0，则函数返回该键的ASCII码并继续执行；如果用户未按键，程序将继续暂停。在这里设置为0，意味着程序将一直等待直到有按键事件发生。

cv.destroyAllWindows()函数用于关闭所有由cv.imshow()函数打开的图像窗口，即关闭之前显示的resize后的图像窗口。

11、OpenCV-Python平移和仿射

# 导入numpy库，用于处理数组和矩阵操作，并将其命名为np
import numpy as np

# 导入OpenCV库，并将其命名为cv以简化调用
import cv2 as cv

# 使用cv.imread函数读取名为'111.jpg'的图像文件，第二个参数为0表示以灰度模式读取
img = cv.imread('111.jpg', 0)

# 获取图像的尺寸信息（高度rows和宽度cols）
rows, cols = img.shape

# 创建一个2x3的浮点型NumPy数组M，它代表了一个仿射变换矩阵：
# 第一列控制水平方向上的缩放和平移，第二列控制垂直方向上的缩放和平移
# 此处设置的变换为在原图基础上向右平移100个单位，向下平移50个单位
M = np.float32([[1, 0, 100], [0, 1, 50]])

# 使用cv.warpAffine函数对原始图像img应用上述定义的仿射变换M
# 参数(M)是2x3的变换矩阵，(cols, rows)是输出图像的目标大小
dst = cv.warpAffine(img, M, (cols, rows))

# 使用cv.imshow函数显示经过变换后的图像，窗口名称为'img'
cv.imshow('img', dst)

# cv.waitKey函数等待用户按键，参数0表示无限等待，直到用户按下任意键
cv.waitKey(0)

# cv.destroyAllWindows函数关闭所有由cv.imshow打开的图像窗口
cv.destroyAllWindows()

12、OpenCV-Python旋转和仿射

# 导入所需库
import numpy as np  # NumPy 是 Python 中用于处理大型多维数组和矩阵的库
import cv2 as cv   # OpenCV 是一个计算机视觉和机器学习软件库

# 读取图像，'111.jpg' 是图片文件名，0 表示以灰度模式读取图像
img = cv.imread('111.jpg', 0)

# 获取图像的维度信息（行数rows和列数cols）
rows, cols = img.shape

# cv.getRotationMatrix2D函数用于生成2D旋转矩阵，参数含义如下：
# 第一个参数是一个元组，表示旋转中心点坐标，这里选择图像中心 ((cols-1)/2.0, (rows-1)/2.0)
# 第二个参数是旋转角度，此处为90度
# 第三个参数是缩放因子，设置为1表示不进行缩放
M = cv.getRotationMatrix2D(((cols-1)/2.0, (rows-1)/2.0), 90, 1)

# cv.warpAffine函数用于根据给定的2x3变换矩阵M对原图像进行仿射变换
# 参数含义如下：
# 第一个参数是输入图像
# 第二个参数是2x3的仿射变换矩阵
# 第三个参数是一个元组，表示输出图像的大小 (cols, rows)
dst = cv.warpAffine(img, M, (cols, rows))

# 使用OpenCV显示旋转后的图像，'img' 是窗口名称
cv.imshow('img', dst)

# 等待用户按键，0 表示无限
cv.waitKey(0)

# 关闭所有OpenCV创建的窗口
cv.destroyAllWindows()

13、OpenCV-Python图像直方图（1）

# 导入所需库
import numpy as np  # Numpy，用于处理数组和矩阵操作
import cv2 as cv  # OpenCV，用于图像处理和计算机视觉任务
from matplotlib import pyplot as plt  # Matplotlib，用于数据可视化，此处用于绘制图像直方图

# 使用OpenCV的imread函数读取名为'888.jpg'的图像，并以灰度模式加载（参数0表示灰度）
img = cv.imread('888.jpg', 0)

# 对于图像的直方图绘制：
# - img.ravel()：将二维图像矩阵转换为一维数组，以便计算每个像素值出现的频率
# - plt.hist() 函数接收以下参数：
#     - 第一个参数：需要计算直方图的数据，这里是img的一维版本
#     - 第二个参数：直方图的bins数量，这里设置为256，意味着在0-255的灰度级上分成256个区间进行统计
#     - 第三个参数：直方图的边界范围，这里设置为[0, 256]，表示统计的灰度值范围是从0到255
plt.hist(img.ravel(), 256, [0, 256])

# 使用Matplotlib的pyplot子模块中的show()函数显示绘制的图像直方图
plt.show()

13、OpenCV-Python图像直方图（2）

# 导入所需库
import numpy as np  # Numpy库，用于处理数组操作
import cv2 as cv   # OpenCV库，用于图像处理和计算机视觉任务
from matplotlib import pyplot as plt  # Matplotlib库，用于数据可视化

# 使用cv2.imread()函数读取图像（以灰度模式加载）
img = cv.imread('888.jpg',0)

# 创建一个与原始图像尺寸相同的二维全零数组作为掩码
mask = np.zeros(img.shape[:2], np.uint8)  # uint8表示8位无符号整数类型，用于存储0-255范围的像素值

# 将掩码图像的特定区域设置为白色（值为255，表示该区域被选中）
mask[100:300, 100:400] = 255

# 使用cv.bitwise_and()函数对原图像进行掩码操作，仅保留掩码区域的像素
masked_img = cv.bitwise_and(img,img,mask = mask)

# 计算原始图像在灰度通道（索引为0）上的直方图
hist_full = cv.calcHist([img],[0],None,[256],[0,256])
# 参数解释：
# [img]：输入图像列表
# [0]：要计算直方图的通道编号
# None：可选的掩码，此处为None表示计算整个图像的直方图
# [256]：直方图bin的数量，对于灰度图像每个bin代表一个灰度级
# [0,256]：直方图的像素值区间范围

# 计算掩码区域在灰度通道（索引为0）上的直方图
hist_mask = cv.calcHist([img],[0],mask,[256],[0,256])

# 使用matplotlib绘制子图并显示图像及直方图
plt.subplot(221), plt.imshow(img, 'gray')  # 显示原始图像
plt.subplot(222), plt.imshow(mask,'gray')  # 显示掩码图像
plt.subplot(223), plt.imshow(masked_img, 'gray')  # 显示掩码操作后的图像
plt.subplot(224), plt.plot(hist_full), plt.plot(hist_mask)  # 绘制原始图像和掩码区域的直方图
plt.xlim([0,256])  # 设置x轴范围从0到256
plt.show()  # 显示所有已绘制图形

plt.imshow(mask, ‘gray’)：该函数用于显示图像。其中，mask是一个二维数组，通常代表一个图像的像素值。参数 ‘gray’ 表示以灰度模式显示这幅图像，即将图像视为单通道数据，每个像素值对应不同的灰度等级。

这两行代码组合在一起的作用就是：在2x2的子图布局中的第二个位置，以灰度形式展示变量mask所代表的图像内容。.

14、OpenCV-Python特征识别：Harri(哈里斯)角点检测（1）

import numpy as np
import cv2 as cv

# 定义图像文件名
filename = '888.jpg'

# 读取图像
img = cv.imread(filename)

# 将图像转换为灰度图像
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# 将灰度图像转换为浮点类型
gray = np.float32(gray)

# 使用cornerHarris算法检测图像中的角点
dst = cv.cornerHarris(gray, 2, 3, 0.04)

# 对检测到的角点进行膨胀操作
dst = cv.dilate(dst, None)

# 设置角点的显示标记
# result用于标记角点，并不重要
best_threshold = 0.01 * dst.max()
img[dst > best_threshold] = [0, 0, 255]

# 显示标记后的图像
cv.imshow('dst', img)

# 等待用户按下任意键
if cv.waitKey(0) & 0xff == 27:
    cv.destroyAllWindows()




# import numpy as np
# import cv2 as cv
# filename = '888.jpg'
# img = cv.imread(filename)
# gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# gray = np.float32(gray)
# dst = cv.cornerHarris(gray,2,3,0.04)
# #result用于标记角点，并不重要
# dst = cv.dilate(dst,None)
# #最佳值的阈值，它可能因图像而异。
# img[dst>0.01*dst.max()]=[0,0,255]
# cv.imshow('dst',img)
# if cv.waitKey(0) & 0xff == 27:
#     cv.destroyAllWindows()

15、OpenCV-Python特征识别：Harri(哈里斯)角点检测（2）

import numpy as np
import cv2 as cv

# 读取图像
filename = '007.jpg'
img = cv.imread(filename)

# 转换为灰度图像
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# 将灰度图像转换为浮点类型
gray = np.float32(gray)

# 使用cornerHarris函数寻找哈里斯角
dst = cv.cornerHarris(gray, 2, 3, 0.04)
dst = cv.dilate(dst, None)

# 对dst进行阈值处理
ret, dst = cv.threshold(dst, 0.01 * dst.max(), 255, 0)
dst = np.uint8(dst)

# 使用connectedComponentsWithStats函数寻找质心
ret, labels, stats, centroids = cv.connectedComponentsWithStats(dst)

# 定义停止和完善拐角的条件
criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 100, 0.001)

# 使用cornerSubPix函数对质心进行精化
corners = cv.cornerSubPix(gray, np.float32(centroids), (5, 5), (-1, -1), criteria)

# 绘制结果
res = np.hstack((centroids, corners))
res = np.intp(res)

# 将质心周围像素着色为红色，拐角像素着色为绿色
img[res[:, 1], res[:, 0]] = [0, 0, 255]
img[res[:, 3], res[:, 2]] = [0, 255, 0]

# 保存绘制结果的图像
cv.imwrite('subpixel5.jpg', img)

cv.imshow('img', img)
# 等待用户按下任意键
if cv.waitKey(0) & 0xff == 27:
    cv.destroyAllWindows()

该Python函数实现了图像处理中的角点检测，并通过亚像素精确度来优化角点位置。以下是详细步骤：

1、导入所需库：numpy（np）和OpenCV（cv2）。

2、读取指定路径下的图像文件（本例为’007.jpg’），使用cv.imread()函数将其加载到内存中，存储在变量img中。

3、将彩色图像转换为灰度图像，通过调用cv.cvtColor()函数并传入颜色空间转换参数cv.COLOR_BGR2GRAY。

4、将灰度图像数据类型转换为浮点型，以便后续进行更精确的计算。

5、使用OpenCV的cornerHarris()函数寻找图像中的角点特征，该函数采用的是哈里斯角点检测算法。

6、对检测到的角点响应图（dst）进行膨胀操作以增强特征点，使用了cv.dilate()函数。

7、对膨胀后的dst进行阈值处理，确定显著的角点区域，这里使用了cv.threshold()函数。

8、使用cv.connectedComponentsWithStats()函数寻找图像中的连通组件及其统计信息，包括质心坐标。

9、定义一个终止条件用于后续的角点精化过程。

10、应用cv.cornerSubPix()函数对之前找到的质心进行亚像素级别的精化，以得到更精确的角点位置。

11、计算并绘制结果，将原始图像与质心及精化后的角点坐标拼接在一起，然后将绘图结果的数据类型转换为整数。

12、根据精化的角点和质心坐标，在原图像上标记出角点（绿色）和质心（红色）。

13、最后，保存处理后的图像至本地磁盘（‘subpixel5.jpg’），并使用cv.imshow()函数显示处理结果。

设置键盘监听，如果用户按下Esc键，则关闭所有窗口。

特别的：

ret, labels, stats, centroids = cv.connectedComponentsWithStats(dst)

cv.connectedComponentsWithStats(dst) 是OpenCV中的一个函数，用于在二值图像（在这个例子中是经过阈值处理的角点响应图dst）上进行连通组件分析。它会将图像中的每个连通区域标记为不同的标签，并返回以下信息：

ret：返回标记过的连通区域的数量。

labels：输出图像，大小与原图像相同，每个像素表示该像素所属连通区域的标签。

stats：一个包含每个连通区域统计信息的数组，其中每个区域的信息包括左上角坐标、宽度、高度、面积等。

centroids：一个包含每个连通区域质心坐标的数组。

在这个特定的上下文中，该函数被用来找到图像中独立的连通区域（即可能的角点位置），并计算出每个区域的质心坐标，以便后续使用cornerSubPix函数进一步优化角点的位置精度

criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 100, 0.001)

criteria 是一个用于OpenCV优化算法的终止条件设置，通常在需要迭代搜索最优解的情况下使用，例如在 cornerSubPix 函数中对角点位置进行亚像素级别的精化。

在这个表达式中：

cv.TERM_CRITERIA_EPS 表示停止迭代的一个条件是达到指定的精度阈值。

cv.TERM_CRITERIA_MAX_ITER 表示另一个条件是达到预设的最大迭代次数。

(100, 0.001) 分别对应最大迭代次数和精度阈值。具体来说，第一个参数100表示最多允许进行100次迭代；第二个参数0.001表示当角点坐标的变化小于0.001时，认为已经达到足够的精度，迭代过程可以提前结束。

因此，criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 100, 0.001) 设置了一个综合考虑迭代次数与精度要求的终止条件，确保在优化过程中既能保证一定的计算效率，又能获得满意的定位精度。

以上就是“16000字+|Python图像处理|OpenCV-Python图像处理（读取显示、绘制矩形直线椭圆圆形文本、多顶点绘制多边形、鼠标事件、调色板、边框绘制，像素操作，缩放平移旋转仿射、直方图、角点）”的全部内容，希望对你有所帮助。
​
​关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、Python练习题

检查学习结果。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

最后祝大家天天进步！！

上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。