TFM Análisis y clasificación de terrenos no estructurados para la locomoción de robots cuadrúpedos

Por Manuel Fernández Alonso

Repositorio

El presente repositorio cuenta con todos los archivos utilizados para la elaboración del TFM. Algunas de las carpetas son repositorios oficiales que contienen archivos añadidos, por lo que se recomienda primero descargar el repositorio oficial, añadiendo los archivos modificados en este TFM. Las carpetas son:

• elevation_mapping: repositorio que contiene el mapa de elevaciones y archivos modificados utilizados para este TFM. En concreto, se utiliza el paquete de ROS elevation_mapping_demos. Los archivos modificados están en las carpetas launch, launch robot real y scripts.
• Google Colab: contiene el Jupyter Notebook utilizado para llevar a cabo la segmentación de imágenes, extracción de propiedades físicas del entorno y el cálculo del índice de traversabilidad.
• grid_map: repositorio necesario para poder ejecutar el repositorio de elevation_mapping, es una de las dependencias.
• legged_robot: repositorio para la simulación de las físicas del robot Unitree A1, así como para su control en tiempo real. Ofrece un entorno de RViz con todos los elementos visuales para una correcta visualización.
• Pruebas_experimentales: carpeta de ejemplo con todos los archivos generados en una prueba experimental completa, sirve como modelo para respetar la estructura y nomenclatura de carpetas necesaria para aplicar correctamente la metodología completa. Incluye las imágenes RGB y de profundidad originales, las imágenes segemntadas con las visualizaciones adicionales, la carpeta con las imágenes de etiquetas para publicarse en ROS y una carpeta con capturas adicionales del mapa de elevaciones y la nube de puntos semántica.
• realsense-ros: repositorio necesario para poder integrar la RealSense en un entorno de ROS.

Los archivos pasos_legged, pasos_elevation_map y Masked Replace calls contienen información útil del simulador del robot, del mapa de elevaciones y del servicio de actualización de capas del mapa de elevaciones, respectivamente.

Puesta en marcha

La ejecución completa de la metodología propuesta en este TFM se divide en tres fases diferentes, tal y como se explica en el Capítulo 7 de la memoria. Estas fases son:

1. Fase de grabación: es la etapa de ejecución real y recolección de datos experimentales. El robot, real o simulado, se controla y se mueve por el entorno, mientras la RealSense guarda las imágenes RGB y de profundidad necesarias para la segmentación posterior, asociándolas con la marca de tiempo correspondiente al momento de la captura. Al mismo tiempo, se graba un archivo de tipo rosbag que contiene todas las comunicaciones realizadas durante la prueba. Este archivo permite reproducir todos los mensajes emitidos por los nodos.
2. Fase de procesamiento en línea: las imágenes RGB-D guardadas se segmentan en Google Colab todas juntas de forma automática. Después, se procede a la extracción de propiedades y al cálculo de la traversabilidad. El tiempo dedicado a llevar a cabo esta fase intermedia no se tiene en cuenta, puesto que se realiza de forma independiente de las otras fases.
3. Fase de reproducción:: se reproduce el archivo \texttt{rosbag} grabado en la primera etapa, que simula la ejecución real y se genera el mapa de elevaciones a partir de la nube de puntos. Además, se aprovechan las imágenes segmentadas de la fase anterior para publicarlas al mismo tiempo que se capturan las imágenes originales. De esta forma, el tiempo de segmentación es prácticamente nulo, evitando así posibles problemas de comunicación debido al retraso que genera el procesamiento de las imágenes.

A continuación, se explica cómo proceder para poder ejecutar cada una de las fases correctamente. Se debe tener acceso a una cuenta de Google Colab y un ecosistema de ROS Noetic en Ubuntu 20.04 para lanzar los diversos archivos. Más información sobre los diferentes archivos se encuentra en el Capítulo 7 de la memoria.

Nota: se explica a continuación la forma de proceder con el robot simulado. Con el robot real es el mismo procedimiento pero utilizando los archivos equivalentes de la carpeta launch robot real y asegurando una conexión correcta con el robot.

Fase de grabación

Para ejecutar los archivos en esta fase se recomienda utilizar Terminator para tener varias terminales abiertas, todas empezando en la dirección del workspace de ROS.

cd catkin_ws

