tools/skpdiff/SkDiffContext.cpp

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkBitmap.h"
   9 #include "SkImageDecoder.h"
  10 #include "SkOSFile.h"
  11 #include "SkRunnable.h"
  12 #include "SkSize.h"
  13 #include "SkStream.h"
  14 #include "SkTDict.h"
  15 #include "SkTaskGroup.h"
  16
  17 // from the tools directory for replace_char(...)
  18 #include "picture_utils.h"
  19
  20 #include "SkDiffContext.h"
  21 #include "SkImageDiffer.h"
  22 #include "skpdiff_util.h"
  23
  24 SkDiffContext::SkDiffContext() {
  25     fDiffers = NULL;
  26     fDifferCount = 0;
  27 }
  28
  29 SkDiffContext::~SkDiffContext() {
  30     if (fDiffers) {
  31         SkDELETE_ARRAY(fDiffers);
  32     }
  33 }
  34
  35 void SkDiffContext::setAlphaMaskDir(const SkString& path) {
  36     if (!path.isEmpty() && sk_mkdir(path.c_str())) {
  37         fAlphaMaskDir = path;
  38     }
  39 }
  40
  41 void SkDiffContext::setRgbDiffDir(const SkString& path) {
  42     if (!path.isEmpty() && sk_mkdir(path.c_str())) {
  43         fRgbDiffDir = path;
  44     }
  45 }
  46
  47 void SkDiffContext::setWhiteDiffDir(const SkString& path) {
  48     if (!path.isEmpty() && sk_mkdir(path.c_str())) {
  49         fWhiteDiffDir = path;
  50     }
  51 }
  52
  53 void SkDiffContext::setLongNames(const bool useLongNames) {
  54     longNames = useLongNames;
  55 }
  56
  57 void SkDiffContext::setDiffers(const SkTDArray<SkImageDiffer*>& differs) {
  58     // Delete whatever the last array of differs was
  59     if (fDiffers) {
  60         SkDELETE_ARRAY(fDiffers);
  61         fDiffers = NULL;
  62         fDifferCount = 0;
  63     }
  64
  65     // Copy over the new differs
  66     fDifferCount = differs.count();
  67     fDiffers = SkNEW_ARRAY(SkImageDiffer*, fDifferCount);
  68     differs.copy(fDiffers);
  69 }
  70
  71 static SkString get_common_prefix(const SkString& a, const SkString& b) {
  72     const size_t maxPrefixLength = SkTMin(a.size(), b.size());
  73     SkASSERT(maxPrefixLength > 0);
  74     for (size_t x = 0; x < maxPrefixLength; ++x) {
  75         if (a[x] != b[x]) {
  76             SkString result;
  77             result.set(a.c_str(), x);
  78             return result;
  79         }
  80     }
  81     if (a.size() > b.size()) {
  82         return b;
  83     } else {
  84         return a;
  85     }
  86 }
  87
  88 static SkString get_combined_name(const SkString& a, const SkString& b) {
  89     // Note (stephana): We must keep this function in sync with
  90     // getImageDiffRelativeUrl() in static/loader.js (under rebaseline_server).
  91     SkString result = a;
  92     result.append("-vs-");
  93     result.append(b);
  94     sk_tools::replace_char(&result, '.', '_');
  95     return result;
  96 }
  97
  98 void SkDiffContext::addDiff(const char* baselinePath, const char* testPath) {
  99     // Load the images at the paths
 100     SkBitmap baselineBitmap;
 101     SkBitmap testBitmap;
 102     if (!SkImageDecoder::DecodeFile(baselinePath, &baselineBitmap)) {
 103         SkDebugf("Failed to load bitmap \"%s\"\n", baselinePath);
 104         return;
 105     }
 106     if (!SkImageDecoder::DecodeFile(testPath, &testBitmap)) {
 107         SkDebugf("Failed to load bitmap \"%s\"\n", testPath);
 108         return;
 109     }
 110
 111     // Setup a record for this diff
 112     fRecordMutex.acquire();
 113     DiffRecord* newRecord = fRecords.addToHead(DiffRecord());
 114     fRecordMutex.release();
 115
 116     // compute the common name
 117     SkString baseName = SkOSPath::Basename(baselinePath);
 118     SkString testName = SkOSPath::Basename(testPath);
 119
 120     if (longNames) {
 121         newRecord->fCommonName = get_combined_name(baseName, testName);
 122     } else {
 123         newRecord->fCommonName = get_common_prefix(baseName, testName);
 124     }
 125     newRecord->fCommonName.append(".png");
 126
 127     newRecord->fBaselinePath = baselinePath;
 128     newRecord->fTestPath = testPath;
 129     newRecord->fSize = SkISize::Make(baselineBitmap.width(), baselineBitmap.height());
 130
 131     // only generate diff images if we have a place to store them
 132     SkImageDiffer::BitmapsToCreate bitmapsToCreate;
 133     bitmapsToCreate.alphaMask = !fAlphaMaskDir.isEmpty();
 134     bitmapsToCreate.rgbDiff = !fRgbDiffDir.isEmpty();
 135     bitmapsToCreate.whiteDiff = !fWhiteDiffDir.isEmpty();
 136
 137     // Perform each diff
 138     for (int differIndex = 0; differIndex < fDifferCount; differIndex++) {
 139         SkImageDiffer* differ = fDiffers[differIndex];
 140
 141         // Copy the results into data for this record
 142         DiffData& diffData = newRecord->fDiffs.push_back();
 143         diffData.fDiffName = differ->getName();
 144
 145         if (!differ->diff(&baselineBitmap, &testBitmap, bitmapsToCreate, &diffData.fResult)) {
 146             // if the diff failed, record -1 as the result
 147             // TODO(djsollen): Record more detailed information about exactly what failed.
 148             // (Image dimension mismatch? etc.)  See http://skbug.com/2710 ('make skpdiff
 149             // report more detail when it fails to compare two images')
 150             diffData.fResult.result = -1;
 151             continue;
 152         }
 153
 154         if (bitmapsToCreate.alphaMask
 155                 && SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
 156                 && !diffData.fResult.poiAlphaMask.empty()
 157                 && !newRecord->fCommonName.isEmpty()) {
 158
 159             newRecord->fAlphaMaskPath = SkOSPath::Join(fAlphaMaskDir.c_str(),
 160                                                        newRecord->fCommonName.c_str());
 161
 162             // compute the image diff and output it
 163             SkBitmap copy;
 164             diffData.fResult.poiAlphaMask.copyTo(&copy, kN32_SkColorType);
 165             SkImageEncoder::EncodeFile(newRecord->fAlphaMaskPath.c_str(), copy,
 166                                        SkImageEncoder::kPNG_Type, 100);
 167
 168             // cleanup the existing bitmap to free up resources;
 169             diffData.fResult.poiAlphaMask.reset();
 170
 171             bitmapsToCreate.alphaMask = false;
 172         }
 173
 174         if (bitmapsToCreate.rgbDiff
 175                 && SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
 176                 && !diffData.fResult.rgbDiffBitmap.empty()
 177                 && !newRecord->fCommonName.isEmpty()) {
 178             // TODO(djsollen): Rather than taking the max r/g/b diffs that come back from
 179             // a particular differ and storing them as toplevel fields within
 180             // newRecord, we should extend outputRecords() to report optional
 181             // fields for each differ (not just "result" and "pointsOfInterest").
 182             // See http://skbug.com/2712 ('allow skpdiff to report different sets
 183             // of result fields for different comparison algorithms')
 184             newRecord->fMaxRedDiff = diffData.fResult.maxRedDiff;
 185             newRecord->fMaxGreenDiff = diffData.fResult.maxGreenDiff;
 186             newRecord->fMaxBlueDiff = diffData.fResult.maxBlueDiff;
 187
 188             newRecord->fRgbDiffPath = SkOSPath::Join(fRgbDiffDir.c_str(),
 189                                                      newRecord->fCommonName.c_str());
 190             SkImageEncoder::EncodeFile(newRecord->fRgbDiffPath.c_str(),
 191                                        diffData.fResult.rgbDiffBitmap,
 192                                        SkImageEncoder::kPNG_Type, 100);
 193             diffData.fResult.rgbDiffBitmap.reset();
 194             bitmapsToCreate.rgbDiff = false;
 195         }
 196
 197         if (bitmapsToCreate.whiteDiff
 198                 && SkImageDiffer::RESULT_CORRECT != diffData.fResult.result
 199                 && !diffData.fResult.whiteDiffBitmap.empty()
 200                 && !newRecord->fCommonName.isEmpty()) {
 201             newRecord->fWhiteDiffPath = SkOSPath::Join(fWhiteDiffDir.c_str(),
 202                                                        newRecord->fCommonName.c_str());
 203             SkImageEncoder::EncodeFile(newRecord->fWhiteDiffPath.c_str(),
 204                                        diffData.fResult.whiteDiffBitmap,
 205                                        SkImageEncoder::kPNG_Type, 100);
 206             diffData.fResult.whiteDiffBitmap.reset();
 207             bitmapsToCreate.whiteDiff = false;
 208         }
 209     }
 210 }
 211
 212 class SkThreadedDiff : public SkRunnable {
 213 public:
 214     SkThreadedDiff() : fDiffContext(NULL) { }
 215
 216     void setup(SkDiffContext* diffContext, const SkString& baselinePath, const SkString& testPath) {
 217         fDiffContext = diffContext;
 218         fBaselinePath = baselinePath;
 219         fTestPath = testPath;
 220     }
 221
 222     void run() SK_OVERRIDE {
 223         fDiffContext->addDiff(fBaselinePath.c_str(), fTestPath.c_str());
 224     }
 225
 226 private:
 227     SkDiffContext* fDiffContext;
 228     SkString fBaselinePath;
 229     SkString fTestPath;
 230 };
 231
 232 void SkDiffContext::diffDirectories(const char baselinePath[], const char testPath[]) {
 233     // Get the files in the baseline, we will then look for those inside the test path
 234     SkTArray<SkString> baselineEntries;
 235     if (!get_directory(baselinePath, &baselineEntries)) {
 236         SkDebugf("Unable to open path \"%s\"\n", baselinePath);
 237         return;
 238     }
 239
 240     SkTaskGroup tg;
 241     SkTArray<SkThreadedDiff> runnableDiffs;
 242     runnableDiffs.reset(baselineEntries.count());
 243
 244     for (int x = 0; x < baselineEntries.count(); x++) {
 245         const char* baseFilename = baselineEntries[x].c_str();
 246
 247         // Find the real location of each file to compare
 248         SkString baselineFile = SkOSPath::Join(baselinePath, baseFilename);
 249         SkString testFile = SkOSPath::Join(testPath, baseFilename);
 250
 251         // Check that the test file exists and is a file
 252         if (sk_exists(testFile.c_str()) && !sk_isdir(testFile.c_str())) {
 253             // Queue up the comparison with the differ
 254             runnableDiffs[x].setup(this, baselineFile, testFile);
 255             tg.add(&runnableDiffs[x]);
 256         } else {
 257             SkDebugf("Baseline file \"%s\" has no corresponding test file\n", baselineFile.c_str());
 258         }
 259     }
 260 }
 261
 262
 263 void SkDiffContext::diffPatterns(const char baselinePattern[], const char testPattern[]) {
 264     // Get the files in the baseline and test patterns. Because they are in sorted order, it's easy
 265     // to find corresponding images by matching entry indices.
 266
 267     SkTArray<SkString> baselineEntries;
 268     if (!glob_files(baselinePattern, &baselineEntries)) {
 269         SkDebugf("Unable to get pattern \"%s\"\n", baselinePattern);
 270         return;
 271     }
 272
 273     SkTArray<SkString> testEntries;
 274     if (!glob_files(testPattern, &testEntries)) {
 275         SkDebugf("Unable to get pattern \"%s\"\n", testPattern);
 276         return;
 277     }
 278
 279     if (baselineEntries.count() != testEntries.count()) {
 280         SkDebugf("Baseline and test patterns do not yield corresponding number of files\n");
 281         return;
 282     }
 283
 284     SkTaskGroup tg;
 285     SkTArray<SkThreadedDiff> runnableDiffs;
 286     runnableDiffs.reset(baselineEntries.count());
 287
 288     for (int x = 0; x < baselineEntries.count(); x++) {
 289         runnableDiffs[x].setup(this, baselineEntries[x], testEntries[x]);
 290         tg.add(&runnableDiffs[x]);
 291     }
 292     tg.wait();
 293 }
 294
 295 void SkDiffContext::outputRecords(SkWStream& stream, bool useJSONP) {
 296     SkTLList<DiffRecord>::Iter iter(fRecords, SkTLList<DiffRecord>::Iter::kHead_IterStart);
 297     DiffRecord* currentRecord = iter.get();
 298
 299     if (useJSONP) {
 300         stream.writeText("var SkPDiffRecords = {\n");
 301     } else {
 302         stream.writeText("{\n");
 303     }
 304
 305     // TODO(djsollen): Would it be better to use the jsoncpp library to write out the JSON?
 306     // This manual approach is probably more efficient, but it sure is ugly.
 307     // See http://skbug.com/2713 ('make skpdiff use jsoncpp library to write out
 308     // JSON output, instead of manual writeText() calls?')
 309     stream.writeText("    \"records\": [\n");
 310     while (currentRecord) {
 311         stream.writeText("        {\n");
 312
 313             SkString baselineAbsPath = get_absolute_path(currentRecord->fBaselinePath);
 314             SkString testAbsPath = get_absolute_path(currentRecord->fTestPath);
 315
 316             stream.writeText("            \"commonName\": \"");
 317             stream.writeText(currentRecord->fCommonName.c_str());
 318             stream.writeText("\",\n");
 319
 320             stream.writeText("            \"differencePath\": \"");
 321             stream.writeText(get_absolute_path(currentRecord->fAlphaMaskPath).c_str());
 322             stream.writeText("\",\n");
 323
 324             stream.writeText("            \"rgbDiffPath\": \"");
 325             stream.writeText(get_absolute_path(currentRecord->fRgbDiffPath).c_str());
 326             stream.writeText("\",\n");
 327
 328             stream.writeText("            \"whiteDiffPath\": \"");
 329             stream.writeText(get_absolute_path(currentRecord->fWhiteDiffPath).c_str());
 330             stream.writeText("\",\n");
 331
 332             stream.writeText("            \"baselinePath\": \"");
 333             stream.writeText(baselineAbsPath.c_str());
 334             stream.writeText("\",\n");
 335
 336             stream.writeText("            \"testPath\": \"");
 337             stream.writeText(testAbsPath.c_str());
 338             stream.writeText("\",\n");
 339
 340             stream.writeText("            \"width\": ");
 341             stream.writeDecAsText(currentRecord->fSize.width());
 342             stream.writeText(",\n");
 343             stream.writeText("            \"height\": ");
 344             stream.writeDecAsText(currentRecord->fSize.height());
 345             stream.writeText(",\n");
 346
 347             stream.writeText("            \"maxRedDiff\": ");
 348             stream.writeDecAsText(currentRecord->fMaxRedDiff);
 349             stream.writeText(",\n");
 350             stream.writeText("            \"maxGreenDiff\": ");
 351             stream.writeDecAsText(currentRecord->fMaxGreenDiff);
 352             stream.writeText(",\n");
 353             stream.writeText("            \"maxBlueDiff\": ");
 354             stream.writeDecAsText(currentRecord->fMaxBlueDiff);
 355             stream.writeText(",\n");
 356
 357             stream.writeText("            \"diffs\": [\n");
 358             for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffIndex++) {
 359                 DiffData& data = currentRecord->fDiffs[diffIndex];
 360                 stream.writeText("                {\n");
 361
 362                     stream.writeText("                    \"differName\": \"");
 363                     stream.writeText(data.fDiffName);
 364                     stream.writeText("\",\n");
 365
 366                     stream.writeText("                    \"result\": ");
 367                     stream.writeScalarAsText((SkScalar)data.fResult.result);
 368                     stream.writeText(",\n");
 369
 370                     stream.writeText("                    \"pointsOfInterest\": ");
 371                     stream.writeDecAsText(data.fResult.poiCount);
 372                     stream.writeText("\n");
 373
 374                 stream.writeText("                }");
 375
 376                 // JSON does not allow trailing commas
 377                 if (diffIndex + 1 < currentRecord->fDiffs.count()) {
 378                     stream.writeText(",");
 379                 }
 380                 stream.writeText("                \n");
 381             }
 382             stream.writeText("            ]\n");
 383
 384         stream.writeText("        }");
 385
 386         currentRecord = iter.next();
 387
 388         // JSON does not allow trailing commas
 389         if (currentRecord) {
 390             stream.writeText(",");
 391         }
 392         stream.writeText("\n");
 393     }
 394     stream.writeText("    ]\n");
 395     if (useJSONP) {
 396         stream.writeText("};\n");
 397     } else {
 398         stream.writeText("}\n");
 399     }
 400 }
 401
 402 void SkDiffContext::outputCsv(SkWStream& stream) {
 403     SkTDict<int> columns(2);
 404     int cntColumns = 0;
 405
 406     stream.writeText("key");
 407
 408     SkTLList<DiffRecord>::Iter iter(fRecords, SkTLList<DiffRecord>::Iter::kHead_IterStart);
 409     DiffRecord* currentRecord = iter.get();
 410
 411     // Write CSV header and create a dictionary of all columns.
 412     while (currentRecord) {
 413         for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffIndex++) {
 414             DiffData& data = currentRecord->fDiffs[diffIndex];
 415             if (!columns.find(data.fDiffName)) {
 416                 columns.set(data.fDiffName, cntColumns);
 417                 stream.writeText(", ");
 418                 stream.writeText(data.fDiffName);
 419                 cntColumns++;
 420             }
 421         }
 422         currentRecord = iter.next();
 423     }
 424     stream.writeText("\n");
 425
 426     double values[100];
 427     SkASSERT(cntColumns < 100);  // Make the array larger, if we ever have so many diff types.
 428
 429     SkTLList<DiffRecord>::Iter iter2(fRecords, SkTLList<DiffRecord>::Iter::kHead_IterStart);
 430     currentRecord = iter2.get();
 431     while (currentRecord) {
 432         for (int i = 0; i < cntColumns; i++) {
 433             values[i] = -1;
 434         }
 435
 436         for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffIndex++) {
 437             DiffData& data = currentRecord->fDiffs[diffIndex];
 438             int index = -1;
 439             SkAssertResult(columns.find(data.fDiffName, &index));
 440             SkASSERT(index >= 0 && index < cntColumns);
 441             values[index] = data.fResult.result;
 442         }
 443
 444         const char* filename = currentRecord->fBaselinePath.c_str() +
 445                 strlen(currentRecord->fBaselinePath.c_str()) - 1;
 446         while (filename > currentRecord->fBaselinePath.c_str() && *(filename - 1) != '/') {
 447             filename--;
 448         }
 449
 450         stream.writeText(filename);
 451
 452         for (int i = 0; i < cntColumns; i++) {
 453             SkString str;
 454             str.printf(", %f", values[i]);
 455             stream.writeText(str.c_str());
 456         }
 457         stream.writeText("\n");
 458
 459         currentRecord = iter2.next();
 460     }
 461 }