色彩空间转换

最新推荐文章于 2023-12-26 00:42:19 发布
最新推荐文章于 2023-12-26 00:42:19 发布
阅读量546 收藏
点赞数
分类专栏： C/C++ development

1. http://blog.csdn.net/yyingwei/article/details/22649575

//以下是yv12到RGB24的转换算法，如果是yuv420到RGB24转换，秩序u,v反过来就可以了。
//即：
// unsigned char* uData = &yData[nYLen];
// unsigned char* vData = &vData[nYLen>>2];
<pre name="code" class="cpp">bool YV12_to_RGB24(unsigned char* pYV12, unsigned char* pRGB24, int iWidth, int iHeight)
{
	if(!pYV12 || !pRGB24)
		return false;

	const long nYLen = long(iHeight * iWidth);
	const int nHfWidth = (iWidth>>1);

	if(nYLen < 1 || nHfWidth < 1) 
		return false;

	unsigned char* yData = pYV12;
	unsigned char* vData = &yData[nYLen];
	unsigned char* uData = &vData[nYLen>>2];
	if(!uData || !vData)
		return false;

	int rgb[3];
	int i, j, m, n, x, y;
	m = -iWidth;
	n = -nHfWidth;
	for(y = 0; y < iHeight; y++)
	{
		m += iWidth;

		if(!(y % 2))
			n += nHfWidth;

		for(x=0; x < iWidth; x++)
		{
			i = m + x;
			j = n + (x>>1);
			rgb[2] = int(yData[i] + 1.370705 * (vData[j] - 128)); // r分量值
			rgb[1] = int(yData[i] - 0.698001 * (uData[j] - 128)  - 0.703125 * (vData[j] - 128)); // g分量值
			rgb[0] = int(yData[i] + 1.732446 * (uData[j] - 128)); // b分量值
			j = nYLen - iWidth - m + x;
			i = (j<<1) + j;
			for(j=0; j<3; j++)
			{
				if(rgb[j]>=0 && rgb[j]<=255)
					pRGB24[i + j] = rgb[j];
				else
					pRGB24[i + j] = (rgb[j] < 0) ? 0 : 255;
			}
		}
	}

	return true;
}

 

2
 

 

#include "stdio.h"

#define  ALIGNMENTTO16(size) (((size) + 15) / 16 * 16)
void UYVYtoYV12(unsigned char* UYVYBuffer, 
                int ImageWidth, 
                int ImageHeight,
                unsigned char* YBuffer, 
                unsigned char* UBuffer, 
                unsigned char* VBuffer, 
                int SrcPitch, 
                int DstPitch)
{
   unsigned char* pDestY = YBuffer;
   unsigned char* pDestU = UBuffer;
   unsigned char* pDestV = VBuffer;
   int i;
   int j;

   //  For each destination U and V pixel
   for (i = 0; i < ImageHeight / 2; ++i)
   {
      for (j = 0; j < ImageWidth / 2; ++j)
      {
         int u;
         int v;

         //  Subsample U
         u = UYVYBuffer[j * 4];
         u += UYVYBuffer[j * 4 + SrcPitch];
         u /= 2;
         pDestU[j] = u;

         //  Subsample V
         v = UYVYBuffer[j * 4 + 2];
         v += UYVYBuffer[j * 4 + 2 + SrcPitch];
         v /= 2;
         pDestV[j] = v;

         //  Copy Y
         pDestY[j * 2] = UYVYBuffer[j * 4 + 1];
         pDestY[j * 2 + 1] = UYVYBuffer[j * 4 + 3];
         pDestY[DstPitch + j * 2] = UYVYBuffer[j * 4 + SrcPitch + 1];
         pDestY[DstPitch + j * 2 + 1] = UYVYBuffer[j * 4 + SrcPitch + 3];
      }

      pDestY += DstPitch * 2;  //  Step 2 Y rows
      pDestU += DstPitch / 2;  //  Step 1 U row
      pDestV += DstPitch / 2;  //  Step 1 V row
      UYVYBuffer += SrcPitch * 2;  //  Step 2 source rows
   }

   return;
}

