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

Costruisci una scena 3D della pista di prova in RoadRunner utilizzando la mappa RoadRunner HD

Questo esempio utilizza:

Questo esempio mostra come creare una scena RoadRunner per una pista di prova utilizzando le funzioni MATLAB®. Puoi creare una scena della pista di prova utilizzando un file Keyhole Markup Language (KML) contenente le sue coordinate di latitudine e longitudine e un file GeoTIFF contenente la sua elevazione. Per importare i file di dati per la strada, è necessario disporre di una licenza Mapping Toolbox™ .

Importa file KML per la traccia di prova

In questo esempio, importi le coordinate per i centri dei binari in MATLAB da un file KML (Dati mappa © 2022 di Google), quindi visualizzi le coordinate utilizzando le funzioni MATLAB per tracciare i dati importati dal file KML.

Crea una tabella geospaziale leggendo i dati geografici dal file KML.

kmlData = readgeotable("TestTrackKMLData.kml");

Tracciare le coordinate della pista di prova.

geoplot(kmlData)
geobasemap topographic

Importa file GeoTIFF per la traccia di prova

I dati del terreno campione utilizzati in questo esempio sono stati scaricati da EarthExplorer, che fornisce dati di scienze della terra dagli archivi dello United States Geological Survey (USGS). È possibile scaricare il file TIF dal sito Web USGS caricando lo shapefile su EarthExplorer, che ritaglia EarthExplorer nell'area della pista di prova.

Convertire la tabella geospaziale in una tabella dei centri stradali per ottenere le coordinate di latitudine e longitudine del percorso di prova.

T = geotable2table(kmlData,["Latitude","Longitude"]);
[georefGrid,spatialRef] = readgeoraster("TestTrack.tif",OutputType="double");
[lat1,lon1] = polyjoin(T.Latitude(1),T.Longitude(1));
[lat2,lon2] = polyjoin(T.Latitude(2),T.Longitude(2));
[lat3,lon3] = polyjoin(T.Latitude(3),T.Longitude(3));
[lat4,lon4] = polyjoin(T.Latitude(4),T.Longitude(4));
[lat5,lon5] = polyjoin(T.Latitude(5),T.Longitude(5));
[lat6,lon6] = polyjoin(T.Latitude(6),T.Longitude(6));
[lat7,lon7] = polyjoin(T.Latitude(7),T.Longitude(7));

Interrogare le elevazioni delle coordinate della traccia dai dati del terreno.

ctrElev1 = geointerp(georefGrid,spatialRef,lat1,lon1);
ctrElev2 = geointerp(georefGrid,spatialRef,lat2,lon2);
ctrElev3 = geointerp(georefGrid,spatialRef,lat3,lon3);
ctrElev4 = geointerp(georefGrid,spatialRef,lat4,lon4);
ctrElev5 = geointerp(georefGrid,spatialRef,lat5,lon5);
ctrElev6 = geointerp(georefGrid,spatialRef,lat6,lon6);
ctrElev7 = geointerp(georefGrid,spatialRef,lat7,lon7);

Crea una mappa RoadRunner HD

Crea la RoadRunner HD Map e imposta il riferimento geografico per la regione di interesse.

Crea una mappa RoadRunner HD vuota come oggetto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Calcolare le coordinate geografiche dell'origine della rete stradale come centro del quadrilatero di delimitazione della rete stradale.

[latLim1,lonLim1] = geoquadline(lat1,lon1);
latMean1 = mean(latLim1);
lonMean1 = mean(lonLim1);

Imposta il riferimento geografico per la regione di interesse.

rrMap.GeoReference = [latMean1 lonMean1];

Proietta le coordinate di latitudine e longitudine sulle coordinate xy della mappa

Trasforma le coordinate di latitudine e longitudine importate in coordinate della mappa xy utilizzando un sistema di riferimento di coordinate proiettato (CRS). Quindi, utilizzando le coordinate xy della mappa per i centri della pista, impostare la larghezza della pista.

