@drawtonomy/sdk 0.7.0 → 0.9.0

package/dist/exporter/opendrive.js

@@ -1,13 +1,18 @@
 // OpenDRIVE 1.8 (.xodr) exporter — emits a road network from a snapshot.
 // No external library dependencies.
 //
-// Design (Phase 1):
-// - Each lane is emitted as an independent <road> (junctions are out of scope)
+// Design:
+// - Each lane is emitted as an independent <road>
 // - Reference line is the midpoints of the left/right boundary samples
 // - Each segment is a <line> geometry; lane width is a per-sample <width>
-// - Lane connectivity (next/prev) is written into <link>
+// - Lane connectivity (next/prev) is written into <link>; branch/merge edges
+//   that a single road link cannot express are synthesized into <junction>
+//   elements (see planJunctions)
+// - Lanelet-only lane tags are stashed in <userData code="laneAttributes">
+//   and restored on import; multi-road signal validity uses <signalReference>
 // - Coordinate frame: canvas (x right, y down) → ENU (x right, y up); y is flipped
 import { computeCenterlineWithWidth } from './laneCenterline';
+import { originToProjString } from './projection';
 import { escapeXml, fmt, pxToEnuX, pxToEnuY, pxToMeter } from './units';
 /** O(1) shape lookup by id. */
 function buildShapeMap(shapes) {
@@ -91,7 +96,7 @@ function buildBoundaryAlignmentOverrides(shapeMap, lanes, epsilonPx = 30) {
             const pt = shapeMap.get(pid);
             if (!pt)
                 continue;
-            endpoints.push({ pointId: pid, x: pt.x, y: pt.y });
+            endpoints.push({ pointId: pid, laneId: lane.id, side, x: pt.x, y: pt.y });
         }
     };
     // Restrict to lanes that participate in a next/prev relationship.
@@ -103,22 +108,37 @@ function buildBoundaryAlignmentOverrides(shapeMap, lanes, epsilonPx = 30) {
         if (hasPrev)
             collectEndpoints(lane, 'start');
     }
-    // Greedy clustering: group points within epsilon of each other.
+    // Greedy clustering: group points within epsilon of each other, with two
+    // refinements over plain first-fit grouping:
+    // 1. An endpoint never joins a cluster that already holds the opposite end
+    //    of the same lane. A connecting lane shorter than epsilon would
+    //    otherwise get its start and end merged into one cluster, collapsing
+    //    its centerline below the degenerate-road export guard and silently
+    //    dropping the lane (and its next/prev chain).
+    // 2. Among the eligible clusters the nearest one wins, so the far end of a
+    //    short lane clusters with its true counterpart rather than with the
+    //    first cluster found within epsilon.
     const clusters = [];
     const eps2 = epsilonPx * epsilonPx;
     for (const ep of endpoints) {
-        let placed = false;
+        let best = null;
+        let bestD2 = Infinity;
         for (const cluster of clusters) {
             const c0 = cluster[0];
             const dx = ep.x - c0.x;
             const dy = ep.y - c0.y;
-            if (dx * dx + dy * dy <= eps2) {
-                cluster.push(ep);
-                placed = true;
-                break;
-            }
+            const d2 = dx * dx + dy * dy;
+            if (d2 > eps2 || d2 >= bestD2)
+                continue;
+            const conflictsOwnLane = cluster.some((m) => m.laneId === ep.laneId && m.side !== ep.side);
+            if (conflictsOwnLane)
+                continue;
+            best = cluster;
+            bestD2 = d2;
         }
-        if (!placed)
+        if (best)
+            best.push(ep);
+        else
             clusters.push([ep]);
     }
     // Use each cluster centroid as the snapped position.
@@ -160,31 +180,58 @@ function emitPlanView(geom) {
     lines.push(`    </planView>`);
     return lines.join('\n');
 }
