有些时候我们需要为一些对象附上随机的颜色，比如我们有这么一个需求，在一个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。这样我们就省略了第一种方法里的循环，实现的方法看起来更加舒服了。
有些时候我们可能会有这样的需求，比如我们想给一张地图上色，相邻的国家的颜色视觉区别要尽可能大，于是我们给的一种或几种颜色，要找到与这些颜色差别最大的颜色，这要怎么实现呢？下面是别人写的代码。我觉得还是有改进的空间的：
static ColorType getUniqueColor(const std::vector<ColorType>& excludedColors)
{
unsigned int i,j,k;
ColorType uniqueColor(0,0,0);
//如果当前没有颜色
if (excludedColors.size()==0)
{
return uniqueColor; //因为没有颜色所以随便返回一个颜色
}
//如果当前只有一个颜色
if (excludedColors.size()==1)
{
int maxDist=-1;
int red=excludedColors[0].mRed;
int green=excludedColors[0].mGreen;
int blue=excludedColors[0].mBlue;
for (i=0;i<256;i+=255)
{
for (j=0;j<256;j+=255)
{
for (k=0;k<256;k+=255)
{
int dist=(i-red)*(i-red)+(j-green)*(j-green)+(k-blue)*(k-blue);
if (dist>maxDist)
{
maxDist=dist;
uniqueColor.mRed=i;
uniqueColor.mGreen=j;
uniqueColor.mBlue=k;
}
}
}
}
return uniqueColor;
}
std::vector<unsigned int> badColors;
badColors.reserve(excludedColors.size()); //预留空间
std::vector<ColorType>::const_iterator iter;
for (iter=excludedColors.begin();iter!=excludedColors.end();iter++)
{
badColors.push_back((iter->mBlue<<16)+(iter->mGreen<<8)+iter->mRed);
}
std::sort(badColors.begin(),badColors.end());
unsigned int duplicates=0;
unsigned int next;
for (i=0,next=1;i<badColors.size()-duplicates;i++)
{
for (j = next; j < badColors.size(); j++)
{
if (badColors[i] != badColors[j])
{
badColors[i + 1] = badColors[j];
next = j + 1;
break;
}
else
{
duplicates++;
}
}
}
badColors.erase(badColors.begin() + (badColors.size() - duplicates), badColors.end());
std::vector<unsigned int>::iterator ulit = badColors.begin();
unsigned int testColor;
for (testColor = 0; testColor < 0xffffff; testColor++)
{
if (testColor == *ulit)
{
ulit++;
}
else
{
break;
}
}
if (testColor == 0x01000000) // 如果搜遍了16.7百万的颜色都没找到的话，则返回无效的颜色
{
uniqueColor = ColorType();
}
else
{
uniqueColor.mBlue = (testColor&0xff0000)>>16;
uniqueColor.mGreen = (testColor&0xff00)>>8;
uniqueColor.mRed = testColor&0xff;
}
return uniqueColor;
}
ColorType是颜色类型，里面包含了三个分量。
如果我们要同时获取多个不同的颜色呢？可以参考下面的代码：
/**
* 产生一个或多个唯一的颜色
* @param count 要产生的颜色的个数
* @param colors 用于保存生成颜色的向量
* @param excludeColors 要排除的颜色
* @return 产生的颜色的个数
*/
static unsigned int getUniqueColors(unsigned int count, std::vector<ColorType>& colors,
const std::vector<ColorType>& excludeColors)
{
unsigned int i, j, k, l;
unsigned int numUnique = 0;
double slValues[] = {0.0, 1.0, 0.5, 0.8, 0.3, 0.6, 0.9, 0.2, 0.7, 0.4, 0.1};
ColorType baseColors[] =
{
ColorType(0,0,255),
ColorType(0,255,0),
ColorType(255,0,0),
ColorType(0,255,255),
ColorType(255,255,0),
ColorType(255,0,255),
ColorType(255,255,255)
};
for (i = 0; i < sizeof(slValues) / sizeof(slValues[0]); i++)
{
for (j = 0; j < sizeof(slValues) / sizeof(slValues[0]); j++)
{
for (k = 0; k < sizeof(baseColors) / sizeof(baseColors[0]); k++)
{
int newColor[3];
int maxValue;
newColor[0] = (int) (baseColors[k].mRed * slValues[j] + 0.5);
newColor[1] = (int) (baseColors[k].mGreen * slValues[j] + 0.5);
newColor[2] = (int) (baseColors[k].mBlue * slValues[j] + 0.5);
maxValue = 0;
for (l = 0; l < 3; l++)
{
if (newColor[l] > maxValue)
{
maxValue = newColor[l];
}
}
maxValue = (int) (maxValue * slValues[i] + 0.5);
for (l = 0; l < 3; l++)
{
if (newColor[l] < maxValue)
{
newColor[l] = maxValue;
}
}
ColorType colorToInsert;
colorToInsert.mRed = newColor[0];
colorToInsert.mGreen = newColor[1];
colorToInsert.mBlue = newColor[2];
for (l=0; l<excludeColors.size(); l++)
{
if (excludeColors[l].mRed == colorToInsert.mRed &&
excludeColors[l].mGreen == colorToInsert.mGreen &&
excludeColors[l].mBlue == colorToInsert.mBlue)
{
break;
}
}
if (l == excludeColors.size())
{
for (l = 0; l < colors.size(); l++)
{
if (colors[l].mRed == colorToInsert.mRed &&
colors[l].mGreen == colorToInsert.mGreen &&
colors[l].mBlue == colorToInsert.mBlue)
{
break;
}
}
if (l == colors.size())
{
colors.push_back (colorToInsert);
++numUnique;
if (colors.size() == count)
{
return numUnique;
}
}
}
}
}
}
return numUnique;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
