Main Content

Questa pagina è stata tradotta con la traduzione automatica. Fai clic qui per vedere l'ultima versione in inglese.

Costruisci strade semplici in modo programmatico utilizzando RoadRunner HD Map

Questo esempio utilizza:

Apri live script

RoadRunner HD Map è un modello di dati stradali per rappresentare dati cartografici ad alta definizione (HD) in una scena RoadRunner . Il modello definisce una struttura semplice per rappresentare i tracciati stradali utilizzando corsie, confini delle corsie, segnaletica orizzontale e incroci. Questo esempio mostra come costruire strade semplici utilizzando gli oggetti e le funzioni MATLAB® RoadRunner HD Map. Le strade possono quindi essere importate in RoadRunner. I passaggi per costruire una strada e importarla in una scena RoadRunner sono:

  • Costruisci una mappa HD in MATLAB

  • Verifica la rappresentazione delle corsie e dei confini delle corsie tracciando la mappa in MATLAB

  • Scrivere la mappa in un file RoadRunner HD Map (.rrhd).

  • Importa il file in RoadRunner e visualizza l'anteprima dei dati della mappa RoadRunner HD

  • Costruisci una scena RoadRunner dal file importato (richiede RoadRunner Scene Builder).

Crea una strada diritta non segnalata

Una strada a larghezza fissa viene definita utilizzando una serie di coordinate x-y che corrispondono alla posizione del centro della strada. Questa figura mostra una strada diritta e non segnalata che creerai in questa sezione. Traccerai anche la strada in MATLAB e poi la salverai in un file binario.

Crea una mappa RoadRunner HD vuota chiamando l'oggetto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Definire il centro della strada diritta come una matrice 2D che contiene tre serie di coordinate x-y che specificano il centro della strada. Inoltre, definire la larghezza della strada.

roadCenters = [0 0;0 50;0 100];
roadWidth = 6;

Crea i confini sinistro e destro della strada utilizzando l'oggetto roadrunner.hdmap.LaneBoundary . Specificare le informazioni sul confine della corsia per l'ID della corsia e le coordinate che definiscono la geometria della corsia.

rrMap.LaneBoundaries(1) = roadrunner.hdmap.LaneBoundary(ID="Left",Geometry=roadCenters-[roadWidth/2 0]);
rrMap.LaneBoundaries(2) = roadrunner.hdmap.LaneBoundary(ID="Right",Geometry=roadCenters+[roadWidth/2 0]);

Creare la corsia stradale utilizzando l'oggetto roadrunner.hdmap.Lane . Specificare le informazioni sulla corsia per l'ID corsia, le coordinate che definiscono la geometria della corsia, la direzione di guida e il tipo di corsia.

rLane = roadrunner.hdmap.Lane(ID="Lane",Geometry=roadCenters,TravelDirection="Forward",LaneType="Driving");

Collegare i confini delle corsie alle corsie. Definire i confini delle corsie sinistra e destra per ciascuna corsia e specificare l'allineamento tra le corsie e i confini delle corsie. 

leftBoundary(rLane,"Left",Alignment="Forward");
rightBoundary(rLane,"Right",Alignment="Forward");
rrMap.Lanes = rLane;

Traccia i centri e i confini delle corsie per visualizzare in anteprima le corsie e i confini delle corsie prima di importarli in RoadRunner.

plot(rrMap);

Scrivi la mappa HD tracciata nel passaggio precedente in un file utilizzando la funzione write .

write(rrMap,"straightRoad.rrhd");

Importa e crea file di mappa HD in RoadRunner

Per istruzioni dettagliate sull'importazione di un file RoadRunner HD Map con estensione .rrhd in RoadRunner, sull'anteprima della mappa e sulla creazione della scena, vedere Importa dati personalizzati utilizzando la mappa RoadRunner HD.

Apri l'applicazione RoadRunner utilizzando l'oggetto roadrunner dalla riga di comando MATLAB® . Prima di creare un oggetto roadrunner per la prima volta, è necessario installare RoadRunner e attivare la licenza RoadRunner in modo interattivo. Per ulteriori informazioni, vedere Installa e attiva RoadRunner.

rrApp = roadrunner("C:\RR\MyProject", InstallationFolder='C:\Program Files\RoadRunner R2023a\bin\win64');

Importa e crea i dati della mappa RoadRunner HD da un file specificato nella scena attualmente aperta. Prima di costruire la scena devi attivare la tua licenza RoadRunner SceneBuilder in modo interattivo.

file = fullfile(pwd,"straightRoad.rrhd");
importScene(rrApp,file,"RoadRunner HD Map");

