add command line flags

experimental/skpdiff/main.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.
  */
 
 #define __NO_STD_VECTOR // Uses cl::vectpr instead of std::vectpr
 #define __NO_STD_STRING // Uses cl::STRING_CLASS instead of std::string
 #include <CL/cl.hpp>
 
+#include "SkCommandLineFlags.h"
+#include "SkGraphics.h"
 #include "SkOSFile.h"
-#include "SkStream.h"
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
 
 #include "SkImageDiffer.h"
 #include "SkCLImageDiffer.h"
 #include "skpdiff_util.h"
 
+#include "SkForceLinking.h"
+__SK_FORCE_IMAGE_DECODER_LINKING;
+
+// Command line argument definitions go here
+DEFINE_bool2(list, l, false, "List out available differs");
+DEFINE_string2(differs, d, "", "The names of the differs to use or all of them by default");
+DEFINE_string2(folders, f, "", "Compare two folders with identical subfile names: <baseline folder> <test folder>");
+DEFINE_string2(patterns, p, "", "Use two patterns to compare images: <baseline> <test>");
+
 /// A callback for any OpenCL errors
 CL_CALLBACK void error_notify(const char* errorInfo, const void* privateInfoSize, ::size_t cb, void* userData) {
     SkDebugf("OpenCL error notify: %s\n", errorInfo);
     exit(1);
 }
 
 /// Creates a device and context with OpenCL
 static bool init_device_and_context(cl::Device* device, cl::Context* context) {
     // Query for a platform
     cl::vector<cl::Platform> platformList;
@@ skipping 53 matching lines @@
             if (diffID >= 0) {
                 queuedDiffIDs.push(diffID);
                 SkDebugf("Result: %f\n", differ->getResult(diffID));
             }
         } else {
             SkDebugf("Baseline file \"%s\" has no corresponding test file\n", baselineFile.c_str());
         }
     }
 }
 
