随机颜色的生成

http://blog.youkuaiyun.com/hjh2005/article/details/8821052

有些时候我们需要为一些对象附上随机的颜色，比如我们有这么一个需求，在一个chart里添加显示曲线，刚开始曲线的颜色默认都是黑色的很不好看，后来为了显示的美观我们想给添加的曲线随机的附上颜色，但是有一个要求，曲线的颜色不能太淡，比如不能是白色。因为我们的chart的背景颜色是白色的，如果曲线也是白色那曲线就会看不到了。

我们首先想到的方法是如下：

Color c(rand()%256,rand()%256,rand()%256);

这样可以实现我们对随机颜色的要求，但是不满足我们不能为白色的要求，为了避免白色，我们在对这个颜色进行检查，如果r、g、b分量的值都超过230，表示颜色太淡重新随机，但是这样的方法总让人感觉不那么舒服。

后来想到了在HSL颜色空间里做文章是否会更舒服呢？

于是通过Wiki复习HSL颜色空间的知识。发现在HSL空间里如果L分量大于200，颜色看起来就比较淡了，所以我们可以随机生成小于200的数值作为L分量，再借助强大的Qt于是我们可以这样实现我们的需求：

首先借助Qt的QColor生成一个颜色对象：

QColor qc=QColor::fromHsl(rand()%360,rand()%256,rand()%200);

这里要注意的是H分量的值域是0到359的。

最后得到的颜色为：

Color c(qc.red(),qc.green(),qc.blue());

如果不用Qt的话，网上有很多HSL颜色空间转RGB颜色空间的代码和公式也可是替代上面用到的Qt。这样我们就省略了第一种方法里的循环，实现的方法看起来更加舒服了。

有些时候我们可能会有这样的需求，比如我们想给一张地图上色，相邻的国家的颜色视觉区别要尽可能大，于是我们给的一种或几种颜色，要找到与这些颜色差别最大的颜色，这要怎么实现呢？下面是别人写的代码。我觉得还是有改进的空间的：

[cpp] view plain copy

1. staticColorTypegetUniqueColor(conststd::vector<ColorType>&excludedColors)
2. {
3. unsignedinti,j,k;
4. ColorTypeuniqueColor(0,0,0);
5. //如果当前没有颜色
6. if(excludedColors.size()==0)
7. {
8. returnuniqueColor;//因为没有颜色所以随便返回一个颜色
9. }
10. //如果当前只有一个颜色
11. if(excludedColors.size()==1)
12. {
13. intmaxDist=-1;
14. intred=excludedColors[0].mRed;
15. intgreen=excludedColors[0].mGreen;
16. intblue=excludedColors[0].mBlue;
18. for(i=0;i<256;i+=255)
19. {
20. for(j=0;j<256;j+=255)
21. {
22. for(k=0;k<256;k+=255)
23. {
24. intdist=(i-red)*(i-red)+(j-green)*(j-green)+(k-blue)*(k-blue);
25. if(dist>maxDist)
26. {
27. maxDist=dist;
28. uniqueColor.mRed=i;
29. uniqueColor.mGreen=j;
30. uniqueColor.mBlue=k;
31. }
32. }
33. }
34. }
35. returnuniqueColor;
36. }
38. std::vector<unsignedint>badColors;
39. badColors.reserve(excludedColors.size());//预留空间
41. std::vector<ColorType>::const_iteratoriter;
42. for(iter=excludedColors.begin();iter!=excludedColors.end();iter++)
43. {
44. badColors.push_back((iter->mBlue<<16)+(iter->mGreen<<8)+iter->mRed);
45. }
47. std::sort(badColors.begin(),badColors.end());
49. unsignedintduplicates=0;
50. unsignedintnext;
52. for(i=0,next=1;i<badColors.size()-duplicates;i++)
53. {
54. for(j=next;j<badColors.size();j++)
55. {
56. if(badColors[i]!=badColors[j])
57. {
58. badColors[i+1]=badColors[j];
59. next=j+1;
60. break;
61. }
62. else
63. {
64. duplicates++;
65. }
66. }
67. }
68. badColors.erase(badColors.begin()+(badColors.size()-duplicates),badColors.end());
70. std::vector<unsignedint>::iteratorulit=badColors.begin();
71. unsignedinttestColor;
72. for(testColor=0;testColor<0xffffff;testColor++)
73. {
74. if(testColor==*ulit)
75. {
76. ulit++;
77. }
78. else
79. {
80. break;
81. }
82. }
84. if(testColor==0x01000000)//如果搜遍了16.7百万的颜色都没找到的话，则返回无效的颜色
85. {
86. uniqueColor=ColorType();
87. }
88. else
89. {
90. uniqueColor.mBlue=(testColor&0xff0000)>>16;
91. uniqueColor.mGreen=(testColor&0xff00)>>8;
92. uniqueColor.mRed=testColor&0xff;
93. }
95. returnuniqueColor;
96. }

