彩色空间转换

最新推荐文章于 2022-11-09 13:40:57 发布
最新推荐文章于 2022-11-09 13:40:57 发布
阅读量211 收藏
点赞数 1
分类专栏： 数据压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50794483/article/details/114971247
版权
本文档详细介绍了如何编程实现YUV与RGB彩色空间的互换，包括实验目的、原理、步骤、代码实现以及实验总结。通过公式推导、码电平分配和色度格式4:2:2的讲解，阐述了转换过程，并提供了实验代码示例。
摘要由CSDN通过智能技术生成

编程实现YUV与RGB空间的互换

1．基本要求（必做）：编写RGB转化为YUV程序，重点掌握函数定义，部分查找表的初始化和调用，缓冲区分配。将得到的RGB文件转换为YUV文件，用YUV Viewer播放器观看，验证是否正确。
2．提高要求（可选）：编写将YUV转换为RGB的程序。将给定的实验数据用该程序转换为RGB文件。并与原RGB文件进行比较，如果有误差，分析误差来自何处

一、实验目的

1、学会从计算和程序的角度分析问题
2、进一步理解彩色空间的概念并掌握不同彩色空间转换的基本方程
3、通过逐步设计程序，掌握编程细节：如查找表的设计，内存分配，对U和V信号进行下采样，文件读写过程等。掌握程序调试的基本方法。

二、实验原理

1.公式推导

（1）由电视原理可知，亮度和色差信号的构成如下：

  • Y＝0.2990R+0.5870G+0.1140B
  • R-Y＝0.7010R-0.5870G-0.1140B
  • B-Y＝-0.2990R-0.5870G+0.8860B

（2）为了使色差信号的动态范围控制在0.5之间，需要进行归一化，对色差信号引入压缩系数。归一化后的色差信号为：

  • U＝-0.1684R-0.3316G+0.5B
  • V＝0.5R-0.4187G-0.0813B

（3）由RGB转YUV的公式可推出YUV转RGB的公式如下：

  • R = Y + 1.4075(V - 128)
  • G = Y - 0.3455(U - 128) - 0.7169(V - 128)
  • B = Y + 1.779(U - 128)

2.码电平分配及表达式

  • 亮度信号
    亮电平信号量化后码电平分配在对分量信号进行8比特均匀量化时，共分为256个等间隔的量化级。为了防止信号变动造成过载，在256级上端留20级，下端留16级作为信号超越动态范围的保护带。
    在这里插入图片描述

  • 色差信号
    色差信号量化后码电平分配色差信号经过归一化处理后，动态范围为-0.5－0.5，让色差零电平对应码电平128，色差信号总共占225个量化级。在256级上端留15级，下端留16级作为信号超越动态范围的保护带。在这里插入图片描述在这里插入图片描述

3.色度格式4：2：2

指色差信号U，V的取样频率为亮度信号取样频率的四分之一，在水平方向和垂直方向上的取样点数均为Y的一半

4.转换原理

在这里插入图片描述

三、实验步骤

  1. 根据实验原理，初步理解如何转换
  2. 由rgb2yuv的例子理解代码
  3. 根据yuv2rgb的转换思想，借鉴rgb2yuv代码的细节处理，书写代码
  4. 运行调试，发现错误，解决问题
  5. 总结分析转换后的文件与原文件的差别。如果有误差，分析误差来源

四、实验代码

1.RGB2YUV（例子）

在这里插入图片描述

  • rgb2yuv.h
int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip);

void InitLookupTable();
  • rgb2yuv.cpp
/* This file contains RGB to YUV transformation functions.                */

#include "stdlib.h"
#include "rgb2yuv.h"

static float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
static float RGBYUV01684[256], RGBYUV03316[256];
static float RGBYUV04187[256], RGBYUV00813[256];


