blocks|key|452755|text|如果您有两个Color对象c1和c2，则可以将c1的每个RGB值与c2的RGB值进行比较。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|452756|int+diffRed+++=+Math.abs(c1.getRed()+++-+c2.getRed());
int+diffGreen+=+Math.abs(c1.getGreen()+-+c2.getGreen());
int+diffBlue++=+Math.abs(c1.getBlue()++-+c2.getBlue());|code-block|syntax|javascript|452757|这些值可以除以差值饱和度(255)，就可以得到两者之间的差值。|452758|float+pctDiffRed+++=+(float)diffRed+++/+255;
float+pctDiffGreen+=+(float)diffGreen+/+255;
float+pctDiffBlue+++=+(float)diffBlue++/+255;|452759|然后你就可以找到平均色差的百分比了。|452760|(pctDiffRed+%2B+pctDiffGreen+%2B+pctDiffBlue)+/+3+*+100|452761|这会给出c1和c2之间的百分比差异。|452762|entityMap^0|6|5|D|2|G|2|N|2|X|2|0|0|0|0|0|0|4|2|7|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|V|$]]

If you have two <code>Color</code> objects <code>c1</code> and <code>c2</code>, you can just compare each RGB value from <code>c1</code> with that of <code>c2</code>.

<pre><code>int diffRed = Math.abs(c1.getRed() - c2.getRed());
int diffGreen = Math.abs(c1.getGreen() - c2.getGreen());
int diffBlue = Math.abs(c1.getBlue() - c2.getBlue());
</code></pre>

Those values you can just divide by the amount of difference saturations (255), and you will get the difference between the two.

<pre><code>float pctDiffRed = (float)diffRed / 255;
float pctDiffGreen = (float)diffGreen / 255;
float pctDiffBlue = (float)diffBlue / 255;
</code></pre>

After which you can just find the average color difference in percentage.

<pre><code>(pctDiffRed + pctDiffGreen + pctDiffBlue) / 3 * 100
</code></pre>

Which would give you a difference in percentage between <code>c1</code> and <code>c2</code>.

blocks|key|667112|text|这只是我第一次想到的一个想法(如果愚蠢的话，很抱歉)。颜色的三个分量可以假设为点的三维坐标，然后您可以计算点之间的距离。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667113|F.E.|667114|Point1+has+R1+G1+B1
Point2+has+R2+G2+B2|code-block|syntax|javascript|667115|颜色之间的距离是|667116|d=sqrt((r2-r1)%5E2%2B(g2-g1)%5E2%2B(b2-b1)%5E2)|667117|百分比为|667118|p=d/sqrt((255)%5E2%2B(255)%5E2%2B(255)%5E2)|667119|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Just an idea that first came to my mind (sorry if stupid).
Three components of colors can be assumed 3D coordinates of points and then you could calculate distance between points.

F.E. 

<pre><code>Point1 has R1 G1 B1
Point2 has R2 G2 B2
</code></pre>

Distance between colors is 

<pre><code>d=sqrt((r2-r1)^2+(g2-g1)^2+(b2-b1)^2)
</code></pre>

Percentage is 

<pre><code>p=d/sqrt((255)^2+(255)^2+(255)^2)
</code></pre>

blocks|key|667254|text|颜色值具有多个维度，因此没有内在的方法来比较两种颜色。您必须为您的用例确定颜色的含义，从而确定如何最好地比较它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667255|最可能的情况是，您希望将颜色的色调、饱和度和/或亮度属性与红/绿/蓝分量进行对比。如果你很难弄清楚你想要如何比较它们，取几对样本颜色，在心里比较它们，然后试着证明/解释为什么它们是相似的/不同的。|667256|一旦您知道要比较颜色的哪些属性/组件，那么您需要弄清楚如何从颜色中提取该信息。|667257|最有可能的情况是，您只需要将颜色从常见的RedGreenBlue表示转换为HueSaturationLightness，然后计算如下所示|667258|avghue+=+(color1.hue+%2B+color2.hue)/2
distance+=+abs(color1.hue-avghue)|code-block|syntax|javascript|667259|此示例将为您提供一个简单的标量值，指示颜色的渐变/色调彼此之间的距离。|667260|参见HSL+and+HSV+at+Wikipedia。|offset|length|667261|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/HSL_and_HSV^0|0|0|0|0|0|0|2|O|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

A color value has more than one dimension, so there is no intrinsic way to compare two colors. You have to determine for your use case the meaning of the colors and thereby how to best compare them. 

Most likely you want to compare the hue, saturation and/or lightness properties of the colors as oppposed to the red/green/blue components. If you are having trouble figuring out how you want to compare them, take some pairs of sample colors and compare them mentally, then try to justify/explain to yourself why they are similar/different. 

Once you know which properties/components of the colors you want to compare, then you need to figure out how to extract that information from a color. 

Most likely you will just need to convert the color from the common RedGreenBlue representation to HueSaturationLightness, and then calculate something like 

<pre><code>avghue = (color1.hue + color2.hue)/2
distance = abs(color1.hue-avghue)
</code></pre>

This example would give you a simple scalar value indicating how far the gradient/hue of the colors are from each other.

See <a href="http://en.wikipedia.org/wiki/HSL_and_HSV" rel="noreferrer">HSL and HSV at Wikipedia</a>.

blocks|key|667361|text|这只是另一种答案，尽管它与Supr的答案相似-只是颜色空间不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667362|问题是:人类感知颜色的差异并不是均匀的，RGB颜色空间忽略了这一点。因此，如果你使用RGB颜色空间，仅仅计算两种颜色之间的欧几里德距离，你可能会得到一个在数学上绝对正确的差异，但不会与人类告诉你的一致。|667363|这可能不是问题--我认为差别不是很大，但如果你想更好地解决这个问题，你应该把你的RGB颜色转换成一个专门为避免上述问题而设计的颜色空间。有几个是对早期模型的改进(因为这是基于人类的感知，我们需要基于实验数据来测量“正确”的值)。我认为Lab+colorspace是最好的，尽管转换成它有点复杂。更简单的应该是CIE+XYZ。|offset|length|667364|Here's+a+site+that+lists+the+formula's+to+convert+between+different+color+spaces，因此您可以进行一些实验。|667365|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lab_color_space#Advantages_of_Lab|1|http://en.wikipedia.org/wiki/CIE_XYZ|2|http://www.easyrgb.com/index.php?X=MATH^0|0|0|39|E|0|4A|7|1|0|0|28|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@$F|Y|G|Z|1|10]|$F|11|G|12|1|13]]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@$F|15|G|16|1|17]]|A|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]|T|$5|M|N|O|A|$P|U]]]]

Just another answer, although it's similar to Supr's one - just a different color space.

The thing is: Humans perceive the difference in color not uniformly and the RGB color space is ignoring this. As a result if you use the RGB color space and just compute the euclidean distance between 2 colors you may get a difference which is mathematically absolutely correct, but wouldn't coincide with what humans would tell you.

