1754 lines
76 KiB
JavaScript
1754 lines
76 KiB
JavaScript
'use strict';
|
|
|
|
const { diagnostic } = require('./diagnostics');
|
|
const { approachForCrossing, arrivalEndpointIds, effectiveCrosswalkInsetMax } = require('./crossing-approach');
|
|
const { haversineMeters, metersAt, polylineLength } = require('../geometry/lane-geometry');
|
|
const {
|
|
roadSurfaceId,
|
|
sidewalkId,
|
|
laneId,
|
|
laneSeparatorId,
|
|
edgeLineId,
|
|
centerLineId,
|
|
junctionSurfaceId,
|
|
connectionConnectorId,
|
|
} = require('./native-ids');
|
|
const { complexJunctionMetrics } = require('./junction-metrics');
|
|
const { resolveJunctionBuildPlan, stationAtDistanceFrom } = require('./junction-build-plan');
|
|
|
|
const RESOLUTION_SCHEMA = 'road-edit-resolution/v1';
|
|
const HANDLE_MANIFEST_SCHEMA = 'road-edit-handles/v1';
|
|
const ACTIVE_STATUSES = new Set(['exact', 'recheck']);
|
|
const SOLVED_KINDS = new Set([
|
|
'road-edge-offset',
|
|
'road-sidewalk-width',
|
|
'road-lane-divider',
|
|
'junction-approach-width',
|
|
'cluster-carriageway-width',
|
|
'cluster-carriageway-cutback',
|
|
'cluster-corner-radius',
|
|
'cluster-crossing-inset',
|
|
'cluster-stop-line-offset',
|
|
'junction-cutback',
|
|
'junction-corner-radius',
|
|
'junction-crosswalk-inset',
|
|
'junction-crosswalk-size',
|
|
'junction-stop-line-offset',
|
|
'lane-maneuver',
|
|
]);
|
|
const KINDS = [
|
|
'road-edge-offset',
|
|
'road-sidewalk-width',
|
|
'road-lane-divider',
|
|
'junction-approach-width',
|
|
'cluster-carriageway-width',
|
|
'cluster-carriageway-cutback',
|
|
'cluster-corner-radius',
|
|
'cluster-crossing-inset',
|
|
'cluster-stop-line-offset',
|
|
'junction-cutback',
|
|
'junction-corner-radius',
|
|
'junction-crosswalk-inset',
|
|
'junction-crosswalk-size',
|
|
'junction-stop-line-offset',
|
|
'lane-maneuver',
|
|
];
|
|
const SUPPORTED_MANEUVERS = new Set([
|
|
'',
|
|
'through',
|
|
'left',
|
|
'right',
|
|
'through;left',
|
|
'through;right',
|
|
'through;left;right',
|
|
]);
|
|
const MIN_LANE_WIDTH_METERS = 2.4;
|
|
// Bounds for the control-marking offsets. The crosswalk may sit anywhere from the
|
|
// junction boundary out to a few metres; the stop line must stay clear of the
|
|
// crossing it protects.
|
|
const MAX_CROSSWALK_INSET_METERS = 8;
|
|
const MIN_STOP_LINE_OFFSET_METERS = 0.5;
|
|
// Default placement, and therefore a handle's value when no constraint exists yet.
|
|
// These live here rather than in native-road.js because the solver must stay free
|
|
// of fs/path — a test asserts that — so the dependency can only point this way.
|
|
const CROSSWALK_JUNCTION_INSET_METERS = 1.5;
|
|
// Zebra geometry. Depth runs along the approach; the span across the road is
|
|
// `stripeCount * pitch`, not a stored number, because stripe and gap widths are
|
|
// standardised while the road they cross is not. Pitch is not editable this phase.
|
|
const CROSSWALK_DEPTH_METERS = 3;
|
|
const CROSSWALK_STRIPE_WIDTH_METERS = 0.45;
|
|
const CROSSWALK_STRIPE_PITCH_METERS = 0.9;
|
|
const MIN_CROSSWALK_DEPTH_METERS = 1;
|
|
const MAX_CROSSWALK_DEPTH_METERS = 12;
|
|
const MIN_CROSSWALK_STRIPE_COUNT = 2;
|
|
const MAX_CROSSWALK_STRIPE_COUNT = 40;
|
|
const STOP_LINE_OFFSET_METERS = 2.7;
|
|
/** Junction-anchored but owned by the main map, unlike the junction shape kinds. */
|
|
const CONTROL_KINDS = new Set(['junction-crosswalk-inset', 'junction-crosswalk-size', 'junction-stop-line-offset']);
|
|
const GEOMETRY_VERSION = 'native-road-package/v1.1';
|
|
|
|
function emptyHandleManifest(context) {
|
|
return {
|
|
schema: HANDLE_MANIFEST_SCHEMA,
|
|
revisionId: typeof context.revisionId === 'string' ? context.revisionId : null,
|
|
previewSeq: Number.isInteger(context.previewSeq) ? context.previewSeq : 0,
|
|
handles: [],
|
|
reserves: [],
|
|
};
|
|
}
|
|
|
|
function constraintState(constraint, applied, reason) {
|
|
return {
|
|
constraintId: constraint.id,
|
|
kind: constraint.kind,
|
|
status: constraint.status,
|
|
applied,
|
|
reason: constraint.status === 'stale' && constraint.replayReason ? constraint.replayReason : reason,
|
|
};
|
|
}
|
|
|
|
function coordinateAt(line, station) {
|
|
if (!Array.isArray(line) || line.length === 0) return null;
|
|
if (line.length === 1) return [...line[0]];
|
|
const total = polylineLength(line);
|
|
if (!Number.isFinite(total) || total <= 0) return [...line[0]];
|
|
let remaining = Math.max(0, Math.min(1, station)) * total;
|
|
for (let index = 1; index < line.length; index += 1) {
|
|
const length = haversineMeters(line[index - 1], line[index]);
|
|
if (length >= remaining) {
|
|
const ratio = length ? remaining / length : 0;
|
|
return [
|
|
line[index - 1][0] + (line[index][0] - line[index - 1][0]) * ratio,
|
|
line[index - 1][1] + (line[index][1] - line[index - 1][1]) * ratio,
|
|
];
|
|
}
|
|
remaining -= length;
|
|
}
|
|
return [...line.at(-1)];
|
|
}
|
|
|
|
function tangentAzimuth(line, station) {
|
|
const point = coordinateAt(line, station);
|
|
if (!point || line.length < 2) return 0;
|
|
const distance = Math.max(0.01, polylineLength(line) * 0.005);
|
|
const before = coordinateAt(line, Math.max(0, station - distance / Math.max(polylineLength(line), 1)));
|
|
const after = coordinateAt(line, Math.min(1, station + distance / Math.max(polylineLength(line), 1)));
|
|
const dx = (after[0] - before[0]) * Math.cos((point[1] * Math.PI) / 180);
|
|
const dy = after[1] - before[1];
|
|
if (Math.abs(dx) + Math.abs(dy) < 1e-12) return 0;
|
|
return ((Math.atan2(dx, dy) * 180) / Math.PI + 360) % 360;
|
|
}
|
|
|
|
function offsetCoordinate(point, azimuth, meters) {
|
|
const radians = (azimuth * Math.PI) / 180;
|
|
const latitudeScale = metersAt(point[1]).lon;
|
|
return [
|
|
point[0] + (Math.sin(radians) * meters) / Math.max(latitudeScale, 1e-9),
|
|
point[1] + (Math.cos(radians) * meters) / 111320,
|
|
];
|
|
}
|
|
|
|
function constraintFor(constraints, kind, anchor) {
|
|
return constraints.find((item) => {
|
|
if (item.kind !== kind || !item.anchor || item.enabled === false) return false;
|
|
if (kind.startsWith('road-')) {
|
|
return (
|
|
item.anchor.type === 'road-interval' &&
|
|
item.anchor.roadId === anchor.roadId &&
|
|
(item.anchor.side || null) === (anchor.side || null) &&
|
|
(kind !== 'road-lane-divider' || item.value?.boundaryIndex === anchor.boundaryIndex)
|
|
);
|
|
}
|
|
if (kind === 'junction-corner-radius')
|
|
return (
|
|
item.anchor.type === 'junction-corner' &&
|
|
item.anchor.nodeId === anchor.nodeId &&
|
|
item.anchor.incomingRoadId === anchor.incomingRoadId &&
|
|
item.anchor.outgoingRoadId === anchor.outgoingRoadId
|
|
);
|
|
if (kind === 'cluster-carriageway-width')
|
|
return (
|
|
item.anchor.type === 'cluster-carriageway' &&
|
|
item.anchor.clusterId === anchor.clusterId &&
|
|
item.anchor.carriagewayKey === anchor.carriagewayKey
|
|
);
|
|
if (kind === 'cluster-carriageway-cutback')
|
|
return (
|
|
item.anchor.type === 'cluster-carriageway' &&
|
|
item.anchor.clusterId === anchor.clusterId &&
|
|
item.anchor.carriagewayKey === anchor.carriagewayKey
|
|
);
|
|
if (kind === 'cluster-corner-radius')
|
|
return (
|
|
item.anchor.type === 'cluster-corner' &&
|
|
item.anchor.clusterId === anchor.clusterId &&
|
|
item.anchor.cornerKey === anchor.cornerKey
|
|
);
|
|
if (kind === 'cluster-crossing-inset' || kind === 'cluster-stop-line-offset')
|
|
return (
|
|
item.anchor.type === 'cluster-crossing' &&
|
|
item.anchor.clusterId === anchor.clusterId &&
|
|
item.anchor.crossingKey === anchor.crossingKey
|
|
);
|
|
if (kind === 'junction-crosswalk-inset' || kind === 'junction-stop-line-offset')
|
|
return (
|
|
item.anchor.type === 'junction-crossing' &&
|
|
item.anchor.crossingId === anchor.crossingId &&
|
|
item.anchor.nodeId === anchor.nodeId &&
|
|
item.anchor.segmentId === anchor.segmentId &&
|
|
item.anchor.roadId === anchor.roadId
|
|
);
|
|
return (
|
|
item.anchor.type === 'junction-approach' &&
|
|
item.anchor.nodeId === anchor.nodeId &&
|
|
item.anchor.segmentId === anchor.segmentId &&
|
|
(item.anchor.side || null) === (anchor.side || null)
|
|
);
|
|
});
|
|
}
|
|
|
|
function clusterCarriageways(model, junctionData, clusters) {
|
|
const result = new Map();
|
|
for (const cluster of Array.isArray(clusters) ? clusters : []) {
|
|
if (!cluster?.id || !Array.isArray(cluster.nodeIds)) continue;
|
|
const plans = new Map();
|
|
for (const nodeId of cluster.nodeIds.map(String)) {
|
|
const approaches = (junctionData.approaches.get(nodeId) || []).map((source) => {
|
|
const roads = source.items.map((item) => item.road);
|
|
const first = source.items[0];
|
|
const line = first?.endpoint.side === 'end' ? [...roads[0].centerline].reverse() : roads[0]?.centerline || [];
|
|
return {
|
|
...source,
|
|
roadIds: roads.map((road) => road.id),
|
|
widthMeters: source.items.reduce((sum, item) => sum + item.road.widthMeters, 0),
|
|
line,
|
|
};
|
|
});
|
|
const node = approaches[0]?.line?.[0] || [0, 0];
|
|
plans.set(nodeId, { node, approaches });
|
|
}
|
|
const topology = resolveJunctionBuildPlan(model, cluster, {
|
|
junctionPlans: plans,
|
|
distanceMeters: haversineMeters,
|
|
lineLengthMeters: polylineLength,
|
|
headingAtEndpoint: (line) => tangentAzimuth(line, 0),
|
|
});
|
|
const armByKey = new Map(topology.arms.flatMap((arm) => arm.members.map((member) => [member.key, arm])));
|
|
result.set(
|
|
String(cluster.id),
|
|
topology.carriageways.map((item) => ({
|
|
...item,
|
|
clusterId: String(cluster.id),
|
|
identity: item.key.split(':carriageway:').at(-1),
|
|
sourceNodeIds: [...new Set(item.roads.flatMap((road) => (road.sourceNodeIds || []).map(String)))].sort(),
|
|
sourceRoadIds: item.roads.map((road) => String(road.id)).sort(),
|
|
widthMeters: item.approach.widthMeters,
|
|
laneCount: item.roads.reduce((sum, road) => sum + (Number(road.laneCount) || 0), 0),
|
|
arm: armByKey.get(item.key),
|
|
})),
|
|
);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function clusterApproachLine(item) {
|
|
return item.approach.line || [];
|
|
}
|
|
|
|
function clusterCenter(model, cluster) {
|
|
const endpointsByNode = new Map();
|
|
for (const endpoint of model.endpoints || []) {
|
|
const nodeId = String(endpoint.nodeId);
|
|
if (!endpointsByNode.has(nodeId) && Array.isArray(endpoint.coordinate))
|
|
endpointsByNode.set(nodeId, endpoint.coordinate);
|
|
}
|
|
const points = (cluster.nodeIds || []).map((nodeId) => endpointsByNode.get(String(nodeId))).filter(Boolean);
|
|
if (!points.length) return null;
|
|
return points.reduce((sum, point) => [sum[0] + point[0] / points.length, sum[1] + point[1] / points.length], [0, 0]);
|
|
}
|
|
|
|
function clusterRadiusPoint(line, center, radius) {
|
|
if (!center || !line.length) return null;
|
|
const length = polylineLength(line);
|
|
if (!Number.isFinite(length) || length <= 0) return line[0] || null;
|
|
const station = stationAtDistanceFrom(line, center, radius, { distanceMeters: haversineMeters });
|
|
return coordinateAt(line, Math.max(0, Math.min(1, station / length)));
|
|
}
|
|
|
|
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 clusterArmRadiusPoint(arm, center, radius) {
|
|
const points = arm.members
|
|
.map((member) => ({ member, point: clusterRadiusPoint(clusterApproachLine(member), center, radius) }))
|
|
.filter((item) => item.point);
|
|
if (!points.length) return null;
|
|
const reference = points[0].point;
|
|
let minimum = Infinity;
|
|
let maximum = -Infinity;
|
|
for (const { member, point } of points) {
|
|
const lateral = signedLateralMeters(reference, point, arm.heading);
|
|
const halfWidth = (Number(member.approach.widthMeters) || 0) / 2;
|
|
minimum = Math.min(minimum, lateral - halfWidth);
|
|
maximum = Math.max(maximum, lateral + halfWidth);
|
|
}
|
|
return Number.isFinite(minimum) && Number.isFinite(maximum)
|
|
? offsetCoordinate(reference, arm.heading + 90, (minimum + maximum) / 2)
|
|
: reference;
|
|
}
|
|
|
|
function clusterCrossingBaseRadius(model, arm, center, inferredRadius) {
|
|
const inferredCenter = clusterArmRadiusPoint(arm, center, inferredRadius);
|
|
if (!inferredCenter) return inferredRadius;
|
|
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 + (Number(member.approach.widthMeters) || 0), 0) / 2 + 3,
|
|
);
|
|
const crossing = (model.crossings || [])
|
|
.filter(
|
|
(item) =>
|
|
(item.osmWayIds || []).some((wayId) => osmWayIds.has(String(wayId))) &&
|
|
haversineMeters(item.coordinate, inferredCenter) <= maximumDistance,
|
|
)
|
|
.sort(
|
|
(first, second) =>
|
|
haversineMeters(first.coordinate, inferredCenter) - haversineMeters(second.coordinate, inferredCenter) ||
|
|
String(first.id).localeCompare(String(second.id)),
|
|
)[0];
|
|
return crossing ? haversineMeters(center, crossing.coordinate) : inferredRadius;
|
|
}
|
|
|
|
function clusterArms(clusterId, items) {
|
|
const byArm = new Map();
|
|
for (const item of items) {
|
|
if (!item.arm || byArm.has(item.arm.key)) continue;
|
|
byArm.set(item.arm.key, {
|
|
...item.arm,
|
|
members: item.arm.members.map((member) => items.find((candidate) => candidate.key === member.key) || member),
|
|
});
|
|
}
|
|
return [...byArm.values()];
|
|
}
|
|
|
|
function numericValue(constraint, key, fallback) {
|
|
const value = constraint?.value?.[key];
|
|
return Number.isFinite(value) ? value : fallback;
|
|
}
|
|
|
|
function clusterCutbackMaximum(cluster, approachLength) {
|
|
const metrics = complexJunctionMetrics(cluster);
|
|
// Keep a measurable local taper between the source-road outer section and
|
|
// the inner core section. The other cap preserves a usable source approach.
|
|
return Math.min(
|
|
approachLength * 0.45,
|
|
Math.max(1, metrics.approachOuterRadius - (metrics.approachInnerRadius + metrics.minimumTransitionMeters)),
|
|
);
|
|
}
|
|
|
|
function roadGroups(model) {
|
|
const groups = new Map();
|
|
for (const road of Array.isArray(model?.roads) ? model.roads : []) {
|
|
if (!road || !Array.isArray(road.centerline) || road.centerline.length < 2) continue;
|
|
if (!groups.has(road.segmentId)) groups.set(road.segmentId, []);
|
|
groups.get(road.segmentId).push(road);
|
|
}
|
|
return groups;
|
|
}
|
|
|
|
function junctionReserves(model) {
|
|
const endpointGroups = new Map();
|
|
for (const endpoint of Array.isArray(model?.endpoints) ? model.endpoints : []) {
|
|
const road = (model.roads || []).find((item) => item.id === endpoint.roadId);
|
|
if (!road) continue;
|
|
if (!endpointGroups.has(endpoint.nodeId)) endpointGroups.set(endpoint.nodeId, new Map());
|
|
const bySegment = endpointGroups.get(endpoint.nodeId);
|
|
if (!bySegment.has(road.segmentId)) bySegment.set(road.segmentId, []);
|
|
bySegment.get(road.segmentId).push({ endpoint, road });
|
|
}
|
|
const reserves = [];
|
|
const approaches = new Map();
|
|
for (const [nodeId, bySegment] of endpointGroups) {
|
|
if (bySegment.size < 3 || bySegment.size > 4) continue;
|
|
const widths = [...bySegment.values()].map((items) => items.reduce((sum, item) => sum + item.road.widthMeters, 0));
|
|
const cutback = Math.max(...widths) * 1.4;
|
|
for (const [segmentId, items] of bySegment) {
|
|
const representative = items[0].road;
|
|
const length = polylineLength(representative.centerline);
|
|
if (!Number.isFinite(length) || length <= 0) continue;
|
|
const fraction = Math.min(0.45, cutback / length);
|
|
const endpoint = items[0].endpoint;
|
|
const range = endpoint.side === 'start' ? [0, fraction] : [1 - fraction, 1];
|
|
const reserve = { nodeId: String(nodeId), roadId: segmentId, fromStation: range[0], toStation: range[1] };
|
|
reserves.push(reserve);
|
|
if (!approaches.has(nodeId)) approaches.set(nodeId, []);
|
|
approaches.get(nodeId).push({ nodeId: String(nodeId), segmentId, items, cutback, length, endpoint, range });
|
|
}
|
|
}
|
|
return { reserves, approaches };
|
|
}
|
|
|
|
function snapshotCandidates(model, constraint) {
|
|
const snapshot = constraint.anchorSnapshot;
|
|
if (!snapshot || !Array.isArray(snapshot.coordinate)) return [];
|
|
const roads = (model.roads || []).filter((road) => {
|
|
if (!road.centerline?.length) return false;
|
|
const nodeMatch = snapshot.osmNodeIds?.some((id) => road.sourceNodeIds?.includes(String(id)));
|
|
const nearest = road.centerline.reduce(
|
|
(best, point) => Math.min(best, haversineMeters(snapshot.coordinate, point)),
|
|
Infinity,
|
|
);
|
|
return nodeMatch && nearest <= 50;
|
|
});
|
|
return roads;
|
|
}
|
|
|
|
function roadForLaneAnchor(model, laneAnchorId) {
|
|
if (typeof laneAnchorId !== 'string') return null;
|
|
for (const road of model.roads || []) {
|
|
const count = Number(road.laneCount) || 0;
|
|
for (let index = 1; index <= count; index += 1) if (laneId(road.id, index) === laneAnchorId) return road;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function reconcileConstraints(model, constraints, base, junctionData, context) {
|
|
const clusterItems = clusterCarriageways(
|
|
model,
|
|
junctionData,
|
|
context.junctionTemplates?.clusters || context.junctionClusters || [],
|
|
);
|
|
const clusterCorners = new Map(
|
|
[...clusterItems].map(([clusterId, items]) => [
|
|
clusterId,
|
|
new Map(
|
|
clusterArms(clusterId, items).map((arm, index, arms) => [
|
|
`corner:${arm.key}>${arms[(index + 1) % arms.length].key}`,
|
|
[arm.representative.key, arms[(index + 1) % arms.length].representative.key],
|
|
]),
|
|
),
|
|
]),
|
|
);
|
|
const versionChanged = Boolean(
|
|
context.compilerGeometryVersion &&
|
|
base?.compilerGeometryVersion &&
|
|
context.compilerGeometryVersion !== base.compilerGeometryVersion,
|
|
);
|
|
return constraints.map((constraint) => {
|
|
if (!constraint.enabled || !constraint.anchor || !['exact', 'recheck'].includes(constraint.status))
|
|
return constraint;
|
|
let matched = false;
|
|
if (constraint.kind === 'lane-maneuver') {
|
|
if (!roadForLaneAnchor(model, constraint.anchor.laneId))
|
|
return { ...constraint, status: 'stale', replayReason: 'anchor-missing' };
|
|
if (versionChanged) return { ...constraint, status: 'recheck' };
|
|
return constraint;
|
|
}
|
|
if (constraint.kind === 'cluster-carriageway-width') {
|
|
const item = clusterItems
|
|
.get(String(constraint.anchor.clusterId))
|
|
?.find((candidate) => candidate.key === constraint.anchor.carriagewayKey);
|
|
const sourcesMatch =
|
|
item &&
|
|
JSON.stringify(item.sourceNodeIds) ===
|
|
JSON.stringify([...constraint.anchor.sourceNodeIds].map(String).sort()) &&
|
|
JSON.stringify(item.sourceRoadIds) === JSON.stringify([...constraint.anchor.sourceRoadIds].map(String).sort());
|
|
if (!sourcesMatch) return { ...constraint, status: 'stale', replayReason: 'anchor-missing' };
|
|
if (versionChanged) return { ...constraint, status: 'recheck' };
|
|
return constraint;
|
|
}
|
|
if (constraint.kind === 'cluster-carriageway-cutback') {
|
|
const item = clusterItems
|
|
.get(String(constraint.anchor.clusterId))
|
|
?.find((candidate) => candidate.key === constraint.anchor.carriagewayKey);
|
|
if (!item) return { ...constraint, status: 'stale', replayReason: 'anchor-missing' };
|
|
if (versionChanged) return { ...constraint, status: 'recheck' };
|
|
return constraint;
|
|
}
|
|
if (constraint.kind === 'cluster-corner-radius') {
|
|
const expected = clusterCorners.get(String(constraint.anchor.clusterId))?.get(constraint.anchor.cornerKey);
|
|
const supplied = [...constraint.anchor.carriagewayKeys].sort();
|
|
if (!expected || JSON.stringify([...expected].sort()) !== JSON.stringify(supplied))
|
|
return { ...constraint, status: 'stale', replayReason: 'anchor-missing' };
|
|
if (versionChanged) return { ...constraint, status: 'recheck' };
|
|
return constraint;
|
|
}
|
|
if (constraint.kind === 'cluster-crossing-inset' || constraint.kind === 'cluster-stop-line-offset') {
|
|
const arm = clusterArms(
|
|
String(constraint.anchor.clusterId),
|
|
clusterItems.get(String(constraint.anchor.clusterId)) || [],
|
|
).find((candidate) => `crossing:${candidate.key}` === constraint.anchor.crossingKey);
|
|
if (!arm) return { ...constraint, status: 'stale', replayReason: 'anchor-missing' };
|
|
if (versionChanged) return { ...constraint, status: 'recheck' };
|
|
return constraint;
|
|
}
|
|
if (constraint.kind.startsWith('road-')) {
|
|
const road = roadForAnchor(model, constraint.anchor.roadId);
|
|
matched = Boolean(road);
|
|
const roadExists = matched;
|
|
if (matched && constraint.kind === 'road-lane-divider')
|
|
matched = Number.isInteger(constraint.value?.boundaryIndex) && constraint.value.boundaryIndex < road.laneCount;
|
|
if (!matched) {
|
|
const candidates = snapshotCandidates(model, constraint);
|
|
if (candidates.length === 1) return { ...constraint, status: 'pending' };
|
|
return {
|
|
...constraint,
|
|
status: candidates.length > 1 ? 'conflicted' : 'stale',
|
|
...(candidates.length || !roadExists
|
|
? { replayReason: candidates.length ? undefined : 'anchor-missing' }
|
|
: {}),
|
|
};
|
|
}
|
|
} else if (constraint.kind === 'junction-corner-radius') {
|
|
const approaches = junctionData.approaches.get(String(constraint.anchor.nodeId));
|
|
matched = Boolean(
|
|
approaches?.some((item) => item.segmentId === constraint.anchor.incomingRoadId) &&
|
|
approaches?.some((item) => item.segmentId === constraint.anchor.outgoingRoadId),
|
|
);
|
|
} else {
|
|
matched = Boolean(
|
|
junctionData.approaches
|
|
.get(String(constraint.anchor.nodeId))
|
|
?.some((item) => item.segmentId === constraint.anchor.segmentId),
|
|
);
|
|
}
|
|
if (!matched) return { ...constraint, status: 'stale', replayReason: 'anchor-missing' };
|
|
if ((versionChanged || context.replay) && constraint.kind === 'road-edge-offset') {
|
|
const value = Number(constraint.value?.offsetMeters);
|
|
const sides = constraint.anchor.side ? [constraint.anchor.side] : ['left', 'right'];
|
|
if (sides.some((side) => !inRange(value, roadEdgeOffsetRange(model, { ...constraint.anchor, side }, null))))
|
|
return { ...constraint, status: 'stale', replayReason: 'range-out-of-bounds' };
|
|
}
|
|
if (versionChanged) return { ...constraint, status: 'recheck' };
|
|
return constraint;
|
|
});
|
|
}
|
|
|
|
function roadForAnchor(model, roadId) {
|
|
return (model.roads || []).find(
|
|
(road) => road.id === roadId || road.sourceRoadId === roadId || road.segmentId === roadId,
|
|
);
|
|
}
|
|
|
|
function inRange(value, range) {
|
|
return Boolean(range && Number.isFinite(value) && value >= range.min && value <= range.max);
|
|
}
|
|
|
|
// This is the authoritative range for both the published edge handle and the
|
|
// solver. A segment can contain two directional roads, but an edge constraint
|
|
// applies to exactly one `roadId`; using the segment total here was the source
|
|
// of the previously advertised-but-invalid drag range.
|
|
function roadEdgeOffsetRange(model, anchor, profile) {
|
|
const road = roadForAnchor(model, anchor?.roadId);
|
|
const side = anchor?.side;
|
|
if (!road || !['left', 'right'].includes(side)) return null;
|
|
const otherSide = side === 'left' ? 'right' : 'left';
|
|
const otherOffset = Number(profile?.edgeOffsets?.[otherSide]) || 0;
|
|
const width = Number(road.widthMeters);
|
|
const minimumWidth = Number(road.laneCount) * MIN_LANE_WIDTH_METERS;
|
|
if (!Number.isFinite(width) || !Number.isFinite(minimumWidth)) return null;
|
|
return {
|
|
min: Math.max(-width / 2, minimumWidth - width - otherOffset),
|
|
max: width / 2,
|
|
};
|
|
}
|
|
|
|
function blocking(diagnostics, constraint, rule, message, coordinate = null) {
|
|
diagnostics.push(diagnostic('error', `constraint:${constraint.id}`, [], rule, message, coordinate));
|
|
}
|
|
|
|
function profileFor(profiles, road) {
|
|
if (!profiles.has(road.id))
|
|
profiles.set(road.id, {
|
|
roadId: road.id,
|
|
segmentId: road.segmentId,
|
|
interval: null,
|
|
edgeOffsets: { left: 0, right: 0 },
|
|
sidewalkWidths: {
|
|
left: road.sidewalkLeft ? 2 : 0,
|
|
right: road.sidewalkRight ? 2 : 0,
|
|
},
|
|
laneDividerOffsets: {},
|
|
transitions: {},
|
|
widthMeters: road.widthMeters,
|
|
});
|
|
return profiles.get(road.id);
|
|
}
|
|
|
|
function applyRoadConstraint(model, constraint, profiles, diagnostics) {
|
|
const road = roadForAnchor(model, constraint.anchor?.roadId);
|
|
if (!road) {
|
|
blocking(diagnostics, constraint, 'direct-edit-road-anchor-missing', '直接编辑约束的道路锚点不存在。');
|
|
return false;
|
|
}
|
|
const anchor = constraint.anchor;
|
|
if (
|
|
anchor.type !== 'road-interval' ||
|
|
!Number.isFinite(anchor.startStation) ||
|
|
!Number.isFinite(anchor.endStation) ||
|
|
anchor.startStation < 0 ||
|
|
anchor.endStation > 1 ||
|
|
anchor.startStation >= anchor.endStation
|
|
) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-invalid-interval',
|
|
'道路编辑区间必须按 0..1 的归一化 station 严格递增。',
|
|
road.centerline?.[0],
|
|
);
|
|
return false;
|
|
}
|
|
const profile = profileFor(profiles, road);
|
|
profile.interval = profile.interval
|
|
? {
|
|
startStation: Math.min(profile.interval.startStation, anchor.startStation),
|
|
endStation: Math.max(profile.interval.endStation, anchor.endStation),
|
|
}
|
|
: { startStation: anchor.startStation, endStation: anchor.endStation };
|
|
const sides = anchor.side ? [anchor.side] : ['left', 'right'];
|
|
if (sides.some((side) => !['left', 'right'].includes(side))) {
|
|
blocking(diagnostics, constraint, 'direct-edit-invalid-side', '道路约束 side 必须是 left 或 right。');
|
|
return false;
|
|
}
|
|
if (constraint.kind === 'road-edge-offset') {
|
|
const offset = Number(constraint.value?.offsetMeters);
|
|
const ranges = sides.map((side) => roadEdgeOffsetRange(model, { ...anchor, side }, profile));
|
|
if (ranges.some((range) => !inRange(offset, range))) {
|
|
const range = ranges.find((item) => item && !inRange(offset, item)) || ranges[0];
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-edge-offset-out-of-range',
|
|
`外缘偏移必须在 ${range ? `${range.min} 到 ${range.max}` : '当前道路可用范围'} 米之间。`,
|
|
);
|
|
return false;
|
|
}
|
|
for (const side of sides) {
|
|
profile.edgeOffsets[side] = offset;
|
|
profile.transitions[`road-edge-offset:${side}`] = constraint.value?.transition || 'smoothstep';
|
|
}
|
|
} else if (constraint.kind === 'road-sidewalk-width') {
|
|
const width = Number(constraint.value?.widthMeters);
|
|
if (!Number.isFinite(width) || width < 0) {
|
|
blocking(diagnostics, constraint, 'direct-edit-invalid-value', '步行带宽度必须是非负米数。');
|
|
return false;
|
|
}
|
|
for (const side of sides) {
|
|
profile.sidewalkWidths[side] = width;
|
|
profile.transitions[`road-sidewalk-width:${side}`] = constraint.value?.transition || 'smoothstep';
|
|
}
|
|
} else if (constraint.kind === 'road-lane-divider') {
|
|
const boundaryIndex = constraint.value?.boundaryIndex;
|
|
const offset = Number(constraint.value?.offsetMeters);
|
|
if (!Number.isInteger(boundaryIndex) || boundaryIndex < 1 || boundaryIndex >= road.laneCount) {
|
|
blocking(diagnostics, constraint, 'direct-edit-lane-boundary-stale', '车道分隔 boundaryIndex 已超出当前车道数。');
|
|
return false;
|
|
}
|
|
if (!Number.isFinite(offset)) {
|
|
blocking(diagnostics, constraint, 'direct-edit-invalid-value', '车道分隔偏移必须是有限米数。');
|
|
return false;
|
|
}
|
|
const laneWidth = road.widthMeters / road.laneCount;
|
|
if (laneWidth - Math.abs(offset) < 2.4) {
|
|
blocking(diagnostics, constraint, 'direct-edit-min-lane-width', '车道分隔调整会使相邻车道小于 2.4 米。');
|
|
return false;
|
|
}
|
|
profile.laneDividerOffsets[boundaryIndex] = offset;
|
|
profile.transitions[`road-lane-divider:${boundaryIndex}`] = constraint.value?.transition || 'smoothstep';
|
|
}
|
|
profile.widthMeters = road.widthMeters + profile.edgeOffsets.left + profile.edgeOffsets.right;
|
|
if (
|
|
Math.abs(profile.edgeOffsets.left) > road.widthMeters / 2 ||
|
|
Math.abs(profile.edgeOffsets.right) > road.widthMeters / 2 ||
|
|
profile.widthMeters < road.laneCount * 2.4
|
|
) {
|
|
blocking(diagnostics, constraint, 'direct-edit-outer-edges-cross', '左右外缘调整后无法容纳最小车道宽度。');
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function applyJunctionConstraint(model, constraint, junctionPlans, junctionData, diagnostics, crossingControls) {
|
|
const anchor = constraint.anchor || {};
|
|
if (anchor.type === 'junction-crossing') {
|
|
const crossing = (model.crossings || []).find((item) => String(item.id) === String(anchor.crossingId));
|
|
const road = (model.roads || []).find((item) => item.id === anchor.roadId);
|
|
const approach = crossing && road ? approachForCrossing(model, crossing) : null;
|
|
if (
|
|
!crossing ||
|
|
!road ||
|
|
!approach ||
|
|
approach.road.id !== road.id ||
|
|
String(road.segmentId) !== String(anchor.segmentId)
|
|
) {
|
|
blocking(diagnostics, constraint, 'direct-edit-crossing-anchor-missing', '直接编辑约束的控制元素锚点不存在。');
|
|
return false;
|
|
}
|
|
const value = Number(constraint.value?.insetMeters ?? constraint.value?.offsetMeters);
|
|
const valid =
|
|
constraint.kind === 'junction-crosswalk-inset'
|
|
? Number.isFinite(value) && value >= 0 && value <= MAX_CROSSWALK_INSET_METERS
|
|
: Number.isFinite(value) && value >= MIN_STOP_LINE_OFFSET_METERS && value <= approach.junctionDistanceMeters;
|
|
if (!valid) {
|
|
blocking(diagnostics, constraint, 'direct-edit-crossing-value-invalid', '控制线位置超出当前元素可用范围。');
|
|
return false;
|
|
}
|
|
// Keep the geometry value in a separate per-crossing map. Multiple crossings
|
|
// may share one approach, so storing this on the approach would couple them.
|
|
const crossingKey = String(anchor.crossingId);
|
|
const control = crossingControls.get(crossingKey) || {};
|
|
crossingControls.set(crossingKey, control);
|
|
if (constraint.kind === 'junction-crosswalk-inset') control.crosswalkInsetMeters = value;
|
|
else control.stopLineOffsetMeters = value;
|
|
return true;
|
|
}
|
|
const approaches = junctionData.approaches.get(String(anchor.nodeId));
|
|
const approach = approaches?.find((item) => item.segmentId === anchor.segmentId);
|
|
if (constraint.kind !== 'junction-corner-radius' && !approach) {
|
|
blocking(diagnostics, constraint, 'direct-edit-junction-anchor-missing', '直接编辑约束的路口进口锚点不存在。');
|
|
return false;
|
|
}
|
|
if (constraint.kind === 'junction-corner-radius') {
|
|
const incoming = approaches?.find((item) => item.segmentId === anchor.incomingRoadId);
|
|
const outgoing = approaches?.find((item) => item.segmentId === anchor.outgoingRoadId);
|
|
const radius = Number(constraint.value?.radiusMeters);
|
|
if (!incoming || !outgoing) {
|
|
blocking(diagnostics, constraint, 'direct-edit-junction-corner-missing', '直接编辑约束的路口角部锚点不存在。');
|
|
return false;
|
|
}
|
|
if (!Number.isFinite(radius) || radius < 0.5 || radius > 30) {
|
|
blocking(diagnostics, constraint, 'direct-edit-corner-radius-invalid', '路口角部半径必须在 0.5 到 30 米之间。');
|
|
return false;
|
|
}
|
|
if (!junctionPlans.has(String(anchor.nodeId)))
|
|
junctionPlans.set(String(anchor.nodeId), { nodeId: String(anchor.nodeId), approaches: {}, corners: {} });
|
|
const plan = junctionPlans.get(String(anchor.nodeId));
|
|
plan.corners[`${anchor.incomingRoadId}->${anchor.outgoingRoadId}`] = radius;
|
|
return true;
|
|
}
|
|
if (!junctionPlans.has(String(anchor.nodeId)))
|
|
junctionPlans.set(String(anchor.nodeId), { nodeId: String(anchor.nodeId), approaches: {}, corners: {} });
|
|
const plan = junctionPlans.get(String(anchor.nodeId));
|
|
const entry = (plan.approaches[anchor.segmentId] ||= {
|
|
widthMeters: approach.items.reduce((sum, item) => sum + item.road.widthMeters, 0),
|
|
cutbackMeters: approach.cutback,
|
|
});
|
|
// An explicit branch per kind: the previous `else` meant every kind that was not
|
|
// approach-width fell through to the cutback validator, so a new kind would have
|
|
// been silently validated as, and written as, a cutback.
|
|
switch (constraint.kind) {
|
|
case 'junction-approach-width': {
|
|
const width = Number(constraint.value?.widthMeters);
|
|
if (!Number.isFinite(width) || width < MIN_LANE_WIDTH_METERS) {
|
|
blocking(diagnostics, constraint, 'direct-edit-min-approach-width', '路口进口宽度不能小于 2.4 米。');
|
|
return false;
|
|
}
|
|
entry.widthMeters = width;
|
|
return true;
|
|
}
|
|
case 'junction-cutback': {
|
|
const cutback = Number(constraint.value?.cutbackMeters);
|
|
if (!Number.isFinite(cutback) || cutback < 1 || cutback > approach.length * 0.45) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-cutback-invalid',
|
|
'路口 cutback 必须落在进口可用长度的 45% 以内。',
|
|
);
|
|
return false;
|
|
}
|
|
entry.cutbackMeters = cutback;
|
|
return true;
|
|
}
|
|
case 'junction-crosswalk-inset': {
|
|
const inset = Number(constraint.value?.insetMeters);
|
|
if (!Number.isFinite(inset) || inset < 0 || inset > MAX_CROSSWALK_INSET_METERS) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-crosswalk-inset-invalid',
|
|
`斑马线内缩必须在 0 到 ${MAX_CROSSWALK_INSET_METERS} 米之间。`,
|
|
);
|
|
return false;
|
|
}
|
|
entry.crosswalkInsetMeters = inset;
|
|
return true;
|
|
}
|
|
case 'junction-crosswalk-size': {
|
|
const depth = Number(constraint.value?.depthMeters);
|
|
const stripeCount = constraint.value?.stripeCount;
|
|
if (!Number.isFinite(depth) || depth < MIN_CROSSWALK_DEPTH_METERS || depth > MAX_CROSSWALK_DEPTH_METERS) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-crosswalk-depth-invalid',
|
|
`斑马线进深必须在 ${MIN_CROSSWALK_DEPTH_METERS} 到 ${MAX_CROSSWALK_DEPTH_METERS} 米之间。`,
|
|
);
|
|
return false;
|
|
}
|
|
if (
|
|
!Number.isInteger(stripeCount) ||
|
|
stripeCount < MIN_CROSSWALK_STRIPE_COUNT ||
|
|
stripeCount > MAX_CROSSWALK_STRIPE_COUNT
|
|
) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-crosswalk-stripes-invalid',
|
|
`斑马线条带数必须是 ${MIN_CROSSWALK_STRIPE_COUNT} 到 ${MAX_CROSSWALK_STRIPE_COUNT} 之间的整数。`,
|
|
);
|
|
return false;
|
|
}
|
|
entry.crosswalkDepthMeters = depth;
|
|
entry.crosswalkStripeCount = stripeCount;
|
|
return true;
|
|
}
|
|
case 'junction-stop-line-offset': {
|
|
const offset = Number(constraint.value?.offsetMeters);
|
|
if (!Number.isFinite(offset) || offset < MIN_STOP_LINE_OFFSET_METERS || offset > approach.length * 0.45) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-stop-line-offset-invalid',
|
|
`停止线退距必须在 ${MIN_STOP_LINE_OFFSET_METERS} 米到进口可用长度的 45% 之间。`,
|
|
);
|
|
return false;
|
|
}
|
|
entry.stopLineOffsetMeters = offset;
|
|
return true;
|
|
}
|
|
default:
|
|
blocking(diagnostics, constraint, 'direct-edit-unknown-junction-kind', '未知的路口约束类型。');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function solveConstraints(model, constraints, junctionData, diagnostics, clusters = []) {
|
|
const roadProfiles = new Map();
|
|
const junctionPlans = new Map();
|
|
const laneManeuvers = new Map();
|
|
const crossingControls = new Map();
|
|
const clusterPlans = new Map();
|
|
const clusterCutbacks = new Map();
|
|
const clusterCorners = new Map();
|
|
const clusterCrossings = new Map();
|
|
const clusterItems = clusterCarriageways(model, junctionData, clusters);
|
|
const states = [];
|
|
for (const constraint of constraints) {
|
|
if (!constraint.enabled) {
|
|
states.push(constraintState(constraint, false, 'disabled'));
|
|
continue;
|
|
}
|
|
if (!ACTIVE_STATUSES.has(constraint.status)) {
|
|
states.push(constraintState(constraint, false, `status-${constraint.status}`));
|
|
continue;
|
|
}
|
|
if (!SOLVED_KINDS.has(constraint.kind)) {
|
|
states.push(constraintState(constraint, false, 'kind-not-solved'));
|
|
continue;
|
|
}
|
|
const roadSnapshot = new Map(
|
|
[...roadProfiles].map(([key, profile]) => [
|
|
key,
|
|
{
|
|
...profile,
|
|
edgeOffsets: { ...profile.edgeOffsets },
|
|
sidewalkWidths: { ...profile.sidewalkWidths },
|
|
laneDividerOffsets: { ...profile.laneDividerOffsets },
|
|
transitions: { ...profile.transitions },
|
|
interval: profile.interval && { ...profile.interval },
|
|
},
|
|
]),
|
|
);
|
|
const laneSnapshot = new Map(laneManeuvers);
|
|
const crossingSnapshot = new Map([...crossingControls].map(([key, value]) => [key, { ...value }]));
|
|
const clusterSnapshot = new Map([...clusterPlans].map(([key, value]) => [key, new Map(value)]));
|
|
const cutbackSnapshot = new Map([...clusterCutbacks].map(([key, value]) => [key, new Map(value)]));
|
|
const cornerSnapshot = new Map([...clusterCorners].map(([key, value]) => [key, new Map(value)]));
|
|
const crossingClusterSnapshot = new Map([...clusterCrossings].map(([key, value]) => [key, new Map(value)]));
|
|
const junctionSnapshot = new Map(
|
|
[...junctionPlans].map(([key, plan]) => [
|
|
key,
|
|
{
|
|
...plan,
|
|
approaches: Object.fromEntries(Object.entries(plan.approaches).map(([id, entry]) => [id, { ...entry }])),
|
|
corners: { ...plan.corners },
|
|
},
|
|
]),
|
|
);
|
|
let applied;
|
|
if (constraint.kind === 'cluster-carriageway-width' || constraint.kind === 'cluster-carriageway-cutback') {
|
|
const item = clusterItems
|
|
.get(String(constraint.anchor?.clusterId))
|
|
?.find((candidate) => candidate.key === constraint.anchor?.carriagewayKey);
|
|
const value = Number(
|
|
constraint.kind === 'cluster-carriageway-width'
|
|
? constraint.value?.widthMeters
|
|
: constraint.value?.cutbackMeters,
|
|
);
|
|
const cluster = clusters.find((candidate) => String(candidate.id) === String(item?.clusterId));
|
|
const cutbackMax = cluster ? clusterCutbackMaximum(cluster, item?.approach.length || 0) : 0;
|
|
if (!item) {
|
|
blocking(diagnostics, constraint, 'direct-edit-cluster-carriageway-missing', '复杂路口车行道锚点不存在。');
|
|
applied = false;
|
|
} else if (
|
|
!Number.isFinite(value) ||
|
|
(constraint.kind === 'cluster-carriageway-width' &&
|
|
(value < Math.max(MIN_LANE_WIDTH_METERS, item.laneCount * MIN_LANE_WIDTH_METERS) ||
|
|
value > item.widthMeters * 2)) ||
|
|
(constraint.kind === 'cluster-carriageway-cutback' && (value < 1 || value > cutbackMax))
|
|
) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-cluster-carriageway-geometry-invalid',
|
|
'复杂路口车行道参数超出当前可用范围。',
|
|
);
|
|
applied = false;
|
|
} else {
|
|
const target = constraint.kind === 'cluster-carriageway-width' ? clusterPlans : clusterCutbacks;
|
|
if (!target.has(item.clusterId)) target.set(item.clusterId, new Map());
|
|
target.get(item.clusterId).set(item.key, value);
|
|
applied = true;
|
|
}
|
|
} else if (constraint.kind === 'cluster-corner-radius') {
|
|
const cluster = clusters.find((item) => String(item.id) === String(constraint.anchor?.clusterId));
|
|
const radius = Number(constraint.value?.radiusMeters);
|
|
const keys = constraint.anchor?.carriagewayKeys || [];
|
|
if (!cluster || !Number.isFinite(radius) || radius < 1 || radius > 25 || keys.length !== 2) {
|
|
blocking(diagnostics, constraint, 'direct-edit-cluster-corner-invalid', '复杂路口角部圆角超出当前可用范围。');
|
|
applied = false;
|
|
} else {
|
|
if (!clusterCorners.has(String(cluster.id))) clusterCorners.set(String(cluster.id), new Map());
|
|
clusterCorners.get(String(cluster.id)).set(String(constraint.anchor.cornerKey), radius);
|
|
applied = true;
|
|
}
|
|
} else if (constraint.kind === 'cluster-crossing-inset' || constraint.kind === 'cluster-stop-line-offset') {
|
|
const clusterId = String(constraint.anchor?.clusterId);
|
|
const arm = clusterArms(clusterId, clusterItems.get(clusterId) || []).find(
|
|
(candidate) => `crossing:${candidate.key}` === constraint.anchor?.crossingKey,
|
|
);
|
|
const value = Number(constraint.value?.insetMeters ?? constraint.value?.offsetMeters);
|
|
const min = constraint.kind === 'cluster-crossing-inset' ? 0 : MIN_STOP_LINE_OFFSET_METERS;
|
|
const max = constraint.kind === 'cluster-crossing-inset' ? MAX_CROSSWALK_INSET_METERS : 12;
|
|
if (!arm || !Number.isFinite(value) || value < min || value > max) {
|
|
blocking(
|
|
diagnostics,
|
|
constraint,
|
|
'direct-edit-cluster-crossing-invalid',
|
|
'复杂路口过街控制元素超出当前可用范围。',
|
|
);
|
|
applied = false;
|
|
} else {
|
|
if (!clusterCrossings.has(clusterId)) clusterCrossings.set(clusterId, new Map());
|
|
const control = clusterCrossings.get(clusterId).get(constraint.anchor.crossingKey) || {};
|
|
if (constraint.kind === 'cluster-crossing-inset') control.crosswalkInsetMeters = value;
|
|
else control.stopLineOffsetMeters = value;
|
|
clusterCrossings.get(clusterId).set(constraint.anchor.crossingKey, control);
|
|
applied = true;
|
|
}
|
|
} else if (constraint.kind === 'lane-maneuver') {
|
|
const laneId = constraint.anchor?.laneId;
|
|
const laneExists = Boolean(roadForLaneAnchor(model, laneId));
|
|
const maneuver = constraint.value?.maneuver;
|
|
const placement = constraint.value?.placementDistanceMeters;
|
|
if (!laneExists) {
|
|
blocking(diagnostics, constraint, 'direct-edit-lane-anchor-missing', '导向箭头车道锚点不存在。');
|
|
applied = false;
|
|
} else if (!SUPPORTED_MANEUVERS.has(maneuver)) {
|
|
blocking(diagnostics, constraint, 'direct-edit-lane-maneuver-invalid', '导向箭头 maneuver 不受支持。');
|
|
applied = false;
|
|
} else if (placement !== undefined && (!Number.isFinite(placement) || placement < 0)) {
|
|
blocking(diagnostics, constraint, 'direct-edit-lane-placement-invalid', '导向箭头位置必须是非负米数。');
|
|
applied = false;
|
|
} else {
|
|
laneManeuvers.set(laneId, {
|
|
maneuver,
|
|
...(placement === undefined ? {} : { placementDistanceMeters: placement }),
|
|
});
|
|
applied = true;
|
|
}
|
|
} else {
|
|
applied = constraint.kind.startsWith('road-')
|
|
? applyRoadConstraint(model, constraint, roadProfiles, diagnostics)
|
|
: applyJunctionConstraint(model, constraint, junctionPlans, junctionData, diagnostics, crossingControls);
|
|
}
|
|
if (!applied) {
|
|
roadProfiles.clear();
|
|
for (const [key, profile] of roadSnapshot) roadProfiles.set(key, profile);
|
|
junctionPlans.clear();
|
|
for (const [key, plan] of junctionSnapshot) junctionPlans.set(key, plan);
|
|
laneManeuvers.clear();
|
|
for (const [key, value] of laneSnapshot) laneManeuvers.set(key, value);
|
|
crossingControls.clear();
|
|
for (const [key, value] of crossingSnapshot) crossingControls.set(key, value);
|
|
clusterPlans.clear();
|
|
for (const [key, value] of clusterSnapshot) clusterPlans.set(key, value);
|
|
clusterCutbacks.clear();
|
|
for (const [key, value] of cutbackSnapshot) clusterCutbacks.set(key, value);
|
|
clusterCorners.clear();
|
|
for (const [key, value] of cornerSnapshot) clusterCorners.set(key, value);
|
|
clusterCrossings.clear();
|
|
for (const [key, value] of crossingClusterSnapshot) clusterCrossings.set(key, value);
|
|
}
|
|
states.push(constraintState(constraint, applied, applied ? null : 'invalid'));
|
|
}
|
|
return {
|
|
roadProfiles,
|
|
junctionPlans,
|
|
laneManeuvers,
|
|
crossingControls,
|
|
clusterPlans,
|
|
clusterCutbacks,
|
|
clusterCorners,
|
|
clusterCrossings,
|
|
states,
|
|
};
|
|
}
|
|
|
|
function roadAffects(roads, model, side, boundaryIndex) {
|
|
const ids = [];
|
|
for (const road of roads) {
|
|
ids.push(roadSurfaceId(road), centerLineId(road.segmentId));
|
|
ids.push(edgeLineId(road.id, side || 'left'), edgeLineId(road.id, side || 'right'));
|
|
if (side) ids.push(sidewalkId(road, side));
|
|
for (let index = 1; index <= road.laneCount; index += 1) ids.push(laneId(road.id, index));
|
|
if (boundaryIndex) ids.push(laneSeparatorId(road.id, boundaryIndex));
|
|
}
|
|
const roadIds = new Set(roads.map((road) => road.id));
|
|
const endpointRoads = new Map((model.endpoints || []).map((endpoint) => [endpoint.id, endpoint.roadId]));
|
|
for (const connection of model.connections || []) {
|
|
const from = endpointRoads.get(connection.fromEndpointId);
|
|
const to = endpointRoads.get(connection.toEndpointId);
|
|
if (!roadIds.has(from) && !roadIds.has(to)) continue;
|
|
const fromRoad = (model.roads || []).find((road) => road.id === from);
|
|
const toRoad = (model.roads || []).find((road) => road.id === to);
|
|
for (let fromIndex = 1; fromIndex <= (fromRoad?.laneCount || 0); fromIndex += 1)
|
|
for (let toIndex = 1; toIndex <= (toRoad?.laneCount || 0); toIndex += 1)
|
|
ids.push(`${connectionConnectorId(connection.id)}:${laneId(from, fromIndex)}->${laneId(to, toIndex)}`);
|
|
}
|
|
return [...new Set(ids)];
|
|
}
|
|
|
|
function makeRoadHandles(model, groups, reserves, constraints, roadProfiles) {
|
|
const handles = [];
|
|
for (const [segmentId, roads] of groups) {
|
|
const road = roads.find((item) => item.direction === 'forward') || roads[0];
|
|
const length = polylineLength(road.centerline);
|
|
if (!Number.isFinite(length) || length <= 0) continue;
|
|
const segmentReserves = reserves.filter((item) => item.roadId === segmentId);
|
|
const startReserve = Math.max(0, ...segmentReserves.map((item) => item.toStation * (item.fromStation === 0)));
|
|
const endReserve = Math.max(0, ...segmentReserves.map((item) => (item.fromStation > 0 ? 1 - item.fromStation : 0)));
|
|
const start = Math.min(1, startReserve);
|
|
const end = Math.max(0, 1 - endReserve);
|
|
const station = start < end ? (start + end) / 2 : 0.5;
|
|
const unavailable = start >= end;
|
|
const width = roads.reduce((sum, item) => sum + (Number(item.widthMeters) || 0), 0);
|
|
const laneCount = roads.reduce((sum, item) => sum + (Number(item.laneCount) || 0), 0);
|
|
// `junctionReserves()` caps each end's reserve at 0.45, so `unavailable`
|
|
// alone can never fire — it would need start >= end, i.e. 0.45 >= 0.55. On a
|
|
// road the junctions geometrically fill, that cap invents an editable band in
|
|
// the middle (1.5 m on a 14.5 m road) with no room for the smoothstep
|
|
// transitions a road-interval constraint needs at both ends.
|
|
//
|
|
// Compare in meters rather than stations: a transition needs real distance,
|
|
// and a band shorter than the road is wide cannot carry a cross-section
|
|
// change. This only marks handles read-only; existing constraints on such a
|
|
// road keep being solved, so a compiler upgrade never silently drops a saved
|
|
// edit and the geometry output is unchanged.
|
|
const bandMeters = Math.max(0, end - start) * length;
|
|
const junctionDominated = bandMeters < width;
|
|
const point = coordinateAt(road.centerline, station);
|
|
const tangent = tangentAzimuth(road.centerline, station);
|
|
const normal = (tangent + 90) % 360;
|
|
const interval = { type: 'road-interval', roadId: road.id, startStation: start, endStation: end };
|
|
const baseDisabled =
|
|
unavailable || junctionDominated ? '该道路全部位于路口保留区,请进入 JunctionTools 编辑。' : undefined;
|
|
const add = (kind, anchor, value, min, max, axis, position, affects, constraint) => {
|
|
const disabledReason = baseDisabled;
|
|
handles.push({
|
|
handleId: `handle:${kind}:${segmentId}:${anchor.side || anchor.boundaryIndex || 'main'}`,
|
|
kind,
|
|
anchor,
|
|
position,
|
|
axisAzimuth: ((axis % 360) + 360) % 360,
|
|
value: { current: value, min, max, unit: 'meter' },
|
|
...(constraint ? { constraintId: constraint.id } : {}),
|
|
affects,
|
|
editable: !disabledReason,
|
|
...(disabledReason ? { disabledReason } : {}),
|
|
});
|
|
};
|
|
for (const side of ['left', 'right']) {
|
|
// Left is `tangent - 90`, matching the geometry compiler: `offsetLine()`
|
|
// shifts a positive offset counter-clockwise from the direction of travel,
|
|
// and sidewalks use `heading + (side === 'left' ? -90 : 90)`. Placing the
|
|
// left handle at `tangent + 90` drew it over the right kerb, so dragging the
|
|
// visually-left handle moved the right edge.
|
|
const sideSign = side === 'left' ? -1 : 1;
|
|
const edgeAnchor = { ...interval, side };
|
|
const edgeConstraint = constraintFor(constraints, 'road-edge-offset', edgeAnchor);
|
|
const edgeRange = roadEdgeOffsetRange(model, edgeAnchor, roadProfiles.get(road.id));
|
|
add(
|
|
'road-edge-offset',
|
|
edgeAnchor,
|
|
numericValue(edgeConstraint, 'offsetMeters', 0),
|
|
edgeRange.min,
|
|
edgeRange.max,
|
|
normal,
|
|
offsetCoordinate(point, tangent + sideSign * 90, width / 2),
|
|
roadAffects(roads, model, side),
|
|
edgeConstraint,
|
|
);
|
|
const sidewalkConstraint = constraintFor(constraints, 'road-sidewalk-width', edgeAnchor);
|
|
const enabled = side === 'left' ? Boolean(road.sidewalkLeft) : Boolean(road.sidewalkRight);
|
|
add(
|
|
'road-sidewalk-width',
|
|
edgeAnchor,
|
|
numericValue(sidewalkConstraint, 'widthMeters', enabled ? 2 : 0),
|
|
0,
|
|
8,
|
|
normal,
|
|
offsetCoordinate(point, tangent + sideSign * 90, width / 2 + (enabled ? 1 : 0)),
|
|
roadAffects(roads, model, side),
|
|
sidewalkConstraint,
|
|
);
|
|
}
|
|
for (let boundaryIndex = 1; boundaryIndex < laneCount; boundaryIndex += 1) {
|
|
const anchor = { ...interval };
|
|
const constraint = constraintFor(constraints, 'road-lane-divider', { ...anchor, boundaryIndex });
|
|
const laneWidth = laneCount ? width / laneCount : MIN_LANE_WIDTH_METERS;
|
|
const lateral = -width / 2 + laneWidth * boundaryIndex;
|
|
add(
|
|
'road-lane-divider',
|
|
{ ...anchor, boundaryIndex },
|
|
numericValue(constraint, 'offsetMeters', 0),
|
|
-Math.max(0.1, laneWidth - MIN_LANE_WIDTH_METERS),
|
|
Math.max(0.1, laneWidth - MIN_LANE_WIDTH_METERS),
|
|
normal,
|
|
offsetCoordinate(point, tangent + 90, lateral),
|
|
roadAffects(roads, model, null, boundaryIndex),
|
|
constraint,
|
|
);
|
|
}
|
|
}
|
|
return handles;
|
|
}
|
|
|
|
function makeLaneManeuverHandles(model, constraints) {
|
|
const handles = [];
|
|
for (const road of model.roads || []) {
|
|
const laneCount = Number(road.laneCount) || 0;
|
|
const length = polylineLength(road.centerline);
|
|
if (!(length > 0) || road.centerline.length < 2) continue;
|
|
for (let index = 1; index <= laneCount; index += 1) {
|
|
const laneAnchorId = laneId(road.id, index);
|
|
const constraint = constraints.find(
|
|
(item) => item.kind === 'lane-maneuver' && item.anchor?.type === 'lane' && item.anchor.laneId === laneAnchorId,
|
|
);
|
|
const value = constraint?.value || {};
|
|
const placement = Number.isFinite(value.placementDistanceMeters) ? value.placementDistanceMeters : 6;
|
|
const station = Math.max(0, Math.min(1, 1 - placement / length));
|
|
const position = coordinateAt(road.centerline, station);
|
|
const axis = tangentAzimuth(road.centerline, station);
|
|
handles.push({
|
|
handleId: `handle:lane-maneuver:${laneAnchorId}`,
|
|
kind: 'lane-maneuver',
|
|
anchor: { type: 'lane', laneId: laneAnchorId, roadId: road.id },
|
|
position,
|
|
axisAzimuth: axis,
|
|
value: { current: placement, min: 0, max: length, unit: 'meter' },
|
|
...(constraint ? { constraintId: constraint.id } : {}),
|
|
affects: [`turn-arrow:${laneAnchorId}`],
|
|
editable: true,
|
|
});
|
|
}
|
|
}
|
|
return handles;
|
|
}
|
|
|
|
function junctionAffects(model, nodeId, segmentIds) {
|
|
const roads = (model.roads || []).filter((road) => segmentIds.has(road.segmentId));
|
|
const ids = [junctionSurfaceId(nodeId), ...roadAffects(roads, model)];
|
|
const endpointRoads = new Map((model.endpoints || []).map((endpoint) => [endpoint.id, endpoint.roadId]));
|
|
for (const connection of model.connections || []) {
|
|
if (String(connection.nodeId) !== String(nodeId)) continue;
|
|
const from = (model.roads || []).find((road) => road.id === endpointRoads.get(connection.fromEndpointId));
|
|
const to = (model.roads || []).find((road) => road.id === endpointRoads.get(connection.toEndpointId));
|
|
for (let fromIndex = 1; fromIndex <= (from?.laneCount || 0); fromIndex += 1)
|
|
for (let toIndex = 1; toIndex <= (to?.laneCount || 0); toIndex += 1)
|
|
ids.push(`${connectionConnectorId(connection.id)}:${laneId(from.id, fromIndex)}->${laneId(to.id, toIndex)}`);
|
|
}
|
|
return [...new Set(ids)];
|
|
}
|
|
|
|
function makeJunctionHandles(model, junctionData, constraints) {
|
|
const handles = [];
|
|
const arrivals = arrivalEndpointIds(model || {});
|
|
for (const [nodeId, approaches] of junctionData.approaches) {
|
|
const segmentIds = new Set(approaches.map((item) => item.segmentId));
|
|
for (const approach of approaches) {
|
|
const road = approach.items[0].road;
|
|
const line = approach.endpoint.side === 'start' ? road.centerline : [...road.centerline].reverse();
|
|
const station = Math.min(0.95, Math.max(0.05, approach.cutback / approach.length));
|
|
const point = coordinateAt(line, station);
|
|
const tangent = tangentAzimuth(line, station);
|
|
const normal = (tangent + 90) % 360;
|
|
const anchor = { type: 'junction-approach', nodeId: String(nodeId), segmentId: approach.segmentId };
|
|
const affects = junctionAffects(model, nodeId, segmentIds);
|
|
// Control markings are positioned by their distance back from the junction,
|
|
// rather than at the approach cutback point shared by shape handles. Keeping
|
|
// these positions distinct is important: otherwise the later stop-line
|
|
// feature covers the crosswalk handle and neither target is discoverable.
|
|
const controlPoint = (offsetMeters, lateralMeters = 0) => {
|
|
const coordinate = coordinateAt(
|
|
line,
|
|
Math.min(0.98, Math.max(0.02, offsetMeters / Math.max(approach.length, 1))),
|
|
);
|
|
return lateralMeters ? offsetCoordinate(coordinate, normal, lateralMeters) : coordinate;
|
|
};
|
|
const add = (kind, value, min, max, axis, constraint, position = point) => {
|
|
handles.push({
|
|
handleId: `handle:${kind}:node/${nodeId}:${approach.segmentId}`,
|
|
kind,
|
|
anchor,
|
|
position,
|
|
axisAzimuth: ((axis % 360) + 360) % 360,
|
|
value: { current: value, min, max, unit: 'meter' },
|
|
...(constraint ? { constraintId: constraint.id } : {}),
|
|
affects,
|
|
editable: true,
|
|
});
|
|
};
|
|
const widthConstraint = constraintFor(constraints, 'junction-approach-width', anchor);
|
|
add(
|
|
'junction-approach-width',
|
|
numericValue(
|
|
widthConstraint,
|
|
'widthMeters',
|
|
approach.items.reduce((sum, item) => sum + item.road.widthMeters, 0),
|
|
),
|
|
MIN_LANE_WIDTH_METERS,
|
|
Math.max(8, approach.items.reduce((sum, item) => sum + item.road.widthMeters, 0) * 2),
|
|
normal,
|
|
widthConstraint,
|
|
);
|
|
const cutbackConstraint = constraintFor(constraints, 'junction-cutback', anchor);
|
|
add(
|
|
'junction-cutback',
|
|
numericValue(cutbackConstraint, 'cutbackMeters', approach.cutback),
|
|
1,
|
|
Math.max(1, approach.length * 0.45),
|
|
tangent,
|
|
cutbackConstraint,
|
|
);
|
|
// Synthetic models used by older resolver consumers may not carry crossing
|
|
// features. Keep their approach-level controls for compatibility; real
|
|
// models below always publish element-owned crossing handles.
|
|
if (!(model.crossings || []).length) {
|
|
const insetConstraint = constraintFor(constraints, 'junction-crosswalk-inset', anchor);
|
|
const insetValue = numericValue(insetConstraint, 'insetMeters', CROSSWALK_JUNCTION_INSET_METERS);
|
|
add(
|
|
'junction-crosswalk-inset',
|
|
insetValue,
|
|
0,
|
|
MAX_CROSSWALK_INSET_METERS,
|
|
(tangent + 180) % 360,
|
|
insetConstraint,
|
|
controlPoint(insetValue, -1),
|
|
);
|
|
const stopConstraint = constraintFor(constraints, 'junction-stop-line-offset', anchor);
|
|
const stopValue = numericValue(stopConstraint, 'offsetMeters', STOP_LINE_OFFSET_METERS);
|
|
add(
|
|
'junction-stop-line-offset',
|
|
stopValue,
|
|
MIN_STOP_LINE_OFFSET_METERS,
|
|
Math.max(MIN_STOP_LINE_OFFSET_METERS, approach.length * 0.45),
|
|
tangent,
|
|
stopConstraint,
|
|
controlPoint(stopValue, 1),
|
|
);
|
|
}
|
|
}
|
|
// Control-marking handles are element-owned. A single approach may serve
|
|
// multiple crossings, so each handle carries the crossing id as well as the
|
|
// road context needed to resolve its geometry.
|
|
for (const crossing of model.crossings || []) {
|
|
const match = approachForCrossing(model, crossing, arrivals);
|
|
if (!match || String(match.road.sourceNodeIds?.at(-1)) !== String(nodeId)) continue;
|
|
const approach = approaches.find((item) => item.segmentId === match.road.segmentId);
|
|
if (!approach) continue;
|
|
const road = match.road;
|
|
const line = approach.endpoint.side === 'start' ? road.centerline : [...road.centerline].reverse();
|
|
const tangent = tangentAzimuth(line, Math.min(0.95, approach.cutback / approach.length));
|
|
// `line` is oriented from the junction outward. Native control geometry
|
|
// follows the road centerline orientation, which is outward for a `start`
|
|
// endpoint and inward for an `end` endpoint. Derive this per approach;
|
|
// assuming every arm has the same endpoint side reverses half the handles.
|
|
const approachAzimuth = approach.endpoint.side === 'start' ? tangent : (tangent + 180) % 360;
|
|
const placementAzimuth = approachAzimuth;
|
|
const anchorBase = {
|
|
type: 'junction-crossing',
|
|
crossingId: String(crossing.id),
|
|
nodeId: String(nodeId),
|
|
segmentId: approach.segmentId,
|
|
roadId: road.id,
|
|
};
|
|
const controlPoint = (offsetMeters, lateralMeters = 0) => {
|
|
const point = coordinateAt(line, Math.min(0.98, Math.max(0.02, offsetMeters / Math.max(approach.length, 1))));
|
|
return lateralMeters ? offsetCoordinate(point, (tangent + 90) % 360, lateralMeters) : point;
|
|
};
|
|
const insetConstraint = constraintFor(constraints, 'junction-crosswalk-inset', anchorBase);
|
|
const insetValue = numericValue(insetConstraint, 'insetMeters', CROSSWALK_JUNCTION_INSET_METERS);
|
|
// The solver may saturate the inset at the junction boundary; the
|
|
// configured value is still the closest stable client-side knob position.
|
|
const insetApplied = insetValue;
|
|
const insetMax = Math.min(
|
|
MAX_CROSSWALK_INSET_METERS,
|
|
Math.max(insetValue, effectiveCrosswalkInsetMax(approach.cutback, match.junctionDistanceMeters) || insetValue),
|
|
);
|
|
handles.push({
|
|
handleId: `handle:junction-crosswalk-inset:crossing/${crossing.id}`,
|
|
kind: 'junction-crosswalk-inset',
|
|
anchor: anchorBase,
|
|
// Anchor the knob to the actual crossing feature. The inset is a value
|
|
// along the approach, not a reliable screen station from the junction;
|
|
// deriving the point from junction distance put the knob off the zebra.
|
|
position: offsetCoordinate(crossing.coordinate, placementAzimuth, insetApplied),
|
|
// Increasing inset moves the crossing toward the junction.
|
|
axisAzimuth: approachAzimuth,
|
|
value: { current: insetValue, min: 0, max: insetMax, unit: 'meter' },
|
|
...(insetConstraint ? { constraintId: insetConstraint.id } : {}),
|
|
affects: [`crosswalk:node/${crossing.id}`],
|
|
editable: true,
|
|
});
|
|
const stopConstraint = constraintFor(constraints, 'junction-stop-line-offset', anchorBase);
|
|
const stopValue = numericValue(stopConstraint, 'offsetMeters', STOP_LINE_OFFSET_METERS);
|
|
handles.push({
|
|
handleId: `handle:junction-stop-line-offset:crossing/${crossing.id}`,
|
|
kind: 'junction-stop-line-offset',
|
|
anchor: anchorBase,
|
|
// The stop line is measured back from the crossing, so its knob follows
|
|
// the rendered line while remaining independent of the road cutback.
|
|
position: offsetCoordinate(
|
|
offsetCoordinate(crossing.coordinate, placementAzimuth, insetApplied),
|
|
placementAzimuth,
|
|
-stopValue,
|
|
),
|
|
// The compiled stop line applies `-offset` along the approach axis, so
|
|
// Increasing the offset moves away from the junction, opposite to the
|
|
// approach axis used by the compiled stop-line geometry.
|
|
axisAzimuth: (approachAzimuth + 180) % 360,
|
|
value: {
|
|
current: stopValue,
|
|
min: MIN_STOP_LINE_OFFSET_METERS,
|
|
max: Math.max(MIN_STOP_LINE_OFFSET_METERS, approach.length * 0.45),
|
|
unit: 'meter',
|
|
},
|
|
...(stopConstraint ? { constraintId: stopConstraint.id } : {}),
|
|
affects: [`stop-line:node/${crossing.id}:1`],
|
|
editable: true,
|
|
});
|
|
}
|
|
const ordered = [...approaches].sort((a, b) => a.segmentId.localeCompare(b.segmentId));
|
|
for (let index = 0; index < ordered.length; index += 1) {
|
|
const incoming = ordered[index];
|
|
const outgoing = ordered[(index + 1) % ordered.length];
|
|
const anchor = {
|
|
type: 'junction-corner',
|
|
nodeId: String(nodeId),
|
|
incomingRoadId: incoming.segmentId,
|
|
outgoingRoadId: outgoing.segmentId,
|
|
};
|
|
const constraint = constraintFor(constraints, 'junction-corner-radius', anchor);
|
|
const first = coordinateAt(
|
|
incoming.endpoint.side === 'start'
|
|
? incoming.items[0].road.centerline
|
|
: [...incoming.items[0].road.centerline].reverse(),
|
|
Math.min(0.95, incoming.cutback / incoming.length),
|
|
);
|
|
const second = coordinateAt(
|
|
outgoing.endpoint.side === 'start'
|
|
? outgoing.items[0].road.centerline
|
|
: [...outgoing.items[0].road.centerline].reverse(),
|
|
Math.min(0.95, outgoing.cutback / outgoing.length),
|
|
);
|
|
const position = [((first?.[0] || 0) + (second?.[0] || 0)) / 2, ((first?.[1] || 0) + (second?.[1] || 0)) / 2];
|
|
handles.push({
|
|
handleId: `handle:junction-corner-radius:node/${nodeId}:${incoming.segmentId}->${outgoing.segmentId}`,
|
|
kind: 'junction-corner-radius',
|
|
anchor,
|
|
position,
|
|
axisAzimuth: tangentAzimuth(incoming.items[0].road.centerline, 0.05),
|
|
value: {
|
|
current: numericValue(
|
|
constraint,
|
|
'radiusMeters',
|
|
Math.max(1, Math.min(12, incoming.items[0].road.widthMeters)),
|
|
),
|
|
min: 0.5,
|
|
max: 30,
|
|
unit: 'meter',
|
|
},
|
|
...(constraint ? { constraintId: constraint.id } : {}),
|
|
affects: junctionAffects(model, nodeId, segmentIds),
|
|
editable: true,
|
|
});
|
|
}
|
|
}
|
|
return handles;
|
|
}
|
|
|
|
function makeClusterCarriagewayHandles(model, junctionData, constraints, clusters) {
|
|
const handles = [];
|
|
for (const [clusterId, items] of clusterCarriageways(model, junctionData, clusters)) {
|
|
const cluster = clusters.find((item) => String(item.id) === String(clusterId));
|
|
if (!cluster) continue;
|
|
for (const item of items) {
|
|
const road = item.roads[0];
|
|
const line = item.approach.endpoint.side === 'start' ? road.centerline : [...road.centerline].reverse();
|
|
const station = Math.min(0.95, Math.max(0.05, item.approach.cutback / Math.max(item.approach.length, 1)));
|
|
const point = coordinateAt(line, station);
|
|
const constraint = constraintFor(constraints, 'cluster-carriageway-width', {
|
|
clusterId,
|
|
carriagewayKey: item.key,
|
|
});
|
|
handles.push({
|
|
handleId: `handle:cluster-carriageway-width:${item.key}`,
|
|
kind: 'cluster-carriageway-width',
|
|
anchor: {
|
|
type: 'cluster-carriageway',
|
|
clusterId,
|
|
carriagewayKey: item.key,
|
|
sourceNodeIds: item.sourceNodeIds,
|
|
sourceRoadIds: item.sourceRoadIds,
|
|
},
|
|
position: point,
|
|
axisAzimuth: (tangentAzimuth(line, station) + 90) % 360,
|
|
value: {
|
|
current: numericValue(constraint, 'widthMeters', item.widthMeters),
|
|
min: Math.max(MIN_LANE_WIDTH_METERS, item.laneCount * MIN_LANE_WIDTH_METERS),
|
|
max: Math.max(item.widthMeters * 2, item.laneCount * MIN_LANE_WIDTH_METERS),
|
|
unit: 'meter',
|
|
},
|
|
...(constraint ? { constraintId: constraint.id } : {}),
|
|
affects: [`complex-junction:${clusterId}:carriageway:${item.approach.segmentId}`],
|
|
editable: true,
|
|
});
|
|
const cutbackConstraint = constraintFor(constraints, 'cluster-carriageway-cutback', {
|
|
clusterId,
|
|
carriagewayKey: item.key,
|
|
});
|
|
handles.push({
|
|
handleId: `handle:cluster-carriageway-cutback:${item.key}`,
|
|
kind: 'cluster-carriageway-cutback',
|
|
anchor: {
|
|
type: 'cluster-carriageway',
|
|
clusterId,
|
|
carriagewayKey: item.key,
|
|
sourceNodeIds: item.sourceNodeIds,
|
|
sourceRoadIds: item.sourceRoadIds,
|
|
},
|
|
position: coordinateAt(
|
|
line,
|
|
Math.min(0.95, Math.max(0.05, item.approach.cutback / Math.max(item.approach.length, 1))),
|
|
),
|
|
axisAzimuth: tangentAzimuth(line, 0.1),
|
|
value: {
|
|
current: numericValue(cutbackConstraint, 'cutbackMeters', item.approach.cutback),
|
|
min: 1,
|
|
max: clusterCutbackMaximum(cluster, item.approach.length),
|
|
unit: 'meter',
|
|
},
|
|
...(cutbackConstraint ? { constraintId: cutbackConstraint.id } : {}),
|
|
affects: [`complex-junction:${clusterId}:carriageway:${item.approach.segmentId}`],
|
|
editable: true,
|
|
});
|
|
}
|
|
}
|
|
return handles;
|
|
}
|
|
|
|
function makeClusterCornerHandles(model, junctionData, constraints, clusters) {
|
|
const handles = [];
|
|
for (const [clusterId, items] of clusterCarriageways(model, junctionData, clusters)) {
|
|
const arms = clusterArms(clusterId, items);
|
|
for (let index = 0; index < arms.length; index += 1) {
|
|
const first = arms[index];
|
|
const second = arms[(index + 1) % arms.length];
|
|
const cornerKey = `corner:${first.key}>${second.key}`;
|
|
const constraint = constraintFor(constraints, 'cluster-corner-radius', { clusterId, cornerKey });
|
|
const firstLine = clusterApproachLine(first.representative);
|
|
const secondLine = clusterApproachLine(second.representative);
|
|
const firstPoint = firstLine[0];
|
|
const secondPoint = secondLine[0];
|
|
handles.push({
|
|
handleId: `handle:cluster-corner-radius:${cornerKey}`,
|
|
kind: 'cluster-corner-radius',
|
|
anchor: {
|
|
type: 'cluster-corner',
|
|
clusterId,
|
|
cornerKey,
|
|
carriagewayKeys: [first.representative.key, second.representative.key],
|
|
},
|
|
position: [(firstPoint[0] + secondPoint[0]) / 2, (firstPoint[1] + secondPoint[1]) / 2],
|
|
axisAzimuth: first.heading,
|
|
value: { current: numericValue(constraint, 'radiusMeters', 12), min: 1, max: 25, unit: 'meter' },
|
|
...(constraint ? { constraintId: constraint.id } : {}),
|
|
affects: [`complex-junction:${clusterId}:corner:${cornerKey}`],
|
|
editable: true,
|
|
});
|
|
}
|
|
}
|
|
return handles;
|
|
}
|
|
|
|
function makeClusterCrossingHandles(model, junctionData, constraints, clusters) {
|
|
const handles = [];
|
|
const itemsByCluster = clusterCarriageways(model, junctionData, clusters);
|
|
for (const cluster of 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 item = arm.representative;
|
|
const line = clusterApproachLine(item);
|
|
const length = polylineLength(line);
|
|
if (length <= 0) continue;
|
|
const crossingKey = `crossing:${arm.key}`;
|
|
const anchor = {
|
|
type: 'cluster-crossing',
|
|
clusterId,
|
|
crossingKey,
|
|
carriagewayKeys: arm.members.map((member) => member.key).sort(),
|
|
};
|
|
// Complex crossing geometry is anchored to the core radius. Using the
|
|
// carriageway cutback here put the editor knob on a different station
|
|
// from the zebra it controls, especially for multi-node clusters.
|
|
const pointAt = (distance) =>
|
|
clusterArmRadiusPoint(arm, center, distance) ||
|
|
coordinateAt(line, Math.min(0.9, Math.max(0.05, distance / length)));
|
|
const baseCrosswalkDistance = clusterCrossingBaseRadius(
|
|
model,
|
|
arm,
|
|
center,
|
|
Math.max(2, complexJunctionMetrics(cluster).coreRadius * 0.68),
|
|
);
|
|
const insetConstraint = constraintFor(constraints, 'cluster-crossing-inset', anchor);
|
|
const inset = numericValue(insetConstraint, 'insetMeters', 0);
|
|
handles.push({
|
|
handleId: `handle:cluster-crossing-inset:${crossingKey}`,
|
|
kind: 'cluster-crossing-inset',
|
|
anchor,
|
|
position: pointAt(baseCrosswalkDistance + inset),
|
|
axisAzimuth: arm.heading,
|
|
value: { current: inset, min: 0, max: MAX_CROSSWALK_INSET_METERS, unit: 'meter' },
|
|
...(insetConstraint ? { constraintId: insetConstraint.id } : {}),
|
|
affects: [`complex-crosswalk:${clusterId}`],
|
|
editable: true,
|
|
});
|
|
const stopConstraint = constraintFor(constraints, 'cluster-stop-line-offset', anchor);
|
|
const offset = numericValue(stopConstraint, 'offsetMeters', 3);
|
|
handles.push({
|
|
handleId: `handle:cluster-stop-line-offset:${crossingKey}`,
|
|
kind: 'cluster-stop-line-offset',
|
|
anchor,
|
|
position: pointAt(baseCrosswalkDistance + inset + offset),
|
|
axisAzimuth: arm.heading,
|
|
value: { current: offset, min: MIN_STOP_LINE_OFFSET_METERS, max: 12, unit: 'meter' },
|
|
...(stopConstraint ? { constraintId: stopConstraint.id } : {}),
|
|
affects: [`complex-stop-line:${clusterId}`],
|
|
editable: true,
|
|
});
|
|
}
|
|
}
|
|
return handles;
|
|
}
|
|
|
|
/**
|
|
* Which handles a selection wants.
|
|
*
|
|
* Whole-manifest responses are expensive: on a 41-road area the handles are
|
|
* 844 KB, 89% of it the `affects` id lists (46 ids per junction handle), and the
|
|
* map renders about six of them. `selection` therefore scopes the manifest to the
|
|
* object being edited. Omitting it keeps the full manifest, which the compiler
|
|
* and the existing callers rely on.
|
|
*
|
|
* The two selection types match the two editors: the main map owns a road
|
|
* segment's cross-section, JunctionTools owns a node.
|
|
*/
|
|
function selectHandles(handles, model, selection) {
|
|
if (!selection || !selection.type) return handles;
|
|
if (selection.type === 'cluster')
|
|
return handles.filter(
|
|
(handle) => handle.anchor?.clusterId === String(selection.id) && handle.kind.startsWith('cluster-'),
|
|
);
|
|
if (selection.type === 'segment') {
|
|
const segmentOf = new Map((model.roads || []).map((road) => [road.id, road.segmentId]));
|
|
const wanted = String(selection.id);
|
|
return handles.filter((handle) => {
|
|
if (!handle.anchor) return false;
|
|
// Control markings are junction-anchored but edited from the main map, and
|
|
// they name their segment directly. Junction *shape* kinds stay out: those
|
|
// are JunctionTools', and the main map must not offer a second way in.
|
|
if (CONTROL_KINDS.has(handle.kind)) return handle.anchor.segmentId === wanted;
|
|
if (handle.kind === 'lane-maneuver') {
|
|
return handle.anchor?.type === 'lane' && segmentOf.get(handle.anchor.roadId) === wanted;
|
|
}
|
|
return handle.kind.startsWith('road-') && segmentOf.get(handle.anchor.roadId) === wanted;
|
|
});
|
|
}
|
|
if (selection.type === 'junction')
|
|
return handles.filter(
|
|
(handle) => handle.kind.startsWith('junction-') && handle.anchor?.nodeId === String(selection.id),
|
|
);
|
|
return handles;
|
|
}
|
|
|
|
function resolveDirectEditConstraints(model, editDocument = null, context = {}) {
|
|
const diagnostics = [];
|
|
const constraints = Array.isArray(editDocument && editDocument.constraints) ? editDocument.constraints : [];
|
|
const handles = emptyHandleManifest(context);
|
|
const groups = roadGroups(model || {});
|
|
const junctionData = junctionReserves(model || {});
|
|
const reconciled = reconcileConstraints(model || {}, constraints, editDocument?.base, junctionData, context);
|
|
const clusters = context.junctionTemplates?.clusters || context.junctionClusters || [];
|
|
const solved = solveConstraints(model || {}, reconciled, junctionData, diagnostics, clusters);
|
|
const effectiveJunctionPlans = buildEffectiveJunctionPlans(
|
|
model || {},
|
|
solved.junctionPlans,
|
|
junctionData,
|
|
clusters,
|
|
solved.clusterPlans,
|
|
);
|
|
handles.reserves = junctionData.reserves;
|
|
handles.handles = selectHandles(
|
|
[
|
|
...makeRoadHandles(model || {}, groups, handles.reserves, reconciled, solved.roadProfiles),
|
|
...makeJunctionHandles(model || {}, junctionData, reconciled),
|
|
...makeClusterCarriagewayHandles(model || {}, junctionData, reconciled, clusters),
|
|
...makeClusterCornerHandles(model || {}, junctionData, reconciled, clusters),
|
|
...makeClusterCrossingHandles(model || {}, junctionData, reconciled, clusters),
|
|
...makeLaneManeuverHandles(model || {}, reconciled),
|
|
],
|
|
model || {},
|
|
context.selection,
|
|
);
|
|
return {
|
|
schema: RESOLUTION_SCHEMA,
|
|
roadProfiles: solved.roadProfiles,
|
|
junctionPlans: solved.junctionPlans,
|
|
effectiveJunctionPlans,
|
|
crossingControls: solved.crossingControls,
|
|
clusterPlans: solved.clusterPlans,
|
|
clusterCutbacks: solved.clusterCutbacks,
|
|
clusterCorners: solved.clusterCorners,
|
|
clusterCrossings: solved.clusterCrossings,
|
|
laneManeuvers: solved.laneManeuvers,
|
|
handles,
|
|
constraintStates: solved.states,
|
|
diagnostics,
|
|
};
|
|
}
|
|
|
|
// Normalize node plans and configured clusters into the read model consumed by
|
|
// JunctionTools. Clusters deliberately remain read-only in this phase: their
|
|
// effective plan is assembled from member nodes without rewriting constraints or
|
|
// silently splitting the cluster into independent editors.
|
|
function buildEffectiveJunctionPlans(model, solvedPlans, junctionData, clusters = [], clusterPlans = new Map()) {
|
|
const nodePlan = (nodeId) => {
|
|
const id = String(nodeId);
|
|
const solved = solvedPlans.get(id);
|
|
const approaches = junctionData.approaches.get(id) || [];
|
|
if (solved)
|
|
return {
|
|
schema: 'junction-effective-plan/v1',
|
|
junctionRef: { type: 'node', id },
|
|
...solved,
|
|
nodeId: id,
|
|
readOnly: false,
|
|
};
|
|
if (!approaches.length) return null;
|
|
return {
|
|
schema: 'junction-effective-plan/v1',
|
|
junctionRef: { type: 'node', id },
|
|
nodeId: id,
|
|
approaches: Object.fromEntries(
|
|
approaches.map((item) => [
|
|
item.segmentId,
|
|
{
|
|
widthMeters: item.items.reduce((sum, entry) => sum + entry.road.widthMeters, 0),
|
|
cutbackMeters: item.cutback,
|
|
},
|
|
]),
|
|
),
|
|
corners: {},
|
|
readOnly: false,
|
|
};
|
|
};
|
|
const result = new Map();
|
|
for (const [nodeId] of junctionData.approaches) {
|
|
const plan = nodePlan(nodeId);
|
|
if (plan) result.set(`node:${nodeId}`, plan);
|
|
}
|
|
for (const cluster of Array.isArray(clusters) ? clusters : []) {
|
|
if (!cluster || !cluster.id || !Array.isArray(cluster.nodeIds)) continue;
|
|
const members = cluster.nodeIds.map((id) => nodePlan(id)).filter(Boolean);
|
|
if (!members.length) continue;
|
|
const approaches = members.flatMap((member) =>
|
|
Object.entries(member.approaches || {}).map(([segmentId, value]) => ({
|
|
nodeId: member.nodeId,
|
|
segmentId,
|
|
...value,
|
|
})),
|
|
);
|
|
const corners = Object.assign({}, ...members.map((member) => member.corners || {}));
|
|
const carriageways = clusterCarriageways(model, junctionData, [cluster]).get(String(cluster.id)) || [];
|
|
const widths = clusterPlans.get(String(cluster.id)) || new Map();
|
|
result.set(`cluster:${cluster.id}`, {
|
|
schema: 'junction-effective-plan/v1',
|
|
junctionRef: { type: 'cluster', id: String(cluster.id) },
|
|
nodeIds: cluster.nodeIds.map(String),
|
|
approaches,
|
|
carriageways: carriageways.map((item) => ({
|
|
key: item.key,
|
|
nodeId: item.nodeId,
|
|
segmentId: item.approach.segmentId,
|
|
widthMeters: widths.get(item.key) ?? item.widthMeters,
|
|
sourceNodeIds: item.sourceNodeIds,
|
|
sourceRoadIds: item.sourceRoadIds,
|
|
})),
|
|
corners,
|
|
readOnly: false,
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
module.exports = {
|
|
CROSSWALK_DEPTH_METERS,
|
|
CROSSWALK_STRIPE_PITCH_METERS,
|
|
CROSSWALK_STRIPE_WIDTH_METERS,
|
|
MAX_CROSSWALK_STRIPE_COUNT,
|
|
MIN_CROSSWALK_STRIPE_COUNT,
|
|
CROSSWALK_JUNCTION_INSET_METERS,
|
|
STOP_LINE_OFFSET_METERS,
|
|
RESOLUTION_SCHEMA,
|
|
HANDLE_MANIFEST_SCHEMA,
|
|
ACTIVE_STATUSES,
|
|
SOLVED_KINDS,
|
|
KINDS,
|
|
GEOMETRY_VERSION,
|
|
roadEdgeOffsetRange,
|
|
SUPPORTED_MANEUVERS,
|
|
resolveDirectEditConstraints,
|
|
buildEffectiveJunctionPlans,
|
|
};
|