रंग पहियों बनाने के लिए समारोह

इस पर मेरा पहला विचार यह है कि "एक अंतरिक्ष में एन वैक्टर कैसे उत्पन्न करते हैं जो एक-दूसरे से दूरी को अधिकतम करते हैं।" आप देख सकते हैं कि आरजीबी (या कोई अन्य स्केल जो आप उपयोग करते हैं जो कलर स्पेस में आधार बनाता है) केवल वैक्टर हैं। यादृच्छिक बिंदु चुनना पर एक नज़र डालें। आशा है कि यह आपके लिए एक अच्छी शुरुआत है! एक बार जब आपके पास वेक्टरों का एक सेट होता है जो एक भाग को अधिकतम कर देते हैं, तो आप उन्हें हैश टेबल या बाद में कुछ में सहेज सकते हैं, और केवल उन सभी रंगों को प्राप्त करने के लिए यादृच्छिक रोटेशन कर सकते हैं जो अधिकतम एक-दूसरे से अलग हैं!

Edit: Thinking about this problem more, it would be better to map the colors in a linear manor, possibly (0,0,0) --> (255,255,255) lexicographically, and then distribute them evenly. I really don't know how well this will work, but it should since, lets say:

एन = 10 हम जानते हैं कि हमारे पास 16777216 रंग हैं (256 ^ 3)। हम लेक्सिकोग्राफिक रूप से अनुक्रमित रंग को खोजने के लिए buckles एल्गोरिदम 515 का उपयोग कर सकते हैं । अतिप्रवाह से बचने के लिए आपको शायद एल्गोरिदम संपादित करना होगा और शायद कुछ मामूली गति सुधार जोड़ें।

मैंने कहीं पढ़ा है मानव आंख 4 से कम मूल्यों के बीच अंतर नहीं कर सकता है। तो यह ध्यान में रखना कुछ है। निम्नलिखित एल्गोरिदम इस के लिए क्षतिपूर्ति नहीं करता है।

मुझे यकीन नहीं है कि यह वही है जो आप चाहते हैं, लेकिन यह यादृच्छिक रूप से गैर-दोहराने वाले रंग मान उत्पन्न करने का एक तरीका है:

(सावधान रहें, असंगत छद्म कोड आगे)

//colors entered as 0-255 [R, G, B]
colors = []; //holds final colors to be used
rand = new Random();

//assumes n is less than 16,777,216
randomGen(int n){
   while (len(colors) < n){
      //generate a random number between 0,255 for each color
      newRed = rand.next(256);
      newGreen = rand.next(256);
      newBlue = rand.next(256);
      temp = [newRed, newGreen, newBlue];
      //only adds new colors to the array
      if temp not in colors {
         colors.append(temp);
      }
   }
}

बेहतर दृश्यता के लिए आप इसे अनुकूलित कर सकते हैं एक तरीका यह है कि प्रत्येक नए रंग और सरणी के सभी रंगों के बीच की दूरी की तुलना करना होगा:

for item in color{
   itemSq = (item[0]^2 + item[1]^2 + item[2]^2])^(.5);
   tempSq = (temp[0]^2 + temp[1]^2 + temp[2]^2])^(.5);
   dist = itemSq - tempSq;
   dist = abs(dist);
}
//NUMBER can be your chosen distance apart.
if dist < NUMBER and temp not in colors {
   colors.append(temp);
}

लेकिन यह दृष्टिकोण आपके एल्गोरिदम को काफी हद तक धीमा कर देगा।

एक और तरीका यादृच्छिकता को स्क्रैप करना और व्यवस्थित रूप से प्रत्येक 4 मानों के माध्यम से जाना होगा और उपर्युक्त उदाहरण में एक सरणी में रंग जोड़ना होगा।

क्या यह एक कारक भी नहीं है जिससे आप रंग स्थापित कर सकें?

जैसे कि आप डिली-ओएस विचार का उपयोग करते हैं, आपको जितना संभव हो सके रंगों को मिश्रण करने की आवश्यकता है। 0 64 128 256 एक से दूसरे तक है। लेकिन एक पहिया में 0 256 64 128 अधिक "अलग" होगा

इसका कोई मतलब भी है क्या?

कुछ संबंधित संसाधन:

ColorBrewer - Sets of colours designed to be maximally distinguishable for use on maps.

Escaping RGBland: Selecting Colors for Statistical Graphics - A technical report describing a set of algorithms for generating good (i.e. maximally distinguishable) colour sets in the hcl colour space.

यहां निर्दिष्ट कोड के एचएसएल कलर व्हील के आसपास समान रूप से आरजीबी रंग आवंटित करने के लिए कुछ कोड दिया गया है।

class cColorPicker
{
public:
    void Pick( vector&v_picked_cols, int count, int bright = 50 );
private:
    DWORD HSL2RGB( int h, int s, int v );
    unsigned char ToRGB1(float rm1, float rm2, float rh);
};
/**

  Evenly allocate RGB colors around HSL color wheel

  @param[out] v_picked_cols  a vector of colors in RGB format
  @param[in]  count   number of colors required
  @param[in]  bright  0 is all black, 100 is all white, defaults to 50

  based on Fig 3 of http://epub.wu-wien.ac.at/dyn/virlib/wp/eng/mediate/epub-wu-01_c87.pdf?ID=epub-wu-01_c87

*/

