पृष्ठभूमि की तुलना में कम समान बनाने के लिए एक रंग को संशोधित करने के लिए एल्गोरिदम


23

मैं एक ठोस रंग से भरी पृष्ठभूमि के साथ, 20 गेंदों के एक दूसरे को उछालते हुए एक डेमो बना रहा हूं। प्रत्येक गेंद के लिए रंग को randint(0, 255)प्रत्येक आर, जी, बी ट्यूपल घटक के लिए यादृच्छिक रूप से चुना जाता है ।

समस्या कुछ गेंदों के रंग के साथ है जो पृष्ठभूमि के समान है, जिससे उन्हें देखना मुश्किल हो जाता है। मैं इससे बचना चाहूंगा, या तो किसी अन्य रंग को रोल करके अगर चुना हुआ एक समान है (किसी दिए गए सीमा के भीतर), या इसे पृष्ठभूमि रंग से दूर ले जाकर

दहलीज के रूप में उपयोग करने के लिए एक समानता सूचकांक की गणना कैसे करें ? या इसे बनाने के लिए एक रंग कैसे बदलना है, कहते हैं, कम ब्लू-ईश ?

स्पष्ट अस्वीकरण: मुझे रंग सिद्धांत के बारे में कुछ नहीं पता है, इसलिए मुझे नहीं पता कि क्या उपरोक्त अवधारणाएं भी मौजूद हैं!

मैं अजगर में कोडिंग कर रहा हूं, लेकिन मैं अवधारणाओं और रणनीतियों की तलाश कर रहा हूं, इसलिए छद्म कोड ठीक है (या सिर्फ सिद्धांत)।

संपादित करें:

कुछ बिंदुओं को स्पष्ट करने के लिए:

  • प्रत्येक गेंद का अपना यादृच्छिक रंग होता है। मैं चाहूंगा कि वे यथासंभव यादृच्छिक रहें, और रंग स्थान का यथासंभव पता लगाने के लिए (यह RGB या HSV हो, pygameरंग को परिभाषित करने के लिए दोनों स्वरूपों को स्वीकार करता है)

  • मैं पृष्ठभूमि के "बहुत करीब" होने के प्रत्येक रंग से बचना चाहूंगा। समस्या सिर्फ ह्यू के बारे में नहीं है: मैं हल्के नीले रंग की गेंद के साथ गहरे नीले रंग की पृष्ठभूमि (या "सफेद-ईश" नीले, आदि के खिलाफ "पूर्ण-नीला" के साथ पूरी तरह से ठीक हूं)

  • अभी के लिए, मुझे परवाह नहीं है अगर एक गेंद एक गेंद के समान रंग (या समरूप) के साथ समाप्त होती है। इससे बचना बोनस है, लेकिन यह एक मामूली बात है।

  • पृष्ठभूमि का रंग एक स्थिर, एकल आरजीबी रंग है। अभी के लिए मैं "बेसिक" ब्लू का उपयोग कर रहा हूं (0, 0, 255), लेकिन मैं इसके साथ व्यवस्थित नहीं हूं। तो पृष्ठभूमि को एक मनमाना रंग (मनमाने रंग, चमक, संतृप्ति, आदि के साथ) पर विचार करें।

EDIT2:

टीएल, डीआर संस्करण: बस एक्स यादृच्छिक रंगों को बनाने का एक तरीका दें ताकि कोई भी "बहुत ज्यादा" फीका न हो, मनमानी की पृष्ठभूमि के खिलाफ (लेकिन एकल और निरंतर) रंग



1
हर गेंद पर सिर्फ आउटलाइन ही क्यों?
ashes999

1
फिर पृष्ठभूमि और गेंदों के रंग दोनों से अलग रूपरेखा रंग बनाने में कोई समस्या हो सकती है;)
क्रॉम्स्टर कहते हैं कि मोनिका

1
@ एएक्सएमएम: यह मानना ​​मुश्किल है कि "मनमाने ढंग से बचने वाले यादृच्छिक रंगों को उत्पन्न करने के लिए" कोई आसान उपाय नहीं है
मैस्टेरियन

1
@MestreLion सिर्फ बाह्यरेखा के लिए काले रंग का उपयोग करता है और 128 की न्यूनतम RGB मान के साथ रंग उत्पन्न करता है। यह इतना आसान है।
ashes999

जवाबों:


33

आप इस तथ्य का उपयोग कर सकते हैं कि रंग एक (तीन आयामी) रंग स्थान बनाते हैं और इस रंग स्थान में दूरी की गणना करते हैं। फिर आपको दो रंगों के बीच की दूरी का पता लगाने के लिए इस रंग स्थान में एक मीट्रिक को परिभाषित करने की आवश्यकता है।

