Port Android palette API for deriving a prominent color from an image.

ui/gfx/color_analysis.h

 // 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.
 
 #ifndef UI_GFX_COLOR_ANALYSIS_H_
 #define UI_GFX_COLOR_ANALYSIS_H_
 
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
@@ skipping 90 matching lines @@
 // Returns an SkColor that represents the calculated dominant color in the
 // image. See CalculateKMeanColorOfPNG() for details.
 GFX_EXPORT SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap,
                                                const HSL& lower_bound,
                                                const HSL& upper_bound,
                                                KMeanImageSampler* sampler);
 // Computes a dominant color using the above algorithm and reasonable defaults
 // for |lower_bound|, |upper_bound| and |sampler|.
 GFX_EXPORT SkColor CalculateKMeanColorOfBitmap(const SkBitmap& bitmap);
 
+// Color flags.
+enum ColorFlags {
+  // Luminosity.
+  LIGHT = 1,
+  NORMAL = 1 << 1,
+  DARK = 1 << 2,
+  // Saturation.
+  VIBRANT = 1 << 3,
+  MUTED = 1 << 4,
+};
+
+// Returns a single RGB color that represents the bitmap. |color_profile| is a
+// bitwise combination of ColorFlags values (precisely one from each category
+// should be used). If a value is succesfully calculated, the return value is

[sadrul, 2017/02/10 19:36:44]

I think it'd be better to use two different enums, instead of having separate
categories within the same enum.

[Evan Stade, 2017/02/13 19:01:13]

Done.

+// fully opaque. For failure, the return value is transparent. This currently
+// calculates one color at a time. We could save computation by calculating
+// multiple colors at once, but there's currently no need to calculate multiple
+// colors.
+GFX_EXPORT SkColor CalculateProminentColorOfBitmap(const SkBitmap& bitmap,
+                                                   int color_profile);
+
 // Compute color covariance matrix for the input bitmap.
 GFX_EXPORT gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap);
 
 // Apply a color reduction transform defined by |color_transform| vector to
 // |source_bitmap|. The result is put into |target_bitmap|, which is expected
 // to be initialized to the required size and type (SkBitmap::kA8_Config).
 // If |fit_to_range|, result is transfored linearly to fit 0-0xFF range.
 // Otherwise, data is clipped.
 // Returns true if the target has been computed.
 GFX_EXPORT bool ApplyColorReduction(const SkBitmap& source_bitmap,
                                    const gfx::Vector3dF& color_transform,
                                    bool fit_to_range,
                                    SkBitmap* target_bitmap);
 
 // Compute a monochrome image representing the principal color component of
 // the |source_bitmap|. The result is stored in |target_bitmap|, which must be
 // initialized to the required size and type (SkBitmap::kA8_Config).
 // Returns true if the conversion succeeded. Note that there might be legitimate
 // reasons for the process to fail even if all input was correct. This is a
 // condition the caller must be able to handle.
 GFX_EXPORT bool ComputePrincipalComponentImage(const SkBitmap& source_bitmap,
                                               SkBitmap* target_bitmap);
 
 }  // namespace color_utils
 
 #endif  // UI_GFX_COLOR_ANALYSIS_H_