@drawtonomy/sdk 0.10.0 → 0.11.0

package/dist/exporter/opendrive.js

@@ -26,6 +26,7 @@ import { fitPlanView } from './odrGeometryFit';
 import { originToProjString } from './projection';
 import { escapeXml, fmt, fmtPrecise, pxToEnuX, pxToEnuY, pxToMeter } from './units';
 import { extractOdrDocument, hashRoadState, rewriteRoadLinkTargets, } from './odrCarryThrough';
+import { trafficSignCode } from './lanelet2';
 /** O(1) shape lookup by id. */
 function buildShapeMap(shapes) {
     const map = new Map();
@@ -1076,7 +1077,7 @@ function laneIdRanges(ids) {
     ranges.push({ fromLane: start, toLane: prev });
     return ranges;
 }
-function attachShapesToRoads(shapeMap, trafficLights, crosswalks, polygons, roads, laneIdToRoadId, laneIdToOdrLaneId, maxAttachDistanceMeter = 50, signalIdStart = 1) {
+function attachShapesToRoads(shapeMap, trafficLights, trafficSigns, crosswalks, polygons, roads, laneIdToRoadId, laneIdToOdrLaneId, maxAttachDistanceMeter = 50, signalIdStart = 1) {
     const roadSignals = new Map();
     const roadObjects = new Map();
     const roadSignalRefs = new Map();
@@ -1101,7 +1102,14 @@ function attachShapesToRoads(shapeMap, trafficLights, crosswalks, polygons, road
         }
         return byRoad;
     };
-    for (const tl of trafficLights) {
+    // Traffic lights (dynamic signals) and traffic signs (static signals)
+    // attach to roads through the same projection / validity machinery; only
+    // the emitted <signal> attributes differ per kind.
+    const signalShapes = [
+        ...trafficLights.map(shape => ({ kind: 'traffic_light', shape })),
+        ...trafficSigns.map(shape => ({ kind: 'traffic_sign', shape })),
+    ];
+    for (const { kind, shape: tl } of signalShapes) {
         const xG = pxToEnuX(tl.x);
         const yG = pxToEnuY(tl.y);
         // Regulatory layer: a signal that names affected lanes attaches to the
@@ -1131,26 +1139,61 @@ function attachShapesToRoads(shapeMap, trafficLights, crosswalks, polygons, road
         }
         if (!best)
             continue;
-        const style = tl.props.style ?? '';
-        const isPed = style.startsWith('pedestrian') || style.includes('ped');
-        // Conventional signal type codes: 1000001 = vehicle, 1000002 = pedestrian.
-        const sigType = isPed ? '1000002' : '1000001';
         const heightM = pxToMeter(tl.props.h);
         const widthM = pxToMeter(tl.props.w);
         const list = roadSignals.get(best.roadId) ?? [];
-        const entry = {
-            id: signalIdCounter++,
-            s: best.proj.s,
-            t: best.proj.t,
-            zOffset: isPed ? 1.5 : 4.5,
-            height: heightM,
-            width: widthM,
-            name: style,
-            type: sigType,
-            subtype: '-1',
-            dynamic: 'yes',
-            orientation: best.proj.t >= 0 ? '+' : '-',
-        };
+        let entry;
+        if (kind === 'traffic_light') {
+            const style = tl.props.style ?? '';
+            const isPed = style.startsWith('pedestrian') || style.includes('ped');
+            // Conventional signal type codes: 1000001 = vehicle, 1000002 = pedestrian.
+            const sigType = isPed ? '1000002' : '1000001';
+            entry = {
+                id: signalIdCounter++,
+                s: best.proj.s,
+                t: best.proj.t,
+                zOffset: isPed ? 1.5 : 4.5,
+                height: heightM,
+                width: widthM,
+                name: style,
+                type: sigType,
+                subtype: '-1',
+                dynamic: 'yes',
+                orientation: best.proj.t >= 0 ? '+' : '-',
+            };
+        }
+        else {
+            // Static traffic sign: reuse the exact OpenDRIVE type / subtype /
+            // country recorded at import time; fresh signs fall back to type "-1"
+            // with the sign code as the name. Full attribute round-trip rides on
+            // <userData code="signAttributes">.
+            const attrs = (tl.props.attributes ?? {});
+            entry = {
+                id: signalIdCounter++,
+                s: best.proj.s,
+                t: best.proj.t,
+                zOffset: 2,
+                height: heightM,
+                width: widthM,
+                name: trafficSignCode(attrs),
+                type: attrs.odr_signal_type || '-1',
+                subtype: attrs.odr_signal_subtype || '-1',
+                country: attrs.odr_country || undefined,
+                dynamic: 'no',
+                orientation: best.proj.t >= 0 ? '+' : '-',
+            };
+            const stash = {};
+            for (const [k, v] of Object.entries(attrs)) {
+                if (k === 'type' || k === 'refers_osm_id' || k.startsWith('odr_'))
+                    continue;
+                if (v === undefined || v === null || v === '')
+                    continue;
+                stash[k] = String(v);
+            }
+            if (Object.keys(stash).length > 0) {
+                entry.userData = [{ code: 'signAttributes', value: JSON.stringify(stash) }];
+            }
+        }
         if (affectedByRoad.size > 0) {
             entry.validity = laneIdRanges(affectedByRoad.get(best.roadId));
         }
@@ -1389,8 +1432,8 @@ function emitSignals(signals, references) {
     const lines = [];
     lines.push(`    <signals>`);
     for (const s of signals) {
-        const attrs = `id="${s.id}" s="${fmt(s.s)}" t="${fmt(s.t)}" zOffset="${fmt(s.zOffset)}" name="${escapeXml(s.name)}" dynamic="${s.dynamic}" orientation="${s.orientation}" type="${s.type}" subtype="${s.subtype}" country="OpenDRIVE" value="0" height="${fmt(s.height)}" width="${fmt(s.width)}"`;
-        if (s.validity?.length || s.stopLinePoints) {
+        const attrs = `id="${s.id}" s="${fmt(s.s)}" t="${fmt(s.t)}" zOffset="${fmt(s.zOffset)}" name="${escapeXml(s.name)}" dynamic="${s.dynamic}" orientation="${s.orientation}" type="${s.type}" subtype="${s.subtype}" country="${escapeXml(s.country ?? 'OpenDRIVE')}" value="0" height="${fmt(s.height)}" width="${fmt(s.width)}"`;
+        if (s.validity?.length || s.stopLinePoints || s.userData?.length) {
             lines.push(`      <signal ${attrs}>`);
             for (const v of s.validity ?? []) {
                 lines.push(`        <validity fromLane="${v.fromLane}" toLane="${v.toLane}"/>`);
@@ -1399,6 +1442,9 @@ function emitSignals(signals, references) {
                 const json = JSON.stringify(s.stopLinePoints.map((p) => [roundMm(p.x), roundMm(p.y)]));
                 lines.push(`        <userData code="stopLine" value="${escapeXml(json)}"/>`);
             }
+            for (const ud of s.userData ?? []) {
+                lines.push(`        <userData code="${escapeXml(ud.code)}" value="${escapeXml(ud.value)}"/>`);
+            }
             lines.push(`      </signal>`);
         }
         else {
@@ -1610,7 +1656,7 @@ const NO_OVERRIDES = new Map();
  * Roads referencing unrecorded elements (e.g. a selective import) are never
  * carried verbatim, so verbatim output cannot dangle into missing roads.
  */
-function planCarryThrough(sidecar, shapeMap, trafficLights, crosswalks) {
+function planCarryThrough(sidecar, shapeMap, trafficLights, trafficSigns, crosswalks) {
     const records = sidecar?.roadRecords;
     if (!sidecar || !records || Object.keys(records).length === 0)
         return null;
@@ -1665,6 +1711,17 @@ function planCarryThrough(sidecar, shapeMap, trafficLights, crosswalks) {
             controllerId: tl.props.controllerId ?? '',
         }, tl.props.affectedLaneIds ?? [], tl.props.attributes?.odr_road_id);
     }
+    for (const ts of trafficSigns) {
+        addRegState({
+            kind: 'traffic_sign',
+            shapeId: ts.id,
+            numbers: [ts.x, ts.y, ts.props.w, ts.props.h, ts.rotation || 0],
+            attributes: ts.props.attributes ?? {},
+            affectedLaneIds: ts.props.affectedLaneIds ?? [],
+            stopLinePts: stopLinePts(ts.props.stopLineId),
+            controllerId: '',
+        }, ts.props.affectedLaneIds ?? [], ts.props.attributes?.odr_road_id);
+    }
     for (const cw of crosswalks) {
         addRegState({
             kind: 'crosswalk',
@@ -1872,6 +1929,7 @@ export function exportToOpenDrive(snapshot, options = {}) {
     const shapeMap = buildShapeMap(shapes);
     const lanes = [];
     const trafficLights = [];
+    const trafficSigns = [];
     const crosswalks = [];
     const polygons = [];
     for (const s of shapes) {
@@ -1879,6 +1937,8 @@ export function exportToOpenDrive(snapshot, options = {}) {
             lanes.push(s);
         else if (s.type === 'traffic_light')
             trafficLights.push(s);
+        else if (s.type === 'traffic_sign')
+            trafficSigns.push(s);
         else if (s.type === 'crosswalk')
             crosswalks.push(s);
         else if (s.type === 'polygon') {
@@ -1895,11 +1955,14 @@ export function exportToOpenDrive(snapshot, options = {}) {
     }
     // Carry-through: with an importer sidecar, unedited original roads are
     // re-emitted verbatim and excluded from regeneration.
-    const carry = planCarryThrough(options.sidecar, shapeMap, trafficLights, crosswalks);
+    const carry = planCarryThrough(options.sidecar, shapeMap, trafficLights, trafficSigns, crosswalks);
     const regenLanes = carry ? lanes.filter(l => !carry.verbatimLaneIds.has(l.id)) : lanes;
     const regenTrafficLights = carry
         ? trafficLights.filter(t => !carry.consumedShapeIds.has(t.id))
         : trafficLights;
+    const regenTrafficSigns = carry
+        ? trafficSigns.filter(t => !carry.consumedShapeIds.has(t.id))
+        : trafficSigns;
     const regenCrosswalks = carry
         ? crosswalks.filter(c => !carry.consumedShapeIds.has(c.id))
         : crosswalks;
@@ -2113,7 +2176,7 @@ export function exportToOpenDrive(snapshot, options = {}) {
     };
     const plan = planConnectivity(exportBundles, laneIdToRoadId, laneIdToOdrLaneId, nextRoadId, connectingSourceFor, connectingTargetFor, contactWidth, externalLanes);
     const roads = exportBundles.map(b => ({ roadId: roadIdByBundle.get(b), geom: b.geom }));
-    const { roadSignals, roadObjects, roadSignalRefs, signalIdByShape } = attachShapesToRoads(shapeMap, regenTrafficLights, regenCrosswalks, polygons, roads, laneIdToRoadId, laneIdToOdrLaneId, undefined, carry?.signalIdBase);
+    const { roadSignals, roadObjects, roadSignalRefs, signalIdByShape } = attachShapesToRoads(shapeMap, regenTrafficLights, regenTrafficSigns, regenCrosswalks, polygons, roads, laneIdToRoadId, laneIdToOdrLaneId, undefined, carry?.signalIdBase);
     // Verbatim road blocks first (original document order). Two minimal
     // rewrites keep their links valid; nothing else is touched:
     // - road links to a dirty road whose lanes regenerated into exactly one