环境亮度检测

在本章节中给大家分享一个比较简单的关于环境亮度检测的小程序。

当前系列所有demo下载地址：

https://github.com/GaoRenBao/OpenCv4-Demo

不同编程语言对应的OpenCv版本以及开发环境信息如下： 

运行效果如下：

C#版本代码如下：

using OpenCvSharp;
using System;
using System.Windows.Forms;

namespace WindowsFormsApp
{
    public partial class Form1 : Form
    {
        /// <summary>
        /// 视频操作
        /// </summary>
        public VideoCapture Cap = new VideoCapture();

        public Form1()
        {
            InitializeComponent();
        }

        // 环境亮度值计算
        public double BrightnessDetection(Mat srcImage)
        {
            Mat dstImage = new Mat();
            Cv2.CvtColor(srcImage, dstImage, ColorConversionCodes.BGR2GRAY);

            // bgr保存了所有0~255个像素值的数量
            int[] bgr = new int[256];
            for (int i = 0; i < bgr.Length; i++) bgr[i] = 0;
            // a为所有亮度值的和
            double a = 0;
            // num 为像素点个数
            int num = 0;
            for (int i = 0; i < dstImage.Rows; i++)
            {
                for (int j = 0; j < dstImage.Cols; j++)
                {
                    // 剔除最大和最小值
                    if (dstImage.At<byte>(i, j) == 0) continue;
                    if (dstImage.At<byte>(i, j) == 255) continue;
                    num++;
                    //在计算过程中，考虑128为亮度均值点
                    a += (double)(dstImage.At<byte>(i, j) - 128.0);
                    int x = (int)dstImage.At<byte>(i, j);
                    bgr[x]++;
                }
            }
            // 计算像素点平均值
            double da = a / num;
            double D = Math.Abs(da);
            // 将平均值乘以每个亮度点的个数，得到整个图像的亮度值，起到均衡亮度值
            // 避免由于某个区域特别亮，导致最终计算结果偏差过大
            double Ma = 0;
            for (int i = 0; i < 256; i++)
            {
                Ma += Math.Abs(i - 128 - da) * bgr[i];
            }
            // 将整个图像的亮度值除以个数，最终得到每个像素点的亮度值
            Ma /= (double)(dstImage.Rows * dstImage.Cols);
            double M = Math.Abs(Ma) + 0.0001;
            double K = D / M;
            double cast = (da > 0) ? K : -K;
            return cast;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Cap.Open(1);
            if (!Cap.IsOpened())
            {
                MessageBox.Show("摄像头打开失败.");
                return;
            }

            Cap.Set(VideoCaptureProperties.FrameWidth, 1280);
            Cap.Set(VideoCaptureProperties.FrameHeight, 720);

            Mat Image = new Mat();
            while (true)
            {
                if (Cap.Read(Image))
                {
                    double value = BrightnessDetection(Image);
                    Cv2.PutText(Image, $"Value:{value}", new Point(10, 30), HersheyFonts.HersheyComplex, 1, new Scalar(0, 0, 255), 2);
                    Cv2.ImShow("Image", Image);
                    Cv2.WaitKey(1);
                }
            }
        }
    }
}

C++版本代码如下：

#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/Stitching.hpp"
#include <iostream>

using namespace cv;
using namespace std;

