floorplan-scene 0.1.0__py3-none-any.whl

floorplan_scene/presentation.py

@@ -0,0 +1,146 @@
+"""SVG 展示数据：只用于 Scene/SVG 往返，不属于物理几何或 FPI/Legend 合同。"""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass, field
+from typing import Literal
+
+from svg.path import Arc, parse_path
+
+PAINT = {"fill", "stroke", "stroke-width", "stroke-linecap", "stroke-dasharray", "fill-rule",
+         "font-size", "text-anchor"}
+DRAWING_ATTRIBUTES = {
+    "line": {"x1", "y1", "x2", "y2"},
+    "path": {"d"},
+    "polygon": {"points"},
+    "polyline": {"points"},
+    "circle": {"cx", "cy", "r"},
+}
+
+
+def _finite(value: str | float) -> float:
+    number = float(value)
+    if not math.isfinite(number) or abs(number) > 1_000_000:
+        raise ValueError("presentation coordinates must be finite millimetres within 1 km")
+    return number
+
+
+def _numbers(value: str) -> list[float]:
+    return [_finite(item) for item in re.split(r"[\s,]+", value.strip())]
+
+
+def validate_paint(attributes: dict[str, str]) -> None:
+    """同一白名单用于 JSON 和 SVG；不允许 URL、CSS、事件或外部资源。"""
+    if not isinstance(attributes, dict) or set(attributes) - PAINT:
+        raise ValueError("unsupported presentation paint attribute")
+    for key, value in attributes.items():
+        if not isinstance(value, str):
+            raise TypeError("presentation attributes must be strings")
+        if key in {"fill", "stroke"}:
+            if value != "none" and not re.fullmatch(r"#[0-9a-fA-F]{6}", value):
+                raise ValueError("presentation colours require none or six-digit hex")
+        elif key in {"stroke-width", "font-size"}:
+            if _finite(value) < 0:
+                raise ValueError("presentation paint size cannot be negative")
+        elif key == "stroke-dasharray":
+            if value != "none" and any(number < 0 for number in _numbers(value)):
+                raise ValueError("presentation dash lengths cannot be negative")
+        elif value not in {"stroke-linecap": {"butt"}, "fill-rule": {"nonzero", "evenodd"},
+                          "text-anchor": {"start", "middle", "end"}}[key]:
+            raise ValueError("unsupported presentation paint value")
+
+
+@dataclass(frozen=True)
+class SvgDecoration:
+    """家具局部毫米坐标下的一个有序绘图图元；没有实体 ID，不计入占地/碰撞/家具数量。
+
+    attributes 只允许 tag 对应的几何属性和 PAINT 白名单，值采用 SVG 字符串语法。
+    禁止 XML、子节点、transform、href、style、事件和 data-* 语义；placement 由家具统一提供。
+    path 保留 d（含曲线与多个子路径），无需将外观线误转换为物理轮廓。
+    """
+
+    tag: Literal["line", "path", "polygon", "polyline", "circle"]
+    attributes: dict[str, str]  # 几何与已解析继承的绘制属性；绝不存整段 XML。
+
+    def __post_init__(self) -> None:
+        geometry = DRAWING_ATTRIBUTES.get(self.tag)
+        if geometry is None or not isinstance(self.attributes, dict):
+            raise ValueError("unsupported decoration primitive")
+        if set(self.attributes) - geometry - PAINT or not geometry <= self.attributes.keys():
+            raise ValueError("invalid decoration attributes")
+        if any(not isinstance(value, str) for value in self.attributes.values()):
+            raise TypeError("decoration attributes must be strings")
+        if sum(len(value) for value in self.attributes.values()) > 1_000_000:
+            raise ValueError("decoration exceeds 1 MB")
+        validate_paint({key: value for key, value in self.attributes.items() if key in PAINT})
+        if self.tag == "path":
+            try:
+                parts = parse_path(self.attributes["d"])
+            except (ValueError, IndexError, ZeroDivisionError) as exc:
+                raise ValueError("invalid decoration path") from exc
+            if not parts or len(parts) > 10000:
+                raise ValueError("invalid decoration path length")
+            for part in parts:
+                for name in ("start", "end", "control", "control1", "control2"):
+                    point = getattr(part, name, None)
+                    if point is not None:
+                        _finite(point.real)
+                        _finite(point.imag)
+                if isinstance(part, Arc):
+                    _finite(part.radius.real)
+                    _finite(part.radius.imag)
+                    _finite(part.rotation)
+        elif self.tag in {"polygon", "polyline"}:
+            values = _numbers(self.attributes["points"])
+            if len(values) % 2 or len(values) < (6 if self.tag == "polygon" else 4):
+                raise ValueError("decoration points require coordinate pairs")
+        else:
+            for key in geometry:
+                _finite(self.attributes[key])
+            if self.tag == "circle" and float(self.attributes["r"]) <= 0:
+                raise ValueError("decoration circle radius must be positive")
+
+
+@dataclass(frozen=True)
+class FurniturePresentation:
+    """可选家具外观，随 placement 平移/旋转；不改变 geometry、尺寸或方向。
+
+    decorations 保持绘制顺序；footprintIndex 为物理占地图元在它们之间的插入位置。
+    footprintStyle 保存占地的可见绘制属性（包括继承值），不保存第二份占地几何。
+    Scene→FPI/Legend/legend_doc 忽略本结构；FPI→Scene 不生成它。
+    """
+
+    decorations: tuple[SvgDecoration, ...] = ()
+    footprintStyle: dict[str, str] = field(default_factory=dict)
+    footprintIndex: int = 0
+
+    def __post_init__(self) -> None:
+        if len(self.decorations) > 10000:
+            raise ValueError("too many decoration primitives")
+        if type(self.footprintIndex) is not int or not 0 <= self.footprintIndex <= len(self.decorations):
+            raise ValueError("footprintIndex must be an insertion index in decorations")
+        validate_paint(self.footprintStyle)
+
+
+@dataclass(frozen=True)
+class ScenePresentation:
+    """可选 SVG 文档画布，不是建筑边界、原图映射或页面相机状态。
+
+    viewBox=(x, y, width, height)，单位毫米，采用 SVG 画布坐标（Y 向下），
+    而非世界组 scale(1 -1) 内的 Y 向上坐标。SVG 导入时保存，导出时优先使用；
+    缺省时沿用 originImage 或几何自动取景。FPI 导入不生成，FPI/Legend 导出忽略。
+    """
+
+    viewBox: tuple[float, float, float, float]
+
+    def __post_init__(self) -> None:
+        if len(self.viewBox) != 4:
+            raise ValueError("presentation viewBox requires four numbers")
+        for value in self.viewBox:
+            if isinstance(value, bool) or not isinstance(value, (int, float)):
+                raise TypeError("presentation viewBox requires numbers")
+            _finite(value)
+        if min(self.viewBox[2:]) <= 0:
+            raise ValueError("presentation viewBox width and height must be positive")

