From cfb3593a0bcb9fd826c47f41e9999f147964a431 Mon Sep 17 00:00:00 2001 From: que01 Date: Thu, 17 Sep 2026 10:07:26 +0800 Subject: [PATCH] fix: verify and align complex junction layer seams --- .trellis/spec/backend/index.md | 1 + .trellis/spec/backend/junction-layer-seams.md | 81 +++ .../09-17-junction-layer-seams/check.jsonl | 2 + .../09-17-junction-layer-seams/commit-plan.md | 23 + .../09-17-junction-layer-seams/design.md | 11 + .../09-17-junction-layer-seams/evidence.md | 89 ++++ .../implement.jsonl | 2 + .../09-17-junction-layer-seams/implement.md | 13 + .../tasks/09-17-junction-layer-seams/prd.md | 26 + .../09-17-junction-layer-seams/task.json | 26 + package.json | 2 +- src/compile/complex-junction-facilities.js | 2 +- src/compile/native-road.js | 80 +-- test/helpers/junction-seams.js | 478 ++++++++++++++++++ test/junction-layer-seams.js | 343 +++++++++++++ 15 files changed, 1122 insertions(+), 57 deletions(-) create mode 100644 .trellis/spec/backend/junction-layer-seams.md create mode 100644 .trellis/tasks/09-17-junction-layer-seams/check.jsonl create mode 100644 .trellis/tasks/09-17-junction-layer-seams/commit-plan.md create mode 100644 .trellis/tasks/09-17-junction-layer-seams/design.md create mode 100644 .trellis/tasks/09-17-junction-layer-seams/evidence.md create mode 100644 .trellis/tasks/09-17-junction-layer-seams/implement.jsonl create mode 100644 .trellis/tasks/09-17-junction-layer-seams/implement.md create mode 100644 .trellis/tasks/09-17-junction-layer-seams/prd.md create mode 100644 .trellis/tasks/09-17-junction-layer-seams/task.json create mode 100644 test/helpers/junction-seams.js create mode 100644 test/junction-layer-seams.js diff --git a/.trellis/spec/backend/index.md b/.trellis/spec/backend/index.md index c40cb21..b5f95f5 100644 --- a/.trellis/spec/backend/index.md +++ b/.trellis/spec/backend/index.md @@ -6,3 +6,4 @@ - [Direct Edit Solver And API](./direct-edit-api.md) -- pure constraint solving, preview/save endpoints, version protection, and rebase behavior. - [Junction Island Contact](./junction-island-contact.md) -- confirmed target contract for full crossing-edge contact, dynamic island legs and the six-point green region (implementation pending). +- [Junction Layer Seams](./junction-layer-seams.md) -- metric seam audit, source identity mapping, and both-end corridor trims. diff --git a/.trellis/spec/backend/junction-layer-seams.md b/.trellis/spec/backend/junction-layer-seams.md new file mode 100644 index 0000000..beae67e --- /dev/null +++ b/.trellis/spec/backend/junction-layer-seams.md @@ -0,0 +1,81 @@ +# Junction layer seams + +## Scope and source contracts + +Complex-junction seams use a **0.01 m** numerical tolerance in local metric +coordinates. This is internal stitching precision, not OSM survey accuracy. +`test/helpers/junction-seams.js` audits published features against source +identities in `junction_structure`; it does not call the geometry builders to +manufacture expected geometry. + +- Exterior surfaces match the complete `directional_road_ids` set of a + carriageway. Core and pavement match `cluster_id`; approaches match + `carriageway_key`. +- Native lanes use `road_id` and travel-direction `lane_index`. Preview lanes + use a combined cross-section index running from `outer.right` to `outer.left`. + Map outgoing lanes in reverse order, followed by incoming lanes in forward + order. Do not equate these two index spaces or choose a nearest lane globally. +- Edge lines match the source road and `side`. Separators match the lane pair; + the boundary between opposite directions belongs to the road centre marking. + Centre markings match the complete `directional_road_ids` set and a primary + `road_id` belonging to that set; a partial source match is not sufficient. +- Sidewalk corners match `corner_key` and strips from their two source arms. + Absence is acceptable only for disabled source sidewalks or an explicit + rejection identifying that exact corner. A cluster-wide fallback diagnostic + must not excuse a missing corner elsewhere. + +## Both ends of a corridor + +`trimRoadAtComplexClusters(road, junctionPlans, clusters, boundaries)` in +`native-road.js` calculates **both** endpoint cutbacks from the original source +polyline and each cluster's `outer.stationMeters`, then calls `trimLineRange` +once. Road surfaces, sidewalks, edges, centre lines and native lanes share it. + +Wrong: select `startCluster || endCluster` as the only trim owner, or trim +sequentially using the second station on the shortened line. Correct: resolve +each endpoint independently and preserve intermediate source bends. + +The first bug leaves the far approach covered by exterior pavement and its +edge/lane endpoints tens of metres past the seam. Vertex-to-boundary checks can +miss it because the long side edges still touch both seam endpoints. + +## Measurements and failures + +`auditJunctionSeams(model, geometry, structures)` returns each layer's `checked`, +`failed`, `notApplicable` and identity-bearing `records`. + +| Interface | Required measurement | +| --- | --- | +| Exterior surface / approach | Endpoint error and complete boundary segment coverage | +| Approach / core and published pavement | Complete segment containment, respecting holes | +| Native / preview lanes and solid edges | Corresponding endpoint or paint-cap midpoint | +| Dashed edges, centre lines, separators | Support alignment and bounded terminal gap | +| Corner / sidewalk strip | Both full end edges, with source-arm matching | + +Missing expected objects fail; never iterate only detected objects and report an +empty set as success. Segment coverage partitions at all boundary crossings, so +interior notches cannot hide between fixed probes. Polygon holes remain holes. + +Dashes do not need white paint across every seam. An outward road starts its +dash sequence at the seam, so its first cap must coincide; the other end can +leave a residual dash cycle. Current edge/separator cycles are 2 m paint + 2 m +gap. Centre markings publish `dash_length_m` and `dash_gap_m`. Report these gaps +separately from the 1 cm transverse alignment tolerance. The audit does not +certify every individual dash, every double-line component, or interior paint +continuity through a complex core where centre markings are not published. + +## Required regression + +Run `node test/junction-layer-seams.js` (also in `npm test`). To inspect every +identity and measurement, run: + +```sh +node test/junction-layer-seams.js --report /private/tmp/junction-layer-seams.json +``` + +Keep nonempty per-layer counts for straight/curved, one-way/two-way, local width +and island edits, two-ended corridors, reordered input, current real OSM and +explicitly sidewalk-enabled real OSM. Required negative controls: exactly 2 cm +displacement, missing single/whole counterparts, wrong source identities, +swapped lane indices, absent first anchored dash, a 2 cm interior notch and a +hole. Do not loosen the tolerance or refresh unrelated fixture snapshots. diff --git a/.trellis/tasks/09-17-junction-layer-seams/check.jsonl b/.trellis/tasks/09-17-junction-layer-seams/check.jsonl new file mode 100644 index 0000000..385a44b --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/check.jsonl @@ -0,0 +1,2 @@ +{"file": ".trellis/spec/backend/junction-island-contact.md", "reason": "检查接缝与诊断"} +{"file": ".trellis/spec/backend/junction-layer-seams.md", "reason": "接缝矩阵、来源映射、两端裁切及负向验证"} diff --git a/.trellis/tasks/09-17-junction-layer-seams/commit-plan.md b/.trellis/tasks/09-17-junction-layer-seams/commit-plan.md new file mode 100644 index 0000000..902b479 --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/commit-plan.md @@ -0,0 +1,23 @@ +# Phase 3.4 提交批次(用户已确认) + +2026-09-17:用户回复“可以”,授权以下两笔提交及接缝专项归档。 + +1. `fix: verify and align complex junction layer seams` + - `src/compile/native-road.js` + - `src/compile/complex-junction-facilities.js` + - `test/helpers/junction-seams.js` + - `test/junction-layer-seams.js` + - `package.json` + - `.trellis/spec/backend/index.md` + - `.trellis/spec/backend/junction-layer-seams.md` + - `.trellis/tasks/09-17-junction-layer-seams/`(需求、设计、实施、验收及上下文) + +2. `docs: scope junction exclusion routing follow-up` + - `.trellis/tasks/09-17-junction-exclusion-routing/`(规划与只读初审,无产品代码) + +没有未识别的脏文件;没有 fixture 快照更新;不推送远端。 +确认后按上述顺序提交,再归档接缝专项并记录会话。 +排除区专项保持 planning,父任务保持已归档。 + +确认要求来源:`.trellis/workflow.md` Phase 3.4 第 5 步 +“Present the plan once, ask for one-shot confirmation”。 diff --git a/.trellis/tasks/09-17-junction-layer-seams/design.md b/.trellis/tasks/09-17-junction-layer-seams/design.md new file mode 100644 index 0000000..babf5c1 --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/design.md @@ -0,0 +1,11 @@ +# 接缝审计设计 + +审计发布几何与来源身份,复用已有 BoundaryGraph/structure 中的接入关系。先在 test/helpers/junction-seams.js 建立独立测量,再由 test/junction-layer-seams.js 编译合成和真实场景。报告以 JSON 可序列化对象输出,各层记录身份、测量值、判定和覆盖数量;不新增产品 API。 + +面积接边测量两端及整段覆盖,不只检查顶点最近距离。线图层按方向与 lane_index 对应外部车道和 transition lane。对条纹/虚线按其连续支撑线或合法裁切终点评估,不要求白条填满所有空间。需先审计生成代码确定每层有效接缝契约,不能将所有图层强行套用道路面边界。 + +局部米制坐标以当前接缝作为原点,避免绝对经纬度距离与面积数值误差。几何辅助优先复用既有 polygon/segment 工具,但测试期望不能调用被测生成器重建同一结果。 + +修改范围:新增测量测试与 helper、package.json 测试入口;如发现局部构建缺陷,仅修改拥有实际接缝的 native-road/complex-junction 模块,并补独立反例。新规划器不纳入本专项。 + +风险:缺失对象容易导致空集通过;虚线和控制标线本来有间隙;曲线法线可能让端点不一致。用覆盖计数、明确不适用原因及人工损坏反例验证审计器。若需改变设施语义,先记录独立专项。 diff --git a/.trellis/tasks/09-17-junction-layer-seams/evidence.md b/.trellis/tasks/09-17-junction-layer-seams/evidence.md new file mode 100644 index 0000000..a2df2fa --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/evidence.md @@ -0,0 +1,89 @@ +# 接缝专项验收证据 + +2026-09-17。实现与专项验收完成,用户已确认 Phase 3.4 提交及归档;父任务 +`junction-reference-fidelity` 保持归档。本次没有实施复杂绕障规划。 + +## 实际修复 + +真实 OSM 的两条相邻路口连接道路只选取一个端点所属 cluster 进行裁切。 +另一端的面边界没有真正形成接边,边线与车道线端点偏离约 28.9 / 34.4 m。 +旧顶点检查仍能通过,因为道路两条长边经过了应有接缝的两个端点。 + +`native-road.js` 现在从原始道路分别计算两端 station,一次裁切;道路面、 +边线、中心线、车道中心线和人行道共同使用这一规则,保留中间弯折。 +角部人行道的自交拒绝诊断改为具体 corner 身份,避免一个角部的拒绝 +掩盖另一个角部的意外缺失。设施省略规则没有更改。 + +## 测量矩阵与结果 + +完整契约见 `.trellis/spec/backend/junction-layer-seams.md`。 + +| 图层/接口 | checked | failed | notApplicable | 最大位置误差 m | 最大未覆盖长度 m | +| --- | ---: | ---: | ---: | ---: | ---: | +| 道路面 / 进口 / 最终铺装 | 172 | 0 | 0 | 0.003285 | 0.000262 | +| 核心 / 进口 | 86 | 0 | 0 | 0 | < 0.000001 | +| 道路边线 | 172 | 0 | 8 | 0.006183 | < 0.000001 | +| 道路中心线 | 26 | 0 | 86 | 0.000005 | < 0.000001 | +| 车道中心线 | 560 | 0 | 0 | 0.006149 | 0 | +| 车道分隔线 | 362 | 0 | 194 | 0.000004 | 0.000002 | +| 人行道 | 68 | 0 | 28 | 0 | 0 | + +以上最大值向上取整。共 **13 个场景、1,446 个测量记录**,阈值始终 +为 0.01 m。`checked` 是接口记录数,包含同一图层不同接口及多场景, +不是互不重复的道路数量。`notApplicable` 可与同一对象的有效测量并存, +用于说明不要求连续白漆或不发布中心标线的接口。 + +场景包含单向直线/曲线、双向直线/曲线、真实 OSM 单路口/相邻路口、 +真实道路显式开启人行道、双向曲线相邻路口、单向/双向局部展宽、 +岛体位移、道路与 cluster 输入重排、虚线边线。 + +测试锁定每个场景各图层的 checked 数量,所有应连续接口须通过。 +每个图层有非空覆盖;源数据没有人行道的真实场景明确标记不适用, +由显式开启人行道的真实场景提供角部接边验证。 + +负向测试验证:精确向东平移 2 cm、删除单个/整组必需对象、错误道路 +来源、交换车道序号、缺失外部人行道/分隔线、缺失起始锚定虚线、 +接边中部 2 cm 缺口及穿过接边的孔洞。原实现子代理中断留下的审计器 +还存在双向/驶出车道序号误配及缺失车道时异常,这些问题均已修正。 + +## 可复现命令 + +```sh +node test/junction-layer-seams.js --report /private/tmp/junction-layer-seams.json +node test/junction-island-offset.js +npm test +npm run test:client +npx prettier --check src/compile/native-road.js src/compile/complex-junction-facilities.js test/helpers/junction-seams.js test/junction-layer-seams.js package.json +git diff --check +``` + +报告按场景和图层保存 checked/failed/notApplicable、对象身份、feature IDs、 +位置误差、未覆盖长度、虚线端部间隙及省略原因;临时报告可随时重建, +不把大型机器报告作为仓库快照。 + +## 质量检查 + +- 专项最终 13 场景 / 1,446 接口通过;已加入 `npm test`。 +- `npm test` 中编译、结构、轨迹、投影、反例、设施、铺装、标线、 + 接缝、编辑文档、修订存储、编辑 solver、Workbench API 和导入测试通过。 + 最终 `test/fixtures.js:18` 仍因既有当前 OSM / 旧基线差异失败。 + 全量运行时为 11 场景,后续新增的 2 场景及强化反例已单独完整重跑通过; + 此后没有修改生产几何代码。 +- TypeScript 检查、独立岛体位移回归、变更文件 Prettier、diff 检查通过。 +- 全仓 `format:check` 仅报告既有未改动的 + `src/compile/junction-facility-composition.js` 格式问题。 +- 独立 `trellis-check` 已复核裁切、来源匹配、面积完整接边、缺对象、 + 车道映射及明确省略契约;未发现阻断问题。 + +## 明确限制 + +不把每个角部都能生成设施作为接缝验收条件。两个单向合成角部因自交被 +生成器明确拒绝;这些记录携带对应 corner 的拒绝原因,其他已发布角部 +仍必须完整接边。未实现新的角部设施语义。 + +虚线按接缝附近支撑线及合法端部间隙测量,起始锚点不能丢失;不声称 +验证整条道路的每根白条、双实/虚线每一组成部分或复杂核心内不存在的 +中心标线。路口外的所有内部标线连续性不是本审计的对象。 + +排除区最终铺装孔洞保留风险仅完成代码初审,尚未运行最终发布面的反例; +保留在 `09-17-junction-exclusion-routing/research.md`,不能当成已修复。 diff --git a/.trellis/tasks/09-17-junction-layer-seams/implement.jsonl b/.trellis/tasks/09-17-junction-layer-seams/implement.jsonl new file mode 100644 index 0000000..c4feaa3 --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/implement.jsonl @@ -0,0 +1,2 @@ +{"file": ".trellis/spec/backend/junction-island-contact.md", "reason": "共享坐标与精度约定"} +{"file": ".trellis/spec/backend/junction-layer-seams.md", "reason": "实施产生的共享接缝与两端裁切契约"} diff --git a/.trellis/tasks/09-17-junction-layer-seams/implement.md b/.trellis/tasks/09-17-junction-layer-seams/implement.md new file mode 100644 index 0000000..73beeb8 --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/implement.md @@ -0,0 +1,13 @@ +# 实施步骤 + +- [x] 审计现有接缝与落面断言,编写 PRD 和设计。 +- [x] 审计每个发布层的身份、裁切和连续性契约,写测量矩阵。 +- [x] 实现独立米制测量和报告,加入 2 cm 偏移、缺对象、错接和中段缺口反例。 +- [x] 建立直线、曲线、编辑、相邻路口、真实 OSM 场景,保证各层非空覆盖。 +- [x] 修复被测量定位的局部接缝错误;超出局部修复范围的项目列入独立专项。 +- [x] 接入 npm test,运行针对性回归、全量回归、变更文件格式及 git diff --check。 +- [x] 记录各层结果、误差、覆盖数量及明确限制;更新规范。 +- [x] 按 Phase 3.4 确认提交批次。 +- [ ] 提交并归档。 + +已知基线问题:npm test 的 test/fixtures.js 快照与当前 OSM 不符;全仓 format:check 曾在 junction-facility-composition.js 失败。不得把这两项写成通过,也不得为本任务直接重置快照。 diff --git a/.trellis/tasks/09-17-junction-layer-seams/prd.md b/.trellis/tasks/09-17-junction-layer-seams/prd.md new file mode 100644 index 0000000..3658bd9 --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/prd.md @@ -0,0 +1,26 @@ +# 复杂路口全图层接缝精度验证 + +## Goal + +以自动测量验证复杂路口各发布图层在应连续接口处的接缝精度,定位并修复支持范围内的局部缺陷。承接已归档 junction-reference-fidelity 的验证遗留。 + +## Requirements + +- 检查道路面、核心/进口面、道路边线、道路中心线、车道中心线、车道分隔线及人行道。 +- 由 road/carriageway/lane 来源身份匹配相邻对象,以米制测量完整接边或对应线端位置,不通过全图最近点掩盖错接。 +- 接缝位置误差上限 0.01 m。明确区分停止线裁切、虚线间隔与本来不发布的设施,这些正常断开不能算接缝失败。 +- 缺少应存在的相邻对象必须报错,不能跳过。各图层报告 checked/failed/not-applicable 数量、对象身份、误差与不适用原因。 +- 测量发现的局部构建错误应修复;新绕障规划和设施规则变更作为独立专项。 + +## Acceptance Criteria + +- [x] 每个图层有非空的应连续样本,覆盖直线、曲线、宽度变化、局部编辑、相邻路口与当前真实 OSM。 +- [x] 人为移动接缝 2 cm、删除必需邻接对象、错接不同道路均被检测;面积接边中间缺口不能只凭两端接触通过。 +- [x] 输入重排保持身份匹配稳定。支持场景满足 1 cm,不放宽阈值或减少覆盖使测试通过。 +- [x] 回归纳入 npm test,记录已有 fixture 差异,不刷新基线掩盖变化。 + +## 范围边界和现有证据 + +不涉及复杂排除区绕障、多通行区路径规划、车辆扫掠、UI 新控件或人工视觉验收。1 cm 为内部拼接精度,不是 OSM 测绘精度。 + +test/index.js:148 已验证 transition lane 与进口断面;:193 验证展宽保持外部图层;:230 仅验证道路面接缝端点;:324 的 0.3 m 落面容差不等同于接缝;:379 验证角部人行道完整端边。test/junction-build-plan-counterexamples.js:718 有核心整段覆盖反例。 diff --git a/.trellis/tasks/09-17-junction-layer-seams/task.json b/.trellis/tasks/09-17-junction-layer-seams/task.json new file mode 100644 index 0000000..8a58755 --- /dev/null +++ b/.trellis/tasks/09-17-junction-layer-seams/task.json @@ -0,0 +1,26 @@ +{ + "id": "junction-layer-seams", + "name": "junction-layer-seams", + "title": "复杂路口全图层接缝精度验证", + "description": "", + "status": "in_progress", + "dev_type": null, + "scope": null, + "package": null, + "priority": "P2", + "creator": "dingkang", + "assignee": "dingkang", + "createdAt": "2026-09-17", + "completedAt": null, + "branch": null, + "base_branch": "main", + "worktree_path": null, + "commit": null, + "pr_url": null, + "subtasks": [], + "children": [], + "parent": null, + "relatedFiles": ["src/compile/native-road.js", "src/compile/complex-junction-facilities.js", "test/helpers/junction-seams.js", "test/junction-layer-seams.js", "package.json"], + "notes": "实现及专项验收完成:13 场景、1446 接口;详情见 evidence.md。全量回归保留既有 fixture / format 基线问题。用户已确认 Phase 3.4 提交及归档。", + "meta": {} +} diff --git a/package.json b/package.json index ad09bfa..076137c 100644 --- a/package.json +++ b/package.json @@ -8,7 +8,7 @@ "road-compiler": "bin/road-compiler.js" }, "scripts": { - "test": "node test/index.js && node test/junction-structure.js && node test/connector-trajectories.js && node test/junction-projection.js && node test/junction-build-plan-counterexamples.js && node test/junction-polygon-ops.js && node test/junction-region-solver.js && node test/junction-facility-composition.js && node test/junction-pavement-region.js && node test/junction-marking-containment.js && node test/junction-corridor-markings.js && node test/native-road-edits.js && node test/road-revisions.js && node test/direct-edit-solver.js && node test/workbench-edit-api.js && node test/workbench-import-compile.js && node test/fixtures.js", + "test": "node test/index.js && node test/junction-structure.js && node test/connector-trajectories.js && node test/junction-projection.js && node test/junction-build-plan-counterexamples.js && node test/junction-polygon-ops.js && node test/junction-region-solver.js && node test/junction-facility-composition.js && node test/junction-pavement-region.js && node test/junction-marking-containment.js && node test/junction-corridor-markings.js && node test/junction-layer-seams.js && node test/native-road-edits.js && node test/road-revisions.js && node test/direct-edit-solver.js && node test/workbench-edit-api.js && node test/workbench-import-compile.js && node test/fixtures.js", "test:fixtures:update-baseline": "node test/update-fixture-baselines.js", "road:workbench": "node bin/road-workbench.js", "road:export": "node bin/road-compiler.js", diff --git a/src/compile/complex-junction-facilities.js b/src/compile/complex-junction-facilities.js index 2a840f9..b16e814 100644 --- a/src/compile/complex-junction-facilities.js +++ b/src/compile/complex-junction-facilities.js @@ -853,7 +853,7 @@ function buildCornerSidewalk({ cornerDiagnostics.push( helpers.diagnostic( 'warning', - `junction-cluster:${cluster.id}`, + `corner:${first.cornerKey}`, [...nodeIds], 'complex-junction-sidewalk-corner-fallback', '该夹角的人行道转角几何自交或无效,已跳过,两侧步行带保持断开。', diff --git a/src/compile/native-road.js b/src/compile/native-road.js index a039f17..ee4413b 100644 --- a/src/compile/native-road.js +++ b/src/compile/native-road.js @@ -708,14 +708,7 @@ function compileGeometry(model, overrides = { overrides: [] }, options = {}) { } const line = cluster?.template === 'complex-junction-v1' - ? trimLineAtComplexCluster( - road.centerline, - road.sourceNodeIds, - junctionPlans, - cluster, - complexClusterCenters.get(cluster.id), - complexApproachBoundaries.get(cluster.id)?.get(road.id), - ) + ? trimRoadAtComplexClusters(road, junctionPlans, activeClusters, complexApproachBoundaries) : trimLineAtJunctions(road.centerline, road.sourceNodeIds, junctionPlans); const ring = roadRing(line, totalWidth); if (!ring) { @@ -1237,7 +1230,6 @@ function compileEdgeLines( const clusterByNode = new Map( clusters.flatMap((cluster) => cluster.nodeIds.map((nodeId) => [String(nodeId), cluster])), ); - const clusterCenters = new Map(clusters.map((cluster) => [cluster.id, clusterCenter(cluster, junctionPlans)])); // Roads swallowed by a complex cluster never get a surface. Deriving their // edge from the centerline anyway paints a curb across bare ground, so take // the surfaces actually emitted as the authority on what can be outlined. @@ -1261,14 +1253,7 @@ function compileEdgeLines( clusterByNode.get(String(road.sourceNodeIds[0])) || clusterByNode.get(String(road.sourceNodeIds.at(-1))); const line = cluster?.template === 'complex-junction-v1' - ? trimLineAtComplexCluster( - road.centerline, - road.sourceNodeIds, - junctionPlans, - cluster, - clusterCenters.get(cluster.id), - complexBoundaries.get(cluster.id)?.get(road.id), - ) + ? trimRoadAtComplexClusters(road, junctionPlans, clusters, complexBoundaries) : trimLineAtJunctions(road.centerline, road.sourceNodeIds, junctionPlans); // On a two-way segment, the inner edge is the road centre boundary and is // owned by center_lines. Emit only each directional carriageway's outer @@ -1345,14 +1330,7 @@ function compileCenterLines( const cluster = clusterForRoad(forward, options) || clusterForRoad(backward, options); const internalCluster = cluster && roadInternalToCluster(forward, cluster); const line = cluster - ? trimLineAtComplexCluster( - forward.centerline, - forward.sourceNodeIds, - junctionPlans, - cluster, - clusterCenter(cluster, junctionPlans), - complexBoundaries.get(cluster.id)?.get(forward.id), - ) + ? trimRoadAtComplexClusters(forward, junctionPlans, options.junctionTemplates.clusters, complexBoundaries) : trimLineAtJunctions(forward.centerline, forward.sourceNodeIds, junctionPlans); const length = lineLengthMeters(line); if (line.length < 2 || !Number.isFinite(length)) { @@ -2030,20 +2008,12 @@ function compileSidewalkSurfaces( ['right', forward.sidewalkRight || Boolean(backward?.sidewalkLeft)], ]; const cluster = clusterForRoad(forward, options) || (backward ? clusterForRoad(backward, options) : null); - const center = cluster ? clusterCenter(cluster, junctionPlans) : null; for (const [side, enabled] of sides) { const profile = forward.directEditProfile; const sidewalkWidth = profile?.sidewalkWidths?.[side] ?? DEFAULT_SIDEWALK_WIDTH_METERS; if (!enabled || sidewalkWidth <= 0) continue; const centerline = cluster - ? trimLineAtComplexCluster( - forward.centerline, - forward.sourceNodeIds, - junctionPlans, - cluster, - center, - complexBoundaries.get(cluster.id)?.get(forward.id), - ) + ? trimRoadAtComplexClusters(forward, junctionPlans, options.junctionTemplates.clusters, complexBoundaries) : trimLineAtJunctions(forward.centerline, forward.sourceNodeIds, junctionPlans); const ring = sidewalkRing(centerline, totalWidth / 2, totalWidth / 2 + sidewalkWidth, side === 'left' ? 1 : -1); if (!ring) { @@ -2310,14 +2280,7 @@ function compileLaneCenterlines( const internalCluster = boundaryCluster && roadInternalToCluster(road, boundaryCluster); const clippedRoadLine = boundaryCluster?.template === 'complex-junction-v1' - ? trimLineAtComplexCluster( - road.centerline, - road.sourceNodeIds, - junctionPlans, - boundaryCluster, - clusterCenters.get(boundaryCluster.id), - complexBoundaries.get(boundaryCluster.id)?.get(road.id), - ) + ? trimRoadAtComplexClusters(road, junctionPlans, clusters, complexBoundaries) : trimLineAtJunctions(road.centerline, road.sourceNodeIds, junctionPlans); // OSM centerline is the shared carriageway center. On a two-way road, // offset each directed carriageway to its own side before placing lanes. @@ -3642,20 +3605,27 @@ function trimLineAtJunctions(line, sourceNodeIds, junctionPlans) { return result; } -function trimLineAtComplexCluster(line, sourceNodeIds, junctionPlans, cluster, center, boundarySection) { - if (!center || line.length < 2) return trimLineAtJunctions(line, sourceNodeIds, junctionPlans); - const radius = complexJunctionMetrics(cluster).approachOuterRadius; - const startInCluster = cluster.nodeIds.map(String).includes(String(sourceNodeIds[0])); - const endInCluster = cluster.nodeIds.map(String).includes(String(sourceNodeIds.at(-1))); +function trimRoadAtComplexClusters(road, junctionPlans, clusters, boundaries) { + const { centerline: line, sourceNodeIds } = road; + if (line.length < 2) return line; const available = lineLengthMeters(line); - const startDistance = startInCluster - ? (boundarySection?.outer.stationMeters ?? distanceAlongLineToRadius(line, center, radius)) - : 0; - const endDistance = endInCluster - ? (boundarySection?.outer.stationMeters ?? distanceAlongLineToRadius([...line].reverse(), center, radius)) - : 0; - const startCutback = startDistance > 0 && available > startDistance + 1 ? startDistance : 0; - const endCutback = endDistance > 0 && available > endDistance + 1 ? endDistance : 0; + // Both stations refer to the original source line. Trimming sequentially + // would shift the second station and choosing one cluster leaves a corridor + // extending through the other junction's approach. + const cutback = (nodeId, oriented) => { + const cluster = clusters.find( + (item) => item.template === 'complex-junction-v1' && item.nodeIds.map(String).includes(String(nodeId)), + ); + if (!cluster) return 0; + const center = clusterCenter(cluster, junctionPlans); + if (!center) return 0; + const station = + boundaries.get(cluster.id)?.get(road.id)?.outer.stationMeters ?? + distanceAlongLineToRadius(oriented, center, complexJunctionMetrics(cluster).approachOuterRadius); + return station > 0 && available > station + 1 ? station : 0; + }; + const startCutback = cutback(sourceNodeIds[0], line); + const endCutback = cutback(sourceNodeIds.at(-1), [...line].reverse()); if (!startCutback && !endCutback) return line; return trimLineRange(line, startCutback, endCutback); } diff --git a/test/helpers/junction-seams.js b/test/helpers/junction-seams.js new file mode 100644 index 0000000..38fa0fc --- /dev/null +++ b/test/helpers/junction-seams.js @@ -0,0 +1,478 @@ +'use strict'; + +// Independent measurements of published geometry. Do not call the boundary or +// marking builders here: a shared bug must not manufacture its own expectation. +const TOLERANCE_METERS = 0.01; +const LAYERS = [ + 'roadSurface', + 'coreApproach', + 'edgeLines', + 'centerLines', + 'laneCenterlines', + 'laneSeparators', + 'sidewalkSurface', +]; +const mix = (a, b, t = 0.5) => a.map((v, i) => v + (b[i] - v) * t); +const ids = (value) => + String(value || '') + .split(',') + .filter(Boolean); +const id = (feature) => feature?.properties?.native_id; +const xy = (point, origin) => [ + (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180), + (point[1] - origin[1]) * 111320, +]; +const distance = (a, b) => Math.hypot(...xy(a, b)); +const dot = (a, b) => a[0] * b[0] + a[1] * b[1]; +const cross = (a, b) => a[0] * b[1] - a[1] * b[0]; +const subtract = (a, b) => a.map((v, i) => v - b[i]); + +function pointSegmentDistance(point, a, b) { + const p = xy(a, point), + q = xy(b, point), + v = subtract(q, p); + const t = Math.max(0, Math.min(1, -dot(p, v) / (dot(v, v) || 1))); + return Math.hypot(...mix(p, q, t)); +} + +function lineDistance(point, line) { + return Math.min(...line.slice(1).map((q, i) => pointSegmentDistance(point, line[i], q))); +} + +function ringsOf(feature) { + if (feature?.geometry?.type === 'Polygon') return feature.geometry.coordinates; + if (feature?.geometry?.type === 'MultiPolygon') return feature.geometry.coordinates.flat(); + return []; +} + +function inside(point, ring) { + let result = false; + for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) { + const a = ring[i], + b = ring[j]; + if (a[1] > point[1] !== b[1] > point[1] && point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0]) + result = !result; + } + return result; +} + +// Partition at every edge crossing. A narrow interior notch cannot hide +// between probes, unlike endpoint-only or fixed quarter-point measurements. +function measureSegment(a, b, feature, boundaryOnly = true) { + const rings = ringsOf(feature).map((ring) => ring.map((p) => xy(p, a))); + const end = xy(b, a), + length = Math.hypot(...end), + length2 = dot(end, end); + if (!rings.length || !length) return { errorMeters: null, uncoveredMeters: length, missing: true }; + const partitions = [0, 1], + intervals = []; + for (const ring of rings) + for (let i = 1; i < ring.length; i++) { + const p = ring[i - 1], + q = ring[i], + v = subtract(q, p), + denominator = cross(end, v); + if (Math.abs(denominator) > 1e-12) { + const t = cross(p, v) / denominator, + u = cross(p, end) / denominator; + if (t > 0 && t < 1 && u >= 0 && u <= 1) partitions.push(t); + } + // Project only edges parallel and numerically coincident with the seam. + // Tolerance is a permitted geometric error, not permission to bridge gaps. + if ( + Math.abs(cross(end, p)) / length <= TOLERANCE_METERS && + Math.abs(cross(end, q)) / length <= TOLERANCE_METERS + ) { + const first = Math.max(0, Math.min(dot(p, end), dot(q, end)) / length2); + const last = Math.min(1, Math.max(dot(p, end), dot(q, end)) / length2); + if (last > first) { + intervals.push([first, last]); + partitions.push(first, last); + } + } + } + partitions.sort((x, y) => x - y); + let uncoveredMeters = 0; + const polygons = feature.geometry.type === 'Polygon' ? [feature.geometry.coordinates] : feature.geometry.coordinates; + const inPolygon = (p) => + polygons.some((polygon) => inside(p, polygon[0]) && !polygon.slice(1).some((hole) => inside(p, hole))); + for (let i = 1; i < partitions.length; i++) { + const first = partitions[i - 1], + last = partitions[i], + t = (first + last) / 2; + if (!intervals.some(([lo, hi]) => t >= lo && t <= hi) && (boundaryOnly || !inPolygon(mix(a, b, t)))) + uncoveredMeters += (last - first) * length; + } + const endpointError = Math.max( + ...[a, b].map((p) => + !boundaryOnly && inPolygon(p) ? 0 : Math.min(...ringsOf(feature).map((ring) => lineDistance(p, ring))), + ), + ); + return { errorMeters: endpointError, uncoveredMeters }; +} + +function caps(feature) { + const ring = ringsOf(feature)[0] || [], + half = (ring.length - 1) / 2; + if (!Number.isInteger(half) || half < 2) return []; + return [ + [ring[0], ring[ring.length - 2]], + [ring[half - 1], ring[half]], + ]; +} + +function auditJunctionSeams(model, geometry, structures) { + const report = Object.fromEntries( + LAYERS.map((layer) => [layer, { checked: 0, failed: 0, notApplicable: 0, records: [] }]), + ); + const features = (layer) => geometry[layer]?.features || []; + function record(layer, identity, measurement, featureIds = []) { + const missing = Boolean(measurement.missing); + const failed = + missing || + !Number.isFinite(measurement.errorMeters) || + measurement.errorMeters > TOLERANCE_METERS || + (measurement.uncoveredMeters || 0) > TOLERANCE_METERS; + report[layer].checked++; + if (failed) report[layer].failed++; + report[layer].records.push({ + ...identity, + featureIds: featureIds.filter(Boolean), + ...measurement, + status: failed ? 'failed' : 'passed', + }); + } + function na(layer, identity, reason) { + report[layer].notApplicable++; + report[layer].records.push({ ...identity, status: 'not-applicable', reason }); + } + function point(layer, identity, expected, candidates, points) { + const actual = candidates.flatMap(points); + record( + layer, + identity, + { + errorMeters: actual.length ? Math.min(...actual.map((p) => distance(expected, p))) : null, + missing: !actual.length, + }, + candidates.map(id), + ); + } + for (const structure of structures) { + const clusterId = structure.junctionRef.id; + const core = features('roadSurface').find( + (f) => f.properties.cluster_id === clusterId && f.properties.kind === 'complex-core', + ); + for (const arm of structure.arms) + for (const carriageway of arm.carriageways) { + const roadIds = carriageway.provenance.roadIds; + const identity = { clusterId, carriagewayKey: carriageway.key, roadIds }; + const approach = features('roadSurface').find((f) => f.properties.carriageway_key === carriageway.key); + if (!approach) { + for (const layer of LAYERS.filter((name) => name !== 'sidewalkSurface')) + record(layer, identity, { missing: true, errorMeters: null, reason: 'Required approach is missing.' }); + continue; + } + const ring = approach.geometry.coordinates[0], + seam = [ring[0], ring[3]]; + const exterior = features('roadSurface').filter( + (f) => + roadIds.length === ids(f.properties.directional_road_ids).length && + roadIds.every((roadId) => ids(f.properties.directional_road_ids).includes(roadId)), + ); + record('roadSurface', { ...identity, join: 'exterior-approach' }, measureSegment(...seam, exterior[0]), [ + id(approach), + id(exterior[0]), + ]); + record('coreApproach', { ...identity, join: 'approach-core' }, measureSegment(ring[1], ring[2], core, false), [ + id(approach), + id(core), + ]); + const pavement = features('roadSurface').find( + (f) => f.properties.cluster_id === clusterId && f.properties.kind === 'complex-pavement-region', + ); + record( + 'roadSurface', + { ...identity, join: 'exterior-published-pavement' }, + measureSegment(...seam, pavement, false), + [id(pavement)], + ); + const road = model.roads.find((r) => r.id === roadIds[0]); + // Preview indices run right-to-left in the outward arm frame; native + // lanes run left-to-right in each road's travel frame. Derive the mapping + // from source direction, never from whichever geometry happens to be near. + const incoming = (r) => carriageway.provenance.nodeIds.includes(String(r.sourceNodeIds.at(-1))); + const sourceRoads = roadIds.map((roadId) => model.roads.find((r) => r.id === roadId)); + const bindings = [...sourceRoads.filter((r) => !incoming(r)), ...sourceRoads.filter(incoming)].flatMap((r) => + Array.from({ length: r.laneCount }, (_, i) => ({ + roadId: r.id, + laneIndex: incoming(r) ? i + 1 : r.laneCount - i, + })), + ); + const previews = features('laneCenterlines').filter( + (f) => + f.properties.carriageway_key === carriageway.key && + f.properties.cluster_preview && + roadIds.includes(f.properties.road_id), + ); + for (let index = 1; index <= carriageway.laneCount; index++) { + const laneIdentity = { ...identity, laneIndex: index }; + const preview = previews.find((f) => f.properties.lane_index === index); + const binding = bindings[index - 1]; + const external = features('laneCenterlines').filter( + (f) => + !f.properties.cluster_preview && + f.properties.road_id === binding.roadId && + f.properties.lane_index === binding.laneIndex, + ); + const expected = mix(...seam, (index - 0.5) / carriageway.laneCount); + point( + 'laneCenterlines', + { ...laneIdentity, join: 'transition-seam' }, + expected, + preview ? [preview] : [], + (f) => [f.geometry.coordinates[0]], + ); + point('laneCenterlines', { ...laneIdentity, join: 'external-transition' }, expected, external, (f) => [ + f.geometry.coordinates[0], + f.geometry.coordinates.at(-1), + ]); + } + // Edges terminate at the outer pavement edge; there is no separately + // published internal edge continuation. Match the same source road only. + const directions = model.roads.filter((r) => r.segmentId === road.segmentId); + for (const sourceRoad of sourceRoads) + for (const side of directions.length > 1 ? ['right'] : ['left', 'right']) { + const edges = features('edgeLines').filter( + (f) => f.properties.road_id === sourceRoad.id && f.properties.side === side, + ); + const expected = seam[(side === 'right') === incoming(sourceRoad) ? 1 : 0]; + if (edges.some((f) => f.properties.pattern !== 'solid')) { + const surfaceRing = ringsOf(exterior[0])[0] || []; + const half = (surfaceRing.length - 1) / 2; + const supports = [surfaceRing.slice(0, half), surfaceRing.slice(half, -1)]; + const support = supports.sort((a, b) => lineDistance(expected, a) - lineDistance(expected, b))[0]; + const nearest = edges + .map((f) => ({ f, ends: caps(f).map((cap) => mix(...cap)) })) + .sort( + (a, b) => + Math.min(...a.ends.map((p) => distance(p, expected))) - + Math.min(...b.ends.map((p) => distance(p, expected))), + )[0]; + const gap = Math.min(...nearest.ends.map((p) => distance(p, expected))); + record( + 'edgeLines', + { ...identity, roadId: sourceRoad.id, side, join: 'dash-support' }, + { + errorMeters: Math.max(...nearest.ends.map((p) => lineDistance(p, support))), + gapMeters: gap, + uncoveredMeters: Math.max(0, gap - (incoming(sourceRoad) ? 4 : 0)), + }, + [id(nearest.f)], + ); + na( + 'edgeLines', + { ...identity, side }, + 'Two-metre dashes with two-metre spacing need not end at the seam.', + ); + continue; + } + const actual = edges.flatMap((f) => caps(f).map((cap) => mix(...cap))); + record( + 'edgeLines', + { ...identity, roadId: sourceRoad.id, side }, + { + missing: !actual.length, + errorMeters: actual.length ? Math.min(...actual.map((p) => distance(p, expected))) : null, + }, + edges.map(id), + ); + } + for (let index = 1; index < carriageway.laneCount; index++) { + const separatorIdentity = { ...identity, leftLaneIndex: index, rightLaneIndex: index + 1 }; + const expected = mix(...seam, index / carriageway.laneCount); + const separators = features('laneSeparators').filter( + (f) => + f.properties.cluster_id === clusterId && + roadIds.includes(f.properties.road_id) && + f.properties.left_lane_index === index && + f.properties.provenance === 'native-road-complex-lane-separator/v1', + ); + point('laneSeparators', { ...separatorIdentity, join: 'transition-seam' }, expected, separators, (f) => + caps(f).map((cap) => mix(...cap)), + ); + const firstBinding = bindings[index - 1], + secondBinding = bindings[index]; + if (firstBinding.roadId !== secondBinding.roadId) { + na( + 'laneSeparators', + separatorIdentity, + 'Opposite directions meet at the road centre marking, not an exterior lane separator.', + ); + continue; + } + const exteriorIndex = Math.min(firstBinding.laneIndex, secondBinding.laneIndex); + const exteriorSeparators = features('laneSeparators').filter( + (f) => + f.properties.road_id === firstBinding.roadId && + f.properties.left_lane_index === exteriorIndex && + f.properties.provenance === 'native-road-lane-separator/v1', + ); + if (!exteriorSeparators.length) + record('laneSeparators', separatorIdentity, { missing: true, errorMeters: null }); + else { + // The final dash need not end at the seam. Its centre must lie on the + // same lane pair's support, near this interface rather than another arm. + const lanes = [exteriorIndex, exteriorIndex + 1].map((laneIndex) => + features('laneCenterlines').find( + (f) => + !f.properties.cluster_preview && + f.properties.road_id === firstBinding.roadId && + f.properties.lane_index === laneIndex, + ), + ); + const nearest = exteriorSeparators + .map((f) => ({ f, point: mix(...caps(f).map((cap) => mix(...cap))) })) + .sort((a, b) => distance(a.point, expected) - distance(b.point, expected))[0]; + const first = lanes[0]?.geometry.coordinates, + second = lanes[1]?.geometry.coordinates; + const support = first && first.length === second?.length ? first.map((p, i) => mix(p, second[i])) : []; + const gap = Math.min(...caps(nearest.f).map((cap) => distance(mix(...cap), expected))); + record( + 'laneSeparators', + { ...separatorIdentity, join: 'external-dash-support' }, + { + missing: !support.length, + errorMeters: support.length + ? Math.max(...caps(nearest.f).map((cap) => lineDistance(mix(...cap), support))) + : null, + gapMeters: gap, + uncoveredMeters: Math.max( + 0, + gap - + (nearest.f.properties.pattern === 'solid' || + !incoming(sourceRoads.find((r) => r.id === firstBinding.roadId)) + ? 0 + : 4), + ), + }, + [id(nearest.f), ...lanes.map(id)], + ); + na( + 'laneSeparators', + separatorIdentity, + 'Dash spacing and stop-line clipping do not require white paint across the seam.', + ); + } + } + if (carriageway.laneCount < 2) na('laneSeparators', identity, 'Single lane has no lane separator.'); + if (directions.length < 2 || road.highway === 'service') + na('centerLines', identity, 'No bidirectional road centre marking is published.'); + else { + const markings = features('centerLines').filter( + (f) => + roadIds.includes(f.properties.road_id) && + roadIds.length === ids(f.properties.directional_road_ids).length && + roadIds.every((roadId) => ids(f.properties.directional_road_ids).includes(roadId)), + ); + const nearest = markings + .map((f) => ({ f, point: mix(...caps(f).map((cap) => mix(...cap))) })) + .sort((a, b) => distance(a.point, mix(...seam)) - distance(b.point, mix(...seam)))[0]; + const supportPoints = nearest ? caps(nearest.f).map((cap) => mix(...cap)) : []; + const gap = supportPoints.length ? Math.min(...supportPoints.map((p) => distance(p, mix(...seam)))) : null; + record( + 'centerLines', + identity, + { + missing: !nearest, + errorMeters: nearest + ? Math.max( + ...supportPoints.map((p) => + Math.abs(lineDistance(p, road.centerline) - (nearest.f.properties.double ? 0.16 : 0)), + ), + ) + : null, + gapMeters: gap, + uncoveredMeters: + gap === null + ? 0 + : Math.max( + 0, + gap - + (incoming(sourceRoads.find((r) => r.id === nearest.f.properties.road_id)) + ? nearest.f.properties.dash_length_m + nearest.f.properties.dash_gap_m + : 0), + ), + }, + [id(nearest?.f)], + ); + na( + 'centerLines', + identity, + 'Road centre dashes terminate outside the cluster; no interior centre marking is published.', + ); + } + } + for (const corner of structure.corners) { + const arms = [corner.fromArmKey, corner.toArmKey].map((key) => structure.arms.find((arm) => arm.key === key)); + const roadGroups = arms.map((arm) => arm.carriageways.flatMap((c) => c.provenance.roadIds)); + const strips = roadGroups.map((roadIds) => + features('sidewalkSurface').filter( + (f) => + f.properties.provenance === 'native-road-sidewalk/v1' && + ids(f.properties.directional_road_ids).some((roadId) => roadIds.includes(roadId)), + ), + ); + const identity = { clusterId, cornerKey: corner.key, roadIds: roadGroups.flat() }; + if (strips.some((group) => !group.length)) { + const enabled = roadGroups.every((group) => + group.some((roadId) => { + const road = model.roads.find((r) => r.id === roadId); + return road?.sidewalkLeft || road?.sidewalkRight; + }), + ); + if (enabled) record('sidewalkSurface', identity, { missing: true, errorMeters: null }); + else na('sidewalkSurface', identity, 'Source arms do not both carry sidewalks.'); + continue; + } + const join = features('sidewalkSurface').find( + (f) => f.properties.kind === 'complex-sidewalk-corner' && f.properties.corner_key === corner.key, + ); + if (!join) { + const omitted = (geometry.diagnostics || []).find( + (d) => + d.subjectId === `corner:${corner.key}` && + [ + 'complex-junction-sidewalk-corner-fallback', + 'complex-junction-island-infeasible', + 'complex-junction-corner-exclusion-overlap', + ].includes(d.rule), + ); + if (omitted) na('sidewalkSurface', identity, `Explicitly rejected corner: ${omitted.rule}. ${omitted.message}`); + else record('sidewalkSurface', identity, { missing: true, errorMeters: null }); + continue; + } + if (caps(join).length !== 2) { + record('sidewalkSurface', identity, { missing: true, errorMeters: null, reason: 'Invalid corner end edges.' }); + continue; + } + for (const [index, cap] of caps(join).entries()) { + const candidates = strips[index] + .map((f) => ({ f, measurement: measureSegment(...cap, f) })) + .sort( + (a, b) => + a.measurement.errorMeters + + a.measurement.uncoveredMeters - + (b.measurement.errorMeters + b.measurement.uncoveredMeters), + ); + record('sidewalkSurface', { ...identity, end: index }, candidates[0].measurement, [ + id(join), + id(candidates[0].f), + ]); + } + } + } + return report; +} + +module.exports = { TOLERANCE_METERS, LAYERS, auditJunctionSeams, measureSegment, distance }; diff --git a/test/junction-layer-seams.js b/test/junction-layer-seams.js new file mode 100644 index 0000000..6d42c57 --- /dev/null +++ b/test/junction-layer-seams.js @@ -0,0 +1,343 @@ +'use strict'; + +const assert = require('assert/strict'); +const fs = require('fs'); +const path = require('path'); +const { compileRoadModel, compileGeometry } = require('../src/compile/native-road'); +const { auditJunctionSeams, LAYERS, measureSegment } = require('./helpers/junction-seams'); + +const overrides = { overrides: [] }; +function compile(name, model, clusters, extra = {}, styles = overrides) { + const geometry = compileGeometry(model, styles, { junctionTemplates: { enabled: true, clusters }, ...extra }); + const structures = geometry.roadSurface.features.map((f) => f.properties.junction_structure).filter(Boolean); + assert.equal(structures.length, clusters.length, `${name}: missing junction structure`); + const report = auditJunctionSeams(model, geometry, structures); + return { name, model, clusters, geometry, structures, report }; +} + +function synthetic(curved = false, twoWay = false, adjacent = false) { + const nodes = [ + [-5, 0], + [240, 0], + [5, 240], + [-240, 0], + [-5, -240], + [100, curved ? 12 : 0], + [5, 0], + ]; + if (adjacent) nodes.push([250, 0], [240, 240], [500, 0], [250, -240]); + const ways = [2, 3, 4, 5].map((n) => [n, [n <= 3 ? 7 : 1, ...(n === 2 ? [6] : []), n]]); + if (adjacent) ways.push([9, [2, 9]], [10, [8, 10]], [11, [8, 11]]); + const internal = [[1, 7], ...(adjacent ? [[2, 8]] : [])]; + const osm = `${nodes.map(([x, y], i) => ``).join('')}${ways.map(([id, refs]) => `${refs.map((ref) => ``).join('')}${twoWay ? '' : ''}`).join('')}${internal.map((refs, i) => `${refs.map((ref) => ``).join('')}`).join('')}`; + return compileRoadModel(osm, overrides); +} + +const cluster = { id: 'synthetic', template: 'complex-junction-v1', coreRadiusMeters: 21, nodeIds: ['1', '7'] }; +const realModel = compileRoadModel( + fs.readFileSync(path.join(__dirname, '../inputs/osm/枫树二路.osm'), 'utf8'), + overrides, +); +const west = { + id: 'west', + template: 'complex-junction-v1', + coreRadiusMeters: 21, + nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147'], +}; +const east = { + id: 'east', + template: 'complex-junction-v1', + coreRadiusMeters: 18, + nodeIds: ['1590698046', '6538106539'], +}; +const scenarios = [ + compile('straight', synthetic(), [cluster]), + compile('curved', synthetic(true), [cluster]), + compile('two-way', synthetic(false, true), [cluster]), + compile('two-way-curved', synthetic(true, true), [cluster]), + compile('real-osm', realModel, [west]), + compile('adjacent', realModel, [west, east]), + compile( + 'sidewalks', + { ...realModel, roads: realModel.roads.map((r) => ({ ...r, sidewalkLeft: true, sidewalkRight: true })) }, + [west], + ), +]; +scenarios.push( + compile('two-way-adjacent', synthetic(true, true, true), [ + cluster, + { ...cluster, id: 'synthetic-east', nodeIds: ['2', '8'] }, + ]), +); +const curvedTwoWay = scenarios.find((s) => s.name === 'two-way-curved'); +const twoWayApproach = curvedTwoWay.geometry.roadSurface.features.find((f) => f.properties.kind === 'complex-approach'); +scenarios.push( + compile('two-way-width-edit', curvedTwoWay.model, [cluster], { + directEdit: { + clusterPlans: new Map([ + [cluster.id, new Map([[twoWayApproach.properties.carriageway_key, twoWayApproach.properties.width_m * 1.2]])], + ]), + }, + }), +); + +const curved = scenarios[1]; +const approach = curved.geometry.roadSurface.features.find((f) => f.properties.kind === 'complex-approach'); +scenarios.push( + compile('width-edit', curved.model, [cluster], { + directEdit: { + clusterPlans: new Map([ + [cluster.id, new Map([[approach.properties.carriageway_key, approach.properties.width_m * 1.2]])], + ]), + }, + }), +); +scenarios.push( + compile('island-edit', realModel, [west], { directEdit: { clusterIslandOffsets: new Map([[west.id, 3.3]]) } }), +); +scenarios.push(compile('adjacent-reordered', { ...realModel, roads: [...realModel.roads].reverse() }, [east, west])); +scenarios.push( + compile( + 'dashed-edges', + synthetic(true, true), + [cluster], + {}, + { + overrides: synthetic(true, true).roads.flatMap((r) => + ['left', 'right'].map((side) => ({ + kind: 'edge-line-style', + roadId: r.id, + side, + color: 'white', + pattern: 'dashed', + })), + ), + }, + ), +); + +const expectedCoverage = { + straight: [8, 4, 8, 0, 24, 16, 4], + curved: [8, 4, 8, 0, 24, 16, 4], + 'two-way': [8, 4, 8, 4, 32, 20, 8], + 'two-way-curved': [8, 4, 8, 4, 32, 20, 8], + 'real-osm': [16, 8, 16, 0, 48, 32, 0], + adjacent: [26, 13, 26, 1, 76, 49, 0], + sidewalks: [16, 8, 16, 0, 48, 32, 8], + 'width-edit': [8, 4, 8, 0, 24, 16, 4], + 'island-edit': [16, 8, 16, 0, 48, 32, 0], + 'adjacent-reordered': [26, 13, 26, 1, 76, 49, 0], + 'dashed-edges': [8, 4, 8, 4, 32, 20, 8], + 'two-way-adjacent': [16, 8, 16, 8, 64, 40, 16], + 'two-way-width-edit': [8, 4, 8, 4, 32, 20, 8], +}; +for (const { name, report } of scenarios) { + assert.deepEqual( + LAYERS.map((layer) => report[layer].checked), + expectedCoverage[name], + `${name}: coverage changed`, + ); + for (const layer of LAYERS) { + assert.equal( + report[layer].failed, + 0, + `${name}/${layer}: ${JSON.stringify(report[layer].records.filter((r) => r.status === 'failed'))}`, + ); + assert.ok(report[layer].records.every((r) => r.status !== 'not-applicable' || r.reason)); + } +} +for (const layer of LAYERS) + assert.ok( + scenarios.some((s) => s.report[layer].checked > 0), + `${layer}: empty audit`, + ); + +// Reordering must preserve expected source identities, not just pass counts. +function identities(report) { + return Object.fromEntries( + LAYERS.map((layer) => [ + layer, + report[layer].records + .map((r) => + JSON.stringify({ + ...r, + featureIds: undefined, + errorMeters: undefined, + uncoveredMeters: undefined, + gapMeters: undefined, + roadIds: [...r.roadIds].sort(), + }), + ) + .sort(), + ]), + ); +} +assert.deepEqual( + identities(scenarios.find((s) => s.name === 'adjacent').report), + identities(scenarios.find((s) => s.name === 'adjacent-reordered').report), +); + +// Corrupt published outputs while retaining the independent expected topology. +const base = scenarios.find((s) => s.name === 'two-way'); +function detects(name, layer, mutate, scenario = base) { + const geometry = structuredClone(scenario.geometry); + mutate(geometry); + const result = auditJunctionSeams(scenario.model, geometry, scenario.structures); + assert.ok(result[layer].failed > 0, `${name}: audit silently accepted damaged ${layer}`); +} +const shift = (coordinates, dx, dy) => + typeof coordinates[0] === 'number' + ? [coordinates[0] + dx / (111320 * Math.cos((coordinates[1] * Math.PI) / 180)), coordinates[1] + dy / 111320] + : coordinates.map((value) => shift(value, dx, dy)); +const move = (feature) => { + feature.geometry.coordinates = shift(feature.geometry.coordinates, 0.02, 0); +}; +for (const [layer, predicate, auditLayer = layer] of [ + ['roadSurface', (f) => Boolean(f.properties.directional_road_ids)], + ['roadSurface', (f) => f.properties.kind === 'complex-core', 'coreApproach'], + ['roadSurface', (f) => f.properties.kind === 'complex-approach'], + ['edgeLines', () => true], + ['centerLines', () => true], + ['laneCenterlines', (f) => !f.properties.cluster_preview], + ['laneSeparators', (f) => f.properties.provenance === 'native-road-complex-lane-separator/v1'], + ['sidewalkSurface', (f) => f.properties.kind === 'complex-sidewalk-corner'], +]) { + detects('missing counterpart', auditLayer, (g) => { + g[layer].features = g[layer].features.filter((f) => !predicate(f)); + }); + detects('one missing counterpart', auditLayer, (g) => { + const index = g[layer].features.findIndex(predicate); + assert.ok(index >= 0); + g[layer].features.splice(index, 1); + }); + detects('2 cm displacement', auditLayer, (g) => g[layer].features.filter(predicate).forEach(move)); +} +detects('wrong preview source', 'laneCenterlines', (g) => { + g.laneCenterlines.features.find((f) => f.properties.cluster_preview).properties.road_id = 'wrong-road'; +}); +detects('wrong centre primary source', 'centerLines', (g) => { + for (const f of g.centerLines.features) f.properties.road_id = 'wrong-road'; +}); +detects('partial centre source match', 'centerLines', (g) => { + for (const f of g.centerLines.features) f.properties.directional_road_ids = `${f.properties.road_id},wrong-road`; +}); +for (const layer of ['edgeLines', 'centerLines', 'laneCenterlines', 'laneSeparators']) { + detects('wrong source', layer, (g) => { + for (const f of g[layer].features) { + f.properties.road_id = 'wrong-road'; + if (f.properties.directional_road_ids) f.properties.directional_road_ids = 'wrong-road'; + } + }); +} +detects('swapped lane indices', 'laneCenterlines', (g) => { + for (const f of g.laneCenterlines.features.filter((f) => !f.properties.cluster_preview)) + f.properties.lane_index = 3 - f.properties.lane_index; +}); +detects('wrong surface source', 'roadSurface', (g) => { + for (const f of g.roadSurface.features.filter((f) => f.properties.directional_road_ids)) + f.properties.directional_road_ids = 'wrong-road'; +}); +detects('missing sidewalk strip', 'sidewalkSurface', (g) => { + g.sidewalkSurface.features = g.sidewalkSurface.features.filter( + (f) => f.properties.provenance !== 'native-road-sidewalk/v1', + ); +}); +detects('wrong sidewalk source', 'sidewalkSurface', (g) => { + for (const f of g.sidewalkSurface.features.filter((f) => f.properties.provenance === 'native-road-sidewalk/v1')) + f.properties.directional_road_ids = 'wrong-road'; +}); +detects( + 'displaced edge dashes', + 'edgeLines', + (g) => g.edgeLines.features.forEach(move), + scenarios.find((s) => s.name === 'dashed-edges'), +); +detects( + 'missing anchored edge dash', + 'edgeLines', + (g) => g.edgeLines.features.shift(), + scenarios.find((s) => s.name === 'dashed-edges'), +); +detects('missing exterior separators', 'laneSeparators', (g) => { + g.laneSeparators.features = g.laneSeparators.features.filter( + (f) => f.properties.provenance !== 'native-road-lane-separator/v1', + ); +}); +detects('displaced exterior separators', 'laneSeparators', (g) => + g.laneSeparators.features.filter((f) => f.properties.provenance === 'native-road-lane-separator/v1').forEach(move), +); + +// A 2 cm notch away from all endpoint/quarter/midpoint probes must fail. +const metric = ([x, y]) => [120 + x / (111320 * Math.cos(Math.PI / 6)), 30 + y / 111320]; +const polygon = (ring) => ({ geometry: { type: 'Polygon', coordinates: [ring.map(metric)] } }); +const full = polygon([ + [0, 0], + [10, 0], + [10, 2], + [0, 2], + [0, 0], +]); +const notch = polygon([ + [0, 0], + [3.11, 0], + [3.11, 0.1], + [3.13, 0.1], + [3.13, 0], + [10, 0], + [10, 2], + [0, 2], + [0, 0], +]); +for (const boundaryOnly of [true, false]) { + assert.ok(measureSegment(metric([0, 0]), metric([10, 0]), full, boundaryOnly).uncoveredMeters < 0.01); + assert.ok(measureSegment(metric([0, 0]), metric([10, 0]), notch, boundaryOnly).uncoveredMeters > 0.019); +} +const holed = polygon([ + [0, -1], + [10, -1], + [10, 2], + [0, 2], + [0, -1], +]); +holed.geometry.coordinates.push( + [ + [3.11, -0.1], + [3.13, -0.1], + [3.13, 0.1], + [3.11, 0.1], + [3.11, -0.1], + ].map(metric), +); +assert.ok(measureSegment(metric([0, 0]), metric([10, 0]), holed, false).uncoveredMeters > 0.019); + +const summary = scenarios.map(({ name, report }) => ({ + name, + layers: Object.fromEntries( + LAYERS.map((layer) => { + const { checked, failed, notApplicable, records } = report[layer]; + return [ + layer, + { + checked, + failed, + notApplicable, + maxErrorMeters: Math.max(0, ...records.map((r) => r.errorMeters || 0)), + maxUncoveredMeters: Math.max(0, ...records.map((r) => r.uncoveredMeters || 0)), + }, + ]; + }), + ), +})); +const reportIndex = process.argv.indexOf('--report'); +if (reportIndex >= 0) + fs.writeFileSync( + process.argv[reportIndex + 1], + JSON.stringify( + { toleranceMeters: 0.01, summary, scenarios: scenarios.map(({ name, report }) => ({ name, report })) }, + null, + 2, + ) + '\n', + ); +console.log( + `junction layer seam tests passed (${scenarios.length} scenarios, ${summary.reduce((sum, s) => sum + Object.values(s.layers).reduce((n, l) => n + l.checked, 0), 0)} measured joins)`, +);