使用C++分析RGB和YUV格式图像的三个通道的概率分布及其熵

最新推荐文章于 2023-06-04 14:50:00 发布
最新推荐文章于 2023-06-04 14:50:00 发布
阅读量963 收藏 6
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45847421/article/details/114649510
版权

使用C++分析RGB和YUV格式图像的三个通道的概率分布及其熵

一、使用C++计算熵的方法

首先，我们要知道如何计算熵，下面给出熵的计算公式
在这里插入图片描述
按照此公式我们可以写出计算熵的函数，方便在后续计算熵时进行调用：

//计算熵的函数，shang=−∑gailv*log2(gailv)
double shang(double gailv[256])
{
    double shang = 0;
	
    for (int i = 0; i < 256; i++)
    {
        if (gailv[i] == 0)
            continue;
        shang = shang - gailv[i]*log(gailv[i])/log(2.0);//c中log函数为以e为底，所以须换底公式
    }
    return shang;
}

二、使用C++分析RGB格式的图像

1、读取图像并分离RGB三通道

rgb文件按每个像素BGR分量以此存储，所以读取方式为b，g，r，b,g,r…；并且图像分辨率为256* 256，所以b，g，r分量各分配256* 256空间

//读取图像
	unsigned char* b = new unsigned char[256*256];
	unsigned char* g = new unsigned char[256*256];
	unsigned char* r = new unsigned char[256*256];
	unsigned char* img = new unsigned char[256*256*3];
	FILE* fp = fopen("C:\\Users\\10202\\Desktop\\down.rgb", "rb");
	fread(img, sizeof(unsigned char), 256*256*3, fp);
	fclose(fp);
	for (int i = 0;i < 256*256; i++)//rgb文件按每个像素BGR分量以此存储，所以读取方式为b，g，r，b,g,r........
	{
		b[i] = img[3*i];
		g[i] = img[3*i+1];
		r[i] = img[3*i+2];
	}

2、计算RGB三通道的概率分布

因为图像是8bit，所以R，G，B分量都是0-255的256个值。所以我们可以通过代码来分别计算R、G、B中0-255各值的数量，并除以整张图像像素总数量计算其概率分布。（RGB格式图像R,G,B分量的总数为数都为256*256）


	//计算分布概率：gailv=i/256/256
	double gailvb[256] = {0};
	double gailvg[256] = {0};
	double gailvr[256] = {0};
	for (int i = 0; i < 256; i++)
	{
	    int ib = 0, ig = 0, ir = 0;
		for (int j = 0; j < 256 * 256; j++)
		{
			if ((int)b[j] == i)
				ib ++;
			if ((int)g[j] == i)
				ig ++;
			if ((int)r[j] == i)
				ir++;
		}
		gailvb[i] = (double)ib/256/256;
		gailvg[i] = (double)ig/256/256;
		gailvr[i] = (double)ir/256/256;
	}

3、计算RGB三通道的熵

可以使用在第二步计算出的R，G，B三分量的概率，并调用“熵函数”来计算熵

double shangb = 0, shangg = 0, shangr = 0;
	shangb = shang(gailvb);
	shangg = shang(gailvg);
	shangr = shang(gailvr);

4、输出RGB分量概率分布及熵值

以.txt格式分别输出R,G,B三分量的概率分布及熵值

//输出BGR分量概率分布及熵值
	FILE* datab = fopen("C:\\Users\\10202\\Desktop\\B.txt","w");//建立存放B数据
	fprintf(datab, "值	概率\n");
	FILE* datag = fopen("C:\\Users\\10202\\Desktop\\G.txt","w");//建立存放G数据
	fprintf(datag, "值	概率\n");
	FILE* datar = fopen("C:\\Users\\10202\\Desktop\\R.txt.","w");//建立存放R数据
	fprintf(datar, "值	概率\n");
	for (int i = 0;i < 256; i++)//输出概率
	{
		fprintf(datab,"%d\t%f\n",i, gailvb[i]);
		fprintf(datag,"%d\t%f\n",i, gailvg[i]);
		fprintf(datar,"%d\t%f\n",i, gailvr[i]);
	}
	fprintf(datab,"B的熵 = %f",shangb);//输出B的熵
    fprintf(datag,"G的熵 = %f",shangg);//输出G的熵
    fprintf(datar,"R的熵 = %f",shangr);//输出R的熵

