diff --git a/.trellis/spec/backend/junction-island-contact.md b/.trellis/spec/backend/junction-island-contact.md index a78003b..70b6b47 100644 --- a/.trellis/spec/backend/junction-island-contact.md +++ b/.trellis/spec/backend/junction-island-contact.md @@ -54,3 +54,25 @@ Wrong: move a stripe until it touches an arc at one point and declare success because overlap area is zero. Correct: share the complete crossing short-edge segment with the island boundary, then derive the green polygon from those same endpoints and verify non-contact curves separately. + +## Generator stage ordering + +`src/compile/complex-junction.js` keeps `buildComplexJunctionGeometry` as the +orchestrator. Its private stages own approach selection/stop lines, arm crossing +layout, corner composition, crossing displacement, pavement assembly and +publication. Keep the existing local solvers in their geometry modules. + +- `buildArmCrossings` writes the arm's `crosswalkFrame`, `crosswalkRadius` and + evidence before `buildCornerCompositions` consumes them. +- Corner contact solutions collect both endpoint offsets for each shared arm. + Call `applyCrossingDisplacements` once after all corners, before pavement + assembly. It updates stripes, stop lines and the full swept crossing regions; + moving only the visible stripes leaves pavement gaps. +- Preserve the current failure dependency during structural refactors: a failed + corner contact solve also skips that corner's sidewalk. Changing this is a + behavior change requiring a dedicated regression, not a helper extraction. +- Core `approach_headings` uses `arm.representative.heading`, not `arm.heading`: + the representative heading and grouped arm heading can differ. +- Validate refactors against complete generator results, including feature + order, metadata and diagnostics. Run `test/junction-island-offset.js` explicitly + alongside `npm test`; it covers the shared-endpoint displacement path. diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/implement.md b/.trellis/tasks/09-08-junction-reference-fidelity/implement.md index e44194d..bb8080e 100644 --- a/.trellis/tasks/09-08-junction-reference-fidelity/implement.md +++ b/.trellis/tasks/09-08-junction-reference-fidelity/implement.md @@ -1,5 +1,13 @@ # 实施计划与阶段出口 +## 2026-09-16 生成器结构重构 + +用户确认梳理 `buildComplexJunctionGeometry`,已将千行入口缩为约 159 行阶段编排,按进口、过街、角部、位移、铺装和发布拆出私有函数。45 次完整新旧返回值深比较一致;几何/编辑/API/导入回归、191 项客户端单测、类型检查和 12 项 E2E 通过。`npm test` 最后仍有重构前已复现的 fixture 快照差异;全仓格式检查仍有未修改文件的既有问题,本次源文件格式通过。独立复核未发现行为变化。详细边界、可重跑差分脚本及证据见 `research/geometry-refactor.md`。未提交,父任务其余验收保持原状态。 + +后续评估已先迁出无状态局部几何工具至 `complex-junction-geometry.js`;`complex-junction.js` 从 1685 行降至 1472 行。设施阶段应以整体迁移的方式进入单独模块,避免将共享 arm frame 和角部失败依赖拆散。完整评估与本轮针对性验证见同一 research 文档。 + +该模块拆分已完成:`complex-junction-surfaces.js` 承担核心/进口/铺装,`complex-junction-facilities.js` 承担进口停止线、过街、角部和位移;入口文件现为 367 行。保持公开导出与构建顺序,差分和针对性回归通过;仍需按任务既有质量门在提交前重跑全量检查。 + 当前为 in_progress;任务已收敛为分阶段推进。第一个新阶段是“复杂路口区域模型”:先统一中心通行区、角部可行域和安全岛边界,再恢复设施与视觉验收。实验性固定安全岛修改已保存至 `/private/tmp/junction-island-experiment.patch`,不作为正式方案。 ## 0. 契约与最小反例 diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/research/geometry-refactor-parity.cjs b/.trellis/tasks/09-08-junction-reference-fidelity/research/geometry-refactor-parity.cjs new file mode 100644 index 0000000..9b45996 --- /dev/null +++ b/.trellis/tasks/09-08-junction-reference-fidelity/research/geometry-refactor-parity.cjs @@ -0,0 +1,47 @@ +'use strict'; + +// Run from the repo root with node --require test/.js. +// This one-off comparison retains the pre-refactor generator as its oracle. +const assert = require('node:assert/strict'); +const path = require('node:path'); +const Module = require('node:module'); +const { execFileSync } = require('node:child_process'); +const root = path.resolve(__dirname, '../../../..'); +const filename = path.join(root, 'src/compile/complex-junction.js'); +const baseline = new Module(filename, module); +baseline.filename = filename; +baseline.paths = Module._nodeModulePaths(path.dirname(filename)); +baseline._compile( + execFileSync('git', ['show', '1679d1b:src/compile/complex-junction.js'], { cwd: root, encoding: 'utf8' }), + filename, +); +const current = require(filename); +const build = current.buildComplexJunctionGeometry; +let comparisons = 0; +const shapes = new Set(); +const diagnostics = new Set(); +let shifted = 0; +let crossingEdits = 0; +current.buildComplexJunctionGeometry = function (model, cluster, helpers) { + const values = {}; + const functions = {}; + for (const [key, value] of Object.entries(helpers)) { + (typeof value === 'function' ? functions : values)[key] = value; + } + const copied = structuredClone({ model, cluster, values }); + const expected = baseline.exports.buildComplexJunctionGeometry(copied.model, copied.cluster, { + ...copied.values, + ...functions, + }); + const actual = build(model, cluster, helpers); + assert.deepStrictEqual(actual, expected, `generator output changed for ${cluster.id}`); + comparisons++; + shapes.add(actual.shape?.kind || 'early-return'); + for (const item of actual.diagnostics) diagnostics.add(item.rule); + if (helpers.clusterIslandOffsetMeters) shifted++; + if (helpers.clusterCrossingControls?.size) crossingEdits++; + return actual; +}; +process.on('exit', () => { + console.log('Generator parity:', { comparisons, shapes: [...shapes], shifted, crossingEdits, diagnostics: [...diagnostics] }); +}); diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/research/geometry-refactor.md b/.trellis/tasks/09-08-junction-reference-fidelity/research/geometry-refactor.md new file mode 100644 index 0000000..d44b1a2 --- /dev/null +++ b/.trellis/tasks/09-08-junction-reference-fidelity/research/geometry-refactor.md @@ -0,0 +1,47 @@ +# 复杂路口生成器结构整理 + +用户于 2026-09-16 确认实施代码审阅提出的结构重构。 + +## 边界与设计 + +现有 buildComplexJunctionGeometry 超过千行,阶段之间依赖 arm 上的可变字段和共享集合。本轮将入口整理为可读的阶段编排,抽取进口、过街布局、角部组合、位移联动和结果装配;角部组合继续拆出有明确职责的局部函数。阶段输入输出显式传递,避免通用可变 context。 + +实现范围为 src/compile/complex-junction.js 及必要的同目录内部模块。保留公开导出、运算顺序、坐标、Feature 顺序、ID、诊断和失败路径。清理本轮相关的无用变量、导入和过时注释;诊断内容不在此次改变。复用既有几何求解模块,不引入框架或新的配置机制,不改 UI 或几何算法。 + +## 验证计划 + +1. 保存重构前生成器,对实际测试输入逐次深比较完整返回值。 +2. 运行现有几何、编辑及完整 npm test 回归;既有失败需与基线区分,禁止刷新快照隐藏差异。 +3. 运行格式、客户端类型及 git diff --check;审阅阶段依赖和失败路径。 +4. 记录重构结果与验证证据,不关闭父任务的其他未完成验收。 + +## 实现与差分结果 + +生产修改仅位于 `src/compile/complex-junction.js`。主函数从 1021 行缩为约 159 行;同文件私有函数分别承担阶段编排及单个设施构建,最大新函数约 115 行。没有新增公开导出或依赖。删除两个无用导入和两项无用坐标计算;保留历史诊断并注明其兼容性原因。 + +差分工具最初位于 `/private/tmp/complex-junction-refactor-parity.cjs`,现保留在同目录 `geometry-refactor-parity.cjs`。用 Node Module 加载基线提交 `1679d1b` 的生成器,将每次实际调用的输入复制后交给旧函数,再对完整返回值执行 `assert.deepStrictEqual`。45 次比较全部一致:主测试流 41 次,单独 island-offset 测试 4 次(其中 3 次非零外移)。覆盖正交、偏置十字、T 形、多臂和节点不足返回,以及无效断面、短过渡、排除区、岛体求解失败、核心闭合失败、过街编辑等诊断路径。 + +检查结果: + +- `npm test` 的代码、几何、编辑、API、工作台导入检查通过,最后 `test/fixtures.js` 失败。该快照差异在重构前已单独复现,重构后输出哈希相同;未刷新基线。 +- `node --require /private/tmp/complex-junction-refactor-parity.cjs test/junction-island-offset.js` 通过。 +- 客户端类型检查、191 项客户端单测通过。 +- 本次源文件格式和 `git diff --check` 通过。全仓 `format:check` 在未修改的 `junction-facility-composition.js` 失败;对 HEAD 原文运行 Prettier 同样失败。 +- `npm run test:e2e` 通过:生产构建及 12 项浏览器回归,包含三臂复杂路口控制编辑、保存和刷新。保留既有 bundle 大小提示。 +- 独立代码复核通过,无新增修复:核对角部失败依赖、Feature/诊断顺序、共享过街位移和停止线联动。 + +本轮未提交,父任务保持进行中。历史“角部设施已省略”诊断与实际默认生成行为的矛盾保留为单独行为修正事项。 + +## 后续模块边界评估(2026-09-16) + +阶段编排已经从入口函数中抽出,但 `complex-junction.js` 仍保留了局部米制计算、道路臂包络、圆角相交、人行道接缝和环验证等无状态几何代码,导致文件仍有 1685 行。它们不依赖构建阶段、Feature 发布或诊断顺序,已迁入 `complex-junction-geometry.js`,入口文件降为 1472 行。 + +下一条清晰边界是 `complex-junction-facilities.js`:进口/停止线、道路臂过街、角部组合和位移联动共用可变的 arm frame,必须作为一个整体迁移;把它们逐个拆成更多小模块会掩盖阶段依赖。核心/入口面/统一铺装可作为之后的 `complex-junction-surfaces.js`。建议在当前功能任务结束并提交现有工作后,以完整输出差分为保护再实施这两次迁移,避免在仍频繁调整的设施算法中扩大冲突面。 + +本次几何模块提取保持输出:两组设施测试与 island-offset 测试通过,差分脚本对 5 次复杂路口完整返回值比较一致;铺装、落面和拓扑反例测试通过,变更文件 Prettier 与 `git diff --check` 通过。 + +随后迁出 `complex-junction-surfaces.js`:核心面、进口面与统一铺装区域现在作为一组独立的 surface 阶段。入口文件从 1473 行降至 1301 行。铺装、落面、拓扑反例与 island-offset 回归通过;差分脚本对 9 次复杂路口完整返回值比较一致,包含无效入口、T 形、圆角降级及非零岛体外移。 + +最后迁出 `complex-junction-facilities.js`:进口与停止线、道路臂过街、角部组合及共享位移共同拥有 arm frame 的写入、消费和最终应用,因此保持为单个模块。入口文件从 1301 行降至 367 行,只保留拓扑/指标/边界图、阶段编排和发布。迁移中补回形态分类所需的 `normalizeHeading` 与 `positiveHeadingDelta` 纯几何导入。设施组合、岛体外移、铺装、落面和拓扑反例通过;差分脚本对 5 次完整返回值比较一致,包含非零岛体外移。 + +完整 `npm test` 通过全部代码、几何、编辑 API 和工作台导入检查,最后仍在已有 `test/fixtures.js` 快照差异退出;该差异与重构前记录一致,未更新基线。首次完整回归暴露 facilities 模块遗漏 `ringsOverlap` 依赖,已补入并重跑。客户端类型检查和变更文件格式检查通过。 diff --git a/src/compile/complex-junction-facilities.js b/src/compile/complex-junction-facilities.js new file mode 100644 index 0000000..2a840f9 --- /dev/null +++ b/src/compile/complex-junction-facilities.js @@ -0,0 +1,955 @@ +'use strict'; + +const { COMPLEX_CROSSWALK_DEPTH_METERS } = require('./junction-metrics'); +const { ringsOverlap } = require('./junction-boundary-graph'); +const { rectangle } = require('./junction-pavement-region'); +const { orthogonalCrossingHeadings, stripeLayout, solveIslandContacts } = require('./junction-facility-composition'); +const { radialShift } = require('./junction-island-offset'); +const { + armCarriesSidewalk, + armEnvelopeAtRadius, + bearing, + cornerEdgeAt, + crossingEvidenceForArm, + directionalProjectionMeters, + exteriorSidewalkSeam, + midpoint, + normalizeHeading, + offsetPolylineAwayFromCenter, + polygonCenter, + positiveHeadingDelta, + pointOnCarriagewayRadius, + projectionRatio, + quadraticCurve, + rayIntersection, + ringSelfIntersects, + signedLateralMeters, +} = require('./complex-junction-geometry'); + +const CORNER_FILLET_SEGMENTS = 12; +const SIDEWALK_WIDTH_METERS = 2; + +function planArmCrossings(model, arms, center, coreRadius, crossingControls, helpers) { + const crossingPlans = new Map( + arms.map((arm) => { + const inferredRadius = Math.max(1, coreRadius * 0.68); + const inferredEnvelope = armEnvelopeAtRadius(arm, inferredRadius, center, helpers); + const evidence = inferredEnvelope + ? crossingEvidenceForArm(model, arm, inferredEnvelope.center, helpers) + : { kind: 'unknown-no-crossing-source', crossingNodeIds: [], crossing: null }; + return [ + arm.key, + { + evidence, + baseRadius: evidence.crossing ? helpers.distanceMeters(center, evidence.crossing.coordinate) : inferredRadius, + }, + ]; + }), + ); + const armCrosswalkRadiusFor = (arm) => + Math.max( + 1, + (crossingPlans.get(arm.key)?.baseRadius || coreRadius * 0.68) + + (crossingControls.get(`crossing:${arm.key}`)?.crosswalkInsetMeters || 0), + ); + return { crossingPlans, armCrosswalkRadiusFor }; +} + +function buildApproachSurfacesAndStops({ + model, + cluster, + helpers, + center, + arms, + carriageways, + boundaryGraph, + crossingControls, + crossingPlans, + armCrosswalkRadiusFor, +}) { + const boundaryParts = []; + const stopLines = []; + const transitionDiagnostics = []; + for (const section of boundaryGraph.sections) { + const item = carriageways.find((candidate) => candidate.key === section.carriagewayKey); + if (!item) continue; + // The approach plan owns the editable handoff distance. It shifts only this + // carriageway's outer transition, leaving neighboring arms untouched. A + // collapsed handoff is reported and omitted rather than publishing a + // zero-area trapezoid that downstream layers could mistake for pavement. + if (section.ringStatus !== 'supported') { + transitionDiagnostics.push( + helpers.diagnostic( + 'warning', + `carriageway:${item.key}`, + item.approach.roadIds.map(String), + 'complex-junction-entry-ring-invalid', + '该进口边界无法形成有效道路面,已省略退化或自交几何。', + section.inner.point, + ), + ); + continue; + } + if (section.exclusionStatus !== 'clear') { + transitionDiagnostics.push( + helpers.diagnostic( + 'warning', + `carriageway:${item.key}`, + item.approach.roadIds.map(String), + 'complex-junction-entry-overlaps-known-region', + '该进口过渡区域侵入已知排除区域,已省略该进口面以保留来源区域。', + section.inner.point, + ), + ); + continue; + } + if (section.transitionStatus !== 'supported') { + transitionDiagnostics.push( + helpers.diagnostic( + 'warning', + `carriageway:${item.key}`, + item.approach.roadIds.map(String), + 'complex-junction-entry-transition-unsupported', + '该进口在当前来源长度内无法形成外部断面到核心断面的连续过渡,已省略退化进口面。', + section.inner.point, + ), + ); + continue; + } + boundaryParts.push({ item, section }); + const stopLine = buildApproachStopLine({ + model, + cluster, + helpers, + center, + item, + arms, + crossingControls, + crossingPlans, + armCrosswalkRadiusFor, + }); + if (stopLine) stopLines.push(stopLine); + } + return { boundaryParts, stopLines, diagnostics: transitionDiagnostics }; +} + +function buildApproachStopLine({ + model, + cluster, + helpers, + center, + item, + arms, + crossingControls, + crossingPlans, + armCrosswalkRadiusFor, +}) { + const outerHalf = item.approach.widthMeters / 2; + const incomingRoad = item.approach.roadIds + .map((roadId) => model.roads.find((road) => road.id === roadId)) + .find((road) => String(road?.sourceNodeIds.at(-1)) === String(item.nodeId)); + if (incomingRoad) { + // Offset is clear space beyond the relocated crossing outer edge; include + // half the stop bar thickness so the minimum offset cannot cut into it. + const arm = arms.find((candidate) => candidate.members.includes(item)); + const crossingKey = `crossing:${arm.key}`; + const crossingRadius = armCrosswalkRadiusFor(arm); + const stopOffset = crossingControls.get(crossingKey)?.stopLineOffsetMeters || 3; + const stopHeading = orthogonalCrossingHeadings(arms.map((candidate) => candidate.heading))[arms.indexOf(arm)]; + const envelope = armEnvelopeAtRadius(arm, crossingRadius, center, helpers); + const basePoint = pointOnCarriagewayRadius(item, center, crossingRadius, helpers); + const lateral = signedLateralMeters(envelope.center, basePoint, stopHeading); + const stopCenter = helpers.offsetCoordinate( + helpers.offsetCoordinate(envelope.center, stopHeading + 90, lateral), + stopHeading, + COMPLEX_CROSSWALK_DEPTH_METERS * 1.5 + 0.24 + stopOffset, + ); + const crossingEvidence = crossingPlans.get(arm.key)?.evidence || { + kind: 'unknown-no-crossing-source', + crossingNodeIds: [], + }; + const ring = [ + helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, -0.24), + helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, outerHalf), stopHeading, -0.24), + helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, outerHalf), stopHeading, 0.24), + helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, 0.24), + helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, -0.24), + ]; + return { + type: 'Feature', + properties: { + native_id: `complex-stop-line:${cluster.id}:${item.approach.segmentId}`, + object_key: `stop-line:${item.key}`, + crossing_key: crossingKey, + arm_key: item.armKey, + carriageway_key: item.key, + cluster_id: cluster.id, + kind: 'complex-stop-line', + road_id: incomingRoad.id, + node_id: item.nodeId, + direction: item.heading, + facility_evidence: crossingEvidence.kind, + ...(crossingEvidence.crossingNodeIds.length + ? { source_crossing_node_ids: crossingEvidence.crossingNodeIds } + : {}), + provenance: 'native-road-complex-junction-stop-line/v1', + }, + geometry: { type: 'Polygon', coordinates: [ring] }, + }; + } +} + +function buildArmCrossings({ + arms, + center, + cluster, + helpers, + publishedCarriageways, + crossingPlans, + armCrosswalkRadiusFor, +}) { + const transitionDiagnostics = []; + // Frames belong to these local topology arms. Complete their layout before + // corner contacts consume the endpoints; displacement is applied only later. + // The four support lines provide a common corner frame, but each long + // crossing remains clipped to its OSM-derived road envelope. Corner islands + // fill the remaining frame gaps; crossings must never do that job. + for (const arm of arms) { + if (!arm.members.every((item) => publishedCarriageways.has(item.key))) { + transitionDiagnostics.push( + helpers.diagnostic( + 'warning', + `crossing:${arm.key}`, + arm.members.flatMap((item) => item.approach.roadIds.map(String)), + 'complex-junction-crosswalk-pavement-unavailable', + '该过街缺少完整可发布的车行道过渡面,已省略标线,避免跨越无效进口。', + center, + ), + ); + continue; + } + const armCrosswalkRadius = armCrosswalkRadiusFor(arm); + arm.crosswalkRadius = armCrosswalkRadius; + const envelope = armEnvelopeAtRadius(arm, armCrosswalkRadius, center, helpers); + if (!envelope) continue; + const evidence = crossingPlans.get(arm.key)?.evidence || { + kind: 'unknown-no-crossing-source', + crossingNodeIds: [], + }; + if (evidence.kind !== 'source-crossing-node') { + transitionDiagnostics.push( + helpers.diagnostic( + 'info', + `crossing:${arm.key}`, + arm.members.flatMap((item) => item.approach.roadIds.map(String)), + 'complex-junction-crossing-source-missing', + '该进口未找到匹配的 OSM 过街节点,过街来源未知,按复杂路口默认生成斑马线。', + envelope.center, + ), + ); + } + arm.crosswalkFrame = { + center: envelope.center, + groupDepth: COMPLEX_CROSSWALK_DEPTH_METERS, + supportHeading: normalizeHeading(arm.heading + 90), + envelopeWidthMeters: envelope.widthMeters, + }; + arm.crosswalkEvidence = evidence; + } + const crossingHeadings = orthogonalCrossingHeadings(arms.map((arm) => arm.heading)); + arms.forEach((arm, index) => { + if (arm.crosswalkFrame) { + arm.crosswalkFrame.heading = crossingHeadings[index]; + arm.crosswalkFrame.supportHeading = normalizeHeading(crossingHeadings[index] + 90); + } + }); + const crossingSpanTrim = coordinatedCrossingSpanTrim(arms, center, helpers); + const crosswalks = []; + const crossingRegions = []; + for (const arm of arms) { + if (!arm.crosswalkFrame) continue; + const crossing = buildArmCrossing(arm, crossingSpanTrim, cluster, helpers); + crosswalks.push(...crossing.crosswalks); + crossingRegions.push(crossing.region); + } + return { crosswalks, crossingRegions, diagnostics: transitionDiagnostics }; +} + +function coordinatedCrossingSpanTrim(arms, center, helpers) { + // Coordinate all four landing pairs before publishing stripes. Trim whole + // stripe pitches symmetrically so stripe size and spacing stay unchanged. + let crossingSpanTrim = 0; + if (arms.length === 4 && arms.every((arm) => arm.crosswalkFrame)) { + for (let attempt = 0; attempt < 12; attempt++) { + const trialTrim = attempt * 1.64; + const candidates = arms.map((arm) => { + const f = arm.crosswalkFrame; + const span = f.envelopeWidthMeters - 0.7 - trialTrim; + if (span < f.groupDepth) return null; + const shifted = helpers.offsetCoordinate(f.center, f.heading, f.groupDepth); + const layout = stripeLayout(span); + const half = span / 2 - (layout.centers[0] - layout.width / 2); + return [-1, 1].map((sign) => helpers.offsetCoordinate(shifted, f.heading + 90, sign * half)); + }); + if (candidates.some((candidate) => !candidate)) break; + const valid = arms.every((arm, i) => { + const j = (i + 1) % arms.length; + const pair = candidates[i] + .flatMap((a) => candidates[j].map((b) => ({ a, b, distance: helpers.distanceMeters(a, b) }))) + .sort((a, b) => a.distance - b.distance)[0]; + const origin = rayIntersection( + { point: pair.a, heading: arm.crosswalkFrame.heading }, + { point: pair.b, heading: arms[j].crosswalkFrame.heading }, + center, + ); + return ( + origin && + [ + [arm, pair.a], + [arms[j], pair.b], + ].every( + ([side, point]) => + directionalProjectionMeters(origin, point, side.crosswalkFrame.heading) > + side.crosswalkFrame.groupDepth / 2 + 0.2, + ) + ); + }); + if (valid) { + crossingSpanTrim = trialTrim; + break; + } + } + } + return crossingSpanTrim; +} + +function buildArmCrossing(arm, crossingSpanTrim, cluster, helpers) { + const crosswalks = []; + const item = arm.representative; + const crossingHeading = arm.crosswalkFrame.heading; + const roadEdgeInset = 0.35; + const usableSpan = Math.max(0.42, arm.crosswalkFrame.envelopeWidthMeters - roadEdgeInset * 2 - crossingSpanTrim); + const groupDepth = arm.crosswalkFrame.groupDepth; + arm.crosswalkFrame.center = helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading, groupDepth); + arm.crosswalkRadius += groupDepth; + const endpoints = [ + helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading + 90, -usableSpan / 2), + helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading + 90, usableSpan / 2), + ]; + const stripeWidth = 0.42; + const layout = stripeLayout(usableSpan); + const stripeCount = layout.centers.length; + const stripeSpacing = layout.pitch; + arm.crosswalkFrame.center = midpoint(...endpoints); + arm.crosswalkFrame.endpoints = endpoints; + arm.crosswalkFrame.spanMeters = usableSpan; + arm.crosswalkFrame.contactEndpointRatio = (layout.centers[0] - layout.width / 2) / usableSpan; + arm.crosswalkFrame.roadEdgeInsetMeters = roadEdgeInset; + const region = rectangle(arm.crosswalkFrame.center, crossingHeading, groupDepth, usableSpan); + for (let stripe = 0; stripe < stripeCount; stripe += 1) { + const along = layout.centers[stripe]; + const centerPoint = helpers.offsetCoordinate(endpoints[0], bearing(...endpoints), along); + const ring = [ + helpers.offsetCoordinate( + helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), + crossingHeading + 90, + -stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), + crossingHeading + 90, + -stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), + crossingHeading + 90, + stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), + crossingHeading + 90, + stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), + crossingHeading + 90, + -stripeWidth / 2, + ), + ]; + crosswalks.push({ + type: 'Feature', + properties: { + native_id: `complex-crosswalk:${cluster.id}:${item.nodeId}:${item.approach.segmentId}:${stripe + 1}`, + object_key: `crossing:${arm.key}`, + crossing_key: `crossing:${arm.key}`, + arm_key: arm.key, + cluster_id: cluster.id, + kind: 'complex-crosswalk', + crossing_node_id: item.nodeId, + road_id: item.approach.roadIds[0], + direction: crossingHeading, + radial_distance_m: arm.crosswalkRadius, + span_m: usableSpan, + road_envelope_span_m: arm.crosswalkFrame.envelopeWidthMeters, + road_edge_inset_m: roadEdgeInset, + group_depth_m: groupDepth, + stripe_width_m: stripeWidth, + stripe_spacing_m: stripeSpacing, + frame_center: arm.crosswalkFrame.center, + frame_support_heading: arm.crosswalkFrame.supportHeading, + facility_evidence: arm.crosswalkEvidence.kind, + ...(arm.crosswalkEvidence.crossingNodeIds.length + ? { source_crossing_node_ids: arm.crosswalkEvidence.crossingNodeIds } + : {}), + provenance: 'native-road-complex-junction-crosswalk/v6-road-clipped', + }, + geometry: { type: 'Polygon', coordinates: [ring] }, + }); + } + return { crosswalks, region }; +} + +function buildCornerCompositions({ + model, + cluster, + helpers, + center, + nodeIds, + arms, + boundaryGraph, + publishedCarriageways, + coreRadius, + outerRadius, +}) { + const cornerFills = []; + const sidewalkCorners = []; + const cornerDiagnostics = []; + const islands = []; + const crosswalks = []; + // Two neighbouring corners contribute offsets to each shared arm crossing. + const armEndpointOffsets = new Map(); + const islandOffsetMeters = Number(helpers.clusterIslandOffsetMeters) || 0; + const cornerOverlapsExclusion = (ring, cornerKey, part) => { + const region = boundaryGraph.exclusionRegions.find((region) => ringsOverlap(region.ring, ring)); + if (!region) return false; + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `corner:${cornerKey}`, + [String(region.id)], + 'complex-junction-corner-exclusion-overlap', + `该角部${part}侵入已知排除区域 ${region.id},已省略,避免覆盖已知不可通行空间。`, + center, + ), + ); + return true; + }; + const omittedCornerFacilityCount = arms.filter((arm, index) => { + const next = arms[(index + 1) % arms.length]; + const delta = positiveHeadingDelta(arm.heading, next.heading); + return delta >= 45 && delta <= 135; + }).length; + // Retain the legacy diagnostic for output compatibility. Default inferred + // corner facilities below are still governed by their geometric checks. + if (omittedCornerFacilityCount) + cornerDiagnostics.push( + helpers.diagnostic( + 'info', + `junction-cluster:${cluster.id}`, + [...nodeIds], + 'complex-junction-corner-facilities-omitted', + `已省略 ${omittedCornerFacilityCount} 组缺少岛体或步行连接来源的角部导流岛和斑马线。`, + center, + ), + ); + const defaultCornerRadius = Math.max(4, Math.min(25, Number(cluster.cornerRadiusMeters) || 12)); + for (let index = 0; index < arms.length; index += 1) { + const first = arms[index]; + const second = arms[(index + 1) % arms.length]; + if (!publishedCarriageways.size) continue; + const cornerRadius = helpers.clusterCornerRadii?.get(first.cornerKey) ?? defaultCornerRadius; + const fillet = buildCornerFillet({ + first, + second, + index, + cornerRadius, + coreRadius, + outerRadius, + center, + cluster, + nodeIds, + helpers, + cornerOverlapsExclusion, + cornerDiagnostics, + }); + if (!fillet) continue; + cornerFills.push(fillet.feature); + const contacts = solveCornerContacts({ + first, + second, + center, + outerRadius, + islandOffsetMeters, + nodeIds, + helpers, + cornerDiagnostics, + armEndpointOffsets, + }); + if (!contacts) continue; + islands.push(...buildCornerIslands(first, index, cluster, contacts, cornerOverlapsExclusion)); + if ( + !first.members.every((item) => publishedCarriageways.has(item.key)) || + !second.members.every((item) => publishedCarriageways.has(item.key)) + ) + continue; + crosswalks.push(...buildDiagonalCrossing(first, index, cluster, contacts, helpers)); + // Preserve the composition's failure dependency: sidewalks are only built + // after the corner contact solve and the carriageway publication checks. + const sidewalk = buildCornerSidewalk({ + first, + second, + index, + model, + cluster, + center, + nodeIds, + boundaryGraph, + helpers, + fillet, + cornerOverlapsExclusion, + cornerDiagnostics, + }); + if (sidewalk) sidewalkCorners.push(sidewalk); + } + return { cornerFills, sidewalkCorners, islands, crosswalks, armEndpointOffsets, diagnostics: cornerDiagnostics }; +} + +function buildCornerFillet({ + first, + second, + index, + cornerRadius, + coreRadius, + outerRadius, + center, + cluster, + nodeIds, + helpers, + cornerOverlapsExclusion, + cornerDiagnostics, +}) { + const delta = positiveHeadingDelta(first.heading, second.heading); + if (delta < 45 || delta > 135) return null; + const bisector = normalizeHeading(first.heading + delta / 2); + const edges = [first, second].map((arm) => cornerEdgeAt(arm, coreRadius + 6, bisector, center, helpers)); + if (!edges.every(Boolean)) return null; + const apex = rayIntersection(edges[0], edges[1], center); + const apexReach = apex ? directionalProjectionMeters(center, apex, bisector) : null; + // The wedge apex has to sit ahead of the core and inside the arm handoff; + // outside that band the two edges are near parallel and any fillet fitted + // to them would sweep across the carriageways instead of the corner. + if (apexReach === null || apexReach < 1 || apexReach > outerRadius) { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `junction-cluster:${cluster.id}`, + [...nodeIds], + 'complex-junction-corner-fillet-fallback', + '该夹角的道路边缘切线无法安全构造圆角,已保留直角过渡。', + center, + ), + ); + return null; + } + // Tangent distance for a circle of `cornerRadius` inscribed in a wedge of + // opening `delta`. + // Keep the radius control continuous. The previous handoff cap made a + // sizeable part of the advertised 1..25 m range geometry-inert: once the + // tangent distance hit the cap, pressing Enter only changed metadata. + // The solver's radius bounds and the generated arm envelope provide the + // validity boundary; this value must remain the direct geometric response. + const tangentDistance = cornerRadius / Math.tan((delta * Math.PI) / 360); + const tangents = edges.map((edge) => helpers.offsetCoordinate(apex, edge.heading, tangentDistance)); + const curve = quadraticCurve(tangents[0], apex, tangents[1], CORNER_FILLET_SEGMENTS); + const ring = [...curve, center, curve[0]]; + if (!ring.every((point) => point.every(Number.isFinite))) return null; + if (cornerOverlapsExclusion(ring, first.cornerKey, '道路补面')) return null; + const feature = { + type: 'Feature', + properties: { + native_id: `complex-corner-fillet:${cluster.id}:${index + 1}`, + cluster_id: cluster.id, + kind: 'complex-corner-fillet', + object_key: first.cornerKey, + corner_key: first.cornerKey, + complex_part: 'corner-fillet', + corner_index: index + 1, + from_heading: first.heading, + to_heading: second.heading, + bisector_heading: bisector, + corner_radius_m: cornerRadius, + tangent_distance_m: Math.round(tangentDistance * 100) / 100, + apex_reach_m: Math.round(apexReach * 100) / 100, + provenance: 'native-road-complex-junction-corner-fillet/v1', + }, + geometry: { type: 'Polygon', coordinates: [ring] }, + }; + return { feature, edges, curve, bisector }; +} + +function solveCornerContacts({ + first, + second, + center, + outerRadius, + islandOffsetMeters, + nodeIds, + helpers, + cornerDiagnostics, + armEndpointOffsets, +}) { + if (!first.crosswalkFrame?.endpoints || !second.crosswalkFrame?.endpoints) return null; + const endpointPairs = first.crosswalkFrame.endpoints.flatMap((a, firstEndpointIndex) => + second.crosswalkFrame.endpoints.map((b, secondEndpointIndex) => ({ + a, + b, + firstEndpointIndex, + secondEndpointIndex, + distance: helpers.distanceMeters(a, b), + })), + ); + const pair = endpointPairs.sort((a, b) => a.distance - b.distance)[0]; + const crossingCorner = rayIntersection( + { point: pair.a, heading: first.crosswalkFrame.heading }, + { point: pair.b, heading: second.crosswalkFrame.heading }, + center, + ); + if (!crossingCorner) return null; + const lonScale = 111320 * Math.cos((crossingCorner[1] * Math.PI) / 180); + const toLocal = (point) => [(point[0] - crossingCorner[0]) * lonScale, (point[1] - crossingCorner[1]) * 111320]; + const fromLocal = (point) => [crossingCorner[0] + point[0] / lonScale, crossingCorner[1] + point[1] / 111320]; + const landing = (arm, endpoint) => { + const frame = arm.crosswalkFrame; + const layout = stripeLayout(frame.spanMeters); + const margin = layout.centers[0] - layout.width / 2; + const edgeCenter = helpers.offsetCoordinate(endpoint, bearing(endpoint, frame.center), margin); + return [-1, 1].map((sign) => + toLocal(helpers.offsetCoordinate(edgeCenter, frame.heading, (sign * frame.groupDepth) / 2)), + ); + }; + let contactSolution = solveIslandContacts( + landing(first, pair.a), + landing(second, pair.b), + COMPLEX_CROSSWALK_DEPTH_METERS, + { maxLegLength: outerRadius }, + ); + if (contactSolution.status !== 'solved') { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `corner:${first.cornerKey}`, + [...nodeIds], + 'complex-junction-island-infeasible', + contactSolution.reason, + crossingCorner, + ), + ); + return null; + } + // Dragging moves the whole pedestrian composition away from the cluster + // centre. Re-solve from the translated landing segments so the island, + // its green contact hexagon and all three complete contacts retain the same + // source coordinates instead of merely translating a detached island. + let islandShift = [0, 0]; + if (islandOffsetMeters > 0) { + const provisionalRing = contactSolution.ring.map(fromLocal); + const provisionalCenter = polygonCenter(provisionalRing); + islandShift = radialShift(center, provisionalCenter, islandOffsetMeters); + const localShift = toLocal([crossingCorner[0] + islandShift[0], crossingCorner[1] + islandShift[1]]); + const translateSegment = (segment) => segment.map((point) => [point[0] + localShift[0], point[1] + localShift[1]]); + const shifted = solveIslandContacts( + translateSegment(landing(first, pair.a)), + translateSegment(landing(second, pair.b)), + COMPLEX_CROSSWALK_DEPTH_METERS, + { maxLegLength: outerRadius }, + ); + if (shifted.status !== 'solved') { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `corner:${first.cornerKey}`, + [...nodeIds], + 'complex-junction-island-offset-infeasible', + shifted.reason, + crossingCorner, + ), + ); + return null; + } + contactSolution = shifted; + const rememberOffset = (arm, endpointIndex) => { + const offsets = armEndpointOffsets.get(arm.key) || [ + [0, 0], + [0, 0], + ]; + offsets[endpointIndex] = islandShift; + armEndpointOffsets.set(arm.key, offsets); + }; + rememberOffset(first, pair.firstEndpointIndex); + rememberOffset(second, pair.secondEndpointIndex); + } + return { contactSolution, fromLocal }; +} + +function buildCornerIslands(first, index, cluster, { contactSolution, fromLocal }, cornerOverlapsExclusion) { + const islands = []; + const publishedIslandRing = contactSolution.ring.map(fromLocal); + const greenRing = contactSolution.greenRing.map(fromLocal); + if (!cornerOverlapsExclusion(publishedIslandRing, first.cornerKey, '安全岛')) + islands.push({ + type: 'Feature', + properties: { + native_id: `complex-corner-island:${cluster.id}:${index + 1}`, + object_key: `island:inferred/${first.cornerKey}`, + cluster_id: cluster.id, + kind: 'island', + corner_key: first.cornerKey, + facility_evidence: 'inferred-complex-junction-corner', + provenance: 'native-road-complex-junction-inferred-island/v1', + island_leg_lengths_m: contactSolution.legLengths, + contact_points: greenRing.slice(0, -1), + }, + geometry: { type: 'Polygon', coordinates: [publishedIslandRing] }, + }); + if (!cornerOverlapsExclusion(greenRing, first.cornerKey, '安全岛绿色接触区')) + islands.push({ + type: 'Feature', + properties: { + native_id: `complex-corner-island-green:${cluster.id}:${index + 1}`, + object_key: `island:inferred/${first.cornerKey}`, + cluster_id: cluster.id, + corner_key: first.cornerKey, + kind: 'island-green', + island_key: `island:inferred/${first.cornerKey}`, + provenance: 'native-road-complex-junction-island-contact-hexagon/v1', + }, + geometry: { type: 'Polygon', coordinates: [greenRing] }, + }); + + return islands; +} + +function buildDiagonalCrossing(first, index, cluster, { contactSolution, fromLocal }, helpers) { + const crosswalks = []; + const stripeWidth = 0.42; + // Complex junctions carry a default diagonal crossing across each safe + // corner. Source crossing nodes refine provenance/inset values, but are + // not required for the default visual treatment. + const outerMidpoint = fromLocal(contactSolution.thirdCenter); + const diagonalDepth = COMPLEX_CROSSWALK_DEPTH_METERS; + const outwardHeading = (Math.atan2(contactSolution.outward[0], contactSolution.outward[1]) * 180) / Math.PI; + const diagonalHeading = outwardHeading; + const diagonalCenter = helpers.offsetCoordinate(outerMidpoint, outwardHeading, diagonalDepth / 2); + const diagonalSpan = COMPLEX_CROSSWALK_DEPTH_METERS; + const layout = stripeLayout(diagonalDepth); + const stripeCount = layout.centers.length; + const stripeSpacing = layout.pitch; + for (let stripe = 0; stripe < stripeCount; stripe += 1) { + const along = -diagonalDepth / 2 + layout.centers[stripe] - (layout.centers[0] - stripeWidth / 2); + const stripeCenter = helpers.offsetCoordinate(diagonalCenter, diagonalHeading, along); + const ring = [ + helpers.offsetCoordinate( + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), + diagonalHeading, + -stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), + diagonalHeading, + -stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), + diagonalHeading, + stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), + diagonalHeading, + stripeWidth / 2, + ), + helpers.offsetCoordinate( + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), + diagonalHeading, + -stripeWidth / 2, + ), + ]; + crosswalks.push({ + type: 'Feature', + properties: { + native_id: `complex-corner-crosswalk:${cluster.id}:${index + 1}:${stripe + 1}`, + object_key: `crossing:corner:${first.cornerKey}`, + crossing_key: `crossing:corner:${first.cornerKey}`, + island_key: `island:inferred/${first.cornerKey}`, + from_boundary: `sidewalk:${first.cornerKey}:from`, + to_boundary: `island:inferred/${first.cornerKey}`, + cluster_id: cluster.id, + kind: 'complex-corner-crosswalk', + stripe_width_m: stripeWidth, + stripe_spacing_m: stripeSpacing, + group_depth_m: COMPLEX_CROSSWALK_DEPTH_METERS, + corner_key: first.cornerKey, + facility_evidence: 'default-complex-junction', + provenance: 'native-road-complex-junction-corner-crosswalk/v1', + }, + geometry: { type: 'Polygon', coordinates: [ring] }, + }); + } + + return crosswalks; +} + +function buildCornerSidewalk({ + first, + second, + index, + model, + cluster, + center, + nodeIds, + boundaryGraph, + helpers, + fillet, + cornerOverlapsExclusion, + cornerDiagnostics, +}) { + const { edges, curve, bisector } = fillet; + // The straight pedestrian strips are trimmed at the cluster boundary, so + // two arms that both carry a footway still meet as two loose ends across + // an empty wedge. Bridge them along the curb the fillet already defines. + // The corner faces clockwise from `first` and counter-clockwise from + // `second`, so each arm must carry the footway on that facing side. + if (!armCarriesSidewalk(first, model, true) || !armCarriesSidewalk(second, model, false)) return null; + const seams = edges.map((edge) => exteriorSidewalkSeam(edge, boundaryGraph, helpers)); + if (!seams.every(Boolean)) { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `corner:${first.cornerKey}`, + edges.flatMap((edge) => edge.roadIds), + 'complex-junction-sidewalk-seam-unavailable', + '该角部缺少两侧可验证的人行道接缝,已省略连接,避免生成悬空步行带。', + center, + ), + ); + return null; + } + const curb = [seams[0].curb, ...curve, seams[1].curb]; + const outerEdge = offsetPolylineAwayFromCenter(curb, center, SIDEWALK_WIDTH_METERS, helpers); + outerEdge[0] = seams[0].outer; + outerEdge[outerEdge.length - 1] = seams[1].outer; + const sidewalkRing = [...curb, ...outerEdge.slice().reverse(), curb[0]]; + if (!sidewalkRing.every((point) => point.every(Number.isFinite)) || ringSelfIntersects(sidewalkRing)) { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `junction-cluster:${cluster.id}`, + [...nodeIds], + 'complex-junction-sidewalk-corner-fallback', + '该夹角的人行道转角几何自交或无效,已跳过,两侧步行带保持断开。', + center, + ), + ); + return null; + } + if (cornerOverlapsExclusion(sidewalkRing, first.cornerKey, '人行道')) return null; + return { + type: 'Feature', + properties: { + native_id: `complex-sidewalk-corner:${cluster.id}:${index + 1}`, + cluster_id: cluster.id, + kind: 'complex-sidewalk-corner', + object_key: `sidewalk-turn:${first.cornerKey}`, + corner_key: first.cornerKey, + corner_index: index + 1, + from_heading: first.heading, + to_heading: second.heading, + bisector_heading: bisector, + width_m: SIDEWALK_WIDTH_METERS, + seam_source: 'published-exterior-sidewalk', + provenance: 'native-road-complex-junction-sidewalk-corner/v1', + }, + geometry: { type: 'Polygon', coordinates: [sidewalkRing] }, + }; +} + +function applyCrossingDisplacements(arms, armEndpointOffsets, crosswalks, crossingRegions, stopLines) { + // Rebuild each shared arm crossing from its two endpoint displacement values. + // Interpolation occurs along its declared support axis, preserving every + // stripe's width and spacing while allowing the two neighbouring islands to + // move in different radial directions. + if (armEndpointOffsets.size) { + for (const arm of arms) { + const offsets = armEndpointOffsets.get(arm.key); + if (!offsets || !arm.crosswalkFrame?.endpoints) continue; + const [start, end] = arm.crosswalkFrame.endpoints; + const movedRing = (ring) => + ring.map((point) => { + const rawRatio = projectionRatio(point, start, end); + const contactRatio = arm.crosswalkFrame.contactEndpointRatio || 0; + const ratio = Math.max(0, Math.min(1, (rawRatio - contactRatio) / (1 - contactRatio * 2))); + const shift = [ + offsets[0][0] * (1 - ratio) + offsets[1][0] * ratio, + offsets[0][1] * (1 - ratio) + offsets[1][1] * ratio, + ]; + return [point[0] + shift[0], point[1] + shift[1]]; + }); + for (const crossing of crosswalks) { + if (crossing.properties.arm_key === arm.key) + crossing.geometry.coordinates[0] = movedRing(crossing.geometry.coordinates[0]); + } + // Preserve the original full crossing footprint and pave the swept + // connection to its new position, including the gaps between white bars. + const frame = arm.crosswalkFrame; + const corners = rectangle(frame.center, frame.heading, frame.groupDepth, frame.spanMeters); + const originalRegion = []; + // Split at the same endpoint clamps used by movedRing. A four-vertex + // rectangle would interpolate across those clamps and cut off the bars. + const contactRatio = frame.contactEndpointRatio || 0; + for (let edge = 0; edge < 4; edge++) { + const ratios = edge % 2 === 0 ? [0, contactRatio, 1 - contactRatio] : [0]; + for (const ratio of ratios) { + originalRegion.push(corners[edge].map((value, axis) => value + (corners[edge + 1][axis] - value) * ratio)); + } + } + originalRegion.push(originalRegion[0]); + const movedRegion = movedRing(originalRegion); + crossingRegions.push(movedRegion); + for (let edge = 0; edge < originalRegion.length - 1; edge++) { + crossingRegions.push([ + originalRegion[edge], + originalRegion[edge + 1], + movedRegion[edge + 1], + movedRegion[edge], + originalRegion[edge], + ]); + } + const averageShift = [(offsets[0][0] + offsets[1][0]) / 2, (offsets[0][1] + offsets[1][1]) / 2]; + for (const stopLine of stopLines) { + if (stopLine.properties.arm_key !== arm.key) continue; + stopLine.geometry.coordinates[0] = stopLine.geometry.coordinates[0].map((point) => [ + point[0] + averageShift[0], + point[1] + averageShift[1], + ]); + } + } + } +} + +module.exports = { + applyCrossingDisplacements, + buildApproachSurfacesAndStops, + buildArmCrossings, + buildCornerCompositions, + planArmCrossings, +}; diff --git a/src/compile/complex-junction-geometry.js b/src/compile/complex-junction-geometry.js new file mode 100644 index 0000000..13fad2a --- /dev/null +++ b/src/compile/complex-junction-geometry.js @@ -0,0 +1,262 @@ +'use strict'; + +const { stationAtDistanceFrom } = require('./junction-build-plan'); + +function normalizeHeading(value) { + return ((((value + 180) % 360) + 360) % 360) - 180; +} + +function armCarriesSidewalk(arm, model, cornerIsClockwise) { + return arm.members.some((member) => + member.approach.roadIds + .map((roadId) => model.roads.find((road) => road.id === roadId)) + .filter(Boolean) + .some((road) => { + const outwardIsForward = String(road.sourceNodeIds[0]) === String(member.nodeId); + const onClockwiseSide = outwardIsForward ? road.sidewalkRight : road.sidewalkLeft; + const onCounterClockwiseSide = outwardIsForward ? road.sidewalkLeft : road.sidewalkRight; + return Boolean(cornerIsClockwise ? onClockwiseSide : onCounterClockwiseSide); + }), + ); +} + +function exteriorSidewalkSeam(edge, graph, helpers) { + const section = graph.sections.find((item) => item.carriagewayKey === edge.carriagewayKey); + if ( + !section || + section.ringStatus !== 'supported' || + section.transitionStatus !== 'supported' || + section.exclusionStatus !== 'clear' + ) + return null; + const target = edge.side === 90 ? section.outer.right : section.outer.left; + for (const feature of helpers.exteriorSidewalks || []) { + const ids = String(feature.properties.directional_road_ids || '').split(','); + if (!edge.roadIds.some((id) => ids.includes(String(id)))) continue; + const ring = feature.geometry.coordinates[0]; + const half = (ring.length - 1) / 2; + for (const [curb, outer] of [ + [ring[0], ring[ring.length - 2]], + [ring[half - 1], ring[half]], + ]) { + if (helpers.distanceMeters(curb, target) <= 0.01) return { curb, outer }; + } + } + return null; +} + +function offsetPolylineAwayFromCenter(points, center, meters, helpers) { + return points.map((point, index) => { + const previous = points[Math.max(0, index - 1)]; + const next = points[Math.min(points.length - 1, index + 1)]; + const tangent = previous === next ? 0 : bearing(previous, next); + return [tangent + 90, tangent - 90] + .map((heading) => helpers.offsetCoordinate(point, heading, meters)) + .sort((first, second) => helpers.distanceMeters(second, center) - helpers.distanceMeters(first, center))[0]; + }); +} + +function ringSelfIntersects(ring) { + const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); + const straddles = (p1, p2, p3, p4) => { + const d1 = cross(p3, p4, p1); + const d2 = cross(p3, p4, p2); + const d3 = cross(p1, p2, p3); + const d4 = cross(p1, p2, p4); + return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0)); + }; + for (let first = 0; first < ring.length - 1; first += 1) { + for (let second = first + 2; second < ring.length - 1; second += 1) { + if (first === 0 && second === ring.length - 2) continue; + if (straddles(ring[first], ring[first + 1], ring[second], ring[second + 1])) return true; + } + } + return false; +} + +function angleAround(center, point) { + return Math.atan2(point[1] - center[1], point[0] - center[0]); +} + +function signedLateralMeters(origin, point, heading) { + const east = (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180); + const north = (point[1] - origin[1]) * 111320; + const radians = ((heading + 90) * Math.PI) / 180; + return east * Math.sin(radians) + north * Math.cos(radians); +} + +function bearing(first, second) { + const east = (second[0] - first[0]) * Math.cos((first[1] * Math.PI) / 180); + const north = second[1] - first[1]; + return (Math.atan2(east, north) * 180) / Math.PI; +} + +function midpoint(first, second) { + return [(first[0] + second[0]) / 2, (first[1] + second[1]) / 2]; +} + +function averageHeading(headings) { + const vector = headings.reduce( + (sum, heading) => { + const radians = (heading * Math.PI) / 180; + return [sum[0] + Math.sin(radians), sum[1] + Math.cos(radians)]; + }, + [0, 0], + ); + return (Math.atan2(vector[0], vector[1]) * 180) / Math.PI; +} + +function positiveHeadingDelta(first, second) { + return (((second - first) % 360) + 360) % 360; +} + +function pointOnCarriagewayRadius(item, center, radius, helpers) { + const station = stationAtDistanceFrom(item.approach.line, center, radius, helpers); + return helpers.pointAlongLine(item.approach.line, Math.max(0, Math.min(item.length, station))); +} + +function armEnvelopeAtRadius(arm, radius, center, helpers) { + if (!arm.members.length) return null; + const centers = arm.members.map((member) => pointOnCarriagewayRadius(member, center, radius, helpers)); + const reference = centers[0]; + let minimum = Infinity; + let maximum = -Infinity; + centers.forEach((point, index) => { + const lateral = signedLateralMeters(reference, point, arm.heading); + const halfWidth = arm.members[index].approach.widthMeters / 2; + minimum = Math.min(minimum, lateral - halfWidth); + maximum = Math.max(maximum, lateral + halfWidth); + }); + if (!Number.isFinite(minimum) || maximum - minimum < 1) return null; + return { + center: helpers.offsetCoordinate(reference, arm.heading + 90, (minimum + maximum) / 2), + widthMeters: maximum - minimum, + }; +} + +function crossingEvidenceForArm(model, arm, center, helpers) { + const osmWayIds = new Set( + arm.members.flatMap((member) => member.roads.flatMap((road) => (road.osmWayIds || []).map(String))), + ); + const maximumDistance = Math.max( + 8, + arm.members.reduce((width, member) => width + member.approach.widthMeters, 0) / 2 + 3, + ); + const crossings = (model.crossings || []) + .filter( + (crossing) => + (crossing.osmWayIds || []).some((wayId) => osmWayIds.has(String(wayId))) && + helpers.distanceMeters(crossing.coordinate, center) <= maximumDistance, + ) + .sort( + (first, second) => + helpers.distanceMeters(first.coordinate, center) - helpers.distanceMeters(second.coordinate, center) || + String(first.id).localeCompare(String(second.id)), + ); + const crossingNodeIds = crossings.map((crossing) => String(crossing.id)); + return { + kind: crossingNodeIds.length ? 'source-crossing-node' : 'unknown-no-crossing-source', + crossingNodeIds, + crossing: crossings[0] || null, + }; +} + +function cornerEdgeAt(arm, radius, bisector, center, helpers) { + const candidates = arm.members.flatMap((member) => { + const point = pointOnCarriagewayRadius(member, center, radius, helpers); + const halfWidth = member.approach.widthMeters / 2; + return [90, -90].map((side) => ({ + point: helpers.offsetCoordinate(point, member.heading + side, halfWidth), + heading: member.heading, + carriagewayKey: member.key, + roadIds: member.approach.roadIds, + side, + })); + }); + return ( + candidates.sort( + (first, second) => + directionalProjectionMeters(center, second.point, bisector) - + directionalProjectionMeters(center, first.point, bisector), + )[0] || null + ); +} + +function rayIntersection(first, second, origin) { + const lonScale = 111320 * Math.cos((origin[1] * Math.PI) / 180); + const toLocal = (point) => [(point[0] - origin[0]) * lonScale, (point[1] - origin[1]) * 111320]; + const direction = (heading) => { + const radians = (heading * Math.PI) / 180; + return [Math.sin(radians), Math.cos(radians)]; + }; + const firstPoint = toLocal(first.point); + const secondPoint = toLocal(second.point); + const firstDirection = direction(first.heading); + const secondDirection = direction(second.heading); + const denominator = firstDirection[0] * secondDirection[1] - firstDirection[1] * secondDirection[0]; + if (Math.abs(denominator) < 1e-4) return null; + const delta = [secondPoint[0] - firstPoint[0], secondPoint[1] - firstPoint[1]]; + const distanceAlongFirst = (delta[0] * secondDirection[1] - delta[1] * secondDirection[0]) / denominator; + const local = [ + firstPoint[0] + firstDirection[0] * distanceAlongFirst, + firstPoint[1] + firstDirection[1] * distanceAlongFirst, + ]; + if (!local.every(Number.isFinite)) return null; + return [origin[0] + local[0] / lonScale, origin[1] + local[1] / 111320]; +} + +function quadraticCurve(start, control, end, segments) { + const result = []; + for (let index = 0; index <= segments; index += 1) { + const t = index / segments; + const u = 1 - t; + result.push([ + u * u * start[0] + 2 * u * t * control[0] + t * t * end[0], + u * u * start[1] + 2 * u * t * control[1] + t * t * end[1], + ]); + } + return result; +} + +function directionalProjectionMeters(origin, point, heading) { + const east = (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180); + const north = (point[1] - origin[1]) * 111320; + const radians = (heading * Math.PI) / 180; + return east * Math.sin(radians) + north * Math.cos(radians); +} + +function polygonCenter(ring) { + const points = ring.slice(0, -1); + return points.reduce((sum, point) => [sum[0] + point[0] / points.length, sum[1] + point[1] / points.length], [0, 0]); +} + +function projectionRatio(point, start, end) { + const lonScale = 111320 * Math.cos((start[1] * Math.PI) / 180); + const vector = [(end[0] - start[0]) * lonScale, (end[1] - start[1]) * 111320]; + const relative = [(point[0] - start[0]) * lonScale, (point[1] - start[1]) * 111320]; + const lengthSquared = vector[0] * vector[0] + vector[1] * vector[1]; + if (lengthSquared < 1e-12) return 0; + return Math.max(0, Math.min(1, (relative[0] * vector[0] + relative[1] * vector[1]) / lengthSquared)); +} + +module.exports = { + angleAround, + armCarriesSidewalk, + armEnvelopeAtRadius, + bearing, + cornerEdgeAt, + crossingEvidenceForArm, + directionalProjectionMeters, + exteriorSidewalkSeam, + midpoint, + normalizeHeading, + offsetPolylineAwayFromCenter, + polygonCenter, + positiveHeadingDelta, + pointOnCarriagewayRadius, + projectionRatio, + quadraticCurve, + rayIntersection, + ringSelfIntersects, + signedLateralMeters, +}; diff --git a/src/compile/complex-junction-surfaces.js b/src/compile/complex-junction-surfaces.js new file mode 100644 index 0000000..ce1cc3a --- /dev/null +++ b/src/compile/complex-junction-surfaces.js @@ -0,0 +1,178 @@ +'use strict'; + +const { solveComplexPavementRegion } = require('./junction-pavement-region'); + +function buildCoreSurface({ cluster, helpers, center, nodeIds, arms, carriageways, shape, coreRadius, coreClosure }) { + const coreRing = coreClosure.status === 'supported' ? coreClosure.ring : null; + const cornerDiagnostics = []; + let coreFeature = null; + if (coreRing) + coreFeature = { + type: 'Feature', + properties: { + native_id: `complex-junction:${cluster.id}:core`, + cluster_id: cluster.id, + kind: 'complex-core', + complex_part: 'core', + center, + radius_m: coreRadius, + configured_radius_m: cluster.coreRadiusMeters, + approach_count: arms.length, + carriageway_count: carriageways.length, + shape_kind: shape.kind, + shape_label: shape.label, + arm_count: arms.length, + through_pair_count: shape.throughPairCount, + approach_headings: arms.map((arm) => Math.round(arm.representative.heading * 10) / 10), + boundary_refs: coreClosure.sharedEdgeRefs, + closure_count: coreClosure.closureCount, + shared_seam_error_m: coreClosure.maxSharedSeamErrorMeters, + shared_seam_errors: coreClosure.sharedSeamErrors, + connected_entry_count: coreClosure.connectedEntryCount, + required_pavement_connected: coreClosure.requiredPavementConnected, + core_ring_area: coreClosure.ringArea, + core_ring_self_intersects: coreClosure.ringSelfIntersects, + exclusion_hole_count: (coreClosure.holes || []).length, + region_status: coreClosure.holes?.length ? 'supported-with-holes' : 'supported', + provenance: 'native-road-complex-junction/v7-shared-entry-core', + }, + geometry: { type: 'Polygon', coordinates: [coreRing, ...(coreClosure.holes || [])] }, + }; + if (coreRing && coreClosure.maxSharedSeamErrorMeters > 0.01) { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `junction-cluster:${cluster.id}`, + [...nodeIds], + 'complex-junction-shared-seam-exceeds-tolerance', + `核心区域与入口断面的最大接缝误差为 ${coreClosure.maxSharedSeamErrorMeters.toFixed(3)} 米,超过 1 厘米验收阈值。`, + center, + ), + ); + } else if (!coreRing) { + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `junction-cluster:${cluster.id}`, + [...nodeIds], + 'complex-junction-core-closure-unsupported', + `路口中心区域缺少可验证的闭合边(${coreClosure.reason}),已保留各进口道路面。`, + center, + ), + ); + } + return { feature: coreFeature, diagnostics: cornerDiagnostics }; +} + +function buildApproachSurfaceFeatures(boundaryParts, model, cluster) { + const features = []; + for (const { item, section } of boundaryParts) { + const ring = section.ring; + features.push({ + type: 'Feature', + properties: { + native_id: `complex-junction:${cluster.id}:carriageway:${item.approach.segmentId}`, + cluster_id: cluster.id, + kind: 'complex-approach', + object_key: item.key, + carriageway_key: item.key, + arm_key: item.armKey, + complex_part: 'carriageway', + heading_deg: item.heading, + lane_count: item.approach.roadIds.reduce( + (sum, roadId) => sum + (model.roads.find((road) => road.id === roadId)?.laneCount || 0), + 0, + ), + width_m: item.approach.widthMeters, + outer_width_m: section.outerWidthMeters, + inner_width_m: section.innerWidthMeters, + transition_length_m: Math.round(section.transitionMeters * 10) / 10, + transition_status: section.transitionStatus, + ring_status: section.ringStatus, + exclusion_status: section.exclusionStatus, + ...(section.exclusionRegionId ? { exclusion_region_id: section.exclusionRegionId } : {}), + boundary_refs: section.edgeRefs, + provenance: 'native-road-complex-junction/v6-shared-transition-sections', + }, + geometry: { type: 'Polygon', coordinates: [ring] }, + }); + } + return features; +} + +function appendPavementRegion(features, crossingRegions, cluster, center, nodeIds, helpers) { + const cornerDiagnostics = []; + // Publish a single canonical pavement region last. The individual approach, + // core and corner polygons above remain structural inputs for editing and + // diagnostics; they are no longer the visible authority at the junction. + const basePavement = features.map((feature) => feature.geometry.coordinates[0]); + const pavementRegion = solveComplexPavementRegion(basePavement, crossingRegions); + if (pavementRegion.status === 'supported') { + for (const feature of features) feature.properties.pavement_input = true; + features.push({ + type: 'Feature', + properties: { + native_id: `complex-junction:${cluster.id}:pavement-region`, + cluster_id: cluster.id, + kind: 'complex-pavement-region', + complex_part: 'pavement-region', + center, + region_status: 'supported', + region_input_count: pavementRegion.inputCount, + crossing_connector_count: 0, + provenance: 'native-road-complex-junction-pavement-region/v1', + }, + geometry: { type: 'MultiPolygon', coordinates: pavementRegion.regions }, + }); + } else + cornerDiagnostics.push( + helpers.diagnostic( + 'warning', + `junction-cluster:${cluster.id}`, + [...nodeIds], + pavementRegion.status === 'unsupported' + ? 'complex-junction-pavement-region-assembly-failed' + : 'complex-junction-pavement-region-disconnected', + pavementRegion.status === 'unsupported' + ? '统一铺装区域无法可靠装配,保留结构输入面并拒绝发布统一铺装面。' + : '过街与入口无法组成连续铺装区域,保留结构输入面并拒绝发布统一铺装面。', + center, + ), + ); + return cornerDiagnostics; +} + +function assemblePavementSurfaces({ + model, + cluster, + helpers, + center, + nodeIds, + topology, + shape, + coreRadius, + coreClosure, + boundaryParts, + cornerFills, + crossingRegions, +}) { + const { feature: coreFeature, diagnostics } = buildCoreSurface({ + cluster, + helpers, + center, + nodeIds, + arms: topology.arms, + carriageways: topology.carriageways, + shape, + coreRadius, + coreClosure, + }); + const features = buildApproachSurfaceFeatures(boundaryParts, model, cluster); + // Preserve the structural surface order before publishing canonical pavement. + features.push(...cornerFills); + if (coreFeature) features.push(coreFeature); + diagnostics.push(...appendPavementRegion(features, crossingRegions, cluster, center, nodeIds, helpers)); + return { features, diagnostics }; +} + +module.exports = { assemblePavementSurfaces }; diff --git a/src/compile/complex-junction.js b/src/compile/complex-junction.js index 8f27636..08ab841 100644 --- a/src/compile/complex-junction.js +++ b/src/compile/complex-junction.js @@ -1,21 +1,21 @@ 'use strict'; const fs = require('fs'); -const { COMPLEX_CROSSWALK_DEPTH_METERS } = require('./junction-metrics'); const { structureFromTopology } = require('./junction-topology'); -const { resolveJunctionBuildPlan, stationAtDistanceFrom } = require('./junction-build-plan'); +const { resolveJunctionBuildPlan } = require('./junction-build-plan'); const { buildJunctionBoundaryGraph, buildCoreClosure, ringsOverlap } = require('./junction-boundary-graph'); -const { solveComplexPavementRegion, rectangle } = require('./junction-pavement-region'); -const { - buildIslandFromCrossingEdges, - orthogonalCrossingHeadings, - stripeLayout, - crossingArcSupport, - solveIslandContacts, -} = require('./junction-facility-composition'); +const { rectangle } = require('./junction-pavement-region'); +const { assemblePavementSurfaces } = require('./complex-junction-surfaces'); const { complexJunctionMetrics: calculateComplexJunctionMetrics } = require('./junction-metrics'); -const { radialShift } = require('./junction-island-offset'); const { convertGeoJson, boundsOf } = require('../reference/gaode'); +const { normalizeHeading, positiveHeadingDelta } = require('./complex-junction-geometry'); +const { + applyCrossingDisplacements, + buildApproachSurfacesAndStops, + buildArmCrossings, + buildCornerCompositions, + planArmCrossings, +} = require('./complex-junction-facilities'); const metricsCache = new WeakMap(); const CORNER_FILLET_SEGMENTS = 12; // Must match DEFAULT_SIDEWALK_WIDTH_METERS in native-road.js so the corner band @@ -64,7 +64,6 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { ], }; const { calibration, coreRadius } = complexJunctionMetrics(cluster); - const sorted = approaches; const shape = classifyJunctionShape(arms, center, helpers); if (shape.kind === 'unsupported') return { @@ -83,890 +82,128 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { center, }; const outerRadius = complexJunctionMetrics(cluster).approachOuterRadius; - const boundaryParts = []; - const transitionDiagnostics = []; - const crosswalks = []; - const crossingRegions = []; - const stopLines = []; - const islands = []; - // Each arm crossing is shared by two corner islands. Corner generation - // records its two endpoint displacements here; the stripes are rebuilt once - // after every corner has contributed, rather than being mutated per corner. - const armEndpointOffsets = new Map(); - const islandOffsetMeters = Number(helpers.clusterIslandOffsetMeters) || 0; const crossingControls = helpers.clusterCrossingControls || new Map(); - const crossingPlans = new Map( - arms.map((arm) => { - const inferredRadius = Math.max(1, coreRadius * 0.68); - const inferredEnvelope = armEnvelopeAtRadius(arm, inferredRadius, center, helpers); - const evidence = inferredEnvelope - ? crossingEvidenceForArm(model, arm, inferredEnvelope.center, helpers) - : { kind: 'unknown-no-crossing-source', crossingNodeIds: [], crossing: null }; - return [ - arm.key, - { - evidence, - baseRadius: evidence.crossing ? helpers.distanceMeters(center, evidence.crossing.coordinate) : inferredRadius, - }, - ]; - }), + const { crossingPlans, armCrosswalkRadiusFor } = planArmCrossings( + model, + arms, + center, + coreRadius, + crossingControls, + helpers, ); - const armCrosswalkRadiusFor = (arm) => - Math.max( - 1, - (crossingPlans.get(arm.key)?.baseRadius || coreRadius * 0.68) + - (crossingControls.get(`crossing:${arm.key}`)?.crosswalkInsetMeters || 0), - ); const boundaryGraph = helpers.boundaryGraph || buildComplexApproachBoundaryGraph(topology, center, cluster, helpers, model.exclusionRegions || []); - for (const section of boundaryGraph.sections) { - const item = carriageways.find((candidate) => candidate.key === section.carriagewayKey); - if (!item) continue; - // The approach plan owns the editable handoff distance. It shifts only this - // carriageway's outer transition, leaving neighboring arms untouched. A - // collapsed handoff is reported and omitted rather than publishing a - // zero-area trapezoid that downstream layers could mistake for pavement. - if (section.ringStatus !== 'supported') { - transitionDiagnostics.push( - helpers.diagnostic( - 'warning', - `carriageway:${item.key}`, - item.approach.roadIds.map(String), - 'complex-junction-entry-ring-invalid', - '该进口边界无法形成有效道路面,已省略退化或自交几何。', - section.inner.point, - ), - ); - continue; - } - if (section.exclusionStatus !== 'clear') { - transitionDiagnostics.push( - helpers.diagnostic( - 'warning', - `carriageway:${item.key}`, - item.approach.roadIds.map(String), - 'complex-junction-entry-overlaps-known-region', - '该进口过渡区域侵入已知排除区域,已省略该进口面以保留来源区域。', - section.inner.point, - ), - ); - continue; - } - if (section.transitionStatus !== 'supported') { - transitionDiagnostics.push( - helpers.diagnostic( - 'warning', - `carriageway:${item.key}`, - item.approach.roadIds.map(String), - 'complex-junction-entry-transition-unsupported', - '该进口在当前来源长度内无法形成外部断面到核心断面的连续过渡,已省略退化进口面。', - section.inner.point, - ), - ); - continue; - } - boundaryParts.push({ item, section }); - const outerHalf = item.approach.widthMeters / 2; - const incomingRoad = item.approach.roadIds - .map((roadId) => model.roads.find((road) => road.id === roadId)) - .find((road) => String(road?.sourceNodeIds.at(-1)) === String(item.nodeId)); - if (incomingRoad) { - // Offset is clear space beyond the relocated crossing outer edge; include - // half the stop bar thickness so the minimum offset cannot cut into it. - const arm = arms.find((candidate) => candidate.members.includes(item)); - const crossingKey = `crossing:${arm.key}`; - const crossingRadius = armCrosswalkRadiusFor(arm); - const stopOffset = crossingControls.get(crossingKey)?.stopLineOffsetMeters || 3; - const stopHeading = orthogonalCrossingHeadings(arms.map((candidate) => candidate.heading))[arms.indexOf(arm)]; - const envelope = armEnvelopeAtRadius(arm, crossingRadius, center, helpers); - const basePoint = pointOnCarriagewayRadius(item, center, crossingRadius, helpers); - const lateral = signedLateralMeters(envelope.center, basePoint, stopHeading); - const stopCenter = helpers.offsetCoordinate( - helpers.offsetCoordinate(envelope.center, stopHeading + 90, lateral), - stopHeading, - COMPLEX_CROSSWALK_DEPTH_METERS * 1.5 + 0.24 + stopOffset, - ); - const crossingEvidence = crossingPlans.get(arm.key)?.evidence || { - kind: 'unknown-no-crossing-source', - crossingNodeIds: [], - }; - const ring = [ - helpers.offsetCoordinate( - helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), - stopHeading, - -0.24, - ), - helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, outerHalf), stopHeading, -0.24), - helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, outerHalf), stopHeading, 0.24), - helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, 0.24), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), - stopHeading, - -0.24, - ), - ]; - stopLines.push({ - type: 'Feature', - properties: { - native_id: `complex-stop-line:${cluster.id}:${item.approach.segmentId}`, - object_key: `stop-line:${item.key}`, - crossing_key: crossingKey, - arm_key: item.armKey, - carriageway_key: item.key, - cluster_id: cluster.id, - kind: 'complex-stop-line', - road_id: incomingRoad.id, - node_id: item.nodeId, - direction: item.heading, - facility_evidence: crossingEvidence.kind, - ...(crossingEvidence.crossingNodeIds.length - ? { source_crossing_node_ids: crossingEvidence.crossingNodeIds } - : {}), - provenance: 'native-road-complex-junction-stop-line/v1', - }, - geometry: { type: 'Polygon', coordinates: [ring] }, - }); - } - } - // The four support lines provide a common corner frame, but each long - // crossing remains clipped to its OSM-derived road envelope. Corner islands - // fill the remaining frame gaps; crossings must never do that job. - const publishedCarriageways = new Set(boundaryParts.map(({ item }) => item.key)); - for (const arm of arms) { - if (!arm.members.every((item) => publishedCarriageways.has(item.key))) { - transitionDiagnostics.push( - helpers.diagnostic( - 'warning', - `crossing:${arm.key}`, - arm.members.flatMap((item) => item.approach.roadIds.map(String)), - 'complex-junction-crosswalk-pavement-unavailable', - '该过街缺少完整可发布的车行道过渡面,已省略标线,避免跨越无效进口。', - center, - ), - ); - continue; - } - const armCrosswalkRadius = armCrosswalkRadiusFor(arm); - arm.crosswalkRadius = armCrosswalkRadius; - const envelope = armEnvelopeAtRadius(arm, armCrosswalkRadius, center, helpers); - if (!envelope) continue; - const evidence = crossingPlans.get(arm.key)?.evidence || { - kind: 'unknown-no-crossing-source', - crossingNodeIds: [], - }; - if (evidence.kind !== 'source-crossing-node') { - transitionDiagnostics.push( - helpers.diagnostic( - 'info', - `crossing:${arm.key}`, - arm.members.flatMap((item) => item.approach.roadIds.map(String)), - 'complex-junction-crossing-source-missing', - '该进口未找到匹配的 OSM 过街节点,过街来源未知,按复杂路口默认生成斑马线。', - envelope.center, - ), - ); - } - arm.crosswalkFrame = { - center: envelope.center, - groupDepth: COMPLEX_CROSSWALK_DEPTH_METERS, - supportHeading: normalizeHeading(arm.heading + 90), - envelopeWidthMeters: envelope.widthMeters, - }; - arm.crosswalkEvidence = evidence; - } - const crossingHeadings = orthogonalCrossingHeadings(arms.map((arm) => arm.heading)); - arms.forEach((arm, index) => { - if (arm.crosswalkFrame) { - arm.crosswalkFrame.heading = crossingHeadings[index]; - arm.crosswalkFrame.supportHeading = normalizeHeading(crossingHeadings[index] + 90); - } + const { + boundaryParts, + stopLines, + diagnostics: transitionDiagnostics, + } = buildApproachSurfacesAndStops({ + model, + cluster, + helpers, + center, + arms, + carriageways, + boundaryGraph, + crossingControls, + crossingPlans, + armCrosswalkRadiusFor, }); - // Coordinate all four landing pairs before publishing stripes. Trim whole - // stripe pitches symmetrically so stripe size and spacing stay unchanged. - let crossingSpanTrim = 0; - if (arms.length === 4 && arms.every((arm) => arm.crosswalkFrame)) { - for (let attempt = 0; attempt < 12; attempt++) { - const trialTrim = attempt * 1.64; - const candidates = arms.map((arm) => { - const f = arm.crosswalkFrame; - const span = f.envelopeWidthMeters - 0.7 - trialTrim; - if (span < f.groupDepth) return null; - const shifted = helpers.offsetCoordinate(f.center, f.heading, f.groupDepth); - const layout = stripeLayout(span); - const half = span / 2 - (layout.centers[0] - layout.width / 2); - return [-1, 1].map((sign) => helpers.offsetCoordinate(shifted, f.heading + 90, sign * half)); - }); - if (candidates.some((candidate) => !candidate)) break; - const valid = arms.every((arm, i) => { - const j = (i + 1) % arms.length; - const pair = candidates[i] - .flatMap((a) => candidates[j].map((b) => ({ a, b, distance: helpers.distanceMeters(a, b) }))) - .sort((a, b) => a.distance - b.distance)[0]; - const origin = rayIntersection( - { point: pair.a, heading: arm.crosswalkFrame.heading }, - { point: pair.b, heading: arms[j].crosswalkFrame.heading }, - center, - ); - return ( - origin && - [ - [arm, pair.a], - [arms[j], pair.b], - ].every( - ([side, point]) => - directionalProjectionMeters(origin, point, side.crosswalkFrame.heading) > - side.crosswalkFrame.groupDepth / 2 + 0.2, - ) - ); - }); - if (valid) { - crossingSpanTrim = trialTrim; - break; - } - } - } - for (let index = 0; index < arms.length; index += 1) { - const arm = arms[index]; - if (!arm.crosswalkFrame) continue; - const item = arm.representative; - const crossingHeading = arm.crosswalkFrame.heading; - const roadEdgeInset = 0.35; - const usableSpan = Math.max(0.42, arm.crosswalkFrame.envelopeWidthMeters - roadEdgeInset * 2 - crossingSpanTrim); - const groupDepth = arm.crosswalkFrame.groupDepth; - arm.crosswalkFrame.center = helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading, groupDepth); - arm.crosswalkRadius += groupDepth; - const endpoints = [ - helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading + 90, -usableSpan / 2), - helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading + 90, usableSpan / 2), - ]; - const stripeWidth = 0.42; - const layout = stripeLayout(usableSpan); - const stripeCount = layout.centers.length; - const stripeSpacing = layout.pitch; - arm.crosswalkFrame.center = midpoint(...endpoints); - arm.crosswalkFrame.endpoints = endpoints; - arm.crosswalkFrame.spanMeters = usableSpan; - arm.crosswalkFrame.contactEndpointRatio = (layout.centers[0] - layout.width / 2) / usableSpan; - arm.crosswalkFrame.roadEdgeInsetMeters = roadEdgeInset; - crossingRegions.push(rectangle(arm.crosswalkFrame.center, crossingHeading, groupDepth, usableSpan)); - for (let stripe = 0; stripe < stripeCount; stripe += 1) { - const along = layout.centers[stripe]; - const centerPoint = helpers.offsetCoordinate(endpoints[0], bearing(...endpoints), along); - const ring = [ - helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), - crossingHeading + 90, - -stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), - crossingHeading + 90, - -stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), - crossingHeading + 90, - stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), - crossingHeading + 90, - stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), - crossingHeading + 90, - -stripeWidth / 2, - ), - ]; - crosswalks.push({ - type: 'Feature', - properties: { - native_id: `complex-crosswalk:${cluster.id}:${item.nodeId}:${item.approach.segmentId}:${stripe + 1}`, - object_key: `crossing:${arm.key}`, - crossing_key: `crossing:${arm.key}`, - arm_key: arm.key, - cluster_id: cluster.id, - kind: 'complex-crosswalk', - crossing_node_id: item.nodeId, - road_id: item.approach.roadIds[0], - direction: crossingHeading, - radial_distance_m: arm.crosswalkRadius, - span_m: usableSpan, - road_envelope_span_m: arm.crosswalkFrame.envelopeWidthMeters, - road_edge_inset_m: roadEdgeInset, - group_depth_m: groupDepth, - stripe_width_m: stripeWidth, - stripe_spacing_m: stripeSpacing, - frame_center: arm.crosswalkFrame.center, - frame_support_heading: arm.crosswalkFrame.supportHeading, - facility_evidence: arm.crosswalkEvidence.kind, - ...(arm.crosswalkEvidence.crossingNodeIds.length - ? { source_crossing_node_ids: arm.crosswalkEvidence.crossingNodeIds } - : {}), - provenance: 'native-road-complex-junction-crosswalk/v6-road-clipped', - }, - geometry: { type: 'Polygon', coordinates: [ring] }, - }); - } - } - // Corner islands and diagonal crossings need explicit island or pedestrian - // connection sources. Angle and road width alone do not establish either, - // so this compiler deliberately leaves them absent until that data exists. - // Each carriageway ends in its own rectangle, so adjacent arms meet at a - // sharp notch instead of a curb. A real corner is one tangent-continuous - // sweep between the two outermost road edges, so fit a fixed-radius fillet - // into the wedge those edges form and fill the sector behind it. + const publishedCarriageways = new Set(boundaryParts.map(({ item }) => item.key)); + const { + crosswalks, + crossingRegions, + diagnostics: crossingDiagnostics, + } = buildArmCrossings({ + arms, + center, + cluster, + helpers, + publishedCarriageways, + crossingPlans, + armCrosswalkRadiusFor, + }); + transitionDiagnostics.push(...crossingDiagnostics); const coreClosure = buildCoreClosure(topology, boundaryGraph, center); - const coreRing = coreClosure.status === 'supported' ? coreClosure.ring : null; - const cornerFills = []; - const sidewalkCorners = []; - const cornerDiagnostics = []; - const cornerOverlapsExclusion = (ring, cornerKey, part) => { - const region = boundaryGraph.exclusionRegions.find((region) => ringsOverlap(region.ring, ring)); - if (!region) return false; - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `corner:${cornerKey}`, - [String(region.id)], - 'complex-junction-corner-exclusion-overlap', - `该角部${part}侵入已知排除区域 ${region.id},已省略,避免覆盖已知不可通行空间。`, - center, - ), - ); - return true; - }; - const omittedCornerFacilityCount = arms.filter((arm, index) => { - const next = arms[(index + 1) % arms.length]; - const delta = positiveHeadingDelta(arm.heading, next.heading); - return delta >= 45 && delta <= 135; - }).length; - if (omittedCornerFacilityCount) - cornerDiagnostics.push( - helpers.diagnostic( - 'info', - `junction-cluster:${cluster.id}`, - [...nodeIds], - 'complex-junction-corner-facilities-omitted', - `已省略 ${omittedCornerFacilityCount} 组缺少岛体或步行连接来源的角部导流岛和斑马线。`, - center, - ), - ); - const defaultCornerRadius = Math.max(4, Math.min(25, Number(cluster.cornerRadiusMeters) || 12)); - for (let index = 0; index < arms.length; index += 1) { - const first = arms[index]; - const second = arms[(index + 1) % arms.length]; - if (!publishedCarriageways.size) continue; - const cornerRadius = helpers.clusterCornerRadii?.get(first.cornerKey) ?? defaultCornerRadius; - const delta = positiveHeadingDelta(first.heading, second.heading); - if (delta < 45 || delta > 135) continue; - const bisector = normalizeHeading(first.heading + delta / 2); - const edges = [first, second].map((arm) => cornerEdgeAt(arm, coreRadius + 6, bisector, center, helpers)); - if (!edges.every(Boolean)) continue; - const apex = rayIntersection(edges[0], edges[1], center); - const apexReach = apex ? directionalProjectionMeters(center, apex, bisector) : null; - // The wedge apex has to sit ahead of the core and inside the arm handoff; - // outside that band the two edges are near parallel and any fillet fitted - // to them would sweep across the carriageways instead of the corner. - if (apexReach === null || apexReach < 1 || apexReach > outerRadius) { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `junction-cluster:${cluster.id}`, - [...nodeIds], - 'complex-junction-corner-fillet-fallback', - '该夹角的道路边缘切线无法安全构造圆角,已保留直角过渡。', - center, - ), - ); - continue; - } - // Tangent distance for a circle of `cornerRadius` inscribed in a wedge of - // opening `delta`. - // Keep the radius control continuous. The previous handoff cap made a - // sizeable part of the advertised 1..25 m range geometry-inert: once the - // tangent distance hit the cap, pressing Enter only changed metadata. - // The solver's radius bounds and the generated arm envelope provide the - // validity boundary; this value must remain the direct geometric response. - const tangentDistance = cornerRadius / Math.tan((delta * Math.PI) / 360); - const tangents = edges.map((edge) => helpers.offsetCoordinate(apex, edge.heading, tangentDistance)); - const curve = quadraticCurve(tangents[0], apex, tangents[1], CORNER_FILLET_SEGMENTS); - const ring = [...curve, center, curve[0]]; - if (!ring.every((point) => point.every(Number.isFinite))) continue; - if (cornerOverlapsExclusion(ring, first.cornerKey, '道路补面')) continue; - cornerFills.push({ - type: 'Feature', - properties: { - native_id: `complex-corner-fillet:${cluster.id}:${index + 1}`, - cluster_id: cluster.id, - kind: 'complex-corner-fillet', - object_key: first.cornerKey, - corner_key: first.cornerKey, - complex_part: 'corner-fillet', - corner_index: index + 1, - from_heading: first.heading, - to_heading: second.heading, - bisector_heading: bisector, - corner_radius_m: cornerRadius, - tangent_distance_m: Math.round(tangentDistance * 100) / 100, - apex_reach_m: Math.round(apexReach * 100) / 100, - provenance: 'native-road-complex-junction-corner-fillet/v1', - }, - geometry: { type: 'Polygon', coordinates: [ring] }, - }); - if (!first.crosswalkFrame?.endpoints || !second.crosswalkFrame?.endpoints) continue; - const endpointPairs = first.crosswalkFrame.endpoints.flatMap((a, firstEndpointIndex) => - second.crosswalkFrame.endpoints.map((b, secondEndpointIndex) => ({ - a, - b, - firstEndpointIndex, - secondEndpointIndex, - distance: helpers.distanceMeters(a, b), - })), - ); - const pair = endpointPairs.sort((a, b) => a.distance - b.distance)[0]; - const crossingCorner = rayIntersection( - { point: pair.a, heading: first.crosswalkFrame.heading }, - { point: pair.b, heading: second.crosswalkFrame.heading }, - center, - ); - if (!crossingCorner) continue; - const stripeWidth = 0.42; - const outerFirst = helpers.offsetCoordinate( - crossingCorner, - first.crosswalkFrame.heading, - first.crosswalkFrame.groupDepth, - ); - const outerSecond = helpers.offsetCoordinate( - crossingCorner, - second.crosswalkFrame.heading, - second.crosswalkFrame.groupDepth, - ); - const lonScale = 111320 * Math.cos((crossingCorner[1] * Math.PI) / 180); - const toLocal = (point) => [(point[0] - crossingCorner[0]) * lonScale, (point[1] - crossingCorner[1]) * 111320]; - const fromLocal = (point) => [crossingCorner[0] + point[0] / lonScale, crossingCorner[1] + point[1] / 111320]; - const landing = (arm, endpoint) => { - const frame = arm.crosswalkFrame; - const layout = stripeLayout(frame.spanMeters); - const margin = layout.centers[0] - layout.width / 2; - const edgeCenter = helpers.offsetCoordinate(endpoint, bearing(endpoint, frame.center), margin); - return [-1, 1].map((sign) => - toLocal(helpers.offsetCoordinate(edgeCenter, frame.heading, (sign * frame.groupDepth) / 2)), - ); - }; - let contactSolution = solveIslandContacts( - landing(first, pair.a), - landing(second, pair.b), - COMPLEX_CROSSWALK_DEPTH_METERS, - { maxLegLength: outerRadius }, - ); - if (contactSolution.status !== 'solved') { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `corner:${first.cornerKey}`, - [...nodeIds], - 'complex-junction-island-infeasible', - contactSolution.reason, - crossingCorner, - ), - ); - continue; - } - // Dragging moves the whole pedestrian composition away from the cluster - // centre. Re-solve from the translated landing segments so the island, - // its green contact hexagon and all three complete contacts retain the same - // source coordinates instead of merely translating a detached island. - let islandShift = [0, 0]; - if (islandOffsetMeters > 0) { - const provisionalRing = contactSolution.ring.map(fromLocal); - const provisionalCenter = polygonCenter(provisionalRing); - islandShift = radialShift(center, provisionalCenter, islandOffsetMeters); - const localShift = toLocal([crossingCorner[0] + islandShift[0], crossingCorner[1] + islandShift[1]]); - const translateSegment = (segment) => - segment.map((point) => [point[0] + localShift[0], point[1] + localShift[1]]); - const shifted = solveIslandContacts( - translateSegment(landing(first, pair.a)), - translateSegment(landing(second, pair.b)), - COMPLEX_CROSSWALK_DEPTH_METERS, - { maxLegLength: outerRadius }, - ); - if (shifted.status !== 'solved') { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `corner:${first.cornerKey}`, - [...nodeIds], - 'complex-junction-island-offset-infeasible', - shifted.reason, - crossingCorner, - ), - ); - continue; - } - contactSolution = shifted; - const rememberOffset = (arm, endpointIndex) => { - const offsets = armEndpointOffsets.get(arm.key) || [ - [0, 0], - [0, 0], - ]; - offsets[endpointIndex] = islandShift; - armEndpointOffsets.set(arm.key, offsets); - }; - rememberOffset(first, pair.firstEndpointIndex); - rememberOffset(second, pair.secondEndpointIndex); - } - const publishedIslandRing = contactSolution.ring.map(fromLocal); - const greenRing = contactSolution.greenRing.map(fromLocal); - if (!cornerOverlapsExclusion(publishedIslandRing, first.cornerKey, '安全岛')) - islands.push({ - type: 'Feature', - properties: { - native_id: `complex-corner-island:${cluster.id}:${index + 1}`, - object_key: `island:inferred/${first.cornerKey}`, - cluster_id: cluster.id, - kind: 'island', - corner_key: first.cornerKey, - facility_evidence: 'inferred-complex-junction-corner', - provenance: 'native-road-complex-junction-inferred-island/v1', - island_leg_lengths_m: contactSolution.legLengths, - contact_points: greenRing.slice(0, -1), - }, - geometry: { type: 'Polygon', coordinates: [publishedIslandRing] }, - }); - if (!cornerOverlapsExclusion(greenRing, first.cornerKey, '安全岛绿色接触区')) - islands.push({ - type: 'Feature', - properties: { - native_id: `complex-corner-island-green:${cluster.id}:${index + 1}`, - object_key: `island:inferred/${first.cornerKey}`, - cluster_id: cluster.id, - corner_key: first.cornerKey, - kind: 'island-green', - island_key: `island:inferred/${first.cornerKey}`, - provenance: 'native-road-complex-junction-island-contact-hexagon/v1', - }, - geometry: { type: 'Polygon', coordinates: [greenRing] }, - }); + const { + cornerFills, + sidewalkCorners, + islands, + crosswalks: cornerCrosswalks, + armEndpointOffsets, + diagnostics: cornerDiagnostics, + } = buildCornerCompositions({ + model, + cluster, + helpers, + center, + nodeIds, + arms, + boundaryGraph, + publishedCarriageways, + coreRadius, + outerRadius, + }); + crosswalks.push(...cornerCrosswalks); + applyCrossingDisplacements(arms, armEndpointOffsets, crosswalks, crossingRegions, stopLines); + const { features, diagnostics: pavementDiagnostics } = assemblePavementSurfaces({ + model, + cluster, + helpers, + center, + nodeIds, + topology, + shape, + coreRadius, + coreClosure, + boundaryParts, + cornerFills, + crossingRegions, + }); + cornerDiagnostics.push(...pavementDiagnostics); + return publishComplexJunction({ + model, + cluster, + helpers, + center, + nodeIds, + topology, + shape, + approaches, + calibration, + coreRadius, + outerRadius, + features, + islands, + sidewalkCorners, + crosswalks, + stopLines, + transitionDiagnostics, + cornerDiagnostics, + }); +} - if ( - !first.members.every((item) => publishedCarriageways.has(item.key)) || - !second.members.every((item) => publishedCarriageways.has(item.key)) - ) - continue; - // Complex junctions carry a default diagonal crossing across each safe - // corner. Source crossing nodes refine provenance/inset values, but are - // not required for the default visual treatment. - const outerMidpoint = fromLocal(contactSolution.thirdCenter); - const diagonalDepth = COMPLEX_CROSSWALK_DEPTH_METERS; - const outwardHeading = (Math.atan2(contactSolution.outward[0], contactSolution.outward[1]) * 180) / Math.PI; - const diagonalHeading = outwardHeading; - const diagonalCenter = helpers.offsetCoordinate(outerMidpoint, outwardHeading, diagonalDepth / 2); - const diagonalSpan = COMPLEX_CROSSWALK_DEPTH_METERS; - const layout = stripeLayout(diagonalDepth); - const stripeCount = layout.centers.length; - const stripeSpacing = layout.pitch; - for (let stripe = 0; stripe < stripeCount; stripe += 1) { - const along = -diagonalDepth / 2 + layout.centers[stripe] - (layout.centers[0] - stripeWidth / 2); - const stripeCenter = helpers.offsetCoordinate(diagonalCenter, diagonalHeading, along); - const ring = [ - helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), - diagonalHeading, - -stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), - diagonalHeading, - -stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), - diagonalHeading, - stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), - diagonalHeading, - stripeWidth / 2, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), - diagonalHeading, - -stripeWidth / 2, - ), - ]; - crosswalks.push({ - type: 'Feature', - properties: { - native_id: `complex-corner-crosswalk:${cluster.id}:${index + 1}:${stripe + 1}`, - object_key: `crossing:corner:${first.cornerKey}`, - crossing_key: `crossing:corner:${first.cornerKey}`, - island_key: `island:inferred/${first.cornerKey}`, - from_boundary: `sidewalk:${first.cornerKey}:from`, - to_boundary: `island:inferred/${first.cornerKey}`, - cluster_id: cluster.id, - kind: 'complex-corner-crosswalk', - stripe_width_m: stripeWidth, - stripe_spacing_m: stripeSpacing, - group_depth_m: COMPLEX_CROSSWALK_DEPTH_METERS, - corner_key: first.cornerKey, - facility_evidence: 'default-complex-junction', - provenance: 'native-road-complex-junction-corner-crosswalk/v1', - }, - geometry: { type: 'Polygon', coordinates: [ring] }, - }); - } - - // The straight pedestrian strips are trimmed at the cluster boundary, so - // two arms that both carry a footway still meet as two loose ends across - // an empty wedge. Bridge them along the curb the fillet already defines. - // The corner faces clockwise from `first` and counter-clockwise from - // `second`, so each arm must carry the footway on that facing side. - if (!armCarriesSidewalk(first, model, true) || !armCarriesSidewalk(second, model, false)) continue; - const seams = edges.map((edge) => exteriorSidewalkSeam(edge, boundaryGraph, helpers)); - if (!seams.every(Boolean)) { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `corner:${first.cornerKey}`, - edges.flatMap((edge) => edge.roadIds), - 'complex-junction-sidewalk-seam-unavailable', - '该角部缺少两侧可验证的人行道接缝,已省略连接,避免生成悬空步行带。', - center, - ), - ); - continue; - } - const curb = [seams[0].curb, ...curve, seams[1].curb]; - const outerEdge = offsetPolylineAwayFromCenter(curb, center, SIDEWALK_WIDTH_METERS, helpers); - outerEdge[0] = seams[0].outer; - outerEdge[outerEdge.length - 1] = seams[1].outer; - const sidewalkRing = [...curb, ...outerEdge.slice().reverse(), curb[0]]; - if (!sidewalkRing.every((point) => point.every(Number.isFinite)) || ringSelfIntersects(sidewalkRing)) { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `junction-cluster:${cluster.id}`, - [...nodeIds], - 'complex-junction-sidewalk-corner-fallback', - '该夹角的人行道转角几何自交或无效,已跳过,两侧步行带保持断开。', - center, - ), - ); - continue; - } - if (cornerOverlapsExclusion(sidewalkRing, first.cornerKey, '人行道')) continue; - sidewalkCorners.push({ - type: 'Feature', - properties: { - native_id: `complex-sidewalk-corner:${cluster.id}:${index + 1}`, - cluster_id: cluster.id, - kind: 'complex-sidewalk-corner', - object_key: `sidewalk-turn:${first.cornerKey}`, - corner_key: first.cornerKey, - corner_index: index + 1, - from_heading: first.heading, - to_heading: second.heading, - bisector_heading: bisector, - width_m: SIDEWALK_WIDTH_METERS, - seam_source: 'published-exterior-sidewalk', - provenance: 'native-road-complex-junction-sidewalk-corner/v1', - }, - geometry: { type: 'Polygon', coordinates: [sidewalkRing] }, - }); - } - // Rebuild each shared arm crossing from its two endpoint displacement values. - // Interpolation occurs along its declared support axis, preserving every - // stripe's width and spacing while allowing the two neighbouring islands to - // move in different radial directions. - if (armEndpointOffsets.size) { - for (const arm of arms) { - const offsets = armEndpointOffsets.get(arm.key); - if (!offsets || !arm.crosswalkFrame?.endpoints) continue; - const [start, end] = arm.crosswalkFrame.endpoints; - const movedRing = (ring) => - ring.map((point) => { - const rawRatio = projectionRatio(point, start, end); - const contactRatio = arm.crosswalkFrame.contactEndpointRatio || 0; - const ratio = Math.max(0, Math.min(1, (rawRatio - contactRatio) / (1 - contactRatio * 2))); - const shift = [ - offsets[0][0] * (1 - ratio) + offsets[1][0] * ratio, - offsets[0][1] * (1 - ratio) + offsets[1][1] * ratio, - ]; - return [point[0] + shift[0], point[1] + shift[1]]; - }); - for (const crossing of crosswalks) { - if (crossing.properties.arm_key === arm.key) - crossing.geometry.coordinates[0] = movedRing(crossing.geometry.coordinates[0]); - } - // Preserve the original full crossing footprint and pave the swept - // connection to its new position, including the gaps between white bars. - const frame = arm.crosswalkFrame; - const corners = rectangle(frame.center, frame.heading, frame.groupDepth, frame.spanMeters); - const originalRegion = []; - // Split at the same endpoint clamps used by movedRing. A four-vertex - // rectangle would interpolate across those clamps and cut off the bars. - const contactRatio = frame.contactEndpointRatio || 0; - for (let edge = 0; edge < 4; edge++) { - const ratios = edge % 2 === 0 ? [0, contactRatio, 1 - contactRatio] : [0]; - for (const ratio of ratios) { - originalRegion.push(corners[edge].map((value, axis) => value + (corners[edge + 1][axis] - value) * ratio)); - } - } - originalRegion.push(originalRegion[0]); - const movedRegion = movedRing(originalRegion); - crossingRegions.push(movedRegion); - for (let edge = 0; edge < originalRegion.length - 1; edge++) { - crossingRegions.push([ - originalRegion[edge], - originalRegion[edge + 1], - movedRegion[edge + 1], - movedRegion[edge], - originalRegion[edge], - ]); - } - const averageShift = [(offsets[0][0] + offsets[1][0]) / 2, (offsets[0][1] + offsets[1][1]) / 2]; - for (const stopLine of stopLines) { - if (stopLine.properties.arm_key !== arm.key) continue; - stopLine.geometry.coordinates[0] = stopLine.geometry.coordinates[0].map((point) => [ - point[0] + averageShift[0], - point[1] + averageShift[1], - ]); - } - } - } - const features = []; - let coreFeature = null; - if (coreRing) - coreFeature = { - type: 'Feature', - properties: { - native_id: `complex-junction:${cluster.id}:core`, - cluster_id: cluster.id, - kind: 'complex-core', - complex_part: 'core', - center, - radius_m: coreRadius, - configured_radius_m: cluster.coreRadiusMeters, - approach_count: approaches.length, - carriageway_count: carriageways.length, - shape_kind: shape.kind, - shape_label: shape.label, - arm_count: arms.length, - through_pair_count: shape.throughPairCount, - approach_headings: sorted.map((item) => Math.round(item.heading * 10) / 10), - boundary_refs: coreClosure.sharedEdgeRefs, - closure_count: coreClosure.closureCount, - shared_seam_error_m: coreClosure.maxSharedSeamErrorMeters, - shared_seam_errors: coreClosure.sharedSeamErrors, - connected_entry_count: coreClosure.connectedEntryCount, - required_pavement_connected: coreClosure.requiredPavementConnected, - core_ring_area: coreClosure.ringArea, - core_ring_self_intersects: coreClosure.ringSelfIntersects, - exclusion_hole_count: (coreClosure.holes || []).length, - region_status: coreClosure.holes?.length ? 'supported-with-holes' : 'supported', - provenance: 'native-road-complex-junction/v7-shared-entry-core', - }, - geometry: { type: 'Polygon', coordinates: [coreRing, ...(coreClosure.holes || [])] }, - }; - if (coreRing && coreClosure.maxSharedSeamErrorMeters > 0.01) { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `junction-cluster:${cluster.id}`, - [...nodeIds], - 'complex-junction-shared-seam-exceeds-tolerance', - `核心区域与入口断面的最大接缝误差为 ${coreClosure.maxSharedSeamErrorMeters.toFixed(3)} 米,超过 1 厘米验收阈值。`, - center, - ), - ); - } else if (!coreRing) { - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `junction-cluster:${cluster.id}`, - [...nodeIds], - 'complex-junction-core-closure-unsupported', - `路口中心区域缺少可验证的闭合边(${coreClosure.reason}),已保留各进口道路面。`, - center, - ), - ); - } - for (const { item, section } of boundaryParts) { - const ring = section.ring; - features.push({ - type: 'Feature', - properties: { - native_id: `complex-junction:${cluster.id}:carriageway:${item.approach.segmentId}`, - cluster_id: cluster.id, - kind: 'complex-approach', - object_key: item.key, - carriageway_key: item.key, - arm_key: item.armKey, - complex_part: 'carriageway', - heading_deg: item.heading, - lane_count: item.approach.roadIds.reduce( - (sum, roadId) => sum + (model.roads.find((road) => road.id === roadId)?.laneCount || 0), - 0, - ), - width_m: item.approach.widthMeters, - outer_width_m: section.outerWidthMeters, - inner_width_m: section.innerWidthMeters, - transition_length_m: Math.round(section.transitionMeters * 10) / 10, - transition_status: section.transitionStatus, - ring_status: section.ringStatus, - exclusion_status: section.exclusionStatus, - ...(section.exclusionRegionId ? { exclusion_region_id: section.exclusionRegionId } : {}), - boundary_refs: section.edgeRefs, - provenance: 'native-road-complex-junction/v6-shared-transition-sections', - }, - geometry: { type: 'Polygon', coordinates: [ring] }, - }); - } - // Corner fills come last so they overlay the rectangular carriageway ends - // they are smoothing; they never replace an OSM-derived road surface. - features.push(...cornerFills); - if (coreFeature) features.push(coreFeature); - // Publish a single canonical pavement region last. The individual approach, - // core and corner polygons above remain structural inputs for editing and - // diagnostics; they are no longer the visible authority at the junction. - const basePavement = features.map((feature) => feature.geometry.coordinates[0]); - const pavementRegion = solveComplexPavementRegion(basePavement, crossingRegions); - if (pavementRegion.status === 'supported') { - for (const feature of features) feature.properties.pavement_input = true; - features.push({ - type: 'Feature', - properties: { - native_id: `complex-junction:${cluster.id}:pavement-region`, - cluster_id: cluster.id, - kind: 'complex-pavement-region', - complex_part: 'pavement-region', - center, - region_status: 'supported', - region_input_count: pavementRegion.inputCount, - crossing_connector_count: 0, - provenance: 'native-road-complex-junction-pavement-region/v1', - }, - geometry: { type: 'MultiPolygon', coordinates: pavementRegion.regions }, - }); - } else - cornerDiagnostics.push( - helpers.diagnostic( - 'warning', - `junction-cluster:${cluster.id}`, - [...nodeIds], - pavementRegion.status === 'unsupported' - ? 'complex-junction-pavement-region-assembly-failed' - : 'complex-junction-pavement-region-disconnected', - pavementRegion.status === 'unsupported' - ? '统一铺装区域无法可靠装配,保留结构输入面并拒绝发布统一铺装面。' - : '过街与入口无法组成连续铺装区域,保留结构输入面并拒绝发布统一铺装面。', - center, - ), - ); +function publishComplexJunction({ + model, + cluster, + helpers, + center, + nodeIds, + topology, + shape, + approaches, + calibration, + coreRadius, + outerRadius, + features, + islands, + sidewalkCorners, + crosswalks, + stopLines, + transitionDiagnostics, + cornerDiagnostics, +}) { // `coreRadiusMeters` is only consulted when there is no reference geometry. // Under calibration the radius comes from the reference span, so a configured // value that silently does nothing has to be reported, not swallowed. @@ -1122,239 +359,6 @@ function complexJunctionMetrics(cluster) { return metrics; } -function normalizeHeading(value) { - return ((((value + 180) % 360) + 360) % 360) - 180; -} - -// `arm.heading` points outward from the junction, so the corner clockwise from -// it sits at heading+90 and the one counter-clockwise at heading-90. A road's -// own sidewalk flags are relative to its digitisation direction, so flip them -// whenever the arm runs against that direction. -function armCarriesSidewalk(arm, model, cornerIsClockwise) { - return arm.members.some((member) => - member.approach.roadIds - .map((roadId) => model.roads.find((road) => road.id === roadId)) - .filter(Boolean) - .some((road) => { - const outwardIsForward = String(road.sourceNodeIds[0]) === String(member.nodeId); - const onClockwiseSide = outwardIsForward ? road.sidewalkRight : road.sidewalkLeft; - const onCounterClockwiseSide = outwardIsForward ? road.sidewalkLeft : road.sidewalkRight; - return Boolean(cornerIsClockwise ? onClockwiseSide : onCounterClockwiseSide); - }), - ); -} - -// Use the emitted strip's complete end edge, including its actual width and -// orientation. A radius extension cannot guarantee this seam on curved roads. -function exteriorSidewalkSeam(edge, graph, helpers) { - const section = graph.sections.find((item) => item.carriagewayKey === edge.carriagewayKey); - if ( - !section || - section.ringStatus !== 'supported' || - section.transitionStatus !== 'supported' || - section.exclusionStatus !== 'clear' - ) - return null; - const target = edge.side === 90 ? section.outer.right : section.outer.left; - for (const feature of helpers.exteriorSidewalks || []) { - const ids = String(feature.properties.directional_road_ids || '').split(','); - if (!edge.roadIds.some((id) => ids.includes(String(id)))) continue; - const ring = feature.geometry.coordinates[0]; - const half = (ring.length - 1) / 2; - for (const [curb, outer] of [ - [ring[0], ring[ring.length - 2]], - [ring[half - 1], ring[half]], - ]) { - if (helpers.distanceMeters(curb, target) <= 0.01) return { curb, outer }; - } - } - return null; -} - -// Offset each vertex along the polyline normal that increases distance from the -// junction centre. The curb is star-shaped around that centre, so "farther from -// the centre" is a reliable stand-in for "on the pedestrian side". -function offsetPolylineAwayFromCenter(points, center, meters, helpers) { - return points.map((point, index) => { - const previous = points[Math.max(0, index - 1)]; - const next = points[Math.min(points.length - 1, index + 1)]; - const tangent = previous === next ? 0 : bearing(previous, next); - return [tangent + 90, tangent - 90] - .map((heading) => helpers.offsetCoordinate(point, heading, meters)) - .sort((first, second) => helpers.distanceMeters(second, center) - helpers.distanceMeters(first, center))[0]; - }); -} - -function ringSelfIntersects(ring) { - const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); - const straddles = (p1, p2, p3, p4) => { - const d1 = cross(p3, p4, p1); - const d2 = cross(p3, p4, p2); - const d3 = cross(p1, p2, p3); - const d4 = cross(p1, p2, p4); - return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0)); - }; - for (let first = 0; first < ring.length - 1; first += 1) { - for (let second = first + 2; second < ring.length - 1; second += 1) { - if (first === 0 && second === ring.length - 2) continue; - if (straddles(ring[first], ring[first + 1], ring[second], ring[second + 1])) return true; - } - } - return false; -} - -function angleAround(center, point) { - return Math.atan2(point[1] - center[1], point[0] - center[0]); -} -function signedLateralMeters(origin, point, heading) { - const east = (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180); - const north = (point[1] - origin[1]) * 111320; - const radians = ((heading + 90) * Math.PI) / 180; - return east * Math.sin(radians) + north * Math.cos(radians); -} -function bearing(first, second) { - const east = (second[0] - first[0]) * Math.cos((first[1] * Math.PI) / 180); - const north = second[1] - first[1]; - return (Math.atan2(east, north) * 180) / Math.PI; -} -function midpoint(first, second) { - return [(first[0] + second[0]) / 2, (first[1] + second[1]) / 2]; -} -function averageHeading(headings) { - const vector = headings.reduce( - (sum, heading) => { - const radians = (heading * Math.PI) / 180; - return [sum[0] + Math.sin(radians), sum[1] + Math.cos(radians)]; - }, - [0, 0], - ); - return (Math.atan2(vector[0], vector[1]) * 180) / Math.PI; -} -function positiveHeadingDelta(first, second) { - return (((second - first) % 360) + 360) % 360; -} -function pointOnCarriagewayRadius(item, center, radius, helpers) { - const station = stationAtDistanceFrom(item.approach.line, center, radius, helpers); - return helpers.pointAlongLine(item.approach.line, Math.max(0, Math.min(item.length, station))); -} -function armEnvelopeAtRadius(arm, radius, center, helpers) { - if (!arm.members.length) return null; - const centers = arm.members.map((member) => pointOnCarriagewayRadius(member, center, radius, helpers)); - const reference = centers[0]; - let minimum = Infinity; - let maximum = -Infinity; - centers.forEach((point, index) => { - const lateral = signedLateralMeters(reference, point, arm.heading); - const halfWidth = arm.members[index].approach.widthMeters / 2; - minimum = Math.min(minimum, lateral - halfWidth); - maximum = Math.max(maximum, lateral + halfWidth); - }); - if (!Number.isFinite(minimum) || maximum - minimum < 1) return null; - return { - center: helpers.offsetCoordinate(reference, arm.heading + 90, (minimum + maximum) / 2), - widthMeters: maximum - minimum, - }; -} -function crossingEvidenceForArm(model, arm, center, helpers) { - const osmWayIds = new Set( - arm.members.flatMap((member) => member.roads.flatMap((road) => (road.osmWayIds || []).map(String))), - ); - const maximumDistance = Math.max( - 8, - arm.members.reduce((width, member) => width + member.approach.widthMeters, 0) / 2 + 3, - ); - const crossings = (model.crossings || []) - .filter( - (crossing) => - (crossing.osmWayIds || []).some((wayId) => osmWayIds.has(String(wayId))) && - helpers.distanceMeters(crossing.coordinate, center) <= maximumDistance, - ) - .sort( - (first, second) => - helpers.distanceMeters(first.coordinate, center) - helpers.distanceMeters(second.coordinate, center) || - String(first.id).localeCompare(String(second.id)), - ); - const crossingNodeIds = crossings.map((crossing) => String(crossing.id)); - return { - kind: crossingNodeIds.length ? 'source-crossing-node' : 'unknown-no-crossing-source', - crossingNodeIds, - crossing: crossings[0] || null, - }; -} -function cornerEdgeAt(arm, radius, bisector, center, helpers) { - const candidates = arm.members.flatMap((member) => { - const point = pointOnCarriagewayRadius(member, center, radius, helpers); - const halfWidth = member.approach.widthMeters / 2; - return [90, -90].map((side) => ({ - point: helpers.offsetCoordinate(point, member.heading + side, halfWidth), - heading: member.heading, - carriagewayKey: member.key, - roadIds: member.approach.roadIds, - side, - })); - }); - return ( - candidates.sort( - (first, second) => - directionalProjectionMeters(center, second.point, bisector) - - directionalProjectionMeters(center, first.point, bisector), - )[0] || null - ); -} -function rayIntersection(first, second, origin) { - const lonScale = 111320 * Math.cos((origin[1] * Math.PI) / 180); - const toLocal = (point) => [(point[0] - origin[0]) * lonScale, (point[1] - origin[1]) * 111320]; - const direction = (heading) => { - const radians = (heading * Math.PI) / 180; - return [Math.sin(radians), Math.cos(radians)]; - }; - const firstPoint = toLocal(first.point); - const secondPoint = toLocal(second.point); - const firstDirection = direction(first.heading); - const secondDirection = direction(second.heading); - const denominator = firstDirection[0] * secondDirection[1] - firstDirection[1] * secondDirection[0]; - if (Math.abs(denominator) < 1e-4) return null; - const delta = [secondPoint[0] - firstPoint[0], secondPoint[1] - firstPoint[1]]; - const distanceAlongFirst = (delta[0] * secondDirection[1] - delta[1] * secondDirection[0]) / denominator; - const local = [ - firstPoint[0] + firstDirection[0] * distanceAlongFirst, - firstPoint[1] + firstDirection[1] * distanceAlongFirst, - ]; - if (!local.every(Number.isFinite)) return null; - return [origin[0] + local[0] / lonScale, origin[1] + local[1] / 111320]; -} -function quadraticCurve(start, control, end, segments) { - const result = []; - for (let index = 0; index <= segments; index += 1) { - const t = index / segments; - const u = 1 - t; - result.push([ - u * u * start[0] + 2 * u * t * control[0] + t * t * end[0], - u * u * start[1] + 2 * u * t * control[1] + t * t * end[1], - ]); - } - return result; -} -function directionalProjectionMeters(origin, point, heading) { - const east = (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180); - const north = (point[1] - origin[1]) * 111320; - const radians = (heading * Math.PI) / 180; - return east * Math.sin(radians) + north * Math.cos(radians); -} - -function polygonCenter(ring) { - const points = ring.slice(0, -1); - return points.reduce((sum, point) => [sum[0] + point[0] / points.length, sum[1] + point[1] / points.length], [0, 0]); -} - -function projectionRatio(point, start, end) { - const lonScale = 111320 * Math.cos((start[1] * Math.PI) / 180); - const vector = [(end[0] - start[0]) * lonScale, (end[1] - start[1]) * 111320]; - const relative = [(point[0] - start[0]) * lonScale, (point[1] - start[1]) * 111320]; - const lengthSquared = vector[0] * vector[0] + vector[1] * vector[1]; - if (lengthSquared < 1e-12) return 0; - return Math.max(0, Math.min(1, (relative[0] * vector[0] + relative[1] * vector[1]) / lengthSquared)); -} module.exports = { resolveComplexJunctionTopology, buildComplexJunctionGeometry,