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.

Construya carreteras sencillas mediante programación utilizando RoadRunner HD Map

Este ejemplo utiliza:

Abrir script en vivo

RoadRunner HD Map es un modelo de datos de carreteras para representar datos de mapas de alta definición (HD) en una escena de RoadRunner . El modelo define una estructura simple para representar diseños de carreteras utilizando carriles, límites de carriles, marcas de carriles y cruces. Este ejemplo muestra cómo construir carreteras sencillas utilizando objetos y funciones de RoadRunner HD Map MATLAB® . Luego, las carreteras se pueden importar a RoadRunner. Los pasos para construir una carretera e importarla a una escena de RoadRunner son:

  • Construya un mapa HD en MATLAB

  • Verifique la representación de carriles y límites de carriles trazando el mapa en MATLAB

  • Escriba el mapa en un archivo RoadRunner HD Map (.rrhd)

  • Importe el archivo a RoadRunner y obtenga una vista previa de los datos del mapa RoadRunner HD

  • Cree una escena RoadRunner a partir del archivo importado (requiere RoadRunner Scene Builder).

Crear una carretera recta sin marcar

Una vía de ancho fijo se define mediante una serie de coordenadas x-y que corresponden a la ubicación del centro de la vía. Esta figura muestra un camino recto y sin marcar que creará en esta sección. También trazará la carretera en MATLAB y luego la guardará en un archivo binario.

Cree un mapa RoadRunner HD vacío llamando al objeto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Defina el centro de la carretera recta como una arreglo 2D que contiene tres conjuntos de coordenadas xy que especifican el centro de la carretera. Además, defina el ancho de la carretera.

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

Cree los límites izquierdo y derecho de la carretera utilizando el objeto roadrunner.hdmap.LaneBoundary . Especifique la información del límite del carril para la identificación del carril y las coordenadas que definen la geometría del carril.

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

Cree el carril de la carretera utilizando el objeto roadrunner.hdmap.Lane . Especifique la información del carril para la identificación del carril, las coordenadas que definen la geometría del carril, la dirección de conducción y el tipo de carril.

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

Vincule los límites de los carriles con los carriles. Defina los límites de los carriles izquierdo y derecho para cada carril y especifique la alineación entre los carriles y los límites de los carriles. 

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

Trace los centros y los límites de los carriles para obtener una vista previa de los carriles y los límites de los carriles antes de importarlos a RoadRunner.

plot(rrMap);

Escriba el mapa HD trazado en el paso anterior en un archivo usando la función write .

write(rrMap,"straightRoad.rrhd");

Importar y crear archivos de mapas HD en RoadRunner

Para obtener instrucciones detalladas sobre cómo importar un archivo de mapa RoadRunner HD con la extensión .rrhd a RoadRunner, obtener una vista previa del mapa y crear la escena, consulte Importar datos personalizados usando RoadRunner HD Map.

Abra la aplicación RoadRunner utilizando el objeto roadrunner desde la línea de comando de MATLAB® . Antes de crear un objeto roadrunner por primera vez, debe instalar RoadRunner y activar su licencia de RoadRunner de forma interactiva. Para obtener más información, consulte Instalar y activar RoadRunner.

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

Importe y cree los datos del mapa RoadRunner HD desde un archivo especificado en la escena abierta actualmente. Antes de construir la escena, debes activar tu licencia de RoadRunner SceneBuilder de forma interactiva.

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

Esta figura muestra una escena creada con RoadRunner Scene Builder.

Agregar marcas al camino recto

En esta sección, agregará marcas de carril blancas sólidas a los límites de los carriles izquierdo y derecho de la carretera recta que creó en la sección anterior. Para especificar una marca de carril, necesita un recurso en RoadRunner. En este ejemplo, utiliza activos que forman parte de Tipos de activos de RoadRunner. Estos activos se especifican en el mapa mediante una ruta relativa a la carpeta del proyecto RoadRunner .

Defina la ruta al activo de marca de carril blanco sólido usando la función roadrunner.hdmap.RelativeAssetPath .

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

Cree una marca de carril blanca sólida en la carretera recta utilizando el objeto roadrunner.hdmap.LaneMarking . Especifique la información de marca de carril para la identificación de marca de carril y la ruta al activo.

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

Cree una referencia para que la marca blanca sólida se aplique a los límites de los carriles utilizando el objeto roadrunner.hdmap.MarkingReference .

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

Utilice atributos paramétricos para aplicar esta marca de carril para abarcar toda la longitud de los límites de los carriles izquierdo y derecho. 

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

Escriba el mapa HD modificado en un archivo.

write(rrMap,"straightRoadWithMarkings.rrhd");

