rebaseline_server: use just skpdiff, not Python Image Library

tools/skpdiff/SkDiffContext.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDiffContext_DEFINED
 #define SkDiffContext_DEFINED
 
@@ skipping 10 matching lines @@
  * Collects records of diffs and outputs them as JSON.
  */
 class SkDiffContext {
 public:
     SkDiffContext();
     ~SkDiffContext();
 
     void setThreadCount(int threadCount) { fThreadCount = threadCount; }
 
     /**
-     * Creates the directory if it does not exist and uses it to store differences
-     * between images.
+     * Sets the directory within which to store alphaMasks (images that
+     * are transparent for each pixel that differs between baseline and test).
+     *
+     * If the directory does not exist yet, it will be created.
      */
-    void setDifferenceDir(const SkString& directory);
+    void setAlphaMaskDir(const SkString& directory);
+
+    /**
+     * Sets the directory within which to store rgbDiffs (images showing the
+     * per-channel difference between baseline and test at each pixel).
+     *
+     * If the directory does not exist yet, it will be created.
+     */
+    void setRgbDiffDir(const SkString& directory);
+
+    /**
+     * Sets the directory within which to store whiteDiffs (images showing white
+     * for each pixel that differs between baseline and test).
+     *
+     * If the directory does not exist yet, it will be created.
+     */
+    void setWhiteDiffDir(const SkString& directory);
 
     /**
      * Sets the differs to be used in each diff. Already started diffs will not retroactively use
      * these.
      * @param differs An array of differs to use. The array is copied, but not the differs
      *                themselves.
      */
     void setDiffers(const SkTDArray<SkImageDiffer*>& differs);
 
     /**
@@ skipping 22 matching lines @@
      *
      * The format of the JSON document is one top level array named "records".
      * Each record in the array is an object with the following values:
      *    "commonName"     : string containing the common prefix of the baselinePath
      *                       and testPath filenames
      *    "baselinePath"   : string containing the path to the baseline image
      *    "testPath"       : string containing the path to the test image
      *    "differencePath" : (optional) string containing the path to an alpha
      *                       mask of the pixel difference between the baseline
      *                       and test images
+     *                       TODO: consider renaming this "alphaMaskPath"
+     *                       to distinguish from other difference types?
+     *    "rgbDiffPath"    : (optional) string containing the path to a bitmap
+     *                       showing per-channel differences between the
+     *                       baseline and test images at each pixel
+     *    "whiteDiffPath"  : (optional) string containing the path to a bitmap

[djsollen, 2014/06/12 13:27:00]

Why do you need a whiteDiffPath?  It stores the exact same info as the alpha
mask in differencePath.  In the UI you should then be able to just draw a white
div the size of the image and then draw the alpha mask image overtop.

[epoger, 2014/06/12 14:02:34]

I'll try that.  A big concern for me is making it as easy as possible for the
client to render the comparison rows.  Do you think the alpha mask will perform
just about as well as a standard single bitmap on constrained platforms,
rendering 50 per page?  (I don't know how expensive the alpha blends are)

+     *                       showing every pixel that differs between the
+     *                       baseline and test images as white
      *
      * They also have an array named "diffs" with each element being one diff record for the two
      * images indicated in the above field.
      * A diff record includes:
      *    "differName"       : string name of the diff metric used
      *    "result"           : numerical result of the diff
      *
      * Here is an example:
      *
      * {
@@ skipping 24 matching lines @@
 
 
 private:
     struct DiffData {
         const char* fDiffName;
         SkImageDiffer::Result fResult;
     };
 
     struct DiffRecord {
         SkString           fCommonName;
-        SkString           fDifferencePath;
+        SkString           fAlphaMaskPath;
+        SkString           fRgbDiffPath;
+        SkString           fWhiteDiffPath;
         SkString           fBaselinePath;
         SkString               fTestPath;
+        int                       fWidth;
+        int                      fHeight;
+        int                  fMaxRedDiff;
+        int                fMaxGreenDiff;
+        int                 fMaxBlueDiff;
         SkTArray<DiffData>        fDiffs;
     };
 
     // Used to protect access to fRecords and ensure only one thread is
     // adding new entries at a time.
     SkMutex fRecordMutex;
 
     // We use linked list for the records so that their pointers remain stable. A resizable array
     // might change its pointers, which would make it harder for async diffs to record their
     // results.
     SkTLList<DiffRecord> fRecords;
 
     SkImageDiffer** fDiffers;
     int fDifferCount;
     int fThreadCount;
 
-    SkString fDifferenceDir;
+    SkString fAlphaMaskDir;
+    SkString fRgbDiffDir;
+    SkString fWhiteDiffDir;
 };
 
 #endif