floorplan-scene 0.1.0__py3-none-any.whl

floorplan_scene/svg.py

@@ -0,0 +1,978 @@
+"""Compact semantic SVG translated from the editable Scene geometry."""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+import xml.etree.ElementTree as ET
+from typing import Any, cast
+
+from defusedxml.common import DefusedXmlException  # type: ignore[import-untyped]
+from defusedxml.ElementTree import fromstring  # type: ignore[import-untyped]
+from shapely.geometry import LineString  # type: ignore[import-untyped]
+from svg.path import Arc, Close, CubicBezier, Move, QuadraticBezier, parse_path
+from svg.path import Line as SvgLine
+
+from .model import (
+    BayWindowParameters,
+    Building,
+    DimensionAnnotation,
+    FloorOpening,
+    FloorplanScene,
+    Furniture,
+    FurniturePlacement,
+    InspectionHatchParameters,
+    Opening,
+    OpeningSegment,
+    Room,
+    Separator,
+    Wall,
+    Zone,
+    read_json,
+    scene_from_dict,
+    scene_to_dict,
+)
+from .presentation import PAINT, FurniturePresentation, ScenePresentation, SvgDecoration
+from .shape_geometry import geometry_shape, object_shape
+from .shapes import (
+    ArcGeometry,
+    BayWindowGeometry,
+    CircleGeometry,
+    Curve,
+    CurveRing,
+    Geometry,
+    LineGeometry,
+    PathGeometry,
+    PipeGeometry,
+    Point,
+    PolygonGeometry,
+    QuadraticGeometry,
+    Ring,
+)
+
+NS = "http://www.w3.org/2000/svg"
+BAY_FIELDS = {"beamThickness": "beam-thickness", "upperFloorThickness": "upper-floor-thickness",
+              "lowerFloorThickness": "lower-floor-thickness", "wallThickness": "wall-thickness",
+              "offset": "offset", "windowHeight": "window-height", "platformType": "platform-type"}
+# data-* carries inert metadata; only the fields consumed below affect the Scene.
+ATTRIBUTES = {
+    "svg": {"viewBox"},
+    "metadata": set(),
+    "g": {"id", "transform"} | PAINT,
+    "line": {"id", "x1", "y1", "x2", "y2"} | PAINT,
+    "path": {"id", "d"} | PAINT,
+    "polygon": {"id", "points"} | PAINT,
+    "polyline": {"points"} | PAINT,
+    "circle": {"id", "cx", "cy", "r"} | PAINT,
+}
+CURVES = (LineGeometry, ArcGeometry, QuadraticGeometry)
+
+
+def _number(value: float) -> str:
+    number = float(value)
+    if not number:
+        return "0"
+    return str(int(number)) if number.is_integer() else repr(number)
+
+
+def _area(value: float) -> str:
+    return f"{value:.2f}"
+
+
+def _point_text(point: Point) -> str:
+    return f"{_number(point[0])},{_number(point[1])}"
+
+
+def _path(rings: tuple[Ring, ...]) -> str:
+    return " ".join("M " + " L ".join(_point_text(point) for point in ring[:-1]) + " Z" for ring in rings)
+
+
+def _curve_command(curve: Curve) -> str:
+    if isinstance(curve, LineGeometry):
+        return "L " + _point_text(curve.end)
+    if isinstance(curve, QuadraticGeometry):
+        return "Q " + _point_text(curve.control) + " " + _point_text(curve.end)
+    if curve.bulge == 0:
+        return "A 0,0 0 0,0 " + _point_text(curve.end)
+    chord = math.dist(curve.start, curve.end)
+    radius = chord * (1 + curve.bulge ** 2) / (4 * abs(curve.bulge))
+    return (f"A {_number(radius)},{_number(radius)} 0 {int(abs(curve.bulge) > 1)},"
+            f"{int(curve.bulge > 0)} " + _point_text(curve.end))
+
+
+def _curve_path(rings: tuple[CurveRing, ...]) -> str:
+    return " ".join("M " + _point_text(ring[0].start) + " "
+                    + " ".join(_curve_command(curve) for curve in ring) + " Z" for ring in rings)
+
+
+def _curve_node(parent: ET.Element, curve: Curve, attrs: dict[str, str]) -> ET.Element:
+    if isinstance(curve, LineGeometry):
+        return ET.SubElement(parent, "line", {"x1": _number(curve.start[0]), "y1": _number(curve.start[1]),
+                             "x2": _number(curve.end[0]), "y2": _number(curve.end[1]), **attrs})
+    return ET.SubElement(parent, "path", {"d": "M " + _point_text(curve.start) + " " + _curve_command(curve),
+                                         "fill": "none", **attrs})
+
+
+def _polygon_nodes(parent: ET.Element, geometry: PolygonGeometry) -> None:
+    for rings in geometry.polygons:
+        if len(rings) == 1:
+            ET.SubElement(parent, "polygon", {"points": " ".join(_point_text(p) for p in rings[0][:-1])})
+        else:
+            ET.SubElement(parent, "path", {"d": _path(rings), "fill-rule": "evenodd"})
+
+
+def _geometry_nodes(
+    parent: ET.Element,
+    geometry: Geometry,
+    *,
+    thickness: float | None = None,
+) -> None:
+    if isinstance(geometry, CURVES):
+        _curve_node(parent, geometry, {"stroke-width": _number(thickness or 10), "stroke-linecap": "butt"})
+    elif isinstance(geometry, PolygonGeometry):
+        _polygon_nodes(parent, geometry)
+    elif isinstance(geometry, PathGeometry):
+        for rings in geometry.polygons:
+            ET.SubElement(parent, "path", {"d": _curve_path(rings), "fill-rule": "evenodd"})
+    elif isinstance(geometry, CircleGeometry):
+        ET.SubElement(parent, "circle", {"cx": _number(geometry.center[0]), "cy": _number(geometry.center[1]),
+                                         "r": _number(geometry.radius)})
+    elif isinstance(geometry, PipeGeometry):
+        parent.attrib.update({"data-center": _point_text(geometry.center),
+                              "data-width": _number(geometry.width),
+                              "data-depth": _number(geometry.depth), "data-angle": _number(geometry.angle),
+                              "data-profile": geometry.profile})
+        for index, value in enumerate(geometry.wallThickness, 1):
+            parent.set(f"data-wall-thickness-{index}", _number(value))
+        shape = geometry_shape(geometry)
+        polygons = [shape] if shape.geom_type == "Polygon" else list(shape.geoms)
+        _polygon_nodes(parent, PolygonGeometry(tuple(tuple(tuple((float(x), float(y)) for x, y in ring.coords)
+                        for ring in (poly.exterior, *poly.interiors)) for poly in polygons)))
+    elif isinstance(geometry, BayWindowGeometry):
+        parent.set("data-profile", geometry.profile)
+        ET.SubElement(parent, "polygon", {"data-part": "outline",
+                      "points": " ".join(_point_text(p) for p in geometry.outline[:-1])})
+        ET.SubElement(parent, "polyline", {"data-part": "wall-path",
+                      "points": " ".join(_point_text(p) for p in geometry.wallPath),
+                      "fill": "none", "stroke-width": "10", "stroke-linecap": "butt"})
+
+
+def _geometry_entity(
+    parent: ET.Element,
+    geometry: Geometry,
+    attrs: dict[str, str],
+    *,
+    thickness: float | None = None,
+) -> ET.Element:
+    node = ET.SubElement(parent, "g", attrs)
+    if isinstance(geometry, (PathGeometry, PipeGeometry, BayWindowGeometry)) or (
+        isinstance(geometry, PolygonGeometry)
+        and (len(geometry.polygons) != 1 or len(geometry.polygons[0]) != 1)
+    ):
+        node.set("data-shape", geometry.type.replace("bay_window", "bayWindow"))
+    _geometry_nodes(node, geometry, thickness=thickness)
+    return node
+
+
+def _attribute_name(name: str) -> str:
+    return "data-" + re.sub(r"([A-Z])", r"-\1", name).lower()
+
+
+def _optional(node: ET.Element, obj: Any, names: tuple[str, ...]) -> None:
+    for name in names:
+        value = getattr(obj, name)
+        if value is not None:
+            node.set(_attribute_name(name), str(value).lower() if isinstance(value, bool) else
+                     _number(value) if isinstance(value, (int, float)) else str(value))
+
+
+def opening_width(opening: Opening, host: Wall | None) -> float:
+    if opening.kind == "niche":
+        return 10 if opening.depth is None else opening.depth
+    return (host.thickness or 100) if host else 100
+
+
+def scene_to_svg(scene: FloorplanScene) -> str:
+    """Export visible geometry with collection defaults inherited from semantic layers."""
+    scene = scene_from_dict(scene_to_dict(scene))
+    shapes = [geometry_shape(wall.geometry, wall.thickness) for wall in scene.walls]
+    shapes += [geometry_shape(item.geometry, item.thickness) for item in scene.buildings]
+    shapes += [geometry_shape(item.geometry) for item in scene.floorOpenings]
+    shapes += [object_shape(item) for item in scene.furniture]
+    shapes += [geometry_shape(zone.geometry) for zone in scene.zones]
+    shapes += [geometry_shape(separator.geometry) for separator in scene.separators]
+    shapes += [geometry_shape(room.geometry) for room in scene.rooms]
+    shapes += [geometry_shape(segment.geometry) for opening in scene.openings for segment in opening.segments]
+    points = [point for shape in shapes if not shape.is_empty for point in
+              ((shape.bounds[0], shape.bounds[1]), (shape.bounds[2], shape.bounds[3]))]
+    points += [point for item in scene.dimensionAnnotations
+               for point in (item.geometry.start, item.geometry.end)]
+    if not points:
+        raise ValueError("cannot render an empty scene")
+    xs, ys = zip(*points)
+    padding = max([200.0, *(wall.thickness or 0 for wall in scene.walls)])
+    if scene.presentation is not None:
+        viewbox = scene.presentation.viewBox
+    elif scene.metadata is None or scene.metadata.originImage is None:
+        viewbox = (min(xs) - padding, -max(ys) - padding,
+                   max(xs) - min(xs) + 2 * padding, max(ys) - min(ys) + 2 * padding)
+    else:
+        x, y, width, height = scene.metadata.originImage.sceneBounds
+        viewbox = x, -y - height, width, height
+    root = ET.Element("svg", {"xmlns": NS, "data-length-unit": scene.unit, "data-area-unit": "m2",
+        "data-angle-unit": "deg",
+        "viewBox": " ".join(_number(v) for v in viewbox)})
+    _optional(root, scene, ("height",))
+    if scene.metadata is not None:
+        metadata = ET.SubElement(root, "metadata")
+        metadata.text = json.dumps(scene_to_dict(scene)["metadata"], ensure_ascii=False,
+                                   separators=(",", ":"), sort_keys=True)
+    world = ET.SubElement(root, "g", {"transform": "scale(1 -1)"})
+
+    if scene.zones:
+        layer = ET.SubElement(world, "g", {"data-layer": "zones"})
+        for zone in scene.zones:
+            attrs = {"id": zone.id}
+            if zone.name is not None:
+                attrs["data-name"] = zone.name
+            _geometry_entity(layer, zone.geometry, attrs)
+
+    if scene.rooms:
+        layer = ET.SubElement(world, "g", {"data-layer": "rooms"})
+        for room in scene.rooms:
+            attrs = {"id": room.id, "data-type": room.type,
+                     "data-label-point": _point_text(room.labelPoint)}
+            if room.roomTypeId is not None:
+                attrs["data-room-type-id"] = str(room.roomTypeId)
+            if room.name is not None:
+                attrs["data-name"] = room.name
+            if room.area is not None:
+                attrs["data-area"] = _area(room.area)
+            _geometry_entity(layer, room.geometry, attrs)
+
+    if scene.floorOpenings:
+        layer = ET.SubElement(world, "g", {"data-layer": "floorOpenings"})
+        for floor_opening in scene.floorOpenings:
+            node = _geometry_entity(layer, floor_opening.geometry, {"id": floor_opening.id})
+            _optional(node, floor_opening, ("name", "bottomElevation", "thickness"))
+
+    def add_object(parent: ET.Element, item: Building | Furniture) -> None:
+        attrs = {"id": item.id, "data-type": item.type}
+        if isinstance(item, Furniture):
+            center_x, center_y = item.placement.center
+            attrs.update({
+                "data-width": _number(item.placement.width),
+                "data-depth": _number(item.placement.depth),
+                "transform": (
+                    f"translate({_number(center_x)} {_number(center_y)}) "
+                    f"rotate({_number(item.placement.rotation)})"
+                ),
+            })
+        if isinstance(item, Furniture):
+            if item.shape is not None:
+                attrs["data-legend-shape"] = item.shape
+            for field in ("upStairDirections", "path", "attributes"):
+                value = getattr(item, field)
+                if value is not None:
+                    attrs[_attribute_name(field)] = json.dumps(value, ensure_ascii=False, allow_nan=False,
+                                                               separators=(",", ":"))
+        node = _geometry_entity(parent, item.geometry, attrs, thickness=item.thickness)
+        if isinstance(item, Furniture) and item.presentation is not None:
+            if len(node) == 1:
+                footprint = node[0]
+            else:
+                # A compound physical footprint is still one object, not decoration fragments.
+                footprint = ET.Element("g", {"data-shape": "polygon"})
+                for child in list(node):
+                    node.remove(child)
+                    footprint.append(child)
+                node.append(footprint)
+            footprint.set("data-role", "footprint")
+            footprint.attrib.update(item.presentation.footprintStyle)
+            node.remove(footprint)
+            for decoration in item.presentation.decorations:
+                ET.SubElement(node, decoration.tag, {**decoration.attributes, "data-role": "decoration"})
+            node.insert(item.presentation.footprintIndex, footprint)
+        if isinstance(item.geometry, CURVES):
+            node.set("data-thickness", "unknown" if item.thickness is None else _number(item.thickness))
+        else:
+            _optional(node, item, ("thickness",))
+        _optional(node, item, ("height", "name"))
+        if item.bottomElevation is not None:
+            node.set("data-bottom-elevation", _number(item.bottomElevation))
+        if isinstance(item, Building) and item.type == "roof":
+            node[0].set("data-role", "footprint")
+            for field in ("height", "bottomElevation", "thickness"):
+                value = getattr(item, field)
+                node.set(_attribute_name(field), "unknown" if value is None else _number(value))
+            for ridge in item.ridgeLines:
+                _curve_node(node, ridge, {"data-role": "ridge"})
+        if isinstance(item, Building) and item.direction is not None:
+            node.set("data-direction", _point_text(item.direction))
+        if isinstance(item, Building) and item.inspectionHatch is not None:
+            node.set("data-hatch-surface", item.inspectionHatch.surface)
+            if item.inspectionHatch.hasStorage is not None:
+                node.set("data-hatch-storage", str(item.inspectionHatch.hasStorage).lower())
+        if isinstance(item, Building) and item.bayWindow is not None:
+            for field, key in BAY_FIELDS.items():
+                value = getattr(item.bayWindow, field)
+                if value is not None:
+                    node.set("data-bay-" + key,
+                             _number(value) if isinstance(value, (int, float)) else str(value))
+
+    if scene.buildings:
+        layer = ET.SubElement(world, "g", {"data-layer": "buildings"})
+        for building in scene.buildings:
+            add_object(layer, building)
+    if scene.furniture:
+        layer = ET.SubElement(world, "g", {"data-layer": "furniture"})
+        for item in scene.furniture:
+            add_object(layer, item)
+
+    if scene.walls:
+        layer = ET.SubElement(world, "g", {"data-layer": "walls"})
+        for wall in scene.walls:
+            attrs = {"id": wall.id}
+            if wall.loadBearing:
+                attrs["data-load-bearing"] = "true"
+            node = _geometry_entity(layer, wall.geometry, attrs, thickness=wall.thickness)
+            node.set("data-thickness", "unknown" if wall.thickness is None else _number(wall.thickness))
+            if wall.height is None and scene.height is not None:
+                node.set("data-height", "unknown")
+            elif wall.height != scene.height:
+                _optional(node, wall, ("height",))
+
+    if scene.separators:
+        layer = ET.SubElement(world, "g", {"data-layer": "separators"})
+        for separator in scene.separators:
+            _geometry_entity(layer, separator.geometry, {"id": separator.id})
+
+    wall_by_id = {wall.id: wall for wall in scene.walls}
+    if scene.openings:
+        layer = ET.SubElement(world, "g", {"data-layer": "openings"})
+        for opening in scene.openings:
+            attrs = {"id": opening.id}
+            if opening.type is not None:
+                attrs["data-type"] = opening.type
+            holder = ET.SubElement(layer, "g", attrs)
+            _optional(holder, opening, ("height", "depth"))
+            if opening.bottomElevation is not None:
+                holder.set("data-bottom-elevation", _number(opening.bottomElevation))
+            for segment in opening.segments:
+                host = wall_by_id.get(segment.wallId or "")
+                segment_attrs = {"stroke-width": _number(opening_width(opening, host))}
+                if segment.wallId is not None:
+                    segment_attrs["data-wall-id"] = segment.wallId
+                node = _curve_node(holder, segment.geometry, segment_attrs)
+                _optional(node, segment, ("openSide", "outside"))
+    if scene.dimensionAnnotations:
+        layer = ET.SubElement(world, "g", {"data-layer": "dimensions"})
+        for dimension in scene.dimensionAnnotations:
+            attrs = {
+                "id": dimension.id,
+                "data-kind": dimension.kind,
+                "data-value": str(dimension.value),
+            }
+            if dimension.refId is not None:
+                attrs["data-ref-id"] = dimension.refId
+            holder = ET.SubElement(layer, "g", attrs)
+            _curve_node(holder, dimension.geometry, {"data-role": "measurement-span"})
+    entity_nodes = {node.get("id"): node for layer in world for node in layer}
+    for collection in ("rooms", "walls", "separators", "openings", "floorOpenings", "buildings",
+                       "furniture", "zones", "dimensionAnnotations"):
+        for item in getattr(scene, collection):
+            if item.attributes is not None:
+                entity_nodes[item.id].set("data-attributes", json.dumps(
+                    item.attributes, ensure_ascii=False, allow_nan=False, separators=(",", ":")))
+    return ET.tostring(root, encoding="unicode") + "\n"
+
+
+def _finite(text: str | None, *, bounded: bool = True) -> float:
+    value = float(text or "nan")
+    if not math.isfinite(value) or bounded and abs(value) > 1_000_000:
+        raise ValueError("SVG coordinates must be finite millimetres within 1 km")
+    return value
+
+
+def _tag(node: ET.Element) -> str:
+    return node.tag.removeprefix("{" + NS + "}")
+
+
+def _point(value: complex) -> Point:
+    return _finite(str(value.real)), _finite(str(value.imag))
+
+
+def _points(node: ET.Element) -> tuple[Point, ...]:
+    values = [_finite(token) for token in re.split(r"[\s,]+", node.attrib["points"].strip())]
+    if len(values) % 2:
+        raise ValueError("points require coordinate pairs")
+    return tuple((values[i], values[i + 1]) for i in range(0, len(values), 2))
+
+
+def _read_path(node: ET.Element, *, closed: bool) -> tuple[CurveRing, ...]:
+    if closed and (node.get("fill") == "none" or "stroke" in node.attrib or "stroke-width" in node.attrib):
+        raise ValueError("closed geometry must use its filled outline without an extra stroke")
+    rings: list[CurveRing] = []
+    ring: list[Curve] = []
+    start: Point | None = None
+    try:
+        parts = parse_path(node.attrib["d"])
+    except (ValueError, IndexError, KeyError, ZeroDivisionError) as exc:
+        raise ValueError("invalid SVG path") from exc
+    if len(parts) > 10000:
+        raise ValueError("SVG path contains too many segments")
+    for part in parts:
+        end = _point(part.end)
+        if isinstance(part, Move):
+            if start is not None:
+                raise ValueError("path subpaths must close")
+            start = end
+        elif isinstance(part, Close):
+            if not closed or start is None or not ring or end != start:
+                raise ValueError("invalid closed path")
+            if ring[-1].end != start:
+                ring.append(LineGeometry(ring[-1].end, start))
+            rings.append(tuple(ring))
+            ring, start = [], None
+        elif start is None:
+            raise ValueError("path must start with M")
+        elif isinstance(part, SvgLine):
+            ring.append(LineGeometry(_point(part.start), end))
+        elif isinstance(part, QuadraticBezier):
+            ring.append(QuadraticGeometry(_point(part.start), _point(part.control), end))
+        elif isinstance(part, Arc):
+            rx, ry = _finite(str(part.radius.real), bounded=False), _finite(str(part.radius.imag), bounded=False)
+            if rx < 0 or not math.isclose(rx, ry, abs_tol=1e-6) or part.start == part.end:
+                raise ValueError("only non-degenerate circular A arcs are supported")
+            _finite(str(part.rotation))
+            bulge = 0.0
+            if rx:
+                # The half-angle identity avoids acos cancellation for almost-straight arcs.
+                ratio = min(1.0, math.dist(_point(part.start), end) / rx / part.radius_scale / 2)
+                bulge = ratio / (1 + math.sqrt(max(0.0, 1 - ratio * ratio)))
+                if part.arc:
+                    bulge = 1 / bulge
+                if not part.sweep:
+                    bulge = -bulge
+            ring.append(ArcGeometry(_point(part.start), end, bulge))
+        else:
+            raise ValueError("only L, circular A and Q path segments are supported")
+    if closed:
+        if start is not None or not rings:
+            raise ValueError("outline needs closed rings")
+        if len(rings) > 1 and node.get("fill-rule") != "evenodd":
+            raise ValueError("outlines with holes require fill-rule=evenodd")
+    elif start is None or len(ring) != 1:
+        raise ValueError("a boundary curve must contain exactly one L, A or Q segment")
+    else:
+        rings.append(tuple(ring))
+    return tuple(rings)
+
+
+def _rings(node: ET.Element) -> tuple[Ring, ...]:
+    if _tag(node) == "polygon":
+        points = _points(node)
+        if len(points) < 3:
+            raise ValueError("polygon needs at least three coordinate pairs")
+        return (points if points[0] == points[-1] else (*points, points[0]),)
+    if _tag(node) != "path":
+        raise ValueError("outline requires path or polygon")
+    curves = _read_path(node, closed=True)
+    if any(not isinstance(curve, LineGeometry) for ring in curves for curve in ring):
+        raise ValueError("polygon outlines require straight segments")
+    return tuple((ring[0].start, *(curve.end for curve in ring)) for ring in curves)
+
+
+def _read_curve(node: ET.Element) -> Curve:
+    if _tag(node) == "line":
+        return LineGeometry((_finite(node.get("x1")), _finite(node.get("y1"))),
+                            (_finite(node.get("x2")), _finite(node.get("y2"))))
+    if _tag(node) == "path":
+        if node.get("fill") != "none":
+            raise ValueError("open curves require fill=none")
+        return _read_path(node, closed=False)[0][0]
+    raise ValueError("curve requires line or path")
+
+
+def _read_compound_wall_path(node: ET.Element) -> PolygonGeometry:
+    """Preserve a browser-valid compound wall centerline as its deterministic footprint."""
+    if _tag(node) != "g" or len(node) != 1 or _tag(node[0]) != "path" or node[0].get("fill") != "none":
+        raise ValueError("compound wall centerlines require one open path")
+    path = node[0]
+    try:
+        parts = parse_path(path.attrib["d"])
+    except (ValueError, IndexError, KeyError, ZeroDivisionError) as exc:
+        raise ValueError("invalid SVG path") from exc
+    if len(parts) > 10000:
+        raise ValueError("SVG path contains too many segments")
+    points: list[Point] = []
+    started = False
+    sample_total = 0
+    for part in parts:
+        if isinstance(part, Move):
+            if started:
+                raise ValueError("wall paths require one open subpath")
+            points.append(_point(part.end))
+            started = True
+            continue
+        if not started or isinstance(part, Close):
+            raise ValueError("wall paths require one open subpath")
+        if not isinstance(part, (SvgLine, QuadraticBezier, CubicBezier, Arc)):
+            raise TypeError("unsupported wall path segment")
+        for name in ("start", "end", "control", "control1", "control2"):
+            value = getattr(part, name, None)
+            if value is not None:
+                _point(value)
+        if isinstance(part, Arc):
+            _finite(str(part.radius.real), bounded=False)
+            _finite(str(part.radius.imag), bounded=False)
+            _finite(str(part.rotation))
+        samples = 1 if isinstance(part, SvgLine) else 64
+        sample_total += samples
+        if sample_total > 100000:
+            raise ValueError("wall path exceeds projection size limit")
+        points.extend(_point(part.point(index / samples)) for index in range(1, samples + 1))
+    if len(points) < 2:
+        raise ValueError("wall path requires at least one segment")
+    marker = node.get("data-thickness")
+    thickness = _finite(path.get("stroke-width")) if marker in {None, "unknown"} else _finite(marker)
+    if thickness <= 0:
+        raise ValueError("wall thickness must be positive")
+    footprint = LineString(points).buffer(thickness / 2, cap_style="flat", join_style="mitre")
+    if footprint.is_empty or not footprint.is_valid:
+        raise ValueError("wall path does not produce a valid footprint")
+    polygons = [footprint] if footprint.geom_type == "Polygon" else list(footprint.geoms)
+    return PolygonGeometry(tuple(tuple(
+        tuple((_finite(str(x)), _finite(str(y))) for x, y in ring.coords)
+        for ring in (polygon.exterior, *polygon.interiors)
+    ) for polygon in polygons))
+
+
+def _read_wall_geometry(node: ET.Element) -> Geometry:
+    if (
+        node.get("data-shape") == "path"
+        and _tag(node) == "g"
+        and len(node) == 1
+        and _tag(node[0]) == "path"
+        and node[0].get("fill") == "none"
+    ):
+        return _read_compound_wall_path(node)
+    try:
+        return _read_geometry(node)
+    except ValueError as exc:
+        if str(exc) not in {
+            "a boundary curve must contain exactly one L, A or Q segment",
+            "only L, circular A and Q path segments are supported",
+        }:
+            raise
+        return _read_compound_wall_path(node)
+
+
+def _read_geometry(node: ET.Element) -> Geometry:
+    tag = _tag(node)
+    if tag == "line":
+        return _read_curve(node)
+    if tag == "polygon":
+        return PolygonGeometry(((_rings(node)),))
+    if tag == "circle":
+        return CircleGeometry((_finite(node.get("cx")), _finite(node.get("cy"))), _finite(node.get("r")))
+    if tag == "path":
+        if node.get("data-shape") == "path":
+            return PathGeometry((_read_path(node, closed=True),))
+        try:
+            closed = any(isinstance(part, Close) for part in parse_path(node.attrib["d"]))
+        except (ValueError, IndexError, KeyError, ZeroDivisionError) as exc:
+            raise ValueError("invalid SVG path") from exc
+        return PolygonGeometry(((_rings(node)),)) if closed else _read_curve(node)
+    if tag != "g":
+        raise ValueError("unsupported geometry element")
+    kind = node.get("data-shape")
+    if kind is None and len(node) == 1:
+        return _read_geometry(node[0])
+    if kind == "polygon":
+        return PolygonGeometry(tuple(_rings(child) for child in node))
+    if kind == "path":
+        if not len(node) or any(_tag(child) != "path" for child in node):
+            raise ValueError("path geometry requires native paths")
+        return PathGeometry(tuple(_read_path(child, closed=True) for child in node))
+    if kind == "pipe":
+        profile = node.get("data-profile", "")
+        if profile not in {"L", "U", "RECT"}:
+            raise ValueError("unsupported pipe profile")
+        count = {"L": 2, "U": 3, "RECT": 4}[profile]
+        center = node.get("data-center", "").split(",")
+        if len(center) != 2:
+            raise ValueError("pipe center requires x,y")
+        for child in node:
+            _rings(child)
+        if not len(node):
+            raise ValueError("pipe needs a visible outline")
+        return PipeGeometry((_finite(center[0]), _finite(center[1])), _finite(node.get("data-width")),
+                            _finite(node.get("data-depth")), _finite(node.get("data-angle")),
+                            cast(Any, profile),
+                            tuple(_finite(node.get(f"data-wall-thickness-{i}"))
+                                  for i in range(1, count + 1)))
+    if kind == "bayWindow":
+        if len(node) != 2 or _tag(node[0]) != "polygon" or _tag(node[1]) != "polyline" or (
+                node[0].get("data-part"), node[1].get("data-part")) != ("outline", "wall-path"):
+            raise ValueError("bay window needs a polygon outline and open wall-path polyline")
+        wall_path = _points(node[1])
+        if len(wall_path) < 2:
+            raise ValueError("bay window wall path needs at least two points")
+        return BayWindowGeometry(_rings(node[0])[0], wall_path, node.attrib["data-profile"])
+    raise ValueError(f"unsupported geometry type: {kind}")
+
+
+def _entity_id(node: ET.Element) -> str:
+    value = node.get("id", "")
+    if not value.strip():
+        raise ValueError("entities require an id")
+    return value
+
+
+def _thickness(node: ET.Element, geometry: Geometry) -> float | None:
+    marker = node.get("data-thickness")
+    if marker == "unknown":
+        return None
+    if marker is not None:
+        return _finite(marker)
+    if isinstance(geometry, CURVES):
+        return _finite(node.get("stroke-width"))
+    return None
+
+
+def _height(node: ET.Element, default: float | None) -> float | None:
+    value = node.get("data-height")
+    if value is None:
+        return default
+    return None if value == "unknown" else _finite(value)
+
+
+def _room_label_point(node: ET.Element, geometry: Geometry) -> Point:
+    marker = node.get("data-label-point")
+    if marker is None or not marker.strip():
+        point = geometry_shape(geometry).representative_point()
+        if point.is_empty:
+            raise ValueError("room geometry cannot provide a label point")
+        return _finite(str(point.x)), _finite(str(point.y))
+    values = marker.split(",")
+    if len(values) != 2:
+        raise ValueError("data-label-point requires x,y")
+    return _finite(values[0]), _finite(values[1])
+
+
+_SVG_NUMBER = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?"
+_FURNITURE_TRANSFORM = re.compile(
+    rf"^translate\(\s*({_SVG_NUMBER})(?:\s+|\s*,\s*)({_SVG_NUMBER})\s*\)\s+"
+    rf"rotate\(\s*({_SVG_NUMBER})\s*\)$"
+)
+
+
+def _furniture_placement(node: ET.Element) -> FurniturePlacement:
+    match = _FURNITURE_TRANSFORM.fullmatch(node.get("transform", ""))
+    if match is None:
+        raise ValueError("furniture transform must be translate(x y) rotate(angle)")
+    center_x, center_y, rotation = (_finite(value) for value in match.groups())
+    width, depth = _finite(node.get("data-width")), _finite(node.get("data-depth"))
+    if width <= 0 or depth <= 0:
+        raise ValueError("furniture data-width and data-depth must be positive")
+    rotation %= 360
+    return FurniturePlacement((center_x, center_y), width, depth, rotation)
+
+
+def svg_to_scene(text: str, *, scene_id: str = "plan") -> FloorplanScene:
+    """Read native SVG geometry; layer membership supplies repeated entity categories."""
+    if len(text.encode()) > 1_000_000:
+        raise ValueError("SVG exceeds 1 MB")
+    try:
+        root = fromstring(text, forbid_dtd=True, forbid_entities=True, forbid_external=True)
+    except (ET.ParseError, DefusedXmlException) as exc:
+        raise ValueError(f"invalid or unsafe SVG XML: {exc}") from exc
+    if (
+        root.tag != "{" + NS + "}svg"
+        or root.get("data-length-unit") != "mm"
+        or root.get("data-area-unit") != "m2"
+        or root.get("data-angle-unit") != "deg"
+    ):
+        raise ValueError("expected SVG units in millimetres, square metres and degrees")
+    nodes = list(root.iter())
+    if len(nodes) > 10000:
+        raise ValueError("SVG contains too many elements")
+    for node in nodes:
+        tag = _tag(node)
+        if node.tag != "{" + NS + "}" + tag or tag not in ATTRIBUTES:
+            raise ValueError(f"unsupported SVG element: {node.tag}")
+        for key, value in node.attrib.items():
+            if key not in ATTRIBUTES[tag] and not key.startswith("data-"):
+                raise ValueError(f"unsupported SVG attribute: {key}")
+            if key in {"fill", "stroke"} and value != "none" and not re.fullmatch(r"#[0-9a-fA-F]{6}", value):
+                raise ValueError("SVG colours must be none or opaque six-digit hex values")
+            if key == "stroke-linecap" and value != "butt":
+                raise ValueError("lines require stroke-linecap=butt")
+    viewbox = [_finite(token) for token in re.split(r"[\s,]+", root.get("viewBox", "").strip())]
+    if len(viewbox) != 4 or min(viewbox[2:]) <= 0:
+        raise ValueError("viewBox requires x, y and positive width, height")
+    ids = [node.attrib["id"] for node in nodes if "id" in node.attrib]
+    if len(ids) != len(set(ids)):
+        raise ValueError("duplicate SVG IDs")
+
+    scene_height = _finite(root.get("data-height")) if "data-height" in root.attrib else None
+    children = list(root)
+    metadata_payload = None
+    if children and _tag(children[0]) == "metadata":
+        metadata_node = children.pop(0)
+        if len(metadata_node) or not (metadata_node.text or "").strip():
+            raise ValueError("SVG metadata must contain one JSON object")
+        metadata_payload = read_json(metadata_node.text or "")
+    if (len(children) != 1 or _tag(children[0]) != "g"
+            or {key: value for key, value in children[0].attrib.items() if not key.startswith("data-")}
+            != {"transform": "scale(1 -1)"}):
+        raise ValueError("SVG requires optional metadata followed by one fixed world transform: scale(1 -1)")
+    world = children[0]
+    layers: dict[str, ET.Element] = {}
+    known_layers = {
+        "zones", "rooms", "floorOpenings", "buildings", "furniture", "walls", "separators", "openings", "dimensions",
+    }
+    for layer in world:
+        if _tag(layer) != "g" or layer.get("data-layer") not in known_layers:
+            raise ValueError("SVG root may only contain known semantic layers")
+        name = cast(str, layer.get("data-layer"))
+        if name in layers:
+            raise ValueError(f"duplicate SVG layer: {name}")
+        layers[name] = layer
+    furniture_nodes = {id(node) for node in layers.get("furniture", ())}
+    if any("transform" in node.attrib and node is not world and id(node) not in furniture_nodes for node in nodes):
+        raise ValueError("transform is allowed only on the world group and furniture entity groups")
+
+    rooms: list[Room] = []
+    walls: list[Wall] = []
+    separators: list[Separator] = []
+    openings: list[Opening] = []
+    floor_openings: list[FloorOpening] = []
+    buildings: list[Building] = []
+    furniture: list[Furniture] = []
+    zones: list[Zone] = []
+    dimension_annotations: list[DimensionAnnotation] = []
+
+    def furniture_geometry(node: ET.Element) -> Geometry:
+        roles = [child.get("data-role") for child in node]
+        if not any(role is not None for role in roles):
+            return _read_geometry(node)
+        if roles.count("footprint") != 1 or any(role not in {"footprint", "decoration"} for role in roles):
+            raise ValueError("furniture details require one footprint and decoration roles")
+        return _read_geometry(node[roles.index("footprint")])
+
+    def furniture_presentation(node: ET.Element) -> FurniturePresentation | None:
+        # Flatten only explicit inherited paint; geometry/placement stay in the semantic fields.
+        if len(node) > 1 and not any(child.get("data-role") for child in node):
+            # Legacy compound footprints have no per-piece presentation contract.
+            return None
+        inherited = {key: value for parent in (layers["furniture"], node)
+                     for key, value in parent.attrib.items() if key in PAINT}
+        decorations = []
+        footprint_style = {}
+        footprint_index = 0
+        for index, child in enumerate(node):
+            paint = {**inherited, **{key: value for key, value in child.attrib.items() if key in PAINT}}
+            if child.get("data-role") == "decoration":
+                if len(child):
+                    raise ValueError("decoration primitives cannot have children")
+                decorations.append(SvgDecoration(cast(Any, _tag(child)), {
+                    **paint, **{key: value for key, value in child.attrib.items() if key != "id" and not key.startswith("data-")},
+                }))
+            else:
+                footprint_style, footprint_index = paint, index
+        if not decorations and not footprint_style and not any(child.get("data-role") for child in node):
+            return None
+        return FurniturePresentation(tuple(decorations), footprint_style, footprint_index)
+
+    for node in layers.get("rooms", ()):
+        if _tag(node) != "g":
+            raise ValueError("rooms require entity groups")
+        geometry = _read_geometry(node)
+        if not isinstance(geometry, (PolygonGeometry, PathGeometry)) or len(geometry.polygons) != 1:
+            raise TypeError("room geometry must contain one polygon or curved footprint")
+        label_point = _room_label_point(node, geometry)
+        area = _finite(node.get("data-area"), bounded=False) if "data-area" in node.attrib else None
+        rooms.append(
+            Room(
+                _entity_id(node),
+                node.attrib["data-type"],
+                label_point,
+                geometry,
+                node.get("data-name"),
+                area,
+                int(node.attrib["data-room-type-id"]) if "data-room-type-id" in node.attrib else None,
+            )
+        )
+
+    for node in layers.get("zones", ()):
+        geometry = _read_geometry(node)
+        if not isinstance(geometry, PolygonGeometry):
+            raise TypeError("zones require polygon geometry")
+        zones.append(Zone(_entity_id(node), node.get("data-name"), geometry))
+
+    def read_object(node: ET.Element, *, is_furniture: bool) -> None:
+        roof = not is_furniture and node.get("data-type") == "roof"
+        ridges: list[LineGeometry] = []
+        if roof:
+            if (
+                _tag(node) != "g" or not len(node) or _tag(node[0]) != "polygon"
+                or node[0].get("data-role") not in {None, "footprint"}
+            ):
+                raise ValueError("roof requires a polygon footprint followed by ridge lines")
+            geometry = _read_geometry(node[0])
+            for child in list(node)[1:]:
+                if _tag(child) != "line" or child.get("data-role") != "ridge":
+                    raise ValueError("roof ridges require line elements with data-role=ridge")
+                ridges.append(cast(LineGeometry, _read_curve(child)))
+        else:
+            geometry = furniture_geometry(node) if is_furniture else _read_geometry(node)
+        if is_furniture:
+            if not isinstance(geometry, PolygonGeometry):
+                raise TypeError("furniture geometry must be a placement-local polygon")
+            furniture.append(Furniture(
+                _entity_id(node),
+                node.attrib["data-type"],
+                _furniture_placement(node),
+                geometry,
+                _finite(node.get("data-height")) if "data-height" in node.attrib else None,
+                _finite(node.get("data-bottom-elevation"))
+                if "data-bottom-elevation" in node.attrib else None,
+                _thickness(node, geometry),
+                node.get("data-name"),
+                node.get("data-legend-shape"),
+                json.loads(node.attrib["data-up-stair-directions"])
+                if "data-up-stair-directions" in node.attrib else None,
+                json.loads(node.attrib["data-path"]) if "data-path" in node.attrib else None,
+                json.loads(node.attrib["data-attributes"]) if "data-attributes" in node.attrib else None,
+                furniture_presentation(node),
+            ))
+            return
+        direction = None
+        if "data-direction" in node.attrib:
+            values = node.attrib["data-direction"].split(",")
+            if len(values) != 2:
+                raise ValueError("direction requires x,y")
+            direction = (_finite(values[0]), _finite(values[1]))
+        bay: dict[str, Any] = {}
+        for field, key in BAY_FIELDS.items():
+            if "data-bay-" + key in node.attrib:
+                value = node.attrib["data-bay-" + key]
+                bay[field] = value if field == "platformType" else _finite(value)
+        common = (
+            _entity_id(node),
+            node.attrib["data-type"],
+            geometry,
+            _height(node, None) if roof else (
+                _finite(node.get("data-height")) if "data-height" in node.attrib else None),
+            None if roof and node.get("data-bottom-elevation") == "unknown" else (
+                _finite(node.get("data-bottom-elevation")) if "data-bottom-elevation" in node.attrib else None),
+            _thickness(node, geometry),
+            direction,
+            node.get("data-name"),
+        )
+        hatch = None
+        if node.get("data-type") == "inspection_hatch" or any(
+            key in node.attrib for key in ("data-hatch-surface", "data-hatch-storage")
+        ):
+            storage = node.get("data-hatch-storage")
+            if storage is not None and storage not in {"true", "false"}:
+                raise ValueError("data-hatch-storage must be true or false")
+            hatch = InspectionHatchParameters(
+                node.get("data-hatch-surface", "unknown"), None if storage is None else storage == "true",
+            )
+        buildings.append(Building(
+            *common, BayWindowParameters(**bay) if bay else None, tuple(ridges), inspectionHatch=hatch,
+        ))
+
+    for node in layers.get("floorOpenings", ()):
+        geometry = _read_geometry(node)
+        if not isinstance(geometry, (PolygonGeometry, PathGeometry, CircleGeometry)):
+            raise TypeError("floor opening requires a polygon, closed path or circle")
+        floor_openings.append(FloorOpening(
+            _entity_id(node), geometry, node.get("data-name"),
+            _finite(node.get("data-bottom-elevation")) if "data-bottom-elevation" in node.attrib else None,
+            _thickness(node, geometry),
+        ))
+
+    for node in layers.get("buildings", ()):
+        read_object(node, is_furniture=False)
+    for node in layers.get("furniture", ()):
+        read_object(node, is_furniture=True)
+
+    for node in layers.get("walls", ()):
+        geometry = _read_wall_geometry(node)
+        bearing = node.get("data-load-bearing")
+        if bearing not in {None, "true", "false"}:
+            raise ValueError("data-load-bearing must be true or false")
+        walls.append(Wall(_entity_id(node), geometry, _thickness(node, geometry),
+                          bearing == "true", _height(node, scene_height)))
+    for node in layers.get("separators", ()):
+        geometry = _read_geometry(node)
+        if not isinstance(geometry, (LineGeometry, ArcGeometry)):
+            raise TypeError("virtual separators require a line or circular arc")
+        separators.append(Separator(_entity_id(node), geometry))
+
+    opening_layer = layers.get("openings")
+    if opening_layer is not None:
+        for node in opening_layer:
+            if _tag(node) != "g":
+                raise ValueError("openings require entity groups")
+            segment_nodes = tuple(node)
+            if not segment_nodes or any(_tag(child) not in {"line", "path"} for child in segment_nodes):
+                raise ValueError("opening geometry requires one or more lines or circular arcs")
+            segments = tuple(OpeningSegment(
+                cast(LineGeometry | ArcGeometry, _read_geometry(child)), child.get("data-wall-id"),
+                child.get("data-open-side"),
+                _finite(child.get("data-outside")) if "data-outside" in child.attrib else None,
+            ) for child in segment_nodes)
+            source_type = node.get("data-type")
+            openings.append(Opening(
+                _entity_id(node), source_type, segments,
+                _finite(node.get("data-height")) if "data-height" in node.attrib else None,
+                _finite(node.get("data-bottom-elevation")) if "data-bottom-elevation" in node.attrib else None,
+                _finite(node.get("data-depth")) if "data-depth" in node.attrib else None,
+            ))
+
+    for node in layers.get("dimensions", ()):
+        if _tag(node) != "g" or len(node) != 1 or _tag(node[0]) != "line":
+            raise ValueError("dimensions require entity groups with one measurement span")
+        if node.get("data-kind") != "linear" or node[0].get("data-role") != "measurement-span":
+            raise ValueError("dimensions require kind=linear and role=measurement-span")
+        value = _finite(node.get("data-value"), bounded=False)
+        if value <= 0 or not value.is_integer():
+            raise ValueError("dimension data-value must be a positive integer")
+        geometry = _read_geometry(node[0])
+        if not isinstance(geometry, LineGeometry):
+            raise TypeError("dimension annotation geometry must be a line")
+        dimension_annotations.append(DimensionAnnotation(
+            _entity_id(node), int(value), geometry, node.get("data-ref-id"),
+        ))
+
+    scene = FloorplanScene(
+        scene_id,
+        rooms=tuple(rooms),
+        walls=tuple(walls),
+        separators=tuple(separators),
+        openings=tuple(openings),
+        floorOpenings=tuple(floor_openings),
+        buildings=tuple(buildings),
+        furniture=tuple(furniture),
+        height=scene_height,
+        zones=tuple(zones),
+        dimensionAnnotations=tuple(dimension_annotations),
+        presentation=ScenePresentation(cast(tuple[float, float, float, float], tuple(viewbox))),
+    )
+    payload = scene_to_dict(scene)
+    attributes = {node.get("id"): read_json(node.attrib["data-attributes"])
+                  for layer in layers.values() for node in layer if "data-attributes" in node.attrib}
+    for collection in ("rooms", "walls", "separators", "openings", "floorOpenings", "buildings",
+                       "furniture", "zones", "dimensionAnnotations"):
+        for entity in payload.get(collection, []):
+            if entity["id"] in attributes:
+                entity["attributes"] = attributes[entity["id"]]
+    if metadata_payload is not None:
+        payload["metadata"] = metadata_payload
+    return scene_from_dict(payload)