Importe y cree los datos del mapa RoadRunner HD desde un archivo especificado en la escena abierta actualmente. 

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

Esta figura muestra una escena creada con RoadRunner Scene Builder.

Crear un camino de doble sentido

Una carretera de doble sentido tiene dos carriles con direcciones de conducción opuestas. Una marca de carril amarilla sólida separa los carriles. Esta figura muestra una carretera recta de doble sentido que creará en esta sección. Se utilizan los mismos centros de carretera y ancho de carretera utilizados en las secciones anteriores.

Cree un mapa RoadRunner HD vacío llamando al objeto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Especifique el carril y los límites del carril. En este ejemplo, la inicialización previa de los valores da como resultado un rendimiento mejorado a medida que aumenta la cantidad de objetos en el mapa.

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

Asigne los valores de propiedad Lane . Utilice la función deal para hacer coincidir las listas de entrada y salida. 

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

Asigne los valores de propiedad LaneBoundaries . En este ejemplo, el carril central se comparte entre Lane1 y Lane2.

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

Vincule los límites de los carriles con los carriles. Defina los límites de los carriles izquierdo y derecho para cada carril y especifique la alineación entre los carriles y los límites de los carriles. 

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

Agregue una marca sólida amarilla además de la marca blanca sólida que agregó antes. Defina la ruta al activo de marca de carril amarillo continuo utilizando la función roadrunner.hdmap.RelativeAssetPath .

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

Cree una marca de carril amarilla continua en la carretera recta utilizando el objeto roadrunner.hdmap.LaneMarking . Especifique la información de marca de carril para la identificación de marca de carril y la ruta al activo.

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

Asigne la marca blanca a los límites del carril en los bordes del carril y la marca amarilla al límite del carril central. Estas marcas abarcan toda la longitud del límite.

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

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

plot(rrMap)

Escriba el mapa HD en un archivo.

write(rrMap,"twoWayRoad.rrhd");

Importe y cree los datos del mapa RoadRunner HD desde un archivo especificado en la escena abierta actualmente. 

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

Esta figura muestra una escena creada con RoadRunner Scene Builder.

Agregar un carril a una carretera de un solo sentido

En esta sección, agrega un carril a una carretera de un solo sentido. Se utiliza una marca blanca discontinua para separar dos carriles con la misma dirección de circulación. Para agregar un carril a una carretera de un solo sentido, deberá dividir un carril en dos desde el borde izquierdo del carril. Esto requiere crear carriles adicionales y límites de carriles en el mapa de RoadRunner HD donde el carril se divide. Esta figura muestra el carril que agregará a la vía de sentido único:

Cree un mapa RoadRunner HD vacío llamando al objeto roadrunnerHDMap .

rrMap = roadrunnerHDMap;

Especifique el carril y los límites del carril.

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

Especifique los grupos de carriles y las marcas de carriles.

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

Asigne los valores de propiedad Lane . Divida Lane1 en Lane4 y Lane5 y use Lane2 y Lane3 para transición.

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

Asigne los valores de propiedad LaneBoundaries . Lane3 comparte su límite derecho con Lane2, que se denota por 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]);

Vincule los límites de los carriles con los carriles. Defina los límites de los carriles izquierdo y derecho para cada carril y especifique la alineación 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),"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");

Especifique la alineación entre los carriles definiendo información sobre su relación predecesora y sucesora.

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

Agregue una marca blanca discontinua además de las marcas blancas y amarillas sólidas que agregó antes. Defina la ruta al activo de marca de carril blanco discontinuo utilizando la función roadrunner.hdmap.RelativeAssetPath .

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

Cree una marca de carril blanca discontinua en la carretera utilizando el objeto roadrunner.hdmap.LaneMarking .

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

Asigne marcas de carril utilizando los atributos paramétricos.

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

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

plot(rrMap)

Escriba el mapa HD en un archivo.

write(rrMap,"laneAdd.rrhd");

El usuario debe copiar el archivo de mapa HD a la carpeta de activos del proyecto actual cuando utilice las opciones de importación y construcción.

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

Cree opciones de importación de mapas RoadRunner HD que carguen el mapa.

importOptions = roadrunnerHDMapImportOptions(ImportStep="Load");

Cargue los datos del mapa RoadRunner HD del archivo especificado en la escena abierta actualmente. 

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

Cree opciones de construcción de mapas RoadRunner HD que construyan el mapa.

buildOptions = roadrunnerHDMapBuildOptions(DetectAsphaltSurfaces=true);

Cree los datos del mapa RoadRunner HD desde el archivo especificado en la escena abierta actualmente. 

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

Esta figura muestra una escena creada con RoadRunner Scene Builder.

Consulte también

|

Temas relacionados