grid_map
1.6.4
Il s'agit d'une bibliothèque C++ avec interface ROS pour gérer des cartes quadrillées bidimensionnelles avec plusieurs couches de données. Il est conçu pour la cartographie robotique mobile afin de stocker des données telles que l'élévation, la variance, la couleur, le coefficient de frottement, la qualité du pied, la normale de la surface, la traversabilité, etc. Il est utilisé dans le package de cartographie d'élévation centrée sur le robot conçu pour la navigation sur terrain accidenté.
Caractéristiques:
Il s'agit d'un code de recherche, attendez-vous à ce qu'il change souvent et toute adéquation à un objectif particulier est exclue.
Le code source est publié sous une licence BSD 3-Clause.
Auteur : Péter Fankhauser
Affiliation : ANYbotics
Responsable : Maximilian Wulf, [email protected], Magnus Gärtner, [email protected]
Avec les contributions 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
Ce projet a été initialement développé à l'ETH Zurich (Autonomous Systems Lab & Robotic Systems Lab).
Ce travail est mené dans le cadre d’ANYmal Research, une communauté visant à faire progresser la robotique à pattes.
Si vous utilisez cet ouvrage dans un contexte académique, veuillez citer la publication suivante :
P. Fankhauser et M. Hutter, "A Universal Grid Map Library: Implementation and Use Case for Rough Terrain Navigation" , dans Robot Operating System (ROS) - The Complete Reference (Volume 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}
}
Ces succursales sont actuellement maintenues :
Les demandes d'extraction pour ROS 1 doivent cibler master . Les demandes d'extraction pour ROS 2 doivent cibler rolling et seront rétroportées si elles ne rompent pas l'ABI.
Une introduction à la bibliothèque de cartes quadrillées comprenant un didacticiel est donnée dans ce chapitre du livre.
L'API C++ est documentée ici :
Pour installer tous les paquets de la bibliothèque de cartes de grille comme les paquets Debian utilisent
sudo apt-get install ros-$ROS_DISTRO-grid-map
Le package grid_map_core dépend uniquement de la bibliothèque d'algèbre linéaire Eigen.
sudo apt-get install libeigen3-dev
Les autres packages dépendent en outre de l'installation standard de ROS ( roscpp , tf , filters , sensor_msgs , nav_msgs et cv_bridge ). D'autres packages de conversion spécifiques au format (par exemple , grid_map_cv , grid_map_pcl etc.) dépendent des packages décrits ci-dessous dans Présentation des packages .
Pour construire à partir des sources, clonez la dernière version de ce référentiel dans votre espace de travail catkin et compilez le package en utilisant
cd catkin_ws/src
git clone https://github.com/anybotics/grid_map.git
cd ../
catkin_make
Pour optimiser les performances, assurez-vous de créer en mode Release . Vous pouvez spécifier le type de build en définissant
catkin_make -DCMAKE_BUILD_TYPE=Release
Ce référentiel se compose des packages suivants :
GridMap et plusieurs classes d'assistance telles que les itérateurs. Ce package est implémenté sans dépendances ROS.Forfaits de conversion supplémentaires :
Exécutez les tests unitaires avec
catkin_make run_tests_grid_map_core run_tests_grid_map_ros
ou
catkin build grid_map --no-deps --verbose --catkin-make-args run_tests
si vous utilisez des outils chatons.
Le package grid_map_demos contient plusieurs nœuds de démonstration. Utilisez ce code pour vérifier votre installation des packages de cartes de grille et pour démarrer avec votre propre utilisation de la bibliothèque.
simple_demo montre un exemple simple d'utilisation de la bibliothèque de cartes quadrillées. Ce nœud ROS crée une carte quadrillée, y ajoute des données et la publie. Pour voir le résultat dans RViz, exécutez la commande
roslaunch grid_map_demos simple_demo.launch
tutoriel_demo est une démonstration étendue des fonctionnalités de la bibliothèque. Lancez le tutoriel_demo avec
roslaunch grid_map_demos tutorial_demo.launch
iterators_demo présente l'utilisation des itérateurs de carte de grille. Lancez-le avec
roslaunch grid_map_demos iterators_demo.launch
image_to_gridmap_demo montre comment convertir les données d'une image en une carte quadrillée. Commencez la démonstration avec
roslaunch grid_map_demos image_to_gridmap_demo.launch
grid_map_to_image_demo montre comment enregistrer une couche de carte quadrillée sur une image. Commencez la démonstration avec
rosrun grid_map_demos grid_map_to_image_demo _grid_map_topic:=/grid_map _file:=/home/$USER/Desktop/grid_map_image.png
opencv_demo démontre les manipulations de cartes à l'aide des fonctions OpenCV. Commencez la démonstration avec
roslaunch grid_map_demos opencv_demo.launch
résolution_change_demo montre comment la résolution d'une carte quadrillée peut être modifiée à l'aide des méthodes de mise à l'échelle d'image OpenCV. Pour voir les résultats, utilisez
roslaunch grid_map_demos resolution_change_demo.launch
filters_demo utilise une chaîne de filtres ROS pour traiter une carte quadrillée. À partir de l'élévation d'une carte de terrain, la démo utilise plusieurs filtres pour montrer comment calculer les normales de surface, utiliser l'inpainting pour remplir les trous, lisser/flou la carte et utiliser des expressions mathématiques pour détecter les bords, calculer la rugosité et la traversabilité. La configuration de la chaîne de filtres est configurée dans le fichier filters_demo_filter_chain.yaml . Lancez la démo avec
roslaunch grid_map_demos filters_demo.launch
Pour plus d’informations sur les filtres de carte de grille, consultez grid_map_filters.
interpolation_demo montre le résultat de différentes méthodes d'interpolation sur la surface résultante. Pour lancer la démo, utilisez
roslaunch grid_map_demos interpolation_demo.launch
L'utilisateur peut jouer avec différents mondes (surfaces) et différents paramètres d'interpolation dans le fichier interpolation_demo.yaml . La visualisation affiche la vérité terrain en vert et jaune. Le résultat de l'interpolation est affiché en rouge et violet. En outre, la démo calcule les erreurs d'interpolation maximales et moyennes, ainsi que le temps moyen requis pour une seule requête d'interpolation.
La carte quadrillée propose quatre méthodes d'interpolation différentes (par ordre de précision croissante et de complexité croissante) :
Pour plus de détails, consultez la littérature répertoriée dans le fichier CubicInterpolation.hpp .
La bibliothèque de cartes en grille contient divers itérateurs pour plus de commodité.
| Carte quadrillée | Sous-carte | Cercle | Doubler | Polygone |
|---|---|---|---|---|
 |  |  |  |  |