-function emitLanes(geom, hasPrev, hasNext) {
+/**
+ * Map a lanelet-style lane subtype to an OpenDRIVE lane type. The exact
+ * OpenDRIVE type wins when the lane carries `odr_type` (set by the OpenDRIVE
+ * importer), so imported maps round-trip their lane types.
+ */
+const LANELET_SUBTYPE_TO_ODR_TYPE = {
+    road: 'driving',
+    highway: 'driving',
+    play_street: 'driving',
+    emergency_lane: 'shoulder',
+    bus_lane: 'bus',
+    bicycle_lane: 'biking',
+    walkway: 'sidewalk',
+    shared_walkway: 'sidewalk',
+    stairs: 'sidewalk',
+    crosswalk: 'walking',
+    exit: 'exit',
+};
+function odrLaneTypeFor(lane) {
+    const attrs = lane.props.attributes ?? {};
+    if (attrs.odr_type)
+        return attrs.odr_type;
+    return LANELET_SUBTYPE_TO_ODR_TYPE[attrs.subtype ?? ''] ?? 'driving';
+}
+/** Road mark type for a boundary linestring (dashed subtype -> broken). */
+function roadMarkTypeFor(shapeMap, boundaryId) {
+    if (!boundaryId)
+        return 'solid';
+    const ls = shapeMap.get(boundaryId);
+    return ls?.props?.attributes?.subtype === 'dashed' ? 'broken' : 'solid';
+}
+function emitLanes(geom, hasPrev, hasNext, laneType, centerMark, outerMark) {
     const lines = [];
     lines.push(`    <lanes>`);
+    // The plan view follows the lane centerline; shifting the lane reference by
+    // +width/2 puts center lane 0 on the lane's left boundary, so a single
+    // right lane (-1) spans the full lane width. One drawtonomy lane therefore
+    // maps to exactly one OpenDRIVE driving lane (not two half-width lanes).
+    emitLaneOffsetEntries(geom, lines);
     lines.push(`      <laneSection s="0">`);
-    // Left side: id=+1 (OpenDRIVE numbers lanes positively to the left of the reference line).
-    lines.push(`        <left>`);
-    lines.push(`          <lane id="1" type="driving" level="false">`);
-    emitLaneLink(lines, hasPrev, hasNext, 1);
-    emitHalfWidthEntries(geom, lines);
-    lines.push(`            <roadMark sOffset="0" type="solid" weight="standard" color="white" width="0.13"/>`);
-    lines.push(`          </lane>`);
-    lines.push(`        </left>`);
-    // Center reference line.
+    // Center reference line (= left boundary after the laneOffset shift).
     lines.push(`        <center>`);
     lines.push(`          <lane id="0" type="none" level="false">`);
     lines.push(`            <link/>`);
-    lines.push(`            <roadMark sOffset="0" type="solid" weight="standard" color="standard" width="0.13"/>`);
+    lines.push(`            <roadMark sOffset="0" type="${centerMark}" weight="standard" color="white" width="0.13"/>`);
     lines.push(`          </lane>`);
     lines.push(`        </center>`);
-    // Right side: id=-1.
     lines.push(`        <right>`);
-    lines.push(`          <lane id="-1" type="driving" level="false">`);
+    lines.push(`          <lane id="-1" type="${laneType}" level="false">`);
     emitLaneLink(lines, hasPrev, hasNext, -1);
-    emitHalfWidthEntries(geom, lines);
-    lines.push(`            <roadMark sOffset="0" type="solid" weight="standard" color="white" width="0.13"/>`);
+    emitWidthEntries(geom, lines);
+    lines.push(`            <roadMark sOffset="0" type="${outerMark}" weight="standard" color="white" width="0.13"/>`);
     lines.push(`          </lane>`);
     lines.push(`        </right>`);
     lines.push(`      </laneSection>`);
@@ -205,28 +252,139 @@ function emitLaneLink(out, hasPrev, hasNext, laneId) {
     }
     out.push(`            </link>`);
 }
-function emitHalfWidthEntries(geom, out) {
+/** Piecewise-linear laneOffset records: +width/2 toward the left boundary. */
+function emitLaneOffsetEntries(geom, out) {
     for (let i = 0; i < geom.odrSamples.length - 1; i++) {
         const s = geom.odrSamples[i].s;
         const halfA = geom.odrSamples[i].width / 2;
         const halfB = geom.odrSamples[i + 1].width / 2;
         const segLen = geom.odrSamples[i + 1].s - s;
-        // Linear fit a + b*ds (c=d=0).
-        const a = halfA;
         const b = segLen > 1e-9 ? (halfB - halfA) / segLen : 0;
-        out.push(`            <width sOffset="${fmt(s)}" a="${fmt(a)}" b="${fmt(b)}" c="0" d="0"/>`);
+        out.push(`      <laneOffset s="${fmt(s)}" a="${fmt(halfA)}" b="${fmt(b)}" c="0" d="0"/>`);
+    }
+}
+/** Piecewise-linear full lane width records: a + b*ds (c=d=0). */
+function emitWidthEntries(geom, out) {
+    for (let i = 0; i < geom.odrSamples.length - 1; i++) {
+        const s = geom.odrSamples[i].s;
+        const wA = geom.odrSamples[i].width;
+        const wB = geom.odrSamples[i + 1].width;
+        const segLen = geom.odrSamples[i + 1].s - s;
+        const b = segLen > 1e-9 ? (wB - wA) / segLen : 0;
+        out.push(`            <width sOffset="${fmt(s)}" a="${fmt(wA)}" b="${fmt(b)}" c="0" d="0"/>`);
+    }
+}
+/**
+ * Plan synthesized <junction> elements for branch / merge connectivity.
+ *
+ * A road <link> can name only one predecessor and one successor, so an edge
+ * is representable as plain road links only when it is its source's only
+ * `next` AND its target's only `prev`. Every other edge (branching or
+ * merging) is routed through a synthesized junction: the target roads become
+ * connecting roads (their <road junction> attribute is set) and each edge is
+ * emitted as a <connection incomingRoad connectingRoad contactPoint="start">
+ * carrying a <laneLink from="-1" to="-1"/> (the exporter emits exactly one
+ * driving lane -1 per road). Edges that share a lane collapse into the same
+ * junction (connected components), so a 2-in x 2-out diamond becomes one
+ * junction with four connections.
+ */
+function planJunctions(lanes, laneIdToRoadId, firstJunctionId) {
+    const validNext = new Map();
+    const validPrev = new Map();
+    for (const lane of lanes) {
+        if (!laneIdToRoadId.has(lane.id))
+            continue;
+        validNext.set(lane.id, (lane.props.next ?? []).filter((id) => laneIdToRoadId.has(id)));
+        validPrev.set(lane.id, (lane.props.prev ?? []).filter((id) => laneIdToRoadId.has(id)));
+    }
+    // Union-find over the lanes participating in junction-routed edges.
+    const parent = new Map();
+    const find = (x) => {
+        let root = x;
+        while (true) {
+            const p = parent.get(root);
+            if (p === undefined || p === root)
+                break;
+            root = p;
+        }
+        let cur = x;
+        while (cur !== root) {
+            const p = parent.get(cur);
+            parent.set(cur, root);
+            cur = p;
+        }
+        return root;
+    };
+    const union = (a, b) => {
+        if (!parent.has(a))
+            parent.set(a, a);
+        if (!parent.has(b))
+            parent.set(b, b);
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            parent.set(rb, ra);
+    };
+    const junctionEdges = [];
+    for (const [laneId, nexts] of validNext) {
+        for (const to of nexts) {
+            const prevsOfTarget = validPrev.get(to) ?? [];
+            if (nexts.length === 1 && prevsOfTarget.length === 1)
+                continue; // plain road link
+            junctionEdges.push({ from: laneId, to });
+            union(laneId, to);
+        }
+    }
+    const plan = {
+        nextJunction: new Map(),
+        prevJunction: new Map(),
+        roadJunction: new Map(),
+        junctions: [],
+    };
+    const junctionByRoot = new Map();
+    let nextId = firstJunctionId;
+    for (const e of junctionEdges) {
+        const root = find(e.from);
+        let junction = junctionByRoot.get(root);
+        if (!junction) {
+            junction = { id: nextId++, connections: [] };
+            junctionByRoot.set(root, junction);
+            plan.junctions.push(junction);
+        }
+        junction.connections.push({
+            incoming: laneIdToRoadId.get(e.from),
+            connecting: laneIdToRoadId.get(e.to),
+        });
+        plan.nextJunction.set(e.from, junction.id);
+        plan.prevJunction.set(e.to, junction.id);
+        plan.roadJunction.set(e.to, junction.id);
     }
+    return plan;
 }
-function emitLink(lane, laneIdToRoadId) {
+function emitLink(lane, laneIdToRoadId, junctionPlan) {
     const lines = [];
     lines.push(`    <link>`);
-    if (lane.props.prev?.[0] && laneIdToRoadId.has(lane.props.prev[0])) {
-        const rid = laneIdToRoadId.get(lane.props.prev[0]);
-        lines.push(`      <predecessor elementType="road" elementId="${rid}" contactPoint="end"/>`);
+    const prevJunction = junctionPlan.prevJunction.get(lane.id);
+    if (prevJunction !== undefined) {
+        lines.push(`      <predecessor elementType="junction" elementId="${prevJunction}"/>`);
+    }
+    else {
+        const prevLane = (lane.props.prev ?? []).find((id) => laneIdToRoadId.has(id));
+        if (prevLane) {
+            const rid = laneIdToRoadId.get(prevLane);
+            lines.push(`      <predecessor elementType="road" elementId="${rid}" contactPoint="end"/>`);
+        }
+    }
+    const nextJunction = junctionPlan.nextJunction.get(lane.id);
+    if (nextJunction !== undefined) {
+        lines.push(`      <successor elementType="junction" elementId="${nextJunction}"/>`);
     }
-    if (lane.props.next?.[0] && laneIdToRoadId.has(lane.props.next[0])) {
-        const rid = laneIdToRoadId.get(lane.props.next[0]);
-        lines.push(`      <successor elementType="road" elementId="${rid}" contactPoint="start"/>`);
+    else {
+        const nextLane = (lane.props.next ?? []).find((id) => laneIdToRoadId.has(id));
+        if (nextLane) {
+            const rid = laneIdToRoadId.get(nextLane);
+            lines.push(`      <successor elementType="road" elementId="${rid}" contactPoint="start"/>`);
+        }
     }
     lines.push(`    </link>`);
     return lines.join('\n');
@@ -275,9 +433,11 @@ function projectToRoad(geom, xG, yG) {
     }
     return { s: bestS, t: bestT, hdg: bestHdg, distance: bestDist, clampedAtEnd: bestClamped };
 }
-function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, laneIdToRoadId, maxAttachDistanceMeter = 50) {
+function attachShapesToRoads(shapeMap, trafficLights, crosswalks, polygons, laneToGeom, laneIdToRoadId, maxAttachDistanceMeter = 50) {
     const roadSignals = new Map();
     const roadObjects = new Map();
+    const roadSignalRefs = new Map();
+    const signalIdByShape = new Map();
     let signalIdCounter = 1;
     let objectIdCounter = 1;
     const roads = [];
@@ -286,16 +446,43 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
         if (roadId !== undefined)
             roads.push({ laneId, geom, roadId });
     });
+    const geomByRoadId = new Map();
+    for (const r of roads)
+        geomByRoadId.set(r.roadId, r.geom);
     for (const tl of trafficLights) {
         const xG = pxToEnuX(tl.x);
         const yG = pxToEnuY(tl.y);
+        // Regulatory layer: a signal that names affected lanes attaches to the
+        // nearest of those lanes' roads and carries a <validity> record for the
+        // road's single driving lane (-1). Distance gating does not apply — the
+        // assignment is explicit.
+        const affectedRoadIds = new Set();
+        for (const laneShapeId of tl.props.affectedLaneIds ?? []) {
+            const rid = laneIdToRoadId.get(laneShapeId);
+            if (rid !== undefined)
+                affectedRoadIds.add(rid);
+        }
         let best = null;
-        for (const r of roads) {
-            const proj = projectToRoad(r.geom, xG, yG);
-            if (!best || proj.distance < best.proj.distance)
-                best = { roadId: r.roadId, proj };
+        if (affectedRoadIds.size > 0) {
+            for (const r of roads) {
+                if (!affectedRoadIds.has(r.roadId))
+                    continue;
+                const proj = projectToRoad(r.geom, xG, yG);
+                if (!best || proj.distance < best.proj.distance)
+                    best = { roadId: r.roadId, proj };
+            }
         }
-        if (!best || best.proj.distance > maxAttachDistanceMeter)
+        else {
+            // Fall back to the nearest road within the attachment distance.
+            for (const r of roads) {
+                const proj = projectToRoad(r.geom, xG, yG);
+                if (!best || proj.distance < best.proj.distance)
+                    best = { roadId: r.roadId, proj };
+            }
+            if (best && best.proj.distance > maxAttachDistanceMeter)
+                best = null;
+        }
+        if (!best)
             continue;
         const style = tl.props.style ?? '';
         const isPed = style.startsWith('pedestrian') || style.includes('ped');
@@ -304,7 +491,7 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
         const heightM = pxToMeter(tl.props.h);
         const widthM = pxToMeter(tl.props.w);
         const list = roadSignals.get(best.roadId) ?? [];
-        list.push({
+        const entry = {
             id: signalIdCounter++,
             s: best.proj.s,
             t: best.proj.t,
@@ -316,8 +503,69 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
             subtype: '-1',
             dynamic: 'yes',
             orientation: best.proj.t >= 0 ? '+' : '-',
-        });
+        };
+        if (affectedRoadIds.size > 0) {
+            // The exporter emits one driving lane (-1) per road.
+            entry.validity = { fromLane: -1, toLane: -1 };
+        }
+        list.push(entry);
         roadSignals.set(best.roadId, list);
+        signalIdByShape.set(tl.id, entry.id);
+        // A signal controlling several lanes spans several roads in the
+        // 1-lane-per-road model. The remaining affected roads get a standard
+        // <signalReference> pointing back at the signal so the validity links
+        // survive a round trip (and ODR consumers see the full coverage).
+        if (affectedRoadIds.size > 1) {
+            for (const r of roads) {
+                if (r.roadId === best.roadId || !affectedRoadIds.has(r.roadId))
+                    continue;
+                const proj = projectToRoad(r.geom, xG, yG);
+                const refs = roadSignalRefs.get(r.roadId) ?? [];
+                refs.push({
+                    id: entry.id,
+                    s: proj.s,
+                    t: proj.t,
+                    orientation: proj.t >= 0 ? '+' : '-',
+                });
+                roadSignalRefs.set(r.roadId, refs);
+            }
+        }
+        // Stop line: emitted on the signal's road as a conventional
+        // <object name="StopLine"> at the projected station of the line's midpoint.
+        if (tl.props.stopLineId) {
+            const stopLs = shapeMap.get(tl.props.stopLineId);
+            const pts = stopLs
+                ? collectPoints(shapeMap, stopLs.props.pointIds, false, new Map())
+                : [];
+            if (pts.length >= 2) {
+                // Carry the full polyline (ENU meters) on the signal so an importer
+                // can rebuild the stop-line linestring and re-link it to the signal.
+                entry.stopLinePoints = pts.map((p) => ({ x: pxToEnuX(p.x), y: pxToEnuY(p.y) }));
+                const a = pts[0];
+                const b = pts[pts.length - 1];
+                const midX = pxToEnuX((a.x + b.x) / 2);
+                const midY = pxToEnuY((a.y + b.y) / 2);
+                const geom = geomByRoadId.get(best.roadId);
+                const proj = projectToRoad(geom, midX, midY);
+                const objList = roadObjects.get(best.roadId) ?? [];
+                objList.push({
+                    id: objectIdCounter++,
+                    s: proj.s,
+                    t: proj.t,
+                    zOffset: 0,
+                    // Stop lines lie across the road (like crosswalks): local hdg = π/2,
+                    // length spanning the painted line, conventional 0.3 m paint width.
+                    hdg: Math.PI / 2,
+                    length: pxToMeter(Math.hypot(b.x - a.x, b.y - a.y)),
+                    width: 0.3,
+                    height: 0,
+                    name: 'StopLine',
+                    type: 'none',
+                    orientation: 'none',
+                });
+                roadObjects.set(best.roadId, objList);
+            }
+        }
     }
     for (const cw of crosswalks) {
         const rotDeg = cw.rotation || 0;
@@ -330,13 +578,35 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
         const cyGlobal = cw.y + cyLocal;
         const xG = pxToEnuX(cxGlobal);
         const yG = pxToEnuY(cyGlobal);
+        // Regulatory layer: a crosswalk that names affected lanes attaches to the
+        // nearest of those lanes' roads (no distance gate — the assignment is
+        // explicit), mirroring the signal behavior above.
+        const affectedRoadIds = new Set();
+        for (const laneShapeId of cw.props.affectedLaneIds ?? []) {
+            const rid = laneIdToRoadId.get(laneShapeId);
+            if (rid !== undefined)
+                affectedRoadIds.add(rid);
+        }
         let best = null;
-        for (const r of roads) {
-            const proj = projectToRoad(r.geom, xG, yG);
-            if (!best || proj.distance < best.proj.distance)
-                best = { roadId: r.roadId, proj };
+        if (affectedRoadIds.size > 0) {
+            for (const r of roads) {
+                if (!affectedRoadIds.has(r.roadId))
+                    continue;
+                const proj = projectToRoad(r.geom, xG, yG);
+                if (!best || proj.distance < best.proj.distance)
+                    best = { roadId: r.roadId, proj };
+            }
         }
-        if (!best || best.proj.distance > maxAttachDistanceMeter)
+        else {
+            for (const r of roads) {
+                const proj = projectToRoad(r.geom, xG, yG);
+                if (!best || proj.distance < best.proj.distance)
+                    best = { roadId: r.roadId, proj };
+            }
+            if (best && best.proj.distance > maxAttachDistanceMeter)
+                best = null;
+        }
+        if (!best)
             continue;
         const dxLocal = cw.props.endX - cw.props.startX;
         const dyLocal = cw.props.endY - cw.props.startY;
@@ -358,6 +628,23 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
         // π/2 regardless of the user-drawn axis direction.
         void relativeHdg;
         const crosswalkHdg = Math.PI / 2;
+        // Regulatory links (affected roads + stop line polyline) ride along as
+        // <userData> — OpenDRIVE's standard extension mechanism — so they survive
+        // an .xodr round trip. Coordinates are ENU meters.
+        const userData = [];
+        if (affectedRoadIds.size > 0) {
+            const links = {
+                affectedRoads: [...affectedRoadIds].sort((a, b) => a - b).map(String),
+            };
+            if (cw.props.stopLineId) {
+                const stopLs = shapeMap.get(cw.props.stopLineId);
+                const pts = stopLs ? collectPoints(shapeMap, stopLs.props.pointIds, false, new Map()) : [];
+                if (pts.length >= 2) {
+                    links.stopLine = pts.map((p) => [roundMm(pxToEnuX(p.x)), roundMm(pxToEnuY(p.y))]);
+                }
+            }
+            userData.push({ code: 'crosswalkLinks', value: JSON.stringify(links) });
+        }
         list.push({
             id: objectIdCounter++,
             s: best.proj.s,
@@ -370,6 +657,7 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
             name: 'crosswalk',
             type: 'crosswalk',
             orientation: 'none',
+            userData: userData.length ? userData : undefined,
         });
         roadObjects.set(best.roadId, list);
     }
@@ -444,19 +732,42 @@ function attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, la
         });
         roadObjects.set(best.roadId, list);
     }
-    return { roadSignals, roadObjects };
+    return { roadSignals, roadObjects, roadSignalRefs, signalIdByShape };
 }
-function emitSignals(signals) {
-    if (!signals.length)
+function emitSignals(signals, references) {
+    if (!signals.length && !references.length)
         return `    <signals/>`;
     const lines = [];
     lines.push(`    <signals>`);
     for (const s of signals) {
-        lines.push(`      <signal 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)}"/>`);
+        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 || s.stopLinePoints) {
+            lines.push(`      <signal ${attrs}>`);
+            if (s.validity) {
+                lines.push(`        <validity fromLane="${s.validity.fromLane}" toLane="${s.validity.toLane}"/>`);
+            }
+            if (s.stopLinePoints) {
+                const json = JSON.stringify(s.stopLinePoints.map((p) => [roundMm(p.x), roundMm(p.y)]));
+                lines.push(`        <userData code="stopLine" value="${escapeXml(json)}"/>`);
+            }
+            lines.push(`      </signal>`);
+        }
+        else {
+            lines.push(`      <signal ${attrs}/>`);
+        }
+    }
+    for (const ref of references) {
+        lines.push(`      <signalReference s="${fmt(ref.s)}" t="${fmt(ref.t)}" id="${ref.id}" orientation="${ref.orientation}">`);
+        lines.push(`        <validity fromLane="-1" toLane="-1"/>`);
+        lines.push(`      </signalReference>`);
     }
     lines.push(`    </signals>`);
     return lines.join('\n');
 }
+/** Round to millimeter precision for compact embedded JSON. */
+function roundMm(v) {
+    return Math.round(v * 1000) / 1000;
+}
 function emitObjects(objects) {
     if (!objects.length)
         return `    <objects/>`;
@@ -477,20 +788,89 @@ function emitObjects(objects) {
             lines.push(`      </object>`);
         }
         else {
-            lines.push(`      <object id="${o.id}" s="${fmt(o.s)}" t="${fmt(o.t)}" zOffset="${fmt(o.zOffset)}" hdg="${fmt(o.hdg)}" name="${escapeXml(o.name)}" type="${o.type}" orientation="${o.orientation}" length="${fmt(o.length)}" width="${fmt(o.width)}" height="${fmt(o.height)}"/>`);
+            const attrs = `id="${o.id}" s="${fmt(o.s)}" t="${fmt(o.t)}" zOffset="${fmt(o.zOffset)}" hdg="${fmt(o.hdg)}" name="${escapeXml(o.name)}" type="${o.type}" orientation="${o.orientation}" length="${fmt(o.length)}" width="${fmt(o.width)}" height="${fmt(o.height)}"`;
+            if (o.userData?.length) {
+                lines.push(`      <object ${attrs}>`);
+                for (const ud of o.userData) {
+                    lines.push(`        <userData code="${escapeXml(ud.code)}" value="${escapeXml(ud.value)}"/>`);
+                }
+                lines.push(`      </object>`);
+            }
+            else {
+                lines.push(`      <object ${attrs}/>`);
+            }
         }
     }
     lines.push(`    </objects>`);
     return lines.join('\n');
 }
-function emitRoad(lane, geom, roadId, laneIdToRoadId, signals, objects) {
+/**
+ * Lane attributes that have no OpenDRIVE representation (speed_limit only
+ * partially maps, one_way / turn_direction / location and custom tags not at
+ * all) are stashed verbatim as JSON in <userData code="laneAttributes"> —
+ * OpenDRIVE's standard extension mechanism — and restored by the importer.
+ * `odr_*` meta attributes are excluded: they are regenerated on import.
+ */
+function emitLaneAttributesUserData(lane) {
+    const stash = {};
+    for (const [k, v] of Object.entries(lane.props.attributes ?? {})) {
+        if (k === 'type' || k.startsWith('odr_'))
+            continue;
+        if (v === undefined || v === null || v === '')
+            continue;
+        stash[k] = String(v);
+    }
+    if (Object.keys(stash).length === 0)
+        return null;
+    return `    <userData code="laneAttributes" value="${escapeXml(JSON.stringify(stash))}"/>`;
+}
+/**
+ * Right-of-way links (`yieldLaneIds`) have no canonical OpenDRIVE road-level
+ * representation in this exporter (junction <priority> mapping is out of
+ * scope), so the yielding lanes' road ids are stashed in
+ * <userData code="yieldRoads"> and restored by the importer.
+ */
+function emitYieldRoadsUserData(lane, laneIdToRoadId) {
+    const yieldRoadIds = [];
+    for (const yieldShapeId of lane.props.yieldLaneIds ?? []) {
+        const rid = laneIdToRoadId.get(yieldShapeId);
+        if (rid !== undefined && !yieldRoadIds.includes(rid))
+            yieldRoadIds.push(rid);
+    }
+    if (yieldRoadIds.length === 0)
+        return null;
+    const json = JSON.stringify(yieldRoadIds.sort((a, b) => a - b).map(String));
+    return `    <userData code="yieldRoads" value="${escapeXml(json)}"/>`;
+}
+/**
+ * Road length attribute. The plan-view geometries are emitted with rounded
+ * (6-decimal) s/length values whose cumulative extent can exceed the exact
+ * road length by ~1e-6, which strict consumers flag as "s too large". Use the
+ * emitted extent plus a tiny pad so the length always covers the geometry.
+ */
+function emittedRoadLength(geom) {
+    let extent = geom.length;
+    for (let i = 0; i < geom.odrSamples.length - 1; i++) {
+        const a = geom.odrSamples[i];
+        const b = geom.odrSamples[i + 1];
+        const segLen = Math.hypot(b.x - a.x, b.y - a.y);
+        if (segLen < 1e-9)
+            continue;
+        const end = parseFloat(fmt(a.s)) + parseFloat(fmt(segLen));
+        if (end > extent)
+            extent = end;
+    }
+    return extent + 1e-4;
+}
+function emitRoad(lane, geom, roadId, laneIdToRoadId, junctionPlan, signals, signalRefs, objects, shapeMap) {
     const speed = lane.props.attributes?.speed_limit;
     const name = escapeXml(lane.props.attributes?.subtype || 'road');
-    const hasPrev = !!(lane.props.prev?.[0] && laneIdToRoadId.has(lane.props.prev[0]));
-    const hasNext = !!(lane.props.next?.[0] && laneIdToRoadId.has(lane.props.next[0]));
+    const hasPrev = (lane.props.prev ?? []).some((id) => laneIdToRoadId.has(id));
+    const hasNext = (lane.props.next ?? []).some((id) => laneIdToRoadId.has(id));
+    const junctionAttr = junctionPlan.roadJunction.get(lane.id) ?? -1;
     const lines = [];
-    lines.push(`  <road name="${name}" length="${fmt(geom.length)}" id="${roadId}" junction="-1">`);
-    lines.push(emitLink(lane, laneIdToRoadId));
+    lines.push(`  <road name="${name}" length="${fmt(emittedRoadLength(geom))}" id="${roadId}" junction="${junctionAttr}">`);
+    lines.push(emitLink(lane, laneIdToRoadId, junctionPlan));
     if (speed) {
         lines.push(`    <type s="0" type="town">`);
         lines.push(`      <speed max="${escapeXml(speed)}" unit="km/h"/>`);
@@ -499,9 +879,15 @@ function emitRoad(lane, geom, roadId, laneIdToRoadId, signals, objects) {
     lines.push(emitPlanView(geom));
     lines.push(`    <elevationProfile/>`);
     lines.push(`    <lateralProfile/>`);
-    lines.push(emitLanes(geom, hasPrev, hasNext));
+    lines.push(emitLanes(geom, hasPrev, hasNext, odrLaneTypeFor(lane), roadMarkTypeFor(shapeMap, lane.props.leftBoundaryId), roadMarkTypeFor(shapeMap, lane.props.rightBoundaryId)));
     lines.push(emitObjects(objects));
-    lines.push(emitSignals(signals));
+    lines.push(emitSignals(signals, signalRefs));
+    const userData = emitLaneAttributesUserData(lane);
+    if (userData)
+        lines.push(userData);
+    const yieldUserData = emitYieldRoadsUserData(lane, laneIdToRoadId);
+    if (yieldUserData)
+        lines.push(yieldUserData);
     lines.push(`  </road>`);
     return lines.join('\n');
 }
@@ -534,32 +920,124 @@ export function exportToOpenDrive(snapshot) {
                 polygons.push({ shape: poly, vertices });
         }
     }
-    // Assign sequential road ids.
+    // Road ids are assigned after geometry construction so degenerate lanes
+    // (zero-length centerlines) neither emit empty roads nor occupy link ids.
     const laneIdToRoadId = new Map();
-    lanes.forEach((lane, i) => laneIdToRoadId.set(lane.id, i + 1));
     const dateStr = new Date().toISOString();
+    const bbox = computeEnuBoundingBox(shapeMap);
+    const geoRefProj = originToProjString(snapshot.origin);
     const lines = [];
     lines.push(`<?xml version="1.0" encoding="UTF-8"?>`);
     lines.push(`<OpenDRIVE>`);
-    lines.push(`  <header revMajor="1" revMinor="8" name="drawtonomy" version="1.0" date="${dateStr}" north="0" south="0" east="0" west="0" vendor="drawtonomy"/>`);
+    // OpenDRIVE 1.8 expects <geoReference> inside <header>. We always emit one —
+    // tmerc-at-origin when snapshot.origin is set, WGS84 longlat as a fallback —
+    // so downstream tools (esmini, RoadRunner, asam-qc-opendrive) see a defined
+    // coordinate reference system rather than nothing. The N/S/E/W attributes
+    // are populated from the actual point cloud so the header bbox reflects the
+    // map extent in ENU metres.
+    lines.push(`  <header revMajor="1" revMinor="8" name="drawtonomy" version="1.0" date="${dateStr}" ` +
+        `north="${fmt(bbox.north)}" south="${fmt(bbox.south)}" east="${fmt(bbox.east)}" west="${fmt(bbox.west)}" vendor="drawtonomy">`);
+    lines.push(`    <geoReference><![CDATA[${escapeCdata(geoRefProj)}]]></geoReference>`);
+    lines.push(`  </header>`);
     const pointOverrides = buildBoundaryAlignmentOverrides(shapeMap, lanes);
     const laneToGeom = new Map();
     for (const lane of lanes) {
         const geom = buildRoadGeometry(shapeMap, lane, pointOverrides);
-        if (geom)
+        if (geom && geom.length >= 0.01 && geom.odrSamples.length >= 2) {
             laneToGeom.set(lane.id, geom);
+        }
+    }
+    let nextRoadId = 1;
+    for (const lane of lanes) {
+        if (laneToGeom.has(lane.id))
+            laneIdToRoadId.set(lane.id, nextRoadId++);
     }
-    const { roadSignals, roadObjects } = attachShapesToRoads(trafficLights, crosswalks, polygons, laneToGeom, laneIdToRoadId);
+    const junctionPlan = planJunctions(lanes, laneIdToRoadId, nextRoadId);
+    const { roadSignals, roadObjects, roadSignalRefs, signalIdByShape } = attachShapesToRoads(shapeMap, trafficLights, crosswalks, polygons, laneToGeom, laneIdToRoadId);
     for (const lane of lanes) {
         const geom = laneToGeom.get(lane.id);
         if (!geom)
             continue;
         const roadId = laneIdToRoadId.get(lane.id);
         const signals = roadSignals.get(roadId) ?? [];
+        const signalRefs = roadSignalRefs.get(roadId) ?? [];
         const objects = roadObjects.get(roadId) ?? [];
-        lines.push(emitRoad(lane, geom, roadId, laneIdToRoadId, signals, objects));
+        lines.push(emitRoad(lane, geom, roadId, laneIdToRoadId, junctionPlan, signals, signalRefs, objects, shapeMap));
+    }
+    // Signal groups: traffic lights sharing a controllerId (one intersection)
+    // become a <controller> listing their emitted signals as <control> records.
+    const controllerGroups = new Map();
+    for (const tl of trafficLights) {
+        const groupId = tl.props.controllerId;
+        if (!groupId)
+            continue;
+        const signalId = signalIdByShape.get(tl.id);
+        if (signalId === undefined)
+            continue;
+        const group = controllerGroups.get(groupId) ?? [];
+        group.push(signalId);
+        controllerGroups.set(groupId, group);
+    }
+    let controllerIdCounter = 1;
+    for (const [groupId, signalIds] of controllerGroups) {
+        lines.push(`  <controller id="${controllerIdCounter++}" name="${escapeXml(groupId)}" sequence="0">`);
+        for (const signalId of signalIds) {
+            lines.push(`    <control signalId="${signalId}" type="0"/>`);
+        }
+        lines.push(`  </controller>`);
+    }
+    // Synthesized junctions for branch / merge connectivity (see planJunctions).
+    for (const junction of junctionPlan.junctions) {
+        lines.push(`  <junction id="${junction.id}" name="junction${junction.id}">`);
+        junction.connections.forEach((conn, idx) => {
+            lines.push(`    <connection id="${idx}" incomingRoad="${conn.incoming}" connectingRoad="${conn.connecting}" contactPoint="start">`);
+            lines.push(`      <laneLink from="-1" to="-1"/>`);
+            lines.push(`    </connection>`);
+        });
+        lines.push(`  </junction>`);
     }
     lines.push(`</OpenDRIVE>`);
     return lines.join('\n');
 }
+/**
+ * Compute the axis-aligned bounding box of all point shapes in ENU metres.
+ * Used to populate OpenDRIVE <header> north/south/east/west attributes.
+ * Returns zeros when the snapshot has no points.
+ */
+function computeEnuBoundingBox(shapeMap) {
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (const s of shapeMap.values()) {
+        if (s.type !== 'point')
+            continue;
+        if (s.x < minX)
+            minX = s.x;
+        if (s.x > maxX)
+            maxX = s.x;
+        if (s.y < minY)
+            minY = s.y;
+        if (s.y > maxY)
+            maxY = s.y;
+    }
+    if (!Number.isFinite(minX)) {
+        return { north: 0, south: 0, east: 0, west: 0 };
+    }
+    // Canvas y points down, ENU y points up — flip when reporting bounds.
+    return {
+        west: pxToEnuX(minX),
+        east: pxToEnuX(maxX),
+        south: pxToEnuY(maxY),
+        north: pxToEnuY(minY),
+    };
+}
+/**
+ * Escape a string so it can appear safely inside an XML CDATA section. The
+ * only character sequence that ends a CDATA section is `]]>`, so we split it
+ * across two CDATA sections.
+ */
+function escapeCdata(s) {
+    return s.replace(/]]>/g, ']]]]><![CDATA[>');
+}
 //# sourceMappingURL=opendrive.js.map