Spaces:
Build error
Build error
| from __future__ import annotations | |
| from urllib.parse import quote | |
| from xml.etree import ElementTree as ET | |
| from .fonts import font_data_uri, get_face | |
| from .models import ( | |
| BitmapRegion, | |
| DocumentSpec, | |
| EllipseGeometry, | |
| LinearGradientPaint, | |
| PathGeometry, | |
| PolygonGeometry, | |
| RectGeometry, | |
| ShapeRegion, | |
| SolidPaint, | |
| TextRegion, | |
| ) | |
| SVG_NS = "http://www.w3.org/2000/svg" | |
| XLINK_NS = "http://www.w3.org/1999/xlink" | |
| ET.register_namespace("", SVG_NS) | |
| ET.register_namespace("xlink", XLINK_NS) | |
| def build_svg( | |
| document: DocumentSpec, | |
| background_href: str | None = None, | |
| background_fallback_href: str | None = None, | |
| embed_fonts: bool = False, | |
| bitmap_hrefs: dict[str, tuple[str, str]] | None = None, | |
| ) -> str: | |
| root = ET.Element( | |
| f"{{{SVG_NS}}}svg", | |
| { | |
| "width": str(document.canvas.width), | |
| "height": str(document.canvas.height), | |
| "viewBox": f"0 0 {document.canvas.width} {document.canvas.height}", | |
| "version": "1.1", | |
| }, | |
| ) | |
| bitmap_hrefs = bitmap_hrefs or {} | |
| needs_markers = any( | |
| isinstance(shape.geometry, PathGeometry) | |
| and (shape.geometry.arrow_start or shape.geometry.arrow_end) | |
| for shape in document.shapes | |
| ) | |
| if embed_fonts or document.shapes or needs_markers: | |
| definitions = ET.SubElement(root, f"{{{SVG_NS}}}defs") | |
| else: | |
| definitions = None | |
| if embed_fonts: | |
| used = { | |
| (region.style.font_family, region.style.font_weight, region.style.italic) | |
| for region in document.regions | |
| if region.include_overlay and region.text | |
| } | |
| assert definitions is not None | |
| style = ET.SubElement(definitions, f"{{{SVG_NS}}}style", {"type": "text/css"}) | |
| style.text = "\n" + "\n".join(font_rule(*item) for item in sorted(used)) + "\n" | |
| if definitions is not None: | |
| for shape in document.shapes: | |
| if isinstance(shape.style.fill, LinearGradientPaint): | |
| definitions.append(gradient_element(shape)) | |
| if needs_markers: | |
| add_arrow_marker(definitions) | |
| if background_href: | |
| relative_href = encoded_image_href(background_href) | |
| fallback_href = encoded_image_href(background_fallback_href or background_href) | |
| ET.SubElement( | |
| root, | |
| f"{{{SVG_NS}}}image", | |
| { | |
| "id": "cleared-background", | |
| "href": relative_href, | |
| f"{{{XLINK_NS}}}href": fallback_href, | |
| "x": "0", | |
| "y": "0", | |
| "width": str(document.canvas.width), | |
| "height": str(document.canvas.height), | |
| "preserveAspectRatio": "none", | |
| }, | |
| ) | |
| layer = ET.SubElement(root, f"{{{SVG_NS}}}g", {"id": "editable-content"}) | |
| content: list[tuple[int, str, ET.Element]] = [] | |
| for shape in document.shapes: | |
| if shape.include_overlay: | |
| content.append((shape.z_index, shape.id, shape_element(shape))) | |
| for bitmap in document.bitmap_regions: | |
| hrefs = bitmap_hrefs.get(bitmap.id) | |
| if hrefs: | |
| content.append((bitmap.z_index, bitmap.id, bitmap_element(bitmap, *hrefs))) | |
| for _, _, element in sorted(content, key=lambda item: (item[0], item[1])): | |
| layer.append(element) | |
| text_layer = ET.SubElement(root, f"{{{SVG_NS}}}g", {"id": "editable-text"}) | |
| for region in sorted(document.regions, key=lambda item: (item.z_index, item.id)): | |
| if region.include_overlay and region.text: | |
| text_layer.append(text_element(region)) | |
| return ET.tostring(root, encoding="unicode", xml_declaration=True) | |
| def gradient_element(shape: ShapeRegion) -> ET.Element: | |
| paint = shape.style.fill | |
| assert isinstance(paint, LinearGradientPaint) | |
| import math | |
| radians = math.radians(paint.angle) | |
| dx, dy = math.cos(radians) * 50, math.sin(radians) * 50 | |
| gradient = ET.Element( | |
| f"{{{SVG_NS}}}linearGradient", | |
| { | |
| "id": f"gradient-{shape.id}", | |
| "x1": f"{compact(50 - dx)}%", | |
| "y1": f"{compact(50 - dy)}%", | |
| "x2": f"{compact(50 + dx)}%", | |
| "y2": f"{compact(50 + dy)}%", | |
| }, | |
| ) | |
| for stop in paint.stops: | |
| ET.SubElement( | |
| gradient, | |
| f"{{{SVG_NS}}}stop", | |
| { | |
| "offset": f"{compact(stop.offset * 100)}%", | |
| "stop-color": stop.color, | |
| "stop-opacity": compact(stop.opacity), | |
| }, | |
| ) | |
| return gradient | |
| def add_arrow_marker(definitions: ET.Element) -> None: | |
| marker = ET.SubElement( | |
| definitions, | |
| f"{{{SVG_NS}}}marker", | |
| { | |
| "id": "editable-arrow", | |
| "viewBox": "0 0 10 10", | |
| "refX": "9", | |
| "refY": "5", | |
| "markerWidth": "6", | |
| "markerHeight": "6", | |
| "orient": "auto-start-reverse", | |
| }, | |
| ) | |
| ET.SubElement(marker, f"{{{SVG_NS}}}path", {"d": "M 0 0 L 10 5 L 0 10 z", "fill": "context-stroke"}) | |
| def shape_element(shape: ShapeRegion) -> ET.Element: | |
| geometry = shape.geometry | |
| style = shape.style | |
| fill = ( | |
| style.fill.color | |
| if isinstance(style.fill, SolidPaint) | |
| else f"url(#gradient-{shape.id})" | |
| ) | |
| attributes = { | |
| "id": shape.id, | |
| "data-role": shape.semantic_role, | |
| "fill": fill, | |
| "fill-opacity": compact(style.fill_opacity), | |
| "stroke": style.stroke, | |
| "stroke-width": compact(style.stroke_width), | |
| "stroke-opacity": compact(style.stroke_opacity), | |
| "stroke-linecap": style.linecap, | |
| "stroke-linejoin": style.linejoin, | |
| "data-confidence": compact(shape.confidence), | |
| "data-source-contours": " | ".join( | |
| " ".join(f"{compact(point.x)},{compact(point.y)}" for point in contour) | |
| for contour in shape.source_contours | |
| ), | |
| } | |
| if isinstance(geometry, RectGeometry): | |
| box = geometry.box | |
| attributes.update( | |
| { | |
| "x": compact(box.x), | |
| "y": compact(box.y), | |
| "width": compact(box.width), | |
| "height": compact(box.height), | |
| "rx": compact(geometry.rx), | |
| "ry": compact(geometry.ry), | |
| } | |
| ) | |
| if abs(geometry.rotation) > 0.01: | |
| cx, cy = box.x + box.width / 2, box.y + box.height / 2 | |
| attributes["transform"] = f"rotate({compact(geometry.rotation)} {compact(cx)} {compact(cy)})" | |
| return ET.Element(f"{{{SVG_NS}}}rect", attributes) | |
| if isinstance(geometry, EllipseGeometry): | |
| attributes.update( | |
| { | |
| "cx": compact(geometry.cx), | |
| "cy": compact(geometry.cy), | |
| "rx": compact(geometry.rx), | |
| "ry": compact(geometry.ry), | |
| } | |
| ) | |
| if abs(geometry.rotation) > 0.01: | |
| attributes["transform"] = ( | |
| f"rotate({compact(geometry.rotation)} {compact(geometry.cx)} {compact(geometry.cy)})" | |
| ) | |
| return ET.Element(f"{{{SVG_NS}}}ellipse", attributes) | |
| if isinstance(geometry, PolygonGeometry): | |
| attributes["points"] = " ".join( | |
| f"{compact(point.x)},{compact(point.y)}" for point in geometry.points | |
| ) | |
| return ET.Element(f"{{{SVG_NS}}}polygon", attributes) | |
| assert isinstance(geometry, PathGeometry) | |
| attributes["d"] = path_data(geometry) | |
| if geometry.arrow_start: | |
| attributes["marker-start"] = "url(#editable-arrow)" | |
| if geometry.arrow_end: | |
| attributes["marker-end"] = "url(#editable-arrow)" | |
| if not geometry.closed and fill != "none": | |
| attributes["fill"] = "none" | |
| return ET.Element(f"{{{SVG_NS}}}path", attributes) | |
| def path_data(geometry: PathGeometry) -> str: | |
| points = geometry.points | |
| if not geometry.smooth or len(points) < 3: | |
| output = f"M {compact(points[0].x)} {compact(points[0].y)}" | |
| output += "".join(f" L {compact(point.x)} {compact(point.y)}" for point in points[1:]) | |
| else: | |
| output = f"M {compact(points[0].x)} {compact(points[0].y)}" | |
| for current, following in zip(points[1:-1], points[2:]): | |
| midpoint_x = (current.x + following.x) / 2 | |
| midpoint_y = (current.y + following.y) / 2 | |
| output += ( | |
| f" Q {compact(current.x)} {compact(current.y)}" | |
| f" {compact(midpoint_x)} {compact(midpoint_y)}" | |
| ) | |
| output += f" T {compact(points[-1].x)} {compact(points[-1].y)}" | |
| if geometry.closed: | |
| output += " Z" | |
| return output | |
| def bitmap_element(bitmap: BitmapRegion, href: str, fallback_href: str) -> ET.Element: | |
| box = bitmap.box | |
| return ET.Element( | |
| f"{{{SVG_NS}}}image", | |
| { | |
| "id": bitmap.id, | |
| "href": encoded_image_href(href), | |
| "x": compact(box.x), | |
| "y": compact(box.y), | |
| "width": compact(box.width), | |
| "height": compact(box.height), | |
| "opacity": compact(bitmap.opacity), | |
| "preserveAspectRatio": "none", | |
| }, | |
| ) | |
| def font_rule(family: str, weight: int, italic: bool) -> str: | |
| face = get_face(family, weight, italic) | |
| style = "italic" if italic else "normal" | |
| return ( | |
| f"@font-face {{font-family:'{face.family}';font-style:{style};" | |
| f"font-weight:{face.weight};src:url('{font_data_uri(face.filename)}') format('woff2');}}" | |
| ) | |
| def text_element(region: TextRegion) -> ET.Element: | |
| box = region.overlay_box | |
| style = region.style | |
| anchor_x = { | |
| "start": box.x, | |
| "middle": box.x + box.width / 2, | |
| "end": box.x + box.width, | |
| }[style.anchor] | |
| baseline = box.y + box.height * 0.82 | |
| attributes = { | |
| "id": region.id, | |
| "x": compact(anchor_x), | |
| "y": compact(baseline), | |
| "font-family": style.font_family, | |
| "font-size": compact(style.font_size), | |
| "font-weight": str(style.font_weight), | |
| "font-style": "italic" if style.italic else "normal", | |
| "fill": style.fill, | |
| "fill-opacity": compact(style.opacity), | |
| "stroke": style.stroke, | |
| "stroke-width": compact(style.stroke_width), | |
| "letter-spacing": compact(style.letter_spacing), | |
| "text-anchor": style.anchor, | |
| "data-confidence": compact(region.confidence), | |
| "data-source-quad": " ".join(f"{compact(p.x)},{compact(p.y)}" for p in region.source_quad), | |
| } | |
| if abs(region.rotation) > 0.01: | |
| attributes["transform"] = f"rotate({compact(region.rotation)} {compact(anchor_x)} {compact(baseline)})" | |
| element = ET.Element(f"{{{SVG_NS}}}text", attributes) | |
| element.text = region.text | |
| return element | |
| def encoded_image_href(href: str) -> str: | |
| if href.startswith("data:image/png;base64,"): | |
| return href | |
| return quote(href, safe="/:%-._~") | |
| def compact(value: float) -> str: | |
| return f"{value:.3f}".rstrip("0").rstrip(".") | |