Merge pull request #23 from BlackFoundryCom/surface-canvas-context

Surface API change: get canvas with context manager

Author: justvanrossum

Lib/blackrenderer/backends/base.py

@@ -99,13 +99,13 @@ class Surface(ABC):
     fileExtension = ".png"
 
     @abstractmethod
-    def __init__(self, boundingBox):
-        # boundingBox = (xMin, yMin, xMax, yMax)
+    def __init__(self):
         ...
 
-    @property
     @abstractmethod
-    def canvas(self):
+    @contextmanager
+    def canvas(self, boundingBox):
+        # boundingBox = (xMin, yMin, xMax, yMax)
         ...
 
     @abstractmethod

Lib/blackrenderer/backends/cairo.py

@@ -193,46 +193,61 @@ def _drawGradient(self, path, gradient, gradientTransform):
 class CairoPixelSurface(Surface):
     fileExtension = ".png"
 
-    def __init__(self, boundingBox):
+    def __init__(self):
+        self._surfaces = []
+
+    @contextmanager
+    def canvas(self, boundingBox):
         x, y, xMax, yMax = boundingBox
         width = xMax - x
         height = yMax - y
-        self.surface = self._setupCairoSurface(width, height)
-        self.context = cairo.Context(self.surface)
-        self.context.translate(-x, height + y)
-        self.context.scale(1, -1)
-        self._canvas = CairoCanvas(self.context)
+        surface = self._setupCairoSurface(width, height)
+        self._surfaces.append((surface, (width, height)))
+        context = cairo.Context(surface)
+        context.translate(-x, height + y)
+        context.scale(1, -1)
+        yield CairoCanvas(context)
 
     def _setupCairoSurface(self, width, height):
         return cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
 
-    @property
-    def canvas(self):
-        return self._canvas
-
     def saveImage(self, path):
-        self.surface.flush()
-        self.surface.write_to_png(os.fspath(path))
-        self.surface.finish()
+        surface, _ = self._surfaces[-1]
+        surface.flush()
+        surface.write_to_png(os.fspath(path))
+        surface.finish()
 
 
 class CairoPDFSurface(CairoPixelSurface):
     fileExtension = ".pdf"
-    _cairoVectorSurfaceClass = cairo.PDFSurface
 
     def _setupCairoSurface(self, width, height):
-        self.width = width
-        self.height = height
         return cairo.RecordingSurface(cairo.CONTENT_COLOR_ALPHA, (0, 0, width, height))
 
     def saveImage(self, path):
-        pdfSurface = self._cairoVectorSurfaceClass(path, self.width, self.height)
-        pdfContext = cairo.Context(pdfSurface)
-        pdfContext.set_source_surface(self.surface, 0.0, 0.0)
-        pdfContext.paint()
+        _, (width, height) = self._surfaces[0]
+        pdfSurface = cairo.PDFSurface(path, width, height)
+        pdfContext = None
+        for surface, (width, height) in self._surfaces:
+            pdfSurface.set_size(width, height)
+            if pdfContext is None:
+                # It's important to call the first set_size() *before*
+                # the context is created, or we'll get an additional
+                # empty page
+                pdfContext = cairo.Context(pdfSurface)
+            pdfContext.set_source_surface(surface, 0.0, 0.0)
+            pdfContext.paint()
+            pdfContext.show_page()
         pdfSurface.flush()
 
 
 class CairoSVGSurface(CairoPDFSurface):
     fileExtension = ".svg"
-    _cairoVectorSurfaceClass = cairo.SVGSurface
+
+    def saveImage(self, path):
+        surface, (width, height) = self._surfaces[-1]
+        svgSurface = cairo.SVGSurface(path, width, height)
+        pdfContext = cairo.Context(svgSurface)
+        pdfContext.set_source_surface(surface, 0.0, 0.0)
+        pdfContext.paint()
+        svgSurface.flush()

Lib/blackrenderer/backends/coregraphics.py

