随机颜色的生成

http://blog.csdn.net/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
plaincopy

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是颜色类型，里面包含了三个分量。

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

[cpp] view
plaincopy

/**

* 产生一个或多个唯一的颜色

* @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;

}