floorplan_scene/render_labels.py

@@ -0,0 +1,315 @@
+"""Deterministic labels used only by visual previews."""
+
+from __future__ import annotations
+
+import math
+import xml.etree.ElementTree as ET
+from typing import Any
+
+from shapely.geometry import LineString  # type: ignore[import-untyped]
+from shapely.geometry import box as shape_box
+
+from .dimensions import dimension_outward_normal, scene_shell
+from .model import FloorplanScene
+from .shape_geometry import geometry_shape, object_shape
+from .svg import NS
+
+Box = tuple[float, float, float, float]
+Label = tuple[str, str, float, float, float]
+
+
+def _number(value: float) -> str:
+    value = round(value, 3)
+    return "0" if value == 0 else f"{value:g}"
+
+
+def _label_box(x: float, y: float, text: str, font_size: float) -> Box:
+    label_width = max(2, sum(1 if ord(char) > 255 else 0.6 for char in text)) * font_size
+    return x - label_width / 2, y - font_size * 0.65, x + label_width / 2, y + font_size * 0.65
+
+
+def _overlaps(box: Box, occupied: list[Box]) -> bool:
+    return any(
+        not (
+            box[2] <= other[0]
+            or box[0] >= other[2]
+            or box[3] <= other[1]
+            or box[1] >= other[3]
+        )
+        for other in occupied
+    )
+
+
+def _rotated_box(box: Box, angle: float) -> Box:
+    center_x, center_y = (box[0] + box[2]) / 2, (box[1] + box[3]) / 2
+    half_width, half_height = (box[2] - box[0]) / 2, (box[3] - box[1]) / 2
+    radians = math.radians(angle)
+    x_extent = abs(math.cos(radians)) * half_width + abs(math.sin(radians)) * half_height
+    y_extent = abs(math.sin(radians)) * half_width + abs(math.cos(radians)) * half_height
+    return center_x - x_extent, center_y - y_extent, center_x + x_extent, center_y + y_extent
+
+
+def _labels(scene: FloorplanScene, room_font: float, entity_font: float) -> list[Label]:
+    labels: list[Label] = []
+    for room in scene.rooms:
+        name = room.name or room.type
+        text = name if room.area is None else f"{name} {room.area:.2f}㎡"
+        labels.append((room.id, text, room.labelPoint[0], -room.labelPoint[1], room_font))
+    for floor_opening in scene.floorOpenings:
+        center = geometry_shape(floor_opening.geometry).representative_point()
+        labels.append((floor_opening.id, floor_opening.name or floor_opening.id, float(center.x), -float(center.y), entity_font))
+    for building in scene.buildings:
+        center = object_shape(building).centroid
+        labels.append((building.id, building.id, float(center.x), -float(center.y), entity_font))
+    for furniture in scene.furniture:
+        center = object_shape(furniture).centroid
+        labels.append((furniture.id, furniture.id, float(center.x), -float(center.y), entity_font))
+    for wall in scene.walls:
+        center = geometry_shape(wall.geometry, wall.thickness).centroid
+        labels.append((wall.id, wall.id, float(center.x), -float(center.y), entity_font))
+    for separator in scene.separators:
+        center = geometry_shape(separator.geometry).centroid
+        labels.append((separator.id, separator.id, float(center.x), -float(center.y), entity_font))
+    for opening in scene.openings:
+        if opening.type == "UNEQUAL_DOUBLE_DOOR":
+            continue  # The symbol already combines this ID and its type label.
+        centers = [geometry_shape(part.geometry).interpolate(.5, normalized=True) for part in opening.segments]
+        points = [(point.x, point.y) for point in centers]
+        if points:
+            labels.append(
+                (
+                    opening.id,
+                    opening.id,
+                    sum(point[0] for point in points) / len(points),
+                    -sum(point[1] for point in points) / len(points),
+                    entity_font,
+                )
+            )
+    return labels
+
+
+def _line(
+    parent: ET.Element,
+    role: str,
+    start: tuple[float, float],
+    end: tuple[float, float],
+    stroke_width: float,
+) -> None:
+    ET.SubElement(
+        parent,
+        f"{{{NS}}}line",
+        {
+            "x1": _number(start[0]),
+            "y1": _number(start[1]),
+            "x2": _number(end[0]),
+            "y2": _number(end[1]),
+            "stroke-width": _number(stroke_width),
+            "data-role": role,
+        },
+    )
+
+
+def _dimension_overlays(
+    root: ET.Element,
+    scene: FloorplanScene,
+    unit_per_pixel: float,
+) -> tuple[list[Box], list[Box]]:
+    occupied: list[Box] = []
+    dimension_shapes: list[Any] = []
+    bounds: list[Box] = []
+    shell = scene_shell(scene)
+    layer = ET.SubElement(root, f"{{{NS}}}g", {"data-render-layer": "dimensions"})
+    for dimension in scene.dimensionAnnotations:
+        normal = dimension_outward_normal(scene, dimension)
+        if normal is None:
+            continue
+        start, end = dimension.geometry.start, dimension.geometry.end
+        dx, dy = end[0] - start[0], end[1] - start[1]
+        length = math.hypot(dx, dy)
+        if length == 0:
+            continue
+        tangent = (dx / length, -dy / length)
+        svg_normal = (normal[0], -normal[1])
+        angle = math.degrees(math.atan2(-dy, dx))
+        if angle > 90:
+            angle -= 180
+        elif angle < -90:
+            angle += 180
+        clearance = 6 * unit_per_pixel
+        label_size = 14 * unit_per_pixel
+        exterior_offset = 0.0
+        if shell is not None:
+            min_x, min_y, max_x, max_y = shell.bounds
+            exterior_offset = max(
+                0.0,
+                *(normal[0] * (x - start[0]) + normal[1] * (y - start[1])
+                  for x in (min_x, max_x) for y in (min_y, max_y)),
+            )
+        chosen: tuple[tuple[float, float], tuple[float, float], Box] | None = None
+        offset = exterior_offset + 32 * unit_per_pixel
+        while chosen is None:
+            scene_start = (start[0] + normal[0] * offset, start[1] + normal[1] * offset)
+            scene_end = (end[0] + normal[0] * offset, end[1] + normal[1] * offset)
+            display_start = (scene_start[0], -scene_start[1])
+            display_end = (scene_end[0], -scene_end[1])
+            text_point = (
+                (display_start[0] + display_end[0]) / 2 + svg_normal[0] * 10 * unit_per_pixel,
+                (display_start[1] + display_end[1]) / 2 + svg_normal[1] * 10 * unit_per_pixel,
+            )
+            label_box = _rotated_box(
+                _label_box(text_point[0], text_point[1], str(dimension.value), label_size), angle
+            )
+            line_shape = LineString((display_start, display_end)).buffer(clearance)
+            text_shape = shape_box(*label_box)
+            collisions = [
+                other for other in dimension_shapes
+                if line_shape.intersects(other) or text_shape.intersects(other)
+            ]
+            if not collisions:
+                chosen = display_start, display_end, label_box
+                dimension_shapes.extend((line_shape, text_shape))
+                break
+            # Move past the colliding shapes along the normal. A diagonal line's bounding
+            # box is not its painted footprint, and no valid dimension may be silently dropped.
+            blocking_max = max(
+                x * svg_normal[0] + y * svg_normal[1]
+                for shape in collisions for x in (shape.bounds[0], shape.bounds[2])
+                for y in (shape.bounds[1], shape.bounds[3])
+            )
+            candidate_min = min(
+                x * svg_normal[0] + y * svg_normal[1]
+                for shape in (line_shape, text_shape) for x in (shape.bounds[0], shape.bounds[2])
+                for y in (shape.bounds[1], shape.bounds[3])
+            )
+            offset += max(clearance, blocking_max - candidate_min + clearance)
+
+        display_start, display_end, label_box = chosen
+        holder = ET.SubElement(layer, f"{{{NS}}}g", {"data-render-dimension": dimension.id})
+        stroke_width = 1.2 * unit_per_pixel
+        extension_gap, extension_overrun = 4 * unit_per_pixel, 6 * unit_per_pixel
+        source_points = ((start[0], -start[1]), (end[0], -end[1]))
+        for source, display in zip(source_points, (display_start, display_end), strict=True):
+            extension_start = (
+                source[0] + svg_normal[0] * extension_gap,
+                source[1] + svg_normal[1] * extension_gap,
+            )
+            extension_end = (
+                display[0] + svg_normal[0] * extension_overrun,
+                display[1] + svg_normal[1] * extension_overrun,
+            )
+            _line(holder, "extension-line", extension_start, extension_end, stroke_width)
+        _line(holder, "dimension-line", display_start, display_end, stroke_width)
+
+        tick = 8 * unit_per_pixel
+        for point in (display_start, display_end):
+            tick_start = (
+                point[0] - (tangent[0] + svg_normal[0]) * tick / 2,
+                point[1] - (tangent[1] + svg_normal[1]) * tick / 2,
+            )
+            tick_end = (
+                point[0] + (tangent[0] + svg_normal[0]) * tick / 2,
+                point[1] + (tangent[1] + svg_normal[1]) * tick / 2,
+            )
+            _line(holder, "end-tick", tick_start, tick_end, stroke_width)
+
+        text_x = (label_box[0] + label_box[2]) / 2
+        text_y = (label_box[1] + label_box[3]) / 2
+        text = ET.SubElement(
+            holder,
+            f"{{{NS}}}text",
+            {
+                "x": _number(text_x),
+                "y": _number(text_y),
+                "font-size": _number(label_size),
+                "data-role": "dimension-value",
+            },
+        )
+        if abs(angle) > 0.001:
+            text.set("transform", f"rotate({_number(angle)} {_number(text_x)} {_number(text_y)})")
+        text.text = str(dimension.value)
+        line_box = (
+            min(display_start[0], display_end[0]) - clearance,
+            min(display_start[1], display_end[1]) - clearance,
+            max(display_start[0], display_end[0]) + clearance,
+            max(display_start[1], display_end[1]) + clearance,
+        )
+        occupied.extend((label_box, line_box))
+        bounds.extend(
+            (
+                label_box,
+                (
+                    min(start[0], end[0], display_start[0], display_end[0]),
+                    min(-start[1], -end[1], display_start[1], display_end[1]),
+                    max(start[0], end[0], display_start[0], display_end[0]),
+                    max(-start[1], -end[1], display_start[1], display_end[1]),
+                ),
+            )
+        )
+    if not list(layer):
+        root.remove(layer)
+    return occupied, bounds
+
+
+def add_render_labels(
+    scene: FloorplanScene, svg: str, width: int, height: int | None = None,
+) -> str:
+    """Add dimensions and non-overlapping labels to an internal preview SVG."""
+    root = ET.fromstring(svg)
+    view_x, view_y, view_width, view_height = map(float, root.attrib["viewBox"].split())
+    unit_per_pixel = max(view_width / width, view_height / height if height else 0)
+    occupied, overlay_bounds = _dimension_overlays(root, scene, unit_per_pixel)
+    if overlay_bounds:
+        margin = 8 * unit_per_pixel
+        view_right, view_bottom = view_x + view_width, view_y + view_height
+        view_x = min(view_x, *(box[0] - margin for box in overlay_bounds))
+        view_y = min(view_y, *(box[1] - margin for box in overlay_bounds))
+        view_right = max(view_right, *(box[2] + margin for box in overlay_bounds))
+        view_bottom = max(view_bottom, *(box[3] + margin for box in overlay_bounds))
+        view_width, view_height = view_right - view_x, view_bottom - view_y
+        root.set(
+            "viewBox",
+            " ".join(_number(value) for value in (view_x, view_y, view_width, view_height)),
+        )
+    layer = ET.SubElement(root, f"{{{NS}}}g", {"data-render-layer": "labels"})
+    for entity_id, text, anchor_x, anchor_y, font_size in _labels(
+        scene, 17 * unit_per_pixel, 11 * unit_per_pixel
+    ):
+        candidates = [(0.0, 0.0)]
+        for distance in (font_size * 1.4, font_size * 2.8):
+            candidates.extend(
+                (
+                    (0, -distance),
+                    (0, distance),
+                    (distance, 0),
+                    (-distance, 0),
+                    (distance, -distance),
+                    (-distance, -distance),
+                    (distance, distance),
+                    (-distance, distance),
+                )
+            )
+        for offset_x, offset_y in candidates:
+            x, y = anchor_x + offset_x, anchor_y + offset_y
+            box = _label_box(x, y, text, font_size)
+            if (
+                box[0] < view_x
+                or box[1] < view_y
+                or box[2] > view_x + view_width
+                or box[3] > view_y + view_height
+                or _overlaps(box, occupied)
+            ):
+                continue
+            ET.SubElement(
+                layer,
+                f"{{{NS}}}text",
+                {
+                    "x": str(x),
+                    "y": str(y),
+                    "font-size": str(font_size),
+                    "data-render-label": entity_id,
+                },
+            ).text = text
+            occupied.append(box)
+            break
+    ET.register_namespace("", NS)
+    return ET.tostring(root, encoding="unicode")