This may not be a problem - the difference is not that large I think, but if you want to solve this "better" you should convert your RGB colors into a color space that was specifically designed to avoid the above problem. There are several ones, improvements from earlier models (since this is based on human perception we need to measure the "correct" values based on experimental data). There's the <a href="http://en.wikipedia.org/wiki/Lab_color_space#Advantages_of_Lab" rel="noreferrer">Lab colorspace</a> which I think would be the best although a bit complicated to convert it to. Simpler would be the <a href="http://en.wikipedia.org/wiki/CIE_XYZ" rel="noreferrer">CIE XYZ</a> one.

<a href="http://www.easyrgb.com/index.php?X=MATH" rel="noreferrer">Here's a site that lists the formula's to convert between different color spaces</a> so you can experiment a bit.

blocks|key|667409|text|实际上，几个月前我也走过同样的路。这个问题没有完美的答案(被here问了几次)，但有一个比sqrt(r-r)等答案更复杂，更容易用RGB直接实现，而不是转移到所有种类的交替色彩空间。我找到了这个公式here，它是相当复杂的真实formula的低成本近似值(通过CIE，这是颜色的W3C，因为这是一个未完成的探索，你可以在那里找到更旧和更简单的色差方程)。祝好运。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|667410|编辑:对于后人，以下是相关的C代码：|667411|typedef+struct+{
+++++unsigned+char+r,+g,+b;
}+RGB;

double+ColourDistance(RGB+e1,+RGB+e2)
{
++++long+rmean+=+(+(long)e1.r+%2B+(long)e2.r+)+/+2;
++++long+r+=+(long)e1.r+-+(long)e2.r;
++++long+g+=+(long)e1.g+-+(long)e2.g;
++++long+b+=+(long)e1.b+-+(long)e2.b;
++++return+sqrt((((512%2Brmean)*r*r)>>8)+%2B+4*g*g+%2B+(((767-rmean)*b*b)>>8));
}|code-block|syntax|javascript|667412|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1313/followup-finding-an-accurate-distance-between-colors|1|http://www.compuphase.com/cmetric.htm|2|http://www.brucelindbloom.com/index.html?ColorCalculator.html^0|U|4|0|2R|4|1|35|7|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]|$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

Actually I walked the same path a couple of months ago. There is no perfect answer to the question (that was asked <a href="https://stackoverflow.com/questions/1313/followup-finding-an-accurate-distance-between-colors">here</a> a couple of times) but there is one, more sophisticated than the sqrt(r-r) etc. answer and more easy to implement directly with RGB without moving to all kinds of alternate color spaces. I found this formula <a href="http://www.compuphase.com/cmetric.htm" rel="nofollow noreferrer">here</a> which is a low cost approximation of the quite complicated real <a href="http://www.brucelindbloom.com/index.html?ColorCalculator.html" rel="nofollow noreferrer">formula</a> (by the CIE which is the W3C of colors, since this is a not finished quest, you can find older and simpler color difference equations there).
Good Luck.
Edit: For posterity, here's the relevant C code:
<pre class="lang-c prettyprint-override"><code>typedef struct {
 unsigned char r, g, b;
} RGB;

double ColourDistance(RGB e1, RGB e2)
{
 long rmean = ( (long)e1.r + (long)e2.r ) / 2;
 long r = (long)e1.r - (long)e2.r;
 long g = (long)e1.g - (long)e2.g;
 long b = (long)e1.b - (long)e2.b;
 return sqrt((((512+rmean)*r*r)&gt;&gt;8) + 4*g*g + (((767-rmean)*b*b)&gt;&gt;8));
}
</code></pre>

blocks|key|453183|text|您需要将任何RGB颜色转换到Lab颜色空间中，以便能够以人类看到它们的方式进行比较。否则你会得到RGB颜色，以一些非常奇怪的方式“匹配”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|453184|Color+Differences上的维基百科链接向您介绍了实验室多年来定义的各种颜色空间差异算法。最简单的只检查两种实验室颜色的欧几里得距离的方法有效，但有一些缺陷。|offset|length|453185|方便的是，在OpenIMAJ项目中有一个更复杂的CIEDE2000算法的Java实现。为它提供两组Lab颜色，它将返回单个距离值。|453186|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Color_difference|1|http://www.openimaj.org/apidocs/org/openimaj/image/colour/processing/CIEDE2000.html^0|0|0|H|0|0|6|8|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

You'll need to convert any RGB colors into the Lab color space to be able to compare them in the way that humans see them. Otherwise you'll be getting RGB colors that 'match' in some very strange ways.

The wikipedia link on <a href="http://en.wikipedia.org/wiki/Color_difference" rel="nofollow">Color Differences</a> gives you an intro into the various Lab color space difference algorithms that have been defined over the years. The simplest that just checks the Euclidian distance of two lab colours, works but has a few flaws. 

Conveniently there's a Java implementation of the more sophisticated CIEDE2000 algorithm in the <a href="http://www.openimaj.org/apidocs/org/openimaj/image/colour/processing/CIEDE2000.html" rel="nofollow">OpenIMAJ</a> project. Provide it your two sets of Lab colours and it'll give you back single distance value.

blocks|key|667504|text|最好的方法是deltaE。DeltaE是一个显示颜色差异的数字。如果deltae+<1，则人眼无法识别差异。我用canvas和js写了一段代码，用于将rgb转换为lab，然后计算增量e。在这个例子中，代码是用我保存为LAB1的基色来识别具有不同颜色的像素。如果不同，则将这些像素设置为红色。您可以增加或减少色差的敏感度，或减小增量e的可接受范围。在此示例中，我为我编写的行中的deltaE指定了10+(增量<=+10)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667505|<script>+++
++var+constants+=+{
++++canvasWidth:+700,+//+In+pixels.
++++canvasHeight:+600,+//+In+pixels.
++++colorMap:+new+Array()+
++++++++++};



++//+-----------------------------------------------------------------------------------------------------