| Ellipse | Spirale | |||
 |  |
L’utilisation de l’itérateur dans une boucle for est courante. Par exemple, parcourez toute la carte de la grille avec GridMapIterator avec
for (grid_map::GridMapIterator iterator(map); !iterator.isPastEnd(); ++iterator) {
cout << "The value at index " << (*iterator).transpose() << " is " << map.at("layer", *iterator) << endl;
}
Les autres itérateurs de grille suivent le même formulaire. Vous pouvez trouver plus d'exemples sur la façon d'utiliser les différents itérateurs dans le nœud iterators_demo .
Remarque : Pour une efficacité maximale lors de l'utilisation d'itérateurs, il est recommandé de stocker localement l'accès direct aux couches de données de la carte de grille avec grid_map::Matrix& data = map["layer"] en dehors de la boucle 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;
}
Vous pouvez trouver une analyse comparative des performances des itérateurs dans le nœud iterator_benchmark du package grid_map_demos qui peut être exécuté avec
rosrun grid_map_demos iterator_benchmark
Attention, même si les itérateurs sont pratiques, il est souvent le plus propre et le plus efficace d'utiliser les méthodes Eigen intégrées. Voici quelques exemples :
Définir une valeur constante pour toutes les cellules d'un calque :
map["layer"].setConstant(3.0);
Ajout de deux couches :
map["sum"] = map["layer_1"] + map["layer_2"];
Mise à l'échelle d'un calque :
map["layer"] = 2.0 * map["layer"];
Max. valeurs entre deux couches :
map["max"] = map["layer_1"].cwiseMax(map["layer_2"]);
Calculez l’erreur quadratique moyenne :
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);
Il existe deux méthodes différentes pour modifier la position de la carte :
setPosition(...) : Change la position de la carte sans modifier les données stockées dans la carte. Cela modifie la correspondance entre les données et la fenêtre cartographique.
move(...) : déplace la région capturée par la carte quadrillée par rapport au cadre de la carte quadrillée statique. Utilisez cette option pour déplacer les limites de la carte quadrillée sans déplacer les données de la carte quadrillée. S'occupe de toute la gestion des données, de sorte que les données de la carte quadrillée soient stationnaires dans le cadre de la carte quadrillée.
Remarque : En raison de la structure circulaire du tampon, les indices voisins peuvent ne pas être proches dans la fenêtre cartographique. Cette hypothèse n'est valable que pour les indices obtenus par getUnwrappedIndex().
setPosition(...) | move(...) |
|---|---|
 |  |