/************************************************************************
 *
 *  int RGB2YUV (int x_dim, int y_dim, void *bmp, YUV *yuv)
 *
 *	Purpose :	It takes a 24-bit RGB bitmap and convert it into
 *				YUV (4:2:0) format
 *
 *  Input :		x_dim	the x dimension of the bitmap
 *				y_dim	the y dimension of the bitmap
 *				bmp		pointer to the buffer of the bitmap
 *				yuv		pointer to the YUV structure
 *
 *  Output :	0		OK
 *				1		wrong dimension
 *				2		memory allocation error
 *
 *	Side Effect :
 *				None
 *
 *	Date :		09/28/2000
 *
 *  Contacts:
 *
 *  Adam Li
 *
 *  DivX Advance Research Center <darc@projectmayo.com>
 *
 ************************************************************************/

int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip)
{
	static int init_done = 0;

	long i, j, size;
	unsigned char *r, *g, *b;
	unsigned char *y, *u, *v;
	unsigned char *pu1, *pu2, *pv1, *pv2, *psu, *psv;
	unsigned char *y_buffer, *u_buffer, *v_buffer;
	unsigned char *sub_u_buf, *sub_v_buf;

	if (init_done == 0)
	{
		InitLookupTable();
		init_done = 1;
	}

	// check to see if x_dim and y_dim are divisible by 2
	if ((x_dim % 2) || (y_dim % 2)) return 1;
	size = x_dim * y_dim;

	// allocate memory
	y_buffer = (unsigned char *)y_out;
	sub_u_buf = (unsigned char *)u_out;
	sub_v_buf = (unsigned char *)v_out;
	u_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
	v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
	if (!(u_buffer && v_buffer))
	{
		if (u_buffer) free(u_buffer);
		if (v_buffer) free(v_buffer);
		return 2;
	}

	b = (unsigned char *)bmp;
	y = y_buffer;
	u = u_buffer;
	v = v_buffer;

	// convert RGB to YUV
	if (!flip) {
		for (j = 0; j < y_dim; j ++)
		{
			y = y_buffer + (y_dim - j - 1) * x_dim;
			u = u_buffer + (y_dim - j - 1) * x_dim;
			v = v_buffer + (y_dim - j - 1) * x_dim;

			for (i = 0; i < x_dim; i ++) {
				g = b + 1;
				r = b + 2;
				*y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
				*u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
				*v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
				b += 3;
				y ++;
				u ++;
				v ++;
			}
		}
	} else {
		for (i = 0; i < size; i++)
		{
			g = b + 1;
			r = b + 2;
			*y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
			*u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
			*v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
			b += 3;
			y ++;
			u ++;
			v ++;
		}
	}

	// subsample UV
	for (j = 0; j < y_dim/2; j ++)
	{
		psu = sub_u_buf + j * x_dim / 2;
		psv = sub_v_buf + j * x_dim / 2;
		pu1 = u_buffer + 2 * j * x_dim;
		pu2 = u_buffer + (2 * j + 1) * x_dim;
		pv1 = v_buffer + 2 * j * x_dim;
		pv2 = v_buffer + (2 * j + 1) * x_dim;
		for (i = 0; i < x_dim/2; i ++)
		{
			*psu = (*pu1 + *(pu1+1) + *pu2 + *(pu2+1)) / 4;
			*psv = (*pv1 + *(pv1+1) + *pv2 + *(pv2+1)) / 4;
			psu ++;
			psv ++;
			pu1 += 2;
			pu2 += 2;
			pv1 += 2;
			pv2 += 2;
		}
	}

	free(u_buffer);
	free(v_buffer);

	return 0;
}


void InitLookupTable()
{
	int i;

	for (i = 0; i < 256; i++) RGBYUV02990[i] = (float)0.2990 * i;
	for (i = 0; i < 256; i++) RGBYUV05870[i] = (float)0.5870 * i;
	for (i = 0; i < 256; i++) RGBYUV01140[i] = (float)0.1140 * i;
	for (i = 0; i < 256; i++) RGBYUV01684[i] = (float)0.1684 * i;
	for (i = 0; i < 256; i++) RGBYUV03316[i] = (float)0.3316 * i;
	for (i = 0; i < 256; i++) RGBYUV04187[i] = (float)0.4187 * i;
	for (i = 0; i < 256; i++) RGBYUV00813[i] = (float)0.0813 * i;
}
  • main.cpp
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "rgb2yuv.h"