ColorType是颜色类型，里面包含了三个分量。

如果我们要同时获取多个不同的颜色呢？可以参考下面的代码：

[cpp] view plain copy

1. /**
2. *产生一个或多个唯一的颜色
3. *@paramcount要产生的颜色的个数
4. *@paramcolors用于保存生成颜色的向量
5. *@paramexcludeColors要排除的颜色
6. *@return产生的颜色的个数
7. */
8. staticunsignedintgetUniqueColors(unsignedintcount,std::vector<ColorType>&colors,
9. conststd::vector<ColorType>&excludeColors)
10. {
11. unsignedinti,j,k,l;
12. unsignedintnumUnique=0;
13. doubleslValues[]={0.0,1.0,0.5,0.8,0.3,0.6,0.9,0.2,0.7,0.4,0.1};
14. ColorTypebaseColors[]=
15. {
16. ColorType(0,0,255),
17. ColorType(0,255,0),
18. ColorType(255,0,0),
19. ColorType(0,255,255),
20. ColorType(255,255,0),
21. ColorType(255,0,255),
22. ColorType(255,255,255)
23. };
25. for(i=0;i<sizeof(slValues)/sizeof(slValues[0]);i++)
26. {
27. for(j=0;j<sizeof(slValues)/sizeof(slValues[0]);j++)
28. {
29. for(k=0;k<sizeof(baseColors)/sizeof(baseColors[0]);k++)
30. {
31. intnewColor[3];
32. intmaxValue;
34. newColor[0]=(int)(baseColors[k].mRed*slValues[j]+0.5);
35. newColor[1]=(int)(baseColors[k].mGreen*slValues[j]+0.5);
36. newColor[2]=(int)(baseColors[k].mBlue*slValues[j]+0.5);
38. maxValue=0;
39. for(l=0;l<3;l++)
40. {
41. if(newColor[l]>maxValue)
42. {
43. maxValue=newColor[l];
44. }
45. }
47. maxValue=(int)(maxValue*slValues[i]+0.5);
48. for(l=0;l<3;l++)
49. {
50. if(newColor[l]<maxValue)
51. {
52. newColor[l]=maxValue;
53. }
54. }
56. ColorTypecolorToInsert;
57. colorToInsert.mRed=newColor[0];
58. colorToInsert.mGreen=newColor[1];
59. colorToInsert.mBlue=newColor[2];
61. for(l=0;l<excludeColors.size();l++)
62. {
63. if(excludeColors[l].mRed==colorToInsert.mRed&&
64. excludeColors[l].mGreen==colorToInsert.mGreen&&
65. excludeColors[l].mBlue==colorToInsert.mBlue)
66. {
67. break;
68. }
69. }
70. if(l==excludeColors.size())
71. {
72. for(l=0;l<colors.size();l++)
73. {
74. if(colors[l].mRed==colorToInsert.mRed&&
75. colors[l].mGreen==colorToInsert.mGreen&&
76. colors[l].mBlue==colorToInsert.mBlue)
77. {
78. break;
79. }
80. }
81. if(l==colors.size())
82. {
83. colors.push_back(colorToInsert);
84. ++numUnique;
85. if(colors.size()==count)
86. {
87. returnnumUnique;
88. }
89. }
90. }
91. }
92. }
93. }
94. returnnumUnique;
95. }