floorplan-scene 0.1.0__py3-none-any.whl

floorplan_scene/rich_svg.py

@@ -0,0 +1,278 @@
+"""Presentation and interaction hints for terminal SVG artifacts."""
+
+from __future__ import annotations
+
+import math
+import re
+import xml.etree.ElementTree as ET
+from collections.abc import Mapping
+
+from .model import FloorplanScene, Opening, OpeningSegment
+from .render_labels import add_render_labels
+from .render_style import DEFAULT_RENDER_COLORS, rich_stylesheet
+from .shape_geometry import arc_circle, offset_arc
+from .shapes import ArcGeometry
+from .svg import NS, _curve_node, opening_width, scene_to_svg, svg_to_scene
+
+_HEX_COLOR = re.compile(r"#[0-9a-fA-F]{6}")
+_DOOR_SIDES = {
+    "LEFT": ("start", "left"),
+    "RIGHT": ("start", "right"),
+    "RIGHT_INVERSE": ("end", "left"),
+    "LEFT_INVERSE": ("end", "right"),
+}
+
+ET.register_namespace("", NS)
+
+
+def _number(value: float) -> str:
+    return str(int(value)) if float(value).is_integer() else repr(value)
+
+
+def _palette(colors: Mapping[str, str] | None) -> dict[str, str]:
+    values = dict(colors or {})
+    unknown = sorted(values.keys() - DEFAULT_RENDER_COLORS.keys())
+    if unknown:
+        raise ValueError(f"unknown render colors: {', '.join(unknown)}")
+    if any(not isinstance(value, str) or not _HEX_COLOR.fullmatch(value) for value in values.values()):
+        raise ValueError("render colors must use #RRGGBB")
+    return {**DEFAULT_RENDER_COLORS, **values}
+
+
+def _door_points(opening: Opening) -> list[tuple[tuple[float, float], tuple[float, float], tuple[float, float]]]:
+    result: list[tuple[tuple[float, float], tuple[float, float], tuple[float, float]]] = []
+    if opening.type not in {"DOOR", "ARCHED_DOOR", "DOUBLE_DOOR"}:
+        return result
+    for segment in opening.segments:
+        side = _DOOR_SIDES.get(segment.openSide or "")
+        if side is None:
+            continue
+        start, end = segment.geometry.start, segment.geometry.end
+        dx, dy = end[0] - start[0], end[1] - start[1]
+        length = math.hypot(dx, dy)
+        normal = (-dy / length, dx / length) if side[1] == "left" else (dy / length, -dx / length)
+        hinge, closed = (start, end) if side[0] == "start" else (end, start)
+        leaves = [(hinge, closed)]
+        if opening.type == "DOUBLE_DOOR":
+            middle = ((start[0] + end[0]) / 2, (start[1] + end[1]) / 2)
+            leaves = [(start, middle), (end, middle)]
+        for hinge, closed in leaves:
+            radius = math.dist(hinge, closed)
+            opened = hinge[0] + normal[0] * radius, hinge[1] + normal[1] * radius
+            result.append((hinge, closed, opened))
+    return result
+
+
+def _opening_symbol(holder: ET.Element, opening: Opening, segment: OpeningSegment, width: float) -> None:
+    """Draw in world coordinates; widths describe symbols, never additional Scene facts."""
+    if isinstance(segment.geometry, ArcGeometry) and segment.geometry.bulge != 0:
+        arc = segment.geometry
+        _curve_node(holder, arc, {"class": "opening-cutout", "stroke-width": _number(width)})
+        _, radius = arc_circle(arc)
+        outer = offset_arc(arc, width / 2)
+        inner = offset_arc(arc, -width / 2) if radius > width / 2 else None
+        for edge in (inner, outer):
+            if edge is not None:
+                _curve_node(holder, edge, {"class": "opening-edge", "aria-hidden": "true"})
+        if inner is not None:
+            for inner_point, outer_point in ((inner.start, outer.start), (inner.end, outer.end)):
+                ET.SubElement(holder, f"{{{NS}}}line", {
+                    "x1": _number(inner_point[0]), "y1": _number(inner_point[1]),
+                    "x2": _number(outer_point[0]), "y2": _number(outer_point[1]),
+                    "class": "opening-jamb", "aria-hidden": "true",
+                })
+        if opening.kind == "window" and opening.type != "WINDOW_HOLE":
+            _curve_node(holder, arc, {"class": "opening-panel", "aria-hidden": "true"})
+        return
+    start, end = segment.geometry.start, segment.geometry.end
+    length = math.dist(start, end)
+    ux, uy = (end[0] - start[0]) / length, (end[1] - start[1]) / length
+    half = width / 2
+
+    def line(a: float, b: float, c: float, d: float, css: str) -> None:
+        ET.SubElement(holder, f"{{{NS}}}line", {
+            "x1": _number(start[0] + ux * a - uy * b),
+            "y1": _number(start[1] + uy * a + ux * b),
+            "x2": _number(start[0] + ux * c - uy * d),
+            "y2": _number(start[1] + uy * c + ux * d),
+            "class": css, "aria-hidden": "true",
+        })
+
+    line(0, 0, length, 0, "opening-cutout")
+    holder[-1].set("stroke-width", _number(width))
+    line(0, -half, 0, half, "opening-jamb")
+    line(length, -half, length, half, "opening-jamb")
+    sliding = opening.type in {"SLIDE_DOOR", "SLIDE_WINDOW"}
+    shutter = opening.type in {"SHUTTER_DOOR", "SHUTTER_WINDOW"}
+    if sliding:
+        line(0, -half / 2, length * .6, -half / 2, "opening-panel")
+        line(length * .4, half / 2, length, half / 2, "opening-panel")
+        for a, b in ((0, -half / 2), (length * .6, -half / 2), (length * .4, half / 2), (length, half / 2)):
+            line(a, b - half / 3, a, b + half / 3, "opening-panel")
+    elif shutter:
+        for index in range(1, 10):
+            position = length * index / 10
+            line(position - length / 50, -half, position + length / 50, half, "opening-panel")
+    elif opening.kind == "window":
+        line(0, -half, length, -half, "opening-edge")
+        line(0, half, length, half, "opening-edge")
+        if opening.type != "WINDOW_HOLE":
+            line(0, 0, length, 0, "opening-panel")
+    elif opening.type == "UNEQUAL_DOUBLE_DOOR":
+        # Leaf widths are absent from Scene; identify the type without inventing a ratio.
+        line(0, 0, length, 0, "opening-panel")
+        angle = math.degrees(math.atan2(uy, ux))
+        if angle > 90:
+            angle -= 180
+        elif angle < -90:
+            angle += 180
+        label = ET.SubElement(holder, f"{{{NS}}}text", {
+            "class": "opening-type-label", "text-anchor": "middle", "font-size": _number(min(140., length / 4)),
+            "transform": (f"translate({_number((start[0] + end[0]) / 2)} {_number((start[1] + end[1]) / 2)}) "
+                          f"rotate({_number(angle)}) scale(1 -1)"),
+            "aria-hidden": "true",
+        })
+        label.text = opening.id + " 子母门"
+    elif opening.kind in {"passage", "niche"} or not _DOOR_SIDES.get(segment.openSide or ""):
+        line(0, -half, length, -half, "opening-edge")
+        line(0, half, length, half, "opening-edge")
+        if opening.kind == "niche":
+            line(0, half, length, half, "opening-panel")
+
+
+def _display_point(point: tuple[float, float]) -> tuple[float, float]:
+    return point[0], -point[1]
+
+
+def _expand_viewbox(root: ET.Element, points: list[tuple[float, float]]) -> None:
+    if not points:
+        return
+    x, y, width, height = (float(value) for value in root.attrib["viewBox"].split())
+    margin = 100.0
+    min_x = min(x, *(point[0] - margin for point in points))
+    min_y = min(y, *(point[1] - margin for point in points))
+    max_x = max(x + width, *(point[0] + margin for point in points))
+    max_y = max(y + height, *(point[1] + margin for point in points))
+    root.set("viewBox", " ".join(_number(value) for value in (min_x, min_y, max_x - min_x, max_y - min_y)))
+
+
+def _entity_label(node: ET.Element) -> str:
+    entity_id = node.attrib["id"]
+    detail = node.get("data-name") or node.get("data-type")
+    if detail is None and node.get("data-value") is not None:
+        detail = f'{node.get("data-value")} mm'
+    return f"{entity_id}, {detail}" if detail else entity_id
+
+
+def scene_to_rich_svg(
+    scene: FloorplanScene,
+    *,
+    colors: Mapping[str, str] | None = None,
+    width: int = 1400,
+    height: int | None = None,
+) -> str:
+    """Render dimensions and opening symbols in a colored, accessible SVG."""
+    palette = _palette(colors)
+    source = scene_to_svg(scene)
+    scene = svg_to_scene(source, scene_id=scene.id)
+    root = ET.fromstring(source)
+    root.set("data-rich-svg", "true")
+    root.set("role", "group")
+    root.set("aria-label", "Interactive floor plan")
+    stylesheet = ET.Element(f"{{{NS}}}style")
+    stylesheet.text = rich_stylesheet(palette)
+    # The workbench removes input CSS; retain only validated color variables there.
+    root.set("style", ";".join(f"--scene-{key.replace('.', '-')}: {value}" for key, value in palette.items()))
+    root.insert(0, stylesheet)
+
+    if scene.metadata is not None and scene.metadata.originImage is not None:
+        origin = scene.metadata.originImage
+        x, y, image_width, image_height = origin.sceneBounds
+        root.insert(1, ET.Element(f"{{{NS}}}image", {
+            "class": "origin-image", "href": origin.url,
+            "x": _number(x), "y": _number(-y - image_height),
+            "width": _number(image_width), "height": _number(image_height),
+            "preserveAspectRatio": "none", "opacity": "0.35",
+            "pointer-events": "none", "aria-hidden": "true",
+        }))
+
+    by_id = {node.get("id"): node for node in root.iter() if node.get("id")}
+    leaf_points: list[tuple[float, float]] = []
+    for node in by_id.values():
+        node.set("tabindex", "0")
+        node.set("role", "button")
+        node.set("aria-pressed", "false")
+        node.set("aria-label", _entity_label(node))
+        title = ET.Element(f"{{{NS}}}title")
+        title.text = _entity_label(node)
+        node.insert(0, title)
+
+    for furniture in scene.furniture:
+        holder = by_id.get(furniture.id)
+        if holder is None:
+            continue
+        length = furniture.placement.depth * .35
+        head = min(length * .25, furniture.placement.width * .2)
+        direction = ET.SubElement(holder, f"{{{NS}}}g", {
+            "class": "furniture-direction",
+            "data-rotation": _number(furniture.placement.rotation),
+            "aria-hidden": "true",
+        })
+        ET.SubElement(direction, f"{{{NS}}}line", {
+            "x1": "0", "y1": "0", "x2": "0", "y2": _number(-length),
+        })
+        ET.SubElement(direction, f"{{{NS}}}polyline", {
+            "points": (
+                f"{_number(-head)},{_number(-length + head)} "
+                f"0,{_number(-length)} {_number(head)},{_number(-length + head)}"
+            ),
+        })
+
+    wall_by_id = {wall.id: wall for wall in scene.walls}
+    for opening in scene.openings:
+        holder = by_id.get(opening.id)
+        if holder is None:
+            continue
+        for node in list(holder):
+            if node.tag in {f"{{{NS}}}line", f"{{{NS}}}path"}:
+                node.set("data-opening-span", "true")
+        for segment in opening.segments:
+            _opening_symbol(holder, opening, segment, opening_width(opening, wall_by_id.get(segment.wallId or "")))
+        for hinge, closed, opened in _door_points(opening):
+            leaf_points.extend(map(_display_point, (hinge, closed, opened)))
+            # The parent flips Y for display; derive sweep in world coordinates.
+            radius = math.dist(hinge, closed)
+            cross = ((closed[0] - hinge[0]) * (opened[1] - hinge[1])
+                     - (closed[1] - hinge[1]) * (opened[0] - hinge[0]))
+            ET.SubElement(holder, f"{{{NS}}}path", {
+                "class": "door-swing",
+                "d": (f"M {_number(closed[0])} {_number(closed[1])} "
+                      f"A {_number(radius)} {_number(radius)} 0 0 {int(cross > 0)} "
+                      f"{_number(opened[0])} {_number(opened[1])}"),
+                "aria-hidden": "true",
+            })
+            ET.SubElement(
+                holder,
+                f"{{{NS}}}line",
+                {
+                    "class": "door-leaf",
+                    "x1": _number(hinge[0]),
+                    "y1": _number(hinge[1]),
+                    "x2": _number(opened[0]),
+                    "y2": _number(opened[1]),
+                    "aria-hidden": "true",
+                },
+            )
+
+    _expand_viewbox(root, leaf_points)
+    return add_render_labels(scene, ET.tostring(root, encoding="unicode"), width, height) + "\n"
+
+
+def enrich_svg(
+    svg: str,
+    *,
+    colors: Mapping[str, str] | None = None,
+    scene_id: str = "rich-svg",
+) -> str:
+    """Validate a semantic SVG through Scene before enriching it."""
+    return scene_to_rich_svg(svg_to_scene(svg, scene_id=scene_id), colors=colors)

