Installation et configuration d'Ubuntu20.04 pour exécuter DynaSLAM

Enterprise 2023-05-05 17:35:48 views: null

Installation et configuration d'Ubuntu20.04 pour exécuter DynaSLAM

Annuaire d'articles

DynaSLAM combine Mask_RCNN et la géométrie multi-vues pour supprimer les fonctionnalités dynamiques sur la base d'ORB-SLAM2, alors configurez l'environnement d'exploitation ORB-SLAM2 et ORB-SLAM3 dans Ubuntu 20.04 + ROS pour exécuter ORB-SLAM2 en temps réel + Simulation Gazebo pour exécuter ORB -SLAM2 + divers connexes Configurer et exécuter DynaSLAM dans l'environnement de base de

1. Installez Anaconda

Entrez sur le site officiel d'Anaconda , cliquez sur Télécharger pour télécharger (Anaconda téléchargera la version correspondante en fonction du système utilisé pour accéder à la page Web, par exemple, ce que j'ai téléchargé ici est Anaconda3-2023.03-Linux-x86_64.sh)

insérez la description de l'image ici
Installer Anaconda

bash Anaconda3-2023.03-Linux-x86_64.sh

(1) Vérifiez l'accord d'installation, appuyez sur Entrée jusqu'à ce qu'il apparaisse Do you accept the license terms? [yes|no], entrez yespour continuer l'installation ;
(2) Après avoir entré oui, vous serez invité à confirmer l'emplacement d'installation, cliquez ici Enterpar défaut ;
(3) Initialisez Anaconda, cette étape n'a besoin que de suivre les invites Entrez oui ;

insérez la description de l'image ici

insérez la description de l'image ici

Redémarrez le terminal pour entrer dans l'environnement conda basic, suivez les invites, si vous souhaitez que l'environnement conda basic ne soit pas activé au démarrage du terminal, définissez auto_activate_basele paramètre sur false :

conda config --set auto_activate_base false

Si vous souhaitez entrer dans l'environnement de base conda ultérieurement, il vous suffit d'utiliser la commande conda pour activer :

conda activate base

insérez la description de l'image ici

Commandes courantes de Conda :

  • Créer un environnement conda
conda create --name 环境名 包名（多个包名用空格分隔）
# 例如：conda create --name my_env python=3.7 numpy pandas scipy
  • Activer (changer) l'environnement conda
conda activate 环境名
# 例如：conda activate bas
  • Afficher l'environnement conda créé
conda info --envs
# 或者：conda info -e，亦或者conda env list
  • Supprimer l'environnement conda spécifié,
# 通过环境名删除
conda remove --name 要删除的环境名 --all

# 通过指定环境文件位置删除（这个方法可以删除不同位置的同名环境）
conda remove -p 要删除的环境所在位置 --all
# 例如：conda remove -p /home/zard/anaconda3/envs/MaskRCNN --all

2. Dépendances d'installation

(1) Installer la bibliothèque boost

sudo apt-get install libboost-all-dev

(2) Référence d'installation de Pangolin, OpenCV2 ou 3 et Eigen3 : Configuration Ubuntu 20.04 Environnement d'exploitation ORB-SLAM2 et ORB-SLAM3 + ROS temps réel exécutant ORB-SLAM + Simulation Gazebo exécutant ORB-SLAM2 + installation de diverses bibliothèques associées, cet article Eigen3.4.0 et OpenCV3.4.5 y sont installés, puis ils sont installés en fonction d'eux

3. Configurez l'environnement Mask_RCNN

Configurer dans l'environnement virtuel Anaconda

# 创建一个虚拟环境
conda create -n MaskRCNN python=2.7
conda activate MaskRCNN
# 这一步可能报错，多尝试几次，可能会成功（非常玄学，可能是网络的问题）
pip install tensorflow==1.14.0
pip install keras==2.0.9
# 这一步可能提示numpy，pillow版本过低，升级numpy和pillow
# sudo pip install numpy==x.x.x
# sudo pip install pillow==x.x.x
pip install scikit-image
pip install pycocotools

Téléchargez DynaSLAM et testez l'environnement

