Exporteren naar OpenDRIVE / OpenSCENARIO / esmini

drawtonomy zet een handgetekende scène om naar een ASAM OpenDRIVE (.xodr) wegnetwerk plus een OpenSCENARIO (.xosc) scenario, gebundeld in één zip die je direct kunt afspelen in esmini.

De conversie is bewust beperkt — hij dekt alleen de vormen die netjes op het ASAM-datamodel passen en laat de rest weg. Op deze pagina staat precies wat er wordt geconverteerd, wat het geëxporteerde voertuig feitelijk doet en wat buiten scope valt, zodat de uitvoer nooit te veel belooft.

Bekijk de volledige ronde trip

De video hieronder is één opname: teken een kruispunt, teken een pad, genereer footprints, exporteer de esmini-zip en speel de geëxporteerde .xosc af in esmini.

Één opname: teken een kruispunt, teken een pad, genereer footprints, exporteer de esmini-zip en speel de geëxporteerde .xosc af in esmini.

Exporteren vanuit de editor

Er is één ASAM-exportoptie. drawtonomy heeft geen aparte menu-items voor .xodr en .xosc — beide bestanden worden samen aangemaakt en in één zip verpakt.

Teken je scène (rijstroken, een kruispunt, voertuigen, een pad…).
Open het menu → Export → .zip (esmini).
Voer een basisnaam in wanneer daarom gevraagd wordt (standaard drawtonomy-<datum>).
Een <naam>.zip wordt gedownload met daarin <naam>.xodr, <naam>.xosc en de esmini 3D-modelassets waarnaar het scenario verwijst.

De gehele huidige pagina wordt geëxporteerd — er is geen modus voor “alleen selectie” bij het ASAM-doel.

Afspelen in esmini

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

Een voertuig dat het geëxporteerde traject volgt in esmini

Het voertuig rijdt langs de oranje lijn — die lijn is de FollowTrajectoryAction die uit het door jou getekende pad is gegenereerd.

Wat er wordt geconverteerd

Naar OpenDRIVE (`.xodr`)

drawtonomy-vorm	OpenDRIVE-element	Opmerkingen
Lane	één `<road>`	1 rijstrook = 1 zelfstandige weg
Traffic light	`<signal>` op de dichtstbijzijnde weg	alleen voertuig-/voetgangerstype
Crosswalk	`<object type="crosswalk">`	loodrecht op de weg geplaatst
Polygon (≥3 punten)	`<object type="patch">` met `<outline>`	vult kruispunt-/gebiedsvisualisaties

Alles wat overblijft — voertuigen, voetgangers, losse punten, vrije linestrings, tekst, afbeeldingen — wordt niet in het .xodr-bestand opgenomen.

Hoe ver elke weg loopt:

De geometrie bestaat uitsluitend uit rechte lijnen. De referentielijn van de weg wordt bemonsterd vanuit de linker- en rechterrand van de rijstrook en uitgestoten als <line>-segmenten. Er worden geen arc-, spiral- of poly3-geometrieën aangemaakt.
Vaste rijstrookindeling. Elke weg krijgt precies één linker rijstrook (id=1), één middenas (id=0) en één rechter rijstrook (id=-1), allemaal type="driving". Wegen met meerdere rijstroken en meerdere rijstrookdelen worden niet weergegeven.
Wegmarkeringen zijn vastgezet op een solid white 0.13 m-lijn.
Geen kruispunten. Elke weg heeft junction="-1" en er wordt nooit een <junction>-element aangemaakt. Kruispunten worden alleen weergegeven via de polygon-patch (visueel) en via predecessor/successor-koppelingen afgeleid uit de next-/prev-verbindingen van de rijstrook (alleen het eerste item).
Geen hoogteprofiel of superelevatie — elevationProfile en lateralProfile worden leeg uitgestuurd (vlakke, planaire wegen).
De schaal is vastgezet op 16,67 px/m; de geografische oorsprong is 0.

Naar OpenSCENARIO (`.xosc`)

drawtonomy-vorm	OpenSCENARIO-element
Vehicle	een `<ScenarioObject>` (`<Vehicle>` of `<Pedestrian>`)
Path footprint (het voorste voertuig)	een `<FollowTrajectoryAction>`

Een “voetganger” is gewoon een Vehicle-vorm waarvan de sjabloonnaam overeenkomt met een voetgangers-/looppatroon — die wordt als <Pedestrian> uitgestoten in plaats van <Vehicle>. Rijstroken, voetgangersoversteekplaatsen, verkeerslichten en vrije linestrings worden niet in het .xosc opgenomen.

Het geëxporteerde scenario is bewust minimaal:

Het enige dynamische gedrag is FollowTrajectoryAction — een tijdgestempelde polylijn. Er zijn geen snelheidsacties, rijstrookwisselingen, reacties op verkeerslichten, botsingspreventie of interactievoorwaarden.
Elke bewegende entiteit begint op SimulationTime ≥ 0 en het scenario heeft een vaste StopTrigger op 60 s.

Hoe een path footprint voertuigbeweging wordt

Dit is de kern van de dynamische export, dus het is de moeite waard om precies te zijn.

Het footprint-paneel: Variable positioning, Interval en Anchor uitgelegd

Een path is een linestring die je tekent, en footprints zijn spookopies van een voertuig die langs die lijn zijn uitgezet (het spoor dat je in de editor ziet). Bij het exporteren:

