floorplan-scene 0.1.0__py3-none-any.whl

floorplan_scene/__init__.py

@@ -0,0 +1,20 @@
+"""Floor plan data structures and format conversion; no application services."""
+from .fpi import FpiImport, FpiSupplement, export_fpi, import_fpi
+from .model import FloorplanScene, read_json, scene_from_dict, scene_to_dict
+from .rich_svg import enrich_svg, scene_to_rich_svg
+from .svg import scene_to_svg, svg_to_scene
+
+__all__ = [
+           "FloorplanScene",
+           "FpiImport",
+           "FpiSupplement",
+           "enrich_svg",
+           "export_fpi",
+           "import_fpi",
+           "read_json",
+           "scene_from_dict",
+           "scene_to_dict",
+           "scene_to_rich_svg",
+           "scene_to_svg",
+           "svg_to_scene",
+]

floorplan_scene/component-defaults.json

@@ -0,0 +1,16 @@
+{
+  "unit": "mm",
+  "source": "kam-service Constants.java and AbstractFpiBayWindowSillStrategy.java",
+  "bay_window_sill": {
+    "windowHeight": 1700,
+    "offset": 450,
+    "upperFloorThickness": 120,
+    "lowerFloorThickness": 120,
+    "wallThickness": 120,
+    "beamThickness": 120
+  },
+  "beam": {
+    "height": 600
+  },
+  "beamSource": "kam-service@bb34fd64d82800b6a507006a045891086295d074 kammodel/constrants/Constant.java DEFAULT_BEAM_HEIGHT"
+}

floorplan_scene/component_defaults.py

@@ -0,0 +1,11 @@
+"""Bundled component defaults; explicit source values always take precedence."""
+
+import json
+from functools import lru_cache
+from importlib.resources import files
+from typing import Any
+
+
+@lru_cache(maxsize=1)
+def component_defaults() -> dict[str, Any]:
+    return dict(json.loads(files(__package__).joinpath("component-defaults.json").read_text()))

floorplan_scene/dimensions.py

@@ -0,0 +1,140 @@
+"""Dimensions that make the current Scene's geometric scale readable."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import replace
+from statistics import median
+from typing import Any
+
+from shapely.errors import GEOSException  # type: ignore[import-untyped]
+from shapely.geometry import LineString  # type: ignore[import-untyped]
+from shapely.geometry import Point as ShapelyPoint
+from shapely.ops import unary_union  # type: ignore[import-untyped]
+
+from .geometry import polygon_parts
+from .model import DimensionAnnotation, FloorplanScene, Wall
+from .shape_geometry import geometry_shape, wall_shape
+from .shapes import LineGeometry, Point
+
+
+def scene_shell(scene: FloorplanScene) -> Any | None:
+    """Return the largest connected room-and-wall shell used for exterior checks."""
+    shapes = [geometry_shape(room.geometry) for room in scene.rooms]
+    shapes.extend(wall_shape(wall) for wall in scene.walls)
+    # A crossed outline has no reliable exterior. Keep the source geometry visible
+    # and use the existing no-shell label placement instead of failing the preview.
+    if any(not shape.is_valid for shape in shapes):
+        return None
+    try:
+        polygons = polygon_parts(unary_union(shapes).buffer(0)) if shapes else []
+    except GEOSException:
+        return None
+    return max(polygons, key=lambda polygon: polygon.area, default=None)
+
+
+def _typical_thickness(scene: FloorplanScene) -> float:
+    values = [wall.thickness for wall in scene.walls if wall.thickness is not None and wall.thickness > 0]
+    return float(median(values)) if values else 200.0
+
+
+def _wall_outward_normal(shell: Any, wall: Wall, fallback_thickness: float) -> tuple[Point, int] | None:
+    if not isinstance(wall.geometry, LineGeometry):
+        return None
+    start, end = wall.geometry.start, wall.geometry.end
+    dx, dy = end[0] - start[0], end[1] - start[1]
+    length = math.hypot(dx, dy)
+    if length < 0.5:
+        return None
+    normal = (-dy / length, dx / length)
+    half_thickness = (wall.thickness or fallback_thickness) / 2
+    if LineString((start, end)).distance(shell.exterior) > half_thickness + 10:
+        return None
+
+    outside_signs: list[int] = []
+    distance = half_thickness + 5
+    for ratio in (0.25, 0.5, 0.75):
+        point = (start[0] + dx * ratio, start[1] + dy * ratio)
+        plus = shell.covers(
+            ShapelyPoint(point[0] + normal[0] * distance, point[1] + normal[1] * distance)
+        )
+        minus = shell.covers(
+            ShapelyPoint(point[0] - normal[0] * distance, point[1] - normal[1] * distance)
+        )
+        if plus != minus:
+            outside_signs.append(1 if not plus else -1)
+    if len(outside_signs) < 2 or abs(sum(outside_signs)) != len(outside_signs):
+        return None
+    sign = outside_signs[0]
+    return (normal[0] * sign, normal[1] * sign), len(outside_signs)
+
+
+def dimension_outward_normal(scene: FloorplanScene, dimension: DimensionAnnotation) -> Point | None:
+    """Prefer the referenced exterior wall; otherwise face away from the plan center."""
+    wall = next((item for item in scene.walls if item.id == dimension.refId), None)
+    shell = scene_shell(scene)
+    if wall is not None and shell is not None:
+        result = _wall_outward_normal(shell, wall, _typical_thickness(scene))
+        if result is not None:
+            return result[0]
+    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:
+        return None
+    normal = (-dy / length, dx / length)
+    if shell is not None:
+        center = shell.centroid
+        projection = ((start[0] + end[0]) / 2 - center.x) * normal[0] + (
+            (start[1] + end[1]) / 2 - center.y
+        ) * normal[1]
+        if projection < 0:
+            normal = (-normal[0], -normal[1])
+    return normal
+
+
+def with_default_dimension(scene: FloorplanScene) -> FloorplanScene:
+    """Add one useful exterior-wall dimension when the Scene has none."""
+    if scene.dimensionAnnotations:
+        return scene
+    shell = scene_shell(scene)
+    if shell is None:
+        return scene
+    fallback_thickness = _typical_thickness(scene)
+    candidates: list[tuple[float, int, int, Wall]] = []
+    for index, wall in enumerate(scene.walls):
+        result = _wall_outward_normal(shell, wall, fallback_thickness)
+        if result is None or not isinstance(wall.geometry, LineGeometry):
+            continue
+        length = math.dist(wall.geometry.start, wall.geometry.end)
+        if round(length) > 0:
+            candidates.append((length, result[1], -index, wall))
+    if not candidates:
+        return scene
+
+    wall = max(candidates)[3]
+    assert isinstance(wall.geometry, LineGeometry)
+    used_ids = {
+        item.id
+        for collection in (
+            scene.rooms,
+            scene.walls,
+            scene.separators,
+            scene.openings,
+            scene.buildings,
+            scene.floorOpenings,
+            scene.furniture,
+            scene.zones,
+        )
+        for item in collection
+    }
+    number = 1
+    while f"D{number}" in used_ids:
+        number += 1
+    dimension = DimensionAnnotation(
+        f"D{number}",
+        round(math.dist(wall.geometry.start, wall.geometry.end)),
+        wall.geometry,
+        wall.id,
+    )
+    return replace(scene, dimensionAnnotations=(dimension,))