Implementation of principal-component color reduction.

ui/gfx/color_utils.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_utils.h"
 
 #include <math.h>
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include <algorithm>
+#include <limits>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #if defined(OS_WIN)
 #include "skia/ext/skia_utils_win.h"
 #endif
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkUnPreMultiply.h"
+#include "ui/gfx/color_analysis.h"
+#include "ui/gfx/matrix3_f.h"
+#include "ui/gfx/vector3d_f.h"
 
 namespace color_utils {
 
 // Helper functions -----------------------------------------------------------
 
 namespace {
 
 int calcHue(double temp1, double temp2, double hue) {
   if (hue < 0.0)
     ++hue;
@@ skipping 223 matching lines @@
 
 SkColor GetSysSkColor(int which) {
 #if defined(OS_WIN)
   return skia::COLORREFToSkColor(GetSysColor(which));
 #else
   NOTIMPLEMENTED();
   return SK_ColorLTGRAY;
 #endif
 }
 
+gfx::Rect ApplyColorReduction(const SkBitmap& source_bitmap,
+                              const gfx::Vector3dF& color_transform,
+                              bool scale_result,
+                              SkBitmap* target_bitmap) {
+  gfx::Rect result_rect;
+  if (!target_bitmap) {
+    NOTREACHED();
+    return result_rect;
+  }
+
+  SkAutoLockPixels source_lock(source_bitmap);
+  SkAutoLockPixels target_lock(*target_bitmap);
+
+  if (!source_bitmap.getPixels())
+    return result_rect;
+
+  if (!target_bitmap->getPixels()) {
+    NOTREACHED();
+    return result_rect;
+  }
+
+  DCHECK(source_bitmap.config() == SkBitmap::kARGB_8888_Config);
+  DCHECK(target_bitmap->config() == SkBitmap::kA8_Config);
+  DCHECK_EQ(source_bitmap.height(), target_bitmap->height());
+  DCHECK_EQ(source_bitmap.width(), target_bitmap->width());
+
+  int height = std::min(source_bitmap.height(), target_bitmap->height());
+  int width = std::min(source_bitmap.width(), target_bitmap->width());

[Alexei Svitkine (slow), 2013/02/21 16:49:59]

Instead of doing this, why not create the target_bitmap with the right size
already?

[motek., 2013/02/21 18:38:43]

As explained in the header, I believe the convention allowing pre-allocated
images to be reused might be better in this case.

[Alexei Svitkine (slow), 2013/02/21 19:49:33]

Got it. Given that you already have DCHECKs() about height/width being equal, do
you need the std::min() calls here, or can you just use source_bitmaps.height()
directly?

+  DCHECK(height > 0 && width > 0);
+
+  result_rect.SetRect(0, 0, width, height);
+  float a0 = 0.0;
+  float scale = 1.0;
+  if (scale_result) {
+    // We will figure out min/max in a preprocessing step and adjust
+    // actual_transform as required.
+    float max_val = std::numeric_limits<float>::min();
+    float min_val = std::numeric_limits<float>::max();
+    for (int y = 0; y < height; ++y) {
+      SkPMColor* current_color = static_cast<uint32_t*>(
+          source_bitmap.getAddr32(0, y));
+      for (int x = 0; x < width; ++x, ++current_color) {
+        SkColor c = SkUnPreMultiply::PMColorToColor(*current_color);
+        float r = SkColorGetR(c);
+        float g = SkColorGetG(c);
+        float b = SkColorGetB(c);
+        float gray_level = gfx::DotProduct(color_transform, r, g, b);
+        max_val = std::max(max_val, gray_level);
+        min_val = std::min(min_val, gray_level);
+      }
+    }
+
+    // Adjust the transform so that the result is scalling.
+    a0 = -min_val;
+    if (max_val > min_val)
+      scale = 255.0 / (max_val - min_val);
+    else
+      scale = 0.0;  // If min==max, uniform 0-level image is expected.
+  }
+
+  for (int y = 0; y < height; ++y) {
+    SkPMColor* current_color = static_cast<uint32_t*>(
+        source_bitmap.getAddr32(0, y));
+    uint8_t* target_color = target_bitmap->getAddr8(0, y);
+    for (int x = 0; x < width; ++x, ++current_color) {
+      SkColor c = SkUnPreMultiply::PMColorToColor(*current_color);
+      float r = SkColorGetR(c);
+      float g = SkColorGetG(c);
+      float b = SkColorGetB(c);
+
+      float gl = (a0 + gfx::DotProduct(color_transform, r, g, b)) * scale;
+      if (gl < 0)
+        gl = 0;
+      if (gl > 0xFF)
+        gl = 0xFF;
+      target_color[x] = static_cast<uint8_t>(gl);
+    }
+  }
+
+  return result_rect;
+}
+
+bool ComputePrincipalComponentImage(const SkBitmap& source_bitmap,
+                                    SkBitmap* target_bitmap) {
+  if (!target_bitmap) {
+    NOTREACHED();
+    return false;
+  }
+
+  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.
+  gfx::Rect result_rect = ApplyColorReduction(
+      source_bitmap, principal, true, target_bitmap);
+  return !result_rect.IsEmpty();
+}
+
 }  // namespace color_utils