#!/usr/bin/env python3 """Audit extraction coverage so the agent can judge what may be missing.""" from __future__ import annotations import argparse import json import math import sys from collections import Counter, 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 import showcase_schema # noqa: E402 HIGH_RISK_TYPES = { "INSERT", "HATCH", "SOLID", "3DFACE", "REGION", "ACAD_PROXY_ENTITY", "DIMENSION", "TEXT", "MTEXT", "IMAGE", "WIPEOUT", } 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="Generated building_spec.json") parser.add_argument("--out", default="work/cad_showcase/extraction_audit", help="Output path stem or folder") parser.add_argument("--vendor-dir", default="work/vendor") parser.add_argument( "--no-strict-gates", action="store_true", help="Report gate failures without a nonzero exit code", ) parser.add_argument( "--frames", nargs="*", default=None, help="detect_sheet_frames out-config JSON(s): enables the frame-ledger gate " "(every detected plan frame must be in the extraction config or listed " "in config discarded_frames with a reason)", ) return parser.parse_args() _BLOCK_LENGTHS_CACHE: dict[tuple[int, str], dict[str, float]] = {} def block_layer_unit_lengths(doc, name: str, max_chord: float, max_depth: int, depth: int = 0) -> dict[str, float]: """Per-layer supported length inside a block DEFINITION (unit scale). Exploding every INSERT for accounting is O(inserts x block size) and times out on real Chinese sheet sets (hundreds of identical axis/door/window blocks). Walking the definition once per block name and multiplying by the insert scale gives the same length totals (rotation preserves length; non-uniform scales are approximated by the mean of |sx|,|sy|). """ key = (id(doc), name) cached = _BLOCK_LENGTHS_CACHE.get(key) if cached is not None: return cached totals: dict[str, float] = defaultdict(float) 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 not inner_name: continue sx = abs(float(inner.dxf.get("xscale", 1.0) or 1.0)) sy = abs(float(inner.dxf.get("yscale", 1.0) or 1.0)) factor = (sx + sy) / 2.0 for layer, length in block_layer_unit_lengths(doc, inner_name, max_chord, max_depth, depth + 1).items(): totals[layer] += length * factor else: length = sum(segment_length_source(segment) for segment in derive.entity_segments(inner, max_chord)) if length > 0: totals[derive.entity_layer(inner)] += length result = dict(totals) _BLOCK_LENGTHS_CACHE[key] = result return result def output_paths(output: Path) -> tuple[Path, Path]: if output.suffix: return output.with_suffix(".json"), output.with_suffix(".md") output.mkdir(parents=True, exist_ok=True) return output / "extraction_audit.json", output / "extraction_audit.md" def segment_length_source(segment: tuple[tuple[float, float], tuple[float, float]]) -> float: (sx, sy), (ex, ey) = segment return math.hypot(ex - sx, ey - sy) def inspect_entity( entity, patterns: dict[str, list[str]], config: dict[str, Any], max_chord: float, fallback_layer: str = "", block_name: str = "", ) -> dict[str, Any]: layer = derive.entity_layer(entity) dxftype = entity.dxftype() category = derive.category_for_entity( entity, patterns, config, fallback_layer=fallback_layer, block_name=block_name, ) segments = derive.entity_segments(entity, max_chord) supported_length = sum(segment_length_source(segment) for segment in segments) sample = None if segments: (sx, sy), (ex, ey) = segments[0] sample = ((sx + ex) / 2.0, (sy + ey) / 2.0) return { "layer": layer, "type": dxftype, "category": category, "segment_count": len(segments), "supported_length": supported_length, "sample": sample, "high_risk": dxftype in HIGH_RISK_TYPES, "insert_name": block_name or (str(entity.dxf.name) if dxftype == "INSERT" and entity.dxf.hasattr("name") else ""), } def config_clips(config: dict[str, Any]) -> list[list[float]]: clips = [] for drawing in config.get("drawings", []) or []: base = drawing.get("clip") for floor in drawing.get("floors", []) or []: clip = floor.get("clip", base) if clip: x0, y0, x1, y1 = clip clips.append([min(x0, x1), min(y0, y1), max(x0, x1), max(y0, y1)]) return clips def source_files_from_config(dxf_dir: Path, config: dict[str, Any]) -> list[Path]: drawings = config.get("drawings") if drawings: return [dxf_dir / drawing["file"] for drawing in drawings if (dxf_dir / drawing["file"]).exists()] return sorted(dxf_dir.glob("*.dxf")) def spec_counts(spec: dict[str, Any]) -> dict[str, dict[str, int]]: categories = [key for key in spec.get("categories", {}) if key != "slab"] result = {} for floor_key, floor in spec.get("floors", {}).items(): result[floor_key] = {category: len(floor.get("segments", {}).get(category, [])) for category in categories} return result def audit( dxf_dir: Path, config: dict[str, Any], spec: dict[str, Any], vendor_dir: Path, frames: list[dict[str, Any]] | None = None, ) -> 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(config.get("scale", config.get("scale_to_meters", 0.001))) file_reports = [] global_entity_types = Counter() global_layer_counts = Counter() global_high_risk = Counter() global_insert_names = Counter() layer_lengths: dict[str, dict[str, Any]] = defaultdict( lambda: { "entity_count": 0, "supported_length_source": 0.0, "classified_length_source": 0.0, "categories": Counter(), "entity_types": Counter(), "high_risk_types": Counter(), } ) total_supported = 0.0 classified_supported = 0.0 captured_from_blocks = 0.0 clips = config_clips(config) clipped_total = 0.0 clipped_classified = 0.0 excludes = derive.exclude_layer_patterns(config) max_block_depth = int(config.get("expand_blocks_max_depth", 2)) block_layer_lengths: dict[str, dict[str, Any]] = defaultdict( lambda: {"supported_length_source": 0.0, "entity_count": 0, "category": None} ) for path in source_files_from_config(dxf_dir, config): doc = derive.read_doc(path, ezdxf, recover) file_total_supported = 0.0 file_classified_supported = 0.0 file_entity_types = Counter() file_high_risk = Counter() file_layers = Counter() file_insert_names = Counter() for source_entity in doc.modelspace(): if source_entity.dxftype() == "INSERT": insert_name = str(source_entity.dxf.name) if source_entity.dxf.hasattr("name") else "" global_high_risk["INSERT"] += 1 file_high_risk["INSERT"] += 1 if insert_name: global_insert_names[insert_name] += 1 file_insert_names[insert_name] += 1 # Config-independent accounting of geometry locked inside blocks, # so missing block expansion cannot hide behind a high coverage number. if insert_name: sx = abs(float(source_entity.dxf.get("xscale", 1.0) or 1.0)) sy = abs(float(source_entity.dxf.get("yscale", 1.0) or 1.0)) factor = (sx + sy) / 2.0 unit_lengths = block_layer_unit_lengths(doc, insert_name, max_chord, max_block_depth) for inner_layer, unit_length in unit_lengths.items(): inner_length = unit_length * factor if inner_length <= 0: continue record = block_layer_lengths[inner_layer] record["supported_length_source"] += inner_length record["entity_count"] += 1 if record["category"] is None: record["category"] = derive.match_category(inner_layer, patterns, excludes) or "" for entity, fallback_layer, block_name in derive.iter_model_entities(source_entity, config): item = inspect_entity(entity, patterns, config, max_chord, fallback_layer, block_name) layer = item["layer"] dxftype = item["type"] length = float(item["supported_length"]) category = item["category"] global_entity_types[dxftype] += 1 global_layer_counts[layer] += 1 file_entity_types[dxftype] += 1 file_layers[layer] += 1 layer_lengths[layer]["entity_count"] += 1 layer_lengths[layer]["supported_length_source"] += length layer_lengths[layer]["entity_types"][dxftype] += 1 if category: layer_lengths[layer]["categories"][category] += 1 layer_lengths[layer]["classified_length_source"] += length classified_supported += length file_classified_supported += length if block_name: captured_from_blocks += length total_supported += length file_total_supported += length if clips and item["sample"] is not None: px, py = item["sample"] if any(c[0] <= px <= c[2] and c[1] <= py <= c[3] for c in clips): clipped_total += length if category: clipped_classified += length if item["high_risk"]: # Top-level INSERTs were already counted above. if not (dxftype == "INSERT" and entity is source_entity): global_high_risk[dxftype] += 1 file_high_risk[dxftype] += 1 layer_lengths[layer]["high_risk_types"][dxftype] += 1 if item["insert_name"] and entity is not source_entity: global_insert_names[item["insert_name"]] += 1 file_insert_names[item["insert_name"]] += 1 file_reports.append( { "file": path.name, "entity_types": dict(file_entity_types.most_common()), "top_layers": dict(file_layers.most_common(20)), "high_risk_types": dict(file_high_risk.most_common()), "insert_names": dict(file_insert_names.most_common(20)), "supported_length_meters": round(file_total_supported * scale, 3), "classified_supported_length_meters": round(file_classified_supported * scale, 3), "supported_length_coverage": round(file_classified_supported / file_total_supported, 4) if file_total_supported else None, } ) unclassified_layers = [] classified_layers = [] for layer, data in layer_lengths.items(): record = { "layer": layer, "entity_count": data["entity_count"], "supported_length_meters": round(data["supported_length_source"] * scale, 3), "classified_length_meters": round(data["classified_length_source"] * scale, 3), "categories": dict(data["categories"].most_common()), "entity_types": dict(data["entity_types"].most_common(10)), "high_risk_types": dict(data["high_risk_types"].most_common()), } if data["classified_length_source"] > 0: classified_layers.append(record) else: unclassified_layers.append(record) unclassified_layers.sort(key=lambda item: (-item["supported_length_meters"], -item["entity_count"], item["layer"])) classified_layers.sort(key=lambda item: (-item["classified_length_meters"], item["layer"])) block_locked_layers = [] block_locked_total = 0.0 block_locked_classifiable = 0.0 for layer, data in block_layer_lengths.items(): length = float(data["supported_length_source"]) block_locked_total += length if data["category"]: block_locked_classifiable += length block_locked_layers.append( { "layer": layer, "category": data["category"] or None, "entity_count": data["entity_count"], "supported_length_meters": round(length * scale, 3), } ) block_locked_layers.sort(key=lambda item: -item["supported_length_meters"]) report = { "dxf_dir": str(dxf_dir), "coverage": { "supported_length_meters": round(total_supported * scale, 3), "classified_supported_length_meters": round(classified_supported * scale, 3), "supported_length_coverage": round(classified_supported / total_supported, 4) if total_supported else None, "block_locked_length_meters": round(block_locked_total * scale, 3), "block_locked_classifiable_length_meters": round(block_locked_classifiable * scale, 3), "block_captured_classified_length_meters": round(captured_from_blocks * scale, 3), # Clip-scoped view: with multi-frame clips, elevations/sections/details # inflate the file-global denominator; judge extraction quality by THIS. "clipped_supported_length_meters": round(clipped_total * scale, 3) if clips else None, "clipped_supported_length_coverage": round(clipped_classified / clipped_total, 4) if clips and clipped_total else None, }, "spec_counts": spec_counts(spec), "files": file_reports, "classified_layers": classified_layers, "unclassified_layers": unclassified_layers[:80], "block_locked_layers": block_locked_layers[:40], "high_risk_entity_types": dict(global_high_risk.most_common()), "top_insert_names": dict(global_insert_names.most_common(50)), "entity_types": dict(global_entity_types.most_common()), "top_layers": dict(global_layer_counts.most_common(50)), "agent_questions": agent_questions(unclassified_layers, global_high_risk, global_insert_names), } report["gates"] = evaluate_gates(report, spec, config, frames) return report GATE_GLAZING_MIN_METERS = 5.0 GATE_ALIGN_CENTER_FACTOR = 0.35 def floors_alignment_gate(spec: dict[str, Any], config: dict[str, Any]) -> dict[str, Any]: """FAIL when floors of one stack are horizontally scattered. The classic multi-frame failure mode:每层保留了图框在图纸墙上的位置, 模型里楼层沿图框间距斜着排开. Wall-bbox centers of floors in the same cap-group must agree to within GATE_ALIGN_CENTER_FACTOR x plan size. """ groups: dict[str, list[tuple[str, float, float, float]]] = defaultdict(list) for fk, floor in spec.get("floors", {}).items(): walls = floor.get("segments", {}).get("walls") or [] if len(walls) < 10: continue xs = [v for s in walls for v in (s["start"][0], s["end"][0])] ys = [v for s in walls for v in (s["start"][1], s["end"][1])] size = max(max(xs) - min(xs), max(ys) - min(ys)) groups[derive._cap_floor_group(fk, config)].append((fk, (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2, size)) worst: tuple[float, str] | None = None for grp, items in groups.items(): if len(items) < 2: continue limit = GATE_ALIGN_CENTER_FACTOR * max(item[3] for item in items) for i in range(len(items)): for j in range(i + 1, len(items)): dist = math.hypot(items[i][1] - items[j][1], items[i][2] - items[j][2]) if dist > limit and (worst is None or dist > worst[0]): worst = ( dist, f"{grp}: {items[i][0]} vs {items[j][0]} centers {round(dist, 1)} m apart (limit {round(limit, 1)})", ) if worst: return { "name": "floors_aligned", "status": "FAIL", "detail": worst[1] + ". Floors are not stacked — per-frame offsets are missing or wrong; " "run detect_sheet_frames.py and use its clip/offset config.", } # Cross-floor datum: envelope centers are blind to "self-consistent but # misplaced" floors (13号 F3 sat one tower-slot off — 85.8 m — and PASSed: # the merged twin-tower envelope hid it). Correlate each floor's wall # profile against the group's reference floor: a strong off-zero peak # means the whole floor sits N meters from the shared wall datum. try: sys.path.insert(0, str(Path(__file__).resolve().parent)) from detect_sheet_frames import correlate_shift, wall_profile except Exception: correlate_shift = wall_profile = None # type: ignore if correlate_shift is not None: wall_segs: dict[str, list[tuple[float, float, float, float]]] = {} for fk, floor in spec.get("floors", {}).items(): segs = floor.get("segments", {}).get("walls") or [] if len(segs) >= 10: wall_segs[fk] = [(s["start"][0], s["start"][1], s["end"][0], s["end"][1]) for s in segs] by_group: dict[str, list[str]] = defaultdict(list) for fk in wall_segs: by_group[derive._cap_floor_group(fk, config)].append(fk) for grp, keys in by_group.items(): if len(keys) < 2: continue ref_key = max(keys, key=lambda k: sum(math.hypot(s[2] - s[0], s[3] - s[1]) for s in wall_segs[k])) ref_x = wall_profile(wall_segs[ref_key], 0, axis_tol=0.02, min_len=0.4) ref_y = wall_profile(wall_segs[ref_key], 1, axis_tol=0.02, min_len=0.4) def zero_cov(ref_prof, prof, tol: float = 0.25) -> float: total = sum(w for _, w in prof) if total <= 0: return 0.0 matched = sum(w for p, w in prof if any(abs(p - rp) <= tol for rp, _ in ref_prof)) return matched / total for fk in keys: if fk == ref_key: continue for axis, ref_prof in ((0, ref_x), (1, ref_y)): prof = wall_profile(wall_segs[fk], axis, axis_tol=0.02, min_len=0.4) shift, cov, ratio = correlate_shift(ref_prof, prof, coarse=0.5, fine=0.05) # a floor already matching IN PLACE is not misplaced, however # attractive some shifted peak looks (dense podium references # let any small profile "match" somewhere: 27号 1#A PH) if shift is not None and zero_cov(ref_prof, prof) >= 0.7 * cov: continue if shift is not None and cov >= 0.45 and ratio >= 1.5 and abs(shift) > 1.0: return { "name": "floors_aligned", "status": "FAIL", "detail": ( f"cross_floor_datum {grp}: {fk} wall profile matches {ref_key} " f"only when shifted {round(shift, 1)} m in {'xy'[axis]} " f"(coverage {cov:.2f}, peak ratio {min(ratio, 99):.1f}) — the floor is " "self-consistent but misplaced (wrong frame offset / wrong tower slot, " "13号 F3 错槽 pattern). Re-check that frame's offset against the shared datum." ), } return { "name": "floors_aligned", "status": "PASS", "detail": "Wall-bbox centers of same-stack floors coincide; cross-floor wall-profile datum consistent.", } def evaluate_gates( report: dict[str, Any], spec: dict[str, Any], config: dict[str, Any], frames: list[dict[str, Any]] | None = None ) -> list[dict[str, Any]]: """Hard checks that must pass before 3D generation. A gate FAIL means the extraction is known-incomplete in a way that high coverage numbers cannot excuse; fix the config (block expansion, layer mapping, source re-export) and re-run instead of accepting the model. """ gates: list[dict[str, Any]] = [ { "name": "all_config_drawings_present", "status": "PASS", "detail": "Every configured source drawing exists and passed config validation.", }, { "name": "unique_floor_keys", "status": "PASS", "detail": "Configured floor keys are unique.", }, { "name": "every_floor_nonempty", "status": "PASS", "detail": "Every floor contains segments, footprint polygons, or caps.", }, floors_alignment_gate(spec, config), ] spec_glazing_segments = sum(counts.get("glazing", 0) for counts in report["spec_counts"].values()) locked_glazing_meters = sum( item["supported_length_meters"] for item in report["block_locked_layers"] if item["category"] == "glazing" ) glazing_named_blocks = [ name for name in report["top_insert_names"] if derive.match_patterns(name, derive.GLAZING_BLOCK_PATTERNS) ] glazing_evidence = locked_glazing_meters >= GATE_GLAZING_MIN_METERS or bool(glazing_named_blocks) if not glazing_evidence: status, detail = "NOT_APPLICABLE", "No curtain-wall/glazing evidence in blocks or block names." elif spec_glazing_segments > 0: status = "PASS" detail = ( f"Spec contains {spec_glazing_segments} glazing segments; " f"~{round(locked_glazing_meters, 1)} m of glazing-layer geometry found inside blocks." ) else: status = "FAIL" detail = ( f"Glazing evidence exists (~{round(locked_glazing_meters, 1)} m on glazing layers inside blocks; " f"block names: {', '.join(glazing_named_blocks[:3]) or 'none'}) but the spec has 0 glazing segments. " "Enable block expansion / classify_block_contents or fix glazing layer mapping, then re-run." ) gates.append({"name": "glazing_captured", "status": status, "detail": detail}) annotation_classified = [ item["layer"] for item in report["classified_layers"] if derive.match_patterns(item["layer"], ["*-IDEN", "*ANNO*", "*-DIMS"]) ] gates.append( { "name": "no_annotation_layers_classified", "status": "WARN" if annotation_classified else "PASS", "detail": ( f"Annotation/identification layers classified as geometry: {', '.join(annotation_classified[:5])}. " "These are tags, not elements; exclude them." if annotation_classified else "No annotation/identification layers classified." ), } ) coverage = report["coverage"] locked_classifiable = float(coverage["block_locked_classifiable_length_meters"]) captured = float(coverage["block_captured_classified_length_meters"]) if locked_classifiable > 0 and captured < 0.5 * locked_classifiable: gates.append( { "name": "block_locked_geometry_captured", "status": "WARN", "detail": ( f"~{round(locked_classifiable, 1)} m of classifiable geometry sits inside blocks but only " f"~{round(captured, 1)} m was captured. Review block expansion settings." ), } ) else: gates.append( { "name": "block_locked_geometry_captured", "status": "PASS", "detail": ( f"Captured ~{round(captured, 1)} m of ~{round(locked_classifiable, 1)} m " "classifiable block-locked geometry." ), } ) gates.append(frame_ledger_gate(config, frames)) gates.append(disconnected_footprints_gate(spec, config)) gates.append(vertical_storey_continuity_gate(spec)) gates.append(declared_area_gate(spec, config)) gates.append(storey_count_gate(spec, config)) return gates def _rect_overlap_ratio(a: list[float], b: list[float]) -> float: """Intersection area / area of rect a (a = the detected frame clip).""" ax0, ay0, ax1, ay1 = min(a[0], a[2]), min(a[1], a[3]), max(a[0], a[2]), max(a[1], a[3]) bx0, by0, bx1, by1 = min(b[0], b[2]), min(b[1], b[3]), max(b[0], b[2]), max(b[1], b[3]) iw = min(ax1, bx1) - max(ax0, bx0) ih = min(ay1, by1) - max(ay0, by0) if iw <= 0 or ih <= 0: return 0.0 area_a = max((ax1 - ax0) * (ay1 - ay0), 1e-9) return (iw * ih) / area_a def frame_ledger_gate(config: dict[str, Any], frames: list[dict[str, Any]] | None) -> dict[str, Any]: """Every DETECTED plan frame must be in the config or explicitly discarded. Frames the Agent silently ignores are exactly where whole floors (or whole wings) go missing on a new project. Pass detect_sheet_frames' out-config via --frames; account for unused frames in config `"discarded_frames": [{"name": ..., "reason": ...}]`. """ if not frames: return { "name": "frame_ledger", "status": "NOT_APPLICABLE", "detail": "No --frames given; frame ledger is not armed for this project.", } discarded = {str(d.get("name", "")) for d in config.get("discarded_frames", [])} cfg_by_file: dict[str, list[dict[str, Any]]] = {} for drawing in config.get("drawings", []) or []: cfg_by_file.setdefault(str(drawing.get("file", "")), []).extend(drawing.get("floors", []) or []) unaccounted: list[str] = [] total = 0 for fcfg in frames: for drawing in fcfg.get("drawings", []) or []: file = str(drawing.get("file", "")) cfg_floors = cfg_by_file.get(file, []) used_cfg: set[int] = set() for frame in drawing.get("floors", []) or []: total += 1 name = str(frame.get("name", "")) key = str(frame.get("key", "")) clip = frame.get("clip") if name in discarded: continue matches = [ index for index, floor in enumerate(cfg_floors) if index not in used_cfg and str(floor.get("key", "")) == key and set(frame.get("include_block_names", []) or []).issubset( set(floor.get("include_block_names", []) or []) ) and clip and floor.get("clip") and _rect_overlap_ratio(clip, floor["clip"]) >= 0.3 ] if matches: used_cfg.add(matches[0]) continue unaccounted.append(f"{file}: {key or '?'} {name}") if unaccounted: shown = "; ".join(unaccounted[:12]) + (" …" if len(unaccounted) > 12 else "") return { "name": "frame_ledger", "status": "FAIL", "detail": ( f"{len(unaccounted)}/{total} detected plan frames are neither used by the config " f"nor listed in discarded_frames: {shown}. Silently ignored frames are where " "floors/wings vanish — use them or discard them WITH a reason." ), } return { "name": "frame_ledger", "status": "PASS", "detail": f"All {total} detected plan frames are used or explicitly discarded.", } def _polygon_area(points: list[list[float]]) -> float: if len(points) < 3: return 0.0 return ( abs( sum( float(points[index][0]) * float(points[(index + 1) % len(points)][1]) - float(points[(index + 1) % len(points)][0]) * float(points[index][1]) for index in range(len(points)) ) ) / 2.0 ) def _polygon_bounds(points: list[list[float]]) -> list[float]: xs = [float(point[0]) for point in points] ys = [float(point[1]) for point in points] return [min(xs), min(ys), max(xs), max(ys)] def _bounds_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) def disconnected_footprints_gate(spec: dict[str, Any], config: dict[str, Any]) -> dict[str, Any]: """Reject small, remote footprint islands unless they are explained. A stray but substantial curtain-wall/component cluster can survive the line-level isolated-cluster filter and become a tall floating fin. The generated footprint exposes it deterministically. Legitimate detached stairs/canopies must be acknowledged with a floor key and reason. """ allowed = { str(item.get("floor_key", "")) for item in config.get("allowed_disconnected_footprints", []) or [] if isinstance(item, dict) and str(item.get("reason", "")).strip() } problems: list[str] = [] checked = 0 for floor_key, floor in spec.get("floors", {}).items(): polygons = [ polygon for polygon in (floor.get("footprint") or {}).get("polygons", []) or [] if isinstance(polygon, list) and len(polygon) >= 3 ] if len(polygons) < 2 or str(floor_key) in allowed: continue checked += 1 measured = sorted( [(_polygon_area(polygon), _polygon_bounds(polygon)) for polygon in polygons], key=lambda item: item[0], reverse=True, ) main_area, main_bounds = measured[0] if main_area <= 0: continue for area, bounds in measured[1:]: ratio = area / main_area gap = _bounds_gap(main_bounds, bounds) if ratio < 0.05 and gap > 2.0: problems.append( f"{floor_key}: {area:.1f} m² island is {ratio:.1%} of the main footprint and {gap:.1f} m away" ) if problems: return { "name": "disconnected_footprints", "status": "FAIL", "detail": ( "Small remote footprint islands would render as floating/orphan building parts: " + "; ".join(problems) + ". Fix the clip/layer/block mapping, or document a legitimate detached element in " "allowed_disconnected_footprints with floor_key and reason." ), } return { "name": "disconnected_footprints", "status": "PASS", "detail": ( f"No unexplained small remote footprint islands across {len(spec.get('floors', {}))} floor(s)" + (f" ({checked} multi-component floor(s) checked)." if checked else ".") ), } def declared_area_gate(spec: dict[str, Any], config: dict[str, Any]) -> dict[str, Any]: """Model footprint areas must match declared areas (经济技术指标表/标注). Cross-evidence beats self-consistency: 1#B passed every internal gate with half the building missing — the site plan exposed it. Config: `"declared_areas_m2": {"F1": 812, ...}`, optional `"declared_area_tolerance"` (default 0.15). """ declared = config.get("declared_areas_m2") if not declared: return { "name": "area_declared", "status": "NOT_APPLICABLE", "detail": "No declared_areas_m2 in config; area cross-check is not armed.", } tol = float(config.get("declared_area_tolerance", 0.15)) problems = [] for key, want in declared.items(): want = float(want) floor = spec.get("floors", {}).get(str(key)) if floor is None: problems.append(f"{key}: not in spec") continue got = float((floor.get("footprint") or {}).get("area") or 0.0) if got <= 0: problems.append(f"{key}: no footprint area in spec") elif abs(got - want) / want > tol: problems.append( f"{key}: model {round(got, 1)} m² vs declared {round(want, 1)} m² " f"({round(100 * (got - want) / want):+d}%)" ) if problems: return { "name": "area_declared", "status": "FAIL", "detail": ( "Footprint area disagrees with the declared evidence: " + "; ".join(problems) + f" (tolerance ±{round(tol * 100)}%). A missing wing / swallowed neighbour " "sheet moves the area far more than balconies do." ), } return { "name": "area_declared", "status": "PASS", "detail": f"{len(declared)} floor area(s) within ±{round(tol * 100)}% of declared values.", } def vertical_storey_continuity_gate(spec: dict[str, Any]) -> dict[str, Any]: """A final full-building model may not jump from F2 directly to F16. Representative typical-floor drawings are source evidence, not permission to leave the repeated storeys absent from the delivered building. The repeated floors must be instantiated and labelled as derived repetitions. """ import re as _re numbered: list[tuple[int, str, dict[str, Any]]] = [] for key, floor in spec.get("floors", {}).items(): match = _re.fullmatch(r"F(\d+)", str(key)) if match: numbered.append((int(match.group(1)), str(key), floor)) numbered.sort() if len(numbered) < 2: return { "name": "vertical_storey_continuity", "status": "PASS", "detail": f"{len(numbered)} numbered storey; no internal continuity gap to test.", } missing: list[str] = [] z_gaps: list[str] = [] for (left_no, left_key, left), (right_no, right_key, right) in zip(numbered, numbered[1:]): if right_no != left_no + 1: missing.append(f"{left_key}->{right_key}") continue left_z = float(left.get("z", 0.0)) right_z = float(right.get("z", 0.0)) nominal = max(float(left.get("height", 0.0)), float(right.get("height", 0.0)), 1.0) if right_z - left_z > max(8.0, nominal * 2.0): z_gaps.append(f"{left_key}->{right_key}={round(right_z - left_z, 2)}m") if missing or z_gaps: parts = [] if missing: parts.append("missing numbered ranges " + ", ".join(missing)) if z_gaps: parts.append("unexplained elevation gaps " + ", ".join(z_gaps)) return { "name": "vertical_storey_continuity", "status": "WARN", "detail": ( "; ".join(parts) + ". Instantiate source-supported repeated typical floors; do not deliver separated floor islands." ), } return { "name": "vertical_storey_continuity", "status": "PASS", "detail": f"Numbered storeys are contiguous from {numbered[0][1]} to {numbered[-1][1]}.", } def storey_count_gate(spec: dict[str, Any], config: dict[str, Any]) -> dict[str, Any]: """Above-ground storey count must match the declared count (总图 22F 标签 / 标高梯级数). Config: `"expected_storeys_above_ground": 22`. Counts spec floors keyed F (mezzanines FM, PH, RF, basements excluded). """ expected = config.get("expected_storeys_above_ground") if expected is None: return { "name": "storey_count", "status": "NOT_APPLICABLE", "detail": "No expected_storeys_above_ground in config; count cross-check is not armed.", } import re as _re actual = sum(1 for k in spec.get("floors", {}) if _re.fullmatch(r"F\d+", str(k))) if actual != int(expected): return { "name": "storey_count", "status": "FAIL", "detail": ( f"Spec has {actual} above-ground storeys (F keys) but the declared " f"count is {expected} (总图 label / elevation ladder). A silently dropped " "floor_order entry or an unexpanded multi-floor frame is the usual cause." ), } return { "name": "storey_count", "status": "PASS", "detail": f"{actual} above-ground storeys match the declared count.", } def agent_questions(unclassified_layers: list[dict], high_risk: Counter, insert_names: Counter) -> list[str]: questions = [] if unclassified_layers: top = [item for item in unclassified_layers if item["supported_length_meters"] > 0][:8] if top: names = ", ".join(f"`{item['layer']}`" for item in top[:5]) questions.append(f"Review unclassified geometry layers with significant length: {names}.") if high_risk.get("INSERT", 0): questions.append("Decide whether INSERT/block geometry must be recursively expanded before modeling.") if high_risk.get("HATCH", 0): questions.append("Check whether hatches represent walls/slabs/columns that line extraction missed.") if insert_names: names = ", ".join(f"`{name}`" for name, _count in insert_names.most_common(5)) questions.append(f"Inspect frequent block names: {names}.") questions.append("Compare SVG overlays against CAD intent before accepting the model.") return questions def markdown(report: dict[str, Any]) -> str: coverage = report["coverage"] lines = [ "# Extraction Audit", "", "Use this as evidence for Agent judgment. High coverage does not prove correctness; low coverage or high-risk entities require review.", "", "## Gates", "", ] for gate in report.get("gates", []): lines.append(f"- **{gate['status']}** `{gate['name']}`: {gate['detail']}") lines.extend( [ "", "## Coverage", "", f"- Supported vector length: `{coverage['supported_length_meters']}` m", f"- Classified supported length: `{coverage['classified_supported_length_meters']}` m", f"- Supported-length coverage: `{coverage['supported_length_coverage']}` " "(modelspace linework only — block-locked geometry is NOT in this denominator)", *( [ f"- CLIP-SCOPED coverage: `{coverage['clipped_supported_length_coverage']}` over " f"`{coverage['clipped_supported_length_meters']}` m inside floor clips — " "on multi-frame sheets judge extraction by THIS number, not the file-global one" ] if coverage.get("clipped_supported_length_coverage") is not None else [] ), f"- Block-locked geometry: `{coverage['block_locked_length_meters']}` m total, " f"`{coverage['block_locked_classifiable_length_meters']}` m classifiable, " f"`{coverage['block_captured_classified_length_meters']}` m captured into the spec", "", "## Agent Questions", "", ] ) for question in report["agent_questions"]: lines.append(f"- {question}") lines.extend(["", "## Block-Locked Geometry By Layer", ""]) for item in report.get("block_locked_layers", [])[:15]: lines.append( f"- `{item['layer']}` (category: {item['category'] or 'unclassified'}): " f"entities `{item['entity_count']}`, length `{item['supported_length_meters']}` m" ) lines.extend(["", "## Spec Counts", ""]) for floor_key, counts in report["spec_counts"].items(): parts = ", ".join(f"{key}: {value}" for key, value in counts.items()) lines.append(f"- `{floor_key}`: {parts}") lines.extend(["", "## High Risk Entity Types", ""]) for key, value in report["high_risk_entity_types"].items(): lines.append(f"- `{key}`: {value}") lines.extend(["", "## Top Unclassified Geometry Layers", ""]) for layer in report["unclassified_layers"][:20]: lines.append( f"- `{layer['layer']}`: entities `{layer['entity_count']}`, " f"supported length `{layer['supported_length_meters']}` m, " f"types `{layer['entity_types']}`" ) lines.extend(["", "## Classified Layers", ""]) for layer in report["classified_layers"][:30]: lines.append( f"- `{layer['layer']}`: `{layer['categories']}`, classified length `{layer['classified_length_meters']}` m" ) lines.extend(["", "## Files", ""]) for item in report["files"]: lines.append( f"- `{item['file']}`: coverage `{item['supported_length_coverage']}`, high-risk `{item['high_risk_types']}`" ) return "\n".join(lines) def main() -> int: args = parse_args() config = derive.read_json(Path(args.config)) spec = json.loads(Path(args.spec).read_text(encoding="utf-8")) try: config = showcase_schema.validate_config(config, Path(args.dxf_dir)) showcase_schema.validate_spec(spec) except showcase_schema.ValidationFailure as exc: print(str(exc), file=sys.stderr) return 3 frames = None if args.frames: frames = [json.loads(Path(p).read_text(encoding="utf-8")) for p in args.frames] report = audit(Path(args.dxf_dir), config, spec, Path(args.vendor_dir), frames) json_path, md_path = output_paths(Path(args.out)) json_path.parent.mkdir(parents=True, exist_ok=True) md_path.parent.mkdir(parents=True, exist_ok=True) json_path.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8") md_path.write_text(markdown(report), encoding="utf-8") failed_gates = [gate for gate in report.get("gates", []) if gate["status"] == "FAIL"] print( json.dumps( { "json": str(json_path), "markdown": str(md_path), "gates": {gate["name"]: gate["status"] for gate in report.get("gates", [])}, }, ensure_ascii=False, ) ) if failed_gates and not args.no_strict_gates: for gate in failed_gates: print(f"GATE FAIL [{gate['name']}]: {gate['detail']}", file=sys.stderr) return 3 return 0 if __name__ == "__main__": raise SystemExit(main())