git clone  https://github.com/BertaBescos/DynaSLAM.git
cd DynaSLAM
python src/python/Check.py

Si sortie :

Mask R-CNN is correctly working

vous pouvez passer à l'étape suivante

4. Installez DynaSLAM

Téléchargez le fichier mask_rcnn_coco.h5 et copiez-le dans DynaSLAM/src/python/le
insérez la description de l'image ici
code source de Dynaslam. Certains ne conviennent qu'à opencv2.4. Pour l'opencv3.4.5 que nous avons installé auparavant, nous devons modifier le code source de dynaslam, et afin d'éviter les erreurs de segment, nous devons également modifier certains contenus. Reportez-vous à l'article : À propos de l'exécution du code source de DynaSLAM (version OpenCV3.x)

4.1 Modifier CMakeLists.txt

(1) DynaSLAM/CMakeLists.txtmoyen

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  -Wall  -O3 ")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall   -O3 ")
# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  -Wall  -O3 -march=native ")
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall   -O3 -march=native")
......................
#find_package(OpenCV 2.4.11 QUIET)
#if(NOT OpenCV_FOUND)
#    message("OpenCV > 2.4.11 not found.")
#    find_package(OpenCV 3.0 QUIET)
#    if(NOT OpenCV_FOUND)
#        message(FATAL_ERROR "OpenCV > 3.0 not found.")
#    endif()
#endif()

find_package(OpenCV 3.4 QUIET)
if(NOT OpenCV_FOUND)
    find_package(OpenCV 2.4 QUIET)
    if(NOT OpenCV_FOUND)
        message(FATAL_ERROR "OpenCV > 2.4.x not found.")
    endif()
endif()
......................
set(Python_ADDITIONAL_VERSIONS "2.7")
#This is to avoid detecting python 3
find_package(PythonLibs 2.7 EXACT REQUIRED)
if (NOT PythonLibs_FOUND)
    message(FATAL_ERROR "PYTHON LIBS not found.")
else()
    message("PYTHON LIBS were found!")
    message("PYTHON LIBS DIRECTORY: " ${PYTHON_LIBRARY} ${PYTHON_INCLUDE_DIRS})
endif()
......................
#find_package(Eigen3 3.1.0 REQUIRED)
find_package(Eigen3 3 REQUIRED)

(2) DynaSLAM/Thirdparty/DBoW/CMakeLists.txtmoyen

#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  -Wall  -O3 -march=native ")
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall  -O3 -march=native")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}  -Wall  -O3 ")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall  -O3 ")
......................
# find_package(OpenCV 3.0 QUIET)
find_package(OpenCV 3.4 QUIET)

(3) DynaSLAM/Thirdparty/g2o/CMakeLists.txtmoyen

#SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -march=native") 
#SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -march=native")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 ") 
SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 ")
......................
#FIND_PACKAGE(Eigen3 3.1.0 REQUIRED)
FIND_PACKAGE(Eigen3 3 REQUIRED)

4.2 Modifier le code source

(1)include/Conversion.h

// cv::Mat toMat(const PyObject* o);
   cv::Mat toMat(PyObject* o);

(2)src/Conversion.cc

/**
 * This file is part of DynaSLAM.
 * Copyright (C) 2018 Berta Bescos <bbescos at unizar dot es> (University of Zaragoza)
 * For more information see <https://github.com/bertabescos/DynaSLAM>.
 *
 */

#include "Conversion.h"
#include <iostream>

namespace DynaSLAM
{
    
    

    static void init()
    {
    
    
        import_array();
    }

    static int failmsg(const char *fmt, ...)
    {
    
    
        char str[1000];

        va_list ap;
        va_start(ap, fmt);
        vsnprintf(str, sizeof(str), fmt, ap);
        va_end(ap);

        PyErr_SetString(PyExc_TypeError, str);
        return 0;
    }

    class PyAllowThreads
    {
    
    
    public:
        PyAllowThreads() : _state(PyEval_SaveThread()) {
    
    }
        ~PyAllowThreads()
        {
    
    
            PyEval_RestoreThread(_state);
        }

    private:
        PyThreadState *_state;
    };