floorplan_scene/shape_geometry.py

@@ -0,0 +1,185 @@
+"""Shapely projections of analytic shapes; sampled points never replace source geometry."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from shapely.affinity import rotate, translate  # type: ignore[import-untyped]
+from shapely.geometry import LineString, MultiPolygon, Polygon, box  # type: ignore[import-untyped]
+from shapely.geometry import Point as ShapelyPoint
+from shapely.ops import unary_union  # type: ignore[import-untyped]
+from svg.path import Arc, QuadraticBezier
+
+from .model import Building, FloorplanScene, Furniture, FurniturePlacement, Wall
+from .shapes import (
+    GEOMETRY_TOLERANCE_MM,
+    ArcGeometry,
+    BayWindowGeometry,
+    CircleGeometry,
+    Curve,
+    Geometry,
+    LineGeometry,
+    PathGeometry,
+    PipeGeometry,
+    Point,
+    PolygonGeometry,
+    QuadraticGeometry,
+)
+
+PROJECTION_TOLERANCE = 0.05  # mm chord error, only for planar computation and PNG rendering.
+
+
+def curve_points(curve: Curve) -> tuple[Point, ...]:
+    if isinstance(curve, LineGeometry) or isinstance(curve, ArcGeometry) and curve.bulge == 0:
+        return curve.start, curve.end
+    path: Arc | QuadraticBezier
+    if isinstance(curve, ArcGeometry):
+        bulge = curve.bulge
+        radius = math.dist(curve.start, curve.end) * (1 + bulge * bulge) / (4 * abs(bulge))
+        angle = abs(4 * math.atan(bulge))
+        count = max(2, math.ceil(angle * math.sqrt(radius / (8 * PROJECTION_TOLERANCE))))
+        path = Arc(complex(*curve.start), complex(radius, radius), 0, abs(bulge) > 1,
+                   bulge > 0, complex(*curve.end))
+    else:
+        curvature = math.hypot(*(curve.start[i] - 2 * curve.control[i] + curve.end[i] for i in (0, 1)))
+        count = max(2, math.ceil(math.sqrt(curvature / (4 * PROJECTION_TOLERANCE))))
+        path = QuadraticBezier(complex(*curve.start), complex(*curve.control), complex(*curve.end))
+    if count > 100_000:
+        raise ValueError("curve exceeds projection size limit")
+    points = (path.point(i / count) for i in range(1, count))
+    return (curve.start, *((p.real, p.imag) for p in points), curve.end)
+
+
+def geometry_shape(geometry: Geometry, thickness: float | None = None) -> Any:
+    if isinstance(geometry, (LineGeometry, ArcGeometry, QuadraticGeometry)):
+        axis = LineString(curve_points(geometry))
+        return axis.buffer(thickness / 2, cap_style=2, join_style=2) if thickness else axis
+    if isinstance(geometry, PolygonGeometry):
+        return MultiPolygon([Polygon(rings[0], rings[1:]) for rings in geometry.polygons])
+    if isinstance(geometry, PathGeometry):
+        polygons = []
+        for rings in geometry.polygons:
+            points = [tuple(p for edge in ring for p in curve_points(edge)[:-1]) for ring in rings]
+            polygons.append(Polygon(points[0], points[1:]))
+        return MultiPolygon(polygons)
+    if isinstance(geometry, CircleGeometry):
+        segments = max(8, math.ceil(math.pi * math.sqrt(geometry.radius / (8 * PROJECTION_TOLERANCE)) / 2))
+        if segments > 25_000:
+            raise ValueError("circle exceeds projection size limit")
+        return ShapelyPoint(geometry.center).buffer(geometry.radius, quad_segs=segments)
+    if isinstance(geometry, BayWindowGeometry):
+        return Polygon(geometry.outline)
+    if isinstance(geometry, PipeGeometry):
+        widths = dict(zip({"L": ("right", "bottom"), "U": ("left", "right", "bottom"),
+                           "RECT": ("left", "top", "right", "bottom")}[geometry.profile],
+                          geometry.wallThickness, strict=True))
+        x, y = geometry.width / 2, geometry.depth / 2
+        strips = {"left": lambda w: box(-x, -y, -x + w, y),
+                  "top": lambda w: box(-x, y - w, x, y),
+                  "right": lambda w: box(x - w, -y, x, y),
+                  "bottom": lambda w: box(-x, -y, x, -y + w)}
+        profile = unary_union([strips[side](w) for side, w in widths.items()])
+        return translate(rotate(profile, geometry.angle, origin=(0, 0)), *geometry.center)
+    raise TypeError(f"unsupported geometry: {type(geometry).__name__}")
+
+
+def subtract_floor_openings(domain: Any, scene: FloorplanScene) -> Any:
+    """Remove floor voids after joining rooms and door bridges, before clearance erosion."""
+    if not scene.floorOpenings:
+        return domain
+    return domain.difference(unary_union([geometry_shape(item.geometry) for item in scene.floorOpenings]))
+
+
+def wall_shape(wall: Wall) -> Any:
+    return geometry_shape(wall.geometry, wall.thickness)
+
+
+def _transform_polygon(
+    geometry: PolygonGeometry,
+    placement: FurniturePlacement,
+    *,
+    inverse: bool,
+) -> PolygonGeometry:
+    angle = math.radians(placement.rotation)
+    cosine, sine = math.cos(angle), math.sin(angle)
+    center_x, center_y = placement.center
+
+    def transform(point: Point) -> Point:
+        x, y = point
+        if inverse:
+            x, y = x - center_x, y - center_y
+            return x * cosine + y * sine, -x * sine + y * cosine
+        return center_x + x * cosine - y * sine, center_y + x * sine + y * cosine
+
+    return PolygonGeometry(tuple(tuple(tuple(transform(point) for point in ring) for ring in polygon)
+                                 for polygon in geometry.polygons))
+
+
+def placed_furniture_geometry(item: Furniture) -> PolygonGeometry:
+    return _transform_polygon(item.geometry, item.placement, inverse=False)
+
+
+def local_furniture_geometry(
+    geometry: PolygonGeometry,
+    placement: FurniturePlacement,
+) -> PolygonGeometry:
+    return _transform_polygon(geometry, placement, inverse=True)
+
+
+def object_shape(item: Building | Furniture) -> Any:
+    geometry = placed_furniture_geometry(item) if isinstance(item, Furniture) else item.geometry
+    return geometry_shape(geometry, item.thickness)
+
+
+def arc_circle(arc: ArcGeometry) -> tuple[Point, float]:
+    """Circle of a directed bulge arc in the unchanged world coordinate system."""
+    dx, dy = arc.end[0] - arc.start[0], arc.end[1] - arc.start[1]
+    factor = (1 - arc.bulge ** 2) / (4 * arc.bulge)
+    center = ((arc.start[0] + arc.end[0]) / 2 - dy * factor,
+              (arc.start[1] + arc.end[1]) / 2 + dx * factor)
+    return center, math.hypot(dx, dy) * (1 + arc.bulge ** 2) / (4 * abs(arc.bulge))
+
+
+def arc_subsegment(host: ArcGeometry, start: Point, end: Point) -> ArcGeometry:
+    """Recover the interval on a host arc, preserving the supplied endpoint order.
+
+    The host interval disambiguates major arcs; choosing the shortest arc loses FPI geometry.
+    Endpoints must already lie on the host centre line (1 mm allowance).
+    """
+    center, radius = arc_circle(host)
+    direction = 1 if host.bulge > 0 else -1
+    extent = abs(4 * math.atan(host.bulge))
+    origin = math.atan2(host.start[1] - center[1], host.start[0] - center[0])
+
+    def parameter(point: Point) -> float:
+        if math.dist(point, host.start) <= GEOMETRY_TOLERANCE_MM:
+            return 0.
+        if math.dist(point, host.end) <= GEOMETRY_TOLERANCE_MM:
+            return extent
+        angle = math.atan2(point[1] - center[1], point[0] - center[0])
+        value = (direction * (angle - origin)) % math.tau
+        if abs(math.dist(point, center) - radius) > GEOMETRY_TOLERANCE_MM or value > extent + GEOMETRY_TOLERANCE_MM / radius:
+            raise ValueError("arc opening endpoints must lie on their host arc")
+        return min(value, extent)
+
+    first, last = parameter(start), parameter(end)
+    if first == 0 and last == extent:
+        return ArcGeometry(start, end, host.bulge)
+    if first == extent and last == 0:
+        return ArcGeometry(start, end, -host.bulge)
+    delta = direction * (last - first)
+    if abs(delta) < 1e-12:
+        raise ValueError("arc opening requires distinct endpoints on its host arc")
+    return ArcGeometry(start, end, math.tan(delta / 4))
+
+
+def offset_arc(arc: ArcGeometry, distance: float) -> ArcGeometry:
+    """Concentric display offset; positive distance increases the radius."""
+    center, radius = arc_circle(arc)
+    if radius + distance <= 0:
+        raise ValueError("arc display offset requires a positive radius")
+    ratio = (radius + distance) / radius
+    def point(value: Point) -> Point:
+        return center[0] + (value[0] - center[0]) * ratio, center[1] + (value[1] - center[1]) * ratio
+    return ArcGeometry(point(arc.start), point(arc.end), arc.bulge)

floorplan_scene/shapes.py

@@ -0,0 +1,82 @@
+"""Analytic plan geometry shared by the Scene, FPI and SVG adapters."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal, TypeAlias
+
+GEOMETRY_TOLERANCE_MM = 1.0
+
+Point: TypeAlias = tuple[float, float]
+Line: TypeAlias = tuple[Point, Point]
+Ring: TypeAlias = tuple[Point, ...]
+Footprint: TypeAlias = tuple[tuple[Ring, ...], ...]
+
+
+@dataclass(frozen=True)
+class LineGeometry:
+    start: Point
+    end: Point
+    type: Literal["line"] = field(default="line", init=False)
+
+
+@dataclass(frozen=True)
+class ArcGeometry:
+    start: Point
+    end: Point
+    bulge: float
+    type: Literal["arc"] = field(default="arc", init=False)
+
+
+@dataclass(frozen=True)
+class QuadraticGeometry:
+    start: Point
+    control: Point
+    end: Point
+    type: Literal["quadratic"] = field(default="quadratic", init=False)
+
+
+Curve: TypeAlias = LineGeometry | ArcGeometry | QuadraticGeometry
+CurveRing: TypeAlias = tuple[Curve, ...]
+CurvedFootprint: TypeAlias = tuple[tuple[CurveRing, ...], ...]
+
+
+@dataclass(frozen=True)
+class PolygonGeometry:
+    polygons: Footprint
+    type: Literal["polygon"] = field(default="polygon", init=False)
+
+
+@dataclass(frozen=True)
+class PathGeometry:
+    polygons: CurvedFootprint
+    type: Literal["path"] = field(default="path", init=False)
+
+
+@dataclass(frozen=True)
+class CircleGeometry:
+    center: Point
+    radius: float
+    type: Literal["circle"] = field(default="circle", init=False)
+
+
+@dataclass(frozen=True)
+class PipeGeometry:
+    center: Point
+    width: float
+    depth: float
+    angle: float
+    profile: Literal["L", "U", "RECT"]
+    wallThickness: tuple[float, ...]
+    type: Literal["pipe"] = field(default="pipe", init=False)
+
+
+@dataclass(frozen=True)
+class BayWindowGeometry:
+    outline: Ring
+    wallPath: tuple[Point, ...]
+    profile: str
+    type: Literal["bay_window"] = field(default="bay_window", init=False)
+
+
+Geometry: TypeAlias = Curve | PolygonGeometry | PathGeometry | CircleGeometry | PipeGeometry | BayWindowGeometry