Ubuntu18.04+teléfono Android IMU+ROS Melodic ejecutando ORB-SLAM2

prefacio

La formación de este blog es inseparable del blog de la Universidad de Tsinghua y se publica aquí https://www.cnblogs.com/MingruiYu/p/12404730.html

1. Instalación de ROS Melodic en la versión 18.04 del sistema ubuntu

Vaya a mi blog anterior Instalación de ROS Melodic en el sistema ubuntu versión 18.04 (evitación perfecta de pozos)

2. Instalación, configuración y operación de instancia monocular SLAM basada en ROS, ORB_SLAM2

1. Configuración temprana del entorno SLAM

Pase a mi blog anterior Ubuntu 18.04 para crear un entorno SLAM (perfecto para evitar trampas, y la versión no corresponde a ningún error)

2. Instale ORB_SLAM2 bajo ROS

Para ejecutar ORB_SLAM en el entorno ROS, lo mejor es colocarlo en la carpeta src del espacio de trabajo (directorio del espacio de trabajo: catkin_ws/src)
e ingresar a la carpeta src del espacio de trabajo de ROS.

cd ~/catkin_ws/src/

Descarga e instala ORB_SLAM2

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

Vaya a la carpeta ORB_SLAM2.

cd ORB_SLAM2

Dar permiso para construir el archivo.sh.

chmod +x build.sh

Compile el archivo build.sh

./build.sh

Aquí se puede informar un error
Pregunta 1:
ORB_SLAM2/src/System.cc: error: 'usleep' no se declaró en este ámbito usleep(5000);
Solución:
busque el encabezado del archivo System.cc correspondiente y agréguelo al archivo de cabecera

#include<unistd.h>

De acuerdo con la situación real, si hay un problema con el archivo usleep, agregue este archivo de encabezado.
Los archivos que necesitan agregar unistd.h son:
Ejemplos/Monocular/mono_euroc.cc
Ejemplos/Monocular/mono_kitti.cc
Ejemplos/Monocular/mono_tum.cc
Ejemplos/RGB-D/rgbd_tum.cc
Ejemplos/Stereo/stereo_euroc.cc
Ejemplos/ Stereo /stereo_kitti.cc
src/LocalMapping.cc
src/LoopClosing.cc
src/System.cc
src/Tracking.cc
src/Viewer.cc Además, si hay enlaces de referencia
de automodificación https://blog.csdn.net / qq_15698613/article/details/98453592 Debido a que necesita ejecutar ORB_SLAM2 en el entorno ROS, debe ejecutar el siguiente comando

chmod +x build_ros.sh

editar archivo bash

sudo  gedit ~/.bashrc

Agregue la ruta que contiene Ejemplos/ROS/ORB_SLAM2 a la variable de entorno ROS_PACKAGE_PATH. Abra el archivo .bashrc y agregue el contenido al final como se muestra en la figura

export ROS_PACKAGE_PATH=${ROS_PACKAGE_PATH}:（PATH）/catkin_ws/src/ORB_SLAM2/Examples/ROS

./build_ros.sh

Es posible que se informe un error durante la compilación
Pregunta 1:

La razón de este problema es que la versión de Pangolin es demasiado alta, por lo que la versión debe reducirse a 0.5.
Disco de red Pangolin
https://pan.baidu.com/s/1yEQvArzHz35CUJc-BEmNiw
Código de extracción: n6r8
Enlace de referencia https://blog.csdn.net/qq_33950926/article/details/121129028
Pregunta 2:
CMakeFiles/RGBD.dir/ build.make:197: la receta para el objetivo '.../RGBD' falló