El primer paso es, en una terminal, cargar el archivo main.launch que lanza el entorno de ROS y carga las físicas del robot en un mundo vacío de Gazebo.

roslaunch elevation_mapping_demos main.launch

En otra terminal, siguiendo los comandos del archivo pasos_legged, se procede a cargar el controlador de los motores del robot. Importante, no seleccionar ningún patrón de marcha hasta que el controlador esté activado en el siguiente paso.

roslaunch legged_controllers load_controller.launch cheater:=false

En una tercera terminal, se carga el GUI para activar los controladores.

rosrun rqt_controller_manager rqt_controller_manager

Haciendo click derecho se pueden activar los dos controladores controllers/joint_state_controller y controllers/legged_controller.

Una vez activados, se escribe en la segunda terminal el patrón de marcha, trot por ejemplo, y se utiliza 2D Nav Goal (la flecha rosa) en el entorno de RViz para levantar al robot y enviarlo a una posición determinada.

Una vez el entorno de ROS se ha lanzado y el modelo del robot está cargado correctamente, se procede a lanzar el nodo que activa y conecta la RealSense. Este comando está integrado en el archivo main.launch comentado, por lo que se puede lanzar desde un inicio o en el momento que se conecta la cámara.

roslaunch elevation_mapping_demos realsense_d435i_legged.launch

Finalmente, cuando esté todo listo para llevar a cabo la prueba experimental, se lanza el archivo para comenzar a grabar el rosbag y guardar las imágenes RGB-D.

roslaunch elevation_mapping_demos record_bag.launch

Nota importante: es imprescindible modificar las rutas de guardado de los archivos modificando el código, así como los tópicos que se desean guardar y otros parámetros.

Opcionalmente, el archivo elevation_map.launch permite lanzar el mapa de elevaciones para comprobar cómo quedaría, pero la idea es que se construya en tiempo real en la fase de reproducción de rosbag.

roslaunch elevation_mapping_demos elevation_map.launch

Fase de procesamiento en línea

El archivo Jupyter Notebook Pruebas_automaticas_Automatic_mask_generator.ipynb contiene todo el procesamiento necesario para llevar a cabo la segmentación de imágenes, extracción de propiedades del entorno a partir de la imagen de profundidad y cálculo de la traversabilidad. La forma correcta de proceder es la siguiente:

1. Cargar las imágenes originales (RGB-D) en Google Drive en una carpeta llamada "Originales", con subcarpetas "RGB" y "Depth". Nota: actualizar los parámetros intrínsecos de la cámara si cambia la resolución de las imágenes RGB y/o de profundidad, ya que resoluciones diferentes implican parámetros diferentes.
2. Ejecutar todas las celdas del Jupyter Notebook para cargar las librerías, funciones, etc. Nota: este proceso debe repetirse con cada nueva sesión de Google Colab.
3. Llevar a cabo la metodología en una primera imagen para la cual se quiera obtener la ecuación del plano base del suelo. Guardar la ecuación en un archivo como plano_base.json. Es imprescindible disponer de una ecuación del plano base que se vaya a utilizar para el resto de imágenes. Se recomienda obtenerlo a partir de una imagen en la que se vean zonas de suelo visible.
4. Una vez se tienen todas las imágenes en las carpetas y la ecuación del plano base del suelo, se lanza la celda Testeo automatizado desde .PNGs - Batch - JSON que lleva a cabo, de forma automática, todo el procedimiento. Se pueden comentar/descomentar líneas en función de las métricas y figuras que se necesiten. Esta celda genera los archivos .json e imágenes de etiquetas imprescindibles para la fase de reproducción. Nota: con el plan gratuito de Google Colab es posible que la ejecución se detenga si son demasiadas imágenes o si se alcanza el límite de almacenamiento en Google Drive, se debe prestar atención a esto.
5. Finalizado todo el proceso, se deben descargar los archivos generados para poder llevar a cabo la última fase de la metodología de forma local. Esto es fundamentalmente la carpeta Labels generada.

Fase de reproducción

En la fase final de la metodología se reproduce el archivo rosbag para simular la ejecución real original, exceptuando la publicación de las imágenes de etiquetas con la segmentación, así como las propiedades asociadas a cada máscara. El procedimiento comienza con la ejecución, en una terminal, el archivo main_replay.launch.

