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;
+

[reed1, 2013/02/12 20:08:15]

Performance note: perhaps the inner loops will run faster if your _sum variables
are int64_t. That would avoid having to convert r,g,b (ints) to doubles for each
pixel just for the add. The int64_t -> double conversion could happen once
outside of the loops.

Haven't measured, so this is just speculation.

[motek., 2013/02/12 22:18:42]

Right. It probably doesn't really matter that much, but I don't see how that
could do any harm either. Fixed up, just in case.

+  for (int y = 0; y < bitmap.height(); ++y) {
+    SkPMColor* current_color = static_cast<uint32_t*>(bitmap.getAddr32(0, y));
+    for (int x = 0; x < bitmap.width(); ++x, ++current_color) {
+      SkColor c = SkUnPreMultiply::PMColorToColor(*current_color);
+      SkColor r = SkColorGetR(c);
+      SkColor g = SkColorGetG(c);
+      SkColor b = SkColorGetB(c);
+
+      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