दिलचस्प पोस्ट
घटनाओं और प्रतिनिधियों और इसके संबंधित अनुप्रयोगों के बीच का अंतर एंड्रॉइड एफबी एसडीके से हमेशा फेसबुक पर संदेश पोस्ट करें एप्पल वॉच एप को डेटा पास करना कोई थ्रेड अपनी नौकरी खत्म करने के बाद एक मूल्य कैसे वापस कर सकता है? एक गो टेम्प्लेट रेंज लूप में, प्रत्येक पुनरावृत्ति पर लूप रीसेट के बाहर घोषित चर हैं? क्यों नोडेलिस्ट के लिए हर नहीं है? स्काला में `डेफ` बनाम` वैल` बनाम `आलसी वैल` का मूल्यांकन पंक्तियों को हटाने का सबसे तेज़ तरीका है जो स्पेशल सील्स के साथ नहीं पकड़ा जा सकता अज्ञात आंतरिक वर्ग से बाहरी चर सेट करना आपने एमवीवीएम में सफलतापूर्वक संदेशबॉक् स। () की कार्यक्षमता कैसे कार्यान्वित की है? इंटरफ़ेस चर स्थिर और अंतिम रूप से क्यों हैं? एक प्रसारण रिसीवर प्रोग्रामेटिक रूप से रजिस्टर करें मैं एक पोर्टेबल isnan / isinf समारोह कैसे कर सकता हूँ किसी पृष्ठ पर खर्च किए गए समय को मापने के लिए कैसे? पायथन में फ़ंक्शन से एकाधिक मानों को वापस करने का सबसे अच्छा तरीका क्या है?

कैसे स्वचालित रूप से एन "अलग" रंग उत्पन्न करने के लिए?

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

public static List<Color> pick(int num) { List<Color> colors = new ArrayList<Color>(); if (num < 2) return colors; float dx = 1.0f / (float) (num - 1); for (int i = 0; i < num; i++) { colors.add(get(i * dx)); } return colors; } public static Color get(float x) { float r = 0.0f; float g = 0.0f; float b = 1.0f; if (x >= 0.0f && x < 0.2f) { x = x / 0.2f; r = 0.0f; g = x; b = 1.0f; } else if (x >= 0.2f && x < 0.4f) { x = (x - 0.2f) / 0.2f; r = 0.0f; g = 1.0f; b = 1.0f - x; } else if (x >= 0.4f && x < 0.6f) { x = (x - 0.4f) / 0.2f; r = x; g = 1.0f; b = 0.0f; } else if (x >= 0.6f && x < 0.8f) { x = (x - 0.6f) / 0.2f; r = 1.0f; g = 1.0f - x; b = 0.0f; } else if (x >= 0.8f && x <= 1.0f) { x = (x - 0.8f) / 0.2f; r = 1.0f; g = 0.0f; b = x; } return new Color(r, g, b); } 

Solutions Collecting From Web of "कैसे स्वचालित रूप से एन "अलग" रंग उत्पन्न करने के लिए?"

आप अपने रंग बनाने के लिए एचएसएल रंग मॉडल का उपयोग कर सकते हैं।

यदि आप चाहते हैं कि भिन्न रंग (भिन्नता), और हल्के या संतृप्ति पर मामूली भिन्नताएं हैं, तो आप ऐसे रंगों को वितरित कर सकते हैं:

 // assumes hue [0, 360), saturation [0, 100), lightness [0, 100) for(i = 0; i < 360; i += 360 / num_colors) { HSLColor c; c.hue = i; c.saturation = 90 + randf() * 10; c.lightness = 50 + randf() * 10; addColor(c); } 

बहुत कुछ चर्चाओं में यह प्रश्न सामने आते हैं:

  • अनोखा रंग बनाने के लिए एल्गोरिथ्म
  • अद्वितीय रंग उत्पन्न करें
  • ग्राफ में स्पष्ट रूप से अलग आरजीबी रंग उत्पन्न करें
  • किसी भी प्राकृतिक संख्या के लिए n भिन्न रंग कैसे उत्पन्न करें?

