色度图

色度图

-

2023年3月17日发(作者：牙齿尖)

C#绘制CIE1931⾊度图

CIE1931⾊度图

CIE1931⾊度图是⼀个理想的图形，如图2.所⽰。理论上的马蹄形曲线内区域包括了⼀切物理上能实

现的颜⾊。在此⼆维⾊度图中，X轴⾊度坐标相当于红原⾊的⽐例，Y轴⾊度坐标相当于绿原⾊的⽐例，并

且有X＋Y＋Z＝1，由X、Y值可得出Z值。图中没有Z轴⾊度坐标，但Z相当于蓝原⾊的⽐例。

描绘马蹄形曲线

描绘马蹄形曲线的⽅法：选取46个光谱轨迹⾊度坐标。

由于马蹄形曲线并⾮随波长变化⽽均匀变化，所以选取坐标时并未按照等波长间隔选取，⽽是根据观

察马蹄形曲线，得出马蹄形曲线上长度⼤概相同的点，对照CIE1931光谱轨迹⾊度坐标表选取。

将波长380nm点作为纯蓝⾊点。实际上该点应该为蓝⾊与红⾊的混合⾊：紫⾊点，但由于紫⾊是混合

⾊，绘制时不好控制计算机上R、B的⽐例，所以绘制马蹄形曲线的时候将该点作为纯蓝⾊点。设⾊度图中

纯蓝⾊点为B点、纯绿⾊点（520nm）为G点、纯红⾊点（780nm）为R点；则B点在计算机上的颜⾊设为

（0，0，255）、G点为（0，255，0）、R点为（255，0，0）。

在波长380nm到520nm之间，选取25个点，然后，⽤B样条曲线算法⽤圆滑连续曲线连接这25个点。

连接的时候，颜⾊变化规律为：B点到498nm（由光谱轨迹⾊度坐标表得到此处为B、G⽐例近似相同点）

颜⾊从（0，0，255）变化到（0，255，255）；498nm到G点颜⾊从（0，255，255）变化到（0，255，0）。

同理，在波长520nm到780nm之间，选取20个点，然后，⽤B样条曲线算法⽤圆滑连续曲线连接这20

个点。连接的时候，颜⾊变化规律为：G点到575nm（由光谱轨迹⾊度坐标表得到此处为G、R⽐例近似相

同点）颜⾊从（0，255，0）变化到（255，255，0）；575nm到R点颜⾊从（255，255，0）变化到（255，0，

0）。

由于连接波长780到380nm两点的是直线，所以在这两点间设511个象素点，然后以画点的⽅式画从

红到蓝的直线。其变化规律相似，颜⾊从（255，0，0）变化到（255，0，255）；再从（255，0，255）变

化到（0，0，255）。

为了表现尽可能多的颜⾊，在颜⾊渐变过程中采⽤了⼀种“准”线性变换的办法。即颜⾊在B点到498nm、

498nm到G点、G点到575nm、575nm到R点以及R点到B点变化时，均为均匀变化。

这样，便绘出了马蹄形曲线。有了曲线后，以等能⽩点C点(255，255，255)（⾊度坐标为X＝0．3333，

Y＝0．3333）为中⼼，向⾊度图边缘上的各点作射线，射线上的点的颜⾊则在⽩⾊与这条射线和马蹄形曲

线边界交点的颜⾊之间连续变化。此时的变化仍采⽤线性均匀变化。为了去除中间不连续部分，射线扫描

先由绿→蓝、绿→红→蓝，再由红→蓝、红→绿做了两次扫描，基本做到了连续。

privatevoidXYZ2RGB(floatx,floaty,floatz,refintr,refintg,refintb)

{

doubledr,dg,db;

dr=0.4185*x-0.1587*y-0.0828*z;

dg=-0.0912*x+0.2524*y+0.0157*z;

db=0.0009*x-0.0025*y+0.1786*z;

doublemax=0;

max=dr>dg?dr:dg;

max=max>db?max:db;

dr=dr/max*255;

dg=dg/max*255;

db=db/max*255;

dr=dr>0?dr:0;

dg=dg>0?dg:0;

db=db>0?db:0;

if(dr>255)

{

dr=255;

}

if(dg>255)

{

dg=255;

}

if(db>255)

{

db=255;

}

r=(int)(dr+0.5);

r=(int)(dr+0.5);

g=(int)(dg+0.5);

b=(int)(db+0.5);

}

privatevoidDrawCIE()

