Adds a function computing image color covariance.

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 <algorithm>
 #include <vector>
 
+#include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace {
 
 // RGBA KMean Constants
 const uint32_t kNumberOfClusters = 4;
 const int kNumberOfIterations = 50;
@@ skipping 372 matching lines @@
   SkColor color = CalculateKMeanColorOfBuffer(
       reinterpret_cast<uint8_t*>(image.get()),
       bitmap.width(),
       bitmap.height(),
       kMinDarkness,
       kMaxBrightness,
       &sampler);
   return color;
 }
 
+gfx::Matrix3F ComputeColorCovariance(const SkBitmap& bitmap) {
+  // First need basic stats to normalize each channel separately.
+  SkAutoLockPixels bitmap_lock(bitmap);
+  gfx::Matrix3F covariance = gfx::Matrix3F::Zeros();
+  if (!bitmap.getPixels())
+    return covariance;
+
+  // Assume ARGB_8888 format.
+  DCHECK(bitmap.config() == SkBitmap::kARGB_8888_Config);
+
+  double r_sum = 0;
+  double g_sum = 0;
+  double b_sum = 0;
+  double rr_sum = 0;
+  double gg_sum = 0;
+  double bb_sum = 0;
+  double rg_sum = 0;
+  double rb_sum = 0;
+  double gb_sum = 0;
+
+  for (int y = 0; y < bitmap.height(); ++y) {

[reed1, 2013/02/12 19:34:51]

SkBitmap stores its pixels in SkPMColor format, not SkColor. You need to use
SkPMColor type in this code, and use the macros in SkColorPriv.h to extract
r,g,b bytes.

SkColor is always in a,r,g,b order as an int (e.g. a << 24, r << 16, g << 8) and
is unpremultiplied.

SkPMColor's byte order is variable, defined in SkColorPriv.h, and can change on
different platforms. Use SkGetPackedR32() etc. to extract r,g,b. Also, note that
these values will already be "pre" multiplied by that pixel's alpha
(SkGetPackedA32).

I don't know (1) if this function is ever called w/ bitmaps that have per-pixel
alpha, and (2) if that has any bearing on its covariance...

[motek., 2013/02/12 19:58:13]

Ah, I see. It seems I should un-pre-multiply and use color as-is. Fixed
accordingly.

+    SkColor* current_color = static_cast<uint32_t*>(bitmap.getAddr32(0, y));
+    for (int x = 0; x < bitmap.width(); ++x, ++current_color) {
+      SkColor r = SkColorGetR(*current_color);
+      SkColor g = SkColorGetG(*current_color);
+      SkColor b = SkColorGetB(*current_color);
+
+      r_sum += r;
+      g_sum += g;
+      b_sum += b;
+      rr_sum += r * r;
+      gg_sum += g * g;
+      bb_sum += b * b;
+      rg_sum += r * g;
+      rb_sum += r * b;
+      gb_sum += g * b;
+    }
+  }
+
+  int pixel_n = bitmap.width() * bitmap.height();
+  r_sum /= pixel_n;
+  g_sum /= pixel_n;
+  b_sum /= pixel_n;
+  rr_sum /= pixel_n;
+  gg_sum /= pixel_n;
+  bb_sum /= pixel_n;
+  rg_sum /= pixel_n;
+  rb_sum /= pixel_n;
+  gb_sum /= pixel_n;
+
+  // Covariance (not normalized) is E(X*X.t) - m * m.t and this is how it
+  // is calculated below.
+  // Each row below represents a row of the matrix describing (co)variances
+  // of R, G and B channels with (R, G, B)
+  covariance.set(
+      rr_sum - r_sum * r_sum, rg_sum - r_sum * g_sum, rb_sum - r_sum * b_sum,
+      rg_sum - r_sum * g_sum, gg_sum - g_sum * g_sum, gb_sum - g_sum * b_sum,
+      rb_sum - r_sum * b_sum, gb_sum - g_sum * b_sum, bb_sum - b_sum * b_sum);
+  return covariance;
+}
+
 }  // color_utils