update skpdiff visualization (image magnification with alpha mask)

tools/skpdiff/SkDiffContext.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 "SkBitmap.h"
 #include "SkImageDecoder.h"
 #include "SkOSFile.h"
@@ skipping 23 matching lines @@
         DiffRecord* nextRecord = currentRecord->fNext;
         SkDELETE(currentRecord);
         currentRecord = nextRecord;
     }
 
     if (NULL != fDiffers) {
         SkDELETE_ARRAY(fDiffers);
     }
 }
 
+void SkDiffContext::setDifferenceDir(const SkString& path) {
+    if (!path.isEmpty() && sk_mkdir(path.c_str())) {
+        fDifferenceDir = path;
+    }
+}
+
 void SkDiffContext::setDiffers(const SkTDArray<SkImageDiffer*>& differs) {
     // Delete whatever the last array of differs was
     if (NULL != fDiffers) {
         SkDELETE_ARRAY(fDiffers);
         fDiffers = NULL;
         fDifferCount = 0;
     }
 
     // Copy over the new differs
     fDifferCount = differs.count();
     fDiffers = SkNEW_ARRAY(SkImageDiffer*, fDifferCount);
     differs.copy(fDiffers);
 }
 
+static SkString get_common_prefix(const SkString& a, const SkString& b) {
+    const size_t maxPrefixLength = SkTMin(a.size(), b.size());
+    SkASSERT(maxPrefixLength > 0);
+    for (size_t x = 0; x < maxPrefixLength; ++x) {
+        if (a[x] != b[x]) {
+            SkString result;
+            result.set(a.c_str(), x);
+            return result;
+        }
+    }
+    if (a.size() > b.size()) {
+        return b;
+    } else {
+        return a;
+    }
+}
+
 void SkDiffContext::addDiff(const char* baselinePath, const char* testPath) {
     // Load the images at the paths
     SkBitmap baselineBitmap;
     SkBitmap testBitmap;
     if (!SkImageDecoder::DecodeFile(baselinePath, &baselineBitmap)) {
         SkDebugf("Failed to load bitmap \"%s\"\n", baselinePath);
         return;
     }
     if (!SkImageDecoder::DecodeFile(testPath, &testBitmap)) {
         SkDebugf("Failed to load bitmap \"%s\"\n", testPath);
         return;
     }
 
     // Setup a record for this diff
     DiffRecord* newRecord = SkNEW(DiffRecord);
     newRecord->fBaselinePath = baselinePath;
     newRecord->fTestPath = testPath;
     newRecord->fNext = fRecords;
     fRecords = newRecord;
 
+    // compute the common name
+    SkString baseName = SkOSPath::SkBasename(baselinePath);
+    SkString testName = SkOSPath::SkBasename(testPath);
+    newRecord->fCommonName = get_common_prefix(baseName, testName);
+
+    bool alphaMaskPending = false;
+    bool alphaMaskCreated = false;
+
     // Perform each diff
     for (int differIndex = 0; differIndex < fDifferCount; differIndex++) {
         SkImageDiffer* differ = fDiffers[differIndex];
+        // TODO only enable for one differ
+        if (!alphaMaskCreated && !fDifferenceDir.isEmpty()) {
+            alphaMaskPending = differ->enablePOIAlphaMask();
+        }
         int diffID = differ->queueDiff(&baselineBitmap, &testBitmap);
         if (diffID >= 0) {
 
             // Copy the results into data for this record
             DiffData& diffData = newRecord->fDiffs.push_back();
 
             diffData.fDiffName = differ->getName();
             diffData.fResult = differ->getResult(diffID);
 
             int poiCount = differ->getPointsOfInterestCount(diffID);
             SkIPoint* poi = differ->getPointsOfInterest(diffID);
             diffData.fPointsOfInterest.append(poiCount, poi);
 
+            if (alphaMaskPending
+                    && SkImageDiffer::RESULT_CORRECT != diffData.fResult
+                    && newRecord->fDifferencePath.isEmpty()) {
+                newRecord->fDifferencePath = SkOSPath::SkPathJoin(fDifferenceDir.c_str(),
+                                                                  newRecord->fCommonName.c_str());
+
+                // compute the image diff and output it
+                SkBitmap* alphaMask = differ->getPointsOfInterestAlphaMask(diffID);
+                SkBitmap copy;
+                alphaMask->copyTo(&copy, SkBitmap::kARGB_8888_Config);
+                SkImageEncoder::EncodeFile(newRecord->fDifferencePath.c_str(), copy,
+                                           SkImageEncoder::kPNG_Type, 100);
+            }
+
+            if (alphaMaskPending) {
+                alphaMaskPending = false;
+                alphaMaskCreated = true;
+            }
+
             // Because we are doing everything synchronously for now, we are done with the diff
             // after reading it.
             differ->deleteDiff(diffID);
         }
     }
 
     // if we get a difference and we want the alpha mask then compute it here.
 }
 
 class SkThreadedDiff : public SkRunnable {
@@ skipping 90 matching lines @@
         stream.writeText("{\n");
     }
     stream.writeText("    \"records\": [\n");
     while (NULL != currentRecord) {
         stream.writeText("        {\n");
 
             SkString differenceAbsPath = get_absolute_path(currentRecord->fDifferencePath);
             SkString baselineAbsPath = get_absolute_path(currentRecord->fBaselinePath);
             SkString testAbsPath = get_absolute_path(currentRecord->fTestPath);
 
-            // strip off directory structure and find the common part of the filename
-            SkString baseName = SkOSPath::SkBasename(baselineAbsPath.c_str());
-            SkString testName = SkOSPath::SkBasename(testAbsPath.c_str());
-            for (size_t x = 0; x < baseName.size(); ++x) {
-                if (baseName[x] != testName[x]) {
-                    baseName.insertUnichar(x, '\n');
-                    break;
-                }
-            }
-
             stream.writeText("            \"commonName\": \"");
-            stream.writeText(baseName.c_str());
+            stream.writeText(currentRecord->fCommonName.c_str());
             stream.writeText("\",\n");
 
             stream.writeText("            \"differencePath\": \"");
             stream.writeText(differenceAbsPath.c_str());
             stream.writeText("\",\n");
 
             stream.writeText("            \"baselinePath\": \"");
             stream.writeText(baselineAbsPath.c_str());
             stream.writeText("\",\n");
 
@@ skipping 110 matching lines @@
         for (int i = 0; i < cntColumns; i++) {
             SkString str;
             str.printf(", %f", values[i]);
             stream.writeText(str.c_str());
         }
         stream.writeText("\n");
 
         currentRecord = currentRecord->fNext;
     }
 }