++function+fillcolormap(imageObj1)+{


++++function+rgbtoxyz(red1,green1,blue1){+//+a+converter+for+converting+rgb+model+to+xyz+model
+var+red2+=+red1/255;
+var+green2+=+green1/255;
+var+blue2+=+blue1/255;
+if(red2>0.04045){
++++++red2+=+(red2%2B0.055)/1.055;
++++++red2+=+Math.pow(red2,2.4);
+}
+else{
++++++red2+=+red2/12.92;
+}
+if(green2>0.04045){
++++++green2+=+(green2%2B0.055)/1.055;
++++++green2+=+Math.pow(green2,2.4);++++
+}
+else{
++++++green2+=+green2/12.92;
+}
+if(blue2>0.04045){
++++++blue2+=+(blue2%2B0.055)/1.055;
++++++blue2+=+Math.pow(blue2,2.4);++++
+}
+else{
++++++blue2+=+blue2/12.92;
+}
+red2+=+(red2*100);
+green2+=+(green2*100);
+blue2+=+(blue2*100);
+var+x+=+(red2+*+0.4124)+%2B+(green2+*+0.3576)+%2B+(blue2+*+0.1805);
+var+y+=+(red2+*+0.2126)+%2B+(green2+*+0.7152)+%2B+(blue2+*+0.0722);
+var+z+=+(red2+*+0.0193)+%2B+(green2+*+0.1192)+%2B+(blue2+*+0.9505);
+var+xyzresult+=+new+Array();
+xyzresult[0]+=+x;
+xyzresult[1]+=+y;
+xyzresult[2]+=+z;
+return(xyzresult);
}+//end+of+rgb_to_xyz+function
function+xyztolab(xyz){+//a+convertor+from+xyz+to+lab+model
+var+x+=+xyz[0];
+var+y+=+xyz[1];
+var+z+=+xyz[2];
+var+x2+=+x/95.047;
+var+y2+=+y/100;
+var+z2+=+z/108.883;
+if(x2>0.008856){
++++++x2+=+Math.pow(x2,1/3);
+}
+else{
++++++x2+=+(7.787*x2)+%2B+(16/116);
+}
+if(y2>0.008856){
++++++y2+=+Math.pow(y2,1/3);
+}
+else{
++++++y2+=+(7.787*y2)+%2B+(16/116);
+}
+if(z2>0.008856){
++++++z2+=+Math.pow(z2,1/3);
+}
+else{
++++++z2+=+(7.787*z2)+%2B+(16/116);
+}
+var+l=+116*y2+-+16;
+var+a=+500*(x2-y2);
+var+b=+200*(y2-z2);
+var+labresult+=+new+Array();
+labresult[0]+=+l;
+labresult[1]+=+a;
+labresult[2]+=+b;
+return(labresult);|code-block|syntax|javascript|667506|}|667507|++++var+canvas+=+document.getElementById('myCanvas');
++++var+context+=+canvas.getContext('2d');
++++var+imageX+=+0;
++++var+imageY+=+0;

++++context.drawImage(imageObj1,+imageX,+imageY,+240,+140);
++++var+imageData+=+context.getImageData(0,+0,+240,+140);
++++var+data+=+imageData.data;
++++var+n+=+data.length;
+++//+iterate+over+all+pixels

++++var+m+=+0;
++++for+(var+i+=+0;+i+<+n;+i+%2B=+4)+{
++++++var+red+=+data[i];
++++++var+green+=+data[i+%2B+1];
++++++var+blue+=+data[i+%2B+2];
++++var+xyzcolor+=+new+Array();
++++xyzcolor+=+rgbtoxyz(red,green,blue);
++++var+lab+=+new+Array();
++++lab+=+xyztolab(xyzcolor);
++++constants.colorMap.push(lab);+//fill+up+the+colormap+array+with+lab+colors.+++++++++
++++++}+

++}|667508|//|667509|++++function+colorize(pixqty)+{

+++++++++function+deltae94(lab1,lab2){++++//calculating+Delta+E+1994

+++++++++var+c1+=+Math.sqrt((lab1[1]*lab1[1])%2B(lab1[2]*lab1[2]));
+++++++++var+c2+=++Math.sqrt((lab2[1]*lab2[1])%2B(lab2[2]*lab2[2]));
+++++++++var+dc+=+c1-c2;
+++++++++var+dl+=+lab1[0]-lab2[0];
+++++++++var+da+=+lab1[1]-lab2[1];
+++++++++var+db+=+lab1[2]-lab2[2];
+++++++++var+dh+=+Math.sqrt((da*da)%2B(db*db)-(dc*dc));
+++++++++var+first+=+dl;
+++++++++var+second+=+dc/(1%2B(0.045*c1));
+++++++++var+third+=+dh/(1%2B(0.015*c1));
+++++++++var+deresult+=+Math.sqrt((first*first)%2B(second*second)%2B(third*third));
+++++++++return(deresult);
++++++++++}+//+end+of+deltae94+function
++++var+lab11+=++new+Array("80","-4","21");
++++var+lab12+=+new+Array();
++++var+k2=0;
++++var+canvas+=+document.getElementById('myCanvas');
++++++++++++++++++++++++++++++++++++++++var+context+=+canvas.getContext('2d');
++++++++++++++++++++++++++++++++++++++++var+imageData+=+context.getImageData(0,+0,+240,+140);
++++++++++++++++++++++++++++++++++++++++var+data+=+imageData.data;

++++for+(var+i=0;+i<pixqty;+i%2B%2B)+{

++++lab12+=+constants.colorMap[i];

++++var+deltae+=+deltae94(lab11,lab12);+++++
++++++++++++++++++++++++++++++++++++++++if+(deltae+<=+10)+{

++++++++++++++++++++++++++++++++++++++++data[i*4]+=+255;
++++++++++++++++++++++++++++++++++++++++data[(i*4)%2B1]+=+0;
++++++++++++++++++++++++++++++++++++++++data[(i*4)%2B2]+=+0;++
++++++++++++++++++++++++++++++++++++++++k2%2B%2B;
++++++++++++++++++++++++++++++++++++++++}+//+end+of+if+
++++++++++++++++++++++++++++++++}+//end+of+for+loop
++++context.clearRect(0,0,240,140);
++++alert(k2);
++++context.putImageData(imageData,0,0);
}+
//+-----------------------------------------------------------------------------------------------------

$(window).load(function+()+{++++
++var+imageObj+=+new+Image();
++imageObj.onload+=+function()+{
++fillcolormap(imageObj);++++
++}
++imageObj.src+=+'./mixcolor.png';
});

//+---------------------------------------------------------------------------------------------------
+var+pixno2+=+240*140;+
+</script>|667510|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The best way is deltaE. DeltaE is a number that shows the difference of the colors. If deltae &lt; 1 then the difference can't recognize by human eyes. I wrote a code in canvas and js for converting rgb to lab and then calculating delta e. On this example the code is recognising pixels which have different color with a base color that I saved as LAB1. and then if it is different makes those pixels red. You can increase or reduce the sensitivity of the color difference with increae or decrease the acceptable range of delta e. In this example I assigned 10 for deltaE in the line that I wrote (deltae &lt;= 10):