    class PyEnsureGIL
    {
    
    
    public:
        PyEnsureGIL() : _state(PyGILState_Ensure()) {
    
    }
        ~PyEnsureGIL()
        {
    
    
            // std::cout << "releasing"<< std::endl;
            PyGILState_Release(_state);
        }

    private:
        PyGILState_STATE _state;
    };

    using namespace cv;

    static PyObject *failmsgp(const char *fmt, ...)
    {
    
    
        char str[1000];

        va_list ap;
        va_start(ap, fmt);
        vsnprintf(str, sizeof(str), fmt, ap);
        va_end(ap);

        PyErr_SetString(PyExc_TypeError, str);
        return 0;
    }

    class NumpyAllocator : public MatAllocator
    {
    
    
    public:
#if (CV_MAJOR_VERSION < 3)
        NumpyAllocator()
        {
    
    
        }
        ~NumpyAllocator() {
    
    }

        void allocate(int dims, const int *sizes, int type, int *&refcount,
                      uchar *&datastart, uchar *&data, size_t *step)
        {
    
    

            // PyEnsureGIL gil;

            int depth = CV_MAT_DEPTH(type);
            int cn = CV_MAT_CN(type);

            const int f = (int)(sizeof(size_t) / 8);
            int typenum = depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE
                                                   : depth == CV_16U  ? NPY_USHORT
                                                   : depth == CV_16S  ? NPY_SHORT
                                                   : depth == CV_32S  ? NPY_INT
                                                   : depth == CV_32F  ? NPY_FLOAT
                                                   : depth == CV_64F  ? NPY_DOUBLE
                                                                      : f * NPY_ULONGLONG + (f ^ 1) * NPY_UINT;
            int i;

            npy_intp _sizes[CV_MAX_DIM + 1];
            for (i = 0; i < dims; i++)
            {
    
    
                _sizes[i] = sizes[i];
            }

            if (cn > 1)
            {
    
    
                _sizes[dims++] = cn;
            }
            PyObject *o = PyArray_SimpleNew(dims, _sizes, typenum);
            if (!o)
            {
    
    

                CV_Error_(CV_StsError, ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims));
            }
            refcount = refcountFromPyObject(o);

            npy_intp *_strides = PyArray_STRIDES(o);
            for (i = 0; i < dims - (cn > 1); i++)
                step[i] = (size_t)_strides[i];

            datastart = data = (uchar *)PyArray_DATA(o);
        }

        void deallocate(int *refcount, uchar *, uchar *)
        {
    
    
            // PyEnsureGIL gil;
            if (!refcount)
                return;
            PyObject *o = pyObjectFromRefcount(refcount);
            Py_INCREF(o);
            Py_DECREF(o);
        }
#else

        NumpyAllocator()
        {
    
    
            stdAllocator = Mat::getStdAllocator();
        }
        ~NumpyAllocator()
        {
    
    
        }

        UMatData *allocate(PyObject *o, int dims, const int *sizes, int type,
                           size_t *step) const
        {
    
    
            UMatData *u = new UMatData(this);
            u->data = u->origdata = (uchar *)PyArray_DATA((PyArrayObject *)o);
            npy_intp *_strides = PyArray_STRIDES((PyArrayObject *)o);
            for (int i = 0; i < dims - 1; i++)
                step[i] = (size_t)_strides[i];
            step[dims - 1] = CV_ELEM_SIZE(type);
            u->size = sizes[0] * step[0];
            u->userdata = o;
            return u;
        }

