diff --git a/.trellis/spec/backend/index.md b/.trellis/spec/backend/index.md index 703246c..c40cb21 100644 --- a/.trellis/spec/backend/index.md +++ b/.trellis/spec/backend/index.md @@ -4,3 +4,5 @@ - [Road Revision Storage](./road-revision-storage.md) -- immutable workbench revision layout, validation, and recovery contract. - [Direct Edit Solver And API](./direct-edit-api.md) -- pure constraint solving, preview/save endpoints, version protection, and rebase behavior. + +- [Junction Island Contact](./junction-island-contact.md) -- confirmed target contract for full crossing-edge contact, dynamic island legs and the six-point green region (implementation pending). diff --git a/.trellis/spec/backend/junction-island-contact.md b/.trellis/spec/backend/junction-island-contact.md new file mode 100644 index 0000000..a78003b --- /dev/null +++ b/.trellis/spec/backend/junction-island-contact.md @@ -0,0 +1,56 @@ +# Junction island contact + +## Status and scope + +Confirmed user requirement, 2026-09-11; implementation pending. Applies to the +complex-junction composition with two adjacent arm crossings and one crossing +beside the inward-curved hypotenuse. This is not a universal traffic-island +definition. Simple junction behavior is unchanged. + +## Geometry contract + +- A contact is the complete short edge of a crossing rectangle, not an arbitrary + white stripe, a point, or only the portion that happens to intersect the island. +- Each of the three crossings contributes one contact segment and two endpoints. + All three complete segments must be shared with the island outer boundary. +- Contact positions are geometry-dependent. The two perpendicular leg lengths + are solved from the contacts and available space; twice crossing depth is not + a hard constraint. +- Preserve six distinct contact endpoints in boundary order. Connecting them + forms the green hexagon on the island. Its three contact edges coincide with + the crossing contacts; its other three edges connect adjacent contacts. + The green region and rounded island outer boundary are distinct geometries. +- Rounded corners and inward curves occupy non-contact boundary portions. + A straight contact edge must remain straight over its full length, including + the hypotenuse-side landing. Rounding must not trim away contact endpoints. +- Solve in local metric coordinates and reuse coordinates across consumers. + Preserve consistent stripe dimensions and spacing, avoid positive-area + crossing/island intersection, and maintain stop-line separation. +- If the available space cannot satisfy the composition, report the object and + failed constraint. Do not shorten a crossing, detach it, or report the partial + composition as valid. + +## Required validation + +For each complete contact segment S and published island boundary B, measure +the length of S covered by B, not polygon intersection area alone. Require +uncovered length and endpoint-to-boundary distance <= 0.01 m; this tolerance +is numerical, not a design gap. Also check interior samples to catch an arc +touching only at the endpoints. + +The six green vertices must equal the six contact endpoints within metric +tolerance, with each used once; the ring must be simple, have positive area, +lie inside the outer island, and retain all three full contact edges. An +independently fitted polygon or a hull dropping vertices fails this contract. + +Required cases: orthogonal base case; unequal contact offsets and crossing +depths; translated/rotated equivalents; changed available space; roundovers +that would cut into contacts; and an infeasible composition. On the current +real OSM, verify all contacts and all six vertices for every published island, +not just feature counts or a hand-picked corner. Retain image evidence showing +the outer boundary, green hexagon, complete crossing rectangles and stop lines. + +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. diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/design.md b/.trellis/tasks/09-08-junction-reference-fidelity/design.md index 2ed3d6a..e23774a 100644 --- a/.trellis/tasks/09-08-junction-reference-fidelity/design.md +++ b/.trellis/tasks/09-08-junction-reference-fidelity/design.md @@ -38,7 +38,7 @@ junction-structure/v1 保持前端投影,按需扩展展示字段;不在客 ## 设施语义契约 -复杂路口中的行人安全岛不是独立的固定角部多边形。它是三组过街连接之间的不可通行区域:一条进口斑马线和相邻两个角部斑马线共同限定其边界。`CrosswalkConnection` 必须连接两个有效步行边界;其内侧端点吸附到 `PedestrianIsland` 或路缘边界,不能悬空或穿过岛体。 +复杂路口中的行人安全岛不是独立的固定角部多边形。它是三组过街连接之间的不可通行区域:两条相邻道路臂斑马线和一条长边侧斑马线共同限定其边界。`CrosswalkConnection` 必须连接两个有效步行边界;其内侧端点吸附到 `PedestrianIsland` 或路缘边界,不能悬空或穿过岛体。 - `PedestrianIsland`:独立的不可通行区域,有连续路缘边界,可作为分阶段过街等待空间。 - `CrosswalkConnection`:连接人行道、路缘或安全岛的过街区域;斑马线不是道路装饰层。 @@ -53,3 +53,14 @@ junction-structure/v1 保持前端投影,按需扩展展示字段;不在客 - 不为性能让浏览器复制几何算法。记录相同输入的冷/热预览耗时与 payload;300 ms 是既有预算提示,不是无需实测的完成承诺。pending 从排队到最新结果完成持续有效。 - 局部米制计算与 GeoJSON 经纬度输出分离;方向绕回、曲线进口、短路段、多区域、来源不完整均为失败风险。 - 回滚按管线/能力关闭;保留新文档的可读性和不支持诊断,禁止旧管线忽略新约束却显示成功。 + + +## 2026-09-11 完整短边接触求解(待实现) + +执行契约见 `.trellis/spec/backend/junction-island-contact.md`。最新用户要求覆盖旧的独立岛体加端点吸附方案。 + +求解应先从整组过街矩形取得两条道路臂侧完整短边,并在局部米制坐标中求其支撑线;直角骨架来自这些短边而非道路边缘。以短边端点与可用区域约束求动态腿长和第三条接触短边的位置。三个接触段确定后,外轮廓的非接触部分才生成圆角/内弧;绿色六边形只使用六个接触端点,并按外边界顺序闭合。外轮廓与绿色区域共用接触段,不各自取近似坐标。 + +完整直线短边不可能整段贴在严格弯曲的曲线上:长边侧应提供与短边等长的直线接入段,内弧在该段两侧延续。圆角不得切入三个接触段。不能通过加描边或扩大渲染宽度掩盖几何缝隙。 + +实现边界:设施组成模块负责局部求解与验证,复杂路口生成器消费同一结果发布外轮廓、绿色区域与过街;如移动可编辑过街位置,resolver 手柄同步消费同一几何定位。不得为当前 OSM 节点 ID 单独适配。无可行解时给出对象级原因,不发布假装接通的部分组合;不得悄悄缩短斑马线短边来通过验证。 diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/implement.md b/.trellis/tasks/09-08-junction-reference-fidelity/implement.md index e34219e..e539a9f 100644 --- a/.trellis/tasks/09-08-junction-reference-fidelity/implement.md +++ b/.trellis/tasks/09-08-junction-reference-fidelity/implement.md @@ -122,3 +122,39 @@ complex-junction.js / native-road.js:构建与全部消费者;direct-edit-so 此处采用明确省略冲突对象,尚未实现绕排除区域重新求解、孔洞或多区域连通;不能据此关闭 A3/A6。下一步需建立区域级共享边界与连通性验证,再推进剩余接入位姿/左右边界编辑,最后做真实数据视觉验收。 本轮验证:npm test、客户端类型检查、188 项客户端单元测试、11 项 E2E(含生产构建)、format:check 与 git diff --check 全部通过。构建保留既有 bundle 大小提示。 + +## 斑马线短边构造修正(未提交) + +用户手绘明确:两条相邻斑马线向各自路口外侧退一个完整矩形短边长度;安全岛两条直角边来自斑马线短边延长线,不来自道路圆角切线。短边延长一倍,连接端点并向直角顶点弯曲,第三组条纹平行于连接弦。 + +已修复此前无效退让:旧代码移动 frame.center 后又用原 endpoints 覆盖,实际条带未移动。现在先移动中心再生成端点;手柄同步。岛体使用最近端点处的两条短边延长线交点及两倍 groupDepth;岛体弧线纯函数覆盖手绘象限、边界相接无面积重叠、旋转平移回归。 + +当前用户 OSM 编译实测:4 个岛体,跨组斑马线重叠面积 0 m²,岛体与条带总交集约 0.00004524 m²。纯几何图为 references/crossing-short-edge-composition.png(编译坐标直接绘制,仅含目标复杂路口道路面/岛体/斑马线)。中央铺装仍存在空洞,整体任务未完成。此次未提交,不能将上述局部通过记作 A3/A8 全部通过。 + +## 用户暂存后的白条规格与正交框架调整 + +本轮保留用户 index 暂存内容,新变更只在工作区。所有复杂斑马线白条长度 3.4m、宽度 0.42m、净间隔 0.4m;端部余量居中分配,不再通过缩放间隔填满跨度。四臂且每臂与拟合正交方向偏差不超过 15°时,斑马线方向共用正交框架;其他结构保留来源方向。岛体继续引用斑马线短边,手柄使用同一退让方向。 + +当前用户 OSM 实测:4 岛,142 白条;跨组过街重叠面积 0m²,岛体与过街交集面积 0m²。references/orthogonal-crossing-composition.png 是编译几何简图,不是浏览器整图验收。中心铺装空洞仍未解决。 + +## 弧边贴合、三个圆角、停止线避让 + +第三组第一条白条按其实际宽度范围内的岛体曲线支撑位置放置,去掉首条居中余量,避免以弦代替弧造成间隙。岛体三个顶点使用曲线过渡,保留直边和中部内弯弧。停止线与手柄加入斑马线已发生的完整退让量。 + +当前 OSM 测量:停止线/斑马线面积交集 0;跨组斑马线面积交集 0;岛/斑马线约 1e-13 m²(浮点误差)。新增圆角、有限条宽弧边支撑、停止线与对应斑马线无交集回归。references/rounded-corner-detail.png 为局部编译几何图,黄色仅用于标示停止线;正式渲染颜色未改变。未提交、未改用户暂存内容。 + +### 本轮局部复核补充 + +复核修正一处遗漏:过街手柄虽然已计算四臂拟合方向,实际固定退让仍用了原道路臂方向;现使用同一 fitted heading。纯设施测试、direct-edit-solver、format:check、客户端类型检查通过。 + +停止线默认值 3m 在当前图上无交集,但不能据此宣称完整可编辑范围无重叠:将当前真实路口各 stopLineOffsetMeters 设为已允许的 0.5m,实际编译产生 47 对停止线/对应白条交集。需统一停止线退距的边界语义/可行域与手柄,再增加下界回归;复核未擅自更改文档参数语义。 + +上述下界问题已由主会话同步修正为距过街外缘的净退距,并包含停止线半厚度;复核重跑同一真实 OSM、相同 0.5m 参数,交集对数从 47 降为 0。此为当前真实样本验证,非任意斜交结构全范围保证。 + +停止线补充:按拟合斑马线方向放置,从退让后的斑马线外缘计净距,并计入停止线半厚 0.24m;编辑手柄同步。新增 0.5m 下界与对应过街无交集回归。当前真实 OSM 全部停止线/过街交集为 0。旧五臂 fixture 在最小退距时与非对应过街仍有少量交集,跨臂极端编辑避让尚未完成,不能外推为任意拓扑无冲突。 +预览 API 单独重跑通过;之前 degraded 断言失败源于其 300ms 时间预算,不能将其解释为几何功能失败。全量 fixture 基线仍与用户更新后的 OSM 不一致,未刷新基线。此次未暂存、未提交。 + + +## 2026-09-11 基线提交与新增完整接触规则 + +用户要求先提交当前视觉基线,已执行。随后补充的五条规则已写入 PRD、design 与 backend/junction-island-contact.md。此次补充为待实现契约,不声称已有代码满足完整短边接触或绿色六边形。下一实现单元:三段完整接触的共享求解 + 六点绿色区域 + 动态腿长,一起验证后交付;不得拆成独立挪动第三条斑马线、独立画绿色六边形的中间态。 diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/prd.md b/.trellis/tasks/09-08-junction-reference-fidelity/prd.md index 285da30..a7ca2c1 100644 --- a/.trellis/tasks/09-08-junction-reference-fidelity/prd.md +++ b/.trellis/tasks/09-08-junction-reference-fidelity/prd.md @@ -54,3 +54,18 @@ A3 的 1 cm 是内部拼接精度,不代表影像测绘精度。视觉相似 ## 待验证技术问题 这些问题由实施阶段证据解决,不要求用户猜实现:现有 polygon 运算是否足以完成区域验证;车道线/步行带全部裁切调用是否统一;现有 OSM 数据能支持哪些歧义归组纠正;校正与旧半径/收口约束的兼容边界。若答案导致缩减上述支持范围,须修订规划后再实施该缩减。 + + +## 2026-09-11 用户补充:三组过街完整接触与绿色六边形 + +本节为最新用户验收要求,优先于此前固定岛体、固定两倍直角边及仅端点吸附的描述。状态:规则已确认,尚待实现;当前已提交的视觉基线不能视为满足以下全部条件。 + +1. 每个此类三角安全岛的三条关联斑马线均必须与岛体接触,不允许其中一条脱离岛体。 +2. 三条接触短边在各自岛边上的位置按现场几何确定,不固定在边中点或三角顶点。 +3. 接触必须覆盖斑马线矩形的完整短边;点接触、部分短边接触、跨圆角悬空均不合格。这里的短边是整组过街矩形的短边,不是任意一根白条的边。 +4. 三条短边各贡献两个真实端点,六个不同接触点沿岛体边界排列,连接形成岛上的绿色六边形。禁止独立拟合装饰六边形、取包围盒或以凸包删掉某些接触点。 +5. 安全岛两条直角边长度可随接触位置、过街宽度及可用空间动态调整;原先“两倍短边长度”仅为旧基线,不再作为固定长度约束。 + +仍保留:复杂路口默认过街、简单路口保持现状;三组白条规格一致;停止线与过街不重叠;岛体非接触部分保留圆角与内弯轮廓。绿色六边形与岛体外轮廓属于不同几何对象。 + +新增验收 A9:三条完整短边均与岛边共享线段;六点一一对应形成非退化绿色六边形;改变接触位置或过街宽度后同步重算岛边与绿色区域,不产生悬空、面积重叠或被圆角裁掉的接触段。不得只用岛数、条纹数和面积无交集来宣称 A9 通过。 diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/crossing-short-edge-composition.png b/.trellis/tasks/09-08-junction-reference-fidelity/references/crossing-short-edge-composition.png new file mode 100644 index 0000000..c9a2367 Binary files /dev/null and b/.trellis/tasks/09-08-junction-reference-fidelity/references/crossing-short-edge-composition.png differ diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/crossing-short-edge-composition.svg b/.trellis/tasks/09-08-junction-reference-fidelity/references/crossing-short-edge-composition.svg new file mode 100644 index 0000000..f29d2bb --- /dev/null +++ b/.trellis/tasks/09-08-junction-reference-fidelity/references/crossing-short-edge-composition.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/orthogonal-crossing-composition.png b/.trellis/tasks/09-08-junction-reference-fidelity/references/orthogonal-crossing-composition.png new file mode 100644 index 0000000..6d3f170 Binary files /dev/null and b/.trellis/tasks/09-08-junction-reference-fidelity/references/orthogonal-crossing-composition.png differ diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/orthogonal-crossing-composition.svg b/.trellis/tasks/09-08-junction-reference-fidelity/references/orthogonal-crossing-composition.svg new file mode 100644 index 0000000..656a9b1 --- /dev/null +++ b/.trellis/tasks/09-08-junction-reference-fidelity/references/orthogonal-crossing-composition.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-corner-detail.png b/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-corner-detail.png new file mode 100644 index 0000000..f346ba3 Binary files /dev/null and b/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-corner-detail.png differ diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-crossing-composition.png b/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-crossing-composition.png new file mode 100644 index 0000000..8cb108b Binary files /dev/null and b/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-crossing-composition.png differ diff --git a/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-crossing-composition.svg b/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-crossing-composition.svg new file mode 100644 index 0000000..f351db3 --- /dev/null +++ b/.trellis/tasks/09-08-junction-reference-fidelity/references/rounded-crossing-composition.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/compile/complex-junction.js b/src/compile/complex-junction.js index 158270d..51ebf16 100644 --- a/src/compile/complex-junction.js +++ b/src/compile/complex-junction.js @@ -1,10 +1,16 @@ '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 { buildJunctionBoundaryGraph, buildCoreClosure, ringsOverlap } = require('./junction-boundary-graph'); -const { solveCornerFeasibleRegion } = require('./junction-region-solver'); +const { + buildIslandFromCrossingEdges, + orthogonalCrossingHeadings, + stripeLayout, + crossingArcSupport, +} = require('./junction-facility-composition'); const { complexJunctionMetrics: calculateComplexJunctionMetrics } = require('./junction-metrics'); const { convertGeoJson, boundsOf } = require('../reference/gaode'); const metricsCache = new WeakMap(); @@ -157,41 +163,37 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { .map((roadId) => model.roads.find((road) => road.id === roadId)) .find((road) => String(road?.sourceNodeIds.at(-1)) === String(item.nodeId)); if (incomingRoad) { - // Keep the stop bar just outside the road crosswalk. The previous fixed - // core-radius offset placed it nearly ten metres beyond the crossing. + // 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 stopCenter = pointOnCarriagewayRadius(item, center, crossingRadius + stopOffset, helpers); + 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, item.heading + 90, -outerHalf), - item.heading, + 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, item.heading + 90, outerHalf), - item.heading, - -0.24, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stopCenter, item.heading + 90, outerHalf), - item.heading, - 0.24, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stopCenter, item.heading + 90, -outerHalf), - item.heading, - 0.24, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(stopCenter, item.heading + 90, -outerHalf), - item.heading, + helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), + stopHeading, -0.24, ), ]; @@ -258,57 +260,68 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { } arm.crosswalkFrame = { center: envelope.center, - groupDepth: 3.4, + 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); + } + }); 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); - const endpoints = [ - helpers.offsetCoordinate(arm.crosswalkFrame.center, arm.heading + 90, -usableSpan / 2), - helpers.offsetCoordinate(arm.crosswalkFrame.center, arm.heading + 90, usableSpan / 2), - ]; 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 stripeCount = Math.max(6, Math.floor((usableSpan - stripeWidth) / 0.82) + 1); - const stripeSpacing = stripeCount > 1 ? (usableSpan - stripeWidth) / (stripeCount - 1) : 0; + 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.roadEdgeInsetMeters = roadEdgeInset; for (let stripe = 0; stripe < stripeCount; stripe += 1) { - const along = stripeWidth / 2 + stripe * stripeSpacing; + const along = layout.centers[stripe]; const centerPoint = helpers.offsetCoordinate(endpoints[0], bearing(...endpoints), along); const ring = [ helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, arm.heading, -groupDepth / 2), - arm.heading + 90, + helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), + crossingHeading + 90, -stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, arm.heading, groupDepth / 2), - arm.heading + 90, + helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), + crossingHeading + 90, -stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, arm.heading, groupDepth / 2), - arm.heading + 90, + helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), + crossingHeading + 90, stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, arm.heading, -groupDepth / 2), - arm.heading + 90, + helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), + crossingHeading + 90, stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(centerPoint, arm.heading, -groupDepth / 2), - arm.heading + 90, + helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), + crossingHeading + 90, -stripeWidth / 2, ), ]; @@ -323,7 +336,7 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { kind: 'complex-crosswalk', crossing_node_id: item.nodeId, road_id: item.approach.roadIds[0], - direction: arm.heading, + direction: crossingHeading, radial_distance_m: arm.crosswalkRadius, span_m: usableSpan, road_envelope_span_m: arm.crosswalkFrame.envelopeWidthMeters, @@ -448,27 +461,29 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { }, geometry: { type: 'Polygon', coordinates: [ring] }, }); - const islandDepth = Math.min(7, Math.max(3, apexReach * 0.35)); - const islandHalfWidth = Math.min( - 2.2, - Math.max(1.2, Math.min(first.widthMeters || 4, second.widthMeters || 4) * 0.28), + if (!first.crosswalkFrame?.endpoints || !second.crosswalkFrame?.endpoints) continue; + const endpointPairs = first.crosswalkFrame.endpoints.flatMap((a) => + second.crosswalkFrame.endpoints.map((b) => ({ a, b, distance: helpers.distanceMeters(a, b) })), ); - const islandCenter = helpers.offsetCoordinate(apex, bisector, -islandDepth * 0.5); - const islandRing = [ - helpers.offsetCoordinate(helpers.offsetCoordinate(apex, bisector, 0.6), bisector + 90, -islandHalfWidth), - helpers.offsetCoordinate( - helpers.offsetCoordinate(islandCenter, bisector, islandDepth * 0.5), - bisector + 90, - -islandHalfWidth * 0.72, - ), - helpers.offsetCoordinate( - helpers.offsetCoordinate(islandCenter, bisector, islandDepth * 0.5), - bisector + 90, - islandHalfWidth * 0.72, - ), - helpers.offsetCoordinate(helpers.offsetCoordinate(apex, bisector, 0.6), bisector + 90, islandHalfWidth), - helpers.offsetCoordinate(helpers.offsetCoordinate(apex, bisector, 0.6), bisector + 90, -islandHalfWidth), - ]; + 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 * 2, + ); + const outerSecond = helpers.offsetCoordinate( + crossingCorner, + second.crosswalkFrame.heading, + second.crosswalkFrame.groupDepth * 2, + ); + const islandRing = buildIslandFromCrossingEdges(crossingCorner, outerFirst, outerSecond); const publishedIslandRing = islandRing; if (!cornerOverlapsExclusion(publishedIslandRing, first.cornerKey, '安全岛')) islands.push({ @@ -493,48 +508,51 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { // 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 islandMidpoint = publishedIslandRing - .slice(0, -1) - .reduce( - (sum, point) => [ - sum[0] + point[0] / (publishedIslandRing.length - 1), - sum[1] + point[1] / (publishedIslandRing.length - 1), - ], - [0, 0], - ); - const diagonalCenter = helpers.offsetCoordinate(islandMidpoint, bisector, islandHalfWidth + 1.2); - const diagonalSpan = Math.min(6, Math.max(2.4, helpers.distanceMeters(tangents[0], tangents[1]) * 0.35)); - const diagonalDepth = 2.4; - const stripeCount = 7; - const stripeWidth = 0.32; - const stripeSpacing = diagonalDepth / stripeCount; + const outerMidpoint = [(outerFirst[0] + outerSecond[0]) / 2, (outerFirst[1] + outerSecond[1]) / 2]; + const diagonalDepth = COMPLEX_CROSSWALK_DEPTH_METERS; + const diagonalHeading = bearing(outerFirst, outerSecond) - 90; + const outwardHeading = bearing(crossingCorner, outerMidpoint); + const theta = (outwardHeading * Math.PI) / 180; + const lonScale = 111320 * Math.cos((outerMidpoint[1] * Math.PI) / 180); + const projectedIsland = publishedIslandRing.map((p) => { + const east = (p[0] - outerMidpoint[0]) * lonScale; + const north = (p[1] - outerMidpoint[1]) * 111320; + return [east * Math.cos(theta) - north * Math.sin(theta), east * Math.sin(theta) + north * Math.cos(theta)]; + }); + const support = crossingArcSupport(projectedIsland, COMPLEX_CROSSWALK_DEPTH_METERS / 2); + if (support === null) continue; + const diagonalCenter = helpers.offsetCoordinate(outerMidpoint, outwardHeading, support + 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 + (stripe + 0.5) * stripeSpacing; - const stripeCenter = helpers.offsetCoordinate(diagonalCenter, bisector, along); + 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, bisector + 90, -diagonalSpan / 2), - bisector, + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), + diagonalHeading, -stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, bisector + 90, diagonalSpan / 2), - bisector, + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), + diagonalHeading, -stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, bisector + 90, diagonalSpan / 2), - bisector, + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), + diagonalHeading, stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, bisector + 90, -diagonalSpan / 2), - bisector, + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), + diagonalHeading, stripeWidth / 2, ), helpers.offsetCoordinate( - helpers.offsetCoordinate(stripeCenter, bisector + 90, -diagonalSpan / 2), - bisector, + helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), + diagonalHeading, -stripeWidth / 2, ), ]; @@ -549,6 +567,9 @@ function buildComplexJunctionGeometry(model, cluster, helpers) { 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', diff --git a/src/compile/direct-edit-solver.js b/src/compile/direct-edit-solver.js index 2db1f0a..46e8fc5 100644 --- a/src/compile/direct-edit-solver.js +++ b/src/compile/direct-edit-solver.js @@ -1,5 +1,9 @@ 'use strict'; +const { orthogonalCrossingHeadings } = require('./junction-facility-composition'); + +const { COMPLEX_CROSSWALK_DEPTH_METERS } = require('./junction-metrics'); + const { diagnostic } = require('./diagnostics'); const { approachForCrossing, arrivalEndpointIds, effectiveCrosswalkInsetMax } = require('./crossing-approach'); const { haversineMeters, metersAt, polylineLength } = require('../geometry/lane-geometry'); @@ -1798,7 +1802,9 @@ function makeClusterCrossingHandles(model, junctionData, constraints, clusters) if (cluster.template !== 'complex-junction-v1') continue; const clusterId = String(cluster.id); const center = clusterCenter(model, cluster); - for (const arm of clusterArms(clusterId, itemsByCluster.get(clusterId) || [])) { + const crossingArms = clusterArms(clusterId, itemsByCluster.get(clusterId) || []); + const crossingHeadings = orthogonalCrossingHeadings(crossingArms.map((arm) => arm.heading)); + for (const [armIndex, arm] of crossingArms.entries()) { const item = arm.representative; const line = clusterApproachLine(item); const length = polylineLength(line); @@ -1831,7 +1837,11 @@ function makeClusterCrossingHandles(model, junctionData, constraints, clusters) handleId: `handle:cluster-crossing-inset:${crossingKey}`, kind: 'cluster-crossing-inset', anchor, - position: pointAt(baseCrosswalkDistance + inset), + position: offsetCoordinate( + pointAt(baseCrosswalkDistance + inset), + crossingHeadings[armIndex], + COMPLEX_CROSSWALK_DEPTH_METERS, + ), axisAzimuth: arm.heading, value: { current: inset, min: 0, max: MAX_CROSSWALK_INSET_METERS, unit: 'meter' }, ...(insetConstraint ? { constraintId: insetConstraint.id } : {}), @@ -1844,7 +1854,11 @@ function makeClusterCrossingHandles(model, junctionData, constraints, clusters) handleId: `handle:cluster-stop-line-offset:${crossingKey}`, kind: 'cluster-stop-line-offset', anchor, - position: pointAt(baseCrosswalkDistance + (Number.isFinite(sourceCrossingDistance) ? inset : 0) + offset), + position: offsetCoordinate( + pointAt(baseCrosswalkDistance + (Number.isFinite(sourceCrossingDistance) ? inset : 0)), + crossingHeadings[armIndex], + COMPLEX_CROSSWALK_DEPTH_METERS * 1.5 + 0.24 + offset, + ), axisAzimuth: arm.heading, value: { current: offset, min: MIN_STOP_LINE_OFFSET_METERS, max: 12, unit: 'meter' }, ...(stopConstraint ? { constraintId: stopConstraint.id } : {}), diff --git a/src/compile/junction-facility-composition.js b/src/compile/junction-facility-composition.js index 3d61a00..aa99862 100644 --- a/src/compile/junction-facility-composition.js +++ b/src/compile/junction-facility-composition.js @@ -17,4 +17,90 @@ function validateFacilityComposition(island, crossings) { return { valid: true, reason: null }; } -module.exports = { buildPedestrianIsland, validateFacilityComposition }; +// The two legs are extensions of crossing short edges, in the same coordinate frame. +function buildIslandFromCrossingEdges(corner, firstEnd, secondEnd, segments = 12) { + const control = corner.map((value, axis) => (value + (firstEnd[axis] + secondEnd[axis]) / 2) / 2); + const mix = (a, b, t) => a.map((v, axis) => v * (1 - t) + b[axis] * t); + const evaluate = (t) => + corner.map((_, axis) => (1 - t) ** 2 * firstEnd[axis] + 2 * t * (1 - t) * control[axis] + t * t * secondEnd[axis]); + const derivative = (t) => + corner.map((_, axis) => 2 * (1 - t) * (control[axis] - firstEnd[axis]) + 2 * t * (secondEnd[axis] - control[axis])); + const cubic = (a, b, c, d) => + Array.from({ length: 9 }, (_, i) => { + const t = i / 8, + u = 1 - t; + return a.map((v, axis) => u ** 3 * v + 3 * u * u * t * b[axis] + 3 * u * t * t * c[axis] + t ** 3 * d[axis]); + }); + const trim = 0.2; + const left = mix(corner, firstEnd, 1 - trim), + right = mix(corner, secondEnd, 1 - trim); + const arcStart = evaluate(trim), + arcEnd = evaluate(1 - trim); + const leftCurve = cubic( + left, + mix(left, firstEnd, 0.65), + arcStart.map((v, i) => v - (derivative(trim)[i] * trim) / 3), + arcStart, + ); + const rightCurve = cubic( + arcEnd, + arcEnd.map((v, i) => v + (derivative(1 - trim)[i] * trim) / 3), + mix(right, secondEnd, 0.65), + right, + ); + const nearFirst = mix(corner, firstEnd, trim), + nearSecond = mix(corner, secondEnd, trim); + const nose = Array.from({ length: 9 }, (_, i) => { + const t = i / 8; + return corner.map((v, axis) => (1 - t) ** 2 * nearSecond[axis] + 2 * t * (1 - t) * v + t * t * nearFirst[axis]); + }); + const middle = Array.from({ length: segments + 1 }, (_, i) => evaluate(trim + ((1 - 2 * trim) * i) / segments)); + const points = [nearFirst, ...leftCurve, ...middle.slice(1), ...rightCurve.slice(1), ...nose.slice(0, -1)]; + return [...points, points[0]]; +} + +module.exports = { buildPedestrianIsland, validateFacilityComposition, buildIslandFromCrossingEdges }; + +// Fit a common orthogonal frame only for a near-orthogonal four-arm crossing. +function orthogonalCrossingHeadings(headings) { + if (headings.length !== 4) return headings; + const radians = Math.PI / 180; + const axis = + Math.atan2( + headings.reduce((sum, h) => sum + Math.sin(h * radians * 4), 0), + headings.reduce((sum, h) => sum + Math.cos(h * radians * 4), 0), + ) / + (4 * radians); + const fitted = headings.map((h) => axis + Math.round((h - axis) / 90) * 90); + if (fitted.some((h, i) => Math.abs(h - headings[i]) > 15)) return headings; + if (new Set(fitted.map((h) => ((h % 360) + 360) % 360)).size !== 4) return headings; + return fitted; +} + +function stripeLayout(span, width = 0.42, gap = 0.4) { + const pitch = width + gap; + const count = Math.max(0, Math.floor((span + gap) / pitch)); + const margin = (span - (count * width + Math.max(0, count - 1) * gap)) / 2; + return { width, gap, pitch, centers: Array.from({ length: count }, (_, i) => margin + width / 2 + i * pitch) }; +} +module.exports.orthogonalCrossingHeadings = orthogonalCrossingHeadings; +module.exports.stripeLayout = stripeLayout; + +// Support of the curved island inside the white bar's lateral footprint. +// Coordinates are local metres: x along the bar, y toward the outside. +function crossingArcSupport(ring, halfWidth) { + const candidates = []; + for (let i = 1; i < ring.length; i++) { + const a = ring[i - 1], + b = ring[i]; + if (Math.abs(a[0]) <= halfWidth) candidates.push(a[1]); + for (const x of [-halfWidth, halfWidth]) { + if ((a[0] < x && b[0] > x) || (b[0] < x && a[0] > x)) { + const t = (x - a[0]) / (b[0] - a[0]); + candidates.push(a[1] + t * (b[1] - a[1])); + } + } + } + return candidates.length ? Math.max(...candidates) : null; +} +module.exports.crossingArcSupport = crossingArcSupport; diff --git a/src/compile/junction-metrics.js b/src/compile/junction-metrics.js index a89d581..2113223 100644 --- a/src/compile/junction-metrics.js +++ b/src/compile/junction-metrics.js @@ -28,4 +28,4 @@ function complexJunctionMetrics(cluster, calibration = null) { }; } -module.exports = { complexJunctionMetrics, transitionLengthForCutback }; +module.exports = { complexJunctionMetrics, transitionLengthForCutback, COMPLEX_CROSSWALK_DEPTH_METERS: 3.4 }; diff --git a/test/index.js b/test/index.js index b0fef3e..1b7da90 100644 --- a/test/index.js +++ b/test/index.js @@ -479,7 +479,14 @@ const sourceCrossingRadius = Math.hypot( (sourceCrossingModel.crossings[0].coordinate[0] - sourceCenter[0]) * sourceLatitudeScale, (sourceCrossingModel.crossings[0].coordinate[1] - sourceCenter[1]) * 111320, ); -assert.ok(Math.abs(sourcedComplexCrosswalk.properties.radial_distance_m - sourceCrossingRadius) < 0.1); +assert.ok( + Math.abs( + sourcedComplexCrosswalk.properties.radial_distance_m - + sourceCrossingRadius - + sourcedComplexCrosswalk.properties.group_depth_m, + ) < 0.1, + 'complex crossing retreats by its full rectangle depth from its source station', +); const sourcedStopLine = sourceCrossingGeometry.vehicleStopLines.features.find( (feature) => feature.properties?.crossing_key === inferredStopLine.properties.crossing_key, ); @@ -532,3 +539,62 @@ assert.equal( 'source-osm-region', ); console.log('road compiler package tests passed'); + +// Stop lines must remain outside the relocated matching crossing stripes. +const polygonClipping = require('polygon-clipping'); +for (const stop of sourceCrossingGeometry.vehicleStopLines.features) { + if (stop.properties.kind !== 'complex-stop-line') continue; + for (const stripe of sourceCrossingGeometry.crosswalks.features) { + if (stripe.properties.crossing_key !== stop.properties.crossing_key) continue; + assert.deepEqual( + polygonClipping.intersection(stop.geometry.coordinates, stripe.geometry.coordinates), + [], + 'stop line does not intersect its crosswalk after default retreat', + ); + } +} + +const minimumStopGeometry = compiler.nativeRoad.compileGeometry( + sourceCrossingModel, + { schema: 'native-road-overrides/v1', overrides: [] }, + { + edgeLines: false, + junctionTemplates: { + enabled: true, + clusters: [ + { + id: 'fixture-five-arm', + template: 'complex-junction-v1', + nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147', '8613058676'], + coreRadiusMeters: 24, + }, + ], + }, + directEdit: { + clusterCrossings: new Map([ + [ + 'fixture-five-arm', + new Map( + sourceCrossingGeometry.vehicleStopLines.features + .filter((f) => f.properties.kind === 'complex-stop-line') + .map((f) => [f.properties.crossing_key, { stopLineOffsetMeters: 0.5 }]), + ), + ], + ]), + }, + }, +); +const minimumStops = minimumStopGeometry.vehicleStopLines.features.filter( + (f) => f.properties.kind === 'complex-stop-line', +); +assert.ok(minimumStops.length > 0); +for (const stop of minimumStops) { + for (const stripe of minimumStopGeometry.crosswalks.features) { + if (stripe.properties.crossing_key !== stop.properties.crossing_key) continue; + assert.deepEqual( + polygonClipping.intersection(stop.geometry.coordinates, stripe.geometry.coordinates), + [], + 'minimum stop offset must not overlap its matching crossing', + ); + } +} diff --git a/test/junction-facility-composition.js b/test/junction-facility-composition.js index dc1c43b..8255361 100644 --- a/test/junction-facility-composition.js +++ b/test/junction-facility-composition.js @@ -20,3 +20,88 @@ assert.equal(validateFacilityComposition(island, crossings).valid, true); assert.equal(buildPedestrianIsland({ key: 'bad', ring, crossingKeys: ['a', 'b'] }), null); assert.equal(validateFacilityComposition(island, crossings.slice(0, 2)).reason, 'crossing-reference-missing'); console.log('junction facility composition tests passed'); + +// User's sketch: a horizontal crossing to the right, a vertical crossing down, +// and the island in the upper-left quadrant, bounded by doubled short edges. +const { buildIslandFromCrossingEdges } = require('../src/compile/junction-facility-composition'); +const clipping = require('polygon-clipping'); +const sketchIsland = buildIslandFromCrossingEdges([0, 0], [0, 6.8], [-6.8, 0]); +assert.deepEqual(sketchIsland[0], sketchIsland.at(-1)); +assert.ok(sketchIsland.every(([x, y]) => x <= 0 && y >= 0)); +const arcMiddle = sketchIsland[7]; +assert.ok(arcMiddle[1] - arcMiddle[0] < 6.8, 'hypotenuse bends toward the right-angle vertex'); +for (const crossing of [ + [ + [0, 0], + [12, 0], + [12, 3.4], + [0, 3.4], + [0, 0], + ], + [ + [0, 0], + [0, -12], + [-3.4, -12], + [-3.4, 0], + [0, 0], + ], +]) + assert.deepEqual(clipping.intersection([sketchIsland], [crossing]), [], 'short-edge attachment has no area overlap'); +const rotate = ([x, y]) => [-y + 20, x - 10]; +const rotatedIsland = buildIslandFromCrossingEdges( + ...[ + [0, 0], + [0, 6.8], + [-6.8, 0], + ].map(rotate), +); +rotatedIsland.forEach((p, i) => + assert.ok( + Math.hypot(...p.map((v, j) => v - rotate(sketchIsland[i])[j])) < 1e-10, + 'composition is independent of world orientation', + ), +); + +const { stripeLayout, orthogonalCrossingHeadings } = require('../src/compile/junction-facility-composition'); +for (const span of [3.4, 8.123, 31.7]) { + const layout = stripeLayout(span); + for (let i = 1; i < layout.centers.length; i++) + assert.ok(Math.abs(layout.centers[i] - layout.centers[i - 1] - layout.width - layout.gap) < 1e-10); + assert.ok(layout.centers[0] >= layout.width / 2); + assert.ok(layout.centers.at(-1) + layout.width / 2 <= span + 1e-10); +} +const fitted = orthogonalCrossingHeadings([62.2, 150.4, 240.7, 332]); +for (let i = 1; i < 4; i++) assert.ok(Math.abs(fitted[i] - fitted[i - 1] - 90) < 1e-10); +assert.deepEqual(orthogonalCrossingHeadings([0, 120, 240]), [0, 120, 240]); +assert.deepEqual(orthogonalCrossingHeadings([0, 40, 180, 270]), [0, 40, 180, 270]); + +const { crossingArcSupport } = require('../src/compile/junction-facility-composition'); +assert.ok(!sketchIsland.some(([x, y]) => x === 0 && y === 0), 'right-angle vertex is rounded'); +assert.ok(!sketchIsland.some(([x, y]) => x === 0 && y === 6.8), 'first arc/leg vertex is rounded'); +assert.ok(!sketchIsland.some(([x, y]) => x === -6.8 && y === 0), 'second arc/leg vertex is rounded'); +// Curve support must consider the ends of a finite-width bar, not only its centre. +const curved = [ + [-3, 2], + [-1, 0], + [1, 0], + [3, 2], + [3, -2], + [-3, -2], + [-3, 2], +]; +assert.equal(crossingArcSupport(curved, 2), 1); +assert.deepEqual( + clipping.intersection( + [curved], + [ + [ + [-2, 1], + [2, 1], + [2, 1.42], + [-2, 1.42], + [-2, 1], + ], + ], + ), + [], +);