feat(B05 평면 형상 제어): 하한 검사 applyEdit 한 곳 · 곡선 삭제 155° 경고 · 놓을 때 맞춤 보고 · 스냅 즉시 계산 줄 · 넣은 R · 고정 곡선표 저장 (430)
- 하한 검사 = 모든 평면 조작이 applyEdit 에서 지난 걸음과 견줌 · 새로 깨면 그 걸음으로 되돌림 · 까닭 상태줄(끼우기 · 지우기 · 놓기 · 방향키 · 곡선 칸) · 손잡이 끌기도 걸음마다 검사 - 곡선 삭제 = 내각 155° 미만이면 막지 않고 경고(상태줄 · 알림) - 끌기 · 손잡이 놓을 때 스냅 켬이면 「함께 밀린 교점 · 못 맞춘 곡선」 보고 - 스냅 끔 · 간격 바꿈 = 계산 줄에 초안 바로(tellDraft) - R · 길이 고정 · 넣은 R = 곡선표 edits 칸(짝 B05_Profile_Route_NodeEdits.py ↔ flattenServerPlan) · 다시 열면 넣은 값으로 - 상태줄 = 겹친 노드(0.5 m 안) · 못 그린 곡선 표시 - 시험 test_430_route_edit_rules · 배선 바뀐 시험 둘(352-3 · 390-4) · 398-2 도우미 알림 가짜 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TteK8mfYZetk5P3bEZkyVZ
This commit is contained in:
Claude Opus 5.5
@@ -19,6 +19,7 @@ import { readState, writeState } from "../A00_Common/b_page_state";
|
||||
import { heightAt } from "../common_util/common_util_surface_sampler";
|
||||
import { loadDesignTerrainGrid } from "./B05_Profile_Api_TerrainGrid";
|
||||
import type { RouteDraft } from "../A00_Common/design/logic/design_pipeline_types";
|
||||
import type { RouteNodeEdit } from "./logic/B05_Profile_UI_RouteEdit_Edits";
|
||||
|
||||
/** 편집 창 분석 지형 — las = 확정 지표면(라이다) · sheet = 수치지형도 서피스. */
|
||||
export type AnalysisTerrain = "las" | "sheet";
|
||||
@@ -121,6 +122,8 @@ export interface RoutePlanResponse {
|
||||
station_snap_step?: number | null;
|
||||
/** 현재 초기값 — 서버가 [확인] 때 프로젝트에 적어 둔 초기노선 갈래(계획서 20). */
|
||||
current_initial?: { logic: string; weights: Record<string, number> | null };
|
||||
/** 노드마다 넣은 편집값(430) — 넣은 R · 고정 · 고정 길이 · 켬끔 · 노드 수와 다르거나 옛 노선이면 null. */
|
||||
node_edits?: RouteNodeEdit[] | null;
|
||||
}
|
||||
|
||||
export interface RouteReplanResponse {
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
"""노드마다 넣은 편집값(430) — 곡선 켬끔 · 넣은 R · 고정(R | 길이) · 고정 길이 → 곡선표 `edits`.
|
||||
|
||||
⚠ 짝: `logic/B05_Profile_UI_RouteEdit_Edits.ts` `flattenServerPlan`(`RouteNodeEdit`)이 읽음 ·
|
||||
거울 시험 `resources/tester/test_430_route_edit_rules.py`.
|
||||
|
||||
곡선표 `curves` 는 **그린** R(접선 자리에 눌린 값)만 있어, 그것으로 다시 열면 눌린 R 이
|
||||
넣은 값으로 굳고 R · 길이 고정이 [저장] 뒤 사라짐 — 넣은 값을 따로 둠. 자리 = 저장 노드
|
||||
(앞 노드에서 0.5 m 안인 점은 `build_planned_polyline` 과 같이 거름).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
from typing import Any
|
||||
|
||||
from common_util.common_util_route_polyline import DUPLICATE_TOLERANCE_M
|
||||
|
||||
_LOCKS = ("radius", "arc")
|
||||
|
||||
|
||||
def node_edits(
|
||||
points: list[tuple[float, float]],
|
||||
flags: list[bool] | None,
|
||||
radii: list[float | None] | None,
|
||||
locks: list[str | None] | None = None,
|
||||
arcs: list[float | None] | None = None,
|
||||
) -> list[dict[str, Any]]:
|
||||
"""점마다의 편집값 — 겹친 점은 빼고 저장 노드와 같은 자리로. 칸이 짧으면 기본값(켬 · 자동)."""
|
||||
|
||||
def at(values: list | None, index: int, default: Any = None) -> Any:
|
||||
return values[index] if values is not None and index < len(values) else default
|
||||
|
||||
kept: list[tuple[float, float]] = []
|
||||
edits: list[dict[str, Any]] = []
|
||||
for index, point in enumerate(points):
|
||||
if kept and math.dist(kept[-1], point) <= DUPLICATE_TOLERANCE_M:
|
||||
continue
|
||||
kept.append(point)
|
||||
lock = at(locks, index)
|
||||
edits.append(
|
||||
{
|
||||
"curve": bool(at(flags, index, True)),
|
||||
"radius_m": at(radii, index),
|
||||
"lock": lock if lock in _LOCKS else None,
|
||||
"arc_m": at(arcs, index),
|
||||
}
|
||||
)
|
||||
return edits
|
||||
@@ -42,6 +42,7 @@ from B03_FileInput.B03_FileInput_Repository import get_project_storage_relative_
|
||||
from B05_Profile.B05_Profile_Engine_RouteInitial import read_initial_choice, write_initial_choice
|
||||
from B05_Profile.B05_Profile_Engine_RouteInitial_Station import snapped_initial
|
||||
from B05_Profile.B05_Profile_Engine_Sections import load_station_snap, load_station_snap_step
|
||||
from B05_Profile.B05_Profile_Route_NodeEdits import node_edits
|
||||
from B05_Profile.B05_Profile_Route_Save import RouteSaveRequest
|
||||
from B05_Profile.B05_Profile_Schema import ( # noqa: F401 — 부르는 곳이 `replan.` 으로 씀
|
||||
RouteInitialCriteria,
|
||||
@@ -211,8 +212,8 @@ def _curves_path(path: Path) -> Path:
|
||||
return path.with_name(f"{path.stem}_curves.json")
|
||||
|
||||
|
||||
def _read_curves(path: Path) -> list[dict]:
|
||||
"""저장해 둔 곡선 성분. 없거나 못 읽으면 빈 목록(옛 프로젝트)."""
|
||||
def _read_curves(path: Path, key: str = "curves") -> list[dict]:
|
||||
"""저장해 둔 곡선 성분(`key` = "edits" 면 넣은 편집값 · 430). 없거나 못 읽으면 빈 목록."""
|
||||
target = _curves_path(path)
|
||||
if not target.is_file():
|
||||
return []
|
||||
@@ -221,7 +222,7 @@ def _read_curves(path: Path) -> list[dict]:
|
||||
except (OSError, json.JSONDecodeError):
|
||||
logger.warning("계획노선 곡선 성분을 읽지 못했습니다: %s", target)
|
||||
return []
|
||||
curves = data.get("curves") if isinstance(data, dict) else None
|
||||
curves = data.get(key) if isinstance(data, dict) else None
|
||||
return curves if isinstance(curves, list) else []
|
||||
|
||||
|
||||
@@ -235,11 +236,14 @@ def _write_planned_polyline(
|
||||
radii: list[float | None] | None = None,
|
||||
station_snap: bool | None = None,
|
||||
station_snap_step: float | None = None,
|
||||
locks: list[str | None] | None = None,
|
||||
arcs: list[float | None] | None = None,
|
||||
) -> dict:
|
||||
"""점 묶음을 폴리라인으로 바꿔 CSV 로 쓴다. 노드 요약을 돌려준다.
|
||||
|
||||
`station_snap` — [확인] 때만 곡선표에 적음(요구 224-2). None 이면 칸을 안 둠(끔) ·
|
||||
`station_snap_step` — 켬 + 간격이 있을 때만 곡선표에 적음(390-5 · 없으면 측점 No.).
|
||||
`locks` · `arcs` — 편집값이 오면 넣은 값을 곡선표 `edits` 에(430 · `_Route_NodeEdits`).
|
||||
|
||||
**노드도 함께 남긴다** — 노드는 폴리라인에서 되뽑을 수 없다. 폴리라인에는 원호 위 점이
|
||||
섞여 있어 다시 단순화하면 꺾임점이 조금씩 지워지고, 그것을 반복하면 [확인]을 누를
|
||||
@@ -262,6 +266,8 @@ def _write_planned_polyline(
|
||||
table["station_snap"] = bool(station_snap)
|
||||
if station_snap and station_snap_step is not None:
|
||||
table["station_snap_step"] = float(station_snap_step)
|
||||
if curve_flags is not None or radii is not None:
|
||||
table["edits"] = node_edits(points, curve_flags, radii, locks, arcs)
|
||||
_curves_path(path).write_text(json.dumps(table, ensure_ascii=False), encoding="utf-8")
|
||||
return {
|
||||
"nodes": len(result.nodes),
|
||||
@@ -507,6 +513,13 @@ async def read_route_plan(project_id: UUID) -> dict[str, Any] | JSONResponse:
|
||||
# 저장해 둔 노드면 이미 꺾임점이라 다시 뽑지 않는다. 없을 때(옛 프로젝트)만 뽑는다.
|
||||
simplify=not saved_nodes,
|
||||
)
|
||||
saved_edits = await asyncio.to_thread(
|
||||
_read_curves,
|
||||
planned_route_working_path(project_root)
|
||||
if working
|
||||
else planned_route_initial_path(project_root),
|
||||
"edits",
|
||||
)
|
||||
return {
|
||||
"status": "success",
|
||||
"project_id": str(project_id),
|
||||
@@ -527,6 +540,10 @@ async def read_route_plan(project_id: UUID) -> dict[str, Any] | JSONResponse:
|
||||
"station_snap": await asyncio.to_thread(load_station_snap, project_root),
|
||||
"station_snap_step": await asyncio.to_thread(load_station_snap_step, project_root),
|
||||
"current_initial": await asyncio.to_thread(read_initial_choice, project_root),
|
||||
# 넣은 R · 고정 · 고정 길이(430) — 저장 노드와 자리가 같을 때만(옛 곡선표 = null)
|
||||
"node_edits": saved_edits
|
||||
if saved_nodes and len(saved_edits) == len(outline.nodes)
|
||||
else None,
|
||||
}
|
||||
|
||||
|
||||
@@ -561,6 +578,7 @@ async def replan_route(project_id: UUID, body: RouteSaveRequest) -> dict[str, An
|
||||
nodes = [(vertex.x, vertex.y) for vertex in request.vertices]
|
||||
curve_flags = [bool(vertex.curve) for vertex in request.vertices]
|
||||
radii = [vertex.radius_m for vertex in request.vertices]
|
||||
draft = getattr(body, "draft", None) # R · 길이 고정(430) — 초안에만 있음
|
||||
# 체인이 끊기면 되돌릴 수 있게 이전 수정본을 손에 쥔다 — 실패했는데 노선만 바뀌면
|
||||
# 종횡단과 어긋난 채 굳고, 다시 누를수록 어긋남이 쌓인다(2026-09-06 실측).
|
||||
# 곡선표 · 노드도 함께 — 남기면 되돌린 노선에 새 곡선표(스냅 켬끔)가 붙음.
|
||||
@@ -576,6 +594,8 @@ async def replan_route(project_id: UUID, body: RouteSaveRequest) -> dict[str, An
|
||||
radii=radii,
|
||||
station_snap=request.station_snap,
|
||||
station_snap_step=request.station_snap_step,
|
||||
locks=list(draft.curveLock) if draft else None,
|
||||
arcs=list(draft.curveArc) if draft else None,
|
||||
),
|
||||
working_path,
|
||||
nodes,
|
||||
|
||||
@@ -39,11 +39,7 @@ import {
|
||||
type AnalysisTerrain,
|
||||
} from "./B05_Profile_Api_Replan";
|
||||
import { bindRouteApply } from "./B05_Profile_UI_RouteEdit_Apply";
|
||||
import {
|
||||
buildEditedPolyline,
|
||||
type EditedCurve,
|
||||
type EditedNode,
|
||||
} from "./logic/B05_Profile_UI_RouteEdit_Curve";
|
||||
import type { EditedCurve, EditedNode } from "./logic/B05_Profile_UI_RouteEdit_Curve";
|
||||
import { drawRouteEditScene, polylineLengthM, watchTheme } from "./B05_Profile_UI_RouteEdit_Render";
|
||||
import { bindNodeSplice, bindRouteEditNavigation } from "./B05_Profile_UI_RouteEdit_Input";
|
||||
import { bindRouteEditPointer } from "./B05_Profile_UI_RouteEdit_Pointer";
|
||||
@@ -69,14 +65,7 @@ import {
|
||||
writeRouteLocks,
|
||||
} from "./B05_Profile_UI_RouteEdit_Lock";
|
||||
import { createInitialPanel, type InitialPanelParams } from "./B05_Profile_UI_RouteEdit_Initial";
|
||||
import {
|
||||
applyArcLocks,
|
||||
applyCurveLimits,
|
||||
curveSummary,
|
||||
flattenServerPlan,
|
||||
spliceNode,
|
||||
type CurveLock,
|
||||
} from "./logic/B05_Profile_UI_RouteEdit_Edits";
|
||||
import * as edits from "./logic/B05_Profile_UI_RouteEdit_Edits";
|
||||
import {
|
||||
bindHistoryControls,
|
||||
createRouteEditHistory,
|
||||
@@ -148,7 +137,7 @@ export async function mountRouteEditor(
|
||||
let curveRadius: Array<number | null> = [];
|
||||
/** 붙들어 둔 값 — 무엇을 고정할지와, 길이를 고정했을 때의 그 길이(m).
|
||||
* 노드를 옮기면 교각이 바뀌어 R 과 길이 중 하나는 반드시 따라 움직인다(`_Edits.ts`). */
|
||||
let curveLock: CurveLock[] = [];
|
||||
let curveLock: edits.CurveLock[] = [];
|
||||
let curveArc: Array<number | null> = [];
|
||||
/** 자리를 못 박은 노드(2026-09-12 사용자 지시 ① · 계획서 22-5) — 0번 = 시점, 끝 칸 = 종점
|
||||
* (기본 고정), 사이 = 교각점. 켜진 자리는 안 끌리고 반지름·곡선 길이 칸으로만 바뀐다.
|
||||
@@ -162,6 +151,7 @@ export async function mountRouteEditor(
|
||||
const snap = bindStationSnap(chrome, projectId, stationIntervalM, (toggle) => {
|
||||
if (toggle) setStationSnap(!stationSnap);
|
||||
if (stationSnap && history) applyEdit(snap.text()); // 전체 · 한 걸음
|
||||
tellDraft(); // 끔 · 간격 바꿈도 계산 줄에 바로(430)
|
||||
draw();
|
||||
});
|
||||
const stations = () => snap.stations(plannedLine.length ? plannedLine : planned, curveInfo);
|
||||
@@ -362,12 +352,11 @@ export async function mountRouteEditor(
|
||||
* 지금은 서버와 **같은 규칙**(`buildEditedPolyline` 짝)으로 즉시 다시 만든다. [확인] 때
|
||||
* 서버가 정본으로 다시 내는 것은 그대로다. */
|
||||
function markEdited(): void {
|
||||
// 길이를 붙든 자리는 교각이 바뀌었을 수 있다 — 그리기 전에 R 부터 다시 잡는다.
|
||||
applyArcLocks(planned, curveLock, curveArc, curveRadius);
|
||||
// 지정해 둔 값이 하한을 밑돌면 하한까지 끌어올린다(계획서 0-9 ④).
|
||||
// 하한은 **R 과 L 을 함께 본 값**이다 — 내각 155° 이상은 R 만 본다(2026-09-12 확정).
|
||||
applyCurveLimits(planned, curveOn, curveRadius, limitRadiusM, limitArcM);
|
||||
const built = buildEditedPolyline(planned, curveOn, curveRadius, minRadiusM);
|
||||
// 길이 고정 R → 지정값 하한(R·L · 내각 155° 이상은 R 만) 끌어올림 → 선(셈은 `_Edits` · 0-9 ④).
|
||||
const built = edits.rebuildLine(
|
||||
{ planned, curveOn, curveRadius, curveLock, curveArc },
|
||||
fitLimits(),
|
||||
);
|
||||
plannedLine = built.vertices;
|
||||
curveInfo = built.curves;
|
||||
nodeInfo = built.nodes;
|
||||
@@ -389,7 +378,7 @@ export async function mountRouteEditor(
|
||||
|
||||
/** 상태줄 꼬리 — 셈은 `_Edits` 몫. */
|
||||
const curveHint = (): string =>
|
||||
curveSummary({
|
||||
edits.curveSummary({
|
||||
nodeCount: planned.length,
|
||||
curveOn,
|
||||
curveRadius,
|
||||
@@ -400,6 +389,7 @@ export async function mountRouteEditor(
|
||||
minRadiusM,
|
||||
fresh: nodeInfo.length === 0,
|
||||
offStation: stationSnap ? fit.offStationCount(plannedLine, curveInfo, snap()) : 0,
|
||||
flags: edits.routeFlags(planned, curveOn, curveInfo), // 겹친 노드 · 못 그린 곡선(430)
|
||||
});
|
||||
|
||||
// ── 곡선 라벨 — 고른 꺾임점 옆에 뜨는 조작 패널. 배선은 `_CurveBar` 몫 ──
|
||||
@@ -433,9 +423,14 @@ export async function mountRouteEditor(
|
||||
const syncCurveBar = curveBar.sync;
|
||||
|
||||
/** 한 번의 편집을 마무리한다 — 다시 그리고, 라벨·상태줄을 맞추고, 되돌리기에 쌓는다.
|
||||
* 측점 스냅 켬이면 고친 자리 앞 곡선부터 MC 를 일반측점에(366-3 · 되살림 `fitting=false` 은 안 맞춤). */
|
||||
* 측점 스냅 켬이면 고친 자리 앞 곡선부터 MC 를 일반측점에(366-3 · 되살림 `fitting=false` 은 안 맞춤).
|
||||
* 하한 검사 한 곳(430) — 지난 걸음이 지키던 하한을 새로 깨면 그 걸음으로 되돌리고 까닭을 상태줄에. */
|
||||
function applyEdit(message: string, record = true, fitting = true): void {
|
||||
const from = fit.fitStart(history?.current?.(), snapshotNow());
|
||||
const before = history?.current?.();
|
||||
markEdited();
|
||||
const stop = fitting && before ? edits.floorStop(before, planned, nodeInfo, fitLimits()) : "";
|
||||
if (stop && before) return restoreSnapshot(before, stop, false);
|
||||
const from = fit.fitStart(before, snapshotNow());
|
||||
if (stationSnap && fitting) planned = fit.fitCurveStations(snapshotNow(), fitLimits(), from);
|
||||
markEdited();
|
||||
writeRouteLocks(projectId, planned, apexLock); // 고정은 [취소] · 다시 열기에도 남는다(22-5).
|
||||
@@ -446,6 +441,13 @@ export async function mountRouteEditor(
|
||||
historyControls.sync();
|
||||
}
|
||||
|
||||
/** 계산 묶음에 알림 — 노선 · 분석 지형 · 스냅이 저장분과 다르면 초안 · 같으면 null(352-3 · 430). */
|
||||
function tellDraft(): void {
|
||||
if (!history) return;
|
||||
const dirty = history.isDirty() || pickedTerrain() !== designTerrain || snap.changed();
|
||||
options.draft?.edited(dirty ? draftLink.draftOfSnapshot(snapshotNow(), snap.draft()) : null);
|
||||
}
|
||||
|
||||
/** 측점 스냅 맞춤 값 — 하한 · 스냅 간격(390-2). */
|
||||
function fitLimits(): fit.FitLimits {
|
||||
return { minRadiusM, limitRadiusM, limitArcM, intervalM: snap() };
|
||||
@@ -526,10 +528,10 @@ export async function mountRouteEditor(
|
||||
routeHead,
|
||||
curveHint,
|
||||
contourHint,
|
||||
commit: () => {
|
||||
if (stationSnap) return applyEdit(snap.text()); // 놓을 때(366-3)
|
||||
history?.commit(snapshotNow());
|
||||
historyControls.sync();
|
||||
commit: (index) => {
|
||||
const before = history?.current?.()?.planned ?? []; // 놓을 때 맞춤(366-3) · 하한 · 보고(430)
|
||||
applyEdit(stationSnap ? snap.text() : "옮겼습니다.");
|
||||
if (stationSnap && index !== undefined) curveBar.noteFit(snap.text(), before, index);
|
||||
},
|
||||
snapStepM: snap,
|
||||
fitDrag: (index) => {
|
||||
@@ -546,7 +548,7 @@ export async function mountRouteEditor(
|
||||
segmentAt: pointer.segmentAt,
|
||||
nodeAt: pointer.nodeAt,
|
||||
insert: (segment, px, py) => {
|
||||
spliceNode(snapshotNow(), segment + 1, toMetric(px, py)); // 편집값도 같은 자리에 끼운다.
|
||||
edits.spliceNode(snapshotNow(), segment + 1, toMetric(px, py)); // 편집값도 같은 자리에 끼운다.
|
||||
picked = segment + 1;
|
||||
applyEdit("새 노드를 넣었습니다(직선 추가).");
|
||||
},
|
||||
@@ -554,7 +556,7 @@ export async function mountRouteEditor(
|
||||
if (planned.length <= 2) return showToast("노선은 노드가 2개 이상이어야 합니다.", "error");
|
||||
if (apexLock[index])
|
||||
return showToast("고정한 점은 못 지웁니다 — 고정을 먼저 푸세요.", "error");
|
||||
spliceNode(snapshotNow(), index);
|
||||
edits.spliceNode(snapshotNow(), index);
|
||||
picked = -1;
|
||||
applyEdit("노드를 지웠습니다(직선 삭제).");
|
||||
},
|
||||
@@ -578,7 +580,7 @@ export async function mountRouteEditor(
|
||||
overlay,
|
||||
busy,
|
||||
projectId,
|
||||
nodes: () => ({ planned, curveOn, curveRadius }),
|
||||
nodes: () => ({ planned, curveOn, curveRadius, curveLock, curveArc }),
|
||||
// 분석 지형만 바꿔도 [확인]이 설계 지형을 바꿔 다시 셈한다(PLAN 133-2).
|
||||
changed: () =>
|
||||
(history?.isDirty() ?? false) || pickedTerrain() !== designTerrain || snap.changed(),
|
||||
@@ -612,7 +614,7 @@ export async function mountRouteEditor(
|
||||
limitArcM = plan.limit_curve_length_m ?? 0;
|
||||
setStationSnap(snap.load(plan));
|
||||
// 곡선 성분을 편집할 수 있는 꼴로 편다 — 셈은 `_Edits` 몫(까닭도 그쪽에 적었다).
|
||||
const flat = flattenServerPlan(nodes, plan.curves ?? []);
|
||||
const flat = edits.flattenServerPlan(nodes, plan.curves ?? [], plan.node_edits);
|
||||
({ planned, curveOn, curveRadius, curveLock, curveArc } = flat);
|
||||
apexLock = lockColumn(planned, readRouteLocks(projectId)); // 닫기 전 고정을 좌표로 되살린다.
|
||||
({ nodes: nodeInfo, curves: curveInfo } = flat);
|
||||
@@ -668,9 +670,7 @@ export async function mountRouteEditor(
|
||||
let terrainTicket = 0;
|
||||
terrainSelect.addEventListener("change", () => {
|
||||
setAnalysisTerrain(projectId, terrainSelect.value === "sheet" ? "sheet" : "las");
|
||||
// 계산 묶음에 알림 — 노선이 그대로여도 지형이 설계와 다르면 초안으로 다시 셈(352-3).
|
||||
const dirty = history?.isDirty() || pickedTerrain() !== designTerrain;
|
||||
options.draft?.edited(dirty ? draftLink.draftOfSnapshot(snapshotNow(), snap.draft()) : null);
|
||||
tellDraft(); // 노선이 그대로여도 지형이 설계와 다르면 초안으로 다시 셈(352-3).
|
||||
const mine = ++terrainTicket;
|
||||
void loadBackground().then((background) => {
|
||||
if (closed || mine !== terrainTicket) return;
|
||||
|
||||
@@ -39,7 +39,10 @@ import type { SnapSetting } from "./B05_Profile_UI_RouteEdit_SnapStep";
|
||||
|
||||
type Vertex = [number, number];
|
||||
type RouteSettings = SnapSetting & { terrain: string | null };
|
||||
type RouteNodes = { planned: Vertex[]; curveOn: boolean[]; curveRadius: Array<number | null> };
|
||||
type RouteNodes = { planned: Vertex[]; curveOn: boolean[]; curveRadius: Array<number | null> } & {
|
||||
curveLock?: RouteDraft["curveLock"];
|
||||
curveArc?: Array<number | null>;
|
||||
};
|
||||
|
||||
export interface RouteApplyParams {
|
||||
/** 옛 [노선 반영] 자리(단추 · 대기 막) — 346-3 부터 안 씀(대기는 페이지 잠금 막 하나). */
|
||||
@@ -72,15 +75,15 @@ interface RouteSource {
|
||||
|
||||
const sources = new Map<string, RouteSource>();
|
||||
|
||||
/** 노드 · 곡선 편집값 → 계약 `RouteDraft`(붙든 값은 서버가 안 씀 · 칸 길이만 맞춤). */
|
||||
/** 노드 · 곡선 편집값 → 계약 `RouteDraft`(R · 길이 고정도 실음 — 서버가 곡선표 `edits` 에 둠 · 430). */
|
||||
export function routeDraftOf(nodes: RouteNodes, settings: RouteSettings): RouteDraft {
|
||||
return {
|
||||
rev: 0,
|
||||
nodes: nodes.planned.map(([x, y]): Vertex => [x, y]),
|
||||
curveOn: nodes.planned.map((_, index) => nodes.curveOn[index] !== false),
|
||||
curveRadius: nodes.planned.map((_, index) => nodes.curveRadius[index] ?? null),
|
||||
curveLock: nodes.planned.map(() => null),
|
||||
curveArc: nodes.planned.map(() => null),
|
||||
curveLock: nodes.planned.map((_, index) => nodes.curveLock?.[index] ?? null),
|
||||
curveArc: nodes.planned.map((_, index) => nodes.curveArc?.[index] ?? null),
|
||||
stationSnap: settings.stationSnap,
|
||||
stationSnapStep: settings.stationSnapStep ?? null,
|
||||
terrain: settings.terrain,
|
||||
|
||||
@@ -10,8 +10,10 @@
|
||||
* 들고 간다. 두 벌로 두면 교각이 바뀔 때 서로 어긋난다(`_Edits.ts` 설명 참고).
|
||||
* ========================================================================== */
|
||||
|
||||
import { showToast } from "@ui/ui_template_elements";
|
||||
import type { EditedCurve, EditedNode, Vertex } from "./logic/B05_Profile_UI_RouteEdit_Curve";
|
||||
import {
|
||||
CURVE_OPTIONAL_INNER_ANGLE_DEG,
|
||||
curveOptionalAt,
|
||||
deflectionRad,
|
||||
radiusFloorM,
|
||||
@@ -63,6 +65,8 @@ export interface CurveBar {
|
||||
label: CurveLabel;
|
||||
/** 고른 자리에 맞춰 패널을 옮겨 그린다. */
|
||||
sync: () => void;
|
||||
/** 끌기 · 손잡이 놓을 때 맞춤 결과를 상태줄 `message` 뒤에(430 · 스냅 끔이면 그대로). */
|
||||
noteFit: (message: string, before: Vertex[], picked: number) => void;
|
||||
}
|
||||
|
||||
export function createCurveBar(params: CurveBarParams): CurveBar {
|
||||
@@ -120,10 +124,17 @@ export function createCurveBar(params: CurveBarParams): CurveBar {
|
||||
params.applyEdit(locked ? `${name}을 고정했습니다.` : `${name} 고정을 풀었습니다.`);
|
||||
},
|
||||
onCurveOn: (on) => {
|
||||
const { picked, curveOn } = params.state();
|
||||
const { picked, curveOn, nodeInfo } = params.state();
|
||||
if (picked < 0) return;
|
||||
curveOn[picked] = on;
|
||||
params.applyEdit(on ? "곡선을 넣었습니다." : "곡선을 지웠습니다.");
|
||||
// 내각 155° 미만 = 곡선을 둬야 하는 자리(별표2 Ⅰ.2.다.(1)) — 막지 않고 경고(430).
|
||||
const inner = nodeInfo[picked]?.inner_angle_deg ?? null;
|
||||
const warn =
|
||||
!on && inner !== null && !curveOptionalAt(inner)
|
||||
? ` — 내각 ${inner.toFixed(1)}° < ${CURVE_OPTIONAL_INNER_ANGLE_DEG}° 곡선 자리(경고)`
|
||||
: "";
|
||||
params.applyEdit(on ? "곡선을 넣었습니다." : `곡선을 지웠습니다${warn}.`);
|
||||
if (warn) showToast(`곡선을 지웠습니다${warn}.`, "warning", 5000);
|
||||
},
|
||||
},
|
||||
params.container,
|
||||
@@ -133,7 +144,7 @@ export function createCurveBar(params: CurveBarParams): CurveBar {
|
||||
* 앞뒤 직선 짧은 쪽 절반까지(`buildEditedPolyline` · 서버 짝 같은 규칙)라 큰 R 은 조용히 눌렸다.
|
||||
* 스냅 켬이면 맞춤이 민 교점 · 못 맞춘 곡선을 덧붙임(408-1 · `before` = 입력 전 교점). */
|
||||
function noteResult(message: string, name: "반지름" | "곡선 길이", before: Vertex[]): void {
|
||||
const { picked, curveRadius, curveInfo, nodeInfo, planned, line, snap } = params.state();
|
||||
const { picked, curveRadius, curveInfo, nodeInfo } = params.state();
|
||||
const status = params.container.querySelector<HTMLElement>(".b05-routeedit__status");
|
||||
if (!status) return;
|
||||
const asked = curveRadius[picked];
|
||||
@@ -144,17 +155,29 @@ export function createCurveBar(params: CurveBarParams): CurveBar {
|
||||
asked === null || asked === undefined || !drawn || drawn.radius_m >= asked - 0.05
|
||||
? message.replace(/\.$/, "")
|
||||
: `${name} ${m(asked * per)} → ${m(drawn.radius_m * per)}(앞뒤 직선이 짧아 접선 자리 모자람)`;
|
||||
const tail = snap
|
||||
? fitNote(
|
||||
before,
|
||||
planned,
|
||||
picked,
|
||||
offStationMcs(line, curveInfo, snap.stepM),
|
||||
snap.stationM,
|
||||
snap.stepM,
|
||||
)
|
||||
: "";
|
||||
status.textContent = (status.textContent ?? "").replace(message, `${head}${tail}.`);
|
||||
status.textContent = (status.textContent ?? "").replace(
|
||||
message,
|
||||
`${head}${fitTail(before, picked, false)}.`,
|
||||
);
|
||||
}
|
||||
|
||||
/** 맞춤이 민 교점 · 못 맞춘 곡선 꼬리 — 스냅 끔이면 ""(`hand` = 고른 IP 를 손이 옮김). */
|
||||
function fitTail(before: Vertex[], picked: number, hand: boolean): string {
|
||||
const { curveInfo, planned, line, snap } = params.state();
|
||||
if (!snap) return "";
|
||||
const off = offStationMcs(line, curveInfo, snap.stepM);
|
||||
return fitNote(before, planned, picked, off, snap.stationM, snap.stepM, hand);
|
||||
}
|
||||
|
||||
/** 끌기 · 손잡이 놓을 때(430) — 상태줄 `message` 뒤에 맞춤 결과(`before` = 누르기 전 교점). */
|
||||
function noteFit(message: string, before: Vertex[], picked: number): void {
|
||||
const status = params.container.querySelector<HTMLElement>(".b05-routeedit__status");
|
||||
const tail = fitTail(before, picked, true);
|
||||
if (status && tail)
|
||||
status.textContent = (status.textContent ?? "").replace(
|
||||
message,
|
||||
`${message.replace(/\.$/, "")}${tail}.`,
|
||||
);
|
||||
}
|
||||
|
||||
/** 고른 자리에 맞춰 라벨을 옮겨 그린다. 끝점은 곡선이 없어 **고정 단추만** 낸다(계획서 22-5). */
|
||||
@@ -238,5 +261,5 @@ export function createCurveBar(params: CurveBarParams): CurveBar {
|
||||
});
|
||||
}
|
||||
|
||||
return { label, sync };
|
||||
return { label, sync, noteFit };
|
||||
}
|
||||
|
||||
@@ -34,6 +34,7 @@ import {
|
||||
import { markShown } from "./B05_Profile_UI_RouteEdit_Marks";
|
||||
import {
|
||||
curveShortfalls,
|
||||
floorNote,
|
||||
radiusFloorM,
|
||||
shortfallCrossed,
|
||||
type CurveLock,
|
||||
@@ -98,8 +99,8 @@ export interface RouteEditPointerParams {
|
||||
routeHead: () => string;
|
||||
curveHint: () => string;
|
||||
contourHint: () => string;
|
||||
/** 끌기 한 번을 되돌리기에 쌓는다. */
|
||||
commit: () => void;
|
||||
/** 끌기 한 번을 되돌리기에 쌓는다 — `index` = 끈 교각점(430 · 놓을 때 맞춤 보고 · 방향키는 안 줌). */
|
||||
commit: (index?: number) => void;
|
||||
/** 스냅 간격(m · 390-5) — 스냅 켬이면 방향키 한 걸음. */
|
||||
snapStepM: () => number;
|
||||
/** 끄는 중 · 방향키 걸음 미리보기(390-5) — 스냅 켬이면 IP `index` 자리 그대로 MC 를 간격 배수에 ·
|
||||
@@ -308,6 +309,9 @@ export function bindRouteEditPointer(params: RouteEditPointerParams): RouteEditP
|
||||
const node = dragHandle.node;
|
||||
const moved = dragHandleTo(node, dragHandle.end, toMetric(px, py));
|
||||
if (moved) {
|
||||
// 교각점이 움직여 이웃 곡선 접선 자리도 바뀜 — 지키던 하한을 새로 깨면 그 걸음만 되돌림(430).
|
||||
const before = curveShortfalls(state.nodeInfo, state.limitRadiusM, state.limitArcM);
|
||||
const kept = [state.planned[node], state.curveRadius[node], state.curveOn[node]] as const;
|
||||
state.planned[node] = moved.apex;
|
||||
// 손으로 끌어도 하한 아래로는 안 내려간다 — 거기서 멈춘다(계획서 0-9 ④).
|
||||
// 하한은 그 자리의 교각까지 본 값이라 L 하한도 함께 지켜진다.
|
||||
@@ -319,8 +323,21 @@ export function bindRouteEditPointer(params: RouteEditPointerParams): RouteEditP
|
||||
params.setPicked(node);
|
||||
// 손잡이 자리는 다시 셈한 곡선에서 나온다 — 접선 자리가 모자라 R 이 눌리면 손이
|
||||
// 끄는 자리보다 덜 따라오고, 그 눌림이 그 자리에서 눈에 보인다.
|
||||
dragMoved = true;
|
||||
params.markEdited();
|
||||
const after = params.state();
|
||||
if (
|
||||
shortfallCrossed(
|
||||
before,
|
||||
curveShortfalls(after.nodeInfo, after.limitRadiusM, after.limitArcM),
|
||||
)
|
||||
) {
|
||||
[state.planned[node], state.curveRadius[node], state.curveOn[node]] = kept;
|
||||
params.markEdited();
|
||||
status.textContent = `${params.routeHead()} — 하한에 걸려 더 못 옮깁니다${floorNote(state.limitRadiusM, state.limitArcM)}.`;
|
||||
params.draw();
|
||||
return;
|
||||
}
|
||||
dragMoved = true;
|
||||
params.syncCurveBar();
|
||||
status.textContent = `${params.routeHead()} — 곡선을 잡는 중. ${params.curveHint()}`;
|
||||
params.draw();
|
||||
@@ -350,9 +367,7 @@ export function bindRouteEditPointer(params: RouteEditPointerParams): RouteEditP
|
||||
state.planned[dragNode] = previous;
|
||||
params.markEdited();
|
||||
fitPreview(state.planned);
|
||||
status.textContent =
|
||||
`${params.routeHead()} — 하한에 걸려 더 못 옮깁니다` +
|
||||
`(곡선반지름 ${state.limitRadiusM}m${state.limitArcM > 0 ? ` · 곡선 길이 ${state.limitArcM}m` : ""}).`;
|
||||
status.textContent = `${params.routeHead()} — 하한에 걸려 더 못 옮깁니다${floorNote(state.limitRadiusM, state.limitArcM)}.`;
|
||||
params.draw();
|
||||
return;
|
||||
}
|
||||
@@ -395,7 +410,7 @@ export function bindRouteEditPointer(params: RouteEditPointerParams): RouteEditP
|
||||
// 끌기 **한 번**이 되돌리기 한 걸음이다 — 프레임마다 쌓으면 한 번 물리는 데 수십 번
|
||||
// 눌러야 한다. 놓는 순간에만 쌓는다.
|
||||
if (dragMoved) {
|
||||
params.commit();
|
||||
params.commit(dragHandle?.node ?? dragNode);
|
||||
// 노선이 바뀌었다 — 보던 측점 횡단을 다시 셈해 **전후로** 늘어놓는다(계획서 0-9 ⑲).
|
||||
// 끄는 동안에는 한 번도 안 부른다(한 장에 0.7초).
|
||||
void params.crossPreview.refresh();
|
||||
|
||||
@@ -98,7 +98,8 @@ export function nudgeMessage(report: NudgeReport, snapping: boolean): string {
|
||||
}
|
||||
|
||||
/** 반지름 · 곡선 길이 입력 뒤 맞춤 결과 꼬리(408-1) — 손으로 옮긴 교점이 없으니 고른 IP 도 「밀림」에 셈 ·
|
||||
* 못 맞춘 곡선 = 측점 밖 MC(`offStationMcs`)를 측점 표기로(셋까지 · 나머지 「외 N」). */
|
||||
* 못 맞춘 곡선 = 측점 밖 MC(`offStationMcs`)를 측점 표기로(셋까지 · 나머지 「외 N」).
|
||||
* `handMoved` = 끌기 · 손잡이로 고른 IP 를 손이 옮김(430 · 놓을 때) — 고른 IP 는 「밀림」에 안 셈. */
|
||||
export function fitNote(
|
||||
before: ReadonlyArray<Vertex>,
|
||||
after: ReadonlyArray<Vertex>,
|
||||
@@ -106,10 +107,11 @@ export function fitNote(
|
||||
offMcs: ReadonlyArray<number>,
|
||||
stationM: number,
|
||||
stepM: number,
|
||||
handMoved = false,
|
||||
): string {
|
||||
const start = before[picked] ?? [0, 0];
|
||||
const report = nudgeReport(before, after, picked, start, start);
|
||||
const pushed = report.pushed + (report.movedM > SAME_M ? 1 : 0);
|
||||
const pushed = report.pushed + (!handMoved && report.movedM > SAME_M ? 1 : 0);
|
||||
const names = offMcs.map((mc) => `No.${stationLabel(mc, stationM, stepM < 1 ? 1 : 0)}`);
|
||||
const more = names.length > 3 ? ` 외 ${names.length - 3}` : "";
|
||||
const off = names.length ? ` · 못 맞춘 곡선 ${names.slice(0, 3).join(", ")}${more}` : "";
|
||||
|
||||
@@ -14,16 +14,10 @@
|
||||
* 순수 계산 — 화면 · fetch · sessionStorage 없음. 부르는 쪽은 `B05_Profile_UI_RouteEdit`.
|
||||
* ========================================================================== */
|
||||
|
||||
import type { EditedCurve, EditedPolyline, Vertex } from "./B05_Profile_UI_RouteEdit_Curve";
|
||||
import {
|
||||
buildEditedPolyline,
|
||||
type EditedCurve,
|
||||
type EditedPolyline,
|
||||
type Vertex,
|
||||
} from "./B05_Profile_UI_RouteEdit_Curve";
|
||||
import {
|
||||
applyArcLocks,
|
||||
applyCurveLimits,
|
||||
curveShortfalls,
|
||||
rebuildLine,
|
||||
shortfallCrossed,
|
||||
type NodeColumns,
|
||||
} from "./B05_Profile_UI_RouteEdit_Edits";
|
||||
@@ -47,10 +41,7 @@ type Columns = Pick<NodeColumns, "curveOn" | "curveRadius" | "curveLock" | "curv
|
||||
|
||||
/** 편집 창 `markEdited` 와 같은 길(길이 고정 R · 하한 끌어올림 → 선) — 값은 사본에. */
|
||||
function build(cols: Columns, planned: Vertex[], limits: FitLimits): EditedPolyline {
|
||||
const radius = [...cols.curveRadius];
|
||||
applyArcLocks(planned, cols.curveLock, cols.curveArc, radius);
|
||||
applyCurveLimits(planned, cols.curveOn, radius, limits.limitRadiusM, limits.limitArcM);
|
||||
return buildEditedPolyline(planned, cols.curveOn, radius, limits.minRadiusM);
|
||||
return rebuildLine({ ...cols, planned, curveRadius: [...cols.curveRadius] }, limits);
|
||||
}
|
||||
|
||||
/** 꺾임점 `k` 곡선의 MC 누가거리 — 곡선이 없으면 null. */
|
||||
|
||||
@@ -42,7 +42,7 @@ export interface EditedCurve {
|
||||
}
|
||||
|
||||
/** 짝: `DUPLICATE_TOLERANCE_M`. 이보다 가까운 뒤엣점은 같은 자리로 보고 버린다. */
|
||||
const DUPLICATE_TOLERANCE_M = 0.5;
|
||||
export const DUPLICATE_TOLERANCE_M = 0.5;
|
||||
/** 짝: `ARC_STEP_DEG`. 원호를 몇 도마다 한 점씩 찍을지. */
|
||||
const ARC_STEP_DEG = 5.0;
|
||||
/** 짝: `math.degrees`/`math.radians` — 파이썬은 **상수 하나를 곱한다**. 곱셈 순서가 다르면
|
||||
|
||||
@@ -18,12 +18,18 @@
|
||||
* 다만 **내각 155° 이상은 뺀다**(별표2 Ⅰ.2.다.(1) 「내각 155도 이상 되는 장소는 곡선을
|
||||
* 설치하지 아니할 수 있다」). 거기서 L 을 채우라고 하면 교각이 0 에 가까워 R 이 수십 배로
|
||||
* 부풀고, **아무것도 안 고쳤는데 노선이 휜다**(실측: 내각 174.8° 자리가 R 12m → 55m).
|
||||
*
|
||||
* ⚠ 짝(430) — `flattenServerPlan` 이 읽는 넣은 값 `edits` ↔ `B05_Profile_Route_NodeEdits.py`(쓰기) ·
|
||||
* 거울 시험 `test_430_route_edit_rules.py`.
|
||||
* ========================================================================== */
|
||||
|
||||
import {
|
||||
buildEditedPolyline,
|
||||
DUPLICATE_TOLERANCE_M,
|
||||
innerAngleDeg,
|
||||
type EditedCurve,
|
||||
type EditedNode,
|
||||
type EditedPolyline,
|
||||
type Vertex,
|
||||
} from "./B05_Profile_UI_RouteEdit_Curve";
|
||||
|
||||
@@ -154,6 +160,97 @@ export function shortfallCrossed(before: readonly number[], after: readonly numb
|
||||
return after.some((value, index) => value > 1e-6 && before[index] <= 1e-6);
|
||||
}
|
||||
|
||||
/** 선을 짜는 값 — 기본 반지름 · 못 넘는 하한(R · L). */
|
||||
export interface CurveLimits {
|
||||
minRadiusM: number;
|
||||
limitRadiusM: number;
|
||||
limitArcM: number;
|
||||
}
|
||||
|
||||
/** 편집 창 `markEdited` 의 셈 — 길이를 붙든 자리 R 다시 잡기 → 지정값 하한까지 끌어올림(`curveRadius`
|
||||
* 를 고침) → 선. 교각이 바뀌었을 수 있어 R 부터 잡고 그린다. */
|
||||
export function rebuildLine(
|
||||
cols: Omit<NodeColumns, "apexLock">,
|
||||
limits: CurveLimits,
|
||||
): EditedPolyline {
|
||||
applyArcLocks(cols.planned, cols.curveLock, cols.curveArc, cols.curveRadius);
|
||||
applyCurveLimits(
|
||||
cols.planned,
|
||||
cols.curveOn,
|
||||
cols.curveRadius,
|
||||
limits.limitRadiusM,
|
||||
limits.limitArcM,
|
||||
);
|
||||
return buildEditedPolyline(cols.planned, cols.curveOn, cols.curveRadius, limits.minRadiusM);
|
||||
}
|
||||
|
||||
/** 하한 글 꼬리 — 「(곡선반지름 12m · 곡선 길이 20m)」. */
|
||||
export function floorNote(limitRadiusM: number, limitArcM: number): string {
|
||||
return `(곡선반지름 ${limitRadiusM}m${limitArcM > 0 ? ` · 곡선 길이 ${limitArcM}m` : ""})`;
|
||||
}
|
||||
|
||||
/** 자리 번호 셋까지 「IP3 · IP5 외 2」. */
|
||||
const ipList = (seats: ReadonlyArray<number>): string =>
|
||||
seats
|
||||
.slice(0, 3)
|
||||
.map((seat) => `IP${seat}`)
|
||||
.join(" · ") + (seats.length > 3 ? ` 외 ${seats.length - 3}` : "");
|
||||
|
||||
/**
|
||||
* 이번 편집이 하한을 **새로** 깼으면 까닭 한 줄 · 아니면 ""(430 · 모든 평면 조작이 `applyEdit` 한 곳에서).
|
||||
* `before` = 지난 걸음 사진 · `nodes` = 지금 노드 요약(스냅 맞춤 전 — 맞춤은 스스로 하한을 지킴).
|
||||
* 노드를 하나 끼우거나 뺐으면 처음 달라진 자리에서 줄을 맞춰 견줌(새 노드 = 지키던 자리) · 둘 넘게 다르면 안 견줌.
|
||||
*/
|
||||
export function floorStop(
|
||||
before: NodeColumns,
|
||||
planned: ReadonlyArray<Vertex>,
|
||||
nodes: ReadonlyArray<EditedNode>,
|
||||
limits: CurveLimits,
|
||||
): string {
|
||||
const gap = planned.length - before.planned.length;
|
||||
if (Math.abs(gap) > 1) return "";
|
||||
const built = rebuildLine({ ...before, curveRadius: [...before.curveRadius] }, limits);
|
||||
const was = curveShortfalls(built.nodes, limits.limitRadiusM, limits.limitArcM);
|
||||
const now = curveShortfalls(nodes, limits.limitRadiusM, limits.limitArcM);
|
||||
const differ = planned.findIndex(
|
||||
(vertex, i) => vertex[0] !== before.planned[i]?.[0] || vertex[1] !== before.planned[i]?.[1],
|
||||
);
|
||||
const at = differ < 0 ? planned.length : differ;
|
||||
const old = (i: number): number =>
|
||||
(gap === 0 || i < at ? was[i] : gap > 0 ? (i === at ? 0 : was[i - 1]) : was[i + 1]) ?? 0;
|
||||
const seats = now.flatMap((value, i) => (value > 1e-6 && old(i) <= 1e-6 ? [i] : []));
|
||||
if (!seats.length) return "";
|
||||
return `하한에 걸려 되돌렸습니다 — ${ipList(seats)}${floorNote(limits.limitRadiusM, limits.limitArcM)}.`;
|
||||
}
|
||||
|
||||
/** 상태줄 표시(430) — 겹친 노드(앞 노드에서 0.5 m 안 · 선을 짤 때 버림 · 짝 `DUPLICATE_TOLERANCE_M`) ·
|
||||
* 못 그린 곡선(켬인데 곡선이 없음 · 곧은 자리 · 겹친 노드는 뺌). */
|
||||
export function routeFlags(
|
||||
planned: ReadonlyArray<Vertex>,
|
||||
curveOn: ReadonlyArray<boolean>,
|
||||
curves: ReadonlyArray<EditedCurve>,
|
||||
): { overlap: number[]; undrawn: number[] } {
|
||||
const overlap: number[] = [];
|
||||
let last: Vertex | null = null;
|
||||
planned.forEach((vertex, i) => {
|
||||
if (last && Math.hypot(vertex[0] - last[0], vertex[1] - last[1]) <= DUPLICATE_TOLERANCE_M)
|
||||
overlap.push(i);
|
||||
else last = vertex;
|
||||
});
|
||||
const drawn = new Set(curves.map((curve) => curve.node_first));
|
||||
const undrawn = planned.flatMap((vertex, i) =>
|
||||
i === 0 ||
|
||||
i === planned.length - 1 ||
|
||||
curveOn[i] === false ||
|
||||
drawn.has(i) ||
|
||||
overlap.includes(i) ||
|
||||
!(innerAngleDeg(planned[i - 1], vertex, planned[i + 1]) < 179.9)
|
||||
? []
|
||||
: [i],
|
||||
);
|
||||
return { overlap, undrawn };
|
||||
}
|
||||
|
||||
export interface CurveSummaryInput {
|
||||
nodeCount: number;
|
||||
curveOn: boolean[];
|
||||
@@ -170,6 +267,8 @@ export interface CurveSummaryInput {
|
||||
fresh: boolean;
|
||||
/** 측점 스냅 켬 때 MC 가 일반측점 밖인 곡선 수(366-3) — 끔이면 0. */
|
||||
offStation?: number;
|
||||
/** 겹친 노드 · 못 그린 곡선 자리(430 · `routeFlags`). */
|
||||
flags?: { overlap: number[]; undrawn: number[] };
|
||||
}
|
||||
|
||||
/** 상태줄 꼬리 — 곡선 수·기준 미달·사용자가 손댄 자리를 한 줄로. */
|
||||
@@ -187,6 +286,7 @@ export function curveSummary(input: CurveSummaryInput): string {
|
||||
]
|
||||
.filter(Boolean)
|
||||
.join(" · ");
|
||||
const { overlap, undrawn } = input.flags ?? { overlap: [], undrawn: [] };
|
||||
if (input.fresh) {
|
||||
const base = input.minRadiusM ? `곡선 기준 R ${input.minRadiusM}m — [저장] 때 반영` : "";
|
||||
return edits ? `${base}${base ? " · " : ""}${edits}` : base;
|
||||
@@ -195,6 +295,8 @@ export function curveSummary(input: CurveSummaryInput): string {
|
||||
`곡선 ${input.curveCount}곳(하한 R ${input.minRadiusM}m)` +
|
||||
`${input.violationCount ? ` · 기준 미달 ${input.violationCount}곳` : ""}` +
|
||||
`${input.offStation ? ` · 측점 밖 곡선 ${input.offStation}개` : ""}` +
|
||||
`${overlap.length ? ` · 겹친 노드 ${ipList(overlap)}(0.5 m 안 · 선에서 빠짐)` : ""}` +
|
||||
`${undrawn.length ? ` · 못 그린 곡선 ${ipList(undrawn)}` : ""}` +
|
||||
`${edits ? ` · ${edits}` : ""}`
|
||||
);
|
||||
}
|
||||
@@ -219,6 +321,15 @@ interface ServerNode {
|
||||
violations?: string[];
|
||||
}
|
||||
|
||||
/** 노드마다 넣은 편집값(430) — 곡선표 `edits` 칸 · 서버 `node_edits`(⚠ 짝 `B05_Profile_Route_NodeEdits.py`). */
|
||||
export interface RouteNodeEdit {
|
||||
curve: boolean;
|
||||
/** 넣은 R(그린 R 아님 · 접선 자리에 눌렸어도 넣은 값) · null = 자동. */
|
||||
radius_m: number | null;
|
||||
lock: CurveLock;
|
||||
arc_m: number | null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 서버가 준 노드·곡선을 **꺾임점 하나 = 곡선 하나**로 편다(2026-09-07).
|
||||
*
|
||||
@@ -231,8 +342,15 @@ interface ServerNode {
|
||||
* ⚠ 서버가 **곡선을 안 둔 자리는 「곡선 없음」으로 연다**. 전부 켬으로 열면 아무것도 안
|
||||
* 만지고 [확인]만 눌러도 그 자리에 곡선이 새로 생겨 노선이 조용히 바뀐다(서버의 편집
|
||||
* 갈래는 켜진 자리마다 원호를 끼운다). 내각 179° 이상인 자리가 그렇다.
|
||||
*
|
||||
* `edits`(430 · 노드 수와 같을 때만 서버가 줌)가 있으면 곡선 켬끔 · R · 고정 · 고정 길이는 **넣은 값**으로 —
|
||||
* 그린 R 로 열면 접선 자리에 눌린 R 이 넣은 값으로 굳고 R · 길이 고정이 [저장] 뒤 사라짐.
|
||||
*/
|
||||
export function flattenServerPlan(nodes: ServerNode[], curves: EditedCurve[]): FlattenedPlan {
|
||||
export function flattenServerPlan(
|
||||
nodes: ServerNode[],
|
||||
curves: EditedCurve[],
|
||||
edits?: ReadonlyArray<RouteNodeEdit> | null,
|
||||
): FlattenedPlan {
|
||||
const replaced = new Map<number, EditedCurve>();
|
||||
const dropped = new Set<number>();
|
||||
curves.forEach((curve) => {
|
||||
@@ -263,11 +381,14 @@ export function flattenServerPlan(nodes: ServerNode[], curves: EditedCurve[]): F
|
||||
tangent_m: null,
|
||||
violations: curve ? (curve.violations ?? []) : (node.violations ?? []),
|
||||
});
|
||||
out.curveOn.push(curve !== undefined);
|
||||
const edit = edits?.[index];
|
||||
out.curveOn.push(edit ? edit.curve : curve !== undefined);
|
||||
// 서버가 고른 반지름을 **그대로 들고 간다** — 안 그러면 편집 한 번에 하한으로 눌린다.
|
||||
out.curveRadius.push(curve ? Math.round(curve.radius_m * 100) / 100 : null);
|
||||
out.curveLock.push(null);
|
||||
out.curveArc.push(null);
|
||||
out.curveRadius.push(
|
||||
edit ? edit.radius_m : curve ? Math.round(curve.radius_m * 100) / 100 : null,
|
||||
);
|
||||
out.curveLock.push(edit?.lock ?? null);
|
||||
out.curveArc.push(edit?.arc_m ?? null);
|
||||
out.apexLock.push(false);
|
||||
if (curve) out.curves.push({ ...curve, node_first: seat, node_last: seat });
|
||||
});
|
||||
|
||||
@@ -20,6 +20,7 @@ const STUBS = {
|
||||
},
|
||||
centerDirectionOf: () => null,
|
||||
},
|
||||
"@ui/ui_template_elements": { showToast: () => {} }, // 곡선 삭제 경고(430)
|
||||
};
|
||||
|
||||
function loadTs(file) {
|
||||
|
||||
@@ -0,0 +1,137 @@
|
||||
/* 430 평면 형상 제어 규칙 한 곳 — `logic/B05_Profile_UI_RouteEdit_Edits.ts`(하한 검사 · 겹친 노드 ·
|
||||
* 못 그린 곡선 · 넣은 값 되살림) · `_KeyNudge.fitNote` 를 Node 로 돌려 JSON 한 줄
|
||||
* (`test_430_route_edit_rules.py` 가 판정).
|
||||
* node helper_430_route_edit_rules.cjs <서버 곡선표 JSON 파일>
|
||||
*/
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
|
||||
|
||||
const ROOT = path.join(__dirname, "..", "..");
|
||||
const LOGIC = path.join(ROOT, "B05_Profile", "logic");
|
||||
const cache = new Map();
|
||||
|
||||
function loadTs(file) {
|
||||
const full = path.resolve(file);
|
||||
if (cache.has(full)) return cache.get(full);
|
||||
const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(full, box.exports);
|
||||
const localRequire = (request) =>
|
||||
request.startsWith(".")
|
||||
? loadTs(path.join(path.dirname(full), `${request}.ts`))
|
||||
: require(request);
|
||||
new Function("exports", "module", "require", js)(box.exports, box, localRequire);
|
||||
cache.set(full, box.exports);
|
||||
return box.exports;
|
||||
}
|
||||
|
||||
const edits = loadTs(path.join(LOGIC, "B05_Profile_UI_RouteEdit_Edits.ts"));
|
||||
const nudge = loadTs(path.join(LOGIC, "B05_Profile_RouteEdit_KeyNudge.ts"));
|
||||
|
||||
const LIMITS = { minRadiusM: 30, limitRadiusM: 20, limitArcM: 0 };
|
||||
// IP1 · IP2 · IP3 — 직선 넉넉(곡선 R 30 다 들어감)
|
||||
const ROUTE = [
|
||||
[0, 0],
|
||||
[100, 0],
|
||||
[200, 60],
|
||||
[300, 0],
|
||||
[400, 0],
|
||||
];
|
||||
|
||||
function cols(planned) {
|
||||
const n = planned.length;
|
||||
return {
|
||||
planned: planned.map((v) => [v[0], v[1]]),
|
||||
curveOn: Array(n).fill(true),
|
||||
curveRadius: Array(n).fill(null),
|
||||
curveLock: Array(n).fill(null),
|
||||
curveArc: Array(n).fill(null),
|
||||
apexLock: Array(n).fill(false),
|
||||
};
|
||||
}
|
||||
|
||||
/** 지난 걸음 `before` 에서 `change` 로 고친 뒤 하한 검사 글. */
|
||||
function stop(before, change) {
|
||||
const now = cols(before.planned);
|
||||
change(now);
|
||||
const built = edits.rebuildLine(now, LIMITS);
|
||||
return edits.floorStop(before, now.planned, built.nodes, LIMITS);
|
||||
}
|
||||
|
||||
const base = cols(ROUTE);
|
||||
const out = {
|
||||
// 같은 노드 수 — IP2 를 IP1 쪽 8 m 앞으로(IP1 · IP2 접선 자리 모자람 → R 하한 아래)
|
||||
moveBreak: stop(base, (c) => (c.planned[2] = [108, 4])),
|
||||
moveOk: stop(base, (c) => (c.planned[2] = [200, 70])),
|
||||
// 끼우기 — IP1 바로 뒤 4 m 에 새 노드(IP1 접선 자리 2 m)
|
||||
insertBreak: stop(base, (c) => {
|
||||
c.planned.splice(2, 0, [104, 1]);
|
||||
for (const k of ["curveOn", "curveRadius", "curveLock", "curveArc", "apexLock"])
|
||||
c[k].splice(2, 0, k === "curveOn" ? true : k === "apexLock" ? false : null);
|
||||
}),
|
||||
// 지우기 — IP2 를 빼도 IP1 · IP3 넉넉
|
||||
deleteOk: stop(base, (c) => {
|
||||
for (const k of ["planned", "curveOn", "curveRadius", "curveLock", "curveArc", "apexLock"])
|
||||
c[k].splice(2, 1);
|
||||
}),
|
||||
// 둘 넘게 다르면 안 견줌
|
||||
manyGap: stop(base, (c) => {
|
||||
c.planned.splice(1, 0, [50, 0], [52, 0]);
|
||||
for (const k of ["curveOn", "curveRadius", "curveLock", "curveArc", "apexLock"])
|
||||
c[k].splice(
|
||||
1,
|
||||
0,
|
||||
...(k === "curveOn" ? [true, true] : k === "apexLock" ? [false, false] : [null, null]),
|
||||
);
|
||||
}),
|
||||
};
|
||||
|
||||
// 이미 하한을 밑돌던 자리는 「새로」가 아님 — 밑돈 노선에서 다시 조금 옮겨도 통과
|
||||
const broken = cols(ROUTE);
|
||||
broken.planned[2] = [108, 4];
|
||||
out.alreadyBroken = stop(broken, (c) => (c.planned[2] = [108.5, 4.2]));
|
||||
|
||||
// 겹친 노드 · 못 그린 곡선
|
||||
const overlap = [
|
||||
[0, 0],
|
||||
[100, 0],
|
||||
[100.3, 0.2],
|
||||
[200, 60],
|
||||
[300, 0],
|
||||
];
|
||||
out.flags = edits.routeFlags(overlap, Array(5).fill(true), []);
|
||||
out.flagsOff = edits.routeFlags(ROUTE, [true, false, false, false, true], []);
|
||||
out.summary = edits.curveSummary({
|
||||
nodeCount: 5,
|
||||
curveOn: Array(5).fill(true),
|
||||
curveRadius: Array(5).fill(null),
|
||||
curveLock: Array(5).fill(null),
|
||||
apexLock: [],
|
||||
curveCount: 2,
|
||||
violationCount: 0,
|
||||
minRadiusM: 30,
|
||||
fresh: false,
|
||||
flags: out.flags,
|
||||
});
|
||||
|
||||
// fitNote — 손으로 옮긴 고른 IP 는 「밀림」에 안 셈(놓을 때 · 430) · 입력 뒤는 셈(408-1)
|
||||
const after = ROUTE.map((v, i) => (i === 2 ? [v[0] + 3, v[1]] : i === 3 ? [v[0] + 1, v[1]] : v));
|
||||
out.noteHand = nudge.fitNote(ROUTE, after, 2, [], 20, 20, true);
|
||||
out.noteInput = nudge.fitNote(ROUTE, after, 2, [], 20, 20);
|
||||
|
||||
// 짝 — 서버 곡선표(파이썬이 씀)를 그대로 펴서 넣은 값이 돌아오는가
|
||||
const server = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
|
||||
const flat = edits.flattenServerPlan(server.nodes, server.curves, server.edits);
|
||||
out.flat = {
|
||||
planned: flat.planned,
|
||||
curveOn: flat.curveOn,
|
||||
curveRadius: flat.curveRadius,
|
||||
curveLock: flat.curveLock,
|
||||
curveArc: flat.curveArc,
|
||||
};
|
||||
const old = edits.flattenServerPlan(server.nodes, server.curves, null);
|
||||
out.flatOld = { curveRadius: old.curveRadius, curveLock: old.curveLock };
|
||||
process.stdout.write(JSON.stringify(out));
|
||||
@@ -49,6 +49,7 @@ def test_편집기_배선() -> None:
|
||||
assert main.count("setAnalysisTerrain(") == 1 # 바꿀 때 한 곳뿐 — 열 때 쓰기 없음
|
||||
handler = main.split('terrainSelect.addEventListener("change"', 1)[1][:900]
|
||||
assert "setAnalysisTerrain(projectId" in handler
|
||||
assert "options.draft?.edited(" in handler # 바꾸면 계산 묶음에 알림
|
||||
assert "tellDraft()" in handler # 바꾸면 계산 묶음에 알림(430 — 스냅과 한 곳)
|
||||
assert "options.draft?.edited(" in main.split("function tellDraft()", 1)[1][:400]
|
||||
# 설계 지형이 수치지형도면 확정 모델(수치지형도 서피스) 등고선을 「LAS」로 쓰지 않음
|
||||
assert 'analysisTerrain(projectId) === "las" && designTerrain === "las"' in main
|
||||
|
||||
@@ -58,6 +58,7 @@ def test_간격별_상태줄_글(texts, step, want) -> None:
|
||||
def test_편집기는_고른_간격_글을_씀() -> None:
|
||||
edit = (B05 / "B05_Profile_UI_RouteEdit.ts").read_text(encoding="utf-8")
|
||||
assert "일반측점에 맞췄" not in edit
|
||||
assert edit.count("applyEdit(snap.text())") == 2
|
||||
assert edit.count("applyEdit(snap.text())") == 1 # 켬 · 간격 바꿈
|
||||
assert 'applyEdit(stationSnap ? snap.text() : "옮겼습니다.")' in edit # 놓을 때(430)
|
||||
snap = SNAP.read_text(encoding="utf-8")
|
||||
assert "text: () => snapFitText(select.value)" in snap
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
"""430 평면 형상 제어 규칙 한 곳 — 하한 검사(`applyEdit` 한 곳 · 끼우기 · 지우기 · 손잡이) ·
|
||||
곡선 삭제 155° 경고 · 놓을 때 맞춤 보고 · 스냅 끔 · 간격 즉시 계산 줄 · R · 길이 고정 ·
|
||||
넣은 R 곡선표 저장(짝) · 겹친 노드 · 못 그린 곡선 표시.
|
||||
|
||||
TS 셈은 Node(`helper_430_route_edit_rules.cjs`) · 짝 = 파이썬 `_write_planned_polyline` 이 쓴
|
||||
곡선표를 TS `flattenServerPlan` 이 펴서 넣은 값이 돌아오는가.
|
||||
|
||||
./venv/Scripts/python.exe -m pytest resources/tester/test_430_route_edit_rules.py -q
|
||||
"""
|
||||
|
||||
import csv
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from B05_Profile import B05_Profile_Router_Replan as replan # noqa: E402
|
||||
from B05_Profile.B05_Profile_Route_NodeEdits import node_edits # noqa: E402
|
||||
from common_util.common_util_route_polyline import build_planned_polyline # noqa: E402
|
||||
|
||||
B05 = ROOT / "B05_Profile"
|
||||
HELPER = Path(__file__).with_name("helper_430_route_edit_rules.cjs")
|
||||
|
||||
# IP2 뒤 직선 16 m — 넣은 R 200 은 접선 자리에 눌려 그려짐 · IP3 바로 뒤 0.3 m 겹친 점
|
||||
NODES = [(0.0, 0.0), (120.0, 0.0), (220.0, 70.0), (236.0, 70.0), (236.2, 70.2), (340.0, 0.0)]
|
||||
FLAGS = [True, True, True, False, True, True]
|
||||
RADII = [None, 40.0, 200.0, None, None, None]
|
||||
LOCKS = [None, "radius", "arc", None, "radius", "bogus"]
|
||||
ARCS = [None, None, 33.5, None, None, None]
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def saved(tmp_path_factory) -> dict:
|
||||
path = tmp_path_factory.mktemp("route") / "planned_route.csv"
|
||||
replan._write_planned_polyline(
|
||||
path,
|
||||
NODES,
|
||||
30.0,
|
||||
simplify=False,
|
||||
curve_flags=FLAGS,
|
||||
radii=RADII,
|
||||
locks=LOCKS,
|
||||
arcs=ARCS,
|
||||
)
|
||||
with replan._nodes_path(path).open(encoding="utf-8") as handle:
|
||||
nodes = [(float(row["x"]), float(row["y"])) for row in csv.DictReader(handle)]
|
||||
outline = build_planned_polyline(nodes, min_radius_m=30.0, simplify=False)
|
||||
return {
|
||||
"path": path,
|
||||
"nodes": [node.as_dict() for node in outline.nodes],
|
||||
"curves": replan._read_curves(path),
|
||||
"edits": replan._read_curves(path, "edits"),
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def got(saved, tmp_path_factory) -> dict:
|
||||
server = tmp_path_factory.mktemp("server") / "plan.json"
|
||||
payload = {key: saved[key] for key in ("nodes", "curves", "edits")}
|
||||
server.write_text(json.dumps(payload), encoding="utf-8")
|
||||
run = subprocess.run( # noqa: S603 — 고정 실행 파일
|
||||
["node", str(HELPER), str(server)],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
timeout=60,
|
||||
)
|
||||
assert run.returncode == 0, run.stderr
|
||||
return json.loads(run.stdout)
|
||||
|
||||
|
||||
# ── 하한 검사 한 곳 ──────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def test_옮겨_새로_깨면_까닭(got) -> None:
|
||||
assert got["moveBreak"].startswith("하한에 걸려 되돌렸습니다 — IP1")
|
||||
assert "(곡선반지름 20m)" in got["moveBreak"]
|
||||
assert got["moveOk"] == ""
|
||||
|
||||
|
||||
def test_끼우기_새로_깨면_까닭_지우기_넉넉하면_통과(got) -> None:
|
||||
assert "IP1" in got["insertBreak"] and "IP2" in got["insertBreak"]
|
||||
assert got["deleteOk"] == ""
|
||||
assert got["manyGap"] == "" # 둘 넘게 다르면 안 견줌
|
||||
|
||||
|
||||
def test_이미_밑돈_자리는_새로가_아님(got) -> None:
|
||||
assert got["alreadyBroken"] == ""
|
||||
|
||||
|
||||
# ── 겹친 노드 · 못 그린 곡선 ─────────────────────────────────────────────────
|
||||
|
||||
|
||||
def test_겹친_노드_못_그린_곡선(got) -> None:
|
||||
assert got["flags"] == {"overlap": [2], "undrawn": [1, 3]}
|
||||
assert got["flagsOff"] == {"overlap": [], "undrawn": []} # 곡선 끈 자리는 「못 그림」 아님
|
||||
assert "겹친 노드 IP2(0.5 m 안 · 선에서 빠짐)" in got["summary"]
|
||||
assert "못 그린 곡선 IP1 · IP3" in got["summary"]
|
||||
|
||||
|
||||
def test_놓을_때_손으로_옮긴_IP_는_밀림에_안_셈(got) -> None:
|
||||
assert got["noteHand"] == " · 함께 밀린 교점 1곳"
|
||||
assert got["noteInput"] == " · 함께 밀린 교점 2곳"
|
||||
|
||||
|
||||
# ── 넣은 R · 고정 곡선표 저장(짝) ────────────────────────────────────────────
|
||||
|
||||
|
||||
def test_곡선표_edits_는_저장_노드와_자리가_같음(saved) -> None:
|
||||
assert len(saved["edits"]) == len(saved["nodes"]) == len(NODES) - 1 # 겹친 점 하나 빠짐
|
||||
assert saved["edits"][2] == {"curve": True, "radius_m": 200.0, "lock": "arc", "arc_m": 33.5}
|
||||
assert saved["edits"][1]["lock"] == "radius"
|
||||
assert saved["edits"][3]["curve"] is False
|
||||
assert saved["edits"][4]["lock"] is None # 모르는 고정 값은 버림
|
||||
|
||||
|
||||
def test_다시_열면_넣은_R_고정이_돌아옴(got, saved) -> None:
|
||||
flat = got["flat"]
|
||||
drawn = next(c["radius_m"] for c in saved["curves"] if c["node_first"] == 2)
|
||||
assert drawn < 200 - 1 # 그린 R 은 눌림
|
||||
assert flat["curveRadius"][1:3] == [40, 200] # 넣은 값
|
||||
assert flat["curveLock"][1:3] == ["radius", "arc"]
|
||||
assert flat["curveArc"][2] == 33.5
|
||||
assert flat["curveOn"][3] is False
|
||||
assert got["flatOld"]["curveRadius"][2] == pytest.approx(drawn, abs=0.01) # 옛 곡선표 = 그린 R
|
||||
|
||||
|
||||
def test_node_edits_짧은_칸은_기본값() -> None:
|
||||
edits = node_edits([(0, 0), (10, 0), (20, 5)], None, [None, 15.0])
|
||||
assert edits[1] == {"curve": True, "radius_m": 15.0, "lock": None, "arc_m": None}
|
||||
assert edits[2] == {"curve": True, "radius_m": None, "lock": None, "arc_m": None}
|
||||
|
||||
|
||||
def test_편집값_없이_쓴_곡선표는_edits_없음(tmp_path) -> None:
|
||||
path = tmp_path / "planned_route.csv"
|
||||
replan._write_planned_polyline(path, NODES, 30.0, simplify=False)
|
||||
assert replan._read_curves(path, "edits") == []
|
||||
|
||||
|
||||
# ── 배선 ────────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
def _read(name: str) -> str:
|
||||
return (B05 / name).read_text(encoding="utf-8")
|
||||
|
||||
|
||||
def test_편집기_배선() -> None:
|
||||
main = _read("B05_Profile_UI_RouteEdit.ts")
|
||||
apply_edit = main.split("function applyEdit(", 1)[1][:700]
|
||||
assert "edits.floorStop(before, planned, nodeInfo, fitLimits())" in apply_edit
|
||||
assert "restoreSnapshot(before, stop, false)" in apply_edit
|
||||
assert "curveBar.noteFit(snap.text(), before, index)" in main # 놓을 때 맞춤 보고
|
||||
snap = main.split("bindStationSnap(chrome", 1)[1][:400]
|
||||
assert "tellDraft();" in snap # 끔 · 간격 바꿈 즉시 계산 줄
|
||||
assert "snap.changed()" in main.split("function tellDraft()", 1)[1][:400]
|
||||
assert "plan.node_edits" in main
|
||||
assert "nodes: () => ({ planned, curveOn, curveRadius, curveLock, curveArc })" in main
|
||||
assert len(main.splitlines()) <= 695
|
||||
|
||||
|
||||
def test_손잡이_끌기_하한_검사() -> None:
|
||||
pointer = _read("B05_Profile_UI_RouteEdit_Pointer.ts")
|
||||
handle = pointer.split("// 곡선 시작·끝점을 끈다", 1)[1][:2200]
|
||||
assert "shortfallCrossed(" in handle
|
||||
assert "params.commit(dragHandle?.node ?? dragNode)" in pointer
|
||||
|
||||
|
||||
def test_곡선_삭제_155_경고() -> None:
|
||||
bar = _read("B05_Profile_UI_RouteEdit_CurveBar.ts")
|
||||
on = bar.split("onCurveOn:", 1)[1][:900]
|
||||
assert "!curveOptionalAt(inner)" in on and '"warning"' in on
|
||||
|
||||
|
||||
def test_저장에_고정_실음_읽기에_node_edits() -> None:
|
||||
apply = _read("B05_Profile_UI_RouteEdit_Apply.ts")
|
||||
assert "nodes.curveLock?.[index] ?? null" in apply
|
||||
assert "nodes.curveArc?.[index] ?? null" in apply
|
||||
router = _read("B05_Profile_Router_Replan.py")
|
||||
assert '"node_edits":' in router
|
||||
assert "locks=list(draft.curveLock) if draft else None" in router
|
||||
Reference in New Issue
Block a user