tests/gentle_compare.py: add pixmaps_diff() and rms().

Author: julian-smith-artifex-com

tests/gentle_compare.py

@@ -28,10 +28,24 @@ def gentle_compare(w0, w1):
     return True
 
 
+def rms(a, b):
+    '''
+    Returns RMS diff of raw bytes of two sequences.
+    '''
+    assert len(a) == len(b)
+    e = 0
+    for aa, bb in zip(a, b):
+        e += (aa - bb) ** 2
+    rms = math.sqrt(e / len(a))
+    return rms
+
+
 def pixmaps_rms(a, b, out_prefix=''):
     '''
-    Returns RMS diff of raw bytes of two pixmaps. We assert that the pixmaps
-    are the same size.
+    Returns RMS diff of raw bytes of two pixmaps.
+
+    We assert that the pixmaps/sequences are the same size.
+
     <a> and <b> can each be a pymupdf.Pixmap or path of a bitmap file.
     '''
     if isinstance(a, str):
@@ -52,3 +66,34 @@ def pixmaps_rms(a, b, out_prefix=''):
     rms = math.sqrt(e / len(a_mv))
     print(f'{out_prefix}compare_pixmaps(): {e=} {rms=}.')
     return rms
+
+
+def pixmaps_diff(a, b, out_prefix=''):
+    '''
+    Returns a pymupdf.Pixmap that represents the difference between pixmaps <a>
+    and <b>.
+    
+    Each byte in the returned pixmap is `128 + (b_byte - a_byte) // 2`.
+    '''
+    if isinstance(a, str):
+        print(f'{out_prefix}pixmaps_rms(): reading pixmap from {a=}.')
+        a = pymupdf.Pixmap(a)
+    if isinstance(b, str):
+        print(f'{out_prefix}pixmaps_rms(): reading pixmap from {b=}.')
+        b = pymupdf.Pixmap(b)
+    assert a.irect == b.irect, f'Differing rects: {a.irect=} {b.irect=}.'
+    a_mv = a.samples_mv
+    b_mv = b.samples_mv
+    c = pymupdf.Pixmap(a.tobytes())
+    c_mv = c.samples_mv
+    assert len(a_mv) == len(b_mv) == len(c_mv)
+    if 1:
+        print(f'{len(a_mv)=}')
+        for i, (a_byte, b_byte, c_byte) in enumerate(zip(a_mv, b_mv, c_mv)):
+            assert 0 <= a_byte < 256
+            assert 0 <= b_byte < 256
+            assert 0 <= c_byte < 256
+            # Set byte to 128 plus half the diff so we represent the full
+            # -255..+255 range.
+            c_mv[i] = 128 + (b_byte - a_byte) // 2
+    return c