roslaunch elevation_mapping_demos main_replay.launch

Nota importante: es imprescindible modificar las direcciones a los archivos y carpetas, así como seleccionar la velocidad de reproducción del rosbag y qué tópicos deben reproducirse.

Antes de lanzar la reproducción del rosbag, se debe lanzar en otra terminal el nodo para generar el mapa de elevaciones desde el inicio.

roslaunch elevation_mapping_demos elevation_map.launch

Una vez está todo cargado, utilizando la barra espaciadora en la primera terminal, se reproduce el rosbag que simula la prueba original. En este caso, se genera el mapa de elevaciones, y el servicio masked_replace se encarga de modificar las capas del mapa según la segmentación llevada a cabo. Además, se publica la imagen de etiquetas y la nube de puntos segmentada.

Nota importante: se ofrece la posibilidad de actualizar la capa semántica con los colores de la segmentación (capa sem_id) o la capa con la traversabilidad (capa traversability). Este parámetro se debe cambiar en los archivos main_replay.launch (1 vez), elevation_map.launch (2 veces). Por defecto, se actualiza la capa de traversabilidad.

Dado que se trata de un proceso de alto costo computacional, se recomienda capturar las imágenes a una tasa baja y utilizar equipos con buenas GPUs. Se pueden observar retrasos en la actualización de las capas del mapa respecto a la imagen publicada, puesto que, con cada llamada a masked_replace, se actualiza el mapa al completo teniendo en cuenta la posición actual del robot. Se deja la puerta abierta a investigar formas de optimizar estos intercambios de información utilizando ROS.

MSc Thesis - Analysis and classification of unstructured terrains for quadruped robot locomotion

By Manuel Fernández Alonso

Repository

This repository contains all the files used to develop the thesis. Some folders mirror official repositories with additional files; therefore, it is recommended to first clone the official repository and then add the files modified in this work. The folders are:

• elevation_mapping: repository with the elevation map and the modified files used in this thesis. Specifically, the ROS package elevation_mapping_demos is used. Modified files are under launch, launch robot real, and scripts.
• Google Colab: contains the Jupyter Notebook used for image segmentation, extraction of physical properties from the environment, and computation of the traversability index.
• grid_map: repository required to run elevation_mapping (one of its dependencies).
• legged_robot: repository for simulating the Unitree A1 robot’s physics and for real-time control. It provides an RViz setup with the necessary visual elements for proper visualization.
• Pruebas_experimentales: example folder with all files generated in a complete experimental run. It serves as a template to follow the folder structure and naming needed to apply the full methodology. It includes the original RGB and depth images, the segmented images with extra visualizations, the folder with label images to be published in ROS, and a folder with additional snapshots of the elevation map and the semantic point cloud.
• realsense-ros: repository required to integrate the RealSense camera in a ROS environment.

The files pasos_legged, pasos_elevation_map, and Masked Replace calls contain useful information about the robot simulator, the elevation map, and the service for updating elevation-map layers, respectively.

Getting started

The full execution of the methodology proposed in this thesis is divided into three phases, as described in Chapter 7 of the report. These phases are:

1. Recording phase: this is the real execution and data collection stage. The robot—real or simulated—is controlled and moves around the environment while the RealSense saves the RGB and depth images required for later segmentation, associating them with the capture timestamp. At the same time, a rosbag file is recorded with all communications during the test. This file allows replaying all messages emitted by the nodes.
2. Online processing phase: the saved RGB-D images are segmented in Google Colab in batch mode. Then, property extraction and traversability computation are performed. The time devoted to this intermediate phase is not considered, since it is carried out independently from the other phases.
3. Replay phase: the rosbag recorded in the first stage is replayed to simulate real execution and generate the elevation map from the point cloud. In addition, the segmented images from the previous phase are published at the same time as the original images are “captured”. In this way, segmentation time is practically zero, avoiding possible communication issues due to image processing delays.

Below is how to execute each phase correctly. You will need access to a Google Colab account and a ROS Noetic ecosystem on Ubuntu 20.04 to launch the various files. More information about the different files is provided in Chapter 7 of the report.

Note: the procedure below uses the simulated robot. For the real robot, follow the same steps but use the equivalent files in the launch robot real folder and ensure a proper connection to the robot.

Recording phase

