एचएसएल टू आरजीबी मान

Question

RGB (रेड ग्रीन ब्लू) रंग मॉडल का मुख्य उद्देश्य इलेक्ट्रॉनिक प्रणालियों में छवियों, जैसे कि टीवी और कंप्यूटर के संवेदन, प्रतिनिधित्व और प्रदर्शन के लिए है

एचएसएल (ह्यू संतृप्ति लपट) एक वैकल्पिक रंग मॉडल है, जिसे 1970 के दशक में कंप्यूटर ग्राफिक्स शोधकर्ताओं द्वारा डिजाइन किया गया था, जिस तरह से मानव दृष्टि रंग बनाने की विशेषताओं को मानती है।

यहाँ RGB और HSL के लिए विकि लेख हैं । एचएसएल में गणना करना ग्राफिक्स कार्यक्रमों के लिए सामान्य है, और बाद में अधिकांश स्क्रीन के लिए पसंदीदा प्रारूप में परिवर्तित हो जाता है: आरजीबी।

कार्य एक फ़ंक्शन / प्रोग्राम लिखना है जो एक इनपुट के रूप में एचएसएल लेता है और आरजीबी आउटपुट करता है।

आप I / O के लिए अपना पसंदीदा प्रतिनिधित्व चुन सकते हैं, जब तक कि उनके बीच सुसंगत न हो।

उदाहरण के लिए, वे 3 तत्वों के साथ एक सरणी / टपल या 3 नामित गुणों के साथ एक वस्तु हो सकता है h, sऔर lहै, लेकिन मैं एक पूर्णांक (खोने परिशुद्धता) के रूप में एचएसएल प्राप्त करने और एक RGB पूर्णांक outputting जैसे अन्य चालाक रूपों को स्वीकार करेंगे।

इनपुट को सीमा और प्रारूप में सुरक्षित माना जा सकता है, यह दोनों आप तय कर सकते हैं। मैं दृढ़ता से या तो पर्वतमाला का सुझाव 0-1 0-1 0-1या 0-360 0-100 0-100एचएसएल के लिए, और 0-1 0-1 0-1या 0-255 0-255 0-255आरजीबी के लिए।

उपरोक्त दोनों को निर्दिष्ट करने के लिए प्रत्येक उत्तर की आवश्यकता होती है, और यदि आपने विशेष रूप से उन पर गर्व किया है, भले ही आपके पास अन्य विविधताओं की तुलना में कम वर्ण न हों, तो अपने उत्तरों में विभिन्न विविधताएँ रखें। शीर्ष पर सबसे छोटा रखो।

छद्म परीक्षण के मामले 0-360 0-100 0-100→0-255 0-255 0-255

h   s   l   → r   g   b

0   0   0   → 0   0   0
90  56  17  → 43  68  19
202 19  39  → 81  104 118
72  55  26  → 88  103 30

रूपांतरण के सूत्र यहां मिल सकते हैं :

रूपांतरण की कल्पना करने का यह एक अच्छा तरीका है:

Comments

के लिए आपका सुझाव रेंज Hकी 0-360है [0,360), यह बेहतर रूप में लिखा जाएगा 0-359?

— जोनाथन एलन

@JonathanAllan मुझे लगता है कि यह मेरे लिए थोड़ा और भ्रमित करने वाला हो सकता है, जैसा कि मुझे पता है कि 395.1 संभव इनपुट नहीं है। यदि कुछ भी, a-bगैर-पूर्णांक मानों के साथ काम करते समय अंकन का उपयोग करना अपने आप में गलत है, लेकिन मैं कहूंगा कि प्रश्न को अधिक पठनीय रखना ठीक है। अगर कोई और शिकायत करता है, तो मैं इसे फिर से

— सुनाऊँगा

हाँ, 359.1 बिंदु पर सहमत - शायद [0,360)तब के मानक अंकन का उपयोग करें :)

— जोनाथन एलन

कोई glsl जवाब नहीं देखकर हैरान;)

— 19

Answer 1

जावास्क्रिप्ट (ईएस 6), 98 95 94 बाइट्स

ले जाता है एच में [0360) और एस / एल में [0,1) । [0,1] में 3 फ़्लोट्स की एक सरणी के रूप में आर , जी और बी आउटपुट ।

(H,S,L)=>[5,3,1].map(i=>A(L*2)*S*([1,Y,0,0,Y,1][(i-~H)%6]-.5)+L,Y=(A=n=>n>1?2-n:n)((H/=60)%2))

