Inkscape shell mode.

anntzer · anntzer · commit d67380d14faf · 2017-03-09T17:29:40.000-08:00
diff --git a/lib/matplotlib/testing/compare.py b/lib/matplotlib/testing/compare.py
@@ -7,9 +7,13 @@
 
 import six
 
+import atexit
+import functools
 import hashlib
+import itertools
 import os
 import shutil
+import sys
 
 import numpy as np
 
@@ -128,6 +132,57 @@ def convert(old, new):
     return convert
 
 
+class _SVGConverter(object):
+    def __init__(self):
+        self._proc = None
+        # We cannot rely on the GC to trigger `__del__` at exit because
+        # other modules (e.g. `subprocess`) may already have their globals
+        # set to `None`, which make `proc.communicate` or `proc.terminate`
+        # fail.  By relying on `atexit` we ensure the destructor runs before
+        # `None`-setting occurs.
+        atexit.register(self.__del__)
+
+    def _read_to_terminator(self):
+        stream = iter(functools.partial(self._proc.stdout.read, 1), b"")
+        terminator = (b"\n", b">")
+        n = len(terminator)
+        its = itertools.tee(stream, n)
+        for i, it in enumerate(its):
+            next(itertools.islice(it, i, i), None)  # Advance `it` by `i`.
+        while True:
+            window = tuple(map(next, its))
+            if (len(window) != n or window == terminator):
+                # First case is to running out of data -- one of the `next(it)`
+                # raises StopIteration, so the tuple is shorter.
+                # Second case is to successful reading until terminator.
+                break
+
+    def __call__(self, orig, dest):
+        if (not self._proc  # First run.
+                or self._proc.poll()):  # Inkscape terminated, e.g. crashed.
+            self._proc = subprocess.Popen([str("inkscape"), "--shell"],
+                                          stdin=subprocess.PIPE,
+                                          stdout=subprocess.PIPE)
+            self._read_to_terminator()
+        try:
+            fsencode = os.fsencode
+        except AttributeError:  # Py2.
+            def fsencode(s):
+                return s.encode(sys.getfilesystemencoding())
+        self._proc.stdin.write(
+            fsencode("{} --export-png={}\n".format(orig, dest)))
+        self._proc.stdin.flush()
+        self._read_to_terminator()
+
+    def __del__(self):
+        if self._proc:
+            if self._proc.poll() is None:  # Not exited yet.
+                self._proc.communicate(b"quit\n")
+                self._proc.wait()
+            self._proc.stdin.close()
+            self._proc.stdout.close()
+
+
 def _update_converter():
     gs, gs_v = matplotlib.checkdep_ghostscript()
     if gs_v is not None:
@@ -138,9 +193,7 @@ def cmd(old, new):
         converter['eps'] = make_external_conversion_command(cmd)
 
     if matplotlib.checkdep_inkscape() is not None:
-        def cmd(old, new):
-            return [str('inkscape'), '-z', old, '--export-png', new]
-        converter['svg'] = make_external_conversion_command(cmd)
+        converter['svg'] = _SVGConverter()
 
 
 #: A dictionary that maps filename extensions to functions which
@@ -363,9 +416,8 @@ def save_diff_image(expected, actual, output):
         actual, actualImage, expected, expectedImage)
     expectedImage = np.array(expectedImage).astype(float)
     actualImage = np.array(actualImage).astype(float)
-    assert expectedImage.ndim == actualImage.ndim
-    assert expectedImage.shape == actualImage.shape
-    absDiffImage = abs(expectedImage - actualImage)
+    assert expectedImage.shape[:2] == actualImage.shape[:2]
+    absDiffImage = np.abs(expectedImage[:, :, :3] - actualImage[:, :, :3])
 
     # expand differences in luminance domain
     absDiffImage *= 255 * 10
