Merge remote-tracking branch 'origin/sub_laptop_8' into sub_laptop_5

D03_PlanAnalysis/D03_PlanAnalysis_UI_3D.ts

@@ -1,25 +1,47 @@
 /* =============================================================================
  * D03_PlanAnalysis_UI_3D.ts
- * D03 [3D] 큰 모달(PLAN 530-3 · 563-1) — 사업 전체 DEM + 그은 선 하나(지반에 붙임) + 측점 막대.
- *   선 고름 = 모달 위 칸(본선 · 갈래) · 뷰어 = B05 `createRouteViewer` 그대로 · 닫으면 버림(WebGL 문맥까지).
- *   예상 코리도 없음(꺾은선 · 계획고 = 지반고라 절성토 0 — 요구서 389 3장 11).
+ * D03 [3D] 큰 모달(PLAN 530-3 · 563-1 · 601-3 · 요구 463-21) — 사업 전체 DEM + 노선망 전체(본선 · 갈래) 한 번에.
+ *   선마다 예상 코리도 = 측점 예상 단면(`logic/D03_PlanAnalysis_Expect` · 리핑암 · 산쪽 절토 · 일반 측구 ·
+ *   계획고 = 지반고) → B05 `buildCorridor` → 뷰어 `setCorridors`(벌마다 노면 · 지형 잘림 한 번) ·
+ *   갈래 머리 = 부모 노면만큼 잘라 냄 · 뷰어 = B05 `createRouteViewer` · 닫으면 버림(WebGL 문맥까지) · 보기만(저장 없음).
  * ========================================================================== */
 
 import "../B05_Profile/B05_Profile_UI_Style.css";
-import { createSelectField } from "@ui/ui_template_input";
 import { openModal } from "@ui/ui_template_modal";
 import { createProgressCircle } from "@ui/ui_template_progress";
 import { showToast } from "@ui/ui_template_elements";
 import type { DtmGrid } from "../common_util/common_util_surface_sampler";
 import { createRouteViewer, type RouteViewer } from "../B05_Profile/B05_Profile_UI_Viewer";
 import { sectionsGround } from "../B05_Profile/logic/B05_Profile_Sections_Ground";
+import { buildCorridor } from "../B05_Profile/logic/B05_Profile_Corridor_Build";
+import type { CorridorBuildResult } from "../B05_Profile/logic/B05_Profile_Corridor_Build";
+import type { SectionStationMarker } from "../B05_Profile/B05_Profile_UI_Markers";
+import { fetchSectionContext } from "../B06_Section/B06_Section_Api_Context";
+import type { CrossSection } from "../B06_Section/B06_Section_Api_Types";
 import type { Vertex } from "./logic/D03_PlanAnalysis_Plan";
+import {
+  branchTrimM,
+  expectLine,
+  expectSections,
+  type ExpectStandard,
+} from "./logic/D03_PlanAnalysis_Expect";
 
 export interface Plan3dLine {
   name: string;
   line: Vertex[];
-  /** 선 위 측점 누가(선마다 No.0 부터). */
-  stations: number[];
+  /** 갈래(다른 선에 붙은 선) — 머리를 부모 노면만큼 잘라 지음. */
+  branch: boolean;
+}
+
+/** 표준 횡단 기본값(config · 서버) — 못 받으면 null(선만). */
+function loadExpectStandard(projectId: string): Promise<ExpectStandard | null> {
+  return fetchSectionContext(projectId).then(
+    (context) => ({
+      standard: context.standard_cross_section as ExpectStandard["standard"],
+      rockBoundaryM: context.rock_boundary_default_offset_m,
+    }),
+    () => null,
+  );
 }
 
 /** 격자 → 뷰어 상자(지형에 붙는 선 · 막대는 높이 원점과 무관 · x · y 만 메시와 맞으면 됨). */