परीक्षण के मामलों

यह स्निपेट परिणामों को वापस [0,255] में परिवर्तित करता है ।

let f =

(H,S,L)=>[5,3,1].map(i=>A(L*2)*S*([1,Y,0,0,Y,1][(i-~H)%6]-.5)+L,Y=(A=n=>n>1?2-n:n)((H/=60)%2))

format = a => JSON.stringify(a.map(v => v * 255 + 0.5 | 0))

console.log(format(f(  0, 0.00, 0.00))) //  0   0    0
console.log(format(f( 90, 0.56, 0.17))) // 43  68   19
console.log(format(f(202, 0.19, 0.39))) // 81  104 118
console.log(format(f( 72, 0.55, 0.26))) // 88  103  30

कैसे?

प्रारंभिक कोड

Y = (                  // we compute Y = 1 - |(H/60) mod 2 - 1| = X / C
  A = n =>             // A = function that returns 1 - |n - 1|
    n > 1 ?            //   first compare n with 1
      2 - n            //     which allows to simplify the formula to either 2 - n
    :                  //   or
      n                //     just n
)((H /= 60) % 2)       // divide H by 60 and compute Y = A(H % 2)

मुख्य कोड

[5, 3, 1].map(i =>     // for each i in (5, 3, 1):
  A(L * 2) * S * (     //   compute (1 - |2L - 1|) * S (this is C), and multiply it by:
    [1, Y, 0, 0, Y, 1] //     either 0, 1 or Y (let's call this factor K), picked from
    [(i - ~H) % 6]     //     a cyclic sequence of period 6, using i and ~H (-6 ≤ ~H ≤ -1)
    - .5               //     minus 1/2
  )                    //   this gives: C(K - 1/2) = CK - C/2, where CK = 0, C or X
  + L                  //   we add L, leading to CK - C/2 + L = CK + m
)                      // end of map() --> returns [R, G, B]

(0, C, X) के क्रमपरिवर्तन

थोड़ा मुश्किल हिस्सा ह्यू घटक के कोण के अनुसार (0, सी, एक्स) के सही क्रमचय को उत्पन्न करना है । जैसा कि निम्नलिखित आकृति में दिखाया गया है, प्रत्येक स्तंभ का मान 6 के समान साइकलिंग अनुक्रम से लिया जाता है , जो अलग-अलग स्थानों पर शुरू होता है। उपरोक्त कोड में, हम सिर्फ + H के बजाय ~ H का उपयोग कर रहे हैं, क्योंकि हमें H को एक पूर्णांक में ले जाने की आवश्यकता है। इसलिए (0,4,2) के बजाय ऑफसेट (5,3,1) ।

                       C,X,0,0,X,C,C,X,0,0,X,C, ...
 +------> C,X,0,0,X,C  <--------->                  offset = 0, (0 - 1) mod 6 = 5
 | +----> X,C,C,X,0,0          <--------->          offset = 4, (4 - 1) mod 6 = 3
 | | +--> 0,0,X,C,C,X      <--------->              offset = 2, (2 - 1) mod 6 = 1
 | | |
(C,X,0) for   0 ≤ H <  60
(X,C,0) for  60 ≤ H < 120
(0,C,X) for 120 ≤ H < 180
(0,X,C) for 180 ≤ H < 240
(X,0,C) for 240 ≤ H < 300
(C,0,X) for 300 ≤ H < 360

Comments

चाहेंगे लेने Hमें [0,6)और में outputting [0,1]कुछ बाइट्स बचाने?

— जोनाथन एलन

@JonathanAllan आह, मैंने ध्यान नहीं दिया I / O प्रारूप ढीला था। धन्यवाद!

— अरनौलद

Answer 2

मैथमेटिका, 155 बाइट्स