#define u_int8_t	unsigned __int8
#define u_int		unsigned __int32
#define u_int32_t	unsigned __int32
#define FALSE		false
#define TRUE		true

/*
 * rgb2yuv
 * required arg1 should be the input RAW RGB24 file
 * required arg2 should be the output RAW YUV12 file
 */ 
int main(int argc, char** argv)
{
	/* variables controlable from command line */
	u_int frameWidth = 352;			/* --width=<uint> */
	u_int frameHeight = 240;		/* --height=<uint> */
	bool flip = TRUE;				/* --flip */
	unsigned int i;

	/* internal variables */
	char* rgbFileName = NULL;
	char* yuvFileName = NULL;
	FILE* rgbFile = NULL;
	FILE* yuvFile = NULL;
	u_int8_t* rgbBuf = NULL;
	u_int8_t* yBuf = NULL;
	u_int8_t* uBuf = NULL;
	u_int8_t* vBuf = NULL;
	u_int32_t videoFramesWritten = 0;

	/* begin process command line */
	/* point to the specified file names */
	rgbFileName = argv[1];
	yuvFileName = argv[2];

	frameWidth = atoi(argv[3]);
	frameHeight = atoi(argv[4]);
	
	/* open the RGB file */
	rgbFile = fopen(rgbFileName, "rb");
	if (rgbFile == NULL)
	{
		printf("cannot find rgb file\n");
		exit(1);
	}
	else
	{
		printf("The input rgb file is %s\n", rgbFileName);
	}

	/* open the RAW file */
	yuvFile = fopen(yuvFileName, "wb");
	if (yuvFile == NULL)
	{
		printf("cannot find yuv file\n");
		exit(1);
	}
	else
	{
		printf("The output yuv file is %s\n", yuvFileName);
	}

	/* get an input buffer for a frame */
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

	/* get the output buffers for a frame */
	yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

	if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
	{
		printf("no enought memory\n");
		exit(1);
	}

	while (fread(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile)) 
	{
		if(RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
		{
			printf("error");
			return 0;
					}

		for (i = 0; i < frameWidth*frameHeight; i++)
		{
			if (yBuf[i] < 16) yBuf[i] = 16;
			if (yBuf[i] > 235) yBuf[i] = 235;
		}

		for (i = 0; i < frameWidth*frameHeight/4; i++)
		{
			if (uBuf[i] < 16) uBuf[i] = 16;
			if (uBuf[i] > 240) uBuf[i] = 240;

			if (vBuf[i] < 16) vBuf[i] = 16;
			if (vBuf[i] > 240) vBuf[i] = 240;
		}

		fwrite(yBuf, 1, frameWidth * frameHeight, yuvFile);
		fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);
		fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);

		printf("\r...%d", ++videoFramesWritten);
	}

	printf("\n%u %ux%u video frames written\n", 
		videoFramesWritten, frameWidth, frameHeight);

	/* cleanup */

	fclose(rgbFile);
	fclose(yuvFile);

	return(0);
}

down.rgb
在这里插入图片描述

out.yuv
在这里插入图片描述

2.YUV2RGB

在这里插入图片描述

  • yuv2rgb.h
int YUV2RGB(int x_dim, int y_dim, void* bmp, void* y_out, void* u_out, void* v_out, int flip);

void InitLookupTable();
  • yuv2rgb.cpp

/* This file contains RGB to YUV transformation functions.                */

#include "stdlib.h"
#include "yuv2rgb.h"

static float YUVRGB14075[256];
static float YUVRGB03455[256], YUVRGB07169[256];
static float YUVRGB1779[256];

