update skpdiff visualization (image magnification with alpha mask)

tools/skpdiff/SkDifferentPixelsMetric_cpu.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <cstring>
 
 #include "SkBitmap.h"
 
 #include "SkDifferentPixelsMetric.h"
 #include "skpdiff_util.h"
 
 struct SkDifferentPixelsMetric::QueuedDiff {
     bool finished;
     double result;
     SkTDArray<SkIPoint>* poi;
+    SkBitmap poiAlphaMask;
 };
 
 const char* SkDifferentPixelsMetric::getName() {
     return "different_pixels";
 }
 
 int SkDifferentPixelsMetric::queueDiff(SkBitmap* baseline, SkBitmap* test) {
     double startTime = get_seconds();
     int diffID = fQueuedDiffs.count();
     QueuedDiff* diff = fQueuedDiffs.push();
     SkTDArray<SkIPoint>* poi = diff->poi = new SkTDArray<SkIPoint>();
 
     // If we never end up running the kernel, include some safe defaults in the result.
     diff->finished = false;
     diff->result = -1;
 
     // Ensure the images are comparable
     if (baseline->width() != test->width() || baseline->height() != test->height() ||
         baseline->width() <= 0 || baseline->height() <= 0 ||
         baseline->config() != test->config()) {
         diff->finished = true;
         return diffID;
     }
 
     int width = baseline->width();
     int height = baseline->height();
     int differentPixelsCount = 0;
 
+    // Prepare the POI alpha mask if needed
+    if (fPOIAlphaMask) {

[epoger, 2013/10/21 15:02:53]

Where is fPOIAlphaMask declared?  I don't see it in SkDiffContext.h

Oh, I see, it's in the SkImageDiffer class declaration, not the
SkDifferentPixelsMetric class declaration (and SkDifferentPixelsMetric extends
SkImageDiffer).  Since it's only used in SkDifferentPixelsMetric, wouldn't it be
better to declare it as part of that class?

+        diff->poiAlphaMask.setConfig(SkBitmap::kA8_Config, width, height);
+        diff->poiAlphaMask.allocPixels();
+        diff->poiAlphaMask.lockPixels();
+        diff->poiAlphaMask.eraseARGB(SK_AlphaOPAQUE, 0, 0, 0);
+    }
+
     // Prepare the pixels for comparison
     baseline->lockPixels();
     test->lockPixels();
     for (int y = 0; y < height; y++) {
         // Grab a row from each image for easy comparison
         unsigned char* baselineRow = (unsigned char*)baseline->getAddr(0, y);
         unsigned char* testRow = (unsigned char*)test->getAddr(0, y);
         for (int x = 0; x < width; x++) {
             // Compare one pixel at a time so each differing pixel can be noted
             if (std::memcmp(&baselineRow[x * 4], &testRow[x * 4], 4) != 0) {
                 poi->push()->set(x, y);
                 differentPixelsCount++;
+                if (fPOIAlphaMask) {
+                    *diff->poiAlphaMask.getAddr8(x,y) = SK_AlphaTRANSPARENT;
+                }
             }
         }
     }
     test->unlockPixels();
     baseline->unlockPixels();
 
     // Calculates the percentage of identical pixels
     diff->result = 1.0 - ((double)differentPixelsCount / (width * height));
 
     SkDebugf("Time: %f\n", (get_seconds() - startTime));
@@ skipping 17 matching lines @@
     return fQueuedDiffs[id].result;
 }
 
 int SkDifferentPixelsMetric::getPointsOfInterestCount(int id) {
     return fQueuedDiffs[id].poi->count();
 }
 
 SkIPoint* SkDifferentPixelsMetric::getPointsOfInterest(int id) {
     return fQueuedDiffs[id].poi->begin();
 }
+
+SkBitmap* SkDifferentPixelsMetric::getPointsOfInterestAlphaMask(int id) {
+    if (fQueuedDiffs[id].poiAlphaMask.empty()) {
+        return NULL;
+    }
+    return &fQueuedDiffs[id].poiAlphaMask;
+}