各个颜色空间的转换

最新推荐文章于 2024-05-08 10:04:42 发布
最新推荐文章于 2024-05-08 10:04:42 发布
阅读量1.7k 收藏
点赞数
分类专栏： C/C++ 图像 文章标签： 色彩控件 转换
C/C++ 同时被 2 个专栏收录
152 篇文章 1 订阅
订阅专栏
图像
36 篇文章 2 订阅
订阅专栏

// 没有验证过

// RGB<->YUV
// RGB<->XYZ
// RGB<->LAB
// RGB<->HSV
// RGB<->CMY

// XYZ<->LAB
// YUV ->XYZ
// LAB ->HSV
// XYZ ->HSV
// RGB ->CMYK
// CMYK->CMY

// http://www.cnblogs.com/phinecos/archive/2009/05/03/1448121.html
// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
// http://www.programmershare.com/1288015/
// http://blog.sina.com.cn/s/blog_6806030c0101ei9z.html

#include <math.h>

template <class T>
const T& HYMin(const T& refT1, const T& refT2)
{
	return (refT1 < refT2) ? refT1 : refT2;
}

template <class T>
const T& HYMax(const T& refT1, const T& refT2)
{
	return (refT1 > refT2) ? refT1 : refT2;
}

// RGB转换为YUV
void RGB2YUV(double dR, double dG, double dB, double &dY, double &dU, double &dV)
{
    dY = 0.257 * dR + 0.504 * dG + 0.098 * dB + 16;		// y
    dU = -0.148 * dR - 0.291 * dG + 0.439 * dB + 128;	// u
    dV = 0.439 * dR - 0.368 * dG - 0.071 * dB + 128;	// v
}

// YUV转换为RGB
void YUV2RGB(double dY, double dU, double dV, double &dR, double &dG, double &dB)
{
    dR = 1.0 * dY + 8 + 1.402 * (dV - 128);
    dG = 1.0 * dY - 0.34413 * (dU - 128) - 0.71414 * (dV - 128); 
    dB = 1.0 * dY + 1.772 * (dU - 128) + 0;
}

// RGB转换为XYZ
void RGB2XYZ(double dR, double dG, double dB, double &dX, double &dY, double &dZ)
{
    double dTempR = (dR / 255.0);
    double dTempG = (dG / 255.0);
    double dTempB = (dB / 255.0);

    if(0.04045 < dTempR)
    {
        dTempR = pow((dTempR + 0.055) / 1.055, 2.4);
    }
    else
    {
        dTempR /= 12.92;
    }

    if(0.04045 < dTempG)
    {
        dTempG = pow((dTempG + 0.055) / 1.055, 2.4);
    }
    else
    {
        dTempG /= 12.92;
    }

    if(0.04045 < dTempB)
    {
        dTempB = pow((dTempB + 0.055) / 1.055, 2.4);
    }
    else
    {
        dTempB /= 12.92;
    }         

    dTempR *= 100.0;
    dTempG *= 100.0;
    dTempB *= 100.0;

    //Observer. = 2°, Illuminant = D65
    dX = 0.4124564 * dTempR + 0.3575761 * dTempG + 0.1804375 * dTempB;
    dY = 0.2126729 * dTempR + 0.7151522 * dTempG + 0.0721750 * dTempB;
    dZ = 0.0193339 * dTempR + 0.1191920 * dTempG + 0.9503041 * dTempB;
}

// XYZ转换为LAB
void XYZ2LAB(double dX, double dY, double dZ, double &dL, double &dA ,double &dB)
{
    double dTempX = dX / 95.047;
    double dTempY = dY / 100.000;
    double dTempZ = dZ / 108.883;

    if(0.008856 < dTempX)
    {
        dTempX = pow((float)dTempX, 1.0f / 3.0f);
    }
    else
    {
        dTempX = ( 7.787 * dTempX ) + (16.0 / 116.0);
    }
	
    if(0.008856 < dTempY)
    {
        dTempY = pow((float)dTempY, 1.0f / 3.0f);
    }
    else
    {
        dTempY = (7.787 * dTempY) + (16.0 / 116.0);
    }

    if(0.008856 < dTempZ)
    {
        dTempZ = pow((float)dTempZ, 1.0f / 3.0f);
    }
    else
    {
        dTempZ = (7.787 * dTempZ) + (16.0 / 116.0);
    }

    dL = (116 * dTempY) - 16;
    dA = 500 * (dTempX - dTempY);
    dB = 200 * (dTempY - dTempZ);
}