<pre><code>&lt;script&gt; 
 var constants = {
 canvasWidth: 700, // In pixels.
 canvasHeight: 600, // In pixels.
 colorMap: new Array() 
 };



 // -----------------------------------------------------------------------------------------------------

 function fillcolormap(imageObj1) {


 function rgbtoxyz(red1,green1,blue1){ // a converter for converting rgb model to xyz model
 var red2 = red1/255;
 var green2 = green1/255;
 var blue2 = blue1/255;
 if(red2&gt;0.04045){
 red2 = (red2+0.055)/1.055;
 red2 = Math.pow(red2,2.4);
 }
 else{
 red2 = red2/12.92;
 }
 if(green2&gt;0.04045){
 green2 = (green2+0.055)/1.055;
 green2 = Math.pow(green2,2.4); 
 }
 else{
 green2 = green2/12.92;
 }
 if(blue2&gt;0.04045){
 blue2 = (blue2+0.055)/1.055;
 blue2 = Math.pow(blue2,2.4); 
 }
 else{
 blue2 = blue2/12.92;
 }
 red2 = (red2*100);
 green2 = (green2*100);
 blue2 = (blue2*100);
 var x = (red2 * 0.4124) + (green2 * 0.3576) + (blue2 * 0.1805);
 var y = (red2 * 0.2126) + (green2 * 0.7152) + (blue2 * 0.0722);
 var z = (red2 * 0.0193) + (green2 * 0.1192) + (blue2 * 0.9505);
 var xyzresult = new Array();
 xyzresult[0] = x;
 xyzresult[1] = y;
 xyzresult[2] = z;
 return(xyzresult);
} //end of rgb_to_xyz function
function xyztolab(xyz){ //a convertor from xyz to lab model
 var x = xyz[0];
 var y = xyz[1];
 var z = xyz[2];
 var x2 = x/95.047;
 var y2 = y/100;
 var z2 = z/108.883;
 if(x2&gt;0.008856){
 x2 = Math.pow(x2,1/3);
 }
 else{
 x2 = (7.787*x2) + (16/116);
 }
 if(y2&gt;0.008856){
 y2 = Math.pow(y2,1/3);
 }
 else{
 y2 = (7.787*y2) + (16/116);
 }
 if(z2&gt;0.008856){
 z2 = Math.pow(z2,1/3);
 }
 else{
 z2 = (7.787*z2) + (16/116);
 }
 var l= 116*y2 - 16;
 var a= 500*(x2-y2);
 var b= 200*(y2-z2);
 var labresult = new Array();
 labresult[0] = l;
 labresult[1] = a;
 labresult[2] = b;
 return(labresult);
</code></pre>

}

<pre><code> var canvas = document.getElementById('myCanvas');
 var context = canvas.getContext('2d');
 var imageX = 0;
 var imageY = 0;

 context.drawImage(imageObj1, imageX, imageY, 240, 140);
 var imageData = context.getImageData(0, 0, 240, 140);
 var data = imageData.data;
 var n = data.length;
 // iterate over all pixels

 var m = 0;
 for (var i = 0; i &lt; n; i += 4) {
 var red = data[i];
 var green = data[i + 1];
 var blue = data[i + 2];
 var xyzcolor = new Array();
 xyzcolor = rgbtoxyz(red,green,blue);
 var lab = new Array();
 lab = xyztolab(xyzcolor);
 constants.colorMap.push(lab); //fill up the colormap array with lab colors. 
 } 

 }
</code></pre>

// ----------------------------------------------------------------------------------------------------- 

<pre><code> function colorize(pixqty) {

 function deltae94(lab1,lab2){ //calculating Delta E 1994

 var c1 = Math.sqrt((lab1[1]*lab1[1])+(lab1[2]*lab1[2]));
 var c2 = Math.sqrt((lab2[1]*lab2[1])+(lab2[2]*lab2[2]));
 var dc = c1-c2;
 var dl = lab1[0]-lab2[0];
 var da = lab1[1]-lab2[1];
 var db = lab1[2]-lab2[2];
 var dh = Math.sqrt((da*da)+(db*db)-(dc*dc));
 var first = dl;
 var second = dc/(1+(0.045*c1));
 var third = dh/(1+(0.015*c1));
 var deresult = Math.sqrt((first*first)+(second*second)+(third*third));
 return(deresult);
 } // end of deltae94 function
 var lab11 = new Array("80","-4","21");
 var lab12 = new Array();
 var k2=0;
 var canvas = document.getElementById('myCanvas');
 var context = canvas.getContext('2d');
 var imageData = context.getImageData(0, 0, 240, 140);
 var data = imageData.data;

 for (var i=0; i&lt;pixqty; i++) {

 lab12 = constants.colorMap[i];

 var deltae = deltae94(lab11,lab12); 
 if (deltae &lt;= 10) {

 data[i*4] = 255;
 data[(i*4)+1] = 0;
 data[(i*4)+2] = 0; 
 k2++;
 } // end of if 
 } //end of for loop
 context.clearRect(0,0,240,140);
 alert(k2);
 context.putImageData(imageData,0,0);
} 
// -----------------------------------------------------------------------------------------------------

$(window).load(function () { 
 var imageObj = new Image();
 imageObj.onload = function() {
 fillcolormap(imageObj); 
 }
 imageObj.src = './mixcolor.png';
});

// ---------------------------------------------------------------------------------------------------
 var pixno2 = 240*140; 
 &lt;/script&gt;
</code></pre>

blocks|key|667560|text|比较颜色的唯一“正确”方法是在CIELab或CIELuv中使用deltaE进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667561|但对于许多应用程序，我认为这是一个足够好的近似值：|667562|distance+=+3+*+%7CdR%7C+%2B+4+*+%7CdG%7C+%2B+3+*+%7CdB%7C|offset|length|style|CODE|667563|我认为在比较颜色时，加权的曼哈顿距离更有意义。记住，颜色原色只存在于我们的脑海中。它们没有任何物理意义。CIELab和CIELuv是根据我们对颜色的感知进行统计建模的。|667564|entityMap^0|0|0|0|15|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

The only "right" way to compare colors is to do it with deltaE in CIELab or CIELuv.

But for a lot of applications I think this is a good enough approximation:

<code>distance = 3 * |dR| + 4 * |dG| + 3 * |dB|</code>

I think a weighted manhattan distance makes a lot more sense when comparing colors. Remember that color primaries are only in our head. They don't have any physical significance. CIELab and CIELuv is modelled statistically from our perception of color.

