diff --git a/workbench/client/src/App.tsx b/workbench/client/src/App.tsx index cf89b0a..17b7fd7 100644 --- a/workbench/client/src/App.tsx +++ b/workbench/client/src/App.tsx @@ -15,7 +15,15 @@ import { } from './edit/element'; import { directEditEnabled, intervalEditingSupported } from './edit/flag'; import type { ElementOutline } from './edit/handle-layer'; -import { azimuthBetween, signedMetersAlongAxis, type Coordinate } from './edit/meters'; +import { + azimuthBetween, + coordinateAtStation, + metersAlongPolyline, + polylineLengthMeters, + toLonLat, + type Coordinate, +} from './edit/meters'; +import { previewArrowFeatures } from './edit/arrow-preview'; import { rendersSame } from './edit/parameter'; import { PreviewRequester, type PreviewDraft } from './edit/preview-request'; import { anchorSnapshotFor, constraintValueFor, draftConstraint, operationFor } from './edit/projection'; @@ -215,13 +223,29 @@ function App() { const laneSelectionFeatures = useMemo(() => { if (!element || element.kind !== 'lane-maneuver' || !state) return []; const ids = new Set(element.featureIds); - return ( + const existing = state.layers.turnArrows?.features.filter((feature) => { const nativeId = feature.properties?.native_id; return typeof nativeId === 'string' && ids.has(nativeId); - }) ?? [] + }) ?? []; + const effective = [...state.overrides.overrides, ...staged] + .reverse() + .find((item) => item.kind === 'lane-maneuver' && item.laneId === element.laneId); + const maneuver = typeof effective?.maneuver === 'string' ? effective.maneuver : element.maneuver; + const placementDistanceMeters = + typeof effective?.placementDistanceMeters === 'number' + ? effective.placementDistanceMeters + : element.placementDistanceMeters; + if (existing.length && maneuver === element.maneuver && placementDistanceMeters === element.placementDistanceMeters) + return existing; + const lane = state.layers.laneCenterlines?.features.find( + (feature) => feature.properties?.native_id === element.laneId, ); - }, [element, state]); + const line = lane?.geometry?.type === 'LineString' ? (lane.geometry.coordinates as Coordinate[]) : null; + const distance = placementDistanceMeters ?? 6; + if (!line || line.length < 2 || !maneuver) return []; + return previewArrowFeatures(element.laneId, maneuver, line, distance); + }, [element, staged, state]); const laneSelectionAxisAzimuth = useMemo(() => { if (!element || element.kind !== 'lane-maneuver' || !state) return null; const road = state.compiled.model.roads.find((item) => item.id === element.roadId); @@ -229,6 +253,23 @@ function App() { const end = road?.centerline.at(-1); return previous && end ? azimuthBetween(previous, end) : null; }, [element, state]); + const laneSelectionAnchor = useMemo(() => { + if (!element || element.kind !== 'lane-maneuver' || !state) return null; + const lane = state.layers.laneCenterlines?.features.find( + (feature) => feature.properties?.native_id === element.laneId, + ); + const line = lane?.geometry?.type === 'LineString' ? (lane.geometry.coordinates as Coordinate[]) : null; + if (!line || line.length < 2) return null; + const effective = [...state.overrides.overrides, ...staged] + .reverse() + .find((item) => item.kind === 'lane-maneuver' && item.laneId === element.laneId); + const distance = + typeof effective?.placementDistanceMeters === 'number' + ? effective.placementDistanceMeters + : (element.placementDistanceMeters ?? 6); + const length = polylineLengthMeters(line); + return length > 0 ? coordinateAtStation(line, 1 - distance / length) : null; + }, [element, staged, state]); const sessionRef = useRef(null); if (directEditEnabled && !sessionRef.current) sessionRef.current = new EditSession(); // Per-frame drag feedback reaches the panel through this rather than through @@ -653,14 +694,19 @@ function App() { element={elementOutline} laneSelectionBounds={laneSelectionBounds} laneSelectionFeatures={laneSelectionFeatures} + laneSelectionHiddenIds={element?.kind === 'lane-maneuver' ? element.featureIds : []} + laneSelectionAnchor={laneSelectionAnchor} laneSelectionAxisAzimuth={laneSelectionAxisAzimuth} onLaneSelectionDragEnd={(from, to) => { - if (!element || element.kind !== 'lane-maneuver' || element.placementDistanceMeters === undefined) return; - const road = state.compiled.model.roads.find((item) => item.id === element.roadId); - const previous = road?.centerline.at(-2); - const end = road?.centerline.at(-1); - if (!previous || !end) return; - const deltaTowardJunction = signedMetersAlongAxis(from, to, azimuthBetween(previous, end)); + if (!element || element.kind !== 'lane-maneuver') return; + const lane = state.layers.laneCenterlines?.features.find( + (feature) => feature.properties?.native_id === element.laneId, + ); + const line = lane?.geometry?.type === 'LineString' ? (lane.geometry.coordinates as Coordinate[]) : null; + if (!line || line.length < 2) return; + const along = metersAlongPolyline(line, toLonLat(to)); + const length = polylineLengthMeters(line); + if (along === null || !(length > 0)) return; const existing = [...state.overrides.overrides, ...staged] .reverse() .find((item) => item.kind === 'lane-maneuver' && item.laneId === element.laneId); @@ -669,7 +715,7 @@ function App() { kind: 'lane-maneuver', laneId: element.laneId, maneuver: typeof existing?.maneuver === 'string' ? existing.maneuver : element.maneuver, - placementDistanceMeters: Math.max(0, element.placementDistanceMeters - deltaTowardJunction), + placementDistanceMeters: Math.max(0, length - along), }); setStatus('箭头位置已暂存;保存并重新生成后应用。'); }} diff --git a/workbench/client/src/components/MapCanvas.tsx b/workbench/client/src/components/MapCanvas.tsx index 6ca4b38..54b47b7 100644 --- a/workbench/client/src/components/MapCanvas.tsx +++ b/workbench/client/src/components/MapCanvas.tsx @@ -41,7 +41,11 @@ interface Props { laneSelectionBounds?: Coordinate[] | null; /** Polygon parts copied to the drag feedback layer; baseline parts are hidden by id. */ laneSelectionFeatures?: GeoJson['features']; + laneSelectionHiddenIds?: string[]; + /** The lane centerline point that anchors every part of the selected arrow. */ + laneSelectionAnchor?: Coordinate | null; laneSelectionAxisAzimuth?: number | null; + /** Receives the axis-projected final map coordinate. */ onLaneSelectionDragEnd?: (from: Coordinate, to: Coordinate) => void; /** Authoritative preview geometry; null returns the map to the baseline. */ preview?: Partial> | null; @@ -69,6 +73,8 @@ export function MapCanvas({ element, laneSelectionBounds, laneSelectionFeatures, + laneSelectionHiddenIds, + laneSelectionAnchor, laneSelectionAxisAzimuth, onLaneSelectionDragEnd, preview, @@ -87,6 +93,7 @@ export function MapCanvas({ const previewRef = useRef(null); const laneSelectionSourceRef = useRef(null); const laneSelectionFeaturesRef = useRef([]); + const laneSelectionAnchorRef = useRef(null); const hiddenMarkingIdsRef = useRef>(new Set()); const visibleRef = useRef(visible); visibleRef.current = visible; @@ -124,10 +131,12 @@ export function MapCanvas({ stateRef.current = state; sceneRef.current = scene; hiddenMarkingIdsRef.current = new Set( - (laneSelectionFeatures ?? []) - .map((feature) => feature.properties?.native_id) - .filter((id): id is string => typeof id === 'string'), + laneSelectionHiddenIds ?? + (laneSelectionFeatures ?? []) + .map((feature) => feature.properties?.native_id) + .filter((id): id is string => typeof id === 'string'), ); + laneSelectionAnchorRef.current = laneSelectionAnchor ?? null; useEffect(() => { if (!target.current) return; const layers = createLayers( @@ -181,6 +190,7 @@ export function MapCanvas({ }); map.addInteraction(select); let laneDragOrigin: Coordinate | null = null; + let laneDragAnchor: Coordinate | null = null; let laneDragFeatures: Feature[] = []; map.addInteraction( new PointerInteraction({ @@ -191,8 +201,9 @@ export function MapCanvas({ }); if (!hit) return false; laneDragOrigin = event.coordinate as Coordinate; + laneDragAnchor = laneSelectionAnchorRef.current ? fromLonLat(laneSelectionAnchorRef.current) : null; laneDragFeatures = laneSelectionFeaturesRef.current.map((feature) => feature.clone()); - return true; + return Boolean(laneDragAnchor); }, handleDragEvent: (event) => { const axis = dragRef.current.laneSelectionAxisAzimuth; @@ -214,8 +225,18 @@ export function MapCanvas({ }); }, handleUpEvent: (event) => { - if (laneDragOrigin) dragRef.current.onLaneSelectionDragEnd?.(laneDragOrigin, event.coordinate as Coordinate); + const axis = dragRef.current.laneSelectionAxisAzimuth; + if (laneDragOrigin && laneDragAnchor && axis !== null && axis !== undefined) { + const to = event.coordinate as Coordinate; + const projectedPointer = fromLonLat( + offsetCoordinate(toLonLat(laneDragOrigin), axis, signedMetersAlongAxis(laneDragOrigin, to, axis)), + ); + const dx = projectedPointer[0] - laneDragOrigin[0]; + const dy = projectedPointer[1] - laneDragOrigin[1]; + dragRef.current.onLaneSelectionDragEnd?.(laneDragOrigin, [laneDragAnchor[0] + dx, laneDragAnchor[1] + dy]); + } laneDragOrigin = null; + laneDragAnchor = null; laneDragFeatures = []; return false; }, diff --git a/workbench/client/src/edit/arrow-preview.test.ts b/workbench/client/src/edit/arrow-preview.test.ts new file mode 100644 index 0000000..1ba3d31 --- /dev/null +++ b/workbench/client/src/edit/arrow-preview.test.ts @@ -0,0 +1,42 @@ +import { describe, expect, it } from 'vitest'; +import { arrowPreviewRings, previewArrowFeatures } from './arrow-preview'; +import { coordinateAtStation, polylineLengthMeters, type Coordinate } from './meters'; + +const lane: Coordinate[] = [ + [116.397, 39.9], + [116.397, 39.91], +]; + +describe('arrow preview geometry', () => { + it('uses the compiler part counts for each maneuver', () => { + expect(arrowPreviewRings('through', lane, 6)).toHaveLength(1); + expect(arrowPreviewRings('left', lane, 6)).toHaveLength(3); + expect(arrowPreviewRings('right', lane, 6)).toHaveLength(3); + expect(arrowPreviewRings('through;left', lane, 6)).toHaveLength(3); + expect(arrowPreviewRings('through;right', lane, 6)).toHaveLength(3); + expect(arrowPreviewRings('through;left;right', lane, 6)).toHaveLength(5); + }); + + it('keeps angular parts instead of replacing them with rectangles', () => { + const [head] = arrowPreviewRings('through', lane, 6); + expect(new Set(head.map(([lon, lat]) => `${lon.toFixed(8)}:${lat.toFixed(8)}`)).size).toBeGreaterThan(4); + expect(head[0]).toEqual(head.at(-1)); + }); + + it('points the arrow tip toward the lane junction end', () => { + const distance = 6; + const [head] = arrowPreviewRings('through', lane, distance); + const total = polylineLengthMeters(lane); + const center = coordinateAtStation(lane, 1 - distance / total)!; + expect(head[0][1]).toBeGreaterThan(center[1]); + }); + + it('assigns stable preview ids to every part', () => { + const features = previewArrowFeatures('lane:1', 'left', lane, 6); + expect(features.map((feature) => feature.properties?.native_id)).toEqual([ + 'lane-preview:lane:1:left:0', + 'lane-preview:lane:1:left:1', + 'lane-preview:lane:1:left:2', + ]); + }); +}); diff --git a/workbench/client/src/edit/arrow-preview.ts b/workbench/client/src/edit/arrow-preview.ts new file mode 100644 index 0000000..7f1d726 --- /dev/null +++ b/workbench/client/src/edit/arrow-preview.ts @@ -0,0 +1,90 @@ +import { azimuthBetween, coordinateAtStation, offsetCoordinate, polylineLengthMeters, type Coordinate } from './meters'; +import type { GeoFeature } from '../types/state'; + +type Ring = Coordinate[]; + +const angularTemplate = (assetId: string): Ring[] => { + const shaftWidth = 0.3; + const shaftHalf = shaftWidth / 2; + const straightBase = 1.18; + const straightTip = 1.92; + const throughHead = (): Ring => [ + [0, straightTip], + [-0.42, straightBase], + [-shaftHalf, straightBase], + [-shaftHalf, 0], + [shaftHalf, 0], + [shaftHalf, straightBase], + [0.42, straightBase], + [0, straightTip], + ]; + const diagonalShaft = (side: number): Ring => { + const start: Coordinate = [0, 0.56]; + const end: Coordinate = [side * 0.72, 0.96]; + const length = Math.hypot(end[0] - start[0], end[1] - start[1]); + const normal = [(-(end[1] - start[1]) / length) * shaftHalf, ((end[0] - start[0]) / length) * shaftHalf]; + return [ + [start[0] + normal[0], start[1] + normal[1]], + [end[0] + normal[0], end[1] + normal[1]], + [end[0] - normal[0], end[1] - normal[1]], + [start[0] - normal[0], start[1] - normal[1]], + [start[0] + normal[0], start[1] + normal[1]], + ]; + }; + const diagonalHead = (side: number): Ring => { + const base: Coordinate = [side * 0.6, 0.89]; + const tip: Coordinate = [side * 1.22, 1.24]; + const length = Math.hypot(tip[0] - base[0], tip[1] - base[1]); + const normal = [(-(tip[1] - base[1]) / length) * 0.36, ((tip[0] - base[0]) / length) * 0.36]; + return [tip, [base[0] + normal[0], base[1] + normal[1]], [base[0] - normal[0], base[1] - normal[1]], tip]; + }; + const turnStem = (side: number): Ring => { + const cutMidpoint = 0.73; + const cutRise = side * 0.084; + return [ + [-shaftHalf, 0], + [shaftHalf, 0], + [shaftHalf, cutMidpoint + cutRise], + [-shaftHalf, cutMidpoint - cutRise], + [-shaftHalf, 0], + ]; + }; + if (assetId === 'through') return [throughHead()]; + if (assetId === 'right') return [turnStem(1), diagonalShaft(1), diagonalHead(1)]; + if (assetId === 'left') return [turnStem(-1), diagonalShaft(-1), diagonalHead(-1)]; + if (assetId === 'through;right') return [throughHead(), diagonalShaft(1), diagonalHead(1)]; + if (assetId === 'through;left') return [throughHead(), diagonalShaft(-1), diagonalHead(-1)]; + if (assetId === 'through;left;right') + return [throughHead(), diagonalShaft(-1), diagonalHead(-1), diagonalShaft(1), diagonalHead(1)]; + return []; +}; + +/** Build the same angular arrow parts used by the compiler, at a lane station. */ +export function arrowPreviewRings(maneuver: string, line: Coordinate[], distance: number): Ring[] { + const total = polylineLengthMeters(line); + if (line.length < 2 || !(total > 0)) return []; + const station = Math.max(0, Math.min(1, 1 - distance / total)); + const center = coordinateAtStation(line, station); + if (!center) return []; + const before = coordinateAtStation(line, Math.max(0, station - Math.min(0.01, station))) || line[0]; + const axis = azimuthBetween(before, center); + return angularTemplate(maneuver).map((template) => { + const ring = template.map(([side, forward]) => + offsetCoordinate(offsetCoordinate(center, axis, forward), axis + 90, side), + ); + return ring; + }); +} + +export function previewArrowFeatures( + laneId: string, + maneuver: string, + line: Coordinate[], + distance: number, +): GeoFeature[] { + return arrowPreviewRings(maneuver, line, distance).map((ring, part) => ({ + type: 'Feature', + properties: { native_id: `lane-preview:${laneId}:${maneuver}:${part}` }, + geometry: { type: 'Polygon', coordinates: [ring] }, + })); +} diff --git a/workbench/client/src/edit/element.test.ts b/workbench/client/src/edit/element.test.ts index 30db417..7bea965 100644 --- a/workbench/client/src/edit/element.test.ts +++ b/workbench/client/src/edit/element.test.ts @@ -172,6 +172,7 @@ describe('elementSelectionFor', () => { kind: 'lane-maneuver', laneId: 'lane:road:way/-3246:forward:2', maneuver: '', + placementDistanceMeters: 6, roadId: 'road:way/-3246:forward', featureIds: ['lane:road:way/-3246:forward:2'], }); diff --git a/workbench/client/src/edit/element.ts b/workbench/client/src/edit/element.ts index f16fbe4..b475a8e 100644 --- a/workbench/client/src/edit/element.ts +++ b/workbench/client/src/edit/element.ts @@ -184,7 +184,9 @@ export function elementSelectionFor( if (!spec && properties?.source === LANE_CENTERLINE_SOURCE) { const laneId = text(properties.native_id); const roadId = text(properties.road_id); - return laneId && roadId ? { kind: 'lane-maneuver', laneId, maneuver: '', roadId, featureIds: [laneId] } : null; + return laneId && roadId + ? { kind: 'lane-maneuver', laneId, maneuver: '', placementDistanceMeters: 6, roadId, featureIds: [laneId] } + : null; } const elementId = elementIdOf(properties); if (!spec || !elementId) return null; diff --git a/workbench/client/src/edit/meters.test.ts b/workbench/client/src/edit/meters.test.ts index 7e4c7f6..17b7db1 100644 --- a/workbench/client/src/edit/meters.test.ts +++ b/workbench/client/src/edit/meters.test.ts @@ -4,6 +4,7 @@ import { coordinateAtStation, fromLonLat, haversineMeters, + metersAlongPolyline, mercatorUnitsForMeters, offsetCoordinate, polylineLengthMeters, @@ -141,6 +142,23 @@ describe('station interpolation', () => { }); }); +describe('polyline projection', () => { + const bent: Coordinate[] = [ + [0, 0], + [0, 0.001], + [0.001, 0.001], + ]; + + it('uses the closest segment rather than a road-wide drag axis', () => { + const along = metersAlongPolyline(bent, [0.00075, 0.00102]); + expect(along).toBeCloseTo(polylineLengthMeters(bent) * 0.875, 1); + }); + + it('returns null when there is no usable segment', () => { + expect(metersAlongPolyline([[0, 0]], [0, 0])).toBeNull(); + }); +}); + describe('bearings', () => { it('reads the cardinal directions', () => { expect(azimuthBetween([0, 0], [0, 0.001])).toBeCloseTo(0, 4); diff --git a/workbench/client/src/edit/meters.ts b/workbench/client/src/edit/meters.ts index 730d691..8175ced 100644 --- a/workbench/client/src/edit/meters.ts +++ b/workbench/client/src/edit/meters.ts @@ -55,6 +55,29 @@ export function polylineLengthMeters(line: Coordinate[]): number { return total; } +/** + * Arc distance to the closest point on a polyline, in meters from its first + * coordinate. Drag release uses this to turn a map point back into a lane + * placement without assuming the lane is straight. + */ +export function metersAlongPolyline(line: Coordinate[], point: Coordinate): number | null { + let traversed = 0; + let best: { distance: number; along: number } | null = null; + for (let index = 1; index < line.length; index += 1) { + const start = line[index - 1]; + const end = line[index]; + const { east: dx, north: dy } = eastNorthMeters(start, end); + const { east: px, north: py } = eastNorthMeters(start, point); + const length = Math.hypot(dx, dy); + if (length < 0.001) continue; + const ratio = clamp((px * dx + py * dy) / (length * length), 0, 1); + const distance = Math.hypot(px - dx * ratio, py - dy * ratio); + if (!best || distance < best.distance) best = { distance, along: traversed + length * ratio }; + traversed += length; + } + return best?.along ?? null; +} + /** * Local east/north components of a displacement, in meters. Each component is a * spherical distance measured along a parallel or a meridian, so the result