Esta é uma biblioteca C++ com interface ROS para gerenciar mapas de grade bidimensionais com múltiplas camadas de dados. Ele é projetado para mapeamento robótico móvel para armazenar dados como elevação, variação, cor, coeficiente de atrito, qualidade de apoio, superfície normal, capacidade de travessia, etc. Ele é usado no pacote Robot-Centric Elevation Mapping projetado para navegação em terrenos acidentados.
Características:
Este é um código de pesquisa, espere que ele mude com frequência e qualquer adequação a um propósito específico seja negada.
O código-fonte é lançado sob uma licença BSD de 3 cláusulas.
Autor: Péter Fankhauser
Afiliação: ANYbotics
Mantenedor: Maximilian Wulf, [email protected], Magnus Gärtner, [email protected]
Com contribuições 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 projeto foi inicialmente desenvolvido na ETH Zurich (Autonomous Systems Lab & Robotic Systems Lab).
Este trabalho é conduzido como parte da ANYmal Research, uma comunidade para o avanço da robótica com pernas.
Se você usar este trabalho em um contexto acadêmico, cite a seguinte publicação:
P. Fankhauser e M. Hutter, "A Universal Grid Map Library: Implementation and Use Case for Rough Terrain Navigation" , em 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}
}
Essas filiais são mantidas atualmente:
As solicitações pull para ROS 1 devem ter como alvo master
. As solicitações pull para ROS 2 devem ter como objetivo rolling
e serão portadas se não quebrarem a ABI.
Uma introdução à biblioteca de mapas de grade, incluindo um tutorial, é fornecida neste capítulo do livro.
A API C++ está documentada aqui:
Para instalar todos os pacotes da biblioteca de mapas de grade conforme os pacotes Debian usam
sudo apt-get install ros-$ROS_DISTRO-grid-map
O pacote grid_map_core depende apenas da biblioteca de álgebra linear Eigen.
sudo apt-get install libeigen3-dev
Os demais pacotes dependem adicionalmente da instalação padrão do ROS ( roscpp , tf , filtros , sensor_msgs , nav_msgs e cv_bridge ). Outros pacotes de conversão específicos de formato (por exemplo, grid_map_cv , grid_map_pcl etc.) dependem dos pacotes descritos abaixo em Visão Geral dos Pacotes .
Para compilar a partir do código-fonte, clone a versão mais recente deste repositório em seu espaço de trabalho catkin e compile o pacote usando
cd catkin_ws/src
git clone https://github.com/anybotics/grid_map.git
cd ../
catkin_make
Para maximizar o desempenho, certifique-se de construir no modo Release . Você pode especificar o tipo de compilação definindo
catkin_make -DCMAKE_BUILD_TYPE=Release
Este repositório consiste nos seguintes pacotes:
GridMap
e várias classes auxiliares, como os iteradores. Este pacote é implementado sem dependências de ROS.Pacotes de conversão adicionais:
Execute os testes de unidade com
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
se você estiver usando ferramentas catkin.
O pacote grid_map_demos contém vários nós de demonstração. Use este código para verificar a instalação dos pacotes de mapa de grade e para começar a usar a biblioteca por conta própria.
simple_demo demonstra um exemplo simples de uso da biblioteca de mapas de grade. Este nó ROS cria um mapa de grade, adiciona dados a ele e os publica. Para ver o resultado no RViz, execute o comando
roslaunch grid_map_demos simple_demo.launch
tutorial_demo é uma demonstração estendida das funcionalidades da biblioteca. Inicie o tutorial_demo com
roslaunch grid_map_demos tutorial_demo.launch
iterators_demo mostra o uso dos iteradores do mapa de grade. Inicie com
roslaunch grid_map_demos iterators_demo.launch
image_to_gridmap_demo demonstra como converter dados de uma imagem em um mapa de grade. Comece a demonstração com
roslaunch grid_map_demos image_to_gridmap_demo.launch
grid_map_to_image_demo demonstra como salvar uma camada de mapa de grade em uma imagem. Comece a demonstração com
rosrun grid_map_demos grid_map_to_image_demo _grid_map_topic:=/grid_map _file:=/home/$USER/Desktop/grid_map_image.png
opencv_demo demonstra manipulações de mapas com ajuda de funções OpenCV. Comece a demonstração com
roslaunch grid_map_demos opencv_demo.launch
resolução_change_demo mostra como a resolução de um mapa de grade pode ser alterada com a ajuda dos métodos de dimensionamento de imagem OpenCV. Para ver os resultados, use
roslaunch grid_map_demos resolution_change_demo.launch
filter_demo usa uma cadeia de filtros ROS para processar um mapa de grade. Começando pela elevação de um mapa de terreno, a demonstração usa vários filtros para mostrar como calcular normais de superfície, usar pintura para preencher buracos, suavizar/desfocar o mapa e usar expressões matemáticas para detectar bordas, calcular rugosidade e capacidade de travessia. A configuração da cadeia de filtros é configurada no arquivo filters_demo_filter_chain.yaml
. Inicie a demonstração com
roslaunch grid_map_demos filters_demo.launch
Para obter mais informações sobre filtros de mapa de grade, consulte grid_map_filters.
interpolation_demo mostra o resultado de diferentes métodos de interpolação na superfície resultante. Para iniciar a demonstração, use
roslaunch grid_map_demos interpolation_demo.launch
O usuário pode brincar com diferentes mundos (superfícies) e diferentes configurações de interpolação no arquivo interpolation_demo.yaml
. A visualização exibe a verdade básica nas cores verde e amarela. O resultado da interpolação é mostrado nas cores vermelha e roxa. Além disso, a demonstração calcula erros de interpolação máximos e médios, bem como o tempo médio necessário para uma única consulta de interpolação.
O mapa de grade apresenta quatro métodos de interpolação diferentes (em ordem crescente de precisão e complexidade):
Para obter mais detalhes, verifique a literatura listada no arquivo CubicInterpolation.hpp
.
A biblioteca de mapas de grade contém vários iteradores por conveniência.
Mapa de grade | Submapa | Círculo | Linha | Polígono |
---|---|---|---|---|
Elipse | Espiral | |||
Usar o iterador em um loop for
é comum. Por exemplo, itere sobre todo o mapa de grade com GridMapIterator
com
for (grid_map::GridMapIterator iterator(map); !iterator.isPastEnd(); ++iterator) {
cout << "The value at index " << (*iterator).transpose() << " is " << map.at("layer", *iterator) << endl;
}
Os outros iteradores do mapa de grade seguem o mesmo formato. Você pode encontrar mais exemplos sobre como usar os diferentes iteradores no nó iterators_demo .
Nota: Para máxima eficiência ao usar iteradores, é recomendado armazenar localmente o acesso direto às camadas de dados do mapa de grade com grid_map::Matrix& data = map["layer"]
fora do loop 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;
}
Você pode encontrar um benchmarking do desempenho dos iteradores no nó iterator_benchmark
do pacote grid_map_demos
que pode ser executado com
rosrun grid_map_demos iterator_benchmark
Esteja ciente de que, embora os iteradores sejam convenientes, geralmente é mais limpo e eficiente usar os métodos Eigen integrados. Aqui estão alguns exemplos:
Definindo um valor constante para todas as células de uma camada:
map["layer"].setConstant(3.0);
Adicionando duas camadas:
map["sum"] = map["layer_1"] + map["layer_2"];
Dimensionando uma camada:
map["layer"] = 2.0 * map["layer"];
Máx. valores entre duas camadas:
map["max"] = map["layer_1"].cwiseMax(map["layer_2"]);
Calcule a raiz do erro quadrático médio:
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);
Existem dois métodos diferentes para alterar a posição do mapa:
setPosition(...)
: Altera a posição do mapa sem alterar os dados armazenados no mapa. Isto altera a correspondência entre os dados e o quadro do mapa.
move(...)
: realoca a região capturada pelo mapa de grade wrt para o quadro do mapa de grade estático. Utilize isto para mover os limites do mapa de grade sem realocar os dados do mapa de grade. Cuida de todo o tratamento de dados, de forma que os dados do mapa de grade fiquem estacionários no quadro do mapa de grade.
Nota : Devido à estrutura circular do buffer, os índices vizinhos podem não ficar próximos no quadro do mapa. Esta suposição vale apenas para índices obtidos por getUnwrappedIndex().
setPosition(...) | move(...) |
---|---|
Este plugin RViz visualiza uma camada de mapa de grade como um gráfico de superfície 3D (mapa de altura). Uma camada separada pode ser escolhida como camada para as informações de cores.
Este pacote fornece um algoritmo eficiente para converter um mapa de elevação em um denso campo de distância sinalizado em 3D. Cada ponto na grade 3D contém a distância até o ponto mais próximo no mapa junto com o gradiente.
Este nó assina um tópico do tipo grid_map_msgs/GridMap e publica mensagens que podem ser visualizadas no RViz. Os tópicos publicados do visualizador podem ser totalmente configurados com um arquivo de parâmetros YAML. Qualquer número de visualizações com parâmetros diferentes pode ser adicionado. Um exemplo está aqui para o arquivo de configuração do tutorial_demo .
Nuvem de pontos | Vetores | Grade de ocupação | Células de grade |
---|---|---|---|
grid_map_topic
(string, padrão: "/grid_map")
O nome do tópico do mapa de grade a ser visualizado. Veja abaixo a descrição dos visualizadores.
/grid_map
(grid_map_msgs/GridMap)
O mapa de grade a ser visualizado.
Os tópicos publicados são configurados com o arquivo de parâmetros YAML. Os possíveis tópicos são:
point_cloud
(sensor_msgs/PointCloud2)
Mostra o mapa de grade como uma nuvem de pontos. Selecione qual camada transformar como pontos com o parâmetro layer
.
name: elevation
type: point_cloud
params:
layer: elevation
flat: false # optional
flat_point_cloud
(sensor_msgs/PointCloud2)
Mostra o mapa de grade como uma nuvem de pontos "plana", ou seja, com todos os pontos na mesma altura z . Isso é conveniente para visualizar mapas ou imagens 2D (ou mesmo fluxos de vídeo) no RViz com a ajuda de seu Color Transformer
. O parâmetro height
determina a posição z desejada da nuvem de pontos plana.
name: flat_grid
type: flat_point_cloud
params:
height: 0.0
Nota: Para omitir pontos na nuvem de pontos plana de células vazias/inválidas, especifique as camadas cuja validade deve ser verificada com setBasicLayers(...)
.
vectors
(visualização_msgs/Marcador)
Visualiza dados vetoriais do mapa de grade como marcadores visuais. Especifique as camadas que contêm os componentes x -, y - e z dos vetores com o parâmetro layer_prefix
. O parâmetro position_layer
define a camada a ser utilizada como ponto inicial dos vetores.
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)
Visualiza uma camada do mapa de grade como grade de ocupação. Especifique a camada a ser visualizada com o parâmetro layer
e os limites superior e inferior com data_min
e 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 uma camada do mapa de grade como células de grade. Especifique a camada a ser visualizada com o parâmetro layer
e os limites superior e inferior com lower_threshold
e 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
(visualização_msgs/Marcador)
Mostra o limite do mapa de grade.
name: map_region
type: map_region
params:
color: 3289650
line_width: 0.003
Nota: Os valores de cores estão no formato RGB como números inteiros concatenados (para cada valor de canal de 0 a 255). Os valores podem ser gerados assim como exemplo para a cor verde (vermelho: 0, verde: 255, azul: 0).
O pacote grid_map_filters contém vários filtros que podem ser aplicados em um mapa de grade para realizar cálculos nos dados nas camadas. Os filtros do mapa de grade são baseados em filtros ROS, o que significa que uma cadeia de filtros pode ser configurada como um arquivo YAML. Além disso, filtros adicionais podem ser escritos e disponibilizados através do mecanismo de plugin ROS, como o InpaintFilter
do pacote grid_map_cv
.
Vários filtros básicos são fornecidos no pacote grid_map_filters :
gridMapFilters/ThresholdFilter
Defina valores na camada de saída para um valor especificado se a camada_de_condição estiver excedendo o limite superior ou inferior (apenas um limite por 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 célula de uma camada o valor médio dentro de um raio.
name: mean_in_radius
type: gridMapFilters/MeanInRadiusFilter
params:
input_layer: input
output_layer: output
radius: 0.06 # in m.
gridMapFilters/MedianFillFilter
Calcule para cada célula NaN de uma camada a mediana (dos finitos) dentro de um patch com raio. Opcionalmente, aplique cálculos de mediana para valores que já são finitos, o raio do patch para esses pontos é dado por existente_value_radius. Observe que o cálculo de preenchimento só é realizado se fill_mask for válido para aquele ponto.
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 os vetores normais de uma camada em um 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 uma nova camada de cores com base nas camadas de vetores normais.
name: surface_normals
type: gridMapFilters/NormalColorMapFilter
params:
input_layers_prefix: normal_vectors_
output_layer: normal_color
gridMapFilters/MathExpressionFilter
Analise e avalie uma expressão de matriz matemática com camadas de um mapa de grade. Consulte EigenLab para obter a documentação das expressões.
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
Analise e avalie uma expressão de matriz matemática em uma janela deslizante em uma camada de um mapa de grade. Consulte EigenLab para obter a documentação das expressões.
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
Duplique uma camada de um mapa de grade.
name: duplicate
type: gridMapFilters/DuplicationFilter
params:
input_layer: input
output_layer: output
gridMapFilters/DeletionFilter
Exclua camadas de um mapa de grade.
name: delete
type: gridMapFilters/DeletionFilter
params:
layers: [color, score] # List of layers.
Além disso, o pacote grid_map_cv fornece os seguintes filtros:
gridMapCv/InpaintFilter
Use OpenCV para pintar/preencher buracos em uma camada.
name: inpaint
type: gridMapCv/InpaintFilter
params:
input_layer: input
output_layer: output
radius: 0.05 # in m
Cinético | Melódico | Noético | |
---|---|---|---|
grid_map | |||
documento |
Cinético | Melódico | Noético | |
---|---|---|---|
grid_map | |||
grid_map_core | |||
grid_map_costmap_2d | |||
grid_map_cv | |||
grid_map_demos | |||
grid_map_filters | |||
grid_map_loader | |||
grid_map_msgs | |||
grid_map_octomap | |||
grid_map_pcl | |||
grid_map_ros | |||
grid_map_rviz_plugin | |||
grid_map_sdf | |||
grid_map_visualization |
Por favor, reporte bugs e solicite recursos usando o Issue Tracker.