algorithm - एल्गोरिदम यादृच्छिक रूप से एक सौंदर्य-सुखदायक रंग पैलेट उत्पन्न




colors (14)

मैं बड़ी संख्या में यादृच्छिक, सौंदर्यपूर्ण रूप से सुखदायक रंग उत्पन्न करने के लिए एक सरल एल्गोरिदम की तलाश में हूं। तो कोई पागल नीयन रंग, मल की याद ताजा रंग, आदि

मुझे इस समस्या का समाधान मिला है लेकिन वे आरजीबी की तुलना में वैकल्पिक रंग पैलेट पर भरोसा करते हैं। मैं बस आगे और पीछे मैपिंग की तुलना में सीधे आरजीबी का उपयोग करता हूं। ये अन्य समाधान भी केवल 32 या इतने आकर्षक यादृच्छिक रंग उत्पन्न कर सकते हैं।

सभी विचारों का स्वागत है।


Answers

आर दो लाइनर में डेविड क्रो की विधि:

GetRandomColours <- function(num.of.colours, color.to.mix=c(1,1,1)) {
  return(rgb((matrix(runif(num.of.colours*3), nrow=num.of.colours)*color.to.mix)/2))
}

मैं दृढ़ता से एक CG HSVtoRGB शेडर फ़ंक्शन का उपयोग करने की अनुशंसा करता हूं, वे बहुत ही अच्छे हैं ... यह आपको एक क्रेट मॉनीटर की तरह नियंत्रण के बजाए चित्रकार की तरह प्राकृतिक रंग नियंत्रण देता है, जो आप संभवतः नहीं हैं!

यह 1 फ्लोट वैल्यू बनाने का एक तरीका है। यानी ग्रे, रंग और चमक और संतृप्ति आदि के संयोजन के 1000 डीएस में:

int rand = a global color randomizer that you can control by script/ by a crossfader etc.
float h = perlin(grey,23.3*rand)
float s = perlin(grey,54,4*rand)
float v = perlin(grey,12.6*rand)

Return float4 HSVtoRGB(h,s,v);

परिणाम अद्भुत रंग रैंडिज़ेशन है! यह प्राकृतिक नहीं है लेकिन यह प्राकृतिक रंग ग्रेडियेंट का उपयोग करता है और यह कार्बनिक और नियंत्रित रूप से इंद्रधनुष / पेस्टल पैरामीटर दिखता है।

पर्लिन के लिए, आप इस फ़ंक्शन का उपयोग कर सकते हैं, यह पेर्लिन का तेज़ ज़िग ज़ाग संस्करण है।

function  zig ( xx : float ): float{    //lfo nz -1,1
    xx= xx+32;
    var x0 = Mathf.Floor(xx);
    var x1 = x0+1;
    var v0 = (Mathf.Sin (x0*.014686)*31718.927)%1;
    var v1 = (Mathf.Sin  (x1*.014686)*31718.927)%1;
    return Mathf.Lerp( v0 , v1 , (xx)%1 )*2-1;
}

distinct-colors प्रयोग करें।

जावास्क्रिप्ट में लिखा है।

यह दृष्टि से अलग रंगों का एक पैलेट उत्पन्न करता है।

विशिष्ट रंग अत्यधिक विन्यास योग्य है:

  • चुनें कि पैलेट में कितने रंग हैं
  • एक विशिष्ट सीमा के लिए रंग को प्रतिबंधित करें
  • क्रोमो (संतृप्ति) को एक विशिष्ट सीमा तक सीमित करें
  • एक विशिष्ट सीमा में हल्केपन को प्रतिबंधित करें
  • पैलेट की सामान्य गुणवत्ता को कॉन्फ़िगर करें

डेविड क्रो के मूल उत्तर, आईई और नोडजेस के विशिष्ट कोड में जावास्क्रिप्ट अनुकूलन शामिल है।