विभिन्न समाधान प्रस्तावित हैं, लेकिन कोई भी इष्टतम नहीं हैं सौभाग्य से, विज्ञान बचाव में आता है

मनमानी एन

  • स्पष्ट छवियों के लिए रंग दिखाता है (निःशुल्क डाउनलोड)
  • मैप रंगीन निजीकरण के लिए एक वेब सेवा (मुफ्त डाउनलोड, एक webservice समाधान अगले महीने तक उपलब्ध होना चाहिए)
  • उच्च-कंट्रास्ट रंग सेट के चयन के लिए एक एल्गोरिथ्म (लेखक एक मुफ्त C ++ कार्यान्वयन प्रदान करते हैं)
  • रंग के उच्च-विपरीत सेट (समस्या के लिए पहला एल्गोरिथ्म)

पिछले 2 अधिकांश विश्वविद्यालय पुस्तकालयों / प्रॉक्सी के माध्यम से मुक्त हो जाएगा

N परिमित और अपेक्षाकृत छोटी है

इस मामले में, कोई सूची समाधान के लिए जा सकता है। इस विषय में एक बहुत दिलचस्प लेख स्वतंत्र रूप से उपलब्ध है:

  • एक रंगीन वर्णमाला और रंग कोडिंग की सीमाएं

विचार करने के लिए कई रंग सूचीएं हैं:

  • बॉयटन की 11 रंगों की सूची लगभग कभी उलझन में नहीं है (पिछले अनुभाग के पहले पेपर में उपलब्ध है)
  • केली के अधिकतम रंग के 22 रंग (उपरोक्त कागज में उपलब्ध है)

मैं भी एक एमआईटी छात्र द्वारा इस पैलेट में भाग गया अंत में, निम्नलिखित लिंक अलग-अलग रंग प्रणालियों / समन्वय के बीच परिवर्तित करने में उपयोगी हो सकते हैं (उदाहरणों में कुछ रंग आरजीबी में निर्दिष्ट नहीं हैं):