得到的txt文件截图如下：
R：
在这里插入图片描述

在这里插入图片描述
G：
在这里插入图片描述

在这里插入图片描述
B：
在这里插入图片描述

在这里插入图片描述
因为未找到如何使用C++来直接生成概率分布图，所以将txt文件导入excel里之后绘制概率分布图，概率分布图如下：
在这里插入图片描述
计算出的熵值如下：

H( R )H( G )H( B )
7.2295537.1784626.856861

5、完整代码

#include "iostream"
#include"stdio.h"
#include"math.h"
using namespace std;

//计算BGR的熵函数，shang=−∑gailv*log2(gailv)
double shang(double gailv[256])
{
    double shang = 0;
	
    for (int i = 0; i < 256; i++)
    {
        if (gailv[i] == 0)
            continue;
        shang = shang - gailv[i]*log(gailv[i])/log(2.0);//c中log函数为以e为底，所以须换底公式
    }
    return shang;
}

int main()
{
	//读取图像
	unsigned char* b = new unsigned char[256*256];
	unsigned char* g = new unsigned char[256*256];
	unsigned char* r = new unsigned char[256*256];
	unsigned char* img = new unsigned char[256*256*3];
	FILE* fp = fopen("C:\\Users\\10202\\Desktop\\down.rgb", "rb");
	fread(img, sizeof(unsigned char), 256*256*3, fp);
	fclose(fp);
	for (int i = 0;i < 256*256; i++)//rgb文件按每个像素BGR分量以此存储，所以读取方式为b，g，r，b,g,r........
	{
		b[i] = img[3*i];
		g[i] = img[3*i+1];
		r[i] = img[3*i+2];
	}

	//计算分布概率：gailv=i/256/256
	double gailvb[256] = {0};
	double gailvg[256] = {0};
	double gailvr[256] = {0};
	for (int i = 0; i < 256; i++)
	{
	    int ib = 0, ig = 0, ir = 0;
		for (int j = 0; j < 256 * 256; j++)
		{
			if ((int)b[j] == i)
				ib ++;
			if ((int)g[j] == i)
				ig ++;
			if ((int)r[j] == i)
				ir++;
		}
		gailvb[i] = (double)ib/256/256;
		gailvg[i] = (double)ig/256/256;
		gailvr[i] = (double)ir/256/256;
	}

	//计算熵，引用熵函数
	double shangb = 0, shangg = 0, shangr = 0;
	shangb = shang(gailvb);
	shangg = shang(gailvg);
	shangr = shang(gailvr);

	//输出BGR分量概率分布及熵值
	FILE* datab = fopen("C:\\Users\\10202\\Desktop\\B.txt","w");//建立存放B数据
	fprintf(datab, "值	概率\n");
	FILE* datag = fopen("C:\\Users\\10202\\Desktop\\G.txt","w");//建立存放G数据
	fprintf(datag, "值	概率\n");
	FILE* datar = fopen("C:\\Users\\10202\\Desktop\\R.txt.","w");//建立存放R数据
	fprintf(datar, "值	概率\n");
	for (int i = 0;i < 256; i++)//输出概率
	{
		fprintf(datab,"%d\t%f\n",i, gailvb[i]);
		fprintf(datag,"%d\t%f\n",i, gailvg[i]);
		fprintf(datar,"%d\t%f\n",i, gailvr[i]);
	}
	fprintf(datab,"B的熵 = %f",shangb);//输出B的熵
    fprintf(datag,"G的熵 = %f",shangg);//输出G的熵
    fprintf(datar,"R的熵 = %f",shangr);//输出R的熵


	fclose(datab);
	fclose(datag);
	fclose(datar);
}

