With over 1.5k stars on GitHub, pySLAM contains a Python implementation of a monocular Visual Odometry (VO) pipeline. It supports many classical and modern local features, and it offers a convenient interface for them. Moreover, it collects other common and useful VO and SLAM tools. I released its first version for educational purposes for a computer vision class I recently taught. I started developing it for fun as a Python programming exercise, during my free time. You can use this framework as a baseline to play with local features, VO techniques, and create your own (proof of concept) VO/SLAM pipeline in Python. 


PLVS is a real-time system that leverages sparse SLAM, volumetric mapping, and 3D unsupervised incremental segmentation. PLVS stands for Points, Lines, Volumetric mapping and Segmentation. The system runs entirely on CPU or can profit from available GPU computational resources for some specific tasks. The underlying SLAM module is sparse and keyframe-based. It relies on the extraction and tracking of keypoints and keylines. Different volumetric mapping methods are supported and integrated in PLVS. A novel “reprojection” error is proposed for bundle-adjusting line segments. This error allows the system to better stabilize the position estimates of the mapped line segment endpoints and improves SLAM performances. An incremental segmentation method is implemented and integrated into the PLVS framework. Additionally, maps can be saved and reused at need providing multi-session mapping capabilities. You can find further details on this page or in the following document
PLVS: A SLAM System with Points, Lines, Volumetric Mapping, and 3D Incremental Segmentation
Luigi Freda



The 3DMR framework provides tools for 3D multi-robot explorationpatrolling, and navigation tasks with different robots under different simulators. It provides the core C++ implementation behind our papers:
3D Multi-Robot Exploration with a Two-Level Coordination Strategy and Prioritization
L. Freda, T. Novo, D. Portugal, R.P. Rocha
3D Multi-Robot Patrolling with a Two-Level Coordination Strategy
L. Freda, M. Gianni, F. Pirri, A. Gawel, R. Dubé, R. Siegwart, C. Cadena

This repository allows testing our proposed multi-robot strategies within V-REP and gazebo. It extends and improves our previous framework 3dpatrollingHere, you can find a list of new features we added. More information on this page



slamplay is a collection of powerful tools to start playing and experimenting with SLAM in C++. It installs and makes available in a single cmake framework some of the most important
– back-end frameworks (g2o, gtsam, ceres, se-sync, etc.),
– front-end tools (OpenCV, PCL, etc.),
– algebra and geometry libs (eigen, Sophus, cholmod, etc.),
– viz tools (pangolin, imgui, etc.),
– loop-closure frameworks (DBOW3, iBOW, etc.), 
along with some nice examples in order to easily and quickly start with all these tools.



This repository provides part of the C++ implementation behind our paper titled 3D Multi-Robot Patrolling with a Two-Level Coordination Strategy“. The software allows testing the proposed multi-robot strategy within a V-REP simulation environment. Further details are available on this page. The above framework 3DMR is now replacing it (by integrating all of the 3Dpatrolling functionalities). 

ROSIntegration for Unreal Engine 4.23
code:  (fork)
news: now this fork has been merged into the original repo

I succeeded in porting the ROSIntegration plugin to the brand new version 4.23 of Unreal Engine (UE). The ROSIntegration plugin allows a cool integration between UE and ROS. The plugin was already available and tested up to UE 4.22. Unfortunately, some memory management bugs prevented the plugin from correctly working (getting continuous crashes) under the new version 4.23 (where more strict checks are performed on UObject and memory management). I successfully found and fixed the bugs in the ROSIntegration plugin. Now, it correctly works without crashes.  


🤖 🐳

The rosdocker repository contains a set of tools that simplify the management of docker containers and (ROS) images with transparent support of NVIDIA drivers.