(x~Clear~c;d=Piecewise@Table[{(P=Permutations)[P@{c,x,0}][[42,i]],(i-1)<=#<i*p},{i,6}];c=(1-Abs[2#3-1])#2;x=c(1-Abs[Mod[#/(p=60),2]-1]);m=#3-c/2;(m+d)255)&

इसे ऑनलाइन आज़माएं!

Comments

या y'know, यह। : पी

— बिलकुल अमानवीय

@totallyhuman मुझे नहीं लगता कि यह सही है क्योंकि एचएसबी Hue(एके एचएसवी) एचएसएल नहीं है (लिंक विकिपीडिया पृष्ठ पर 2 ए और 2 बी देखें)।

— जोनाथन एलन

जेनी - अगर यह सही है, तो इसे नीचे पोस्ट न करने के लिए कोई कारण नहीं है क्योंकि यह आपके गैर-निर्मित के साथ है!

— जोनाथन एलन

@JonathanAllan ओह, तो यह है। यह थोड़ा कष्टप्रद है कि कैसे RGBColorमौजूद है लेकिन HSLColorनहीं है। > _>

— पूरी तरह

क्या इसका कोई अनऑर्गनाइज्ड वर्जन है?

— user76284

Answer 3

पायथन 2 , 32 बाइट्स

from colorsys import*;hls_to_rgb

इसे ऑनलाइन आज़माएं!

यह कार्यक्षमता वास्तव में लाइब्रेरी के hls_to_rgbअंदर के माध्यम से पायथन में बनाई गई है colorsys। प्रारूप मेरा इनपुट HLS की एक 0-1 श्रेणी है (HSL के बजाय, दोनों एक ही चीज़ के लिए सामान्य समरूप हैं [यद्यपि, HSL अधिक सामान्य है])। और खदान 0 से 1 की सीमा के साथ टुपल में आरजीबी मान को आउटपुट करती है।

क्रेडिट

जोनाथन एलन को यह इंगित करने के लिए धन्यवाद कि मुझे बस इसे आयात करने की आवश्यकता है (और फिर आगे बाइट काउंट को कम करने में मेरी मदद करें)।

Comments

मुझे लगता है कि यह सिर्फ 31 बाइट्स हो सकता है from colorsys import hls_to_rgbक्योंकि हमें एक फ़ंक्शन देता है जिसका पुन: उपयोग किया जा सकता है। संपादित करें - कि 21 के रूप में बनाते हैं from colorsys import*।

— जोनाथन एलन

@JonathanAllan धन्यवाद, अपडेट किया गया।

— नील

वास्तव में शायद सिर्फ import colorsys15 के लिए!

— जोनाथन एलन

@JonathanAllan नीस, फिर से अपडेट किया गया।

— नील

हालांकि यह सच हो सकता है, मुझे लगता है कि यह कोडगुल्फ़िंग की भावना को बहुत अधिक प्रभावित करता है: /

— १०'१

Answer 4

सी ++, 228 221 बाइट्स

-7 बाइट्स Zacharý को धन्यवाद

#define S(o,n)r[t[int(h[0])/60*3+o]+o-2]=(n+h[2]-c/2)*255;
void C(float*h,int*r){float g=2*h[2]-1,c=(g<0?1+g:1-g)*h[1],a=int(h[0])%120/60.f-1;int t[]={2,2,2,3,1,2,3,3,0,4,2,0,4,1,1,2,3,1};S(0,c)S(1,c*(a<0?1+a:1-a))S(2,0)}

तर्क दोनों सरणियाँ हैं जिनका न्यूनतम आकार 3 तत्वों (यानी float hsl[3]और) हैint rgb[3]

ठीक है। अब, वह कैसे काम करता है? वह लंबी सरणी क्या है?

खैर, यह एक लंबी सरणी नहीं है, यह एक intसरणी है। एक तरफ मजाक करें, सरणी इंगित करती है कि हम सीएक्स और 0 को कितनी स्थिति में स्थानांतरित करते हैं जब हम सही क्रमचय का चयन करना चाहते हैं, + 2. याद रखें कि आर ', जी' और बी 'कैसे चुने जाते हैं?

मान लें कि हमारे पास "सामान्य" क्रम है, जो {C, X, 0} है

अब, जब पहले क्रमपरिवर्तन (अर्थात {C, X, 0}) का चयन किया जाता है, तो आपको शिफ्ट नहीं होने की आवश्यकता है, जो ठीक वैसी ही है जैसा कि सही शिफ्टिंग 0. द्वारा। तो सरणी के पहले 3 तत्व 0,0 और हैं 0

दूसरे क्रमपरिवर्तन ({X, C, 0}) के लिए, हमें C को 1 से दाईं ओर और 1 की बाईं पारी X से दाईं ओर स्थानांतरित करने की आवश्यकता है, इसलिए सरणी का चौथा, पांचवा और छठा तत्व 1, -1 और 0 हैं।

और इसी तरह...

3 जी और 4 वें क्रमपरिवर्तन के मामले में, मुझे 0 को 2 से स्थानांतरित करने की आवश्यकता है, इसलिए दाईं ओर -2 को स्थानांतरित करना होगा। चूँकि अधिक संख्याएँ हैं जो 2 संख्याएँ ऋणात्मक हैं, मैं सरणी में प्रत्येक तत्वों में 2 जोड़ता हूँ और रनटाइम पर 2 घटाता हूँ (गोल्फ कारणों के लिए, सरणी में केवल संपूर्ण संख्याएँ रखने के लिए)।

Comments

221 बाइट्स: pastebin.com/C8WaSSpb

— Zacharý

Answer 5

पायथन 2 , 119 112 बाइट्स

def f(h,s,l):c=(1-abs(2*l-1))*s;m=l-c/2;x=c*(1-abs(h%2-1))+m;c+=m;return[c,m,x,c,m,x,m,c,x,m][7-int(h)*5%9:][:3]

इसे ऑनलाइन आज़माएं!

के रूप में इनपुट लेता है H=[0,6[, S=[0,1], L=[0,1]

Answer 6

HTML + जावास्क्रिप्ट (ES6), 8 + 88 = 96 बाइट्स

f=
(h,s,l)=>(p.style.color=`hsl(${h},${s}%,${l}%)`,getComputedStyle(p).color.match(/\d+/g))

<div oninput=o.textContent=f(h.value,s.value,l.value)>H: <input type=number min=0 max=360 value=0 id=h>°<br>S: <input type=number min=0 max=100 value=0 id=s>%<br>L: <input type=number min=0 max=100 value=0 id=l>%<pre id=o>0,0,0</pre>
<p id=p>

एक कोण और दो प्रतिशत के रूप में इनपुट लेता है। मैं HTML स्निपेट <p id=p>और जावास्क्रिप्ट तीर फ़ंक्शन स्कोर कर रहा हूं । मुझे नहीं पता कि ब्राउज़र किस राउंडिंग का उपयोग करते हैं, इसलिए मेरे उत्तर आपसे थोड़े अलग हो सकते हैं।

Answer 7

स्विफ्ट 4, 218 बाइट्स

एचएसएल मानों को तर्क के रूप में सीमा [0,1] में स्वीकार करता है, और आरजीबी मानों को उसी श्रेणी में रखता है:

import Cocoa;typealias F=CGFloat;func f(h:F,s:F,l:F)->[F]{var r=F(),g=F(),b=F(),x=s*min(1-l,l),n=2*x/max(l+x,1e-9);NSColor(hue:h,saturation:n,brightness:l+x,alpha:1).getRed(&r,green:&g,blue:&b,alpha:nil);return[r,g,b]}

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

UIKit संस्करण ठीक उसी लंबाई का है, जैसा कि केवल प्रतिस्थापन हैं:

• Cocoa → UIKit
• NSColor → UIColor

Ungolfed:

#if os(iOS)
    import UIKit
    typealias Color = UIColor
#elseif os(OSX)
    import Cocoa
    typealias Color = NSColor
#endif

typealias F = CGFloat

func f(h: F,s: F,l: F) -> [F] {
    var r = F(), g = F(), b = F()

    let x = s * min(1 - l, l)
    let n = 2 * x / max(l + x, 1e-9)

    let color = Color(hue: h, saturation: n, brightness: l + x, alpha: 1)
    color.getRed(&r, green: &g,blue: &b, alpha: nil)

    return [r, g, b]
}

निम्नलिखित स्निपेट का उपयोग परीक्षण के लिए किया जा सकता है, बस , और h, के मूल्यों को प्रतिस्थापित करके :sl

let h: CGFloat = 0
let s: CGFloat = 0
let l: CGFloat = 0

let result = f(h: h/360, s: s/100, l: l/100).map { Int(round($0*255)) }
print(result)

---

^{दुर्भाग्य से, मैं एक ऑनलाइन सैंडबॉक्स को लिंक प्रदान नहीं कर सकता, क्योंकि वे सभी लिनक्स पर चलते हैं, जिसमें कोको शामिल नहीं है।}

Answer 8

GLSL (GL_ES) 160 144 134 131 बाइट्स

ह्यू 0-6 की रेंज में है (3 बाइट्स बचाता है)
सत, लाइट और आरजीबी 0-1 हैं

vec3 f(vec3 c){return mix(c.bbb,mix(clamp(vec3(-1,2,2)-abs(c.r-vec3(3,2,4))*vec3(-1,1,1),0.,1.),vec3(c.b>.5),abs(.5-c.b)*2.),c.g);}

इसे shaders की पुस्तक पर आज़माएँ

202 19 39 → 81 104 118 पर एक छोटी सी त्रुटि को छोड़कर , जो सही था, आउटपुट का परीक्षण करने के लिए एक प्रिंटस्क्रीन पर colorpicker टूल का उपयोग किया गया

Answer 9

आर , 88 बाइट्स

function(h,s,l){v=(2*l+s*(1-abs(2*l-1)))/2;col2rgb(hsv(h,ifelse(v==0,v,(2*(v-l))/v),v))}

इसे ऑनलाइन आज़माएं!

यह फ़ंक्शन इनपुट के रूप में एच, एस, और एल मानों को 0-1 राउंडेड मानों के रूप में लेता है और आरजीबी मानों को 0-255 राउंड मानों के रूप में आउटपुट करता है। यह एचएसएल प्रतिनिधित्व को एचएसवी प्रतिनिधित्व में hsv()परिवर्तित करता है, फिर एचएसवी प्रतिनिधित्व को आर रंग में बदलने के लिए उपयोग करता है (यानी हेक्स प्रतिनिधित्व - # आरजीबीबी), फिर col2rgb()आर रंग को आरजीबी मूल्यों में परिवर्तित करने के लिए उपयोग करता है।

Answer 10

जेली ,  ३ ९  ३२ बाइट्स

-1 caird coinheringaahing के लिए धन्यवाद ( %2सिर्फ है Ḃ)
-1 और / या caird coinheringaahing के लिए -4 धन्यवाद के लिए प्रेरणा !

Ḥ;Ḃ’ACש"⁵×\;0+³_®H¤⁴Ḟị336Œ?¤¤œ?

एक पूरा कार्यक्रम तीन कमांड लाइन तर्क ले रहा है:

• L, H, Sश्रेणियों में [0,1), [0,6), और [0,1)क्रमशः

जो आरजीबी प्रारूप के रूप में एक सूची प्रिंट करता है

• [R, G, B] रेंज में तीन मूल्यों में से प्रत्येक के साथ [0,1]

_{नोट: Hजैसे चाहें लपेट सकते हैं [0,360)।}

इसे ऑनलाइन आज़माएं!

कैसे?

Ḥ;Ḃ’ACש"⁵×\;0+³_®H¤⁴Ḟị336Œ?¤¤œ? - Main link: number, L (in [0,1]); number, H (in [0,6))
Ḥ                                - double                 =     2L
  Ḃ                              - modulo by 2            =              H%2
 ;                               - concatenate            = [   2L   ,   H%2]

   ’                             - decrement              = [   2L-1 ,   H%2-1]
    A                            - absolute               = [  |2L-1|,  |H%2-1|]
     C                           - complement             = [1-|2L-1|,1-|H%2-1|]
                                 -                        = [C/S     ,C/X]
         ⁵                       - 3rd program argument   = S  (in [0,1])
        "                        - zip with:
      ×                          -   multiplication       = [C,C/X]
       ©                         -   (copy the result, C, to the register)
           \                     - cumulative reduce with:
          ×                      -   multiplication       = [C, C/X*C] = [C,X]
            ;0                   - concatenate zero       = [C,X,0]
               ³                 - 1st program argument   = L
              +                  - add (vectorises)       = [C+L,X+L,L]
                   ¤             - nilad followed by link(s) as a nilad:
                 ®               -   recall from register = C
                  H              -   halve                = C/2
                _                - subtract               = [C+L-C/2,X+L-C/2,L-C/2]
                             ¤   - nilad followed by link(s) as a nilad:
                    ⁴            -   2nd program argument = H
                     Ḟ           -   floor                = floor(H)
                            ¤    -   nilad followed by link(s) as a nilad:
                       336       -     literal 336
                          Œ?     -     Shortest permutation of natural numbers with a
                                 -     lexicographical index of 336 in all permutations
                                 -     thereof            = [3,5,6,4,2,1]
                      ị          -   index into (1-indexed & modular)
                              œ? - get that permutation of [C+L-C/2,X+L-C/2,L-C/2]
                                 - implicit print

Comments

उफ़, बिल्कुल। धन्यवाद!

— जोनाथन एलन