diff --git a/A00_Common/design/design_page.ts b/A00_Common/design/design_page.ts index a99cb8563..d282918c5 100644 --- a/A00_Common/design/design_page.ts +++ b/A00_Common/design/design_page.ts @@ -33,7 +33,7 @@ import { guardDesignLeave } from "./design_leave"; import { usePipeIds } from "./design_pipe_ids"; import { pinDraftProject } from "./design_store"; import { setRouteShiftOpener } from "../../B06_Section/B06_Section_UI_Cross_Center"; -import { reconcilePagePipeline } from "./design_pipeline_page"; +import { pipelineDetail, reconcilePagePipeline } from "./design_pipeline_page"; import { forgetPageData, onPageBusy } from "./design_page_data"; import { pageRouteId } from "./design_page_route"; import { setPipeSectionsSource } from "./design_structure_pipe_calc"; @@ -116,9 +116,12 @@ export function renderDesignPage(root: HTMLElement): MountedPage { const projectId = localStorage.getItem(CURRENT_PROJECT_ID_KEY) ?? ""; pinDraftProject(projectId); // 연 프로젝트 고정(388-3) — 다른 탭이 바꿔도 이 탭 초안 칸 그대로 usePipeIds(projectId || null); // 관 세션 id 장부 = 이 프로젝트(323-5 · 카드 · 알약 · 종단 · 3D 같은 id) - // 관 길이 · 흙막이 개수 = 공용 캐시(페이지 노선) 한 벌 — 마지막 연 보기의 사본이 아님(416 · B05 = B06) + // 관 길이 · 흙막이 개수 = 공용 캐시(페이지 노선) 한 벌 — 마지막 연 보기의 사본이 아님(416 · B05 = B06) · + // 노선 초안 동안 = 계산 줄 새 노선 상세(다시 센 횡단 · 428) setPipeSectionsSource( - () => peekSectionDetail(projectId, pageRouteId(projectId))?.cross_sections ?? null, + () => + (pipelineDetail(projectId) ?? peekSectionDetail(projectId, pageRouteId(projectId))) + ?.cross_sections ?? null, ); // 한 벌 틀 — 좌측 자리 · 가운데(위 칸 + 아래 종단도). 진행 단계 틀은 단계 상태가 오면 감싼다. diff --git a/B04_PreProcess/B04_PreProcess_Router_Basins.py b/B04_PreProcess/B04_PreProcess_Router_Basins.py index d4a6f9726..034f0e7da 100644 --- a/B04_PreProcess/B04_PreProcess_Router_Basins.py +++ b/B04_PreProcess/B04_PreProcess_Router_Basins.py @@ -366,6 +366,9 @@ def _raw_payload( **point.as_dict(), "chainage_m": round(pipe.chainage_m, 2), "lonlat": list(to_lonlat(pipe.x, pipe.y)), + # 노선 위 자리(사업지 CRS) — 화면이 따라가기만 한 관을 가림(rebasePipeDraft · 428) + "x": round(float(pipe.x), 3), + "y": round(float(pipe.y), 3), "source": pipe.reason, } for pipe, point in zip(detail.pipes, points) @@ -568,6 +571,20 @@ async def delete_pipe_points(project_id: UUID) -> dict[str, Any] | JSONResponse: return _payload(project_id, context, detail, points, False, stale) +async def _stand_pipe_stations(project_id: UUID) -> None: + """관 PUT 끝 — 측점을 지금 관 자리로 다시 세움(`put_plus_stations` 처럼 · 부르는 길 모두 · 428). + + 노선 [저장] 뒤 관 차례가 화면 누가거리로 관을 덮으면 서버가 노선 저장 때 세운 측점과 어긋남 — + 여기서 맞추지 않으면 「측점이 없는 구조물」 · 옛 자리 카드가 남음. 실패해도 관 저장은 그대로. + """ + from B06_Section.B06_Section_Router_Stations import ensure_structure_stations + + try: + await ensure_structure_stations(project_id) + except Exception: + logger.exception("관 저장: 측점 맞춤 실패(저장은 그대로): project_id=%s", project_id) + + @router.put("/{project_id}/drainage/pipe-points", response_model=None) async def put_pipe_points( project_id: UUID, @@ -610,6 +627,7 @@ async def put_pipe_points( failed = await asyncio.to_thread( safe_sync, resolve_stored_project_path(context.stored_path), importer(session) ) + await _stand_pipe_stations(project_id) result = _payload(project_id, context, detail, points, True, stale) result["saved_count"] = saved result["snapshot_failed"] = failed # 못 만든 구조물 조합 복사본(142-2) — [저장] 알림 diff --git a/B06_Section/B06_Section_Cross_Refresh.ts b/B06_Section/B06_Section_Cross_Refresh.ts index 2b8ee8076..62ac31348 100644 --- a/B06_Section/B06_Section_Cross_Refresh.ts +++ b/B06_Section/B06_Section_Cross_Refresh.ts @@ -57,6 +57,8 @@ import { useStationKeys } from "./B06_Section_Station_Keys"; import { hasStaleDesigns, staleKey } from "./B06_Section_UI_Section_Common"; import { applyStructureAreaRows, structureAreaRows } from "./B06_Section_Structure_Layouts"; import { withPipeOptions } from "./B06_Section_Section_Adjusts"; +import { extendUnclosed } from "../B05_Profile/logic/B05_Profile_Sections_Ground"; +import { designTerrainGridNow } from "../B05_Profile/B05_Profile_Api_TerrainGrid"; /** 계획선 편집 델타 — B05 `AlignmentEdits`와 저장분 `profile_alignment.edits`가 같은 모양이다. */ export interface CrossRefreshEdits { @@ -367,6 +369,8 @@ function refreshLocally(input: CrossRefreshInput): number[] | null { return Math.max(session ?? (typeof stored === "number" ? stored : 0), 0); }; + // 미교차 넓힘 격자 — 받기 전이면 null(받은 뒤 다시 셈이 넓힘 · 지문에 실음) + const grid = designTerrainGridNow(projectId)?.grid ?? null; const updated: number[] = []; for (const section of detail.cross_sections) { const previous = section.design; @@ -432,7 +436,7 @@ function refreshLocally(input: CrossRefreshInput): number[] | null { // 국부 연산(346-2) — 입력 지문(지반 표본 · 계획고 · 횡단 입력 · 구조물 맥락 · 표준값)이 같고 // 설계가 그때 낸 그 객체면 앞 결과 그대로. 계획고 ▲ 한 번에 다시 세는 측점은 곡선 둘레 몇 곳뿐. const samples = section.samples ?? []; - const fingerprint = `${standardKey}|${elevation}|${samples.length}|${JSON.stringify({ ...options, standard: null })}`; + const fingerprint = `${standardKey}|${elevation}|${samples.length}|${grid ? "grid" : ""}|${JSON.stringify({ ...options, standard: null })}`; const memo = memos.get(section); if ( memo?.samples === section.samples && @@ -444,6 +448,21 @@ function refreshLocally(input: CrossRefreshInput): number[] | null { let next; try { next = computeCrossDesign(samples, elevation, options); + // 미교차 넓힘 — 서버 [저장] `extend_unclosed_sections` 짝 · 넓힌 표본을 측점에 남김(428 · 묶음 cross 와 같음) + const wide = + grid && next.slope_unclosed + ? extendUnclosed( + samples, + [section.center_x, section.center_y], + section.frame.left_xy, + (more) => computeCrossDesign(more as typeof samples, elevation, options), + grid, + ) + : null; + if (wide && (wide.info.left_m || wide.info.right_m)) { + section.samples = wide.samples as typeof samples; + next = computeCrossDesign(section.samples, elevation, options); + } } catch { continue; // 샘플 부족·값 손상 측점은 건너뛴다(서버 엔진과 같은 태도). } diff --git a/B06_Section/B06_Section_UI_Missing_Stations.ts b/B06_Section/B06_Section_UI_Missing_Stations.ts index ead81240e..03868c228 100644 --- a/B06_Section/B06_Section_UI_Missing_Stations.ts +++ b/B06_Section/B06_Section_UI_Missing_Stations.ts @@ -10,11 +10,15 @@ * 대신 **왜 값이 없는지**가 화면에 남는다. * ⚠ 지표 샘플링 조건이 저장에 없으면 **단추를 잠그고 사유를 보인다** — 조건을 지어내면 * 그 측점만 다른 지표에서 뽑혀 옆 측점과 지반고가 어긋난다. + * [저장] 뒤 다시 봄(428) — 관 · 구조물 초안이 정본으로 나가 비면 저장이 끝난 뒤 한 번 더 묻고 줄을 갈음 + * (서버가 관 PUT 끝에 측점을 다시 세움 · 옛 알림이 남지 않게). * ========================================================================== */ import { API_BASE_URL } from "@config/config_frontend"; import { createButton, showToast } from "@ui/ui_template_elements"; import { attachHoverInfo } from "@ui/ui_template_hover_info"; +import { useDesignStore } from "../A00_Common/design/design_store"; +import { savingDesign } from "../A00_Common/design/design_save"; interface MissingStation { chainage_m: number; @@ -49,12 +53,14 @@ export async function mountMissingStationNotice( projectId: string, onCreated: () => void | Promise, ): Promise { + watchSaves(host, projectId, onCreated); let data: MissingResponse; try { data = await call(projectId, "GET"); } catch { return; // 점검이 안 되는 것으로 화면을 막지 않는다 — 이 줄은 덤이다. } + host.querySelector(":scope > .b06-missing-stations")?.remove(); // 다시 봄 = 줄 하나 const missing = data.missing ?? []; if (!missing.length) return; @@ -99,3 +105,27 @@ export async function mountMissingStationNotice( } host.prepend(box); } + +const watched = new WeakSet(); + +/** 관 · 구조물 초안이 비면(저장 · 되돌림) 저장이 끝난 뒤 다시 물음 — 자리(`host`)가 떠나면 끊음. */ +function watchSaves( + host: HTMLElement, + projectId: string, + onCreated: () => void | Promise, +): void { + if (watched.has(host)) return; + watched.add(host); + const store = useDesignStore(projectId, null); + let timer = 0; + // ponytail: 저장 끝 신호가 없어 0.3 s 마다 봄 — 저장 끝 알림 창구가 생기면 그리로 + const recheck = (): void => { + window.clearTimeout(timer); + if (!host.isConnected) return stops.forEach((stop) => stop()); + if (savingDesign(projectId)) timer = window.setTimeout(recheck, 300); + else void mountMissingStationNotice(host, projectId, onCreated); + }; + const stops = (["pipes", "structures"] as const).map((key) => + store.subscribe(key, (value) => value === null && recheck()), + ); +} diff --git a/B06_Section/logic/B06_Section_Station_Swap.ts b/B06_Section/logic/B06_Section_Station_Swap.ts index 9d1b1a256..6adaba697 100644 --- a/B06_Section/logic/B06_Section_Station_Swap.ts +++ b/B06_Section/logic/B06_Section_Station_Swap.ts @@ -5,6 +5,9 @@ * · 같은 측점(열쇠 · 없으면 같은 자리 같은 종류)은 앞 횡단을 이어 받음 — 설계 · 구조물 제원 · 이름 그대로 · * 자리(누가거리 · 좌표 · 방위 · 확폭)와 지반 표본(채워 왔으면)만 새것. * · 새 측점 = 지반 표본 + 기본 설계(계획고 0 → 낡음 → 브라우저 다시 셈이 곧 채움). + * · 상단측 = 새 지반 표본으로 다시(단면 유형 기본값 재료 · 서버 횡단 파일 `uphill_side` 짝 · 428). + * · 0.5 m 넘게 옮긴 관 · 구조물 측점 = 기본 설계 + 사용자가 만진 칸만 — 서버가 그 행을 지우고 기본 설계에 + * [저장] 수정분을 얹는 것과 같음(`sync_cross_section_rows` · `compute_default_designs` · 428). * · 빠진 측점 = 목록에서 뺌(세션 고침은 열쇠로 남음 · 노선이 바뀐 때만 「노선 밖 고침」 · 부르는 쪽). * · 옛 상세는 그대로 둠 — 새 객체를 돌려줌(쥔 쪽이 갈아끼움). * @@ -15,6 +18,7 @@ import type { PipelineStation } from "../../A00_Common/design/logic/design_pipeline_types"; import type { CrossSection, SectionDetailResponse, SectionStation } from "../B06_Section_Api_Fetch"; +import { uphillSide } from "../../B05_Profile/logic/B05_Profile_Pipeline_Detail"; interface Sample { offset_m: number; @@ -51,15 +55,36 @@ export function formatStation(chainageM: number): string { export const stationIdOf = (chainageM: number): string => `station_${String(Math.round(chainageM * 1000)).padStart(12, "0")}`; -/** 새 측점의 기본 설계 — 계획고 0 이라 늘 낡음 → 다시 셈이 세션 선택 · 기본값으로 채움. */ -const freshDesign = () => +/** 새 측점의 기본 설계 — 계획고 0 이라 늘 낡음 → 다시 셈이 세션 선택 · 기본값으로 채움 · 단면 유형 = 상단측 깎기. */ +const freshDesign = (uphill: CrossSection["uphill_side"]) => ({ design_elevation_m: 0, ground_type: "ripping_rock", - section_mode: "left_cut", + section_mode: `${uphill ?? "left"}_cut`, ditch_type: "standard", }) as unknown as NonNullable; +/** 서버가 행을 지우고 새로 세우는 옮김 폭(m) — `sync_cross_section_rows` 의 0.5 m 짝. */ +const FACILITY_RESEED_M = 0.5; +/** 다시 셈 입력 중 기본 설계가 정하는 칸 — 옮긴 시설 측점은 버림(세션 고침은 열쇠째 옮겨 다시 얹힘). */ +const AUTO_INPUT_KEYS = [ + "ditch_side", + "rock_boundary_offset_m", + "two_stage_slope", + "ditch_choice", + "ditch_enabled", +]; + +/** 옮긴 시설 측점 설계 — 기본 설계 위에 앞 설계의 나머지(사용자가 만진 칸 · 결과 칸은 다시 셈이 갈음). */ +function reseeded( + prior: CrossSection["design"], + uphill: CrossSection["uphill_side"], +): NonNullable { + const design = { ...prior, ...freshDesign(uphill) } as Record; + for (const key of AUTO_INPUT_KEYS) delete design[key]; + return design as unknown as NonNullable; +} + function kindOf(station: PipelineStation): SectionStation["kind"] { if (station.kind === "end") return station.key.endsWith("EP") ? "ep" : "bp"; if (station.kind === "curve") return "curve"; @@ -169,7 +194,18 @@ export function swapCrossSections( }; longStations.push({ ...place, ...(prior?.structure ? { structure: prior.structure } : {}) }); const samples = station.ground ? groundSamples(station) : (prior?.samples ?? []); - return prior ? { ...prior, ...place, samples } : { ...place, samples, design: freshDesign() }; + const uphill = station.ground ? uphillSide(station) : (prior?.uphill_side ?? null); + if (!prior) return { ...place, uphill_side: uphill, samples, design: freshDesign(uphill) }; + const reseed = + (station.kind === "pipe" || station.kind === "structure") && + Math.abs(prior.chainage_m - station.chainageM) > FACILITY_RESEED_M; + return { + ...prior, + ...place, + uphill_side: uphill, + samples, + ...(reseed ? { design: reseeded(prior.design, uphill) } : {}), + }; }); const removed = detail.cross_sections .map((section, i) => (used.has(section) ? null : oldKeys[i])) diff --git a/common_util/common_util_route_follow.ts b/common_util/common_util_route_follow.ts index 9641471c5..396ecef98 100644 --- a/common_util/common_util_route_follow.ts +++ b/common_util/common_util_route_follow.ts @@ -107,8 +107,9 @@ export function placeOnLine( draft: ReadonlyArray

, before: ReadonlyArray, @@ -120,7 +121,14 @@ export function rebasePipeDraft

{ const was = pipe.id ? old.get(pipe.id) : undefined; const now = pipe.id ? moved.get(pipe.id) : undefined; - if (!was || !now || Math.abs(pipe.chainage_m - was.chainage_m) > SAME_STATION_M) return pipe; + const followed = + pipe.x != null && + pipe.y != null && + was?.x != null && + was.y != null && + Math.hypot(pipe.x - was.x, pipe.y - was.y) <= FOLLOW_SAME_XY_M; + if (!was || !now || (!followed && Math.abs(pipe.chainage_m - was.chainage_m) > SAME_STATION_M)) + return pipe; const shift = now.chainage_m - pipe.chainage_m; return { ...pipe, @@ -134,6 +142,9 @@ export function rebasePipeDraft

a.chainage_m - b.chainage_m); } +/** 따라가기만 한 관 = 정본과 같은 땅 위 자리(m) — 서버 좌표가 mm 3자리라 그 반올림 폭. */ +const FOLLOW_SAME_XY_M = 0.001; + export interface FollowingPoint { chainage_m: number; x?: number | null; diff --git a/resources/tester/helper_428_pipe_move.mjs b/resources/tester/helper_428_pipe_move.mjs new file mode 100644 index 000000000..88051f58c --- /dev/null +++ b/resources/tester/helper_428_pipe_move.mjs @@ -0,0 +1,180 @@ +/* PLAN 428 헬퍼 — 옮긴 관(0.5 m 넘게)의 횡단: 측점 갈아끼움(기본 설계 + 만진 칸) → 저장 노선 다시 셈(미교차 + * 넓힘) → 관 길이. 서버 길(기본 설계 · 넓힘)과 같은 값인지 시험이 견줌 · 관 초안 얹기(rebasePipeDraft). + * node helper_428_pipe_move.mjs <묶음.mjs> + * 짝 = `test_428_pipe_move_mirror.py` · 표준출력 JSON 한 벌. + */ +import { readFileSync } from "node:fs"; +import { pathToFileURL } from "node:url"; + +const store = () => { + const m = new Map(); + return { + getItem: (k) => (m.has(k) ? m.get(k) : null), + setItem: (k, v) => m.set(k, String(v)), + removeItem: (k) => m.delete(k), + key: (i) => [...m.keys()][i] ?? null, + get length() { + return m.size; + }, + clear: () => m.clear(), + }; +}; +globalThis.window = globalThis; +globalThis.sessionStorage = store(); +globalThis.localStorage = store(); +const any = new Proxy(function () {}, { + get: (_t, k) => (k === Symbol.toPrimitive ? () => 0 : any), + apply: () => any, + construct: () => any, +}); +globalThis.document = any; +globalThis.requestAnimationFrame = (run) => setTimeout(run, 0); + +const job = JSON.parse(readFileSync(process.argv[3], "utf8")); +const gridBytes = readFileSync(process.argv[4]); +// 설계 지형 격자 창구만 가짜 — 그 밖 요청은 404(관 초안 · 저장 관 없음) +globalThis.fetch = async (url) => { + const href = String(url); + if (href.includes("/route/terrain-sources")) + return Response.json({ design: "las", grid: { model_id: 1, smooth: false, signature: "s" } }); + if (href.includes("/grid?")) return new Response(gridBytes); + return new Response("{}", { status: 404 }); +}; + +const m = await import(pathToFileURL(process.argv[2]).href); +const P = "p428"; +const R = 7; +m.writeState("std-cross", job.standard, P); +m.rememberRockBoundaryDefault(P, job.rockDefault); + +/** 서버 횡단(표본 · 틀) → 묶음 측점 꼴(지반 = 중심 → 바깥 · 좌 +). */ +const stationOf = (key, section) => { + const samples = section.samples; + const side = (sign) => + samples + .filter((s) => s.offset_m * sign > 1e-9) + .map((s) => ({ offsetM: Math.abs(s.offset_m), z: s.elevation_m })) + .sort((a, b) => a.offsetM - b.offsetM); + const center = samples.find((s) => Math.abs(s.offset_m) < 1e-9); + return { + key, + kind: "pipe", + chainageM: section.chainage_m, + x: section.center_x, + y: section.center_y, + left: section.frame.left_xy, + azimuthDeg: section.azimuth_deg ?? 0, + planRadiusM: null, + curveOuterSide: null, + curveWideningM: null, + ground: { left: side(1), right: side(-1), centerZ: center ? center.elevation_m : null }, + }; +}; +const culvertAt = (chainage) => ({ ...job.culvert, chainage_m: chainage }); +const alignmentAt = (chainage, z) => ({ + stations: [{ chainage_m: chainage, plan_elevation_m: z }], + samples: [ + { chainage_m: 0, elevation_m: z }, + { chainage_m: 100000, elevation_m: z }, + ], + balance: { cut_area_m2: 0, fill_area_m2: 0, net_area_m2: 0 }, +}); +const pipeLength = (section) => + m.computeStoredLayouts(section, [section])?.culvert?.pipe?.lengthM ?? null; +const pick = (design) => ({ + section_mode: design.section_mode, + ground_type: design.ground_type, + ditch_side: design.ditch_side ?? null, + two_stage_slope: design.two_stage_slope ?? null, + rock_boundary_offset_m: design.rock_boundary_offset_m ?? null, + inlet_structure: design.inlet_structure ?? null, + cut: design.cut_area_m2 ?? null, + fill: design.fill_area_m2 ?? null, + ends: design.design_line + ? [design.design_line[0].offset_m, design.design_line.at(-1).offset_m] + : null, +}); + +const out = {}; +const oldDetail = () => ({ + longitudinal: { length_m: 1000, stations: [], profile_alignment: { policy: {} } }, + cross_sections: [ + { ...structuredClone(job.old), kind: "irregular", culvert: culvertAt(job.old.chainage_m) }, + ], +}); + +/* 옮긴 관 — 0.5 m 넘게: 갈아끼움 → 다시 셈(넓힘) → 관 길이 */ +{ + const swap = m.swapCrossSections( + oldDetail(), + [stationOf("pipe:p-a", job.moved)], + ["pipe:p-a"], + 20, + ); + const section = swap.detail.cross_sections[0]; + out.swapped = { uphill: section.uphill_side, ...pick(section.design) }; + section.culvert = culvertAt(job.moved.chainage_m); // 그림 자료가 새 자리에 다시 붙음(withDraftShapes 몫) + // 격자는 받기가 끝나야 씀 — 첫 다시 셈이 받기를 띄움 · 받은 뒤 다시 셈이 넓힘 + await m.refreshCrossDesigns({ + projectId: P, + routeId: R, + detail: swap.detail, + edits: { station_offsets: {}, curve_radii: {} }, + alignment: alignmentAt(job.moved.chainage_m, job.elevation), + }); + await new Promise((next) => setTimeout(next, 50)); + out.firstSamples = section.samples.length; // 격자 받기 전 = 안 넓힘(지문에 격자 유무 · 받은 뒤 다시 셈) + await m.refreshCrossDesigns({ + projectId: P, + routeId: R, + detail: swap.detail, + edits: { station_offsets: {}, curve_radii: {} }, + alignment: alignmentAt(job.moved.chainage_m, job.elevation), + }); + out.browser = { + ...pick(section.design), + samples: section.samples.length, + sampleEnds: [section.samples[0].offset_m, section.samples.at(-1).offset_m], + pipeLength: pipeLength(section), + }; + // 서버 = 같은 표본 · 기본 설계 → 서버 Node 가 같은 함수로 구조물 폐회로 면적 · 관 길이(`_recompute`) + const server = { + ...structuredClone(job.moved), + kind: "irregular", + samples: job.serverSamples, + design: { ...job.serverDesign, inlet_structure: job.old.design.inlet_structure }, + culvert: culvertAt(job.moved.chainage_m), + }; + m.applyStructureAreaRows([server], m.structureAreaRows([server])); + out.server = { ...pick(server.design), pipeLength: pipeLength(server) }; +} + +/* 0.5 m 안 옮김 — 앞 설계 그대로(서버가 행을 옮겨 사용자 설계 값 그대로) */ +{ + const near = { ...stationOf("pipe:p-a", job.old), chainageM: job.old.chainage_m + 0.3 }; + const swap = m.swapCrossSections(oldDetail(), [near], ["pipe:p-a"], 20); + out.near = pick(swap.detail.cross_sections[0].design); +} + +/* 관 초안 얹기 — 따라가기만 한 관(땅 위 자리 = 정본) = 서버 누가거리 · 사용자가 옮긴 관 = 그대로 */ +out.rebase = m + .rebasePipeDraft( + [ + { id: "f", chainage_m: 105, x: 10, y: 20, source: "user" }, + { id: "u", chainage_m: 210, x: 55, y: 66, source: "user" }, + { id: "s", chainage_m: 300, source: "user" }, + ], + [ + { id: "f", chainage_m: 100, x: 10, y: 20 }, + { id: "u", chainage_m: 200, x: 50, y: 60 }, + { id: "s", chainage_m: 300 }, + ], + [ + { id: "f", chainage_m: 104, x: 10.5, y: 20.5, source: "user" }, + { id: "u", chainage_m: 203, x: 51, y: 61, source: "user" }, + { id: "s", chainage_m: 301, x: 1, y: 1, source: "user" }, + ], + ) + .map((pipe) => [pipe.id, pipe.chainage_m]); + +process.stdout.write(JSON.stringify(out)); diff --git a/resources/tester/helper_428_pipe_move_entry.ts b/resources/tester/helper_428_pipe_move_entry.ts new file mode 100644 index 000000000..4a36f9bd0 --- /dev/null +++ b/resources/tester/helper_428_pipe_move_entry.ts @@ -0,0 +1,11 @@ +/* PLAN 428 시험 묶음 진입점 — 옮긴 관 측점 갈아끼움 · 저장 노선 다시 셈(넓힘) · 관 길이 · 관 초안 얹기(진짜 모듈 · vite ssr). */ +export { swapCrossSections } from "../../B06_Section/logic/B06_Section_Station_Swap"; +export { refreshCrossDesigns } from "../../B06_Section/B06_Section_Cross_Refresh"; +export { + applyStructureAreaRows, + computeStoredLayouts, + structureAreaRows, +} from "../../B06_Section/B06_Section_Structure_Layouts"; +export { rememberRockBoundaryDefault } from "../../B06_Section/B06_Section_UI_Standard_Panel"; +export { writeState } from "../../A00_Common/b_page_state"; +export { rebasePipeDraft } from "../../common_util/common_util_route_follow"; diff --git a/resources/tester/test_416_page_cache.py b/resources/tester/test_416_page_cache.py index be83854a9..8d7a4378c 100644 --- a/resources/tester/test_416_page_cache.py +++ b/resources/tester/test_416_page_cache.py @@ -48,7 +48,11 @@ def test_암선_기본은_config(r): def test_M5_관_길이는_공용_캐시(r): assert r["m5"] == {"before": 8, "cleared": None, "after": 11} page = _read("A00_Common/design/design_page.ts") - assert "peekSectionDetail(projectId, pageRouteId(projectId))?.cross_sections" in page + # 노선 초안 동안 = 계산 줄 새 노선 상세 · 그 밖 = 공용 캐시(428) + assert ( + "(pipelineDetail(projectId) ?? peekSectionDetail(projectId, pageRouteId(projectId)))" + in page + ) found = subprocess.run( # noqa: S603, S607 — 고정 실행 파일 ["git", "grep", "-l", "setPipeSectionsSource(", "--", "*.ts"], cwd=ROOT, diff --git a/resources/tester/test_428_pipe_move_mirror.py b/resources/tester/test_428_pipe_move_mirror.py new file mode 100644 index 000000000..57a732ace --- /dev/null +++ b/resources/tester/test_428_pipe_move_mirror.py @@ -0,0 +1,228 @@ +"""PLAN 428 — 평면 · 관 옮김 뒤 횡단 형상 · 측점 한 값. + +요구 255-1 · 257-1 · 261 · 분석 424 1장 · 7장. + +못박는 것 + - 0.5 m 넘게 옮긴 관 측점 = 기본 설계(새 상단측 깎기 · 리핑암 · 표준 측구) + + 사용자가 만진 칸 — 서버가 그 행을 지우고 기본 설계를 세우는 것과 같음 · + 0.5 m 안이면 앞 설계 그대로. + - 저장 노선 다시 셈(`refreshCrossDesigns`)이 미교차 측점을 서버 `extend_unclosed` + 와 같이 넓힘 → 브라우저 관 길이 = 서버 관 길이(같은 기하 함수 · 표본 · 설계). + - 관 초안 얹기 — 따라가기만 한 관(땅 위 자리 = 정본 x · y) = 서버 누가거리 · + 사용자가 옮긴 관 = 그대로. + - 관 PUT 끝 서버가 측점을 다시 세움 · GET 관 지점에 x · y. +짝: `helper_428_pipe_move.mjs` · 진입점 `helper_428_pipe_move_entry.ts` · +지형 · 노선 틀 = `test_346_2_pipeline_cross_page.py`. +""" + +from __future__ import annotations + +import inspect +import json +import shutil +import subprocess +import sys +import tempfile +from pathlib import Path + +import pytest + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +for path in (ROOT, HERE): + if str(path) not in sys.path: + sys.path.insert(0, str(path)) + +from test_346_2_pipeline_cross_page import _fake, _line, _sections # noqa: E402 + +from B06_Section.B06_Section_Engine_Design import compute_cross_design # noqa: E402 +from B06_Section.B06_Section_Engine_SampleExtend import extend_unclosed # noqa: E402 +from common_util.common_util_surface_sampler import DtmGridSampler, dtm_grid_bytes # noqa: E402 +from config.config_system import STANDARD_ROCK_BOUNDARY_DEFAULT_OFFSET_M # noqa: E402 +from config.config_system_design import STANDARD_CROSS_SECTION # noqa: E402 + +pytestmark = pytest.mark.skipif( + not (ROOT / "config" / "node_modules" / "vite").is_dir(), + reason="프론트엔드 의존성 미설치", +) + +CULVERT = { + "type": "pipe", + "pipe_kind": "흄관", + "diameter_m": 1.0, + "min_cover_m": 0.5, + "inlet": {"role": "inlet", "structure": "기슭막이", "revet_form": "돌쌓기(찰)"}, + "outlet": {"role": "outlet", "structure": "기슭막이", "revet_form": "돌쌓기(찰)"}, +} + + +def _pipe_section(line, sampler, chainage: float) -> dict: + data = _sections(line, sampler, [{"id": "p-a", "chainage_m": chainage, "source": "user"}]) + return next(s for s in data["cross_sections"] if abs(s["chainage_m"] - chainage) < 1e-6) + + +def _server(section: dict, elevation: float, sampler): + """서버 길 — 옮긴 관 측점 = 기본 설계(상단측 깎기 · `compute_default_designs`) + → [저장] 보정 맨 앞 미교차 넓힘(`extend_unclosed_sections` — 저장 설계의 + 단면 유형 · 측구 칸을 입력으로 다시 셈).""" + base = { + "ground_type": "ripping_rock", + "ditch_type": "standard", + "standard": STANDARD_CROSS_SECTION, + "rock_boundary_offset_m": STANDARD_ROCK_BOUNDARY_DEFAULT_OFFSET_M, + } + stored = compute_cross_design( + section["samples"], + elevation, + section_mode=f"{section.get('uphill_side') or 'left'}_cut", + **base, + ) + + def compute(samples): + return compute_cross_design( + samples, + elevation, + section_mode=stored["section_mode"], + ditch_side=stored.get("ditch_side"), + ditch_enabled=stored.get("ditch_enabled"), + ditch_choice=stored.get("ditch_choice"), + two_stage_slope=bool(stored.get("two_stage_slope", False)), + **base, + ) + + wide = extend_unclosed(section["samples"], section["frame"], compute, sampler) + if not (wide and (wide[1]["left_m"] or wide[1]["right_m"])): + return section["samples"], stored, wide + return wide[0], compute(wide[0]), wide + + +@pytest.fixture(scope="module") +def r(tmp_path_factory) -> dict: + work = tmp_path_factory.mktemp("b428") + build = subprocess.run( # noqa: S603 — 고정 실행 파일 + [ + "node", + str(ROOT / "config" / "node_modules" / "vite" / "bin" / "vite.js"), + "build", + "--configLoader", + "runner", + "--ssr", + "../resources/tester/helper_428_pipe_move_entry.ts", + "--outDir", + str(work), + "--logLevel", + "error", + ], + cwd=ROOT, + capture_output=True, + text=True, + encoding="utf-8", + timeout=300, + ) + assert build.returncode == 0, build.stderr + bundle = work / "bundle.mjs" + shutil.copy(work / "helper_428_pipe_move_entry.js", bundle) + with tempfile.TemporaryDirectory() as folder: + npz, nodes = _fake(Path(folder)) + line = _line(nodes) + sampler = DtmGridSampler.from_npz(npz) + old = _pipe_section(line, sampler, 90.0) + moved = _pipe_section(line, sampler, 96.0) # 6 m 옮김 — 서버가 옛 행을 지우고 새로 세움 + # 표본 20 m 밖까지 닿는 성토 높이 — 넓힘이 실제로 도는 자리 + for rise in (10.0, 14.0, 18.0, 24.0): + elevation = float(moved["center_z"]) + rise + samples, design, wide = _server(moved, elevation, sampler) + if samples is not moved["samples"]: + break + else: + pytest.fail("넓힘이 도는 계획고를 못 찾음") + uphill = moved.get("uphill_side") or "left" + other = "right" if uphill == "left" else "left" + old["design"] = { + "design_elevation_m": elevation, + "ground_type": "soil", + "section_mode": f"{other}_cut", + "ditch_side": other, + "two_stage_slope": True, + "rock_boundary_offset_m": 9.0, + "inlet_structure": "revet", + } + job = { + "old": old, + "moved": moved, + "elevation": elevation, + "standard": STANDARD_CROSS_SECTION, + "rockDefault": STANDARD_ROCK_BOUNDARY_DEFAULT_OFFSET_M, + "culvert": CULVERT, + "serverSamples": samples, + "serverDesign": design, + } + path = Path(folder) / "job.json" + path.write_text(json.dumps(job), encoding="utf-8") + grid = Path(folder) / "grid.bin" + grid.write_bytes(dtm_grid_bytes(npz)) + proc = subprocess.run( # noqa: S603 — 고정 실행 파일 + ["node", str(HERE / "helper_428_pipe_move.mjs"), str(bundle), str(path), str(grid)], + cwd=ROOT, + capture_output=True, + text=True, + encoding="utf-8", + timeout=120, + ) + assert proc.returncode == 0, proc.stderr + out = json.loads(proc.stdout) + out["job"] = {"uphill": uphill, "other": other, "wide": wide[1], "samples": len(samples)} + out["serverDesign"] = design + return out + + +def test_옮긴_관_측점_기본_설계와_만진_칸(r): + s = r["swapped"] + assert s["uphill"] == r["job"]["uphill"] # 상단측 = 새 지반 + assert s["section_mode"] == f"{r['job']['uphill']}_cut" + assert s["ground_type"] == "ripping_rock" + assert s["ditch_side"] is None and s["two_stage_slope"] is None + assert s["rock_boundary_offset_m"] is None + assert s["inlet_structure"] == "revet" # 사용자가 만진 칸은 따라감 + + +def test_0_5m_안_옮김_앞_설계_그대로(r): + n = r["near"] + assert n["section_mode"] == f"{r['job']['other']}_cut" + assert n["ground_type"] == "soil" and n["ditch_side"] == r["job"]["other"] + assert n["rock_boundary_offset_m"] == 9.0 + + +def test_저장_노선_다시_셈이_서버처럼_넓힘(r): + b = r["browser"] + s = r["server"] # 구조물 폐회로 면적까지(서버 Node 와 같은 함수) + assert r["job"]["wide"]["left_m"] or r["job"]["wide"]["right_m"] + assert r["firstSamples"] < b["samples"] == r["job"]["samples"] # 격자 받은 뒤 넓힘 + assert abs(b["cut"] - s["cut"]) < 1e-3 and abs(b["fill"] - s["fill"]) < 1e-3 + d = r["serverDesign"] + ends = [d["design_line"][0]["offset_m"], d["design_line"][-1]["offset_m"]] + assert all(abs(a - e) < 1e-3 for a, e in zip(b["ends"], ends)) + + +def test_옮긴_관_관_길이_브라우저_대_서버(r): + got = r["browser"]["pipeLength"] + want = r["server"]["pipeLength"] + assert got is not None and want is not None and got > 0 + assert abs(got - want) < 1e-3, (got, want) + + +def test_관_초안_얹기_따라가기만_한_관은_서버_누가거리(r): + assert r["rebase"] == [["f", 104], ["u", 210], ["s", 301]] + + +def test_관_PUT_끝_측점_다시_세움_GET_좌표(): + from B04_PreProcess import B04_PreProcess_Router_Basins as basins + + put = inspect.getsource(basins.put_pipe_points) + assert ( + put.index("save_pipe_points") < put.index("_stand_pipe_stations(") < put.index("_payload(") + ) + stand = inspect.getsource(basins._stand_pipe_stations) + assert "ensure_structure_stations(project_id)" in stand and "except Exception" in stand + raw = inspect.getsource(basins._raw_payload) + assert '"x": round(float(pipe.x), 3)' in raw and '"y": round(float(pipe.y), 3)' in raw