【python】OpenCV—Statistics

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. ]]