Questa figura mostra una scena creata utilizzando RoadRunner Scene Builder.

Aggiungi segnaletica alla strada diritta

In questa sezione aggiungerai segnaletica orizzontale bianca continua ai limiti delle corsie sinistra e destra della strada diritta creata nella sezione precedente. Per specificare una segnaletica orizzontale, è necessaria una risorsa in RoadRunner. In questo esempio, utilizzi le risorse che fanno parte del Tipi di risorse RoadRunner. Queste risorse sono specificate nella mappa utilizzando un percorso relativo alla cartella del progetto RoadRunner .

Definire il percorso verso la risorsa di segnaletica bianca continua utilizzando la funzione roadrunner.hdmap.RelativeAssetPath .

solidWhiteAsset = roadrunner.hdmap.RelativeAssetPath(AssetPath="Assets/Markings/SolidSingleWhite.rrlms");

Crea una segnaletica orizzontale solida bianca sulla strada diritta utilizzando l'oggetto roadrunner.hdmap.LaneMarking . Specificare le informazioni sulla segnaletica orizzontale per l'ID della segnaletica stradale e il percorso della risorsa.

rrMap.LaneMarkings = roadrunner.hdmap.LaneMarking(ID="SolidWhite",AssetPath=solidWhiteAsset);

Creare un riferimento per la segnaletica bianca continua da applicare ai confini della corsia utilizzando l'oggetto roadrunner.hdmap.MarkingReference .

markingRefSW = roadrunner.hdmap.MarkingReference(MarkingID=roadrunner.hdmap.Reference(ID="SolidWhite"));

Utilizza gli attributi parametrici per applicare questa segnaletica orizzontale per coprire l'intera lunghezza dei confini della corsia sinistra e destra. 

markingSpan = [0 1];
markingAttribSW = roadrunner.hdmap.ParametricAttribution(MarkingReference=markingRefSW,Span=markingSpan);
rrMap.LaneBoundaries(1).ParametricAttributes = markingAttribSW;
rrMap.LaneBoundaries(2).ParametricAttributes = markingAttribSW;

Scrivi la mappa HD modificata in un file.

write(rrMap,"straightRoadWithMarkings.rrhd");

Importa e crea i dati della mappa RoadRunner HD da un file specificato nella scena attualmente aperta. 

file = fullfile(pwd,"straightRoadWithMarkings.rrhd");
importScene(rrApp,file,"RoadRunner HD Map");

Questa figura mostra una scena creata utilizzando RoadRunner Scene Builder.

Creare una strada a doppio senso

Una strada a doppio senso ha due corsie con direzioni di guida opposte. Una segnaletica gialla continua separa le corsie. Questa figura mostra una strada diritta a doppio senso che creerai in questa sezione. Utilizzerai gli stessi centri stradali e la stessa larghezza stradale utilizzati nelle sezioni precedenti.

Crea una mappa RoadRunner HD vuota chiamando l'oggetto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Specificare la corsia e i limiti della corsia. In questo esempio, la preinizializzazione dei valori determina un miglioramento delle prestazioni all'aumentare del numero di oggetti nella mappa.

rrMap.Lanes(2,1) = roadrunner.hdmap.Lane();
rrMap.LaneBoundaries(3,1) = roadrunner.hdmap.LaneBoundary();

Assegnare i valori della proprietà Lane . Utilizzare la funzione deal per abbinare gli elenchi di input e output. 

[rrMap.Lanes.ID] = deal("Lane1","Lane2");
[rrMap.Lanes.Geometry] = deal(roadCenters-[roadWidth/4 0],roadCenters+[roadWidth/4 0]);
[rrMap.Lanes.TravelDirection] = deal("Backward","Forward");
[rrMap.Lanes.LaneType] = deal("Driving");

Assegnare i valori della proprietà LaneBoundaries . In questo esempio, la corsia centrale è condivisa tra Lane1 e Lane2.

[rrMap.LaneBoundaries.ID] = deal("Left","Center","Right");
[rrMap.LaneBoundaries.Geometry] = deal(roadCenters-[roadWidth/2 0],...
  roadCenters,roadCenters+[roadWidth/2 0]);

Collegare i confini delle corsie alle corsie. Definire i confini delle corsie sinistra e destra per ciascuna corsia e specificare l'allineamento tra le corsie e i confini delle corsie. 

leftBoundary(rrMap.Lanes(1),"Left",Alignment="Forward");
rightBoundary(rrMap.Lanes(1),"Center",Alignment="Forward");
leftBoundary(rrMap.Lanes(2),"Center",Alignment="Forward");
rightBoundary(rrMap.Lanes(2),"Right",Alignment="Forward");

