domingo, 30 de noviembre de 2014

Tutorial -- Building of LSD-SLAM on ROS with Catkin Workspace (ROS Indigo + Ubuntu 14.04 [64-bit]) (English)

In this tutorial, we'll see how to compile the LSD-SLAM project on Ubuntu 14.04 using the ROS (Robot Operating System) framework in its "Indigo Igloo" version and specifically using "Catkin", which is currently the official building system of ROS and has become the successor of the original ROS building system known as "Rosbuild".   

In the following, the steps to carry out the installation and compilation of the LSD-SLAM project are described:   

1- Once ROS has been installed and configured and we have created a Catkin Workspace, we open a terminal on Ubuntu and we navigate to the folder that we are using as the Catkin Workspace by running the following command:  

cd <path_to_catkin_ws>/src 

In the preceding command, where <path_to_catkin_ws> appears one must put the location in which the Catkin Workspace is found within the Ubuntu file-system.     

2- Within the Workspace we clone the principal "branch" of the LSD-SLAM project with the command: git clone https://github.com/tum-vision/lsd_slam.git



3- In the following, we change to the Catkin "branch" of the LSD-SLAM project with these commands:

cd lsd_slam/   
git checkout catkin

4- With the preceding commands, we should already have available in the Workspace the code of the LSD-SLAM "branch" of Catkin, but even so we next perform a simple manual verification to prove that the structure of the project files that we have in our Workspace is in correspondence with the Catkin "branch" of the LSD-SLAM project.


We run the command: ls   

The response that we should receive should be the following:

LICENSE lsd_slam lsd_slam_core lsd_slam_viewer README.md

5- At this point, it would only remain for us to install the dependencies that the project needs in order to be compiled.
We must install the following libraries:

ros-indigo-libg2o ros-indigo-cv-bridge liblapack-dev libblas-dev freeglut3-dev libqglviewer-dev libsuitesparse-dev libx11-dev

The installation of these libraries carried out with the following single command:

sudo apt-get install ros-indigo-libg2o ros-indigo-cv-bridge liblapack-dev libblas-dev freeglut3-dev libqglviewer-dev libsuitesparse-dev libx11-dev  

6) At this point, we try to perform the compilation. For that, we first of all change to the Catkin Workspace with the instruction: cd <path_to_catkin_ws>    

Next we run the command that performs the compilation: catkin_make    

In case the compilation is successful, you can go to step 11 to perform the execution test of the project, being able to visualize that way that the whole system works correctly. 

7- If the compilation has failed, this is probably because some configuration files of the project are not set up properly for compilation in ROS Indigo with Catkin Workspace. First of all, we open the file "package.xml" both in the folder "lsd_slam/lsd_slam_viewer" and in the folder "lsd_slam/lsd_slam_core".   Once both files are open, we will verify that inside them there are the two following instructions:

...
<build_depend>cmake_modules</build_depend>
... 
<run_depend>cmake_modules</run_depend> 
...  

In case they don't exist, we will introduce them in the following way: 

The instruction <build_depend>cmake_modules</build_depend> will go right after all of the instructions of type <build_depend>  

The instruction <run_depend>cmake_modules</run_depend> will go just after all of the instructions of type <run_depend>.

8- We continue verification of the configuration files. Now we will open the file "CMakeFiles.txt" both in the folder "lsd_slam/lsd_slam_viewer" and in the folder "lsd_slam/lsd_slam_core" and we will verify that in both files there is the following instruction:

...
find_package(cmake_modules REQUIRED)   
...

In case it doesn't exist, we introduce it just before the first instruction of the type "find_package".

9- We will finish the test of the configuration files by opening the file "CMakeLists.txt" in the folder "lsd_slam/lsd_slam_core" and verifying that the following instruction exists:  

...
target_link_libraries(lsdslam ${FABMAP_LIB} ${G2O_LIBRARIES} ${catkin_LIBRARIES} csparse cxsparse X11) 
...  

In case the preceding instruction doesn't exist, there must exist another similar one without the added library "X11", therefore the only thing that we would have to do would be to add the library "X11" to the instruction "target_link_libraries" as is shown in the instruction above.  

10- At this point we return to compiling the project as explained in step 6. The commands for compiling are the following: 

cd <path_to_catkin_ws> 
catkin_make  

In this case the compilation ought to be performed correctly since all of the configuration files are adapted for the compilation in ROS Indigo with Catkin Workspace.

11) At this point, once we have already succeeded in compiling the project, we will carry out a small test of the system with the aid of one of the ".bag" files that the creators of the project provide to test the LSD_SLAM system. 

The ".bag" file that we will utilize can be downloaded here: LSD_room.bag.zip
Once the file "LSD_room.bag.zip" is downloaded, it will have to be decompressed.