// RGB转换为LAB
void RGB2LAB(double dR, double dG, double dB, double &dLAB_L, double &dLAB_A, double &dLAB_B)
{
    double dX, dY, dZ;
    RGB2XYZ(dR, dG, dB, dX, dY, dZ);
	XYZ2LAB(dX, dY, dZ, dLAB_L, dLAB_A, dLAB_B);
}

// LAB转换为XYZ
void LAB2XYZ(double dLAB_L, double dLAB_A, double dLAB_B, double &dX, double &dY, double &dZ)
{
    double dTempY = (dLAB_L + 16) / 116;
    double dTempX = dLAB_A / 500 + dTempY;
    double dTempZ = dTempY - dLAB_B / 200;

    if(pow((double)dTempY, 3) > 0.008856)
	{
        dTempY = pow((double)dTempY, 3);
	}
    else
	{
		dTempY = (dTempY - 16 / 116) / 7.787;
	}

    if(pow((double)dTempX, 3) > 0.008856)
	{
        dTempX = pow((double)dTempX, 3);
	}
    else
	{
        dTempX = (dTempX - 16 / 116) / 7.787;
	}

    if(pow((double)dTempZ, 3) > 0.008856)
	{
        dTempZ = pow((double)dTempZ, 3);
	}
    else
	{
        dTempZ = (dTempZ - 16.0 / 116.0) / 7.787;
	}

	dX = 95.047 * dTempX;
	dY = 100.000 * dTempY;
    dZ = 108.883 * dTempZ;
}

// XYZ转换为RGB
void XYZ2RGB(double dX, double dY, double dZ, double &dR, double &dG, double &dB)
{
    double dTempX = dX / 100.0f;        // X from 0 to  95.047      (Observer = 2°, Illuminant = D65)
    double dTempY = dY / 100.0f;        // Y from 0 to 100.000
    double dTempZ = dZ / 100.0f;        // Z from 0 to 108.883

    double dTempR = dTempX * 3.2404542 + dTempY * -1.5371385 + dTempZ * -0.4985314;
    double dTempG = dTempX * -0.9692660 + dTempY * 1.8760108 + dTempZ * 0.0415560;
    double dTempB = dTempX * 0.0556434 + dTempY * -0.2040259 + dTempZ * 1.0572252;

    if(0.0031308 < dTempR)
	{
        dTempR = 1.055 * (pow(dTempR, (1 / 2.4))) - 0.055;
	}
    else
	{
        dTempR *= 12.92;
	}
	
    if(0.0031308 < dTempG)
	{
        dTempG = 1.055 * (pow(dTempG, (1 / 2.4))) - 0.055;
	}
    else
	{
        dTempG *= 12.92;
	}
	
    if(0.0031308 < dTempB)
	{
        dTempB = 1.055 * (pow(dTempB, (1 / 2.4))) - 0.055;
	}
    else
	{
        dTempB *= 12.92;
	}
	
    dR = 255.0f * dTempR;
    dG = 255.0f * dTempG;
    dB = 255.0f * dTempB;
}

// LAB转换为RGB
void LAB2RGB(double dLAB_L, double dLAB_A, double dLAB_B, double &dR, double &dG, double &dB)
{
    double dX, dY, dZ;
    LAB2XYZ(dLAB_L, dLAB_A, dLAB_B, dX, dY, dZ);
    XYZ2RGB(dX, dY, dZ, dR, dG, dB);
}

