Add ability to constrain dominant color selection to a HSL range.

ui/gfx/color_analysis.cc

 // Copyright (c) 2012 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 "ui/gfx/color_analysis.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/color_utils.h"
 
+namespace color_utils {
 namespace {
 
 // RGBA KMean Constants
 const uint32_t kNumberOfClusters = 4;
 const int kNumberOfIterations = 50;
-const uint32_t kMaxBrightness = 665;
-const uint32_t kMinDarkness = 100;
+
+const HSL kDefaultLowerHSLBound = {-1, -1, 0.15};
+const HSL kDefaultUpperHSLBound = {-1, -1, 0.85};
 
 // Background Color Modification Constants
 const SkColor kDefaultBgColor = SK_ColorWHITE;
 
 // Support class to hold information about each cluster of pixel data in
 // the KMean algorithm. While this class does not contain all of the points
 // that exist in the cluster, it keeps track of the aggregate sum so it can
 // compute the new center appropriately.
 class KMeanCluster {
  public:
@@ skipping 98 matching lines @@
   SkAutoLockPixels auto_lock(bitmap);
   uint32_t* in = static_cast<uint32_t*>(bitmap.getPixels());
   uint32_t* out = buffer;
   int pixel_count = std::min(bitmap.width() * bitmap.height(), buffer_size);
   for (int i = 0; i < pixel_count; ++i)
     *out++ = SkUnPreMultiply::PMColorToColor(*in++);
 }
 
 } // namespace
 
-namespace color_utils {
-
 KMeanImageSampler::KMeanImageSampler() {
 }
 
 KMeanImageSampler::~KMeanImageSampler() {
 }
 
 GridSampler::GridSampler() : calls_(0) {
 }
 
 GridSampler::~GridSampler() {
@@ skipping 53 matching lines @@
   }
   return best_color;
 }
 
 // For a 16x16 icon on an Intel Core i5 this function takes approximately
 // 0.5 ms to run.
 // TODO(port): This code assumes the CPU architecture is little-endian.
 SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_data,
                                     int img_width,
                                     int img_height,
-                                    uint32_t darkness_limit,
-                                    uint32_t brightness_limit,
+                                    const HSL& lower_bound,
+                                    const HSL& upper_bound,
                                     KMeanImageSampler* sampler) {
   SkColor color = kDefaultBgColor;
   if (img_width > 0 && img_height > 0) {
     std::vector<KMeanCluster> clusters;
     clusters.resize(kNumberOfClusters, KMeanCluster());
 
     // Pick a starting point for each cluster
     std::vector<KMeanCluster>::iterator cluster = clusters.begin();
     while (cluster != clusters.end()) {
       // Try up to 10 times to find a unique color. If no unique color can be
@@ skipping 95 matching lines @@
     // color is.
     std::sort(clusters.begin(), clusters.end(),
               KMeanCluster::SortKMeanClusterByWeight);
 
     // Loop through the clusters to figure out which cluster has an appropriate
     // color. Skip any that are too bright/dark and go in order of weight.
     for (std::vector<KMeanCluster>::iterator cluster = clusters.begin();
         cluster != clusters.end(); ++cluster) {
       uint8_t r, g, b;
       cluster->GetCentroid(&r, &g, &b);
-      // Sum the RGB components to determine if the color is too bright or too
-      // dark.
-      // TODO (dtrainor): Look into using HSV here instead. This approximation
-      // might be fine though.
-      uint32_t summed_color = r + g + b;
 
-      if (summed_color < brightness_limit && summed_color > darkness_limit) {
+      SkColor current_color = SkColorSetARGB(SK_AlphaOPAQUE, r, g, b);
+      HSL hsl;
+      SkColorToHSL(current_color, &hsl);
+      if (IsWithinHSLRange(hsl, lower_bound, upper_bound)) {
         // If we found a valid color just set it and break. We don't want to
         // check the other ones.
-        color = SkColorSetARGB(0xFF, r, g, b);
+        color = current_color;
         break;
       } else if (cluster == clusters.begin()) {
         // We haven't found a valid color, but we are at the first color so
         // set the color anyway to make sure we at least have a value here.
-        color = SkColorSetARGB(0xFF, r, g, b);
+        color = current_color;
       }
     }
   }
 
   // Find a color that actually appears in the image (the K-mean cluster center
   // will not usually be a color that appears in the image).
   return FindClosestColor(decoded_data, img_width, img_height, color);
 }
 
 SkColor CalculateKMeanColorOfPNG(scoped_refptr<base::RefCountedMemory> png,
-                                 uint32_t darkness_limit,
-                                 uint32_t brightness_limit,
+                                 const HSL& lower_bound,
+                                 const HSL& upper_bound,
                                  KMeanImageSampler* sampler) {
   int img_width = 0;
   int img_height = 0;
   std::vector<uint8_t> decoded_data;
   SkColor color = kDefaultBgColor;
 
-  if (png.get() &&
-      png->size() &&
+  if (png.get() && png->size() &&
       gfx::PNGCodec::Decode(png->front(),
                             png->size(),
                             gfx::PNGCodec::FORMAT_BGRA,
                             &decoded_data,
                             &img_width,
                             &img_height)) {
     return CalculateKMeanColorOfBuffer(&decoded_data[0],
                                        img_width,
                                        img_height,
-                                       darkness_limit,
-                                       brightness_limit,
+                                       lower_bound,
+                                       upper_bound,
                                        sampler);
   }
   return color;
 }
 
 SkColor CalculateKMeanColorOfPNG(scoped_refptr<base::RefCountedMemory> png) {
   GridSampler sampler;
-  return CalculateKMeanColorOfPNG(png, kMinDarkness, kMaxBrightness, &sampler);
+  return CalculateKMeanColorOfPNG(
+      png, kDefaultLowerHSLBound, kDefaultUpperHSLBound, &sampler);
 }
 
 SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap,
-                                    uint32_t darkness_limit,
-                                    uint32_t brightness_limit,
+                                    const HSL& lower_bound,
+                                    const HSL& upper_bound,
                                     KMeanImageSampler* sampler) {
   // SkBitmap uses pre-multiplied alpha but the KMean clustering function
   // above uses non-pre-multiplied alpha. Transform the bitmap before we
   // analyze it because the function reads each pixel multiple times.
   int pixel_count = bitmap.width() * bitmap.height();
   scoped_ptr<uint32_t[]> image(new uint32_t[pixel_count]);
   UnPreMultiply(bitmap, image.get(), pixel_count);
 
   return CalculateKMeanColorOfBuffer(reinterpret_cast<uint8_t*>(image.get()),
                                      bitmap.width(),
                                      bitmap.height(),
-                                     darkness_limit,
-                                     brightness_limit,
+                                     lower_bound,
+                                     upper_bound,
                                      sampler);
 }
 
 SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap) {
   GridSampler sampler;
   return CalculateKMeanColorOfBitmap(
-      bitmap, kMinDarkness, kMaxBrightness, &sampler);
+      bitmap, kDefaultLowerHSLBound, kDefaultUpperHSLBound, &sampler);
 }
 
 gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap) {
   // First need basic stats to normalize each channel separately.
   SkAutoLockPixels bitmap_lock(bitmap);
   gfx::Matrix3F covariance = gfx::Matrix3F::Zeros();
   if (!bitmap.getPixels())
     return covariance;
 
   // Assume ARGB_8888 format.
@@ skipping 142 matching lines @@
   gfx::Matrix3F covariance = ComputeColorCovariance(source_bitmap);
   gfx::Matrix3F eigenvectors = gfx::Matrix3F::Zeros();
   gfx::Vector3dF eigenvals = covariance.SolveEigenproblem(&eigenvectors);
   gfx::Vector3dF principal = eigenvectors.get_column(0);
   if (eigenvals == gfx::Vector3dF() || principal == gfx::Vector3dF())
     return false;  // This may happen for some edge cases.
   return ApplyColorReduction(source_bitmap, principal, true, target_bitmap);
 }
 
 }  // color_utils