In the following, we will begin to start the nodes needed to execute the test.   

We will open a new terminal and enter the following command to start the ROS CORE: roscore

We open a new terminal and enter the following command to execute the LSD-SLAM visualization node: rosrun lsd_slam_viewer viewer  

We open a new terminal and enter the following command to execute the main LSD-SLAM node: rosrun lsd_slam_core live_slam image:=/image_raw camera_info:=/camera_info 

At this point it only remains for us to execute the file "LSD_room.bag" with the following instruction: rosbag play <path>/LSD_room.bag   

In the command above, <path> would be the location in the Ubuntu file-system where the file "LSD_room.bag" is stored. 

The result would be something like this:










Final note: If on execution the "viewer" produces some error, make sure that you have the latest drivers of the graphics card and have installed all the software updates of Ubuntu.
In case of Ubuntu being virtualized with VirtualBox, make sure that you have installed all the software updates of Ubuntu and also have installed "Guest Additions", and if there are still errors appearing that don't abort execution of the node, they don't matter because they are minor problems of the virtualization that don't hinder the correct execution of the "viewer".    

References:    

Official page of the LSD-SLAM project: vision.in.tum.de/research/lsdslam    
Official page of the LSD-SLAM project code: github.com/tum-vision/lsd_slam    
Official documentation of "Catkin": catkin/conceptual_overview    
Official tutorial of installation and ROS configuration: InstallingandConfiguringROSEnvironment   Official tutorial for creation of the Catkin Workspace: catkin/Tutorials/create_a_workspace 

domingo, 23 de noviembre de 2014

Tutorial -- Compilación de LSD-SLAM en ROS con Catkin Workspace (ROS Indigo+Ubuntu 14.04 [64-bits])

En este tutorial se va a mostrar como compilar el proyecto de LSD-SLAM en Ubuntu 14.04 utilizando el framework de ROS (Robot Operating System) en su versión "Indigo Igloo"y concretamente usando "catkin" que es el sistema de compilación oficial de ROS en la actualidad y ha sido el sucesor del sistema de compilación original de ROS denominado "rosbuild".  

A continuación se describen los pasos para realizar la instalación y compilación del proyecto LSD-SLAM:

1- Una vez que tenemos ROS instalado y configurado y que hemos creado un Catkin Workspace abrimos un terminal en Ubuntu y nos dirigimos a la carpeta que estemos utilizando como Catkin Workspace introduciendo el siguiente comando:
cd <path_to_catkin_ws>/src

En el comando anterior, donde aparece <path_to_catkin_ws> hay que introducir la ubicación en la que se encuentra nuestro Catkin Workspace dentro del sistema de ficheros de Ubuntu.

2- Clonamos dentro de nuestro Workspace la "branch" principal del proyecto LSD-SLAM con el comando: git clone https://github.com/tum-vision/lsd_slam.git

3- A continuación cambiamos a la "branch" de Catkin del proyecto LSD-SLAM con estos comandos:
cd lsd_slam/
git checkout catkin

4- Con los comandos anteriores ya deberíamos tener disponible en nuestro Workspace el código de la "branch" de Catkin de LSD-SLAM pero aun así a continuación realizaremos una simple verificación manual para comprobar que la estructura de ficheros del proyecto que tenemos en nuestro Workspace es la correspondiente a la "branch" de Catkin del proyecto LSD-SLAM.
Introducimos el comando: ls
La respuesta que deberíamos recibir tendría que ser la siguiente:
LICENSE  lsd_slam  lsd_slam_core  lsd_slam_viewer  README.md

5- En este momento unicamente nos faltaría instalar las dependencias que necesita el proyecto para a continuación poder ser compilado.
Deberemos instalar las siguientes librerías:
ros-indigo-libg2o ros-indigo-cv-bridge liblapack-dev libblas-dev freeglut3-dev libqglviewer-dev libsuitesparse-dev libx11-dev

La instalación de estas librerías la realizaremos con único comando el cual se muestra a continuación:
sudo apt-get install ros-indigo-libg2o ros-indigo-cv-bridge liblapack-dev libblas-dev freeglut3-dev libqglviewer-dev libsuitesparse-dev libx11-dev

6- En este punto intentaremos realizar la compilación. Para ello en primer lugar nos dirigiremos al Catkin Workspace con la instrucción: cd <path_to_catkin_ws>
Seguidamente introduciremos el comando que se encarga de la compilación: catkin_make

En caso de que la compilación se realice correctamente puede pasar al punto 11 para realizar una ejecución de prueba del proyecto pudiendo así visualizar que todo funciona correctamente.

