From 022908abed3ea66f8596042ccd5178f2135cc577 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Fri, 4 Sep 2026 18:12:54 +0900 Subject: [PATCH 1/5] =?UTF-8?q?fix(B07):=20=ED=9A=A1=EB=8B=A8=EB=A9=B4?= =?UTF-8?q?=EB=8F=84=20=EC=B9=B8=20=ED=81=AC=EA=B8=B0=20=ED=86=B5=EC=9D=BC?= =?UTF-8?q?=20=E2=80=94=20=EC=B6=95=EC=B2=99=201/100=20=EC=9C=A0=EC=A7=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 실측 결과 축척은 문제가 아니었음. 실거리 3 m 가 모든 단면에서 30.0 mm (mm/m = 10.0 단일값). 뒤죽박죽으로 보인 원인은 칸 크기 — 한 장 안에서 폭 116~218 mm, 높이 29~178 mm 로 제각각이었음. - 장별 완전 통일: 한 장 안 모든 칸을 그 장 최대 블록 크기로 통일(_grid_for). 테두리는 build_cross_drawing(cell_frame=...) 로 칸에 맞춰 그림. - 장 경계는 전체 최소 장수가 되도록 동적계획으로 선택(_sheet_breaks). 앞에서부터 채우면 바로 뒤의 큰 단면이 칸을 키워 6칸짜리 장에 1개만 실리는 낭비가 있었음. - 축척은 지식DB 「설계제원_총괄」 기준 1/100 고정 — 어떤 경우에도 줄이지 않고 안 들어가면 장을 나눔. 장수는 세트마다 달라짐(2026-09-04 사용자 확정). 검증(용화_LAS): 장 21개 전부 칸 크기 단일값, mm/m = 10 단일, 측점 65개 누락 0, 칸 밖 이탈 0.000 mm. 실서버 API 로도 동일 확인. Co-Authored-By: Claude Opus 5 (1M context) --- .../B07_DesignDetail_Engine_Cad.py | 34 ++--- .../B07_DesignDetail_Engine_Cad_Sheet.py | 126 +++++++++++------- 2 files changed, 96 insertions(+), 64 deletions(-) diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad.py index 93daca79..04b121aa 100644 --- a/B07_DesignDetail/B07_DesignDetail_Engine_Cad.py +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad.py @@ -443,6 +443,7 @@ def build_cross_drawing( design_elevation_m: float | None = None, frame: dict[str, float] | None = None, origin: tuple[float, float] = (0.0, 0.0), + cell_frame: tuple[float, float, float, float] | None = None, ) -> dict[str, Any]: """횡단도 한 장을 지표/설계/구조물(+암 경계) 레이어 + CAD 수량 산출표로 만든다. @@ -450,6 +451,10 @@ def build_cross_drawing( 설계선·구조물이 원지반과 갈라지는 구간 + 여유다. 세로는 이 단면 선들의 bbox 중심을 0에 둔다(측점마다 화면 중앙 정렬). design_elevation_m는 현재 배치에 쓰지 않지만 향후 표고 주석용으로 시그니처를 유지한다. + + cell_frame(왼쪽, 아래, 오른쪽, 위 — 종이 mm)을 주면 테두리를 그 칸에 맞춰 + 그린다. 장 배치에서 한 장 안의 칸을 같은 크기로 통일할 때 쓴다(2026-09-04 + 사용자 확정 — 축척 1/100은 그대로, 칸만 통일). """ ox, oy = origin raw_ground = points_from_samples(source.get("samples", []), "offset_m") @@ -511,16 +516,20 @@ def build_cross_drawing( ) table_bottom = table_top - cross_table_height() - # 외곽 테두리: 단면 범위와 표를 함께 감싼다. - frame_x = max((x1 - x0) / 2.0 * CROSS_MM + 4.0, cross_table_width() / 2.0 + 4.0) - frame_top = oy + half_height + 4.0 - frame_bottom = table_bottom - 4.0 + # 외곽 테두리: 단면 범위와 표를 함께 감싼다. 칸 크기를 받았으면 그 칸에 맞춘다. + if cell_frame is not None: + frame_left, frame_bottom, frame_right, frame_top = cell_frame + else: + frame_x = max((x1 - x0) / 2.0 * CROSS_MM + 4.0, cross_table_width() / 2.0 + 4.0) + frame_left, frame_right = center_x - frame_x, center_x + frame_x + frame_top = oy + half_height + 4.0 + frame_bottom = table_bottom - 4.0 corners = [ - (center_x - frame_x, frame_bottom), - (center_x + frame_x, frame_bottom), - (center_x + frame_x, frame_top), - (center_x - frame_x, frame_top), - (center_x - frame_x, frame_bottom), + (frame_left, frame_bottom), + (frame_right, frame_bottom), + (frame_right, frame_top), + (frame_left, frame_top), + (frame_left, frame_bottom), ] border = polyline_entity(drawing_id, corners, FRAME_LAYER_ID, TABLE_LINE_COLOR) if border: @@ -542,12 +551,7 @@ def build_cross_drawing( "x1": x1, # 블록 테두리(종이 mm). 프론트가 자기 그림을 이 안으로 자르고, 갈아 끼울 # 서버 설계선을 이 안에서만 골라내는 데 쓴다. - "frame": [ - center_x - frame_x, - frame_bottom, - center_x + frame_x, - frame_top, - ], + "frame": [frame_left, frame_bottom, frame_right, frame_top], } ], "layers": [ diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py index 43a1e52d..cce9992e 100644 --- a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Sheet.py @@ -84,72 +84,85 @@ def section_block_size( return (width, top + below) -def _pack( - blocks: list[tuple[int, float, float]], start: int, rows: int -) -> tuple[int, list[float], list[float]]: - """blocks[start:]를 rows행 **열 우선**으로 담아 (담은 개수, 열폭, 행높이)를 낸다. - - 열폭은 그 열에 든 블록의 최대폭, 행높이는 그 행에 든 블록의 최대높이다 — 칸을 - 전체 최대치로 통일하지 않으면서 행·열은 맞춘다(2026-08-30 사용자 확정). - """ +def _grid_for(group: list[tuple[int, float, float]]) -> tuple[float, float, int, int]: + """한 장에 담을 블록 묶음의 (칸폭, 칸높이, 열수, 행수) — 칸은 그 장 최대 블록 기준.""" usable_w, usable_h = usable_area() - col_widths: list[float] = [] - row_heights: list[float] = [0.0] * rows - count = 0 - for index, (_chainage, width, height) in enumerate(blocks[start:]): - column, row = divmod(index, rows) - current = col_widths[column] if column < len(col_widths) else 0.0 - new_col = max(current, width + _BLOCK_GAP_MM) - new_row = max(row_heights[row], height + _BLOCK_GAP_MM) - if sum(col_widths[:column]) + new_col > usable_w: - break - if sum(row_heights) - row_heights[row] + new_row > usable_h: - break - if column < len(col_widths): - col_widths[column] = new_col - else: - col_widths.append(new_col) - row_heights[row] = new_row - count = index + 1 - return count, col_widths, row_heights + cell_w = max(width for _c, width, _h in group) + _BLOCK_GAP_MM + cell_h = max(height for _c, _w, height in group) + _BLOCK_GAP_MM + return cell_w, cell_h, int(usable_w // cell_w), int(usable_h // cell_h) -def _slots(col_widths: list[float], row_heights: list[float], count: int) -> list[list[float]]: +def _max_take(blocks: list[tuple[int, float, float]], start: int) -> int: + """blocks[start:] 를 한 장에 담을 수 있는 최대 개수(칸 통일 기준).""" + limit = 0 + for take in range(1, len(blocks) - start + 1): + _cw, _ch, columns, rows = _grid_for(blocks[start : start + take]) + if columns * rows < take: + break + limit = take + return limit + + +def _sheet_breaks(blocks: list[tuple[int, float, float]]) -> list[int]: + """장 경계를 **전체 최소 장수**가 되도록 고른다 (측점 순서는 유지). + + 앞에서부터 최대한 채우면 바로 뒤에 큰 단면이 오는 순간 칸이 그 단면 크기로 + 튀어 그 장이 통째로 비었다(2026-09-04 실측: 6칸짜리 장에 1개만 배치). 단면 + 크기는 측점마다 원지반 기울기로 달라지므로, 경계를 뒤에서부터 훑어 최소 장수 + 조합을 고른다 — 큰 단면은 자기 장에 몰리고 비슷한 크기끼리 한 장에 모인다. + 같은 장수면 **앞 장을 더 많이 채우는 쪽**을 고른다(뒷장에 여백을 몰아 준다). + """ + total = len(blocks) + best_sheets = [0] * (total + 1) + best_take = [0] * (total + 1) + for start in range(total - 1, -1, -1): + limit = max(_max_take(blocks, start), 1) + choice = (total + 1, 0) + for take in range(1, limit + 1): + candidate = (best_sheets[start + take] + 1, -take) + if candidate < choice: + choice = candidate + best_sheets[start], best_take[start] = choice[0], -choice[1] + breaks: list[int] = [] + start = 0 + while start < total: + breaks.append(best_take[start]) + start += best_take[start] + return breaks + + +def _slots(cell_w: float, cell_h: float, rows: int, count: int) -> list[list[float]]: """칸의 (가로 중심, 아래 변) — 좌하단부터 아래→위로 채우고, 열이 차면 오른쪽 열. - 세로는 중심이 아니라 **아래 변**을 준다. 수량표 높이는 모든 블록이 같으므로 - 아래를 맞추면 같은 행의 표가 한 줄로 선다(2026-08-30 사용자: 표는 행·열을 맞춘다). + 칸이 모두 같은 크기이므로 격자 좌표만 계산하면 된다(2026-08-29 사용자: 채우는 + 순서는 좌하단부터 열 우선). """ usable_w, usable_h = usable_area() - rows = len(row_heights) slots: list[list[float]] = [] for index in range(count): column, row = divmod(index, rows) - x = -usable_w / 2.0 + sum(col_widths[:column]) + col_widths[column] / 2.0 - y = -usable_h / 2.0 + sum(row_heights[:row]) - slots.append([x, y]) + slots.append( + [ + -usable_w / 2.0 + column * cell_w + cell_w / 2.0, + -usable_h / 2.0 + row * cell_h, + ] + ) return slots def plan_cross_sheets(blocks: list[tuple[int, float, float]]) -> list[dict[str, Any]]: """(측점, 폭, 높이) 목록을 A1 장으로 나눈다. - 블록 크기를 먼저 재서 **가장 많이 담기는 행 수**를 고르고, 그 행·열 격자에 - 담는다(2026-08-30 사용자 지시 — 전체 최대치 통일은 여백이 너무 많았다). + 한 장 안의 칸은 모두 같은 크기(그 장 최대 블록 기준)이고 빈 곳은 여백으로 둔다. + 작성 척도는 1/100 고정 — 안 들어가면 장을 나눌 뿐 줄이지 않는다(지식DB + 「설계제원_총괄」 측량·도면 기준). 장에 담기는 측점 수는 세트마다 다르다 + (2026-09-04 사용자 확정). """ sheets: list[dict[str, Any]] = [] start = 0 - while start < len(blocks): - best: tuple[int, list[float], list[float]] = (0, [], []) - for rows in range(1, len(blocks) - start + 1): - packed = _pack(blocks, start, rows) - if packed[0] > best[0]: - best = packed - count, col_widths, row_heights = best - if count == 0: # 한 칸도 못 담을 만큼 큰 블록 — 그래도 한 장에 하나는 놓는다. - count, col_widths, row_heights = 1, [blocks[start][1]], [blocks[start][2]] + for count in _sheet_breaks(blocks): group = blocks[start : start + count] - number = len(sheets) + 1 + cell_w, cell_h, _columns, rows = _grid_for(group) chainages = [chainage for chainage, _w, _h in group] sheets.append( { @@ -157,10 +170,12 @@ def plan_cross_sheets(blocks: list[tuple[int, float, float]]) -> list[dict[str, # 바뀌어 한 장에 담기는 측점 수가 달라졌을 때 같은 이름이 다른 구간을 # 가리키고, 옛 확정 표시가 그대로 새 구간에 붙는다(2026-09-01 지적). "id": f"cross_s{chainages[0]:05d}m", - "number": number, + "number": len(sheets) + 1, "chainages": chainages, - "rows": len(row_heights), - "slots": _slots(col_widths, row_heights, count), + "rows": max(rows, 1), + "cell_width": cell_w, + "cell_height": cell_h, + "slots": _slots(cell_w, cell_h, max(rows, 1), count), } ) start += count @@ -172,6 +187,8 @@ def build_cross_sheet(sheet: dict[str, Any], sections: list[dict[str, Any]]) -> entities: list[dict[str, Any]] = [] placements: list[dict[str, Any]] = [] slots = sheet.get("slots") or [] + cell_w = float(sheet.get("cell_width") or 0.0) + cell_h = float(sheet.get("cell_height") or 0.0) for index, section in enumerate(sections): if index >= len(slots): @@ -197,6 +214,16 @@ def build_cross_sheet(sheet: dict[str, Any], sections: list[dict[str, Any]]) -> center_x - (min_x + max_x) / 2.0, bottom_y + _BLOCK_GAP_MM / 2.0 - min_y, ) + # 3) 테두리는 칸 크기로 통일한다 — 단면 크기와 무관하게 한 장 안에서 같은 크기. + cell_frame = None + if cell_w > 0.0 and cell_h > 0.0: + half = (cell_w - _BLOCK_GAP_MM) / 2.0 + cell_frame = ( + center_x - half, + bottom_y + _BLOCK_GAP_MM / 2.0, + center_x + half, + bottom_y + cell_h - _BLOCK_GAP_MM / 2.0, + ) placed = build_cross_drawing( section["source"], seed_id, @@ -205,6 +232,7 @@ def build_cross_sheet(sheet: dict[str, Any], sections: list[dict[str, Any]]) -> section.get("quantity_table"), section.get("title", ""), origin=origin, + cell_frame=cell_frame, ) entities.extend(placed["entities"]) placements.extend(placed.get("cross_placements") or []) From 6dd0dec93a5c4b7083d528a12bba2d096d856328 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Fri, 4 Sep 2026 18:38:43 +0900 Subject: [PATCH 2/5] =?UTF-8?q?feat(B07):=20=EA=B3=84=ED=9A=8D=ED=8F=89?= =?UTF-8?q?=EB=A9=B4=EB=8F=84=203=EC=A2=85=20=E2=80=94=20=EC=88=98?= =?UTF-8?q?=EC=B9=98=EB=93=B1=EA=B3=A0=EC=84=A0=20=EB=B0=B0=EA=B2=BD=20?= =?UTF-8?q?=EC=9C=84=20=EB=85=B8=EC=84=A0=C2=B7=EC=B8=A1=EC=A0=90=C2=B7?= =?UTF-8?q?=EA=B5=AC=EC=A1=B0=EB=AC=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 빈 도각이던 계획평면도(지형·노선배치도·배치도)를 실제 도면으로 만듦. - 배경 공용화: map_background() 한 창구로 도엽 등고선·세류선 읽기·좌표 환산· 도곽 절취를 모음. 유역도와 계획평면도가 같은 것을 부르고, 환산 결과는 파일 mtime 을 키로 캐시(_metric_lines_cached). - 축척 1/1,200 고정(DRAWING_SCALE_PLAN) — 지식DB 「설계제원_총괄」 측량·도면 기준. 횡단면도와 같은 원칙으로 줄이지 않고 안 들어가면 장을 나눔(plan_chunks, 종단 측점 기준·경계 측점 1개 중복). - 세 장이 같은 배경·같은 도곽 배치를 쓰고 주제만 다름. 측점 눈금은 종단 측점 좌표로 찍고, 구조물은 pipe_points.json 정본을 읽어 마름모+이름으로 표기. - 도면 목록·단건 조회에 kind="plan" 추가. 화면 목록은 id 접두어로 묶어 장이 나뉘어도 한 그룹으로 보임. 검증(용화_LAS): 콘텐츠 734.3x489.2 mm ≤ A1 작도영역 739.2x499.2, 노선 실거리 630.1x214.2 m → 종이 525.12x178.46 mm(실측 0.83333 mm/m = 1/1,200 일치), 배경 등고선 180줄이 세 장 동일, 유역도 8.5초 → 계획평면도 1.3초(캐시 적중, 파일 재읽기 없음). Co-Authored-By: Claude Opus 5 (1M context) --- .../B07_DesignDetail_Api_Fetch.ts | 53 ++- .../B07_DesignDetail_Engine_Cad_Plan.py | 388 ++++++++++++++++++ B07_DesignDetail/B07_DesignDetail_Router.py | 10 + .../B07_DesignDetail_Router_Support.py | 59 ++- .../B07_DesignDetail_Router_Support_Basin.py | 248 ++++++++--- B07_DesignDetail/B07_DesignDetail_Schema.py | 4 +- .../B07_DesignDetail_UI_Panels.ts | 56 ++- config/config_system.py | 3 + 8 files changed, 729 insertions(+), 92 deletions(-) create mode 100644 B07_DesignDetail/B07_DesignDetail_Engine_Cad_Plan.py diff --git a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts index accd314c..2a29b156 100644 --- a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts +++ b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts @@ -5,7 +5,14 @@ import { API_BASE_URL, API_TIMEOUT_MS } from "@config/config_frontend"; export interface DesignDrawingItem { id: string; // blank: 아직 내용을 만들지 않은 도면 — 도각만 실려 온다. - kind: "cover" | "longitudinal" | "cross" | "mass_haul" | "watershed" | "blank"; + kind: + | "cover" + | "longitudinal" + | "cross" + | "mass_haul" + | "watershed" + | "plan" + | "blank"; label: string; chainage_m: number | null; confirmed: boolean; @@ -67,7 +74,10 @@ export interface CrossDesignInfo { cross_slope_pct?: number; paved?: boolean; ditch: DitchSpec; - road_edges?: Record<"left" | "right", { offset_m: number; elevation_m: number }>; + road_edges?: Record< + "left" | "right", + { offset_m: number; elevation_m: number } + >; design_elevation_m: number; cut_area_m2: number; fill_area_m2: number; @@ -80,7 +90,14 @@ export interface DesignDrawingResponse { route_id: number; id: string; // blank: 아직 내용을 만들지 않은 도면 — 도각만 실려 온다. - kind: "cover" | "longitudinal" | "cross" | "mass_haul" | "watershed" | "blank"; + kind: + | "cover" + | "longitudinal" + | "cross" + | "mass_haul" + | "watershed" + | "plan" + | "blank"; label: string; drawing: CadDrawing; confirmed: boolean; @@ -97,7 +114,10 @@ export interface DesignDrawingConfirmResponse { design?: CrossDesignInfo | null; } -async function requestJson(path: string, init: RequestInit = {}): Promise { +async function requestJson( + path: string, + init: RequestInit = {}, +): Promise { const controller = new AbortController(); const timeoutId = window.setTimeout(() => controller.abort(), API_TIMEOUT_MS); try { @@ -108,14 +128,17 @@ async function requestJson(path: string, init: RequestInit = {}): Promise signal: controller.signal, }); const payload = (await response.json()) as T & { message?: string }; - if (!response.ok) throw new Error(payload.message ?? `HTTP ${response.status}`); + if (!response.ok) + throw new Error(payload.message ?? `HTTP ${response.status}`); return payload; } finally { window.clearTimeout(timeoutId); } } -export function fetchDesignDrawingList(projectId: string): Promise { +export function fetchDesignDrawingList( + projectId: string, +): Promise { return requestJson(`/projects/${projectId}/design-drawings`); } @@ -123,7 +146,9 @@ export function fetchDesignDrawing( projectId: string, drawingId: string, ): Promise { - return requestJson(`/projects/${projectId}/design-drawings/${encodeURIComponent(drawingId)}`); + return requestJson( + `/projects/${projectId}/design-drawings/${encodeURIComponent(drawingId)}`, + ); } export function confirmDesignDrawing( @@ -141,7 +166,10 @@ export function confirmDesignDrawing( ); } -export function invalidateDesignDrawing(projectId: string, drawingId: string): Promise { +export function invalidateDesignDrawing( + projectId: string, + drawingId: string, +): Promise { return requestJson( `/projects/${projectId}/design-drawings/${encodeURIComponent(drawingId)}/invalidate`, { method: "POST" }, @@ -157,11 +185,16 @@ export interface FrameTemplateResponse { customized: boolean; } -export function fetchFrameTemplate(projectId: string): Promise { +export function fetchFrameTemplate( + projectId: string, +): Promise { return requestJson(`/projects/${projectId}/frame-template`); } -export function saveFrameTemplate(projectId: string, drawing: CadDrawing): Promise { +export function saveFrameTemplate( + projectId: string, + drawing: CadDrawing, +): Promise { return requestJson(`/projects/${projectId}/frame-template`, { method: "PUT", body: JSON.stringify({ drawing }), diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Plan.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Plan.py new file mode 100644 index 00000000..18da7be6 --- /dev/null +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Plan.py @@ -0,0 +1,388 @@ +"""B07 계획평면도 CAD 조립 — 수치등고선 배경 위에 노선·측점·구조물을 얹는다. + +세 장이 같은 배경·같은 축척을 쓰고 주제만 다르다(2026-09-04 사용자 지시). + + - 계획평면도(지형) : 등고선·세류선만 + - 계획평면도(노선배치도): 배경 + 계획노선 + 측점 + - 계획평면도(배치도) : 배경 + 계획노선 + 구조물 배치 + +배경 자료는 유역도와 **같은 창구**(`B07_DesignDetail_Router_Support_Basin.map_background`) +에서 온다 — 도엽 GeoJSON 읽기·좌표 환산은 한 번뿐이고 여러 도면이 그 결과를 나눠 쓴다. + +축척은 지식DB 「설계제원_총괄」 측량·도면 기준 **1/1,200 고정**이다. 횡단면도와 같은 +원칙으로, 한 장에 안 들어가면 축척을 줄이지 않고 **장을 나눈다**. + +좌표 규약: 종이 mm = (사업지 좌표 m - 그 장 콘텐츠 최소점) x MM (1/1,200 -> 1 m = 5/6 mm). +""" + +import math +from typing import Any + +from B07_DesignDetail.B07_DesignDetail_Engine_Cad import ( + DRAWING_FORMAT, + FRAME_LAYER_ID, + TABLE_LABEL_COLOR, + _layer, + _text_entity, + polyline_entity, + station_plus_label, +) +from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( + compass_entities, + entities_bbox, + frame_entities, + scale_fields, + usable_area, +) +from config.config_system import DRAWING_SCALE_PLAN + +# 도면 좌표 = 종이 mm. 실거리 1 m가 종이에서 차지하는 mm (1/1,200 -> 0.8333). +MM = 1000.0 / DRAWING_SCALE_PLAN + +CONTOUR_LAYER_ID = "b07-plan-contour" +CONTOUR_COLOR = "#6b7684" +STREAM_LAYER_ID = "b07-plan-stream" +STREAM_COLOR = "#4d9dff" +ROUTE_LAYER_ID = "b07-plan-route" +ROUTE_COLOR = "#ffe066" +STATION_LAYER_ID = "b07-plan-station" +STATION_COLOR = "#ff9d4d" +STRUCTURE_LAYER_ID = "b07-plan-structure" +STRUCTURE_COLOR = "#ff4d4d" +TITLE_LAYER_ID = "b07-plan-title" + +_ROUTE_WIDTH = 3 +_TITLE_FONT_SIZE = 7.0 +_FONT_SIZE = 2.2 +_STATION_FONT_SIZE = 2.0 +_STATION_TICK_MM = 2.5 # 측점 눈금 반길이(종이 mm) +_STRUCTURE_SIZE_MM = 3.0 # 구조물 기호 반크기(종이 mm) +_STRUCTURE_FONT_SIZE = 2.2 +_TITLE_BAND = 22.0 # 제목·척도가 차지하는 위쪽 띠(mm) +_COMPASS_SIZE = 26.0 +_COMPASS_MARGIN = 12.0 + +# 세 장의 주제 (id 접두어, 도면명, 노선·측점·구조물을 그리는지). +PLAN_KINDS: tuple[tuple[str, str, bool, bool, bool], ...] = ( + ("plan_terrain", "계획평면도(지형)", False, False, False), + ("plan_route", "계획평면도(노선배치도)", True, True, False), + ("plan_layout", "계획평면도(배치도)", True, False, True), +) +PLAN_KIND_LABELS: dict[str, str] = {kind: label for kind, label, *_rest in PLAN_KINDS} + +# 구조물 종류별 표기 — pipe_points.json 의 facility 값 기준. +_FACILITY_LABELS: dict[str, str] = { + "ford_bridge": "세월교", + "box_culvert": "BOX암거", + "bridge": "교량", +} + + +def plan_area_mm() -> tuple[float, float]: + """지형 배경이 차지할 수 있는 크기(mm) — A1 작도영역에서 방위표 칸과 제목 띠를 뺀다. + + 라우터는 이 크기를 축척으로 되돌려 등고선·세류선 절취 범위를 잡는다(정의처 한 곳). + """ + width, height = usable_area() + return (width - (_COMPASS_MARGIN + _COMPASS_SIZE), height - _TITLE_BAND) + + +def _chunk_span_m() -> tuple[float, float]: + """한 장이 담을 수 있는 실거리(m) — 도곽 지형 영역을 축척으로 되돌린 크기.""" + area_w, area_h = plan_area_mm() + return (area_w * DRAWING_SCALE_PLAN / 1000.0, area_h * DRAWING_SCALE_PLAN / 1000.0) + + +def plan_chunks(stations: list[tuple[float, float, float]]) -> list[dict[str, Any]]: + """노선을 한 장에 들어가는 구간으로 나눈다. 각 항목: {number, start_m, end_m}. + + 입력은 종단 측점의 (누가거리 m, x, y)다 — **도면 목록과 도면 생성이 같은 자료**를 + 보아야 장수가 어긋나지 않는다(종단도 분할과 같은 방식). + + 축척 1/1,200 은 고정이므로 한 장에 안 들어가면 **노선을 따라 장을 나눈다** + (2026-09-04 — 횡단면도와 같은 원칙). 경계 측점 1개를 중복시켜 장 사이에서 노선이 + 끊겨 보이지 않게 한다(납품 도면 관례). + """ + ordered = sorted(stations, key=lambda item: item[0]) + if len(ordered) < 2: + span = (ordered[0][0] if ordered else 0.0, ordered[0][0] if ordered else 0.0) + return [{"number": 1, "start_m": span[0], "end_m": span[1]}] + span_w, span_h = _chunk_span_m() + + def fits(part: list[tuple[float, float, float]]) -> bool: + width = max(x for _c, x, _y in part) - min(x for _c, x, _y in part) + height = max(y for _c, _x, y in part) - min(y for _c, _x, y in part) + # 가로로 길든 세로로 길든 도곽에만 들어가면 된다 — 두 방향 다 본다. + return (width <= span_w and height <= span_h) or (width <= span_h and height <= span_w) + + chunks: list[dict[str, Any]] = [] + start = 0 + while start < len(ordered) - 1: + end = start + 1 + while end + 1 < len(ordered) and fits(ordered[start : end + 2]): + end += 1 + chunks.append( + { + "number": len(chunks) + 1, + "start_m": float(ordered[start][0]), + "end_m": float(ordered[end][0]), + } + ) + start = end # 경계 측점 1개 중복 + return chunks + + +def plan_drawing_id(kind: str, chunk: dict[str, Any], total: int) -> str: + """장이 하나면 접두어 그대로, 여럿이면 `plan_route_2` 처럼 번호를 붙인다.""" + return kind if total <= 1 else f"{kind}_{chunk['number']}" + + +def plan_drawing_label(kind: str, chunk: dict[str, Any], total: int) -> str: + label = PLAN_KIND_LABELS.get(kind, kind) + return label if total <= 1 else f"{label} {chunk['number']}장" + + +def _structure_label(structure: dict[str, Any]) -> str: + """구조물 표기 — 세월교·BOX암거는 이름, 배수관은 관경(mm).""" + facility = structure.get("facility") + if isinstance(facility, str) and facility in _FACILITY_LABELS: + return _FACILITY_LABELS[facility] + options = structure.get("options") + diameter = options.get("pipe_diameter_mm") if isinstance(options, dict) else None + return f"D{int(diameter)}" if isinstance(diameter, (int, float)) else "배수시설" + + +def _station_entities( + drawing_id: str, + stations: list[tuple[float, float, float]], + interval_m: float, + paper: Any, +) -> list[dict[str, Any]]: + """측점 눈금과 이름(No.n+00)을 노선 위에 직각으로 세운다. + + 입력은 **종단 측점**(누가거리 m, x, y)이다 — 노선 정점은 수백 개라 전부 찍으면 + 뭉개지고, 정점의 누가거리는 측점 간격의 배수가 아니라 걸러지지도 않는다 + (2026-09-04 실측: 눈금이 2개만 찍혔음). + """ + entities: list[dict[str, Any]] = [] + for index, (chainage, x, y) in enumerate(stations): + point = (x, y) + before = stations[max(index - 1, 0)] + after = stations[min(index + 1, len(stations) - 1)] + dx, dy = after[1] - before[1], after[2] - before[2] + length = math.hypot(dx, dy) or 1.0 + # 노선 진행 방향의 법선 — 눈금을 노선과 직각으로 세운다. + nx, ny = -dy / length, dx / length + cx, cy = paper(point) + tick = polyline_entity( + drawing_id, + [ + (cx - nx * _STATION_TICK_MM, cy - ny * _STATION_TICK_MM), + (cx + nx * _STATION_TICK_MM, cy + ny * _STATION_TICK_MM), + ], + STATION_LAYER_ID, + STATION_COLOR, + suffix=f":tick:{index}", + ) + if tick: + entities.append(tick) + entities.append( + _text_entity( + f"{drawing_id}:station:{index}", + station_plus_label(chainage, interval_m), + cx + nx * (_STATION_TICK_MM + 1.5), + cy + ny * (_STATION_TICK_MM + 1.5), + STATION_LAYER_ID, + _STATION_FONT_SIZE, + STATION_COLOR, + ) + ) + return entities + + +def _structure_entities( + drawing_id: str, + structures: list[dict[str, Any]], + paper: Any, + box: tuple[float, float, float, float], +) -> list[dict[str, Any]]: + """구조물 위치를 마름모 기호 + 이름으로 찍는다. 이 장의 범위 밖은 건너뛴다.""" + entities: list[dict[str, Any]] = [] + min_x, min_y, max_x, max_y = box + for index, structure in enumerate(structures): + x, y = structure.get("x"), structure.get("y") + if not isinstance(x, (int, float)) or not isinstance(y, (int, float)): + continue + if not (min_x <= x <= max_x and min_y <= y <= max_y): + continue + cx, cy = paper((float(x), float(y))) + size = _STRUCTURE_SIZE_MM + marker = polyline_entity( + drawing_id, + [ + (cx, cy + size), + (cx + size, cy), + (cx, cy - size), + (cx - size, cy), + (cx, cy + size), + ], + STRUCTURE_LAYER_ID, + STRUCTURE_COLOR, + suffix=f":structure:{index}", + ) + if marker: + entities.append(marker) + entities.append( + _text_entity( + f"{drawing_id}:structure:label:{index}", + _structure_label(structure), + cx + size + 1.0, + cy, + STRUCTURE_LAYER_ID, + _STRUCTURE_FONT_SIZE, + STRUCTURE_COLOR, + ) + ) + return entities + + +def build_plan_drawing( + kind: str, + drawing_id: str, + label: str, + route_xy: list[tuple[float, float]], + stations: list[tuple[float, float, float]], + contours: list[list[tuple[float, float]]], + streams: list[list[tuple[float, float]]], + structures: list[dict[str, Any]], + interval_m: float = 20.0, +) -> dict[str, Any]: + """계획평면도 한 장을 만든다. 좌표는 모두 사업지 CRS(m)로 받아 종이 mm로만 옮긴다. + + `kind` 가 세 장 중 무엇을 그릴지 정한다(`PLAN_KINDS`). 배경은 세 장이 같다. + """ + with_route, with_station, with_structure = next( + ((r, s, t) for name, _label, r, s, t in PLAN_KINDS if name == kind), + (True, False, False), + ) + # 도곽 배치는 세 장이 같아야 한다 — 노선을 그리지 않는 지형도도 노선을 범위에 넣는다. + everything = [ + *route_xy, + *(point for line in contours for point in line), + *(point for line in streams for point in line), + ] + if not everything: + raise FileNotFoundError( + "계획평면도에 그릴 좌표가 없습니다. B04 전처리에서 수치지형도 도엽을 먼저 받으세요." + ) + min_x = min(x for x, _y in everything) + min_y = min(y for _x, y in everything) + max_x = max(x for x, _y in everything) + max_y = max(y for _x, y in everything) + + def paper(point: tuple[float, float]) -> tuple[float, float]: + return ((point[0] - min_x) * MM, (point[1] - min_y) * MM) + + entities: list[dict[str, Any]] = [] + for index, line in enumerate(contours): + contour = polyline_entity( + drawing_id, + [paper(point) for point in line], + CONTOUR_LAYER_ID, + CONTOUR_COLOR, + suffix=f":contour:{index}", + ) + if contour: + entities.append(contour) + for index, line in enumerate(streams): + stream = polyline_entity( + drawing_id, + [paper(point) for point in line], + STREAM_LAYER_ID, + STREAM_COLOR, + suffix=f":stream:{index}", + ) + if stream: + entities.append(stream) + + map_bbox = entities_bbox(entities) + + # 노선·측점·구조물은 배경 위에 얹는다 — 아래에 깔리면 등고선에 묻힌다. + if with_route: + route = polyline_entity( + drawing_id, + [paper(point) for point in route_xy], + ROUTE_LAYER_ID, + ROUTE_COLOR, + width=_ROUTE_WIDTH, + ) + if route: + entities.append(route) + if with_station and stations: + entities.extend(_station_entities(drawing_id, stations, interval_m, paper)) + if with_structure: + entities.extend( + _structure_entities(drawing_id, structures, paper, (min_x, min_y, max_x, max_y)) + ) + + # 방위표는 지형 오른쪽 칸 맨 위에 둔다(유역도와 같은 자리). + if map_bbox: + entities.extend( + compass_entities( + drawing_id, + ( + map_bbox[2] + _COMPASS_MARGIN + _COMPASS_SIZE / 2.0, + map_bbox[3] - _COMPASS_SIZE / 2.0, + ), + _COMPASS_SIZE, + ) + ) + + bbox = entities_bbox(entities) + if bbox: + min_bx, _min_by, max_bx, max_by = bbox + entities.append( + _text_entity( + f"{drawing_id}:title", + label, + (min_bx + max_bx) / 2.0, + max_by + 12.0, + TITLE_LAYER_ID, + _TITLE_FONT_SIZE, + TABLE_LABEL_COLOR, + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:scale", + f"S = 1/{DRAWING_SCALE_PLAN:,}", + max_bx, + max_by + 5.0, + TITLE_LAYER_ID, + _FONT_SIZE, + TABLE_LABEL_COLOR, + align="right", + ) + ) + entities.extend( + frame_entities( + drawing_id, + entities_bbox(entities) or bbox, + fit=False, + fields={"도면명": label, **scale_fields(("", DRAWING_SCALE_PLAN))}, + ) + ) + + return { + "format": DRAWING_FORMAT, + "entities": entities, + "layers": [ + _layer(CONTOUR_LAYER_ID, "등고선", locked=True), + _layer(STREAM_LAYER_ID, "계류", locked=True), + _layer(ROUTE_LAYER_ID, "계획노선"), + _layer(STATION_LAYER_ID, "측점"), + _layer(STRUCTURE_LAYER_ID, "구조물"), + _layer(TITLE_LAYER_ID, "표제"), + _layer(FRAME_LAYER_ID, "도각", locked=True), + ], + } diff --git a/B07_DesignDetail/B07_DesignDetail_Router.py b/B07_DesignDetail/B07_DesignDetail_Router.py index a46bba9a..f4777153 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router.py +++ b/B07_DesignDetail/B07_DesignDetail_Router.py @@ -35,13 +35,16 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( ) from B07_DesignDetail.B07_DesignDetail_Router_Support import ( MASS_HAUL_ID, + PLAN_ID, WATERSHED_ID, _cross_sheet_plan, _drawing_list, _invalidate_drawing, _read_drawing, + _read_json, _recompute_confirmed_design, _store_confirmed_drawing, + plan_source, watershed_source, ) from B07_DesignDetail.B07_DesignDetail_Schema import ( @@ -300,6 +303,13 @@ async def get_design_drawing( if context is None: return JSONResponse(status_code=404, content={"status": "error", "message": reason}) source_design = await asyncio.to_thread(watershed_source, context) + elif PLAN_ID.fullmatch(drawing_id): + # 계획평면도는 유역도와 **같은 배경 창구**를 쓴다 — 자료 읽기·환산이 캐시된다. + context, reason = await load_drainage_context(project_id) + if context is None: + return JSONResponse(status_code=404, content={"status": "error", "message": reason}) + longitudinal = await asyncio.to_thread(_read_json, longitudinal_path) + source_design = await asyncio.to_thread(plan_source, context, longitudinal, drawing_id) kind, label, drawing, confirmed, quantity_table = await asyncio.to_thread( _read_drawing, project_root, longitudinal_path, drawing_id, source_design ) diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support.py b/B07_DesignDetail/B07_DesignDetail_Router_Support.py index 0381742e..ef362b2a 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support.py @@ -26,6 +26,13 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Long import ( longitudinal_chunks, ) from B07_DesignDetail.B07_DesignDetail_Engine_Cad_MassHaul import build_mass_haul_drawing +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import ( + PLAN_KINDS, + build_plan_drawing, + plan_chunks, + plan_drawing_id, + plan_drawing_label, +) from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import ( CROSS_SHEET_ID, build_cross_sheet, @@ -45,6 +52,9 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( CONTOUR_FILE as CONTOUR_FILE, ) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + PLAN_ID as PLAN_ID, +) from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( STREAM_FILE as STREAM_FILE, ) @@ -69,6 +79,12 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( clip_line_to_box as clip_line_to_box, ) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + plan_source as plan_source, +) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + plan_stations as plan_stations, +) from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( watershed_source as watershed_source, ) @@ -100,9 +116,6 @@ COVER_ID = "cover" # 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). # 화면 순서(DRAWING_GROUPS)와 같은 이름을 쓴다. BLANK_DRAWINGS: tuple[tuple[str, str], ...] = ( - ("blank_plan_terrain", "계획평면도(지형)"), - ("blank_plan_route", "계획평면도(노선배치도)"), - ("blank_plan_layout", "계획평면도(배치도)"), ("blank_plan_lidar", "계획평면도(라이다)"), ("blank_cross_standard", "표준 횡단면도"), ("blank_standard", "표준도"), @@ -151,6 +164,19 @@ def _drawing_list( confirmed=bool(manifest_drawings.get(sheet["id"], {}).get("confirmed")), ) ) + # 계획평면도 3종 — 축척 1/1,200 고정이라 노선이 길면 장이 나뉜다(장수는 노선이 정한다). + plan_sheets = plan_chunks(plan_stations(longitudinal)) + for kind, _label, *_rest in PLAN_KINDS: + for chunk in plan_sheets: + drawing_id = plan_drawing_id(kind, chunk, len(plan_sheets)) + drawings.append( + DesignDrawingItem( + id=drawing_id, + kind="plan", + label=plan_drawing_label(kind, chunk, len(plan_sheets)), + confirmed=bool(manifest_drawings.get(drawing_id, {}).get("confirmed")), + ) + ) # 노선 전장 1장짜리 도면 — 자료가 없으면 여는 시점에 404로 알린다(목록에는 항상 둔다). for drawing_id, kind, label in ( (COVER_ID, "cover", "표지"), @@ -381,6 +407,8 @@ def _read_drawing( if saved.get("format") == DRAWING_FORMAT: if drawing_id in (COVER_ID, MASS_HAUL_ID, WATERSHED_ID): kind = drawing_id # id와 kind가 같은 단장 도면 + elif PLAN_ID.fullmatch(drawing_id): + kind = "plan" else: kind = "longitudinal" if _LONG_ID.fullmatch(drawing_id) else "cross" label = str(manifest_entry.get("label") or drawing_id) @@ -409,6 +437,31 @@ def _read_drawing( None, ) + if PLAN_ID.fullmatch(drawing_id): + # stored_design = plan_source()가 모아 준 노선·측점·배경·구조물 좌표(사업지 CRS). + if not isinstance(stored_design, dict): + raise FileNotFoundError("계획평면도 자료가 없습니다.") + longitudinal = _read_json(longitudinal_path) + interval = infer_station_interval(longitudinal.get("stations") or []) + label = str(stored_design.get("label") or drawing_id) + return ( + "plan", + label, + build_plan_drawing( + str(stored_design.get("kind") or "plan_terrain"), + drawing_id, + label, + stored_design.get("route_xy") or [], + stored_design.get("stations") or [], + stored_design.get("contours") or [], + stored_design.get("streams") or [], + stored_design.get("structures") or [], + interval, + ), + False, + None, + ) + if drawing_id == WATERSHED_ID: # stored_design = watershed_source()가 모아 준 노선·유역·배경 좌표(사업지 CRS). if not isinstance(stored_design, dict): diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py b/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py index f229cf17..73c52af0 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py @@ -7,6 +7,7 @@ import json import logging import math import re +from functools import lru_cache from pathlib import Path from typing import Any @@ -14,33 +15,19 @@ from pyproj import Transformer from B04_PreProcess.B04_PreProcess_Router_Watershed import CONTOUR_FILE, STREAM_FILE from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Basin import map_area_mm +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import ( + plan_area_mm, + plan_chunks, + plan_drawing_label, +) from common_util.common_util_drainage_pipes import detail_basins_path -from config.config_system import DRAWING_SCALE_BASIN +from config.config_system import DRAWING_SCALE_BASIN, DRAWING_SCALE_PLAN logger = logging.getLogger(__name__) -_STAGE_DIR = "B07_DesignDetail" - -_CROSS_ID = re.compile(r"^cross_(\d+)m$") -_LONG_ID = re.compile(r"^longitudinal(?:_(\d+))?$") -# 노선 전장에 한 장씩만 나오는 도면 — 라우터가 원본 자료를 따로 실어 넘긴다. -MASS_HAUL_ID = "mass_haul" -WATERSHED_ID = "watershed" -COVER_ID = "cover" - -# 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). -# 화면 순서(DRAWING_GROUPS)와 같은 이름을 쓴다. -BLANK_DRAWINGS: tuple[tuple[str, str], ...] = ( - ("blank_plan_terrain", "계획평면도(지형)"), - ("blank_plan_route", "계획평면도(노선배치도)"), - ("blank_plan_layout", "계획평면도(배치도)"), - ("blank_plan_lidar", "계획평면도(라이다)"), - ("blank_cross_standard", "표준 횡단면도"), - ("blank_standard", "표준도"), - ("blank_landuse", "용지도"), -) -BLANK_LABELS: dict[str, str] = dict(BLANK_DRAWINGS) +# 도면 id 상수·빈 도면 목록은 `B07_DesignDetail_Router_Support` 한 곳이 정본이다. +# 이 모듈에 있던 같은 이름의 사본은 아무도 읽지 않으면서 값만 어긋나 지웠다(2026-09-04). def _geojson_payload(path: Path) -> dict[str, Any]: @@ -185,26 +172,186 @@ def _too_far_from_route( return min(math.hypot(cx - x, cy - y) for x, y in route_xy) > _BASIN_MAX_DISTANCE_M +@lru_cache(maxsize=8) +def _metric_lines_cached( + path_str: str, mtime_ns: int, crs: str +) -> tuple[tuple[tuple[float, float], ...], ...]: + """도엽 GeoJSON 한 벌을 사업지 좌표계(m) 선 목록으로 돌려 **캐시**한다. + + 같은 배경을 유역도와 계획평면도가 나눠 쓴다 — 도면마다 다시 읽고 다시 투영하면 + 한 장 여는 데 수 초가 걸린다(등고선 수만 점). 파일이 바뀌면 mtime 이 달라져 + 캐시가 저절로 갈린다(`_read_template` 와 같은 방식). + """ + to_metric = Transformer.from_crs("EPSG:4326", crs, always_xy=True) + lines: list[tuple[tuple[float, float], ...]] = [] + for feature in _geojson_features(Path(path_str)): + for part in _geometry_lines(feature.get("geometry")): + converted = tuple( + (float(x), float(y)) + for x, y in (to_metric.transform(point[0], point[1]) for point in part) + ) + if len(converted) >= 2: + lines.append(converted) + return tuple(lines) + + +def _metric_lines(path: Path, crs: str) -> list[list[tuple[float, float]]]: + """캐시된 배경 선을 쓰기 좋은 형태로 낸다. 파일이 없으면 빈 목록.""" + if not path.is_file(): + return [] + cached = _metric_lines_cached(str(path), path.stat().st_mtime_ns, crs) + return [list(line) for line in cached] + + +def map_background( + project_root: Path, + crs: str, + scale: int, + area_mm: tuple[float, float], + extent_points: list[tuple[float, float]], +) -> dict[str, list[list[tuple[float, float]]]]: + """도엽 등고선·세류선을 사업지 좌표계로 읽어 **그 도면의 도곽 크기로 절취**한다. + + 유역도·계획평면도·용지도가 같은 창구를 쓴다 — 자료 읽기·좌표 환산은 한 번뿐이고 + (`_metric_lines` 캐시), 도면마다 다른 것은 축척과 도곽 크기뿐이다. + + `extent_points` 는 그 도면의 주제(노선·유역 등) 좌표다. 도곽보다 크면 그쪽을 + 우선한다 — 배경만 잘리고 주제는 다 보인다. + """ + area_w_mm, area_h_mm = area_mm + half_w_m = area_w_mm / 2.0 * scale / 1000.0 + half_h_m = area_h_mm / 2.0 * scale / 1000.0 + if extent_points: + center_x = (min(x for x, _y in extent_points) + max(x for x, _y in extent_points)) / 2.0 + center_y = (min(y for _x, y in extent_points) + max(y for _x, y in extent_points)) / 2.0 + box = ( + min(center_x - half_w_m, min(x for x, _y in extent_points)), + min(center_y - half_h_m, min(y for _x, y in extent_points)), + max(center_x + half_w_m, max(x for x, _y in extent_points)), + max(center_y + half_h_m, max(y for _x, y in extent_points)), + ) + else: + box = (-math.inf, -math.inf, math.inf, math.inf) + + sheet_dir = Path(project_root) / "B04_PreProcess" / "processed" + background: dict[str, list[list[tuple[float, float]]]] = {} + for key, filename in (("contours", CONTOUR_FILE), ("streams", STREAM_FILE)): + lines: list[list[tuple[float, float]]] = [] + for line in _metric_lines(sheet_dir / filename, crs): + lines.extend(clip_line_to_box(line, box)) + background[key] = lines + return background + + +PLAN_ID = re.compile(r"^(plan_terrain|plan_route|plan_layout)(?:_(\d+))?$") + + +def plan_stations(longitudinal: dict[str, Any]) -> list[tuple[float, float, float]]: + """종단 측점의 (누가거리 m, x, y) — 계획평면도 장 나눔의 유일한 기준 자료.""" + stations: list[tuple[float, float, float]] = [] + for station in longitudinal.get("stations") or []: + if not isinstance(station, dict): + continue + chainage = station.get("chainage_m") + x, y = station.get("center_x"), station.get("center_y") + if all(isinstance(value, (int, float)) for value in (chainage, x, y)): + stations.append((float(chainage), float(x), float(y))) + return stations + + +def plan_chunk_for( + longitudinal: dict[str, Any], drawing_id: str +) -> tuple[str, dict[str, Any], int]: + """도면 id 에서 (주제, 그 장의 구간, 전체 장수)를 찾는다.""" + match = PLAN_ID.fullmatch(drawing_id) + if not match: + raise ValueError("올바르지 않은 계획평면도 ID입니다.") + kind = match.group(1) + chunks = plan_chunks(plan_stations(longitudinal)) + number = int(match.group(2)) if match.group(2) else 1 + chunk = next((item for item in chunks if item["number"] == number), None) + if chunk is None: + raise FileNotFoundError("요청한 계획평면도 장을 찾을 수 없습니다.") + return kind, chunk, len(chunks) + + +def plan_source(context: Any, longitudinal: dict[str, Any], drawing_id: str) -> dict[str, Any]: + """계획평면도 한 장의 입력(노선·측점·등고선·세류선·구조물)을 사업지 CRS(m)로 모은다. + + 배경은 유역도와 **같은 창구**(`map_background`)를 쓴다 — 도엽 GeoJSON 읽기·좌표 + 환산이 캐시돼 두 도면이 자료를 나눠 쓴다(2026-09-04 사용자 지시). + + 장이 여럿이면 그 장의 구간(누가거리)에 드는 노선·구조물만 싣고, 배경도 그 범위로 + 절취한다 — 축척 1/1,200 은 고정이므로 안 들어가면 장을 나눈다. + """ + kind, chunk, total = plan_chunk_for(longitudinal, drawing_id) + start_m, end_m = float(chunk["start_m"]), float(chunk["end_m"]) + + route_xy: list[tuple[float, float]] = [] + for vertex in context.vertices: + chainage = float(getattr(vertex, "chainage_m", 0.0) or 0.0) + if total > 1 and not (start_m <= chainage <= end_m): + continue + route_xy.append((vertex.x, vertex.y)) + # 측점 눈금은 **종단 측점**을 쓴다 — 노선 정점은 조밀하고 누가거리가 간격의 배수가 아니다. + stations = [ + station + for station in plan_stations(longitudinal) + if total <= 1 or start_m <= station[0] <= end_m + ] + + structures = [ + structure + for structure in _plan_structures(context) + if total <= 1 or start_m <= float(structure.get("chainage_m") or -1.0) <= end_m + ] + background = map_background( + Path(context.project_root), + context.crs, + DRAWING_SCALE_PLAN, + plan_area_mm(), + route_xy, + ) + return { + "kind": kind, + "label": plan_drawing_label(kind, chunk, total), + "route_xy": route_xy, + "stations": stations, + "contours": background["contours"], + "streams": background["streams"], + "structures": structures, + } + + +def _plan_structures(context: Any) -> list[dict[str, Any]]: + """배치도에 찍을 구조물 — B04 배수시설 정본(`pipe_points.json`)을 그대로 읽는다. + + 좌표는 이미 사업지 CRS(m)다(B04가 그렇게 쓴다). 없으면 빈 목록 — 배치도는 배경과 + 노선만으로도 열린다. + """ + path = Path(context.project_root) / "B04_PreProcess" / "drainage" / "edits" / "pipe_points.json" + points = _geojson_payload(path).get("points") + if not isinstance(points, list): + return [] + return [point for point in points if isinstance(point, dict)] + + def watershed_source(context: Any) -> dict[str, Any]: """유역도 입력(노선·세부유역·등고선·세류선)을 사업지 CRS(m)로 모은다. 저장본은 전부 WGS84라 여기서 미터 좌표로 되돌린다(B04가 저장할 때와 반대 방향). 되돌리는 좌표계가 둘이다. **배경(도엽 등고선·세류선)은 사업지 좌표계**로 돌린다 — - 노선(`context.vertices`)이 그 좌표계에 있으므로 같은 자리에 겹쳐야 한다. **세부유역은 - 그 파일을 쓸 때 쓴 좌표계**로 돌린다 — 좌표계 기록 이전 저장본은 노선 CSV의 EPSG - 라벨로 쓰였고, 그 라벨로 되돌려야 원래 미터 좌표가 나온다(2026-09-01). + 노선(`context.vertices`)이 그 좌표계에 있으므로 같은 자리에 겹쳐야 한다(그 환산은 + `map_background()` 안에 있다). **세부유역은 그 파일을 쓸 때 쓴 좌표계**로 돌린다 — + 좌표계 기록 이전 저장본은 노선 CSV의 EPSG 라벨로 쓰였고, 그 라벨로 되돌려야 원래 + 미터 좌표가 나온다(2026-09-01). """ basins_payload = _geojson_payload(detail_basins_path(context.stored_path)) - to_metric = Transformer.from_crs("EPSG:4326", context.crs, always_xy=True) to_basin_metric = Transformer.from_crs( "EPSG:4326", _basins_crs(context, basins_payload), always_xy=True ) - def metric(point: tuple[float, float]) -> tuple[float, float]: - x, y = to_metric.transform(point[0], point[1]) - return (float(x), float(y)) - def basin_metric(point: tuple[float, float]) -> tuple[float, float]: x, y = to_basin_metric.transform(point[0], point[1]) return (float(x), float(y)) @@ -237,39 +384,14 @@ def watershed_source(context: Any) -> dict[str, Any]: # 배경(등고선·세류선)은 **여러 도엽을 합쳐 받은 뒤 도곽 크기로 절취**한다 # (2026-08-30 사용자 지시 — 노선이 도엽 경계에 걸릴 수 있어 주변 도엽까지 받아 둔다). - # 도엽 등고선 한 줄은 도엽 끝까지 이어지므로 "걸치면 통째로"는 도면이 A1을 넘긴다 - # (실측 430x871 mm). 절취 범위 = 도곽 안 지형 영역(정보표·제목 제외)을 축척으로 되돌린 크기. - usable_w_mm, usable_h_mm = map_area_mm() - half_w_m = usable_w_mm / 2.0 * DRAWING_SCALE_BASIN / 1000.0 - half_h_m = usable_h_mm / 2.0 * DRAWING_SCALE_BASIN / 1000.0 - extent = [*route_xy, *(point for basin in basins for point in basin["ring"])] - if extent: - center_x = (min(x for x, _y in extent) + max(x for x, _y in extent)) / 2.0 - center_y = (min(y for _x, y in extent) + max(y for _x, y in extent)) / 2.0 - # 노선·유역이 도곽보다 크면 그쪽을 우선한다 — 배경만 잘리고 주제는 다 보인다. - min_x = min(center_x - half_w_m, min(x for x, _y in extent)) - max_x = max(center_x + half_w_m, max(x for x, _y in extent)) - min_y = min(center_y - half_h_m, min(y for _x, y in extent)) - max_y = max(center_y + half_h_m, max(y for _x, y in extent)) - else: - min_x = min_y = -math.inf - max_x = max_y = math.inf - - box = (min_x, min_y, max_x, max_y) - - def clip(line: list[tuple[float, float]]) -> list[list[tuple[float, float]]]: - return clip_line_to_box(line, box) - - sheet_dir = Path(context.project_root) / "B04_PreProcess" / "processed" - background: dict[str, list[list[tuple[float, float]]]] = {} - for key, filename in (("contours", CONTOUR_FILE), ("streams", STREAM_FILE)): - lines: list[list[tuple[float, float]]] = [] - for feature in _geojson_features(sheet_dir / filename): - for part in _geometry_lines(feature.get("geometry")): - converted = [metric(point) for point in part] - if len(converted) >= 2: - lines.extend(clip(converted)) - background[key] = lines + # 읽기·환산·절취는 `map_background()` 한 곳에 있고 계획평면도·용지도도 같은 것을 쓴다. + background = map_background( + Path(context.project_root), + context.crs, + DRAWING_SCALE_BASIN, + map_area_mm(), + [*route_xy, *(point for basin in basins for point in basin["ring"])], + ) return { "route_xy": route_xy, diff --git a/B07_DesignDetail/B07_DesignDetail_Schema.py b/B07_DesignDetail/B07_DesignDetail_Schema.py index f88fe71f..1fc0ce6d 100644 --- a/B07_DesignDetail/B07_DesignDetail_Schema.py +++ b/B07_DesignDetail/B07_DesignDetail_Schema.py @@ -10,7 +10,7 @@ class DesignDrawingItem(BaseModel): id: str # blank: 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). - kind: Literal["cover", "longitudinal", "cross", "mass_haul", "watershed", "blank"] + kind: Literal["cover", "longitudinal", "cross", "mass_haul", "watershed", "plan", "blank"] label: str chainage_m: float | None = None confirmed: bool = False @@ -33,7 +33,7 @@ class DesignDrawingResponse(BaseModel): route_id: int id: str # blank: 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). - kind: Literal["cover", "longitudinal", "cross", "mass_haul", "watershed", "blank"] + kind: Literal["cover", "longitudinal", "cross", "mass_haul", "watershed", "plan", "blank"] label: str drawing: dict[str, Any] confirmed: bool = False diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts index bf045511..9e8ef8ad 100644 --- a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts +++ b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts @@ -8,7 +8,10 @@ import { attachCollapsible } from "@ui/ui_template_collapsible"; import { currentLanguageIndex, ui_locales } from "@ui/ui_template_locale"; -import type { CrossDesignInfo, DesignDrawingItem } from "./B07_DesignDetail_Api_Fetch"; +import type { + CrossDesignInfo, + DesignDrawingItem, +} from "./B07_DesignDetail_Api_Fetch"; function L(key: keyof typeof ui_locales): string { return ui_locales[key][currentLanguageIndex]; @@ -24,11 +27,13 @@ export const DRAWING_GROUPS: readonly { label: string; kind?: DesignDrawingItem["kind"]; blankId?: string; + /** 축척 고정으로 장이 나뉘는 도면 — `plan_route`, `plan_route_2` … 를 한 묶음으로 본다. */ + idPrefix?: string; }[] = [ { label: "표지", kind: "cover" }, - { label: "계획평면도(지형)", blankId: "blank_plan_terrain" }, - { label: "계획평면도(노선배치도)", blankId: "blank_plan_route" }, - { label: "계획평면도(배치도)", blankId: "blank_plan_layout" }, + { label: "계획평면도(지형)", idPrefix: "plan_terrain" }, + { label: "계획평면도(노선배치도)", idPrefix: "plan_route" }, + { label: "계획평면도(배치도)", idPrefix: "plan_layout" }, { label: "계획평면도(라이다)", blankId: "blank_plan_lidar" }, { label: "종단면도", kind: "longitudinal" }, { label: "표준 횡단면도", blankId: "blank_cross_standard" }, @@ -64,7 +69,10 @@ export function buildDrawingSidePanel( return panel; } - const drawingButton = (drawing: DesignDrawingItem, label: string): HTMLButtonElement => { + const drawingButton = ( + drawing: DesignDrawingItem, + label: string, + ): HTMLButtonElement => { const button = document.createElement("button"); button.type = "button"; button.className = "b07-drawing-button"; @@ -81,7 +89,13 @@ export function buildDrawingSidePanel( for (const group of DRAWING_GROUPS) { const items = group.kind ? drawings.filter((item) => item.kind === group.kind) - : drawings.filter((item) => item.id === group.blankId); + : group.idPrefix + ? drawings.filter( + (item) => + item.id === group.idPrefix || + item.id.startsWith(`${group.idPrefix}_`), + ) + : drawings.filter((item) => item.id === group.blankId); // 한 장짜리(와 아직 내용이 없는 도면)는 컨테이너 없이 버튼 하나로 둔다. if (items.length <= 1) { const [drawing] = items; @@ -103,7 +117,8 @@ export function buildDrawingSidePanel( const button = drawingButton(drawing, group.label); // 도각만 있는 도면은 그렇다고 알린다 — 빈 화면을 보고 오류로 오해하지 않게. button.dataset.pending = String(drawing.kind === "blank"); - if (drawing.kind === "blank") button.title = "준비 중 — 도각만 표시합니다"; + if (drawing.kind === "blank") + button.title = "준비 중 — 도각만 표시합니다"; panel.append(button); continue; } @@ -125,7 +140,10 @@ export function buildDrawingSidePanel( return panel; } -const GROUND_TYPE_LABEL: Record = { +const GROUND_TYPE_LABEL: Record< + CrossDesignInfo["ground_type"], + keyof typeof ui_locales +> = { soil: "B06_Design_Ground_Soil", ripping_rock: "B06_Design_Ground_Ripping", blasting_rock: "B06_Design_Ground_Blasting", @@ -147,7 +165,8 @@ export function isCrossSheet(drawing: DesignDrawingItem): boolean { /** 측구 규격 표시 문자열 (design 신구조: 형식별 ditch spec, F-2 호환). */ function ditchLabel(design: CrossDesignInfo): string { const ditch = design.ditch; - if (!ditch || ditch.type === "none" || design.ditch_enabled === false) return "없음"; + if (!ditch || ditch.type === "none" || design.ditch_enabled === false) + return "없음"; if (ditch.type === "l_type") return `L형 ${ditch.width_m.toFixed(2)}×${ditch.depth_m.toFixed(2)}m`; return `${ditch.top_width_m.toFixed(2)}×${ditch.depth_m.toFixed(2)}m`; @@ -183,19 +202,23 @@ export function buildDesignInfoPanel( const heading = document.createElement("div"); heading.className = "b07-info__heading"; const stationName = document.createElement("strong"); - const scopeLabel = scope === "sheet" ? L("B07_Info_Sheet") : L("B07_Info_Station"); + const scopeLabel = + scope === "sheet" ? L("B07_Info_Sheet") : L("B07_Info_Station"); stationName.textContent = `${scopeLabel} ${title}`; const confirmed = design?.status === "confirmed"; const badge = document.createElement("span"); badge.className = `b07-info__badge${confirmed ? " b07-info__badge--confirmed" : ""}`; - badge.textContent = confirmed ? L("B07_Info_Confirmed") : L("B07_Info_Provisional"); + badge.textContent = confirmed + ? L("B07_Info_Confirmed") + : L("B07_Info_Provisional"); heading.append(stationName, badge); panel.append(heading); if (!design) { const empty = document.createElement("p"); empty.className = "b07-info__empty"; - empty.textContent = scope === "sheet" ? L("B07_Info_SheetHint") : L("B07_Info_NoDesign"); + empty.textContent = + scope === "sheet" ? L("B07_Info_SheetHint") : L("B07_Info_NoDesign"); panel.append(empty); return panel; } @@ -210,7 +233,9 @@ export function buildDesignInfoPanel( infoRow(L("B07_Info_CutSide"), cutSideLabel(design.section_mode)), infoRow( L("B07_Info_DitchSide"), - design.ditch_side === "left" ? L("B06_Design_Ditch_Left") : L("B06_Design_Ditch_Right"), + design.ditch_side === "left" + ? L("B06_Design_Ditch_Left") + : L("B06_Design_Ditch_Right"), ), ); @@ -220,7 +245,10 @@ export function buildDesignInfoPanel( planTitle.textContent = L("B07_Info_Plan_Title"); plan.append( planTitle, - infoRow(L("B07_Info_DesignElevation"), `${design.design_elevation_m.toFixed(2)}m`), + infoRow( + L("B07_Info_DesignElevation"), + `${design.design_elevation_m.toFixed(2)}m`, + ), infoRow(L("B07_Info_CutSlope"), `1:${design.cut_slope_ratio}`), infoRow(L("B07_Info_FillSlope"), `1:${design.fill_slope_ratio}`), infoRow(L("B07_Info_RoadWidth"), `${design.roadbed_width_m.toFixed(2)}m`), diff --git a/config/config_system.py b/config/config_system.py index 50a826ca..de4780e4 100644 --- a/config/config_system.py +++ b/config/config_system.py @@ -175,6 +175,9 @@ DRAWING_SCALE_MASSHAUL_H_CANDIDATES = ( DRAWING_MASSHAUL_USABLE_WIDTH_MM = 700.0 DRAWING_SCALE_MASSHAUL_V_M3_MM = 50.0 # 유토곡선 세로 — 종이 1 mm 당 토량(㎥) DRAWING_SCALE_BASIN = 6000 # 유역도 평면 축척 분모 (실거리 1 m = 1/6 mm) +# 계획평면도·용지도 평면 축척 분모 — 지식DB 「설계제원_총괄」 측량·도면 기준 1/1,200. +# 횡단면도와 같은 원칙: 축척은 줄이지 않고, 한 장에 안 들어가면 **장을 나눈다**. +DRAWING_SCALE_PLAN = 1200 # 시스템 리소스 로그 (루트 log 폴더에 단일 파일, 1개월 보관) LOG_BASE_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "log") From d662b0725db4648d60766f7aabfa7b42f9927d71 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Fri, 4 Sep 2026 18:51:23 +0900 Subject: [PATCH 3/5] =?UTF-8?q?feat(B07):=20=EC=9A=A9=EC=A7=80=EB=8F=84=20?= =?UTF-8?q?=E2=80=94=20=EB=93=B1=EA=B3=A0=EC=84=A0=20=EB=B0=B0=EA=B2=BD=20?= =?UTF-8?q?+=20=EC=97=B0=EC=86=8D=EC=A7=80=EC=A0=81=EB=8F=84=C2=B7?= =?UTF-8?q?=ED=96=89=EC=A0=95=EA=B5=AC=EC=97=AD=C2=B7=EB=B2=94=EB=A1=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 빈 도각이던 용지도를 실제 도면으로 만듦. 축척·도곽·장 나눔은 계획평면도와 같고(1/1,200) 배경도 같은 창구(map_background)를 씀. - 연속지적도 필지 경계 + 지번(jibun) 표기. 작은 필지는 솎고(종이 6x3 mm 미만), 도곽을 통째로 감싸는 임야 대필지는 도곽 중심에 지번만 적음 — 그러지 않으면 노선이 대필지 안에 들어앉을 때 지번이 통째로 사라짐. - 시군구·읍면동/리 경계를 파선·일점쇄선으로 구분. 지적·행정 경계는 도곽 범위로 절취 — 자르지 않으면 산지 대필지 하나가 도면을 10 km 로 벌림(실측 8,368 mm). - 도면용 색을 화면용과 따로 정함(등고선을 가장 옅게, 행정 경계를 굵고 진하게). - 범례를 유역도 정보표 자리(오른쪽 칸 방위표 아래)에 넣음. - _geometry_lines 가 MultiPolygon 을 편다 — 지적·행정구역이 그 형식임. 검증(용화_LAS): 콘텐츠 734.3x489.2 mm ≤ A1 작도영역, 지번 「산77-15임」이 지적 속성과 일치, 도면 목록에 landuse 가 실림. 이 노선은 임야 대필지 한 곳에 통째로 들어가 경계선이 도곽 안에 없음 — 자료대로의 정상 결과. Co-Authored-By: Claude Opus 5 (1M context) --- .../B07_DesignDetail_Api_Fetch.ts | 2 + .../B07_DesignDetail_Engine_Cad_Landuse.py | 339 ++++++++++++++++++ B07_DesignDetail/B07_DesignDetail_Router.py | 11 + .../B07_DesignDetail_Router_Support.py | 47 ++- .../B07_DesignDetail_Router_Support_Basin.py | 136 ++++++- B07_DesignDetail/B07_DesignDetail_Schema.py | 22 +- .../B07_DesignDetail_UI_Panels.ts | 2 +- 7 files changed, 554 insertions(+), 5 deletions(-) create mode 100644 B07_DesignDetail/B07_DesignDetail_Engine_Cad_Landuse.py diff --git a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts index 2a29b156..38a360c9 100644 --- a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts +++ b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts @@ -12,6 +12,7 @@ export interface DesignDrawingItem { | "mass_haul" | "watershed" | "plan" + | "landuse" | "blank"; label: string; chainage_m: number | null; @@ -97,6 +98,7 @@ export interface DesignDrawingResponse { | "mass_haul" | "watershed" | "plan" + | "landuse" | "blank"; label: string; drawing: CadDrawing; diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Landuse.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Landuse.py new file mode 100644 index 00000000..1949a66f --- /dev/null +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Landuse.py @@ -0,0 +1,339 @@ +"""B07 용지도 CAD 조립 — 수치등고선 배경 위에 연속지적도·행정구역을 얹는다. + +사용자 지시(2026-09-04) — 「용지도는 계획평면도와 같이 수치등고선을 배경으로 하고 +연속지적도·시군구·읍면동을 얹을 것. 색상은 변경하고, 배수유역도의 표 자리에 범례를 +넣을 것. 연속지적도에 지번 정보가 있는지 확인하고, 없으면 일단 그림만」. + +지번은 있다(2026-09-04 실측: 저장된 연속지적도 GeoJSON 필지마다 `jibun`·`jimok`· +`parea`·`owner_nm` + 시도·시군구·읍면동·리 이름). 이번 판은 **지번만** 적는다 — +지목·면적·소유 구분은 용지 조서(표)에서 쓸 값이라 도면에는 넣지 않는다. + +축척·도곽·장 나눔은 계획평면도와 **같다**(1/1,200 고정). 배경도 같은 창구를 쓴다. + +좌표 규약: 종이 mm = (사업지 좌표 m - 그 장 콘텐츠 최소점) x MM (1/1,200 -> 1 m = 5/6 mm). +""" + +from typing import Any + +from B07_DesignDetail.B07_DesignDetail_Engine_Cad import ( + DRAWING_FORMAT, + FRAME_LAYER_ID, + TABLE_LABEL_COLOR, + _layer, + _text_entity, + polyline_entity, +) +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import ( + _COMPASS_MARGIN, + _COMPASS_SIZE, + _FONT_SIZE, + _TITLE_FONT_SIZE, + MM, + plan_area_mm, +) +from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( + compass_entities, + entities_bbox, + frame_entities, + scale_fields, +) +from config.config_system import DRAWING_SCALE_PLAN + +LANDUSE_KIND = "landuse" +LANDUSE_LABEL = "용지도" + +CONTOUR_LAYER_ID = "b07-landuse-contour" +PARCEL_LAYER_ID = "b07-landuse-parcel" +JIBUN_LAYER_ID = "b07-landuse-jibun" +EMD_LAYER_ID = "b07-landuse-emd" +SGG_LAYER_ID = "b07-landuse-sgg" +ROUTE_LAYER_ID = "b07-landuse-route" +LEGEND_LAYER_ID = "b07-landuse-legend" +TITLE_LAYER_ID = "b07-landuse-title" + +# 도면용 색 — 화면용(유역도)보다 **가라앉힌** 색을 쓴다. 지적 경계가 주제이므로 배경 +# 등고선은 가장 옅게, 행정 경계는 굵고 진하게 가른다(2026-09-04 사용자 「색상은 변경」). +CONTOUR_COLOR = "#9aa3ad" +PARCEL_COLOR = "#8c6b4f" +JIBUN_COLOR = "#5c4632" +EMD_COLOR = "#2f7d4f" +SGG_COLOR = "#a63d3d" +ROUTE_COLOR = "#ffe066" +LEGEND_COLOR = TABLE_LABEL_COLOR + +_ROUTE_WIDTH = 3 +_SGG_WIDTH = 3 +_EMD_WIDTH = 2 +_JIBUN_FONT_SIZE = 1.8 +_LEGEND_FONT_SIZE = 2.4 +# 지번을 적을 최소 필지 크기(종이 mm) — 이보다 작으면 글자가 겹쳐 읽히지 않는다. +_JIBUN_MIN_W_MM = 6.0 +_JIBUN_MIN_H_MM = 3.0 + +_LEGEND_ROW_H = 6.0 +_LEGEND_SAMPLE_W = 12.0 +_LEGEND_GAP = 3.0 +_LEGEND_TOP_GAP = 8.0 + +# 범례 항목 (표기 이름, 색, 선굵기, 파선). +_LEGEND_ROWS: tuple[tuple[str, str, int, list[int] | None], ...] = ( + ("계획노선", ROUTE_COLOR, _ROUTE_WIDTH, None), + ("필지 경계", PARCEL_COLOR, 1, None), + ("읍면동·리 경계", EMD_COLOR, _EMD_WIDTH, [8, 4]), + ("시군구 경계", SGG_COLOR, _SGG_WIDTH, [14, 5, 3, 5]), + ("등고선", CONTOUR_COLOR, 1, None), +) + + +def _ring_center(ring: list[tuple[float, float]]) -> tuple[float, float]: + """고리의 bbox 중심 — 오목한 필지에서도 글자가 도면 밖으로 튀지 않는다.""" + xs = [x for x, _y in ring] + ys = [y for _x, y in ring] + return ((min(xs) + max(xs)) / 2.0, (min(ys) + max(ys)) / 2.0) + + +def _legend_entities(drawing_id: str, origin: tuple[float, float]) -> list[dict[str, Any]]: + """범례 — 유역도에서 유역 정보표가 있던 자리(오른쪽 칸)에 놓는다.""" + entities: list[dict[str, Any]] = [] + x, y = origin + entities.append( + _text_entity( + f"{drawing_id}:legend:title", + "범 례", + x + _LEGEND_SAMPLE_W / 2.0 + 6.0, + y, + LEGEND_LAYER_ID, + _LEGEND_FONT_SIZE + 0.6, + LEGEND_COLOR, + ) + ) + for index, (label, color, width, dash) in enumerate(_LEGEND_ROWS): + row_y = y - _LEGEND_TOP_GAP - index * _LEGEND_ROW_H + sample = polyline_entity( + drawing_id, + [(x, row_y), (x + _LEGEND_SAMPLE_W, row_y)], + LEGEND_LAYER_ID, + color, + suffix=f":legend:{index}", + dash=dash, + width=width, + ) + if sample: + entities.append(sample) + entities.append( + _text_entity( + f"{drawing_id}:legend:label:{index}", + label, + x + _LEGEND_SAMPLE_W + _LEGEND_GAP, + row_y, + LEGEND_LAYER_ID, + _LEGEND_FONT_SIZE, + LEGEND_COLOR, + align="left", + ) + ) + return entities + + +def _boundary_entities( + drawing_id: str, + rings: list[list[tuple[float, float]]], + layer_id: str, + color: str, + width: int, + dash: list[int] | None, + paper: Any, + tag: str, +) -> list[dict[str, Any]]: + entities: list[dict[str, Any]] = [] + for index, ring in enumerate(rings): + line = polyline_entity( + drawing_id, + [paper(point) for point in ring], + layer_id, + color, + suffix=f":{tag}:{index}", + dash=dash, + width=width, + ) + if line: + entities.append(line) + return entities + + +def build_landuse_drawing( + drawing_id: str, + label: str, + route_xy: list[tuple[float, float]], + contours: list[list[tuple[float, float]]], + parcels: list[dict[str, Any]], + emd_rings: list[list[tuple[float, float]]], + sgg_rings: list[list[tuple[float, float]]], +) -> dict[str, Any]: + """용지도 한 장을 만든다. 좌표는 모두 사업지 CRS(m)로 받아 종이 mm로만 옮긴다. + + `parcels`는 {"ring": [(x, y)...], "props": {지적 속성}} 목록이다. 도곽에 걸친 필지는 + 라우터가 잘라 넘기므로 고리가 아니라 **열린 선**일 수 있다. + """ + everything = [ + *route_xy, + *(point for line in contours for point in line), + *(point for parcel in parcels for point in parcel.get("ring") or []), + ] + if not everything: + raise FileNotFoundError( + "용지도에 그릴 좌표가 없습니다. B04 전처리에서 연속지적도·수치지형도를 먼저 받으세요." + ) + min_x = min(x for x, _y in everything) + min_y = min(y for _x, y in everything) + + def paper(point: tuple[float, float]) -> tuple[float, float]: + return ((point[0] - min_x) * MM, (point[1] - min_y) * MM) + + entities: list[dict[str, Any]] = [] + # 배경 등고선이 가장 아래 — 지적 경계가 주제라 옅게 깐다. + entities.extend( + _boundary_entities( + drawing_id, contours, CONTOUR_LAYER_ID, CONTOUR_COLOR, 1, None, paper, "contour" + ) + ) + # 필지 경계 + 지번. + jibun: list[dict[str, Any]] = [] + for index, parcel in enumerate(parcels): + ring = parcel.get("ring") or [] + label_at = parcel.get("label_at") + if len(ring) >= 2: + outline = polyline_entity( + drawing_id, + [paper(point) for point in ring], + PARCEL_LAYER_ID, + PARCEL_COLOR, + suffix=f":parcel:{index}", + ) + if outline: + entities.append(outline) + elif label_at is None: + continue + if label_at is not None: + # 도곽을 통째로 감싼 필지 — 경계선이 없으니 지정된 자리에 지번만 적는다. + center = paper(tuple(label_at)) + else: + paper_ring = [paper(point) for point in ring] + width = max(x for x, _y in paper_ring) - min(x for x, _y in paper_ring) + height = max(y for _x, y in paper_ring) - min(y for _x, y in paper_ring) + # 작은 필지는 지번을 솎는다 — 글자가 겹치면 큰 필지 것까지 못 읽는다. + if width < _JIBUN_MIN_W_MM or height < _JIBUN_MIN_H_MM: + continue + center = _ring_center(paper_ring) + text = (parcel.get("props") or {}).get("jibun") + if not isinstance(text, str) or not text: + continue + jibun.append( + _text_entity( + f"{drawing_id}:jibun:{index}", + text, + center[0], + center[1], + JIBUN_LAYER_ID, + _JIBUN_FONT_SIZE, + JIBUN_COLOR, + ) + ) + # 행정 경계는 필지 위에, 노선은 그 위에 — 아래에 깔리면 필지 선에 묻힌다. + entities.extend( + _boundary_entities( + drawing_id, emd_rings, EMD_LAYER_ID, EMD_COLOR, _EMD_WIDTH, [8, 4], paper, "emd" + ) + ) + entities.extend( + _boundary_entities( + drawing_id, + sgg_rings, + SGG_LAYER_ID, + SGG_COLOR, + _SGG_WIDTH, + [14, 5, 3, 5], + paper, + "sgg", + ) + ) + map_bbox = entities_bbox(entities) + route = polyline_entity( + drawing_id, + [paper(point) for point in route_xy], + ROUTE_LAYER_ID, + ROUTE_COLOR, + width=_ROUTE_WIDTH, + ) + if route: + entities.append(route) + entities.extend(jibun) # 지번은 가장 위 — 선에 가리면 못 읽는다. + + # 오른쪽 칸: 방위표가 맨 위, 그 아래로 범례(유역도에서 유역 정보표가 있던 자리). + if map_bbox: + column_x = map_bbox[2] + _COMPASS_MARGIN + column_top = map_bbox[3] + entities.extend( + compass_entities( + drawing_id, + (column_x + _COMPASS_SIZE / 2.0, column_top - _COMPASS_SIZE / 2.0), + _COMPASS_SIZE, + ) + ) + entities.extend(_legend_entities(drawing_id, (column_x, column_top - _COMPASS_SIZE - 10.0))) + + bbox = entities_bbox(entities) + if bbox: + min_bx, _min_by, max_bx, max_by = bbox + entities.append( + _text_entity( + f"{drawing_id}:title", + label, + (min_bx + max_bx) / 2.0, + max_by + 12.0, + TITLE_LAYER_ID, + _TITLE_FONT_SIZE, + TABLE_LABEL_COLOR, + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:scale", + f"S = 1/{DRAWING_SCALE_PLAN:,}", + max_bx, + max_by + 5.0, + TITLE_LAYER_ID, + _FONT_SIZE, + TABLE_LABEL_COLOR, + align="right", + ) + ) + entities.extend( + frame_entities( + drawing_id, + entities_bbox(entities) or bbox, + fit=False, + fields={"도면명": label, **scale_fields(("", DRAWING_SCALE_PLAN))}, + ) + ) + + return { + "format": DRAWING_FORMAT, + "entities": entities, + "layers": [ + _layer(CONTOUR_LAYER_ID, "등고선", locked=True), + _layer(PARCEL_LAYER_ID, "필지 경계"), + _layer(JIBUN_LAYER_ID, "지번"), + _layer(EMD_LAYER_ID, "읍면동·리 경계"), + _layer(SGG_LAYER_ID, "시군구 경계"), + _layer(ROUTE_LAYER_ID, "계획노선"), + _layer(LEGEND_LAYER_ID, "범례"), + _layer(TITLE_LAYER_ID, "표제"), + _layer(FRAME_LAYER_ID, "도각", locked=True), + ], + } + + +def landuse_area_mm() -> tuple[float, float]: + """지적 배경이 차지할 수 있는 크기(mm) — 계획평면도와 같다(같은 축척·같은 도곽).""" + return plan_area_mm() diff --git a/B07_DesignDetail/B07_DesignDetail_Router.py b/B07_DesignDetail/B07_DesignDetail_Router.py index f4777153..aa8b3b5c 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router.py +++ b/B07_DesignDetail/B07_DesignDetail_Router.py @@ -34,6 +34,7 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( use_title_fields, ) from B07_DesignDetail.B07_DesignDetail_Router_Support import ( + LANDUSE_ID, MASS_HAUL_ID, PLAN_ID, WATERSHED_ID, @@ -44,6 +45,7 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support import ( _read_json, _recompute_confirmed_design, _store_confirmed_drawing, + landuse_source, plan_source, watershed_source, ) @@ -303,6 +305,15 @@ async def get_design_drawing( if context is None: return JSONResponse(status_code=404, content={"status": "error", "message": reason}) source_design = await asyncio.to_thread(watershed_source, context) + elif LANDUSE_ID.fullmatch(drawing_id): + # 용지도도 같은 배경 창구를 쓴다 — 지적·행정 경계만 따로 읽는다. + context, reason = await load_drainage_context(project_id) + if context is None: + return JSONResponse(status_code=404, content={"status": "error", "message": reason}) + longitudinal = await asyncio.to_thread(_read_json, longitudinal_path) + source_design = await asyncio.to_thread( + landuse_source, context, longitudinal, drawing_id + ) elif PLAN_ID.fullmatch(drawing_id): # 계획평면도는 유역도와 **같은 배경 창구**를 쓴다 — 자료 읽기·환산이 캐시된다. context, reason = await load_drainage_context(project_id) diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support.py b/B07_DesignDetail/B07_DesignDetail_Router_Support.py index ef362b2a..9fb6f583 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support.py @@ -21,6 +21,10 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Cover import ( build_blank_drawing, build_cover_drawing, ) +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Landuse import ( + LANDUSE_LABEL, + build_landuse_drawing, +) from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Long import ( build_longitudinal_drawing, longitudinal_chunks, @@ -52,6 +56,9 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( CONTOUR_FILE as CONTOUR_FILE, ) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + LANDUSE_ID as LANDUSE_ID, +) from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( PLAN_ID as PLAN_ID, ) @@ -79,6 +86,9 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( clip_line_to_box as clip_line_to_box, ) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + landuse_source as landuse_source, +) from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( plan_source as plan_source, ) @@ -119,7 +129,6 @@ BLANK_DRAWINGS: tuple[tuple[str, str], ...] = ( ("blank_plan_lidar", "계획평면도(라이다)"), ("blank_cross_standard", "표준 횡단면도"), ("blank_standard", "표준도"), - ("blank_landuse", "용지도"), ) BLANK_LABELS: dict[str, str] = dict(BLANK_DRAWINGS) @@ -177,6 +186,19 @@ def _drawing_list( confirmed=bool(manifest_drawings.get(drawing_id, {}).get("confirmed")), ) ) + # 용지도 — 계획평면도와 같은 축척·같은 장 나눔을 쓴다. + for chunk in plan_sheets: + drawing_id = "landuse" if len(plan_sheets) <= 1 else f"landuse_{chunk['number']}" + drawings.append( + DesignDrawingItem( + id=drawing_id, + kind="landuse", + label=LANDUSE_LABEL + if len(plan_sheets) <= 1 + else f"{LANDUSE_LABEL} {chunk['number']}장", + confirmed=bool(manifest_drawings.get(drawing_id, {}).get("confirmed")), + ) + ) # 노선 전장 1장짜리 도면 — 자료가 없으면 여는 시점에 404로 알린다(목록에는 항상 둔다). for drawing_id, kind, label in ( (COVER_ID, "cover", "표지"), @@ -409,6 +431,8 @@ def _read_drawing( kind = drawing_id # id와 kind가 같은 단장 도면 elif PLAN_ID.fullmatch(drawing_id): kind = "plan" + elif LANDUSE_ID.fullmatch(drawing_id): + kind = "landuse" else: kind = "longitudinal" if _LONG_ID.fullmatch(drawing_id) else "cross" label = str(manifest_entry.get("label") or drawing_id) @@ -437,6 +461,27 @@ def _read_drawing( None, ) + if LANDUSE_ID.fullmatch(drawing_id): + # stored_design = landuse_source()가 모아 준 노선·등고선·지적·행정 경계(사업지 CRS). + if not isinstance(stored_design, dict): + raise FileNotFoundError("용지도 자료가 없습니다.") + label = str(stored_design.get("label") or LANDUSE_LABEL) + return ( + "landuse", + label, + build_landuse_drawing( + drawing_id, + label, + stored_design.get("route_xy") or [], + stored_design.get("contours") or [], + stored_design.get("parcels") or [], + stored_design.get("emd_rings") or [], + stored_design.get("sgg_rings") or [], + ), + False, + None, + ) + if PLAN_ID.fullmatch(drawing_id): # stored_design = plan_source()가 모아 준 노선·측점·배경·구조물 좌표(사업지 CRS). if not isinstance(stored_design, dict): diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py b/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py index 73c52af0..3c104371 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py @@ -15,6 +15,7 @@ from pyproj import Transformer from B04_PreProcess.B04_PreProcess_Router_Watershed import CONTOUR_FILE, STREAM_FILE from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Basin import map_area_mm +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Landuse import LANDUSE_LABEL from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import ( plan_area_mm, plan_chunks, @@ -76,7 +77,7 @@ def _basins_crs(context: Any, payload: dict[str, Any]) -> str: def _geometry_lines(geometry: Any) -> list[list[tuple[float, float]]]: - """LineString·MultiLineString·Polygon을 점열 목록으로 편다.""" + """LineString·MultiLineString·Polygon·MultiPolygon을 점열 목록으로 편다.""" if not isinstance(geometry, dict): return [] kind = geometry.get("type") @@ -91,6 +92,15 @@ def _geometry_lines(geometry: Any) -> list[list[tuple[float, float]]]: for part in coordinates if isinstance(part, list) ] + # 연속지적도·행정구역은 MultiPolygon 이다 — 폴리곤마다 고리를 모두 편다(2026-09-04). + if kind == "MultiPolygon": + return [ + [(float(p[0]), float(p[1])) for p in ring if isinstance(p, list)] + for polygon in coordinates + if isinstance(polygon, list) + for ring in polygon + if isinstance(ring, list) + ] return [] @@ -336,6 +346,130 @@ def _plan_structures(context: Any) -> list[dict[str, Any]]: return [point for point in points if isinstance(point, dict)] +LANDUSE_ID = re.compile(r"^landuse(?:_(\d+))?$") + +# B04 가 내려받아 저장하는 지적·행정구역 GeoJSON (전부 WGS84). +PARCEL_FILE = "연속지적도_bounds.geojson" +EMD_FILE = "행정구역_읍면동_bounds.geojson" +SGG_FILE = "행정구역_시군구_bounds.geojson" + + +def _clip_rings( + path: Path, crs: str, box: tuple[float, float, float, float] +) -> list[list[tuple[float, float]]]: + """행정구역 경계를 사업지 좌표계로 돌려 도곽 범위로 절취한다(속성은 안 씀).""" + rings: list[list[tuple[float, float]]] = [] + for ring in _metric_lines(path, crs): + rings.extend(clip_line_to_box(ring, box)) + return rings + + +def _contains(ring: list[tuple[float, float]], point: tuple[float, float]) -> bool: + """점이 고리 안에 드는지 (반직선 교차 판정).""" + x, y = point + inside = False + for index in range(len(ring)): + x1, y1 = ring[index - 1] + x2, y2 = ring[index] + if (y1 > y) != (y2 > y) and x < (x2 - x1) * (y - y1) / ((y2 - y1) or 1e-12) + x1: + inside = not inside + return inside + + +def _clip_parcels( + path: Path, crs: str, box: tuple[float, float, float, float] +) -> list[dict[str, Any]]: + """연속지적도를 사업지 좌표계로 돌려 도곽 안 필지만 남긴다 (지번 표기용 속성 포함). + + 필지는 지번을 적어야 하므로 경계선만 자르는 `_metric_lines` 캐시를 쓰지 못한다 — + 피처와 속성을 짝지어 읽는다. 도곽 밖 필지는 여기서 버려 도면이 무거워지지 않게 한다. + + 두 가지를 함께 낸다. + - `ring` : 도곽으로 자른 경계선(밖으로 나가는 부분은 버린다). 자르지 않으면 + 산지 대필지 하나가 도면을 10 km 로 벌린다(2026-09-04 실측: 콘텐츠 8,368 mm). + - `label_at` : 도곽을 **통째로 감싸는** 필지의 지번 자리. 임야 대필지 안에 노선이 + 들어앉으면 경계선이 도곽 안에 하나도 없어 지번이 사라진다(2026-09-04 실측: + 용화_LAS 노선이 「산77-1임 일월면 용화리」 한 필지 안에 통째로 들어감). + """ + if not path.is_file(): + return [] + transformer = Transformer.from_crs("EPSG:4326", crs, always_xy=True) + min_x, min_y, max_x, max_y = box + center = ((min_x + max_x) / 2.0, (min_y + max_y) / 2.0) + parcels: list[dict[str, Any]] = [] + for feature in _geojson_features(path): + properties = feature.get("properties") or {} + for ring in _geometry_lines(feature.get("geometry")): + converted = [ + (float(x), float(y)) + for x, y in (transformer.transform(point[0], point[1]) for point in ring) + ] + if len(converted) < 3: + continue + if max(x for x, _y in converted) < min_x or min(x for x, _y in converted) > max_x: + continue + if max(y for _x, y in converted) < min_y or min(y for _x, y in converted) > max_y: + continue + parts = [part for part in clip_line_to_box(converted, box) if len(part) >= 2] + for part in parts: + parcels.append({"ring": part, "props": properties}) + if not parts and _contains(converted, center): + parcels.append({"ring": [], "props": properties, "label_at": center}) + return parcels + + +def landuse_source(context: Any, longitudinal: dict[str, Any], drawing_id: str) -> dict[str, Any]: + """용지도 한 장의 입력(노선·등고선·연속지적도·행정구역)을 사업지 CRS(m)로 모은다. + + 축척·도곽·장 나눔은 계획평면도와 같다 — 배경도 같은 창구(`map_background`)를 쓴다. + """ + match = LANDUSE_ID.fullmatch(drawing_id) + if not match: + raise ValueError("올바르지 않은 용지도 ID입니다.") + chunks = plan_chunks(plan_stations(longitudinal)) + number = int(match.group(1)) if match.group(1) else 1 + chunk = next((item for item in chunks if item["number"] == number), None) + if chunk is None: + raise FileNotFoundError("요청한 용지도 장을 찾을 수 없습니다.") + total = len(chunks) + start_m, end_m = float(chunk["start_m"]), float(chunk["end_m"]) + + route_xy = [ + (vertex.x, vertex.y) + for vertex in context.vertices + if total <= 1 or start_m <= float(getattr(vertex, "chainage_m", 0.0) or 0.0) <= end_m + ] + background = map_background( + Path(context.project_root), + context.crs, + DRAWING_SCALE_PLAN, + plan_area_mm(), + route_xy, + ) + # 지적·행정 경계는 등고선과 **같은 범위**로 자른다 — 배경보다 넓으면 도면이 A1을 넘는다. + area_w_mm, area_h_mm = plan_area_mm() + half_w = area_w_mm / 2.0 * DRAWING_SCALE_PLAN / 1000.0 + half_h = area_h_mm / 2.0 * DRAWING_SCALE_PLAN / 1000.0 + center_x = (min(x for x, _y in route_xy) + max(x for x, _y in route_xy)) / 2.0 + center_y = (min(y for _x, y in route_xy) + max(y for _x, y in route_xy)) / 2.0 + box = ( + min(center_x - half_w, min(x for x, _y in route_xy)), + min(center_y - half_h, min(y for _x, y in route_xy)), + max(center_x + half_w, max(x for x, _y in route_xy)), + max(center_y + half_h, max(y for _x, y in route_xy)), + ) + sheet_dir = Path(context.project_root) / "B04_PreProcess" / "processed" + label = LANDUSE_LABEL if total <= 1 else f"{LANDUSE_LABEL} {number}장" + return { + "label": label, + "route_xy": route_xy, + "contours": background["contours"], + "parcels": _clip_parcels(sheet_dir / PARCEL_FILE, context.crs, box), + "emd_rings": _clip_rings(sheet_dir / EMD_FILE, context.crs, box), + "sgg_rings": _clip_rings(sheet_dir / SGG_FILE, context.crs, box), + } + + def watershed_source(context: Any) -> dict[str, Any]: """유역도 입력(노선·세부유역·등고선·세류선)을 사업지 CRS(m)로 모은다. diff --git a/B07_DesignDetail/B07_DesignDetail_Schema.py b/B07_DesignDetail/B07_DesignDetail_Schema.py index 1fc0ce6d..d4b7fddf 100644 --- a/B07_DesignDetail/B07_DesignDetail_Schema.py +++ b/B07_DesignDetail/B07_DesignDetail_Schema.py @@ -10,7 +10,16 @@ class DesignDrawingItem(BaseModel): id: str # blank: 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). - kind: Literal["cover", "longitudinal", "cross", "mass_haul", "watershed", "plan", "blank"] + kind: Literal[ + "cover", + "longitudinal", + "cross", + "mass_haul", + "watershed", + "plan", + "landuse", + "blank", + ] label: str chainage_m: float | None = None confirmed: bool = False @@ -33,7 +42,16 @@ class DesignDrawingResponse(BaseModel): route_id: int id: str # blank: 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). - kind: Literal["cover", "longitudinal", "cross", "mass_haul", "watershed", "plan", "blank"] + kind: Literal[ + "cover", + "longitudinal", + "cross", + "mass_haul", + "watershed", + "plan", + "landuse", + "blank", + ] label: str drawing: dict[str, Any] confirmed: bool = False diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts index 9e8ef8ad..74d19953 100644 --- a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts +++ b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts @@ -41,7 +41,7 @@ export const DRAWING_GROUPS: readonly { { label: "토적도(유토곡선)", kind: "mass_haul" }, { label: "유역도(배수 유역도)", kind: "watershed" }, { label: "표준도", blankId: "blank_standard" }, - { label: "용지도", blankId: "blank_landuse" }, + { label: "용지도", idPrefix: "landuse" }, ]; /** B06 확정 산출물 기반 도면 목록 패널. */ From 18c174036b3a0de7053547bf9021aa0ecff5d16e Mon Sep 17 00:00:00 2001 From: umsangdon Date: Fri, 4 Sep 2026 19:00:38 +0900 Subject: [PATCH 4/5] =?UTF-8?q?feat(B07):=20=EA=B3=84=ED=9A=8D=ED=8F=89?= =?UTF-8?q?=EB=A9=B4=EB=8F=84(=EB=9D=BC=EC=9D=B4=EB=8B=A4)=20=E2=80=94=20?= =?UTF-8?q?=EC=A7=80=ED=91=9C=EB=A9=B4=20=EC=9D=8C=EC=98=81=EA=B8=B0?= =?UTF-8?q?=EB=B3=B5=20=EB=B0=B0=EA=B2=BD=201=EC=B0=A8=20=EB=B0=B0?= =?UTF-8?q?=EC=B9=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 빈 도각이던 라이다 계획평면도에 지표면 탑뷰 그림을 얹음. - 확정 DTM 격자를 도곽 범위로 잘라 음영기복 PNG 를 만들고 Image 엔티티로 실음 (북서 315도·고도 45도, 한 변 최대 1,600 px). 점구름 4,900만 점을 그대로 그리지 않음. - 어느 지표면을 쓸지는 1단계 확정값을 따름 — DrainageContext 에 surface_params 를 실어 전달. - 축척·도곽·장 나눔은 계획평면도와 같음(1/1,200) — 노선이 같은 자리에 섬. - entities_bbox 가 꼭짓점 배열(points)을 세도록 고침. 세지 않으면 그림이 도곽 계산에서 통째로 빠짐. 검증(용화_LAS): 콘텐츠 726.1x487.2 mm ≤ A1 작도영역, 그림 범위 안에 노선이 완전히 들어감, 음영기복 준비 0.4초·자료 214 KB. 능선·계곡이 눈으로 구분됨. Co-Authored-By: Claude Opus 5 (1M context) --- .../B07_DesignDetail_Api_Fetch.ts | 2 + .../B07_DesignDetail_Engine_Cad_Lidar.py | 220 ++++++++++++++++++ .../B07_DesignDetail_Engine_Template.py | 6 + B07_DesignDetail/B07_DesignDetail_Router.py | 9 + .../B07_DesignDetail_Router_Support.py | 45 +++- .../B07_DesignDetail_Router_Support_Basin.py | 114 +++++++++ B07_DesignDetail/B07_DesignDetail_Schema.py | 2 + .../B07_DesignDetail_UI_Panels.ts | 2 +- common_util/common_util_drainage_context.py | 4 + 9 files changed, 402 insertions(+), 2 deletions(-) create mode 100644 B07_DesignDetail/B07_DesignDetail_Engine_Cad_Lidar.py diff --git a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts index 38a360c9..b51b8f63 100644 --- a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts +++ b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts @@ -13,6 +13,7 @@ export interface DesignDrawingItem { | "watershed" | "plan" | "landuse" + | "plan_lidar" | "blank"; label: string; chainage_m: number | null; @@ -99,6 +100,7 @@ export interface DesignDrawingResponse { | "watershed" | "plan" | "landuse" + | "plan_lidar" | "blank"; label: string; drawing: CadDrawing; diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Lidar.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Lidar.py new file mode 100644 index 00000000..726061c1 --- /dev/null +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Lidar.py @@ -0,0 +1,220 @@ +"""B07 계획평면도(라이다) CAD 조립 — 지표면 격자를 음영기복 그림으로 깔고 노선을 얹는다. + +사용자 지시(2026-09-04) — 「라이다 계획평면도는 3D 자료를 탑뷰에서 본 그림이 필요함. +가능한 범위에서 일단 배치해 주면 보고 개선하겠음」. + +점구름을 그대로 그리면 수천만 점이라 도면 만들기가 느려진다(용화_LAS 실측 4,900만 점). +이미 만들어 둔 **지표면 격자(DTM)** 로 음영기복 이미지를 서버에서 만들어 배경으로 깐다. +도면 틀이 이미지 요소를 받아 주므로(`Image` 엔티티) PNG 를 그대로 싣는다. + +축척·도곽·장 나눔은 계획평면도와 같다(1/1,200 고정) — 같은 자리에 노선이 서야 한다. +""" + +import base64 +import io +import math +from typing import Any + +import numpy as np + +from B07_DesignDetail.B07_DesignDetail_Engine_Cad import ( + DRAWING_FORMAT, + FRAME_LAYER_ID, + TABLE_LABEL_COLOR, + _layer, + _text_entity, + polyline_entity, +) +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import ( + _COMPASS_MARGIN, + _COMPASS_SIZE, + _FONT_SIZE, + _ROUTE_WIDTH, + _TITLE_FONT_SIZE, + MM, +) +from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( + compass_entities, + entities_bbox, + frame_entities, + scale_fields, +) +from config.config_system import DRAWING_SCALE_PLAN + +LIDAR_KIND = "plan_lidar" +LIDAR_LABEL = "계획평면도(라이다)" + +SHADE_LAYER_ID = "b07-lidar-shade" +ROUTE_LAYER_ID = "b07-lidar-route" +TITLE_LAYER_ID = "b07-lidar-title" +ROUTE_COLOR = "#ffe066" + +# 음영기복 광원 — 도면 관행대로 북서(방위각 315°)에서 45° 높이로 비춘다. +_AZIMUTH_DEG = 315.0 +_ALTITUDE_DEG = 45.0 +# 그림이 지나치게 커지지 않도록 한 변 최대 픽셀 수 (A1 에 인쇄하면 1,200 px 이면 충분하다). +_MAX_PIXELS = 1600 + + +def hillshade_png(z: np.ndarray, valid: np.ndarray, resolution_m: float) -> tuple[str, int, int]: + """지표면 격자에서 음영기복 PNG(data URL)를 만든다. (data_url, 가로 px, 세로 px). + + 입력 `z`는 행이 남→북 순서(격자 y 오름차순)다. 그림은 위가 북이어야 하므로 뒤집는다. + 빈 칸(`valid`가 False)은 흰색으로 두어 도면에서 배경과 구분되게 한다. + """ + from PIL import Image + + grid = np.asarray(z, dtype=np.float64) + mask = np.asarray(valid, dtype=bool) + if grid.ndim != 2 or grid.size == 0: + raise ValueError("지표면 격자가 비어 있습니다.") + + # 큰 격자는 미리 솎는다 — A1 한 장에 1,600 px 이상은 눈으로 구분되지 않는다. + rows, columns = grid.shape + stride = max(1, math.ceil(max(rows, columns) / _MAX_PIXELS)) + if stride > 1: + grid = grid[::stride, ::stride] + mask = mask[::stride, ::stride] + resolution_m *= stride + + filled = np.where(mask, grid, np.nan) + # 빈 칸이 기울기를 망치지 않도록 평균으로 메운 뒤 기울기를 잰다. + mean = float(np.nanmean(filled)) if np.isfinite(filled).any() else 0.0 + filled = np.nan_to_num(filled, nan=mean) + dz_dy, dz_dx = np.gradient(filled, max(resolution_m, 1e-6)) + + slope = np.arctan(np.hypot(dz_dx, dz_dy)) + aspect = np.arctan2(-dz_dx, dz_dy) + azimuth = math.radians(360.0 - _AZIMUTH_DEG + 90.0) + altitude = math.radians(_ALTITUDE_DEG) + shade = np.sin(altitude) * np.cos(slope) + np.cos(altitude) * np.sin(slope) * np.cos( + azimuth - aspect + ) + shade = np.clip(shade, 0.0, 1.0) + # 배경이므로 완전히 검지 않게 누르되, 능선·계곡이 인쇄에서 보일 만큼은 대비를 준다 + # (2026-09-04 실측: 120~255 는 너무 흐렸음). + pixels = (90 + 160 * shade).astype(np.uint8) + pixels[~mask] = 255 + + image = Image.fromarray(np.flipud(pixels), mode="L") + buffer = io.BytesIO() + image.save(buffer, format="PNG", optimize=True) + data_url = "data:image/png;base64," + base64.b64encode(buffer.getvalue()).decode("ascii") + return (data_url, image.width, image.height) + + +def build_lidar_plan_drawing( + drawing_id: str, + label: str, + route_xy: list[tuple[float, float]], + shade_image: str | None, + shade_box: tuple[float, float, float, float] | None, +) -> dict[str, Any]: + """라이다 계획평면도 한 장을 만든다. + + `shade_box`는 음영기복 그림이 덮는 실좌표 범위(min_x, min_y, max_x, max_y)다 — + 그림 네 모서리를 그 범위 그대로 종이에 놓아야 노선과 좌표가 맞는다. + """ + everything = [*route_xy] + if shade_box: + everything.extend([(shade_box[0], shade_box[1]), (shade_box[2], shade_box[3])]) + if not everything: + raise FileNotFoundError( + "라이다 계획평면도에 그릴 자료가 없습니다. B04 전처리에서 지표면을 먼저 만드세요." + ) + min_x = min(x for x, _y in everything) + min_y = min(y for _x, y in everything) + + def paper(point: tuple[float, float]) -> tuple[float, float]: + return ((point[0] - min_x) * MM, (point[1] - min_y) * MM) + + entities: list[dict[str, Any]] = [] + if shade_image and shade_box: + left, bottom = paper((shade_box[0], shade_box[1])) + right, top = paper((shade_box[2], shade_box[3])) + entities.append( + { + "id": f"{drawing_id}:shade", + "type": "Image", + "lineColor": "#ffffff", + "lineWidth": 1, + "layerId": SHADE_LAYER_ID, + "shapeData": { + "points": [ + {"x": left, "y": bottom}, + {"x": right, "y": bottom}, + {"x": right, "y": top}, + {"x": left, "y": top}, + ], + "imageData": shade_image, + }, + } + ) + route = polyline_entity( + drawing_id, + [paper(point) for point in route_xy], + ROUTE_LAYER_ID, + ROUTE_COLOR, + width=_ROUTE_WIDTH, + ) + if route: + entities.append(route) + + map_bbox = entities_bbox(entities) + if map_bbox: + entities.extend( + compass_entities( + drawing_id, + ( + map_bbox[2] + _COMPASS_MARGIN + _COMPASS_SIZE / 2.0, + map_bbox[3] - _COMPASS_SIZE / 2.0, + ), + _COMPASS_SIZE, + ) + ) + + bbox = entities_bbox(entities) + if bbox: + min_bx, _min_by, max_bx, max_by = bbox + entities.append( + _text_entity( + f"{drawing_id}:title", + label, + (min_bx + max_bx) / 2.0, + max_by + 12.0, + TITLE_LAYER_ID, + _TITLE_FONT_SIZE, + TABLE_LABEL_COLOR, + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:scale", + f"S = 1/{DRAWING_SCALE_PLAN:,}", + max_bx, + max_by + 5.0, + TITLE_LAYER_ID, + _FONT_SIZE, + TABLE_LABEL_COLOR, + align="right", + ) + ) + entities.extend( + frame_entities( + drawing_id, + entities_bbox(entities) or bbox, + fit=False, + fields={"도면명": label, **scale_fields(("", DRAWING_SCALE_PLAN))}, + ) + ) + + return { + "format": DRAWING_FORMAT, + "entities": entities, + "layers": [ + _layer(SHADE_LAYER_ID, "지표면 음영기복", locked=True), + _layer(ROUTE_LAYER_ID, "계획노선"), + _layer(TITLE_LAYER_ID, "표제"), + _layer(FRAME_LAYER_ID, "도각", locked=True), + ], + } diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Template.py b/B07_DesignDetail/B07_DesignDetail_Engine_Template.py index ecec48f0..6708d945 100644 --- a/B07_DesignDetail/B07_DesignDetail_Engine_Template.py +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Template.py @@ -194,6 +194,12 @@ def entities_bbox(entities: list[dict[str, Any]]) -> tuple[float, float, float, if isinstance(p, dict): xs.append(float(p["x"])) ys.append(float(p["y"])) + # 꼭짓점 배열을 쓰는 엔티티(Image·Hatch)도 범위에 넣는다 — 넣지 않으면 라이다 + # 음영기복 그림이 도곽 계산에서 통째로 빠진다(2026-09-04). + for vertex in shape.get("points") or []: + if isinstance(vertex, dict) and "x" in vertex and "y" in vertex: + xs.append(float(vertex["x"])) + ys.append(float(vertex["y"])) center = shape.get("center") if isinstance(center, dict): r = float(shape.get("radius", 0.0)) diff --git a/B07_DesignDetail/B07_DesignDetail_Router.py b/B07_DesignDetail/B07_DesignDetail_Router.py index aa8b3b5c..5cd8a010 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router.py +++ b/B07_DesignDetail/B07_DesignDetail_Router.py @@ -35,6 +35,7 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( ) from B07_DesignDetail.B07_DesignDetail_Router_Support import ( LANDUSE_ID, + LIDAR_ID, MASS_HAUL_ID, PLAN_ID, WATERSHED_ID, @@ -46,6 +47,7 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support import ( _recompute_confirmed_design, _store_confirmed_drawing, landuse_source, + lidar_source, plan_source, watershed_source, ) @@ -305,6 +307,13 @@ async def get_design_drawing( if context is None: return JSONResponse(status_code=404, content={"status": "error", "message": reason}) source_design = await asyncio.to_thread(watershed_source, context) + elif LIDAR_ID.fullmatch(drawing_id): + # 라이다 계획평면도는 확정 DTM 격자로 음영기복 그림을 만들어 넘긴다. + context, reason = await load_drainage_context(project_id) + if context is None: + return JSONResponse(status_code=404, content={"status": "error", "message": reason}) + longitudinal = await asyncio.to_thread(_read_json, longitudinal_path) + source_design = await asyncio.to_thread(lidar_source, context, longitudinal, drawing_id) elif LANDUSE_ID.fullmatch(drawing_id): # 용지도도 같은 배경 창구를 쓴다 — 지적·행정 경계만 따로 읽는다. context, reason = await load_drainage_context(project_id) diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support.py b/B07_DesignDetail/B07_DesignDetail_Router_Support.py index 9fb6f583..93936c4f 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support.py @@ -25,6 +25,10 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Landuse import ( LANDUSE_LABEL, build_landuse_drawing, ) +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Lidar import ( + LIDAR_LABEL, + build_lidar_plan_drawing, +) from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Long import ( build_longitudinal_drawing, longitudinal_chunks, @@ -59,6 +63,9 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( LANDUSE_ID as LANDUSE_ID, ) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + LIDAR_ID as LIDAR_ID, +) from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( PLAN_ID as PLAN_ID, ) @@ -89,6 +96,9 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( landuse_source as landuse_source, ) +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( + lidar_source as lidar_source, +) from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( plan_source as plan_source, ) @@ -126,7 +136,6 @@ COVER_ID = "cover" # 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). # 화면 순서(DRAWING_GROUPS)와 같은 이름을 쓴다. BLANK_DRAWINGS: tuple[tuple[str, str], ...] = ( - ("blank_plan_lidar", "계획평면도(라이다)"), ("blank_cross_standard", "표준 횡단면도"), ("blank_standard", "표준도"), ) @@ -186,6 +195,19 @@ def _drawing_list( confirmed=bool(manifest_drawings.get(drawing_id, {}).get("confirmed")), ) ) + # 계획평면도(라이다) — 지표면 음영기복 배경. 같은 축척·같은 장 나눔. + for chunk in plan_sheets: + drawing_id = "plan_lidar" if len(plan_sheets) <= 1 else f"plan_lidar_{chunk['number']}" + drawings.append( + DesignDrawingItem( + id=drawing_id, + kind="plan_lidar", + label=LIDAR_LABEL + if len(plan_sheets) <= 1 + else f"{LIDAR_LABEL} {chunk['number']}장", + confirmed=bool(manifest_drawings.get(drawing_id, {}).get("confirmed")), + ) + ) # 용지도 — 계획평면도와 같은 축척·같은 장 나눔을 쓴다. for chunk in plan_sheets: drawing_id = "landuse" if len(plan_sheets) <= 1 else f"landuse_{chunk['number']}" @@ -433,6 +455,8 @@ def _read_drawing( kind = "plan" elif LANDUSE_ID.fullmatch(drawing_id): kind = "landuse" + elif LIDAR_ID.fullmatch(drawing_id): + kind = "plan_lidar" else: kind = "longitudinal" if _LONG_ID.fullmatch(drawing_id) else "cross" label = str(manifest_entry.get("label") or drawing_id) @@ -461,6 +485,25 @@ def _read_drawing( None, ) + if LIDAR_ID.fullmatch(drawing_id): + # stored_design = lidar_source()가 만든 노선 + 지표면 음영기복 그림. + if not isinstance(stored_design, dict): + raise FileNotFoundError("라이다 계획평면도 자료가 없습니다.") + label = str(stored_design.get("label") or LIDAR_LABEL) + return ( + "plan_lidar", + label, + build_lidar_plan_drawing( + drawing_id, + label, + stored_design.get("route_xy") or [], + stored_design.get("shade_image"), + stored_design.get("shade_box"), + ), + False, + None, + ) + if LANDUSE_ID.fullmatch(drawing_id): # stored_design = landuse_source()가 모아 준 노선·등고선·지적·행정 경계(사업지 CRS). if not isinstance(stored_design, dict): diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py b/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py index 3c104371..7858a53f 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support_Basin.py @@ -16,6 +16,7 @@ from pyproj import Transformer from B04_PreProcess.B04_PreProcess_Router_Watershed import CONTOUR_FILE, STREAM_FILE from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Basin import map_area_mm from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Landuse import LANDUSE_LABEL +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Lidar import LIDAR_LABEL, hillshade_png from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import ( plan_area_mm, plan_chunks, @@ -470,6 +471,119 @@ def landuse_source(context: Any, longitudinal: dict[str, Any], drawing_id: str) } +LIDAR_ID = re.compile(r"^plan_lidar(?:_(\d+))?$") + + +def _sheet_box( + route_xy: list[tuple[float, float]], +) -> tuple[float, float, float, float]: + """그 장의 도곽 범위(실좌표 m) — 계획평면도·용지도·라이다가 같은 규칙을 쓴다.""" + area_w_mm, area_h_mm = plan_area_mm() + half_w = area_w_mm / 2.0 * DRAWING_SCALE_PLAN / 1000.0 + half_h = area_h_mm / 2.0 * DRAWING_SCALE_PLAN / 1000.0 + center_x = (min(x for x, _y in route_xy) + max(x for x, _y in route_xy)) / 2.0 + center_y = (min(y for _x, y in route_xy) + max(y for _x, y in route_xy)) / 2.0 + return ( + min(center_x - half_w, min(x for x, _y in route_xy)), + min(center_y - half_h, min(y for _x, y in route_xy)), + max(center_x + half_w, max(x for x, _y in route_xy)), + max(center_y + half_h, max(y for _x, y in route_xy)), + ) + + +def _chunk_route( + context: Any, longitudinal: dict[str, Any], number: int +) -> tuple[list[tuple[float, float]], dict[str, Any], int]: + """장 번호로 그 장의 노선 구간을 잘라 낸다 (계획평면도 장 나눔과 같은 기준).""" + chunks = plan_chunks(plan_stations(longitudinal)) + chunk = next((item for item in chunks if item["number"] == number), None) + if chunk is None: + raise FileNotFoundError("요청한 장을 찾을 수 없습니다.") + total = len(chunks) + start_m, end_m = float(chunk["start_m"]), float(chunk["end_m"]) + route_xy = [ + (vertex.x, vertex.y) + for vertex in context.vertices + if total <= 1 or start_m <= float(getattr(vertex, "chainage_m", 0.0) or 0.0) <= end_m + ] + return route_xy, chunk, total + + +def lidar_source(context: Any, longitudinal: dict[str, Any], drawing_id: str) -> dict[str, Any]: + """라이다 계획평면도 한 장의 입력(노선 + 지표면 음영기복 그림)을 모은다. + + 지표면은 확정 DTM 격자(`dtm_{필터}[_smooth].npz`)를 도곽 범위로 잘라 쓴다 — + 점구름을 그대로 그리면 수천만 점이라 도면 만들기가 느려진다(2026-09-04 사용자 지시). + """ + match = LIDAR_ID.fullmatch(drawing_id) + if not match: + raise ValueError("올바르지 않은 라이다 계획평면도 ID입니다.") + number = int(match.group(1)) if match.group(1) else 1 + route_xy, chunk, total = _chunk_route(context, longitudinal, number) + box = _sheet_box(route_xy) + label = LIDAR_LABEL if total <= 1 else f"{LIDAR_LABEL} {chunk['number']}장" + + shade_image: str | None = None + shade_box: tuple[float, float, float, float] | None = None + try: + shade_image, shade_box = _hillshade_for_box(context, box) + except (FileNotFoundError, ValueError, OSError) as exc: + # 지표면이 없어도 노선·도각은 그린다 — 빈 화면보다 낫다. + logger.warning("B07 라이다 계획평면도: 음영기복을 만들지 못했습니다 — %s", exc) + + return { + "label": label, + "route_xy": route_xy, + "shade_image": shade_image, + "shade_box": shade_box, + } + + +def _hillshade_for_box( + context: Any, box: tuple[float, float, float, float] +) -> tuple[str, tuple[float, float, float, float]]: + """확정 DTM 격자를 도곽 범위로 잘라 음영기복 PNG(data URL)와 실제 덮은 범위를 낸다.""" + import numpy as np + + params = getattr(context, "surface_params", None) or {} + source_filter = str(params.get("source_filter") or "csf") + smooth = bool(params.get("smooth", True)) + models_dir = Path(context.project_root) / "B04_PreProcess" / "models" + candidates = [models_dir / f"dtm_{source_filter}_smooth.npz"] if smooth else [] + candidates.append(models_dir / f"dtm_{source_filter}.npz") + candidates.extend(sorted(models_dir.glob("dtm_*_smooth.npz"))) + candidates.extend(sorted(models_dir.glob("dtm_*.npz"))) + path = next((item for item in candidates if item.is_file()), None) + if path is None: + raise FileNotFoundError("확정 지표면 격자(DTM)가 없습니다.") + + with np.load(path, allow_pickle=False) as data: + grid_x = np.asarray(data["x"], dtype=np.float64) + grid_y = np.asarray(data["y"], dtype=np.float64) + grid_z = np.asarray(data["z"], dtype=np.float64) + valid = np.asarray(data["valid_mask"], dtype=bool) + resolution = float(np.asarray(data["resolution"]).reshape(-1)[0]) + + min_x, min_y, max_x, max_y = box + columns = np.where((grid_x >= min_x) & (grid_x <= max_x))[0] + rows = np.where((grid_y >= min_y) & (grid_y <= max_y))[0] + if columns.size < 2 or rows.size < 2: + raise ValueError("도곽 안에 지표면 격자가 없습니다.") + sliced_z = grid_z[rows[0] : rows[-1] + 1, columns[0] : columns[-1] + 1] + sliced_valid = valid[rows[0] : rows[-1] + 1, columns[0] : columns[-1] + 1] + + data_url, _width, _height = hillshade_png(sliced_z, sliced_valid, resolution) + return ( + data_url, + ( + float(grid_x[columns[0]]), + float(grid_y[rows[0]]), + float(grid_x[columns[-1]]), + float(grid_y[rows[-1]]), + ), + ) + + def watershed_source(context: Any) -> dict[str, Any]: """유역도 입력(노선·세부유역·등고선·세류선)을 사업지 CRS(m)로 모은다. diff --git a/B07_DesignDetail/B07_DesignDetail_Schema.py b/B07_DesignDetail/B07_DesignDetail_Schema.py index d4b7fddf..dbe92954 100644 --- a/B07_DesignDetail/B07_DesignDetail_Schema.py +++ b/B07_DesignDetail/B07_DesignDetail_Schema.py @@ -18,6 +18,7 @@ class DesignDrawingItem(BaseModel): "watershed", "plan", "landuse", + "plan_lidar", "blank", ] label: str @@ -50,6 +51,7 @@ class DesignDrawingResponse(BaseModel): "watershed", "plan", "landuse", + "plan_lidar", "blank", ] label: str diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts index 74d19953..2eab42c6 100644 --- a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts +++ b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts @@ -34,7 +34,7 @@ export const DRAWING_GROUPS: readonly { { label: "계획평면도(지형)", idPrefix: "plan_terrain" }, { label: "계획평면도(노선배치도)", idPrefix: "plan_route" }, { label: "계획평면도(배치도)", idPrefix: "plan_layout" }, - { label: "계획평면도(라이다)", blankId: "blank_plan_lidar" }, + { label: "계획평면도(라이다)", idPrefix: "plan_lidar" }, { label: "종단면도", kind: "longitudinal" }, { label: "표준 횡단면도", blankId: "blank_cross_standard" }, { label: "횡단면도", kind: "cross" }, diff --git a/common_util/common_util_drainage_context.py b/common_util/common_util_drainage_context.py index 2d023038..a785695f 100644 --- a/common_util/common_util_drainage_context.py +++ b/common_util/common_util_drainage_context.py @@ -58,6 +58,9 @@ class DrainageContext: crs: str = "EPSG:5186" route_id: int | None = None to_lonlat: Callable[[float, float], tuple[float, float]] = lambda x, y: (x, y) + # 1단계에서 확정한 지표면 선택(source_filter·method·smooth). B07 라이다 계획평면도가 + # 어느 DTM 격자로 음영기복을 만들지 고르는 데 쓴다(2026-09-04). + surface_params: dict[str, Any] = field(default_factory=dict) async def load_drainage_context(project_id: UUID) -> tuple[DrainageContext | None, str]: @@ -112,6 +115,7 @@ async def load_drainage_context(project_id: UUID) -> tuple[DrainageContext | Non crs=crs, route_id=int(route["id"]) if route else None, to_lonlat=lambda x, y: transformer.transform(x, y), + surface_params=dict(surface_params), ), "", ) From 02bd45bf3c7c76ff00414e4bc0e2e8ebc644f2de Mon Sep 17 00:00:00 2001 From: umsangdon Date: Fri, 4 Sep 2026 19:09:06 +0900 Subject: [PATCH 5/5] =?UTF-8?q?feat(B07):=20=ED=91=9C=EC=A4=80=20=ED=9A=A1?= =?UTF-8?q?=EB=8B=A8=EB=A9=B4=EB=8F=84=20=E2=80=94=20=EC=B9=98=EC=88=98?= =?UTF-8?q?=C2=B7=EC=B8=A1=EA=B5=AC=20=ED=99=95=EB=8C=80=EB=8F=84=C2=B7?= =?UTF-8?q?=EC=95=94=EB=B0=98=EC=84=A0=202=EB=8B=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 빈 도각이던 표준 횡단면도를 실제 도면으로 만듦. - 본 그림: B06 좌측 패널 모식도와 같은 배치를 실치수로 그림(1/50). 노폭·노견· 측구 상단폭·노면 전폭에 치수선(눈금+치수값)을 붙이고, 절토·성토 경사비와 횡단경사를 표기. 값은 B06 표준 횡단면 설정을 그대로 읽고 없으면 config 기본값. - 측구 부분 확대도(1/10): 상단폭·저폭·깊이 치수 + 확대 축척 표기. - 암반 2단 절토: 아래는 암반 경사(1:0.4), 위는 토사 경사(1:1), 갈리는 높이에 암반선을 파선으로 긋고 각도를 함께 적음. - 암 L형 측구·포장 횡단경사는 주기(※)로 적음 — 본 그림은 토사 기준. 곁들여: Router_Support 가 700줄을 넘어 재수출 import 를 한 문장으로 합쳐 681줄로 줄임(기능 변화 없음). 검증: 치수값이 STANDARD_CROSS_SECTION 과 일치(500·3000·500·900·4000), 확대도 900·300·300 + S=1/10, 2단 절토선 꺾임점 1개, 콘텐츠 358.2x172.6 mm ≤ A1 작도영역. Co-Authored-By: Claude Opus 5 (1M context) --- .../B07_DesignDetail_Api_Fetch.ts | 2 + .../B07_DesignDetail_Engine_Cad_Standard.py | 581 ++++++++++++++++++ B07_DesignDetail/B07_DesignDetail_Router.py | 17 + .../B07_DesignDetail_Router_Support.py | 97 ++- B07_DesignDetail/B07_DesignDetail_Schema.py | 2 + .../B07_DesignDetail_UI_Panels.ts | 2 +- config/config_system.py | 4 + 7 files changed, 646 insertions(+), 59 deletions(-) create mode 100644 B07_DesignDetail/B07_DesignDetail_Engine_Cad_Standard.py diff --git a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts index b51b8f63..e842eae7 100644 --- a/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts +++ b/B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts @@ -14,6 +14,7 @@ export interface DesignDrawingItem { | "plan" | "landuse" | "plan_lidar" + | "cross_standard" | "blank"; label: string; chainage_m: number | null; @@ -101,6 +102,7 @@ export interface DesignDrawingResponse { | "plan" | "landuse" | "plan_lidar" + | "cross_standard" | "blank"; label: string; drawing: CadDrawing; diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Standard.py b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Standard.py new file mode 100644 index 00000000..ce03210c --- /dev/null +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Cad_Standard.py @@ -0,0 +1,581 @@ +"""B07 표준 횡단면도 CAD 조립 — 변수 모식도에 치수를 넣고, 측구 확대도·암반선 2단을 함께 낸다. + +사용자 지시(2026-09-04) — 「표준 횡단면도 좌상단에 기본값으로 B06 좌측 패널의 변수 위치 +안내와 비슷한 그림을 넣고, 변수 이름 자리에 도면처럼 치수를 적을 것. 측구는 작으니 부분 +확대도로. 발파·암반이면 암반선과 각도를 넣어 절토측이 2단(토사 각도 + 암반 각도)으로 +표현될 것」. + +배치는 B06 좌측 패널 모식도(`B06_Section_UI_Standard_Diagram.ts`)와 같다 — 좌가 절토·측구, +우가 성토, 가운데가 계획고. 다른 점은 **실치수**라는 것이다. 모식도는 위치 안내라 비율이 +없지만 도면은 축척(본 그림 1/50, 측구 확대도 1/10)대로 그리고 치수선을 붙인다. + +값은 B06 「표준 횡단면 설정」(`standard_cross_section`)을 그대로 읽는다 — 여기서 기하를 +다시 정하지 않는다. 저장값이 없으면 config 기본값을 쓴다. + +좌표 규약: 종이 mm = 실거리 m x MM. 원점은 계획고(노면 중심). +""" + +import math +from typing import Any + +from B07_DesignDetail.B07_DesignDetail_Engine_Cad import ( + DRAWING_FORMAT, + FRAME_LAYER_ID, + TABLE_LABEL_COLOR, + _layer, + _text_entity, + polyline_entity, +) +from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( + entities_bbox, + frame_entities, + scale_fields, +) +from config.config_system import ( + DRAWING_SCALE_CROSS_STANDARD, + DRAWING_SCALE_DITCH_DETAIL, + STANDARD_CROSS_SECTION, +) + +STANDARD_KIND = "cross_standard" +STANDARD_LABEL = "표준 횡단면도" + +# 도면 좌표 = 종이 mm. 본 그림 1/50 -> 1 m = 20 mm, 측구 확대도 1/10 -> 1 m = 100 mm. +MM = 1000.0 / DRAWING_SCALE_CROSS_STANDARD +DETAIL_MM = 1000.0 / DRAWING_SCALE_DITCH_DETAIL + +SECTION_LAYER_ID = "b07-std-section" +ROCK_LAYER_ID = "b07-std-rock" +DIM_LAYER_ID = "b07-std-dim" +DETAIL_LAYER_ID = "b07-std-detail" +NOTE_LAYER_ID = "b07-std-note" +TITLE_LAYER_ID = "b07-std-title" + +SECTION_COLOR = "#111111" +ROCK_COLOR = "#a63d3d" +DIM_COLOR = "#2f6fb0" +DETAIL_COLOR = "#111111" +NOTE_COLOR = "#333333" + +_LINE_WIDTH = 2 +_TITLE_FONT_SIZE = 7.0 +_LABEL_FONT_SIZE = 3.0 +_DIM_FONT_SIZE = 2.6 +_NOTE_FONT_SIZE = 2.8 + +# 그림에 세울 절·성토 높이(m) — 표준도는 실제 지형이 없으므로 대표 높이로 그린다. +_CUT_HEIGHT_M = 3.0 +_FILL_HEIGHT_M = 3.0 +# 암반 구간: 절토 밑에서 이만큼이 암반이고 그 위가 토사다(2단 절토). +_ROCK_HEIGHT_M = 1.5 + +_DIM_TICK_MM = 1.6 # 치수선 끝 눈금 반길이 +_DIM_OFFSET_MM = 8.0 # 치수선을 그림에서 띄우는 거리 +_DIM_GAP_MM = 6.0 # 치수선 단 사이 + + +def _ground(kind: str, standard: dict[str, Any] | None) -> dict[str, Any]: + """표준 횡단면 설정에서 한 지반유형 값을 꺼낸다. 없으면 config 기본값.""" + stored = (standard or {}).get(kind) + if isinstance(stored, dict) and stored: + merged = dict(STANDARD_CROSS_SECTION.get(kind) or {}) + merged.update(stored) + return merged + return dict(STANDARD_CROSS_SECTION.get(kind) or {}) + + +def _number(value: Any, fallback: float) -> float: + return float(value) if isinstance(value, (int, float)) else fallback + + +def _dim_entities( + drawing_id: str, + tag: str, + start: tuple[float, float], + end: tuple[float, float], + label: str, + layer_id: str = DIM_LAYER_ID, +) -> list[dict[str, Any]]: + """치수선 한 벌(치수선 + 양끝 눈금 + 치수값). 좌표는 종이 mm.""" + entities: list[dict[str, Any]] = [] + line = polyline_entity(drawing_id, [start, end], layer_id, DIM_COLOR, suffix=f":dim:{tag}") + if line: + entities.append(line) + dx, dy = end[0] - start[0], end[1] - start[1] + length = math.hypot(dx, dy) or 1.0 + nx, ny = -dy / length, dx / length + for index, point in enumerate((start, end)): + tick = polyline_entity( + drawing_id, + [ + (point[0] - nx * _DIM_TICK_MM, point[1] - ny * _DIM_TICK_MM), + (point[0] + nx * _DIM_TICK_MM, point[1] + ny * _DIM_TICK_MM), + ], + layer_id, + DIM_COLOR, + suffix=f":dim:{tag}:tick:{index}", + ) + if tick: + entities.append(tick) + entities.append( + _text_entity( + f"{drawing_id}:dim:{tag}:text", + label, + (start[0] + end[0]) / 2.0 + nx * 2.2, + (start[1] + end[1]) / 2.0 + ny * 2.2, + layer_id, + _DIM_FONT_SIZE, + DIM_COLOR, + ) + ) + return entities + + +def _section_geometry(values: dict[str, Any]) -> dict[str, Any]: + """표준 단면의 실좌표(m) 꼭짓점. 좌가 절토·측구, 우가 성토(B06 모식도와 같은 배치).""" + road = _number(values.get("road_width_m"), 3.0) + shoulder_left = _number(values.get("shoulder_left_m"), 0.5) + shoulder_right = _number(values.get("shoulder_right_m"), 0.5) + ditch = values.get("ditch") if isinstance(values.get("ditch"), dict) else {} + top_width = _number(ditch.get("top_width_m"), 0.9) + bottom_width = _number(ditch.get("bottom_width_m"), 0.3) + depth = _number(ditch.get("depth_m"), 0.3) + slope = values.get("cross_slope_pct") if isinstance(values.get("cross_slope_pct"), dict) else {} + cross_pct = _number(slope.get("max"), _number(slope.get("min"), 3.0)) + cut_ratio = _number(values.get("cut_slope_ratio"), 1.0) + fill_ratio = _number(values.get("fill_slope_ratio"), 1.2) + + road_left = -(road / 2.0 + shoulder_left) + road_right = road / 2.0 + shoulder_right + # 횡단경사는 측구(좌) 쪽으로 내려간다 — 노면 좌끝이 계획고보다 낮다. + drop = abs(road_left) * cross_pct / 100.0 + surface = [(road_right, 0.0), (road_left, -drop)] + + ditch_top_left = road_left - top_width + ditch_bottom_y = -drop - depth + inset = (top_width - bottom_width) / 2.0 + ditch_line = [ + (road_left, -drop), + (road_left - inset, ditch_bottom_y), + (ditch_top_left + inset, ditch_bottom_y), + (ditch_top_left, -drop), + ] + cut_top = (ditch_top_left - _CUT_HEIGHT_M * cut_ratio, -drop + _CUT_HEIGHT_M) + fill_toe = (road_right + _FILL_HEIGHT_M * fill_ratio, -_FILL_HEIGHT_M) + return { + "road": road, + "shoulder_left": shoulder_left, + "shoulder_right": shoulder_right, + "top_width": top_width, + "bottom_width": bottom_width, + "depth": depth, + "cross_pct": cross_pct, + "cut_ratio": cut_ratio, + "fill_ratio": fill_ratio, + "road_left": road_left, + "road_right": road_right, + "drop": drop, + "surface": surface, + "ditch_line": ditch_line, + "ditch_top_left": ditch_top_left, + "cut_start": (ditch_top_left, -drop), + "cut_top": cut_top, + "fill_toe": fill_toe, + } + + +def _rock_entities( + drawing_id: str, geometry: dict[str, Any], rock_ratio: float, paper: Any +) -> list[dict[str, Any]]: + """암반선과 2단 절토(아래=암반각, 위=토사각)를 절토측에 덧그린다.""" + entities: list[dict[str, Any]] = [] + start_x, start_y = geometry["cut_start"] + soil_ratio = geometry["cut_ratio"] + # 아래 단: 암반각으로 _ROCK_HEIGHT_M 만큼 올라간다. + bench = (start_x - _ROCK_HEIGHT_M * rock_ratio, start_y + _ROCK_HEIGHT_M) + # 위 단: 그 위는 토사각. + upper = ( + bench[0] - (_CUT_HEIGHT_M - _ROCK_HEIGHT_M) * soil_ratio, + bench[1] + (_CUT_HEIGHT_M - _ROCK_HEIGHT_M), + ) + two_stage = polyline_entity( + drawing_id, + [paper((start_x, start_y)), paper(bench), paper(upper)], + ROCK_LAYER_ID, + ROCK_COLOR, + suffix=":rock:cut", + width=_LINE_WIDTH, + ) + if two_stage: + entities.append(two_stage) + # 암반선 — 2단이 갈리는 높이의 수평 파선. + boundary = polyline_entity( + drawing_id, + [paper((bench[0] - 1.5, bench[1])), paper((geometry["road_right"], bench[1]))], + ROCK_LAYER_ID, + ROCK_COLOR, + suffix=":rock:boundary", + dash=[6, 4], + ) + if boundary: + entities.append(boundary) + label_x, label_y = paper((bench[0] - 1.6, bench[1])) + entities.append( + _text_entity( + f"{drawing_id}:rock:boundary:text", + "암반선", + label_x, + label_y + 2.5, + ROCK_LAYER_ID, + _LABEL_FONT_SIZE, + ROCK_COLOR, + align="right", + ) + ) + mid_lower = paper(((start_x + bench[0]) / 2.0, (start_y + bench[1]) / 2.0)) + mid_upper = paper(((bench[0] + upper[0]) / 2.0, (bench[1] + upper[1]) / 2.0)) + entities.append( + _text_entity( + f"{drawing_id}:rock:lower", + f"암반 1:{rock_ratio:g}", + mid_lower[0] - 6.0, + mid_lower[1], + ROCK_LAYER_ID, + _DIM_FONT_SIZE, + ROCK_COLOR, + align="right", + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:rock:upper", + f"토사 1:{soil_ratio:g}", + mid_upper[0] - 6.0, + mid_upper[1], + ROCK_LAYER_ID, + _DIM_FONT_SIZE, + ROCK_COLOR, + align="right", + ) + ) + return entities + + +def _ditch_detail_entities( + drawing_id: str, geometry: dict[str, Any], origin: tuple[float, float] +) -> list[dict[str, Any]]: + """측구 부분 확대도(1/10) — 작아서 본 그림에서는 치수를 읽을 수 없다.""" + entities: list[dict[str, Any]] = [] + top_width = geometry["top_width"] + bottom_width = geometry["bottom_width"] + depth = geometry["depth"] + inset = (top_width - bottom_width) / 2.0 + ox, oy = origin + + def paper(point: tuple[float, float]) -> tuple[float, float]: + return (ox + point[0] * DETAIL_MM, oy + point[1] * DETAIL_MM) + + shape = [ + (0.0, 0.0), + (inset, -depth), + (inset + bottom_width, -depth), + (top_width, 0.0), + ] + outline = polyline_entity( + drawing_id, + [paper(point) for point in shape], + DETAIL_LAYER_ID, + DETAIL_COLOR, + suffix=":detail:ditch", + width=_LINE_WIDTH, + ) + if outline: + entities.append(outline) + entities.extend( + _dim_entities( + drawing_id, + "detail-top", + paper((0.0, 0.0 + 0.06)), + paper((top_width, 0.0 + 0.06)), + f"{top_width * 1000:.0f}", + DETAIL_LAYER_ID, + ) + ) + entities.extend( + _dim_entities( + drawing_id, + "detail-bottom", + paper((inset, -depth - 0.06)), + paper((inset + bottom_width, -depth - 0.06)), + f"{bottom_width * 1000:.0f}", + DETAIL_LAYER_ID, + ) + ) + entities.extend( + _dim_entities( + drawing_id, + "detail-depth", + paper((top_width + 0.08, 0.0)), + paper((top_width + 0.08, -depth)), + f"{depth * 1000:.0f}", + DETAIL_LAYER_ID, + ) + ) + title = paper((top_width / 2.0, 0.3)) + entities.append( + _text_entity( + f"{drawing_id}:detail:title", + f"측구 상세도 (S = 1/{DRAWING_SCALE_DITCH_DETAIL})", + title[0], + title[1], + DETAIL_LAYER_ID, + _LABEL_FONT_SIZE, + TABLE_LABEL_COLOR, + ) + ) + return entities + + +def build_standard_cross_drawing( + drawing_id: str, label: str, standard: dict[str, Any] | None = None +) -> dict[str, Any]: + """표준 횡단면도 한 장을 만든다 — 본 그림 + 치수 + 측구 확대도 + 암반 2단 + 주기.""" + soil = _ground("soil", standard) + rock = _ground("rock", standard) + paved = _ground("paved", standard) + geometry = _section_geometry(soil) + + def paper(point: tuple[float, float]) -> tuple[float, float]: + return (point[0] * MM, point[1] * MM) + + entities: list[dict[str, Any]] = [] + # 본 그림: 절토면 - 측구 - 노면 - 성토면을 한 줄로 잇는다. + outline = [ + geometry["cut_top"], + *geometry["ditch_line"][::-1], + *geometry["surface"][::-1], + geometry["fill_toe"], + ] + body = polyline_entity( + drawing_id, + [paper(point) for point in outline], + SECTION_LAYER_ID, + SECTION_COLOR, + suffix=":section", + width=_LINE_WIDTH, + ) + if body: + entities.append(body) + # 중심선(계획고). + center = polyline_entity( + drawing_id, + [paper((0.0, 1.2)), paper((0.0, -1.2))], + SECTION_LAYER_ID, + SECTION_COLOR, + suffix=":center", + dash=[10, 3, 2, 3], + ) + if center: + entities.append(center) + entities.append( + _text_entity( + f"{drawing_id}:center:text", + "계획고", + *paper((0.0, 1.45)), + SECTION_LAYER_ID, + _LABEL_FONT_SIZE, + SECTION_COLOR, + ) + ) + + # 치수선 — 노면 아래 두 단(위: 노견·노폭·노견, 아래: 노면 전폭). + base_y = min(geometry["fill_toe"][1], -geometry["drop"] - geometry["depth"]) + dim_y = base_y * MM - _DIM_OFFSET_MM + half = geometry["road"] / 2.0 + entities.extend( + _dim_entities( + drawing_id, + "shoulder-left", + (geometry["road_left"] * MM, dim_y), + (-half * MM, dim_y), + f"{geometry['shoulder_left'] * 1000:.0f}", + ) + ) + entities.extend( + _dim_entities( + drawing_id, + "road", + (-half * MM, dim_y), + (half * MM, dim_y), + f"{geometry['road'] * 1000:.0f}", + ) + ) + entities.extend( + _dim_entities( + drawing_id, + "shoulder-right", + (half * MM, dim_y), + (geometry["road_right"] * MM, dim_y), + f"{geometry['shoulder_right'] * 1000:.0f}", + ) + ) + entities.extend( + _dim_entities( + drawing_id, + "ditch-top", + (geometry["ditch_top_left"] * MM, dim_y), + (geometry["road_left"] * MM, dim_y), + f"{geometry['top_width'] * 1000:.0f}", + ) + ) + roadbed_width_m = geometry["road"] + geometry["shoulder_left"] + geometry["shoulder_right"] + entities.extend( + _dim_entities( + drawing_id, + "roadbed", + (geometry["road_left"] * MM, dim_y - _DIM_GAP_MM), + (geometry["road_right"] * MM, dim_y - _DIM_GAP_MM), + f"{roadbed_width_m * 1000:.0f}", + ) + ) + + # 경사·횡단경사 표기. + cut_mid = paper( + ( + (geometry["cut_start"][0] + geometry["cut_top"][0]) / 2.0, + (geometry["cut_start"][1] + geometry["cut_top"][1]) / 2.0, + ) + ) + fill_mid = paper( + ( + (geometry["road_right"] + geometry["fill_toe"][0]) / 2.0, + (0.0 + geometry["fill_toe"][1]) / 2.0, + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:cut:text", + f"절토 1:{geometry['cut_ratio']:g}", + cut_mid[0] - 4.0, + cut_mid[1] + 3.0, + SECTION_LAYER_ID, + _DIM_FONT_SIZE, + SECTION_COLOR, + align="right", + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:fill:text", + f"성토 1:{geometry['fill_ratio']:g}", + fill_mid[0] + 4.0, + fill_mid[1] + 3.0, + SECTION_LAYER_ID, + _DIM_FONT_SIZE, + SECTION_COLOR, + align="left", + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:cross-slope:text", + f"횡단경사 {geometry['cross_pct']:g}%", + *paper((geometry["road_left"] / 2.0, 0.6)), + SECTION_LAYER_ID, + _DIM_FONT_SIZE, + SECTION_COLOR, + ) + ) + + # 암반 구간 2단 절토. + entities.extend( + _rock_entities(drawing_id, geometry, _number(rock.get("cut_slope_ratio"), 0.4), paper) + ) + + body_bbox = entities_bbox(entities) + right = body_bbox[2] if body_bbox else 0.0 + top = body_bbox[3] if body_bbox else 0.0 + + # 측구 부분 확대도 — 본 그림 오른쪽 위. + entities.extend(_ditch_detail_entities(drawing_id, geometry, (right + 28.0, top - 30.0))) + + # 주기: 구간별로 달라지는 값만 적는다(기본은 토사). + notes = [ + "※ 본 그림은 토사 구간 기준임.", + f"※ 암 구간 — 절토 1:{_number(rock.get('cut_slope_ratio'), 0.4):g}, " + f"L형 측구 {_number((rock.get('ditch_l_type') or {}).get('width_m'), 0.5) * 1000:.0f}" + f"×{_number((rock.get('ditch_l_type') or {}).get('depth_m'), 0.1) * 1000:.0f}mm " + "(횡단면도에서 일반·L형 중 선택).", + f"※ 포장 구간 — 절·성토 경사는 토사와 같고 횡단경사만 " + f"{_number((paved.get('cross_slope_pct') or {}).get('min'), 1.5):g}~" + f"{_number((paved.get('cross_slope_pct') or {}).get('max'), 2.0):g}% 임.", + "※ 치수 단위 mm.", + ] + note_bbox = entities_bbox(entities) + note_x = note_bbox[0] if note_bbox else 0.0 + note_y = (note_bbox[1] if note_bbox else 0.0) - 12.0 + for index, note in enumerate(notes): + entities.append( + _text_entity( + f"{drawing_id}:note:{index}", + note, + note_x, + note_y - index * 5.0, + NOTE_LAYER_ID, + _NOTE_FONT_SIZE, + NOTE_COLOR, + align="left", + ) + ) + + bbox = entities_bbox(entities) + if bbox: + min_bx, _min_by, max_bx, max_by = bbox + entities.append( + _text_entity( + f"{drawing_id}:title", + label, + (min_bx + max_bx) / 2.0, + max_by + 12.0, + TITLE_LAYER_ID, + _TITLE_FONT_SIZE, + TABLE_LABEL_COLOR, + ) + ) + entities.append( + _text_entity( + f"{drawing_id}:scale", + f"S = 1/{DRAWING_SCALE_CROSS_STANDARD}", + max_bx, + max_by + 5.0, + TITLE_LAYER_ID, + _DIM_FONT_SIZE, + TABLE_LABEL_COLOR, + align="right", + ) + ) + entities.extend( + frame_entities( + drawing_id, + entities_bbox(entities) or bbox, + fit=False, + fields={ + "도면명": label, + **scale_fields(("", DRAWING_SCALE_CROSS_STANDARD)), + }, + ) + ) + + return { + "format": DRAWING_FORMAT, + "entities": entities, + "layers": [ + _layer(SECTION_LAYER_ID, "표준 단면"), + _layer(ROCK_LAYER_ID, "암반선·2단 절토"), + _layer(DIM_LAYER_ID, "치수"), + _layer(DETAIL_LAYER_ID, "측구 상세도"), + _layer(NOTE_LAYER_ID, "주기"), + _layer(TITLE_LAYER_ID, "표제"), + _layer(FRAME_LAYER_ID, "도각", locked=True), + ], + } diff --git a/B07_DesignDetail/B07_DesignDetail_Router.py b/B07_DesignDetail/B07_DesignDetail_Router.py index 5cd8a010..f4bb7d50 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router.py +++ b/B07_DesignDetail/B07_DesignDetail_Router.py @@ -17,6 +17,7 @@ from B06_Section.B06_Section_Repository import ( get_cross_section_design, get_cross_section_designs, get_longitudinal_section, + get_project_standard_cross_section, merge_cross_section_design_by_round, ) from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import ( @@ -34,6 +35,7 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Template import ( use_title_fields, ) from B07_DesignDetail.B07_DesignDetail_Router_Support import ( + CROSS_STANDARD_ID, LANDUSE_ID, LIDAR_ID, MASS_HAUL_ID, @@ -307,6 +309,21 @@ async def get_design_drawing( if context is None: return JSONResponse(status_code=404, content={"status": "error", "message": reason}) source_design = await asyncio.to_thread(watershed_source, context) + elif drawing_id == CROSS_STANDARD_ID: + # 표준 횡단면도는 B06 「표준 횡단면 설정」 저장값으로 그린다(없으면 config 기본값). + pool = get_db_pool() + async with pool.acquire() as connection: + async with connection.cursor() as cursor: + await cursor.execute( + "SELECT company_id FROM projects WHERE id = %s AND deleted_at IS NULL", + (str(project_id),), + ) + row = await cursor.fetchone() + source_design = ( + await get_project_standard_cross_section(connection, int(row[0]), project_id) + if row + else None + ) elif LIDAR_ID.fullmatch(drawing_id): # 라이다 계획평면도는 확정 DTM 격자로 음영기복 그림을 만들어 넘긴다. context, reason = await load_drainage_context(project_id) diff --git a/B07_DesignDetail/B07_DesignDetail_Router_Support.py b/B07_DesignDetail/B07_DesignDetail_Router_Support.py index 93936c4f..76e1627c 100644 --- a/B07_DesignDetail/B07_DesignDetail_Router_Support.py +++ b/B07_DesignDetail/B07_DesignDetail_Router_Support.py @@ -47,66 +47,36 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Sheet import ( plan_cross_sheets, section_block_size, ) +from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Standard import ( + STANDARD_LABEL, + build_standard_cross_drawing, +) from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Table import ( QUANTITY_VALUE_KEYS, ) from B07_DesignDetail.B07_DesignDetail_Engine_Template import add_title_fields -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _BASIN_MAX_DISTANCE_M as _BASIN_MAX_DISTANCE_M, -) # 유역도 배경·파일 입출력 조각은 700줄 제한으로 떼어냈다(2026-09-04). # 여기서 그대로 다시 내보내 호출부(`B07_DesignDetail_Router.py`)의 import 경로는 불변이다. -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - CONTOUR_FILE as CONTOUR_FILE, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - LANDUSE_ID as LANDUSE_ID, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - LIDAR_ID as LIDAR_ID, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - PLAN_ID as PLAN_ID, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - STREAM_FILE as STREAM_FILE, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _basins_crs as _basins_crs, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _clip_segment as _clip_segment, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _geojson_features as _geojson_features, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _geojson_payload as _geojson_payload, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _geometry_lines as _geometry_lines, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - _too_far_from_route as _too_far_from_route, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - clip_line_to_box as clip_line_to_box, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - landuse_source as landuse_source, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - lidar_source as lidar_source, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - plan_source as plan_source, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - plan_stations as plan_stations, -) -from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( - watershed_source as watershed_source, +from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import ( # noqa: F401 + _BASIN_MAX_DISTANCE_M, + CONTOUR_FILE, + LANDUSE_ID, + LIDAR_ID, + PLAN_ID, + STREAM_FILE, + _basins_crs, + _clip_segment, + _geojson_features, + _geojson_payload, + _geometry_lines, + _too_far_from_route, + clip_line_to_box, + landuse_source, + lidar_source, + plan_source, + plan_stations, + watershed_source, ) from B07_DesignDetail.B07_DesignDetail_Router_Support_Io import ( _cross_files, @@ -132,13 +102,12 @@ _LONG_ID = re.compile(r"^longitudinal(?:_(\d+))?$") MASS_HAUL_ID = "mass_haul" WATERSHED_ID = "watershed" COVER_ID = "cover" +# 표준 횡단면도 — 노선 자료가 아니라 B06 표준 횡단면 설정값으로 그리는 한 장. +CROSS_STANDARD_ID = "cross_standard" # 아직 내용을 만들지 않은 도면 — 도각만 실어 연다(2026-09-01 사용자 지시). # 화면 순서(DRAWING_GROUPS)와 같은 이름을 쓴다. -BLANK_DRAWINGS: tuple[tuple[str, str], ...] = ( - ("blank_cross_standard", "표준 횡단면도"), - ("blank_standard", "표준도"), -) +BLANK_DRAWINGS: tuple[tuple[str, str], ...] = (("blank_standard", "표준도"),) BLANK_LABELS: dict[str, str] = dict(BLANK_DRAWINGS) @@ -224,6 +193,7 @@ def _drawing_list( # 노선 전장 1장짜리 도면 — 자료가 없으면 여는 시점에 404로 알린다(목록에는 항상 둔다). for drawing_id, kind, label in ( (COVER_ID, "cover", "표지"), + (CROSS_STANDARD_ID, "cross_standard", STANDARD_LABEL), (MASS_HAUL_ID, "mass_haul", "토적도(유토곡선)"), (WATERSHED_ID, "watershed", "유역도(배수 유역도)"), ): @@ -449,7 +419,7 @@ def _read_drawing( # 포맷 버전이 다르면(테이블·레이어 구성 변경 전 저장본) 캐시를 버리고 # 아래에서 원본 기준으로 재생성한다. 확정 상태도 무효로 응답해 재확정 유도. if saved.get("format") == DRAWING_FORMAT: - if drawing_id in (COVER_ID, MASS_HAUL_ID, WATERSHED_ID): + if drawing_id in (COVER_ID, MASS_HAUL_ID, WATERSHED_ID, CROSS_STANDARD_ID): kind = drawing_id # id와 kind가 같은 단장 도면 elif PLAN_ID.fullmatch(drawing_id): kind = "plan" @@ -485,6 +455,17 @@ def _read_drawing( None, ) + if drawing_id == CROSS_STANDARD_ID: + # stored_design = B06 표준 횡단면 설정값(라우터가 실어 준다). 없으면 config 기본값. + standard = stored_design if isinstance(stored_design, dict) else None + return ( + "cross_standard", + STANDARD_LABEL, + build_standard_cross_drawing(drawing_id, STANDARD_LABEL, standard), + False, + None, + ) + if LIDAR_ID.fullmatch(drawing_id): # stored_design = lidar_source()가 만든 노선 + 지표면 음영기복 그림. if not isinstance(stored_design, dict): diff --git a/B07_DesignDetail/B07_DesignDetail_Schema.py b/B07_DesignDetail/B07_DesignDetail_Schema.py index dbe92954..53abb805 100644 --- a/B07_DesignDetail/B07_DesignDetail_Schema.py +++ b/B07_DesignDetail/B07_DesignDetail_Schema.py @@ -19,6 +19,7 @@ class DesignDrawingItem(BaseModel): "plan", "landuse", "plan_lidar", + "cross_standard", "blank", ] label: str @@ -52,6 +53,7 @@ class DesignDrawingResponse(BaseModel): "plan", "landuse", "plan_lidar", + "cross_standard", "blank", ] label: str diff --git a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts index 2eab42c6..8de0f675 100644 --- a/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts +++ b/B07_DesignDetail/B07_DesignDetail_UI_Panels.ts @@ -36,7 +36,7 @@ export const DRAWING_GROUPS: readonly { { label: "계획평면도(배치도)", idPrefix: "plan_layout" }, { label: "계획평면도(라이다)", idPrefix: "plan_lidar" }, { label: "종단면도", kind: "longitudinal" }, - { label: "표준 횡단면도", blankId: "blank_cross_standard" }, + { label: "표준 횡단면도", kind: "cross_standard" }, { label: "횡단면도", kind: "cross" }, { label: "토적도(유토곡선)", kind: "mass_haul" }, { label: "유역도(배수 유역도)", kind: "watershed" }, diff --git a/config/config_system.py b/config/config_system.py index de4780e4..701e782e 100644 --- a/config/config_system.py +++ b/config/config_system.py @@ -178,6 +178,10 @@ DRAWING_SCALE_BASIN = 6000 # 유역도 평면 축척 분모 (실거리 1 m = 1/ # 계획평면도·용지도 평면 축척 분모 — 지식DB 「설계제원_총괄」 측량·도면 기준 1/1,200. # 횡단면도와 같은 원칙: 축척은 줄이지 않고, 한 장에 안 들어가면 **장을 나눈다**. DRAWING_SCALE_PLAN = 1200 +# 표준 횡단면도 — 상세도라 지식DB에 지정 축척이 없다. 본 그림 1/50, 측구 부분확대도 +# 1/10 (2026-09-04). 노폭 4 m 기준 본 그림이 A1 작도영역에 여유 있게 든다. +DRAWING_SCALE_CROSS_STANDARD = 50 +DRAWING_SCALE_DITCH_DETAIL = 10 # 시스템 리소스 로그 (루트 log 폴더에 단일 파일, 1개월 보관) LOG_BASE_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "log")