#!/usr/bin/env python3
"""Draw SVG overlays comparing source CAD vectors with extracted showcase geometry."""
from __future__ import annotations
import argparse
import html
import json
import math
import sys
from collections import defaultdict
from pathlib import Path
from typing import Any
sys.path.insert(0, str(Path(__file__).resolve().parent))
import derive_showcase_spec as derive # noqa: E402
CATEGORY_COLORS = {
"walls": "#c44e30",
"glazing": "#79b8c9",
"roof": "#b8ae98",
"columns": "#f58a1f",
"beams": "#1f66c2",
"railings": "#6f746d",
"doors": "#8a6a45",
"detail_lines": "#8c9088",
"floor_lines": "#18a058",
"grid": "#20242a",
}
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--dxf-dir", required=True, help="Sanitized DXF folder")
parser.add_argument("--config", required=True, help="Extraction config JSON")
parser.add_argument("--spec", required=True, help="building_spec.json")
parser.add_argument("--out-dir", required=True, help="Output folder for floor SVG overlays")
parser.add_argument("--vendor-dir", default="work/vendor")
return parser.parse_args()
def source_to_meters(point: tuple[float, float], offset: tuple[float, float], origin: tuple[float, float], scale: float) -> tuple[float, float]:
return (
(point[0] + offset[0] - origin[0]) * scale,
(point[1] + offset[1] - origin[1]) * scale,
)
def line_length(segment: tuple[tuple[float, float], tuple[float, float]]) -> float:
(sx, sy), (ex, ey) = segment
return math.hypot(ex - sx, ey - sy)
def collect_source_segments(dxf_dir: Path, config: dict[str, Any], spec: dict[str, Any], vendor_dir: Path) -> dict[str, list[dict[str, Any]]]:
ezdxf, recover = derive.import_ezdxf(vendor_dir)
patterns = derive.layer_patterns(config)
max_chord = float(config.get("curve_chord_source_length", 750.0))
scale = float(spec.get("units", {}).get("scale_to_meters", config.get("scale", 0.001)))
origin_values = spec.get("units", {}).get("origin_source", [0.0, 0.0])
origin = (float(origin_values[0]), float(origin_values[1]))
result: dict[str, list[dict[str, Any]]] = defaultdict(list)
drawings = config.get("drawings")
if not drawings:
drawings = [{"file": path.name, "floors": [{"key": path.stem}]} for path in sorted(dxf_dir.glob("*.dxf"))]
for drawing in drawings:
path = dxf_dir / drawing["file"]
if not path.exists():
continue
doc = derive.read_doc(path, ezdxf, recover)
floors = drawing.get("floors") or [{"key": path.stem}]
for floor in floors:
floor_key = str(floor["key"])
offset_values = floor.get("offset", drawing.get("offset", [0, 0]))
offset = (float(offset_values[0]), float(offset_values[1]))
for source_entity in doc.modelspace():
for entity, fallback_layer, block_name in derive.iter_model_entities(source_entity, config):
layer = derive.entity_layer(entity)
category = derive.category_for_entity(
entity,
patterns,
config,
fallback_layer=fallback_layer,
block_name=block_name,
)
for start, end in derive.entity_segments(entity, max_chord):
if line_length((start, end)) <= 0:
continue
if not derive.segment_matches_floor(start, end, floor, drawing):
continue
p1 = source_to_meters(start, offset, origin, scale)
p2 = source_to_meters(end, offset, origin, scale)
result[floor_key].append(
{
"start": p1,
"end": p2,
"category": category or "unclassified",
"layer": layer,
"source_type": entity.dxftype(),
"block_name": block_name,
}
)
return result
def bounds_for_floor(floor: dict[str, Any], source_segments: list[dict[str, Any]]) -> list[float]:
xs = [floor["bounds"][0], floor["bounds"][2]]
ys = [floor["bounds"][1], floor["bounds"][3]]
for segment in source_segments:
xs.extend([segment["start"][0], segment["end"][0]])
ys.extend([segment["start"][1], segment["end"][1]])
margin = 2.0
return [min(xs) - margin, min(ys) - margin, max(xs) + margin, max(ys) + margin]
def svg_line(segment: dict[str, Any], color: str, width: float, opacity: float, extra: str = "") -> str:
sx, sy = segment["start"]
ex, ey = segment["end"]
title = html.escape(f"{segment.get('category', '')} {segment.get('layer', '')} {segment.get('source_type', '')}")
return (
f'