Esporta verso OpenDRIVE / OpenSCENARIO / esmini

Con drawtonomy puoi trasformare una scena disegnata a mano in una rete stradale ASAM OpenDRIVE (.xodr) e in uno scenario OpenSCENARIO (.xosc), racchiusi in un unico zip che puoi riprodurre subito con esmini.

La conversione è volutamente essenziale: copre le poche forme che si mappano in modo pulito sul modello dati ASAM e lascia tutto il resto fuori. Questa pagina documenta con precisione cosa viene convertito, cosa fa effettivamente il veicolo esportato e quali funzionalità non sono ancora incluse, così il risultato non promette mai più di quanto possa mantenere.

Il round-trip completo in video

Il video qui sotto è una ripresa unica: si disegna un incrocio, si tracciano corsie e un percorso, si generano le impronte, si esporta lo zip esmini e infine si riproduce il .xosc esportato in esmini.

Ripresa unica: disegna un incrocio, traccia un percorso, genera le impronte, esporta lo zip esmini e riproduci il .xosc in esmini.

Esportare dall’editor

C’è un solo punto di accesso per l’esportazione ASAM. drawtonomy non espone voci di menu separate per .xodr e .xosc — entrambi i file vengono prodotti insieme e compressi in un unico zip.

1. Disegna la tua scena (corsie, un incrocio, veicoli, un percorso…).
2. Apri il menu → Export → .zip (esmini).
3. Inserisci un nome di base quando richiesto (il default è drawtonomy-<data>).
4. Viene scaricato un <nome>.zip contenente <nome>.xodr, <nome>.xosc e i modelli 3D esmini a cui lo scenario fa riferimento.

Viene esportata l’intera pagina corrente — non esiste una modalità “solo selezione” per il target ASAM.

Riproduzione

unzip drawtonomy-2026-05-30.zip
cd drawtonomy-2026-05-30
esmini --osc drawtonomy-2026-05-30.xosc --window 60 60 1024 768

Il veicolo percorre la linea arancione — quella linea è la FollowTrajectoryAction generata dal percorso che hai disegnato.

Cosa viene convertito

In OpenDRIVE (.xodr)

Forma drawtonomy	Elemento OpenDRIVE	Note
Lane	una <road>	1 corsia = 1 strada indipendente
Traffic light	<signal> sulla strada più vicina	solo tipo veicolo / pedone
Crosswalk	<object type="crosswalk">	posizionato perpendicolare alla strada
Polygon (≥3 punti)	<object type="patch"> con <outline>	riempie visivamente intersezioni/aree

Tutto il resto — veicoli, pedoni, punti isolati, linestring libere, testo, immagini — non viene scritto nel .xodr.

Dettagli su come viene generata ogni strada:

• La geometria è solo a linee rette. La linea di riferimento della strada viene campionata dai bordi sinistro/destro della corsia ed emessa come segmenti <line>. Non vengono prodotte geometrie arc, spiral o poly3.
• Layout di corsia fisso. Ogni strada ha esattamente una corsia sinistra (id=1), una centrale (id=0) e una destra (id=-1), tutte type="driving". Strade multi-corsia e sezioni di corsia multiple non sono rappresentate.
• Le segnalazioni stradali sono codificate come linea solid white 0.13 m.
• Nessun junction. Ogni strada porta junction="-1" e non viene mai generato alcun elemento <junction>. Le intersezioni sono rappresentate solo dal patch poligonale (aspetto visivo) e dai collegamenti predecessore/successore derivati dalle connessioni next / prev della corsia (solo la prima voce).
• Nessun profilo altimetrico / superelevazione — elevationProfile e lateralProfile vengono emessi vuoti (strade piatte e planari).
• La scala è fissa a 16,67 px/m; l’origine geografica è 0.

In OpenSCENARIO (.xosc)

Forma drawtonomy	Elemento OpenSCENARIO
Vehicle	uno <ScenarioObject> (<Vehicle> o <Pedestrian>)
Path footprint (il veicolo di testa)	una <FollowTrajectoryAction>

Un “pedone” è semplicemente una forma veicolo il cui nome di template corrisponde a un pattern pedone/camminata — viene emesso come <Pedestrian> invece che <Vehicle>. Corsie, strisce pedonali, semafori e linestring libere non vengono inclusi nel .xosc.

Lo scenario esportato è volutamente minimale:

• L’unico comportamento dinamico è FollowTrajectoryAction — una polilinea con timestamp. Non ci sono azioni di velocità, cambi di corsia, risposte ai semafori, evitamento collisioni o condizioni di interazione.
• Ogni entità in movimento parte da SimulationTime ≥ 0 e lo scenario ha un StopTrigger fisso a 60 s.

Come un path footprint diventa movimento del veicolo

Questo è il cuore dell’esportazione dinamica, quindi vale la pena essere precisi.

Un path è una linestring che disegni, e i footprints sono copie fantasma di un veicolo disposte lungo di essa (la scia visibile nell’editor). Al momento dell’esportazione:

