1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "ui/gfx/color_utils.h" 6 7 #include <math.h> 8 #if defined(OS_WIN) 9 #include <windows.h> 10 #endif 11 12 #include <algorithm> 13 14 #include "base/basictypes.h" 15 #include "base/logging.h" 16 #include "build/build_config.h" 17 #if defined(OS_WIN) 18 #include "skia/ext/skia_utils_win.h" 19 #endif 20 #include "third_party/skia/include/core/SkBitmap.h" 21 22 namespace color_utils { 23 24 25 // Helper functions ----------------------------------------------------------- 26 27 namespace { 28 29 int calcHue(double temp1, double temp2, double hue) { 30 if (hue < 0.0) 31 ++hue; 32 else if (hue > 1.0) 33 --hue; 34 35 double result = temp1; 36 if (hue * 6.0 < 1.0) 37 result = temp1 + (temp2 - temp1) * hue * 6.0; 38 else if (hue * 2.0 < 1.0) 39 result = temp2; 40 else if (hue * 3.0 < 2.0) 41 result = temp1 + (temp2 - temp1) * (2.0 / 3.0 - hue) * 6.0; 42 43 // Scale the result from 0 - 255 and round off the value. 44 return static_cast<int>(result * 255 + .5); 45 } 46 47 // Next two functions' formulas from: 48 // http://www.w3.org/TR/WCAG20/#relativeluminancedef 49 // http://www.w3.org/TR/WCAG20/#contrast-ratiodef 50 51 double ConvertSRGB(double eight_bit_component) { 52 const double component = eight_bit_component / 255.0; 53 return (component <= 0.03928) ? 54 (component / 12.92) : pow((component + 0.055) / 1.055, 2.4); 55 } 56 57 SkColor LumaInvertColor(SkColor color) { 58 HSL hsl; 59 SkColorToHSL(color, &hsl); 60 hsl.l = 1.0 - hsl.l; 61 return HSLToSkColor(hsl, 255); 62 } 63 64 double ContrastRatio(double foreground_luminance, double background_luminance) { 65 DCHECK_GE(foreground_luminance, 0.0); 66 DCHECK_GE(background_luminance, 0.0); 67 foreground_luminance += 0.05; 68 background_luminance += 0.05; 69 return (foreground_luminance > background_luminance) ? 70 (foreground_luminance / background_luminance) : 71 (background_luminance / foreground_luminance); 72 } 73 74 } // namespace 75 76 77 // ---------------------------------------------------------------------------- 78 79 unsigned char GetLuminanceForColor(SkColor color) { 80 int luma = static_cast<int>((0.3 * SkColorGetR(color)) + 81 (0.59 * SkColorGetG(color)) + 82 (0.11 * SkColorGetB(color))); 83 return std::max(std::min(luma, 255), 0); 84 } 85 86 double RelativeLuminance(SkColor color) { 87 return (0.2126 * ConvertSRGB(SkColorGetR(color))) + 88 (0.7152 * ConvertSRGB(SkColorGetG(color))) + 89 (0.0722 * ConvertSRGB(SkColorGetB(color))); 90 } 91 92 void SkColorToHSL(SkColor c, HSL* hsl) { 93 double r = static_cast<double>(SkColorGetR(c)) / 255.0; 94 double g = static_cast<double>(SkColorGetG(c)) / 255.0; 95 double b = static_cast<double>(SkColorGetB(c)) / 255.0; 96 double vmax = std::max(std::max(r, g), b); 97 double vmin = std::min(std::min(r, g), b); 98 double delta = vmax - vmin; 99 hsl->l = (vmax + vmin) / 2; 100 if (SkColorGetR(c) == SkColorGetG(c) && SkColorGetR(c) == SkColorGetB(c)) { 101 hsl->h = hsl->s = 0; 102 } else { 103 double dr = (((vmax - r) / 6.0) + (delta / 2.0)) / delta; 104 double dg = (((vmax - g) / 6.0) + (delta / 2.0)) / delta; 105 double db = (((vmax - b) / 6.0) + (delta / 2.0)) / delta; 106 // We need to compare for the max value because comparing vmax to r, g, or b 107 // can sometimes result in values overflowing registers. 108 if (r >= g && r >= b) 109 hsl->h = db - dg; 110 else if (g >= r && g >= b) 111 hsl->h = (1.0 / 3.0) + dr - db; 112 else // (b >= r && b >= g) 113 hsl->h = (2.0 / 3.0) + dg - dr; 114 115 if (hsl->h < 0.0) 116 ++hsl->h; 117 else if (hsl->h > 1.0) 118 --hsl->h; 119 120 hsl->s = delta / ((hsl->l < 0.5) ? (vmax + vmin) : (2 - vmax - vmin)); 121 } 122 } 123 124 SkColor HSLToSkColor(const HSL& hsl, SkAlpha alpha) { 125 double hue = hsl.h; 126 double saturation = hsl.s; 127 double lightness = hsl.l; 128 129 // If there's no color, we don't care about hue and can do everything based on 130 // brightness. 131 if (!saturation) { 132 uint8 light; 133 134 if (lightness < 0) 135 light = 0; 136 else if (lightness >= 1.0) 137 light = 255; 138 else 139 light = SkDoubleToFixed(lightness) >> 8; 140 141 return SkColorSetARGB(alpha, light, light, light); 142 } 143 144 double temp2 = (lightness < 0.5) ? 145 (lightness * (1.0 + saturation)) : 146 (lightness + saturation - (lightness * saturation)); 147 double temp1 = 2.0 * lightness - temp2; 148 return SkColorSetARGB(alpha, 149 calcHue(temp1, temp2, hue + 1.0 / 3.0), 150 calcHue(temp1, temp2, hue), 151 calcHue(temp1, temp2, hue - 1.0 / 3.0)); 152 } 153 154 bool IsWithinHSLRange(const HSL& hsl, 155 const HSL& lower_bound, 156 const HSL& upper_bound) { 157 DCHECK(hsl.h >= 0 && hsl.h <= 1) << hsl.h; 158 DCHECK(hsl.s >= 0 && hsl.s <= 1) << hsl.s; 159 DCHECK(hsl.l >= 0 && hsl.l <= 1) << hsl.l; 160 DCHECK(lower_bound.h < 0 || upper_bound.h < 0 || 161 (lower_bound.h <= 1 && upper_bound.h <= lower_bound.h + 1)) 162 << "lower_bound.h: " << lower_bound.h 163 << ", upper_bound.h: " << upper_bound.h; 164 DCHECK(lower_bound.s < 0 || upper_bound.s < 0 || 165 (lower_bound.s <= upper_bound.s && upper_bound.s <= 1)) 166 << "lower_bound.s: " << lower_bound.s 167 << ", upper_bound.s: " << upper_bound.s; 168 DCHECK(lower_bound.l < 0 || upper_bound.l < 0 || 169 (lower_bound.l <= upper_bound.l && upper_bound.l <= 1)) 170 << "lower_bound.l: " << lower_bound.l 171 << ", upper_bound.l: " << upper_bound.l; 172 173 // If the upper hue is >1, the given hue bounds wrap around at 1. 174 bool matches_hue = upper_bound.h > 1 175 ? hsl.h >= lower_bound.h || hsl.h <= upper_bound.h - 1 176 : hsl.h >= lower_bound.h && hsl.h <= upper_bound.h; 177 return (upper_bound.h < 0 || lower_bound.h < 0 || matches_hue) && 178 (upper_bound.s < 0 || lower_bound.s < 0 || 179 (hsl.s >= lower_bound.s && hsl.s <= upper_bound.s)) && 180 (upper_bound.l < 0 || lower_bound.l < 0 || 181 (hsl.l >= lower_bound.l && hsl.l <= upper_bound.l)); 182 } 183 184 SkColor HSLShift(SkColor color, const HSL& shift) { 185 HSL hsl; 186 int alpha = SkColorGetA(color); 187 SkColorToHSL(color, &hsl); 188 189 // Replace the hue with the tint's hue. 190 if (shift.h >= 0) 191 hsl.h = shift.h; 192 193 // Change the saturation. 194 if (shift.s >= 0) { 195 if (shift.s <= 0.5) 196 hsl.s *= shift.s * 2.0; 197 else 198 hsl.s += (1.0 - hsl.s) * ((shift.s - 0.5) * 2.0); 199 } 200 201 SkColor result = HSLToSkColor(hsl, alpha); 202 203 if (shift.l < 0) 204 return result; 205 206 // Lightness shifts in the style of popular image editors aren't actually 207 // represented in HSL - the L value does have some effect on saturation. 208 double r = static_cast<double>(SkColorGetR(result)); 209 double g = static_cast<double>(SkColorGetG(result)); 210 double b = static_cast<double>(SkColorGetB(result)); 211 if (shift.l <= 0.5) { 212 r *= (shift.l * 2.0); 213 g *= (shift.l * 2.0); 214 b *= (shift.l * 2.0); 215 } else { 216 r += (255.0 - r) * ((shift.l - 0.5) * 2.0); 217 g += (255.0 - g) * ((shift.l - 0.5) * 2.0); 218 b += (255.0 - b) * ((shift.l - 0.5) * 2.0); 219 } 220 return SkColorSetARGB(alpha, 221 static_cast<int>(r), 222 static_cast<int>(g), 223 static_cast<int>(b)); 224 } 225 226 void BuildLumaHistogram(const SkBitmap& bitmap, int histogram[256]) { 227 DCHECK_EQ(kN32_SkColorType, bitmap.colorType()); 228 229 SkAutoLockPixels bitmap_lock(bitmap); 230 231 int pixel_width = bitmap.width(); 232 int pixel_height = bitmap.height(); 233 for (int y = 0; y < pixel_height; ++y) { 234 for (int x = 0; x < pixel_width; ++x) 235 ++histogram[GetLuminanceForColor(bitmap.getColor(x, y))]; 236 } 237 } 238 239 SkColor AlphaBlend(SkColor foreground, SkColor background, SkAlpha alpha) { 240 if (alpha == 0) 241 return background; 242 if (alpha == 255) 243 return foreground; 244 245 int f_alpha = SkColorGetA(foreground); 246 int b_alpha = SkColorGetA(background); 247 248 double normalizer = (f_alpha * alpha + b_alpha * (255 - alpha)) / 255.0; 249 if (normalizer == 0.0) 250 return SK_ColorTRANSPARENT; 251 252 double f_weight = f_alpha * alpha / normalizer; 253 double b_weight = b_alpha * (255 - alpha) / normalizer; 254 255 double r = (SkColorGetR(foreground) * f_weight + 256 SkColorGetR(background) * b_weight) / 255.0; 257 double g = (SkColorGetG(foreground) * f_weight + 258 SkColorGetG(background) * b_weight) / 255.0; 259 double b = (SkColorGetB(foreground) * f_weight + 260 SkColorGetB(background) * b_weight) / 255.0; 261 262 return SkColorSetARGB(static_cast<int>(normalizer), 263 static_cast<int>(r), 264 static_cast<int>(g), 265 static_cast<int>(b)); 266 } 267 268 SkColor BlendTowardOppositeLuminance(SkColor color, SkAlpha alpha) { 269 unsigned char background_luminance = 270 color_utils::GetLuminanceForColor(color); 271 const SkColor blend_color = 272 (background_luminance < 128) ? SK_ColorWHITE : SK_ColorBLACK; 273 return color_utils::AlphaBlend(blend_color, color, alpha); 274 } 275 276 SkColor GetReadableColor(SkColor foreground, SkColor background) { 277 const SkColor foreground2 = LumaInvertColor(foreground); 278 const double background_luminance = RelativeLuminance(background); 279 return (ContrastRatio(RelativeLuminance(foreground), background_luminance) >= 280 ContrastRatio(RelativeLuminance(foreground2), background_luminance)) ? 281 foreground : foreground2; 282 } 283 284 SkColor InvertColor(SkColor color) { 285 return SkColorSetARGB( 286 SkColorGetA(color), 287 255 - SkColorGetR(color), 288 255 - SkColorGetG(color), 289 255 - SkColorGetB(color)); 290 } 291 292 SkColor GetSysSkColor(int which) { 293 #if defined(OS_WIN) 294 return skia::COLORREFToSkColor(GetSysColor(which)); 295 #else 296 NOTIMPLEMENTED(); 297 return SK_ColorLTGRAY; 298 #endif 299 } 300 301 } // namespace color_utils 302