void YUY2toYV12(unsigned char* YUY2Buffer, 
                int ImageWidth, 
                int ImageHeight,
                unsigned char* YBuffer, 
                unsigned char* UBuffer, 
                unsigned char* VBuffer, 
                int SrcPitch, 
                int DstPitch)
{
   unsigned char* pDestY = YBuffer;
   unsigned char* pDestU = UBuffer;
   unsigned char* pDestV = VBuffer;
   int i;
   int j;

   //  For each destination U and V pixel
   for (i = 0; i < ImageHeight / 2; ++i)
   {
      for (j = 0; j < ImageWidth / 2; ++j)
      {
         int u;
         int v;

         //  Subsample U
         u = YUY2Buffer[j * 4 + 1];
         u += YUY2Buffer[j * 4 + 1 + SrcPitch];
         u /= 2;
         pDestU[j] = u;

         //  Subsample V
         v = YUY2Buffer[j * 4 + 3];
         v += YUY2Buffer[j * 4 + 3 + SrcPitch];
         v /= 2;
         pDestV[j] = v;

         //  Copy Y
         pDestY[j * 2] = YUY2Buffer[j * 4];
         pDestY[j * 2 + 1] = YUY2Buffer[j * 4 + 2];
         pDestY[DstPitch + j * 2] = YUY2Buffer[j * 4 + SrcPitch];
         pDestY[DstPitch + j * 2 + 1] = YUY2Buffer[j * 4 + SrcPitch + 2];
      }

      pDestY += DstPitch * 2;  //  Step 2 Y rows
      pDestU += DstPitch / 2;  //  Step 1 U row
      pDestV += DstPitch / 2;  //  Step 1 V row
      YUY2Buffer += SrcPitch * 2;  //  Step 2 source rows
   }

   return;
}

void YVYUtoYV12( unsigned char *src, 
                int ImageWidth, 
                int ImageHeight,
                unsigned char *YBuffer, 
                unsigned char *UBuffer, 
                unsigned char *VBuffer, 
                int SrcPitch,
                int DstPitch )
{
    int i,j;

    unsigned char *YDst=YBuffer;
    unsigned char *UDst=UBuffer;
    unsigned char *VDst=VBuffer;

    // for each destination u and v pixel
    for(i=0;i<ImageHeight/2;i++)
    {
        for(j=0;j<ImageWidth/2;j++)
        {
            int u,v;

            // subsample u
            u = src[j*4+3];
            u +=src[j*4+3+SrcPitch];
            u /= 2;
            UDst[j] = u ;

            // subsample v
            v = src[j*4+1];
            v += src[j*4+1+SrcPitch];
            v /= 2;
            VDst[j] = v;

            // calculate the 4 y's
            YDst[j*2] = src[j*4];
            YDst[j*2+1] = src[j*4+2];
            YDst[DstPitch + j*2] = src[j*4+SrcPitch];
            YDst[DstPitch + j*2 + 1] = src[j*4+SrcPitch + 2];

        }
        YDst+=DstPitch*2;   // step 2 y rows
        UDst+=DstPitch/2;   // step 1 u row
        VDst+=DstPitch/2;   // step 1 v row
        src+=SrcPitch*2; // step 2 source rows
    }
}

void main()
{
   //待转换数据和宽高
   LPBYTE SrcBuffer = ?;
   int width = ?;
   int height = ?;

   int YV12BufferSize = ALIGNMENTTO16(width * 3 / 2) * height;
   LPBYTE YV12Buffer = new BYTE[YV12BufferSize]();

   LPBYTE pY = YV12Buffer;
   LPBYTE pV = pY + width * height;
   LPBYTE pU = pV + width * height / 4;
   
   int SrcPitch = ALIGNMENTTO16(width) * 2;
   int DstPitch = ALIGNMENTTO16(width);

   // UYYV to YV12
   UYVYtoYV12(SrcBuffer, 
      width, 
      height,
      pY, 
      pU, 
      pV, 
      SrcPitch, 
      DstPitch);

   // YUV2 to YV12
   YUY2toYV12(SrcBuffer, 
      width, 
      height,
      pY, 
      pU, 
      pV, 
      SrcPitch, 
      DstPitch);

   // YVYU to YV12
   YVYUtoYV12(SrcBuffer, 
      width, 
      height,
      pY, 
      pU, 
      pV, 
      SrcPitch, 
      DstPitch);

   delete YV12Buffer;
}
 

 

 

 

