rebaseline_server: delete no-longer-used weightedDiffMeasure

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 31 matching lines @@
 WHITEDIFFS_SUBDIR = 'whitediffs'
 
 VALUES_PER_BAND = 256
 
 # Keys used within DiffRecord dictionary representations.
 # NOTE: Keep these in sync with static/constants.js
 KEY__DIFFERENCES__MAX_DIFF_PER_CHANNEL = 'maxDiffPerChannel'
 KEY__DIFFERENCES__NUM_DIFF_PIXELS = 'numDifferingPixels'
 KEY__DIFFERENCES__PERCENT_DIFF_PIXELS = 'percentDifferingPixels'
 KEY__DIFFERENCES__PERCEPTUAL_DIFF = 'perceptualDifference'
-KEY__DIFFERENCES__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,
@@ skipping 47 matching lines @@
     except Exception:
       logging.exception('unable to download actual_image_url %s to file %s' %
                         (actual_image_url, actual_image_file))
       raise
 
     # Generate the diff image (absolute diff at each pixel) and
     # max_diff_per_channel.
     diff_image = _generate_image_diff(actual_image, expected_image)
     diff_histogram = diff_image.histogram()
     (diff_width, diff_height) = diff_image.size
-    self._weighted_diff_measure = _calculate_weighted_diff_metric(
-        diff_histogram, diff_width * diff_height)
     self._max_diff_per_channel = _max_per_band(diff_histogram)
 
     # 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)
@@ skipping 50 matching lines @@
   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).
-
-    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."""
     return {
         KEY__DIFFERENCES__NUM_DIFF_PIXELS: self._num_pixels_differing,
         KEY__DIFFERENCES__PERCENT_DIFF_PIXELS:
             self.get_percent_pixels_differing(),
-        KEY__DIFFERENCES__WEIGHTED_DIFF: self.get_weighted_diff_measure(),
         KEY__DIFFERENCES__MAX_DIFF_PER_CHANNEL: self._max_diff_per_channel,
         KEY__DIFFERENCES__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):
@@ skipping 60 matching lines @@
 
     Raises a KeyError if we don't have a DiffRecord for this image pair.
     """
     key = (_sanitize_locator(expected_image_locator),
            _sanitize_locator(actual_image_locator))
     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.)
-  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 = []
@@ skipping 114 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))