// RGB转换为HSV
void RGB2HSV(double dR, double dG, double dB, double &dH, double &dS, double& dV)
{
    double dTempR = (dR / 255);			// RGB from 0 to 255
    double dTempG = (dG / 255);
    double dTempB = (dB / 255);

    double dMin, dMax, dDelMax;
    dMin = HYMin(HYMin(dTempR, dTempG), dTempB);
    dMax = HYMax(HYMax(dTempR, dTempG), dTempB);
    dDelMax = dMax - dMin;				// Delta RGB value 

    dV = dMax;

    if(0 == dMax)			// This is a gray, no chroma
    {
        dH = 0.0;				// HSV results from 0 to 1
        dS = 0.0;
    }
    else					// Chromatic data
    {
        dS = dDelMax / dMax;        

        double dDelR = (((dMax - dTempR) / 6) + (dDelMax / 2)) / dDelMax;
        double dDelG = (((dMax - dTempG) / 6) + (dDelMax / 2)) / dDelMax;
        double dDelB = (((dMax - dTempB) / 6) + (dDelMax / 2)) / dDelMax;

        if(dTempR == dMax)
		{
            dH = dDelB - dDelG;
		}
        else if(dTempG == dMax)
		{
            dH = (1.0 / 3.0) + dDelR - dDelB;
		}
        else if(dTempB == dMax)
		{
            dH = (2.0 / 3.0) + dDelG - dDelR;
		}			

        if(0 > dH)
		{
            dH += 1.0;
		}
		
        if(1 < dH)
		{
            dH -= 1.0;
		}
    }
}

// HSV转换为RGB
void HSV2RGB(double dH, double dS, double dV, double &dR, double &dG, double &dB)
{
    if(dS == 0)                       // HSV from 0 to 1
    {
        dR = 255.0f * dV;
        dG = 255.0f * dV;
        dB = 255.0f * dV;
    }
    else
    {
		// 86912219
        double dTempH, dTempI, dTemp1, dTemp2, dTemp3;

        dTempH = 6.0f * dH;
        if(6 == dTempH)
		{
            dTempH = 0.0;     // H must be < 1
		}
		
        dTempI = int(dTempH);            //Or  var_i = floor( var_h )
        dTemp1 = dV * (1 - dS);
        dTemp2 = dV * (1 - dS * (dTempH - dTempI));
        dTemp3 = dV * (1 - dS * (1 - (dTempH - dTempI)));

        double dTempR, dTempG, dTempB;
		
        if(0 == dTempI)
        {
            dTempR = dV; 
            dTempG = dTemp3 ;
            dTempB = dTemp1;
        }
        else if(1 == dTempI) 
        {
            dTempR = dTemp2 ;
            dTempG = dV;
            dTempB = dTemp1;
        }
        else if(2 == dTempI)
		{
            dTempR = dTemp1;
            dTempG = dV;
            dTempB = dTemp3;
        }
        else if (3 == dTempI)
        {
            dTempR = dTemp1 ;
            dTempG = dTemp2 ;
            dTempB = dV;
        }
        else if(4 == dTempI)
        {
            dTempR = dTemp3;
            dTempG = dTemp1; 
            dTempB = dV;
        }
        else
        {
            dTempR = dV;
            dTempG = dTemp1;
            dTempB = dTemp2;
        }

        dR = 255.0f * dTempR;	// RGB results from 0 to 255
        dG = 255.0f * dTempR;
        dB = 255.0f * dTempR;
    }
}

// YUV转换为XYZ
void YUV2XYZ(double dL, double dU, double dV, double &dX, double &dY, double &dZ)
{
    double dTempY, dRefX, dRefY, dRefZ, dRefU, dRefV, dTempU, dTempV;
	
    dTempY = (dL + 16) / 116;
    if(pow(dTempY, 3) > 0.008856)
	{
        dTempY = pow(dTempY, 3);
	}
    else
	{
        dTempY = (dTempY - 16.0 / 116.0) / 7.787;
	}

    dRefX =  95.047;      //Observer= 2°, Illuminant= D65
    dRefY = 100.000;
    dRefZ = 108.883;

    dRefU = (4 * dRefX ) / (dRefX + (15 * dRefY) + (3 * dRefZ));
    dRefV = (9 * dRefY ) / (dRefX + (15 * dRefY) + (3 * dRefZ));

    dTempU = dU / (13 * dL) + dRefU;
    dTempV = dV / (13 * dL) + dRefV;

    dY = dTempY * 100;
    dX = -(9 * dY * dTempU) / ((dTempU - 4) * dTempV  - dTempU * dTempV);
    dZ = (9 * dY - (15 * dTempV * dY) - (dTempV * dX)) / (3 * dTempV);
}