blocks|key|667596|text|下面的所有方法都会得到一个从0到100的分数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667597|internal+static+class+ColorDifference
{
++++internal+enum+Method
++++{
++++++++Binary,+//+true+or+false,+0+is+false
++++++++Square,
++++++++Dimensional,
++++++++CIE76
++++}

++++public+static+double+Calculate(Method+method,+int+argb1,+int+argb2)
++++{
++++++++int[]+c1+=+ColorConversion.ArgbToArray(argb1);
++++++++int[]+c2+=+ColorConversion.ArgbToArray(argb2);
++++++++return+Calculate(method,+c1[1],+c2[1],+c1[2],+c2[2],+c1[3],+c2[3],+c1[0],+c2[0]);
++++}

++++public+static+double+Calculate(Method+method,+int+r1,+int+r2,+int+g1,+int+g2,+int+b1,+int+b2,+int+a1+=+-1,+int+a2+=+-1)
++++{
++++++++switch+(method)
++++++++{
++++++++++++case+Method.Binary:
++++++++++++++++return+(r1+==+r2+&&+g1+==+g2+&&+b1+==+b2+&&+a1+==+a2)+?+0+:+100;
++++++++++++case+Method.CIE76:
++++++++++++++++return+CalculateCIE76(r1,+r2,+g1,+g2,+b1,+b2);
++++++++++++case+Method.Dimensional:
++++++++++++++++if+(a1+==+-1+%7C%7C+a2+==+-1)+return+Calculate3D(r1,+r2,+g1,+g2,+b1,+b2);
++++++++++++++++else+return+Calculate4D(r1,+r2,+g1,+g2,+b1,+b2,+a1,+a2);
++++++++++++case+Method.Square:
++++++++++++++++return+CalculateSquare(r1,+r2,+g1,+g2,+b1,+b2,+a1,+a2);
++++++++++++default:
++++++++++++++++throw+new+InvalidOperationException();
++++++++}
++++}

++++public+static+double+Calculate(Method+method,+Color+c1,+Color+c2,+bool+alpha)
++++{
++++++++switch+(method)
++++++++{
++++++++++++case+Method.Binary:
++++++++++++++++return+(c1.R+==+c2.R+&&+c1.G+==+c2.G+&&+c1.B+==+c2.B+&&+(!alpha+%7C%7C+c1.A+==+c2.A))+?+0+:+100;
++++++++++++case+Method.CIE76:
++++++++++++++++if+(alpha)+throw+new+InvalidOperationException();
++++++++++++++++return+CalculateCIE76(c1,+c2);
++++++++++++case+Method.Dimensional:
++++++++++++++++if+(alpha)+return+Calculate4D(c1,+c2);
++++++++++++++++else+return+Calculate3D(c1,+c2);
++++++++++++case+Method.Square:
++++++++++++++++if+(alpha)+return+CalculateSquareAlpha(c1,+c2);
++++++++++++++++else+return+CalculateSquare(c1,+c2);
++++++++++++default:
++++++++++++++++throw+new+InvalidOperationException();
++++++++}
++++}

++++//+A+simple+idea,+based+on+on+a+Square
++++public+static+double+CalculateSquare(int+argb1,+int+argb2)
++++{
++++++++int[]+c1+=+ColorConversion.ArgbToArray(argb1);
++++++++int[]+c2+=+ColorConversion.ArgbToArray(argb2);
++++++++return+CalculateSquare(c1[1],+c2[1],+c1[2],+c2[2],+c1[3],+c2[3]);
++++}

++++public+static+double+CalculateSquare(Color+c1,+Color+c2)
++++{
++++++++return+CalculateSquare(c1.R,+c2.R,+c1.G,+c2.G,+c1.B,+c2.B);
++++}

++++public+static+double+CalculateSquareAlpha(int+argb1,+int+argb2)
++++{
++++++++int[]+c1+=+ColorConversion.ArgbToArray(argb1);
++++++++int[]+c2+=+ColorConversion.ArgbToArray(argb2);
++++++++return+CalculateSquare(c1[1],+c2[1],+c1[2],+c2[2],+c1[3],+c2[3],+c1[0],+c2[0]);
++++}

++++public+static+double+CalculateSquareAlpha(Color+c1,+Color+c2)
++++{
++++++++return+CalculateSquare(c1.R,+c2.R,+c1.G,+c2.G,+c1.B,+c2.B,+c1.A,+c2.A);
++++}

++++public+static+double+CalculateSquare(int+r1,+int+r2,+int+g1,+int+g2,+int+b1,+int+b2,+int+a1+=+-1,+int+a2+=+-1)
++++{
++++++++if+(a1+==+-1+%7C%7C+a2+==+-1)+return+(Math.Abs(r1+-+r2)+%2B+Math.Abs(g1+-+g2)+%2B+Math.Abs(b1+-+b2))+/+7.65;
++++++++else+return+(Math.Abs(r1+-+r2)+%2B+Math.Abs(g1+-+g2)+%2B+Math.Abs(b1+-+b2)+%2B+Math.Abs(a1+-+a2))+/+10.2;
++++}

++++//+from:http://stackoverflow.com/questions/9018016/how-to-compare-two-colors
++++public+static+double+Calculate3D(int+argb1,+int+argb2)
++++{
++++++++int[]+c1+=+ColorConversion.ArgbToArray(argb1);
++++++++int[]+c2+=+ColorConversion.ArgbToArray(argb2);
++++++++return+Calculate3D(c1[1],+c2[1],+c1[2],+c2[2],+c1[3],+c2[3]);
++++}

++++public+static+double+Calculate3D(Color+c1,+Color+c2)
++++{
++++++++return+Calculate3D(c1.R,+c2.R,+c1.G,+c2.G,+c1.B,+c2.B);
++++}

++++public+static+double+Calculate3D(int+r1,+int+r2,+int+g1,+int+g2,+int+b1,+int+b2)
++++{
++++++++return+Math.Sqrt(Math.Pow(Math.Abs(r1+-+r2),+2)+%2B+Math.Pow(Math.Abs(g1+-+g2),+2)+%2B+Math.Pow(Math.Abs(b1+-+b2),+2))+/+4.41672955930063709849498817084;
++++}

++++//+Same+as+above,+but+made+4D+to+include+alpha+channel
++++public+static+double+Calculate4D(int+argb1,+int+argb2)
++++{
++++++++int[]+c1+=+ColorConversion.ArgbToArray(argb1);
++++++++int[]+c2+=+ColorConversion.ArgbToArray(argb2);
++++++++return+Calculate4D(c1[1],+c2[1],+c1[2],+c2[2],+c1[3],+c2[3],+c1[0],+c2[0]);
++++}

++++public+static+double+Calculate4D(Color+c1,+Color+c2)
++++{
++++++++return+Calculate4D(c1.R,+c2.R,+c1.G,+c2.G,+c1.B,+c2.B,+c1.A,+c2.A);
++++}

++++public+static+double+Calculate4D(int+r1,+int+r2,+int+g1,+int+g2,+int+b1,+int+b2,+int+a1,+int+a2)
++++{
++++++++return+Math.Sqrt(Math.Pow(Math.Abs(r1+-+r2),+2)+%2B+Math.Pow(Math.Abs(g1+-+g2),+2)+%2B+Math.Pow(Math.Abs(b1+-+b2),+2)+%2B+Math.Pow(Math.Abs(a1+-+a2),+2))+/+5.1;
++++}

++++/**
++++*+Computes+the+difference+between+two+RGB+colors+by+converting+them+to+the+L*a*b+scale+and
++++*+comparing+them+using+the+CIE76+algorithm+{+http://en.wikipedia.org/wiki/Color_difference#CIE76}
++++*/
++++public+static+double+CalculateCIE76(int+argb1,+int+argb2)
++++{
++++++++return+CalculateCIE76(Color.FromArgb(argb1),+Color.FromArgb(argb2));
++++}

++++public+static+double+CalculateCIE76(Color+c1,+Color+c2)
++++{
++++++++return+CalculateCIE76(c1.R,+c2.R,+c1.G,+c2.G,+c1.B,+c2.B);
++++}

++++public+static+double+CalculateCIE76(int+r1,+int+r2,+int+g1,+int+g2,+int+b1,+int+b2)
++++{
++++++++int[]+lab1+=+ColorConversion.ColorToLab(r1,+g1,+b1);
++++++++int[]+lab2+=+ColorConversion.ColorToLab(r2,+g2,+b2);
++++++++return+Math.Sqrt(Math.Pow(lab2[0]+-+lab1[0],+2)+%2B+Math.Pow(lab2[1]+-+lab1[1],+2)+%2B+Math.Pow(lab2[2]+-+lab1[2],+2))+/+2.55;
++++}
}


