{"id":13847812,"url":"https://github.com/pamela-project/slambench","last_synced_at":"2025-07-12T11:32:41.612Z","repository":{"id":46796333,"uuid":"121010006","full_name":"pamela-project/slambench","owner":"pamela-project","description":"SLAM performance evaluation framework","archived":false,"fork":false,"pushed_at":"2024-04-02T09:01:31.000Z","size":9598,"stargazers_count":310,"open_issues_count":26,"forks_count":83,"subscribers_count":19,"default_branch":"master","last_synced_at":"2024-08-05T19:34:57.088Z","etag":null,"topics":["performance-analysis","slam"],"latest_commit_sha":null,"homepage":"https://apt.cs.manchester.ac.uk/projects/PAMELA/","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/pamela-project.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null}},"created_at":"2018-02-10T11:34:38.000Z","updated_at":"2024-07-16T00:47:40.000Z","dependencies_parsed_at":"2024-01-15T20:56:19.984Z","dependency_job_id":"a17247dd-df80-4e0a-9608-b11e65b82cca","html_url":"https://github.com/pamela-project/slambench","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pamela-project%2Fslambench","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pamela-project%2Fslambench/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pamela-project%2Fslambench/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pamela-project%2Fslambench/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/pamela-project","download_url":"https://codeload.github.com/pamela-project/slambench/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":225820303,"owners_count":17529138,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["performance-analysis","slam"],"created_at":"2024-08-04T19:00:32.295Z","updated_at":"2024-11-21T23:30:40.839Z","avatar_url":"https://github.com/pamela-project.png","language":"C++","readme":"# SLAMBench \n\n[![Build Status](https://travis-ci.org/pamela-project/slambench2.svg?branch=master)](https://travis-ci.org/pamela-project/slambench2)\n\nCode has been added for the most recent paper based on SLAMBench:\n\n[Robust SLAM Systems: Are We There Yet?](https://arxiv.org/abs/2109.13160) \\\nhttps://robustslam.github.io/evaluation\n\n## Contents\n\n* [What is SLAMBench?](#what-is-slambench)\n* [How to set up SLAMBench?](#how-to-set-up-slambench)\n* [What algorithms does SLAMBench support?](#what-algorithms-does-slambench-support)\n* [How to run an existing algorithm with SLAMBench?](#how-to-run-an-existing-algorithm-with-slambench)\n* [How to add a new benchmark in SLAMBench?](#how-to-add-a-new-benchmark-in-slambench)\n* [Known Issues](#known-issues)\n* [Release History](#release-history)\n\n## Most frequent questions ##\n\n### Where are the algorithms ? ###\n\nUse the following command to list all available algorithms:\n\n```\nmake usecases\n```\n\n## What is SLAMBench? ##\n\nSLAMBench is a SLAM performance benchmark that combines a framework for quantifying quality-of-result with instrumentation of accuracy, execution time, memory usage and energy consumption. It also include a graphical interface to visualize these information.\n\nSLAMBench offers a platform for a broad spectrum of future research in jointly exploring the design space of algorithmic and implementation-level optimisations. It targets desktop, laptop, mobile and embedded platforms. Some of the benchmarks (in particular KFusion) were tested on Ubuntu, OS X and Android (more information about android here [https://github.com/bbodin/slambench-android](https://github.com/bbodin/slambench-android)).\n\nSLAMBench currently supports the following algorithms:\n\n* ORB-SLAM3 [Campos et al, ARXIV'20]: C++ as distributed by https://github.com/UZ-SLAMLab\n* ReFusion [Palazollo et al. IROS'19]: CUDA as distributed by https://github.com/PRBonn\n* OpenVINS [Geneva et al. IROS'19]: C++ as distributed by https://github.com/rpng/\n* Supereight [Vespa et al. RA-L'18]: C++, OpenMP as distributed by https://github.com/emanuelev\n* BundleFusion [Dai et al. ACM TOG'17]: CUDA as distributed by https://github.com/niessner\n* SemanticFusion [McCormac et al. ICRA'17]: CUDA as distributed by https://github.com/seaun163\n* ORB-SLAM2 [Mur-Artal et al, TOR'15 and TOR'17]: C++ as distributed by https://github.com/raulmur\n* DSO [Engel et al. Arxiv'16]: C++ as distributed by https://github.com/JakobEngel\n* ElasticFusion [Whelan et al, IJRR'16]: CUDA as distributed by https://github.com/mp3guy\n* InfiniTAMv2 [Kahler et al, ISMAR'15]: C++, OpenMP and CUDA versions as distributed by https://github.com/victorprad/\n* KinectFusion [Newcombe et al. ISMAR'11]: C++, OpenMP, OpenCL and CUDA inspired by https://github.com/GerhardR\n* LSDSLAM [Engel et al, ECCV'14]: C++, and threaded as distributed by https://github.com/tum-vision/ and modified by https://github.com/mp3guy\n* MonoSLAM [Davison et al, TPAMI'07]: Original version as distributed by https://github.com/hanmekim/\n* OKVIS [Leutenegger et al, IJRR'15]: Original version as distributed by https://github.com/ethz-asl\n* PTAM [Klein et al, ISMAR'07 and ECCV'08]: Original version as distributed by https://github.com/Oxford-PTAM/\n* SVO [Forster et al, ICRA'14]: Original version as distributed by https://github.com/uzh-rpg/rpg_svo/ (a more recent version available at http://rpg.ifi.uzh.ch/svo2.html)\n\n**IMPORTANT: If you use any of those algorithms in scientific publications, you should refer to the respective publications.**\n\nIn addition, if you use SLAMBench in scientific publications, we would appreciate citations to the following papers:\n```\n\n@inproceedings{bujanca2021robust,  \n  author={Bujanca, Mihai and Shi, Xuesong and Spear, Matthew and Zhao, Pengpeng and Lennox, Barry and Luj{\\'a}n, Mikel},\n  booktitle={2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},\n  title={Robust SLAM Systems: Are We There Yet?},\n  year={2021},\n  doi={10.1109/IROS51168.2021.9636814}\n}\n\n@inproceedings{bujanca2019slambench,\n  title={SLAMBench 3.0: Systematic automated reproducible evaluation of SLAM systems for robot vision challenges and scene understanding},\n  author={Bujanca, Mihai and Gafton, Paul and Saeedi, Sajad and Nisbet, Andy and Bodin, Bruno and O'Boyle, Michael FP and Davison, {Andrew J} and Kelly, {Paul H.J.} and Riley, Graham and Lennox, Barry and Luj{\\'a}n, Mikel and Furber, Steven},\n  booktitle={2019 International Conference on Robotics and Automation (ICRA)},\n  pages={6351--6358},\n  year={2019},\n  organization={IEEE}\n}\n\n@inproceedings{Bodin2018,\nauthor    = \"Bruno Bodin and Harry Wagstaff and Sajad Saeedi and Luigi Nardi and Emanuele Vespa and Mayer, {John H} and Andy Nisbet and Mikel Luj{\\'a}n and Steve Furber and Davison, {Andrew J} and Kelly, {Paul H.J.} and Michael O'Boyle\",\ntitle     = \"SLAMBench2: Multi-Objective Head-to-Head Benchmarking for Visual SLAM\",\nbooktitle = \"{IEEE Intl. Conf. on Robotics and Automation (ICRA)}\",\nyear = {2018},\nmonth = {May}\n}\n\n@inproceedings{Nardi2015,\n  title={Introducing SLAMBench, a performance and accuracy benchmarking methodology for SLAM},\n  author={Nardi, Luigi and Bodin, Bruno and Zia, M Zeeshan and Mawer, John and Nisbet, Andy and Kelly, Paul HJ and Davison, Andrew J and Luj{\\'a}n, Mikel and O'Boyle, Michael FP and Riley, Graham and others},\n  booktitle={2015 IEEE international conference on robotics and automation (ICRA)},\n  pages={5783--5790},\n  year={2015},\n  organization={IEEE}\n}\n```\n\n## How to set up SLAMBench?\n\nAs SLAMBench deals with multiple SLAM algorithms, dependencies might be difficult to install on any systems.\nTo ease the usage of SLAMBench we provide auto-installation of dependencies and recommend the use fresh installation of Ubuntu 18/20 or Fedora 24-29.\n### Dependency installation\n\n#### Required by SLAMBench framework\n* CMake 2.8.11 or higher is required.\n* Make\n* GCC C/C++\n* Boost (Optional)\n* GLUT (Optional)\n\n#### Required by benchmarks and datasets\n* Git\n* Mercurial\n* wget\n* unzip\n* lapack\n* blas\n* findutils\n* cvs\n* glog\n* gflags\n* p7zip\n\n#### To install them\n\nWith Fedora 29: `dnf install -y yaml-cpp-devel gtk2-devel mesa-libEGL-devel vtk-devel cmake make git mercurial wget unzip gcc gcc-c++ lapack blas lapack-devel blas-devel findutils  cvs  glut-devel glew-devel boost-devel glog-devel gflags-devel libXmu-devel p7zip`\n\nWith Fedora 24:\n```dnf install -y gtk2-devel vtk-devel cmake make git mercurial wget unzip gcc gcc-c++ lapack blas lapack-devel blas-devel findutils  cvs  glut-devel glew-devel boost-devel glog-devel gflags-devel libXmu-devel```\n\nWith Ubuntu 20.04:\n``` apt-get -y install libvtk6.3 libvtk6-dev unzip libflann-dev wget mercurial git gcc g++ cmake python-numpy freeglut3 freeglut3-dev libglew-dev libglu1-mesa libglu1-mesa-dev libgl1-mesa-glx libgl1-mesa-dev libxmu-dev libxi-dev  libboost-all-dev cvs libgoogle-glog-dev libatlas-base-dev gfortran  gtk2.0 libgtk2.0-dev  libyaml-dev build-essential libyaml-cpp-dev ```\n\nWith Ubuntu 18.04:\n``` apt-get -y install libvtk6.3 libvtk6-dev unzip libflann-dev wget mercurial git gcc g++ cmake python-numpy freeglut3 freeglut3-dev libglew-dev libglu1-mesa libglu1-mesa-dev libgl1-mesa-glx libgl1-mesa-dev libxmu-dev libxi-dev libboost-all-dev cvs libgoogle-glog-dev libatlas-base-dev gfortran gtk2.0 libgtk2.0-dev  libyaml-dev build-essential libyaml-cpp-dev ```\n\n#### Special requirements for CUDA\n\nTo run the CUDA implementation of some of the algorithms, you will need extra dependencies.\n\nWith Ubuntu: `apt-get -y install nvidia-cuda-toolkit clinfo`\n\nWith Fedora: `yum install cuda`\n\n### Compilation of SLAMBench and its benchmarks\n\n#### 1. Dependencies\n\nInstall dependencies first [NOTE can be installed by the user on its system as well]:\n\n```bash\nmake deps\n```\nThe idea is to maximise the chance of a good build, by selection the best cocktail of libraries.\nThis will download and compile the following applications: Brisk, Ceres, CVD, Eigen3, Flann, FreeImage, G2O, Gvars, OpenCV, OpenGV, OpenTuner, Pangolin, PCL, Suitesparse, TooN.\n\nYou can also install each ofthese individually, using the commands such as: `eigen3`, `flann`, `g2o`, `opencv`, `opengv`, `pcl`, `toon`, `suitesparse`, ...\n\nmore information is available in the `framework/makefiles/README.md` file.\n\n#### 2. SLAMBench Framework\n\nSLAMBench is a framework that can be compiled by simply running:\n\n```bash\nmake slambench\n```\n\nAlthough, by doing this, you only compile the libraries of SLAMBench.\n\n#### 3. Usecases\n\nTo download use-cases, there are specific target named after the type of algorithm you need to test:\n\n```bash\nmake kfusion lsdslam\n```\n\nThen to compile these specific use-case, you will need to specify identifiers together with the slambench target:\n\n```bash\nmake slambench APPS=kfusion,lsdslam\n```\n\nThe current benchmarks identifiers are efusion, infinitam, kfusion, lsdslam, monoslam, okvis, ptam, orbslam2, svo.\nYou will find more information to download and compile use-cases with the `make usecases` command.\n\n#### 4. Datasets\n\nTo test a SLAM algorithm you can use a Live camera, or a dataset. \nSLAMBench provides tools to automatically download some of the most popular datasets, that is ICL-NUIM and TUM RGB-D. \nThe file format (*.slam) will then include all the most important information about the dataset, those are **Camera calibration setting**, **initial position of the sensors**, and the **ground truth**.\n\nAs an example to download and generate the Living Room Trajectory 2 from the ICLNUIM dataset, you can run the following :\n\n```bash\n\u003e make datasets/ICL_NUIM/living_room_traj2_loop.slam\n```\n\nSLAMBench currently supports the following datasets:\n\n* OpenLORIS [Shi et al, ICRA'20]: Lifelong SLAM dataset\n* Bonn Dynamic [Palazollo et al. IROS'19]: Dynamic scene dataset\n* UZH-FPV [Delmerico et al. ICRA'19]: Drone racing dataset\n* ETH Illumination [Park et al, ICRA'17]: Illumination changes dataset\n* VolumeDeform [Innmann et al, ECCV'16]: Non-rigid reconstruction\n* EuRoC MAV [Burri et al, IJRR'16]: Micro Aerial Vehicle dataset\n* ICL-NUIM [Handa et al, ICRA'14]: Synthetic dataset\n* TUM RGB-D [Sturm et al, IROS'12]: A standard SLAM benchmark\nA complete list of the datasets available is provided by the command `make datasets`.\n\n## What algorithms does SLAMBench support?\n\nSLAMBench is already compatible with a wide range of algorithms which are not included in this repository (see [above](#what-is-slambench) for list of algorithms).\n\nHowever you can easily integrate those algorithms using the command:\n\n```bash\nmake usecases\n```\n\nThis command will explain in details how to integrate algorithms that are already compatible with SLAMBench.\n\n## How to run an existing algorithm with SLAMBench?\n\nOnce you have compiled a benchmark, there are several ways to run it.\nFor each implementation of this benchmark, you will find a specific library. \nAs an example, with KinectFusion, after running `make slambench APPS=kfusion`, you may find the following libraries in the `build/lib` directory :\n\n```bash\n\u003e ls build/lib/libkfusion-*-library.so\n\nbuild/lib/libkfusion-cpp-library.so   \nbuild/lib/libkfusion-notoon-library.so      \nbuild/lib/libkfusion-openmp-library.so\nbuild/lib/libkfusion-cuda-library.so  \nbuild/lib/libkfusion-opencl-library.so\n```\n\nWe can see five different implementations (cpp, notoon, and openmp, cuda and opencl). The list of available binaries depends of the dependencies you installed beforehand. For example, you need CUDA to compile the kfusion-cuda. A complete list of the dependencies is available at the end of this README.\n\n### Running a benchmark (e.g. KinectFusion)\n\nTo run one algorithm you will need to use a **loader**. \nThere are three different loaders supported, **benchmark**, **pangolin**, and **lifelong**.\nThe first two loaders are used the same way, except that **benchmark** is a command line application dedicated to measurements, while **pangolin** is a graphical user interface less precise in term of measurement but which provide a good interface for demonstrations. The **lifelong** loader can take multiple input (multiple .slam files following the -i option, separated by ',') which will be sent to the benchmark one by one. Other than that it is similar to the **benchmark** loader. There is currently no loader both supporting loading multiple input and having a graphical user interface.\n\n\nEach loader has a series of parameters to specify such as the dataset location, or the libraries to run. \nThe list of those parameters is available by using the \"--help\" parameters.\n\n```bash\n\u003e ./build/bin/benchmark_loader --help \n== SLAMBench Configuration ==\nAvailable parameters :\n-fl            --frame-limit           : last frame to compute (Default=0)\n-o             --log-file              : Output log file (Default=)\n-i             --input                 : Specify the input file or mode. (Default=)\n-load          --load-library          : Load a specific SLAM library. (Default=)\n-dse           --dse                   : Output solution space of parameters. (Default=false)\n-h             --help                  : Print the help. (Default=false)\n-nf            --negative-focal-length : negative focal length (Default=false)\n-realtime      --realtime-mode         : realtime frame loading mode (Default=false)\n-realtime-mult --realtime-multiplier   : realtime frame loading mode (Default=1)\n-fo            --file-output           : File to write slamfile containing outputs (Default=)\n```\n\n\nThen if you run the loader again, while providing a dataset file `-i dataset.slam`, you will see new parameters dedicated to the dataset: \n\n\n```bash\n\u003e ./build/bin/benchmark_loader -i datasets/ICL_NUIM/living_room_traj2_loop.slam --help\n== SLAMBench Configuration ==\nAvailable parameters :\n....\n-Camera-intrisics --Camera-intrisics       : (Default=nullptr  Current=0.751875,1,0.4992185,0.4989583)\n-Depth-intrisics  --Depth-intrisics        : (Default=nullptr  Current=0.751875,1,0.4992185,0.4989583)\n-Depth-dip        --Depth-disparity-params : (Default=nullptr  Current=0.001,0)\n-Camera-intrisics --Camera-intrisics       : (Default=nullptr  Current=0.751875,1,0.4992185,0.4989583)\n```\n\nFinally is you add a library name `-load libname`, more parameter can be seen: \n\n```bash\n\u003e ./build/bin/benchmark_loader -i datasets/ICL_NUIM/living_room_traj2_loop.slam -load ./build/lib/libkfusion-cpp-library.so  --help\n== SLAMBench Configuration ==\nAvailable parameters :\n\n....\n\n-c                --compute-size-ratio     : Compute ratio (Default=1)\n-r                --integration-rate       : integration-rate  (Default=2)\n-t                --tracking-rate          : tracking-rate     (Default=1)\n-z                --rendering-rate         : rendering-rate    (Default=4)\n-l                --icp-threshold          : icp-threshold     (Default=1e-05)\n-m                --mu                     : mu                (Default=0.1)\n-s                --volume-size            : volume-size       (Default=8,8,8)\n-d                --volume-direction       : volume-direction  (Default=4,4,4)\n-v                --volume-resolution      : volume-resolution (Default=256,256,256)\n-y1               --pyramid-level1         : pyramid-level1    (Default=10)\n-y2               --pyramid-level2         : pyramid-level2    (Default=5)\n-y3               --pyramid-level3         : pyramid-level3    (Default=4)\n```\n\n\nYou can run a loader with **only one dataset** at a time and **it must be specified first**.\n\nIn the next section we will explain how to use SLAMBench to evaluate the performance of a SLAM algorithm.\n\n### Evaluating a benchmark (eg. KinectFusion)\n\nSLAMBench works with Metrics and Outputs elements. \nWhen you run the ```benchmark_loader``` or the ```pangolin_loader``` or the ```lifelong_loader``` these are those elements that you can visualize.\nMetrics are components generated by SLAMBench framework really, while Outputs are generated by the algorithm or may be elements post-processed by SLAMBench (such as the aligned trajectory with the ground truth).\n\nLet us run the benchmark loader. Its output is composed of two main parts, the `Properties` section, and the `Statistics` section. \nthe properties section details all the parameters used for the experiment (could been changed or not via the command line). \nthe statistics section report all the outputs and metrics selection for output in the benchmark loader.\n\n```bash\n\u003e ./build/bin/benchmark_loader -i datasets/ICL_NUIM/living_room_traj2_loop.slam -load ./build/lib/libkfusion-cpp-library.so \n\nSLAMBench Report run started:\t2018-02-02 04:41:31\n\nProperties:\n=================\n\nframe-limit: 0\nlog-file: \ninput: datasets/ICL_NUIM/living_room_traj2_loop.slam\nload-library: ./build/lib/libkfusion-cpp-library.so\ndse: false\nhelp: false\nnegative-focal-length: false\nrealtime-mode: false\nrealtime-multiplier: 1\nfile-output: \nCamera-intrisics: 0.751875,1,0.4992185,0.4989583\nDepth-intrisics: 0.751875,1,0.4992185,0.4989583\nDepth-disparity-params: 0.001,0\nCamera-intrisics: 0.751875,1,0.4992185,0.4989583\ncompute-size-ratio: 1\nintegration-rate: 2\ntracking-rate: 1\nrendering-rate: 4\nicp-threshold: 1e-05\nmu: 0.1\nvolume-size: 8,8,8\nvolume-direction: 4,4,4\nvolume-resolution: 256,256,256\npyramid-level1: 10\npyramid-level2: 5\npyramid-level3: 4\nStatistics:\n=================\n\nFrame Number\tTimestamp\tDuration_Frame\tGPU_Memory\tCPU_Memory\t\tDuration_Preprocessing\tDuration_Tracking\tDuration_Integration\tDuration_Raycasting\tDuration_Render\tX\tY\tZATE_Frame\n1\t0.0000000000\t0.7679200000\t0\t623801799\t\t0.1254800000\t0.0195420000\t0.0561620000\t0.0000030000\t0.5667170000\t4.0000000000\t4.0000000000\t4.0000000000\t0.0000002980\n2\t1.0000000000\t0.2003970000\t0\t623801799\t\t0.1242030000\t0.0156470000\t0.0581670000\t0.0000000000\t0.0023710000\t4.0000000000\t4.0000000000\t4.0000000000\t0.0010031639\n3\t2.0000000000\t0.1989980000\t0\t623801799\t\t0.1233680000\t0.0152360000\t0.0580180000\t0.0000000000\t0.0023690000\t4.0000000000\t4.0000000000\t4.0000000000\t0.0055015362\n4\t3.0000000000\t0.7518580000\t0\t623801799\t\t0.1220660000\t0.0152080000\t0.0563070000\t0.5559520000\t0.0023170000\t4.0000000000\t4.0000000000\t4.0000000000\t0.0036504765\n5\t4.0000000000\t1.3683420000\t0\t623801799\t\t0.1240890000\t0.0767240000\t0.0581630000\t0.5504240000\t0.5589330000\t3.9957129955\t4.0020360947\t4.0009112358\t0.0021276891\n...\n```\n\n## How to add a new benchmark in SLAMBench?\n\nThe main reason to provide a new version of SLAMBench is not only because of the introduction of new benchmarks but also because we provide now \na clear and specific API for SLAM algorithms to be implemented in order to add a new algorithm.\n\n```\nbool sb_new_slam_configuration(SLAMBenchLibraryHelper * slam_settings);\nbool sb_init_slam_system(SLAMBenchLibraryHelper * slam_settings);\nbool sb_update_frame(SLAMBenchLibraryHelper * slam_settings, slambench::io::SLAMFrame * type);\nbool sb_process_once(SLAMBenchLibraryHelper * slam_settings);\nbool sb_relocalize(SLAMBenchLibraryHelper * slam_settings);\nbool sb_update_outputs(SLAMBenchLibraryHelper *lib, const slambench::TimeStamp *latest_output);\nbool sb_clean_slam_system();\nbool sb_update_outputs(SLAMBenchUI *);\n```\n\n**If each of those functions are correctly implemented for a specific implementation of a specific algorithm, then this algorithm is compatible with SLAMBench and can be evaluated as well.**\n\nIn this section we will present those functions one by one.\n\n### bool sb\\_new\\_slam\\_configuration(SLAMBenchLibraryHelper * slam\\_settings)\n\nThis function is called first, and only once, SLAM systems is expected to provide its parameters.\n\nExample :\n\n```cpp\nbool sb_new_slam_configuration(SLAMBenchLibraryHelper * slam_settings)  {\n\tslam_settings-\u003eaddParameter(TypedParameter\u003cfloat\u003e(\"c\", \"confidence\",    \"Confidence\",   \u0026confidence,    \u0026default_confidence));\n\tslam_settings-\u003eaddParameter(TypedParameter\u003cfloat\u003e(\"d\", \"depth\",         \"Depth\",        \u0026depth,         \u0026default_depth));\n\tslam_settings-\u003eaddParameter(TypedParameter\u003cint\u003e  (\"td\", \"textureDim\",   \"textureDim\",   \u0026textureDim,    \u0026default_textureDim));\n\treturn true;\n}\n```\n\nshould always return `true` or an exception will be raised.\n\n\n### bool sb\\_init\\_slam\\_system(SLAMBenchLibraryHelper * slam\\_settings)\n\nThis function is called second, and only once, SLAM systems is expected to allocate memory, retrieve sensor informations.\n\n\nTo retrieve sensor there is `SensorFinder`:\n```cpp\nslambench::io::CameraSensorFinder sensor_finder;\nauto rgb_sensor = sensor_finder.FindOne(slam_settings-\u003eget_sensors(), {{\"camera_type\", \"rgb\"}});\n```\n\nSLAM systems are also expected to define there output, there is one mandatory output, the pose:\n\n```cpp\npose_output = new slambench::outputs::Output(\"Pose\", slambench::values::VT_POSE, true);\nslam_settings-\u003eGetOutputManager().RegisterOutput(pose_output);\n```\nshould always return `true` or an exception will be raised.\n\n### bool sb_update_frame (SLAMBenchLibraryHelper *slam_settings, slambench::io::SLAMFrame *frame)\n\nAlgorithms receive frames ordered by timestamp.\nWhen `sb_update_frame` returns `false`, `sb_update_frame` will be directly called again with the next frame, if it returns `true`, `sb_process_once` will be called once.\n\n### bool sb_process_once (SLAMBenchLibraryHelper *slam_settings)\n\nShould always return `true` or an exception will be raised.\n\n### bool sb_relocalize (SLAMBenchLibraryHelper *slam_settings)\n\nThis is newly introduced to support lifelong SLAM evaluation. It will be called when the input sequence has been switched to the next one. The implementation is expected to explicitly trigger tracking lost and invoke the algorithm's re-localization procedure (if there be). It should return whether the relocalization is sucessful from the algorithm's perspective.\n\nFor backward compatibility, this function is allowed to be unimplemented in a benchmark. In such cases, the ```sb_process_once``` function will be called in a re-localization situation.\n\n### bool sb_clean_slam_system()\n\nThis function is called last, and only once, SLAM systems is expected to clean everything (free memory).\n\n```cpp\nbool sb_clean_slam_system() {\n\tdelete eFusion;\n\tdelete inputRGB;\n\tdelete inputDepth;\n\treturn true;\n}\n```\n\nshould always return `true` or an exception will be raised.\n\n### bool sb_update_outputs(SLAMBenchLibraryHelper *slam_settings, const slambench::TimeStamp *timestamp) \n\nThe algorithm will return visible outputs (Pose, Point cloud, Frames) as defined by the `sb_init_slam_system` function.\n\nExample :\n\n```cpp\nbool sb_update_outputs(SLAMBenchLibraryHelper *lib, const slambench::TimeStamp *ts_p) {\nslambench::TimeStamp ts = *ts_p;\n\nif(pose_output-\u003eIsActive()) {\n\t// Get the current pose as an eigen matrix\n\tEigen::Matrix4f mat = eFusion-\u003egetCurrPose();\n\n\tstd::lock_guard\u003cFastLock\u003e lock (lib-\u003eGetOutputManager().GetLock());\n\tpose_output-\u003eAddPoint(ts, new slambench::values::PoseValue(mat));\n}\n```\n\nshould always return `true` or an exception will be raised.\n\n## Known Issues\n\n### KFusion CUDA version\n\nKFusion CUDA requires GCC 4.9 to work. To specify a new gcc compiler for CUDA only, you can use the `CUDA_HOST_COMPILER` flag as follows :\n\n```bash\nmake slambench APPS=kfusion CUDA_HOST_COMPILER=$(which gcc-4.9)\n```\n\nModern O.S. are now using more recent version of this compiler, this may introduce several compatibility issues.\nTo fix one of them, in the compilation process, when compiling CUDA application we use the ` -D_GLIBCXX_USE_CXX11_ABI=0 ` flag.\n\n## Release History\nVersion 4.0 (Oct 2021)\n- Robustness evaluation\n\nVersion 3.0 (May 2019)\n- Depth estimation \n- Dynamic reconstruction\n- Semantic reconstruction\n\nVersion 2.0 (Feb 2018)\n\n* This release is a complete new version\n\nRelease candidate 1.1 (17 Mar 2015)\n\n* Bugfix : Move bilateralFilterKernel from preprocessing to tracking\n* Bugfix : Wrong interpretation of ICP Threshold parameter.\n* Esthetic : Uniformisation of HalfSampleRobustImage kernel\n* Performance : Change float3 to float4 for the rendering kernels (No effect on OpenCL, but high performance improvement with CUDA)\n* Performance : Add a dedicated buffer for the OpenCL rendering\n* Feature : Add OSX support\n\nRelease candidate 1.0 (12 Nov 2014)\n\n* First public release\n\nCopyright (c) 2014-2021 University of Edinburgh, Imperial College, University of Manchester.\nDeveloped in the PAMELA project, EPSRC Programme Grant EP/K008730/1 and\n\nThe RAIN Hub, funded by the Industrial Strategy Challenge Fund,\npart of the UK government’s modern Industrial Strategy. The fund is\ndelivered by UK Research and Innovation and managed by EPSRC [EP/R026084/1].\n","funding_links":[],"categories":["C++"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpamela-project%2Fslambench","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpamela-project%2Fslambench","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpamela-project%2Fslambench/lists"}