feat: refine complex junction geometry and workbench

This commit is contained in:
que01 committed 2026-09-23 17:55:55 +08:00
1 parent 7c04d086db
commit 05614d1a69
20 files changed
+315 -267

No files matched your search

+3 -1
View File
@@ -11,4 +11,6 @@ const inputFile = index >= 0 && args[index + 1] ? path.resolve(args[index + 1])
const input = inputFile ? JSON.parse(fs.readFileSync(inputFile, 'utf8')) : null;
const portIndex = args.indexOf('--port');
const port = portIndex >= 0 ? Number(args[portIndex + 1]) : 8787;
startWorkbench({ input, inputFile, repoRoot: path.resolve(__dirname, '..'), port, debug: args.includes('--debug') });
// Keep the diagnostic read model enabled by default. Use --no-debug only when
// running a minimal production-like session.
startWorkbench({ input, inputFile, repoRoot: path.resolve(__dirname, '..'), port, debug: !args.includes('--no-debug') });
+1 -1
View File
@@ -10,7 +10,7 @@
"scripts": {
"test": "node test/index.js && node test/junction-structure.js && node test/connector-trajectories.js && node test/junction-projection.js && node test/junction-build-plan-counterexamples.js && node test/junction-polygon-ops.js && node test/junction-region-solver.js && node test/junction-facility-composition.js && node test/junction-pavement-region.js && node test/junction-marking-containment.js && node test/junction-corridor-markings.js && node test/junction-layer-seams.js && node test/native-road-edits.js && node test/road-revisions.js && node test/direct-edit-solver.js && node test/workbench-edit-api.js && node test/workbench-import-compile.js && node test/fixtures.js",
"test:fixtures:update-baseline": "node test/update-fixture-baselines.js",
"road:workbench": "node bin/road-workbench.js",
"road:workbench": "npm run build && node bin/road-workbench.js",
"road:export": "node bin/road-compiler.js",
"build": "vite build --config workbench/client/vite.config.ts",
"dev": "vite --config workbench/client/vite.config.ts",
+4 -3
View File
@@ -5,6 +5,7 @@ const { ringsOverlap } = require('./junction-boundary-graph');
const { rectangle } = require('./junction-pavement-region');
const { orthogonalCrossingHeadings, stripeLayout, solveIslandContacts } = require('./junction-facility-composition');
const { radialShift } = require('./junction-island-offset');
const { METERS_PER_DEGREE, metersAt } = require('../geometry/metric');
const {
armCarriesSidewalk,
armEnvelopeAtRadius,
@@ -625,9 +626,9 @@ function solveCornerContacts({
center,
);
if (!crossingCorner) return null;
const lonScale = 111320 * Math.cos((crossingCorner[1] * Math.PI) / 180);
const toLocal = (point) => [(point[0] - crossingCorner[0]) * lonScale, (point[1] - crossingCorner[1]) * 111320];
const fromLocal = (point) => [crossingCorner[0] + point[0] / lonScale, crossingCorner[1] + point[1] / 111320];
const { lon } = metersAt(crossingCorner[1]);
const toLocal = (point) => [(point[0] - crossingCorner[0]) * lon, (point[1] - crossingCorner[1]) * METERS_PER_DEGREE];
const fromLocal = (point) => [crossingCorner[0] + point[0] / lon, crossingCorner[1] + point[1] / METERS_PER_DEGREE];
const landing = (arm, endpoint) => {
const frame = arm.crosswalkFrame;
const layout = stripeLayout(frame.spanMeters);
+16 -32
View File
@@ -1,6 +1,13 @@
'use strict';
const { stationAtDistanceFrom } = require('./junction-build-plan');
const {
METERS_PER_DEGREE,
averageHeading,
headingDegrees: bearing,
metersAt,
signedLateralMeters,
} = require('../geometry/metric');
function normalizeHeading(value) {
return ((((value + 180) % 360) + 360) % 360) - 180;
@@ -78,34 +85,10 @@ 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;
}
@@ -183,8 +166,8 @@ function cornerEdgeAt(arm, radius, bisector, center, helpers) {
}
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 { lon } = metersAt(origin[1]);
const toLocal = (point) => [(point[0] - origin[0]) * lon, (point[1] - origin[1]) * METERS_PER_DEGREE];
const direction = (heading) => {
const radians = (heading * Math.PI) / 180;
return [Math.sin(radians), Math.cos(radians)];
@@ -202,7 +185,7 @@ function rayIntersection(first, second, origin) {
firstPoint[1] + firstDirection[1] * distanceAlongFirst,
];
if (!local.every(Number.isFinite)) return null;
return [origin[0] + local[0] / lonScale, origin[1] + local[1] / 111320];
return [origin[0] + local[0] / lon, origin[1] + local[1] / METERS_PER_DEGREE];
}
function quadraticCurve(start, control, end, segments) {
@@ -219,8 +202,9 @@ function quadraticCurve(start, control, end, segments) {
}
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 { lon, lat } = metersAt(origin[1]);
const east = (point[0] - origin[0]) * lon;
const north = (point[1] - origin[1]) * lat;
const radians = (heading * Math.PI) / 180;
return east * Math.sin(radians) + north * Math.cos(radians);
}
@@ -231,9 +215,9 @@ function polygonCenter(ring) {
}
function projectionRatio(point, start, end) {
const lonScale = 111320 * Math.cos((start[1] * Math.PI) / 180);
const vector = [(end[0] - start[0]) * lonScale, (end[1] - start[1]) * 111320];
const relative = [(point[0] - start[0]) * lonScale, (point[1] - start[1]) * 111320];
const { lon, lat } = metersAt(start[1]);
const vector = [(end[0] - start[0]) * lon, (end[1] - start[1]) * lat];
const relative = [(point[0] - start[0]) * lon, (point[1] - start[1]) * lat];
const lengthSquared = vector[0] * vector[0] + vector[1] * vector[1];
if (lengthSquared < 1e-12) return 0;
return Math.max(0, Math.min(1, (relative[0] * vector[0] + relative[1] * vector[1]) / lengthSquared));
+4 -3
View File
@@ -8,6 +8,7 @@ const { rectangle } = require('./junction-pavement-region');
const { assemblePavementSurfaces } = require('./complex-junction-surfaces');
const { complexJunctionMetrics: calculateComplexJunctionMetrics } = require('./junction-metrics');
const { convertGeoJson, boundsOf } = require('../reference/gaode');
const { metersAt } = require('../geometry/metric');
const { normalizeHeading, positiveHeadingDelta } = require('./complex-junction-geometry');
const {
applyCrossingDisplacements,
@@ -341,10 +342,10 @@ function readReferenceCalibration(cluster) {
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);
const { lon, lat } = metersAt((bounds.minLat + bounds.maxLat) / 2);
return {
longSpanMeters: (bounds.maxLon - bounds.minLon) * lonScale,
shortSpanMeters: (bounds.maxLat - bounds.minLat) * 111320,
longSpanMeters: (bounds.maxLon - bounds.minLon) * lon,
shortSpanMeters: (bounds.maxLat - bounds.minLat) * lat,
};
} catch (_) {
return null;
+1 -12
View File
@@ -22,18 +22,7 @@ const MAX_APPROACH_DISTANCE_METERS = 25;
/** How far an inset may pull the crosswalk from its natural spot. */
const MAX_JUNCTION_INSET_METERS = 4;
const EARTH_RADIUS_METERS = 6371008.8;
const toRadians = (degrees) => (degrees * Math.PI) / 180;
function distanceMeters(a, b) {
if (!Array.isArray(a) || !Array.isArray(b)) return Infinity;
const lat1 = toRadians(a[1]);
const lat2 = toRadians(b[1]);
const h =
Math.sin(toRadians(b[1] - a[1]) / 2) ** 2 +
Math.cos(lat1) * Math.cos(lat2) * Math.sin(toRadians(b[0] - a[0]) / 2) ** 2;
return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h)));
}
const { distanceMeters } = require('../geometry/metric');
/** Endpoints that a connection arrives at, i.e. roads that end in a junction. */
function arrivalEndpointIds(model) {
+6 -40
View File
@@ -7,6 +7,7 @@ const { COMPLEX_CROSSWALK_DEPTH_METERS } = require('./junction-metrics');
const { diagnostic } = require('./diagnostics');
const { approachForCrossing, arrivalEndpointIds, effectiveCrosswalkInsetMax } = require('./crossing-approach');
const { haversineMeters, metersAt, polylineLength } = require('../geometry/lane-geometry');
const { offsetCoordinate, signedLateralMeters } = require('../geometry/metric');
const {
roadSurfaceId,
sidewalkId,
@@ -45,28 +46,9 @@ const SOLVED_KINDS = new Set([
'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-carriageway-transition-length',
'cluster-carriageway-position',
'cluster-carriageway-direction',
'cluster-carriageway-edge-offset',
'cluster-corner-radius',
'cluster-island-offset',
'cluster-crossing-inset',
'cluster-stop-line-offset',
'junction-cutback',
'junction-corner-radius',
'junction-crosswalk-inset',
'junction-crosswalk-size',
'junction-stop-line-offset',
'lane-maneuver',
];
// Set iteration order is insertion order, so this is the same list as the
// literal above — one source of truth instead of two copies that can drift.
const KINDS = [...SOLVED_KINDS];
const SUPPORTED_MANEUVERS = new Set([
'',
'through',
@@ -153,15 +135,6 @@ function tangentAzimuth(line, station) {
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;
@@ -288,8 +261,8 @@ function clusterCenter(model, cluster) {
}
function azimuthBetween(from, to) {
const east = (to[0] - from[0]) * 111320 * Math.cos((from[1] * Math.PI) / 180);
const north = (to[1] - from[1]) * 111320;
const east = (to[0] - from[0]) * metersAt(from[1]).lon;
const north = (to[1] - from[1]) * metersAt(from[1]).lat;
return ((Math.atan2(east, north) * 180) / Math.PI + 360) % 360;
}
@@ -301,13 +274,6 @@ function clusterRadiusPoint(line, center, radius) {
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) }))
+7 -16
View File
@@ -6,6 +6,8 @@ const { solvePavedRegion } = require('./junction-region-solver');
const { stationAtDistanceFrom } = require('./junction-build-plan');
const { offsetCoordinate, metersAt } = require('../geometry/metric');
function pointAtStation(line, station, helpers) {
let remaining = Math.max(0, station);
for (let index = 1; index < line.length; index += 1) {
@@ -33,16 +35,6 @@ function tangentAtStation(line, station, helpers) {
return null;
}
function offsetCoordinate(point, heading, meters) {
if (!point || !Number.isFinite(heading)) return null;
const radians = (heading * Math.PI) / 180;
const lonMeters = 111320 * Math.cos((point[1] * Math.PI) / 180);
return [
point[0] + (Math.sin(radians) * meters) / Math.max(lonMeters, 1e-9),
point[1] + (Math.cos(radians) * meters) / 111320,
];
}
function sectionAt(item, radius, center, widthMeters, helpers, explicitStation, edgeOffsets = null) {
const station = Math.max(
0,
@@ -211,10 +203,9 @@ function ringsOverlap(first, second) {
function coordinateDistanceMeters(first, second) {
if (!first?.every(Number.isFinite) || !second?.every(Number.isFinite)) return Infinity;
const radians = Math.PI / 180;
const latitude = ((first[1] + second[1]) / 2) * radians;
const east = (second[0] - first[0]) * 111320 * Math.cos(latitude);
const north = (second[1] - first[1]) * 111320;
const { lon, lat } = metersAt((first[1] + second[1]) / 2);
const east = (second[0] - first[0]) * lon;
const north = (second[1] - first[1]) * lat;
return Math.hypot(east, north);
}
@@ -223,8 +214,8 @@ function coordinateDistanceMeters(first, second) {
// every remaining edge is an explicit closure between adjacent arms.
// Split at boundary crossings to check complete seam intervals, not samples.
function segmentCoveredByRing(start, end, ring) {
const scale = Math.cos((start[1] * Math.PI) / 180);
const xy = (p) => [(p[0] - start[0]) * 111320 * scale, (p[1] - start[1]) * 111320];
const { lon, lat } = metersAt(start[1]);
const xy = (p) => [(p[0] - start[0]) * lon, (p[1] - start[1]) * lat];
const d = xy(end),
boundary = ring.map(xy);
const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
+1 -14
View File
@@ -1,13 +1,10 @@
'use strict';
const { topologyIdentity } = require('./junction-topology');
const { normalizeHeading, offsetCoordinate } = require('../geometry/metric');
const MIN_ENTRY_SECTION_METERS = 12;
function normalizeHeading(value) {
return ((((value + 180) % 360) + 360) % 360) - 180;
}
function averageHeading(headings) {
const vector = headings.reduce(
(sum, heading) => {
@@ -31,16 +28,6 @@ function tangentAt(line, station, length, helpers) {
return null;
}
function offsetCoordinate(point, heading, meters) {
if (!point || !Number.isFinite(heading)) return null;
const radians = (heading * Math.PI) / 180;
const lonMeters = 111320 * Math.cos((point[1] * Math.PI) / 180);
return [
point[0] + (Math.sin(radians) * meters) / Math.max(lonMeters, 1e-9),
point[1] + (Math.cos(radians) * meters) / 111320,
];
}
function boundaryAt(point, tangent, widthMeters) {
const halfWidth = Math.max(0, Number(widthMeters) || 0) / 2;
return {
+6 -4
View File
@@ -1,15 +1,17 @@
'use strict';
const { metersAt } = require('../geometry/metric');
// Pure geometry helpers for the cluster-level island drag. This module does
// not mutate compiler features; callers can validate the returned rings before
// publishing a preview.
function radialShift(center, islandCenter, distanceMeters) {
const scale = 111320 * Math.cos((center[1] * Math.PI) / 180);
const east = (islandCenter[0] - center[0]) * scale;
const north = (islandCenter[1] - center[1]) * 111320;
const { lon, lat } = metersAt(center[1]);
const east = (islandCenter[0] - center[0]) * lon;
const north = (islandCenter[1] - center[1]) * lat;
const length = Math.hypot(east, north);
if (!Number.isFinite(length) || length < 1e-9 || !Number.isFinite(distanceMeters)) return [0, 0];
return [(distanceMeters * east) / length / scale, (distanceMeters * north) / length / 111320];
return [(distanceMeters * east) / length / lon, (distanceMeters * north) / length / lat];
}
module.exports = { radialShift };
+4 -5
View File
@@ -2,6 +2,7 @@
const { union, difference } = require('./junction-polygon-ops');
const { segmentCoveredByRing } = require('./junction-boundary-graph');
const { metersAt, offsetCoordinate } = require('../geometry/metric');
/**
* The road layer has one authoritative complex-junction region. Construction
@@ -37,8 +38,8 @@ function solveComplexPavementRegion(parts, crossingRegions = [], exclusionRegion
// crossing instead of checking fixed samples that can miss a narrow obstacle.
function segmentCoveredByPolygon(start, end, polygon) {
if (!segmentCoveredByRing(start, end, polygon[0])) return false;
const scale = 111320 * Math.cos((start[1] * Math.PI) / 180);
const xy = (p) => [(p[0] - start[0]) * scale, (p[1] - start[1]) * 111320];
const { lon, lat } = metersAt(start[1]);
const xy = (p) => [(p[0] - start[0]) * lon, (p[1] - start[1]) * lat];
const d = xy(end);
const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
return polygon.slice(1).every((hole) => {
@@ -80,9 +81,7 @@ function segmentCoveredByPolygon(start, end, polygon) {
}
function offset(point, heading, meters) {
const radians = (heading * Math.PI) / 180;
const scale = 111320 * Math.cos((point[1] * Math.PI) / 180);
return [point[0] + (Math.sin(radians) * meters) / scale, point[1] + (Math.cos(radians) * meters) / 111320];
return offsetCoordinate(point, heading, meters);
}
function rectangle(center, heading, depth, span) {
+19 -68
View File
@@ -34,6 +34,19 @@ const {
junctionSurfaceId,
connectionConnectorId,
} = require('./native-ids');
const {
METERS_PER_DEGREE,
distanceMeters,
headingDegrees,
headingVector,
interpolate,
metersAt,
offsetCoordinate,
project,
unproject,
} = require('../geometry/metric');
const headingAtEndpoint = (line) => headingDegrees(line[0], line[1]);
const OVERRIDE_SCHEMA = 'native-road-overrides/v1';
const MOTOR_HIGHWAYS = new Set([
@@ -233,12 +246,12 @@ function roadExtent(roads) {
}
function distanceToExtentEdgeMeters(point, extent) {
const lonScale = 111320 * Math.cos((point[1] * Math.PI) / 180);
const lonScale = metersAt(point[1]).lon;
return Math.min(
(point[0] - extent.minLon) * lonScale,
(extent.maxLon - point[0]) * lonScale,
(point[1] - extent.minLat) * 111320,
(extent.maxLat - point[1]) * 111320,
(point[1] - extent.minLat) * METERS_PER_DEGREE,
(extent.maxLat - point[1]) * METERS_PER_DEGREE,
);
}
@@ -515,8 +528,8 @@ function connectionEndpointsCompatible(model, fromId, toId) {
)
return false;
if (from.nodeId === to.nodeId) return true;
const dx = (from.coordinate[0] - to.coordinate[0]) * 111320 * Math.cos((from.coordinate[1] * Math.PI) / 180);
const dy = (from.coordinate[1] - to.coordinate[1]) * 111320;
const dx = (from.coordinate[0] - to.coordinate[0]) * metersAt(from.coordinate[1]).lon;
const dy = (from.coordinate[1] - to.coordinate[1]) * METERS_PER_DEGREE;
return Math.hypot(dx, dy) <= 35;
}
@@ -1783,7 +1796,6 @@ function compileLaneMarkings(model, overrides, lanes, diagnostics, junctionPlans
}
const previous = lane.coordinates.at(-2);
const end = lane.coordinates.at(-1);
const meters = project(end, end);
const vector = project(previous, end);
const length = Math.hypot(-vector[0], -vector[1]);
const axis = length ? [-vector[0] / length, -vector[1] / length] : null;
@@ -1864,10 +1876,6 @@ function clusterCenter(cluster, junctionPlans) {
: null;
}
function angularDistance(first, second) {
return Math.abs(((first - second + 180) % 360) - 180);
}
function laneSeparatorStyle(overrides, roadId, leftLaneIndex, rightLaneIndex) {
const value = overrides.overrides.find(
(item) =>
@@ -2475,22 +2483,6 @@ function compileLaneCenterlines(
return { features, byRoadId, markingByRoadId };
}
function cubicTurnCurve(start, end, startHeading, endHeading, radius, turn, center) {
const reach = turn === 'right' ? Math.max(5, radius * 0.75) : Math.max(9, radius * 1.35);
const first = offsetCoordinate(start, startHeading, reach);
const second = offsetCoordinate(end, endHeading, reach);
const points = [];
for (let index = 0; index <= 18; index += 1) {
const t = index / 18;
const inverse = 1 - t;
points.push([
inverse ** 3 * start[0] + 3 * inverse ** 2 * t * first[0] + 3 * inverse * t ** 2 * second[0] + t ** 3 * end[0],
inverse ** 3 * start[1] + 3 * inverse ** 2 * t * first[1] + 3 * inverse * t ** 2 * second[1] + t ** 3 * end[1],
]);
}
return points.every((point) => point.every(Number.isFinite)) ? points : [start, center, end];
}
function compileConnectors(model, lanes, diagnostics, overrides, junctionPlans, options, islands, pavementFeatures) {
const features = [];
const movements = [];
@@ -2968,9 +2960,7 @@ function offsetLine(line, offsetMeters) {
function lineLengthMeters(line) {
return line.slice(1).reduce((sum, point, index) => {
const previous = line[index];
const dx = (point[0] - previous[0]) * 111320 * Math.cos((point[1] * Math.PI) / 180);
const dy = (point[1] - previous[1]) * 111320;
return sum + Math.hypot(dx, dy);
return sum + distanceMeters(previous, point);
}, 0);
}
function polygonAreaMeters(ring) {
@@ -3545,11 +3535,6 @@ function junctionTemplateFor(nodeId, segmentIds, configured, diagnostics, node)
};
}
function headingVector(degrees) {
const radians = (degrees * Math.PI) / 180;
return [Math.sin(radians), Math.cos(radians)];
}
function lineIntersection(firstPoint, firstDirection, secondPoint, secondDirection) {
const cross = firstDirection[0] * secondDirection[1] - firstDirection[1] * secondDirection[0];
if (Math.abs(cross) < 1e-4) return null;
@@ -3671,27 +3656,9 @@ function trimLineRange(line, startCutback, endCutback) {
return result;
}
function headingAtEndpoint(line) {
return headingDegrees(line[0], line[1]);
}
function headingDegrees(a, b) {
return (Math.atan2((b[0] - a[0]) * Math.cos((a[1] * Math.PI) / 180), b[1] - a[1]) * 180) / Math.PI;
}
function offsetCoordinate(point, degrees, meters) {
const radians = (degrees * Math.PI) / 180;
return [
point[0] + (Math.sin(radians) * meters) / (111320 * Math.cos((point[1] * Math.PI) / 180)),
point[1] + (Math.cos(radians) * meters) / 111320,
];
}
function angleAround(center, point) {
return Math.atan2(point[1] - center[1], point[0] - center[0]);
}
function sortAround(center, points) {
return points.sort(
(a, b) => Math.atan2(a[1] - center[1], a[0] - center[0]) - Math.atan2(b[1] - center[1], b[0] - center[0]),
);
}
function convexHull(points) {
const unique = [...new Map(points.map((point) => [`${point[0]},${point[1]}`, point])).values()].sort(
(a, b) => a[0] - b[0] || a[1] - b[1],
@@ -3710,14 +3677,6 @@ function convexHull(points) {
}
return [...lower.slice(0, -1), ...upper.slice(0, -1)];
}
function interpolate(a, b, ratio) {
return [a[0] + (b[0] - a[0]) * ratio, a[1] + (b[1] - a[1]) * ratio];
}
function distanceMeters(a, b) {
const dx = (b[0] - a[0]) * 111320 * Math.cos((a[1] * Math.PI) / 180);
const dy = (b[1] - a[1]) * 111320;
return Math.hypot(dx, dy);
}
function hasSelfIntersection(ring, closed = true) {
for (let first = 0; first < ring.length - 1; first += 1)
for (let second = first + 1; second < ring.length - 1; second += 1) {
@@ -3808,14 +3767,6 @@ function sidewalkRing(line, innerOffset, outerOffset, side) {
return ring.every((point) => point.every(Number.isFinite)) ? ring : null;
}
function project(point, origin) {
const scale = 111320;
return [(point[0] - origin[0]) * scale * Math.cos((origin[1] * Math.PI) / 180), (point[1] - origin[1]) * scale];
}
function unproject(point, origin) {
const scale = 111320;
return [point[0] / (scale * Math.cos((origin[1] * Math.PI) / 180)) + origin[0], point[1] / scale + origin[1]];
}
function xmlAttrs(text) {
const attrs = {};
for (const match of text.matchAll(/([:\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) attrs[match[1]] = match[2] ?? match[3];
+1 -4
View File
@@ -3,6 +3,7 @@
const fs = require('fs');
const path = require('path');
const { laneCenterline } = require('../geometry/lane-geometry');
const { metersAt: metersForLat } = require('../geometry/metric');
const ASSET_MANIFEST = path.resolve(__dirname, '..', '..', 'assets', 'lane-icons', 'manifest.json');
let defaultManifestCache = null;
@@ -457,10 +458,6 @@ function isOneway(way) {
return ['yes', 'true', '1'].includes(String(way.tags.oneway || '').toLowerCase());
}
function metersForLat(lat) {
return { lon: 111320 * Math.cos((lat * Math.PI) / 180), lat: 110540 };
}
function normalizeMetersVector([dxLon, dyLat], meters) {
const x = dxLon * meters.lon;
const y = dyLat * meters.lat;
+5 -1
View File
@@ -5,6 +5,10 @@ const path = require('path');
const { zipSync } = require('fflate');
const { LAYER_REGISTRY, validatePublishedLayers } = require('../compile/layer-manifest');
// Single source of truth for the version: package.json. The generator string is
// embedded byte-for-byte into every export, so it must never drift from the
// release version.
const ROOT_FILES = [
'manifest.json',
'compiled.json',
@@ -14,7 +18,7 @@ const ROOT_FILES = [
'traffic-signals.json',
];
const GENERATOR = Object.freeze({ name: 'road-compiler', version: '0.3.0' });
const GENERATOR = Object.freeze({ name: 'road-compiler', version: require('../../package.json').version });
function packageEntries(directory) {
const manifestPath = path.join(directory, 'manifest.json');
+6 -14
View File
@@ -1,6 +1,9 @@
'use strict';
const EARTH_RADIUS_METERS = 6371008.8;
// The single equirectangular metric source is `./metric`; `haversineMeters` is
// re-exported for constraint-station bookkeeping only — never for seam-critical
// distances, which must stay equirectangular to keep the 1 cm seam contract.
const { METERS_PER_DEGREE, averageHeading, haversineMeters, metersAt } = require('./metric');
function laneCenterline(lane) {
const ring = lane?.geometry?.type === 'Polygon' ? lane.geometry.coordinates?.[0] : null;
@@ -115,15 +118,6 @@ function polylineLength(polyline) {
return total;
}
function haversineMeters(a, b) {
const lat1 = degreesToRadians(a[1]);
const lat2 = degreesToRadians(b[1]);
const dLat = degreesToRadians(b[1] - a[1]);
const dLon = degreesToRadians(b[0] - a[0]);
const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h)));
}
function appendCoordinates(target, coordinates) {
for (const coordinate of coordinates) {
if (!sameCoordinate(target.at(-1), coordinate)) target.push(copyCoordinate(coordinate));
@@ -142,10 +136,6 @@ function copyCoordinate(coordinate) {
return [coordinate[0], coordinate[1]];
}
function metersAt(latitude) {
return { lon: 111320 * Math.cos(degreesToRadians(latitude)), lat: 111320 };
}
function degreesToRadians(value) {
return (value * Math.PI) / 180;
}
@@ -161,4 +151,6 @@ module.exports = {
projectedDistanceAlong,
stitchPolylines,
metersAt,
averageHeading,
METERS_PER_DEGREE,
};
+131
View File
@@ -0,0 +1,131 @@
'use strict';
// The single local-metre approximation shared by the whole compiler.
//
// One degree of latitude is METERS_PER_DEGREE metres everywhere; one degree of
// longitude is scaled by cos(latitude) taken at the first point of a
// measurement. Every distance, offset, heading, and planar projection in src/
// must come from here: the junction seam contract is 1 cm, which two
// independent copies of this family cannot be trusted to keep — one copy had
// already drifted to 110540 on the latitude axis.
//
// Two deliberate exceptions remain:
// - `haversineMeters()` in lane-geometry is great-circle distance. The direct
// edit solver uses it for persisted constraint stations; switching it to the
// equirectangular value would silently reinterpret every saved edit.
// - `test/helpers/junction-seams.js` re-derives its own copy on purpose: the
// seam audit must not call the geometry it audits.
//
// This module must stay free of fs/path so the solver can require it.
const METERS_PER_DEGREE = 111320;
const EARTH_RADIUS_METERS = 6371008.8;
function metersAt(latitude) {
return { lon: METERS_PER_DEGREE * Math.cos((latitude * Math.PI) / 180), lat: METERS_PER_DEGREE };
}
function distanceMeters(a, b) {
const dx = (b[0] - a[0]) * metersAt(a[1]).lon;
const dy = (b[1] - a[1]) * METERS_PER_DEGREE;
return Math.hypot(dx, dy);
}
function offsetCoordinate(point, degrees, meters) {
if (!point || !Number.isFinite(degrees)) return null;
const radians = (degrees * Math.PI) / 180;
const lonMeters = metersAt(point[1]).lon;
return [
point[0] + (Math.sin(radians) * meters) / Math.max(lonMeters, 1e-9),
point[1] + (Math.cos(radians) * meters) / METERS_PER_DEGREE,
];
}
// Azimuth from `a` to `b` in degrees, unnormalized: west of north is negative.
// Callers that need [0, 360) wrap with `normalizeDegrees()`.
function headingDegrees(a, b) {
return (Math.atan2((b[0] - a[0]) * Math.cos((a[1] * Math.PI) / 180), b[1] - a[1]) * 180) / Math.PI;
}
function headingVector(degrees) {
const radians = (degrees * Math.PI) / 180;
return [Math.sin(radians), Math.cos(radians)];
}
function normalizeDegrees(value) {
return ((value % 360) + 360) % 360;
}
function angularDistance(a, b) {
return Math.abs(((a - b + 540) % 360) - 180);
}
function normalizeHeading(value) {
return ((((value + 180) % 360) + 360) % 360) - 180;
}
// Signed projection of `point` onto the axis `heading + 90` (driver's right of
// `heading`) in local metres.
function signedLateralMeters(origin, point, heading) {
const east = (point[0] - origin[0]) * metersAt(origin[1]).lon;
const north = (point[1] - origin[1]) * METERS_PER_DEGREE;
const radians = ((heading + 90) * Math.PI) / 180;
return east * Math.sin(radians) + north * Math.cos(radians);
}
// Great-circle distance in metres, for persisted constraint stations only —
// equirectangular must not silently reinterpret saved edits.
// Mean Earth radius follows IUGG: 6371008.8 m.
function haversineMeters(a, b) {
const radians = Math.PI / 180;
const dLat = (b[1] - a[1]) * radians;
const dLon = (b[0] - a[0]) * radians;
const sinLat = Math.sin(dLat / 2);
const sinLon = Math.sin(dLon / 2);
const h = sinLat * sinLat + Math.cos(a[1] * radians) * Math.cos(b[1] * radians) * sinLon * sinLon;
return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h)));
}
function interpolate(a, b, ratio) {
return [a[0] + (b[0] - a[0]) * ratio, a[1] + (b[1] - a[1]) * ratio];
}
// Local planar frame relative to `origin`, in metres. `project`/`unproject`
// are inverse; everything between them runs in flat space.
function project(point, origin) {
return [(point[0] - origin[0]) * metersAt(origin[1]).lon, (point[1] - origin[1]) * METERS_PER_DEGREE];
}
function unproject(point, origin) {
return [point[0] / metersAt(origin[1]).lon + origin[0], point[1] / METERS_PER_DEGREE + origin[1]];
}
// Circular mean of headings (handles the -180/180 wrap).
function averageHeading(values) {
let sinSum = 0;
let cosSum = 0;
for (const value of values) {
const radians = (value * Math.PI) / 180;
sinSum += Math.sin(radians);
cosSum += Math.cos(radians);
}
return (Math.atan2(sinSum, cosSum) * 180) / Math.PI;
}
module.exports = {
METERS_PER_DEGREE,
angularDistance,
averageHeading,
distanceMeters,
headingDegrees,
headingVector,
haversineMeters,
interpolate,
metersAt,
normalizeDegrees,
normalizeHeading,
offsetCoordinate,
project,
signedLateralMeters,
unproject,
};
+6 -7
View File
@@ -3,6 +3,10 @@
const fs = require('fs');
const PI = Math.PI;
// GCJ-02 conversion is deliberately self-contained, but the local-metre scale
// is the compiler-wide equirectangular metric — one copy keeps reference
// matching and SVG projection consistent with native road geometry.
const { METERS_PER_DEGREE, distanceMeters } = require('../geometry/metric');
const EARTH_A = 6378245.0;
const EARTH_EE = 0.00669342162296594323;
@@ -92,11 +96,6 @@ function centerOf(bounds) {
return [(bounds.minLon + bounds.maxLon) / 2, (bounds.minLat + bounds.maxLat) / 2];
}
function distanceMeters(first, second) {
const lonScale = 111320 * Math.cos((first[1] * PI) / 180);
return Math.hypot((second[0] - first[0]) * lonScale, (second[1] - first[1]) * 111320);
}
function parseOsmNodes(xml) {
const nodes = [];
for (const match of xml.matchAll(/<node\b([^>]*?)(?:\/>|>([\s\S]*?)<\/node>)/g)) {
@@ -218,10 +217,10 @@ function inspectReference({
function localReferenceSvg({ converted, nativeIntersection, center, radiusMeters = 180 }) {
const width = 1000;
const height = 1000;
const lonScale = 111320 * Math.cos((center[1] * PI) / 180);
const lonScale = METERS_PER_DEGREE * Math.cos((center[1] * PI) / 180);
const project = (point) => [
width / 2 + ((point[0] - center[0]) * lonScale * width) / (radiusMeters * 2),
height / 2 - ((point[1] - center[1]) * 111320 * height) / (radiusMeters * 2),
height / 2 - ((point[1] - center[1]) * METERS_PER_DEGREE * height) / (radiusMeters * 2),
];
const pathFor = (coordinates) => {
const parts = [];
+10 -22
View File
@@ -3,8 +3,15 @@
const fs = require('fs');
const crypto = require('crypto');
const { parseOsm } = require('./osm');
const {
angularDistance,
distanceMeters,
headingDegrees,
headingVector,
normalizeDegrees,
unproject,
} = require('./geometry/metric');
const EARTH_RADIUS = 6371008.8;
const CURB_OFFSET_METERS = 5.2;
const MAX_SIGNAL_POLE_DISTANCE_FROM_STOP_METERS = 40;
const MAST_REACH_METERS = 4.5;
@@ -491,29 +498,10 @@ function nearestCenter(point, centers) {
);
}
function metersBetween(a, b) {
const lat = (((a[1] + b[1]) / 2) * Math.PI) / 180;
return ((Math.hypot((a[0] - b[0]) * Math.cos(lat), a[1] - b[1]) * Math.PI) / 180) * EARTH_RADIUS;
return distanceMeters(a, b);
}
function moveMeters(point, vector, meters) {
const scale = 180 / Math.PI / EARTH_RADIUS;
return [
point[0] + (vector[0] * meters * scale) / Math.cos((point[1] * Math.PI) / 180),
point[1] + vector[1] * meters * scale,
];
}
function headingBetween(from, to) {
const latitude = (((from[1] + to[1]) / 2) * Math.PI) / 180;
return (Math.atan2((to[0] - from[0]) * Math.cos(latitude), to[1] - from[1]) * 180) / Math.PI;
}
function headingVector(degrees) {
const radians = (degrees * Math.PI) / 180;
return [Math.sin(radians), Math.cos(radians)];
}
function normalizeDegrees(value) {
return ((value % 360) + 360) % 360;
}
function angularDistance(a, b) {
return Math.abs(((a - b + 540) % 360) - 180);
return unproject([vector[0] * meters, vector[1] * meters], point);
}
module.exports = {
+70 -15
View File
@@ -463,6 +463,11 @@ function App() {
* same id in the document, which `validateEditDocument()` rejects outright.
*/
const gesture = useRef<{ operationId: string; createdAt: string } | null>(null);
const pendingDraft = useRef<PreviewDraft | null>(null);
const debugIslandDraft = (stage: string, draft: PreviewDraft | null) => {
const item = draft?.constraints?.find((constraint) => constraint.kind === 'cluster-island-offset');
if (item) console.log('[direct-edit:island]', stage, item.value, item.id, item.provenance?.operationId);
};
const gestureIdentity = () => {
if (!gesture.current)
gesture.current = {
@@ -576,6 +581,16 @@ function App() {
for (const constraint of draft.constraints ?? []) constraints.set(constraint.id, constraint);
for (const operation of draft.operations ?? []) operations.set(operation.id, operation);
}
// Every member draft is built from the same gesture operation. Merge its
// constraint ids instead of letting the last member overwrite the earlier
// operation; otherwise validation sees operation ids that are absent from
// the final constraint set.
for (const operation of operations.values()) {
if (!gesture.current || operation.id !== gesture.current.operationId) continue;
operation.constraintIds = [...constraints.values()]
.filter((constraint) => constraint.provenance.operationId === operation.id)
.map((constraint) => constraint.id);
}
return { constraints: [...constraints.values()], operations: [...operations.values()] };
};
const settleGroup = (handles: EditHandle[], value: number) => {
@@ -590,19 +605,26 @@ function App() {
const defaultKey = [...frequencies.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
const changed = handles.filter(
(handle) =>
formatParameterValue(handle.value.current) === defaultKey && !rendersSame(value, handle.value.current),
formatParameterValue(handle.value.current) === defaultKey &&
(Boolean(gesture.current) || !rendersSame(value, handle.value.current)),
);
if (!changed.length) {
// Once typing has produced a draft, the group value is authoritative. The
// preview may already have rewritten every manifest value before blur or
// Enter; using that refreshed manifest to filter members would discard the
// pending edit and restore the old document.
const targetHandles = gesture.current ? handles : changed;
if (!targetHandles.length) {
abandonGesture();
return;
}
const draft = draftForGroup(changed, value);
if (draft)
commitGesture(
draft,
changed.map((handle) => `constraint:${handle.handleId}`),
);
else abandonGesture();
const draft = draftForGroup(targetHandles, value);
if (draft) {
pendingDraft.current = draft;
const ids = targetHandles
.map((handle) => `constraint:${handle.handleId}`)
.filter((id) => (draft.constraints ?? []).some((constraint) => constraint.id === id));
commitGesture(draft, ids);
} else abandonGesture();
};
const draftLane = (laneId: string, maneuver: string, placementDistanceMeters: number): PreviewDraft | null => {
const handle = manifest?.handles.find(
@@ -654,6 +676,8 @@ function App() {
*/
const commitGesture = (draft: PreviewDraft | null, constraintIds: string[]) => {
if (!draft || !session) return;
debugIslandDraft('session.commit', draft);
pendingDraft.current = null;
requester?.flush(draft);
session.commit(draft.constraints ?? [], constraintIds, gestureIdentity());
recordEdit(editHistoryRef.current, 'session');
@@ -681,10 +705,15 @@ function App() {
*/
const draftValue = (handle: EditHandle, value: number) => {
const draft = draftFor(handle, value);
if (draft) requester?.schedule(draft);
if (draft) {
pendingDraft.current = draft;
debugIslandDraft('preview.schedule', draft);
requester?.schedule(draft);
}
};
/** Neither channel committed: release the id and put the settled state back. */
const abandonGesture = () => {
pendingDraft.current = null;
gesture.current = null;
panelRef.current?.clearLive();
previewSession();
@@ -719,7 +748,11 @@ function App() {
// captured at pointerdown, so this compares against the pre-drag value. The
// element box is a large hit target, which makes a click-without-drag common
// rather than an edge case — but the same applies to a tapped handle dot.
if (rendersSame(value, handle.value.current)) {
// A focused field can already match the refreshed manifest after its
// preview response. The live gesture identity is the source of truth for
// whether this blur has an edit to commit; comparing against the manifest
// here would abandon that edit and restore the old preview.
if (!gesture.current && rendersSame(value, handle.value.current)) {
abandonGesture();
return;
}
@@ -843,12 +876,22 @@ function App() {
setStatus('已放弃未保存的直接编辑');
};
const saveDirectEdits = async (recompile = true) => {
if (!session || !session.dirty) return true;
// A field still being typed in holds an uncommitted value. Blur fires before
// click so the button press would settle it anyway, but that ordering is not
// something to depend on for whether an edit is persisted.
panelRef.current?.settleOpenEdit();
panelRef.current?.commitPending();
// A preview draft is authoritative user intent even if the input event
// that normally commits it was interrupted by a manifest refresh.
if (session && pendingDraft.current) {
const draft = pendingDraft.current;
debugIslandDraft('save.fallback-commit', draft);
const ids = (draft.constraints ?? []).map((constraint) => constraint.id);
session.commit(draft.constraints ?? [], ids, gestureIdentity());
pendingDraft.current = null;
}
if (!session || !session.dirty) return true;
const fragment = session.fragment();
debugIslandDraft('save.payload', fragment);
let version: number;
try {
const result = await api.saveEdits({
@@ -1324,7 +1367,10 @@ function App() {
.catch((error: Error) => setStatus(`更新失败:${error.message}`));
}}
onCandidateMarkersChange={setJunctionNodeMarkers}
onApply={() => setJunctionSession((current) => (current ? applyJunctionDraft(current) : current))}
onApply={() => {
panelRef.current?.commitPending();
setJunctionSession((current) => (current ? applyJunctionDraft(current) : current));
}}
onDiscard={discardJunctionDraft}
onSave={() =>
void compile().then((ok) => {
@@ -1346,8 +1392,17 @@ function App() {
setJunctionSession((current) => (current ? { ...current, status: 'draft', dirty: true } : current));
}}
onDraftGroup={(handles, value) => {
console.log(
'[direct-edit:island:group-input]',
value,
handles.map((handle) => ({ id: handle.handleId, kind: handle.kind, current: handle.value.current })),
);
const draft = draftForGroup(handles, value);
if (draft) requester?.schedule(draft);
if (draft) {
pendingDraft.current = draft;
debugIslandDraft('preview.schedule.group', draft);
requester?.schedule(draft);
}
setJunctionSession((current) => (current ? { ...current, status: 'draft', dirty: true } : current));
}}
onSettle={(handle, value) => {
@@ -49,7 +49,7 @@ export interface ParameterPanelHandle {
* in time on its own — but only just, and nothing states that ordering. Saving
* calls this first so the guarantee does not rest on event order.
*/
settleOpenEdit(): void;
commitPending(): void;
}
/** Baseline text is kept on the node so a restore cannot go stale with a closure. */
@@ -124,8 +124,11 @@ function ParameterRow({
// Committing a value that renders the same as the stored one would turn a
// focus/blur with no typing into an edit, because the field shows a rounded
// form of what the manifest holds.
if (value !== null && rangeVerdictOf(value, min, max) === 'ok' && !rendersSame(value, current))
onSettle(handle, value);
// The manifest may already contain this value because an authoritative
// preview arrived while the field was focused. Compare with the value at
// focus, not the freshly replaced manifest, or blur would abandon a valid
// edit and clear the preview.
if (value !== null && rangeVerdictOf(value, min, max) === 'ok') onSettle(handle, value);
// Typed, then left unusable: a previously previewed keystroke may still be
// pending, so the settled state has to be put back.
else onAbandon();
@@ -192,7 +195,13 @@ function ParameterRow({
const next = Math.min(max, Math.max(min, (parsed ?? current) + direction * step));
draft(formatParameterValue(next));
}
if (event.key === 'Enter') event.currentTarget.blur();
if (event.key === 'Enter') {
event.preventDefault();
// Commit from the row's current text first. Calling blur here
// made Enter depend on React's rerender and the refreshed
// manifest, which could turn a valid preview back into 0.
settle();
}
if (event.key === 'Escape') {
setText(null);
onAbandon();
@@ -271,7 +280,7 @@ export function ParameterPanel({
}
live.current.clear();
},
settleOpenEdit() {
commitPending() {
// `blur()` runs the row's onBlur synchronously, so the command is on the
// stack by the time this returns.
for (const node of nodes.current.values()) if (node === document.activeElement) node.blur();