Alleen de voorste footprint (de eerste) wordt een bewegend <ScenarioObject>. De achterliggende spookopies dienen als canvas-preview en worden weggelaten — je krijgt één voertuig dat het hele pad aflegt, geen rij voertuigen.
De controlepunten van het pad worden de trajectpunten in wereld(ENU)-meters.
Elk punt krijgt een time, en het resultaat wordt geschreven als een <Trajectory> → <Polyline> van <Vertex time="…"> binnen een <FollowTrajectoryAction>.

Snelheid is vast (de belangrijkste beperking)

Het traject wordt getimed op een vaste 10 m/s (≈ 36 km/h). drawtonomy heeft geen snelheidsveld in de UI, en de exporter overschrijft de standaard nooit. In esmini zie je de entiteit ~36 km/h rapporteren, ongeacht wat je hebt getekend. Je stelt geen snelheid in — je bepaalt de timing via de indeling van de footprints, zoals hieronder beschreven.

Twee tijdsmodi

Of de schakelaar “Variable positioning” aan staat, bepaalt hoe de tijd over het traject wordt verdeeld:

Uniform (schakelaar UIT) — footprints staan op gelijke booglengte-Intervals en de tijd is afstand / 10 m/s. De beweging heeft een constante snelheid. Het wijzigen van het Interval verandert alleen het aantal geschreven hoekpunten (bemonsteringsdichtheid); de padvorm en totale duur blijven ongewijzigd.
Variable (schakelaar AAN) — elke footprint is vastgepind op een positie langs het pad, en de totale duur wordt verdeeld in gelijke tijdsvakken tussen de footprints. Waar footprints dicht op elkaar staan, rijdt het voertuig langzaam; waar ze verder uit elkaar staan, rijdt het snel. Dit is de enige manier om de effectieve snelheid langs de route te variëren.

Wat je aanpast ↔ wat er verandert in het `.xosc`

Editoractie	Effect op de export
Verplaats een controlepunt van het pad	Trajectcoördinaten + totale duur (lengte verandert, snelheid blijft 10 m/s)
Sleep een footprint in Variable-modus	De genormaliseerde positie van die footprint → de `time` van het hoekpunt → de lokale (effectieve) snelheid van dat segment
Schakel Variable positioning om	Wisselt tussen gelijke-tijd- en gelijke-snelheidstiming
Wijzig Interval (uniforme modus)	Alleen het aantal hoekpunten — trajectvorm en snelheid blijven ongewijzigd
Wijzig Anchor	Alleen de tekenverschuiving van de footprint — geen effect op het geëxporteerde traject
Wijzig het voertuigsjabloon	`vehicleCategory`, 3D-model, begrenzingsdooshoogte, prestatiepreset
Vergroot of verklein het voertuig (b, h)	BoundingBox-afmetingen en asgeometrie
Roteer het voertuig	Beginrichting (alleen als het voertuig geen traject heeft)
Verplaats het voertuig	Beginwaarde `WorldPosition` (vastgemaakt aan het trajectstartpunt als het er een heeft)

Om de veelgestelde vraag direct te beantwoorden: ja — het verplaatsen van een footprint halverwege het pad in Variable-modus verandert het geëxporteerde snelheidsplan, omdat het dat segment opnieuw timet. Verplaatsen in Uniform-modus, of het wijzigen van de Anchor, heeft dat effect niet.

Vastgeprogrammeerde waarden

Voor eerlijkheid over de scope: de volgende waarden komen uit vaste tabellen of constanten en zijn niet in de editor in te stellen: voertuigcategorie/prestatiepresets, 3D-modelpaden, voertuighoogte per categorie, asgeometrie (afgeleid van afmetingen), volgmodus (position), de stop-trigger op 60 s en — het belangrijkst — de trajectsnelheid van 10 m/s.

Programmatische export

De exporter zit in @drawtonomy/sdk en draait zonder de editor. In tegenstelling tot het menu kun je via de SDK de twee bestanden ook afzonderlijk uitstoten:

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

const snapshot = createSnapshot(shapes)

// Gebundeld (zelfde als het menu):
const { blob, baseName } = exporter.buildEsminiZip(snapshot, {
  baseName: 'my-scene',
})

// Of elk formaat afzonderlijk:
const xodr = exporter.exportToOpenDrive(snapshot)
const xosc = exporter.exportToOpenScenario(snapshot, {
  xodrFilename: 'my-scene.xodr',
})

Zie voor de volledige API en uitbreidingspunten de Exporter SDK-referentie.

Uitgestoten versies

Formaat	Versie
OpenDRIVE	1.8
OpenSCENARIO	1.3

Overzicht van de scope

Ondersteund: rechte wegen vanuit rijstroken; signalen, voetgangersoversteekplaatsen en kruispuntpatches als OpenDRIVE-objecten; één voertuig per pad dat een tijdgetraject volgt; een werkende esmini-zip die je direct kunt afspelen.

Nog niet ondersteund: OpenDRIVE-kruispunten, gebogen geometrie, wegen met meerdere rijstroken, weghoogte; OpenSCENARIO-snelheidsacties, rijstrookwisselingen, verkeerslichtlogica, interactie tussen meerdere actoren of enige snelheidsregeling per voertuig.

Zie ook

Exporter-architectuur — wat de pijplijn doet tussen snapshot en bestand.
Een doelformaat toevoegen — koppel CARLA, SUMO, Unity of iets anders.