三、使用C++分析YUV格式的图像

1、读取图像并分离RGB三通道

YUV按照全部像素Y数据块、U数据块、V数据块依次存放，且为4：2：0采样，所以读取方式为YYYY…,U…,V…；并且图像分辨率为256* 256，所以Y分配空间为256* 256，U、V分配空间为256*256/4

//读取图像
	unsigned char* y = new unsigned char[256*256];
	unsigned char* u = new unsigned char[256*256/4];
	unsigned char* v = new unsigned char[256*256/4];
	unsigned char* img = new unsigned char[256*256*3/2];
	FILE* fp = fopen("C:\\Users\\10202\\Desktop\\down.yuv", "rb");
	fread(img, sizeof(unsigned char), 256*256*3/2, fp);
	fclose(fp);
	for (int i = 0;i < 256*256; i++)//YUV按照全部像素Y数据块、U数据块、V数据块依次存放，且为4：2：0采样，所以读取方式为YYYY...,U...,V...
	{
		y[i] = img[i];
	}
	for (int i = 0;i < 256*256/4; i++)
	{
		u[i] = img[i+256*256];
		v[i] = img[i+256*256*5/4];
	}

2、计算YUV三通道的概率分布

因为图像是8bit，所以Y，U，V分量都是0-255的256个值。所以我们可以通过代码来分别计算Y、U、V中0-255各值的数量，并分别各自除以各自的总数量计算其概率分布。（要注意的是与RGB格式图像不同，YUV格式图像Y分量的总数为256* 256，U分量的总数为256* 256/4，V分量的总数为256* 256/4）

//计算分布概率：gailv=i/总数（Y为256*256，U、V为256*256/4）
	double gailvy[256] = {0};
	double gailvu[256] = {0};
	double gailvv[256] = {0};
	for (int i = 0; i < 256; i++)
	{
	    int iy = 0;
		for (int j = 0; j < 256 * 256; j++)
		{
			if ((int)y[j] == i)
				iy ++;
		}
		gailvy[i] = (double)iy/256/256;
	}
	for (int i = 0; i < 256; i++)
	{
	    int iu = 0, iv = 0;
		for (int j = 0; j < 256*256/4 ; j++)
		{
			if ((int)u[j] == i)
				iu ++;
			if ((int)v[j] == i)
				iv++;
		}
	
		
		gailvu[i] = (double)iu/256/256*4;
		gailvv[i] = (double)iv/256/256*4;
	}

3、计算YUV三通道的熵

可以使用在第二步计算出的Y，U，V三分量的概率，并调用“熵函数”来计算熵

//计算熵，引用熵函数
	double shangy = 0, shangu = 0, shangv = 0;
	shangy = shang(gailvy);
	shangu = shang(gailvu);
	shangv = shang(gailvv);

4、输出RGB分量概率分布及熵值

以.txt格式分别输出Y,U,V三分量的概率分布及熵值

//输出YUV分量概率分布及熵值
	FILE* datay = fopen("C:\\Users\\10202\\Desktop\\Y.txt","w");//建立存放Y数据
	fprintf(datay, "值	概率\n");
	FILE* datau = fopen("C:\\Users\\10202\\Desktop\\U.txt","w");//建立存放U数据
	fprintf(datau, "值	概率\n");
	FILE* datav = fopen("C:\\Users\\10202\\Desktop\\V.txt","w");//建立存放V数据
	fprintf(datav, "值	概率\n");
	for (int i = 0;i < 256; i++)//输出概率
	{
		fprintf(datay,"%d\t%f\n",i, gailvy[i]);
		fprintf(datau,"%d\t%f\n",i, gailvu[i]);
		fprintf(datav,"%d\t%f\n",i, gailvv[i]);
	}
	fprintf(datay,"Y的熵 = %f",shangy);//输出B的熵
    fprintf(datau,"U的熵 = %f",shangu);//输出G的熵
    fprintf(datav,"V的熵 = %f",shangv);//输出R的熵

