पायथन

Question

के साथ समान रंग की गणना करना यदि मेरे पास आरजीबी मान थे: 255, 165, 0, 218, 255, 0 और 255, 37, 0 के समान रंगों की गणना करने के लिए क्या किया जा सकता है, लेकिन फिर भी किसी भी आरजीबी रंग के लिए आवेदन कर रहा है?

उदाहरण के लिए:

>>> to_analogous(0, 218, 255) 
[(0, 255, 165),(0, 90, 255)] 

संपादित करें: सरलता के लिए, एक अनुरूप रंग इस रूप में देखी जा सकती है, हरी जा रहा है इनपुट रंग, तो नीले, हरे और पीले हरे उत्पादन किया जा रहा है:
http://www.tigercolor.com/Images/Analogous.gif

Answer 1

आरजीबी से एचएसएल में कनवर्ट करना और घुमावदार +/- 30 डिग्री वास्तव में वही हो सकता है जो आप चाहते हैं, लेकिन आपको रंगीन पहिया दिखाई नहीं देगी।

यहाँ नमूना कोड अनुरूप रंग का उत्पादन करने के है और::

import colorsys 

DEG30 = 30/360. 
def adjacent_colors((r, g, b), d=DEG30): # Assumption: r, g, b in [0, 255] 
    r, g, b = map(lambda x: x/255., [r, g, b]) # Convert to [0, 1] 
    h, l, s = colorsys.rgb_to_hls(r, g, b)  # RGB -> HLS 
    h = [(h+d) % 1 for d in (-d, d)]   # Rotation by d 
    adjacent = [map(lambda x: int(round(x*255)), colorsys.hls_to_rgb(hi, l, s)) 
      for hi in h] # H'LS -> new RGB 
    return adjacent 

, प्राप्त करने क्रमश: 12 और 128 रंग, शुद्ध लाल (शीर्ष पर) के साथ शुरू, यह आप क्या मिलेगा है

अन्य रंगीन पहिया एक घटिया रंग प्रणाली पर विचार करके प्राप्त किया गया था। इसके लिए, आइए सादगी के लिए आरवायबी कलर स्पेस पर विचार करें (यह किसी भी सामान्य विद्यालय में आपके कला वर्गों में शायद रंग मिश्रण को दर्शाता है)। यह उपयोग करके, हम तुरंत बाद पहियों प्राप्त:

इन अनुरूप रंग प्राप्त करने के लिए, हम आरजीबी में एक रंग पर विचार सीधे RYB में एक रंग का प्रतिनिधित्व करते हैं, और फिर RYB से आरजीबी में बदलने का। उदाहरण के लिए, मान लें कि आपके पास आरजीबी में एक तिहाई (255, 128, 0) है। कॉल करें कि आरवाईबी ट्रिपल ट्रिपल करें और आरजीबी में कनवर्ट करें (255, 64, 0)। यह आरवाईबी -> आरजीबी रूपांतरण इस अर्थ में अद्वितीय नहीं है कि इसके लिए कई परिभाषाएं हो सकती हैं, मैंने गॉससेट और चेन द्वारा "पेंट प्रेस्ड कलर कंपोजिटिंग" से एक का उपयोग किया है। रूपांतरण करने के लिए कोड यहां दिया गया है:

def _cubic(t, a, b): 
    weight = t * t * (3 - 2*t) 
    return a + weight * (b - a) 

def ryb_to_rgb(r, y, b): # Assumption: r, y, b in [0, 1] 
    # red 
    x0, x1 = _cubic(b, 1.0, 0.163), _cubic(b, 1.0, 0.0) 
    x2, x3 = _cubic(b, 1.0, 0.5), _cubic(b, 1.0, 0.2) 
    y0, y1 = _cubic(y, x0, x1), _cubic(y, x2, x3) 
    red = _cubic(r, y0, y1) 

    # green 
    x0, x1 = _cubic(b, 1.0, 0.373), _cubic(b, 1.0, 0.66) 
    x2, x3 = _cubic(b, 0., 0.), _cubic(b, 0.5, 0.094) 
    y0, y1 = _cubic(y, x0, x1), _cubic(y, x2, x3) 
    green = _cubic(r, y0, y1) 

    # blue 
    x0, x1 = _cubic(b, 1.0, 0.6), _cubic(b, 0.0, 0.2) 
    x2, x3 = _cubic(b, 0.0, 0.5), _cubic(b, 0.0, 0.0) 
    y0, y1 = _cubic(y, x0, x1), _cubic(y, x2, x3) 
    blue = _cubic(r, y0, y1) 

    return (red, green, blue)