知识点

像素值统计

- 最小(min)

- 最大(max)

- 均值(mean)

- 标准方差(standard deviation)

相关API

  • 最大最小值minMaxLoc
    minMaxLoc() 函数要求输入图像必须是 CV_8UC1 类型的，否则会报错。

  • 计算均值与标准方差meanStdDev
    meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev)
    - src 表示输入 Mat 图像

  • mean 表示计算出各个通道的均值,数组长度与通道数目一致

  • stddev 表示计算出各个通道的标准方差，数组长度与通道数目一致

方差的概念与计算公式，例如 两人的5次测验成绩如下：
X： 50，100，100，60，50，平均值E(X)=72；
Y： 73， 70， 75， 72，70 平均值E(Y)=72。
平均成绩相同，但X 不稳定，对平均值的偏离大。

方差描述随机变量对于数学期望的偏离程度。
单个偏离是消除符号影响方差即偏离平方的均值，记为E(X)：直接计算公式分离散型和连续型。推导另一种计算公式得到：“方差等于各个数据与其算术平均数的离差平方和的平均数”。其中，分别为离散型和连续型计算公式 [1] 。 称为标准差或均方差，方差描述波动程度。[

](https://blog.csdn.net/Apple_Coco/article/details/93529575)
image.png

C++代码

  1. #include <opencv2/opencv.hpp>
  2. #include <iostream>
  4. using namespace std;
  5. using namespace cv;
  7. void day10() {
  9.     // 读取一张灰度图像
  10.     Mat src_gray = imread("E:\\_Image\\OpenCVTest\\girl.jpg", IMREAD_GRAYSCALE);
  11.     if (src_gray.empty()) {
  12.         cout << "could not load image.." << endl;
  13.         return;
  14.     }
  15.     imshow("src_gray", src_gray);
  17.     if (src_gray.type() == CV_8UC1) {
  18.         double minVal = 0, maxVal = 0;
  19.         Point minLoc, maxLoc;
  20.         minMaxLoc(src_gray, &minVal, &maxVal, &minLoc, &maxLoc, Mat());
  21.         printf("min: %.2f, max: %.2f\n", minVal, maxVal);
  22.         printf("min loc: (%d, %d)\n", minLoc.x, minLoc.y);
  23.         printf("max loc: (%d, %d)\n", maxLoc.x, maxLoc.y);
  24.     }
  25.     else {
  26.         cout << "not gray image.." << endl;
  27.     }
  29.     // 读取一张三通道彩色图像，获得它的均值和方差
  30.     Mat src_color = imread("E:\\_Image\\OpenCVTest\\girl.jpg");
  31.     if (src_color.empty()) {
  32.         cout << "could not load image.." << endl;
  33.         return;
  34.     }
  35.     imshow("src_color", src_color);
  37.     Mat mean, stddev;
  38.     meanStdDev(src_color, mean, stddev);
  39.     printf("blue channel -> mean: %.2f, stddev: %2f\n", mean.at<double>(0, 0), stddev.at<double>(0, 0));
  40.     printf("green channel -> mean: %.2f, stddev: %2f\n", mean.at<double>(1, 0), stddev.at<double>(1, 0));
  41.     printf("red channel -> mean: %.2f, stddev: %2f\n", mean.at<double>(2, 0), stddev.at<double>(2, 0));
  43.     // 根据图像的均值将彩色图像转换为二值图像
  44.     for (int row = 0; row < src_color.rows; row++) {
  45.         for (int col = 0; col < src_color.cols; col++) {
  46.             Vec3b bgr = src_color.at<Vec3b>(row, col);
  47.             bgr[0] = bgr[0] < mean.at<double>(0, 0) ? 0 : 255;
  48.             bgr[1] = bgr[1] < mean.at<double>(1, 0) ? 0 : 255;
  49.             bgr[2] = bgr[2] < mean.at<double>(2, 0) ? 0 : 255;
  50.             src_color.at<Vec3b>(row, col) = bgr;
  51.         }
  52.     }
  53.     imshow("binary", src_color);
  55.     waitKey(0);
  56. }

Python代码

  1. import cv2 as cv
  2. import numpy as np
  4. # 查看版本
  5. print(cv.__version__)
  7. # 读取和显示图像
  8. src = cv.imread("E:/_Image/OpenCVTest/girl.jpg", cv.IMREAD_GRAYSCALE)
  9. cv.imshow("src", src)
  11. # 获取灰度图的极值及位置
  12. mmin, mmax, minLoc, maxLoc = cv.minMaxLoc(src)
  13. print("min: %.2f, max: %.2f" % (mmin, mmax))
  14. print("minLoc: ", minLoc)
  15. print("maxLoc: ", maxLoc)
  17. # 获取灰度图的均值和方差
  18. means, stddev = cv.meanStdDev(src)
  19. print("means: %.2f, stddev: %.2f" % (means, stddev))
  20. src[np.where(src < means)] = 0
  21. src[np.where(src > means)] = 255
  22. cv.imshow("binary", src)
  24. ## 彩色图像二值化
  25. src = cv.imread("E:/_Image/OpenCVTest/girl.jpg")
  26. cv.imshow("color", src)
  27. h, w, ch = src.shape
  28. means, stddev = cv.meanStdDev(src)
  29. print("blue channel -> means: %.2f, stddev: %.2f" % (means[0], stddev[0]))
  30. print("green channel -> means: %.2f, stddev: %.2f" % (means[1], stddev[1]))
  31. print("red channel -> means: %.2f, stddev: %.2f" % (means[2], stddev[2]))
  32. print("h, w, ch", h, w, ch)
  33. for row in range(h):
  34.     for col in range(w):
  35.         b, g, r = src[row, col]
  36.         b = 0 if b < means[0] else 255
  37.         g = 0 if g < means[1] else 255
  38.         r = 0 if r < means[2] else 255
  39.         src[row, col] = [b, g, r]
  40. cv.imshow("color_binary", src)
  42. # 等待键盘输入，释放内存
  43. cv.waitKey()
  44. cv.destroyAllWindows()

Javascript代码

  1. <template>
  2.   <div>
  3.     <p>图像像素值统计</p>
  4.     <p id="status">OpenCV.js is loading...</p>
  5.     <div class="inputoutput">
  6.       <img id="imageSrc" src="imgs/girl.jpg" />
  7.     </div>
  8.     <div class="inputoutput">
  9.       <canvas id="canvasOutput"></canvas>
  10.       <div class="caption">canvasOutput</div>
  11.     </div>
  12.   </div>
  13. </template>
  15. <script>
  16. export default {
  17.   name: "day10",
  18.   mounted() {
  19.     this.init();
  20.   },
  21.   destoryed() {},
  22.   data() {
  23.     return {
  24.       mats: [],
  25.     };
  26.   },
  27.   methods: {
  28.     init() {
  29.       setTimeout(() => {
  30.         if (window.cv) {
  31.           this.onOpenCvReady(window.cv);
  32.         } else {
  33.           this.init();
  34.         }
  35.       }, 500);
  36.     },
  37.     onOpenCvReady(cv) {
  38.       document.getElementById("status").innerHTML = "OpenCV.js is ready.";
  40.       // 官方文档链接：
  42.       // 读取图像
  43.       let src = this.createMat(cv, 1, { name: "imageSrc" });
  45.       // 转化到 gray 色彩空间
  46.       let gray = this.createMat(cv, 2);
  47.       cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
  49.       // 计算灰度图的极值和位置
  50.       // 和 C++，Python 程序运行的结果不一致，感到很奇怪
  51.       if (gray.type() === cv.CV_8UC1) {
  52.         let ret = cv.minMaxLoc(gray);
  53.         console.log(ret);
  54.       }
  56.       // 计算彩色图的均值和方差
  57.       let bgr = this.createMat(cv, 2);
  58.       cv.cvtColor(src, bgr, cv.COLOR_RGBA2BGR);
  59.       let means = this.createMat(cv, 2);
  60.       let stddev = this.createMat(cv, 2);
  61.       cv.meanStdDev(bgr, means, stddev);
  62.       //   this.showImgInfo(means)
  63.       //   this.showImgInfo(stddev)
  64.       // 和 C++，Python 程序运行的结果不一致，感到很奇怪
  65.       console.log(`blue channel -> mean: ${means.ucharAt(0, 0)}, stddev: ${stddev.ucharAt(0, 0)}`);
  66.       console.log(`green channel -> mean: ${means.ucharAt(1, 0)}, stddev: ${stddev.ucharAt(1, 0)}`);
  67.       console.log(`red channel -> mean: ${means.ucharAt(2, 0)}, stddev: ${stddev.ucharAt(2, 0)}`);
  69.       // 显示图像
  70.       cv.imshow("canvasOutput", gray);
  72.       // 销毁所有 mat
  73.       this.destoryAllMats();
  74.     },
  75.     createMat(cv, type, ops) {
  76.       switch (type) {
  77.         case 1:
  78.           if (ops && ops.name) {
  79.             let mat = cv.imread(ops.name);
  80.             this.mats.push(mat);
  81.             return mat;
  82.           }
  83.           break;
  84.         case 2: {
  85.           let mat = new cv.Mat();
  86.           this.mats.push(mat);
  87.           return mat;
  88.         }
  89.         case 3:
  90.           if (ops && ops.rows && ops.cols && ops.type && ops.initValue) {
  91.             let mat = new cv.Mat(ops.rows, ops.cols, ops.type, ops.initValue);
  92.             this.mats.push(mat);
  93.             return mat;
  94.           }
  95.           break;
  96.         default:
  97.           break;
  98.       }
  99.     },
  100.     showImgInfo(src) {
  101.       console.log("img size :", src.size());
  102.       console.log("img type :", src.type());
  103.       console.log("img cols :", src.cols);
  104.       console.log("img rows :", src.rows);
  105.       console.log("img depth:", src.depth());
  106.       console.log("img channels:", src.channels());
  107.     },
  108.     destoryAllMats() {
  109.       let i = 0;
  110.       this.mats.forEach((item) => {
  111.         item.delete();
  112.         i++;
  113.       });
  114.       console.log("销毁图象数：", i);
  115.     },
  116.   },
  117. };
  118. </script>
  120. <style lang="scss" scoped>
  121. </style>

image.png
image.png
image.png