得到的txt文件截图如下：
Y：
在这里插入图片描述

在这里插入图片描述
U：
在这里插入图片描述

在这里插入图片描述
V:
在这里插入图片描述

在这里插入图片描述
因为未找到如何使用C++来直接生成概率分布图，所以将txt文件导入excel里之后绘制概率分布图，概率分布图如下：
在这里插入图片描述
计算出的熵值如下：

H( Y )H( U )H( V )
6.3318195.1264024.113143

5、完整代码

#include "iostream"
#include"stdio.h"
#include"math.h"
using namespace std;

//计算YUV的熵函数，shang=−∑gailv*log2(gailv)
double shang(double gailv[256])
{
    double shang = 0;
	
    for (int i = 0; i < 256; i++)
    {
        if (gailv[i] == 0)
            continue;
        shang = shang - gailv[i]*log(gailv[i])/log(2.0);//c中log函数为以e为底，所以须换底公式
    }
    return shang;
}

int main()
{
	//读取图像
	unsigned char* y = new unsigned char[256*256];
	unsigned char* u = new unsigned char[256*256/4];
	unsigned char* v = new unsigned char[256*256/4];
	unsigned char* img = new unsigned char[256*256*3/2];
	FILE* fp = fopen("C:\\Users\\10202\\Desktop\\down.yuv", "rb");
	fread(img, sizeof(unsigned char), 256*256*3/2, fp);
	fclose(fp);
	for (int i = 0;i < 256*256; i++)//YUV按照全部像素Y数据块、U数据块、V数据块依次存放，且为4：2：0采样，所以读取方式为YYYY...,U...,V...
	{
		y[i] = img[i];
	}
	for (int i = 0;i < 256*256/4; i++)
	{
		u[i] = img[i+256*256];
		v[i] = img[i+256*256*5/4];
	}
	
	//计算分布概率：gailv=i/总数（Y为256*256，U、V为256*256/4）
	double gailvy[256] = {0};
	double gailvu[256] = {0};
	double gailvv[256] = {0};
	for (int i = 0; i < 256; i++)
	{
	    int iy = 0;
		for (int j = 0; j < 256 * 256; j++)
		{
			if ((int)y[j] == i)
				iy ++;
		}
		gailvy[i] = (double)iy/256/256;
	}
	for (int i = 0; i < 256; i++)
	{
	    int iu = 0, iv = 0;
		for (int j = 0; j < 256*256/4 ; j++)
		{
			if ((int)u[j] == i)
				iu ++;
			if ((int)v[j] == i)
				iv++;
		}
	
		
		gailvu[i] = (double)iu/256/256*4;
		gailvv[i] = (double)iv/256/256*4;
	}

	//计算熵，引用熵函数
	double shangy = 0, shangu = 0, shangv = 0;
	shangy = shang(gailvy);
	shangu = shang(gailvu);
	shangv = shang(gailvv);

	//输出YUV分量概率分布及熵值
	FILE* datay = fopen("C:\\Users\\10202\\Desktop\\Y.txt","w");//建立存放Y数据
	fprintf(datay, "值	概率\n");
	FILE* datau = fopen("C:\\Users\\10202\\Desktop\\U.txt","w");//建立存放U数据
	fprintf(datau, "值	概率\n");
	FILE* datav = fopen("C:\\Users\\10202\\Desktop\\V.txt","w");//建立存放V数据
	fprintf(datav, "值	概率\n");
	for (int i = 0;i < 256; i++)//输出概率
	{
		fprintf(datay,"%d\t%f\n",i, gailvy[i]);
		fprintf(datau,"%d\t%f\n",i, gailvu[i]);
		fprintf(datav,"%d\t%f\n",i, gailvv[i]);
	}
	fprintf(datay,"Y的熵 = %f",shangy);//输出B的熵
    fprintf(datau,"U的熵 = %f",shangu);//输出G的熵
    fprintf(datav,"V的熵 = %f",shangv);//输出R的熵


	fclose(datay);
	fclose(datau);
	fclose(datav);
}

