source: trunk/src/lol/image/color.h @ 2218

Last change on this file since 2218 was 2218, checked in by sam, 7 years ago

color: write the RGB to HSL routine and its associated unit tests.

File size: 6.6 KB
Line 
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
5//   This program is free software; you can redistribute it and/or
6//   modify it under the terms of the Do What The Fuck You Want To
7//   Public License, Version 2, as published by Sam Hocevar. See
8//   http://www.wtfpl.net/ for more details.
9//
10
11//
12// The Color class
13// ---------------
14// Provides various color conversion routines.
15//
16
17#if !defined __LOL_IMAGE_COLOR_H__
18#define __LOL_IMAGE_COLOR_H__
19
20#include <lol/math/vector.h>
21
22namespace lol
23{
24
25class Color
26{
27public:
28    /*
29     * Convert linear RGB to sRGB
30     */
31    static vec3 LinearRGBTosRGB(vec3 src)
32    {
33        vec3 ret = 12.92f * src;
34        if (src.r > 0.0031308f)
35            ret.r = 1.055f * pow(src.r, 1.0f / 2.4f) - 0.055f;
36        if (src.g > 0.0031308f)
37            ret.g = 1.055f * pow(src.g, 1.0f / 2.4f) - 0.055f;
38        if (src.b > 0.0031308f)
39            ret.b = 1.055f * pow(src.b, 1.0f / 2.4f) - 0.055f;
40        return ret;
41    }
42
43    static vec4 LinearRGBTosRGB(vec4 src)
44    {
45        return vec4(LinearRGBTosRGB(src.rgb), src.a);
46    }
47
48    /*
49     * Convert sRGB to linear RGB
50     */
51    static vec3 sRGBToLinearRGB(vec3 src)
52    {
53        vec3 ret = 1.0f / 12.92f * src;
54        if (src.r > 0.04045f)
55            ret.r = pow(src.r + 0.055f, 2.4f) / pow(1.055f, 2.4f);
56        if (src.g > 0.04045f)
57            ret.g = pow(src.g + 0.055f, 2.4f) / pow(1.055f, 2.4f);
58        if (src.b > 0.04045f)
59            ret.b = pow(src.b + 0.055f, 2.4f) / pow(1.055f, 2.4f);
60        return ret;
61    }
62
63    static vec4 sRGBToLinearRGB(vec4 src)
64    {
65        return vec4(sRGBToLinearRGB(src.rgb), src.a);
66    }
67
68    /*
69     * Convert linear HSV to linear RGB
70     */
71    static vec3 HSVToRGB(vec3 src)
72    {
73        vec3 tmp = abs(fract(vec3(src.x) + vec3(3.f, 2.f, 1.f) / 3.f) * 6.f - vec3(3.f));
74        return mix(vec3(1.f), clamp(tmp - vec3(1.f), 0.f, 1.f), src.y) * src.z;
75    }
76
77    static vec4 HSVToRGB(vec4 src)
78    {
79        return vec4(HSVToRGB(src.rgb), src.a);
80    }
81
82    /*
83     * Convert RGB to HSV
84     */
85    static vec3 RGBToHSV(vec3 src)
86    {
87        float K = 0.f;
88
89        if (src.g < src.b)
90            src = src.rbg, K = -1.f;
91
92        if (src.r < src.g)
93            src = src.grb, K = -2.f / 6.f - K;
94
95        float chroma = src.r - min(src.g, src.b);
96        return vec3(abs(K + (src.g - src.b) / (6.f * chroma + 1e-20f)),
97                    chroma / (src.r + 1e-20f),
98                    src.r);
99    }
100
101    static vec4 RGBToHSV(vec4 src)
102    {
103        return vec4(RGBToHSV(src.rgb), src.a);
104    }
105
106    /*
107     * Convert RGB to HSL
108     */
109    static vec3 RGBToHSL(vec3 src)
110    {
111        float K = 0.f;
112
113        if (src.g < src.b)
114            src = src.rbg, K = -1.f;
115
116        if (src.r < src.g)
117            src = src.grb, K = -2.f / 6.f - K;
118
119        float chroma = src.r - min(src.g, src.b);
120        float luma = src.r + min(src.g, src.b);
121        return vec3(abs(K + (src.g - src.b) / (6.f * chroma + 1e-20f)),
122                    chroma / (min(luma, 2.f - luma) + 1e-20f),
123                    0.5f * luma);
124    }
125
126    static vec4 RGBToHSL(vec4 src)
127    {
128        return vec4(RGBToHSL(src.rgb), src.a);
129    }
130
131    /*
132     * Convert linear HSV to linear HSL
133     */
134    static vec3 HSVToHSL(vec3 src)
135    {
136        float tmp = (2 - src.y) * src.z;
137        return vec3(src.x, src.y * src.z / (1.f - abs(1.f - tmp)), 0.5f * tmp);
138    }
139
140    static vec4 HSVToHSL(vec4 src)
141    {
142        return vec4(HSVToHSL(src.rgb), src.a);
143    }
144
145    /*
146     * Convert linear HSL to linear HSV
147     */
148    static vec3 HSLToHSV(vec3 src)
149    {
150        float tmp = src.y * (0.5f - abs(0.5f - src.z));
151        return vec3(src.x, 2.f * tmp / (src.z + tmp), src.z + tmp);
152    }
153
154    static vec4 HSLToHSV(vec4 src)
155    {
156        return vec4(HSLToHSV(src.rgb), src.a);
157    }
158
159    /*
160     * Convert linear RGB [0 1] to CIE XYZ [0 100]
161     */
162    static vec3 LinearRGBToCIEXYZ(vec3 src)
163    {
164        mat3 m(vec3(41.24f, 21.26f,  1.93f),
165               vec3(35.76f, 71.52f, 11.92f),
166               vec3(18.05f,  7.22f, 95.05f));
167        return m * src;
168    }
169
170    static vec4 LinearRGBToCIEXYZ(vec4 src)
171    {
172        return vec4(LinearRGBToCIEXYZ(src.rgb), src.a);
173    }
174
175    /*
176     * Convert CIE XYZ [0 100] to linear RGB [0 1]
177     */
178    static vec3 CIEXYZToLinearRGB(vec3 src)
179    {
180        mat3 m(vec3( 0.032406f, -0.009689f,  0.000557f),
181               vec3(-0.015372f,  0.018758f, -0.002040f),
182               vec3(-0.004986f,  0.000415f,  0.010570f));
183        return m * src;
184    }
185
186    static vec4 CIEXYZToLinearRGB(vec4 src)
187    {
188        return vec4(CIEXYZToLinearRGB(src.rgb), src.a);
189    }
190
191    /*
192     * Convert CIE XYZ to CIE xyY
193     */
194    static vec3 CIEXYZToCIExyY(vec3 src)
195    {
196        float tmp = 1.0f / (src.x + src.y + src.z);
197        return vec3(src.x * tmp, src.y * tmp, src.y);
198    }
199
200    static vec4 CIEXYZToCIExyY(vec4 src)
201    {
202        return vec4(CIEXYZToCIExyY(src.rgb), src.a);
203    }
204
205    /*
206     * Convert CIE xyY to CIE XYZ
207     */
208    static vec3 CIExyYToCIEXYZ(vec3 src)
209    {
210        return src.z * vec3(src.x / src.y,
211                            1.0f,
212                            (1.0f - src.x - src.y) / src.y);
213    }
214
215    static vec4 CIExyYToCIEXYZ(vec4 src)
216    {
217        return vec4(CIEXYZToCIExyY(src.rgb), src.a);
218    }
219
220    /*
221     * Convert CIE XYZ to CIE L*a*b*
222     * Note: XYZ values are normalised using a D65 illuminant if
223     * no white value is provided.
224     */
225    static vec3 CIEXYZToCIELab(vec3 src, vec3 white)
226    {
227        float const a = (6.0 * 6.0 * 6.0) / (29 * 29 * 29);
228        float const b = (29.0 * 29.0) / (3 * 6 * 6);
229        float const c = 4.0 / 29;
230        float const d = 1.0 / 3;
231
232        src /= white;
233
234        vec3 f = b * src + vec3(c);
235        if (src.x > a)
236            f.x = pow(src.x, d);
237        if (src.y > a)
238            f.y = pow(src.y, d);
239        if (src.z > a)
240            f.z = pow(src.z, d);
241
242        return vec3(116.f * f.y - 16.f,
243                    500.f * (f.x - f.y),
244                    200.f * (f.y - f.z));
245    }
246
247    static vec3 CIEXYZToCIELab(vec3 src)
248    {
249        return CIEXYZToCIELab(src, vec3(95.047f, 100.f, 108.883f));
250    }
251
252    static vec4 CIEXYZToCIELab(vec4 src, vec4 white)
253    {
254        return vec4(CIEXYZToCIELab(src.rgb, white.rgb), src.a);
255    }
256
257    static vec4 CIEXYZToCIELab(vec4 src)
258    {
259        return vec4(CIEXYZToCIELab(src.rgb), src.a);
260    }
261
262    /*
263     * Return distance using the CIEDE2000 metric,
264     * input should be in CIE L*a*b*.
265     */
266    static float DistanceCIEDE2000(vec3 lab1, vec3 lab2);
267
268    /*
269     * Convert a wavelength into an xyY fully saturated colour.
270     */
271    static vec3 WavelengthToCIExyY(float nm);
272};
273
274} /* namespace lol */
275
276#endif // __LOL_IMAGE_COLOR_H__
277
Note: See TracBrowser for help on using the repository browser.