generateRandomComplementaryColor = function(r, g, b){
    //--- JavaScript code
    var red = Math.floor((Math.random() * 256));
    var green = Math.floor((Math.random() * 256));
    var blue = Math.floor((Math.random() * 256));
    //---

    //--- Extra check for Internet Explorers, its Math.random is not random enough.
    if(!/MSIE 9/i.test(navigator.userAgent) && !/MSIE 10/i.test(navigator.userAgent) && !/rv:11.0/i.test(navigator.userAgent)){
        red = Math.floor((('0.' + window.crypto.getRandomValues(new Uint32Array(1))[0]) * 256));
        green = Math.floor((('0.' + window.crypto.getRandomValues(new Uint32Array(1))[0]) * 256));
        blue = Math.floor((('0.' + window.crypto.getRandomValues(new Uint32Array(1))[0]) * 256));
    };
    //---

    //--- nodejs code
    /*
    crypto = Npm.require('crypto');
    red = Math.floor((parseInt(crypto.randomBytes(8).toString('hex'), 16)) * 1.0e-19 * 256);
    green = Math.floor((parseInt(crypto.randomBytes(8).toString('hex'), 16)) * 1.0e-19 * 256);
    blue = Math.floor((parseInt(crypto.randomBytes(8).toString('hex'), 16)) * 1.0e-19 * 256);
    */
    //---

    red = (red + r)/2;
    green = (green + g)/2;
    blue = (blue + b)/2;

    return 'rgb(' + Math.floor(red) + ', ' + Math.floor(green) + ', ' + Math.floor(blue) + ')';
}

फ़ंक्शन का उपयोग करके चलाएं:

generateRandomComplementaryColor(240, 240, 240);

यहां सी # में त्वरित और गंदे रंग जनरेटर हैं (इस http://threekings.tk/mirror/ryb_TR.pdf में वर्णित 'आरवाईबी दृष्टिकोण' का उपयोग करके)। यह http://afriggeri.github.com/RYB/ से एक पुनर्लेख है।

उपयोग:

List<Color> ColorPalette = ColorGenerator.Generate(30).ToList();

पहले दो रंग सफेद होते हैं और काले रंग की छाया होती है। मैं अक्सर उन्हें इस तरह छोड़ देता हूं (लिंक का उपयोग करके):

List<Color> ColorsPalette = ColorGenerator
            .Generate(30)
            .Skip(2) // skip white and black
            .ToList(); 

कार्यान्वयन:

public static class ColorGenerator
{

    // RYB color space
    private static class RYB
    {
        private static readonly double[] White = { 1, 1, 1 };
        private static readonly double[] Red = { 1, 0, 0 };
        private static readonly double[] Yellow = { 1, 1, 0 };
        private static readonly double[] Blue = { 0.163, 0.373, 0.6 };
        private static readonly double[] Violet = { 0.5, 0, 0.5 };
        private static readonly double[] Green = { 0, 0.66, 0.2 };
        private static readonly double[] Orange = { 1, 0.5, 0 };
        private static readonly double[] Black = { 0.2, 0.094, 0.0 };

        public static double[] ToRgb(double r, double y, double b)
        {
            var rgb = new double[3];
            for (int i = 0; i < 3; i++)
            {
                rgb[i] = White[i]  * (1.0 - r) * (1.0 - b) * (1.0 - y) +
                         Red[i]    * r         * (1.0 - b) * (1.0 - y) +
                         Blue[i]   * (1.0 - r) * b         * (1.0 - y) +
                         Violet[i] * r         * b         * (1.0 - y) +
                         Yellow[i] * (1.0 - r) * (1.0 - b) *        y +
                         Orange[i] * r         * (1.0 - b) *        y +
                         Green[i]  * (1.0 - r) * b         *        y +
                         Black[i]  * r         * b         *        y;
            }

            return rgb;
        }
    }

    private class Points : IEnumerable<double[]>
    {
        private readonly int pointsCount;
        private double[] picked;
        private int pickedCount;

        private readonly List<double[]> points = new List<double[]>();

        public Points(int count)
        {
            pointsCount = count;
        }

        private void Generate()
        {
            points.Clear();
            var numBase = (int)Math.Ceiling(Math.Pow(pointsCount, 1.0 / 3.0));
            var ceil = (int)Math.Pow(numBase, 3.0);
            for (int i = 0; i < ceil; i++)
            {
                points.Add(new[]
                {
                    Math.Floor(i/(double)(numBase*numBase))/ (numBase - 1.0),
                    Math.Floor((i/(double)numBase) % numBase)/ (numBase - 1.0),
                    Math.Floor((double)(i % numBase))/ (numBase - 1.0),
                });
            }
        }

        private double Distance(double[] p1)
        {
            double distance = 0;
            for (int i = 0; i < 3; i++)
            {
                distance += Math.Pow(p1[i] - picked[i], 2.0);
            }

            return distance;
        }

        private double[] Pick()
        {
            if (picked == null)
            {
                picked = points[0];
                points.RemoveAt(0);
                pickedCount = 1;
                return picked;
            }

            var d1 = Distance(points[0]);
            int i1 = 0, i2 = 0;
            foreach (var point in points)
            {
                var d2 = Distance(point);
                if (d1 < d2)
                {
                    i1 = i2;
                    d1 = d2;
                }

                i2 += 1;
            }

            var pick = points[i1];
            points.RemoveAt(i1);

            for (int i = 0; i < 3; i++)
            {
                picked[i] = (pickedCount * picked[i] + pick[i]) / (pickedCount + 1.0);
            }

            pickedCount += 1;
            return pick;
        }