Solución:
modifique el archivo CMakeLists.txt en la carpeta home/catkin_ws/src/ORB_SLAM2/Examples/ROS/ORB_SLAM2/.
Agregue la siguiente línea de código después de set(LIBS xxxxx.

-lboost_system

Simplemente vuelva a compilar
Consulte el enlace https://blog.csdn.net/weixin_44436677/article/details/105587986
Hasta ahora, se ha instalado ORB_SLAM2.

3. Ejecute la instancia SLAM monocular

Una vez completada la compilación, se generarán varios archivos ejecutables en la carpeta ORB_SLAM2/Examples. Aquí tomamos el caso del monocular como ejemplo para mostrar cómo ejecutar el programa ORB_SLAM2.

(1) Descargar el conjunto de datos

Hay tres conjuntos de datos: TUM, KITTI y EuRoC. El conjunto de datos TUM se usa aquí y la secuencia se descarga desde http://vision.in.tum.de/data/datasets/rgbd-dataset/download y se descomprime. Descargué el primero y el nombre del archivo descargado es: rgbd-dataset_freiburg_xyz.

(2) compilar

El formato de comando oficial es el siguiente:
PATH_TO_SEQUENCE_FOLDER es la ruta de almacenamiento del conjunto de datos.
tumx.yaml corresponde al conjunto de datos, por ejemplo, TUM1.yaml, TUM2.yaml y TUM3.yaml corresponden a freiburg1, freiburg2 y freiburg3 respectivamente.

./Examples/Monocular/mono_tum Vocabulary/ORBvoc.txtExamples/Monocular/TUMX.yaml PATH_TO_SEQUENCE_FOLDER

Modifique adecuadamente de acuerdo con las diferentes rutas de guardado, la mía está en el directorio principal

./Examples/Monocular/mono_tum Vocabulary/ORBvoc.txt Examples/Monocular/TUM1.yaml /home/wei/rgbd_dataset_freiburg1_xyz

(3) Resultados

Basta con mostrar el diagrama de extracción de puntos característicos. Olvidé tomar una captura de pantalla aquí. El diagrama de red es el siguiente

para demostrar que la configuración es correcta.

3. Establezca la transmisión de comunicación entre la cámara del teléfono Android y la PC

1. Descarga de la herramienta Android

https://github.com/hitcm/Android_Camera-IMU

git clone https://github.com/hitcm/Android_Camera-IMU.git
sudo apt-get install ros-melodic-imu-tools  # 修改对应自己的 ROS 版本

Asegúrese de obtener la carpeta completa, que se utilizará más adelante. Copie el apk compilado en la carpeta clonada en el teléfono Android e instálelo en el teléfono.

2. Conecte el punto de acceso para poner la PC y el teléfono Android bajo la misma LAN

Modo de operación:
Terminal 1: roscore
teléfono móvil Android: ingrese la ip de su computadora (la IP de la PC se puede verificar ingresando ifconfig en la terminal de la PC), y luego haga clic en Conectar.Si la conexión es exitosa, ingresará a la interfaz de la cámara.
Terminal 2:

cd Android_Camera-IMU
roslaunch android_cam-imu.launch

Luego aparecerá una interfaz de Rviz:
si desea mostrar la imagen en tiempo real, debe agregar - Por tema - agregar /cámara/imagen_sin procesar/imagen.
Si desea mostrar imu, debe agregar - Por tema - agregar imu y cambiar el mapa a imu en Fix Frame.
Enlace de referencia https://www.cnblogs.com/MingruiYu/p/12404730.html

4. Calibración de parámetros de cámara de la cámara del teléfono Android

Tablero de calibración

(1) Recopilar y guardar imágenes

Aquí nos referimos a un código de captura y guardado automático escrito por la Universidad de Tsinghua, y lo modificamos directamente sobre la base del código ros_mono.cc de ORB-SLAM2, y escribimos un ros_camera_capture.cc en el mismo directorio que ros_mono.cc:

/**
* This file is to capture images from Android phone, for camera calibration
* This file is used with Android_Camera-IMU
*/

#include<iostream>
#include<algorithm>
#include<fstream>
#include<chrono>

#include<ros/ros.h>
#include <cv_bridge/cv_bridge.h>

#include<opencv2/core/core.hpp>

#include"../../../include/System.h"

using namespace std;

string save_dir = "PATH"; // 修改为自己保存图片的路径
int imgId = 0;

void GrabImage(const sensor_msgs::ImageConstPtr& msg);

int main(int argc, char **argv)
{

    std::cout << "To save the current frame, please press 'Q' or 'q' " << std::endl;
    std::cout << "The images will be saved to " <<  save_dir << std::endl;

    ros::init(argc, argv, "PClistener");
    ros::start();

    ros::NodeHandle nodeHandler;
    ros::Subscriber sub = nodeHandler.subscribe("/camera/image_raw", 1, GrabImage);

    ros::spin();

    ros::shutdown();

    return 0;
}

void GrabImage(const sensor_msgs::ImageConstPtr& msg)
{
    string imgname;
    cv_bridge::CvImageConstPtr cv_ptr;
    try
    {
        cv_ptr = cv_bridge::toCvShare(msg);
        cv::Mat img = cv_ptr->image;
        cv::imshow("img_name", img);

        char key = cv::waitKey(1);
        // press "q" to save the image 
        if(key == 'q' || key == 'Q'){  
            imgId++;
            imgname = "img_" + to_string(imgId) + ".jpg";
            cv::imwrite(save_dir + imgname, img);
            std::cout << "has saved image "<< imgId << " to " << save_dir << std::endl;
        }
    }
    catch (cv_bridge::Exception& e)
    {
        ROS_ERROR("cv_bridge exception: %s", e.what());
        return;
    }
}

Preste atención a modificar el directorio donde se guarda la imagen.Además
, agregue el siguiente contenido a CMakeLists.txt en el directorio ORB_SLAM2/Examples/ROS/ORB_SLAM2 (solo agréguelo arriba de # Nodo para cámara monocular):

# Node for capture images for camera calibration
rosbuild_add_executable(CameraCapture
src/ros_camera_capture.cc
)

target_link_libraries(CameraCapture
${LIBS}
)

Vuelva a compilar el proyecto ORB_SLAM2

cd PATH/ORB_SLAM2
./build_ros.sh

Abra la terminal 1: ingrese la aplicación en el teléfono
roscore y ejecute la cámara Abra la terminal 2: en el directorio Android_Camera-IMU

roslaunch android_cam-imu.launch

(Puede apagar Rviz)
Abra la terminal 3:

rosrun ORB_SLAM2 CameraCapture

Seleccione el cuadro de imagen correspondiente al teléfono móvil en la computadora con el mouse y presione la tecla q para guardar la imagen.

(2) Realizar la calibración y crear un nuevo directorio de trabajo

El directorio principal (carpeta) camera_calibration_opencv,
copie el contenido de la carpeta samples/cpp/tutorial_code/calib3d/camera_calibration en el directorio de instalación de OpenCV a este directorio.
Modificar VID5.xml
VID5.xml almacena la ruta de la imagen de calibración, así que agregue la ruta de todas las imágenes de calibración en VID.xml (paso anterior)

<?xml version="1.0"?>
<opencv_storage>
<images>
PATH/img_1.jpg
PATH/img_2.jpg
PATH/img_3.jpg
</images>
</opencv_storage>

Modifique el ancho y la altura del tablero de ajedrez. Tenga en cuenta que el ancho y la altura aquí se refieren al número de intersecciones internas, no al número de cuadrados. Como se muestra arriba, los datos del tablero de ajedrez son 9 y 6

<BoardSize_Width> 9</BoardSize_Width>
<BoardSize_Height>6</BoardSize_Height>

Modifique la longitud lateral (mm) de cada cuadrícula, mida con una regla

<Square_Size>20</Square_Size>

Modificar la ruta de VID5.xml

<Input>"VID5.xml"</Input>

Modificar y agregar parámetros de distorsión tangencial

<Calibrate_FixPrincipalPointAtTheCenter> 1 </Calibrate_FixPrincipalPointAtTheCenter>

(3) Compilar y ejecutar, calibrar

Cree un nuevo CMakeLists.txt en el directorio de trabajo camera_calibration_opencv:

project(Camera_Calibration)
set(CMAKE_CXX_STANDARD 11)

find_package(OpenCV 3.0 QUIET)
if(NOT OpenCV_FOUND)    
    find_package(OpenCV 2.4.3 QUIET)
    if(NOT OpenCV_FOUND)
        message(FATAL_ERROR "OpenCV > 2.4.3 not found.")
    endif()
endif()

include_directories(${OpenCV_INCLUDE_DIR})
add_executable(Camera_Calibration camera_calibration.cpp)
target_link_libraries(Camera_Calibration ${OpenCV_LIBS})

cd camera_calibration_opencv
mkdir build
cd build
cmake ..
make

calibración

cd camera_calibration_opencv
./build/Camera_Calibration in_VID5.xml

Después de que se inicie el programa, mostrará la extracción del punto de esquina de la imagen calibrada, y luego mostrará la imagen corregida, y los parámetros de calibración se guardarán en out_camera_data.xml después de que todos se cierren uno por uno.

(4) Complete los parámetros en el archivo de configuración de ORB-SLAM2

La salida del parámetro está en out_camera_data.xml:

<camera_matrix type_id="opencv-matrix"> es la matriz de referencia interna de la cámara, el orden es fx, 0, cx; 0, fy, cy; 0, 0, 1.
<coeficientes_de_distorsión type_id="opencv-matrix"> es el parámetro de distorsión, su orden es k1, k2, p1, p2, k3.
Luego, cree un nuevo archivo de configuración AndroidPhone.yaml en ORB_SLAM2 (TUM1.yaml se coloca en un directorio), copie el contenido de TUM1.yaml y modifique los parámetros de la cámara de acuerdo con out_camera_data.xml.

Cinco, ejecuta ORB_SLAM2

Abra la terminal 1: ingrese la aplicación en el teléfono
roscore y ejecute la cámara Abra la terminal 2: en el directorio Android_Camera-IMU

roslaunch android_cam-imu.launch

(Rviz se puede apagar)

Abra la terminal 3:

rosrun ORB_SLAM2 Mono /home/wei/catkin_ws/src/ORB_SLAM2/Vocabulary/ORBvoc.txt /home/wei/catkin_ws/src/ORB_SLAM2/Examples/Monocular/AndroidPhone.yaml

Modifique la ruta usted mismo
Ejecute el gráfico

Six, blog de referencia

https://www.cnblogs.com/MingruiYu/p/12404730.html
https://www.jianshu.com/p/967a35dbb56a
https://blog.csdn.net/qq_29796781/article/details/80008643
https:/ /blog.csdn.net/weixin_44436677/article/details/105587986
Otras partes del blog están en el texto.