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

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

color: add HSL/HSV conversions, fix XYZ/RGB conversions that I mixed up,
add XYZ to xyY conversion (which gives us a pretty accurate xy graph of
the sRGB gamut), and normalise XYZ using a D65 white point.

File size: 6.9 KB
Line 
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2012 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 HSVToLinearRGB(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 HSVToLinearRGB(vec4 src)
78    {
79        return vec4(HSVToLinearRGB(src.rgb), src.a);
80    }
81
82    /*
83     * Convert linear HSV to linear HSL
84     */
85    static vec3 HSVToHSL(vec3 src)
86    {
87        float tmp = (2 - src.y) * src.z;
88        return vec3(src.x, src.y * src.z / (1.f - abs(1.f - tmp)), 0.5f * tmp);
89    }
90
91    static vec4 HSVToHSL(vec4 src)
92    {
93        return vec4(HSVToHSL(src.rgb), src.a);
94    }
95
96    /*
97     * Convert linear HSL to linear HSV
98     */
99    static vec3 HSLToHSV(vec3 src)
100    {
101        float tmp = src.y * (0.5f - abs(0.5f - src.z));
102        return vec3(src.x, 2.f * tmp / (src.z + tmp), src.z + tmp);
103    }
104
105    static vec4 HSLToHSV(vec4 src)
106    {
107        return vec4(HSLToHSV(src.rgb), src.a);
108    }
109
110    /*
111     * Convert linear RGB to CIE XYZ
112     */
113    static vec3 LinearRGBToCIEXYZ(vec3 src)
114    {
115        mat3 m(vec3(0.4124f, 0.2126f, 0.0193f),
116               vec3(0.3576f, 0.7152f, 0.1192f),
117               vec3(0.1805f, 0.0722f, 0.9505f));
118        return m * src;
119    }
120
121    static vec4 LinearRGBToCIEXYZ(vec4 src)
122    {
123        return vec4(LinearRGBToCIEXYZ(src.rgb), src.a);
124    }
125
126    /*
127     * Convert CIE XYZ to linear RGB
128     */
129    static vec3 CIEXYZToLinearRGB(vec3 src)
130    {
131        mat3 m(vec3(3.2406f, -0.9689f, 0.0557f),
132               vec3(-1.5372f, 1.8758f, -0.2040f),
133               vec3(-0.4986f, 0.0415f, 1.0570f));
134        return m * src;
135    }
136
137    static vec4 CIEXYZToLinearRGB(vec4 src)
138    {
139        return vec4(CIEXYZToLinearRGB(src.rgb), src.a);
140    }
141
142    /*
143     * Convert CIE XYZ to CIE xyY
144     */
145    static vec3 CIEXYZToCIExyY(vec3 src)
146    {
147        float tmp = 1.0f / (src.x + src.y + src.z);
148        return vec3(src.x * tmp, src.y * tmp, src.y);
149    }
150
151    static vec4 CIEXYZToCIExyY(vec4 src)
152    {
153        return vec4(CIEXYZToCIExyY(src.rgb), src.a);
154    }
155
156    /*
157     * Convert CIE XYZ to CIE L*a*b*
158     * Note: XYZ values are normalised using a D65 illuminant.
159     */
160    static vec3 CIEXYZToCIELab(vec3 src)
161    {
162        float const a = (6.0 * 6.0 * 6.0) / (29 * 29 * 29);
163        float const b = (29.0 * 29.0) / (3 * 6 * 6);
164        float const c = 4.0 / 29;
165        float const d = 1.0 / 3;
166
167        /* Normalise XYZ using D65 illuminant */
168        src *= vec3(1.f / 95.047f, 1.f / 100.f, 1.f / 108.883f);
169
170        vec3 f = b * src + vec3(c);
171        if (src.x > a)
172            f.x = pow(src.x, d);
173        if (src.y > a)
174            f.y = pow(src.y, d);
175        if (src.z > a)
176            f.z = pow(src.z, d);
177
178        return vec3(116.f * f.y - 16.f,
179                    500.f * (f.x - f.y),
180                    200.f * (f.y - f.z));
181    }
182
183    static vec4 CIEXYZToCIELab(vec4 src)
184    {
185        return vec4(CIEXYZToLinearRGB(src.rgb), src.a);
186    }
187
188    /*
189     * Return distance using the CIEDE2000 metric,
190     * input should be in CIE L*a*b*.
191     */
192    static float DistanceCIEDE2000(vec3 lab1, vec3 lab2)
193    {
194        float const deg2rad = 6.28318530718f / 360.f;
195        float const rad2deg = 360.f / 6.28318530718f;
196
197        float C1 = length(lab1.yz);
198        float C2 = length(lab2.yz);
199        float C_ = 0.5f * (C1 + C2);
200
201        float L1 = lab1.x;
202        float L2 = lab2.x;
203        float dLp = L2 - L1;
204        float L_ = 0.5f * (L1 + L2);
205
206        float tmp1 = pow(C_, 7.f);
207        float tmp2 = 1.5f - 0.5f * sqrt(tmp1 / (tmp1 + pow(25.f, 7.f)));
208        float ap1 = lab1.y * tmp2;
209        float ap2 = lab2.y * tmp2;
210        float Cp1 = sqrt(ap1 * ap1 + lab1.z * lab1.z);
211        float Cp2 = sqrt(ap2 * ap2 + lab2.z * lab2.z);
212        float dCp = Cp2 - Cp1;
213        float Cp_ = 0.5f * (Cp1 + Cp2);
214
215        float hp1 = fmod(atan2(lab1.z, ap1) * rad2deg, 360.f);
216        if (hp1 < 0.f)
217            hp1 += 360.f;
218        float hp2 = fmod(atan2(lab2.z, ap2) * rad2deg, 360.f);
219        if (hp2 < 0.f)
220            hp2 += 360.f;
221        float dhp;
222        if (abs(hp1 - hp2) <= 180.f)
223            dhp = hp2 - hp1;
224        else if (hp2 <= hp1)
225            dhp = hp2 - hp1 + 360.f;
226        else
227            dhp = hp2 - hp1 - 360.f;
228        float dHp = 2.f * sqrt(Cp1 * Cp2) * sin(dhp / 2.f * deg2rad);
229        float Hp_;
230        if (abs(hp1 - hp2) > 180.f)
231            Hp_ = 0.5f * (hp1 + hp2 + 360.f);
232        else
233            Hp_ = 0.5f * (hp1 + hp2);
234
235        float T = 1.f - 0.17f * cos((Hp_ - 30.f) * deg2rad)
236                      + 0.24f * cos(2 * Hp_ * deg2rad)
237                      + 0.32f * cos((3.f * Hp_ + 6.f) * deg2rad)
238                      - 0.20f * cos((4.f * Hp_ - 63.f) * deg2rad);
239        float SL = 1.f + 0.015f * (L_ - 50) * (L_ - 50)
240                                / sqrt(20.f + (L_ - 50) * (L_ - 50));
241        float SC = 1.f + 0.045f * Cp_;
242        float SH = 1.f + 0.015f * Cp_ * T;
243        float RT = -2.f * sqrt(pow(Cp_, 7.f) / (pow(Cp_, 7.f) + pow(25.f, 7.f)))
244                        * sin(60.f * deg2rad * exp(-pow((Hp_ - 275.f) / 25.f, 2.f)));
245
246        dLp /= SL;
247        dCp /= SC;
248        dHp /= SH;
249
250        return sqrt(dLp * dLp + dCp * dCp + dHp * dHp + RT * dCp * dHp);
251    }
252};
253
254} /* namespace lol */
255
256#endif // __LOL_IMAGE_COLOR_H__
257
Note: See TracBrowser for help on using the repository browser.