RGB और HLS (HBS) के बीच रंग परिवर्तित करने के लिए कैसे

सारांश

नीचे दिए गए कोड अंश रंगों (लाल, हरा, नीला) RGB और HLS/HBS (छटा, Lightness, संतृप्ति/छटा, चमक, संतृप्ति) के बीच में कनवर्ट करता है।

अधिक जानकारी

RGBtoHLS() एक DWORD RGB मान लेता है, उसे HLS और संग्रह में वैश्विक vars H, L और s. HLStoRGB परिणाम H, L और S के वर्तमान मान लेता है और में एक RGB DWORD समकक्ष मान देता है करने के लिए का अनुवाद करता है। H, L और S vars केवल के द्वारा लिखे गए हैं:

  1. RGBtoHLS (प्रारंभ)
  2. स्क्रॉल पट्टी हैंडलर्स
एल्गोरिथ्म के लिए संदर्भ का एक बिंदु है, Foley और Van Dam, "मौलिक की सहभागी कंप्यूटर ग्राफ़िक्स," पृष्ठ 618-19। उनके एल्गोरिथ्म बिंदु फ़्लोटिंग में है। चार्ट को किसी कम सामान्य (हार्डवायर्ड श्रेणियाँ) अभिन्न एल्गोरिथ्म लागू करता है।


इस नमूने में संभावित राउंड-बंद त्रुटियाँ हैं। ((0.5 + x) /y) बिंदु फ़्लोटिंग phrased है बिना ((x + (y/2)) /y), yielding एक बहुत छोटा राउंड-बंद त्रुटि। यह कई निम्न विभागों के असामान्य दिखाई देता है।
   */    #define  HLSMAX   RANGE /* H,L, and S vary over 0-HLSMAX */ 
#define RGBMAX 255 /* R,G, and B vary over 0-RGBMAX */
/* HLSMAX BEST IF DIVISIBLE BY 6 */
/* RGBMAX, HLSMAX must each fit in a byte. */

/* Hue is undefined if Saturation is 0 (grey-scale) */
/* This value determines where the Hue scrollbar is */
/* initially set for achromatic colors */
#define UNDEFINED (HLSMAX*2/3)

void RGBtoHLS(lRGBColor)

DWORD lRGBColor;
{
WORD R,G,B; /* input RGB values */
BYTE cMax,cMin; /* max and min RGB values */
WORD Rdelta,Gdelta,Bdelta; /* intermediate value: % of spread from max

*/
/* get R, G, and B out of DWORD */
R = GetRValue(lRGBColor);
G = GetGValue(lRGBColor);
B = GetBValue(lRGBColor);

/* calculate lightness */
cMax = max( max(R,G), B);
cMin = min( min(R,G), B);
L = ( ((cMax+cMin)*HLSMAX) + RGBMAX )/(2*RGBMAX);

if (cMax == cMin) { /* r=g=b --> achromatic case */
S = 0; /* saturation */
H = UNDEFINED; /* hue */
}
else { /* chromatic case */
/* saturation */
if (L <= (HLSMAX/2))
S = ( ((cMax-cMin)*HLSMAX) + ((cMax+cMin)/2) ) / (cMax+cMin);
else
S = ( ((cMax-cMin)*HLSMAX) + ((2*RGBMAX-cMax-cMin)/2) )
/ (2*RGBMAX-cMax-cMin);

/* hue */
Rdelta = ( ((cMax-R)*(HLSMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin);
Gdelta = ( ((cMax-G)*(HLSMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin);
Bdelta = ( ((cMax-B)*(HLSMAX/6)) + ((cMax-cMin)/2) ) / (cMax-cMin);

if (R == cMax)
H = Bdelta - Gdelta;
else if (G == cMax)
H = (HLSMAX/3) + Rdelta - Bdelta;
else /* B == cMax */
H = ((2*HLSMAX)/3) + Gdelta - Rdelta;

if (H < 0)
H += HLSMAX;
if (H > HLSMAX)
H -= HLSMAX;
}
}
/* utility routine for HLStoRGB */
WORD HueToRGB(n1,n2,hue)
WORD n1;
WORD n2;
WORD hue;
{
/* range check: note values passed add/subtract thirds of range */
if (hue < 0)
hue += HLSMAX;

if (hue > HLSMAX)
hue -= HLSMAX;

/* return r,g, or b value from this tridrant */
if (hue < (HLSMAX/6))
return ( n1 + (((n2-n1)*hue+(HLSMAX/12))/(HLSMAX/6)) );
if (hue < (HLSMAX/2))
return ( n2 );
if (hue < ((HLSMAX*2)/3))
return ( n1 + (((n2-n1)*(((HLSMAX*2)/3)-hue)+(HLSMAX/12))/(HLSMAX/6))
);
else
return ( n1 );
}

DWORD HLStoRGB(hue,lum,sat)
WORD hue;
WORD lum;
WORD sat;
{
WORD R,G,B; /* RGB component values */
WORD Magic1,Magic2; /* calculated magic numbers (really!) */

if (sat == 0) { /* achromatic case */
R=G=B=(lum*RGBMAX)/HLSMAX;
if (hue != UNDEFINED) {
/* ERROR */
}
}
else { /* chromatic case */
/* set up magic numbers */
if (lum <= (HLSMAX/2))
Magic2 = (lum*(HLSMAX + sat) + (HLSMAX/2))/HLSMAX;
else
Magic2 = lum + sat - ((lum*sat) + (HLSMAX/2))/HLSMAX;
Magic1 = 2*lum-Magic2;

/* get RGB, change units from HLSMAX to RGBMAX */
R = (HueToRGB(Magic1,Magic2,hue+(HLSMAX/3))*RGBMAX +
(HLSMAX/2))/HLSMAX;
G = (HueToRGB(Magic1,Magic2,hue)*RGBMAX + (HLSMAX/2)) / HLSMAX;
B = (HueToRGB(Magic1,Magic2,hue-(HLSMAX/3))*RGBMAX +
(HLSMAX/2))/HLSMAX;
}
return(RGB(R,G,B));
}

गुण

आलेख ID: 29240 - पिछली समीक्षा: 27/01/2017 - संशोधन: 1

प्रतिक्रिया