rebaseline_server: fail fast if skpdiff binary is not available

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.
 """
@@ skipping 13 matching lines @@
   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'
+SKPDIFF_BINARY = find_run_binary.find_path_to_program('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 63 matching lines @@
     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,
+          [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
@@ skipping 30 matching lines @@
     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)."""
+    (inclusive).
+
+    TODO(epoger): Delete this function, now that we have perceptual diff?
+    """
     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
 
   def as_dict(self):
     """Returns a dictionary representation of this DiffRecord, as needed when
     constructing the JSON representation."""
@@ skipping 72 matching lines @@
     return self._diff_dict[key]
 
 
 # Utility functions
 
 def _calculate_weighted_diff_metric(histogram, num_pixels):
   """Given the histogram of a diff image (per-channel diff at each
   pixel between two images), calculate the weighted diff metric (a
   stab at how different the two images really are).
 
+  TODO(epoger): Delete this function, now that we have perceptual diff?
+
   Args:
     histogram: PIL histogram of a per-channel diff between two images
     num_pixels: integer; the total number of pixels in the diff image
 
   Returns: a weighted diff metric, as a float between 0 and 100 (inclusive).
   """
   # TODO(epoger): As a wild guess at an appropriate metric, weight each
   # different pixel by the square of its delta value.  (The more different
   # a pixel is from its expectation, the more we care about it.)
-  # In the long term, we will probably use some metric generated by
-  # skpdiff anyway.
   assert(len(histogram) % VALUES_PER_BAND == 0)
   num_bands = len(histogram) / VALUES_PER_BAND
   max_diff = num_pixels * num_bands * (VALUES_PER_BAND - 1)**2
   total_diff = 0
   for index in xrange(len(histogram)):
     total_diff += histogram[index] * (index % VALUES_PER_BAND)**2
   return float(100 * total_diff) / max_diff
 
 def _max_per_band(histogram):
   """Given the histogram of an image, return the maximum value of each band
@@ skipping 109 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))