internal+static+class+ColorConversion
{

++++public+static+int[]+ArgbToArray(int+argb)
++++{
++++++++return+new+int[]+{+(argb+>>+24),+(argb+>>+16)+&+0xFF,+(argb+>>+8)+&+0xFF,+argb+&+0xFF+};
++++}

++++public+static+int[]+ColorToLab(int+R,+int+G,+int+B)
++++{
++++++++//+http://www.brucelindbloom.com

++++++++double+r,+g,+b,+X,+Y,+Z,+fx,+fy,+fz,+xr,+yr,+zr;
++++++++double+Ls,+fas,+fbs;
++++++++double+eps+=+216.0f+/+24389.0f;
++++++++double+k+=+24389.0f+/+27.0f;

++++++++double+Xr+=+0.964221f;++//+reference+white+D50
++++++++double+Yr+=+1.0f;
++++++++double+Zr+=+0.825211f;

++++++++//+RGB+to+XYZ
++++++++r+=+R+/+255.0f;+//R+0..1
++++++++g+=+G+/+255.0f;+//G+0..1
++++++++b+=+B+/+255.0f;+//B+0..1

++++++++//+assuming+sRGB+(D65)
++++++++if+(r+<=+0.04045)+r+=+r+/+12;
++++++++else+r+=+(float)Math.Pow((r+%2B+0.055)+/+1.055,+2.4);

++++++++if+(g+<=+0.04045)+g+=+g+/+12;
++++++++else+g+=+(float)Math.Pow((g+%2B+0.055)+/+1.055,+2.4);

++++++++if+(b+<=+0.04045)+b+=+b+/+12;
++++++++else+b+=+(float)Math.Pow((b+%2B+0.055)+/+1.055,+2.4);

++++++++X+=+0.436052025f+*+r+%2B+0.385081593f+*+g+%2B+0.143087414f+*+b;
++++++++Y+=+0.222491598f+*+r+%2B+0.71688606f+*+g+%2B+0.060621486f+*+b;
++++++++Z+=+0.013929122f+*+r+%2B+0.097097002f+*+g+%2B+0.71418547f+*+b;

++++++++//+XYZ+to+Lab
++++++++xr+=+X+/+Xr;
++++++++yr+=+Y+/+Yr;
++++++++zr+=+Z+/+Zr;

++++++++if+(xr+>+eps)+fx+=+(float)Math.Pow(xr,+1+/+3.0);
++++++++else+fx+=+(float)((k+*+xr+%2B+16.0)+/+116.0);

++++++++if+(yr+>+eps)+fy+=+(float)Math.Pow(yr,+1+/+3.0);
++++++++else+fy+=+(float)((k+*+yr+%2B+16.0)+/+116.0);

++++++++if+(zr+>+eps)+fz+=+(float)Math.Pow(zr,+1+/+3.0);
++++++++else+fz+=+(float)((k+*+zr+%2B+16.0)+/+116);

++++++++Ls+=+(116+*+fy)+-+16;
++++++++fas+=+500+*+(fx+-+fy);
++++++++fbs+=+200+*+(fy+-+fz);

++++++++int[]+lab+=+new+int[3];
++++++++lab[0]+=+(int)(2.55+*+Ls+%2B+0.5);
++++++++lab[1]+=+(int)(fas+%2B+0.5);
++++++++lab[2]+=+(int)(fbs+%2B+0.5);
++++++++return+lab;
++++}
}|code-block|syntax|javascript|667598|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

All methods below result in a scale from 0-100.