Leggi il CRS proiettato Trasverso di Mercatore dalla mappa RoadRunner HD.

p = readCRS(rrMap);

Proiettare le coordinate di latitudine e longitudine sulle coordinate xy.

[x1,y1] = projfwd(p,lat1,lon1);
[x2,y2] = projfwd(p,lat2,lon2);
[x3,y3] = projfwd(p,lat3,lon3);
[x4,y4] = projfwd(p,lat4,lon4);
[x5,y5] = projfwd(p,lat5,lon5);
[x6,y6] = projfwd(p,lat6,lon6);
[x7,y7] = projfwd(p,lat7,lon7);

Definire i centri stradali e le larghezze stradali della pista di prova.

rdCtrs1 = [x1 y1 ctrElev1];
rdWidth1 = 6.5;
rdCtrs2 = [x2 y2 ctrElev2];
rdWidth2 = 10;
rdCtrs3 = [x3 y3 ctrElev3];
rdWidth3 = 5;
rdCtrs4 = [x4 y4 ctrElev4];
rdWidth4 = 3.5;

Upsampling dei dati stradali

Poiché i punti dati ottenuti dal file KML sono sparsi e il percorso di prova contiene curve strette, è necessario sovracampionare i dati per evitare di modellare corsie di pista imprecise. Eseguire l'upcampionamento dei dati utilizzando la funzione helper helperRoadDimensions .

[lftBndry1,rgtBndry1,ctrBndry1] = helperRoadDimensions(rdCtrs1,rdWidth1);
[lftBndry2,rgtBndry2,ctrBndry2] = helperRoadDimensions(rdCtrs2,rdWidth2);
[lftBndry3,rgtBndry3,ctrBndry3] = helperRoadDimensions(rdCtrs3,rdWidth3);
[lftBndry4,rgtBndry4,ctrBndry4] = helperRoadDimensions(rdCtrs4,rdWidth4);

Specificare le corsie e i confini delle corsie

Crea la mappa RoadRunner HD utilizzando i dati interpolati e modifica i dati per assomigliare alla pista di prova.

Specificare le proprietà della corsia per la mappa RoadRunner HD.

rrMap.Lanes(4,1) = roadrunner.hdmap.Lane;
for i = 1:4
    rrMap.Lanes(i).Geometry = eval(strcat("ctrBndry",num2str(i)));
    rrMap.Lanes(i).TravelDirection = "Bidirectional";
    rrMap.Lanes(i).ID = strcat("Lane",num2str(i));
    rrMap.Lanes(i).LaneType = "Driving";
end

Specificare le informazioni sul confine della corsia.

rrMap.LaneBoundaries(8,1) = roadrunner.hdmap.LaneBoundary;
for i = 1:4
    rrMap.LaneBoundaries(i*2-1).ID = strcat("Left",num2str(i));
    rrMap.LaneBoundaries(i*2).ID = strcat("Right",num2str(i));
    rrMap.LaneBoundaries(i*2-1).Geometry = eval(strcat('lftBndry',num2str(i)));
    rrMap.LaneBoundaries(i*2).Geometry = eval(strcat('rgtBndry',num2str(i)));
end

Specificare gli allineamenti 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),"Right3",Alignment="Forward");
leftBoundary(rrMap.Lanes(4),"Left4",Alignment="Forward");
rightBoundary(rrMap.Lanes(4),"Right4",Alignment="Forward");

Specificare la segnaletica orizzontale

Definire i percorsi dei file per le risorse che contrassegnano la corsia bianca continua e tratteggiata utilizzando oggetti roadrunner.hdmap.RelativeAssetPath .

wideSolidWhiteAsset = roadrunner.hdmap.RelativeAssetPath(AssetPath="Assets/Markings/Germany/WideSolidSingle.rrlms");
dashedWhiteAsset = roadrunner.hdmap.RelativeAssetPath(AssetPath="Assets/Markings/Germany/DashedSingle12.rrlms");

