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

ui/gfx/color_analysis_unittest.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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.h"
 
 using color_utils::FindClosestColor;
 
 namespace {
 
 const unsigned char k1x1White[] = {
   0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
   0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
@@ skipping 57 matching lines @@
   0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69,
   0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x57,
   0x81, 0x0e, 0x17, 0x00, 0x00, 0x00, 0x14, 0x49,
   0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0xcf,
   0xc0, 0xc0, 0xc4, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
   0xf0, 0x1f, 0x00, 0x0c, 0x10, 0x02, 0x01, 0x2c,
   0x8f, 0x8b, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x49,
   0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
 };
 
+const color_utils::HSL kDefaultLowerBound = {-1, -1, 0.15};
+const color_utils::HSL kDefaultUpperBound = {-1, -1, 0.85};
+
+// Creates a 1 dimensional png of the pixel colors found in |colors|.

[Matt Giuca, 2014/05/22 05:03:52]

Nit: 1-dimensional.

[calamity, 2014/05/22 07:36:36]

Done.

+scoped_refptr<base::RefCountedMemory> CreateTestPNG(
+    const std::vector<SkColor>& colors) {
+  SkBitmap bitmap;
+  bitmap.setConfig(SkBitmap::kARGB_8888_Config, colors.size(), 1);
+  bitmap.allocPixels();
+  SkAutoLockPixels lock(bitmap);
+  for (size_t i = 0; i < colors.size(); ++i) {
+    bitmap.eraseArea(SkIRect::MakeXYWH(i, 0, 1, 1), colors[i]);
+  }
+  return gfx::Image::CreateFrom1xBitmap(bitmap).As1xPNGBytes();
+}
+
 class MockKMeanImageSampler : public color_utils::KMeanImageSampler {
  public:
   MockKMeanImageSampler() : current_result_index_(0) {
   }
 
   explicit MockKMeanImageSampler(const std::vector<int>& samples)
       : prebaked_sample_results_(samples),
         current_result_index_(0) {
   }
 
@@ skipping 55 matching lines @@
 TEST_F(ColorAnalysisTest, CalculatePNGKMeanAllWhite) {
   MockKMeanImageSampler test_sampler;
   test_sampler.AddSample(0);
 
   scoped_refptr<base::RefCountedBytes> png(
       new base::RefCountedBytes(
           std::vector<unsigned char>(
               k1x1White,
               k1x1White + sizeof(k1x1White) / sizeof(unsigned char))));
 
-  SkColor color =
-      color_utils::CalculateKMeanColorOfPNG(png, 100, 600, &test_sampler);
+  SkColor color = color_utils::CalculateKMeanColorOfPNG(
+      png, kDefaultLowerBound, kDefaultUpperBound, &test_sampler);
 
   EXPECT_EQ(color, SK_ColorWHITE);
 }
 
-TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreWhite) {
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreWhiteLightness) {
   MockKMeanImageSampler test_sampler;
   test_sampler.AddSample(0);
   test_sampler.AddSample(1);
   test_sampler.AddSample(2);
 
   scoped_refptr<base::RefCountedBytes> png(
      new base::RefCountedBytes(
          std::vector<unsigned char>(
              k1x3BlueWhite,
              k1x3BlueWhite + sizeof(k1x3BlueWhite) / sizeof(unsigned char))));
 
-  SkColor color =
-      color_utils::CalculateKMeanColorOfPNG(png, 100, 600, &test_sampler);
+  SkColor color = color_utils::CalculateKMeanColorOfPNG(
+      png, kDefaultLowerBound, kDefaultUpperBound, &test_sampler);
 
-  EXPECT_EQ(color, SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF));
+  EXPECT_EQ(SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF), color);
 }
 
 TEST_F(ColorAnalysisTest, CalculatePNGKMeanPickMostCommon) {
   MockKMeanImageSampler test_sampler;
   test_sampler.AddSample(0);
   test_sampler.AddSample(1);
   test_sampler.AddSample(2);
 
   scoped_refptr<base::RefCountedBytes> png(
      new base::RefCountedBytes(
          std::vector<unsigned char>(
              k1x3BlueRed,
              k1x3BlueRed + sizeof(k1x3BlueRed) / sizeof(unsigned char))));
 
+  SkColor color = color_utils::CalculateKMeanColorOfPNG(
+      png, kDefaultLowerBound, kDefaultUpperBound, &test_sampler);
+
+  EXPECT_EQ(SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00), color);
+}
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreRedHue) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+  test_sampler.AddSample(1);
+  test_sampler.AddSample(2);
+
+  std::vector<SkColor> colors(4, SK_ColorRED);
+  colors[1] = SK_ColorBLUE;
+
+  scoped_refptr<base::RefCountedMemory> png = CreateTestPNG(colors);
+
   SkColor color =
-      color_utils::CalculateKMeanColorOfPNG(png, 100, 600, &test_sampler);
+      color_utils::CalculateKMeanColorOfPNG(png,
+                                            color_utils::HSL{0.2, -1, 0.15},
+                                            color_utils::HSL{0.8, -1, 0.85},
+                                            &test_sampler);
 
-  EXPECT_EQ(color, SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00));
+  EXPECT_EQ(SK_ColorBLUE, color);
+}
+
+TEST_F(ColorAnalysisTest, CalculatePNGKMeanIgnoreGreySaturation) {
+  MockKMeanImageSampler test_sampler;
+  test_sampler.AddSample(0);
+  test_sampler.AddSample(1);
+  test_sampler.AddSample(2);
+
+  std::vector<SkColor> colors(4, SK_ColorGRAY);
+  colors[1] = SK_ColorBLUE;
+
+  scoped_refptr<base::RefCountedMemory> png = CreateTestPNG(colors);
+  SkColor color =
+      color_utils::CalculateKMeanColorOfPNG(png,
+                                            color_utils::HSL{-1, 0.3, -1},
+                                            color_utils::HSL{-1, 1, -1},
+                                            &test_sampler);
+
+  EXPECT_EQ(SK_ColorBLUE, color);
 }
 
 TEST_F(ColorAnalysisTest, GridSampler) {
   color_utils::GridSampler sampler;
   const int kWidth = 16;
   const int kHeight = 16;
   // Sample starts at 1,1.
   EXPECT_EQ(1 + 1 * kWidth, sampler.GetSample(kWidth, kHeight));
   EXPECT_EQ(1 + 4 * kWidth, sampler.GetSample(kWidth, kHeight));
   EXPECT_EQ(1 + 7 * kWidth, sampler.GetSample(kWidth, kHeight));
@@ skipping 246 matching lines @@
   uint8_t min_gl = 0;
   uint8_t max_gl = 0;
   Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
 
   EXPECT_EQ(0, min_gl);
   EXPECT_EQ(255, max_gl);
   EXPECT_EQ(min_gl, SkColorGetA(result.getColor(0, 0)));
   EXPECT_EQ(max_gl, SkColorGetA(result.getColor(299, 199)));
   EXPECT_EQ(93U, SkColorGetA(result.getColor(150, 0)));
 }