-static void print_help()
-{
-    SkDebugf(
-    "Usage:\n" \
-    "skpdiff <baseline directory> <test directory>\n\n"
-    );
+
+/// Compares two sets of images identified by glob style patterns with the given differ
+static void diff_patterns(const char baselinePattern[], const char testPattern[], SkImageDiffer* differ) {
+    // Get the files in the baseline and test patterns. Because they are in sorted order, it's easy
+    // to find corresponding images by matching entry indices.
+    //
+    SkTArray<SkString> baselineEntries;
+    if (!glob_files(baselinePattern, &baselineEntries)) {
+        SkDebugf("Unable to get pattern \"%s\"\n", baselinePattern);
+        return;
+    }
+
+    SkTArray<SkString> testEntries;
+    if (!glob_files(testPattern, &testEntries)) {
+        SkDebugf("Unable to get pattern \"%s\"\n", testPattern);
+        return;
+    }
+
+    if (baselineEntries.count() != testEntries.count()) {
+        SkDebugf("Baseline and test patterns do not yield corresponding number of files\n");
+        return;
+    }
+
+    SkTDArray<int> queuedDiffIDs;
+    for (int entryIndex = 0; entryIndex < baselineEntries.count(); entryIndex++) {
+        const char* baselineFilename = baselineEntries[entryIndex].c_str();
+        const char* testFilename     = testEntries    [entryIndex].c_str();
+        SkDebugf("%s %s\n", baselineFilename, testFilename);
+
+        int diffID = differ->queueDiffOfFile(baselineFilename, testFilename);
+        if (diffID >= 0) {
+            queuedDiffIDs.push(diffID);
+            SkDebugf("Result: %f\n", differ->getResult(diffID));
+        }
+    }
 }
 
-int main(int argc, char** argv) {
-    if (argc != 3)
-    {
-        print_help();
-        return 1;
-    }
 
+static bool init_cl_diff(SkImageDiffer* differ)
+{
     // Setup OpenCL
     cl::Device device;
     cl::Context context;
     if (!init_device_and_context(&device, &context)) {
-        return 1;
+        return false;
     }
 
     // Setup our differ of choice
-    SkCLImageDiffer* differ = SkNEW(SkDifferentPixelsImageDiffer);
-    if (!differ->init(device(), context())) {
-        return 1;
+    SkCLImageDiffer* clDiffer = (SkCLImageDiffer*)differ;
+    return clDiffer->init(device(), context());
+}
+
+// List here every differ
+SkDifferentPixelsImageDiffer gDiffPixel;

[djsollen, 2013/06/27 12:43:50]

why does this or the 2 arrays below need to be global?

Ideally we would have these differ's self register (like GMs and Tests do), but
lets not spend time on the registration in this CL.  Just add a TODO about that
and we can come back to it later if we have time.

+
+/// A null terminated array of pointer to every differ declared above
+SkImageDiffer* gDiffers[] = { &gDiffPixel, NULL };
+
+/// A parallel array of functions to initialize the above differs
+bool (*gDiffInits[])(SkImageDiffer*) = { init_cl_diff, NULL };
+
+
+int main(int argc, char** argv) {
+    // Setup command line parsing
+    SkCommandLineFlags::SetUsage("Compare images using various metrics.");
+    SkCommandLineFlags::Parse(argc, argv);
+
+    // Needed by various Skia components
+    SkAutoGraphics ag;
+
+    if (FLAGS_list) {
+        SkDebugf("Differs:\n");

[djsollen, 2013/06/27 12:43:50]

"available metrics" as the user facing way to describe the internal concept of a
differ

     }
 
-    // Diff our folders
-    diff_directories(argv[1], argv[2], differ);
+    // Figure which differs the user chose, and optionally print them if the user requests it
+    SkTDArray<int> chosenDiffers;
+    for (int differIndex = 0; NULL != gDiffers[differIndex]; differIndex++) {
+        if (FLAGS_list) {
+            SkDebugf("    %s", gDiffers[differIndex]->getName());
+            SkDebugf("\n");
+        }
+
+        // Check if this differ was chosen by any of the flags
+        if (FLAGS_differs.isEmpty()) {
+            // If no differs were chosen, they all get added
+            chosenDiffers.push(differIndex);
+        } else {
+            for (int flagIndex = 0; flagIndex < FLAGS_differs.count(); flagIndex++) {
+                if (SkString(FLAGS_differs[flagIndex]).equals(gDiffers[differIndex]->getName())) {
+                    chosenDiffers.push(differIndex);
+                    break;
+                }
+            }
+        }
+    }
+
+    // Don't attempt to initialize the differ if we aren't going to use it
+    if (FLAGS_folders.isEmpty() && FLAGS_patterns.isEmpty()) {
+        return 0;
+    }
+
+    // Validate command line flags
+    if (!FLAGS_folders.isEmpty()) {
+        if (2 != FLAGS_folders.count()) {
+            SkDebugf("Folders flag expects two arguments: <baseline folder> <test folder>\n");
+            return 1;
+        }
+    }
+
+    if (!FLAGS_patterns.isEmpty()) {
+        if (2 != FLAGS_patterns.count()) {
+            SkDebugf("Patterns flag expects two arguments: <baseline pattern> <test pattern>\n");
+            return 1;
+        }
+    }
+
+    // Perform each requested diff
+    for (int differIndex = 0; differIndex < chosenDiffers.count(); differIndex++) {

[djsollen, 2013/06/27 12:43:50]

This is going to be a pretty inefficient method of doing the differences as
you're going to decode the baselines for each diff.  Let's not attempt to solve
that this CL either, but again add a TODO describing the inefficiency and follow
up with another CL to fix it.

+        // Get the chosen differ and say which one they chose
+        SkImageDiffer * differ = gDiffers[differIndex];
+        SkDebugf("Using differ \"%s\"\n", differ->getName());
+
+        // Initialize the differ using the global list of init functions that match the list of differs

[djsollen, 2013/06/27 12:43:50]

exceeds 100 char

+        gDiffInits[differIndex](differ);
+
+        // Perform a folder diff if one is requested
+        if (!FLAGS_folders.isEmpty()) {
+            diff_directories(FLAGS_folders[0], FLAGS_folders[1], differ);
+        }
+
+        // Perform a pattern diff if one is requested
+        if (!FLAGS_patterns.isEmpty()) {
+            diff_patterns(FLAGS_patterns[0], FLAGS_patterns[1], differ);
+        }
+    }
 
     return 0;
 }