eomsangdon/Aislo
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity
Files
bb63b30aae2ba2a16c8ce0b78f2dd1e92ea591cc
Aislo/resources/tester/test_224_2_station_snap.py
T

389 lines
15 KiB
Python
Raw Blame History

"""요구 224-2 · PLAN 326 — 계획노선 편집 [측점 스냅].
짝: 파이썬 `B05_Profile_Engine_Sections_Core` (`_chainages` · `_design_curve_spans` ·
`snap_curve_stations`) ↔ TS `B05_Profile_UI_RouteEdit_Frame.ts` (`stationsAlong` ·
`curveSpans` · `snapCurveStations`). 켜면 호(BC~EC) 안 측점 중 곡선 중점 MC 에 가장 가까운
하나를 floor(MC+0.5) 로 옮김 · 측점 없는 호는 안 심음 · 같은 m 하나로.
"""
from __future__ import annotations
import json
import math
import re
import subprocess
import sys
from pathlib import Path
import numpy as np
import pytest
ROOT = Path(__file__).resolve().parents[2]
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from B05_Profile import B05_Profile_Engine_Sections_Core as core # noqa: E402
TS_FILE = ROOT / "B05_Profile" / "B05_Profile_UI_RouteEdit_Frame.ts"
TSC = ROOT / "config" / "node_modules" / "typescript" / "bin" / "tsc"
GRID = [float(value) for value in range(0, 1001, 20)]
def _snap(spans: list[tuple[float, float]], stations: list[float] | None = None) -> list[float]:
return [float(v) for v in core.snap_curve_stations(stations or GRID, spans)]
# ── 파이썬 규칙 ────────────────────────────────────────────────────────────────
def test_곡선_없음_그대로() -> None:
assert _snap([]) == GRID
def test_측점_없는_호는_안_심음() -> None:
assert _snap([(621.0, 639.0)]) == GRID
def test_호_안_하나를_정수_MC_로() -> None:
out = _snap([(612.0, 634.0)]) # MC 623
assert 623.0 in out and 620.0 not in out and len(out) == len(GRID)
def test_호_안_둘이면_MC_에_가까운_하나만() -> None:
out = _snap([(616.1, 646.5)]) # MC 631.3 — 640(8.7) 이 620(11.3) 보다 가까움
assert 631.0 in out and 640.0 not in out and 620.0 in out
def test_BC_위_측점은_호_밖() -> None:
assert _snap([(620.0, 630.0)]) == GRID
assert _snap([(610.0, 620.0)]) == GRID # EC 위도 밖
def test_반_올림() -> None:
out = _snap([(611.0, 640.0)]) # MC 625.5 → 626 · 640 = EC 위라 밖
assert 626.0 in out and 620.0 not in out and 640.0 in out
def test_같은_m_는_하나로() -> None:
# 20.3 이 MC 20.35 → 20 으로 옮겨 이웃 20 과 같은 m — 하나만 남음
assert _snap([(20.1, 20.6)], [0.0, 20.0, 20.3, 40.0]) == [0.0, 20.0, 40.0]
# ── 파이썬 ↔ TS 거울 ─────────────────────────────────────────────────────────
def _arc(cx: float, cy: float, radius: float, start: float, end: float, count: int) -> list:
return [
[cx + radius * math.cos(angle), cy + radius * math.sin(angle)]
for angle in np.linspace(start, end, count)
]
def _bend_route() -> tuple[list, list]:
"""직선 300 m → R 40 호 → 직선 — 곡선표 한 줄 + 노선 밖 곡선 · 방향 없는 곡선."""
arc = _arc(300.0, 40.0, 40.0, -math.pi / 2, 0.3, 60)
line = [[0.0, 0.0], *arc, [arc[-1][0] - 200 * math.sin(0.3), arc[-1][1] + 200 * math.cos(0.3)]]
curves = [
{"start": arc[0], "apex": [340.0, 0.0], "end": arc[-1], "radius_m": 40.0},
{"start": [0.0, 500.0], "apex": [10.0, 510.0], "end": [20.0, 500.0], "radius_m": 30.0},
{"start": [50.0, 0.0], "apex": [60.0, 0.0], "end": [70.0, 0.0], "radius_m": 30.0},
{"start": [80.0, 0.0], "apex": [90.0, 1.0], "end": [100.0, 0.0], "radius_m": None},
]
return line, curves
CASES = [
{"line": [[0, 0], [1000, 0]], "interval": 20, "end": True, "curves": []},
{
"line": [[0, 0], [1000.3, 0]],
"interval": 20,
"end": True,
"curves": [{"start": [616.1, 0], "apex": [631.3, 3], "end": [646.5, 0], "radius_m": 40}],
},
{
"line": [[0, 0], [500, 0], [500, 0], [700, 10]],
"interval": 20,
"end": False,
"curves": [
{"start": [611, 0], "apex": [625.5, -2], "end": [640, 0], "radius_m": 25},
{"start": [621, 0], "apex": [630, 2], "end": [639, 0], "radius_m": 25},
{"start": [100, 0], "apex": [110, 2], "end": [112, 0], "radius_m": 25},
],
},
{"line": _bend_route()[0], "interval": 20, "end": True, "curves": _bend_route()[1]},
{"line": _bend_route()[0], "interval": 7.5, "end": True, "curves": _bend_route()[1]},
]
_RUNNER = """
import { readFileSync, writeFileSync } from "node:fs";
import * as frame from "./B05_Profile_UI_RouteEdit_Frame.js";
const cases = JSON.parse(readFileSync(process.argv[2], "utf8"));
const out = {
tolerance: frame.DESIGN_CURVE_MATCH_TOLERANCE_M,
edge: frame.CURVE_STATION_EDGE_M,
rows: cases.map((item) => {
const grid = frame.stationsAlong(item.line, item.interval, item.end);
const spans = frame.curveSpans(item.line, item.curves);
return { grid, spans, snapped: frame.snapCurveStations(grid, spans) };
}),
};
writeFileSync(process.argv[3], JSON.stringify(out));
"""
def _python_row(case: dict) -> dict:
points, route_chainage = core._clean_polyline(np.asarray(case["line"], dtype=np.float64))
grid = core._chainages(float(route_chainage[-1]), float(case["interval"]), case["end"])
spans = core._design_curve_spans(points, route_chainage, case["curves"])
return {
"grid": [float(v) for v in grid],
"spans": [[span[0], span[1]] for span in spans],
"snapped": [float(v) for v in core.snap_curve_stations(grid, spans)],
}
def _ts_rows(tmp_path: Path) -> dict:
out = tmp_path / "js"
subprocess.run( # noqa: S603 — 고정 실행 파일
[
"node",
str(TSC),
str(TS_FILE),
"--outDir",
str(out),
"--module",
"esnext",
"--target",
"es2022",
"--moduleResolution",
"bundler",
"--ignoreConfig",
],
cwd=str(ROOT),
check=True,
capture_output=True,
)
for emitted in out.glob("*.js"):
emitted.write_text(
re.sub(r'(from\s+"\./[^"]+)"', r'\1.js"', emitted.read_text(encoding="utf-8")),
encoding="utf-8",
)
(out / "runner.mjs").write_text(_RUNNER, encoding="utf-8")
payload = tmp_path / "input.json"
result = tmp_path / "output.json"
payload.write_text(json.dumps(CASES), encoding="utf-8")
subprocess.run( # noqa: S603
["node", str(out / "runner.mjs"), str(payload), str(result)],
cwd=str(ROOT),
check=True,
capture_output=True,
)
return json.loads(result.read_text(encoding="utf-8"))
@pytest.mark.skipif(not TSC.is_file(), reason="프론트엔드 의존성 미설치")
def test_스냅_셈이_두_쪽에서_같다(tmp_path: Path) -> None:
actual = _ts_rows(tmp_path)
assert actual["tolerance"] == core.DESIGN_CURVE_MATCH_TOLERANCE_M
assert actual["edge"] == core.CURVE_STATION_EDGE_M
moved = 0
for index, case in enumerate(CASES):
expected = _python_row(case)
row = actual["rows"][index]
assert row["grid"] == pytest.approx(expected["grid"], abs=1e-9), f"사례 {index} 격자"
assert len(row["spans"]) == len(expected["spans"]), f"사례 {index} 곡선 수"
for got, want in zip(row["spans"], expected["spans"], strict=True):
assert got == pytest.approx(want, abs=1e-9), f"사례 {index} 곡선"
assert row["snapped"] == pytest.approx(expected["snapped"], abs=1e-9), f"사례 {index} 스냅"
moved += row["snapped"] != row["grid"]
assert moved >= 3 # 옮김이 실제로 일어난 사례를 견줌
def test_짝_머리글이_서로를_가리킨다() -> None:
text = TS_FILE.read_text(encoding="utf-8")
assert "B05_Profile_Engine_Sections_Core.py" in text and "snap_curve_stations" in text
assert "snapCurveStations" in (core.__doc__ or "")
# ── generate_sections ────────────────────────────────────────────────────────
class _Flat:
def sample_xy(self, xy):
count = len(np.asarray(xy, dtype=np.float64))
return np.full(count, 100.0), np.ones(count, dtype=bool)
_LINE = [[0.0, 0.0, 100.0], [1000.3, 0.0, 100.0]]
_CURVES = [{"start": [616.1, 0.0], "apex": [631.3, 3.0], "end": [646.5, 0.0], "radius_m": 40.0}]
def _stations(snap: bool | None, extras: tuple = ()) -> list[dict]:
kwargs = {} if snap is None else {"station_snap": snap}
result = core.generate_sections(
_LINE,
_Flat(),
core.SectionGenerationOptions(extra_stations=extras),
design_curves=_CURVES,
**kwargs,
)
return result["longitudinal"]["stations"]
def test_끔은_지금과_같음() -> None:
assert _stations(False) == _stations(None)
assert 640.0 in [s["chainage_m"] for s in _stations(False)]
def test_켬은_640_없고_631_있음() -> None:
by_chainage = {s["chainage_m"]: s for s in _stations(True)}
assert 640.0 not in by_chainage and 631.0 in by_chainage
assert by_chainage[631.0]["kind"] == "regular"
assert by_chainage[631.0]["plan_radius_m"] == 40.0 # 호 안 = 곡선표 반경
assert len(by_chainage) == len(_stations(False))
def test_631_에_관이면_grid() -> None:
by_chainage = {s["chainage_m"]: s for s in _stations(True, ((631.0, "관"),))}
assert by_chainage[631.0]["kind"] == "irregular"
assert by_chainage[631.0]["grid"] is True
# 640 에 놓인 관은 스냅 뒤 격자가 아니라 따로 선 측점
off_grid = {s["chainage_m"]: s for s in _stations(True, ((640.0, "관"),))}
assert off_grid[640.0]["kind"] == "irregular" and "grid" not in off_grid[640.0]
# ── 서버 저장 · 정본 (326-2) ─────────────────────────────────────────────────
_NODES = [(0.0, 0.0), (300.0, 0.0), (300.0, 300.0)]
def _working(tmp_path: Path) -> Path:
from common_util.common_util_route_geometry import planned_route_working_path
path = planned_route_working_path(tmp_path)
path.parent.mkdir(parents=True, exist_ok=True)
return path
def test_확인_때_곡선표에_적고_읽음(tmp_path: Path) -> None:
from B05_Profile import B05_Profile_Router_Replan as replan
from B05_Profile.B05_Profile_Engine_Sections import load_station_snap
path = _working(tmp_path)
assert load_station_snap(tmp_path) is False # 파일 없음
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False)
assert "station_snap" not in json.loads(replan._curves_path(path).read_text("utf-8"))
assert load_station_snap(tmp_path) is False # 칸 없음 = 끔(옛 프로젝트)
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False, station_snap=True)
assert load_station_snap(tmp_path) is True
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False, station_snap=False)
assert load_station_snap(tmp_path) is False
def _patch_replan(monkeypatch, tmp_path: Path):
from B05_Profile import B05_Profile_Router_Replan as replan
async def paths(_project_id):
return tmp_path, "stored"
async def criteria(_project_id):
return 30.0, 0.0, 0.0
monkeypatch.setattr(replan, "_project_paths", paths)
monkeypatch.setattr(replan, "_plan_criteria", criteria)
return replan
def test_실패하면_곡선표_노드도_되돌림(tmp_path: Path, monkeypatch) -> None:
import asyncio
from uuid import uuid4
replan = _patch_replan(monkeypatch, tmp_path)
async def broken(*_args, **_kwargs):
return {"error": "체인 끊김"}
monkeypatch.setattr(replan, "_recompute", broken)
path = _working(tmp_path)
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False)
files = (path, replan._curves_path(path), replan._nodes_path(path))
before = {file: file.read_bytes() for file in files}
request = replan.RouteReplanRequest(
vertices=[{"x": 0, "y": 0}, {"x": 320, "y": 40}, {"x": 300, "y": 300}],
station_snap=True,
)
response = asyncio.run(replan.replan_route(uuid4(), request))
assert response.status_code == 409
assert {file: file.read_bytes() for file in files} == before
def test_GET_계획노선이_스냅_값을_돌려줌(tmp_path: Path, monkeypatch) -> None:
import asyncio
from uuid import uuid4
replan = _patch_replan(monkeypatch, tmp_path)
path = _working(tmp_path)
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False)
assert asyncio.run(replan.read_route_plan(uuid4()))["station_snap"] is False
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False, station_snap=True)
assert asyncio.run(replan.read_route_plan(uuid4()))["station_snap"] is True
def test_측점_셈_둘_다_스냅을_읽음(tmp_path: Path, monkeypatch) -> None:
from B05_Profile import B05_Profile_Engine_Sections as sections
from B05_Profile import B05_Profile_Router_Replan as replan
path = _working(tmp_path)
replan._write_planned_polyline(path, _NODES, 30.0, simplify=False)
replan._curves_path(path).write_text(
json.dumps({"curves": _CURVES, "station_snap": True}), encoding="utf-8"
)
monkeypatch.setattr(sections, "_load_route_polyline", lambda *_args: _LINE)
monkeypatch.setattr(sections, "build_surface_sampler", lambda *_args, **_kw: _Flat())
# [저장] 때 구조물 측점 셈 — 631 은 스냅한 격자 자리
stations, _ = sections.sample_structure_sections(
tmp_path, "route.geojson", "f", "m", False, extra_stations=((631.0, "관"),)
)
assert [s["chainage_m"] for s in stations] == [631.0] and stations[0]["grid"] is True
seen: dict = {}
def stop(*_args, **kwargs):
seen.update(kwargs)
raise RuntimeError("여기까지")
monkeypatch.setattr(sections, "generate_sections", stop)
monkeypatch.setattr(sections, "_load_pipe_points", lambda *_args: [])
monkeypatch.setattr(sections, "resolve_extra_stations", lambda *_args: ())
with pytest.raises(RuntimeError):
sections.run_section_generation(tmp_path, "route.geojson", "f", "m", False)
assert seen["station_snap"] is True
def test_횡단_미리보기도_스냅(tmp_path: Path, monkeypatch) -> None:
from B05_Profile import B05_Profile_Router_Terrain as terrain
from common_util.common_util_route_polyline import build_planned_polyline
monkeypatch.setattr(terrain, "build_surface_sampler", lambda *_args, **_kw: _Flat())
built = build_planned_polyline(_NODES, min_radius_m=40.0, simplify=False)
points, chain = core._clean_polyline(np.asarray(built.vertices, dtype=np.float64))
spans = core._design_curve_spans(points, chain, [c.as_dict() for c in built.curves])
assert len(spans) == 1
target = math.floor((spans[0][0] + spans[0][1]) / 2 + 0.5)
assert target % 20 # 격자 밖 자리여야 견줄 뜻이 있음
def ask(snap: bool) -> float:
request = terrain.CrossPreviewRequest(
vertices=[{"x": x, "y": y} for x, y in _NODES],
chainage_m=target,
min_radius_m=40.0,
station_interval_m=20.0,
station_snap=snap,
)
params = {"source_filter": "f", "method": "m", "smooth": False}
return terrain._cross_preview(tmp_path, params, request)["chainage_m"]
assert ask(True) == target
assert ask(False) % 20 == 0
Reference in New Issue View Git Blame Copy Permalink