feat(344-2): 첫 계획선 · 관 자리 투영 · 구조물 좌표 따라감 · 계획고 옮김 짝
- 첫 계획선(계획고 = 지반고) base_pvi TS 짝 = B05_Profile/logic/B05_Profile_Grade_Ground.ts(1순위만 · 못 서는 땅은 null = 서버로 다시 셈) - 관 자리 투영 TS 짝 · 구조물 따라감 py · ts 짝 = common_util_route_follow(정수 m · 구간 끝 밂 · 0 ~ 연장 자름 · 20 m 넘으면 멀어짐 표시 · 상수 STRUCTURE_ROUTE_DRIFT_MAX_M) - 구조물 x · y 저장(저장 때 노선 위 자리 · 자리가 그대로면 옛 좌표 지킴 · 옛 자료는 읽을 때 채움) · 노선 [확인] 때 구조물 정본이 좌표를 따라감 - 노선 바뀜 때 계획고 옮김 = 바뀐 구간만 새 지반 첫 계획선 · 앞 그대로 · 뒤 길이 차만큼 밂(B05_Profile_Engine_Grade_Carry.py ↔ logic/B05_Profile_Grade_Carry.ts) - 거울 시험 test_344_2_route_pairs(+ helper cjs) · buildCurves · evaluateAt 내보냄 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ji4nuyLVHcxrXWHTdb5nRD
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,129 @@
|
||||
/* =============================================================================
|
||||
* B05_Profile/logic/B05_Profile_Grade_Carry.ts
|
||||
* 노선이 바뀔 때 계획고 옮김 — 바뀐 구간만 지반에 다시 맞추고 그 밖 편집은 길이 차만큼 밂(344-2).
|
||||
*
|
||||
* 짝 = 파이썬 `B05_Profile_Engine_Grade_Carry.py`(서버 정본 · 같은 규칙) · 거울 시험 =
|
||||
* resources/tester/test_344_2_route_pairs.py.
|
||||
* - 바뀐 구간 = 옛 · 새 노선 정점열의 같은 앞머리 · 꼬리를 뺀 가운데(바뀐 노드 앞 · 뒤 접선점 사이).
|
||||
* - 앞 = 그대로 · 뒤 = 누가거리만 길이 차만큼 밂 · 안 = 새 지반 첫 계획선 꼭짓점(`groundFollowingBasePvi`)
|
||||
* · 안의 편집(계획고 · 종단곡선 R)은 버림.
|
||||
* - 옮기는 것 = base_pvi · station_offsets · curve_radii(누가거리 글자 키).
|
||||
* ========================================================================== */
|
||||
|
||||
import {
|
||||
chainageKey,
|
||||
type AlignmentEdits,
|
||||
type AlignmentNode,
|
||||
} from "../B05_Profile_UI_Profile_Alignment";
|
||||
|
||||
/** 같은 정점으로 볼 거리(m) — 파이썬 `SAME_VERTEX_M` 짝. */
|
||||
export const SAME_VERTEX_M = 1e-3;
|
||||
const EPS = 1e-6;
|
||||
|
||||
export interface XY {
|
||||
x: number;
|
||||
y: number;
|
||||
}
|
||||
|
||||
export interface ChangedSpan {
|
||||
start_m: number;
|
||||
old_end_m: number;
|
||||
new_end_m: number;
|
||||
delta_m: number;
|
||||
start_fixed: boolean;
|
||||
end_fixed: boolean;
|
||||
}
|
||||
|
||||
const roundTo = (value: number, digits: number): number => Number(value.toFixed(digits));
|
||||
|
||||
function cumulative(xy: ReadonlyArray<XY>): number[] {
|
||||
const total = [0];
|
||||
for (let index = 1; index < xy.length; index += 1) {
|
||||
const prev = xy[index - 1];
|
||||
total.push(total[index - 1] + Math.hypot(xy[index].x - prev.x, xy[index].y - prev.y));
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
const same = (a: XY, b: XY): boolean =>
|
||||
Math.abs(a.x - b.x) <= SAME_VERTEX_M && Math.abs(a.y - b.y) <= SAME_VERTEX_M;
|
||||
|
||||
/** 옛 · 새 노선 정점열 → 바뀐 누가거리 구간 · 같으면 null(파이썬 `changed_span` 짝). */
|
||||
export function changedSpan(
|
||||
oldXy: ReadonlyArray<XY>,
|
||||
newXy: ReadonlyArray<XY>,
|
||||
): ChangedSpan | null {
|
||||
const limit = Math.min(oldXy.length, newXy.length);
|
||||
let prefix = 0;
|
||||
while (prefix < limit && same(oldXy[prefix], newXy[prefix])) prefix += 1;
|
||||
if (prefix === oldXy.length && prefix === newXy.length) return null;
|
||||
let suffix = 0;
|
||||
while (
|
||||
suffix < limit - prefix &&
|
||||
same(oldXy[oldXy.length - 1 - suffix], newXy[newXy.length - 1 - suffix])
|
||||
)
|
||||
suffix += 1;
|
||||
const oldCum = cumulative(oldXy);
|
||||
const newCum = cumulative(newXy);
|
||||
return {
|
||||
start_m: prefix ? oldCum[prefix - 1] : 0,
|
||||
old_end_m: suffix ? oldCum[oldXy.length - suffix] : oldCum[oldCum.length - 1],
|
||||
new_end_m: suffix ? newCum[newXy.length - suffix] : newCum[newCum.length - 1],
|
||||
delta_m: newCum[newCum.length - 1] - oldCum[oldCum.length - 1],
|
||||
start_fixed: prefix > 0,
|
||||
end_fixed: suffix > 0,
|
||||
};
|
||||
}
|
||||
|
||||
const before = (span: ChangedSpan, s: number): boolean =>
|
||||
s < span.start_m - EPS || (span.start_fixed && s <= span.start_m + EPS);
|
||||
|
||||
const after = (span: ChangedSpan, s: number, end: number): boolean =>
|
||||
s > end + EPS || (span.end_fixed && s >= end - EPS);
|
||||
|
||||
/** 옛 꼭짓점 · 편집을 새 노선으로 옮김 — `groundPvi` = 새 노선 지반 첫 계획선(전 구간). */
|
||||
export function carryProfileEdits(
|
||||
basePvi: ReadonlyArray<AlignmentNode>,
|
||||
edits: Partial<AlignmentEdits> | null | undefined,
|
||||
span: ChangedSpan,
|
||||
groundPvi: ReadonlyArray<AlignmentNode>,
|
||||
): { basePvi: AlignmentNode[]; edits: AlignmentEdits } {
|
||||
const moved = (s: number): number | null => {
|
||||
if (before(span, s)) return s;
|
||||
if (after(span, s, span.old_end_m)) return s + span.delta_m;
|
||||
return null; // 바뀐 구간 안 — 버림
|
||||
};
|
||||
|
||||
const nodes = new Map<number, AlignmentNode>();
|
||||
basePvi.forEach((node) => {
|
||||
const at = moved(node.chainage_m);
|
||||
if (at !== null)
|
||||
nodes.set(roundTo(at, 3), { chainage_m: roundTo(at, 6), elevation_m: node.elevation_m });
|
||||
});
|
||||
groundPvi.forEach((node) => {
|
||||
const s = node.chainage_m;
|
||||
if (before(span, s) || after(span, s, span.new_end_m)) return;
|
||||
const slot = roundTo(s, 3);
|
||||
if (!nodes.has(slot))
|
||||
nodes.set(slot, { chainage_m: roundTo(s, 6), elevation_m: node.elevation_m });
|
||||
});
|
||||
|
||||
const carry = (values: Record<string, number> | undefined): Record<string, number> => {
|
||||
const out: Record<string, number> = {};
|
||||
Object.entries(values ?? {}).forEach(([key, value]) => {
|
||||
const chainage = Number(key);
|
||||
if (!Number.isFinite(chainage) || value == null) return;
|
||||
const at = moved(chainage);
|
||||
if (at !== null) out[chainageKey(at)] = Number(value);
|
||||
});
|
||||
return out;
|
||||
};
|
||||
|
||||
return {
|
||||
basePvi: [...nodes.keys()].sort((a, b) => a - b).map((slot) => nodes.get(slot)!),
|
||||
edits: {
|
||||
station_offsets: carry(edits?.station_offsets),
|
||||
curve_radii: carry(edits?.curve_radii),
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
/* =============================================================================
|
||||
* B05_Profile/logic/B05_Profile_Grade_Ground.ts
|
||||
* 첫 계획선(계획고 = 지반고) 꼭짓점 — 종단 지반 표본 · 측점 → base_pvi (344-2).
|
||||
*
|
||||
* 짝 = 파이썬 `B05_Profile_Engine_Grade_Profile.design_ground_following_profile` 의 base_pvi 몫
|
||||
* (1순위만 · 관 정착 · 직선 분할 폴백은 짝 없음). 그 위 선형은 이미 짝인 `buildAlignment`
|
||||
* (`B05_Profile_UI_Profile_Alignment.ts`). 거울 시험 = resources/tester/test_344_2_route_pairs.py.
|
||||
* 1순위가 못 서는 땅(유효 지반 둘 미만 · 연장 0)이면 null — 부르는 쪽이 「서버로 다시 셈」 표시만.
|
||||
* ========================================================================== */
|
||||
|
||||
import {
|
||||
buildCurves,
|
||||
evaluateAt,
|
||||
type AlignmentNode,
|
||||
type AlignmentPolicy,
|
||||
} from "../B05_Profile_UI_Profile_Alignment";
|
||||
|
||||
/** 종단 지반 표본 한 점 — 저장 종단 `samples[]` 꼴. */
|
||||
export interface GroundSample {
|
||||
chainage_m: number;
|
||||
elevation_m?: number | null;
|
||||
valid?: boolean;
|
||||
}
|
||||
|
||||
export interface GroundFollowingInput {
|
||||
samples: ReadonlyArray<GroundSample>;
|
||||
/** 측점 누가거리 — 모든 측점이 꼭짓점. */
|
||||
stations: ReadonlyArray<number>;
|
||||
policy: AlignmentPolicy;
|
||||
startOffsetM?: number;
|
||||
endOffsetM?: number;
|
||||
}
|
||||
|
||||
/** 파이썬 `round(value, digits)` 와 같은 값(이진 값 그대로 십진 반올림). */
|
||||
const roundTo = (value: number, digits: number): number => Number(value.toFixed(digits));
|
||||
|
||||
/** `np.interp` — 오름차순 xs · 범위 밖은 양 끝값. */
|
||||
function interp(xs: number[], ys: number[], value: number): number {
|
||||
if (value <= xs[0]) return ys[0];
|
||||
if (value >= xs[xs.length - 1]) return ys[ys.length - 1];
|
||||
let low = 0;
|
||||
let high = xs.length - 1;
|
||||
while (high - low > 1) {
|
||||
const mid = (low + high) >> 1;
|
||||
if (xs[mid] <= value) low = mid;
|
||||
else high = mid;
|
||||
}
|
||||
const span = xs[high] - xs[low];
|
||||
return span <= 0 ? ys[high] : ys[low] + ((ys[high] - ys[low]) * (value - xs[low])) / span;
|
||||
}
|
||||
|
||||
/** 파이썬 `ground_profile` 짝 — 누가거리 순 · 빈 지반은 선형 보간. 유효 둘 미만이면 null. */
|
||||
export function groundProfile(
|
||||
samples: ReadonlyArray<GroundSample>,
|
||||
): { chainage: number[]; ground: number[] } | null {
|
||||
const rows = samples
|
||||
.map((sample) => ({
|
||||
s: Number(sample.chainage_m ?? 0),
|
||||
z: (sample.valid ?? true) && sample.elevation_m != null ? Number(sample.elevation_m) : NaN,
|
||||
}))
|
||||
.sort((a, b) => a.s - b.s);
|
||||
const finite = rows.filter((row) => Number.isFinite(row.z));
|
||||
if (finite.length < 2 || rows.length < 2) return null;
|
||||
const fs = finite.map((row) => row.s);
|
||||
const fz = finite.map((row) => row.z);
|
||||
return { chainage: rows.map((row) => row.s), ground: rows.map((row) => interp(fs, fz, row.s)) };
|
||||
}
|
||||
|
||||
/** 종단곡선을 넣어도 측점마다 `target` 을 지나게 하는 꼭짓점 표고 — 파이썬 `pass_through` 짝. */
|
||||
export function passThrough(baseS: number[], target: number[], policy: AlignmentPolicy): number[] {
|
||||
let baseZ = [...target];
|
||||
for (let round = 0; round < 12; round += 1) {
|
||||
const pvi = baseS.map((s, index) => ({ chainage_m: s, elevation_m: baseZ[index] }));
|
||||
const curves = buildCurves(pvi, policy, {}, []);
|
||||
const error = baseS.map((s, index) => target[index] - evaluateAt(baseS, baseZ, curves, s));
|
||||
error[0] = 0;
|
||||
error[error.length - 1] = 0;
|
||||
if (Math.max(...error.map(Math.abs)) < 1e-4) break;
|
||||
baseZ = baseZ.map((z, index) => z + error[index]);
|
||||
}
|
||||
return baseZ;
|
||||
}
|
||||
|
||||
/** 첫 계획선 꼭짓점(base_pvi · 0.000001 m) — 못 서는 땅이면 null(서버로 다시 셈). */
|
||||
export function groundFollowingBasePvi(input: GroundFollowingInput): AlignmentNode[] | null {
|
||||
const profile = groundProfile(input.samples);
|
||||
if (!profile) return null;
|
||||
const { chainage, ground } = profile;
|
||||
const total = chainage[chainage.length - 1];
|
||||
if (!(total > 0)) return null;
|
||||
|
||||
let nodeS = [
|
||||
...new Set(
|
||||
input.stations
|
||||
.filter((value) => Number.isFinite(value) && value >= 0 && value <= total)
|
||||
.map((value) => roundTo(value, 3)),
|
||||
),
|
||||
].sort((a, b) => a - b);
|
||||
if (nodeS.length < 2) nodeS = chainage.map((value) => roundTo(value, 3));
|
||||
if (nodeS[0] > 0) nodeS.unshift(0);
|
||||
if (nodeS[nodeS.length - 1] < total) nodeS.push(roundTo(total, 3));
|
||||
|
||||
const target = nodeS.map((s) => interp(chainage, ground, s));
|
||||
target[0] += input.startOffsetM ?? 0;
|
||||
target[target.length - 1] += input.endOffsetM ?? 0;
|
||||
const baseZ = passThrough(nodeS, target, input.policy);
|
||||
return nodeS.map((s, index) => ({
|
||||
chainage_m: roundTo(s, 6),
|
||||
elevation_m: roundTo(baseZ[index], 6),
|
||||
}));
|
||||
}
|
||||
Reference in New Issue
Block a user