// XYZ转换为HSV
void XYZ2HSV(double dX, double dY, double dZ,double &dH, double &dS, double &dV)
{
    double dR, dG, dB;
    XYZ2RGB(dX, dY, dZ, dR, dG, dB);
    RGB2HSV(dR, dG, dB, dH, dS, dV);
}

// LAB转换为HSV
void LAB2HSV(double dL, double dA, double dB, double &dH, double &dS, double &dV)
{
    double dX, dY, dZ;
    LAB2XYZ(dL, dA, dB, dX, dY, dZ);
    XYZ2HSV(dX, dY, dZ, dH, dS, dV);
}


// RGB转换为CMY
void RGB2CMY(double dR, double dG, double dB, double &dC, double &dM, double dY)
{
    dC = 1.0 - (dR / 255.0f);
    dM = 1.0 - (dG / 255.0f);
    dY = 1.0 - (dB / 255.0f);
}

//CMY转换为RGB
void CMY2RGB(double dC, double dM, double dY, double &dR, double &dG, double &dB)
{
    dR = (1.0f - dC) * 255.0f;
    dG = (1.0f - dM) * 255.0f;
    dB = (1.0f - dY) * 255.0f;
}

//RGB转换为CMYK
void RGB2CMYK(double dR, double dG, double dB, double &dC, double &dM, double dY, double &dK)
{
    // RGB2CMY
    RGB2CMY(dR, dG, dB, dC, dM, dY);
	
    //CMYK and CMY values from 0 to 1
    double dTempK = 1.0;

    if(dC < dTempK)
	{
        dTempK = dC;
	}
	
    if(dM < dTempK)
	{
        dTempK = dM;
	}

    if(dY < dTempK)
	{
        dTempK = dY;
	}
	
    if(1 == dTempK)
    { //Black
        dC = 0;
        dM = 0;
        dY = 0;
    }
    else 
    {
        dC = (dC - dTempK) / (1 - dTempK);
        dM = (dM - dTempK) / (1 - dTempK);
        dY = (dY - dTempK) / (1 - dTempK);
    }
	
    dK = dTempK;
}

// CMYK转换为CMY
void CMYK2CMY(double dC1, double dM1, double dY1, double dK1, double &dC2, double &dM2, double dY2)
{
    dC2 = (dC1 * (1 - dK1) + dK1);
    dM2 = (dM1 * (1 - dK1) + dK1);
    dY2 = (dY1 * (1 - dK1) + dK1);
}


// RGB<-->HSL互转描述, 我已验证, 这个就是Windows颜色选择对话框的颜色选择转换算法

http://www.cnblogs.com/daiguagua/p/3311756.html