int YUV2RGB(int width, int height, void* rgb_out, void* y_in, void* u_in, void* v_in, int flip)
{
	static int init_done = 0;

	long i, j, size;
	float r1, g1, b1;
	unsigned char* r, * g, * b;
	unsigned char* y, * u, * v;
	unsigned char* y_buffer, * u_buffer, * v_buffer, * rgb_buffer;
	unsigned char* sub_u_buf, * sub_v_buf;

	if (init_done == 0)
	{
		InitLookupTable();
		init_done = 1;
	}

	// 检查width和height能否被2除尽
	if ((width % 2) || (height % 2)) return 1;
	size = width * height;

	// allocate memory分配内存
	y_buffer = (unsigned char*)y_in;
	u_buffer = (unsigned char*)u_in;
	v_buffer = (unsigned char*)v_in;
	rgb_buffer = (unsigned char*)rgb_out;
	sub_u_buf = (unsigned char*)malloc(size);
	sub_v_buf = (unsigned char*)malloc(size);

	for (i = 0; i < height; i++)
	{
		for (j = 0; j < width; j++)
		{
			*(sub_u_buf + i * width + j) = *(u_buffer + (i / 2) * (width / 2) + j / 2);
			*(sub_v_buf + i * width + j) = *(v_buffer + (i / 2) * (width / 2) + j / 2);
		}
	}

	b = rgb_buffer;//RGB格式文件储存时顺序为倒序
	y = y_buffer;
	u = sub_u_buf;
	v = sub_v_buf;

	// convert YUV to RGB    
	for (i = 0; i < height; i++)
	{
		for (j = 0; j < width; j++)
		{
			g = b + 1;
			r = b + 2;
			r1 = *y + YUVRGB14075[*v];
			g1 = *y - YUVRGB03455[*u] - YUVRGB07169[*v];
			b1 = *y + YUVRGB1779[*u];
			*r = (r1 > 0 ? (r1 > 255 ? 255 : (unsigned char)r1) : 0);
			*g = (g1 > 0 ? (g1 > 255 ? 255 : (unsigned char)g1) : 0);
			*b = (b1 > 0 ? (b1 > 255 ? 255 : (unsigned char)b1) : 0);
			b = b + 3;
			y++;
			u++;
			v++;
		}
	}
	if (sub_u_buf != NULL) free(sub_u_buf);
	if (sub_v_buf != NULL) free(sub_v_buf);



	return 0;
}


void InitLookupTable()
{
	int i;

	for (i = 0; i < 256; i++) YUVRGB14075[i] = (float)1.4075 * (i - 128);
	for (i = 0; i < 256; i++) YUVRGB03455[i] = (float)0.3455 * (i - 128);
	for (i = 0; i < 256; i++) YUVRGB07169[i] = (float)0.7169 * (i - 128);
	for (i = 0; i < 256; i++) YUVRGB1779[i] = (float)1.779 * (i - 128);

}
  • main.cpp
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>  
#include <malloc.h>
#include "yuv2rgb.h"

#define u_int8_t	unsigned __int8  //1个字节
#define u_int		unsigned __int32  //4个字节
#define u_int32_t	unsigned __int32
#define FALSE		false
#define TRUE		true