7- Si la compilación ha fallado esto es probablemente a que algunos ficheros de configuración del proyecto no están configurados adecuadamente para la compilación en ROS Indigo con Catkin Workspace.
En primer lugar abriremos el archivo "package.xml" tanto de la carpeta "lsd_slam/lsd_slam_viewer" como el de la carpeta "lsd_slam/lsd_slam_core". Una vez abiertos ambos archivos verificaremos que en su interior existan las dos instrucciones siguientes:
...
<build_depend>cmake_modules</build_depend>
...
<run_depend>cmake_modules</run_depend>
...

En caso de que no existan las introduciremos de la siguiente manera:
La instrucción <build_depend>cmake_modules</build_depend> irá ubicada justo después de todas las instrucciones del tipo <build_depend>La instrucción <run_depend>cmake_modules</run_depend> irá ubicada justo después de todas las instrucciones del tipo <run_depend>

8- Continuamos la verificación de ficheros de configuración. Ahora abriremos el archivo "CMakeFiles.txt" tanto de la carpeta "lsd_slam/lsd_slam_viewer" como de la carpeta "lsd_slam/lsd_slam_core" y verificaremos que en ambos archivos existe la siguiente instrucción:
...
find_package(cmake_modules REQUIRED)
...

En caso de que no exista la introduciremos justo antes de la primera instrucción de tipo "find_package".

9- Finalizaremos la comprobación de ficheros de configuración abriendo el archivo "CMakeLists.txt" de la carpeta "lsd_slam/lsd_slam_core" y verificando que existe la siguiente instrucción:
...
target_link_libraries(lsdslam ${FABMAP_LIB} ${G2O_LIBRARIES} ${catkin_LIBRARIES} csparse cxsparse X11)
...

En caso de que la anterior instrucción no exista, deberá existir otra parecida pero sin la librería "X11" añadida por lo tanto lo único que tendremos que hacer será añadir la librería "X11" a la instrucción "target_link_libraries" tal como se muestra en la instrucción de arriba.

10- En este punto volveremos a compilar el proyecto igual que se explico en el punto 6.
Los comandos para compilar son los siguientes:
cd <path_to_catkin_ws>
catkin_make
En este caso la compilación debería realizarse correctamente ya que todos los archivos de configuración están adaptados para la compilación en ROS Indigo con Caktin Workspace.

11- En este punto una vez que ya hemos conseguido compilar el proyecto realizaremos una pequeña prueba del sistema con la ayuda de uno de los ficheros ".bag" que aportan los creadores del proyecto para poder probar el sistema LSD-SLAM.
El archivo ".bag" que utilizaremos puede descargarse aquí: LSD_room.bag.zip
Una vez descargado el archivo "LSD_room.bag.zip" deberá descomprimirse.
A continuación empezaremos a iniciar los nodos necesarios para ejecutar la prueba.
Abrimos un nuevo terminal e insertamos el siguiente comando para iniciar el ROS CORE:
roscore
Abrimos un nuevo terminal e insertamos el siguiente comando para ejecutar el nodo de visualización de LSD-SLAM:  rosrun lsd_slam_viewer viewer
Abrimos un nuevo terminal e insertamos el siguiente comando para ejecutar el nodo principal de LSD-SLAM: rosrun lsd_slam_core live_slam image:=/image_raw camera_info:=/camera_info
En este momento solo nos falta ejecutar el archivo "LSD_room.bag" con la siguiente instrucción:
rosbag play <path>/LSD_room.bag
En el comando anterior <path> sera la ubicación en el sistema de ficheros de Ubuntu donde está el archivo "LSD_room.bag"

El resultado sería algo como esto:




















Nota final: Si al ejecutar el "viewer" se produce algún error asegúrese de que tiene los Drivers de la tarjeta gráfica actualizados y de tener instaladas todas las actualizaciones de Software de Ubuntu.
En caso de estar virtualizando Ubuntu con VirtualBox asegúrese de tener instaladas todas las actualizaciones de Software de Ubuntu y también de tener instalado "Guest Additions" y si aun así siguen saliendo "errores" que no aborten la ejecución del nodo, no le de importancia ya que son problemas menores de las virtualización que no impiden la ejecución correcta del "viewer".


Referencias:

Página oficial del proyecto LSD-SLAM: vision.in.tum.de/research/lsdslam
Página oficial del código del proyecto LSD-SLAM: github.com/tum-vision/lsd_slam
Documentación oficial de "catkin": catkin/conceptual_overview
Tutorial oficial de instalación y configuración de ROS: InstallingandConfiguringROSEnvironment
Tutorial oficial para la creación de un Catkin Workspace: catkin/Tutorials/create_a_workspace