To run the files in this phase, it is recommended to use Terminator so you can have multiple terminals open, all starting in the ROS workspace path.

cd catkin_ws

The first step is, in one terminal, to load the main.launch file, which launches the ROS environment and loads the robot physics in an empty Gazebo world.

roslaunch elevation_mapping_demos main.launch

In another terminal, following the commands in the pasos_legged file, the robot motor controller is loaded. Important: do not select any gait pattern until the controller is activated in the next step.

roslaunch legged_controllers load_controller.launch cheater:=false

In a third terminal, load the GUI to activate the controllers.

rosrun rqt_controller_manager rqt_controller_manager

By right-clicking, you can activate the two controllers controllers/joint_state_controller and controllers/legged_controller.

Once they are activated, type the gait pattern in the second terminal, trot for example, and use 2D Nav Goal (the pink arrow) in the RViz environment to raise the robot and send it to a specific position.

Once the ROS environment has been launched and the robot model is loaded correctly, launch the node that enables and connects the RealSense. This command is integrated (commented) in the main.launch file, so it can be launched from the start or at the moment the camera is connected.

roslaunch elevation_mapping_demos realsense_d435i_legged.launch

Finally, when everything is ready to carry out the experimental test, launch the file to start recording the rosbag and save the RGB-D images.

roslaunch elevation_mapping_demos record_bag.launch

Important note: it is essential to modify the save paths by editing the code, as well as the topics to be saved and other parameters.

Optionally, the elevation_map.launch file allows launching the elevation map to check how it would look, but the idea is that it is built in real time during the rosbag replay phase.

roslaunch elevation_mapping_demos elevation_map.launch

Online processing phase

The Jupyter Notebook file Pruebas_automaticas_Automatic_mask_generator.ipynb contains all the processing needed to perform image segmentation, extract environment properties from the depth image, and compute traversability. The correct procedure is as follows:

1. Upload the original images (RGB-D) to Google Drive in a folder called "Originales", with subfolders "RGB" and "Depth". Note: update the camera intrinsic parameters if the resolution of the RGB and/or depth images changes, since different resolutions imply different parameters.
2. Run all the cells in the Jupyter Notebook to load libraries, functions, etc. Note: this process must be repeated with each new Google Colab session.
3. Apply the methodology on a first image from which you want to obtain the base ground plane equation. Save the equation in a file such as plano_base.json. It is essential to have a base plane equation that will be used for the rest of the images. It is recommended to obtain it from an image where visible ground areas can be seen.
4. Once you have all the images in the folders and the base ground plane equation, run the cell Testeo automatizado desde .PNGs - Batch - JSON, which automatically performs the entire procedure. You can comment/uncomment lines depending on the metrics and figures you need. This cell generates the .json files and label images required for the replay phase. Note: with the free Google Colab plan, execution may stop if there are too many images or if the Google Drive storage limit is reached—pay attention to this.

Once the process is finished, download the generated files to be able to carry out the last phase of the methodology locally. This is mainly the generated Labels folder.

Replay phase

In the final phase of the methodology, the rosbag file is replayed to simulate the original real execution, except for publishing the label images with the segmentation, as well as the properties associated with each mask. The procedure starts by running, in one terminal, the main_replay.launch file.

roslaunch elevation_mapping_demos main_replay.launch

Important note: it is essential to modify the paths to the files and folders, as well as select the rosbag replay speed and which topics should be replayed.

Before starting the rosbag replay, in another terminal launch the node to generate the elevation map from the beginning.

roslaunch elevation_mapping_demos elevation_map.launch

Once everything is loaded, using the space bar in the first terminal, replay the rosbag that simulates the original test. In this case, the elevation map is generated, and the masked_replace service is responsible for modifying the map layers according to the performed segmentation. In addition, the label image and the segmented point cloud are published.

Important note: there is an option to update the semantic layer with the segmentation colors (layer sem_id) or the traversability layer (layer traversability). This parameter must be changed in the files main_replay.launch (once) and elevation_map.launch (twice). By default, the traversability layer is updated.

Since this is a high computational-cost process, it is recommended to capture images at a low rate and use machines with good GPUs. Delays may be observed in the update of the map layers with respect to the published image, since with each masked_replace call, the entire map is updated taking into account the current robot pose. The door is left open to investigate ways to optimize these information exchanges using ROS.