void cColorPicker::Pick( vector&v_picked_cols, int count, int bright )
{
    v_picked_cols.clear();
    for( int k_hue = 0; k_hue < 360; k_hue += 360/count )
        v_picked_cols.push_back( HSL2RGB( k_hue, 100, bright ) );
}
/**

  Convert HSL to RGB

  based on http://www.codeguru.com/code/legacy/gdi/colorapp_src.zip

*/

DWORD cColorPicker::HSL2RGB( int h, int s, int l )
{
    DWORD ret = 0;
    unsigned char r,g,b;

    float saturation = s / 100.0f;
    float luminance = l / 100.f;
    float hue = (float)h;

    if (saturation == 0.0) 
    {
      r = g = b = unsigned char(luminance * 255.0);
    }
    else
    {
      float rm1, rm2;

      if (luminance <= 0.5f) rm2 = luminance + luminance * saturation;  
      else                     rm2 = luminance + saturation - luminance * saturation;
      rm1 = 2.0f * luminance - rm2;   
      r   = ToRGB1(rm1, rm2, hue + 120.0f);   
      g = ToRGB1(rm1, rm2, hue);
      b  = ToRGB1(rm1, rm2, hue - 120.0f);
    }

    ret = ((DWORD)(((BYTE)(r)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(b))<<16)));

    return ret;
}


unsigned char cColorPicker::ToRGB1(float rm1, float rm2, float rh)
{
  if      (rh > 360.0f) rh -= 360.0f;
  else if (rh <   0.0f) rh += 360.0f;

  if      (rh <  60.0f) rm1 = rm1 + (rm2 - rm1) * rh / 60.0f;   
  else if (rh < 180.0f) rm1 = rm2;
  else if (rh < 240.0f) rm1 = rm1 + (rm2 - rm1) * (240.0f - rh) / 60.0f;      

  return static_cast(rm1 * 255);
}

int _tmain(int argc, _TCHAR* argv[])
{
    vector myCols;
    cColorPicker colpick;
    colpick.Pick( myCols, 20 );
    for( int k = 0; k < (int)myCols.size(); k++ )
        printf("%d: %d %d %d\n", k+1,
        ( myCols[k] & 0xFF0000 ) >>16,
        ( myCols[k] & 0xFF00 ) >>8,
        ( myCols[k] & 0xFF ) );

    return 0;
}

रंगों को "अवधारणात्मक वर्दी" रंगस्थान में अधिकतम दूरी से ढूंढना सबसे अच्छा होगा, उदाहरण के लिए CIELAB (एल *, ए *, बी * आपके दूरी मीट्रिक के रूप में निर्देशांक के बीच यूक्लिडियन दूरी का उपयोग करके) और फिर अपनी पसंद के रंगस्थान में कनवर्ट करना। मानवीय दृश्य प्रणाली में गैर-रैखिकता का अनुमान लगाने के लिए रंगस्थान को ट्विक करके अवधारणात्मक एकरूपता प्राप्त की जाती है।

"सबसे अंतरनीय" प्राप्त करने के लिए हमें लैब (या किसी अन्य अवधारणात्मक रैखिक रंग स्थान) जैसे आरसीबी की अवधारणात्मक रंग स्थान का उपयोग करने की आवश्यकता है। इसके अलावा, हम अंतरिक्ष के आकार को कम करने के लिए इस जगह को माप सकते हैं।

सभी संभावित मात्राबद्ध प्रविष्टियों के साथ पूर्ण 3 डी स्पेस जेनरेट करें और k = N के साथ के-साधन एल्गोरिदम चलाएं। परिणामी केंद्र / "साधन" एक-दूसरे से लगभग सबसे अलग-अलग होना चाहिए।

मुझे यह एक पुरानी पोस्ट पता है, लेकिन मुझे इस विषय के लिए PHP समाधान की तलाश करते हुए पाया गया और अंततः एक साधारण समाधान के साथ आया:

function random_color($i = null, $n = 10, $sat = .5, $br = .7) {
    $i = is_null($i) ? mt_rand(0,$n) : $i;
    $rgb = hsv2rgb(array($i*(360/$n), $sat, $br));
    for ($i=0 ; $i<=2 ; $i++) 
        $rgb[$i] = dechex(ceil($rgb[$i]));
    return implode('', $rgb);
}

function hsv2rgb($c) { 
    list($h,$s,$v)=$c; 
    if ($s==0) 
        return array($v,$v,$v); 
    else { 
        $h=($h%=360)/60; 
        $i=floor($h); 
        $f=$h-$i; 
        $q[0]=$q[1]=$v*(1-$s); 
        $q[2]=$v*(1-$s*(1-$f)); 
        $q[3]=$q[4]=$v; 
        $q[5]=$v*(1-$s*$f); 
        return(array($q[($i+4)%6]*255,$q[($i+2)%6]*255,$q[$i%6]*255)); //[1] 
    } 
}

तो बस random_color() फ़ंक्शन को कॉल करें जहां $ मैं रंग की पहचान करता हूं, $ n संभावित रंगों की संख्या, $ संतृप्ति बैठता है और चमकती है।