Files
cad-building-showcase/scripts/derive_showcase_spec.py
zhengwr 1e11d38fa9 derive: per-cluster footprint hulls — twin-tower floors no longer bridged
concave_hull over all points cannot split disconnected masses: 13号 一号楼
standard floors (A/B towers in one floor key) got ONE 135.6m hull and
use_footprint_slabs laid plates across the 36m void (user-visible as
"triangular links" between towers). Points are now union-find clustered
(footprint_cluster_linkage, 6m grid buckets; segment endpoints forced into
one cluster) and hulled per cluster — real link bridges keep clusters
merged via their walls. F4-F10 now 2x49.8m hulls matching the site-plan
OBB; 黄桥/27号 re-derived with no regression; DoD visual check extended
(look at the AIR between masses in front/side views). Regression: twintower
scenario (+3 checks).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-03 07:48:22 +08:00

1179 lines
47 KiB
Python
Executable File

#!/usr/bin/env python3
"""Extract a normalized building_spec.json from sanitized DXF files."""
from __future__ import annotations
import argparse
import fnmatch
import json
import math
import re
import sys
from collections import defaultdict
from pathlib import Path
from typing import Any
DEFAULT_CATEGORIES = {
"walls": {"label": "墙体", "color": "#d4cbb8", "width": 0.20},
"glazing": {"label": "玻璃/幕墙", "color": "#79b8c9", "width": 0.055},
"roof": {"label": "屋顶/屋盖", "color": "#b8ae98", "width": 0.0},
"columns": {"label": "柱", "color": "#f58a1f", "width": 0.45},
"beams": {"label": "梁/结构", "color": "#1f66c2", "width": 0.35},
"railings": {"label": "栏杆/扶手", "color": "#6f746d", "width": 0.055},
"doors": {"label": "门/开启线", "color": "#8a6a45", "width": 0.045},
"detail_lines": {"label": "平面细节", "color": "#8c9088", "width": 0.025},
"floor_lines": {"label": "楼面线", "color": "#18a058", "width": 0.04},
"grid": {"label": "轴网", "color": "#20242a", "width": 0.02},
"slab": {"label": "楼板", "color": "#c8ccc2", "width": 0.0},
}
DEFAULT_LAYER_HINTS = {
"walls": ["I-WALL", "A-WALL", "L-SITE-WALL", "*WALL*", "*墙*"],
"glazing": ["A-GLAZ*", "*GLAZ*", "*CURT*", "*幕墙*", "*玻璃*"],
"roof": ["A-ROOF*", "*ROOF*", "*屋顶*", "*屋面*"],
"columns": ["S-COLS", "*COL*", "*COLUMN*", "*柱*"],
"beams": ["S-STRS", "S-STRS-MBND", "*BEAM*", "*梁*", "*结构*"],
"railings": ["A-FLOR-HRAL*", "*HRAL*", "*RAIL*", "*HANDRAIL*", "*栏杆*", "*扶手*"],
"doors": ["A-DOOR*", "*DOOR*", "*门*"],
"detail_lines": ["A-GENM", "A-DETL*", "C-PRKG", "*PRKG*", "*PARK*", "A-AREA", "A-FLOR-LEVL"],
"floor_lines": ["A-FLOR", "A-FLOR-OVHD", "*FLOOR*", "*FLOR*", "*楼面*", "*地面*"],
"grid": ["S-GRID", "*GRID*", "*轴网*", "*轴线*"],
}
# Curtain-wall / glazing geometry is commonly locked inside INSERT blocks whose
# exploded entities sit on glazing layers (e.g. A-GLAZ-CURT). Expanding only these
# block-name patterns by default captures glass without pulling in axis-number /
# dimension blocks. Disable with config {"expand_glazing_blocks": false}.
# DWG->DXF conversion can mangle CJK block names ("系统嵌板"->"系统嵌"), so the
# patterns are deliberately loose; layer-based probing below is the robust path.
GLAZING_BLOCK_PATTERNS = ["*幕墙*", "*玻璃*", "*嵌板*", "*系统嵌*", "*GLAZ*", "*CURT*", "*幕*"]
# Block-name matching alone misses geometry inside wrapper/sheet blocks and any
# block whose name was mangled during conversion. Probe mode therefore expands
# every INSERT up to expand_blocks_max_depth and keeps only sub-entities whose
# own layer classifies into one of these categories. Disable with
# {"classify_block_contents": false}; widen with {"block_content_categories": [...]}.
DEFAULT_BLOCK_CONTENT_CATEGORIES = ["glazing", "railings", "doors"]
# Identification/annotation layers (door tags, axis numbers, area labels) match
# broad category patterns like "A-DOOR*" but carry no element geometry.
DEFAULT_EXCLUDE_LAYER_PATTERNS = ["*-IDEN"]
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--dxf-dir", required=True, help="Folder containing sanitized DXF files")
parser.add_argument("--config", help="Extraction config JSON. If omitted, one floor per DXF is generated.")
parser.add_argument("--out", default="work/cad_showcase/building_spec.json")
parser.add_argument("--vendor-dir", default="work/vendor")
return parser.parse_args()
def import_ezdxf(vendor_dir: Path):
if vendor_dir.exists():
sys.path.insert(0, str(vendor_dir.resolve()))
try:
import ezdxf # type: ignore
from ezdxf import recover # type: ignore
except ImportError as exc:
raise SystemExit(
"Missing dependency: ezdxf. Install locally with:\n"
f" python3 -m pip install --target {vendor_dir} ezdxf"
) from exc
return ezdxf, recover
def read_json(path: Path | None) -> dict[str, Any]:
if not path:
return {}
return json.loads(path.read_text(encoding="utf-8"))
def read_doc(path: Path, ezdxf, recover):
try:
return ezdxf.readfile(path)
except ezdxf.DXFError:
doc, _auditor = recover.readfile(path)
return doc
def point_in_clip(point: tuple[float, float], clip: list[float] | None) -> bool:
if not clip:
return True
x1, y1, x2, y2 = clip
xmin, xmax = sorted((x1, x2))
ymin, ymax = sorted((y1, y2))
return xmin <= point[0] <= xmax and ymin <= point[1] <= ymax
def flatten_arc(entity, max_chord: float) -> list[tuple[float, float]]:
center = entity.dxf.center
radius = float(entity.dxf.radius)
start = math.radians(float(entity.dxf.start_angle))
end = math.radians(float(entity.dxf.end_angle))
if end < start:
end += math.tau
arc_len = abs(end - start) * radius
steps = max(8, min(96, int(max(arc_len / max(max_chord, 1.0), 8))))
return [
(
float(center.x + math.cos(start + (end - start) * i / steps) * radius),
float(center.y + math.sin(start + (end - start) * i / steps) * radius),
)
for i in range(steps + 1)
]
def flatten_circle(entity, max_chord: float) -> list[tuple[float, float]]:
center = entity.dxf.center
radius = float(entity.dxf.radius)
circumference = math.tau * radius
steps = max(24, min(144, int(max(circumference / max(max_chord, 1.0), 24))))
return [
(
float(center.x + math.cos(math.tau * i / steps) * radius),
float(center.y + math.sin(math.tau * i / steps) * radius),
)
for i in range(steps + 1)
]
def flatten_spline(entity, max_chord: float) -> list[tuple[float, float]]:
try:
points = list(entity.flattening(distance=max(max_chord, 1.0)))
except Exception:
return []
return [(float(point.x), float(point.y)) for point in points]
def segment_in_clip(start: tuple[float, float], end: tuple[float, float], clip: list[float] | None) -> bool:
midpoint = ((start[0] + end[0]) / 2.0, (start[1] + end[1]) / 2.0)
return point_in_clip(midpoint, clip) or point_in_clip(start, clip) or point_in_clip(end, clip)
def clip_segment_to_rect(
start: tuple[float, float], end: tuple[float, float], clip: list[float] | None
) -> tuple[tuple[float, float], tuple[float, float]] | None:
"""Trim a segment to the clip rectangle (Liang-Barsky).
Keeping whole segments whose midpoint falls inside the frame lets long
table borders / annotation rules carry the full sheet width into the
floor (13号地块: a 56 m frame emitted 143 m of geometry, and footprint
hulls grew stray plates). Fully-inside segments pass through unchanged.
"""
if not clip:
return start, end
x1, y1, x2, y2 = (float(v) for v in clip)
sx, sy = start
ex, ey = end
dx, dy = ex - sx, ey - sy
t0, t1 = 0.0, 1.0
for p, q in ((-dx, sx - x1), (dx, x2 - sx), (-dy, sy - y1), (dy, y2 - sy)):
if abs(p) < 1e-12:
if q < 0:
return None
continue
r = q / p
if p < 0:
if r > t1:
return None
if r > t0:
t0 = r
else:
if r < t0:
return None
if r < t1:
t1 = r
if t1 - t0 <= 1e-9:
return None
return (sx + t0 * dx, sy + t0 * dy), (sx + t1 * dx, sy + t1 * dy)
def segment_matches_floor(
start: tuple[float, float],
end: tuple[float, float],
floor: dict[str, Any],
drawing: dict[str, Any],
) -> bool:
clip = floor.get("clip", drawing.get("clip"))
if clip:
return segment_in_clip(start, end, clip)
split_x = floor.get("split_x", drawing.get("split_x"))
side = floor.get("side")
if split_x is not None and side:
midpoint_x = (start[0] + end[0]) / 2.0
if str(side).lower() in {"left", "west", "negative", "lt"}:
return midpoint_x < float(split_x)
if str(side).lower() in {"right", "east", "positive", "gt"}:
return midpoint_x >= float(split_x)
return True
def layer_patterns(config: dict[str, Any]) -> dict[str, list[str]]:
merged = {key: list(value) for key, value in DEFAULT_LAYER_HINTS.items()}
for key, patterns in config.get("layers", {}).items():
merged[key] = list(patterns)
return merged
def exclude_layer_patterns(config: dict[str, Any]) -> list[str]:
return list(config.get("exclude_layers", DEFAULT_EXCLUDE_LAYER_PATTERNS))
def match_category(
layer: str,
patterns_by_category: dict[str, list[str]],
exclude_patterns: list[str] | None = None,
) -> str | None:
upper_layer = layer.upper()
for pattern in exclude_patterns or []:
if fnmatch.fnmatch(upper_layer, str(pattern).upper()):
return None
for category, patterns in patterns_by_category.items():
for pattern in patterns:
upper_pattern = str(pattern).upper()
if fnmatch.fnmatch(upper_layer, upper_pattern):
return category
return None
def match_patterns(value: str, patterns: list[str]) -> bool:
upper_value = value.upper()
return any(fnmatch.fnmatch(upper_value, str(pattern).upper()) for pattern in patterns)
def block_category(block_name: str, config: dict[str, Any]) -> str | None:
for category, patterns in config.get("block_name_categories", {}).items():
if match_patterns(block_name, list(patterns)):
return category
return None
def entity_layer(entity) -> str:
return str(entity.dxf.layer) if entity.dxf.hasattr("layer") else ""
def category_for_entity(
entity,
patterns_by_category: dict[str, list[str]],
config: dict[str, Any],
fallback_layer: str = "",
block_name: str = "",
) -> str | None:
excludes = exclude_layer_patterns(config)
category = match_category(entity_layer(entity), patterns_by_category, excludes)
if not category and fallback_layer and config.get("block_insert_layer_fallback", True):
category = match_category(fallback_layer, patterns_by_category, excludes)
if not category and block_name:
category = block_category(block_name, config)
return category
def should_expand_insert(entity, config: dict[str, Any]) -> bool:
if entity.dxftype() != "INSERT":
return False
block_name = str(entity.dxf.name) if entity.dxf.hasattr("name") else ""
expand_blocks = config.get("expand_blocks", False)
if isinstance(expand_blocks, bool) and expand_blocks:
return True
if isinstance(expand_blocks, list) and match_patterns(block_name, expand_blocks):
return True
if config.get("expand_glazing_blocks", True) and match_patterns(block_name, GLAZING_BLOCK_PATTERNS):
return True
expand_block_names = config.get("expand_block_names", [])
return bool(expand_block_names and match_patterns(block_name, list(expand_block_names)))
_PROBE_CACHE: dict[int, tuple[dict[str, list[str]], list[str], set[str]]] = {}
def _probe_rules(config: dict[str, Any]) -> tuple[dict[str, list[str]], list[str], set[str]]:
cached = _PROBE_CACHE.get(id(config))
if cached is None:
cached = (
layer_patterns(config),
exclude_layer_patterns(config),
set(config.get("block_content_categories", DEFAULT_BLOCK_CONTENT_CATEGORIES)),
)
_PROBE_CACHE[id(config)] = cached
return cached
def probe_keep_entity(entity, config: dict[str, Any]) -> bool:
"""Keep a probed block sub-entity only if its own layer classifies."""
patterns, excludes, allowed = _probe_rules(config)
category = match_category(entity_layer(entity), patterns, excludes)
return category is not None and category in allowed
_BLOCK_LEAF_LAYERS: dict[tuple[int, str], frozenset[str]] = {}
def block_leaf_layers(doc, name: str, max_depth: int, depth: int = 0) -> frozenset[str]:
"""Layers used by a block definition (recursing into nested INSERTs).
Cheap definition walk (no explode/transform) memoized per document+name so
probe expansion can skip the expensive virtual explode for the vast
majority of blocks (axis bubbles, tags, hatched symbols) whose contents can
never classify into block_content_categories.
"""
key = (id(doc), name)
cached = _BLOCK_LEAF_LAYERS.get(key)
if cached is not None:
return cached
layers: set[str] = set()
try:
block = doc.blocks.get(name)
except Exception:
block = None
if block is not None:
for inner in block:
if inner.dxftype() == "INSERT" and depth < max_depth:
inner_name = str(inner.dxf.name) if inner.dxf.hasattr("name") else ""
if inner_name:
layers |= block_leaf_layers(doc, inner_name, max_depth, depth + 1)
else:
layers.add(entity_layer(inner))
result = frozenset(layers)
_BLOCK_LEAF_LAYERS[key] = result
return result
def probe_block_may_match(entity, config: dict[str, Any]) -> bool:
"""True if any leaf layer of the INSERT's block could classify for probing."""
doc = getattr(entity, "doc", None)
block_name = str(entity.dxf.name) if entity.dxf.hasattr("name") else ""
if doc is None or not block_name:
return True # cannot prove it is irrelevant; expand as before
patterns, excludes, allowed = _probe_rules(config)
max_depth = int(config.get("expand_blocks_max_depth", 2))
for layer in block_leaf_layers(doc, block_name, max_depth):
category = match_category(layer, patterns, excludes)
if category is not None and category in allowed:
return True
return False
def iter_model_entities(entity, config: dict[str, Any], depth: int = 0):
"""Yield (entity, fallback_layer, block_name) tuples to inspect/extract.
INSERT handling, in priority order:
- Explicit expansion (expand_blocks / glazing block-name patterns): yield all
sub-entities, with the insert layer as classification fallback.
- Probe expansion (classify_block_contents, default on): descend into every
block — including wrapper/sheet blocks and blocks with mangled names — but
keep only sub-entities whose own layer classifies into
block_content_categories. This is what captures curtain-wall glazing that
block-name matching misses.
"""
if entity.dxftype() != "INSERT":
yield entity, "", ""
return
explicit = should_expand_insert(entity, config)
probe = bool(config.get("classify_block_contents", True))
max_depth = int(config.get("expand_blocks_max_depth", 2))
if (not explicit and not probe) or depth >= max_depth:
yield entity, "", ""
return
if not explicit and probe and not probe_block_may_match(entity, config):
# No leaf layer of this block can classify -> exploding it cannot
# contribute geometry; skip the expensive virtual expansion.
yield entity, "", ""
return
insert_layer = entity_layer(entity)
block_name = str(entity.dxf.name) if entity.dxf.hasattr("name") else ""
try:
from ezdxf import explode as ezdxf_explode
virtual_entities = list(ezdxf_explode.virtual_block_reference_entities(entity))
except Exception:
yield entity, "", ""
return
for virtual_entity in virtual_entities:
if virtual_entity.dxftype() == "INSERT":
yield from iter_model_entities(virtual_entity, config, depth + 1)
elif explicit:
yield virtual_entity, insert_layer, block_name
elif probe_keep_entity(virtual_entity, config):
yield virtual_entity, "", block_name
def polyline_points(entity) -> list[tuple[float, float]]:
if entity.dxftype() == "LWPOLYLINE":
return [(float(x), float(y)) for x, y in entity.get_points("xy")]
if entity.dxftype() == "POLYLINE":
return [
(float(vertex.dxf.location.x), float(vertex.dxf.location.y))
for vertex in entity.vertices
]
return []
def points_from_entity(entity, max_chord: float) -> list[tuple[float, float]]:
dxftype = entity.dxftype()
if dxftype == "LINE":
return [
(float(entity.dxf.start.x), float(entity.dxf.start.y)),
(float(entity.dxf.end.x), float(entity.dxf.end.y)),
]
if dxftype in {"LWPOLYLINE", "POLYLINE"}:
return polyline_points(entity)
if dxftype == "ARC":
return flatten_arc(entity, max_chord)
if dxftype == "CIRCLE":
return flatten_circle(entity, max_chord)
if dxftype == "SPLINE":
return flatten_spline(entity, max_chord)
return []
def entity_segments(entity, max_chord: float) -> list[tuple[tuple[float, float], tuple[float, float]]]:
points = points_from_entity(entity, max_chord)
if len(points) < 2:
return []
pairs = list(zip(points, points[1:]))
if entity.dxftype() in {"LWPOLYLINE", "POLYLINE"}:
closed = bool(getattr(entity, "closed", False) or getattr(entity, "is_closed", False))
if closed and len(points) > 2 and points[0] != points[-1]:
pairs.append((points[-1], points[0]))
return pairs
def cleaned_segment(
start: tuple[float, float],
end: tuple[float, float],
offset: tuple[float, float],
min_source_length: float,
min_meters_length: float,
scale: float,
) -> tuple[tuple[float, float], tuple[float, float]] | None:
sx, sy = start[0] + offset[0], start[1] + offset[1]
ex, ey = end[0] + offset[0], end[1] + offset[1]
source_length = math.hypot(ex - sx, ey - sy)
if source_length < min_source_length or source_length * scale < min_meters_length:
return None
return (sx, sy), (ex, ey)
def auto_drawings(dxf_dir: Path) -> list[dict[str, Any]]:
drawings = []
for index, path in enumerate(sorted(dxf_dir.glob("*.dxf")), start=1):
key = f"F{index:02d}"
drawings.append(
{
"file": path.name,
"floors": [{"key": key, "name": path.stem}],
}
)
return drawings
def floor_sort_key(key: str) -> tuple[int, str]:
text = key.upper()
if text.startswith("B"):
number = int(re.sub(r"\D", "", text) or "1")
return (-number, text)
if text in {"RF", "ROOF"}:
return (999, text)
number = int(re.sub(r"\D", "", text) or "0")
return (number, text)
def collect_raw_segments(
dxf_dir: Path,
config: dict[str, Any],
ezdxf,
recover,
) -> tuple[dict[str, dict[str, Any]], list[dict[str, Any]]]:
patterns = layer_patterns(config)
default_widths = {
key: float(value.get("width", 0.1))
for key, value in DEFAULT_CATEGORIES.items()
}
default_widths.update({key: float(value) for key, value in config.get("default_widths", {}).items()})
scale = float(config.get("scale", config.get("scale_to_meters", 0.001)))
min_source_length = float(config.get("min_source_length", 1.0))
min_source_by_category = {
key: float(value) for key, value in config.get("min_source_length_by_category", {}).items()
}
min_meters_length = float(config.get("min_length_meters", 0.0))
min_meters_by_category = {
key: float(value) for key, value in config.get("min_length_meters_by_category", {}).items()
}
max_chord = float(config.get("curve_chord_source_length", 750.0))
drawings = config.get("drawings") or auto_drawings(dxf_dir)
floor_data: dict[str, dict[str, Any]] = {}
extraction_report: list[dict[str, Any]] = []
for drawing in drawings:
path = dxf_dir / drawing["file"]
if not path.exists():
extraction_report.append({"file": drawing["file"], "status": "missing"})
continue
doc = read_doc(path, ezdxf, recover)
entities = list(doc.modelspace())
floors = drawing.get("floors") or [{"key": Path(drawing["file"]).stem, "name": Path(drawing["file"]).stem}]
# Single pass over (expanded) entities, bucketed per floor. Expanding
# INSERTs per floor is O(floors x inserts) and times out on Chinese
# multi-frame sheets where one DWG holds every floor of a building.
floor_specs = []
buckets: dict[str, dict[str, list[dict[str, Any]]]] = {}
counts: dict[str, int] = {}
for floor in floors:
key = str(floor["key"])
offset_values = floor.get("offset", drawing.get("offset", [0, 0]))
floor_specs.append((floor, key, (float(offset_values[0]), float(offset_values[1]))))
buckets[key] = defaultdict(list)
counts[key] = 0
ignored_by_type: dict[str, int] = defaultdict(int)
for entity in entities:
for extracted_entity, fallback_layer, block_name in iter_model_entities(entity, config):
layer = entity_layer(extracted_entity)
category = category_for_entity(
extracted_entity,
patterns,
config,
fallback_layer=fallback_layer,
block_name=block_name,
)
if not category:
ignored_by_type[extracted_entity.dxftype()] += 1
continue
segments = entity_segments(extracted_entity, max_chord)
if not segments:
continue
source_type = extracted_entity.dxftype()
width = default_widths.get(category, 0.1)
min_source = min_source_by_category.get(category, min_source_length)
min_meters = min_meters_by_category.get(category, min_meters_length)
for start, end in segments:
for floor, key, offset in floor_specs:
if not segment_matches_floor(start, end, floor, drawing):
continue
trimmed = clip_segment_to_rect(start, end, floor.get("clip", drawing.get("clip")))
if trimmed is None:
continue
seg = cleaned_segment(trimmed[0], trimmed[1], offset, min_source, min_meters, scale)
if not seg:
continue
clean_start, clean_end = seg
buckets[key][category].append(
{
"start_source": clean_start,
"end_source": clean_end,
"width": width,
"layer": layer,
"source_type": source_type,
"block_name": block_name,
"fallback_layer": fallback_layer,
}
)
counts[key] += 1
for floor, key, _offset in floor_specs:
floor_data[key] = {
"key": key,
"name": str(floor.get("name", key)),
"z": floor.get("z"),
"height": float(floor.get("height", config.get("floor_height", 4.2))),
"source_file": path.name,
"segments_source": dict(buckets[key]),
}
extraction_report.append(
{
"file": path.name,
"floor": key,
"status": "ok",
"segments": counts[key],
"ignored_entity_types": dict(sorted(ignored_by_type.items())),
}
)
return floor_data, extraction_report
def source_origin(floor_data: dict[str, dict[str, Any]], config: dict[str, Any]) -> tuple[float, float]:
if "origin" in config:
origin = config["origin"]
return float(origin[0]), float(origin[1])
xs: list[float] = []
ys: list[float] = []
for floor in floor_data.values():
for segments in floor["segments_source"].values():
for segment in segments:
xs.extend([segment["start_source"][0], segment["end_source"][0]])
ys.extend([segment["start_source"][1], segment["end_source"][1]])
if not xs:
return 0.0, 0.0
if config.get("origin_strategy", "min") == "center":
return (min(xs) + max(xs)) / 2.0, (min(ys) + max(ys)) / 2.0
return min(xs), min(ys)
def to_meters(point: tuple[float, float], origin: tuple[float, float], scale: float) -> list[float]:
return [
round((point[0] - origin[0]) * scale, 6),
round((point[1] - origin[1]) * scale, 6),
]
def generated_footprint(segments: dict[str, list[dict[str, Any]]], config: dict[str, Any]) -> dict[str, Any] | None:
if not config.get("generate_footprints", False):
return None
try:
from shapely import MultiPoint, concave_hull # type: ignore
except Exception:
return None
categories = list(config.get("footprint_categories", ["walls", "glazing", "floor_lines", "railings", "columns"]))
points: list[tuple[float, float]] = []
for category in categories:
for segment in segments.get(category, []):
start = segment.get("start")
end = segment.get("end")
if not start or not end:
continue
points.append((float(start[0]), float(start[1])))
points.append((float(end[0]), float(end[1])))
unique_points = sorted(set(points))
if len(unique_points) < 4:
return None
# Cluster points by proximity BEFORE hulling: concave_hull over all points
# can never split disconnected masses, so a twin-tower floor got ONE
# bridged hull and use_footprint_slabs laid plates across the 36 m void
# (13号 一号楼 A/B座). Per-cluster hulls keep genuinely linked wings —
# a real 连廊 contributes walls that join the clusters.
linkage = float(config.get("footprint_cluster_linkage", 6.0))
parent = list(range(len(unique_points)))
def find(a: int) -> int:
while parent[a] != a:
parent[a] = parent[parent[a]]
a = parent[a]
return a
def union(a: int, b: int) -> None:
ra, rb = find(a), find(b)
if ra != rb:
parent[rb] = ra
cell = max(linkage, 1e-6)
buckets: dict[tuple[int, int], list[int]] = {}
for idx, (px, py) in enumerate(unique_points):
buckets.setdefault((int(px // cell), int(py // cell)), []).append(idx)
for (bx, by), members in buckets.items():
for gx in (bx - 1, bx, bx + 1):
for gy in (by - 1, by, by + 1):
for other in buckets.get((gx, gy), []):
union(members[0], other)
for other in members[1:]:
union(members[0], other)
# Segments span their endpoints: both ends of one segment belong together.
seg_pt_index = {pt: i for i, pt in enumerate(unique_points)}
for category in categories:
for segment in segments.get(category, []):
start = segment.get("start")
end = segment.get("end")
if not start or not end:
continue
a = seg_pt_index.get((float(start[0]), float(start[1])))
b = seg_pt_index.get((float(end[0]), float(end[1])))
if a is not None and b is not None:
union(a, b)
clusters: dict[int, list[tuple[float, float]]] = {}
for idx, pt in enumerate(unique_points):
clusters.setdefault(find(idx), []).append(pt)
ratio = float(config.get("footprint_concave_ratio", 0.35))
simplify = float(config.get("footprint_simplify_tolerance", 0.12))
min_area = float(config.get("footprint_min_area", 8.0))
polygons = []
try:
for cluster_pts in clusters.values():
if len(cluster_pts) < 4:
continue
hull = concave_hull(MultiPoint(cluster_pts), ratio=ratio)
if simplify > 0:
hull = hull.simplify(simplify, preserve_topology=True)
if hull.is_empty or hull.area < min_area:
continue
if hull.geom_type == "Polygon":
polygons.append(hull)
elif hull.geom_type == "MultiPolygon":
polygons.extend(hull.geoms)
if not polygons:
return None
except Exception:
return None
result_polygons = []
for polygon in sorted(polygons, key=lambda item: item.area, reverse=True):
if polygon.area < min_area:
continue
coords = [[round(float(x), 6), round(float(y), 6)] for x, y in polygon.exterior.coords]
if len(coords) > 3:
result_polygons.append(coords)
max_polygons = int(config.get("footprint_max_polygons", 3))
if len(result_polygons) >= max_polygons:
break
if not result_polygons:
return None
return {
"source": "concave_hull",
"categories": categories,
"polygons": result_polygons,
"area": round(sum(abs(polygon.area) for polygon in polygons), 3),
}
def merge_collinear(segs: list[dict[str, Any]], angle_tol_deg: float = 6.0, offset_tol: float = 0.30, gap_tol: float = 3.6) -> list[dict[str, Any]]:
"""Merge collinear, near-touching segments into continuous spans.
CAD curtain walls are often drawn as sparse panel/mullion segments with gaps;
extruding each one gives a row of disconnected glass fins. Merging along each
facade line (bridging gaps up to ``gap_tol``) yields continuous glazing bands.
Only bridge gaps that contain no opaque wall on the same line.
"""
groups: dict[tuple, list] = {}
keep: list[dict[str, Any]] = []
for s in segs:
a = s["start"]; b = s["end"]
dx = b[0] - a[0]; dy = b[1] - a[1]; length = math.hypot(dx, dy)
if length < 1e-6:
keep.append(s); continue
ang = math.atan2(dy, dx) % math.pi
akey = round(ang / math.radians(angle_tol_deg))
nx, ny = -dy / length, dx / length
okey = round((a[0] * nx + a[1] * ny) / offset_tol)
groups.setdefault((akey, okey), []).append((a, b, nx, ny, float(s.get("width", 0.06)), s.get("layer", "")))
out = list(keep)
for items in groups.values():
a0, b0, nx, ny, width, layer = items[0]
dirx, diry = -ny, nx
offv = a0[0] * nx + a0[1] * ny
intervals = []
for (a, b, *_rest) in items:
t0 = a[0] * dirx + a[1] * diry; t1 = b[0] * dirx + b[1] * diry
intervals.append([min(t0, t1), max(t0, t1)])
intervals.sort()
merged = [intervals[0][:]]
for lo, hi in intervals[1:]:
if lo <= merged[-1][1] + gap_tol:
merged[-1][1] = max(merged[-1][1], hi)
else:
merged.append([lo, hi])
for lo, hi in merged:
out.append({
"start": [round(offv * nx + lo * dirx, 6), round(offv * ny + lo * diry, 6)],
"end": [round(offv * nx + hi * dirx, 6), round(offv * ny + hi * diry, 6)],
"width": width, "layer": layer, "source_type": "merged",
})
return out
def _cap_floor_group(fk: str, config: dict[str, Any] | None = None) -> str:
"""Cap grouping: which floors stack in the same tower for cap logic.
Configurable via config["cap_groups"] = [["AUX_*", "AUX"], ["B*", "BASE"], ...]
(fnmatch patterns, first match wins). Defaults reproduce the A208 case:
AUX_* prefix = annex tower, B1/B1M = basement, everything else = main.
"""
for pattern, group in (config or {}).get("cap_groups", []):
if fnmatch.fnmatch(fk.upper(), str(pattern).upper()):
return str(group)
if fk.startswith("AUX_"):
return "AUX"
if fk in {"B1", "B1M"}:
return "BASE"
return "MAIN"
def _shapely_union(polys: list):
try:
from shapely.geometry import Polygon
from shapely.ops import unary_union
except Exception:
return None
gs = []
for p in polys:
try:
g = Polygon(p)
if not g.is_valid:
g = g.buffer(0)
if not g.is_empty and g.area > 0:
gs.append(g)
except Exception:
pass
return unary_union(gs) if gs else None
def _shapely_to_polys(geom, min_area: float = 3.0) -> list[list[list[float]]]:
res = []
if geom is None or geom.is_empty:
return res
geoms = [geom] if geom.geom_type == "Polygon" else list(getattr(geom, "geoms", []))
for g in geoms:
if g.geom_type != "Polygon" or g.area < min_area:
continue
res.append([[round(float(x), 6), round(float(y), 6)] for x, y in g.exterior.coords])
return res
def compute_caps(floors: dict[str, Any], config: dict[str, Any]) -> None:
"""Store floor['caps'] = [{z, polygons}] that close column tops.
- Above-ground setback floor: cap = own_footprint(buffered) - upper_footprint.
- Basement top (no same-group upper): cap = full footprint (ground/podium deck).
Requires shapely; silently no-ops if unavailable or footprints missing.
"""
if not config.get("generate_caps", True):
return
buf = float(config.get("cap_buffer", 1.3))
for fk, fl in floors.items():
own_polys = fl.get("footprint", {}).get("polygons", [])
if not own_polys:
continue
ftop = float(fl["z"]) + float(fl.get("height", 4.2))
grp = _cap_floor_group(fk, config)
upper = []
for ok, ot in floors.items():
if ok == fk or _cap_floor_group(ok, config) != grp:
continue
if abs(float(ot.get("z", 0.0)) - ftop) > 0.8:
continue
upper.extend(ot.get("footprint", {}).get("polygons", []))
own_u = _shapely_union(own_polys)
if own_u is None:
return # shapely unavailable
if not upper:
if grp == "BASE":
polys = _shapely_to_polys(own_u.buffer(0.5))
else:
polys = [] # roof_specs handles above-ground tops
else:
up_u = _shapely_union(upper)
polys = _shapely_to_polys(own_u.buffer(buf).difference(up_u.buffer(0.05))) if up_u is not None else []
if polys:
fl.setdefault("caps", []).append({"z": round(ftop, 6), "polygons": polys})
def drop_isolated_clusters(segments: dict[str, list[dict[str, Any]]], config: dict[str, Any], floor_key: str) -> dict[str, list[dict[str, Any]]]:
"""Drop tiny segment clusters far away from the floor's main mass.
Sheet legends and title blocks draw window/door symbols with REAL geometry
layers (黄桥: four 1 m CURTWALL strips 30 m east of the building on every
frame), so layer exclusion cannot catch them — and the generated footprint
hull then stretches into sliver fins ("每层一个尖角"). Cluster all
classified segments by endpoint proximity, keep the largest cluster plus
anything near it or substantial, and WARN about what was dropped.
Config: {"drop_isolated_clusters": false} disables; tuning knobs
cluster_linkage (m, 3.0), isolation_distance (m, 12.0),
isolation_min_length (m, 15.0).
"""
if not config.get("drop_isolated_clusters", True):
return segments
linkage = float(config.get("cluster_linkage", 3.0))
iso_dist = float(config.get("isolation_distance", 12.0))
min_len = float(config.get("isolation_min_length", 15.0))
items: list[tuple[str, int, dict[str, Any]]] = []
for category, segs in segments.items():
for i, seg in enumerate(segs):
items.append((category, i, seg))
if len(items) < 2:
return segments
parent = list(range(len(items)))
def find(a: int) -> int:
while parent[a] != a:
parent[a] = parent[parent[a]]
a = parent[a]
return a
def union(a: int, b: int) -> None:
ra, rb = find(a), find(b)
if ra != rb:
parent[rb] = ra
cell = max(linkage, 1e-6)
buckets: dict[tuple[int, int], list[int]] = {}
for idx, (_c, _i, seg) in enumerate(items):
for px, py in (seg["start"], seg["end"]):
buckets.setdefault((int(px // cell), int(py // cell)), []).append(idx)
for (bx, by), members in buckets.items():
for gx in (bx - 1, bx, bx + 1):
for gy in (by - 1, by, by + 1):
for other in buckets.get((gx, gy), []):
union(members[0], other)
for other in members[1:]:
union(members[0], other)
clusters: dict[int, list[int]] = {}
for idx in range(len(items)):
clusters.setdefault(find(idx), []).append(idx)
def cluster_stats(indices: list[int]) -> tuple[float, list[float]]:
total = 0.0
bx = [math.inf, math.inf, -math.inf, -math.inf]
for idx in indices:
seg = items[idx][2]
(x1, y1), (x2, y2) = seg["start"], seg["end"]
total += math.hypot(x2 - x1, y2 - y1)
bx[0] = min(bx[0], x1, x2); bx[1] = min(bx[1], y1, y2)
bx[2] = max(bx[2], x1, x2); bx[3] = max(bx[3], y1, y2)
return total, bx
stats = {root: cluster_stats(idx_list) for root, idx_list in clusters.items()}
main_root = max(stats, key=lambda r: stats[r][0])
main_box = stats[main_root][1]
def box_gap(a: list[float], b: list[float]) -> float:
dx = max(0.0, max(a[0] - b[2], b[0] - a[2]))
dy = max(0.0, max(a[1] - b[3], b[1] - a[3]))
return math.hypot(dx, dy)
dropped: set[int] = set()
for root, idx_list in clusters.items():
if root == main_root:
continue
total, box = stats[root]
gap = box_gap(main_box, box)
if gap > iso_dist and total < min_len:
dropped.update(idx_list)
print(
f"WARNING isolated_cluster {floor_key}: dropped {len(idx_list)} segments "
f"({total:.1f}m total, {gap:.0f}m from main mass) — likely sheet legend/"
"title-block content; set drop_isolated_clusters=false to keep",
file=sys.stderr,
)
if not dropped:
return segments
dropped_keys = {(items[d][0], items[d][1]) for d in dropped}
return {
category: [seg for i, seg in enumerate(segs) if (category, i) not in dropped_keys]
for category, segs in segments.items()
}
def drop_unsupported_roof_lines(floors: dict[str, Any], config: dict[str, Any]) -> None:
"""Drop roof outlines that would extrude into ribbons floating in mid-air.
Plans draw low canopies / porch roofs whose supports are hatch-only
columns the extractor cannot capture (黄桥: 坡屋面 outlines on the F3
sheet with zero walls beneath on any floor). A roof segment is kept only
if some plate exists under it — any floor's footprint or cap polygon
within roof_support_distance (m, default 2.0). Dropped segments are
reported loudly; keep them via {"drop_unsupported_roof_lines": false} or
model the canopy explicitly with a roof_specs plate.
"""
if not config.get("drop_unsupported_roof_lines", True):
return
try:
from shapely.geometry import Point, Polygon
from shapely.ops import unary_union
except ImportError:
return
plates = []
for fl in floors.values():
polys = list(fl.get("footprint", {}).get("polygons", []))
for cap in fl.get("caps", []):
polys.extend(cap.get("polygons", []))
for coords in polys:
try:
poly = Polygon([(float(x), float(y)) for x, y in coords])
if not poly.is_valid:
poly = poly.buffer(0)
if not poly.is_empty:
plates.append(poly)
except Exception:
continue
if not plates:
return # no footprint evidence at all — nothing to judge against
support = unary_union(plates).buffer(float(config.get("roof_support_distance", 2.0)))
for key, fl in floors.items():
roof = fl.get("segments", {}).get("roof")
if not roof:
continue
kept, dropped_len, dropped = [], 0.0, 0
for seg in roof:
mid = Point((seg["start"][0] + seg["end"][0]) / 2.0, (seg["start"][1] + seg["end"][1]) / 2.0)
if support.contains(mid):
kept.append(seg)
else:
dropped += 1
dropped_len += math.hypot(seg["end"][0] - seg["start"][0], seg["end"][1] - seg["start"][1])
if dropped:
print(
f"WARNING unsupported_roof {key}: dropped {dropped} roof segments "
f"({dropped_len:.1f}m) with no slab/cap beneath — likely a canopy whose "
"supports are hatch-only; set drop_unsupported_roof_lines=false or add a "
"roof_specs plate to keep them",
file=sys.stderr,
)
fl["segments"]["roof"] = kept
def finalize_spec(
floor_data: dict[str, dict[str, Any]],
config: dict[str, Any],
extraction_report: list[dict[str, Any]],
dxf_dir: Path,
) -> dict[str, Any]:
scale = float(config.get("scale", config.get("scale_to_meters", 0.001)))
origin = source_origin(floor_data, config)
ordered_keys = config.get("floor_order") or sorted(floor_data.keys(), key=floor_sort_key)
# floor_order gaps must be LOUD: a stale floor_order copied from a sibling
# config silently dropped 13号 b2 F11-F16 ("floors":12 was the only tell).
missing_from_order = [k for k in floor_data if k not in ordered_keys]
if missing_from_order:
print(
f"WARNING floor_order missing keys {missing_from_order}: these floors are "
"extracted in config drawings but NOT in floor_order — they would be "
"silently dropped. Add them to floor_order (or remove them from drawings).",
file=sys.stderr,
)
ghost_keys = [k for k in ordered_keys if k not in floor_data]
if ghost_keys:
print(
f"WARNING floor_order ghost keys {ghost_keys}: present in floor_order but "
"no drawing produces them — check for typos or missing drawing entries.",
file=sys.stderr,
)
floors: dict[str, Any] = {}
for index, key in enumerate(ordered_keys):
if key not in floor_data:
continue
floor = floor_data[key]
segments: dict[str, list[dict[str, Any]]] = {category: [] for category in DEFAULT_CATEGORIES if category != "slab"}
xs: list[float] = []
ys: list[float] = []
for category, raw_segments in floor["segments_source"].items():
for raw in raw_segments:
start = to_meters(raw["start_source"], origin, scale)
end = to_meters(raw["end_source"], origin, scale)
xs.extend([start[0], end[0]])
ys.extend([start[1], end[1]])
segments.setdefault(category, []).append(
{
"start": start,
"end": end,
"width": float(raw["width"]),
"layer": raw["layer"],
"source_type": raw["source_type"],
}
)
segments = drop_isolated_clusters(segments, config, key)
xs = [p for segs in segments.values() for seg in segs for p in (seg["start"][0], seg["end"][0])]
ys = [p for segs in segments.values() for seg in segs for p in (seg["start"][1], seg["end"][1])]
bounds = [
round(min(xs), 6) if xs else 0.0,
round(min(ys), 6) if ys else 0.0,
round(max(xs), 6) if xs else 1.0,
round(max(ys), 6) if ys else 1.0,
]
floor_height = float(floor["height"])
z = float(floor["z"]) if floor["z"] is not None else index * floor_height
floors[key] = {
"name": floor["name"],
"z": round(z, 6),
"height": floor_height,
"bounds": bounds,
"source_file": floor["source_file"],
"segments": segments,
}
footprint = generated_footprint(segments, config)
if footprint:
floors[key]["footprint"] = footprint
# Post-process: make facade glazing continuous, and cap column tops.
if config.get("merge_glazing", True):
for floor in floors.values():
glz = floor.get("segments", {}).get("glazing")
if glz:
floor["segments"]["glazing"] = merge_collinear(
glz,
gap_tol=float(config.get("glazing_gap_tol", 3.6)),
)
compute_caps(floors, config)
drop_unsupported_roof_lines(floors, config)
# Topless-roof guard: the top above-ground floor of each group must end in
# a cap or a config roof_specs entry, otherwise the model renders open-top
# ("没有屋顶"). Warn loudly so the Agent adds roof_specs before building.
roof_tops: dict[str, float] = {}
for r in config.get("roof_specs", []):
fk = str(r.get("floor_key"))
if fk not in floors:
continue
grp = _cap_floor_group(fk, config)
z = float(r.get("z", float(floors[fk]["z"]) + float(floors[fk].get("height", 4.2))))
roof_tops[grp] = max(roof_tops.get(grp, -1e9), z)
groups: dict[str, str] = {}
for key in floors:
grp = _cap_floor_group(key, config)
if grp not in groups or float(floors[key]["z"]) > float(floors[groups[grp]]["z"]):
groups[grp] = key
for grp, top_key in groups.items():
top = floors[top_key]
covered = roof_tops.get(grp, -1e9) >= float(top["z"]) - 0.8
if grp != "BASE" and not top.get("caps") and not covered:
print(
f"WARNING topless_group {grp}: top floor '{top_key}' has no caps and no "
f"roof_specs entry; add config roof_specs=[{{'floor_key': '{top_key}', ...}}] "
"or the model will have no roof plate.",
file=sys.stderr,
)
categories = {
key: {"label": value["label"], "color": value["color"]}
for key, value in DEFAULT_CATEGORIES.items()
}
for key, value in config.get("categories", {}).items():
categories.setdefault(key, {}).update(value)
return {
"project": {
"name": config.get("project_name", "CAD Building Showcase"),
"description": config.get("description", "建筑 CAD 生成的 Web 展示模型"),
},
"source": {
"dxf_dir": str(dxf_dir),
"config": config,
},
"units": {
"source": config.get("source_units", "millimeters"),
"scale_to_meters": scale,
"origin_source": [origin[0], origin[1]],
},
"categories": categories,
"floors": floors,
"extraction_report": extraction_report,
}
def main() -> int:
args = parse_args()
dxf_dir = Path(args.dxf_dir)
if not dxf_dir.exists():
raise SystemExit(f"DXF folder not found: {dxf_dir}")
config = read_json(Path(args.config) if args.config else None)
ezdxf, recover = import_ezdxf(Path(args.vendor_dir))
floor_data, extraction_report = collect_raw_segments(dxf_dir, config, ezdxf, recover)
spec = finalize_spec(floor_data, config, extraction_report, dxf_dir)
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(spec, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps({"out": str(out), "floors": len(spec["floors"])}, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())