Extracting more than one wallpaper prominent color

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 <limits.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 338 matching lines @@
   return !(hsl.h >= 0.028f && hsl.h <= 0.10f && hsl.s <= 0.82f);
 }
 
 // This algorithm is a port of Android's Palette API. Compare to package
 // android.support.v7.graphics and see that code for additional high-level
 // explanation of this algorithm. There are some minor differences:
 //   * This code doesn't exclude the same color from being used for
 //   different color profiles.
 //   * This code doesn't try to heuristically derive missing colors from
 //   existing colors.
-SkColor CalculateProminentColor(const SkBitmap& bitmap,
-                                const HSL& lower_bound,
-                                const HSL& upper_bound,
-                                const HSL& goal) {
+std::vector<SkColor> CalculateProminentColors(
+    const SkBitmap& bitmap,
+    const std::vector<HSL>& lower_bounds,
+    const std::vector<HSL>& upper_bounds,
+    const std::vector<HSL>& goals) {
   DCHECK(!bitmap.empty());
   DCHECK(!bitmap.isNull());
 
   const uint32_t* pixels = static_cast<uint32_t*>(bitmap.getPixels());
   const int pixel_count = bitmap.width() * bitmap.height();
 
   // For better performance, only consider at most 10k pixels (evenly
   // distributed throughout the image). This has a very minor impact on the
   // outcome but improves runtime substantially for large images. 10,007 is a
   // prime number to reduce the chance of picking an unrepresentative sample.
@@ skipping 15 matching lines @@
   // Now throw out some uninteresting colors.
   std::vector<SkColor> interesting_colors;
   interesting_colors.reserve(color_counts.size());
   for (auto color_count : color_counts) {
     SkColor color = color_count.first;
     if (IsInterestingColor(color))
       interesting_colors.push_back(color);
   }
 
   if (interesting_colors.empty())
-    return SK_ColorTRANSPARENT;
+    return std::vector<SkColor>(goals.size(), SK_ColorTRANSPARENT);

[Evan Stade, 2017/06/20 23:07:53]

nit: maybe put the best_colors initialization above this line and return that
here (without having added any colors to it)

[Qiang(Joe) Xu, 2017/06/21 01:10:52]

Done.

 
   // Group the colors into "boxes" and repeatedly split the most voluminous box.
   // We stop the process when a box can no longer be split (there's only one
   // color in it) or when the number of color boxes reaches 12. As per the
   // Android docs,
   //
   //   For landscapes, good values are in the range 12-16. For images which
   //   are largely made up of people's faces then this value should be increased
   //   to 24-32.
   const int kMaxColors = 12;
@@ skipping 14 matching lines @@
   // Now extract a single color to represent each box. This is the average color
   // in the box, weighted by the frequency of that color in the source image.
   std::vector<WeightedColor> box_colors;
   uint64_t max_weight = 0;
   while (!boxes.empty()) {
     box_colors.push_back(boxes.top().GetWeightedAverageColor(color_counts));
     boxes.pop();
     max_weight = std::max(max_weight, box_colors.back().weight);
   }
 
-  // Given these box average colors, find the best one for the desired color
+  // Given these box average colors, find the best one for each desired color
   // profile. "Best" in this case means the color which fits in the provided
   // bounds and comes closest to |goal|. It's possible that no color will fit in
   // the provided bounds, in which case we'll return an empty color.
-  double best_suitability = 0;
-  SkColor best_color = SK_ColorTRANSPARENT;
-  for (const auto& box_color : box_colors) {
-    HSL hsl;
-    SkColorToHSL(box_color.color, &hsl);
-    if (!IsWithinHSLRange(hsl, lower_bound, upper_bound))
-      continue;
+  std::vector<SkColor> best_colors(goals.size(), SK_ColorTRANSPARENT);
+  for (size_t i = 0; i < goals.size(); ++i) {

[Evan Stade, 2017/06/20 23:07:53]

nit: I think this loop would be cleaner (and you'd head off the possibility of
weird states like the vectors being different sizes) if you passed in a vector
of structs instead of 3 vectors of HSLs.

[Qiang(Joe) Xu, 2017/06/21 01:10:52]

Done.

+    double best_suitability = 0;
+    for (const auto& box_color : box_colors) {
+      HSL hsl;
+      SkColorToHSL(box_color.color, &hsl);
+      if (!IsWithinHSLRange(hsl, lower_bounds[i], upper_bounds[i]))
+        continue;
 
-    double suitability =
-        (1 - std::abs(hsl.s - goal.s)) * 3 +
-        (1 - std::abs(hsl.l - goal.l)) * 6.5 +
-        (box_color.weight / static_cast<float>(max_weight)) * 0.5;
-    if (suitability > best_suitability) {
-      best_suitability = suitability;
-      best_color = box_color.color;
+      double suitability =
+          (1 - std::abs(hsl.s - goals[i].s)) * 3 +
+          (1 - std::abs(hsl.l - goals[i].l)) * 6.5 +
+          (box_color.weight / static_cast<float>(max_weight)) * 0.5;
+      if (suitability > best_suitability) {
+        best_suitability = suitability;
+        best_colors[i] = box_color.color;
+      }
     }
   }
 
-  return best_color;
+  return best_colors;
 }
 
 } // namespace
 
 KMeanImageSampler::KMeanImageSampler() {
 }
 
 KMeanImageSampler::~KMeanImageSampler() {
 }
 
@@ skipping 250 matching lines @@
                                      bitmap.width(), bitmap.height(),
                                      lower_bound, upper_bound, sampler);
 }
 
 SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap) {
   GridSampler sampler;
   return CalculateKMeanColorOfBitmap(
       bitmap, kDefaultLowerHSLBound, kDefaultUpperHSLBound, &sampler);
 }
 