<pre><code>internal static class ColorDifference
{
 internal enum Method
 {
 Binary, // true or false, 0 is false
 Square,
 Dimensional,
 CIE76
 }

 public static double Calculate(Method method, int argb1, int argb2)
 {
 int[] c1 = ColorConversion.ArgbToArray(argb1);
 int[] c2 = ColorConversion.ArgbToArray(argb2);
 return Calculate(method, c1[1], c2[1], c1[2], c2[2], c1[3], c2[3], c1[0], c2[0]);
 }

 public static double Calculate(Method method, int r1, int r2, int g1, int g2, int b1, int b2, int a1 = -1, int a2 = -1)
 {
 switch (method)
 {
 case Method.Binary:
 return (r1 == r2 &amp;&amp; g1 == g2 &amp;&amp; b1 == b2 &amp;&amp; a1 == a2) ? 0 : 100;
 case Method.CIE76:
 return CalculateCIE76(r1, r2, g1, g2, b1, b2);
 case Method.Dimensional:
 if (a1 == -1 || a2 == -1) return Calculate3D(r1, r2, g1, g2, b1, b2);
 else return Calculate4D(r1, r2, g1, g2, b1, b2, a1, a2);
 case Method.Square:
 return CalculateSquare(r1, r2, g1, g2, b1, b2, a1, a2);
 default:
 throw new InvalidOperationException();
 }
 }

 public static double Calculate(Method method, Color c1, Color c2, bool alpha)
 {
 switch (method)
 {
 case Method.Binary:
 return (c1.R == c2.R &amp;&amp; c1.G == c2.G &amp;&amp; c1.B == c2.B &amp;&amp; (!alpha || c1.A == c2.A)) ? 0 : 100;
 case Method.CIE76:
 if (alpha) throw new InvalidOperationException();
 return CalculateCIE76(c1, c2);
 case Method.Dimensional:
 if (alpha) return Calculate4D(c1, c2);
 else return Calculate3D(c1, c2);
 case Method.Square:
 if (alpha) return CalculateSquareAlpha(c1, c2);
 else return CalculateSquare(c1, c2);
 default:
 throw new InvalidOperationException();
 }
 }

 // A simple idea, based on on a Square
 public static double CalculateSquare(int argb1, int argb2)
 {
 int[] c1 = ColorConversion.ArgbToArray(argb1);
 int[] c2 = ColorConversion.ArgbToArray(argb2);
 return CalculateSquare(c1[1], c2[1], c1[2], c2[2], c1[3], c2[3]);
 }

 public static double CalculateSquare(Color c1, Color c2)
 {
 return CalculateSquare(c1.R, c2.R, c1.G, c2.G, c1.B, c2.B);
 }

 public static double CalculateSquareAlpha(int argb1, int argb2)
 {
 int[] c1 = ColorConversion.ArgbToArray(argb1);
 int[] c2 = ColorConversion.ArgbToArray(argb2);
 return CalculateSquare(c1[1], c2[1], c1[2], c2[2], c1[3], c2[3], c1[0], c2[0]);
 }

 public static double CalculateSquareAlpha(Color c1, Color c2)
 {
 return CalculateSquare(c1.R, c2.R, c1.G, c2.G, c1.B, c2.B, c1.A, c2.A);
 }

 public static double CalculateSquare(int r1, int r2, int g1, int g2, int b1, int b2, int a1 = -1, int a2 = -1)
 {
 if (a1 == -1 || a2 == -1) return (Math.Abs(r1 - r2) + Math.Abs(g1 - g2) + Math.Abs(b1 - b2)) / 7.65;
 else return (Math.Abs(r1 - r2) + Math.Abs(g1 - g2) + Math.Abs(b1 - b2) + Math.Abs(a1 - a2)) / 10.2;
 }

 // from:http://stackoverflow.com/questions/9018016/how-to-compare-two-colors
 public static double Calculate3D(int argb1, int argb2)
 {
 int[] c1 = ColorConversion.ArgbToArray(argb1);
 int[] c2 = ColorConversion.ArgbToArray(argb2);
 return Calculate3D(c1[1], c2[1], c1[2], c2[2], c1[3], c2[3]);
 }

 public static double Calculate3D(Color c1, Color c2)
 {
 return Calculate3D(c1.R, c2.R, c1.G, c2.G, c1.B, c2.B);
 }

 public static double Calculate3D(int r1, int r2, int g1, int g2, int b1, int b2)
 {
 return Math.Sqrt(Math.Pow(Math.Abs(r1 - r2), 2) + Math.Pow(Math.Abs(g1 - g2), 2) + Math.Pow(Math.Abs(b1 - b2), 2)) / 4.41672955930063709849498817084;
 }

 // Same as above, but made 4D to include alpha channel
 public static double Calculate4D(int argb1, int argb2)
 {
 int[] c1 = ColorConversion.ArgbToArray(argb1);
 int[] c2 = ColorConversion.ArgbToArray(argb2);
 return Calculate4D(c1[1], c2[1], c1[2], c2[2], c1[3], c2[3], c1[0], c2[0]);
 }

 public static double Calculate4D(Color c1, Color c2)
 {
 return Calculate4D(c1.R, c2.R, c1.G, c2.G, c1.B, c2.B, c1.A, c2.A);
 }

 public static double Calculate4D(int r1, int r2, int g1, int g2, int b1, int b2, int a1, int a2)
 {
 return Math.Sqrt(Math.Pow(Math.Abs(r1 - r2), 2) + Math.Pow(Math.Abs(g1 - g2), 2) + Math.Pow(Math.Abs(b1 - b2), 2) + Math.Pow(Math.Abs(a1 - a2), 2)) / 5.1;
 }

 /**
 * Computes the difference between two RGB colors by converting them to the L*a*b scale and
 * comparing them using the CIE76 algorithm { http://en.wikipedia.org/wiki/Color_difference#CIE76}
 */
 public static double CalculateCIE76(int argb1, int argb2)
 {
 return CalculateCIE76(Color.FromArgb(argb1), Color.FromArgb(argb2));
 }

 public static double CalculateCIE76(Color c1, Color c2)
 {
 return CalculateCIE76(c1.R, c2.R, c1.G, c2.G, c1.B, c2.B);
 }

 public static double CalculateCIE76(int r1, int r2, int g1, int g2, int b1, int b2)
 {
 int[] lab1 = ColorConversion.ColorToLab(r1, g1, b1);
 int[] lab2 = ColorConversion.ColorToLab(r2, g2, b2);
 return Math.Sqrt(Math.Pow(lab2[0] - lab1[0], 2) + Math.Pow(lab2[1] - lab1[1], 2) + Math.Pow(lab2[2] - lab1[2], 2)) / 2.55;
 }
}


internal static class ColorConversion
{

 public static int[] ArgbToArray(int argb)
 {
 return new int[] { (argb &gt;&gt; 24), (argb &gt;&gt; 16) &amp; 0xFF, (argb &gt;&gt; 8) &amp; 0xFF, argb &amp; 0xFF };
 }

 public static int[] ColorToLab(int R, int G, int B)
 {
 // http://www.brucelindbloom.com

 double r, g, b, X, Y, Z, fx, fy, fz, xr, yr, zr;
 double Ls, fas, fbs;
 double eps = 216.0f / 24389.0f;
 double k = 24389.0f / 27.0f;

 double Xr = 0.964221f; // reference white D50
 double Yr = 1.0f;
 double Zr = 0.825211f;

 // RGB to XYZ
 r = R / 255.0f; //R 0..1
 g = G / 255.0f; //G 0..1
 b = B / 255.0f; //B 0..1

 // assuming sRGB (D65)
 if (r &lt;= 0.04045) r = r / 12;
 else r = (float)Math.Pow((r + 0.055) / 1.055, 2.4);

 if (g &lt;= 0.04045) g = g / 12;
 else g = (float)Math.Pow((g + 0.055) / 1.055, 2.4);

 if (b &lt;= 0.04045) b = b / 12;
 else b = (float)Math.Pow((b + 0.055) / 1.055, 2.4);

 X = 0.436052025f * r + 0.385081593f * g + 0.143087414f * b;
 Y = 0.222491598f * r + 0.71688606f * g + 0.060621486f * b;
 Z = 0.013929122f * r + 0.097097002f * g + 0.71418547f * b;

 // XYZ to Lab
 xr = X / Xr;
 yr = Y / Yr;
 zr = Z / Zr;

 if (xr &gt; eps) fx = (float)Math.Pow(xr, 1 / 3.0);
 else fx = (float)((k * xr + 16.0) / 116.0);

 if (yr &gt; eps) fy = (float)Math.Pow(yr, 1 / 3.0);
 else fy = (float)((k * yr + 16.0) / 116.0);

 if (zr &gt; eps) fz = (float)Math.Pow(zr, 1 / 3.0);
 else fz = (float)((k * zr + 16.0) / 116);

 Ls = (116 * fy) - 16;
 fas = 500 * (fx - fy);
 fbs = 200 * (fy - fz);

 int[] lab = new int[3];
 lab[0] = (int)(2.55 * Ls + 0.5);
 lab[1] = (int)(fas + 0.5);
 lab[2] = (int)(fbs + 0.5);
 return lab;
 }
}
</code></pre>

blocks|key|667642|text|只使用RGB的一个简单方法是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|667643|cR=R1-R2+
cG=G1-G2+
cB=B1-B2+
uR=R1%2BR2+
distance=cR*cR*(2%2BuR/256)+%2B+cG*cG*4+%2B+cB*cB*(2%2B(255-uR)/256)|code-block|syntax|javascript|667644|我已经使用这个工具有一段时间了，它在大多数情况下都能很好地工作。|667645|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A simple method that only uses RGB is

