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 437 matching lines @@
         (box_color.weight / static_cast<float>(max_weight)) * 0.5;
     if (suitability > best_suitability) {
       best_suitability = suitability;
       best_color = box_color.color;
     }
   }
 
   return best_color;
 }
 
+SkColor CalculateProminentColorOfBitmap(const SkBitmap& bitmap,
+                                        LumaRange luma,
+                                        SaturationRange saturation) {
+  if (bitmap.empty() || bitmap.isNull())
+    return SK_ColorTRANSPARENT;
+
+  // The hue is not relevant to our bounds or goal colors.
+  HSL lower_bound = {
+      -1,
+  };
+  HSL upper_bound = {
+      -1,
+  };
+  HSL goal = {
+      -1,
+  };
+
+  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 (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);

[bruthig, 2017/06/20 15:32:14]

estade@ will be able to better advise but IIUC CalculateProminentColor() is the
expensive part of the algorithm and it would be much much cheaper to only
process the image once and pull out the colors for the color profiles.  Where-as
this appears to be processing the image once per color profile which will be
unacceptably slow.

[Evan Stade, 2017/06/20 17:11:08]

yes, as explained in the email, we only want to repeat the last loop in
CalculateProminentColor (the one over box_colors). The rest of that function is
expensive and need not be repeated.

[Qiang(Joe) Xu, 2017/06/20 22:48:55]

done, thanks for explaining!

+}
+
 } // namespace
 
 KMeanImageSampler::KMeanImageSampler() {
 }
 
 KMeanImageSampler::~KMeanImageSampler() {
 }
 
 GridSampler::GridSampler() : calls_(0) {
 }
@@ skipping 248 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) {
-  if (bitmap.empty() || bitmap.isNull())
-    return SK_ColorTRANSPARENT;
-
-  // The hue is not relevant to our bounds or goal colors.
-  HSL lower_bound = {
-      -1,
-  };
-  HSL upper_bound = {
-      -1,
-  };
-  HSL goal = {
-      -1,
-  };
-
-  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;
+std::vector<SkColor> CalculateProminentColorsOfBitmap(
+    const SkBitmap& bitmap,
+    const ColorProfiles& color_profiles) {
+  std::vector<SkColor> colors;
+  for (auto profile : color_profiles) {
+    colors.push_back(CalculateProminentColorOfBitmap(bitmap, profile.luma,
+                                                     profile.saturation));
   }
-
-  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 colors;
 }
 
 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