floorplan_scene/render_style.py

@@ -0,0 +1,126 @@
+"""Shared presentation colors and rules for SVG and PNG previews."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from .model import DOOR_OPENING_TYPES, PASSAGE_OPENING_TYPES, WINDOW_OPENING_TYPES
+
+DEFAULT_RENDER_COLORS = {
+    "background": "#FFFFFF",
+    "zone": "#EEF0F1",
+    "room": "#F0F1EE",
+    "room.living": "#F4EFE6",
+    "room.dining": "#F4EFE6",
+    "room.living_dining": "#F4EFE6",
+    "room.bedroom": "#F2E8DD",
+    "room.kitchen": "#EAF1E7",
+    "room.bathroom": "#E5F1F4",
+    "room.balcony": "#EDF3ED",
+    "room.circulation": "#ECEFF1",
+    "room.study": "#EEEBF2",
+    "room.storage": "#EEECE7",
+    "room.closet": "#EEECE7",
+    "room.laundry": "#EAF1E7",
+    "room.office": "#EEEBF2",
+    "room.multipurpose": "#F0F1EE",
+    "room.outline": "#C4CBD0",
+    "furniture": "#FAFBFC",
+    "furniture.outline": "#718089",
+    "floorOpening": "#E3F2FD",
+    "floorOpening.outline": "#81949F",
+    "building": "#A9B6C0",
+    "building.outline": "#606C72",
+    "wall": "#AEB7BB",
+    "wall.load_bearing": "#606C72",
+    "separator": "#9CA9AB",
+    "opening.door": "#AD7C4C",
+    "opening.passage": "#749184",
+    "opening.window": "#3485A5",
+    "opening.niche": "#9A8170",
+    "opening.unknown": "#718089",
+    "dimension": "#81949F",
+    "label": "#344B5C",
+    "hover.fill": "#E3EDF1",
+    "hover.stroke": "#48758A",
+    "selected.fill": "#D3E4EB",
+    "selected.stroke": "#315F74",
+}
+
+
+
+def render_stylesheet(colors: Mapping[str, str] | None = None) -> str:
+    """Build preview CSS; semantic SVG files remain free of presentation colors."""
+    palette = {**DEFAULT_RENDER_COLORS, **(colors or {})}
+    room_rules = "\n".join(
+        f'[data-layer="rooms"] > [id][data-type="{kind}"] {{ fill: {palette[f"room.{kind}"]}; }}'
+        for kind in (
+            "living",
+            "dining",
+            "living_dining",
+            "bedroom",
+            "kitchen",
+            "bathroom",
+            "balcony",
+            "circulation", "study", "storage", "closet", "laundry", "office", "multipurpose",
+        )
+    )
+    opening_rules = "\n".join(
+        f'{", ".join(f"""[data-layer="openings"] > [data-type="{kind}"]""" for kind in types)} '
+        f'{{ stroke: {palette[f"opening.{category}"]}; }}'
+        for category, types in (
+            ("door", sorted(DOOR_OPENING_TYPES)),
+            ("passage", sorted(PASSAGE_OPENING_TYPES)),
+            ("window", sorted(WINDOW_OPENING_TYPES)),
+            ("niche", ["NICHE"]),
+        )
+    )
+    opening_rules += (
+        f'\n[data-layer="openings"] > [id]:not([data-type]) '
+        f'{{ stroke: {palette["opening.unknown"]}; }}'
+    )
+    return f"""
+[data-layer="zones"] > [id] {{ fill: {palette["zone"]}; }}
+[data-layer="rooms"] > [id] {{ fill: {palette["room"]}; stroke: {palette["room.outline"]}; stroke-width: 7; }}
+{room_rules}
+[data-layer="floorOpenings"] > [id] {{ fill: {palette["floorOpening"]}; stroke: {palette["floorOpening.outline"]}; stroke-width: 16; stroke-dasharray: 60 40; }}
+[data-layer="furniture"] > [id] {{ fill: {palette["furniture"]}; stroke: {palette["furniture.outline"]}; stroke-width: 12; }}
+[data-layer="buildings"] [data-type="roof"] > [data-role="ridge"] {{ fill: none; stroke-width: 20; }}
+[data-layer="buildings"] > [id] {{ fill: {palette["building"]}; stroke: {palette["building.outline"]}; stroke-width: 12; }}
+[data-layer="buildings"] > [id][data-type="inspection_hatch"] {{ fill: none; }}
+[data-layer="walls"] > [id] {{ fill: {palette["wall"]}; stroke: {palette["wall"]}; }}
+[data-layer="walls"] > [id][data-load-bearing="true"] {{ fill: {palette["wall.load_bearing"]}; stroke: {palette["wall.load_bearing"]}; }}
+[data-layer="separators"] {{ fill: none; stroke: {palette["separator"]}; stroke-dasharray: 80 80; }}
+[data-layer="openings"] {{ fill: none; }}
+{opening_rules}
+[data-layer="dimensions"] {{ display: none; }}
+[data-layer="walls"] > [id] > *, [data-layer="furniture"] > [id] > *,
+[data-layer="buildings"] > [id] > *, [data-layer="openings"] > [id] > * {{ stroke: inherit; }}
+[data-render-layer="dimensions"] {{ fill: none; stroke: {palette["dimension"]}; pointer-events: none; }}
+[data-render-layer="dimensions"] text {{ fill: {palette["dimension"]}; stroke: {palette["background"]};
+  stroke-width: 3px; paint-order: stroke; font-family: "Noto Sans SC", sans-serif;
+  text-anchor: middle; dominant-baseline: central; pointer-events: none; }}
+[data-render-label] {{ fill: {palette["label"]}; stroke: {palette["background"]}; stroke-width: 3px;
+  paint-order: stroke; font-family: "Noto Sans SC", sans-serif; text-anchor: middle; dominant-baseline: central;
+  pointer-events: none; }}
+"""
+
+
+def rich_stylesheet(colors: Mapping[str, str] | None = None) -> str:
+    """Opening symbols and interaction use the same rules on screen and in exports."""
+    palette = {**DEFAULT_RENDER_COLORS, **(colors or {})}
+    return render_stylesheet(palette) + f"""
+svg {{ background: {palette['background']}; }}
+[id] {{ cursor: pointer; outline: none; transition: fill 120ms ease, stroke 120ms ease; }}
+[data-layer] > [id]:hover, [data-layer] > [id]:focus-visible, [data-layer] > [id].is-hovered {{ fill: {palette['hover.fill']}; stroke: {palette['hover.stroke']}; }}
+[data-layer] > [id][aria-pressed="true"], [data-layer] > [id].is-selected {{ fill: {palette['selected.fill']}; stroke: {palette['selected.stroke']}; }}
+[data-layer="openings"] > [id] > [data-opening-span] {{ display: none; }}
+[data-layer="openings"] > [id] > .opening-cutout {{ stroke: {palette['background']}; }}
+.opening-jamb, .opening-panel, .opening-edge, .door-leaf, .door-swing, .furniture-direction {{ fill: none; pointer-events: none; }}
+.opening-jamb, .opening-panel {{ stroke-width: 16; }}
+.opening-edge {{ stroke-width: 12; stroke-dasharray: 50 50; }}
+[data-layer="openings"] .opening-type-label {{ fill: {palette['opening.door']}; stroke: {palette['background']};
+  stroke-width: 16; paint-order: stroke; dominant-baseline: central; font-family: "Noto Sans SC", sans-serif; }}
+.door-leaf, .door-swing {{ stroke-width: 24; }}
+.furniture-direction {{ stroke: {palette['selected.stroke']}; stroke-width: 18; stroke-linecap: round; stroke-linejoin: round; }}
+"""