जैसे दो बिंदुओं x = (X1, x2, x3) और y = (y1, y2, y3) के बीच एक यूक्लिडियन स्थान में दूरी d (x, y) = sqrt ((y1-X1) * (y1-) द्वारा दी गई है X1) + (y2-x2) * (y2-x2) + (y3-x3) * (y3-x3))।

अब आप गेंदों के रंग और आपके पृष्ठभूमि के रंग के बीच की दूरी की गणना कर सकते हैं और यदि यह बहुत छोटा है, तो एक नया यादृच्छिक रंग बनाएं और फिर से परीक्षण करें।

आप पाएंगे कि इस कार्य के लिए न तो RGB और न ही HSV अच्छे रंग स्थान हैं। रंग अंतर पर विकिपीडिया लेख को रोजगार एल एक रंग अंतरिक्ष और कई संभव मैट्रिक्स देता है।

इस विषय पर स्टैकओवरफ़्लो पर एक डिस्कसियन भी है ।


यह एक बहुत अच्छा तरीका है, मैं ऐसा कर सका :) धन्यवाद! इसके अलावा, एक पर्याप्त "माइनुम दूरी" दहलीज खोजने के बारे में थोड़ा विस्तार से देखभाल करें? यदि RGB पर्याप्त नहीं है, तो L को b में कैसे बदलें? मैं सटीक धारणा मैट्रिक्स के लिए प्रयास नहीं कर रहा हूँ, इसलिए कोई भी "अच्छा पर्याप्त" चूक करेगा।
MestreLion

1
इस उत्तर से प्यार करें, अच्छी तरह से सोचा जाए कि समीकरण और संदर्भ प्रदान करने के लिए कार्य को कैसे करना है, इसकी अच्छी व्याख्या। अच्छा पहला जवाब।
टॉम 'ब्लू' पिडॉक

1
यदि आप मानव धारणा के "अच्छे पर्याप्त" सन्निकटन के लिए देख रहे हैं, तो आप YUV रंग स्थान पर देखना चाह सकते हैं , जिसका RGB से सीधा रूपांतरण है।
trm

5
थोड़ा समय बचाएं, और वर्गमूल (महंगा) न लें। बस अपने न्यूनतम रंग दूरी का मान बनाएं जो आप वर्ग से तुलना करते हैं।
क्रिस कुडमोर

1
@MestreLion L a b * कलर स्पेस को अवधारणात्मक रूप से समान होने के लिए आविष्कार किया गया था, जिसका अर्थ है कि दो रंगों के बीच की कथित दूरी रंग स्पेस में वास्तविक दूरी के समान है। चूंकि RGB रंग उपकरण पर निर्भर होते हैं, आप सीधे लैब और RGB के बीच परिवर्तित नहीं हो सकते। हालाँकि, यदि आप किसी विशिष्ट पूर्ण RGB रंग स्थान का उपयोग करते हैं, तो आप उन्हें परिवर्तित कर सकते हैं। यह लेख देखें: en.wikipedia.org/wiki/SRGB_color_space और यह लेख: en.wikipedia.org/wiki/Lab_color_space
jwir3

8

