feat: refine complex junction geometry and workbench
This commit is contained in:
1 parent
7c04d086db
commit
05614d1a69
20 files changed
+315
-267
No files matched your search
@@ -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
@@ -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",
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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) }))
|
||||
|
||||
@@ -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,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 {
|
||||
|
||||
@@ -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 };
|
||||
@@ -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
@@ -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];
|
||||
|
||||
@@ -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,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');
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
@@ -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,
|
||||
};
|
||||
@@ -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
@@ -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 = {
|
||||
|
||||
@@ -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();
|
||||
|
||||
Reference in new issue
Block a user