ROS learning [17] ----- Instalación y configuración del paquete ORB_SLAM2 basado en ubuntu16.04

Cuando se realiza el aprendizaje ROS, la etapa de aprendizaje esencial es el aprendizaje de ORB_SLAM2 y, al mismo tiempo, también es un sistema de visualización visual que se ejecuta compilando los archivos usted mismo. En este blog, el senior Lin Jun lleva a todos a comprender la instalación y ORB_SLAM2 Configuracion

• sistema ubuntu: ubuntuKylin-16.04
• versión de opencv: opencv-3.4.1
• Versión ROS: cinética

Primero, comprende ORB_SLAM2

1. ¿Qué es ORB_SLAM2?

• ORB-SLAM es un sistema visual SLAM escrito por Raúl Mur-Artal de la Universidad de Zaragoza en España.
• Su artículo "ORB-SLAM: un
  sistema SLAM monocular versátil y preciso " fue publicado en el 2015 IEEE Trans. On Robotics.
• El código fuente abierto incluye ORB-SLAM temprano y ORB-SLAM2 posterior. La primera versión se utiliza principalmente para SLAM monocular, mientras que la segunda versión admite tres interfaces: monocular, binocular y RGBD.

2. Características de ORB_SLAM2

• Los puntos de características extraídos y rastreados usan ORB. El proceso de extracción de características ORB es muy rápido, adecuado para el sistema en tiempo real.
• La detección de bucle invertido utiliza un modelo de bolsa de palabras y su diccionario es un diccionario ORB grande.
• La interfaz es rica, admite entrada de sensor múltiple monocular, binocular, RGBD, ROS es opcional durante la compilación, lo que hace que su aplicación sea muy ligera. El precio es para soportar varias interfaces, y la lógica del código es un poco más complicada.
• El cálculo en tiempo real se realiza en la PC a 30 ms / fotograma, pero no funciona bien en la plataforma integrada.

A través de las definiciones y características anteriores, tiene una cierta comprensión de ORB_SLAM2 en detalle, ahora, comience la instalación de ORB_SLAM2

En segundo lugar, instale Pangolin

Pangolin es una biblioteca ligera de entrada / salida de OpenGL y pantalla de video que encapsula OpenGL. Se puede usar para visión 3D y mapa visual de navegación 3D, puede ingresar varios tipos de video y puede retener el video y los datos de entrada para la depuración

1. Instalar, descargar y compilar herramientas

 sudo apt-get install cmake
 sudo apt-get install git
 sudo apt-get install g++  

2. Dependencias de instalación

 sudo apt-get install libglew-dev
 sudo apt-get install libboost-dev libboost-thread-dev libboost-filesystem-dev
 sudo apt-get install libpython2.7-dev

3. Instale Pangolin

1) Descargue el paquete Pangolin de gitHub al local

git clone https://github.com/stevenlovegrove/Pangolin.git

2) Ingrese a la carpeta Pangolin y cree una carpeta de compilación

cd Pangolin
mkdir build
cd build

3), compilación de configuración

cmake -DCPP11_NO_BOOSR=1 ..

4), compilar el archivo de recursos Pangolin

sudo make -j8

La compilación es exitosa como se muestra arriba:

Tres, instale opencv

1), la instalación de opencv, el senior Lin Jun escribió otro blog, los amigos pueden consultar el blog de instalación de opencv, el enlace es el siguiente:
https://blog.csdn.net/qq_42451251/article/details/105565305

Cuarto, instale la biblioteca Eigen

La magia de Eigen es que es una biblioteca construida con archivos de encabezado puro. Esto significa que solo puede encontrar sus archivos de encabezado, no archivos binarios como .so o .a. Al usarlo, solo necesita introducir el archivo de encabezado Eigen, ¡no es necesario vincular el archivo de la biblioteca!

1) El comando de instalación es el siguiente:

sudo apt-get install libeigen3-dev

2) Verifique la ubicación específica de la biblioteca Eigen

sudo updatedb
locate eigen3

Se puede ver que la ubicación de la biblioteca eigen3 está enusr / include / eigen3En este directorio, recuerde este directorio, ¡debe usarlo más tarde!

V. Instalación de ORB_SLAM2

En progresoORB_SLAM2La instalación es, necesitamos preparar algunas herramientas para compilar o descargar el código fuente de ORB_SLAM2, los pasos específicos son los siguientes:

1. Clone el paquete ORB_SLAM2 en ubuntu local

1), descargue el paquete de recursos ORB_SLAM2

cd
git clone https://github.com/raulmur/ORB_SLAM2.git ORB_SLAM2

El proceso de descarga es lento, ¡tenga paciencia!