<pre><code>cR=R1-R2 
cG=G1-G2 
cB=B1-B2 
uR=R1+R2 
distance=cR*cR*(2+uR/256) + cG*cG*4 + cB*cB*(2+(255-uR)/256)
</code></pre>

I've used this one for a while now, and it works well enough for most purposes.

blocks|key|453417|text|对于快速和肮脏，您可以这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|453418|import+java.awt.Color;
private+Color+dropPrecision(Color+c,int+threshold){
++++return+new+Color((c.getRed()/threshold),
+++++++++++++++++++++(c.getGreen()/threshold),
+++++++++++++++++++++(c.getBlue()/threshold));
}
public+boolean+inThreshold(Color+_1,Color+_2,int+threshold){
++++return+dropPrecision(_1,threshold)==dropPrecision(_2,threshold);
}|code-block|syntax|javascript|453419|利用整数除法对颜色进行量化。|453420|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For quick and dirty, you can do

<pre class="lang-java prettyprint-override"><code>import java.awt.Color;
private Color dropPrecision(Color c,int threshold){
 return new Color((c.getRed()/threshold),
 (c.getGreen()/threshold),
 (c.getBlue()/threshold));
}
public boolean inThreshold(Color _1,Color _2,int threshold){
 return dropPrecision(_1,threshold)==dropPrecision(_2,threshold);
}
</code></pre>

making use of integer division to quantize the colors.

blocks|key|453464|text|我在我的android上使用了这个，它看起来很令人满意，尽管不推荐使用RGB空间：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|453465|++++public+double+colourDistance(int+red1,int+green1,+int+blue1,+int+red2,+int+green2,+int+blue2)
{
++++++double+rmean+=+(+red1+%2B+red2+)/2;
++++int+r+=+red1+-+red2;
++++int+g+=+green1+-+green2;
++++int+b+=+blue1+-+blue2;
++++double+weightR+=+2+%2B+rmean/256;
++++double+weightG+=+4.0;
++++double+weightB+=+2+%2B+(255-rmean)/256;
++++return+Math.sqrt(weightR*r*r+%2B+weightG*g*g+%2B+weightB*b*b);
}|code-block|syntax|javascript|453466|然后，我使用下面的代码来获取相似度百分比：|453467|double+maxColDist+=+764.8339663572415;
double+d1+=+colourDistance(red1,green1,blue1,red2,green2,blue2);
String+s1+=+(int)+Math.round(((maxColDist-d1)/maxColDist)*100)+%2B+"%25+match";|453468|它工作得足够好了。|453469|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I used this in my android up and it seems satisfactory although RGB space is not recommended:

<pre><code> public double colourDistance(int red1,int green1, int blue1, int red2, int green2, int blue2)
{
 double rmean = ( red1 + red2 )/2;
 int r = red1 - red2;
 int g = green1 - green2;
 int b = blue1 - blue2;
 double weightR = 2 + rmean/256;
 double weightG = 4.0;
 double weightB = 2 + (255-rmean)/256;
 return Math.sqrt(weightR*r*r + weightG*g*g + weightB*b*b);
}
</code></pre>

Then I used the following to get percent of similarity:

<pre><code>double maxColDist = 764.8339663572415;
double d1 = colourDistance(red1,green1,blue1,red2,green2,blue2);
String s1 = (int) Math.round(((maxColDist-d1)/maxColDist)*100) + "% match";
</code></pre>

It works well enough.

blocks|key|453514|text|我尝试了各种方法，如实验室颜色空间，HSV比较，我发现亮度很好地实现了这一目的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|453515|这是Python版本|453516|def+lum(c):
++++def+factor(component):
++++++++component+=+component+/+255;
++++++++if+(component+<=+0.03928):
++++++++++++component+=+component+/+12.92;
++++++++else:
++++++++++++component+=+math.pow(((component+%2B+0.055)+/+1.055),+2.4);

++++++++return+component
++++components+=+[factor(ci)+for+ci+in+c]

++++return+(components[0]+*+0.2126+%2B+components[1]+*+0.7152+%2B+components[2]+*+0.0722)+%2B+0.05;

def+color_distance(c1,+c2):

++++l1+=+lum(c1)
++++l2+=+lum(c2)
++++higher+=+max(l1,+l2)
++++lower+=+min(l1,+l2)

++++return+(higher+-+lower)+/+higher


c1+=+ImageColor.getrgb('white')
c2+=+ImageColor.getrgb('yellow')
print(color_distance(c1,+c2))|code-block|syntax|javascript|453517|会给你带来|453518|0.0687619047619048|453519|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I've tried various methods like LAB color space, HSV comparisons and I've found that luminosity works pretty well for this purpose.

Here is Python version 

<pre><code>def lum(c):
 def factor(component):
 component = component / 255;
 if (component &lt;= 0.03928):
 component = component / 12.92;
 else:
 component = math.pow(((component + 0.055) / 1.055), 2.4);

 return component
 components = [factor(ci) for ci in c]

 return (components[0] * 0.2126 + components[1] * 0.7152 + components[2] * 0.0722) + 0.05;

def color_distance(c1, c2):

 l1 = lum(c1)
 l2 = lum(c2)
 higher = max(l1, l2)
 lower = min(l1, l2)

 return (higher - lower) / higher


c1 = ImageColor.getrgb('white')
c2 = ImageColor.getrgb('yellow')
print(color_distance(c1, c2))
</code></pre>

Will give you

<pre><code>0.0687619047619048
</code></pre>

I want to design a program that can help me assess between 5 pre-defined colors which one is more similar to a variable color, and with what percentage. The thing is that I don't know how to do that manually step by step. So it is even more difficult to think of a program.

More details: The colors are from photographs of tubes with gel that as different colors. I have 5 tubes with different colors were each is representative of 1 of 5 levels. I want to take photographs of other samples and on the computer assess to which level that sample belongs by comparing colors, and I want to know that with a percentage of approximation too. I would like a program that does something like this: <a href="http://www.colortools.net/color_matcher.html">http://www.colortools.net/color_matcher.html</a>

If you can tell me what steps to take, even if they are things for me to think and do manually. It would be very helpful.

How to compare two colors for similarity/difference

Python

Java

我想设计一个程序，可以帮助我评估5种预定义的颜色中，哪一种更类似于可变颜色，以及百分比。问题是，我不知道如何一步一步地手动完成。所以想出一个程序就更难了。更多细节:颜色来自不同颜色的管与凝胶的照片。我有5个不同颜色的管子，每个都代表5个级别中的1个。我想拍摄其他样本的照片，并在计算机上通过比较颜色来评估该样本属于哪个级...

问如何比较两种颜色的相似性/差异性
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何比较两种颜色的相似性/差异性EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何比较两种颜色的相似性/差异性
EN