Creare riferimenti per la segnaletica orizzontale bianca continua e tratteggiata utilizzando oggetti roadrunner.hdmap.MarkingReference , per applicare la segnaletica orizzontale ai confini della corsia.

markingRefSW = roadrunner.hdmap.MarkingReference(MarkingID=roadrunner.hdmap.Reference(ID="WideSolidWhite"));
markingRefDW = roadrunner.hdmap.MarkingReference(MarkingID=roadrunner.hdmap.Reference(ID="DashedWhite"));

Crea la segnaletica orizzontale utilizzando un oggetto roadrunner.hdmap.LaneMarking .

rrMap.LaneMarkings(2,1) = roadrunner.hdmap.LaneMarking;
rrMap.LaneMarkings(1).ID = "WideSolidWhite";
rrMap.LaneMarkings(2).ID = "DashedWhite";
rrMap.LaneMarkings(1).AssetPath = wideSolidWhiteAsset;
rrMap.LaneMarkings(2).AssetPath = dashedWhiteAsset;

Creare le attribuzioni parametriche utilizzando i riferimenti di marcatura e gli intervalli di marcatura personalizzati.

prmAttr1Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0 0.007],MarkingReference=markingRefSW);
prmAttr1Span2 = roadrunner.hdmap.ParametricAttribution(Span=[0.007 0.01],MarkingReference=markingRefDW);
prmAttr1Span3 = roadrunner.hdmap.ParametricAttribution(Span=[0.01 0.93],MarkingReference=markingRefSW);
prmAttr1Span4 = roadrunner.hdmap.ParametricAttribution(Span=[0.93 0.95],MarkingReference=markingRefDW);
prmAttr1Span5 = roadrunner.hdmap.ParametricAttribution(Span=[0.95 1],MarkingReference=markingRefSW);
prmAttr2Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0 0.575],MarkingReference=markingRefSW);
prmAttr2Span2 = roadrunner.hdmap.ParametricAttribution(Span=[0.575 0.602],MarkingReference=markingRefDW);
prmAttr2Span3 = roadrunner.hdmap.ParametricAttribution(Span=[0.602 1],MarkingReference=markingRefSW);
prmAttr3Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0 1],MarkingReference=markingRefSW);
prmAttr4Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0 0.439],MarkingReference=markingRefSW);
prmAttr4Span2 = roadrunner.hdmap.ParametricAttribution(Span=[0.471 0.655],MarkingReference=markingRefSW);
prmAttr4Span3 = roadrunner.hdmap.ParametricAttribution(Span=[0.684 1],MarkingReference=markingRefSW);
prmAttr5Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0.06 0.315],MarkingReference=markingRefSW);
prmAttr5Span2 = roadrunner.hdmap.ParametricAttribution(Span=[0.73 0.94],MarkingReference=markingRefSW);
prmAttr6Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0.1 0.85],MarkingReference=markingRefSW);
prmAttr7Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0 1],MarkingReference=markingRefSW);
prmAttr8Span1 = roadrunner.hdmap.ParametricAttribution(Span=[0.2 0.959],MarkingReference=markingRefSW);

Specificare gli attributi parametrici per i confini della corsia in modo che assomiglino alla pista di prova.

rrMap.LaneBoundaries(1).ParametricAttributes = [prmAttr1Span1 prmAttr1Span2 prmAttr1Span3 prmAttr1Span4 prmAttr1Span5];
rrMap.LaneBoundaries(2).ParametricAttributes = [prmAttr2Span1 prmAttr2Span2 prmAttr2Span3];
rrMap.LaneBoundaries(3).ParametricAttributes = prmAttr3Span1;
rrMap.LaneBoundaries(4).ParametricAttributes = [prmAttr4Span1 prmAttr4Span2 prmAttr4Span3];
rrMap.LaneBoundaries(5).ParametricAttributes = [prmAttr5Span1 prmAttr5Span2];
rrMap.LaneBoundaries(6).ParametricAttributes = prmAttr6Span1;
rrMap.LaneBoundaries(7).ParametricAttributes = prmAttr7Span1;
rrMap.LaneBoundaries(8).ParametricAttributes = prmAttr8Span1;