        public IEnumerator<double[]> GetEnumerator()
        {
            Generate();
            for (int i = 0; i < pointsCount; i++)
            {
                yield return Pick();
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

    public static IEnumerable<Color> Generate(int numOfColors)
    {
        var points = new Points(numOfColors);

        foreach (var point in points)
        {
            var rgb = RYB.ToRgb(point[0], point[1], point[2]);
            yield return Color.FromArgb(
                (int)Math.Floor(255 * rgb[0]),
                (int)Math.Floor(255 * rgb[1]),
                (int)Math.Floor(255 * rgb[2]));
        }
    }
}

PHP में:

function pastelColors() {
    $r = dechex(round(((float) rand() / (float) getrandmax()) * 127) + 127);
    $g = dechex(round(((float) rand() / (float) getrandmax()) * 127) + 127);
    $b = dechex(round(((float) rand() / (float) getrandmax()) * 127) + 127);

    return "#" . $r . $g . $b;
}

स्रोत: https://.com/a/12266311/2875783


आप निरंतर रंग के साथ यादृच्छिक रंगों के आरजीबी मान औसत कर सकते हैं:

(जावा में उदाहरण)

public Color generateRandomColor(Color mix) {
    Random random = new Random();
    int red = random.nextInt(256);
    int green = random.nextInt(256);
    int blue = random.nextInt(256);

    // mix the color
    if (mix != null) {
        red = (red + mix.getRed()) / 2;
        green = (green + mix.getGreen()) / 2;
        blue = (blue + mix.getBlue()) / 2;
    }

    Color color = new Color(red, green, blue);
    return color;
}


सफेद रंग के साथ यादृच्छिक रंग मिलाकर (255, 255, 255) मूल रंग के रंग को बनाए रखते हुए हल्केपन को बढ़ाकर तटस्थ पेस्टल बनाता है। ये यादृच्छिक रूप से जेनरेट किए गए पेस्टल आमतौर पर अच्छी तरह से अच्छी तरह से जाते हैं, खासकर बड़ी संख्या में।

उपर्युक्त विधि का उपयोग करके उत्पन्न कुछ पेस्टल रंग यहां दिए गए हैं:


आप यादृच्छिक रंग को निरंतर पेस्टल के साथ भी मिला सकते हैं, जिसके परिणामस्वरूप तटस्थ रंगों का एक टिंटेड सेट होता है। उदाहरण के लिए, हल्के नीले रंग का उपयोग इन रंगों को बनाता है:


आगे बढ़ते हुए, आप अपने जनरेटर को हेरिस्टिक जोड़ सकते हैं जो पूरक रंगों या छायांकन के स्तर को ध्यान में रखता है, लेकिन यह सब उस छाप पर निर्भर करता है जिसे आप अपने यादृच्छिक रंगों से प्राप्त करना चाहते हैं।

कुछ अतिरिक्त संसाधन:


जावास्क्रिप्ट में:

function pastelColors(){
    var r = (Math.round(Math.random()* 127) + 127).toString(16);
    var g = (Math.round(Math.random()* 127) + 127).toString(16);
    var b = (Math.round(Math.random()* 127) + 127).toString(16);
    return '#' + r + g + b;
}

यहां विचार देखा: http://blog.functionalfun.net/2008/07/random-pastel-colour-generator.html


एक उत्तर जिसे अनदेखा नहीं किया जाना चाहिए, क्योंकि यह सरल है और फायदे प्रस्तुत करता है, वास्तविक जीवन की तस्वीरों और चित्रों का नमूना है। आधुनिक कला चित्रों, सीज़ेन, वैन गोग, मॉनेट, फोटो के थंबनेल पर यादृच्छिक रंग चाहते हैं के रूप में कई यादृच्छिक पिक्सल के रूप में नमूना ... लाभ यह है कि आप विषय के आधार पर रंग प्राप्त कर सकते हैं और वे कार्बनिक रंग हैं। बस एक फ़ोल्डर में 20 - 30 चित्रों और यादृच्छिक नमूना हर समय एक यादृच्छिक तस्वीर डाल दें।

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


ऐसा करने के लिए एक और पैलेट में कनवर्ट करना एक बेहतर तरीका है। ऐसा करने का एक कारण है कि: अन्य पैलेट 'अवधारणात्मक' हैं - यानी, वे समान दिखने वाले रंगों को एक साथ रखते हैं, और एक चर को समायोजित करने से रंग को अनुमानित तरीके से बदल दिया जाता है। आरजीबी के लिए इनमें से कोई भी सच नहीं है, जहां रंगों के बीच कोई स्पष्ट संबंध नहीं है जो "अच्छी तरह से साथ जाते हैं"।


मैं एक रंगीन पहिया का उपयोग करता हूं और एक यादृच्छिक स्थिति देता हूं जिसमें आप सुनहरा कोण जोड़ सकते हैं (137,5 डिग्री)

http://en.wikipedia.org/wiki/Golden_angle

प्रत्येक बार अलग-अलग रंग प्राप्त करने के लिए जो ओवरलैप नहीं करते हैं।

कलर व्हील के लिए चमक को समायोजित करने से आप अलग-अलग चमकदार / गहरे रंग के संयोजन भी प्राप्त कर सकते हैं।

मुझे यह ब्लॉग पोस्ट मिला है जो सुनहरा अनुपात का उपयोग कर समस्या और समाधान को वास्तव में अच्छी तरह बताता है।

http://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/

अद्यतन: मुझे अभी यह अन्य दृष्टिकोण मिला है:

इसे आरवाईबी (लाल, पीला, नीला) विधि कहा जाता है और यह इस पेपर में वर्णित है:

http://threekings.tk/mirror/ryb_TR.pdf

"पेंट प्रेरित रंग कंपोजिटिंग" के रूप में।

एल्गोरिदम रंग उत्पन्न करता है और प्रत्येक नए रंग को पहले से चुने गए लोगों को अपनी यूक्लिडियन दूरी को अधिकतम करने के लिए चुना जाता है।

यहां आप जावास्क्रिप्ट में एए अच्छा कार्यान्वयन पा सकते हैं:

http://afriggeri.github.com/RYB/

अद्यतन 2:

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

http://tools.medialab.sciences-po.fr/iwanthue/index.php


function fnGetRandomColour(iDarkLuma, iLightLuma) 
{       
  for (var i=0;i<20;i++)
  {
    var sColour = ('ffffff' + Math.floor(Math.random() * 0xFFFFFF).toString(16)).substr(-6);

    var rgb = parseInt(sColour, 16);   // convert rrggbb to decimal
    var r = (rgb >> 16) & 0xff;  // extract red
    var g = (rgb >>  8) & 0xff;  // extract green
    var b = (rgb >>  0) & 0xff;  // extract blue

    var iLuma = 0.2126 * r + 0.7152 * g + 0.0722 * b; // per ITU-R BT.709


    if (iLuma > iDarkLuma && iLuma < iLightLuma) return sColour;
  }
  return sColour;
} 

पेस्टल के लिए, उच्च लुमा अंधेरे / प्रकाश पूर्णांक में गुजरें - यानि fnGetRandomColour (120, 250)

क्रेडिट: http://paulirish.com/2009/random-hex-color-code-snippets/ .com/questions/12043187/how-to-check-if-hex-color-is-too-black पर सभी क्रेडिट


यहां मैंने जो साइट बनाई है, उसके लिए मैंने लिखा है। यह वर्ग के साथ किसी भी div के लिए एक यादृच्छिक फ्लैट पृष्ठभूमि रंग स्वचालित रूप से उत्पन्न करेगा .flat-color-gen । Jquery केवल पृष्ठ पर सीएसएस जोड़ने के प्रयोजनों के लिए आवश्यक है; इसके मुख्य भाग के लिए यह आवश्यक नहीं है, जो generateFlatColorWithOrder() विधि है।

जेएसफ़ील्ड लिंक

(function($) {
    function generateFlatColorWithOrder(num, rr, rg, rb) {
        var colorBase = 256;
        var red = 0;
        var green = 0;
        var blue = 0;
        num = Math.round(num);
        num = num + 1;
        if (num != null) {

            red = (num*rr) % 256;
            green = (num*rg) % 256;
            blue = (num*rb) % 256;
        }
        var redString = Math.round((red + colorBase) / 2).toString();
        var greenString = Math.round((green + colorBase) / 2).toString();
        var blueString = Math.round((blue + colorBase) / 2).toString();
        return "rgb("+redString+", "+greenString+", "+blueString+")";
        //return '#' + redString + greenString + blueString;
    }

    function generateRandomFlatColor() {
        return generateFlatColorWithOrder(Math.round(Math.random()*127));
    }

    var rr = Math.round(Math.random()*1000);
    var rg = Math.round(Math.random()*1000);
    var rb = Math.round(Math.random()*1000);
    console.log("random red: "+ rr);
    console.log("random green: "+ rg);
    console.log("random blue: "+ rb);
    console.log("----------------------------------------------------");
    $('.flat-color-gen').each(function(i, obj) {
        console.log(generateFlatColorWithOrder(i));
        $(this).css("background-color",generateFlatColorWithOrder(i, rr, rg, rb).toString());
    });
})(window.jQuery);

असल में समस्या नीचे उबलती है:
1) उन सभी बहुभुजों को निर्धारित करें जिनमें कुछ जगह शामिल है जिसमें कोई अन्य बहुभुज नहीं है। आपके उपर्युक्त उदाहरण में, आपके पास 3 आकार / चक्र / बहुभुज हैं जिनमें कोई अन्य नहीं है: चतुर्भुज युक्त एस, चतुर्भुज युक्त ई, और उनमें से 2 के नीचे त्रिकोण।
2) निर्धारित करें कि क्या एस और ई इनमें से किसी भी बहुभुज के अंदर / बाहर विपरीत हैं।

भाग 1 के लिए, आपको एक ग्राफ बनाना होगा:

अपनी दी गई रेखा के चौराहे बिंदुओं की एक सरणी बनाएं, यह एन ^ 2 है। याद रखें कि प्रत्येक चौराहे बिंदु से कौन सी रेखाएं आईं। ये चौराहे बिंदु आपके ग्राफ के चरम हैं।

यदि वे एक ही पंक्ति से हैं तो दो चरम "जुड़े" हैं और उनके बीच कोई अन्य चौराहे बिंदु नहीं है। स्पष्ट रूप से यह निर्धारित करने के लिए फ़्लोटिंग पॉइंट की सटीकता पर भरोसा न करें।

अब आप अपने लेआउट में बहुभुज खोजना चाहते हैं। एक ग्राफ में सामान्य रूप से चक्रों की घातीय संख्या हो सकती है। हालांकि, प्रत्येक किनारे केवल 2 "आंतरिक" बहुभुज सीमा हो सकती है, इसलिए हम केवल चक्रों के बहुपद उप-समूह में रूचि रखते हैं। तो एक किनारा उठाओ, फिर बहुभुज में अगला किनारा ढूंढें, और तब तक दोहराएं जब तक कि आप कहां से शुरू नहीं करते हैं या यह निर्धारित करते हैं कि पहला किनारा बहुभुज का हिस्सा नहीं था।

तो मान लीजिए कि आप एज ई = (यू, वी) से आ रहे हैं, और बहुभुज में अगला किनारा ढूंढना चाहते हैं (उसी वर्टेक्स वी साझा करना)।
1) यू - वी के रूप में एक वेक्टर टी बनाएँ।
2) किनारों का सेट बनाएं जो वर्टेक्स वी के समीप हैं। उस सेट से ई को हटाएं।
3) यदि सेट खाली है, तो किनारे बहुभुज का हिस्सा नहीं है।
4) ए में प्रत्येक किनारे (क्यू, वी) के लिए, एक वेक्टर आर का निर्माण क्यू - वी। (याद रखें क्यू और वी 2 डी विमान में बिंदुओं का प्रतिनिधित्व करें)।
5) सामान्यीकृत आर: लंबाई 1 के वेक्टर बनाने के लिए इसकी लंबाई से विभाजित करें।
6) CrossProductValue (टी, आर) निर्धारित करें।
7) कम से कम CrossProductValue के साथ ए में किनारे आसन्न बहुभुज में अगला किनारा है। सबसे बड़ा CrossProductValue के साथ ए में किनारे अन्य बहुभुज में अगला किनारा है।

CrossProductChecker(2D T, 2D R) {
  return (T.x*R.y - T.y*R.x); // cross product for 2 dimensions
}

तो अपने बहुभुज खोजने के लिए इसका इस्तेमाल करें। क्रॉस प्रोडक्ट्स और साइनसॉइड्स के बीच संबंधों को देखने के लिए यह विचार करें कि यह कैसे काम करता है।

============

अब जब आपके पास सभी बहुभुज हैं, तो सब कुछ करना है कि क्या कोई ऐसा है जो एस अंदर है और ई बाहर है, या दूसरी तरफ है।

ऐसा करने का आसान तरीका एस से ई तक एक रेखा खींचना है। यदि यह किसी भी बहुभुज (ऊपर से चक्र) को कई बार छेड़छाड़ करता है, तो वे बहुभुज के बाहर या दोनों दोनों होते हैं इसलिए जांचते रहें।

यदि रेखा चक्र को एक विषम संख्या में छेड़छाड़ करती है, तो एक बहुभुज के अंदर है और एक बाहर है, तो आप कह सकते हैं कि कोई रास्ता नहीं है।





algorithm colors