| 1 | /// @ref gtx_color_space |
| 2 | |
| 3 | #include "../ext/scalar_relational.hpp" |
| 4 | #include "../ext/scalar_constants.hpp" |
| 5 | |
| 6 | namespace glm |
| 7 | { |
| 8 | template<typename T, qualifier Q> |
| 9 | GLM_FUNC_QUALIFIER vec<3, T, Q> rgbColor(const vec<3, T, Q>& hsvColor) |
| 10 | { |
| 11 | vec<3, T, Q> hsv = hsvColor; |
| 12 | vec<3, T, Q> rgbColor; |
| 13 | |
| 14 | if(equal(hsv.y, static_cast<T>(0), epsilon<T>())) |
| 15 | // achromatic (grey) |
| 16 | rgbColor = vec<3, T, Q>(hsv.z); |
| 17 | else |
| 18 | { |
| 19 | T sector = floor(hsv.x * (T(1) / T(60))); |
| 20 | T frac = (hsv.x * (T(1) / T(60))) - sector; |
| 21 | // factorial part of h |
| 22 | T o = hsv.z * (T(1) - hsv.y); |
| 23 | T p = hsv.z * (T(1) - hsv.y * frac); |
| 24 | T q = hsv.z * (T(1) - hsv.y * (T(1) - frac)); |
| 25 | |
| 26 | switch(int(sector)) |
| 27 | { |
| 28 | default: |
| 29 | case 0: |
| 30 | rgbColor.r = hsv.z; |
| 31 | rgbColor.g = q; |
| 32 | rgbColor.b = o; |
| 33 | break; |
| 34 | case 1: |
| 35 | rgbColor.r = p; |
| 36 | rgbColor.g = hsv.z; |
| 37 | rgbColor.b = o; |
| 38 | break; |
| 39 | case 2: |
| 40 | rgbColor.r = o; |
| 41 | rgbColor.g = hsv.z; |
| 42 | rgbColor.b = q; |
| 43 | break; |
| 44 | case 3: |
| 45 | rgbColor.r = o; |
| 46 | rgbColor.g = p; |
| 47 | rgbColor.b = hsv.z; |
| 48 | break; |
| 49 | case 4: |
| 50 | rgbColor.r = q; |
| 51 | rgbColor.g = o; |
| 52 | rgbColor.b = hsv.z; |
| 53 | break; |
| 54 | case 5: |
| 55 | rgbColor.r = hsv.z; |
| 56 | rgbColor.g = o; |
| 57 | rgbColor.b = p; |
| 58 | break; |
| 59 | } |
| 60 | } |
| 61 | |
| 62 | return rgbColor; |
| 63 | } |
| 64 | |
| 65 | template<typename T, qualifier Q> |
| 66 | GLM_FUNC_QUALIFIER vec<3, T, Q> hsvColor(const vec<3, T, Q>& rgbColor) |
| 67 | { |
| 68 | vec<3, T, Q> hsv = rgbColor; |
| 69 | T Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b); |
| 70 | T Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b); |
| 71 | T Delta = Max - Min; |
| 72 | |
| 73 | hsv.z = Max; |
| 74 | |
| 75 | if(!equal(Max, static_cast<T>(0), epsilon<T>())) |
| 76 | { |
| 77 | hsv.y = Delta / hsv.z; |
| 78 | T h = static_cast<T>(0); |
| 79 | |
| 80 | if(equal(rgbColor.r, Max, epsilon<T>())) |
| 81 | // between yellow & magenta |
| 82 | h = static_cast<T>(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta; |
| 83 | else if(equal(rgbColor.g, Max, epsilon<T>())) |
| 84 | // between cyan & yellow |
| 85 | h = static_cast<T>(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta; |
| 86 | else |
| 87 | // between magenta & cyan |
| 88 | h = static_cast<T>(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta; |
| 89 | |
| 90 | if(h < T(0)) |
| 91 | hsv.x = h + T(360); |
| 92 | else |
| 93 | hsv.x = h; |
| 94 | } |
| 95 | else |
| 96 | { |
| 97 | // If r = g = b = 0 then s = 0, h is undefined |
| 98 | hsv.y = static_cast<T>(0); |
| 99 | hsv.x = static_cast<T>(0); |
| 100 | } |
| 101 | |
| 102 | return hsv; |
| 103 | } |
| 104 | |
| 105 | template<typename T> |
| 106 | GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> saturation(T const s) |
| 107 | { |
| 108 | vec<3, T, defaultp> rgbw = vec<3, T, defaultp>(T(0.2126), T(0.7152), T(0.0722)); |
| 109 | |
| 110 | vec<3, T, defaultp> const col((T(1) - s) * rgbw); |
| 111 | |
| 112 | mat<4, 4, T, defaultp> result(T(1)); |
| 113 | result[0][0] = col.x + s; |
| 114 | result[0][1] = col.x; |
| 115 | result[0][2] = col.x; |
| 116 | result[1][0] = col.y; |
| 117 | result[1][1] = col.y + s; |
| 118 | result[1][2] = col.y; |
| 119 | result[2][0] = col.z; |
| 120 | result[2][1] = col.z; |
| 121 | result[2][2] = col.z + s; |
| 122 | |
| 123 | return result; |
| 124 | } |
| 125 | |
| 126 | template<typename T, qualifier Q> |
| 127 | GLM_FUNC_QUALIFIER vec<3, T, Q> saturation(const T s, const vec<3, T, Q>& color) |
| 128 | { |
| 129 | return vec<3, T, Q>(saturation(s) * vec<4, T, Q>(color, T(0))); |
| 130 | } |
| 131 | |
| 132 | template<typename T, qualifier Q> |
| 133 | GLM_FUNC_QUALIFIER vec<4, T, Q> saturation(const T s, const vec<4, T, Q>& color) |
| 134 | { |
| 135 | return saturation(s) * color; |
| 136 | } |
| 137 | |
| 138 | template<typename T, qualifier Q> |
| 139 | GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, Q>& color) |
| 140 | { |
| 141 | const vec<3, T, Q> tmp = vec<3, T, Q>(0.33, 0.59, 0.11); |
| 142 | return dot(color, tmp); |
| 143 | } |
| 144 | }//namespace glm |