feat(workbench): drag control markings as elements

This commit is contained in:
que01 committed 2026-09-02 16:04:38 +08:00
1 parent 834470cfa1
commit 31552a5b6f
9 files changed
+244 -75

No files matched your search

@@ -151,6 +151,12 @@ With edit mode off, selecting a turn-arrow part may still show read-only element
information, but it must not create a manifest request, ghost, preview, handle, or
staged lane-maneuver override.
Crosswalk inset and stop-line offset follow the same element ownership rule. New
manifests use a `junction-crossing` anchor containing `crossingId` plus its road
context; legacy `junction-approach` anchors remain readable for document replay.
The crossing values must be kept separate from junction approach width/cutback
plans so editing one crossing cannot move the road geometry or another crossing.
---
## 10. Saving is not the same as applying
+145 -62
View File
@@ -154,6 +154,14 @@ function constraintFor(constraints, kind, anchor) {
item.anchor.incomingRoadId === anchor.incomingRoadId &&
item.anchor.outgoingRoadId === anchor.outgoingRoadId
);
if (kind === 'junction-crosswalk-inset' || kind === 'junction-stop-line-offset')
return (
item.anchor.type === 'junction-crossing' &&
item.anchor.crossingId === anchor.crossingId &&
item.anchor.nodeId === anchor.nodeId &&
item.anchor.segmentId === anchor.segmentId &&
item.anchor.roadId === anchor.roadId
);
return (
item.anchor.type === 'junction-approach' &&
item.anchor.nodeId === anchor.nodeId &&
@@ -437,8 +445,40 @@ function applyRoadConstraint(model, constraint, profiles, diagnostics) {
return true;
}
function applyJunctionConstraint(model, constraint, junctionPlans, junctionData, diagnostics) {
function applyJunctionConstraint(model, constraint, junctionPlans, junctionData, diagnostics, crossingControls) {
const anchor = constraint.anchor || {};
if (anchor.type === 'junction-crossing') {
const crossing = (model.crossings || []).find((item) => String(item.id) === String(anchor.crossingId));
const road = (model.roads || []).find((item) => item.id === anchor.roadId);
const approach = crossing && road ? approachForCrossing(model, crossing) : null;
if (
!crossing ||
!road ||
!approach ||
approach.road.id !== road.id ||
String(road.segmentId) !== String(anchor.segmentId)
) {
blocking(diagnostics, constraint, 'direct-edit-crossing-anchor-missing', '直接编辑约束的控制元素锚点不存在。');
return false;
}
const value = Number(constraint.value?.insetMeters ?? constraint.value?.offsetMeters);
const valid =
constraint.kind === 'junction-crosswalk-inset'
? Number.isFinite(value) && value >= 0 && value <= MAX_CROSSWALK_INSET_METERS
: Number.isFinite(value) && value >= MIN_STOP_LINE_OFFSET_METERS && value <= approach.junctionDistanceMeters;
if (!valid) {
blocking(diagnostics, constraint, 'direct-edit-crossing-value-invalid', '控制线位置超出当前元素可用范围。');
return false;
}
// Keep the geometry value in a separate per-crossing map. Multiple crossings
// may share one approach, so storing this on the approach would couple them.
const crossingKey = String(anchor.crossingId);
const control = crossingControls.get(crossingKey) || {};
crossingControls.set(crossingKey, control);
if (constraint.kind === 'junction-crosswalk-inset') control.crosswalkInsetMeters = value;
else control.stopLineOffsetMeters = value;
return true;
}
const approaches = junctionData.approaches.get(String(anchor.nodeId));
const approach = approaches?.find((item) => item.segmentId === anchor.segmentId);
if (constraint.kind !== 'junction-corner-radius' && !approach) {
@@ -564,6 +604,7 @@ function solveConstraints(model, constraints, junctionData, diagnostics) {
const roadProfiles = new Map();
const junctionPlans = new Map();
const laneManeuvers = new Map();
const crossingControls = new Map();
const states = [];
for (const constraint of constraints) {
if (!constraint.enabled) {
@@ -592,6 +633,7 @@ function solveConstraints(model, constraints, junctionData, diagnostics) {
]),
);
const laneSnapshot = new Map(laneManeuvers);
const crossingSnapshot = new Map([...crossingControls].map(([key, value]) => [key, { ...value }]));
const junctionSnapshot = new Map(
[...junctionPlans].map(([key, plan]) => [
key,
@@ -627,7 +669,7 @@ function solveConstraints(model, constraints, junctionData, diagnostics) {
} else {
applied = constraint.kind.startsWith('road-')
? applyRoadConstraint(model, constraint, roadProfiles, diagnostics)
: applyJunctionConstraint(model, constraint, junctionPlans, junctionData, diagnostics);
: applyJunctionConstraint(model, constraint, junctionPlans, junctionData, diagnostics, crossingControls);
}
if (!applied) {
roadProfiles.clear();
@@ -636,10 +678,12 @@ function solveConstraints(model, constraints, junctionData, diagnostics) {
for (const [key, plan] of junctionSnapshot) junctionPlans.set(key, plan);
laneManeuvers.clear();
for (const [key, value] of laneSnapshot) laneManeuvers.set(key, value);
crossingControls.clear();
for (const [key, value] of crossingSnapshot) crossingControls.set(key, value);
}
states.push(constraintState(constraint, applied, applied ? null : 'invalid'));
}
return { roadProfiles, junctionPlans, laneManeuvers, states };
return { roadProfiles, junctionPlans, laneManeuvers, crossingControls, states };
}
function roadAffects(roads, model, side, boundaryIndex) {
@@ -820,15 +864,7 @@ function junctionAffects(model, nodeId, segmentIds) {
function makeJunctionHandles(model, junctionData, constraints) {
const handles = [];
// Which crossing each approach road serves, so the crosswalk handle can publish
// a ceiling that actually moves the zebra. Built once: `approachForCrossing()`
// scans the roads per crossing.
const crossingByRoadId = new Map();
const arrivals = arrivalEndpointIds(model || {});
for (const crossing of model.crossings || []) {
const match = approachForCrossing(model, crossing, arrivals);
if (match) crossingByRoadId.set(match.road.id, match);
}
for (const [nodeId, approaches] of junctionData.approaches) {
const segmentIds = new Set(approaches.map((item) => item.segmentId));
for (const approach of approaches) {
@@ -886,60 +922,106 @@ function makeJunctionHandles(model, junctionData, constraints) {
tangent,
cutbackConstraint,
);
// Control markings sit inside the reserve but are not junction *shape*, so
// they drag along the approach tangent like the cutback does.
//
// The ceiling is per-approach, not the flat MAX_CROSSWALK_INSET_METERS this
// used to publish: `crossingJunctionInset()` saturates once the inset
// reaches the cutback, and sooner when the crossing sits far from the
// junction. Measured across eight groups the real ceiling ran 1.0–4.5m
// against a declared 8, leaving 44–88% of the range moving nothing and
// saying nothing — the dead-control failure `flag.ts` exists to prevent.
// `approach.items` can hold both directional roads of a segment, and each
// may serve a different crossing at a different junction. Take the one that
// actually ends here — the same last-source-node rule
// `crossingJunctionInset()` uses to find its junction plan. Without the
// filter, two handles on one segment published the same ceiling, and one of
// them was wrong.
const crossing = approach.items
.filter((item) => String(item.road.sourceNodeIds?.at(-1)) === String(nodeId))
.map((item) => crossingByRoadId.get(item.road.id))
.find(Boolean);
const crosswalkConstraint = constraintFor(constraints, 'junction-crosswalk-inset', anchor);
const insetValue = numericValue(crosswalkConstraint, 'insetMeters', CROSSWALK_JUNCTION_INSET_METERS);
const cutbackValue = numericValue(cutbackConstraint, 'cutbackMeters', approach.cutback);
const ceiling = crossing
? effectiveCrosswalkInsetMax(cutbackValue, crossing.junctionDistanceMeters)
: MAX_CROSSWALK_INSET_METERS;
// Never below the value already in force: a max under `current` would be a
// manifest that contradicts itself. Equal to it is honest — it says this
// approach has no headroom left, which is a real state.
// Synthetic models used by older resolver consumers may not carry crossing
// features. Keep their approach-level controls for compatibility; real
// models below always publish element-owned crossing handles.
if (!(model.crossings || []).length) {
const insetConstraint = constraintFor(constraints, 'junction-crosswalk-inset', anchor);
const insetValue = numericValue(insetConstraint, 'insetMeters', CROSSWALK_JUNCTION_INSET_METERS);
add(
'junction-crosswalk-inset',
insetValue,
0,
MAX_CROSSWALK_INSET_METERS,
(tangent + 180) % 360,
insetConstraint,
controlPoint(insetValue, -1),
);
const stopConstraint = constraintFor(constraints, 'junction-stop-line-offset', anchor);
const stopValue = numericValue(stopConstraint, 'offsetMeters', STOP_LINE_OFFSET_METERS);
add(
'junction-stop-line-offset',
stopValue,
MIN_STOP_LINE_OFFSET_METERS,
Math.max(MIN_STOP_LINE_OFFSET_METERS, approach.length * 0.45),
tangent,
stopConstraint,
controlPoint(stopValue, 1),
);
}
}
// Control-marking handles are element-owned. A single approach may serve
// multiple crossings, so each handle carries the crossing id as well as the
// road context needed to resolve its geometry.
for (const crossing of model.crossings || []) {
const match = approachForCrossing(model, crossing, arrivals);
if (!match || String(match.road.sourceNodeIds?.at(-1)) !== String(nodeId)) continue;
const approach = approaches.find((item) => item.segmentId === match.road.segmentId);
if (!approach) continue;
const road = match.road;
const line = approach.endpoint.side === 'start' ? road.centerline : [...road.centerline].reverse();
const tangent = tangentAzimuth(line, Math.min(0.95, approach.cutback / approach.length));
const placementAzimuth = tangent;
const anchorBase = {
type: 'junction-crossing',
crossingId: String(crossing.id),
nodeId: String(nodeId),
segmentId: approach.segmentId,
roadId: road.id,
};
const controlPoint = (offsetMeters, lateralMeters = 0) => {
const point = coordinateAt(line, Math.min(0.98, Math.max(0.02, offsetMeters / Math.max(approach.length, 1))));
return lateralMeters ? offsetCoordinate(point, (tangent + 90) % 360, lateralMeters) : point;
};
const insetConstraint = constraintFor(constraints, 'junction-crosswalk-inset', anchorBase);
const insetValue = numericValue(insetConstraint, 'insetMeters', CROSSWALK_JUNCTION_INSET_METERS);
// The solver may saturate the inset at the junction boundary; the
// configured value is still the closest stable client-side knob position.
const insetApplied = insetValue;
const insetMax = Math.min(
MAX_CROSSWALK_INSET_METERS,
Math.max(insetValue, Number.isFinite(ceiling) ? ceiling : MAX_CROSSWALK_INSET_METERS),
);
add(
'junction-crosswalk-inset',
insetValue,
0,
insetMax,
// The approach tangent points away from the junction. Increasing an
// inset moves the crosswalk toward the junction, so expose the inverse
// axis to keep positive drag values aligned with the handle's meaning.
(tangent + 180) % 360,
crosswalkConstraint,
controlPoint(insetValue, -1),
);
const stopLineConstraint = constraintFor(constraints, 'junction-stop-line-offset', anchor);
add(
'junction-stop-line-offset',
numericValue(stopLineConstraint, 'offsetMeters', STOP_LINE_OFFSET_METERS),
MIN_STOP_LINE_OFFSET_METERS,
Math.max(MIN_STOP_LINE_OFFSET_METERS, approach.length * 0.45),
tangent,
stopLineConstraint,
controlPoint(numericValue(stopLineConstraint, 'offsetMeters', STOP_LINE_OFFSET_METERS), 1),
Math.max(insetValue, effectiveCrosswalkInsetMax(approach.cutback, match.junctionDistanceMeters) || insetValue),
);
handles.push({
handleId: `handle:junction-crosswalk-inset:crossing/${crossing.id}`,
kind: 'junction-crosswalk-inset',
anchor: anchorBase,
// Anchor the knob to the actual crossing feature. The inset is a value
// along the approach, not a reliable screen station from the junction;
// deriving the point from junction distance put the knob off the zebra.
position: offsetCoordinate(crossing.coordinate, placementAzimuth, insetApplied),
axisAzimuth: (tangent + 180) % 360,
value: { current: insetValue, min: 0, max: insetMax, unit: 'meter' },
...(insetConstraint ? { constraintId: insetConstraint.id } : {}),
affects: [`crosswalk:node/${crossing.id}`],
editable: true,
});
const stopConstraint = constraintFor(constraints, 'junction-stop-line-offset', anchorBase);
const stopValue = numericValue(stopConstraint, 'offsetMeters', STOP_LINE_OFFSET_METERS);
handles.push({
handleId: `handle:junction-stop-line-offset:crossing/${crossing.id}`,
kind: 'junction-stop-line-offset',
anchor: anchorBase,
// The stop line is measured back from the crossing, so its knob follows
// the rendered line while remaining independent of the road cutback.
position: offsetCoordinate(
offsetCoordinate(crossing.coordinate, placementAzimuth, insetApplied),
placementAzimuth,
-stopValue,
),
// The compiled stop line applies `-offset` along the approach axis, so
// this tangent is the positive drag direction for increasing offset.
axisAzimuth: tangent,
value: {
current: stopValue,
min: MIN_STOP_LINE_OFFSET_METERS,
max: Math.max(MIN_STOP_LINE_OFFSET_METERS, approach.length * 0.45),
unit: 'meter',
},
...(stopConstraint ? { constraintId: stopConstraint.id } : {}),
affects: [`stop-line:node/${crossing.id}:1`],
editable: true,
});
}
const ordered = [...approaches].sort((a, b) => a.segmentId.localeCompare(b.segmentId));
for (let index = 0; index < ordered.length; index += 1) {
@@ -1048,6 +1130,7 @@ function resolveDirectEditConstraints(model, editDocument = null, context = {})
schema: RESOLUTION_SCHEMA,
roadProfiles: solved.roadProfiles,
junctionPlans: solved.junctionPlans,
crossingControls: solved.crossingControls,
laneManeuvers: solved.laneManeuvers,
handles,
constraintStates: solved.states,
+23 -2
View File
@@ -21,7 +21,14 @@ const CONSTRAINT_ANCHORS = {
'lane-maneuver': 'lane',
};
const CONSTRAINT_KINDS = Object.freeze(Object.keys(CONSTRAINT_ANCHORS));
const ANCHOR_TYPES = new Set(['road-station', 'road-interval', 'junction-approach', 'junction-corner', 'lane']);
const ANCHOR_TYPES = new Set([
'road-station',
'road-interval',
'junction-approach',
'junction-crossing',
'junction-corner',
'lane',
]);
const CONSTRAINT_STATUSES = new Set(['exact', 'recheck', 'pending', 'conflicted', 'stale']);
const TRANSITIONS = new Set(['smoothstep', 'linear']);
const SIDES = new Set(['left', 'right']);
@@ -63,7 +70,11 @@ function validateAnchor(scope, kind, anchor) {
const expected = CONSTRAINT_ANCHORS[kind];
if (!anchor || typeof anchor !== 'object') fail(scope, 'anchor', 'is required');
if (!ANCHOR_TYPES.has(anchor.type)) fail(scope, 'anchor.type', `is not a known anchor type (got ${anchor.type})`);
if (anchor.type !== expected) fail(scope, 'anchor.type', `must be ${expected} for kind ${kind} (got ${anchor.type})`);
// Existing v2 documents used junction-approach for control markings. Accept
// those anchors for replay while new manifests write element-level crossings.
const crossingControl = expected === 'junction-approach' && anchor.type === 'junction-crossing';
if (anchor.type !== expected && !crossingControl)
fail(scope, 'anchor.type', `must be ${expected} for kind ${kind} (got ${anchor.type})`);
if (anchor.side !== undefined && !SIDES.has(anchor.side)) fail(scope, 'anchor.side', 'must be left or right');
if (expected === 'road-station') {
requireString(scope, 'anchor.roadId', anchor.roadId);
@@ -74,9 +85,19 @@ function validateAnchor(scope, kind, anchor) {
requireStation(scope, 'anchor.endStation', anchor.endStation);
if (anchor.startStation >= anchor.endStation)
fail(scope, 'anchor.startStation', 'must be strictly less than anchor.endStation');
} else if (crossingControl) {
requireString(scope, 'anchor.crossingId', anchor.crossingId);
requireString(scope, 'anchor.nodeId', anchor.nodeId);
requireString(scope, 'anchor.segmentId', anchor.segmentId);
requireString(scope, 'anchor.roadId', anchor.roadId);
} else if (expected === 'junction-approach') {
requireString(scope, 'anchor.nodeId', anchor.nodeId);
requireString(scope, 'anchor.segmentId', anchor.segmentId);
} else if (expected === 'junction-crossing') {
requireString(scope, 'anchor.crossingId', anchor.crossingId);
requireString(scope, 'anchor.nodeId', anchor.nodeId);
requireString(scope, 'anchor.segmentId', anchor.segmentId);
requireString(scope, 'anchor.roadId', anchor.roadId);
} else if (expected === 'junction-corner') {
requireString(scope, 'anchor.nodeId', anchor.nodeId);
requireString(scope, 'anchor.incomingRoadId', anchor.incomingRoadId);
+19 -6
View File
@@ -777,7 +777,13 @@ function compileGeometry(model, overrides = { overrides: [] }, options = {}) {
});
const edgeLines =
options.edgeLines === false ? [] : compileEdgeLines(model, overrides, junctionPlans, options, features);
const controls = compileControlMarkings(model, lanes, diagnostics, junctionPlans);
const controls = compileControlMarkings(
model,
lanes,
diagnostics,
junctionPlans,
options.directEdit?.crossingControls,
);
const allControls = {
crosswalks: [...controls.crosswalks, ...generatedComplexCrosswalks],
stopLines: [...controls.stopLines, ...generatedComplexStopLines],
@@ -1223,7 +1229,7 @@ function edgeLineStyle(overrides, roadId, side) {
return value ? { color: value.color, pattern: value.pattern } : { color: 'white', pattern: 'solid' };
}
function compileControlMarkings(model, lanes, diagnostics, junctionPlans = new Map()) {
function compileControlMarkings(model, lanes, diagnostics, junctionPlans = new Map(), crossingControls = new Map()) {
const crosswalks = [];
const stopLines = [];
const arrivalEndpointIds = new Set(
@@ -1267,7 +1273,10 @@ function compileControlMarkings(model, lanes, diagnostics, junctionPlans = new M
(a, b) => a.junctionDistanceMeters - b.junctionDistanceMeters || a.placement.distance - b.placement.distance,
)[0];
const crosswalkCandidate = approach || candidate;
const junctionInsetMeters = approach ? crossingJunctionInset(approach, junctionPlans, model) : 0;
const crossingOverride = crossingControls.get(String(crossing.id));
const junctionInsetMeters = approach
? crossingJunctionInset(approach, junctionPlans, model, crossingOverride?.crosswalkInsetMeters)
: 0;
const controlCenter = offsetByMeters(crossing.coordinate, crosswalkCandidate.placement.axis, junctionInsetMeters);
const { axis } = crosswalkCandidate.placement;
const across = [-axis[1], axis[0]];
@@ -1314,7 +1323,9 @@ function compileControlMarkings(model, lanes, diagnostics, junctionPlans = new M
const stopCenter = offsetByMeters(
laneCenterAtCrossing,
approach.placement.axis,
-approachControls(junctionPlans, approach.road, model).stopLineOffsetMeters,
-(Number.isFinite(crossingOverride?.stopLineOffsetMeters)
? crossingOverride.stopLineOffsetMeters
: approachControls(junctionPlans, approach.road, model).stopLineOffsetMeters),
);
stopLines.push(
controlFeature(
@@ -1379,11 +1390,13 @@ function approachControls(junctionPlans, road, model) {
};
}
function crossingJunctionInset(candidate, junctionPlans, model) {
function crossingJunctionInset(candidate, junctionPlans, model, overrideInset) {
const junctionNodeId = candidate.road.sourceNodeIds.at(-1);
const plan = junctionPlans.get(junctionNodeId);
if (!plan) return 0;
const inset = approachControls(junctionPlans, candidate.road, model).crosswalkInsetMeters;
const inset = Number.isFinite(overrideInset)
? overrideInset
: approachControls(junctionPlans, candidate.road, model).crosswalkInsetMeters;
const targetDistance = Math.max(0, plan.cutbackMeters - inset);
return Math.min(CROSSWALK_MAX_JUNCTION_INSET_METERS, Math.max(0, candidate.junctionDistanceMeters - targetDistance));
}
+16 -2
View File
@@ -170,6 +170,20 @@ function App() {
* element box and its controls hang off this.
*/
const [element, setElement] = useState<ElementSelection | null>(null);
const visibleEditHandles = useMemo(() => {
if (!element || element.kind === 'lane-maneuver') return editHandles;
const constraintKind = specOfKind(element.kind).constraintKind;
// Control markings use the selected outline itself as their drag target,
// exactly like lane-maneuver. Keep the selected control in the index so the
// outline can resolve its semantics, while the layer hides its duplicate dot.
return editHandles.filter(
(handle) =>
!handle.kind.startsWith('junction-cross') ||
(handle.kind === constraintKind &&
handle.anchor.type === 'junction-crossing' &&
String(handle.anchor.crossingId) === String(element.crossingNodeId)),
);
}, [editHandles, element]);
/**
* The selected element as something to draw and grab.
*
@@ -189,7 +203,7 @@ function App() {
const layer = specOfKind(element.kind).layer;
const drawn = preview?.[layer] ?? state.layers[layer];
const bounds = orientedBoundsOf(groupMembers(drawn?.features ?? [], element.elementId));
return bounds ? { handleId: handle.handleId, bounds } : null;
return bounds ? { handleId: handle.handleId, bounds, hideOtherHandles: true } : null;
}, [editMode, element, editHandles, state, preview]);
const laneSelectionBounds = useMemo<Coordinate[] | null>(() => {
if (!element || element.kind !== 'lane-maneuver' || !state || !element.featureIds.length) return null;
@@ -785,7 +799,7 @@ function App() {
onSignalDragEnd={finishSignalMove}
onSignalRotate={rotateSignal}
onSignalRotateEnd={finishSignalRotate}
handles={editHandles}
handles={visibleEditHandles}
ranges={editRanges}
element={elementOutline}
laneSelectionBounds={laneSelectionBounds}
+9 -1
View File
@@ -263,12 +263,20 @@ export function handleForElement<T extends { kind: string; anchor: Record<string
const nodeId = road?.sourceNodeIds.at(-1);
if (!road || nodeId === undefined) return null;
return (
handles.find(
(handle) =>
handle.kind === spec.constraintKind &&
handle.anchor.type === 'junction-crossing' &&
String(handle.anchor.crossingId) === String(element.crossingNodeId),
) ??
// Accept legacy manifests while a saved server document is being upgraded.
handles.find(
(handle) =>
handle.kind === spec.constraintKind &&
handle.anchor.segmentId === road.segmentId &&
String(handle.anchor.nodeId) === String(nodeId),
) ?? null
) ??
null
);
}
+8
View File
@@ -82,6 +82,14 @@ export class EditGhostLayer {
* whether you have hit the limit.
*/
show(handle: EditHandle, value: number): void {
// Control markings are dragged from their selected outline, like lane
// maneuvers. The generic scalar knob/readout would reintroduce a confusing
// blue point and "+N 米" label, so let the preview outline be the only feedback.
if (handle.kind === 'junction-crosswalk-inset' || handle.kind === 'junction-stop-line-offset') {
this.pending = false;
this.source.clear();
return;
}
const clamped = value >= handle.value.max - 1e-6 || value <= handle.value.min + 1e-6;
const delta = value - handle.value.current;
this.pending = false;
+17 -2
View File
@@ -34,6 +34,8 @@ export interface ElementOutline {
handleId: string;
/** Four corners, EPSG:4326, oriented along the element. */
bounds: Coordinate[];
/** Hide every point handle while a control element owns the gesture. */
hideOtherHandles?: boolean;
}
const EDITABLE_STYLE: Record<string, Style> = {
@@ -96,6 +98,7 @@ export class EditHandleLayer {
private index = new Map<string, EditHandle>();
private ranges = new Map<string, IntervalRangeHandle>();
private elementIds = new Set<string>();
private hideOtherHandles = false;
constructor() {
this.layer = new VectorLayer({
@@ -104,10 +107,17 @@ export class EditHandleLayer {
zIndex: 100,
style: (feature) => {
const id = String(feature.get(HANDLE_ID));
if (this.elementIds.has(id)) return ELEMENT_STYLE;
if (this.elementIds.has(id)) {
// The selected element outline owns the drag gesture. Its companion
// point is kept in the semantic index but must not be painted as a
// confusing second red/green control dot.
return feature.getGeometry()?.getType() === 'Polygon' ? ELEMENT_STYLE : undefined;
}
if (this.hideOtherHandles && feature.getGeometry()?.getType() === 'Point') return undefined;
if (this.ranges.has(id)) return RANGE_STYLE;
const handle = this.index.get(id);
if (!handle) return undefined;
if (handle.kind === 'junction-crosswalk-inset' || handle.kind === 'junction-stop-line-offset') return undefined;
return handle.editable ? EDITABLE_STYLE[handle.kind] : DISABLED_STYLE;
},
});
@@ -126,6 +136,7 @@ export class EditHandleLayer {
this.index = new Map(handles.map((handle) => [handle.handleId, handle]));
this.ranges = new Map(ranges.map((range) => [range.handleId, range]));
this.elementIds = new Set(element ? [element.handleId] : []);
this.hideOtherHandles = element?.hideOtherHandles === true;
this.source.clear();
if (element)
this.source.addFeatures([
@@ -134,8 +145,11 @@ export class EditHandleLayer {
[HANDLE_ID]: element.handleId,
}),
]);
const renderedHandles = element?.hideOtherHandles
? handles.filter((handle) => handle.handleId === element.handleId)
: handles;
this.source.addFeatures(
[...handles, ...ranges].map(
[...renderedHandles, ...(element?.hideOtherHandles ? [] : ranges)].map(
(handle) =>
new Feature({
geometry: new Point(fromLonLat(handle.position)),
@@ -149,6 +163,7 @@ export class EditHandleLayer {
this.index = new Map();
this.ranges = new Map();
this.elementIds = new Set();
this.hideOtherHandles = false;
this.source.clear();
}
+1
View File
@@ -59,6 +59,7 @@ export type SemanticAnchor =
boundaryIndex?: number;
}
| { type: 'junction-approach'; nodeId: string; segmentId: string; side?: Side }
| { type: 'junction-crossing'; crossingId: string; nodeId: string; segmentId: string; roadId: string }
| { type: 'junction-corner'; nodeId: string; incomingRoadId: string; outgoingRoadId: string };
export type RoadIntervalAnchor = Extract<SemanticAnchor, { type: 'road-interval' }>;