rebaseline_server: use new intermediate JSON format

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 25 matching lines @@
 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
 
+# Keys used within DiffRecord dictionary representations.
+# NOTE: Keep these in sync with static/constants.js
+KEY__DIFFERENCE_DATA__MAX_DIFF_PER_CHANNEL = 'maxDiffPerChannel'
+KEY__DIFFERENCE_DATA__NUM_DIFF_PIXELS = 'numDifferingPixels'
+KEY__DIFFERENCE_DATA__PERCENT_DIFF_PIXELS = 'percentDifferingPixels'
+KEY__DIFFERENCE_DATA__PERCEPTUAL_DIFF = 'perceptualDifference'
+KEY__DIFFERENCE_DATA__WEIGHTED_DIFF = 'weightedDiffMeasure'
+
 
 class DiffRecord(object):
   """ Record of differences between two images. """
 
   def __init__(self, storage_root,
                expected_image_url, expected_image_locator,
                actual_image_url, actual_image_locator,
                expected_images_subdir=DEFAULT_IMAGES_SUBDIR,
                actual_images_subdir=DEFAULT_IMAGES_SUBDIR,
                image_suffix=DEFAULT_IMAGE_SUFFIX):
@@ skipping 123 matching lines @@
 
   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."""
     return {
-        'numDifferingPixels': self._num_pixels_differing,
-        'percentDifferingPixels': self.get_percent_pixels_differing(),
-        'weightedDiffMeasure': self.get_weighted_diff_measure(),
-        'maxDiffPerChannel': self._max_diff_per_channel,
+        KEY__DIFFERENCE_DATA__NUM_DIFF_PIXELS: self._num_pixels_differing,
+        KEY__DIFFERENCE_DATA__PERCENT_DIFF_PIXELS:
+            self.get_percent_pixels_differing(),
+        KEY__DIFFERENCE_DATA__WEIGHTED_DIFF: self.get_weighted_diff_measure(),
+        KEY__DIFFERENCE_DATA__MAX_DIFF_PER_CHANNEL: self._max_diff_per_channel,
+        KEY__DIFFERENCE_DATA__PERCEPTUAL_DIFF: self._perceptual_difference,
     }
 
 
 class ImageDiffDB(object):
   """ Calculates differences between image pairs, maintaining a database of
   them for download."""
 
   def __init__(self, storage_root):
     """
     Args:
@@ skipping 76 matching lines @@
   # different pixel by the square of its delta value.  (The more different
   # a pixel is from its expectation, the more we care about it.)
   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
   (a.k.a. "color channel", such as R/G/B) across the entire image.
 
   Args:
     histogram: PIL histogram
 
   Returns the maximum value of each band within the image histogram, as a list.
   """
   max_per_band = []
   assert(len(histogram) % VALUES_PER_BAND == 0)
   num_bands = len(histogram) / VALUES_PER_BAND
   for band in xrange(num_bands):
     # Assuming that VALUES_PER_BAND is 256...
     #  the 'R' band makes up indices 0-255 in the histogram,
     #  the 'G' band makes up indices 256-511 in the histogram,
     #  etc.
     min_index = band * VALUES_PER_BAND
     index = min_index + VALUES_PER_BAND
     while index > min_index:
       index -= 1
       if histogram[index] > 0:
         max_per_band.append(index - min_index)
         break
   return max_per_band
 
+
 def _generate_image_diff(image1, image2):
   """Wrapper for ImageChops.difference(image1, image2) that will handle some
   errors automatically, or at least yield more useful error messages.
 
   TODO(epoger): Currently, some of the images generated by the bots are RGBA
   and others are RGB.  I'm not sure why that is.  For now, to avoid confusion
   within the UI, convert all to RGB when diffing.
 
   Args:
     image1: a PIL image object
     image2: a PIL image object
 
   Returns: per-pixel diffs between image1 and image2, as a PIL image object
   """
   try:
     return ImageChops.difference(image1.convert('RGB'), image2.convert('RGB'))
   except ValueError:
     logging.error('Error diffing image1 [%s] and image2 [%s].' % (
         repr(image1), repr(image2)))
     raise
 
+
 def _download_and_open_image(local_filepath, url):
   """Open the image at local_filepath; if there is no file at that path,
   download it from url to that path and then open it.
 
   Args:
     local_filepath: path on local disk where the image should be stored
     url: URL from which we can download the image if we don't have it yet
 
   Returns: a PIL image object
   """
   if not os.path.exists(local_filepath):
     _mkdir_unless_exists(os.path.dirname(local_filepath))
     with contextlib.closing(urllib.urlopen(url)) as url_handle:
       with open(local_filepath, 'wb') as file_handle:
         shutil.copyfileobj(fsrc=url_handle, fdst=file_handle)
   return _open_image(local_filepath)
 
+
 def _open_image(filepath):
   """Wrapper for Image.open(filepath) that yields more useful error messages.
 
   Args:
     filepath: path on local disk to load image from
 
   Returns: a PIL image object
   """
   try:
     return Image.open(filepath)
   except IOError:
     logging.error('IOError loading image file %s' % filepath)
     raise
 
+
 def _save_image(image, filepath, format='PNG'):
   """Write an image to disk, creating any intermediate directories as needed.
 
   Args:
     image: a PIL image object
     filepath: path on local disk to write image to
     format: one of the PIL image formats, listed at
             http://effbot.org/imagingbook/formats.htm
   """
   _mkdir_unless_exists(os.path.dirname(filepath))
   image.save(filepath, format)
 
+
 def _mkdir_unless_exists(path):
   """Unless path refers to an already-existing directory, create it.
 
   Args:
     path: path on local disk
   """
   if not os.path.isdir(path):
     os.makedirs(path)
 
+
 def _sanitize_locator(locator):
   """Returns a sanitized version of a locator (one in which we know none of the
   characters will have special meaning in filenames).
 
   Args:
     locator: string, or something that can be represented as a string
   """
   return DISALLOWED_FILEPATH_CHAR_REGEX.sub('_', str(locator))
 
+
 def _get_difference_locator(expected_image_locator, actual_image_locator):
   """Returns the locator string used to look up the diffs between expected_image
   and actual_image.
 
+  We must keep this function in sync with getImageDiffRelativeUrl() in
+  static/loader.js
+
   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))