1. Solo il footprint iniziale (il primo) diventa un <ScenarioObject> in movimento. I fantasmi successivi sono un’anteprima sul canvas e vengono scartati — ottieni un veicolo che percorre l’intero tracciato, non una coda.
2. I punti di controllo del percorso diventano i vertici della traiettoria, in metri nel sistema ENU.
3. A ogni vertice viene assegnato un time, e il risultato viene scritto come <Trajectory> → <Polyline> di <Vertex time="…"> all’interno di una <FollowTrajectoryAction>.

La velocità è fissa (questa è la limitazione chiave)

La traiettoria è temporizzata a una velocità fissa di 10 m/s (≈ 36 km/h). drawtonomy non ha un campo velocità da nessuna parte nell’interfaccia, e l’esportatore non modifica mai questo valore predefinito. In esmini vedrai l’entità riportare circa 36 km/h indipendentemente da ciò che hai disegnato. Non si imposta la velocità — si modella il timing attraverso il layout dei footprint, come descritto di seguito.

Due modalità di temporizzazione

Il toggle “Variable positioning” del percorso determina come il tempo viene distribuito lungo la traiettoria:

• Uniforme (toggle OFF) — i footprint si trovano a Interval di lunghezza d’arco uguale e il tempo è distanza / 10 m/s. Il moto è a velocità costante. Cambiare l’Interval modifica solo il numero di vertici scritti (densità di campionamento); la forma del percorso e la durata totale rimangono invariate.
• Variabile (toggle ON) — ogni footprint è ancorato a una posizione lungo il percorso e la durata totale viene suddivisa in intervalli di tempo uguali tra i footprint. Dove i footprint sono ravvicinati il veicolo si muove lentamente; dove sono distanziati si muove rapidamente. Questo è l’unico modo per variare la velocità effettiva lungo il tracciato.

Cosa modifichi nell’editor ↔ cosa cambia nel .xosc

Azione nell’editor	Effetto sull’esportazione
Spostare un punto di controllo del percorso	Coordinate del vertice della traiettoria + durata totale (la lunghezza cambia, la velocità rimane 10 m/s)
Trascinare un footprint in modalità Variable	La posizione normalizzata di quel footprint → il time del suo vertice → la velocità (effettiva) locale di quel tratto
Attivare/disattivare Variable positioning	Passa dalla temporizzazione a tempo uguale a quella a velocità uguale
Cambiare Interval (modalità uniforme)	Solo numero di vertici — forma della traiettoria e velocità invariate
Cambiare Anchor	Solo offset di disegno del footprint — nessun effetto sulla traiettoria esportata
Cambiare il template del veicolo	vehicleCategory, modello 3D, altezza del bounding box, preset di performance
Ridimensionare il veicolo (w, h)	Dimensioni del BoundingBox e geometria degli assali
Ruotare il veicolo	Direzione iniziale (solo quando il veicolo non ha una traiettoria)
Spostare il veicolo	WorldPosition di Init (agganciata all’inizio della traiettoria se presente)

Per rispondere direttamente alla domanda più frequente: sì — spostare un footprint a metà percorso in modalità Variable modifica il piano di velocità esportato, perché ricomputa il timing di quel segmento. Spostarlo in modalità Uniform, o cambiare l’Anchor, non ha questo effetto.

Valori fissi nel codice

Per onestà sullo scopo, questi parametri derivano da mappe o costanti fisse e non da nulla che puoi modificare nell’editor: categoria veicolo e preset di performance, percorsi dei modelli 3D, altezza del veicolo per categoria, geometria degli assali (derivata dalle dimensioni), modalità di seguimento (position), il trigger di stop a 60 s e — soprattutto — la velocità della traiettoria a 10 m/s.

Esportazione programmatica

L’esportatore è incluso in @drawtonomy/sdk e funziona senza l’editor. A differenza del menu, l’SDK consente anche di emettere i due file singolarmente:

import { exporter, createSnapshot } from '@drawtonomy/sdk'

const snapshot = createSnapshot(shapes)

// Bundle (uguale al menu):
const { blob, baseName } = exporter.buildEsminiZip(snapshot, {
  baseName: 'my-scene',
})

// Oppure ciascun formato separatamente:
const xodr = exporter.exportToOpenDrive(snapshot)
const xosc = exporter.exportToOpenScenario(snapshot, {
  xodrFilename: 'my-scene.xodr',
})

Per l’API completa e i punti di estensione, consulta il riferimento dell’Exporter SDK.

Versioni emesse

Formato	Versione
OpenDRIVE	1.8
OpenSCENARIO	1.3

Riepilogo dell’ambito

Supportato: strade a linee rette da corsie; segnali, strisce pedonali e patch di intersezione come oggetti OpenDRIVE; un veicolo per percorso che segue una traiettoria temporizzata; uno zip esmini funzionante pronto per la riproduzione immediata.

Non ancora supportato: junction OpenDRIVE, geometria curva, strade multi-corsia, profilo altimetrico delle strade; azioni di velocità OpenSCENARIO, cambi di corsia, logica semaforica, interazione multi-agente o qualsiasi controllo di velocità per singolo veicolo.

Vedi anche

• Architettura dell’esportatore — cosa fa la pipeline tra snapshot e file.
• Aggiungere un formato target — collega CARLA, SUMO, Unity o qualsiasi altra cosa.