cv2.countNonZero
函数名
cv2.countNonZero功能描述
cv2.countNonZero 函数用于计算图像中非零像素的数量。该函数接受一个单通道图像作为输入，并返回该图像中非零像素的个数。参数
src（必需）：输入图像，必须为单通道图像（例如灰度图像）。返回值
retval：一个整数，表示输入图像中非零像素的数量。
import cv2
import numpy as np
pth = "C://Users/Administrator/Desktop/1.jpg"
print('cv2.__version__:', cv2.__version__)
img_src = cv2.imread(pth, cv2.IMREAD_GRAYSCALE)
count = cv2.countNonZero(img_src)
print('非零像素点个数:', count)
arr = np.eye(5)
print('np.eye(5):\n', arr)
count = cv2.countNonZero(arr)
print('非零像素点个数:', count)
count_zero = arr.shape[0]*arr.shape[1]-count
print('零像素点个数:',count_zero)
output
cv2.__version__: 4.4.0
非零像素点个数: 571523
np.eye(5):
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
非零像素点个数: 5
零像素点个数: 20
可以灵活使用，从而求出非零元素
cv2.minMaxLoc
- 函数原型
minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(src, mask=None) - 参数
- src：输入的数组或图像。这通常是一个 NumPy 数组，可以是单通道或多通道图像，但在查找最大值和最小值时，通常使用单通道图像（如灰度图像）。
- mask（可选）：与 src 大小相同的操作掩码，用于指定函数应该考虑哪些元素。如果指定了掩码，则只有掩码中对应位置为真的元素才会被考虑。默认为 None，即考虑所有元素。
- 返回值
- minVal：src 中的最小值。
- maxVal：src 中的最大值。
- minLoc：minVal 的坐标（作为元组返回，例如 (x, y)）。
- maxLoc：maxVal 的坐标（作为元组返回，例如 (x, y)）。
import cv2
pth = "C://Users/Administrator/Desktop/1.jpg"
img = cv2.imread(pth)[:, :, 2] # 提取其中R通道
ret = cv2.minMaxLoc(img)
print('minMaxLoc(img): ', ret)
output
minMaxLoc(img): (0.0, 246.0, (46, 334), (567, 348))
如果存在多个最大值或者最小值，返回是谁的位置？
import numpy as np
arr = np.array([[1, 1, 0, 2, 0], [0, 20, 20, 11, 15]])
print('arr:\n', arr)
ret = cv2.minMaxLoc(arr)
print('minMaxLoc(arr): ', ret)
output
arr:
[[ 1 1 0 2 0]
[ 0 20 20 11 15]]
minMaxLoc(arr): (0.0, 20.0, (2, 0), (1, 1))
可以看到，返回的是第一次遇到的最大值和最小值坐标
cv2.sumElems
函数原型
retval = cv2.sumElems(src)参数
src：输入图像或数组。这可以是一个单通道、三通道或四通道图像，或者任何 NumPy 数组。返回值
retval：一个四元组，包含四个元素，分别对应图像或数组可能包含的第0、1、2、3通道的元素总和。如果输入是单通道图像，则只有第一个元素（对应通道0）有意义；如果是三通道图像，则前三个元素（对应通道0、1、2）有意义；对于四通道图像，所有四个元素都有意义。
import cv2
import numpy as np
pth = "C://Users/Administrator/Desktop/1.jpg"
print('cv2.__version__:', cv2.__version__)
img_src = cv2.imread(pth) #,cv2.IMREAD_GRAYSCALE)
val = cv2.sumElems(img_src)
print('像素元素和:', val )
arr = np.eye(5)
val = cv2.sumElems(arr)
print('np.eye(5)元素和:', val)
output
cv2.__version__: 4.4.0
像素元素和: (52660277.0, 63894342.0, 73320574.0, 0.0)
np.eye(5)元素和: (5.0, 0.0, 0.0, 0.0)
cv2.mean
函数原型
mean = cv2.mean(src[, mask])参数
src：- 类型：cv2.Mat
- 描述：输入图像或数组。可以是多通道（如彩色图像）或单通道（如灰度图像）。
mask（可选）：
- 类型：cv2.Mat
- 描述：一个可选的掩码，用于指定要计算均值的区域。掩码应具有与 src 相同的尺寸，并且应为8位单通道图像（可以是二进制掩码）。如果未提供掩码，则将对整个 src 进行计算。
返回值
mean：类型：元组（对于彩色图像为 (B, G, R) 或 (B, G, R, A) 对于带有透明度的图像，对于灰度图像为单个浮点数）
描述：返回一个包含通道均值的元组。对于多通道图像，将返回每个通道的均值；对于灰度图像，将返回该灰度图像的均值。
import cv2
import numpy as np
pth = "C://Users/Administrator/Desktop/1.jpg"
print('cv2.__version__:', cv2.__version__)
img_src = cv2.imread(pth)
val = cv2.mean(img_src)
print('像素平均值:',val)
arr = np.eye(5)
val = cv2.mean(arr)
print('np.eye(5)平均值:',val)
output
cv2.__version__: 4.4.0
像素平均值: (90.74226471926221, 110.10039494906329, 126.34333342523539, 0.0)
np.eye(5)平均值: (0.2, 0.0, 0.0, 0.0)
cv2.meanStdDev
函数原型
cv2.meanStdDev(src, mean, stddev, [mask=None])参数
src：- 类型：cv2.Mat
- 描述：输入图像或数组，可以是多通道（如彩色图像）或单通道（如灰度图像）。
mean：
- 类型：cv2.OutputArray
- 描述：输出参数，用于存储计算得到的均值。对于多通道图像，mean 是一个数组，其中包含每个通道的均值。
stddev：
- 类型：cv2.OutputArray
- 描述：输出参数，用于存储计算得到的标准差。对于多通道图像，stddev 是一个数组，其中包含每个通道的标准差。
mask（可选）：
- 类型：cv2.Mat
- 描述：一个可选的8位单通道数组，用于指定要计算均值和标准差的区域。mask 中的非零元素表示要计算的像素，零元素表示要忽略的像素。
返回值
该函数没有直接的返回值，但计算得到的均值和标准差分别存储在 mean 和 stddev 参数中。
import cv2
import numpy as np
pth = "C://Users/Administrator/Desktop/1.jpg"
print('cv2.__version__:', cv2.__version__)
img_src = cv2.imread(pth)
val = cv2.meanStdDev(img_src)
print(type(val))
print('val[0]:', type(val[0]))
print('val[0][0]:', type(val[0][0]))
print('图像的平均值:\n', val[0])
print('图像的标准差:\n' ,val[1])
print('图像B通道的平均值:\n', val[0][0][0])
print('图像B通道的标准差:\n', val[1][0][0])
arr = np.eye(5)
val = cv2.meanStdDev(arr)
print('np.eye(5)的平均值:', val[0])
print('np.eye(5)的标准差:', val[1])
print('np.eye(5)的平均值:', val[0][0][0])
print('np.eye(5)的标准差:', val[1][0][0])
output
cv2.__version__: 4.4.0
<class 'tuple'>
val[0]: <class 'numpy.ndarray'>
val[0][0]: <class 'numpy.ndarray'>
图像的平均值:
[[ 90.74226472]
[110.10039495]
[126.34333343]]
图像的标准差:
[[54.58439785]
[52.8880298 ]
[51.22834654]]
图像B通道的平均值:
90.74226471926221
图像B通道的标准差:
54.58439785209522
np.eye(5)的平均值: [[0.2]]
np.eye(5)的标准差: [[0.4]]
np.eye(5)的平均值: 0.2
np.eye(5)的标准差: 0.4
cv2.reduce
- 函数语法
dst = cv2.reduce(src, dim, reduce_type[, dst[, dtype]]) - 参数说明
- src：输入图像或数组。
- dim：指定降维的维度，可以是 0（按行降维）或 1（按列降维）。
- reduce_type：指定降维操作的类型，有以下几种取值：
cv2.REDUCE_SUM：对元素进行求和。
cv2.REDUCE_AVG：对元素进行平均。
cv2.REDUCE_MAX：取元素的最大值。
cv2.REDUCE_MIN：取元素的最小值。 - dst（可选）：输出数组，即降维后的结果。如果不提供，将自动创建。
- dtype（可选）：输出数组的数据类型。如果不设置，则根据输入和 reduce_type 推断。
- 返回值
返回降维后的数组（向量），存储在 dst 中。
import cv2
import numpy as np
arr = np.array([[1, 1, 0, 2, 0],
[0, 20, 20, 11, 15],
[5, 5, 5, 5, 5]], dtype=np.uint8)
print(arr.shape, arr.dtype)
print('arr:\n', arr)
# reduce为行向量，计算最小最大值
row_min = cv2.reduce(arr, 0, cv2.REDUCE_MIN)
print('row_reduce_min: \n', row_min)
row_max = cv2.reduce(arr, 0, cv2.REDUCE_MAX)
print('row_reduce_max: \n', row_max)
# reduce为列向量，计算最小最大值
col_min = cv2.reduce(arr, 1, cv2.REDUCE_MIN)
print('col_reduce_min: \n', col_min)
col_max = cv2.reduce(arr, 1, cv2.REDUCE_MAX)
print('col_reduce_max: \n', col_max)
# reduce为行向量，计算和、均值
row_sum = cv2.reduce(arr, 0, cv2.REDUCE_SUM, dtype=cv2.CV_32S)
print('row_sum: \n', row_sum)
row_avg = cv2.reduce(arr, 0, cv2.REDUCE_AVG, dtype=cv2.CV_32F)
print('row_avg: \n', row_avg)
# reduce为列向量，计算和、均值
col_sum = cv2.reduce(arr, 1, cv2.REDUCE_SUM, dtype=cv2.CV_32S)
print('col_sum: \n', col_sum)
col_avg = cv2.reduce(arr, 1, cv2.REDUCE_AVG, dtype=cv2.CV_32F)
print('col_avg: \n', col_avg)
output
(3, 5) uint8
arr:
[[ 1 1 0 2 0]
[ 0 20 20 11 15]
[ 5 5 5 5 5]]
row_reduce_min:
[[0 1 0 2 0]]
row_reduce_max:
[[ 5 20 20 11 15]]
col_reduce_min:
[[0]
[0]
[5]]
col_reduce_max:
[[ 2]
[20]
[ 5]]
row_sum:
[[ 6 26 25 18 20]]
row_avg:
[[2. 8.666667 8.333334 6. 6.666667]]
col_sum:
[[ 4]
[66]
[25]]
col_avg:
[[ 0.8]
[13.2]
[ 5. ]]