Ce plugin RViz visualise une couche de carte quadrillée sous forme de tracé de surface 3D (carte de hauteur). Un calque séparé peut être choisi comme calque pour les informations de couleur.
Ce package fournit un algorithme efficace pour convertir une carte d'élévation en un champ de distance signé 3D dense. Chaque point de la grille 3D contient la distance jusqu'au point le plus proche de la carte ainsi que le dégradé.
Ce nœud s'abonne à un sujet de type grid_map_msgs/GridMap et publie des messages pouvant être visualisés dans RViz. Les sujets publiés du visualiseur peuvent être entièrement configurés avec un fichier de paramètres YAML. N'importe quel nombre de visualisations avec différents paramètres peuvent être ajoutés. Un exemple est ici pour le fichier de configuration du tutoriel_demo .
| Nuage de points | Vecteurs | Grille d'occupation | Cellules de la grille |
|---|---|---|---|
 |  |  |  |
grid_map_topic (chaîne, par défaut : "/grid_map")
Nom du sujet de carte de grille à visualiser. Voir ci-dessous pour la description des visualiseurs.
/grid_map (grid_map_msgs/GridMap)
La carte quadrillée à visualiser.
Les sujets publiés sont configurés avec le fichier de paramètres YAML. Les sujets possibles sont :
point_cloud (sensor_msgs/PointCloud2)
Affiche la carte quadrillée sous forme de nuage de points. Sélectionnez le calque à transformer en points avec le paramètre layer .
name: elevation
type: point_cloud
params:
layer: elevation
flat: false # optional
flat_point_cloud (sensor_msgs/PointCloud2)
Affiche la carte quadrillée sous la forme d'un nuage de points "plat", c'est-à-dire avec tous les points à la même hauteur z . Ceci est pratique pour visualiser des cartes ou des images 2D (ou même des flux vidéo) dans RViz à l'aide de son Color Transformer . Le paramètre height détermine la position z souhaitée du nuage de points plat.
name: flat_grid
type: flat_point_cloud
params:
height: 0.0
Remarque : Afin d'omettre des points dans le nuage de points plats des cellules vides/invalides, spécifiez les couches dont la validité doit être vérifiée avec setBasicLayers(...) .
vectors (visualization_msgs/Marker)
Visualise les données vectorielles de la carte quadrillée sous forme de marqueurs visuels. Spécifiez les couches qui contiennent les composants x -, y - et z des vecteurs avec le paramètre layer_prefix . Le paramètre position_layer définit la couche à utiliser comme point de départ des vecteurs.
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/OccupancyGrid)
Visualise une couche de la carte quadrillée sous forme de grille d'occupation. Spécifiez la couche à visualiser avec le paramètre layer , ainsi que les limites supérieure et inférieure avec data_min et data_max .
name: traversability_grid
type: occupancy_grid
params:
layer: traversability
data_min: -0.15
data_max: 0.15
grid_cells (nav_msgs/GridCells)
Visualise une couche de la carte quadrillée sous forme de cellules de grille. Spécifiez la couche à visualiser avec le paramètre layer , ainsi que les limites supérieure et inférieure avec lower_threshold et 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 (visualization_msgs/Marker)
Affiche la limite de la carte quadrillée.
name: map_region
type: map_region
params:
color: 3289650
line_width: 0.003
Remarque : les valeurs de couleur sont au format RVB sous forme d'entiers concaténés (pour chaque valeur de canal 0-255). Les valeurs peuvent être générées comme ceci à titre d'exemple pour la couleur verte (rouge : 0, vert : 255, bleu : 0).
Le package grid_map_filters contient plusieurs filtres qui peuvent être appliqués à une carte quadrillée pour effectuer des calculs sur les données dans les couches. Les filtres de grille sont basés sur les filtres ROS, ce qui signifie qu'une chaîne de filtres peut être configurée sous forme de fichier YAML. De plus, des filtres supplémentaires peuvent être écrits et mis à disposition via le mécanisme du plugin ROS, comme InpaintFilter du package grid_map_cv .
Plusieurs filtres de base sont fournis dans le package grid_map_filters :
gridMapFilters/ThresholdFilter
Définissez les valeurs dans la couche de sortie sur une valeur spécifiée si condition_layer dépasse le seuil supérieur ou inférieur (un seul seuil à la fois).
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
Calculez pour chaque cellule d'une couche la valeur moyenne à l'intérieur d'un rayon.
name: mean_in_radius
type: gridMapFilters/MeanInRadiusFilter
params:
input_layer: input
output_layer: output
radius: 0.06 # in m.
gridMapFilters/MedianFillFilter
Calculez pour chaque cellule NaN d'une couche la médiane (des finis) à l'intérieur d'un patch avec rayon. Facultativement, appliquez des calculs médians pour des valeurs déjà finies, le rayon du patch pour ces points est donné par existante_valeur_radius. Notez que le calcul de remplissage n'est effectué que si le fill_mask est valide pour ce point.
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
Calculez les vecteurs normaux d’une couche dans une carte.
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
Calculez un nouveau calque de couleur basé sur des calques vectoriels normaux.
name: surface_normals
type: gridMapFilters/NormalColorMapFilter
params:
input_layers_prefix: normal_vectors_
output_layer: normal_color
gridMapFilters/MathExpressionFilter
Analyser et évaluer une expression matricielle mathématique avec les couches d'une carte quadrillée. Voir EigenLab pour la documentation des expressions.
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
Analysez et évaluez une expression matricielle mathématique dans une fenêtre glissante sur une couche d’une carte quadrillée. Voir EigenLab pour la documentation des expressions.
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
Dupliquez une couche d'une carte quadrillée.
name: duplicate
type: gridMapFilters/DuplicationFilter
params:
input_layer: input
output_layer: output
gridMapFilters/DeletionFilter
Supprimez des couches d’une carte quadrillée.
name: delete
type: gridMapFilters/DeletionFilter
params:
layers: [color, score] # List of layers.
De plus, le package grid_map_cv fournit les filtres suivants :
gridMapCv/InpaintFilter
Utilisez OpenCV pour peindre/remplir des trous dans un calque.
name: inpaint
type: gridMapCv/InpaintFilter
params:
input_layer: input
output_layer: output
radius: 0.05 # in m
| Cinétique | Mélodique | Noétique | |
|---|---|---|---|
| grille_map | |||
| doc |
| Cinétique | Mélodique | Noétique | |
|---|---|---|---|
| grille_map | |||
| grille_map_core | |||
| grille_map_costmap_2d | |||
| grille_map_cv | |||
| grille_map_demos | |||
| grille_map_filters | |||
| grille_map_loader | |||
| grille_map_msgs | |||
| grille_map_octomap | |||
| grille_map_pcl | |||
| grille_map_ros | |||
| grille_map_rviz_plugin | |||
| grille_map_sdf | |||
| grille_map_visualisation |
Veuillez signaler les bogues et demander des fonctionnalités à l’aide du Issue Tracker.
