Script to run glretrace in parallel, comparing generated snapshots.

[apitrace] / scripts / snapdiff.py

diff --git a/scripts/snapdiff.py b/scripts/snapdiff.py
index 0e40419167efdff0b250b4c1ca14fcaf18b5f675..965044068a1d3a55cf401c4f76e791dd2a31d79d 100755 (executable)
--- a/scripts/snapdiff.py
+++ b/scripts/snapdiff.py
@@ -26,6 +26,10 @@
 ##########################################################################/
 
 
+'''Snapshot (image) comparison script.
+'''
+
+
 import sys
 import os.path
 import optparse
@@ -40,46 +44,48 @@ import ImageEnhance
 thumb_size = 320, 320
 
 
-def _compare(ref_image, src_image, delta_image):
-    import subprocess
-    p = subprocess.Popen([
-        'compare', 
-        '-metric', 'AE', 
-        '-fuzz', '%u%%' % options.fuzz, 
-        '-dissimilarity-threshold', '1',
-        ref_image, src_image, delta_image
-    ], stderr=subprocess.PIPE)
-    _, stderr = p.communicate()
-    try:
-        return int(stderr)
-    except ValueError:
-        return 0xffffffff
+class Comparer:
+    '''Image comparer.'''
 
+    def __init__(self, ref_image, src_image, alpha = False):
+        self.ref_im = Image.open(ref_image)
+        self.src_im = Image.open(src_image)
 
-def compare(ref_image, src_image, delta_image):
-    ref_im = Image.open(ref_image)
-    src_im = Image.open(src_image)
+        # Ignore
+        if not alpha:
+            self.ref_im = self.ref_im.convert('RGB')
+            self.src_im = self.src_im.convert('RGB')
 
-    ref_im = ref_im.convert('RGB')
-    src_im = src_im.convert('RGB')
+        self.diff = ImageChops.difference(self.src_im, self.ref_im)
 
-    diff = ImageChops.difference(src_im, ref_im)
+    def write_diff(self, diff_image, fuzz = 0.05):
+        # make a difference image similar to ImageMagick's compare utility
+        mask = ImageEnhance.Brightness(self.diff).enhance(1.0/fuzz)
+        mask = mask.convert('L')
 
-    mask = ImageEnhance.Brightness(diff).enhance(100.0/options.fuzz)
-    mask = mask.convert('L')
+        lowlight = Image.new('RGB', self.src_im.size, (0xff, 0xff, 0xff))
+        highlight = Image.new('RGB', self.src_im.size, (0xf1, 0x00, 0x1e))
+        diff_im = Image.composite(highlight, lowlight, mask)
 
-    lowlight = Image.new('RGB', src_im.size, (0xff, 0xff, 0xff))
-    highlight = Image.new('RGB', src_im.size, (0xf1, 0x00, 0x1e))
-    delta_im = Image.composite(highlight, lowlight, mask)
+        diff_im = Image.blend(self.src_im, diff_im, 0xcc/255.0)
+        diff_im.save(diff_image)
 
-    delta_im = Image.blend(src_im, delta_im, 0xcc/255.0)
-    delta_im.save(delta_image)
+    def precision(self):
+        # See also http://effbot.org/zone/pil-comparing-images.htm
+        h = self.diff.histogram()
+        square_error = 0
+        for i in range(1, 256):
+            square_error += sum(h[i : 3*256: 256])*i*i
+        rel_error = float(square_error*2 + 1) / float(self.diff.size[0]*self.diff.size[1]*3*255*255*2)
+        bits = -math.log(rel_error)/math.log(2.0)
+        return bits
 
-    # See also http://effbot.org/zone/pil-comparing-images.htm
-    # TODO: this is approximate due to the grayscale conversion
-    h = diff.convert('L').histogram()
-    ae = sum(h[255 * options.fuzz // 100 + 1 : 256])
-    return ae
+    def ae(self):
+        # Compute absolute error
+        # TODO: this is approximate due to the grayscale conversion
+        h = self.diff.convert('L').histogram()
+        ae = sum(h[int(255 * fuzz) + 1 : 256])
+        return ae
 
 
 def surface(html, image):
@@ -133,8 +139,8 @@ def main():
         help="output filename [default: %default]")
     optparser.add_option(
         '-f', '--fuzz',
-        type="int", dest="fuzz", default=5,
-        help="fuzz percentage [default: %default]")
+        type="float", dest="fuzz", default=0.05,
+        help="fuzz ratio [default: %default]")
     optparser.add_option(
         '--overwrite',
         action="store_true", dest="overwrite", default=False,
@@ -171,7 +177,9 @@ def main():
                or not os.path.exists(delta_image) \
                or (os.path.getmtime(delta_image) < os.path.getmtime(ref_image) \
                    and os.path.getmtime(delta_image) < os.path.getmtime(src_image)):
-                compare(ref_image, src_image, delta_image)
+
+                comparer = Comparer(ref_image, src_image)
+                comparer.write_diff(delta_image, fuzz=options.fuzz)
 
             html.write('      <tr>\n')
             surface(html, ref_image)