@@ -46,58 +68,84 @@ export function openPlan3d(
   projectId: string,
   surface: { modelId: number; grid: DtmGrid },
   lines: Plan3dLine[],
+  intervalM: number,
 ): void {
   if (!lines.length) return void showToast("3D 로 볼 선이 없습니다.", "warning");
   let viewer: RouteViewer | null = createRouteViewer();
-  let loaded = false;
-  const pick = createSelectField({
-    options: lines.map((item, i) => ({ value: String(i), text: item.name })),
-    value: "0",
-    size: 28,
-    ariaLabel: "선",
-  }).select;
-  pick.classList.add("d03-plan__3d-year");
-  const top = document.createElement("div");
-  top.className = "d03-plan__3d-top";
-  top.append(pick);
+  const standard = loadExpectStandard(projectId);
 
-  const load = async (index: number): Promise<void> => {
-    const item = lines[index] ?? lines[0];
+  const load = async (): Promise<void> => {
     if (!viewer) return;
     const progress = createProgressCircle({ label: "3D 지형을 불러오는 중…", overlay: true });
     progress.set(null);
     viewer.root.append(progress.root);
     const started = performance.now();
-    const stat: Record<string, unknown> = { line: item.name, done: false };
+    const stat: Record<string, unknown> = { lines: lines.length, done: false };
     (window as unknown as { __d03Plan3d?: unknown }).__d03Plan3d = stat;
     try {
-      if (!loaded) {
-        await viewer.loadSurface(
-          projectId,
-          surface.modelId,
-          "dtm",
-          true,
-          5,
-          gridBounds(surface.grid),
-        );
-        loaded = true;
-      }
+      const [std] = await Promise.all([
+        standard,
+        viewer.loadSurface(projectId, surface.modelId, "dtm", true, 5, gridBounds(surface.grid)),
+      ]);
       if (!viewer) return;
-      viewer.markers.renderRoute(item.line.map(([x, y]) => ({ x, y })));
-      const ground = sectionsGround(item.line, item.stations, surface.grid);
-      viewer.renderStationLines(
-        ground.stations.map((station, i) => ({
-          station_id: String(item.stations[i] ?? station.chainage_m),
-          center_x: station.center_x,
-          center_y: station.center_y,
-          center_z: station.center_z,
-          frame: { left_xy: station.left_xy },
-          kind: "regular",
-          chainage_m: item.stations[i] ?? station.chainage_m,
-        })),
-        2.5,
-      );
-      stat.stations = ground.stations.length;
+      stat.surfaceMs = Math.round(performance.now() - started);
+      viewer.markers.renderRoutes(lines.map((item) => item.line.map(([x, y]) => ({ x, y }))));
+      const built = performance.now();
+      const trim = std ? branchTrimM(std) : 0;
+      const markers: SectionStationMarker[] = [];
+      const builds: CorridorBuildResult[] = [];
+      const perLine: Array<Record<string, unknown>> = [];
+      lines.forEach((item, index) => {
+        const plan = expectLine(item.line, item.branch ? trim : 0, intervalM);
+        if (!plan) return;
+        const ground = sectionsGround(plan.line, plan.stations, surface.grid);
+        ground.stations.forEach((station, i) => {
+          const chainage = (plan.stations[i] ?? station.chainage_m) + plan.offsetM;
+          markers.push({
+            station_id: `${index}:${chainage}`,
+            center_x: station.center_x,
+            center_y: station.center_y,
+            center_z: station.center_z,
+            frame: { left_xy: station.left_xy },
+            kind: "regular",
+            chainage_m: chainage,
+          });
+        });
+        if (!std) return;
+        const sections = expectSections(
+          ground.stations,
+          std,
+          surface.grid,
+        ) as unknown as CrossSection[];
+        const build = buildCorridor(
+          sections,
+          plan.line.map(([x, y]) => ({ x, y })),
+        );
+        if (build) {
+          build.sections = sections; // 지형 잘림이 읽음
+          builds.push(build);
+        }
+        perLine.push({
+          name: item.name,
+          branch: item.branch,
+          offsetM: plan.offsetM,
+          sections: sections.length,
+          corridor: !!build,
+          // 노면 중심(설계선 오프셋 0) − 측점 지반고
+          centerDelta: sections.map((c) =>
+            c.center_z === null ? null : (c.design?.design_elevation_m ?? NaN) - c.center_z,
+          ),
+        });
+      });
+      viewer.renderStationLines(markers, 2.5);
+      viewer.setCorridors(builds);
+      Object.assign(stat, {
+        trimM: trim,
+        corridors: builds.length,
+        stations: markers.length,
+        buildMs: Math.round(performance.now() - built),
+        perLine,
+      });
       viewer.setView("iso");
     } catch (error) {
       showToast(error instanceof Error ? error.message : "3D 지형을 불러오지 못했습니다.", "error");
@@ -107,16 +155,15 @@ export function openPlan3d(
       progress.remove();
     }
   };
-  pick.addEventListener("change", () => void load(Number(pick.value)));
 
   openModal({
-    title: "3D 보기 — 지형 + 그은 선",
+    title: "3D 보기 — 지형 + 노선망(표준 횡단)",
     closeLabel: "닫기",
     wide: true,
     dialogClass: "d03-plan__3d-modal",
     mount: (body) => {
       body.classList.add("d03-plan__3d-body");
-      body.append(top, viewer!.root);
+      body.append(viewer!.root);
       viewer!.setActive(true);
     },
     beforeClose: () => {
@@ -125,5 +172,5 @@ export function openPlan3d(
       return true;
     },
   });
-  void load(0);
+  void load();
 }

D03_PlanAnalysis/D03_PlanAnalysis_UI_Page.ts

@@ -59,7 +59,6 @@ import { createPlanMenu } from "./D03_PlanAnalysis_UI_Menu";
 import { createPlanPoints } from "./D03_PlanAnalysis_UI_Points";
 import { createPlanPieces } from "./D03_PlanAnalysis_UI_Pieces";
 import { createPlanProps } from "./D03_PlanAnalysis_UI_Props";
-import { lineLength, stationChainages } from "./logic/D03_PlanAnalysis_Draw";
 import {
   emptyNetwork,
   fromServer,
@@ -519,10 +518,10 @@ export async function renderD03PlanAnalysis(root: HTMLElement): Promise<void> {
       .map((line, index) => ({
         name: names[index],
         line: line.vertices,
-        stations: stationChainages(lineLength(line.vertices), PLAN_STATION_INTERVAL_M),
+        branch: line.branch !== null,
       }))
       .filter((item) => item.line.length > 1);
-    openPlan3d(projectId, surface, lines);
+    openPlan3d(projectId, surface, lines, PLAN_STATION_INTERVAL_M);
   }
 
   // 검증 창구 — 꼴 · 미리보기 · 제약 · 화면 자리 · 재기 · 회전 · 저장 시간(ORCA 판정)

D03_PlanAnalysis/logic/D03_PlanAnalysis_Expect.ts

@@ -0,0 +1,162 @@
+/* =============================================================================
+ * D03_PlanAnalysis_Expect.ts
+ * D03 예상 횡단(PLAN 544-1 · 601-1 · 요구 363-1 · 463-21) — 측점 지반 → 표준 횡단 기본값 설계선 · 절 · 성토 ㎡.
+ *   셈 = 공용 `computeCrossDesign`(① 짝 `compute_cross_design` · 거울 `test_b06_cross_design_mirror.py`)
+ *   · 기본 = B 초기 설계와 같음(리핑암 · 산쪽 절토 · 일반 측구 · 암 경계 = 서버 기본) · 계획고 = 측점 중심 지반고
+ *   · 미교차 = `extendUnclosed`(격자 있을 때) · 곡선 확폭 없음 · 보기만(저장 없음).
+ *   3D = 같은 단면을 B05 `buildCorridor` 가 읽는 측점 꼴로(`expectSections`) · 노선망 전체 = 선마다(`expectLine`) ·
+ *   갈래 머리 = 부모 노면(차도 반 + 노견)만큼 잘라 냄(두 노면 겹침 막음).
+ *   시험 `resources/tester/test_544_1_plan_expect.py`.
+ * ========================================================================== */
+
+import {
+  computeCrossDesign,
+  type CrossDesignOptions,
+  type CrossDesignResult,
+  type StandardCrossSectionSpec,
+} from "../../common_util/common_util_cross_design";
+import type { DtmGrid } from "../../common_util/common_util_surface_sampler";
+import {
+  extendUnclosed,
+  type CrossGroundPoint,
+  type StationGround,
+} from "../../B05_Profile/logic/B05_Profile_Sections_Ground";
+import { lineLength, sliceLine, stationChainages, type Vertex } from "./D03_PlanAnalysis_Draw";
+
+/** 서버 `sections/context` 의 표준 횡단(config) · 암 경계 기본 오프셋. */
+export interface ExpectStandard {
+  standard: StandardCrossSectionSpec;
+  rockBoundaryM: number | null;
+}
+
+export interface ExpectCross {
+  design: CrossDesignResult;
+  /** 설계에 쓴 지반 표본(미교차로 넓혔으면 넓힌 것). */
+  samples: CrossGroundPoint[];
+}
+
+/** B 초기 설계 기본 — 리핑암 · 산쪽 절토(모르면 좌) · 일반 측구. */
+export function expectOptions(
+  uphill: "left" | "right" | null,
+  std: ExpectStandard,
+): CrossDesignOptions {
+  return {
+    groundType: "ripping_rock",
+    sectionMode: `${uphill ?? "left"}_cut`,
+    ditchType: "standard",
+    standard: std.standard,
+    rockBoundaryOffsetM: std.rockBoundaryM,
+  };
+}
+
+/** 측점 하나 예상 단면 — 지반고 · 표본이 없으면 null. */
+export function expectCross(
+  station: StationGround,
+  std: ExpectStandard,
+  grid?: DtmGrid | null,
+): ExpectCross | null {
+  const elevation = station.center_z;
+  if (elevation === null) return null;
+  const options = expectOptions(station.uphill_side, std);
+  try {
+    let samples = station.samples;
+    let design = computeCrossDesign(samples, elevation, options);
+    const wide =
+      design.slope_unclosed && grid
+        ? extendUnclosed(
+            samples,
+            [station.center_x, station.center_y],
+            station.left_xy,
+            (next) => computeCrossDesign(next, elevation, options),
+            grid,
+          )
+        : null;
+    if (wide) {
+      samples = wide.samples as CrossGroundPoint[];
+      design = computeCrossDesign(samples, elevation, options);
+    }
+    return { design, samples };
+  } catch {
+    return null; // 표본 부족 — B 와 같은 태도(그 측점 건너뜀)
+  }
+}
+
+/** B06 `CrossSection` 중 `buildCorridor` 가 읽는 칸(B06 형 파일은 별칭 import 라 여기 안 끌어옴). */
+export interface ExpectSection {
+  station_id: string;
+  chainage_m: number;
+  label: string;
+  kind: "regular";
+  center_z: number | null;
+  azimuth_deg: null;
+  center_x: number;
+  center_y: number;
+  uphill_side: "left" | "right" | null;
+  frame: { left_xy: [number, number] };
+  samples: CrossGroundPoint[];
+  design: CrossDesignResult;
+}
+
+/** 3D 코리도 입력 — 측점마다 예상 단면(못 세운 측점 뺌) · 누가 = 연도 노선 위 누가. */
+export function expectSections(
+  stations: StationGround[],
+  std: ExpectStandard,
+  grid?: DtmGrid | null,
+): ExpectSection[] {
+  return stations.flatMap((station) => {
+    const cross = expectCross(station, std, grid);
+    if (!cross) return [];
+    return [
+      {
+        station_id: String(station.chainage_m),
+        chainage_m: station.chainage_m,
+        label: "",
+        kind: "regular",
+        center_z: station.center_z,
+        azimuth_deg: null,
+        center_x: station.center_x,
+        center_y: station.center_y,
+        uphill_side: station.uphill_side,
+        frame: { left_xy: station.left_xy },
+        samples: cross.samples,
+        design: cross.design,
+      },
+    ];
+  });
+}
+
+/** 갈래 머리 잘라 낼 길이(m) — 리핑암 표준 차도 반 + 넓은 노견(부모 노면 안). */
+export function branchTrimM(std: ExpectStandard): number {
+  const rock = std.standard.rock;
+  if (!rock) return 0;
+  return (
+    (rock.road_width_m ?? 0) / 2 + Math.max(rock.shoulder_left_m ?? 0, rock.shoulder_right_m ?? 0)
+  );
+}
+
+/** 3D 한 선 — 그릴 꺾은선 · 그 위 측점(꺾은선 첫 점 = 0) · 원래 누가 = 측점 + `offsetM`. */
+export interface ExpectLine {
+  line: Vertex[];
+  offsetM: number;
+  stations: number[];
+}
+
+/** 선 하나 3D 입력 — 측점 = 원래 누가(`intervalM`) · `trimM` > 0(갈래)이면 머리를 잘라 낸 자리부터.
+ *  남는 길이가 1 m 안 되면 null. */
+export function expectLine(
+  vertices: ReadonlyArray<Vertex>,
+  trimM: number,
+  intervalM: number,
+): ExpectLine | null {
+  const length = lineLength(vertices);
+  const offsetM = Math.max(0, trimM);
+  if (vertices.length < 2 || length - offsetM < 1) return null;
+  const line = offsetM > 0 ? sliceLine(vertices, offsetM, length) : [...vertices];
+  const stations = [
+    0,
+    ...stationChainages(length, intervalM)
+      .filter((m) => m > offsetM + 1e-6)
+      .map((m) => m - offsetM),
+  ];
+  return { line, offsetM, stations };
+}