        UMatData *allocate(int dims0, const int *sizes, int type, void *data,
                           size_t *step, int flags, UMatUsageFlags usageFlags) const
        {
    
    
            if (data != 0)
            {
    
    
                CV_Error(Error::StsAssert, "The data should normally be NULL!");
                // probably this is safe to do in such extreme case
                return stdAllocator->allocate(dims0, sizes, type, data, step, flags,
                                              usageFlags);
            }
            PyEnsureGIL gil;

            int depth = CV_MAT_DEPTH(type);
            int cn = CV_MAT_CN(type);
            const int f = (int)(sizeof(size_t) / 8);
            int typenum =
                depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE
                                         : depth == CV_16U  ? NPY_USHORT
                                         : depth == CV_16S  ? NPY_SHORT
                                         : depth == CV_32S  ? NPY_INT
                                         : depth == CV_32F  ? NPY_FLOAT
                                         : depth == CV_64F  ? NPY_DOUBLE
                                                            : f * NPY_ULONGLONG + (f ^ 1) * NPY_UINT;
            int i, dims = dims0;
            cv::AutoBuffer<npy_intp> _sizes(dims + 1);
            for (i = 0; i < dims; i++)
                _sizes[i] = sizes[i];
            if (cn > 1)
                _sizes[dims++] = cn;
            PyObject *o = PyArray_SimpleNew(dims, _sizes, typenum);
            if (!o)
                CV_Error_(Error::StsError,
                          ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims));
            return allocate(o, dims0, sizes, type, step);
        }

        bool allocate(UMatData *u, int accessFlags,
                      UMatUsageFlags usageFlags) const
        {
    
    
            return stdAllocator->allocate(u, accessFlags, usageFlags);
        }

        void deallocate(UMatData *u) const
        {
    
    
            if (u)
            {
    
    
                PyEnsureGIL gil;
                PyObject *o = (PyObject *)u->userdata;
                Py_XDECREF(o);
                delete u;
            }
        }

        const MatAllocator *stdAllocator;
#endif
    };

    NumpyAllocator g_numpyAllocator;

    NDArrayConverter::NDArrayConverter() {
    
     init(); }

    void NDArrayConverter::init()
    {
    
    
        import_array();
    }

    cv::Mat NDArrayConverter::toMat(PyObject *o)
    {
    
    
        cv::Mat m;

        if (!o || o == Py_None)
        {
    
    
            if (!m.data)
                m.allocator = &g_numpyAllocator;
        }

        if (!PyArray_Check(o))
        {
    
    
            failmsg("toMat: Object is not a numpy array");
        }

        int typenum = PyArray_TYPE(o);
        int type = typenum == NPY_UBYTE ? CV_8U : typenum == NPY_BYTE                     ? CV_8S
                                              : typenum == NPY_USHORT                     ? CV_16U
                                              : typenum == NPY_SHORT                      ? CV_16S
                                              : typenum == NPY_INT || typenum == NPY_LONG ? CV_32S
                                              : typenum == NPY_FLOAT                      ? CV_32F
                                              : typenum == NPY_DOUBLE                     ? CV_64F
                                                                                          : -1;

        if (type < 0)
        {
    
    
            failmsg("toMat: Data type = %d is not supported", typenum);
        }

        int ndims = PyArray_NDIM(o);

        if (ndims >= CV_MAX_DIM)
        {
    
    
            failmsg("toMat: Dimensionality (=%d) is too high", ndims);
        }

        int size[CV_MAX_DIM + 1];
        size_t step[CV_MAX_DIM + 1], elemsize = CV_ELEM_SIZE1(type);
        const npy_intp *_sizes = PyArray_DIMS(o);
        const npy_intp *_strides = PyArray_STRIDES(o);
        bool transposed = false;

        for (int i = 0; i < ndims; i++)
        {
    
    
            size[i] = (int)_sizes[i];
            step[i] = (size_t)_strides[i];
        }

        if (ndims == 0 || step[ndims - 1] > elemsize)
        {
    
    
            size[ndims] = 1;
            step[ndims] = elemsize;
            ndims++;
        }

        if (ndims >= 2 && step[0] < step[1])
        {
    
    
            std::swap(size[0], size[1]);
            std::swap(step[0], step[1]);
            transposed = true;
        }

        if (ndims == 3 && size[2] <= CV_CN_MAX && step[1] == elemsize * size[2])
        {
    
    
            ndims--;
            type |= CV_MAKETYPE(0, size[2]);
        }

        if (ndims > 2)
        {
    
    
            failmsg("toMat: Object has more than 2 dimensions");
        }

        m = Mat(ndims, size, type, PyArray_DATA(o), step);

        if (m.data)
        {
    
    
#if (CV_MAJOR_VERSION < 3)
            m.refcount = refcountFromPyObject(o);
            m.addref(); // protect the original numpy array from deallocation
                        // (since Mat destructor will decrement the reference counter)
#else
            m.u = g_numpyAllocator.allocate(o, ndims, size, type, step);
            m.addref();
            Py_INCREF(o);
            // m.u->refcount = *refcountFromPyObject(o);
#endif
        };
        m.allocator = &g_numpyAllocator;

        if (transposed)
        {
    
    
            Mat tmp;
            tmp.allocator = &g_numpyAllocator;
            transpose(m, tmp);
            m = tmp;
        }
        return m;
    }

    PyObject *NDArrayConverter::toNDArray(const cv::Mat &m)
    {
    
    
        if (!m.data)
            Py_RETURN_NONE;
        Mat temp;
        Mat *p = (Mat *)&m;
#if (CV_MAJOR_VERSION < 3)
        if (!p->refcount || p->allocator != &g_numpyAllocator)
        {
    
    
            temp.allocator = &g_numpyAllocator;
            m.copyTo(temp);
            p = &temp;
        }
        p->addref();
        return pyObjectFromRefcount(p->refcount);
#else
        if (!p->u || p->allocator != &g_numpyAllocator)
        {
    
    
            temp.allocator = &g_numpyAllocator;
            m.copyTo(temp);
            p = &temp;
        }
        // p->addref();
        // return pyObjectFromRefcount(&p->u->refcount);
        PyObject *o = (PyObject *)p->u->userdata;
        Py_INCREF(o);
        return o;
#endif
    }
}