// 环境亮度值计算
double BrightnessDetection(Mat srcImage)
{
    Mat dstImage;
    cvtColor(srcImage, dstImage, COLOR_BGR2GRAY);
    // bgr保存了所有0~255个像素值的数量
    int bgr[256] = { 0 };
    // a为所有亮度值的和
    double a = 0;
    // num 为像素点个数
    int num = 0;
    for (int i = 0; i < dstImage.rows; i++)
    {
        for (int j = 0; j < dstImage.cols; j++)
        {
            // 剔除最大和最小值
            if (dstImage.at<uchar>(i, j) == 0) continue;
            if (dstImage.at<uchar>(i, j) == 255) continue;
            num++;
            //在计算过程中，考虑128为亮度均值点
            a += double(dstImage.at<uchar>(i, j) - 128);
            int x = (int)dstImage.at<uchar>(i, j);
            bgr[x]++;
        }
    }
    // 计算像素点平均值
    double da = a / num;
    double D = abs(da);

    // 将平均值乘以每个亮度点的个数，得到整个图像的亮度值，起到均衡亮度值
    // 避免由于某个区域特别亮，导致最终计算结果偏差过大
    double Ma = 0;
    for (int i = 0; i < 256; i++) {
        Ma += fabs(i - 128 - da) * bgr[i];
    }
    // 将整个图像的亮度值除以个数，最终得到每个像素点的亮度值
    Ma /= double((dstImage.rows * dstImage.cols));
    // 输出亮度值
    double M = fabs(Ma) + 0.0001;
    double K = D / M;
    double cast = (da > 0) ? K : -K;
    return cast;
}

int main()
{
    VideoCapture Cap;
    Cap.open(1);
    if (!Cap.isOpened())
        return 0;

    Cap.set(CAP_PROP_FRAME_WIDTH, 1280);
    Cap.set(CAP_PROP_FRAME_HEIGHT, 720);
    Cap.set(CAP_PROP_EXPOSURE, 0);  //曝光

    Mat srcImage;
    while (1)
    {
        Cap >> srcImage;
        if (!srcImage.empty())
        {
            double value =  BrightnessDetection(srcImage);

            putText(srcImage, "value:" + to_string(value), Point(10, 30), FONT_HERSHEY_COMPLEX, 1, Scalar(0, 0, 255), 2, LINE_AA);
            imshow("srcImage", srcImage);
            waitKey(1);
        }
    }
    return 0;
}

Python版本代码如下：

import cv2
import math


# 环境亮度值计算
def BrightnessDetection(srcImage):
    dstImage = cv2.cvtColor(srcImage, cv2.COLOR_BGR2GRAY)
    # bgr保存了所有0~255个像素值的数量
    bgr = [0] * 256
    # a为所有亮度值的和
    a = 0
    # num 为像素点个数
    num = 0

    imgH = dstImage.shape[0]
    imgW = dstImage.shape[1]
    for i in range(imgW):
        for j in range(imgH):
            # 剔除最大和最小值
            if dstImage[j, i] == 0:
                continue;
            if dstImage[j, i] == 255:
                continue;
            num = num + 1
            # 在计算过程中，考虑128为亮度均值点
            a = a + dstImage[j, i] - 128
            x = dstImage[j, i]
            bgr[x] = bgr[x] + 1

    # 计算像素点平均值
    da = a / num
    D = abs(da)

    # 将平均值乘以每个亮度点的个数，得到整个图像的亮度值，起到均衡亮度值
    # 避免由于某个区域特别亮，导致最终计算结果偏差过大
    Ma = 0;
    for i in range(256):
        Ma = Ma + math.fabs(i - 128 - da) * bgr[i]

    # 将整个图像的亮度值除以个数，最终得到每个像素点的亮度值
    Ma = Ma / (imgH * imgW)
    # 输出亮度值
    M = math.fabs(Ma) + 0.0001
    K = D / M
    cast = K if (da > 0) else -K
    return cast


# 打开摄像头
Cap = cv2.VideoCapture(0)
# 判断视频是否打开
if not Cap.isOpened():
    print('Open Camera Error.')
else:
    # 读取图像
    while True:
        grabbed, img = Cap.read()
        if img is None:
            continue

        value = BrightnessDetection(img)
        font = cv2.FONT_HERSHEY_COMPLEX  # 设置字体
        img = cv2.putText(img, "Vlaue:" + str(value), (10, 30), font, 1, (0, 0, 255), 2)

        cv2.imshow("srcImage", img)
        cv2.waitKey(1)