3
 

 

int YUV2RGB(void* pYUV, void* pRGB, int width, int height, bool alphaYUV, bool alphaRGB)  
{  
	if (NULL == pYUV)  
	{  
		return -1;  
	}  
	unsigned char* pYUVData = (unsigned char *)pYUV;  
	unsigned char* pRGBData = (unsigned char *)pRGB;  
	if (NULL == pRGBData)  
	{  
		if (alphaRGB)  
		{  
			pRGBData = new unsigned char[width*height*4];  
		}  
		else  
			pRGBData = new unsigned char[width*height*3];  
	}  
	int Y1, U1, V1, Y2, alpha1, alpha2, R1, G1, B1, R2, G2, B2;  
	int C1, D1, E1, C2;  
	if (alphaRGB)  
	{  
		if (alphaYUV)  
		{  
			for (int i=0; i<height; ++i)  
			{  
				for (int j=0; j<width/2; ++j)  
				{  
					Y1 = *(pYUVData+i*width*3+j*6);  
					U1 = *(pYUVData+i*width*3+j*6+1);  
					Y2 = *(pYUVData+i*width*3+j*6+2);  
					V1 = *(pYUVData+i*width*3+j*6+3);  
					alpha1 = *(pYUVData+i*width*3+j*6+4);  
					alpha2 = *(pYUVData+i*width*3+j*6+5);  
					C1 = Y1-16;  
					C2 = Y2-16;  
					D1 = U1-128;  
					E1 = V1-128;  
					R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
					G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
					B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
					R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
					G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
					B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
					*(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;  
					*(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;  
					*(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;  
					*(pRGBData+(height-i-1)*width*4+j*8+3) = alpha1;      
					*(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;  
					*(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;  
					*(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;  
					*(pRGBData+(height-i-1)*width*4+j*8+7) = alpha2;      
				}  
			}     
		}  
		else  
		{  
			int alpha = 255;  
			for (int i=0; i<height; ++i)  
			{  
				for (int j=0; j<width/2; ++j)  
				{  
					Y1 = *(pYUVData+i*width*2+j*4);  
					U1 = *(pYUVData+i*width*2+j*4+1);  
					Y2 = *(pYUVData+i*width*2+j*4+2);  
					V1 = *(pYUVData+i*width*2+j*4+3);  
					C1 = Y1-16;  
					C2 = Y2-16;  
					D1 = U1-128;  
					E1 = V1-128;  
					R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
					G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
					B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
					R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
					G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
					B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
					*(pRGBData+(height-i-1)*width*4+j*8+2) = R1<0 ? 0 : R1;  
					*(pRGBData+(height-i-1)*width*4+j*8+1) = G1<0 ? 0 : G1;  
					*(pRGBData+(height-i-1)*width*4+j*8) = B1<0 ? 0 : B1;  
					*(pRGBData+(height-i-1)*width*4+j*8+3) = alpha;   
					*(pRGBData+(height-i-1)*width*4+j*8+6) = R2<0 ? 0 : R2;  
					*(pRGBData+(height-i-1)*width*4+j*8+5) = G2<0 ? 0 : G2;  
					*(pRGBData+(height-i-1)*width*4+j*8+4) = B2<0 ? 0 : B2;  
					*(pRGBData+(height-i-1)*width*4+j*8+7) = alpha;   
				}  
			}     
		}  
	}  
	else  
	{  
		if (alphaYUV)  
		{  
			for (int i=0; i<height; ++i)  
			{  
				for (int j=0; j<width/2; ++j)  
				{  
					Y1 = *(pYUVData+i*width*3+j*4);  
					U1 = *(pYUVData+i*width*3+j*4+1);  
					Y2 = *(pYUVData+i*width*3+j*4+2);  
					V1 = *(pYUVData+i*width*3+j*4+3);  
					C1 = Y1-16;  
					C2 = Y2-16;  
					D1 = U1-128;  
					E1 = V1-128;  
					R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
					G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
					B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
					R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
					G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
					B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
					*(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;  
					*(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;  
					*(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;  
					*(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;  
					*(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;  
					*(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;  
				}  
			}  
		}  
		else  
		{  
			for (int i=0; i<height; ++i)  
			{  
				for (int j=0; j<width/2; ++j)  
				{  
					Y1 = *(pYUVData+i*width*2+j*4);  
					U1 = *(pYUVData+i*width*2+j*4+1);  
					Y2 = *(pYUVData+i*width*2+j*4+2);  
					V1 = *(pYUVData+i*width*2+j*4+3);  
					C1 = Y1-16;  
					C2 = Y2-16;  
					D1 = U1-128;  
					E1 = V1-128;  
					R1 = ((298*C1 + 409*E1 + 128)>>8>255 ? 255 : (298*C1 + 409*E1 + 128)>>8);  
					G1 = ((298*C1 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C1 - 100*D1 - 208*E1 + 128)>>8);    
					B1 = ((298*C1+516*D1 +128)>>8>255 ? 255 : (298*C1+516*D1 +128)>>8);    
					R2 = ((298*C2 + 409*E1 + 128)>>8>255 ? 255 : (298*C2 + 409*E1 + 128)>>8);  
					G2 = ((298*C2 - 100*D1 - 208*E1 + 128)>>8>255 ? 255 : (298*C2 - 100*D1 - 208*E1 + 128)>>8);  
					B2 = ((298*C2 + 516*D1 +128)>>8>255 ? 255 : (298*C2 + 516*D1 +128)>>8);    
					*(pRGBData+(height-i-1)*width*3+j*6+2) = R1<0 ? 0 : R1;  
					*(pRGBData+(height-i-1)*width*3+j*6+1) = G1<0 ? 0 : G1;  
					*(pRGBData+(height-i-1)*width*3+j*6) = B1<0 ? 0 : B1;  
					*(pRGBData+(height-i-1)*width*3+j*6+5) = R2<0 ? 0 : R2;  
					*(pRGBData+(height-i-1)*width*3+j*6+4) = G2<0 ? 0 : G2;  
					*(pRGBData+(height-i-1)*width*3+j*6+3) = B2<0 ? 0 : B2;  
				}  
			}     
		}  
	}  
	return 0;  
}  


bool YV12_to_RGB24(unsigned char* pYV12, unsigned char* pRGB24, int iWidth, int iHeight)
{
	if(!pYV12 || !pRGB24)
		return false;

	const long nYLen = long(iHeight * iWidth);
	const int nHfWidth = (iWidth>>1);

	if(nYLen < 1 || nHfWidth < 1) 
		return false;

	unsigned char* yData = pYV12;
	unsigned char* vData = &yData[nYLen];
	unsigned char* uData = &vData[nYLen>>2];
	if(!uData || !vData)
		return false;

	int rgb[3];
	int i, j, m, n, x, y;
	m = -iWidth;
	n = -nHfWidth;
	for(y = 0; y < iHeight; y++)
	{
		m += iWidth;

		if(!(y % 2))
			n += nHfWidth;

		for(x=0; x < iWidth; x++)
		{
			i = m + x;
			j = n + (x>>1);
			rgb[2] = int(yData[i] + 1.370705 * (vData[j] - 128)); // r分量值
			rgb[1] = int(yData[i] - 0.698001 * (uData[j] - 128)  - 0.703125 * (vData[j] - 128)); // g分量值
			rgb[0] = int(yData[i] + 1.732446 * (uData[j] - 128)); // b分量值
			j = nYLen - iWidth - m + x;
			i = (j<<1) + j;
			for(j=0; j<3; j++)
			{
				if(rgb[j]>=0 && rgb[j]<=255)
					pRGB24[i + j] = rgb[j];
				else
					pRGB24[i + j] = (rgb[j] < 0) ? 0 : 255;
			}
		}
	}

	return true;
}
 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  xxq123321
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
颜色空间转换

				
			

			

				

					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格式转换为彩色...

			
		

	



                

              
                



	

		

			

				
					
opencv实现图像颜色空间转换

				
			

			

				

					08-25
				

			

		

		

			
				
在图像处理领域，颜色空间转换是一项基础且重要的任务，因为不同的颜色空间适用于不同的应用场景。本篇文章主要探讨了如何使用 OpenCV 实现图像的颜色空间转换，涵盖了 RGB、HSV、YUV 等常见颜色空间。  RGB 颜色...

			
		

	



                


  
              

                


	

		

			

				
					
颜色空间转换.zip_matlab 图像处理_图像空间_图像空间转换_颜色空间_颜色空间转换

				
			

			

				

					07-13
				

			

		

		

			
				
在图像处理领域，颜色空间转换是一项基础且重要的技术。它涉及到如何将图像数据从一个颜色模型转换到另一个颜色模型，以便进行分析、编辑或优化显示。本压缩包包含了一个名为"颜色空间转换.m"的MATLAB程序，以及一个...

			
		

	





	

		

			

				
					
基于色彩空间转换的彩色变换方法

					
最新发布

				
			

			

				

					m0_65928388的博客
				

				

					12-26
					
					1197
					
				

			

		

		

			
				
一、概述彩色图像的颜色特征对图像的表现力和视觉效果有着重要影响，在媒体和娱乐、摄影和摄像、医学诊断、地理和环境研究等方面起着重要作用。然而，由于拍摄条件、光照和相机设置等因素的影响，图像的色彩和视觉效果可能不够理想。而彩色图像的处理和调整在许多应用中都起着关键的作用，如图像增强、色彩校正、特效处理等。本博客旨在探讨一种基于色彩空间转换的彩色变换方法，以改善彩色图像的色彩鲜艳度和变换图像色调等，实现对彩色图像颜色特征的灵活调整和优化，提高图像的色彩和视觉效果。彩色图像分类全彩色图像处理：图像为彩色图。

			
		

	



		

			
		



	

		

			

				
					
用于Matlab的彩色图像色彩空间转换的MEX文件!.rar_matlab色彩_mex文件_色彩空间转换

				
			

			

				

					09-23
				

			

		

		

			
				
3. **色彩空间转换**：色彩空间是描述颜色的方法，常见的有RGB（红绿蓝）、HSV（色相饱和度值）、YUV、YCbCr、Lab（L* a* b*）和XYZ等。这些不同的色彩空间各有特点，适用于不同的应用场景。例如，RGB适合显示设备，...

			
		

	





	

		

			

				
					
色彩空间转换小软件

				
			

			

				

					08-06
				

			

		

		

			
				
支持两种YCBCR与RGB的转换标准：HDTV和SDTV。分别采用BT656和BT709系数转换。

			
		

	





	

		

			

				
					
色彩管理中的颜色空间的相互转换

				
			

			

				

					07-02
				

			

		

		

			
				
在彩色图像复制过程中，要做到从扫描、显示、输出到印刷的颜色统一性，就必须实行标准化、规范化、数据化的色彩管理。色彩管理包括：1．输入设备间的颜色匹配；2．原稿颜色与显示器颜色之间的匹配；3．输出设备间的颜色匹配；4．显示器颜色与印刷品颜色之间的匹配；5．原稿与印刷品之间的颜色匹配。色彩管理就是要解决各种设备间的颜色转换匹配问题。我们都知道，对一个颜色的度量可以有多种方法，而每一种方法都是放在一个被称之为颜色空间的坐标系当中来进行度量的。自20世纪初开始，颜色度量空间的研究和定义有了更加完善的发展。至今，随着计算机技术的发展和普及，色彩空间及其相互转化和管理的技术日趋成熟，为再现我们这个丰富多彩的世界提供了完备的技术基础。

			
		

	





	

		

			

				
					
色彩空间的转换

				
			

			

				

					学习笔记
				

				

					01-27
					
					467
					
				

			

		

		

			
				
颜色空间转换, 从bgr到hsv
hsv_image = cv.cvtColor(image, cv.COLOR_BGR2HSV)
用inRange函数提取指定颜色范围,其余置为(0)黑,这里对hsv来处理
mask = cv.inRange(hsv_image, lowerb=lower_hsv, upperb=upper_hsv)
import cv2 as cv
import numpy as np


# 颜色空间转换, 从bgr到gray, hsv, yuv, ycrcb
def color_s.

			
		

	





	

		

			

				
					
C++语言基础(22)-转换构造函数和类型转换函数

				
			

			

				

					weixin_34334744的博客
				

				

					07-05
					
					201
					
				

			

		

		

			
				
一.转换构造函数
将其它类型转换为当前类类型需要借助转换构造函数（Conversion constructor）。转换构造函数也是一种构造函数，它遵循构造函数的一般规则。转换构造函数只有一个参数。

#include &lt;iostream&gt;
using namespace std;

//复数类
class Complex{
public:
    Complex():...

			
		

	





	

		

			

				
					
彩色空间转换

				
			

			

				

					qq_55041016的博客
				

				

					05-10
					
					2536
					
				

			

		

		

			
				
彩色空间，你知道多少？

			
		

	





	

		

			

				
					
色彩空间及转换

				
			

			

				

					chao
				

				

					08-23
					
					929
					
				

			

		

		

			
				
AP0-to-XYZ Matrix
In the code, matrix is created by:

const float AP0_2_XYZ_MAT[4][4] = RGBtoXYZ( AP0, 1.0);
and the operator would be:

const float RGB_out[3] = mult_f3_f44( RGB_in, AP0_2_XYZ_MAT);
Equivalent math:

R_out =  0.9525523959 * R_in +  0.00000

			
		

	





	

		

			

				
					
【图像处理】色彩空间变换

				
			

			

				

					DawN
				

				

					04-25
					
					8889
					
				

			

		

		

			
				
彩色空间变换
一、简介
​	一般图像是有红（R）、绿（G）、蓝（B)三个通道，每个通道由（0-255）不同的值组成，这就构成了多彩的图像，这称为图像的颜色空间。在图像处理中，还有另外的颜色空间（如HSV，HIS），这些更具有可分离性和可操作性。所以很多的图像算法需要将图像从RGB转换为其他空间。
二、RGB与灰度空间互转
​	RGB（红绿蓝）是依据人眼识别的颜色定义出的空间，可表示大部分颜色。但在...

			
		

	





	

		

			

				
					
5、颜色空间转换（物体跟踪）几何变换（扩展缩放、平移、仿射变换、旋转、透视变换）

				
			

			

				

					le000426的博客
				

				

					10-27
					
					1015
					
				

			

		

		

			
				
一、颜色空间转换
BGR，即蓝-绿-红色彩空间，每一个像素点都由一个三元数组来表示，分别代表蓝、绿、红三种颜色。另一个与之相似的颜色空间：RGB，它们只是在颜色的顺序上不同。
RGB[A]准换成灰度：Y=0.299R+0.587G+0.114*B
灰度转换为RGB[A]：R=Y,G=Y,B=Y,A=max(ChannelRange)
该空间广泛用于视频和图像压缩，不能算作纯粹的色彩空间，它是RGB颜色空间的一种解码方式Y通道表示亮度，而Cr和Cb表示红色差值(在RGB空间中R通道和Y的差值）和蓝色差值(在R

			
		

	





	

		

			

				
					
RGB与HSV色彩空间转换详解

				
			

			

				

					
				

			

		

		

			
				
本文主要介绍了RGB和HSV两种色彩空间之间的转换...这些转换公式是基本的色彩空间转换方法，实际应用中可能需要根据不同的需求进行调整或优化。在处理图像或进行色彩分析时，理解并掌握RGB与HSV之间的转换是非常有用的。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值