2) El senior Lin Jun ha subido el paquete de recursos ORB_SLAM2 después de descargarlo en el módulo de recursos backend CSDN. Los socios pequeños pueden descargar a través del siguiente enlace, el enlace de descarga es el siguiente:
https://download.csdn.net/download/ qq_42451251 / 12332604
3), corte el paquete de recursos de código fuente ORB_SLAM2 en la carpeta src del espacio de trabajo ROS

2. La compilación del paquete ORB_SLAM2 en el espacio ROS

1) Ingrese el paquete ORB_SLAM2

cd ~/lenovo/ros/src/ORB_SLAM2

2), modificarbuild.shPermisos de archivo

chmod +x build.sh

3), compilarbuild.shArchivo

./build.sh

En términos generales, este proceso esperará al 59% durante mucho tiempo, pero no lo cierre. Después de aproximadamente 5 minutos, continuará compilando, porque algunos procesos deben esperar la compilación
4). Si desea compilar más rápido, puede Modifique make -j en el archivo build.sh para hacer -j8. Por supuesto, si la configuración de su computadora es baja, se recomienda modificar para hacer una compilación de un solo subproceso; lo siguientebuild_ros.sh¡El archivo también se puede operar de esta manera!

3. Preparación para ejecutar ORB_SLAM en entorno ROS

1) Si necesita ejecutar ORB_SLAM en el entorno ROS, debemos aprobarbuild_ros.shEl archivo está compilado, los pasos específicos son los siguientes:
1. Continuar modificando los permisos en el terminal actual

chmod +x build_ros.sh

2), agregue variables de entorno, agregue a .bashrcFin de archivo

gedit ~/.bashrc
export ROS_PACKAGE_PATH=${ROS_PACKAGE_PATH}:~/lenovo/ros/src/ORB_SLAM2/Examples/ROS

Entre ellos~ / lenovo / ros /En correspondencia con la ruta y el nombre del propio espacio de trabajo ROS de Lin Jun, ¡modifíquelo según su propio espacio de trabajo ROS!
3), compilarbuild_ros.shArchivo

./build_ros.sh

El proceso de compilación también debe esperar por el tiempo, solo esperar en silencio. Por supuesto, puede estar equivocado al final, como se muestra a continuación: La

causa del error es: libboost_system.so y libboost_filesystem.so no puede encontrar el directorio de enlaces
4)
1. Verboost_systemYboost_filesystemUbicación específica

locate  boost_system
locate boost_filesystem

2. Copie el nombre del archivo anterior y luego corresponda a la ruta / usr / lib / x86_64-linux-gnuBaje para encontrar el archivo anterior correspondiente y coloquelibboost_system.soYlibboost_system.so.1.58.0Conlibboost_filesystem.soYlibboost_filesystem.so.1.58.0Copie juntos a la ruta ORB_SLAM2 / lib de la siguiente manera:

3. Copie los cuatro archivos anteriores a la ruta debajo de ORB_SLAM2 / lib

4.ORB_SLAM2 / Ejemplos / ROS / ORB_SLAM2Agregue el directorio de la biblioteca

a Cmakelists.txt en Localice la función set () y agregue el siguiente código al final de la función:

${PROJECT_SOURCE_DIR}/../../../lib/libboost_filesystem.so
${PROJECT_SOURCE_DIR}/../../../lib/libboost_system.so

Como se muestra a continuación:

cierre después de guardar
5), vuelva a compilar en el terminal ahora, el éxito es el siguiente:

./build_ros.sh

Aquí, nuestro ORB_SLAM2 está básicamente instalado. A continuación, descargaremos y procesaremos el conjunto de datos, y luego ejecutaremos

Seis, instale usb_cam

1. Instalar usb_cam

1) Ingrese el espacio ros y descargue usb_cam

cd lenovo/ros/src
git clone https://github.com/bosch-ros-pkg/usb_cam.git

2), compilar el espacio de trabajo ROS

cd ~/lenovo/ros
ctakin_make

3) Programa de registro para que el paquete de funciones surta efecto

source ./devel/setup.bash

4), crearusb_camCompilar carpeta

cd src/usb_cam
mkdir build
cd build

5), compilar

cmake ..
make -j8

6), modificarusb_camPermisos
del archivo de inicio Vaya al archivo de inicio en usb_cam para encontrar el archivo de inicio, configure sus permisos para que sea ejecutable:

7), conéctese a la cámara del portátil

8), cree un nuevo terminal y ejecute el nodo de la cámara:

roslaunch usb_cam usb_cam-test.launch

En este punto, nuestra cámara usb_cam se descarga y se prueba, y el nodo en ejecución se apaga. ¡El terminal no está ocupado por un tiempo, y necesitamos este terminal más tarde! A continuación, debemos modificar el nodo de la cámara del archivo de lenguaje c en ORB_SLAM2 a usb_cam / image_raw

2. Modifique el nodo de la cámara del archivo de configuración

