686 lines
25 KiB
JavaScript
686 lines
25 KiB
JavaScript
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const { laneCenterline } = require('../geometry/lane-geometry');
|
|
|
|
const ASSET_MANIFEST = path.resolve(__dirname, '..', '..', 'assets', 'lane-icons', 'manifest.json');
|
|
const LANE_WIDTH_METERS = 3.2;
|
|
const PLACEMENT_DISTANCE_METERS = 9;
|
|
const SPATIAL_MATCH_MAX_DISTANCE_METERS = 18;
|
|
const SPATIAL_MATCH_MIN_ALIGNMENT = Math.cos(Math.PI / 6);
|
|
|
|
// Existing osm2streets lane arrows are approximately 1.4 m across. Keep the
|
|
// 25-unit upstream icon at the same on-road scale rather than at screen scale.
|
|
const SVG_METERS_PER_UNIT = 0.1;
|
|
|
|
function loadManifest(file = ASSET_MANIFEST) {
|
|
const manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
|
|
if (!Array.isArray(manifest.assets)) throw new Error('turn-lane asset manifest has no assets array');
|
|
return manifest;
|
|
}
|
|
|
|
function supportedAssets(manifest = loadManifest()) {
|
|
return new Map(
|
|
manifest.assets
|
|
.filter((asset) => asset.supported === true && asset.tested === true)
|
|
.map((asset) => [asset.id, asset]),
|
|
);
|
|
}
|
|
|
|
function buildCustomTurnLaneArrows(osm, options = {}) {
|
|
const enabled = options.enabled === true;
|
|
const diagnostics = [];
|
|
if (!enabled) return { features: [], diagnostics: [{ reason: 'disabled' }] };
|
|
const assets = supportedAssets(options.manifest);
|
|
const endpointRoadCounts = roadCountsByNode(osm);
|
|
const networkIntersectionNodes = new Set(
|
|
(options.network?.intersections || []).flatMap(([, intersection]) => intersection.osm_ids || []).map(Number),
|
|
);
|
|
const features = [];
|
|
const ways = [...osm.ways.values()].sort((a, b) => a.id - b.id);
|
|
for (const way of ways) {
|
|
for (const direction of ['forward', 'backward']) {
|
|
const tag = way.tags[`turn:lanes:${direction}`];
|
|
if (!tag) continue;
|
|
const laneCount = directionalLaneCount(way, direction);
|
|
if (!laneCount) {
|
|
diagnostics.push(skip(way, direction, 'missing_lane_count'));
|
|
continue;
|
|
}
|
|
const endpoint = endpointGeometry(osm, way, direction, endpointRoadCounts, networkIntersectionNodes);
|
|
if (!endpoint) {
|
|
diagnostics.push(skip(way, direction, 'indeterminate_intersection_endpoint'));
|
|
continue;
|
|
}
|
|
const maneuvers = String(tag)
|
|
.split('|')
|
|
.map((value) => normalizeManeuver(value));
|
|
for (let laneIndex = 0; laneIndex < maneuvers.length; laneIndex += 1) {
|
|
const maneuver = maneuvers[laneIndex];
|
|
const asset = assets.get(maneuver);
|
|
if (!asset) {
|
|
diagnostics.push(
|
|
skip(way, direction, 'unsupported_or_untested_maneuver', { lane_index: laneIndex, maneuver }),
|
|
);
|
|
continue;
|
|
}
|
|
if (laneIndex >= laneCount) {
|
|
diagnostics.push(skip(way, direction, 'lane_index_exceeds_lane_count', { lane_index: laneIndex, maneuver }));
|
|
continue;
|
|
}
|
|
const resolvedPlacement = lanePlacement(
|
|
way,
|
|
direction,
|
|
laneIndex,
|
|
endpoint,
|
|
options.lanePolygons,
|
|
options.crosswalkStripes,
|
|
options.stopLines,
|
|
);
|
|
if (resolvedPlacement?.blocked) {
|
|
diagnostics.push(skip(way, direction, 'no_safe_turn_arrow_position', { lane_index: laneIndex, maneuver }));
|
|
continue;
|
|
}
|
|
const placement =
|
|
resolvedPlacement ||
|
|
fallbackLanePlacement(endpoint, direction, laneIndex, options.crosswalkStripes, options.stopLines);
|
|
if (!placement) {
|
|
diagnostics.push(skip(way, direction, 'no_safe_turn_arrow_position', { lane_index: laneIndex, maneuver }));
|
|
continue;
|
|
}
|
|
const parts = templateFor(asset.id, options.manifest);
|
|
for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
|
|
features.push(
|
|
makeFeature(
|
|
way,
|
|
direction,
|
|
laneIndex,
|
|
maneuver,
|
|
asset,
|
|
partIndex,
|
|
parts[partIndex],
|
|
placement.center,
|
|
placement,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { features, diagnostics };
|
|
}
|
|
|
|
function normalizeManeuver(value) {
|
|
const parts = String(value || '')
|
|
.split(';')
|
|
.map((part) => part.trim())
|
|
.filter(Boolean)
|
|
.sort();
|
|
const supported = new Map([
|
|
['through', 'through'],
|
|
['left', 'left'],
|
|
['right', 'right'],
|
|
['left;through', 'through;left'],
|
|
['right;through', 'through;right'],
|
|
['left;right;through', 'through;left;right'],
|
|
]);
|
|
return supported.get(parts.join(';')) || parts.join(';');
|
|
}
|
|
|
|
function directionalLaneCount(way, direction) {
|
|
const specific = Number(way.tags[`lanes:${direction}`]);
|
|
if (Number.isInteger(specific) && specific > 0) return specific;
|
|
const total = Number(way.tags.lanes);
|
|
if (Number.isInteger(total) && total > 0 && total % 2 === 0 && !isOneway(way)) return total / 2;
|
|
if (Number.isInteger(total) && total > 0 && isOneway(way)) return total;
|
|
return null;
|
|
}
|
|
|
|
function roadCountsByNode(osm) {
|
|
const out = new Map();
|
|
for (const way of osm.ways.values()) {
|
|
if (!way.tags.highway || way.tags.highway === 'service') continue;
|
|
for (const ref of new Set(way.refs)) out.set(ref, (out.get(ref) || 0) + 1);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function endpointGeometry(osm, way, direction, roadCounts, networkIntersectionNodes) {
|
|
const forward = direction === 'forward';
|
|
const endpointIndex = forward ? way.refs.length - 1 : 0;
|
|
const neighborIndex = forward ? endpointIndex - 1 : 1;
|
|
const node = osm.nodes.get(way.refs[endpointIndex]);
|
|
const neighbor = osm.nodes.get(way.refs[neighborIndex]);
|
|
if (!node || !neighbor) return null;
|
|
const networkSaysIntersection =
|
|
networkIntersectionNodes && networkIntersectionNodes.size > 0 && networkIntersectionNodes.has(node.id);
|
|
if (!networkSaysIntersection && (roadCounts.get(node.id) || 0) < 3) return null;
|
|
const meters = metersForLat(node.lat);
|
|
// For both directions, point from the adjacent road node to the endpoint.
|
|
// At a forward endpoint this is the OSM-way direction; at a backward
|
|
// endpoint it is the reverse OSM-way direction, i.e. the actual travel
|
|
// direction used by turn:lanes:backward.
|
|
const raw = [node.lon - neighbor.lon, node.lat - neighbor.lat];
|
|
const axis = normalizeMetersVector(raw, meters);
|
|
if (!axis) return null;
|
|
return { node, axis, right: [axis[1], -axis[0]], meters };
|
|
}
|
|
|
|
function laneCenter(endpoint, direction, laneIndex, meters) {
|
|
const lateral = (laneIndex + 0.5) * LANE_WIDTH_METERS;
|
|
// The local axis always follows travel, so moving back from either endpoint
|
|
// places the marking on its approach lane before the intersection.
|
|
return addMeters(
|
|
[endpoint.node.lon, endpoint.node.lat],
|
|
endpoint.axis,
|
|
-PLACEMENT_DISTANCE_METERS,
|
|
endpoint.right,
|
|
lateral,
|
|
meters,
|
|
);
|
|
}
|
|
|
|
function fallbackLanePlacement(endpoint, direction, laneIndex, crosswalkStripes, stopLines) {
|
|
const lateral = (laneIndex + 0.5) * LANE_WIDTH_METERS;
|
|
for (const distance of [PLACEMENT_DISTANCE_METERS, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42]) {
|
|
const center = addMeters(
|
|
[endpoint.node.lon, endpoint.node.lat],
|
|
endpoint.axis,
|
|
-distance,
|
|
endpoint.right,
|
|
lateral,
|
|
endpoint.meters,
|
|
);
|
|
if (!nearIntersectionMarking(center, endpoint.axis, crosswalkStripes, stopLines, endpoint.meters)) {
|
|
return {
|
|
center,
|
|
axis: endpoint.axis,
|
|
right: endpoint.right,
|
|
meters: endpoint.meters,
|
|
placementDistance: distance,
|
|
placementSource: 'osm_way_fallback',
|
|
};
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function lanePlacement(way, direction, laneIndex, endpoint, lanePolygons, crosswalkStripes, stopLines) {
|
|
if (!Array.isArray(lanePolygons)) return null;
|
|
const expectedDirection = direction === 'forward' ? 'Fwd' : 'Back';
|
|
const directionalCandidates = lanePolygons.filter(
|
|
(feature) => feature.properties?.type === 'Driving' && feature.properties.direction === expectedDirection,
|
|
);
|
|
let candidates = directionalCandidates.filter((feature) =>
|
|
(feature.properties.osm_way_ids || []).map(Number).includes(way.id),
|
|
);
|
|
let placementSource = 'driving_lane_centerline';
|
|
let spatialAnchors = null;
|
|
if (!candidates.length) {
|
|
const ranked = directionalCandidates
|
|
.map((feature) => ({ feature, anchor: spatialLaneAnchor(feature, endpoint) }))
|
|
.filter(({ anchor }) => anchor)
|
|
.filter(
|
|
({ anchor }) =>
|
|
anchor.alignment >= SPATIAL_MATCH_MIN_ALIGNMENT && anchor.distance <= SPATIAL_MATCH_MAX_DISTANCE_METERS,
|
|
)
|
|
.sort(
|
|
(a, b) =>
|
|
a.anchor.distance - b.anchor.distance ||
|
|
a.anchor.lateral - b.anchor.lateral ||
|
|
Number(a.feature.properties.index) - Number(b.feature.properties.index),
|
|
);
|
|
if (ranked.length) {
|
|
// JOSM may split a tagged OSM way into temporary negative IDs. Those IDs
|
|
// are absent from osm2streets' rendered polygons, so associate the full
|
|
// physical approach by endpoint proximity and road-axis alignment.
|
|
candidates = ranked.map(({ feature }) => feature);
|
|
placementSource = 'spatial_driving_lane_centerline';
|
|
spatialAnchors = new Map(ranked.map(({ feature, anchor }) => [feature, anchor]));
|
|
}
|
|
}
|
|
candidates.sort((a, b) => {
|
|
const lateralA = spatialAnchors?.get(a)?.lateral;
|
|
const lateralB = spatialAnchors?.get(b)?.lateral;
|
|
if (Number.isFinite(lateralA) && Number.isFinite(lateralB) && lateralA !== lateralB) return lateralA - lateralB;
|
|
return Number(a.properties.index) - Number(b.properties.index);
|
|
});
|
|
const lane = candidates[laneIndex];
|
|
const spatialAnchor = spatialAnchors?.get(lane);
|
|
if (spatialAnchor) {
|
|
const sampled = placementDistances()
|
|
.map((distance) => ({
|
|
center: sampleCenterlineAwayFromEndpoint(spatialAnchor, distance, endpoint.meters),
|
|
distance,
|
|
}))
|
|
.find(
|
|
({ center }) =>
|
|
center && !nearIntersectionMarking(center, spatialAnchor.axis, crosswalkStripes, stopLines, endpoint.meters),
|
|
);
|
|
if (!sampled) return { blocked: true };
|
|
return {
|
|
center: sampled.center,
|
|
axis: spatialAnchor.axis,
|
|
right: [spatialAnchor.axis[1], -spatialAnchor.axis[0]],
|
|
meters: endpoint.meters,
|
|
placementDistance: sampled.distance,
|
|
placementSource,
|
|
};
|
|
}
|
|
const centerline = laneCenterline(lane);
|
|
if (!centerline) return null;
|
|
const startsAtEndpoint = direction === 'backward';
|
|
const ordered = startsAtEndpoint ? centerline : [...centerline].reverse();
|
|
const sampled = [PLACEMENT_DISTANCE_METERS, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42]
|
|
.map((distance) => ({ center: samplePolyline(ordered, distance, endpoint.meters), distance }))
|
|
.find(
|
|
({ center }) =>
|
|
center &&
|
|
!nearIntersectionMarking(
|
|
center,
|
|
axisForLane(ordered, endpoint.meters),
|
|
crosswalkStripes,
|
|
stopLines,
|
|
endpoint.meters,
|
|
),
|
|
);
|
|
if (!sampled) return { blocked: true };
|
|
const axis = axisForLane(ordered, endpoint.meters);
|
|
if (!axis) return null;
|
|
return {
|
|
center: sampled.center,
|
|
axis,
|
|
right: [axis[1], -axis[0]],
|
|
meters: endpoint.meters,
|
|
placementDistance: sampled.distance,
|
|
placementSource,
|
|
};
|
|
}
|
|
|
|
function spatialLaneAnchor(lane, endpoint) {
|
|
const centerline = laneCenterline(lane);
|
|
if (!centerline) return null;
|
|
let best = null;
|
|
for (let index = 0; index < centerline.length - 1; index += 1) {
|
|
const start = centerline[index];
|
|
const end = centerline[index + 1];
|
|
const point = closestPointOnSegment([endpoint.node.lon, endpoint.node.lat], start, end, endpoint.meters);
|
|
const distance = Math.hypot(
|
|
(point[0] - endpoint.node.lon) * endpoint.meters.lon,
|
|
(point[1] - endpoint.node.lat) * endpoint.meters.lat,
|
|
);
|
|
const tangent = normalizeMetersVector(subtractPoint(end, start), endpoint.meters);
|
|
if (!tangent || (best && distance >= best.distance)) continue;
|
|
const dot = tangent[0] * endpoint.axis[0] + tangent[1] * endpoint.axis[1];
|
|
const axis = dot >= 0 ? tangent : [-tangent[0], -tangent[1]];
|
|
const offset = subtractPoint(point, [endpoint.node.lon, endpoint.node.lat]);
|
|
best = {
|
|
point,
|
|
distance,
|
|
axis,
|
|
alignment: Math.abs(dot),
|
|
lateral:
|
|
offset[0] * endpoint.right[0] * endpoint.meters.lon + offset[1] * endpoint.right[1] * endpoint.meters.lat,
|
|
centerline,
|
|
segmentIndex: index,
|
|
};
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function placementDistances() {
|
|
return [PLACEMENT_DISTANCE_METERS, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42];
|
|
}
|
|
|
|
function sampleCenterlineAwayFromEndpoint(anchor, distanceMeters, meters) {
|
|
const { centerline, segmentIndex } = anchor;
|
|
const start = centerline[segmentIndex];
|
|
const end = centerline[segmentIndex + 1];
|
|
const tangent = normalizeMetersVector(subtractPoint(end, start), meters);
|
|
if (!tangent) return null;
|
|
// Walk away from the junction along the rendered centerline. This preserves
|
|
// curved or split lane geometry instead of approximating it with a tangent.
|
|
const towardEnd = tangent[0] * anchor.axis[0] + tangent[1] * anchor.axis[1] < 0;
|
|
const points = [anchor.point];
|
|
if (towardEnd) {
|
|
for (let index = segmentIndex + 1; index < centerline.length; index += 1) points.push(centerline[index]);
|
|
} else {
|
|
for (let index = segmentIndex; index >= 0; index -= 1) points.push(centerline[index]);
|
|
}
|
|
return samplePolyline(points, distanceMeters, meters);
|
|
}
|
|
|
|
function closestPointOnSegment(point, start, end, meters) {
|
|
const dx = (end[0] - start[0]) * meters.lon;
|
|
const dy = (end[1] - start[1]) * meters.lat;
|
|
const px = (point[0] - start[0]) * meters.lon;
|
|
const py = (point[1] - start[1]) * meters.lat;
|
|
const lengthSquared = dx * dx + dy * dy;
|
|
const ratio = lengthSquared ? Math.max(0, Math.min(1, (px * dx + py * dy) / lengthSquared)) : 0;
|
|
return [start[0] + ratio * (end[0] - start[0]), start[1] + ratio * (end[1] - start[1])];
|
|
}
|
|
|
|
function axisForLane(ordered, meters) {
|
|
return normalizeMetersVector(subtractPoint(ordered[0], ordered[1]), meters);
|
|
}
|
|
|
|
function nearIntersectionMarking(center, axis, stripes, stopLines, meters) {
|
|
if (!axis) return true;
|
|
const right = [axis[1], -axis[0]];
|
|
const samples = [];
|
|
for (const forward of [-0.2, 0.5, 1.2, 1.9, 2.2]) {
|
|
for (const lateral of [-1.6, -0.8, 0, 0.8, 1.6]) {
|
|
samples.push(addMeters(center, axis, forward, right, lateral, meters));
|
|
}
|
|
}
|
|
return [...(stripes || []), ...(stopLines || [])].some((feature) =>
|
|
samples.some((point) => nearFeature(point, feature, meters)),
|
|
);
|
|
}
|
|
|
|
function nearFeature(point, feature, meters) {
|
|
const ring = feature.geometry?.type === 'Polygon' ? feature.geometry.coordinates?.[0] : null;
|
|
if (!ring?.length) return false;
|
|
const xs = ring.map((coordinate) => coordinate[0]);
|
|
const ys = ring.map((coordinate) => coordinate[1]);
|
|
const clearance = 0.7;
|
|
const dx = Math.max((Math.min(...xs) - point[0]) * meters.lon, 0, (point[0] - Math.max(...xs)) * meters.lon);
|
|
const dy = Math.max((Math.min(...ys) - point[1]) * meters.lat, 0, (point[1] - Math.max(...ys)) * meters.lat);
|
|
return Math.hypot(dx, dy) < clearance;
|
|
}
|
|
|
|
function subtractPoint([lon, lat], [otherLon, otherLat]) {
|
|
return [lon - otherLon, lat - otherLat];
|
|
}
|
|
|
|
function samplePolyline(points, distanceMeters, meters) {
|
|
let remaining = distanceMeters;
|
|
for (let index = 0; index < points.length - 1; index += 1) {
|
|
const start = points[index];
|
|
const end = points[index + 1];
|
|
const vector = normalizeMetersVector(subtractPoint(end, start), meters);
|
|
const length = Math.hypot((end[0] - start[0]) * meters.lon, (end[1] - start[1]) * meters.lat);
|
|
if (!vector || !length) continue;
|
|
if (remaining <= length) return addMeters(start, vector, remaining, [0, 0], 0, meters);
|
|
remaining -= length;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function makeFeature(way, direction, laneIndex, maneuver, asset, partIndex, template, center, endpoint) {
|
|
const ring = template.map(([rightMeters, forwardMeters]) =>
|
|
addMeters(center, endpoint.axis, forwardMeters, endpoint.right, rightMeters, endpoint.meters),
|
|
);
|
|
return {
|
|
type: 'Feature',
|
|
properties: {
|
|
type: 'lane arrow',
|
|
source: 'osm_turn_lanes',
|
|
osm_way_id: way.id,
|
|
direction,
|
|
lane_index: laneIndex,
|
|
maneuver,
|
|
source_asset: asset.id,
|
|
source_asset_path: asset.source,
|
|
arrow_part: partIndex,
|
|
// SVG strokes and fills are expanded separately for GeoJSON validity.
|
|
// This stable key lets the QGIS normalizer restore one rendered arrow.
|
|
custom_arrow_id: `${way.id}:${direction}:${laneIndex}:${maneuver}`,
|
|
placement_distance_meters: endpoint.placementDistance ?? PLACEMENT_DISTANCE_METERS,
|
|
placement_source: endpoint.placementSource ?? 'osm_way_fallback',
|
|
},
|
|
geometry: { type: 'Polygon', coordinates: [ring] },
|
|
};
|
|
}
|
|
|
|
function skip(way, direction, reason, extra = {}) {
|
|
return { source: 'osm_turn_lanes', osm_way_id: way.id, direction, reason, ...extra };
|
|
}
|
|
|
|
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;
|
|
const length = Math.hypot(x, y);
|
|
return length ? [x / length, y / length] : null;
|
|
}
|
|
|
|
function addMeters(center, axis, axisDistance, right, rightDistance, meters) {
|
|
return [
|
|
center[0] + (axis[0] * axisDistance + right[0] * rightDistance) / meters.lon,
|
|
center[1] + (axis[1] * axisDistance + right[1] * rightDistance) / meters.lat,
|
|
];
|
|
}
|
|
|
|
function arrowRingsAt(maneuver, center, axis, manifest = loadManifest()) {
|
|
const normalized = normalizeManeuver(maneuver);
|
|
if (!supportedAssets(manifest).has(normalized) || !Array.isArray(center) || !Array.isArray(axis)) return [];
|
|
const meters = metersForLat(center[1]);
|
|
const length = Math.hypot(axis[0], axis[1]);
|
|
if (!Number.isFinite(length) || length < 0.001) return [];
|
|
const forward = [axis[0] / length, axis[1] / length];
|
|
const right = [forward[1], -forward[0]];
|
|
return templateFor(normalized, manifest).map((template) =>
|
|
template.map(([rightMeters, forwardMeters]) =>
|
|
addMeters(center, forward, forwardMeters, right, rightMeters, meters),
|
|
),
|
|
);
|
|
}
|
|
|
|
function templateFor(assetId, manifest = loadManifest()) {
|
|
const asset = supportedAssets(manifest).get(assetId);
|
|
if (!asset) throw new Error(`Unsupported or untested turn-lane asset: ${assetId}`);
|
|
return angularTemplate(assetId);
|
|
}
|
|
|
|
function angularTemplate(assetId) {
|
|
const shaftWidth = 0.3;
|
|
const shaftHalf = shaftWidth / 2;
|
|
const straightBase = 1.18;
|
|
const straightTip = 1.92;
|
|
const rectangle = (minX, minY, maxX, maxY) => [
|
|
[minX, minY],
|
|
[maxX, minY],
|
|
[maxX, maxY],
|
|
[minX, maxY],
|
|
[minX, minY],
|
|
];
|
|
const throughHead = () => [
|
|
[0, straightTip],
|
|
[-0.42, straightBase],
|
|
[-shaftHalf, straightBase],
|
|
[-shaftHalf, 0],
|
|
[shaftHalf, 0],
|
|
[shaftHalf, straightBase],
|
|
[0.42, straightBase],
|
|
[0, straightTip],
|
|
];
|
|
const diagonalShaft = (side) => {
|
|
const start = [0, 0.56];
|
|
const end = [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) => {
|
|
const base = [side * 0.6, 0.89];
|
|
const tip = [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) => {
|
|
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)];
|
|
throw new Error(`No angular turn-lane template: ${assetId}`);
|
|
}
|
|
|
|
function sourceSvgTemplateFor(asset, assetId) {
|
|
const source = fs.readFileSync(path.resolve(__dirname, '..', '..', 'assets', 'lane-icons', asset.source), 'utf8');
|
|
const mirrorX = asset.mirror_x === true;
|
|
const anchorX = Number(asset.anchor_x);
|
|
if (!Number.isFinite(anchorX)) throw new Error(`turn-lane asset has invalid anchor_x: ${assetId}`);
|
|
const shapes = [];
|
|
for (const match of source.matchAll(/<line\b([^>]*)\/>|<path\b([^>]*)\/>/g)) {
|
|
const attrs = parseSvgAttrs(match[1] || match[2]);
|
|
const strokeWidth = Number(attrs['stroke-width'] || 0);
|
|
if (match[1]) {
|
|
shapes.push(
|
|
strokePolygon(
|
|
[
|
|
[Number(attrs.x1), Number(attrs.y1)],
|
|
[Number(attrs.x2), Number(attrs.y2)],
|
|
],
|
|
strokeWidth,
|
|
),
|
|
);
|
|
} else {
|
|
const points = parseSvgPath(attrs.d || '');
|
|
if (attrs.fill !== 'none') shapes.push(points);
|
|
if (strokeWidth > 0) shapes.push(strokePolygon(points, strokeWidth));
|
|
}
|
|
}
|
|
return shapes
|
|
.filter((ring) => ring.length >= 4)
|
|
.map((ring) =>
|
|
ring.map(([x, y]) => [
|
|
(mirrorX ? anchorX - x : x - anchorX) * SVG_METERS_PER_UNIT,
|
|
(23 - y) * SVG_METERS_PER_UNIT,
|
|
]),
|
|
);
|
|
}
|
|
|
|
function parseSvgAttrs(text) {
|
|
const attrs = {};
|
|
for (const match of text.matchAll(/([\w:-]+)=(['"])(.*?)\2/g)) attrs[match[1]] = match[3];
|
|
return attrs;
|
|
}
|
|
|
|
function parseSvgPath(value) {
|
|
const tokens = value.match(/[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g) || [];
|
|
let index = 0;
|
|
let command = '';
|
|
let point = [0, 0];
|
|
let start = null;
|
|
const points = [];
|
|
const number = () => Number(tokens[index++]);
|
|
const lineTo = (x, y) => {
|
|
point = [x, y];
|
|
points.push(point);
|
|
};
|
|
while (index < tokens.length) {
|
|
if (/^[a-zA-Z]$/.test(tokens[index])) command = tokens[index++];
|
|
const relative = command === command.toLowerCase();
|
|
const op = command.toUpperCase();
|
|
if (op === 'Z') {
|
|
if (start) points.push(start);
|
|
command = '';
|
|
continue;
|
|
}
|
|
if (op === 'M' || op === 'L') {
|
|
const x = number();
|
|
const y = number();
|
|
const next = relative ? [point[0] + x, point[1] + y] : [x, y];
|
|
if (op === 'M' && !start) {
|
|
start = next;
|
|
point = next;
|
|
points.push(point);
|
|
command = relative ? 'l' : 'L';
|
|
} else lineTo(...next);
|
|
continue;
|
|
}
|
|
if (op === 'H') {
|
|
lineTo(relative ? point[0] + number() : number(), point[1]);
|
|
continue;
|
|
}
|
|
if (op === 'V') {
|
|
lineTo(point[0], relative ? point[1] + number() : number());
|
|
continue;
|
|
}
|
|
if (op === 'C') {
|
|
const values = [number(), number(), number(), number(), number(), number()];
|
|
const controls = relative ? values.map((n, i) => n + point[i % 2]) : values;
|
|
const origin = point;
|
|
for (let step = 1; step <= 8; step += 1) {
|
|
const t = step / 8;
|
|
const u = 1 - t;
|
|
lineTo(
|
|
u ** 3 * origin[0] + 3 * u ** 2 * t * controls[0] + 3 * u * t ** 2 * controls[2] + t ** 3 * controls[4],
|
|
u ** 3 * origin[1] + 3 * u ** 2 * t * controls[1] + 3 * u * t ** 2 * controls[3] + t ** 3 * controls[5],
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
if (op === 'A') {
|
|
number();
|
|
number();
|
|
number();
|
|
number();
|
|
number();
|
|
const x = number();
|
|
const y = number();
|
|
lineTo(relative ? point[0] + x : x, relative ? point[1] + y : y);
|
|
continue;
|
|
}
|
|
throw new Error(`Unsupported SVG path command: ${command}`);
|
|
}
|
|
return points;
|
|
}
|
|
|
|
function strokePolygon(points, width) {
|
|
if (points.length < 2) return [];
|
|
const half = width / 2;
|
|
const left = [];
|
|
const right = [];
|
|
for (let index = 0; index < points.length; index += 1) {
|
|
const prev = points[Math.max(0, index - 1)];
|
|
const next = points[Math.min(points.length - 1, index + 1)];
|
|
const dx = next[0] - prev[0];
|
|
const dy = next[1] - prev[1];
|
|
const length = Math.hypot(dx, dy) || 1;
|
|
const nx = (-dy / length) * half;
|
|
const ny = (dx / length) * half;
|
|
left.push([points[index][0] + nx, points[index][1] + ny]);
|
|
right.unshift([points[index][0] - nx, points[index][1] - ny]);
|
|
}
|
|
return [...left, ...right, left[0]];
|
|
}
|
|
|
|
module.exports = {
|
|
arrowRingsAt,
|
|
buildCustomTurnLaneArrows,
|
|
loadManifest,
|
|
normalizeManeuver,
|
|
supportedAssets,
|
|
templateFor,
|
|
};
|