885 lines
36 KiB
JavaScript
885 lines
36 KiB
JavaScript
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const { structureFromTopology } = require('./junction-topology');
|
|
const { resolveJunctionBuildPlan, stationAtDistanceFrom } = require('./junction-build-plan');
|
|
const { buildJunctionBoundaryGraph, buildCoreClosure } = require('./junction-boundary-graph');
|
|
const { complexJunctionMetrics: calculateComplexJunctionMetrics } = require('./junction-metrics');
|
|
const { convertGeoJson, boundsOf } = require('../reference/gaode');
|
|
const metricsCache = new WeakMap();
|
|
const CORNER_FILLET_SEGMENTS = 12;
|
|
// Must match DEFAULT_SIDEWALK_WIDTH_METERS in native-road.js so the corner band
|
|
// lines up with the straight strips it joins.
|
|
const SIDEWALK_WIDTH_METERS = 2;
|
|
// The straight strips are trimmed against the cluster boundary using the road
|
|
// centerline, so they stop a little beyond the carriageway end. Run the corner
|
|
// past that end and let the two overlap rather than chase an exact seam.
|
|
const SIDEWALK_CORNER_OVERRUN_METERS = 6;
|
|
|
|
// Compatibility export for current compiler consumers. The build-plan module is
|
|
// pure and is the shared authority for geometry and direct-edit identity.
|
|
const resolveComplexJunctionTopology = resolveJunctionBuildPlan;
|
|
|
|
function buildComplexJunctionGeometry(model, cluster, helpers) {
|
|
const nodeIds = new Set(cluster.nodeIds.map(String));
|
|
const nodes = cluster.nodeIds.map((id) => helpers.junctionPlans.get(String(id))?.node).filter(Boolean);
|
|
if (nodes.length < 2)
|
|
return {
|
|
features: [],
|
|
diagnostics: [
|
|
helpers.diagnostic(
|
|
'warning',
|
|
`junction-cluster:${cluster.id}`,
|
|
[...nodeIds],
|
|
'complex-junction-insufficient-nodes',
|
|
'复合路口至少需要两个有效节点。',
|
|
null,
|
|
),
|
|
],
|
|
};
|
|
const center = nodes.reduce(
|
|
(sum, point) => [sum[0] + point[0] / nodes.length, sum[1] + point[1] / nodes.length],
|
|
[0, 0],
|
|
);
|
|
const topology = resolveComplexJunctionTopology(model, cluster, helpers);
|
|
const { carriageways, arms } = topology;
|
|
const approaches = arms.map((arm) => arm.representative);
|
|
if (approaches.length < 3)
|
|
return {
|
|
features: [],
|
|
diagnostics: [
|
|
helpers.diagnostic(
|
|
'warning',
|
|
`junction-cluster:${cluster.id}`,
|
|
[...nodeIds],
|
|
'complex-junction-insufficient-approaches',
|
|
'复合路口无法识别足够的外部进口。',
|
|
center,
|
|
),
|
|
],
|
|
};
|
|
const { calibration, coreRadius } = complexJunctionMetrics(cluster);
|
|
const sorted = approaches;
|
|
const shape = classifyJunctionShape(arms, center, helpers);
|
|
if (shape.kind === 'unsupported')
|
|
return {
|
|
features: [],
|
|
diagnostics: [
|
|
helpers.diagnostic(
|
|
'warning',
|
|
`junction-cluster:${cluster.id}`,
|
|
[...nodeIds],
|
|
'complex-junction-shape-fallback',
|
|
`${shape.label},已回退为普通路口渲染。`,
|
|
center,
|
|
),
|
|
],
|
|
shape,
|
|
center,
|
|
};
|
|
const outerRadius = complexJunctionMetrics(cluster).approachOuterRadius;
|
|
const boundaryParts = [];
|
|
const transitionDiagnostics = [];
|
|
const crosswalks = [];
|
|
const stopLines = [];
|
|
const islands = [];
|
|
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: 'inferred-road-envelope', 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),
|
|
);
|
|
const boundaryGraph = buildJunctionBoundaryGraph(
|
|
topology,
|
|
center,
|
|
{
|
|
outerRadiusFor: (item) => Math.max(coreRadius + 4, outerRadius - Math.max(0, Number(item.approach.cutback) || 0)),
|
|
innerRadiusFor: () => complexJunctionMetrics(cluster).approachInnerRadius,
|
|
},
|
|
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.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) {
|
|
// Keep the stop bar just outside the road crosswalk. The previous fixed
|
|
// core-radius offset placed it nearly ten metres beyond the crossing.
|
|
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 crossingEvidence = crossingPlans.get(arm.key)?.evidence || {
|
|
kind: 'inferred-road-envelope',
|
|
crossingNodeIds: [],
|
|
};
|
|
const ring = [
|
|
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,
|
|
0.24,
|
|
),
|
|
helpers.offsetCoordinate(
|
|
helpers.offsetCoordinate(stopCenter, item.heading + 90, -outerHalf),
|
|
item.heading,
|
|
-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.
|
|
for (const arm of arms) {
|
|
const armCrosswalkRadius = armCrosswalkRadiusFor(arm);
|
|
arm.crosswalkRadius = armCrosswalkRadius;
|
|
const envelope = armEnvelopeAtRadius(arm, armCrosswalkRadius, center, helpers);
|
|
if (!envelope) continue;
|
|
arm.crosswalkFrame = {
|
|
center: envelope.center,
|
|
groupDepth: 3.4,
|
|
supportHeading: normalizeHeading(arm.heading + 90),
|
|
envelopeWidthMeters: envelope.widthMeters,
|
|
};
|
|
arm.crosswalkEvidence = crossingPlans.get(arm.key)?.evidence || {
|
|
kind: 'inferred-road-envelope',
|
|
crossingNodeIds: [],
|
|
};
|
|
}
|
|
for (let index = 0; index < arms.length; index += 1) {
|
|
const arm = arms[index];
|
|
if (!arm.crosswalkFrame) continue;
|
|
const item = arm.representative;
|
|
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;
|
|
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;
|
|
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 centerPoint = helpers.offsetCoordinate(endpoints[0], bearing(...endpoints), along);
|
|
const ring = [
|
|
helpers.offsetCoordinate(
|
|
helpers.offsetCoordinate(centerPoint, arm.heading, -groupDepth / 2),
|
|
arm.heading + 90,
|
|
-stripeWidth / 2,
|
|
),
|
|
helpers.offsetCoordinate(
|
|
helpers.offsetCoordinate(centerPoint, arm.heading, groupDepth / 2),
|
|
arm.heading + 90,
|
|
-stripeWidth / 2,
|
|
),
|
|
helpers.offsetCoordinate(
|
|
helpers.offsetCoordinate(centerPoint, arm.heading, groupDepth / 2),
|
|
arm.heading + 90,
|
|
stripeWidth / 2,
|
|
),
|
|
helpers.offsetCoordinate(
|
|
helpers.offsetCoordinate(centerPoint, arm.heading, -groupDepth / 2),
|
|
arm.heading + 90,
|
|
stripeWidth / 2,
|
|
),
|
|
helpers.offsetCoordinate(
|
|
helpers.offsetCoordinate(centerPoint, arm.heading, -groupDepth / 2),
|
|
arm.heading + 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: arm.heading,
|
|
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 cornerFills = [];
|
|
const sidewalkCorners = [];
|
|
const cornerDiagnostics = [];
|
|
for (const arm of arms) {
|
|
if (!arm.crosswalkFrame || arm.crosswalkEvidence.kind !== 'inferred-road-envelope') continue;
|
|
cornerDiagnostics.push(
|
|
helpers.diagnostic(
|
|
'info',
|
|
`crossing:${arm.key}`,
|
|
arm.members.flatMap((member) => member.approach.roadIds.map(String)),
|
|
'complex-junction-crossing-inferred',
|
|
'该进口未找到与道路及当前位置匹配的 OSM 过街节点;已按最终车行道范围推断斑马线和停止线。',
|
|
arm.crosswalkFrame.center,
|
|
),
|
|
);
|
|
}
|
|
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];
|
|
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;
|
|
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] },
|
|
});
|
|
|
|
// 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 curb = [
|
|
...edgeRunToRadius(
|
|
apex,
|
|
edges[0],
|
|
tangentDistance,
|
|
outerRadius + SIDEWALK_CORNER_OVERRUN_METERS,
|
|
center,
|
|
helpers,
|
|
).reverse(),
|
|
...curve.slice(1, -1),
|
|
...edgeRunToRadius(
|
|
apex,
|
|
edges[1],
|
|
tangentDistance,
|
|
outerRadius + SIDEWALK_CORNER_OVERRUN_METERS,
|
|
center,
|
|
helpers,
|
|
),
|
|
];
|
|
const outerEdge = offsetPolylineAwayFromCenter(curb, center, SIDEWALK_WIDTH_METERS, helpers);
|
|
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;
|
|
}
|
|
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,
|
|
overrun_m: SIDEWALK_CORNER_OVERRUN_METERS,
|
|
provenance: 'native-road-complex-junction-sidewalk-corner/v1',
|
|
},
|
|
geometry: { type: 'Polygon', coordinates: [sidewalkRing] },
|
|
});
|
|
}
|
|
const coreClosure = buildCoreClosure(topology, boundaryGraph, center);
|
|
const coreRing = coreClosure.status === 'supported' ? coreClosure.ring : null;
|
|
const features = [];
|
|
if (coreRing)
|
|
features.push({
|
|
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,
|
|
provenance: 'native-road-complex-junction/v7-shared-entry-core',
|
|
},
|
|
geometry: { type: 'Polygon', coordinates: [coreRing] },
|
|
});
|
|
else {
|
|
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.outer.right,
|
|
section.inner.right,
|
|
section.inner.left,
|
|
section.outer.left,
|
|
section.outer.right,
|
|
];
|
|
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.outer.stationMeters - section.inner.stationMeters) * 10) / 10,
|
|
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);
|
|
// `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.
|
|
const configuredRadiusIgnored =
|
|
calibration && Number.isFinite(cluster.coreRadiusMeters) && Math.abs(coreRadius - cluster.coreRadiusMeters) > 0.5;
|
|
const configurationDiagnostics = configuredRadiusIgnored
|
|
? [
|
|
helpers.diagnostic(
|
|
'info',
|
|
`junction-cluster:${cluster.id}`,
|
|
[...nodeIds],
|
|
'complex-junction-configured-radius-ignored',
|
|
`已按参考几何校准核心半径为 ${Math.round(coreRadius * 10) / 10} 米,配置的 coreRadiusMeters=${cluster.coreRadiusMeters} 在有参考文件时不生效。`,
|
|
center,
|
|
),
|
|
]
|
|
: [];
|
|
const knownIslandFeatures = (model.exclusionRegions || [])
|
|
.filter(
|
|
(region) =>
|
|
Array.isArray(region.ring) &&
|
|
region.ring.length >= 4 &&
|
|
region.ring.some((point) => helpers.distanceMeters(point, center) <= outerRadius + 12),
|
|
)
|
|
.map((region) => ({
|
|
type: 'Feature',
|
|
properties: {
|
|
native_id: `osm-traffic-island:${region.id}`,
|
|
object_key: `island:osm/${region.id}`,
|
|
kind: 'island',
|
|
osm_way_ids: String(region.id),
|
|
source: region.source,
|
|
facility_evidence: 'source-osm-region',
|
|
},
|
|
geometry: { type: 'Polygon', coordinates: [region.ring] },
|
|
}));
|
|
const allFeatures = [
|
|
...features,
|
|
...islands,
|
|
...sidewalkCorners,
|
|
...crosswalks,
|
|
...stopLines,
|
|
...knownIslandFeatures,
|
|
];
|
|
const structure = structureFromTopology(topology, shape, center, allFeatures);
|
|
for (const feature of allFeatures) {
|
|
feature.properties.junction_key = structure.junctionKey;
|
|
feature.properties.topology_fingerprint = structure.topologyFingerprint;
|
|
}
|
|
// Persist the compiler authority with a generated road surface, including the
|
|
// supported-shape case where only the central polygon had to be skipped.
|
|
const carrier = features.find((feature) => feature.properties.kind === 'complex-core') || features[0];
|
|
if (carrier) carrier.properties.junction_structure = structure;
|
|
return {
|
|
structure,
|
|
features,
|
|
islands: [...islands, ...sidewalkCorners],
|
|
crosswalks,
|
|
stopLines,
|
|
center,
|
|
shape,
|
|
approaches,
|
|
diagnostics: [
|
|
...transitionDiagnostics,
|
|
...cornerDiagnostics,
|
|
...configurationDiagnostics,
|
|
helpers.diagnostic(
|
|
'info',
|
|
`junction-cluster:${cluster.id}`,
|
|
[...nodeIds],
|
|
calibration ? 'complex-junction-reference-calibrated' : 'complex-junction-generated',
|
|
calibration
|
|
? `已识别为${shape.label},使用参考几何校准参数后重新生成 ${approaches.length} 个进口、道路面、斑马线和停止线。`
|
|
: `已识别为${shape.label},独立生成 ${approaches.length} 个进口、道路面、斑马线和停止线。`,
|
|
center,
|
|
),
|
|
],
|
|
};
|
|
}
|
|
|
|
function classifyJunctionShape(arms, center, helpers) {
|
|
const headings = arms.map((arm) => arm.heading);
|
|
const throughPairs = [];
|
|
for (let first = 0; first < headings.length; first += 1) {
|
|
for (let second = first + 1; second < headings.length; second += 1) {
|
|
const delta = Math.abs(normalizeHeading(headings[first] - headings[second]));
|
|
if (delta >= 155) throughPairs.push([first, second]);
|
|
}
|
|
}
|
|
const sorted = [...headings].sort((a, b) => a - b);
|
|
const gaps = sorted.map((heading, index) => positiveHeadingDelta(heading, sorted[(index + 1) % sorted.length]));
|
|
const hasRightAngleCross =
|
|
arms.length === 4 && gaps.filter((gap) => gap >= 55 && gap <= 125).length >= 3 && throughPairs.length >= 2;
|
|
const hasOppositePair = throughPairs.length >= 1;
|
|
if (arms.length === 3 && hasOppositePair)
|
|
return { kind: 't-junction', label: '3 臂 T 字路口', throughPairCount: throughPairs.length };
|
|
if (hasRightAngleCross) {
|
|
const centers = arms.map((arm) => arm.members[0]?.approach?.line?.at?.(-1)).filter(Boolean);
|
|
const spread =
|
|
centers.length === arms.length
|
|
? Math.max(...centers.map((point) => helpers.distanceMeters(point, center))) -
|
|
Math.min(...centers.map((point) => helpers.distanceMeters(point, center)))
|
|
: 0;
|
|
return {
|
|
kind: spread > 12 ? 'offset-cross' : 'cross',
|
|
label: spread > 12 ? '4 臂偏置十字路口' : '4 臂十字路口',
|
|
throughPairCount: throughPairs.length,
|
|
};
|
|
}
|
|
if (arms.length >= 3 && arms.length <= 8) {
|
|
return { kind: 'multi-arm', label: `${arms.length} 臂非规则路口`, throughPairCount: throughPairs.length };
|
|
}
|
|
return { kind: 'unsupported', label: '暂不支持的路口形态', throughPairCount: throughPairs.length };
|
|
}
|
|
|
|
function readReferenceCalibration(cluster) {
|
|
if (!cluster.referenceFile || !fs.existsSync(cluster.referenceFile)) return null;
|
|
try {
|
|
const converted = convertGeoJson(JSON.parse(fs.readFileSync(cluster.referenceFile, 'utf8')));
|
|
const bounds = boundsOf({
|
|
features: converted.features.filter((feature) => [1, 2, 3, 4].includes(Number(feature.properties?.type))),
|
|
});
|
|
const lonScale = 111320 * Math.cos((((bounds.minLat + bounds.maxLat) / 2) * Math.PI) / 180);
|
|
return {
|
|
longSpanMeters: (bounds.maxLon - bounds.minLon) * lonScale,
|
|
shortSpanMeters: (bounds.maxLat - bounds.minLat) * 111320,
|
|
};
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function complexJunctionMetrics(cluster) {
|
|
if (metricsCache.has(cluster)) return metricsCache.get(cluster);
|
|
const calibration = readReferenceCalibration(cluster);
|
|
const metrics = calculateComplexJunctionMetrics(cluster, calibration);
|
|
metricsCache.set(cluster, metrics);
|
|
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);
|
|
}),
|
|
);
|
|
}
|
|
|
|
// Walk outward along a wedge edge from its tangent point until the curb reaches
|
|
// `targetRadius`, so the corner band overlaps the straight strip it joins.
|
|
function edgeRunToRadius(apex, edge, tangentDistance, targetRadius, center, helpers) {
|
|
const points = [];
|
|
for (let extra = 0; extra <= 40; extra += 2) {
|
|
const point = helpers.offsetCoordinate(apex, edge.heading, tangentDistance + extra);
|
|
points.push(point);
|
|
if (helpers.distanceMeters(point, center) >= targetRadius) break;
|
|
}
|
|
return points;
|
|
}
|
|
|
|
// 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' : 'inferred-road-envelope',
|
|
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,
|
|
}));
|
|
});
|
|
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);
|
|
}
|
|
module.exports = {
|
|
resolveComplexJunctionTopology,
|
|
buildComplexJunctionGeometry,
|
|
classifyJunctionShape,
|
|
complexJunctionMetrics,
|
|
};
|