小大小丑
关注
专栏目录
yansejuzhen.zip_颜色空间转换
07-14
颜色空间转换是将图像从一种颜色模型转换到另一种颜色模型的过程，以满足特定应用的需求或优化处理效果。本主题主要围绕"yansejuzhen.zip_颜色空间转换"展开，特别是HSV空间与RGB空间之间的转换。 RGB（红绿蓝）...
5、颜色空间转换（物体跟踪）几何变换（扩展缩放、平移、仿射变换、旋转、透视变换）
le000426的博客
10-27 1037
一、颜色空间转换 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
计算机视觉 | 3.颜色空间及其转换（hsv通道识别掩膜）
阅读从未停止，输出从未开始
11-02 2850
前言 把图像转为灰度图像的像素网格以及 x 和 y 的函数来处理以后，我们还需要学会如何利用这些信息，例如如何用图像信息来分离特定区域。 计算机图形和视频广泛应用了颜色阈值这门技术，比如蓝幕。使用蓝幕时，我们需要识别并替换大片蓝色区域，构建虚拟的背景图就是通过蓝幕进行（比如我们要将下图的蓝色背景换成跑车本该在的跑道上）。 能够理解颜色阈值的基本原理并将代码用于实际的案例是本文的目标，下面将详细介绍如何利用Python实现颜色阈值的选取与蓝幕替换，本节的原理和代码结合的十分紧密，所以就不像以往那样拆成原理+
OpenCV-Python学习 ＜三＞ 颜色空间及其转换
New_Tank的博客
04-09 4406
我们常看到各种颜色空间类型，有RGB色彩空间, Gray(灰度)色彩空间，XYZ色彩空间，YCrCb色彩空间，HSV色彩空间，HLS色彩空间，Bayer色彩空间等。 不同的色彩空间都有其擅长处理的区域。所以就有了转换的需求。 1. 色彩空间的介绍： 1.1： Gray色彩空间： Gray通常指8位灰度图，像素取值范围[0-255], 当图像由RG颜色空间转换为Gray色彩空间时，其处理方法如下： Gray= 0.299*R + 0.587*G + .114*R 当Gray转换成RGB色彩空间
图像颜色空间转换
qq_34902877的博客
03-04 850
一、常用颜色空间 1、RGB：red（红色）、green（绿色）、blue（蓝色） 2、HSL：hue（色相）、saturation（饱和度）、lightness（亮度） 3、HSV：hue、saturation、value(色调) 色相指的是色彩的外相，是在不同波长的光照射下，人眼所感觉不同的颜色，如红色、黄色、蓝色等。 饱和度是指色彩的鲜艳程度，也称色彩的纯度。饱和度取决于该色中含色成分和消色成分（灰色）的比例。含色成分越大，饱和度越大；消色成分越大，饱和度越小。纯的颜色都是高度饱和.
OpenCV（五）：图像颜色空间转换
weixin_63357306的博客
08-29 1669
RGB 颜色空间是最常见的颜色表示方式之一，其中 R、G、B 分别表示红色、绿色和蓝色分量。在 OpenCV 中，RGB 图像可以通过 CvType.CV_8UC3 的类型来表示，其中 8U 表示 8 位无符号整数，C3 表示三个通道。
RGB和HSL色彩空间转换
04-16
总的来说，RGB和HSL色彩空间转换涉及颜色理论、图像处理和编程实践，理解这些概念并能进行实际操作对于进行颜色处理的任何工作都十分必要。MATLAB提供的转换函数方便了这一过程，使得在不同色彩空间之间切换变得更加...
opencv实现图像颜色空间转换
08-25
在图像处理领域，颜色空间转换是一项基础且重要的任务，因为不同的颜色空间适用于不同的应用场景。本篇文章主要探讨了如何使用 OpenCV 实现图像的颜色空间转换，涵盖了 RGB、HSV、YUV 等常见颜色空间。 RGB 颜色...
颜色空间转换
08-21
它通过红、绿、蓝三种原色的不同组合来创建各种颜色。RGB值通常在0（黑色）到255（最大亮度）之间，100%的R、G、B组合可得到白色。 2. CMYK颜色空间： CMYK（Cyan, Magenta, Yellow, Key/Black）是减性颜色模型，...
图像颜色空间的转换_RGB -HSV.rar_group9dd_颜色空间_颜色空间转换
07-14
RGB（红绿蓝）颜色空间是最常见的一种颜色模型，它基于加性混色原理，即通过红（Red）、绿（Green）、蓝（Blue）三种基色的不同强度组合来表达各种颜色。在计算机显示中，RGB模型是最基本的，因为显示器就是通过红、...
opencv_4_色彩空间类型转换
m0_43402033的博客
03-26 731
比较常见的色彩空间包括：GRAY色彩空间XYZ色彩空间YCrCb色彩空间HSV色彩空间HLS色彩空间CIELab色彩空间CIELuv色彩空间Bayer色彩空间等等。
【数字图像处理】颜色空间的转换
weixin_44378835的博客
04-01 1345
HSI/ HSV 颜色空间模型是从人的视觉系统出发， 用 H （Hue）、 S（Saturation）、 I（Intensity） 或 V（Value） 分别代表色调、 色饱和度、 亮度三种独立的颜色特征。CMY 颜色空间正好与 RGB 颜色空间互补， 即用白色减去 RGB 颜色空间中的某一颜色值就等于这种颜色在 CMY 颜色空间中的值。YCbCr 颜色空间采用一个亮度信号 （Y） 和两个色差信号 （Cb ， Cr ） 来表示。对于[0,1]的 R、G、B 值，HSV 各个分量计算如下。
Opencv2.4学习：：颜色空间转换（BGR2HSV）
热门推荐
dieju8330的博客
09-06 2万+
常见颜色空间： 1、RGB：基于三原色 2、HSV：色度、饱和度、亮度 3、YUV：亮度、色度   cvtColor void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0)  src:原图像  dst:输出图像  code:转换模式，有CV_RGB2GRAY  CV_RGB2HSY   CV_...
第4章：色彩空间类型转换
weixin_57440207的博客
01-23 3597
第四章：色彩空间类型转换one. 色彩空间基础知识：1. GRAY色彩空间：2. XYZ色彩空间3. YCrCb色彩空间3. HSV色彩空间4. HLS 色彩空间5. CIEL * a * b *色彩空间6. CIEL * u * v *色彩空间7. Bayer色彩空间two. 类型转换函数：three. 类型转换实例four. HSV色彩空间讨论：1. 获取指定颜色：2. 标记指定颜色：five. alpha通道： 色彩空间称为颜色空间、彩色空间、颜色模型、彩色系统、彩色模型、色彩模型等。 常见的色彩空间
色彩空间转换
qq_42829848的博客
09-17 2225
根据RGB与HIS颜色空间相互转换的数学公式，利用Python语言编写相应的颜色空间转换的函数。基于以上编写的颜色空间转换函数以及利用HSI色彩空间进行图像切割、检测等操作。
常用颜色空间及转换
weixin_43938931的博客
09-08 1370
原理介绍： 颜色空间也称彩色模型(又称彩色空间或彩色系统）它的用途是在某些标准下用通常可接受的方式对彩色加以说明。 本质上，彩色模型是坐标系统和子空间的阐述。位于系统的每种颜色都有单个点表示。现在使用的彩色模型很多，主要是由于彩色科学是一个包括很多应用的很宽的领域。 在彩色图像处理中，选择合适的彩色模型是很重要的。从应用的角度来看，人们提出的众多彩色模型可以分为两类。一类面向诸如彩色显示器...
opencv基础篇 ——（二）颜色空间转换
零落年华的专栏
04-18 1448
颜色空间是描述图像中颜色的数学模型。不同的颜色空间使用不同的方式来表示颜色，每种颜色空间都有其特定的优点和用途。RGB 是最常见的颜色空间之一，它使用红色（Red）、绿色（Green）、蓝色（Blue）三个颜色通道来描述一个颜色。在 RGB 空间中，每个像素由这三个通道的强度值组成，通常范围在 0 到 255 之间。RGB 颜色空间适用于大多数彩色显示设备，如电脑显示器、数字相机等。BGR 是 RGB 的变种，其中颜色通道的顺序颠倒为蓝色（Blue）、绿色（Green）、红色（Red）。
图像处理中的颜色空间转换
最新发布
嵌入式之斋
05-08 425
RGB到HSV转换： RGB颜色空间由红色（R）、绿色（G）和蓝色（B）三个分量组成，而HSV颜色空间由色调（Hue）、饱和度（Saturation）和明度（Value）三个分量组成。RGB到CMYK转换： CMYK颜色空间由青色（Cyan）、品红色（Magenta）、黄色（Yellow）和黑色（Black）四个分量组成。常见的颜色空间转换包括RGB到HSV、RGB到灰度、RGB到CMYK等。颜色空间转换可以帮助我们更好地理解图像的颜色信息和特征，以及进行颜色相关的图像处理任务，如色彩增强、颜色检测等。
颜色空间
血色浪漫的专栏
02-09 3913
摘自：http://blog.csdn.net/juyingmin/article/details/5689591  （注：做了一些完善工作） 1,CMY/CMYK颜色空间         青、品红、黄（CMY）（Cyan、Magenta、Yellow）彩色模型是彩色图象印刷行业使用的彩色空间，在彩色立方体中它们是红、绿、蓝的补色，称为减色基，而红、绿、蓝称为加色基。在CMY模型中，颜
图像处理中的颜色空间转换详解
在图像处理中，理解并掌握各种颜色空间的转换是至关重要的。 1. CIE-RGB和CIE-XYZ: CIE-RGB是一个基于人眼感知的真实三原色系统，而CIE-XYZ则是一个虚拟三原色系统，用于科学地描述颜色。XYZ颜色空间是通过CIE-RGB...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值