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";
 }
 
+bool SkDifferentPixelsMetric::enablePOIAlphaMask() {
+    fPOIAlphaMask = true;
+    return true;
+}
+
 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) {
+        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;
+}