#!/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 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 seg = cleaned_segment(start, end, 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 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)) try: hull = concave_hull(MultiPoint(unique_points), ratio=ratio) if simplify > 0: hull = hull.simplify(simplify, preserve_topology=True) if hull.is_empty or hull.area < min_area: return None if hull.geom_type == "Polygon": polygons = [hull] elif hull.geom_type == "MultiPolygon": polygons = list(hull.geoms) else: 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 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) 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"], } ) 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) # 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())