"""여수로 수문 설치도 DXF 파서. 여수로(spillway) 수문 설치도(설계도)에서 수문 구조물의 핵심 파라미터를 자동 추출한다. 보통 1/2 도면(평면+정면), 2/2 도면(측면단면)의 쌍으로 제공됨. 추출되는 핵심 파라미터: - 수문 개수(n_gates), 수문 폭(gate_width), 수문 높이(gate_height) - 각 주요 표고(Gate Sill, Weir Crest, Gate Top, Trunnion Pin, 수위들) - 평면도 외곽(ogee 단면이 extrude될 span 방향) - 측면 단면 외곽(ogee profile polyline) - 교각(pier) 위치 목록 사용법: parser = GateParser() params = parser.parse(plan_dxf_path, section_dxf_path) """ from __future__ import annotations import contextlib import math import re from dataclasses import dataclass, field from itertools import pairwise from pathlib import Path from typing import ClassVar import ezdxf import numpy as np # --------------------------------------------------------------------------- # 데이터 클래스 # --------------------------------------------------------------------------- @dataclass class GateParams: """여수로 수문 구조물 파라미터 (단위: m, 표고는 해발기준 m).""" # 수문 본체 n_gates: int = 3 gate_width: float = 15.0 # 수문 폭 (clear span) gate_height: float = 7.0 # 수문 높이 (sill→top) # 교각 (pier) pier_count: int = 4 # 보통 n_gates + 1 pier_width: float = 3.0 # 교각 폭 (유출방향 수직) pier_length: float = 25.0 # 교각 길이 (유출방향) # 주요 표고 (m, 해발) el_gate_sill: float = 46.700 el_stoplog_sill: float = 46.000 # Stoplog sill (파서에서 추출; 현재 빌더 미사용) el_weir_crest: float = 47.000 el_gate_top: float = 53.700 el_trunnion_pin: float = 50.200 el_mwl: float = 53.830 # M.W.L 최대수위 el_nhwl: float = 52.500 # N.H.W.L 상시만수위 el_lwl: float = 45.000 # L.W.L 최저수위 el_downstream: float = 44.000 el_upstream_bed: float = 41.500 el_bridge_top: float = 56.000 # 공도교 상면 # 구조 전체 (평면) total_span: float = 75.0 # dam axis 방향 전체 폭 total_length: float = 25.0 # 유출방향 전체 길이 dam_axis_y: float = 0.0 # dam axis의 Y 좌표 (로컬) # 단면 프로파일 (ogee) - 로컬 좌표계로 정규화된 점 목록 [(x, z), ...] # x: 유출방향 (0=상류 시작), z: 표고 (해발) ogee_profile: list = field(default_factory=list) # 평면 외곽 (상류측/하류측 경계) plan_outline_upstream: list = field(default_factory=list) plan_outline_downstream: list = field(default_factory=list) # 수문 게이트 중심선 (평면 X 좌표, 순서대로) - 로컬 기준 gate_centers_x: list = field(default_factory=list) # 평면 방향 보정 (detail DXF 내에서 mesh의 +X축이 가리키는 각도) # PCA로 plan outline 주축을 찾아 mesh 빌더 좌표계와 detail DXF 좌표계의 # 상대 회전을 표현. 기본 0.0 = detail의 +X가 span 방향 (수평 그려진 경우). plan_frame_angle_deg: float = 0.0 # 부속 구조물 존재 여부 (도면 검출 결과로 갱신; 구조적 요소는 default False, 시각은 True) has_service_bridge: bool = False # 공도교 (수문 상부 service bridge) has_hoist_housings: bool = True # 여수로 개폐장치 — 래디얼 게이트엔 보통 필수 (파서가 hoist 관련 레이어/블록 검출 시 확정 유지, 없으면 False로 낮춤; 플래그 이름은 직렬화 호환 위해 보존) has_downstream_apron: bool = True # 하류 에이프런 — 시각 맥락, 사용자 토글 가능 has_water_surface: bool = True # 상류 수면 표시 — 시각 맥락, 사용자 토글 가능 # Phase B' — 실제 도면 기하 (parametric 폴백의 우선 대체) # plan 영역 CS-CONC 레이어의 폐합 폴리라인 (chamber-local 좌표, m 단위) plan_outline_polygon: list = field(default_factory=list) # 외곽: [(x,y), ...] pier_plan_polygons: list = field(default_factory=list) # 각 교각: [[(x,y), ...], ...] # 공도교(service bridge)의 실제 plan bbox — (x0, y0, x1, y1) local m, None이면 폴백 bridge_plan_bbox: tuple | None = None # 공도교 Y 방향 두께(도면 기반 실측). None이면 bbox Y 길이 사용. bridge_deck_thickness_m: float = 1.2 # 사용자 직접 지정 공도교 위치 (UI 편집 가능; 4개 값 모두 유효하면 다른 경로 대신 사용) # 기본 None/-1: 사용자 미입력으로 간주. 양수로 편집 시 override 적용. bridge_x_start: float | None = None bridge_x_end: float | None = None bridge_y_start: float | None = None bridge_y_end: float | None = None # FLOW 화살표로 검출된 유수 방향 단위벡터 (DXF XY frame, dx²+dy²=1) # None이면 PCA만 사용 (span 180° 모호성 존재). 검출 시 plan_frame_angle_deg가 # 전체 -180..180 범위로 정확 설정됨. flow_direction_2d: tuple | None = None # 메타데이터 source_files: list = field(default_factory=list) raw_text_annotations: list = field(default_factory=list) def summary(self) -> str: """요약 텍스트 반환.""" return ( f"Gate: {self.n_gates}문 × W{self.gate_width:.1f}m × H{self.gate_height:.1f}m\n" f" Sill EL.{self.el_gate_sill:.2f} / Crest EL.{self.el_weir_crest:.2f} / " f"Top EL.{self.el_gate_top:.2f} / Trunnion EL.{self.el_trunnion_pin:.2f}\n" f" W.L: MWL {self.el_mwl:.2f} / NHWL {self.el_nhwl:.2f} / LWL {self.el_lwl:.2f}\n" f" Total: {self.total_span:.1f}m × {self.total_length:.1f}m\n" f" 부속: 공도교={'O' if self.has_service_bridge else 'X'}, " f"개폐장치={'O' if self.has_hoist_housings else 'X'}, " f"에이프런={'O' if self.has_downstream_apron else 'X'}, " f"수면={'O' if self.has_water_surface else 'X'}\n" f" 기하: plan_outline={len(self.plan_outline_polygon)}pts, " f"piers={len(self.pier_plan_polygons)}\n" f" Gate centers (X): {[f'{x:.1f}' for x in self.gate_centers_x]}" ) # --------------------------------------------------------------------------- # 파서 # --------------------------------------------------------------------------- class GateParser: """여수로 수문 설치도 파서.""" # 구조 레이어 (concrete 본체 geometry) STRUCT_LAYERS: ClassVar[set[str]] = { "CS-CONC-Spillway", "CS-CONC-Bridge", } def parse(self, plan_dxf: str | Path, section_dxf: str | Path | None = None) -> GateParams: """평면/정면 도면과 측면단면 도면을 파싱. Args: plan_dxf: 1/2 도면 (평면 + 정면). 필수. section_dxf: 2/2 도면 (측면 단면). 선택적, 있으면 ogee 프로파일 추출. Returns: GateParams """ params = GateParams() params.source_files.append(str(plan_dxf)) # Plan + Elevation 도면 파싱 self._parse_plan_file(Path(plan_dxf), params) # Section 도면 파싱 (있으면) if section_dxf: params.source_files.append(str(section_dxf)) self._parse_section_file(Path(section_dxf), params) # 누락된 파라미터는 기본값 + 추론 self._infer_missing_params(params) return params # ----- Plan/Elevation 도면 파싱 ----- def _parse_plan_file(self, path: Path, params: GateParams): """1/2 도면에서 수문 개수, 크기, 평면 배치, 표고를 추출 (Phase D 통합). view_detector로 평면도/입면도/측면도 영역을 분리한 뒤: - 평면도 영역 내 geometry → 외곽·교각·게이트 위치 - 입면도 영역 내 geometry → 게이트 높이 등 (현재는 보조, 추후 확장) view_detector가 영역을 못 찾으면 기존 y_mid 휴리스틱으로 폴백. """ doc = ezdxf.readfile(str(path)) msp = doc.modelspace() # 0) 부속 구조물 존재성 검출 (공도교 등) self._detect_optional_components(msp, params) # 1) 텍스트 주석 스캔 → 수문 사양 + 표고 (전체 스캔, view 무관) self._scan_text_annotations(msp, params) # 2) 뷰 영역 식별 (Phase D): view_detector 우선, 실패 시 y_mid 폴백 plan_bounds_mm = None # (x0, y0, x1, y1) — 파서는 mm 좌표로 filter try: from view_detector import detect_view_regions views = detect_view_regions(str(path)) plan_view = next((v for v in views if v.view_type == "plan"), None) if plan_view is not None: # view bounds는 m 단위, 파서는 mm 단위로 작업 → 1000배 변환 b = plan_view.bounds # (xmin_m, ymin_m, xmax_m, ymax_m) plan_bounds_mm = (b[0] * 1000.0, b[1] * 1000.0, b[2] * 1000.0, b[3] * 1000.0) params.raw_text_annotations.append(( f"[view] plan detected: " f"x=[{b[0]:.1f},{b[2]:.1f}]m y=[{b[1]:.1f},{b[3]:.1f}]m " f"(W={plan_view.width:.1f}m, H={plan_view.height:.1f}m)", 0.0, 0.0 )) except Exception as _e: pass # plan bounds로 필터할 함수 정의 def _in_plan(x, y): if plan_bounds_mm is not None: x0, y0, x1, y1 = plan_bounds_mm return x0 <= x <= x1 and y0 <= y <= y1 # 폴백: 뒤에서 계산할 y_mid 사용. 임시로 True 반환해 전체 처리. return True # 폴백용 y_mid 계산 (view_detector 실패 시) y_values = [] for e in msp: if e.dxf.layer != "CS-CONC-Spillway": continue with contextlib.suppress(Exception): if e.dxftype() == "LWPOLYLINE": y_values.extend(p[1] for p in e.get_points()) elif e.dxftype() == "LINE": y_values.extend([e.dxf.start.y, e.dxf.end.y]) if not y_values: return ymin = min(y_values) ymax = max(y_values) y_mid = (ymin + ymax) / 2 # view_detector가 plan을 찾았으면 그걸로 교체; 아니면 y_mid 유지 if plan_bounds_mm is not None: # plan y-range의 상한을 유지, 하한을 plan 영역 y0로 ymin = plan_bounds_mm[1] ymax = plan_bounds_mm[3] y_mid = ymin # 기존 로직에서 mid 이상만 plan으로 취급하므로 plan 하한을 mid로 # 3) 평면 영역 (Y > y_mid) 지오메트리 추출 plan_pts_all = [] for e in msp: if e.dxf.layer not in self.STRUCT_LAYERS: continue try: if e.dxftype() == "LWPOLYLINE": pts = [(p[0], p[1]) for p in e.get_points()] if pts and np.mean([p[1] for p in pts]) > y_mid: plan_pts_all.extend(pts) elif e.dxftype() == "LINE": s, en = e.dxf.start, e.dxf.end if (s.y + en.y) / 2 > y_mid: plan_pts_all.extend([(s.x, s.y), (en.x, en.y)]) except Exception: pass if plan_pts_all: arr = np.array(plan_pts_all) params.total_span = float(arr[:, 0].max() - arr[:, 0].min()) / 1000.0 # mm→m params.total_length = float(arr[:, 1].max() - arr[:, 1].min()) / 1000.0 # --- 평면 방향 결정 --- # 1순위: FLOW 화살표 (사용자 지정 유수 방향 → 180° 모호성 해소) # 2순위: plan geometry PCA 주축 (부호 모호성 존재, -90..+90 정규화) flow_dir = self._detect_flow_direction(msp) if flow_dir is not None: params.flow_direction_2d = flow_dir fx, fy = flow_dir # 배치 파이프라인 `fit_meshes_to_quad`는 CW quad 기본값으로 # mesh Y를 먼저 반전(flip_y_for_cw_quad=True) 후 회전 적용. # mesh +Y(빌더 downstream 컨벤션)가 world flow 방향과 일치하려면, # 유도: (0,1) → Y-flip → (0,-1) → rotate(-span) → (-sin(span),-cos(span)) # 이 벡터가 flow=(fx,fy)와 같아야 함 → sin(span)=-fx, cos(span)=-fy # → span = atan2(-fx, -fy) span_angle_rad = math.atan2(-fx, -fy) span_angle_deg = math.degrees(span_angle_rad) while span_angle_deg > 180: span_angle_deg -= 360 while span_angle_deg <= -180: span_angle_deg += 360 params.plan_frame_angle_deg = span_angle_deg params.raw_text_annotations.append(( f"[flow] detected flow_dir=({fx:+.3f},{fy:+.3f}) " f"→ plan_frame_angle={span_angle_deg:+.1f}°", 0.0, 0.0 )) else: try: centered = arr - arr.mean(axis=0) cov = np.cov(centered.T) eigvals, eigvecs = np.linalg.eigh(cov) idx = int(np.argmax(eigvals)) main_axis = eigvecs[:, idx] span_angle_rad = math.atan2(float(main_axis[1]), float(main_axis[0])) span_angle_deg = math.degrees(span_angle_rad) while span_angle_deg > 90: span_angle_deg -= 180 while span_angle_deg < -90: span_angle_deg += 180 params.plan_frame_angle_deg = span_angle_deg except Exception: params.plan_frame_angle_deg = 0.0 # 수문 중심 추정: 평면 폭을 n_gates로 균등 분할 # 정확한 위치는 아래 4) 단계에서 치수선으로 보정 x_min = float(arr[:, 0].min()) / 1000.0 # 기본 추정 if not params.gate_centers_x: gate_spacing = params.total_span / params.n_gates params.gate_centers_x = [ x_min + gate_spacing * (i + 0.5) for i in range(params.n_gates) ] # 4) DIMENSION 엔티티 → clear span 확인 및 수문 위치 보정 self._extract_gate_positions_from_dims(msp, params) # 5) Phase B' — 평면 폴리곤/교각 폴리곤 직접 추출 self._extract_plan_polygons(msp, params, y_mid, ymin, ymax) def _parse_section_file(self, path: Path, params: GateParams): """2/2 도면에서 측면 ogee 단면 프로파일 추출.""" doc = ezdxf.readfile(str(path)) msp = doc.modelspace() # 텍스트 주석도 보조적으로 스캔 (표고 보강) self._scan_text_annotations(msp, params) # CS-CONC-Spillway 레이어에서 가장 긴 LWPOLYLINE = ogee 프로파일 추정 best_poly = None best_len = 0 for e in msp: if e.dxf.layer != "CS-CONC-Spillway": continue if e.dxftype() != "LWPOLYLINE": continue try: pts = [(p[0], p[1]) for p in e.get_points()] if len(pts) > best_len: best_len = len(pts) best_poly = pts except Exception: pass if best_poly and len(best_poly) >= 5: # mm → m 변환, 로컬 좌표 정규화 arr = np.array(best_poly) # X 원점 = 상류측 시작, Z = 표고 (해발 m 변환 필요) # 단면 도면의 Y는 보통 해발표고(m)에 mm 스케일 x_local = (arr[:, 0] - arr[:, 0].min()) / 1000.0 # 도면의 Y는 해발에 mm scale (예: 12978mm는 EL.12.978m가 아님 주의) # 측면도에서 Y 범위 보고 해발 대응을 추정: Gate Sill/Weir Crest 위치 비교 # 간단화: 최저점 = el_upstream_bed, 스케일은 mm→m z_min_local = arr[:, 1].min() / 1000.0 z_shift = params.el_upstream_bed - z_min_local z_local = arr[:, 1] / 1000.0 + z_shift params.ogee_profile = list(zip(x_local.tolist(), z_local.tolist(), strict=False)) # ----- 부속 구조물 존재성 검출 (Phase A) ----- # # 구체 검출 로직은 optional_detector 모듈에 위임. 본 파서는 구조물 특유의 # 컴포넌트 명세(레이어 토큰·텍스트 키워드·default)만 선언. _COMPONENT_SPECS = None # lazy init (import 시 호출) @classmethod def _get_component_specs(cls): if cls._COMPONENT_SPECS is None: from optional_detector import ComponentSpec cls._COMPONENT_SPECS = [ ComponentSpec( name="service_bridge", layer_tokens=("bridge", "공도교", "공도", "관리도로", "service road"), text_keywords=("공도교", "service bridge", "관리교", "관리도로"), default=False, ), ComponentSpec( name="hoist_housings", layer_tokens=("hoist", "권양", "winch", "gantry"), text_keywords=("권양기", "hoist", "winch", "hoisting"), default=True, preserve_default_on_no_signal=True, # 별도 레이어 없이 그리는 경우 많음 ), ComponentSpec( name="downstream_apron", layer_tokens=("apron", "에이프런", "stilling", "물받이", "감세"), text_keywords=("에이프런", "apron", "물받이", "감세공", "stilling basin"), default=True, preserve_default_on_no_signal=True, # 시각 맥락용 ), ] return cls._COMPONENT_SPECS def _detect_flow_direction(self, msp, search_radius_mm: float = 10000.0, shaft_min_len_mm: float = 2000.0) -> tuple | None: """도면의 "FLOW" 텍스트와 인접 화살표(LINE 클러스터)에서 유수 방향 추출. 알고리즘: 1. TEXT/MTEXT에서 "FLOW", "흐름", "유수" 키워드 탐지 2. 각 텍스트 위치에서 반경 10m 내 LINE 수집 - 길이 ≥ 2m: shaft 후보 (가장 긴 것 선택) - 길이 < 2m: arrowhead 후보 3. shaft의 두 끝점 중 **arrowhead 점들이 더 밀집한 쪽이 tip** (arrowhead가 없으면 텍스트에서 더 먼 쪽을 tip으로 폴백) 4. 방향 = (tip - tail) 정규화 5. 여러 FLOW가 있으면 평균 Returns: (dx, dy) 단위벡터 or None (검출 실패) """ flow_dirs: list[tuple[float, float]] = [] # TEXT 엔티티 먼저 모아두고, LINE은 msp 한 번 더 순회 (메모리 효율) flow_texts = [] for e in msp: try: et = e.dxftype() if et not in ("TEXT", "MTEXT"): continue txt = e.dxf.text if et == "TEXT" else (e.text or "") except Exception: continue if not txt: continue tu = txt.strip().upper() if "FLOW" not in tu and "흐름" not in txt and "유수" not in txt: continue try: pos = e.dxf.insert flow_texts.append((float(pos.x), float(pos.y))) except Exception: continue if not flow_texts: return None # LINE 수집 (한 번만) all_lines: list[tuple[float, float, float, float, float]] = [] # (sx,sy,ex,ey,len) for e in msp: try: if e.dxftype() != "LINE": continue s = e.dxf.start en = e.dxf.end dx = en.x - s.x dy = en.y - s.y length = math.sqrt(dx * dx + dy * dy) all_lines.append((float(s.x), float(s.y), float(en.x), float(en.y), length)) except Exception: continue for (tx, ty) in flow_texts: shaft_cands = [] arrow_pts = [] for (sx, sy, ex, ey, L) in all_lines: mx = (sx + ex) * 0.5 my = (sy + ey) * 0.5 if math.hypot(mx - tx, my - ty) > search_radius_mm: continue if shaft_min_len_mm <= L: shaft_cands.append((L, sx, sy, ex, ey)) else: arrow_pts.append((sx, sy)) arrow_pts.append((ex, ey)) if not shaft_cands: continue shaft_cands.sort(key=lambda t: -t[0]) _, sx, sy, ex, ey = shaft_cands[0] s_end = (sx, sy); e_end = (ex, ey) # 어느 끝이 tip인가: arrowhead 점들이 더 밀집한 쪽 s_cnt = 0; e_cnt = 0 for (ax, ay) in arrow_pts: if math.hypot(ax - sx, ay - sy) < math.hypot(ax - ex, ay - ey): s_cnt += 1 else: e_cnt += 1 if s_cnt == 0 and e_cnt == 0: # arrowhead 검출 실패 → 텍스트에서 먼 쪽을 tip으로 가정 d_s = math.hypot(sx - tx, sy - ty) d_e = math.hypot(ex - tx, ey - ty) if d_s > d_e: tip, tail = s_end, e_end else: tip, tail = e_end, s_end elif s_cnt > e_cnt: tip, tail = s_end, e_end else: tip, tail = e_end, s_end dx = tip[0] - tail[0] dy = tip[1] - tail[1] L = math.hypot(dx, dy) if L < 1e-3: continue flow_dirs.append((dx / L, dy / L)) if not flow_dirs: return None # 평균 (여러 FLOW가 있으면 방향 일치성 확인 후 평균) avg_dx = sum(d[0] for d in flow_dirs) / len(flow_dirs) avg_dy = sum(d[1] for d in flow_dirs) / len(flow_dirs) L = math.hypot(avg_dx, avg_dy) if L < 0.3: # 여러 FLOW가 서로 반대 방향을 가리키면 벡터 합이 작아짐 → 신뢰도 낮음 return None return (avg_dx / L, avg_dy / L) def _detect_optional_components(self, msp, params: GateParams): """Phase A: 부속 구조물 존재 여부를 도면에서 검출해 has_* 플래그 갱신.""" from optional_detector import detect_components, summary_line reports = detect_components(msp, self._get_component_specs()) params.has_service_bridge = reports["service_bridge"].present params.has_hoist_housings = reports["hoist_housings"].present params.has_downstream_apron = reports["downstream_apron"].present params.raw_text_annotations.append((summary_line(reports), 0.0, 0.0)) # ----- Phase B' 평면 폴리곤 추출 ----- @staticmethod def _polygon_area(pts: list) -> float: """shoelace 면적 (부호 없음).""" if len(pts) < 3: return 0.0 a = 0.0 n = len(pts) for i in range(n): x1, y1 = pts[i][0], pts[i][1] x2, y2 = pts[(i + 1) % n][0], pts[(i + 1) % n][1] a += x1 * y2 - x2 * y1 return abs(a) * 0.5 @staticmethod def _is_closed(pts: list, tol: float = 1.0) -> bool: """첫점~끝점 거리가 tol 이하거나 동일점이면 폐합.""" if len(pts) < 3: return False dx = pts[0][0] - pts[-1][0] dy = pts[0][1] - pts[-1][1] return (dx * dx + dy * dy) ** 0.5 <= tol def _extract_plan_polygons(self, msp, params: GateParams, y_mid: float, ymin: float, ymax: float): """plan 영역에서 외곽/교각 폴리곤 추출 (3단계 폴백). 추출 성공 시 self._pier_origin_mm = (ox, oy)에 실제 사용된 origin을 기록 → bridge bbox가 같은 로컬 프레임에 정합.""" self._pier_origin_mm = None # 성공 시 각 경로에서 설정 # === 1차: 폐합 LWPOLYLINE === closed_polys: list[tuple[list, float]] = [] for e in msp: if e.dxf.layer != "CS-CONC-Spillway": continue if e.dxftype() != "LWPOLYLINE": continue try: pts = [(p[0], p[1]) for p in e.get_points()] except Exception: continue if not pts: continue mid_y = sum(p[1] for p in pts) / len(pts) if mid_y <= y_mid: continue is_closed_dxf = False with contextlib.suppress(Exception): is_closed_dxf = bool(e.closed) is_closed_geom = self._is_closed(pts, tol=5.0) if not (is_closed_dxf or is_closed_geom): continue area = self._polygon_area(pts) if area < 100.0: continue closed_polys.append((pts, area)) method_used = "none" expected_n_piers = params.n_gates + 1 if closed_polys: # 폐합 폴리곤 경로 (기존 로직) closed_polys.sort(key=lambda t: -t[1]) outline_pts, outline_area = closed_polys[0] arr_outline = np.array(outline_pts) x_min_mm = arr_outline[:, 0].min() y_min_mm = arr_outline[:, 1].min() self._pier_origin_mm = (x_min_mm, y_min_mm) xmin_m = x_min_mm / 1000.0 ymin_m = y_min_mm / 1000.0 params.plan_outline_polygon = [ ((x / 1000.0) - xmin_m, (y / 1000.0) - ymin_m) for x, y in outline_pts ] pier_min_area = outline_area * 0.015 pier_max_area = outline_area * 0.45 pier_polys_m = [] for pts, area in closed_polys[1:]: if not (pier_min_area <= area <= pier_max_area): continue pier_polys_m.append([ ((x / 1000.0) - xmin_m, (y / 1000.0) - ymin_m) for x, y in pts ]) params.pier_plan_polygons = pier_polys_m method_used = "closed_polylines" # 2차: polygon_reconstructor로 face enumeration (폐합 실패 또는 pier 부족) if len(params.pier_plan_polygons) != expected_n_piers: ok_recon = self._extract_piers_from_line_soup(msp, params, y_mid) if ok_recon: method_used = "face_enumeration" # 3차: 선 스윕 + 격자 정렬 (수평/수직 선 클러스터 → pier 경계 매칭) if len(params.pier_plan_polygons) != expected_n_piers: ok_sweep = self._extract_piers_from_vertical_clusters(msp, params, y_mid) if ok_sweep: method_used = "vertical_clusters" # 4차: bridge 실제 bbox 추출 — pier 추출 방법이 사용한 origin과 동일 프레임 if params.has_service_bridge and self._pier_origin_mm is not None: bridge_bbox_mm = self._extract_bridge_bbox_mm(msp) if bridge_bbox_mm is not None: ox, oy = self._pier_origin_mm bbox = ( (bridge_bbox_mm[0] - ox) / 1000.0, (bridge_bbox_mm[1] - oy) / 1000.0, (bridge_bbox_mm[2] - ox) / 1000.0, (bridge_bbox_mm[3] - oy) / 1000.0, ) params.bridge_plan_bbox = bbox # 사용자 편집 가능한 초기값으로 UI param 노출 (sanity 통과 가정 하) params.bridge_x_start = float(bbox[0]) params.bridge_y_start = float(bbox[1]) params.bridge_x_end = float(bbox[2]) params.bridge_y_end = float(bbox[3]) params.raw_text_annotations.append(( f"[plan_poly] outline_pts={len(params.plan_outline_polygon)}, " f"piers={len(params.pier_plan_polygons)}/{expected_n_piers}, " f"bridge_bbox={params.bridge_plan_bbox}, " f"method={method_used}", 0.0, 0.0 )) def _compute_plan_origin_mm(self, params: GateParams, msp) -> tuple | None: """pier_plan_polygons 또는 plan_outline_polygon의 DXF mm origin을 역산. 각 추출 방법이 이미 (0,0)-기준 로컬 좌표로 저장했으므로, DXF mm 좌표에서 해당 points의 실제 min X/Y를 찾아 origin으로 사용. 여러 폴백 경로를 시도. """ if params.pier_plan_polygons: # pier 폴리곤의 로컬 좌표에서 최소값은 (0,0)에 가까우므로, DXF 상의 # 실제 해당 point 위치를 찾기 위해 폴리곤의 mm 기준 bbox를 별도 계산 # → parser가 로컬 저장 시 사용한 origin과 동일해야 함. # 각 추출 메서드가 origin을 다르게 쓸 수 있으므로, plan 영역 CS-CONC-Spillway # 전체 geometry에서 pier 폴리곤 실제 위치를 역추정: # 간단히: plan 영역 CS-CONC-Spillway geometry의 bbox min을 origin으로 return self._plan_bbox_origin_mm(msp) if params.plan_outline_polygon: return self._plan_bbox_origin_mm(msp) return None def _plan_bbox_origin_mm(self, msp) -> tuple | None: """plan 영역 CS-CONC-Spillway 전체 geometry의 DXF mm bbox min 반환.""" try: from view_detector import detect_view_regions # noqa: F401 (protective availability check) except ImportError: return None for fn in getattr(self, "_cached_paths", []) or []: pass # 현재 context에서 path 접근 불가 — msp로 대체 # msp 기반 bbox: plan 영역 bounds를 view_detector 없이 추정하기 어려움. # 대신 pier_plan_polygons을 역산: 여러 추출 경로가 모두 "plan 영역 geometry # 최소점"을 origin으로 쓰므로, 여기서도 동일하게 계산. xs: list = [] ys: list = [] for e in msp: if e.dxf.layer != "CS-CONC-Spillway": continue try: if e.dxftype() == "LINE": xs.extend([e.dxf.start.x, e.dxf.end.x]) ys.extend([e.dxf.start.y, e.dxf.end.y]) elif e.dxftype() == "LWPOLYLINE": for p in e.get_points(): xs.append(p[0]) ys.append(p[1]) except Exception: continue if not xs: return None # plan 영역만: Y 중간값 이상만 남김 (기존 y_mid 휴리스틱과 동일) y_sorted = sorted(ys) y_mid = y_sorted[len(y_sorted) // 2] xs_plan = [x for x, y in zip(xs, ys, strict=False) if y > y_mid] ys_plan = [y for y in ys if y > y_mid] if not xs_plan: return None return (min(xs_plan), min(ys_plan)) def _extract_bridge_bbox_mm(self, msp) -> tuple | None: """Bridge 관련 레이어(CS-CONC-Bridge / 공도교 / 관리도로 등)의 DXF mm bbox (x_min, y_min, x_max, y_max) 반환. 없으면 None. 주의: 관리도로_수정은 보조 레이어라 제외(주 레이어만 사용). """ tokens = ("bridge", "공도교", "공도", "service road") xs: list = [] ys: list = [] for e in msp: try: layer = e.dxf.layer except Exception: continue lname = layer.lower() if not any(t.lower() in lname for t in tokens): continue try: if e.dxftype() == "LINE": xs.extend([e.dxf.start.x, e.dxf.end.x]) ys.extend([e.dxf.start.y, e.dxf.end.y]) elif e.dxftype() == "LWPOLYLINE": for p in e.get_points(): xs.append(p[0]) ys.append(p[1]) except Exception: continue if not xs: return None return (min(xs), min(ys), max(xs), max(ys)) def _extract_piers_from_line_soup(self, msp, params: GateParams, y_mid: float) -> bool: """plan 영역 CS-CONC-Spillway의 개방선(LINE + LWPOLYLINE 인접쌍)에서 **polygon_reconstructor로 폐합 영역(face)을 복원**해 outline/pier 분류. 알고리즘: 1. 선분 수집 (plan bounds 내부만) 2. polygon_reconstructor.reconstruct_polygons로 모든 face 복원 3. 면적 내림차순: 가장 큰 것은 bbox outer face → outline (또는 해당 face 제외하고 그 다음 것이 실제 구조물 외곽) 4. 외곽 면적의 1.5%~45% 범위 면을 pier 후보 반환: pier가 n_gates+1 개 검출되면 True, 아니면 False. """ # 1) 선분 수집 (원본 DXF mm 단위, plan 영역만) try: from polygon_reconstructor import reconstruct_polygons except ImportError: return False segs: list[tuple[tuple[float, float], tuple[float, float]]] = [] # plan_bounds_mm는 호출 컨텍스트에서 y_mid 계산에 반영됐으므로 # 여기서는 y > y_mid 필터만 일관 적용 for e in msp: if e.dxf.layer != "CS-CONC-Spillway": continue et = e.dxftype() if et == "LINE": try: s, en = e.dxf.start, e.dxf.end if (s.y + en.y) / 2 > y_mid: segs.append(((s.x, s.y), (en.x, en.y))) except Exception: pass elif et == "LWPOLYLINE": try: pts = [(p[0], p[1]) for p in e.get_points()] except Exception: continue if not pts or sum(p[1] for p in pts) / len(pts) <= y_mid: continue segs.extend(pairwise(pts)) # closed flag이면 마지막→첫 번째도 추가 try: if bool(getattr(e, "closed", False)): segs.append((pts[-1], pts[0])) except Exception: pass if not segs: return False # 2) Face 복원 (DXF mm 단위, tol=5mm — CAD 수치 오차 흡수) faces = reconstruct_polygons(segs, tol=5.0, min_area=1000.0, max_faces=3000) if not faces: # 최소한 bbox outline은 세팅 all_x = [p[0] for seg in segs for p in (seg[0], seg[1])] all_y = [p[1] for seg in segs for p in (seg[0], seg[1])] xmin_mm, xmax_mm = min(all_x), max(all_x) ymin_mm, ymax_mm = min(all_y), max(all_y) w = (xmax_mm - xmin_mm) / 1000.0 h = (ymax_mm - ymin_mm) / 1000.0 params.plan_outline_polygon = [ (0.0, 0.0), (w, 0.0), (w, h), (0.0, h) ] return False # 3) 가장 큰 face = 외곽, 그 다음부터 pier 후보 # (planar face enumeration에서 outer face가 항상 포함되진 않으나, # 포함돼도 본 필터에서 정상 처리됨 — 최대 면적을 outline으로 사용) outline_pts, outline_area = faces[0] # 좌표 원점 정규화 (plan 영역 bbox 원점을 0,0으로) arr_x = [p[0] for p in outline_pts] arr_y = [p[1] for p in outline_pts] x_min_mm = min(arr_x); y_min_mm = min(arr_y) self._pier_origin_mm = (x_min_mm, y_min_mm) params.plan_outline_polygon = [ ((x - x_min_mm) / 1000.0, (y - y_min_mm) / 1000.0) for x, y in outline_pts ] # Pier 후보: 외곽 면적의 1.5%~45% + 예상 pier 치수 범위(폭·길이 각 50~200%)에 부합 pier_min_area = outline_area * 0.015 pier_max_area = outline_area * 0.45 # pier_length는 보통 여수로 전체 길이와 비슷하므로 총 길이 사용 expected_pw = params.pier_width expected_pl = max(params.pier_length, params.total_length * 0.5) w_lo, w_hi = expected_pw * 0.5, expected_pw * 2.0 l_lo, l_hi = expected_pl * 0.5, expected_pl * 2.0 pier_polys: list[list[tuple]] = [] for pts, area in faces[1:]: if not (pier_min_area <= area <= pier_max_area): continue xs = [p[0] for p in pts] ys = [p[1] for p in pts] w_mm = max(xs) - min(xs) l_mm = max(ys) - min(ys) w_m = w_mm / 1000.0; l_m = l_mm / 1000.0 # 폭/길이 어느 쪽이 span 축인지 자동 판단 — 더 긴 쪽을 length로 매핑 if l_m < w_m: w_m, l_m = l_m, w_m if not (w_lo <= w_m <= w_hi): continue if not (l_lo <= l_m <= l_hi): continue pier_polys.append([ ((x - x_min_mm) / 1000.0, (y - y_min_mm) / 1000.0) for x, y in pts ]) params.pier_plan_polygons = pier_polys # 성공 기준: pier 수가 예상(n_gates+1)과 일치 expected = params.n_gates + 1 return len(pier_polys) == expected # ----- Phase B'' 선 스윕 + 격자 정렬 ----- def _extract_piers_from_vertical_clusters(self, msp, params: GateParams, y_mid: float) -> bool: """개방선으로 그려진 도면에서 수직 클러스터 gap 패턴으로 gate/pier 식별. 전략: parametric 수치(gate_width, pier_width)에 의존하지 않고 **gap 분포로 gate opening을 먼저 찾은 뒤**, 클러스터를 pier 영역으로 그룹핑해 bbox 폴리곤을 생성. 실측 DXF 흔한 파턴에 맞춰짐. 단계: 1) plan 영역 수직 세그먼트 수집 2) X 1D 클러스터링 → 각 클러스터 (x_avg, y_min, y_max, total_len) 3) 길이 필터 (pier_length × 0.3 이상 = 의미 있는 structural 수직선) 4) 인접 클러스터 gap 계산 → 상위 n_gates 개가 gate opening 5) gate opening 사이/양끝 영역을 pier 영역으로 그룹화 6) 각 pier 영역의 leftmost·rightmost 클러스터가 pier 경계, Y 범위는 그 영역 클러스터들의 교집합 7) 로컬 좌표 m로 변환해 pier_plan_polygons 저장 반환: 정확히 n_gates+1 개 pier 생성되면 True. """ n_expected = params.n_gates + 1 # 1) 수직 세그먼트 수집 verticals: list[tuple[float, float, float]] = [] # (x_avg, y1, y2) for e in msp: if e.dxf.layer != "CS-CONC-Spillway": continue et = e.dxftype() pairs: list[tuple[tuple, tuple]] = [] if et == "LINE": try: s, en = e.dxf.start, e.dxf.end pairs.append(((s.x, s.y), (en.x, en.y))) except Exception: continue elif et == "LWPOLYLINE": try: pts = [(p[0], p[1]) for p in e.get_points()] except Exception: continue pairs.extend(pairwise(pts)) for p1, p2 in pairs: dx = p2[0] - p1[0]; dy = p2[1] - p1[1] if abs(dy) < 100.0: continue if abs(dy) < 3.0 * abs(dx): continue if (p1[1] + p2[1]) / 2 <= y_mid: continue verticals.append(((p1[0] + p2[0]) / 2, min(p1[1], p2[1]), max(p1[1], p2[1]))) if not verticals: return False # 2) X 클러스터링 (greedy 1D, tol 500mm) verticals.sort(key=lambda v: v[0]) cluster_tol_mm = 500.0 clusters_raw: list[list] = [[verticals[0]]] for seg in verticals[1:]: if seg[0] - clusters_raw[-1][-1][0] < cluster_tol_mm: clusters_raw[-1].append(seg) else: clusters_raw.append([seg]) # 3) 특성 계산 + 길이 필터 length_threshold = max(params.pier_length * 0.3 * 1000.0, 3000.0) strong: list[tuple[float, float, float, float]] = [] # (x, y_min, y_max, total_len) for cl in clusters_raw: xs = [s[0] for s in cl] y_min = min(s[1] for s in cl) y_max = max(s[2] for s in cl) total_len = sum(s[2] - s[1] for s in cl) if total_len >= length_threshold: strong.append((sum(xs) / len(xs), y_min, y_max, total_len)) if len(strong) < 2 * n_expected: # 기대하는 수직선 수(pier당 2)가 안 나오면 실패 return False # 4) gap 분포 분석 → 상위 n_gates gap이 gate opening strong.sort(key=lambda c: c[0]) gaps = [(i, strong[i + 1][0] - strong[i][0]) for i in range(len(strong) - 1)] if not gaps: return False # 상위 n_gates gap 인덱스 sorted_gaps = sorted(gaps, key=lambda g: -g[1]) if len(sorted_gaps) < params.n_gates: return False gate_gap_indices = sorted([sorted_gaps[i][0] for i in range(params.n_gates)]) # 5) pier 영역 그룹화 pier_regions: list[list[tuple]] = [] prev = 0 for gi in gate_gap_indices: pier_regions.append(strong[prev:gi + 1]) # gi 포함 = pier 오른쪽 edge prev = gi + 1 pier_regions.append(strong[prev:]) if len(pier_regions) != n_expected: return False # 5a) 각 pier region이 최소 2개 클러스터 (left + right edge) 확보 for region in pier_regions: if len(region) < 2: return False # 6) pier 폴리곤 구성 (leftmost~rightmost X, Y 범위는 region 전체) pier_polys_mm: list[list[tuple]] = [] for region in pier_regions: left_x = region[0][0] right_x = region[-1][0] # Y 범위: region 클러스터들의 교집합 (공통으로 존재하는 수직 범위) y_min = max(c[1] for c in region) y_max = min(c[2] for c in region) # 교집합이 짧으면 합집합으로 폴백 (정보 보존) if y_max - y_min < params.pier_length * 1000.0 * 0.3: y_min = min(c[1] for c in region) y_max = max(c[2] for c in region) pier_polys_mm.append([ (left_x, y_min), (right_x, y_min), (right_x, y_max), (left_x, y_max), ]) # 7) 로컬 좌표 m 변환 (plan_outline_polygon이 있으면 그 origin 재사용, 없으면 pier bbox) all_x = [p[0] for poly in pier_polys_mm for p in poly] all_y = [p[1] for poly in pier_polys_mm for p in poly] ox_mm = min(all_x) oy_mm = min(all_y) self._pier_origin_mm = (ox_mm, oy_mm) if not params.plan_outline_polygon: # pier bbox를 outline으로 사용 (단순 사각형) w_m = (max(all_x) - ox_mm) / 1000.0 h_m = (max(all_y) - oy_mm) / 1000.0 # 약간의 여유 margin margin = 0.5 params.plan_outline_polygon = [ (-margin, -margin), (w_m + margin, -margin), (w_m + margin, h_m + margin), (-margin, h_m + margin), ] params.pier_plan_polygons = [ [((x - ox_mm) / 1000.0, (y - oy_mm) / 1000.0) for x, y in poly] for poly in pier_polys_mm ] return True # ----- 텍스트 주석 스캔 ----- # 핵심 키워드 → 파라미터 매핑 _ELEVATION_PATTERNS: ClassVar[list[tuple[str, str]]] = [ (r"Gate Sill\s*EL\.?\s*(\d+\.?\d*)", "el_gate_sill"), (r"Weir Crest\s*EL\.?\s*(\d+\.?\d*)", "el_weir_crest"), (r"Gate Top\s*EL\.?\s*(\d+\.?\d*)", "el_gate_top"), (r"Trunnion(?: Pin)?\s*EL\.?\s*(\d+\.?\d*)", "el_trunnion_pin"), (r"Stoplog Sill\s*EL\.?\s*(\d+\.?\d*)", "el_stoplog_sill"), (r"M\.?W\.?L\.?\s*EL\.?\s*(\d+\.?\d*)", "el_mwl"), (r"N\.?H\.?W\.?L\.?\s*EL\.?\s*(\d+\.?\d*)", "el_nhwl"), (r"F\.?W\.?L\.?\s*EL\.?\s*(\d+\.?\d*)", "el_nhwl"), # F.W.L ≈ N.H.W.L (r"L\.?W\.?L\.?\s*EL\.?\s*(\d+\.?\d*)", "el_lwl"), ] _GATE_SPEC_PATTERN = re.compile( r"W\s*(\d+\.?\d*)\s*m?\s*[xX×]\s*H\s*(\d+\.?\d*)\s*m?\s*[xX×]\s*(\d+)\s*(?:문|門|bay)", re.IGNORECASE, ) def _scan_text_annotations(self, msp, params: GateParams): """TEXT, MTEXT 주석을 스캔하여 사양/표고 파싱.""" for e in msp: et = e.dxftype() if et not in ("TEXT", "MTEXT"): continue try: txt = e.dxf.text if et == "TEXT" else (e.text or "") txt = txt.strip() except Exception: continue if not txt: continue # 원본 주석 보관 try: pos = e.dxf.insert params.raw_text_annotations.append((txt, pos.x, pos.y)) except Exception: params.raw_text_annotations.append((txt, 0.0, 0.0)) # 수문 사양: "W15.0m x H7.0m x 3문" m = self._GATE_SPEC_PATTERN.search(txt) if m: params.gate_width = float(m.group(1)) params.gate_height = float(m.group(2)) params.n_gates = int(m.group(3)) # 표고 패턴 for pattern, field_name in self._ELEVATION_PATTERNS: mm = re.search(pattern, txt, re.IGNORECASE) if mm: try: val = float(mm.group(1)) if hasattr(params, field_name): setattr(params, field_name, val) except Exception: pass # ----- 수문 위치 추출 (치수선 기반) ----- def _extract_gate_positions_from_dims(self, msp, params: GateParams): """DIMENSION 엔티티에서 'Clear Span'을 찾아 수문 중심 X 좌표 보정.""" clear_span_dims = [] for e in msp: if e.dxftype() != "DIMENSION": continue try: text = e.dxf.get("text", "") meas = e.dxf.get("actual_measurement", None) if meas is None or meas < 1000 or meas > 100000: continue # "Clear Span <>" 패턴 또는 15000 근처의 수평 치수 is_clear_span = "Clear Span" in text or abs(meas - 15000) < 500 dp1 = e.dxf.defpoint dp2 = e.dxf.defpoint2 if e.dxf.hasattr("defpoint2") else dp1 dx = abs(dp2.x - dp1.x) dy = abs(dp2.y - dp1.y) # 수평 치수 (dx > dy) if dx > dy and is_clear_span: # dp1과 dp2의 중점 X (그리고 평면영역 Y > 45000 인지 확인) mid_x = (dp1.x + dp2.x) / 2 mid_y = (dp1.y + dp2.y) / 2 if mid_y > 40000: # 평면영역 clear_span_dims.append(mid_x / 1000.0) # mm→m except Exception: continue if clear_span_dims: clear_span_dims.sort() # 중복 제거 (동일 X 근처) unique = [] for x in clear_span_dims: if not unique or abs(x - unique[-1]) > params.gate_width * 0.5: unique.append(x) if len(unique) >= 2: # 최소 2개 이상 확인되면 신뢰 # 로컬 좌표계로 변환 x_min = min(unique) params.gate_centers_x = [x - x_min + params.gate_width / 2 for x in unique] params.n_gates = len(unique) # ----- 누락 파라미터 추론 ----- def _infer_missing_params(self, params: GateParams): """파싱되지 않은 파라미터를 합리적 기본값/추론값으로 채움.""" # 수문 높이: Gate Top - Gate Sill if abs(params.gate_height - 7.0) < 0.01: # 기본값 상태면 diff = params.el_gate_top - params.el_gate_sill if 4.0 < diff < 15.0: params.gate_height = diff # pier_count = n_gates + 1 params.pier_count = params.n_gates + 1 # 교각 폭 추론: gate_centers_x가 있으면 인접 수문 간격에서 계산 if len(params.gate_centers_x) >= 2: # 인접 수문 중심 간격 = gate_width + pier_width spacings = [params.gate_centers_x[i+1] - params.gate_centers_x[i] for i in range(len(params.gate_centers_x) - 1)] avg_spacing = sum(spacings) / len(spacings) inferred_pw = avg_spacing - params.gate_width if 1.0 <= inferred_pw <= 8.0: params.pier_width = inferred_pw else: params.pier_width = 3.0 else: total_gate_w = params.n_gates * params.gate_width if params.total_span > total_gate_w: inferred = (params.total_span - total_gate_w) / (params.n_gates + 1) params.pier_width = inferred if 1.5 <= inferred <= 3.5 else 3.0 else: params.pier_width = 3.0 # gate_centers_x가 비어있으면 균등 배치 if not params.gate_centers_x: pw = params.pier_width gw = params.gate_width params.gate_centers_x = [ pw + gw * 0.5 + i * (gw + pw) for i in range(params.n_gates) ] # 구조물 유효 폭 (수문+교각만, wing wall 제외) pw = params.pier_width gw = params.gate_width effective_span = params.n_gates * gw + (params.n_gates + 1) * pw # gate_centers_x를 로컬 좌표계(0 ~ effective_span)로 재정렬 if params.gate_centers_x: offset = params.gate_centers_x[0] - (pw + gw / 2) params.gate_centers_x = [x - offset for x in params.gate_centers_x] params.total_span = effective_span # ogee_profile이 비어있으면 표준 ogee 곡선으로 생성 if not params.ogee_profile: params.ogee_profile = self._default_ogee_profile(params) def _default_ogee_profile(self, params: GateParams) -> list: """표준 ogee 여수로 단면을 표고 기반으로 생성. 간략화된 crest → 경사면 → apron 프로파일. 점 목록 [(x_along_flow, z_elevation)] """ crest_el = params.el_weir_crest sill_el = params.el_gate_sill upstream_bed = params.el_upstream_bed downstream_bed = params.el_downstream # 상류 수직 → 크레스트 정상 → 하류 곡선 → 수평 apron profile = [ (0.0, upstream_bed), # 상류 바닥 (0.0, crest_el - 2.0), # 상류 옹벽 상단 (수면 아래) (1.0, crest_el), # 크레스트 정점 (3.0, crest_el - 1.5), # 하류 곡선 시작 (7.0, sill_el + 2.0), # 하류 경사면 중간 (12.0, sill_el), # 게이트 sill 레벨 (20.0, sill_el), # 평탄 apron (25.0, downstream_bed), # 하류 바닥 ] return profile # --------------------------------------------------------------------------- # 편의 함수 # --------------------------------------------------------------------------- def parse_gate_dxf(plan_dxf: str, section_dxf: str | None = None) -> GateParams: """간편 호출 인터페이스.""" parser = GateParser() return parser.parse(plan_dxf, section_dxf) if __name__ == "__main__": # 샘플 테스트 import sys if len(sys.argv) >= 3: params = parse_gate_dxf(sys.argv[1], sys.argv[2]) elif len(sys.argv) == 2: params = parse_gate_dxf(sys.argv[1]) else: # Gate_Sample 기본 경로 base = Path("Gate_Sample") f1 = base / "12995740-M40-001 여수로 수문 설치도(1／2).dxf" f2 = base / "12995740-M40-002 여수로 수문 설치도(2／2).dxf" params = parse_gate_dxf(str(f1), str(f2)) print(params.summary()) print() print(f"ogee profile: {len(params.ogee_profile)} points") if params.ogee_profile: for x, z in params.ogee_profile[:10]: print(f" ({x:.2f}m, EL.{z:.2f})")