@@ -218,24 +218,23 @@ def _unpackColorLine(colorLine):
 class CoreGraphicsPixelSurface(Surface):
     fileExtension = ".png"
 
-    def __init__(self, boundingBox):
+    def __init__(self):
+        self.context = None
+
+    @contextmanager
+    def canvas(self, boundingBox):
         x, y, xMax, yMax = boundingBox
         width = xMax - x
         height = yMax - y
-        self.context = self._setupCGContext(x, y, width, height)
-        self._canvas = CoreGraphicsCanvas(self.context)
+        self._setupCGContext(x, y, width, height)
+        yield CoreGraphicsCanvas(self.context)
 
     def _setupCGContext(self, x, y, width, height):
         rgbColorSpace = CG.CGColorSpaceCreateDeviceRGB()
-        context = CG.CGBitmapContextCreate(
+        self.context = CG.CGBitmapContextCreate(
             None, width, height, 8, 0, rgbColorSpace, CG.kCGImageAlphaPremultipliedFirst
         )
-        CG.CGContextTranslateCTM(context, -x, -y)
-        return context
-
-    @property
-    def canvas(self):
-        return self._canvas
+        CG.CGContextTranslateCTM(self.context, -x, -y)
 
     def saveImage(self, path):
         image = CG.CGBitmapContextCreateImage(self.context)
@@ -245,19 +244,25 @@ def saveImage(self, path):
 class CoreGraphicsPDFSurface(CoreGraphicsPixelSurface):
     fileExtension = ".pdf"
 
+    @contextmanager
+    def canvas(self, boundingBox):
+        with super().canvas(boundingBox) as canvas:
+            CG.CGContextBeginPage(self.context, self._mediaBox)
+            yield canvas
+            CG.CGContextEndPage(self.context)
+
     def _setupCGContext(self, x, y, width, height):
-        mediaBox = ((x, y), (width, height))
-        self.data = CFDataCreateMutable(None, 0)
-        consumer = CG.CGDataConsumerCreateWithCFData(self.data)
-        context = CG.CGPDFContextCreate(consumer, mediaBox, None)
-        CG.CGContextBeginPage(context, mediaBox)
-        return context
+        if self.context is None:
+            self._mediaBox = ((x, y), (width, height))
+            self._data = CFDataCreateMutable(None, 0)
+            consumer = CG.CGDataConsumerCreateWithCFData(self._data)
+            self.context = CG.CGPDFContextCreate(consumer, self._mediaBox, None)
+        return self.context
 
     def saveImage(self, path):
-        CG.CGContextEndPage(self.context)
         CG.CGPDFContextClose(self.context)
         with open(path, "wb") as f:
-            f.write(self.data)
+            f.write(self._data)
 
 
 def saveImageAsPNG(image, path):

Lib/blackrenderer/backends/skia.py

@@ -180,56 +180,66 @@ def _unpackColorLine(colorLine):
     return colors, stops
 
 
-class SkiaPixelSurface(Surface):
-    fileExtension = ".png"
-
-    def __init__(self, boundingBox):
+class _SkiaBaseSurface(Surface):
+    @contextmanager
+    def canvas(self, boundingBox):
         x, y, xMax, yMax = boundingBox
         width = xMax - x
         height = yMax - y
-        skCanvas = self._setupSkCanvas(x, y, width, height)
+        skCanvas, surfaceData = self._setupSkCanvas(x, y, width, height)
         skCanvas.translate(-x, height + y)
         skCanvas.scale(1, -1)
-        self._canvas = SkiaCanvas(skCanvas)
+        yield SkiaCanvas(skCanvas)
+        self._finalizeCanvas(surfaceData)
+
+
+class SkiaPixelSurface(_SkiaBaseSurface):
+    fileExtension = ".png"
+
+    def __init__(self):
+        self._image = None
 
     def _setupSkCanvas(self, x, y, width, height):
-        self.surface = skia.Surface(width, height)
-        return self.surface.getCanvas()
+        surface = skia.Surface(width, height)
+        return surface.getCanvas(), surface
 
-    @property
-    def canvas(self):
-        return self._canvas
+    def _finalizeCanvas(self, surface):
+        self._image = surface.makeImageSnapshot()
 
     def saveImage(self, path, format=skia.kPNG):
-        image = self.surface.makeImageSnapshot()
-        image.save(os.fspath(path), format)
+        self._image.save(os.fspath(path), format)
 
 
-class SkiaPDFSurface(SkiaPixelSurface):
+class SkiaPDFSurface(_SkiaBaseSurface):
     fileExtension = ".pdf"
 
+    def __init__(self):
+        self._pictures = []
+
     def _setupSkCanvas(self, x, y, width, height):
-        self.recorder = skia.PictureRecorder()
-        return self.recorder.beginRecording(width, height)
+        recorder = skia.PictureRecorder()
+        return recorder.beginRecording(width, height), recorder
+
+    def _finalizeCanvas(self, recorder):
+        self._pictures.append(recorder.finishRecordingAsPicture())
 
     def saveImage(self, path):
         stream = skia.FILEWStream(os.fspath(path))
-        picture = self.recorder.finishRecordingAsPicture()
-        self._drawPictureToStream(picture, stream)
-
-    def _drawPictureToStream(self, picture, stream):
         with skia.PDF.MakeDocument(stream) as document:
-            x, y, width, height = picture.cullRect()
-            assert x == 0 and y == 0
-            with document.page(width, height) as canvas:
-                canvas.drawPicture(picture)
+            for picture in self._pictures:
+                x, y, width, height = picture.cullRect()
+                assert x == 0 and y == 0
+                with document.page(width, height) as canvas:
+                    canvas.drawPicture(picture)
         stream.flush()
 
 
 class SkiaSVGSurface(SkiaPDFSurface):
     fileExtension = ".svg"
 
-    def _drawPictureToStream(self, picture, stream):
+    def saveImage(self, path):
+        stream = skia.FILEWStream(os.fspath(path))
+        picture = self._pictures[-1]
         canvas = skia.SVGCanvas.Make(picture.cullRect(), stream)
         canvas.drawPicture(picture)
         del canvas  # hand holding skia-python with GC: it needs to go before stream

Lib/blackrenderer/backends/svg.py

@@ -219,74 +219,73 @@ def _gradientToSVG(
 class SVGSurface(Surface):
     fileExtension = ".svg"
 
-    def __init__(self, boundingBox):
+    def __init__(self):
+        self._svgElements = None
+
+    @contextmanager
+    def canvas(self, boundingBox):
         x, y, xMax, yMax = boundingBox
         width = xMax - x
         height = yMax - y
-        self.viewBox = x, y, width, height
+        self._viewBox = x, y, width, height
         transform = Transform(1, 0, 0, -1, 0, height + 2 * y)
-        self._canvas = SVGCanvas(transform)
+        canvas = SVGCanvas(transform)
+        yield canvas
+        self._svgElements = canvas.elements
+
+    def saveImage(self, path):
+        with open(path, "wb") as f:
+            writeSVGElements(self._svgElements, self._viewBox, f)
+
+
+def writeSVGElements(elements, viewBox, stream):
+    clipPaths = {}
+    gradients = {}
+    for fillPath, fillT, clipPath, clipT, paint, paintT in elements:
+        clipKey = clipPath, clipT
+        if clipPath is not None and clipKey not in clipPaths:
+            clipPaths[clipKey] = f"clip_{len(clipPaths)}"
+        gradientKey = paint, paintT
+        if not isinstance(paint, RGBAPaint) and gradientKey not in gradients:
+            gradients[gradientKey] = f"gradient_{len(gradients)}"
+
+    root = ET.Element(
+        "svg",
+        width=formatNumber(viewBox[2]),
+        height=formatNumber(viewBox[3]),
+        preserveAspectRatio="xMinYMin slice",
+        viewBox=" ".join(formatNumber(n) for n in viewBox),
+        version="1.1",
+        xmlns="http://www.w3.org/2000/svg",
+    )
 
-    @property
-    def canvas(self):
-        return self._canvas
+    # root.attrib["xmlns:link"] = "http://www.w3.org/1999/xlink"
 
-    def saveImage(self, pathOrFile):
-        if hasattr(pathOrFile, "write"):
-            self.writeSVG(pathOrFile)
-        else:
-            with open(pathOrFile, "wb") as f:
-                self.writeSVG(f)
-
-    def writeSVG(self, stream):
-        elements = self.canvas.elements
-        clipPaths = {}
-        gradients = {}
-        for fillPath, fillT, clipPath, clipT, paint, paintT in elements:
-            clipKey = clipPath, clipT
-            if clipPath is not None and clipKey not in clipPaths:
-                clipPaths[clipKey] = f"clip_{len(clipPaths)}"
-            gradientKey = paint, paintT
-            if not isinstance(paint, RGBAPaint) and gradientKey not in gradients:
-                gradients[gradientKey] = f"gradient_{len(gradients)}"
-
-        root = ET.Element(
-            "svg",
-            width=formatNumber(self.viewBox[2]),
-            height=formatNumber(self.viewBox[3]),
-            preserveAspectRatio="xMinYMin slice",
-            viewBox=" ".join(formatNumber(n) for n in self.viewBox),
-            version="1.1",
-            xmlns="http://www.w3.org/2000/svg",
+    if gradients:
+        defs = ET.SubElement(root, "defs")
+        for (gradient, gradientTransform), gradientID in gradients.items():
+            defs.append(gradient.toSVG(gradientID, gradientTransform))
+
+    for (clipPath, clipTransform), clipID in clipPaths.items():
+        clipElement = ET.SubElement(root, "clipPath", id=clipID)
+        ET.SubElement(
+            clipElement, "path", d=clipPath, transform=formatMatrix(clipTransform)
         )
 
-        # root.attrib["xmlns:link"] = "http://www.w3.org/1999/xlink"
-
-        if gradients:
-            defs = ET.SubElement(root, "defs")
-            for (gradient, gradientTransform), gradientID in gradients.items():
-                defs.append(gradient.toSVG(gradientID, gradientTransform))
-
-        for (clipPath, clipTransform), clipID in clipPaths.items():
-            clipElement = ET.SubElement(root, "clipPath", id=clipID)
-            ET.SubElement(
-                clipElement, "path", d=clipPath, transform=formatMatrix(clipTransform)
-            )
-
-        for fillPath, fillT, clipPath, clipT, paint, paintT in elements:
-            attrs = [("d", fillPath)]
-            if isinstance(paint, RGBAPaint):
-                attrs += colorToSVGAttrs(paint)
-            else:
-                attrs.append(("fill", f"url(#{gradients[paint, paintT]})"))
-            attrs.append(("transform", formatMatrix(fillT)))
-            if clipPath is not None:
-                clipKey = clipPath, clipTransform
-                attrs.append(("clip-path", f"url(#{clipPaths[clipKey]})"))
-            ET.SubElement(root, "path", dict(attrs))
-
-        tree = ET.ElementTree(root)
-        tree.write(stream, pretty_print=True, xml_declaration=True)
+    for fillPath, fillT, clipPath, clipT, paint, paintT in elements:
+        attrs = [("d", fillPath)]
+        if isinstance(paint, RGBAPaint):
+            attrs += colorToSVGAttrs(paint)
+        else:
+            attrs.append(("fill", f"url(#{gradients[paint, paintT]})"))
+        attrs.append(("transform", formatMatrix(fillT)))
+        if clipPath is not None:
+            clipKey = clipPath, clipTransform
+            attrs.append(("clip-path", f"url(#{clipPaths[clipKey]})"))
+        ET.SubElement(root, "path", dict(attrs))
+
+    tree = ET.ElementTree(root)
+    tree.write(stream, pretty_print=True, xml_declaration=True)
 
 
 def formatCoord(pt):