Add the perceptual difference metric to the rebaseline server

gm/rebaseline_server/imagediffdb.py

 #!/usr/bin/python
 
 """
 Copyright 2013 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 Calulate differences between image pairs, and store them in a database.
 """
 
 import contextlib
+import csv
 import logging
 import os
 import re
 import shutil
+import sys
+import tempfile
 import urllib
 try:
   from PIL import Image, ImageChops
 except ImportError:
   raise ImportError('Requires PIL to be installed; see '
                     + 'http://www.pythonware.com/products/pil/')
 
+# Set the PYTHONPATH to include the tools directory.
+sys.path.append(
+    os.path.join(
+        os.path.dirname(os.path.realpath(__file__)), os.pardir, os.pardir,
+                        'tools'))
+import find_run_binary
+
+SKPDIFF_BINARY_NAME = 'skpdiff'
+
 DEFAULT_IMAGE_SUFFIX = '.png'
 DEFAULT_IMAGES_SUBDIR = 'images'
 
 DISALLOWED_FILEPATH_CHAR_REGEX = re.compile('[^\w\-]')
 
 DIFFS_SUBDIR = 'diffs'
 WHITEDIFFS_SUBDIR = 'whitediffs'
 
 VALUES_PER_BAND = 256
 
@@ skipping 58 matching lines @@
     # Generate the whitediff image (any differing pixels show as white).
     # This is tricky, because when you convert color images to grayscale or
     # black & white in PIL, it has its own ideas about thresholds.
     # We have to force it: if a pixel has any color at all, it's a '1'.
     bands = diff_image.split()
     graydiff_image = ImageChops.lighter(ImageChops.lighter(
         bands[0], bands[1]), bands[2])
     whitediff_image = (graydiff_image.point(lambda p: p > 0 and VALUES_PER_BAND)
                                      .convert('1', dither=Image.NONE))
 
+    # Calculate the perceptual difference percentage.
+    skpdiff_csv_dir = tempfile.mkdtemp()
+    try:
+      skpdiff_csv_output = os.path.join(skpdiff_csv_dir, 'skpdiff-output.csv')
+      skpdiff_binary = find_run_binary.find_path_to_program(SKPDIFF_BINARY_NAME)
+      expected_img = os.path.join(storage_root, expected_images_subdir,
+                                  str(expected_image_locator) + image_suffix)
+      actual_img = os.path.join(storage_root, actual_images_subdir,
+                                str(actual_image_locator) + image_suffix)
+      find_run_binary.run_command(
+          [skpdiff_binary, '-p', expected_img, actual_img,
+           '--csv', skpdiff_csv_output, '-d', 'perceptual'])
+      with contextlib.closing(open(skpdiff_csv_output)) as csv_file:
+        for row in csv.DictReader(csv_file):
+          perceptual_similarity = float(row[' perceptual'].strip())
+          if not 0 <= perceptual_similarity <= 1:
+            # skpdiff outputs -1 if the images are different sizes. Treat any
+            # output that does not lie in [0, 1] as having 0% perceptual
+            # similarity.
+            perceptual_similarity = 0
+          # skpdiff returns the perceptual similarity, convert it to get the
+          # perceptual difference percentage.
+          self._perceptual_difference = 100 - (perceptual_similarity * 100)
+    finally:
+      shutil.rmtree(skpdiff_csv_dir)
+
     # Final touches on diff_image: use whitediff_image as an alpha mask.
     # Unchanged pixels are transparent; differing pixels are opaque.
     diff_image.putalpha(whitediff_image)
 
     # Store the diff and whitediff images generated above.
     diff_image_locator = _get_difference_locator(
         expected_image_locator=expected_image_locator,
         actual_image_locator=actual_image_locator)
     basename = str(diff_image_locator) + image_suffix
     _save_image(diff_image, os.path.join(
         storage_root, DIFFS_SUBDIR, basename))
     _save_image(whitediff_image, os.path.join(
         storage_root, WHITEDIFFS_SUBDIR, basename))
 
     # Calculate difference metrics.
     (self._width, self._height) = diff_image.size
     self._num_pixels_differing = (
         whitediff_image.histogram()[VALUES_PER_BAND - 1])
 
   def get_num_pixels_differing(self):
     """Returns the absolute number of pixels that differ."""
     return self._num_pixels_differing
 
   def get_percent_pixels_differing(self):
     """Returns the percentage of pixels that differ, as a float between
     0 and 100 (inclusive)."""
     return ((float(self._num_pixels_differing) * 100) /
             (self._width * self._height))
 
+  def get_perceptual_difference(self):
+    """Returns the perceptual difference percentage."""
+    return self._perceptual_difference
+
   def get_weighted_diff_measure(self):
     """Returns a weighted measure of image diffs, as a float between 0 and 100
     (inclusive)."""
     return self._weighted_diff_measure
 
   def get_max_diff_per_channel(self):
     """Returns the maximum difference between the expected and actual images
     for each R/G/B channel, as a list."""
     return self._max_diff_per_channel
 
@@ skipping 215 matching lines @@
 
   Args:
     expected_image_locator: locator string pointing at expected image
     actual_image_locator: locator string pointing at actual image
 
   Returns: already-sanitized locator where the diffs between expected and
       actual images can be found
   """
   return "%s-vs-%s" % (_sanitize_locator(expected_image_locator),
                        _sanitize_locator(actual_image_locator))