Aggiungi un contrassegno solido giallo oltre al contrassegno bianco solido aggiunto prima. Definire il percorso della risorsa segnaletica gialla continua utilizzando la funzione roadrunner.hdmap.RelativeAssetPath .

solidYellowAsset = roadrunner.hdmap.RelativeAssetPath(AssetPath="Assets/Markings/SolidSingleYellow.rrlms");

Crea una segnaletica di corsia gialla continua sulla strada diritta utilizzando l'oggetto roadrunner.hdmap.LaneMarking . Specificare le informazioni sulla segnaletica orizzontale per l'ID della segnaletica orizzontale e il percorso della risorsa.

rrMap.LaneMarkings(2,1) = roadrunner.hdmap.LaneMarking();
[rrMap.LaneMarkings.ID] = deal("SolidWhite","SolidYellow");
[rrMap.LaneMarkings.AssetPath] = deal(solidWhiteAsset,solidYellowAsset);

Assegnare la segnaletica bianca ai confini della corsia ai bordi della corsia e la segnaletica gialla al confine della corsia centrale. Questi segni coprono l'intera lunghezza del confine.

markingRefSY = roadrunner.hdmap.MarkingReference(MarkingID=roadrunner.hdmap.Reference(ID="SolidYellow"));
markingAttribSY = roadrunner.hdmap.ParametricAttribution(MarkingReference=markingRefSY,Span=markingSpan);
[rrMap.LaneBoundaries.ParametricAttributes] = deal(markingAttribSW,markingAttribSY,markingAttribSW);

Traccia i centri delle corsie e i confini delle corsie.

plot(rrMap)

Scrivere la mappa HD in un file.

write(rrMap,"twoWayRoad.rrhd");

Importa e crea i dati della mappa RoadRunner HD da un file specificato nella scena attualmente aperta. 

file = fullfile(pwd,"twoWayRoad.rrhd");
importScene(rrApp,file,"RoadRunner HD Map");

Questa figura mostra una scena creata utilizzando RoadRunner Scene Builder.

Aggiungere una corsia ad una strada a senso unico

In questa sezione aggiungi una corsia a una strada a senso unico. Una segnaletica bianca tratteggiata viene utilizzata per separare due corsie con la stessa direzione di marcia. Per aggiungere una corsia a una strada a senso unico, dovrai dividere una corsia in due dal bordo sinistro di una corsia. Ciò richiede la creazione di corsie e limiti di corsia aggiuntivi nella mappa RoadRunner HD nel punto in cui la corsia si divide. Questa figura mostra la corsia che aggiungerai alla strada a senso unico:

Crea una mappa RoadRunner HD vuota chiamando l'oggetto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Specificare la corsia e i limiti della corsia.

rrMap.Lanes(5,1) = roadrunner.hdmap.Lane();
rrMap.LaneBoundaries(8,1) = roadrunner.hdmap.LaneBoundary();

Specificare i gruppi di corsia e la segnaletica orizzontale.

rrMap.LaneGroups(3,1) = roadrunner.hdmap.LaneGroup();
rrMap.LaneMarkings(3,1) = roadrunner.hdmap.LaneMarking();

Assegnare i valori della proprietà Lane . Dividere Lane1 in Lane4 e Lane5 e utilizzare Lane2 e Lane3 per la transizione.

[rrMap.Lanes.ID] = deal("Lane1","Lane2","Lane3","Lane4","Lane5");
[rrMap.Lanes.Geometry] = deal([0 -20;0 0;0 20;],[0 20;0 40;0 60;],[0 20;-3 40;-6 60],[-6 60;-6 80;-6 100],[0 60;0 80;0 100]);
[rrMap.Lanes.TravelDirection] = deal("Forward");
[rrMap.Lanes.LaneType] = deal("Driving");

Assegnare i valori della proprietà LaneBoundaries . Lane3 condivide il confine destro con Lane2, indicato con Left2.

[rrMap.LaneBoundaries.ID] = deal("Left1","Right1","Left2","Right2","Left3","Left4","Center4","Right4");
[rrMap.LaneBoundaries.Geometry] = deal([-3 -20;-3 0;-3 20],[3 -20;3 0;3 20],[-3 20;-3 40;-3 60;],...
        [3 20;3 40;3 60],[-3 20;-6 40;-9 60],[-9 60;-9 80;-9 100],[-3 60;-3 80;-3 100],[3 60;3 80;3 100]);