{

ListmySmallx=newList();

ListmySmally=newList();

ListmySmallz=newList();

using(FileStreamfs=newFileStream("轮廓坐标.txt",,,ite))

{

lock(fs)

{

StreamReadersr=newStreamReader(fs,8);

while(!tream)

{

stringstr=ne();

string[]temp=(newchar[]{},EmptyEntries);

if(<3)continue;

((temp[1]));

((temp[2]));

}

}

}

//1:选择3个顶点

PointFp1=newPointF();//代表最下⾯的点

PointFp2=newPointF();//代表最上⾯的点

PointFp3=newPointF();//代表最右边的点

//代表最下⾯的点

p1.X=0.173101f;

p1.Y=0.004774f;

//代表最上⾯的点

p2.X=0.082053f;

p2.Y=0.83409f;

//代表最右边的点

p3.X=0.73469f;

p3.Y=0.26531f;

floatk3=0,b3=0;

k3=(p3.Y-p1.Y)/(p3.X-p1.X);

b3=p3.Y-p3.X*k3;

//左边数组

ListleftArray=newList();

ListrightArray=newList();

PointFtempPonit=newPointF();

for(inti=0;i<(int)();i++)

{

tempPonit.X=mySmallx[i];

tempPonit.Y=mySmally[i];

if(i<161)

{

(tempPonit);

if(i==160)

{

(tempPonit);

}

}

elseif(i>=161&&i<339)

{

(tempPonit);

}

}

}

ListdownArray=newList();

for(floaty=0.001f;y<0.265;y+=0.001f)

{

if(y>p1.Y&&y

{

tempPonit.X=(y-b3)/k3;

tempPonit.Y=y;

(tempPonit);

}

}

Bitmapbitmap=newBitmap(2000,2000,24bppRgb);

Rectangledimension=newRectangle(0,0,,);

BitmapDatapicData=ts(dimension,ite,24bppRgb);

floattempx=0,tempy=0;

floatminy=0,maxy=0;

floatminx=0,maxx=0;

floatmiddlex=0;

doubleminvalue1=999999;

doubleminvalue2=999999;

intmaxindex=0,minindex=0;

for(inti=0;i<;i++)

{

tempy=(float)i/(float);

if(tempy0.83409)

{

continue;

}

for(intj=0;j<;j++)

{

tempx=(float)j/(float);

if(tempx0.73469)

{

continue;

}

//1、判断左边的数组

maxindex=0;

minindex=0;

minvalue2=999999;

minvalue1=999999;

for(intk=0;k<(int)();k++)

{

doublevalue1=tempy-leftArray[k].Y;

doublevalue2=leftArray[k].Y-tempy;

if(value10)

{

minvalue1=value1;

minindex=k;

}

if(value20)

{

minvalue2=value2;

maxindex=k;

}

}

miny=leftArray[minindex].Y;

minx=leftArray[minindex].X;

maxy=leftArray[maxindex].Y;

maxx=leftArray[maxindex].X;

middlex=minx-(tempy-miny)/(maxy-miny)*(minx-maxx);

if(tempx

{

continue;

continue;

}

//2、判断右边的数组

maxindex=0;

minindex=0;

minvalue2=999999;

minvalue1=999999;

for(intk=0;k<(int)();k++)

{

doublevalue1=tempy-rightArray[k].Y;

doublevalue2=rightArray[k].Y-tempy;

if(value10)

{

minvalue1=value1;

minindex=k;

}

if(value20)

{

minvalue2=value2;

maxindex=k;

}

}

miny=rightArray[minindex].Y;

minx=rightArray[minindex].X;

maxy=rightArray[maxindex].Y;

maxx=rightArray[maxindex].X;

middlex=minx-(tempy-miny)/(maxy-miny)*(minx-maxx);

if(tempx>middlex||maxindex==minindex)

{

continue;

}

//3、判断下边的数组

maxindex=0;

minindex=0;

minvalue2=999999;

minvalue1=999999;

for(intk=0;k<(int)();k++)

{

doublevalue1=tempy-downArray[k].Y;

doublevalue2=downArray[k].Y-tempy;

if(value10)

{

minvalue1=value1;

minindex=k;

}

if(value20)

{

minvalue2=value2;

maxindex=k;

}

}

miny=downArray[minindex].Y;

minx=downArray[minindex].X;

maxy=downArray[maxindex].Y;

maxx=downArray[maxindex].X;

middlex=minx-(tempy-miny)/(maxy-miny)*(minx-maxx);

if(tempx>middlex||maxindex==minindex)

{

continue;

}

floatx=0,y=0,z=0;

x=tempx;

y=tempy;

y=tempy;

z=1-x-y;

intR=0,G=0,B=0;

XYZ2RGB(x,y,z,refR,refG,refB);

unsafe

{

byte*target=(byte*)ter();

target[(-i)*+3*j]=(byte)B;

target[(-i)*+3*j+1]=(byte)G;

target[(-i)*+3*j+2]=(byte)R;

}

}

}

Bits(picData);

bitmap=(newRectangle(0,200,1600,1800),ormat);

("",);

}

结果：