//为了防止不同编译系统的int语法不同
int main(int argc, char* argv[])
{
	/* variables controlable from command line */
	u_int frameWidth = 352;			/* --width=<uint> */
	u_int frameHeight = 240;		/* --height=<uint> */
	bool flip = TRUE;				/* --flip */
	unsigned int i;

	//声明指针
	char* rgbFileName = NULL;
	char* yuvFileName = NULL;
	FILE* rgbFile = NULL;
	FILE* yuvFile = NULL;
	u_int8_t* rgbBuf = NULL;
	u_int8_t* yBuf = NULL;
	u_int8_t* uBuf = NULL;
	u_int8_t* vBuf = NULL;
	u_int32_t videoFramesWritten = 0;

	//分配参数
	yuvFileName = argv[1];
	rgbFileName = argv[2];

	frameWidth = atoi(argv[3]);   //将字符型的256转换成整型
	frameHeight = atoi(argv[4]);

	//打开yuv文件
	yuvFile = fopen(yuvFileName, "rb");
	if (yuvFile == NULL)
	{
		printf("cannot find yuv file\n");
		exit(1);
	}
	else
	{
		printf("The input yuv file is %s\n", yuvFileName);
	}

	//创建rgb文件
	rgbFile = fopen(rgbFileName, "wb");
	if (rgbFile == NULL)
	{
		printf("cannot find rgb file\n");
		exit(1);
	}
	else
	{
		printf("The output rgb file is %s\n", rgbFileName);
	}

	// 分配指定内存空间，获得帧输入缓冲区
	rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);  

	//分配内存空间，获得帧输出缓冲区。注意4:2:2格式
	yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
	uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
	vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

	//判断buffer是否已满
	if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
	{
		printf("no enought memory\n");
		exit(1);
	}
	
	//若fread读入成功，则返回十几读取的数据量个数。若视频结束，fread读取失败则返回0，循环结束。
	while (fread(yBuf, 1, frameWidth * frameHeight, yuvFile)
		&& fread(uBuf, 1, frameWidth * frameHeight / 4, yuvFile)
		&& fread(vBuf, 1, frameWidth * frameHeight / 4, yuvFile))
	{
				if (YUV2RGB(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
		{
			printf("error");
			return 0;
		}
		fwrite(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile);


		printf("\r...%d", ++videoFramesWritten);
	}

	printf("\n%u %ux%u video frames written\n",
		videoFramesWritten, frameWidth, frameHeight);



	//关闭释放文件
	fclose(rgbFile);
	fclose(yuvFile);
	if (rgbBuf != NULL)free(rgbBuf);
	if (yBuf != NULL)free(yBuf);
	if (uBuf != NULL)free(uBuf);
	if (vBuf != NULL)free(vBuf);

	return(0);
}

在这里插入图片描述
down.yuv
在这里插入图片描述
out.rgb
在这里插入图片描述

五、实验总结

由以上四图分别比较，rgb原图与经过yuv转换后的rgb图片基本一致；yuv原图与经过rgb转换后的yuv图片基本一致
在这里插入图片描述

六、问题解决

在编程中我遇到如下问题，下列是解决办法，供同样遇到的同学参考：

  1. ‘fopen’: This function or variable may be unsafe
  • 解决：添加如下语句：#define_CRT_SECURE_NO_WARNINGS
    （注意在代码第一行添加，我在后面添加不知道为啥运行发生了错误，调整位置就好了）
  1. rgb与yuv互换时，要注意调整如下命令参数：
  • rgb2yuv
    在这里插入图片描述
  • yuv2rgb
    在这里插入图片描述
  • 嵌入清单调节为否在这里插入图片描述
小帆每天加油吖
关注
专栏目录
色彩空间类型转换
weixin_56894534的博客
06-27 326
© Fu Xianjun. All Rights Reserved. RGB图像是一种比较常见的色彩空间类型，还有一些比较常见的色彩空间包括GRAY色彩空间（灰度图像），XYZ色彩空间，YCrC色彩空间，HSV色彩空间，HLS色彩空间，CIEL*a*b*色彩空间，CIEL*u*v*色彩空间，Bayer色彩空间等。 色彩空间类型转换：指将图像从一个色彩空间转换到另一个色彩空间。 在一些应用中，需要将色彩空间的图像转换为二值图像。 色彩空间也称为*颜色空间，彩色空间，颜色模型，色彩系统，彩色模型，色彩模型.
数据压缩实验一：彩色空间转换
weixin_43503346的博客
03-24 163
一、实验目的 1.学会从计算和程序的角度分析问题，通过完成本实验，理解计算思维，即从问题出发，通过逐步分析和分解，把原问题转化 为可用程序方式解决的问题。在此过程中设计出一个解决方案。 2.进一步理解彩色空间的概念并掌握不同彩色空间转换的基本方程。 3.通过逐步设计程序，掌握编程细节:如查找表的设计，内存分配，对 U 和 V 信号进 行下采样，文件读写过程等。掌握程序调试的基本方法。 二、实验内容 掌握彩色空间转换的基本思想及转换公式 (1)YUV与RGB空间的相互转换 由电视原理可知，亮度和色差信号的构成
PIE SDK彩色空间变换
weixin_34221073的博客
01-03 136
1. 算法功能简介 使用彩色空间变换工具可以将三波段红、绿、蓝图像变换到一个特定的彩色空间，并且能从所选彩色空间变换回 RGB。两次变换之间，通过对比度拉伸，可以生成一个色彩增强的彩色合成图像。此外，颜色亮度值波段或亮度波段可以被另一个波段（通常具有较高的空间分辨率）代替，生成一幅合成图像（将一幅图像的色彩特征与另一幅图像的空间特征相结合）。 彩色变换的一般工作流程：选择...
彩色空间转换实验1
08-08
在进行彩色空间转换实验时，我们常常会涉及不同的颜色模型，比如从RGB转换到YUV。RGB（红绿蓝）是一种加性颜色模型，广泛应用于显示器，而YUV（亮度、色差U、色差V）是电视和视频常用的减性颜色模型，尤其在处理彩色...
rgb2hsi.zip_rgb-hsi_rgb2hsi_彩色空间_彩色空间转换
07-13
彩色空间转换在很多场景下都有用武之地，比如： 1. **色彩分析**：HSI空间更容易分析颜色特性，如区分颜色类别。 2. **图像增强**：通过调整HSI分量，可以实现色彩平衡、对比度增强等效果。 3. **图像分割**：HSI中...
matlab 图像彩色空间转换RGB,LUV,XYZ,LAB.rar_Lab matlab_lab空间转换_matlab RGB
09-23
在图像处理领域，色彩空间转换是一项基础且重要的任务。MATLAB作为一个强大的数学计算与数据分析工具，也提供了丰富的图像处理函数，其中包括对不同色彩空间的转换。本教程主要讲解如何使用MATLAB实现图像从RGB到LUV...
rgb到不同彩色空间转换公式.docx
10-30
在不同的应用场景中，有时我们需要将RGB颜色转换为其他彩色空间，例如XYZ、YCrCb、HSV或Lab等。这些转换公式在图像处理、计算机视觉和色彩科学中有着重要的应用。 1. **RGB到灰度的转换**： RGB到灰度的转换是通过...
【图像处理】三种空间域灰度级—彩色变换合集
04-09
文件给出了三种常见的空间域-彩色变换的编码，仅供参考！
彩色图像处理 & 彩色空间转换及代码实现
最新发布
m0_61899108的博客
11-09 1305
为什么要研究彩色图像处理？ 符合人类视觉特点：人类可以辨别几千种颜色色调和亮度；只能辨别几十种灰度层次。 有用的描绘子：简化目标物的区分；目标识别，根据目标的颜色特征。 彩色图像处理可分为： 全彩色处理：数码相机，数码摄像机，彩色扫描仪。 伪彩色处理：对不同的灰度或灰度范围赋予不同的颜色。 当一束白光通过一个玻璃棱镜时，出现的光束 不是白光，而是由一端为紫色到另一端为红色的 连续彩色谱组成。
彩色空间转换（RGB ⇔ YUV）
Tinsley的博客
03-28 531
1．彩色空间转换的基本思想及转换公式 (1)YUV与RGB空间的相互转换 由电视原理可知，亮度和色差信号的构成如下： Y＝0.2990R+0.5870G+0.1140B R-Y＝0.7010R-0.5870G-0.1140B B-Y＝-0.2990R-0.5870G+0.8860B 为了使色差信号的动态范围控制在0.5之间，需要进行归一化，对色差信号引入压缩系数。归一化后的色差信号为： U＝...
实验一 彩色空间转换
zsy2415535899的博客
03-18 431
1、基本原理      yuv的存储格式有打包(packed)格式和平面(planar)格式。前者将 YUV 分量存放在同一个数组中,通常是几个相邻的像素组成一个宏像素(macro-pixel);而后者使用三个数组分开存放 YUV 三个分量,就像是一个三维平面一样。本实验将bgr4:4:4格式的rgb文件转换为yuv;plannar,4:2:0格式。      由彩色电视原理可知，rg
颜色空间转换
william_hehe的博客
03-16 313
import cv2 import numpy as np img = cv2.imread('.\McGrady.jpg') img1 = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #将原图的彩色BGR格式转换为灰度GRAY格式图像 img2 = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) #将原图的彩色BGR格式转换为彩色...
RGB到YUV彩色空间转换实验详解
"彩色空间转换实验1 - 实现RGB到YUV的转换，涉及文件操作、主函数参数处理以及彩色空间基础知识" 实验1的核心是将RGB颜色空间的图像数据转换成YUV颜色空间。在数字图像处理中，RGB（红绿蓝）是一种加色模型，用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值