-SkColor CalculateProminentColorOfBitmap(const SkBitmap& bitmap,
-                                        LumaRange luma,
-                                        SaturationRange saturation) {
+std::vector<SkColor> CalculateProminentColorsOfBitmap(
+    const SkBitmap& bitmap,
+    const ColorProfiles& color_profiles) {
+  size_t size = color_profiles.size();
   if (bitmap.empty() || bitmap.isNull())
-    return SK_ColorTRANSPARENT;
+    return std::vector<SkColor>(size, SK_ColorTRANSPARENT);
 
   // The hue is not relevant to our bounds or goal colors.
-  HSL lower_bound = {
-      -1,
-  };
-  HSL upper_bound = {
-      -1,
-  };
-  HSL goal = {
-      -1,
-  };
+  std::vector<HSL> lower_bounds(size, {-1});

[danakj, 2017/06/20 23:22:03]

3 mallocs per call to this function is not awesome. estade's suggestion of a
vector of structs would reduce this to 1 malloc.

[Qiang(Joe) Xu, 2017/06/21 01:10:52]

Done.

+  std::vector<HSL> upper_bounds(size, {-1});
+  std::vector<HSL> goals(size, {-1});
+  for (size_t i = 0; i < size; ++i) {
+    switch (color_profiles[i].luma) {
+      case LumaRange::LIGHT:
+        lower_bounds[i].l = 0.55f;
+        upper_bounds[i].l = 1;
+        goals[i].l = 0.74f;
+        break;
+      case LumaRange::NORMAL:
+        lower_bounds[i].l = 0.3f;
+        upper_bounds[i].l = 0.7f;
+        goals[i].l = 0.5f;
+        break;
+      case LumaRange::DARK:
+        lower_bounds[i].l = 0;
+        upper_bounds[i].l = 0.45f;
+        goals[i].l = 0.26f;
+        break;
+    }
 
-  switch (luma) {
-    case LumaRange::LIGHT:
-      lower_bound.l = 0.55f;
-      upper_bound.l = 1;
-      goal.l = 0.74f;
-      break;
-    case LumaRange::NORMAL:
-      lower_bound.l = 0.3f;
-      upper_bound.l = 0.7f;
-      goal.l = 0.5f;
-      break;
-    case LumaRange::DARK:
-      lower_bound.l = 0;
-      upper_bound.l = 0.45f;
-      goal.l = 0.26f;
-      break;
+    switch (color_profiles[i].saturation) {
+      case SaturationRange::VIBRANT:
+        lower_bounds[i].s = 0.35f;
+        upper_bounds[i].s = 1;
+        goals[i].s = 1;
+        break;
+      case SaturationRange::MUTED:
+        lower_bounds[i].s = 0;
+        upper_bounds[i].s = 0.4f;
+        goals[i].s = 0.3f;
+        break;
+    }
   }
 
-  switch (saturation) {
-    case SaturationRange::VIBRANT:
-      lower_bound.s = 0.35f;
-      upper_bound.s = 1;
-      goal.s = 1;
-      break;
-    case SaturationRange::MUTED:
-      lower_bound.s = 0;
-      upper_bound.s = 0.4f;
-      goal.s = 0.3f;
-      break;
-  }
-
-  return CalculateProminentColor(bitmap, lower_bound, upper_bound, goal);
+  return CalculateProminentColors(bitmap, lower_bounds, upper_bounds, goals);
 }
 
 gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap) {
   // First need basic stats to normalize each channel separately.
   gfx::Matrix3F covariance = gfx::Matrix3F::Zeros();
   if (!bitmap.getPixels())
     return covariance;
 
   // Assume ARGB_8888 format.
   DCHECK(bitmap.colorType() == kN32_SkColorType);
@@ skipping 147 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