Collegare i confini delle corsie alle corsie. Definire i confini delle corsie sinistra e destra per ciascuna corsia e specificare l'allineamento tra le corsie e i confini delle corsie. 

leftBoundary(rrMap.Lanes(1),"Left1",Alignment="Forward");
rightBoundary(rrMap.Lanes(1),"Right1",Alignment="Forward");
leftBoundary(rrMap.Lanes(2),"Left2",Alignment="Forward");
rightBoundary(rrMap.Lanes(2),"Right2",Alignment="Forward");
leftBoundary(rrMap.Lanes(3),"Left3",Alignment="Forward");
rightBoundary(rrMap.Lanes(3),"Left2",Alignment="Forward");
leftBoundary(rrMap.Lanes(4),"Left4",Alignment="Forward");
rightBoundary(rrMap.Lanes(4),"Center4",Alignment="Forward");
leftBoundary(rrMap.Lanes(5),"Center4",Alignment="Forward");
rightBoundary(rrMap.Lanes(5),"Right4",Alignment="Forward");

Specificare l'allineamento tra le corsie definendo le informazioni sulla relazione predecessore e successore.

rrMap.Lanes(3).Successors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane4"),Alignment="Forward");
rrMap.Lanes(3).Predecessors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane1"),Alignment="Forward");
rrMap.Lanes(2).Successors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane5"),Alignment="Forward");
rrMap.Lanes(2).Predecessors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane1"),Alignment="Forward");
rrMap.Lanes(1).Successors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane2"),Alignment="Forward");
rrMap.Lanes(4).Predecessors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane3"),Alignment="Forward");
rrMap.Lanes(5).Predecessors = roadrunner.hdmap.AlignedReference(Reference=roadrunner.hdmap.Reference(ID="Lane2"),Alignment="Forward");

Aggiungi un segno bianco tratteggiato oltre ai segni bianchi e gialli solidi aggiunti prima. Definire il percorso della risorsa segnaletica bianca tratteggiata utilizzando la funzione roadrunner.hdmap.RelativeAssetPath .

dashedWhiteAsset = roadrunner.hdmap.RelativeAssetPath(AssetPath="Assets/Markings/DashedSingleWhite.rrlms");

Crea una segnaletica bianca tratteggiata sulla strada utilizzando l'oggetto roadrunner.hdmap.LaneMarking .

rrMap.LaneMarkings(3,1) = roadrunner.hdmap.LaneMarking();
[rrMap.LaneMarkings.ID] = deal("SolidWhite","SolidYellow","DashedWhite");
[rrMap.LaneMarkings.AssetPath] = deal(solidWhiteAsset,solidYellowAsset,dashedWhiteAsset);

Assegnare la segnaletica orizzontale utilizzando gli attributi parametrici.

markingRefDW = roadrunner.hdmap.MarkingReference(MarkingID=roadrunner.hdmap.Reference(ID="DashedWhite"));
markingAttribDW = roadrunner.hdmap.ParametricAttribution(MarkingReference=markingRefDW,Span=markingSpan);
[rrMap.LaneBoundaries.ParametricAttributes] = deal(markingAttribSY,markingAttribSW,markingAttribDW,markingAttribSW,...
    markingAttribSY,markingAttribSY,markingAttribDW,markingAttribSW);

Tracciare i centri delle corsie e i confini delle corsie.

plot(rrMap)

Scrivere la mappa HD in un file.

write(rrMap,"laneAdd.rrhd");

L'utente deve copiare il file della mappa HD nella cartella delle risorse del progetto corrente quando utilizza le opzioni di importazione e creazione.

copyfile("laneAdd.rrhd", "C:\RR\MyProject\Assets");

Crea opzioni di importazione della mappa RoadRunner HD che caricano la mappa.

importOptions = roadrunnerHDMapImportOptions(ImportStep="Load");

Carica i dati della mappa RoadRunner HD dal file specificato nella scena attualmente aperta. 

file = fullfile("C:\RR\MyProject\Assets","laneAdd.rrhd");
importScene(rrApp,file,"RoadRunner HD Map",importOptions);

Crea opzioni di creazione della mappa RoadRunner HD che costruiscono la mappa.

buildOptions = roadrunnerHDMapBuildOptions(DetectAsphaltSurfaces=true);

Costruisci i dati della mappa RoadRunner HD dal file specificato nella scena attualmente aperta. 

buildScene(rrApp,"RoadRunner HD Map",buildOptions);

Questa figura mostra una scena creata utilizzando RoadRunner Scene Builder.

Vedi anche

|

Argomenti complementari