Main Content

Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

Cree una escena 3D de pista de prueba en RoadRunner usando RoadRunner HD Map

Este ejemplo utiliza:

Abrir script en vivo

Este ejemplo muestra cómo crear una escena RoadRunner para una pista de prueba usando funciones MATLAB®. Puede crear una escena de la pista de prueba utilizando un archivo Keyhole Markup Language (KML) que contiene sus coordenadas de latitud y longitud y un archivo GeoTIFF que contiene su elevación. Para importar los archivos de datos de la carretera, debe tener una licencia de Mapping Toolbox™ .

Importar archivo KML para pista de prueba

En este ejemplo, importa las coordenadas de los centros de seguimiento a MATLAB desde un archivo KML (datos de mapas © 2022 de Google) y luego ve las coordenadas utilizando funciones de MATLAB para trazar los datos importados desde el archivo KML.

Cree una tabla geoespacial leyendo datos geográficos del archivo KML.

kmlData = readgeotable("TestTrackKMLData.kml");

Trazar las coordenadas de la pista de prueba.

geoplot(kmlData)
geobasemap topographic

Importar archivo GeoTIFF para pista de prueba

Los datos de muestra del terreno utilizados en este ejemplo se descargaron de EarthExplorer, que proporciona datos de ciencias terrestres de los archivos del Servicio Geológico de los Estados Unidos (USGS). Puede descargar el archivo TIF desde el sitio web del USGS cargando el archivo de forma en EarthExplorer, que recorta EarthExplorer en el área de la pista de prueba.

Convierta la tabla geoespacial en una tabla de centros de carreteras para obtener las coordenadas de latitud y longitud de la pista de prueba.

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));

Consulta las elevaciones de las coordenadas de la ruta a partir de los datos 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);

Crear mapa RoadRunner HD

Cree el mapa RoadRunner HD y establezca la referencia geográfica para la región de interés.

Cree un mapa RoadRunner HD vacío como un objeto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Calcule las coordenadas geográficas del origen de la red vial como el centro del cuadrilátero delimitador de la red vial.

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

Establezca la referencia geográfica para la región de interés.

rrMap.GeoReference = [latMean1 lonMean1];

Proyecto Coordenadas Latitud-Longitud a Coordenadas del Mapa xy

Transforme las coordenadas de latitud y longitud importadas en coordenadas del mapa xy utilizando un sistema de referencia de coordenadas proyectadas (CRS). Luego, utilizando las coordenadas del mapa xy para los centros de la pista, establezca el ancho de la pista.

Lea el CRS proyectado de Transverse Mercator en el mapa HD de RoadRunner .

p = readCRS(rrMap);

Proyecte las coordenadas de latitud y longitud en coordenadas 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);

Defina los centros de las carreteras y los anchos de las carreteras de la pista de prueba.

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;

Muestra de datos de carreteras

Debido a que los puntos de datos obtenidos del archivo KML son escasos y la pista de prueba contiene curvas cerradas, debe realizar un muestreo adicional de los datos para evitar modelar carriles de pista inexactos. Realice un muestreo de los datos utilizando la función auxiliar 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);

Especificar carriles y límites de carriles

Cree el mapa RoadRunner HD utilizando los datos interpolados y modifíquelos para que se parezcan a la pista de prueba.

Especifique las propiedades del carril para el mapa 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

Especifique la información del límite del carril.

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

Especifique las alineaciones entre los carriles y los límites de los carriles.

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");

Especificar marcas de carril

Defina rutas de archivos a los activos de señalización de carril blanco sólido y blanco discontinuo utilizando objetos roadrunner.hdmap.RelativeAssetPath .

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

Cree referencias para las marcas anchas blancas sólidas y blancas discontinuas utilizando objetos roadrunner.hdmap.MarkingReference , para aplicar las marcas a los límites de los carriles.

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

Cree marcas de carril utilizando un objeto 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;

Cree las atribuciones paramétricas utilizando las referencias de marcado y los intervalos de marcado personalizados.

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);

Especifique los atributos paramétricos de los límites de los carriles para que se parezcan a la pista de prueba.

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;

Especificar barreras

Cree una referencia para el activo BridgeRailing , para aplicar las barreras a los límites de los carriles.

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");

Cree barreras utilizando un objeto roadrunner.hdmap.Barrier y especifique las barreras y sus respectivas geometrías.

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;

Establecer límites geográficos y escribir datos de mapas en un archivo binario

Configurar los límites geográficos para el mapa RoadRunner HD centra la escena en la carretera importada y le permite insertar la red de carreteras en la escena sin usar la herramienta Configuración mundial en RoadRunner.

Establezca los límites geográficos del mapa como los valores de coordenadas mínimo y máximo del límite izquierdo.

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

Trazar los centros de los carriles y los límites de los carriles.

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

Escriba el mapa RoadRunner HD en un archivo binario usando la función write y copie el archivo en la carpeta de activos de su proyecto. Este código utiliza una ruta de proyecto de Windows® de muestra.

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

Importar archivo de mapa RoadRunner HD a RoadRunner

Importe su archivo de mapa RoadRunner HD a RoadRunner para crear una escena y luego guárdela.

Para abrir RoadRunner usando MATLAB, especifique la ruta a su proyecto. Este código muestra una carpeta de proyecto de muestra en Windows. Abra RoadRunner usando la ruta especificada a su proyecto.

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

Importe su archivo de mapa RoadRunner HD a RoadRunner y cree la escena. Para crear la escena, debe tener una licencia activa de 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")

Guarde la escena construida.

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

Esta imagen muestra la escena 3D de la pista de pruebas en RoadRunner.

Test track scene in RoadRunner

Para visualizar la superficie del terreno, puede importar el archivo TestTrack.tif a RoadRunner usando el Herramienta de mapa de elevación.

Test Track with terrain in RoadRunner

Consulte también

|

Temas relacionados