केली और बॉयटन की सूची के लिए, मैंने पहले से ही आरजीबी (सफेद और काले रंग के अपवाद के साथ रूपांतरण किया है, जो स्पष्ट होना चाहिए)। कुछ सी # कोड:

 public static ReadOnlyCollection<Color> KellysMaxContrastSet { get { return _kellysMaxContrastSet.AsReadOnly(); } } private static readonly List<Color> _kellysMaxContrastSet = new List<Color> { UIntToColor(0xFFFFB300), //Vivid Yellow UIntToColor(0xFF803E75), //Strong Purple UIntToColor(0xFFFF6800), //Vivid Orange UIntToColor(0xFFA6BDD7), //Very Light Blue UIntToColor(0xFFC10020), //Vivid Red UIntToColor(0xFFCEA262), //Grayish Yellow UIntToColor(0xFF817066), //Medium Gray //The following will not be good for people with defective color vision UIntToColor(0xFF007D34), //Vivid Green UIntToColor(0xFFF6768E), //Strong Purplish Pink UIntToColor(0xFF00538A), //Strong Blue UIntToColor(0xFFFF7A5C), //Strong Yellowish Pink UIntToColor(0xFF53377A), //Strong Violet UIntToColor(0xFFFF8E00), //Vivid Orange Yellow UIntToColor(0xFFB32851), //Strong Purplish Red UIntToColor(0xFFF4C800), //Vivid Greenish Yellow UIntToColor(0xFF7F180D), //Strong Reddish Brown UIntToColor(0xFF93AA00), //Vivid Yellowish Green UIntToColor(0xFF593315), //Deep Yellowish Brown UIntToColor(0xFFF13A13), //Vivid Reddish Orange UIntToColor(0xFF232C16), //Dark Olive Green }; public static ReadOnlyCollection<Color> BoyntonOptimized { get { return _boyntonOptimized.AsReadOnly(); } } private static readonly List<Color> _boyntonOptimized = new List<Color> { Color.FromArgb(0, 0, 255), //Blue Color.FromArgb(255, 0, 0), //Red Color.FromArgb(0, 255, 0), //Green Color.FromArgb(255, 255, 0), //Yellow Color.FromArgb(255, 0, 255), //Magenta Color.FromArgb(255, 128, 128), //Pink Color.FromArgb(128, 128, 128), //Gray Color.FromArgb(128, 0, 0), //Brown Color.FromArgb(255, 128, 0), //Orange }; static public Color UIntToColor(uint color) { var a = (byte)(color >> 24); var r = (byte)(color >> 16); var g = (byte)(color >> 8); var b = (byte)(color >> 0); return Color.FromArgb(a, r, g, b); } 

और हेक्स और 8-बिट-प्रति-चैनल के प्रतिनिधित्व में आरजीबी मूल्य हैं:

 kelly_colors_hex = [ 0xFFB300, # Vivid Yellow 0x803E75, # Strong Purple 0xFF6800, # Vivid Orange 0xA6BDD7, # Very Light Blue 0xC10020, # Vivid Red 0xCEA262, # Grayish Yellow 0x817066, # Medium Gray # The following don't work well for people with defective color vision 0x007D34, # Vivid Green 0xF6768E, # Strong Purplish Pink 0x00538A, # Strong Blue 0xFF7A5C, # Strong Yellowish Pink 0x53377A, # Strong Violet 0xFF8E00, # Vivid Orange Yellow 0xB32851, # Strong Purplish Red 0xF4C800, # Vivid Greenish Yellow 0x7F180D, # Strong Reddish Brown 0x93AA00, # Vivid Yellowish Green 0x593315, # Deep Yellowish Brown 0xF13A13, # Vivid Reddish Orange 0x232C16, # Dark Olive Green ] kelly_colors = dict(vivid_yellow=(255, 179, 0), strong_purple=(128, 62, 117), vivid_orange=(255, 104, 0), very_light_blue=(166, 189, 215), vivid_red=(193, 0, 32), grayish_yellow=(206, 162, 98), medium_gray=(129, 112, 102), # these aren't good for people with defective color vision: vivid_green=(0, 125, 52), strong_purplish_pink=(246, 118, 142), strong_blue=(0, 83, 138), strong_yellowish_pink=(255, 122, 92), strong_violet=(83, 55, 122), vivid_orange_yellow=(255, 142, 0), strong_purplish_red=(179, 40, 81), vivid_greenish_yellow=(244, 200, 0), strong_reddish_brown=(127, 24, 13), vivid_yellowish_green=(147, 170, 0), deep_yellowish_brown=(89, 51, 21), vivid_reddish_orange=(241, 58, 19), dark_olive_green=(35, 44, 22)) 

आप सभी जावा डेवलपर्स के लिए, यहां JavaFX रंग हैं:

 // Don't forget to import javafx.scene.paint.Color; private static final Color[] KELLY_COLORS = { Color.web("0xFFB300"), // Vivid Yellow Color.web("0x803E75"), // Strong Purple Color.web("0xFF6800"), // Vivid Orange Color.web("0xA6BDD7"), // Very Light Blue Color.web("0xC10020"), // Vivid Red Color.web("0xCEA262"), // Grayish Yellow Color.web("0x817066"), // Medium Gray Color.web("0x007D34"), // Vivid Green Color.web("0xF6768E"), // Strong Purplish Pink Color.web("0x00538A"), // Strong Blue Color.web("0xFF7A5C"), // Strong Yellowish Pink Color.web("0x53377A"), // Strong Violet Color.web("0xFF8E00"), // Vivid Orange Yellow Color.web("0xB32851"), // Strong Purplish Red Color.web("0xF4C800"), // Vivid Greenish Yellow Color.web("0x7F180D"), // Strong Reddish Brown Color.web("0x93AA00"), // Vivid Yellowish Green Color.web("0x593315"), // Deep Yellowish Brown Color.web("0xF13A13"), // Vivid Reddish Orange Color.web("0x232C16"), // Dark Olive Green }; 

निम्न क्रम के अनुसार क्रमबद्ध किए गए केली रंग निम्न हैं।

बेतरतीब केली रंग

निम्नलिखित रंगों के अनुसार सॉर्ट किए गए केली रंग हैं (ध्यान दें कि कुछ पिल्ले बहुत विपरीत नहीं हैं)

हलकी केली रंग

यहाँ एक विचार है एक एचएसवी सिलेंडर की कल्पना करो

चमक और संतृप्ति के लिए इच्छित ऊपरी और निचली सीमाओं को परिभाषित करें यह अंतरिक्ष के भीतर एक वर्ग क्रॉस सेक्शन रिंग को परिभाषित करता है।

अब, इस अंतरिक्ष के भीतर बेतरतीब ढंग से बिखरे हुए एन अंक।

फिर उन पर एक पुनरावृत्त प्रतिकृति एल्गोरिथ्म लागू करें, या तो निश्चित पुनरावृत्तियों के लिए, या अंक स्थिर होने तक।

अब आपके पास एन के अंक का प्रतिनिधित्व करना चाहिए जो कि रंग अंतरिक्ष में जितना संभव हो उतना अलग है जितना आपकी रुचि है।

ह्यूगो

उरी कोहेन के जवाब की तरह, लेकिन इसके बजाय एक जनरेटर है रंगों का उपयोग अलग से शुरू कर देंगे नियतात्मक।

नमूना, पहले बाएं रंग: नमूना

 #!/usr/bin/env python3.3 import colorsys import itertools from fractions import Fraction def zenos_dichotomy(): """ http://en.wikipedia.org/wiki/1/2_%2B_1/4_%2B_1/8_%2B_1/16_%2B_%C2%B7_%C2%B7_%C2%B7 """ for k in itertools.count(): yield Fraction(1,2**k) def getfracs(): """ [Fraction(0, 1), Fraction(1, 2), Fraction(1, 4), Fraction(3, 4), Fraction(1, 8), Fraction(3, 8), Fraction(5, 8), Fraction(7, 8), Fraction(1, 16), Fraction(3, 16), ...] [0.0, 0.5, 0.25, 0.75, 0.125, 0.375, 0.625, 0.875, 0.0625, 0.1875, ...] """ yield 0 for k in zenos_dichotomy(): i = k.denominator # [1,2,4,8,16,...] for j in range(1,i,2): yield Fraction(j,i) bias = lambda x: (math.sqrt(x/3)/Fraction(2,3)+Fraction(1,3))/Fraction(6,5) # can be used for the v in hsv to map linear values 0..1 to something that looks equidistant def genhsv(h): for s in [Fraction(6,10)]: # optionally use range for v in [Fraction(8,10),Fraction(5,10)]: # could use range too yield (h, s, v) # use bias for v here if you use range genrgb = lambda x: colorsys.hsv_to_rgb(*x) flatten = itertools.chain.from_iterable gethsvs = lambda: flatten(map(genhsv,getfracs())) getrgbs = lambda: map(genrgb, gethsvs()) def genhtml(x): uint8tuple = map(lambda y: int(y*255), x) return "rgb({},{},{})".format(*uint8tuple) gethtmlcolors = lambda: map(genhtml, getrgbs()) if __name__ == "__main__": print(list(itertools.islice(gethtmlcolors(), 100))) 

पीढ़ियों के लिए आने के लिए मैं यहां पायथन में स्वीकृत उत्तर जोड़ता हूं।

 import numpy as np import colorsys def _get_colors(num_colors): colors=[] for i in np.arange(0., 360., 360. / num_colors): hue = i/360. lightness = (50 + np.random.rand() * 10)/100. saturation = (90 + np.random.rand() * 10)/100. colors.append(colorsys.hls_to_rgb(hue, lightness, saturation)) return colors 

सभी को बहुत ही उपयोगी YUV रंग अंतरिक्ष के अस्तित्व को याद किया गया है जो मानवीय दृश्य प्रणाली में कथित रंग अंतर का प्रतिनिधित्व करने के लिए डिज़ाइन किया गया था। YUV में दूरी मानव धारणा में अंतर प्रतिनिधित्व करते हैं मुझे MagicCube4D के लिए इस कार्यक्षमता की आवश्यकता है जो 4-आयामी रूबिक के क्यूब्स और असीमित संख्या में अन्य 4 डी ट्विस्टी पहेलियाँ होती हैं, जिनमें मनमानी चेहरे होते हैं।

YUV में यादृच्छिक बिंदुओं का चयन करके मेरा समाधान शुरू होता है और उसके बाद परिणाम दोबारा सबसे निकटतम दो बिंदुओं को तोड़ता है, और केवल रिजल्ट लौटने पर आरजीबी को परिवर्तित करता है। विधि ओ (एन ^ 3) है, लेकिन यह कैश्ड हो सकता है कि छोटी संख्या या उन लोगों के लिए कोई फर्क नहीं पड़ता। यह निश्चित रूप से और अधिक कुशल बनाया जा सकता है लेकिन परिणाम उत्कृष्ट दिखाई देते हैं।

यह समारोह चमक थ्रेसहोल्ड के वैकल्पिक विनिर्देशों के लिए अनुमति देता है ताकि रंगों का उत्पादन न हो जाए, जिसमें कोई भी घटक दी गई राशि से अधिक उज्ज्वल या गहरा नहीं है। IE आप काला या सफेद के करीब मान नहीं चाह सकते यह उपयोगी है जब परिणामी रंगों को आधार रंग के रूप में उपयोग किया जाएगा जो बाद में प्रकाश, लेयरिंग, पारदर्शिता इत्यादि के माध्यम से छायांकित हो जाते हैं और अभी भी उनके आधार रंगों से अलग दिखेंगे।

 import java.awt.Color; import java.util.Random; /** * Contains a method to generate N visually distinct colors and helper methods. * * @author Melinda Green */ public class ColorUtils { private ColorUtils() {} // To disallow instantiation. private final static float U_OFF = .436f, V_OFF = .615f; private static final long RAND_SEED = 0; private static Random rand = new Random(RAND_SEED); /* * Returns an array of ncolors RGB triplets such that each is as unique from the rest as possible * and each color has at least one component greater than minComponent and one less than maxComponent. * Use min == 1 and max == 0 to include the full RGB color range. * * Warning: ON^2 algorithm blows up fast for more than 100 colors. */ public static Color[] generateVisuallyDistinctColors(int ncolors, float minComponent, float maxComponent) { rand.setSeed(RAND_SEED); // So that we get consistent results for each combination of inputs float[][] yuv = new float[ncolors][3]; // initialize array with random colors for(int got = 0; got < ncolors;) { System.arraycopy(randYUVinRGBRange(minComponent, maxComponent), 0, yuv[got++], 0, 3); } // continually break up the worst-fit color pair until we get tired of searching for(int c = 0; c < ncolors * 1000; c++) { float worst = 8888; int worstID = 0; for(int i = 1; i < yuv.length; i++) { for(int j = 0; j < i; j++) { float dist = sqrdist(yuv[i], yuv[j]); if(dist < worst) { worst = dist; worstID = i; } } } float[] best = randYUVBetterThan(worst, minComponent, maxComponent, yuv); if(best == null) break; else yuv[worstID] = best; } Color[] rgbs = new Color[yuv.length]; for(int i = 0; i < yuv.length; i++) { float[] rgb = new float[3]; yuv2rgb(yuv[i][0], yuv[i][1], yuv[i][2], rgb); rgbs[i] = new Color(rgb[0], rgb[1], rgb[2]); //System.out.println(rgb[i][0] + "\t" + rgb[i][1] + "\t" + rgb[i][2]); } return rgbs; } public static void hsv2rgb(float h, float s, float v, float[] rgb) { // H is given on [0->6] or -1. S and V are given on [0->1]. // RGB are each returned on [0->1]. float m, n, f; int i; float[] hsv = new float[3]; hsv[0] = h; hsv[1] = s; hsv[2] = v; System.out.println("H: " + h + " S: " + s + " V:" + v); if(hsv[0] == -1) { rgb[0] = rgb[1] = rgb[2] = hsv[2]; return; } i = (int) (Math.floor(hsv[0])); f = hsv[0] - i; if(i % 2 == 0) f = 1 - f; // if i is even m = hsv[2] * (1 - hsv[1]); n = hsv[2] * (1 - hsv[1] * f); switch(i) { case 6: case 0: rgb[0] = hsv[2]; rgb[1] = n; rgb[2] = m; break; case 1: rgb[0] = n; rgb[1] = hsv[2]; rgb[2] = m; break; case 2: rgb[0] = m; rgb[1] = hsv[2]; rgb[2] = n; break; case 3: rgb[0] = m; rgb[1] = n; rgb[2] = hsv[2]; break; case 4: rgb[0] = n; rgb[1] = m; rgb[2] = hsv[2]; break; case 5: rgb[0] = hsv[2]; rgb[1] = m; rgb[2] = n; break; } } // From http://en.wikipedia.org/wiki/YUV#Mathematical_derivations_and_formulas public static void yuv2rgb(float y, float u, float v, float[] rgb) { rgb[0] = 1 * y + 0 * u + 1.13983f * v; rgb[1] = 1 * y + -.39465f * u + -.58060f * v; rgb[2] = 1 * y + 2.03211f * u + 0 * v; } public static void rgb2yuv(float r, float g, float b, float[] yuv) { yuv[0] = .299f * r + .587f * g + .114f * b; yuv[1] = -.14713f * r + -.28886f * g + .436f * b; yuv[2] = .615f * r + -.51499f * g + -.10001f * b; } private static float[] randYUVinRGBRange(float minComponent, float maxComponent) { while(true) { float y = rand.nextFloat(); // * YFRAC + 1-YFRAC); float u = rand.nextFloat() * 2 * U_OFF - U_OFF; float v = rand.nextFloat() * 2 * V_OFF - V_OFF; float[] rgb = new float[3]; yuv2rgb(y, u, v, rgb); float r = rgb[0], g = rgb[1], b = rgb[2]; if(0 <= r && r <= 1 && 0 <= g && g <= 1 && 0 <= b && b <= 1 && (r > minComponent || g > minComponent || b > minComponent) && // don't want all dark components (r < maxComponent || g < maxComponent || b < maxComponent)) // don't want all light components return new float[]{y, u, v}; } } private static float sqrdist(float[] a, float[] b) { float sum = 0; for(int i = 0; i < a.length; i++) { float diff = a[i] - b[i]; sum += diff * diff; } return sum; } private static double worstFit(Color[] colors) { float worst = 8888; float[] a = new float[3], b = new float[3]; for(int i = 1; i < colors.length; i++) { colors[i].getColorComponents(a); for(int j = 0; j < i; j++) { colors[j].getColorComponents(b); float dist = sqrdist(a, b); if(dist < worst) { worst = dist; } } } return Math.sqrt(worst); } private static float[] randYUVBetterThan(float bestDistSqrd, float minComponent, float maxComponent, float[][] in) { for(int attempt = 1; attempt < 100 * in.length; attempt++) { float[] candidate = randYUVinRGBRange(minComponent, maxComponent); boolean good = true; for(int i = 0; i < in.length; i++) if(sqrdist(candidate, in[i]) < bestDistSqrd) good = false; if(good) return candidate; } return null; // after a bunch of passes, couldn't find a candidate that beat the best. } /** * Simple example program. */ public static void main(String[] args) { final int ncolors = 10; Color[] colors = generateVisuallyDistinctColors(ncolors, .8f, .3f); for(int i = 0; i < colors.length; i++) { System.out.println(colors[i].toString()); } System.out.println("Worst fit color = " + worstFit(colors)); } } 

आपके "विशिष्ट" समस्या को प्रबंधित करने के लिए यहां एक समाधान है, जो पूरी तरह से अधिकाधिक है:

प्रतिलिपि शुल्क के साथ उस पर एक इकाई के गोलाकार और ड्रॉप बिंदु बनाएं। एक कण प्रणाली चलाएं जब तक वे आगे नहीं बढ़ते (या डेल्टा "बहुत छोटा") है इस बिंदु पर, प्रत्येक अंक जितना संभव हो उतना एक दूसरे से दूर हैं। कन्वर्ट (एक्स, वाई, जेड) आरजीबी के लिए

मैं इसका उल्लेख करता हूं क्योंकि समस्याओं के कुछ वर्गों के लिए, इस तरह का समाधान ब्रूट बल से बेहतर काम कर सकता है।

मैं मूल रूप से इस क्षेत्र को दूर करने के लिए इस दृष्टिकोण को देखा था ।

फिर, एचएसएल स्पेस या आरजीबी स्पेस का ट्रैविसिंग का सबसे स्पष्ट समाधान शायद ठीक काम करेगा।

मैं अधिकतम करने के लिए संतृप्ति और lumination को ठीक करने और केवल रंग पर ध्यान केंद्रित करने की कोशिश करेंगे। जैसे कि मैं इसे देखता हूं, एच 0 से 255 तक जा सकता है और उसके आस-पास लपेटता है। अब अगर आप दो विपरीत रंग चाहते हैं तो आप इस अंगूठी के विपरीत पक्ष यानी 0 और 128 ले लेंगे। यदि आप 4 रंग चाहते हैं, तो आप कुछ 256 लंबाई के चक्र से 1/4 यानी 0, 64,128,192 के बीच अलग-अलग कर सकते हैं। और निश्चित रूप से, जैसा कि दूसरों को सुझाव दिया जाता है जब आपको एन रंग चाहिए, आप उन्हें 256 / N से अलग कर सकते हैं।

मैं इस विचार में क्या जोड़ूंगा, इस क्रम को बनाने के लिए एक बाइनरी संख्या का उलट प्रतिनिधित्व देना है। इसे देखो:

 0 = 00000000 after reversal is 00000000 = 0 1 = 00000001 after reversal is 10000000 = 128 2 = 00000010 after reversal is 01000000 = 64 3 = 00000011 after reversal is 11000000 = 192 

… इस तरह यदि आपको अलग-अलग रंगों की ज़रूरत हो तो आप केवल पहले एन संख्या ले सकते हैं, उन्हें उल्टा कर सकते हैं, और आप जितना संभव हो उतना दूर के अंक प्राप्त कर सकते हैं (एन की शक्ति दो के लिए) जबकि एक ही समय में प्रत्येक उपसर्ग क्रम बहुत अलग है

मेरे उपयोग के मामले में यह एक महत्वपूर्ण लक्ष्य था, क्योंकि मेरे पास एक चार्ट था जहां रंग इस रंग से ढंकित क्षेत्र द्वारा हल किया गया था। मैं बड़े अंतर के लिए चार्ट के सबसे बड़े क्षेत्रों को चाहता था, और मैं कुछ छोटे क्षेत्रों के साथ ठीक था, जिनके रंग शीर्ष 10 के समान थे, क्योंकि यह पाठक के लिए स्पष्ट था, जो एक ही क्षेत्र को देख कर एक है।

यदि एन काफी बड़ा है, तो आप कुछ समान दिखने वाला रंग प्राप्त करने जा रहे हैं। दुनिया में उनमें से बहुत से हैं

क्यों नहीं समान रूप से स्पेक्ट्रम के माध्यम से उन्हें वितरित करें, जैसे:

 IEnumerable<Color> CreateUniqueColors(int nColors) { int subdivision = (int)Math.Floor(Math.Pow(nColors, 1/3d)); for(int r = 0; r < 255; r += subdivision) for(int g = 0; g < 255; g += subdivision) for(int b = 0; b < 255; b += subdivision) yield return Color.FromArgb(r, g, b); } 

यदि आप अनुक्रम को मिलाकर देखना चाहते हैं, तो समान रंग एक दूसरे के बगल में नहीं हैं, तो आप परिणामस्वरूप की सूची को घसीटना कर सकते हैं।

क्या मैं यह सोच रहा हूं?

यह MATLAB में तुच्छ है (एक एचएसवी कमांड है):

 cmap = hsv(number_of_colors) 

मैंने आर नामक योग्यपाल के लिए एक पैकेज लिखा है जो विशेष रूप से इस प्रयोजन के लिए डिज़ाइन किया गया है। मैं सुझाव देता हूं कि यह कैसे काम करता है यह जानने के लिए विनेट को देखो, लेकिन मैं मुख्य बिंदुओं को संक्षेप करने की कोशिश करूँगा

क्वाच्चपाल एचएसएल कलर स्पेस में रंगों का एक विनिर्देश लेता है (जिसे पहले इस धागे में वर्णित किया गया था), इसे डीआईएन 99 9 रंगीन स्थान (जो प्रत्यक्ष रूप से एकसमान है) में प्रोजेक्ट करता है और एन को ढूंढता है कि किसी भी ओफ़ के बीच न्यूनतम दूरी को अधिकतम करता है।

 # Create a palette of 4 colors of hues from 0 to 360, saturations between # 0.1 and 0.5, and lightness from 0.6 to 0.85 pal <- qualpal(n = 4, list(h = c(0, 360), s = c(0.1, 0.5), l = c(0.6, 0.85))) # Look at the colors in hex format pal$hex #> [1] "#6F75CE" "#CC6B76" "#CAC16A" "#76D0D0" # Create a palette using one of the predefined color subspaces pal2 <- qualpal(n = 4, colorspace = "pretty") # Distance matrix of the DIN99d color differences pal2$de_DIN99d #> #69A3CC #6ECC6E #CA6BC4 #> 6ECC6E 22 #> CA6BC4 21 30 #> CD976B 24 21 21 plot(pal2) 

यहां छवि विवरण दर्ज करें

मुझे लगता है कि यह साधारण पुनरावर्ती एल्गोरिथ्म स्वीकार्य जवाब को पूरा करता है, ताकि अलग-अलग रंग मूल्यों को उत्पन्न किया जा सके। मैंने इसे एचएसवी के लिए बनाया है, लेकिन इसका इस्तेमाल अन्य रंग के स्थानों के लिए भी किया जा सकता है

यह चक्रों में रंगों को उत्पन्न करता है, प्रत्येक चक्र में एक दूसरे के लिए जितना संभव हो उतना संभव है।

 /** * 1st cycle: 0, 120, 240 * 2nd cycle (+60): 60, 180, 300 * 3th cycle (+30): 30, 150, 270, 90, 210, 330 * 4th cycle (+15): 15, 135, 255, 75, 195, 315, 45, 165, 285, 105, 225, 345 */ public static float recursiveHue(int n) { // if 3: alternates red, green, blue variations float firstCycle = 3; // First cycle if (n < firstCycle) { return n * 360f / firstCycle; } // Each cycle has as much values as all previous cycles summed (powers of 2) else { // floor of log base 2 int numCycles = (int)Math.floor(Math.log(n / firstCycle) / Math.log(2)); // divDown stores the larger power of 2 that is still lower than n int divDown = (int)(firstCycle * Math.pow(2, numCycles)); // same hues than previous cycle, but summing an offset (half than previous cycle) return recursiveHue(n % divDown) + 180f / divDown; } } 

मैं यहां इस तरह के एल्गोरिदम का पता लगाने में असमर्थ था। मुझे उम्मीद है यह मदद करता है, यह मेरी पहली पोस्ट यहाँ है