Simplify life for people trying to pick a "readable" foreground color by not ...

app/gfx/color_utils.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "app/gfx/color_utils.h"
 
 #include <math.h>
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
@@ skipping 38 matching lines @@
 // Next three functions' formulas from:
 // http://www.w3.org/TR/WCAG20/#relativeluminancedef
 // http://www.w3.org/TR/WCAG20/#contrast-ratiodef
 
 double ConvertSRGB(double eight_bit_component) {
   const double component = eight_bit_component / 255.0;
   return (component <= 0.03928) ?
       (component / 12.92) : pow((component + 0.055) / 1.055, 2.4);
 }
 
+SkColor LumaInvertColor(const SkColor& color) {
+  HSL hsl;
+  SkColorToHSL(color, &hsl);
+  hsl.l = 1.0 - hsl.l;
+  return HSLToSkColor(hsl, 255);
+}
+
 double RelativeLuminance(SkColor color) {
   return (0.2126 * ConvertSRGB(SkColorGetR(color))) +
       (0.7152 * ConvertSRGB(SkColorGetG(color))) +
-      (0.0722 * ConvertSRGB(SkColorGetB(color)));
+      (0.0722 * ConvertSRGB(SkColorGetB(color))) + 0.05;
 }
 
-double ContrastRatio(SkColor color1, SkColor color2) {
-  const double l1 = RelativeLuminance(color1) + 0.05;
-  const double l2 = RelativeLuminance(color2) + 0.05;
-  return (l1 > l2) ? (l1 / l2) : (l2 / l1);
+double ContrastRatio(double foreground_luminance, double background_luminance) {
+  return (foreground_luminance > background_luminance) ?

[sky, 2009/09/24 21:46:32]

Do you need to deal with getting 0,0 passed in, which results in divide by 0? At
least a DCHECK.

[Peter Kasting, 2009/09/24 21:50:06]

In theory yes... in practice the results from RelativeLuminance() are guaranteed
to be > 0, so this can't happen.  If it ever does, a DCHECK is just going to
make us crash one line earlier.  I will add some comments though.

+      (foreground_luminance / background_luminance) :
+      (background_luminance / foreground_luminance);
 }
 
 }  // namespace
 
 // ----------------------------------------------------------------------------
 
 void SkColorToHSL(SkColor c, HSL* hsl) {
   double r = static_cast<double>(SkColorGetR(c)) / 255.0;
   double g = static_cast<double>(SkColorGetG(c)) / 255.0;
   double b = static_cast<double>(SkColorGetB(c)) / 255.0;
@@ skipping 166 matching lines @@
     return foreground;
   return SkColorSetRGB(
     ((SkColorGetR(foreground) * alpha) +
      (SkColorGetR(background) * (255 - alpha))) / 255,
     ((SkColorGetG(foreground) * alpha) +
      (SkColorGetG(background) * (255 - alpha))) / 255,
     ((SkColorGetB(foreground) * alpha) +
      (SkColorGetB(background) * (255 - alpha))) / 255);
 }
 
-SkColor PickMoreReadableColor(SkColor foreground1,
-                              SkColor foreground2,
-                              SkColor background) {
-  return (ContrastRatio(foreground1, background) >=
-      ContrastRatio(foreground2, background)) ? foreground1 : foreground2;
+SkColor GetReadableColor(SkColor foreground, SkColor background) {
+  const SkColor foreground2 = LumaInvertColor(foreground);
+  const double background_luminance = RelativeLuminance(background);
+  return (ContrastRatio(RelativeLuminance(foreground), background_luminance) >=
+          ContrastRatio(RelativeLuminance(foreground2), background_luminance)) ?
+      foreground : foreground2;
 }
 
 SkColor GetSysSkColor(int which) {
 #if defined(OS_WIN)
   return skia::COLORREFToSkColor(GetSysColor(which));
 #else
   NOTIMPLEMENTED();
   return SK_ColorLTGRAY;
 #endif
 }
 
 }  // namespace color_utils