grid_map
1.6.4
Esta es una biblioteca C++ con interfaz ROS para administrar mapas de cuadrícula bidimensionales con múltiples capas de datos. Está diseñado para que el mapeo robótico móvil almacene datos como elevación, variación, color, coeficiente de fricción, calidad del punto de apoyo, normal de la superficie, transitabilidad, etc. Se utiliza en el paquete de mapeo de elevación centrado en robot diseñado para navegación en terrenos accidentados.
Características:
Este es un código de investigación, espere que cambie con frecuencia y que se rechace cualquier idoneidad para un propósito particular.
El código fuente se publica bajo una licencia BSD de 3 cláusulas.
Autor: Péter Fankhauser
Afiliación: ANYbotics
Mantenedor: Maximilian Wulf, [email protected], Magnus Gärtner, [email protected]
Con contribuciones de: Simone Arreghini, Tanja Baumann, Jeff Delmerico, Remo Diethelm, Perry Franklin, Magnus Gärtner, Ruben Grandia, Edo Jelavic, Dominic Jud, Ralph Kaestner, Philipp Krüsi, Alex Millane, Daniel Stonier, Elena Stumm, Martin Wermelinger, Christos Zalidis
Este proyecto fue desarrollado inicialmente en ETH Zurich (Laboratorio de Sistemas Autónomos y Laboratorio de Sistemas Robóticos).
Este trabajo se lleva a cabo como parte de ANYmal Research, una comunidad para avanzar en la robótica con patas.
Si utiliza este trabajo en un contexto académico, cite la siguiente publicación:
P. Fankhauser y M. Hutter, "Una biblioteca de mapas de cuadrícula universal: implementación y caso de uso para navegación en terrenos difíciles" , en Robot Operating System (ROS): la referencia completa (volumen 1), A. Koubaa (Ed.), Springer , 2016. (PDF)
@incollection{Fankhauser2016GridMapLibrary,
author = {Fankhauser, P{'{e}}ter and Hutter, Marco},
booktitle = {Robot Operating System (ROS) – The Complete Reference (Volume 1)},
title = {{A Universal Grid Map Library: Implementation and Use Case for Rough Terrain Navigation}},
chapter = {5},
editor = {Koubaa, Anis},
publisher = {Springer},
year = {2016},
isbn = {978-3-319-26052-5},
doi = {10.1007/978-3-319-26054-9{_}5},
url = {http://www.springer.com/de/book/9783319260525}
}
Actualmente se mantienen estas sucursales:
Las solicitudes de extracción para ROS 1 deben apuntar master . Las solicitudes de extracción para ROS 2 deben apuntar a rolling y se respaldarán si no rompen la ABI.
En este capítulo del libro se ofrece una introducción a la biblioteca de mapas de cuadrícula, incluido un tutorial.
La API de C++ está documentada aquí:
Para instalar todos los paquetes de la biblioteca de mapas de cuadrícula como usan los paquetes de Debian
sudo apt-get install ros-$ROS_DISTRO-grid-map
El paquete grid_map_core depende únicamente de la biblioteca de álgebra lineal Eigen.
sudo apt-get install libeigen3-dev
Los demás paquetes dependen además de la instalación estándar de ROS ( roscpp , tf , filters , sensor_msgs , nav_msgs y cv_bridge ). Otros paquetes de conversión específicos de formato (por ejemplo , grid_map_cv , grid_map_pcl , etc.) dependen de los paquetes que se describen a continuación en Descripción general de paquetes .
Para compilar desde el código fuente, clone la última versión de este repositorio en su espacio de trabajo catkin y compile el paquete usando
cd catkin_ws/src
git clone https://github.com/anybotics/grid_map.git
cd ../
catkin_make
Para maximizar el rendimiento, asegúrese de compilar en modo de lanzamiento . Puede especificar el tipo de compilación configurando
catkin_make -DCMAKE_BUILD_TYPE=Release
Este repositorio consta de los siguientes paquetes:
GridMap y varias clases auxiliares, como los iteradores. Este paquete se implementa sin dependencias de ROS.Paquetes de conversión adicionales:
Ejecute las pruebas unitarias con
catkin_make run_tests_grid_map_core run_tests_grid_map_ros
o
catkin build grid_map --no-deps --verbose --catkin-make-args run_tests
si está utilizando herramientas de amento.
El paquete grid_map_demos contiene varios nodos de demostración. Utilice este código para verificar su instalación de los paquetes de mapas de cuadrícula y comenzar con su propio uso de la biblioteca.
simple_demo muestra un ejemplo sencillo del uso de la biblioteca de mapas de cuadrícula. Este nodo ROS crea un mapa de cuadrícula, le agrega datos y lo publica. Para ver el resultado en RViz, ejecute el comando
roslaunch grid_map_demos simple_demo.launch
tutorial_demo es una demostración ampliada de las funcionalidades de la biblioteca. Inicie el tutorial_demo con
roslaunch grid_map_demos tutorial_demo.launch
iterators_demo muestra el uso de los iteradores del mapa de cuadrícula. Ejecútelo con
roslaunch grid_map_demos iterators_demo.launch
image_to_gridmap_demo demuestra cómo convertir datos de una imagen a un mapa de cuadrícula. Comience la demostración con
roslaunch grid_map_demos image_to_gridmap_demo.launch
grid_map_to_image_demo muestra cómo guardar una capa de mapa de cuadrícula en una imagen. Comience la demostración con
rosrun grid_map_demos grid_map_to_image_demo _grid_map_topic:=/grid_map _file:=/home/$USER/Desktop/grid_map_image.png
opencv_demo demuestra manipulaciones de mapas con la ayuda de funciones OpenCV. Comience la demostración con
roslaunch grid_map_demos opencv_demo.launch
resolución_change_demo muestra cómo se puede cambiar la resolución de un mapa de cuadrícula con la ayuda de los métodos de escalado de imágenes OpenCV. Para ver los resultados, utilizar
roslaunch grid_map_demos resolution_change_demo.launch
filters_demo utiliza una cadena de filtros ROS para procesar un mapa de cuadrícula. A partir de la elevación de un mapa del terreno, la demostración utiliza varios filtros para mostrar cómo calcular las normales de la superficie, usar pintura para rellenar agujeros, suavizar/desenfocar el mapa y usar expresiones matemáticas para detectar bordes, calcular la rugosidad y la transitabilidad. La configuración de la cadena de filtros se configura en el archivo filters_demo_filter_chain.yaml . Inicie la demostración con
roslaunch grid_map_demos filters_demo.launch
Para obtener más información sobre los filtros de mapas de cuadrícula, consulte grid_map_filters.
interpolation_demo muestra el resultado de diferentes métodos de interpolación en la superficie resultante. Inicie la demostración, use
roslaunch grid_map_demos interpolation_demo.launch
El usuario puede jugar con diferentes mundos (superficies) y diferentes configuraciones de interpolación en el archivo interpolation_demo.yaml . La visualización muestra la verdad fundamental en color verde y amarillo. El resultado de la interpolación se muestra en colores rojo y morado. Además, la demostración calcula los errores de interpolación máximos y promedio, así como el tiempo promedio requerido para una única consulta de interpolación.
El mapa de cuadrícula presenta cuatro métodos de interpolación diferentes (en orden de precisión creciente y complejidad creciente):
Para obtener más detalles, consulte la literatura que figura en el archivo CubicInterpolation.hpp .
La biblioteca de mapas de cuadrícula contiene varios iteradores para mayor comodidad.
| Mapa de cuadrícula | Submapa | Círculo | Línea | Polígono |
|---|---|---|---|---|
 |  |  |  |  |
| Elipse | Espiral | |||
 |  |
Es común usar el iterador en un bucle for . Por ejemplo, itere sobre todo el mapa de cuadrícula con GridMapIterator con
for (grid_map::GridMapIterator iterator(map); !iterator.isPastEnd(); ++iterator) {
cout << "The value at index " << (*iterator).transpose() << " is " << map.at("layer", *iterator) << endl;
}
Los otros iteradores del mapa de cuadrícula siguen la misma forma. Puede encontrar más ejemplos sobre cómo utilizar los diferentes iteradores en el nodo iterators_demo .
Nota: Para obtener la máxima eficiencia al utilizar iteradores, se recomienda almacenar localmente el acceso directo a las capas de datos del mapa de cuadrícula con grid_map::Matrix& data = map["layer"] fuera del bucle for :
grid_map::Matrix& data = map["layer"];
for (GridMapIterator iterator(map); !iterator.isPastEnd(); ++iterator) {
const Index index(*iterator);
cout << "The value at index " << index.transpose() << " is " << data(index(0), index(1)) << endl;
}
Puede encontrar una evaluación comparativa del rendimiento de los iteradores en el nodo iterator_benchmark del paquete grid_map_demos que se puede ejecutar con
rosrun grid_map_demos iterator_benchmark
Tenga en cuenta que, si bien los iteradores son convenientes, a menudo es más limpio y eficiente utilizar los métodos Eigen integrados. A continuación se muestran algunos ejemplos:
Establecer un valor constante para todas las celdas de una capa:
map["layer"].setConstant(3.0);
Añadiendo dos capas:
map["sum"] = map["layer_1"] + map["layer_2"];
Escalar una capa:
map["layer"] = 2.0 * map["layer"];
Máx. valores entre dos capas:
map["max"] = map["layer_1"].cwiseMax(map["layer_2"]);
Calcule la raíz del error cuadrático medio:
map.add("error", (map.get("layer_1") - map.get("layer_2")).cwiseAbs());
unsigned int nCells = map.getSize().prod();
double rootMeanSquaredError = sqrt((map["error"].array().pow(2).sum()) / nCells);
Hay dos métodos diferentes para cambiar la posición del mapa:
setPosition(...) : Cambia la posición del mapa sin cambiar los datos almacenados en el mapa. Esto cambia la correspondencia entre los datos y el marco del mapa.
move(...) : Reubica la región capturada por el mapa de cuadrícula wrt al marco del mapa de cuadrícula estática. Utilícelo para mover los límites del mapa de cuadrícula sin reubicar los datos del mapa de cuadrícula. Se encarga de todo el manejo de datos, de modo que los datos del mapa de cuadrícula estén estacionarios en el marco del mapa de cuadrícula.
Nota : debido a la estructura circular del búfer, es posible que los índices vecinos no queden muy cerca en el marco del mapa. Esta suposición sólo es válida para los índices obtenidos mediante getUnwrappedIndex().
setPosition(...) | move(...) |
|---|---|
 |  |
Este complemento de RViz visualiza una capa de mapa de cuadrícula como un gráfico de superficie 3D (mapa de altura). Se puede elegir una capa separada como capa para la información de color.
Este paquete proporciona un algoritmo eficiente para convertir un mapa de elevación en un denso campo de distancia firmado en 3D. Cada punto de la cuadrícula 3D contiene la distancia al punto más cercano del mapa junto con el gradiente.
Este nodo se suscribe a un tema de tipo grid_map_msgs/GridMap y publica mensajes que se pueden visualizar en RViz. Los temas publicados del visualizador se pueden configurar completamente con un archivo de parámetros YAML. Se puede agregar cualquier número de visualizaciones con diferentes parámetros. Aquí hay un ejemplo para el archivo de configuración de tutorial_demo .
| Nube de puntos | Vectores | Cuadrícula de ocupación | Celdas de cuadrícula |
|---|---|---|---|
 |  |  |  |
grid_map_topic (cadena, predeterminado: "/grid_map")
El nombre del tema del mapa de cuadrícula que se visualizará. Consulte a continuación la descripción de los visualizadores.
/grid_map (grid_map_msgs/GridMap)
El mapa de cuadrícula para visualizar.
Los temas publicados se configuran con el archivo de parámetros YAML. Los posibles temas son:
point_cloud (sensor_msgs/PointCloud2)
Muestra el mapa de cuadrícula como una nube de puntos. Seleccione qué capa transformar como puntos con el parámetro layer .
name: elevation
type: point_cloud
params:
layer: elevation
flat: false # optional
flat_point_cloud (sensor_msgs/PointCloud2)
Muestra el mapa de cuadrícula como una nube de puntos "plana", es decir, con todos los puntos a la misma altura z . Esto es conveniente para visualizar mapas o imágenes en 2D (o incluso secuencias de video) en RViz con la ayuda de su Color Transformer . El parámetro height determina la posición z deseada de la nube de puntos planos.
name: flat_grid
type: flat_point_cloud
params:
height: 0.0
Nota: Para omitir puntos en la nube de puntos planos de celdas vacías/no válidas, especifique las capas cuya validez se debe verificar con setBasicLayers(...) .
vectors (visualization_msgs/Marcador)
Visualiza datos vectoriales del mapa de cuadrícula como marcadores visuales. Especifique las capas que contienen los componentes x , y y z de los vectores con el parámetro layer_prefix . El parámetro position_layer define la capa que se utilizará como punto inicial de los vectores.
name: surface_normals
type: vectors
params:
layer_prefix: normal_
position_layer: elevation
scale: 0.06
line_width: 0.005
color: 15600153 # red
occupancy_grid (nav_msgs/OcupaciónGrid)
Visualiza una capa del mapa de cuadrícula como cuadrícula de ocupación. Especifique la capa que se visualizará con el parámetro layer y el límite superior e inferior con data_min y data_max .
name: traversability_grid
type: occupancy_grid
params:
layer: traversability
data_min: -0.15
data_max: 0.15
grid_cells (nav_msgs/GridCells)
Visualiza una capa del mapa de cuadrícula como celdas de cuadrícula. Especifique la capa que se visualizará con el parámetro layer y los límites superior e inferior con lower_threshold y upper_threshold .
name: elevation_cells
type: grid_cells
params:
layer: elevation
lower_threshold: -0.08 # optional, default: -inf
upper_threshold: 0.08 # optional, default: inf
region (visualización_msgs/Marcador)
Muestra el límite del mapa de cuadrícula.
name: map_region
type: map_region
params:
color: 3289650
line_width: 0.003
Nota: Los valores de color están en formato RGB como números enteros concatenados (para cada valor de canal 0-255). Los valores se pueden generar así como ejemplo para el color verde (rojo: 0, verde: 255, azul: 0).
El paquete grid_map_filters contiene varios filtros que se pueden aplicar a un mapa de cuadrícula para realizar cálculos sobre los datos en las capas. Los filtros del mapa de cuadrícula se basan en filtros ROS, lo que significa que se puede configurar una cadena de filtros como un archivo YAML. Además, se pueden escribir filtros adicionales y ponerlos a disposición a través del mecanismo del complemento ROS, como InpaintFilter del paquete grid_map_cv .
Se proporcionan varios filtros básicos en el paquete grid_map_filters :
gridMapFilters/ThresholdFilter
Establezca los valores en la capa de salida en un valor específico si condition_layer excede el umbral superior o inferior (solo un umbral a la vez).
name: lower_threshold
type: gridMapFilters/ThresholdFilter
params:
condition_layer: layer_name
output_layer: layer_name
lower_threshold: 0.0 # alternative: upper_threshold
set_to: 0.0 # # Other uses: .nan, .inf
gridMapFilters/MeanInRadiusFilter
Calcule para cada celda de una capa el valor medio dentro de un radio.
name: mean_in_radius
type: gridMapFilters/MeanInRadiusFilter
params:
input_layer: input
output_layer: output
radius: 0.06 # in m.
gridMapFilters/MedianFillFilter
Calcule para cada celda NaN de una capa la mediana (de finitos) dentro de un parche con radio. Opcionalmente, aplique cálculos de mediana para valores que ya son finitos; el radio del parche para estos puntos viene dado por radio_valor_existente. Tenga en cuenta que el cálculo del relleno solo se realiza si fill_mask es válido para ese punto.
name: median
type: gridMapFilters/MedianFillFilter
params:
input_layer: input
output_layer: output
fill_hole_radius: 0.11 # in m.
filter_existing_values: false # Default is false. If enabled it also does a median computation for existing values.
existing_value_radius: 0.2 # in m. Note that this option only has an effect if filter_existing_values is set true.
fill_mask_layer: fill_mask # A layer that is used to compute which areas to fill. If not present in the input it is automatically computed.
debug: false # If enabled, the additional debug_infill_mask_layer is published.
debug_infill_mask_layer: infill_mask # Layer used to visualize the intermediate, sparse-outlier removed fill mask. Only published if debug is enabled.
gridMapFilters/NormalVectorsFilter
Calcule los vectores normales de una capa en un mapa.
name: surface_normals
type: gridMapFilters/NormalVectorsFilter
params:
input_layer: input
output_layers_prefix: normal_vectors_
radius: 0.05
normal_vector_positive_axis: z
gridMapFilters/NormalColorMapFilter
Calcule una nueva capa de color basada en capas de vectores normales.
name: surface_normals
type: gridMapFilters/NormalColorMapFilter
params:
input_layers_prefix: normal_vectors_
output_layer: normal_color
gridMapFilters/MathExpressionFilter
Analizar y evaluar una expresión matricial matemática con capas de un mapa de cuadrícula. Consulte EigenLab para obtener la documentación de las expresiones.
name: math_expression
type: gridMapFilters/MathExpressionFilter
params:
output_layer: output
expression: acos(normal_vectors_z) # Slope.
# expression: abs(elevation - elevation_smooth) # Surface roughness.
# expression: 0.5 * (1.0 - (slope / 0.6)) + 0.5 * (1.0 - (roughness / 0.1)) # Weighted and normalized sum.
gridMapFilters/SlidingWindowMathExpressionFilter
Analiza y evalúa una expresión matricial matemática dentro de una ventana deslizante en una capa de un mapa de cuadrícula. Consulte EigenLab para obtener la documentación de las expresiones.
name: math_expression
type: gridMapFilters/SlidingWindowMathExpressionFilter
params:
input_layer: input
output_layer: output
expression: meanOfFinites(input) # Box blur
# expression: sqrt(sumOfFinites(square(input - meanOfFinites(input))) ./ numberOfFinites(input)) # Standard deviation
# expression: 'sumOfFinites([0,-1,0;-1,5,-1;0,-1,0].*elevation_inpainted)' # Sharpen with kernel matrix
compute_empty_cells: true
edge_handling: crop # options: inside, crop, empty, mean
window_size: 5 # in number of cells (optional, default: 3), make sure to make this compatible with the kernel matrix
# window_length: 0.05 # instead of window_size, in m
gridMapFilters/DuplicationFilter
Duplica una capa de un mapa de cuadrícula.
name: duplicate
type: gridMapFilters/DuplicationFilter
params:
input_layer: input
output_layer: output
gridMapFilters/DeletionFilter
Eliminar capas de un mapa de cuadrícula.
name: delete
type: gridMapFilters/DeletionFilter
params:
layers: [color, score] # List of layers.
Además, el paquete grid_map_cv proporciona los siguientes filtros:
gridMapCv/InpaintFilter
Utilice OpenCV para pintar/rellenar agujeros en una capa.
name: inpaint
type: gridMapCv/InpaintFilter
params:
input_layer: input
output_layer: output
radius: 0.05 # in m
| Cinético | Melódico | Noético | |
|---|---|---|---|
| mapa_cuadricula | |||
| doc |
| Cinético | Melódico | Noético | |
|---|---|---|---|
| mapa_cuadricula | |||
| grid_map_core | |||
| grid_map_costmap_2d | |||
| grid_map_cv | |||
| grid_map_demos | |||
| filtros_mapa_cuadrícula | |||
| cargador_mapa_cuadrícula | |||
| grid_map_msgs | |||
| grid_map_octomap | |||
| grid_map_pcl | |||
| grid_map_ros | |||
| grid_map_rviz_plugin | |||
| grid_map_sdf | |||
| visualización_mapa_cuadrícula |
Informe errores y solicite funciones utilizando el Rastreador de problemas.