4.3 Compiler DynaSLAM

conda activate MaskRCNN
cd DynaSLAM
chmod +x build.sh
./build.sh
  • Si la branche master n'a pas le fichier mono_carla.cc, il doit être commenté
# add_executable(mono_carla
# Examples/Monocular/mono_carla.cc)
# target_link_libraries(mono_carla ${PROJECT_NAME})
  • Erreur erreur fatale : ndarrayobject.h : aucun fichier ou directeur de ce type, numpy est installé dans l'environnement virtuel et Python3, mais le python2 fourni avec Ubuntu n'est pas installé, mais pip ne peut pas être utilisé car il sera installé dans python3, donc
sudo apt-get install python-numpy
  • Erreur : erreur : l'assertion statique a échoué : std : : map doit avoir le même type de valeur que son allocateur. C'est un vieux problème. Je l'ai écrit dans l'article où j'ai installé ORB, et je l'ai mis dans le fichier include/LoopClosing.h dans le Répertoire du code source ORB-SLAM2 de
// typedef map<KeyFrame*,g2o::Sim3,std::less<KeyFrame*>,
//        Eigen::aligned_allocator<std::pair<const KeyFrame*, g2o::Sim3> > > KeyFrameAndPose;
//修改为：
typedef map<KeyFrame*,g2o::Sim3,std::less<KeyFrame*>,
        Eigen::aligned_allocator<std::pair<KeyFrame *const, g2o::Sim3> > > KeyFrameAndPose;

courir:

./Examples/RGB-D/rgbd_tum Vocabulary/ORBvoc.txt Examples/RGB-D/TUM3.yaml /XXX/tum_dataset/ /XXX/tum_dataset/associations.txt (path_to_masks) (path_to_output)

Ne pas donner ces deux derniers paramètres équivaut à exécuter ORB-SLAM2. Si vous souhaitez uniquement utiliser la fonction de MaskRCNN mais ne souhaitez pas enregistrer le masque dans path_to_masks, écrivez-le comme no_save, sinon donnez une adresse de dossier pour enregistrer le masque.

insérez la description de l'image ici

Le CPU (mon i5 de 12e génération) ne peut pas tourner du tout, il est bloqué, mais l'effet de positionnement pour les données dynamiques est effectivement bien meilleur :
insérez la description de l'image ici

Je suppose que tu aimes

Origine blog.csdn.net/zardforever123/article/details/130064101
conseillé
Classement
du quotidien
Plus
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(18)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(35)
2024-04-29(5)
2024-04-28(10)

Code World

© 2018 codetd.com