Specificare le barriere

Creare un riferimento per l'asset BridgeRailing , per applicare le barriere ai confini della corsia.

path = roadrunner.hdmap.RelativeAssetPath(AssetPath="Assets/Extrusions/BridgeRailing.rrext");
rrMap.BarrierTypes(1) = roadrunner.hdmap.BarrierType(ID="BridgeRailing",ExtrusionPath=path);
guardRailRef = roadrunner.hdmap.Reference(ID="BridgeRailing");

Crea barriere utilizzando un oggetto roadrunner.hdmap.Barrier e specifica le barriere e le rispettive geometrie.

rrMap.Barriers(5,1) = roadrunner.hdmap.Barrier;
for i = 1:5
    rrMap.Barriers(i).BarrierTypeReference = guardRailRef;
    rrMap.Barriers(i).ID = strcat('Barrier',num2str(i));
    rrMap.Barriers(i).FlipLaterally = false;
end
rrMap.Barriers(1).Geometry = lftBndry1(6:428,:);
rrMap.Barriers(2).Geometry = [x5 y5 ctrElev5];
rrMap.Barriers(3).Geometry = [x6 y6 ctrElev6];
rrMap.Barriers(4).Geometry = [x7 y7 ctrElev7];
rrMap.Barriers(5).Geometry = lftBndry4;

Imposta i confini geografici e scrivi i dati della mappa su un file binario

L'impostazione dei confini geografici per la mappa RoadRunner HD centra la scena sulla strada importata e consente di inserire la rete stradale nella scena senza utilizzare lo strumento Impostazioni mondiali in RoadRunner.

Imposta i limiti geografici della mappa come valori delle coordinate minimo e massimo del confine sinistro.

minBndry = min(lftBndry1);
maxBndry = max(lftBndry1);
rrMap.GeographicBoundary = [minBndry; maxBndry];

Traccia i centri delle corsie e i confini delle corsie.

plot(rrMap)
title("RoadRunner HD Map of Test Track")
xlabel('x (m)')
ylabel('y (m)')

Scrivi la mappa RoadRunner HD in un file binario utilizzando la funzione write e copia il file nella cartella delle risorse per il tuo progetto. Questo codice utilizza un percorso di progetto Windows® di esempio.

fileName1 = "TestTrackMap.rrhd";
write(rrMap,fileName1)
copyfile TestTrackMap.rrhd C:\RR\MyProjects\Assets\

Importa il file della mappa HD RoadRunner in RoadRunner

Importa il file della mappa RoadRunner HD in RoadRunner per creare una scena, quindi salva la scena.

Per aprire RoadRunner utilizzando MATLAB, specifica il percorso del tuo progetto. Questo codice mostra una cartella di progetto di esempio in Windows. Apri RoadRunner utilizzando il percorso specificato per il tuo progetto.

rrProjectPath = "C:\RR\MyProjects";
rrApp = roadrunner(rrProjectPath);

Importa il file della mappa RoadRunner HD in RoadRunner e costruisci la scena. Per creare la scena, è necessario disporre di una licenza attiva RoadRunner Scene Builder .

options = roadrunnerHDMapImportOptions(ImportStep="Load");
importScene(rrApp,fullfile("C:\RR\MyProjects\Assets\","TestTrackMap.rrhd"),"RoadRunner HD Map",options)
buildScene(rrApp,"RoadRunner HD Map")

Salva la scena costruita.

fileName2 = "TestTrackMap.rrscene";
saveScene(rrApp,fileName2)

Questa immagine mostra la scena 3D della scena della pista di prova in RoadRunner.

Test track scene in RoadRunner

Per visualizzare la superficie del terreno, è possibile importare il file TestTrack.tif in RoadRunner utilizzando Strumento Mappa elevazione.

Test Track with terrain in RoadRunner

Vedi anche

roadrunner | roadrunnerHDMap