संयुक्त राष्ट्र के वेब एक्सेसिबिलिटी स्टैंडर्ड्स पेज ( http://www.un.org/webaccessibility/1_visual/13_colourcontrast.shtml ) वेबसाइटों पर उचित टेक्स्ट कंट्रास्ट सुनिश्चित करने के लिए एक मानक को इंगित करता है , यह ध्यान में रखते हुए कि कुछ उपयोगकर्ता कलरब्लाइंड हैं। यह आपके लिए विशेष रूप से महत्वपूर्ण हो सकता है क्योंकि आपके कुछ उपयोगकर्ता रंगीन हो सकते हैं और साथ ही एक हरे रंग की पृष्ठभूमि से एक लाल गेंद को बताना मुश्किल होगा (यदि उनके समान प्रकाश हो)।

संयुक्त राष्ट्र के पृष्ठ रसदार स्टूडियो चमकदार रंग कंट्रास्ट अनुपात अनुपात विश्लेषक ( http://juicystudio.com/services/luminositycontrastratio.php#specify ) को इंगित करता है, जिसमें पृष्ठभूमि पर पाठ का अनुपात 4.5: 1 के विपरीत होना चाहिए, जो कि मुझे छोड़कर अपने मामले के समान होने का विश्वास करें:

  • बड़े पाठ: बड़े पैमाने पर पाठ और बड़े पैमाने के पाठ की छवियों में कम से कम 3: 1 का विपरीत अनुपात होता है

अब इसके विपरीत अनुपात क्या है? हाइपरलिंक के बाद आगे (यह मजेदार है!) हम एक W3 पृष्ठ पर आते हैं जो विपरीत अनुपात को परिभाषित करता है:

Contrast Ratio = (L1 + 0.05)/(L2 + 0.05)

जहां L1 और L2 रंगों के सापेक्ष प्रकाशमान हैं। L1 अधिक चमकदार रंग है, L2 कम चमकदार रंग है। फिर, हम उसी W3 पृष्ठ के लिंक का अनुसरण करते हैं जो निर्दिष्ट करता है:

L = 0.2126 * R + 0.7152 * G + 0.0722 * B where R, G and B are defined as:

if RsRGB <= 0.03928 then R = RsRGB/12.92 else R = ((RsRGB+0.055)/1.055) ^ 2.4
if GsRGB <= 0.03928 then G = GsRGB/12.92 else G = ((GsRGB+0.055)/1.055) ^ 2.4
if BsRGB <= 0.03928 then B = BsRGB/12.92 else B = ((BsRGB+0.055)/1.055) ^ 2.4
and RsRGB, GsRGB, and BsRGB are defined as:

RsRGB = R8bit/255
GsRGB = G8bit/255
BsRGB = B8bit/255

ध्यान दें : ऊपर दिया गया कार्यवाहक प्रतीक ^ एक्सप्रेशनिएशन (x symbol ) को संदर्भित करता है

एक कंट्रास्ट एल्गोरिथ्म के लिए हमारे पास एक बहुत अच्छा ढांचा है (यह कलरब्लाइंड फ्रेंडली है!)

  • प्रत्येक रंग के लिए आर, जी, बी मान निर्धारित करें
  • प्रत्येक रंग के लिए ल्यूमिनेन्स निर्धारित करें
  • यदि कम से कम चमकदार रंग के लिए अधिक चमकदार रंग का कंट्रास्ट अनुपात 3 से कम है, तो reroll!

2
यह नोट करना चाहते हैं कि ^ प्रतिपादक होना चाहिए। हमें पागल सी-जैसे उपयोगकर्ताओं के लिए इसका मतलब है कि xor (मुझे वास्तव में लगता है कि आप एक मिनट के लिए फ्लोटिंग पॉइंट वैल्यू पर एक बिटवाइज़ ऑपरेशन करने की कोशिश कर रहे थे)।
छप

यह एक अद्भुत दृष्टिकोण है, मुझे यह पसंद है! :)
MestreLion

और इस बारे में चिंता न करें ^, मैं इस संदर्भ में कभी भी बिटवेअर XOR के बारे में नहीं सोचूंगा। (या किसी भी वास्तव में। C'mon C phreaks, ^छद्म-संहिताओं में घातांकता के लिए de-facto simbol है (हालाँकि बहुत कम भाषाएँ वास्तव में इसका उपयोग करती हैं ... अजगर में है **)
MestreLion

1
बस टाइपिंग फिक्सिंग। इसके अलावा, अगर किसी व्यक्ति को ^ से परेशानी है, तो संभावना है कि भविष्य में कोई और व्यक्ति भी हो सकता है। विशिष्ट होने के लिए चोट नहीं करता है।
जॉन

1
@ जॉन कोई चिंता नहीं, मुझे यकीन नहीं है कि भ्रम कहाँ से उत्पन्न होता है (अर्थात किस भाषा का प्रयोग ^ किस उद्देश्य के लिए किया गया है)। मुझे केवल पता है ^ कभी-कभी वीबीएन के साथ अपने अनुभव के कारण घातांक के लिए उपयोग किया जाता है (मुझे किसी अन्य भाषा का पता नहीं है जो इसे घातांक के रूप में उपयोग करते हैं, लेकिन शायद कुछ हैं)। बस एक सिर के रूप में, यह कैरेट प्रतीक है, न कि गाजर प्रतीक। सब्जियों के साथ प्रोग्रामिंग के बारे में कुछ भगवान भयानक मजाक बनाता है (विशेष रूप से एक वर्ग जड़ों को शामिल करने से पहले) इसे किसी को बदलने के लिए चाहते हो सकता है।
छप

2

0-255प्रत्येक घटक के लिए एक यादृच्छिक मान उत्पन्न करके RGB मानों का उपयोग करना न केवल पृष्ठभूमि के समान रंगों का निर्माण कर सकता है, आप गेंदों के लिए बहुत समान रंगों के साथ भी समाप्त हो सकते हैं।

मैं शायद एक कम यादृच्छिक दृष्टिकोण चुनूंगा और ऐसे रंगों का निर्माण करूंगा जो बदले में अलग होने की गारंटी देते हैं। आप ह्यू रेंज में प्रत्येक ~ 32 डिग्री के लिए एक रंग बना सकते हैं और चमक या संतृप्ति को वैकल्पिक कर सकते हैं (आरजीबी के बजाय एचएसवी रंग-मॉडल का उपयोग करें)।

तो कुछ इस तरह:

numColors = 20;
stepSize = 360 / (numColors / 2 + 1); // hue step size
for(i = 0; i < numColors; i++){
    color = HSV(i / 2 * stepSize, 0.5 + (i % 2) * 0.5, 1.0) 
}

जो 20 रंगों, अच्छी तरह से वितरित किया जाएगा। यह मानता है कि आप पूर्णांक गणित का उपयोग कर रहे हैं, इसलिए i = 0और i = 1उसी मूल्य को बनाएगा।

बेशक, यह बहुत अच्छा नहीं है। यदि आपके पास बनाने के लिए 100 रंग मान हैं, तो ह्यू स्पेसिंग पर्याप्त नहीं हो सकती है और आप फिर से इसी तरह के रंगों के साथ समाप्त हो जाएंगे। उस स्थिति में आप V(चमक) मूल्य भी भिन्न हो सकते हैं ।

मुझे नहीं पता कि आपकी पृष्ठभूमि का रंग कैसा है, लेकिन एचएसवी रंगों की तुलना करना आसान बनाता है (बस 3 घटकों की तुलना करें और यह मत भूलो कि एचयूई परिपत्र है (0 == 360))।

अद्यतन करें:

चूँकि मैंने वास्तव में आपके प्रश्न का उत्तर नहीं दिया, बल्कि एक और दृष्टिकोण प्रदान किया, यहाँ बताया गया है कि कैसे एक मनमाना पृष्ठभूमि के लिए एक एल्गोरिथ्म और पूरी तरह से यादृच्छिक रंगीन गेंदें दिख सकती हैं (यह एक जानवर-बल दृष्टिकोण है लेकिन आपके उपयोग के मामले में ठीक काम करना चाहिए):

// background color, currently equals RGB(0, 0, 255)
bg = HSV(240, 1.0, 1.0)

// number of colors to create is equal to the amount of balls
numColors = balls.length

// set threshold to compare colors. you can tweak this to your liking
threshold = 0.15

for(i = 0; i < numColors; i++){
    do {
        // assuming rnd returns a random float 0-1 inclusive
        color = HSV(rnd() * 360, rnd(), rnd())
        // calculate delta values, normalize hue to 0-1
        dH = (180 - abs(abs(bg.h - color.h) - 180)) / 360
        dS = bg.s - color.s
        dV = bg.v - color.v
        // "distance" between bg and color
        difference = sqrt(dH * dH + dS * dS + dV * dV)
    } while(difference < threshold)

    ball[i].color = color
}

आपके अल्गोरिथम के बारे में, यह पृष्ठभूमि के रंग को कैसे ध्यान में रख रहा है?
10

वर्तमान में यह पृष्ठभूमि के रंग को ध्यान में नहीं ले रहा है ... आप इसे उत्पन्न रंगों (जैसा कि पिछले पैराग्राफ में वर्णित है) की तुलना करके इसे ट्विक कर सकते हैं और फिर एक अलग के साथ एक रंग बना सकते हैं V(जैसा कि वर्तमान एल्गोरिथ्म में परिवर्तन नहीं होता है)।
बंमज़ैक

@MestreLion एक वैकल्पिक एल्गोरिथ्म के साथ एक अपडेट जोड़ा गया
bummzack

बढ़िया, जो एक अच्छी रणनीति लगती है। जानवर बल ठीक है, रंग केवल एक बार प्रारंभ में उत्पन्न होते हैं, गेम लूप के भीतर नहीं। लगता है कि आप रेने के समान ही उपयोग कर रहे हैं, एचएसवी में सादे यूक्लिडियन दूरी के साथ, सही? एचएसवी के लिए एक उपयुक्त सीमा का कोई संदर्भ? आरजीबी की तरह एच, एस और वी की दूरी समान है?
MestreLion

@MestreLion हां, रेने ने अपने जवाब में जो बताया, वह मेरा दूसरा एल्गोरिथ्म है। दुख की बात है कि अच्छे बदलाव के लिए कोई निश्चित मूल्य नहीं है क्योंकि रंग परिवर्तन समान रूप से नहीं होते हैं। हम नीले रंग की तुलना में हरे रंग में बहुत तेजी से बदलाव को पहचानते हैं ... इसलिए हरे रंग के लिए एक छोटी सी सीमा काम कर सकती है लेकिन अन्य रंगों आदि के लिए पर्याप्त नहीं होगी। जहां तक ​​मुझे पता है कि लैब रंग-स्थान मानव रंग धारणा के करीब है और यदि आप एचएसवी कलरस्पेस के साथ वांछनीय परिणाम प्राप्त नहीं करते हैं तो सबसे उपयुक्त हो सकता है।
बम्म्ज़ैक

1

चूँकि आपने उल्लेख किया है कि आपको एक स्थिर पृष्ठभूमि मिली है, गेंदों का रंग अभी भी एक यादृच्छिक हो सकता है लेकिन उन्हें कुछ निश्चित सीमाओं पर गिरना पड़ता है जो अभी भी पृष्ठभूमि की तारीफ करते हैं।

मूल बातें। इससे पहले कि हम यह करें कि आपको मूल बातें जानने की जरूरत है। निम्नलिखित रंगों पर विचार करें:

Black   #000000 rgb(0,0,0)
Red     #FF0000 rgb(255,0,0)
Green   #00FF00 rgb(0,255,0)
Blue    #0000FF rgb(0,0,255)
Yellow  #FFFF00 rgb(255,255,0)
Cyan    #00FFFF rgb(0,255,255)
Pink    #FF00FF rgb(255,0,255)
Gray    #C0C0C0 rgb(192,192,192)
White   #FFFFFF rgb(255,255,255)

कलर्स RGB [(0..255), (0..255), (0..255) का मिश्रण ऊपर के रूप में नए रंग बनाता है।

नकारात्मक रंगों के लिए कम्प्यूटिंग नकारात्मक रंग के लिए कम्प्यूटिंग ठीक उसी तरह है जैसे सियान में लाल, बैंगनी में हरा, पीले में नीला।

Red     #FF0000 rgb(255,0,0) ->     Cyan    #00FFFF rgb(0,255,255)
Green   #00FF00 rgb(0,255,0) ->     Purple   #FF00FF    rgb(255,0,255)
Blue    #0000FF rgb(0,0,255) ->     Yellow  #FFFF00 rgb(255,255,0)

पूरक रंग

पूरक रंगों की गणना पर संदर्भ के अनुसार: http://serennu.com/colour/rgbtohsl.php

एचएसएल के बारे में

एचएसएल रंग की इन तीन विशेषताओं में से प्रत्येक के लिए एक नंबर देते हुए, उनके रंग, संतृप्ति और लपट के संदर्भ में रंगों को व्यक्त करता है।

रंग पहिया पर कुदाल की स्थिति है, 0 डिग्री से 359 डिग्री तक व्यक्त किया गया है, जो पहिया के 360 ° का प्रतिनिधित्व करता है; 0 ° लाल होना, 180 ° लाल रंग का विपरीत रंग का सियान, इत्यादि।

संतृप्ति रंग की तीव्रता है, यह कितना सुस्त या उज्ज्वल है। निचली संतृप्ति, डलर (ग्रेअर) रंग दिखता है। यह प्रतिशत के रूप में व्यक्त किया जाता है, 100% पूर्ण संतृप्ति, सबसे चमकदार, और 0% कोई संतृप्ति, ग्रे नहीं है।

लाइटनेस कितनी हल्की होती है। संतृप्ति के लिए थोड़ा अलग। रंग में जितना अधिक सफ़ेद होगा उसका लाइटनेस मान जितना अधिक होगा, उतना ही काला, उसका लाइटनेस कम होगा। तो 100% लाइटनेस का रंग सफेद हो जाता है, 0% लाइटनेस का रंग काला हो जाता है, और "शुद्ध" रंग 50% लाइटनेस होगा।

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

तो एचएसएल संकेतन इस तरह दिखता है, उस क्रम में ह्यू, संतृप्ति और लपट के मूल्यों को देते हुए: टी

लाल: 0 ° 100% 50% पीला गुलाबी: 0 ° 100% 90% सियान: 180 ° 100% 50% यहां चरण हैं:

  1. अपने रंग को HSL में बदलें।

  2. Hue मान को Hue के विपरीत बदलें (जैसे, यदि आपका Hue 50 ° है, तो विपरीत पहिया पर 230 ° - 180 ° और आगे होगा)।

  3. संतृप्ति और लपट के मूल्यों को छोड़ दें जैसा कि वे थे।

  4. इस नए HSL मान को अपने मूल रंग संकेतन (RGB या जो भी हो) में बदलें।

EasyRGB.com जैसी साइटें आपके लिए RGB से HSL या इसके विपरीत जेनेरिक रूपांतरण कर सकती हैं।

संदर्भ में PHP में किया गया प्रोग्रामिंग उदाहरण

RGB से HSL में रूपांतरण

ब्लू # 0000FF आरजीबी (0,0,255) से ऊपर का मूल्य रेड हेक्साडेसिमल 00 + ग्रीन हेक्साडेसिमल 00 + ब्लू हेक्साडेसिमल एफएफ के रूप में प्रस्तुत किया जा सकता है

$redhex  = substr($hexcode,0,2);
$greenhex = substr($hexcode,2,2);
$bluehex = substr($hexcode,4,2);

इसे Red Decimal 0 + Green Decimal 0 + Blue Decimal 255 के रूप में भी पेश किया जा सकता है

$var_r = (hexdec($redhex)) / 255;
$var_g = (hexdec($greenhex)) / 255;
$var_b = (hexdec($bluehex)) / 255;

अब इन मानों को rgb2hsl रूटीन में प्लग करें। नीचे उस रूपांतरण के लिए EasyRGB.com के सामान्य कोड का मेरा PHP संस्करण है:

इनपुट $ var_r है, $ var_g और $ var_b आउटपुट के ऊपर से HSL $ h, $ s और $ l के बराबर है - इन्हें फिर से इनपुट मानों की तरह 1 के अंश के रूप में व्यक्त किया जाता है।

$var_min = min($var_r,$var_g,$var_b);ttt
$var_max = max($var_r,$var_g,$var_b);
$del_max = $var_max - $var_min;

$l = ($var_max + $var_min) / 2;

if ($del_max == 0)
{
        $h = 0;
        $s = 0;
}
else
{
        if ($l < 0.5)
        {
                $s = $del_max / ($var_max + $var_min);
        }
        else
        {
                $s = $del_max / (2 - $var_max - $var_min);
        };

        $del_r = ((($var_max - $var_r) / 6) + ($del_max / 2)) / $del_max;
        $del_g = ((($var_max - $var_g) / 6) + ($del_max / 2)) / $del_max;
        $del_b = ((($var_max - $var_b) / 6) + ($del_max / 2)) / $del_max;

        if ($var_r == $var_max)
        {
                $h = $del_b - $del_g;
        }
        elseif ($var_g == $var_max)
        {
                $h = (1 / 3) + $del_r - $del_b;
        }
        elseif ($var_b == $var_max)
        {
                $h = (2 / 3) + $del_g - $del_r;
        };

        if ($h < 0)
        {
                $h += 1;
        };

        if ($h > 1)
        {
                $h -= 1;
        };
};

तो अब हमारे पास एचएसएल मूल्य के रूप में रंग है, चर $ h, $ s और $ l में। इन तीन आउटपुट चर को फिर से डिग्री और प्रतिशत के बजाय इस स्तर पर 1 के भिन्न के रूप में आयोजित किया जाता है। तो जैसे, सियान (180 ° 100% 50%) $ h = 0.5, $ s = 1 और $ l = 0.5 के रूप में सामने आएगा।

अगला विपरीत ह्यू के मूल्य का पता लगाएं, अर्थात, जो 180 ° या 0.5 है, दूर है (मुझे यकीन है कि गणितज्ञों के पास इसे डॉट करने का एक और अधिक सुंदर तरीका है, लेकिन):

विपरीत ह्यू, $ h2 की गणना करें

            $h2 = $h + 0.5;

            if ($h2 > 1)
                    {
                            $h2 -= 1;
                    };

पूरक रंग का एचएसएल मूल्य अब $ h2, $ s, $ l में है। इसलिए हम इसे वापस RGB (फिर से, EasyRGB.com सूत्र के मेरे PHP संस्करण) में बदलने के लिए तैयार हैं। ध्यान दें कि इनपुट और आउटपुट प्रारूप इस बार भिन्न हैं, मेरी टिप्पणी कोड के शीर्ष पर देखें:

इनपुट पूरक रंग का एचएसएल मूल्य है, $ h2, $ s, $ l में 1 आउटपुट के अंशों को सामान्य 255 255 255 प्रारूप में आरजीबी, $ r, $ g में आयोजित किया जाता है, $ b Hue फ़ंक्शन hue_2_bgb के उपयोग से परिवर्तित किया जाता है, दिखाया गया है इस कोड के अंत में

    if ($s == 0)
    {
            $r = $l * 255;
            $g = $l * 255;
            $b = $l * 255;
    }
    else
    {
            if ($l < 0.5)
            {
                    $var_2 = $l * (1 + $s);
            }
            elset
            {
                    $var_2 = ($l + $s) - ($s * $l);
            };

            $var_1 = 2 * $l - $var_2;
            $r = 255 * hue_2_rgb($var_1,$var_2,$h2 + (1 / 3));
            $g = 255 * hue_2_rgb($var_1,$var_2,$h2);
            $b = 255 * hue_2_rgb($var_1,$var_2,$h2 - (1 / 3));
    };

   // Function to convert hue to RGB, called from above

    function hue_2_rgb($v1,$v2,$vh)
    {
            if ($vh < 0)
            {
                    $vh += 1;
            };

            if ($vh > 1)
            {
                    $vh -= 1;
            };

            if ((6 * $vh) < 1)
            {
                    return ($v1 + ($v2 - $v1) * 6 * $vh);
            };

            if ((2 * $vh) < 1)
            {
                    return ($v2);
            };

            if ((3 * $vh) < 2)
            {
                    return ($v1 + ($v2 - $v1) * ((2 / 3 - $vh) * 6));
            };

            return ($v1);
    };

और उस दिनचर्या के बाद, हमारे पास आखिरकार $ r, $ g और $ b 255 255 255 (RGB) प्रारूप में हैं, जिसे हम हेक्स के छह अंकों में बदल सकते हैं:

    $rhex = sprintf("%02X",round($r));
    $ghex = sprintf("%02X",round($g));
    $bhex = sprintf("%02X",round($b));

    $rgbhex = $rhex.$ghex.$bhex;

$ rgbhex हमारा उत्तर है - हेक्स में पूरक रंग।

चूँकि आपकी रंगीन पृष्ठभूमि नीली है या 0,0,255 HSL है

ह्यू (एच): 240 डिग्री / संतृप्ति (एस): 100% / लाइटनेस (एल): 4.9%

240 के विपरीत एक सर्कल में 60 है, तो RGB में वापस कनवर्ट करें # 181800 का मान देता है


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

धन्यवाद क्रॉम अब कर रहा है। @MestreLion, चूंकि पृष्ठभूमि स्थिर है, आप अपनी गेंदों के लिए एक सीमा निर्दिष्ट कर सकते हैं जो अभी भी पृष्ठभूमि को पूरक करता है।
ऐस कैसरेरा

वर्तमान में मेरे उत्तर का खुलासा।
ऐस कैसरिया

किया हुआ। मुझे नहीं लगता है कि साइटों के स्पष्टीकरण पर बहुत कुछ बदलना है क्योंकि इसे अच्छी तरह से समझाया गया है। EasyRGB.com पर लोगों को क्रेडिट
ऐस कैसरिया


1

मैं एक रूपरेखा बनाने के @ ashes999 के विचार पर विस्तार करना चाहूंगा।

मेरा कोड अजगर की तरह होने वाला है क्योंकि मैं अपने सिर के ऊपर से उतर सकता हूं (मैंने अपने जीवन में कभी भी अजगर की एक पंक्ति नहीं लिखी है, लेकिन मैंने एक या दो बार किताब पर नज़र रखी है)।

def lerp(a,b,value): # assuming your library was not kind enough to give you this for free
    return a + ((b - a) * value);

def drawRandomBall(bgColour,radius,point):
    var ballColour = Colour(random(0,255),random(0,255),random(0,255);
    var outlineColour = Colour(lerp(bgColour.R,255 - ballColour.R,0.5),lerp(bgColour.G,255 - ballColour.G,0.5),lerp(bgColour.B,255 - ballColour.B,0.5));
    fillCircle(point,radius+1,outlineColour);
    fillCircle(point,radius,ballColour);

यह विशेष रूप से सुंदर नहीं लग सकता है और यह वास्तव में उत्पादन कोड के लिए आदर्श नहीं है, लेकिन इसे त्वरित-फिक्स के रूप में पर्याप्त होना चाहिए। मैंने कोड का परीक्षण नहीं किया है क्योंकि मेरे पास "स्क्रीन के चारों ओर उछलती हुई गेंदें" कार्यक्रम नहीं है ताकि मैं यह परीक्षण कर सकूं।


संपादित करें:

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

निम्नलिखित के साथ लाइनों को 276-284 बदलें:

# Colour generator
def generateColourNonBG(leeway):
    color = (randint(0,255), randint(0,255), randint(0,255))
    while color[0] >= BG_COLOR[0]-leeway and color[0] =< BG_COLOR[0] + leeway and
    color[1] >= BG_COLOR[1]-leeway and color[1] =< BG_COLOR[1] + leeway and
    color[2] >= BG_COLOR[2]-leeway and color[2] =< BG_COLOR[2] + leeway:
        color = (randint(0,255), randint(0,255), randint(0,255))

# Ball generator
def generateBall():
    Ball(generateColourNonBG(5),
                   radius=randint(10, radius),
                   position=[randint(100, screen.get_size()[0]-radius),
                             randint(100, screen.get_size()[0]-radius)],
                   velocity=[randint(50, 50+vel[0]), randint(50, 50+vel[1])],
                   )                       

# Create the balls
balls = pygame.sprite.Group()
for _ in xrange(BALLS):
    balls.add(generateBall())

इस नए सरलीकृत संस्करण में, एक फैक्टरी विधि गेंदों को बाहर निकालती है, और एक विशेष विधि रंगों को उत्पन्न करती है। रंग जनरेटर यह देखने के लिए यादृच्छिक रूप से उत्पन्न रंग का परीक्षण करता है कि क्या यह पृष्ठभूमि रंग के निकटता की एक निश्चित सीमा के भीतर है। एक रंग को बीजी रंग के बहुत करीब माना जाता है यदि उसके तीन रंग चैनल leewayबीजी के दोनों ओर हैं। इसलिए यदि लेवे 0 है, तो केवल बीजी से मेल खाने वाले रंगों को मना कर दिया जाता है। मैंने 5 को डिफ़ॉल्ट के रूप में चुना है, जो कि बीजी रंग और 5 रंगों को दोनों ओर से मना करता है। चूंकि बीजी रंग सफेद है, इसलिए मुझे यकीन नहीं है कि यह काला इंकार कर देगा क्योंकि अंक गोल लपेटते हैं। यह न्यूनतम और अधिकतम कार्यों के उपयोग से बचा जा सकता है, लेकिन मैंने उन्हें संक्षिप्तता के लिए छोड़ दिया।


मैं किसी भी रणनीति के लिए खुला हूं :) एक कार्यक्रम को बदलने के लिए के रूप में, मैं आपको यह दे सकता हूं कि: github.com/MestreLion/rainballs प्रासंगिक लाइनें 279-284 होगी
मेस्ट्रेलेयन

मैं pygameएक पुस्तकालय के रूप में उपयोग कर रहा हूँ । Lerp नहीं, बस मूल RGB-HSV-CYMK रूपांतरण: pygame.org/docs/ref/color.html
MestreLion

@MestreLion ओह प्रभु, अब मुझे इसका परीक्षण करने के लिए pygame और अजगर स्थापित करना होगा। मैंने इस एक एक्सपी के साथ खुद को पैर में गोली मार ली है। लेरिंग की आसान, lerpमेरे जवाब में कार्य यह सब है। (लर्प का अर्थ है 'रैखिक प्रक्षेप')।
छपरा

@MestreLion एक बिट के बारे में बताया, अजगर के मेरे संस्करण को पसंद करता है प्रिंट को बिना कोष्ठक के नहीं कहा जाता है। निश्चित है कि, लेकिन अब मैं सही पुस्तकालयों को खोजने में सक्षम नहीं होने से pygame से त्रुटियों को मिला है। मैं अपने कोड को फिर से लिखने के लिए फिट करूँगा कि आपको क्या मिला है, लेकिन जब तक मैं pygame को ठीक नहीं करता, तब तक मैं इसका परीक्षण नहीं कर सकता। यदि आप पहले से ही (आपके लिए कुछ अजगर लिखने के लिए काफी अच्छा महसूस कर रहे हैं) तो उस फ़ाइल को उस प्रश्न पर लागू करने की सलाह दूंगा।
छपरा

आप printअलग हैं क्योंकि आप पायथन 3 का उपयोग कर रहे हैं, और मैं अभी भी पायथन 2 में हूं। और मुझे यकीन नहीं है कि pygameअभी तक Py3 में पोर्ट किया गया था। नीचे: परेशान मत करो :) सवाल रंगों के बारे में है, आपको वास्तविक गेंदों की ज़रूरत नहीं है चारों ओर उछलते हुए :)
MestreLion

1

आरजीबी प्रारूप के लिए, यह काफी अच्छा काम करता है और यह तुच्छ है:

विविधता_स्कोर = (एब्स (आर 1 - आर 2) + एब्स (जी 1 - जी 2) + एब्स (बी 1 - बी 2)) / 765.0

यह आपको 0.0 और 1.0 के बीच का स्कोर देगा। निचला, दो रंगों को अलग करना कठिन है।

यह स्पष्ट होना चाहिए, लेकिन पूर्णता के लिए: आर, जी, बी मानों को पहले एक फ्लोटिंग पॉइंट नंबर पर डालना होगा, और यह माना जाता है कि उनका अधिकतम मूल्य 255 है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.