四、总结

由计算结果不难看出，YUV格式的三分量的熵要小于RGB格式的三分量的熵，且YUV为4:2:0格式，可知YUV格式图像占空间更小。实际情况下此次两张图YUV格式图像大小98,304 字节，RGB格式图像大小196,608 字节，YUV格式图像大小小于RGB格式图像大小，占用空间更少，与计算结果相吻合。
通过此次实验进一步验证了两种图像格式，并且熟悉巩固了C++语言的使用，为后续进一步学习数据压缩打下了基础。

黑色糖渣
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【opencv-c++】cv::split通道分离
jn10010537的博客
10-04 1498
opencv读取的图像是BGR色彩空间，第一个通道是蓝色通道Blur，第二个通道是绿色通道Green，第三个通道是红色通道Red，和我们传统意义上的RGB相反。OutputArrayOfArrays的mv，输出的vector容器，装载不同通道的图像信息。我们可以分别分离出BGR各个通道，通道分离之后，就变成单通道的灰度图像了。opencv中实现图像通道的分离的函数分别是cv::split()。InputArray类型的m，输入的需要分离通道的图像。通道的分离是图像操作的基础操作。
【数字图像处理实验二】：RGB图3个通道的提取、RGB图转灰度图、图片反转、图片亮度调整、直方图显示
热门推荐
Stick_2
07-03 1万+
这里介绍：RGB图3个通道的提取、RGB图转灰度图、图片反转、图片亮度调整具体操作，需导入的库如下： 原图如下： 结果如下，从左到右分别是：Red，Green，Blue 这里借助skimage库中的exposure函数来进行图像亮度的调整 结果如下：.........
【数字图像处理】OpenCV-C++-计算图像的熵值
weixin_44211644的博客
11-23 1970
学习记录 2022.11.23
图像BGR通道的拆分与合并
零木的博客
10-30 6308
通道的分离与合并 使用的函数： cv.split(src) 作用： 将彩色图像，分成b、g、r  3个单通道图像 。 方便我们对 BGR 三个通道分别进行操作。   参数：是需要分离通道的图像数组。   注意： 1   cv2.split() 是一个比较耗时的操作。只有真正需要时才用它，能用numpy的方式，修改多通道里的某个通道的值，就用numpy 2   3个单通道的图像...
C++ OpenCV 基本函数（memcpy 内存拷贝、split多通道分离、merge多通道合并函数 ）
weixin_39451323的博客
11-23 5306
OpenCV 基本函数memcpy 内存拷贝split多通道分离 用实现照片底片化的例子介绍一些基本函数 所谓照片底片化，就是将图像每个像素的RGB三个通道取反，如果是256色，就是R’=255-R, G’=255-G, B’=255-B，如果是0.0-1.0的颜色空间，就是R’=1.0-R, G’=1.0-G, B’=1.0-B。通过上述描述，可得出算法：遍历每个像素点RGB值-重新计算-生成图像 memcpy 内存拷贝 原始图像： /#include<iostream> #include
基于C++的RGB与YUV之间的相互转换设计与实现
05-12
基于C++的RGB与YUV之间的相互转换设计与实现
C/C++源码,图像RGB转换为YUV420sp和YUV420sp格式转换为YUV422
10-26
C/C++ 源码，图像RGB格式转换为YUV420格式和图像YUV420sp格式转换为YUV422，亲测有效，已经得到验证过
YUV2RGB.rar_matlab图像处理_yuv2rgb_yuv2rgb avi_yuv2rgb24_yuy2图片格式
09-24
标签中的`yuv2rgb`和`yuy2图片格式`进一步强调了这个主题的核心，即处理YUY2格式的YUV数据并将其转换为RGB格式。`matlab图像处理`则表明这是在MATLAB环境下完成的，MATLAB提供了强大的图像处理工具箱，使得这样的...
444_rgb_rgb888图像格式_rgb_RGB888对比YUV444_YCbCr444转RGB888_ycbcr转rgb8
10-02
RGB888是一种常见的颜色表示方式，它使用三个通道（红、绿、蓝）来表示每个像素的颜色，每个通道用8位二进制数表示，总共24位。这种格式能够呈现16777216种不同的颜色，即256（2^8）的三次方。 相比之下，YUV和...
RGB2YUV.rar_rgb2yuv_视频格式转换
09-24
描述中提到的"rgb2yuv.cpp"是一个C++源代码文件，很可能实现了一个将RGB图像或视频帧转换为YUV格式的程序。通过编译这个源代码，用户可以在自己的系统上执行RGB到YUV的转换操作。 RGB和YUV之间的转换涉及到色彩空间...
Opencv函数--split（获取彩色图像三通道）
chenkent888的专栏
10-04 2685
1、split函数的主要功能是把一个彩色图像分割成3个通道，方便进一步的图像处理，具体说明如下： C++: void split(const Mat& mtx, Mat* mv) C++: void split(const Mat& mtx, vector& mv) 2、还有一个函数merge可以实现相反的操作： C++: void merge(const Mat* mv, s
图像处理之通道分离与合并
ZXM_SHU
07-03 1743
通道分离 目的：将彩色图像，分成b、g、r 3个单通道图像。方便我们对BGR 三个通道分别进行操作。 函数：cv2.split(img) 参数说明：参数1：待分离通道的图像 Python代码实现 #加载opencv import cv2 src=cv2.imread('split.jpg') cv2.imshow('before',src) #调用通道分离 b,g,r=cv2.split(src) #三通道分别显示 cv2.imshow('blue',b) cv2.imshow('green',g) cv2
C++ 使用Opencv实现分通道图像滤波
qwqwfqfasf的博客
07-13 1376
c++实现图像分通道滤波
C/C++开发，opencv读写图像函数详解
最新发布
技术需要分享
06-04 9755
C/C++开发，opencv读写图像函数详解，给出如何读取不同图片格式及指定图片flag，如何将图像数据存储为不同图片格式及指定图片flag。
C++Opencv通道的分离、合并和混合
qq_45373844的博客
11-12 2193
C++Opencv通道的分离、合并和混合
Opencv学习笔记（十三）图像通道拆分、合并、边界填充
weixin_43170082的博客
04-13 196
文章目录代码 图像通道拆分是将BGR拆分为三个独立的单通道。 通道合并是将独立的单通道合并为BGR图像。 边界填充是是对图像的四周以不同的方式进行扩充。 代码 import cv2 import numpy as np from matplotlib import pyplot as plt src = cv2.imread(r'F:\OPENCV\Opencv\lenna.jpg', cv2.IMREAD_COLOR) if src is None: print('image is empty')
【学习OpenCV4】图像通道的分离、合并与混合方法（C++）
Huffie博客
07-20 1453
图像通道的分离后输出的多通道序列一般使用 std::vector<Mat> mv; 来存储，mv[0] 、mv[1]、mv[2]、分别对应BGR三个通道。但是现在显示的相当于是三张单通道的图像，也就相当于三张灰度图像。要想让三张图像恢复直观意义上的色彩，就需要使用下面通道合并的方法了。
c++ opencv 分离r,g,b三通道
脚踏实地
09-26 9447
今天学习了c++ opencv 分离通道的方法 ，操作很奇怪的...       Mat bgr_res[3]; Mat bgr[3]; for( int j = 0 ; j < 3; j++) { split(src, bgr); for (int i=0; i<3; ++i) { if (i != j ) bgr[i] = Mat::zeros(src.
OpenCV笔记之六（4）——图像处理之颜色通道拆分、合并及颜色空间
东寻的博客
03-21 8802
1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值