1) El camino es:ros / src / ORB_SLAM2 / Ejemplos / ROS / ORB_SLAM2 / srcEl archivo ros_mono.cc bajo lo siguiente, como sigue:

2), modifique el contenido de los tres archivos anteriores, modifique el nodo de la cámara parausb_cam / image_rawPor supuesto, solo usaremos el archivo ros_mono.cc en la implementación posterior, por lo que por el momento, solo puede modificar esto, se recomienda modificarlo:

usb_cam/image_raw

3), compile nuevamente bajo ORB_SLAM2build_ros.shArchivo

chmod +x build_ros.sh
./build_ros.sh

Como puede ver, el nodo del archivo que modificamos se actualiza.
Aquí, tenemos que configurarlo bien, ¡comencemos nuestro experimento!

Siete, la operación monocular de ORB_SLAM2

1. Descargue el conjunto de datos TUM

1) Descargue el conjunto de datos TMU a través del siguiente enlace,
http://vision.in.tum.de/data/datasets/rgbd-dataset/download

2. Cree una carpeta de datos en el paquete ORB_SLAM2 debajo del espacio ROS para almacenar el conjunto de datos TMU

1), crea una carpeta de datos

mkdir Data

2) Cargue el conjunto de datos descargados en la carpeta bajo el software de transferencia y extraiga los archivos aquí.

Aquí, nuestro conjunto de datos está listo para completarse. A continuación, ejecutaremos el conjunto de datos ORB_SLAM2.

3. Operación monocular basada en TMU en ORB_SLAM2

1). Ingrese el siguiente comando para ejecutar monocularmente

./Examples/Monocular/mono_tum Vocabulary/ORBvoc.txt Examples/Monocular/TUM1.yaml Data/rgbd_dataset_freiburg1_xyz/

Entre ellosData / rgbd_dataset_freiburg1_xyz /Es la ruta de nuestro conjunto de datos
2). Los resultados de la operación monocular son los siguientes: el

pequeño cuadrado azul en la ventana derecha de la figura es la función ORB de la imagen extraída, y la ventana izquierda muestra el mapa escaso del entorno y el movimiento de la cámara Pista.
3) Además, hay muchos conjuntos de datos en nuestro conjunto de datos, también podemos probar a través de otros conjuntos de datos, el código de prueba es el siguiente:

 ./Examples/Monocular/mono_tum Vocabulary/ORBvoc.txt Examples/Monocular/TUM2.yaml Data/rgbd_dataset_freiburg1_xyz/

 ./Examples/Monocular/mono_tum Vocabulary/ORBvoc.txt Examples/Monocular/TUM3.yaml Data/rgbd_dataset_freiburg1_xyz/

Hay muchos conjuntos de datos en el conjunto de datos descargados, que se pueden probar. ¡Aquí se dan los dos resultados de prueba anteriores!

4. Operación monocular basada en la cámara en el paquete ORB-SLAM2 bajo ROS

Para poder ejecutar ORB-SLAM2 en línea en tiempo real, debe usar la cámara de ROS y la computadora portátil, ¡así que asegúrese de que la cámara de su computadora portátil esté conectada a la computadora!
1) Ejecute el nodo de la cámara nuevamente en el terminal recién creado arriba,

roslaunch usb_cam usb_cam-test.launch

2) Llame a la cámara del portátil para ejecutar ORB-SLAM2 en tiempo real

 rosrun ORB_SLAM2 Mono /home/xxx/lenovo/ros/src/ORB_SLAM2/Vocabulary/ORBvoc.txt /home/xxx/lenovo/ros/src/ORB_SLAM2/Examples/ROS/ORB_SLAM2/Asus.yaml

En el código anteriorxxxNombre de usuario que representa ubuntu,lenovo / ros¡En nombre del propio espacio ROS de Lin Jun,

sosteniendo su computadora portátil y caminando lentamente, podemos ver que la ventana izquierda está planificando el camino, y la ventana derecha está capturando RGB! ¡Asegúrate de moverte lentamente!
3) Además de estar en Mono, también podemos ejecutar otros archivos ejecutables, como las siguientes etiquetas: Senior Lin Jun solo ha probado estos dos por el momento, y los otros aún no lo han probado:

 rosrun ORB_SLAM2 RGBD /home/xxx/lenovo/ros/src/ORB_SLAM2/Vocabulary/ORBvoc.txt /home/xxx/lenovo/ros/src/ORB_SLAM2/Examples/ROS/ORB_SLAM2/Asus.yaml

Lo anterior es todo el contenido de este blog. ¡Espero que tus amigos puedan ayudarte a comprender el funcionamiento de ORB_SLAM2 en ros leyendo este blog!
En el área de comentarios de los amigos que encontraron el problema, el Senior Lin Jun lo responderá para todos. ¡Este senior no tiene demasiado frío!
Otro día de la programación de Chen Yiyue sigue años ^ _ ^