Parameter reference

Every setting in RTAB-Map is a Group/Name string key with a string value, collected in a rtabmap::ParametersMap. The 615 parameters below are declared in Parameters.h; the same keys are used by rtabmap::Rtabmap and rtabmap::Odometry, by the applications, by the --Param Group/Name value command-line arguments of the tools and by the ROS wrappers, so a setting found here applies everywhere.

rtabmap::ParametersMap parameters;
parameters.insert(rtabmap::ParametersPair(rtabmap::Parameters::kMemSTMSize(), "20"));
rtabmap.init(parameters, "map.db");

Each key links to its accessor on rtabmap::Parameters, which is also how the key is spelled in code (Parameters::kMemSTMSize() for Mem/STMSize). Defaults given with a condition depend on how RTAB-Map was built; call rtabmap::Parameters::getDefaultParameters() to read the values of the build in use.

Groups: Rtabmap, Mem, Kp, DbSqlite3, Db, SURF, SIFT, BRIEF, FAST, GFTT, ORB, FREAK, BRISK, KAZE, SuperPoint, SuperPointRpautrat, PyDetector, Bayes, VhEp, RGBD, Optimizer, g2o, GTSAM, Odom, OdomF2M, OdomMono, OdomFovis, OdomViso2, OdomORBSLAM, OdomOKVIS, OdomLOAM, OdomMSCKF, OdomVINSFusion, OdomOpenVINS, OdomOpen3D, OdomCuVSLAM, OdomLIOSAM, Reg, Vis, PyMatcher, GMS, PyDescriptor, Icp, Stereo, StereoBM, StereoSGBM, Grid, GridGlobal, Marker, MarkerAprilTag, MarkerOpenCV, ImuFilter

Rtabmap

Top-level loop closure detection and map management.

Key	Type	Default	Description
Rtabmap/PublishStats	bool	true	Publishing statistics.
Rtabmap/PublishLastSignature	bool	true	Publishing last signature.
Rtabmap/PublishPdf	bool	true	Publishing pdf.
Rtabmap/PublishLikelihood	bool	true	Publishing likelihood.
Rtabmap/PublishRAMUsage	bool	false	Publishing RAM usage in statistics (may add a small overhead to get info from the system).
Rtabmap/ComputeRMSE	bool	true	Compute root mean square error (RMSE) and publish it in statistics, if ground truth is provided.
Rtabmap/SaveWMState	bool	false	Save working memory state after each update in statistics.
Rtabmap/TimeThr	float	0	Maximum time allowed for map update (ms) (0 means infinity). When map update time exceeds this fixed time threshold, some nodes in Working Memory (WM) are transferred to Long-Term Memory to limit the size of the WM and decrease the update time.
Rtabmap/MemoryThr	int	0	Maximum nodes in the Working Memory (0 means infinity). Similar to Rtabmap/TimeThr, when the number of nodes in Working Memory (WM) exceeds this treshold, some nodes are transferred to Long-Term Memory to keep WM size fixed.
Rtabmap/DetectionRate	float	1	Detection rate (Hz). RTAB-Map will filter input images to satisfy this rate.
Rtabmap/ImageBufferSize	unsigned int	1	Data buffer size (0 min inf).
Rtabmap/CreateIntermediateNodes	bool	false	Create intermediate nodes between loop closure detection. Only used when Rtabmap/DetectionRate>0.
Rtabmap/WorkingDirectory	string	""	Working directory.
Rtabmap/MaxRetrieved	unsigned int	2	Maximum nodes retrieved at the same time from LTM.
Rtabmap/MaxRepublished	unsigned int	2	Maximum nodes republished when requesting missing data. When RGBD/Enabled=false, only loop closure data is republished, otherwise the closest nodes from the current localization are republished first. Ignored if Rtabmap/PublishLastSignature=false.
Rtabmap/StatisticLogsBufferedInRAM	bool	true	Statistic logs buffered in RAM instead of written to hard drive after each iteration.
Rtabmap/StatisticLogged	bool	false	Logging enabled.
Rtabmap/StatisticLoggedHeaders	bool	true	Add column header description to log files.
Rtabmap/StartNewMapOnLoopClosure	bool	false	Start a new map only if there is a global loop closure with a previous map.
Rtabmap/StartNewMapOnGoodSignature	bool	false	Start a new map only if the first signature is not bad (i.e., has enough features, see Kp/BadSignRatio).
Rtabmap/ImagesAlreadyRectified	bool	true	Images are already rectified. By default RTAB-Map assumes that received images are rectified. If they are not, they can be rectified by RTAB-Map if this parameter is false.
Rtabmap/RectifyOnlyFeatures	bool	false	If Rtabmap/ImagesAlreadyRectified is false and this parameter is true, the whole RGB image will not be rectified, only the features. Warning: As projection of RGB-D image to point cloud is assuming that images are rectified, the generated point cloud map will have wrong colors if this parameter is true.
Rtabmap/LoopThr	float	0.11	Loop closing threshold.
Rtabmap/LoopRatio	float	0	The loop closure hypothesis must be over LoopRatio x lastHypothesisValue.
Rtabmap/LoopGPS	bool	true	Use GPS to filter likelihood (if GPS is recorded). Only locations inside the local radius RGBD/LocalRadius of the current GPS location are considered for loop closure detection.
Rtabmap/VirtualPlaceLikelihoodRatio	int	0	Likelihood ratio for virtual place (for no loop closure hypothesis): 0=Mean / StdDev, 1=StdDev / (Max-Mean)

Mem

Memory management: what is kept in STM/WM, what is transferred to LTM.

Key	Type	Default	Description
Mem/RehearsalSimilarity	float	0.6	Rehearsal similarity.
Mem/ImageKept	bool	false	Keep raw images in RAM.
Mem/BinDataKept	bool	true	Keep binary data in db.
Mem/RawDescriptorsKept	bool	true	Raw descriptors kept in memory.
Mem/LoadVisualLocalFeaturesOnInit	bool	true	Load all local visual features (keypoints, descriptors and 3D points) in RAM when loading an existing database. This can add significant time to initialize the memory but the features will be already loaded before computing loop closure transforms. If false, the features are loaded on-demand from the database when a loop closure transformation should be estimated.
Mem/MapLabelsAdded	bool	true	Create map labels. The first node of a map will be labeled as "map#" where # is the map ID.
Mem/SaveDepth16Format	bool	false	Save depth image into 16 bits format to reduce memory used. Warning: values over ~65 meters are ignored (maximum 65535 millimeters).
Mem/NotLinkedNodesKept	bool	true	Keep not linked nodes in db (rehearsed nodes and deleted nodes).
Mem/IntermediateNodeDataKept	bool	false	Keep intermediate node data in db.
Mem/ImageCompressionFormat	string	.jpg	RGB image compression format. It should be ".jpg" or ".png".
Mem/DepthCompressionFormat	string	.rvl	Depth image compression format for 16UC1 depth type. It should be ".png" or ".rvl". If depth type is 32FC1, ".png" is used.
Mem/STMSize	unsigned int	10	Short-term memory size.
Mem/IncrementalMemory	bool	true	SLAM mode, otherwise it is Localization mode.
Mem/LocalizationReadOnly	bool	false	In localization mode, open the database in read-only mode (ignored if Mem/IncrementalMemory=true). Currrenty incompatible with memory management (Rtabmap/LoopThr and Rtabmap/MemoryThr cannot be used) and if there are disjoint sessions in working memory. Last localization pose won't be saved back in the database at the end of the session, so the robot will always restart to original last localization pose, unless RGBD/StartAtOrigin is used or an external initial pose is provided on initialization.
Mem/LocalizationDataSaved	bool	false	Save localization data during localization session (when Mem/IncrementalMemory=false). When enabled, the database will then also grow in localization mode. This mode would be used only for debugging purpose.
Mem/ReduceGraph	bool	false	Reduce graph. Merge nodes when loop closures are added (ignoring those with user data). Note that this approach assumes that 100%% of the loop closures accepted are good, so it is highly recommended to enable RGBD/OptimizeMaxError at the same time.
Mem/RecentWmRatio	float	0.2	Ratio of locations after the last loop closure in WM that cannot be transferred.
Mem/TransferSortingByWeightId	bool	false	On transfer, signatures are sorted by weight->ID only (i.e. the oldest of the lowest weighted signatures are transferred first). If false, the signatures are sorted by weight->Age->ID (i.e. the oldest inserted in WM of the lowest weighted signatures are transferred first). Note that retrieval updates the age, not the ID.
Mem/RehearsalIdUpdatedToNewOne	bool	false	On merge, update to new id. When false, no copy. Keep this disable if Rtabmap/CreateIntermediateNodes=true.
Mem/RehearsalWeightIgnoredWhileMoving	bool	false	When the robot is moving, weights are not updated on rehearsal.
Mem/GenerateIds	bool	true	True=Generate location IDs, False=use input image IDs.
Mem/BadSignaturesIgnored	bool	false	Bad signatures are ignored.
Mem/InitWMWithAllNodes	bool	false	Initialize the Working Memory with all nodes in Long-Term Memory. When false, it is initialized with nodes of the previous session.
Mem/DepthAsMask	bool	true	Use depth image as mask when extracting features for vocabulary.
Mem/DepthMaskFloorThr	float	0.0	Filter floor from depth mask below specified threshold (m) before extracting features. 0 means disabled. Ignored if Mem/DepthAsMask is false.
Mem/StereoFromMotion	bool	false	Triangulate features without depth using stereo from motion (odometry). It would be ignored if Mem/DepthAsMask is true and the feature detector used supports masking.
Mem/ImagePreDecimation	unsigned int	1	Decimation of the RGB image before visual feature detection. If depth size is larger than decimated RGB size, depth is decimated to be always at most equal to RGB size. If Mem/DepthAsMask is true and if depth is smaller than decimated RGB, depth may be interpolated to match RGB size for feature detection.
Mem/ImagePostDecimation	unsigned int	1	Decimation of the RGB image before saving it to database. If depth size is larger than decimated RGB size, depth is decimated to be always at most equal to RGB size. Decimation is done from the original image. If set to same value than Mem/ImagePreDecimation, data already decimated is saved (no need to re-decimate the image).
Mem/CompressionParallelized	bool	true	Compression of sensor data is multi-threaded.
Mem/LaserScanDownsampleStepSize	int	1	If > 1, downsample the laser scans when creating a signature.
Mem/LaserScanVoxelSize	float	0.0	If > 0 m, voxel filtering is done on laser scans when creating a signature. If the laser scan had normals, they will be removed. To recompute the normals, make sure to use Mem/LaserScanNormalK or Mem/LaserScanNormalRadius parameters.
Mem/LaserScanNormalK	int	0	If > 0 and laser scans don't have normals, normals will be computed with K search neighbors when creating a signature.
Mem/LaserScanNormalRadius	float	0.0	If > 0 m and laser scans don't have normals, normals will be computed with radius search neighbors when creating a signature.
Mem/UseOdomFeatures	bool	true	Use odometry features instead of regenerating them.
Mem/UseOdomGravity	bool	false	Use odometry instead of IMU orientation to add gravity links to new nodes created. We assume that odometry is already aligned with gravity (e.g., we are using a VIO approach). Gravity constraints are used by graph optimization only if Optimizer/GravitySigma is not zero.
Mem/CovOffDiagIgnored	bool	true	Ignore off diagonal values of the covariance matrix.
Mem/GlobalDescriptorStrategy	int	0	Extract global descriptor from sensor data. 0=disabled, 1=PyDescriptor
Mem/RotateImagesUpsideUp	bool	false	Rotate images so that upside is up if they are not already. This can be useful in case the robots don't have all same camera orientation but are using the same map, so that not rotation-invariant visual features can still be used across the fleet.

Kp

Bag-of-words dictionary used for global loop closure detection.

Key	Type	Default	Description
Kp/NNStrategy	int	1	kNNFlannNaive=0, kNNFlannKdTree=1, kNNFlannLSH=2, kNNBruteForce=3, kNNBruteForceGPU=4
Kp/IncrementalDictionary	bool	true
Kp/IncrementalFlann	bool	true	When using FLANN based strategy, add/remove points to its index without always rebuilding the index (the index is built only when the dictionary increases of the factor Kp/FlannRebalancingFactor in size).
Kp/FlannRebalancingFactor	float	2.0	Factor used when rebuilding the incremental FLANN index (see Kp/IncrementalFlann). Set <=1 to disable.
Kp/ByteToFloat	bool	false	For Kp/NNStrategy=1, binary descriptors are converted to float by converting each byte to float instead of converting each bit to float. When converting bytes instead of bits, less memory is used and search is faster at the cost of slightly less accurate matching.
Kp/MaxDepth	float	0	Filter extracted keypoints by depth (0=inf).
Kp/MinDepth	float	0	Filter extracted keypoints by depth.
Kp/MaxFeatures	int	500	Maximum features extracted from the images (0 means not bounded, <0 means no extraction).
Kp/SSC	bool	false	If true, SSC (Suppression via Square Covering) is applied to limit keypoints.
Kp/BadSignRatio	float	0.5	Bad signature ratio. If Kp/MaxFeatures=0, the ratio is computed from the average number of words per signature (less than Ratio x AverageWordsPerImage = bad).
Kp/NndrRatio	float	0.8	NNDR ratio (A matching pair is detected, if its distance is closer than X times the distance of the second nearest neighbor.)
Kp/DetectorStrategy	int	8 with CV_MAJOR_VERSION &gt; 2 && !defined(HAVE_OPENCV_XFEATURES2D) 6 otherwise	0=SURF 1=SIFT 2=ORB 3=FAST/FREAK 4=FAST/BRIEF 5=GFTT/FREAK 6=GFTT/BRIEF 7=BRISK 8=GFTT/ORB 9=KAZE 10=ORB-OCTREE 11=SuperPoint 12=SURF/FREAK 13=GFTT/DAISY 14=SURF/DAISY 15=PyDetector 16=SuperPoint-Rpautrat
Kp/TfIdfLikelihoodUsed	bool	true	Use of the td-idf strategy to compute the likelihood.
Kp/Parallelized	bool	true	If the dictionary update and signature creation were parallelized.
Kp/RoiRatios	string	0.0 0.0 0.0 0.0	Region of interest ratios [left, right, top, bottom].
Kp/DictionaryPath	string	""	Path of the pre-computed dictionary
Kp/NewWordsComparedTogether	bool	true	When adding new words to dictionary, they are compared also with each other (to detect same words in the same signature).
Kp/FlannIndexSaved	bool	false	Save FLANN index during localization session (when Mem/IncrementalMemory=false). The FLANN index will be saved to database after the first time localization mode is used, then on next sessions, the index is reloaded from the database instead of being rebuilt again. This can save significant loading time when the visual word dictionary is big (>1M words). Note that if the dictionary is modified (parameters or data), the index will be rebuilt and saved again on the next session. Ignored on initialization if Mem/InitWMWithAllNodes is enabled.
Kp/SerializeWithChecksum	bool	true	On serialization of the FLANN index, compute checksum of the data used by the FLANN index. This adds a slight overhead on serialization/deserialization to make sure that the dictionary data correspond to same data used when the index was built.
Kp/SubPixWinSize	int	3	See cv::cornerSubPix().
Kp/SubPixIterations	int	0	See cv::cornerSubPix(). 0 disables sub pixel refining.
Kp/SubPixEps	double	0.02	See cv::cornerSubPix().
Kp/GridRows	int	1	Number of rows of the grid used to extract uniformly "@ref param_KpMaxFeatures "Kp/MaxFeatures" / grid cells" features from each cell.
Kp/GridCols	int	1	Number of columns of the grid used to extract uniformly "@ref param_KpMaxFeatures "Kp/MaxFeatures" / grid cells" features from each cell.

DbSqlite3

Key	Type	Default	Description
DbSqlite3/InMemory	bool	false	Using database in the memory instead of a file on the hard disk.
DbSqlite3/CacheSize	unsigned int	10000	PRAGMA cache_size: number of database pages kept in SQLite's page cache (approx. cacheSize * page_size bytes, often ~4 KiB per page). Larger values reduce disk I/O when the working set fits in RAM. SQLite built-in default is typically 2000 pages.
DbSqlite3/JournalMode	int	3	PRAGMA journal_mode: rollback journal storage. See sqlite.org/pragma.html::pragma_journal_mode for more details. 0=DELETE (SQLite default): journal file deleted after each commit. 1=TRUNCATE: journal truncated to zero length. 2=PERSIST: journal file kept, header zeroed after commit. 3=MEMORY: journal in RAM only; faster, weaker crash safety. 4=OFF: no journal; fastest, risk of corruption on crash.
DbSqlite3/Synchronous	int	0	PRAGMA synchronous: how aggressively SQLite syncs the database to disk. See sqlite.org/pragma.html::pragma_synchronous for more details. 0=OFF: no wait for persistent storage; fastest, corruption possible on power loss. 1=NORMAL: sync at critical moments (common SQLite default with WAL). 2=FULL (SQLite safest default): sync after every commit; slowest.
DbSqlite3/TempStore	int	2	PRAGMA temp_store: where SQLite stores temporary tables and indices. See sqlite.org/pragma.html::pragma_temp_store for more details. 0=DEFAULT: SQLite compile-time default (often on-disk temp files). 1=FILE: temporary files in the system temp directory. 2=MEMORY: temporary data in RAM when possible.

Db

Database (long-term memory) storage.

Key	Type	Default	Description
Db/TargetVersion	string	""	Target database version for backward compatibility purpose. Only Major and minor versions are used and should be set (e.g., 0.19 vs 0.20 or 1.0 vs 2.0). Patch version is ignored (e.g., 0.20.1 and 0.20.3 will generate a 0.20 database).

SURF

Key	Type	Default	Description
SURF/Extended	bool	false	Extended descriptor flag (true - use extended 128-element descriptors; false - use 64-element descriptors).
SURF/HessianThreshold	float	500	Threshold for hessian keypoint detector used in SURF.
SURF/Octaves	int	4	Number of pyramid octaves the keypoint detector will use.
SURF/OctaveLayers	int	2	Number of octave layers within each octave.
SURF/Upright	bool	false	Up-right or rotated features flag (true - do not compute orientation of features; false - compute orientation).
SURF/GpuVersion	bool	false	GPU-SURF: Use GPU version of SURF. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.
SURF/GpuKeypointsRatio	float	0.01	Used with SURF GPU.

SIFT

Key	Type	Default	Description
SIFT/NOctaveLayers	int	3	The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution. Not used by CudaSift, the number of octaves is still computed automatically.
SIFT/ContrastThreshold	double	0.04	The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector. Not used by CudaSift (see SIFT/GaussianThreshold instead).
SIFT/EdgeThreshold	double	10	The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).
SIFT/Sigma	double	1.6	The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.
SIFT/PreciseUpscale	bool	false	Whether to enable precise upscaling in the scale pyramid (OpenCV >= 4.8).
SIFT/RootSIFT	bool	false	Apply RootSIFT normalization of the descriptors.
SIFT/Gpu	bool	false	CudaSift: Use GPU version of SIFT. This option is enabled only if RTAB-Map is built with CudaSift dependency and GPUs are detected.
SIFT/GaussianThreshold	float	2.0	CudaSift: Threshold on difference of Gaussians for feature pruning. The higher the threshold, the less features with low response/hessian are produced by the detector.
SIFT/MaxGaussianThreshold	float	0.0	CudaSift: Maximum threshold on difference of Gaussians for feature pruning (ignored if smaller or equal than SIFT/GaussianThreshold). The lower the threshold, the less features with high response/hessian are produced by the detector.
SIFT/Upscale	bool	false	CudaSift: Whether to enable upscaling.

BRIEF

Key	Type	Default	Description
BRIEF/Bytes	int	32	Bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.

FAST

Key	Type	Default	Description
FAST/Threshold	int	20	Threshold on difference between intensity of the central pixel and pixels of a circle around this pixel.
FAST/NonmaxSuppression	bool	true	If true, non-maximum suppression is applied to detected corners (keypoints).
FAST/Gpu	bool	false	GPU-FAST: Use GPU version of FAST. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.
FAST/GpuKeypointsRatio	double	0.05	Used with FAST GPU.
FAST/MinThreshold	int	7	Minimum threshold. Used only when FAST/GridRows and FAST/GridCols are set.
FAST/MaxThreshold	int	200	Maximum threshold. Used only when FAST/GridRows and FAST/GridCols are set.
FAST/GridRows	int	0	Grid rows (0 to disable). Adapts the detector to partition the source image into a grid and detect points in each cell.
FAST/GridCols	int	0	Grid cols (0 to disable). Adapts the detector to partition the source image into a grid and detect points in each cell.
FAST/CV	int	0	Enable FastCV implementation if non-zero (and RTAB-Map is built with FastCV support). Values should be 9 and 10.

GFTT

Key	Type	Default	Description
GFTT/QualityLevel	double	0.001
GFTT/MinDistance	double	7
GFTT/BlockSize	int	3
GFTT/UseHarrisDetector	bool	false
GFTT/K	double	0.04
GFTT/Gpu	bool	false	GPU-GFTT: Use GPU version of GFTT. This option is enabled only if OpenCV>=3 is built with CUDA and GPUs are detected.

ORB

Key	Type	Default	Description
ORB/ScaleFactor	float	2	Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor will mean that to cover certain scale range you will need more pyramid levels and so the speed will suffer.
ORB/NLevels	int	3	The number of pyramid levels. The smallest level will have linear size equal to input_image_linear_size/pow(scaleFactor, nlevels).
ORB/EdgeThreshold	int	19	This is size of the border where the features are not detected. It should roughly match the patchSize parameter.
ORB/FirstLevel	int	0	It should be 0 in the current implementation.
ORB/WTA_K	int	2	The number of points that produce each element of the oriented BRIEF descriptor. The default value 2 means the BRIEF where we take a random point pair and compare their brightnesses, so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3 random points (of course, those point coordinates are random, but they are generated from the pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such output will occupy 2 bits, and therefore it will need a special variant of Hamming distance, denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).
ORB/ScoreType	int	0	The default HARRIS_SCORE=0 means that Harris algorithm is used to rank features (the score is written to KeyPoint::score and is used to retain best nfeatures features); FAST_SCORE=1 is alternative value of the parameter that produces slightly less stable keypoints, but it is a little faster to compute.
ORB/PatchSize	int	31	size of the patch used by the oriented BRIEF descriptor. Of course, on smaller pyramid layers the perceived image area covered by a feature will be larger.
ORB/Gpu	bool	false	GPU-ORB: Use GPU version of ORB. This option is enabled only if OpenCV is built with CUDA and GPUs are detected.

FREAK

Key	Type	Default	Description
FREAK/OrientationNormalized	bool	true	Enable orientation normalization.
FREAK/ScaleNormalized	bool	true	Enable scale normalization.
FREAK/PatternScale	float	22	Scaling of the description pattern.
FREAK/NOctaves	int	4	Number of octaves covered by the detected keypoints.

BRISK

Key	Type	Default	Description
BRISK/Thresh	int	30	FAST/AGAST detection threshold score.
BRISK/Octaves	int	3	Detection octaves. Use 0 to do single scale.
BRISK/PatternScale	float	1	Apply this scale to the pattern used for sampling the neighbourhood of a keypoint.

KAZE

Key	Type	Default	Description
KAZE/Extended	bool	false	Set to enable extraction of extended (128-byte) descriptor.
KAZE/Upright	bool	false	Set to enable use of upright descriptors (non rotation-invariant).
KAZE/Threshold	float	0.001	Detector response threshold to accept keypoint.
KAZE/NOctaves	int	4	Maximum octave evolution of the image.
KAZE/NOctaveLayers	int	4	Default number of sublevels per scale level.
KAZE/Diffusivity	int	1	Diffusivity type: 0=DIFF_PM_G1, 1=DIFF_PM_G2, 2=DIFF_WEICKERT or 3=DIFF_CHARBONNIER.

SuperPoint

Key	Type	Default	Description
SuperPoint/ModelPath	string	""	[Required] Path to pre-trained weights Torch file of SuperPoint (*.pt).
SuperPoint/Threshold	float	0.010	Detector response threshold to accept keypoint.
SuperPoint/NMS	bool	true	If true, non-maximum suppression is applied to detected keypoints.
SuperPoint/NMSRadius	int	4	[SuperPoint/NMS=true] Minimum distance (pixels) between keypoints.
SuperPoint/Cuda	bool	true	Use Cuda device for Torch, otherwise CPU device is used by default.

SuperPointRpautrat

Key	Type	Default	Description
SuperPointRpautrat/WeightsPath	string	""	[Required] SuperPoint weights file (*.pth).
SuperPointRpautrat/ModelPath	string	""	[Required] SuperPoint python model file (superpoint_pytorch.py).
SuperPointRpautrat/Threshold	float	0.005	Detector response threshold to accept keypoint.
SuperPointRpautrat/NMS	bool	true	If true, non-maximum suppression is applied to detected keypoints.
SuperPointRpautrat/NMSRadius	int	4	[SuperPointRpautrat/NMS=true] Minimum distance (pixels) between keypoints.
SuperPointRpautrat/Cuda	bool	true	Use Cuda device for Torch, otherwise CPU device is used by default.

PyDetector

Key	Type	Default	Description
PyDetector/Path	string	""	Path to python script file (see available ones in rtabmap/corelib/src/python/*). See the header to see where the script should be copied.
PyDetector/Cuda	bool	true	Use cuda.

Bayes

Bayes filter used for loop closure hypotheses.

Key	Type	Default	Description
Bayes/VirtualPlacePriorThr	float	0.9	Virtual place prior. Considering that we are at a new place, this is the prior probability to move again to a new place (unvisited location). The prior probability to move to a previously visited location is 1 - VirtualPlacePriorThr (split equally against all previously visited locations).
Bayes/PredictionLC	string	0.1 0.36 0.30 0.16 0.062 0.0151 0.00255 0.000324 2.5e-05 1.3e-06 4.8e-08 1.2e-09 1.9e-11 2.2e-13 1.7e-15 8.5e-18 2.9e-20 6.9e-23	Prediction of loop closures (Gaussian-like, here with sigma=1.6) - Format: {VirtualPlaceProb, LoopClosureProb, NeighborLvl1, NeighborLvl2, ...}. Considering we are at a previously visited location, the first value is the probability to move to a new place (unvisited location), the second value is the probability to stay at the same location, the third value is the probability to move to a neighbor or loop closure at the first depth level, the fourth value is the probability to move to a neighbor or loop closure at the second depth level, etc. If the sum of the values is not 1, the difference is normalized against all remaining visited locations. Normally, the sum of these values should be 1.
Bayes/FullPredictionUpdate	bool	false	Regenerate all the prediction matrix on each iteration (otherwise only removed/added ids are updated).

VhEp

Key	Type	Default	Description
VhEp/Enabled	bool	false	Verify visual loop closure hypothesis by computing a fundamental matrix. This is done prior to transformation computation when RGBD/Enabled is enabled.
VhEp/MatchCountMin	int	8	Minimum of matching visual words pairs to accept the loop hypothesis.
VhEp/RansacParam1	float	3	Fundamental matrix (see cvFindFundamentalMat()): Max distance (in pixels) from the epipolar line for a point to be inlier.
VhEp/RansacParam2	float	0.99	Fundamental matrix (see cvFindFundamentalMat()): Performance of RANSAC.

RGBD

Metric SLAM: graph, proximity detection and localization.

Key	Type	Default	Description
RGBD/Enabled	bool	true	Activate metric SLAM. If set to false, classic RTAB-Map loop closure detection is done using only images and without any metric information.
RGBD/LinearUpdate	float	0.1	Minimum linear displacement (m) to update the map. Rehearsal is done prior to this, so weights are still updated. To update the map when not moving, both RGBD/LinearUpdate and RGBD/AngularUpdate should be set to 0.
RGBD/AngularUpdate	float	0.1	Minimum angular displacement (rad) to update the map. Rehearsal is done prior to this, so weights are still updated. To update the map when not moving, both RGBD/LinearUpdate and RGBD/AngularUpdate should be set to 0.
RGBD/LinearSpeedUpdate	float	0.0	Maximum linear speed (m/s) to update the map (0 means not limit).
RGBD/AngularSpeedUpdate	float	0.0	Maximum angular speed (rad/s) to update the map (0 means not limit).
RGBD/AggressiveLoopThr	float	0.05	Loop closure threshold used (overriding Rtabmap/LoopThr) when a new mapping session is not yet linked to a map of the highest loop closure hypothesis. In localization mode, this threshold is used when there are no loop closure constraints with any map in the cache (RGBD/MaxOdomCacheSize). In all cases, the goal is to aggressively loop on a previous map in the database. Only used when RGBD/Enabled is enabled. Set 1 to disable.
RGBD/NewMapOdomChangeDistance	float	0	A new map is created if a change of odometry translation greater than X m is detected (0 m = disabled).
RGBD/OptimizeFromGraphEnd	bool	false	Optimize graph from the newest node. If false, the graph is optimized from the oldest node of the current graph (this adds an overhead computation to detect to oldest node of the current graph, but it can be useful to preserve the map referential from the oldest node). Warning when set to false: when some nodes are transferred, the first referential of the local map may change, resulting in momentary changes in robot/map position (which are annoying in teleoperation).
RGBD/OptimizeMaxError	float	3.0	Reject loop closures if optimization error ratio is greater than this value (0=disabled). Ratio is computed as absolute error over standard deviation of each link. This will help to detect when a wrong loop closure is added to the graph. If used with Optimizer/Robust, the disabled loop closure links will be removed.
RGBD/OptimizeMaxErrorRepairRadius	float	0.0	If two consecutive loop closures are rejected by RGBD/OptimizeMaxError on the same old loop closure link, we will remove that old link, and other old links under that radius if necessary, until optimization is accepted. When optimization is accepted, the old loop closure links are removed from the graph. This feature is useful to reject bad loop closures that were accepted previously. Set to 0 to disable this feature.
RGBD/MaxLoopClosureDistance	float	0.0	Reject loop closures/localizations if the distance from the map is over this distance (0=disabled).
RGBD/ForceOdom3DoF	bool	true	Force odometry pose to be 3DoF if Reg/Force3DoF=true.
RGBD/StartAtOrigin	bool	false	If true, rtabmap will assume the robot is starting from origin of the map. If false, rtabmap will assume the robot is restarting from the last saved localization pose from previous session (the place where it shut down previously). Used only in localization mode (Mem/IncrementalMemory=false).
RGBD/GoalReachedRadius	float	0.5	Goal reached radius (m).
RGBD/PlanStuckIterations	int	0	Mark the current goal node on the path as unreachable if it is not updated after X iterations (0=disabled). If all upcoming nodes on the path are unreachabled, the plan fails.
RGBD/PlanLinearVelocity	float	0	Linear velocity (m/sec) used to compute path weights.
RGBD/PlanAngularVelocity	float	0	Angular velocity (rad/sec) used to compute path weights.
RGBD/GoalsSavedInUserData	bool	false	When a goal is received and processed with success, it is saved in user data of the location with this format: "GOAL:#".
RGBD/MaxLocalRetrieved	unsigned int	2	Maximum local locations retrieved (0=disabled) near the current pose in the local map or on the current planned path (those on the planned path have priority).
RGBD/LocalRadius	float	10	Local radius (m) for nodes selection in the local map. This parameter is used in some approaches about the local map management.
RGBD/LocalImmunizationRatio	float	0.25	Ratio of working memory for which local nodes are immunized from transfer.
RGBD/ScanMatchingIdsSavedInLinks	bool	true	Save scan matching IDs from one-to-many proximity detection in link's user data.
RGBD/NeighborLinkRefining	bool	false	When a new node is added to the graph, the transformation of its neighbor link to the previous node is refined using registration approach selected (Reg/Strategy).
RGBD/LoopClosureIdentityGuess	bool	false	Use Identity matrix as guess when computing loop closure transform, otherwise no guess is used, thus assuming that registration strategy selected (Reg/Strategy) can deal with transformation estimation without guess.
RGBD/LoopClosureReextractFeatures	bool	false	Extract features even if there are some already in the nodes. Raw features are not saved in database.
RGBD/LocalBundleOnLoopClosure	bool	false	Do local bundle adjustment with neighborhood of the loop closure.
RGBD/InvertedReg	bool	false	On loop closure, do registration from the target to reference instead of reference to target.
RGBD/CreateOccupancyGrid	bool	false	Create local occupancy grid maps. See "Grid" group for parameters.
RGBD/MarkerDetection	bool	false	Detect static markers to be added as landmarks for graph optimization. If input data have already landmarks, this will be ignored. See "Marker" group for parameters.
RGBD/LoopCovLimited	bool	false	Limit covariance of non-neighbor links to minimum covariance of neighbor links. In other words, if covariance of a loop closure link is smaller than the minimum covariance of odometry links, its covariance is set to minimum covariance of odometry links.
RGBD/MaxOdomCacheSize	int	10	Maximum odometry cache size. Used only in localization mode (when Mem/IncrementalMemory=false). This is used to get smoother localizations and to verify localization transforms (when RGBD/OptimizeMaxError!=0) to make sure we don't teleport to a location very similar to one we previously localized on. Set 0 to disable caching.
RGBD/LocalizationSmoothing	bool	true	Adjust localization constraints based on optimized odometry cache poses (when RGBD/MaxOdomCacheSize>0).
RGBD/LocalizationPriorError	double	0.001	The corresponding variance (error x error) set to priors of the map's poses during localization (when RGBD/MaxOdomCacheSize>0).
RGBD/LocalizationSecondTryWithoutProximityLinks	bool	true	When localization is rejected by graph optimization validation, try a second time without proximity links if landmark or loop closure links are also present in odometry cache (see RGBD/MaxOdomCacheSize). If it succeeds, the proximity links are removed. This assumes that global loop closure and landmark links are more accurate than proximity links.
RGBD/ProximityByTime	bool	false	Detection over all locations in STM.
RGBD/ProximityBySpace	bool	true	Detection over locations (in Working Memory) near in space.
RGBD/ProximityMaxGraphDepth	int	50	Maximum depth from the current/last loop closure location and the local loop closure hypotheses. Set 0 to ignore.
RGBD/ProximityMaxPaths	int	3	Maximum paths compared (from the most recent) for proximity detection. 0 means no limit.
RGBD/ProximityPathFilteringRadius	float	1	Path filtering radius to reduce the number of nodes to compare in a path in one-to-many proximity detection. The nearest node in a path should be inside that radius to be considered for one-to-one proximity detection.
RGBD/ProximityPathMaxNeighbors	int	0	Maximum neighbor nodes compared on each path for one-to-many proximity detection. Set to 0 to disable one-to-many proximity detection (by merging the laser scans).
RGBD/ProximityPathRawPosesUsed	bool	true	When comparing to a local path for one-to-many proximity detection, merge the scans using the odometry poses (with neighbor link optimizations) instead of the ones in the optimized local graph.
RGBD/ProximityAngle	float	45	Maximum angle (degrees) for one-to-one proximity detection.
RGBD/ProximityOdomGuess	bool	false	Use odometry as motion guess for one-to-one proximity detection.
RGBD/ProximityGlobalScanMap	bool	false	Create a global assembled map from laser scans for one-to-many proximity detection, replacing the original one-to-many proximity detection (i.e., detection against local paths). Only used in localization mode (Mem/IncrementalMemory=false), otherwise original one-to-many proximity detection is done. Note also that if graph is modified (i.e., memory management is enabled or robot jumps from one disjoint session to another in same database), the global scan map is cleared and one-to-many proximity detection is reverted to original approach.
RGBD/ProximityMergedScanCovFactor	double	100.0	Covariance factor for one-to-many proximity detection (when RGBD/ProximityPathMaxNeighbors>0 and scans are used).

Optimizer

Graph optimization back-end.

Key	Type	Default	Description
Optimizer/Strategy	int	2 with defined(RTABMAP_GTSAM) 1 with defined(RTABMAP_G2O) 3 with defined(RTABMAP_CERES) 0 otherwise	Graph optimization strategy: 0=TORO, 1=g2o, 2=GTSAM and 3=Ceres.
Optimizer/Iterations	int	20 with defined(RTABMAP_GTSAM) or defined(RTABMAP_G2O) or defined(RTABMAP_CERES) 100 otherwise	Optimization iterations.
Optimizer/Epsilon	double	0.00001 with defined(RTABMAP_GTSAM) 0.0 with defined(RTABMAP_G2O) 0.000001 with defined(RTABMAP_CERES) 0.00001 otherwise	Stop optimizing when the error improvement is less than this value.
Optimizer/VarianceIgnored	bool	false	Ignore constraints' variance. If checked, identity information matrix is used for each constraint. Otherwise, an information matrix is generated from the variance saved in the links.
Optimizer/Robust	bool	false	Robust graph optimization using Vertigo (only work for g2o and GTSAM optimization strategies).
Optimizer/PriorsIgnored	bool	true	Ignore prior constraints (global pose or GPS) while optimizing. Currently only g2o and gtsam optimization supports this.
Optimizer/LandmarksIgnored	bool	false	Ignore landmark constraints while optimizing. Currently only g2o and gtsam optimization supports this.
Optimizer/GravitySigma	float	0.3 with defined(RTABMAP_G2O) \|\| defined(RTABMAP_GTSAM) 0.0 otherwise	Gravity sigma value (>=0, typically between 0.1 and 0.3). Optimization is done while preserving gravity orientation of the poses. This should be used only with visual/lidar inertial odometry approaches, for which we assume that all odometry poses are aligned with gravity. Set to 0 to disable gravity constraints. Currently supported only with g2o and GTSAM optimization strategies (see Optimizer/Strategy).
Optimizer/Baseline	double	0.075	When doing bundle adjustment with RGB-D data (mono camera + depth), set a fake baseline (m) so the BA backend treats depth as stereo disparity. Applies to all BA-capable backends (g2o, GTSAM, Ceres). Set to 0 to keep the problem mono (depth observations are ignored). For real stereo data the baseline in the calibration (Tx) is used directly.
Optimizer/PixelVariance	double	1.0	Pixel variance used on the u/v axes of every bundle adjustment reprojection edge. Applies to all BA-capable backends (g2o, GTSAM, Ceres). Should approximate the squared 1-sigma keypoint localization error in pixels. Set higher (e.g. 4-9) if features are noisy (low texture, motion blur, low light, or large detector scale). Set lower (e.g. 0.01-0.1) if features are sub-pixel refined (Lucas-Kanade tracking, parabolic peak interpolation). Intuition: the lower the pixel variance, the more the optimizer trusts the keypoint positions.
Optimizer/DisparityVariance	double	1.0	Disparity variance used on the disparity axis (u - u_right) of stereo / RGB-D bundle adjustment edges. Applies to all BA-capable backends (g2o, GTSAM, Ceres). Defaults to the same value as PixelVariance for backward compatibility. Set higher (e.g. 2-4) if your depth source is noisier than your feature detector's u/v precision (typical for stereo block matchers / SGM at long range). Set lower (e.g. 0.01-0.1) if your depth source is more accurate than the u/v detector (typical for ToF / LiDAR-fused depth where range is measured directly rather than triangulated). Intuition: the lower the disparity variance, the more the optimizer trusts the depth measurements. Geometric note: wider baseline and/or higher image resolution improve a block matcher's effective disparity precision (larger disparity magnitudes and finer sub-pixel refinement), so wide-baseline high-resolution stereo pairs can usually afford a lower disparity variance (e.g. 0.1-0.5); narrow-baseline low-resolution pairs should keep it higher (e.g. 1-4).
Optimizer/RobustKernelDelta	double	8	Robust kernel delta used for bundle adjustment (0 means don't use robust kernel). Applies to all BA-capable backends (g2o, GTSAM, Ceres). Observations with chi2 over this threshold will be ignored in the second optimization pass.

g2o

Key	Type	Default	Description
g2o/Solver	int	3 with defined(RTABMAP_ORB_SLAM) 0 otherwise	0=csparse 1=pcg 2=cholmod 3=Eigen
g2o/Optimizer	int	0	0=Levenberg 1=GaussNewton

GTSAM

Key	Type	Default	Description
GTSAM/Optimizer	int	1	0=Levenberg 1=GaussNewton 2=Dogleg
GTSAM/Incremental	bool	false	Do graph optimization incrementally (iSAM2) to increase optimization speed on loop closures. Note that only GaussNewton and Dogleg optimization algorithms are supported (GTSAM/Optimizer) in this mode.
GTSAM/IncRelinearizeThreshold	double	0.01	Only relinearize variables whose linear delta magnitude is greater than this threshold. See GTSAM::ISAM2 doc for more info.
GTSAM/IncRelinearizeSkip	int	1	Only relinearize any variables every X calls to ISAM2::update(). See GTSAM::ISAM2 doc for more info.

Odom

Odometry front-end shared settings.

Key	Type	Default	Description
Odom/Strategy	int	0	0=Frame-to-Map (F2M) 1=Frame-to-Frame (F2F) 2=Fovis 3=viso2 4=DVO-SLAM 5=ORB_SLAM 6=OKVIS 7=LOAM 8=MSCKF_VIO 9=VINS-Fusion 10=OpenVINS 11=FLOAM 12=Open3D 13=cuVSLAM 14=LIO-SAM
Odom/ResetCountdown	int	0	Automatically reset odometry after X consecutive images where odometry cannot be computed (a value of 0 disables auto-reset). When a reset occurs, odometry resumes from the last successfully computed pose with large covariance to trigger a new map. If external odometry is used, it will also be reset based on the motion estimated relative to the last computed pose but no large covariance will be received, so that a new map won't be triggered.
Odom/Holonomic	bool	true	If the robot is holonomic (strafing commands can be issued). If not, y value will be estimated from x and yaw values (y=x*tan(yaw)).
Odom/FillInfoData	bool	true	Fill info with data (inliers/outliers features).
Odom/ImageBufferSize	unsigned int	1	Data buffer size (0 min inf).
Odom/FilteringStrategy	int	0	0=No filtering 1=Kalman filtering 2=Particle filtering. This filter is used to smooth the odometry output.
Odom/ParticleSize	unsigned int	400	Number of particles of the filter.
Odom/ParticleNoiseT	float	0.002	Noise (m) of translation components (x,y,z).
Odom/ParticleLambdaT	float	100	Lambda of translation components (x,y,z).
Odom/ParticleNoiseR	float	0.002	Noise (rad) of rotational components (roll,pitch,yaw).
Odom/ParticleLambdaR	float	100	Lambda of rotational components (roll,pitch,yaw).
Odom/KalmanProcessNoise	float	0.001	Process noise covariance value.
Odom/KalmanMeasurementNoise	float	0.01	Process measurement covariance value.
Odom/GuessMotion	bool	true	Guess next transformation from the last motion computed.
Odom/GuessSmoothingDelay	float	0	Guess smoothing delay (s). Estimated velocity is averaged based on last transforms up to this maximum delay. This can help to get smoother velocity prediction. Last velocity computed is used directly if Odom/FilteringStrategy is set or the delay is below the odometry rate.
Odom/KeyFrameThr	float	0.3	[Visual] Create a new keyframe when the number of inliers drops under this ratio of features in last frame. Setting the value to 0 means that a keyframe is created for each processed frame.
Odom/VisKeyFrameThr	int	150	[Visual] Create a new keyframe when the number of inliers drops under this threshold. Setting the value to 0 means that a keyframe is created for each processed frame.
Odom/ScanKeyFrameThr	float	0.9	[Geometry] Create a new keyframe when the number of ICP inliers drops under this ratio of points in last frame's scan. Setting the value to 0 means that a keyframe is created for each processed frame.
Odom/ImageDecimation	unsigned int	1	Decimation of the RGB image before registration. If depth size is larger than decimated RGB size, depth is decimated to be always at most equal to RGB size. If Vis/DepthAsMask is true and if depth is smaller than decimated RGB, depth may be interpolated to match RGB size for feature detection.
Odom/AlignWithGround	bool	false	Align odometry with the ground on initialization.
Odom/Deskewing	bool	true	Lidar deskewing. If input lidar has time channel, it will be deskewed with a constant motion model (with IMU orientation and/or guess if provided).

OdomF2M

Key	Type	Default	Description
OdomF2M/MaxSize	int	2000	[Visual] Local map size: If > 0 (example 5000), the odometry will maintain a local map of X maximum words.
OdomF2M/MaxNewFeatures	int	0	[Visual] Maximum features (sorted by keypoint response) added to local map from a new key-frame. 0 means no limit.
OdomF2M/InitDepthFactor	float	0.05	[Visual] Depth factor used to initialize depth of features without depth. Depth = Factor * fx.
OdomF2M/FloorThreshold	float	0.0	[Visual] Only track features in 3D feature map that are over this threshold (height in base frame). Can be useful to ignore reflections on the floor. 0 means disabled.
OdomF2M/ScanMaxSize	int	2000	[Geometry] Maximum local scan map size.
OdomF2M/ScanSubtractRadius	float	0.05	[Geometry] Radius used to filter points of a new added scan to local map. This could match the voxel size of the scans.
OdomF2M/ScanSubtractAngle	float	45	[Geometry] Max angle (degrees) used to filter points of a new added scan to local map (when OdomF2M/ScanSubtractRadius>0). 0 means any angle.
OdomF2M/ScanRange	float	0	[Geometry] Distance Range used to filter points of local map (when > 0). 0 means local map is updated using time and not range.
OdomF2M/ValidDepthRatio	float	0.75	If a new frame has points without valid depth, they are added to local feature map only if points with valid depth on total points is over this ratio. Setting to 1 means no points without valid depth are added to local feature map.
OdomF2M/BundleAdjustment	int	1 with defined(RTABMAP_G2O) \|\| defined(RTABMAP_ORB_SLAM) 0 otherwise	Local bundle adjustment. Value matches the Optimizer/Strategy parameter: 0=disabled (TORO is not BA-capable), 1=g2o, 2=GTSAM, 3=Ceres, 4=cvsba.
OdomF2M/BundleAdjustmentMaxFrames	int	10	Maximum frames used for bundle adjustment (0=inf or all current frames in the local map).
OdomF2M/BundleAdjustmentMinMotion	float	0.0	To create a new keyframe with bundle adjustment, a minimum motion (in pixels) can be required. The motion is computed by the average distance between inliers of the previous keyframe and new frame.
OdomF2M/BundleAdjustmentMaxKeyFramesPerFeature	int	0	Maximum keyframes per feature for bundle adjustment. 0 means not limit.
OdomF2M/BundleUpdateFeatureMapOnAllFrames	bool	false	Update 3D local feature map on every frame with bundle adjustment. Recommended if Vis/DepthAsMask=false and Mem/UseOdomFeatures=true so that features without depth are better triangulated on every frame (not only on keyframes). If disabled, the feature map is updated only when a new keyframe is added (legacy approach).

OdomMono

Key	Type	Default	Description
OdomMono/InitMinFlow	float	100	Minimum optical flow required for the initialization step.
OdomMono/InitMinTranslation	float	0.1	Minimum translation required for the initialization step.
OdomMono/MinTranslation	float	0.02	Minimum translation to add new points to local map. On initialization, translation x 5 is used as the minimum.
OdomMono/MaxVariance	float	0.01	Maximum variance to add new points to local map.

OdomFovis

Key	Type	Default	Description
OdomFovis/FeatureWindowSize	int	9	The size of the n x n image patch surrounding each feature, used for keypoint matching.
OdomFovis/MaxPyramidLevel	int	3	The maximum Gaussian pyramid level to process the image at. Pyramid level 1 corresponds to the original image.
OdomFovis/MinPyramidLevel	int	0	The minimum pyramid level.
OdomFovis/TargetPixelsPerFeature	int	250	Specifies the desired feature density as a ratio of input image pixels per feature detected. This number is used to control the adaptive feature thresholding.
OdomFovis/FastThreshold	int	20	FAST threshold.
OdomFovis/UseAdaptiveThreshold	bool	true	Use FAST adaptive threshold.
OdomFovis/FastThresholdAdaptiveGain	double	0.005	FAST threshold adaptive gain.
OdomFovis/UseHomographyInitialization	bool	true	Use homography initialization.
OdomFovis/UseBucketing	bool	true
OdomFovis/BucketWidth	int	80
OdomFovis/BucketHeight	int	80
OdomFovis/MaxKeypointsPerBucket	int	25
OdomFovis/UseImageNormalization	bool	false
OdomFovis/InlierMaxReprojectionError	double	1.5	The maximum image-space reprojection error (in pixels) a feature match is allowed to have and still be considered an inlier in the set of features used for motion estimation.
OdomFovis/CliqueInlierThreshold	double	0.1	See Howard's greedy max-clique algorithm for determining the maximum set of mutually consisten feature matches. This specifies the compatibility threshold, in meters.
OdomFovis/MinFeaturesForEstimate	int	20	Minimum number of features in the inlier set for the motion estimate to be considered valid.
OdomFovis/MaxMeanReprojectionError	double	10.0	Maximum mean reprojection error over the inlier feature matches for the motion estimate to be considered valid.
OdomFovis/UseSubpixelRefinement	bool	true	Specifies whether or not to refine feature matches to subpixel resolution.
OdomFovis/FeatureSearchWindow	int	25	Specifies the size of the search window to apply when searching for feature matches across time frames. The search is conducted around the feature location predicted by the initial rotation estimate.
OdomFovis/UpdateTargetFeaturesWithRefined	bool	false	When subpixel refinement is enabled, the refined feature locations can be saved over the original feature locations. This has a slightly negative impact on frame-to-frame visual odometry, but is likely better when using this library as part of a visual SLAM algorithm.
OdomFovis/StereoRequireMutualMatch	bool	true
OdomFovis/StereoMaxDistEpipolarLine	double	1.5
OdomFovis/StereoMaxRefinementDisplacement	double	1.0
OdomFovis/StereoMaxDisparity	int	128

OdomViso2

Key	Type	Default	Description
OdomViso2/RansacIters	int	200	Number of RANSAC iterations.
OdomViso2/InlierThreshold	double	2.0	Fundamental matrix inlier threshold.
OdomViso2/Reweighting	bool	true	Lower border weights (more robust to calibration errors).
OdomViso2/MatchNmsN	int	3	Non-max-suppression: min. distance between maxima (in pixels).
OdomViso2/MatchNmsTau	int	50	Non-max-suppression: interest point peakiness threshold.
OdomViso2/MatchBinsize	int	50	Matching bin width/height (affects efficiency only).
OdomViso2/MatchRadius	int	200	Matching radius (du/dv in pixels).
OdomViso2/MatchDispTolerance	int	2	Disparity tolerance for stereo matches (in pixels).
OdomViso2/MatchOutlierDispTolerance	int	5	Outlier removal: disparity tolerance (in pixels).
OdomViso2/MatchOutlierFlowTolerance	int	5	Outlier removal: flow tolerance (in pixels).
OdomViso2/MatchMultiStage	bool	true	Multistage matching (denser and faster).
OdomViso2/MatchHalfResolution	bool	true	Match at half resolution, refine at full resolution.
OdomViso2/MatchRefinement	int	1	Refinement (0=none,1=pixel,2=subpixel).
OdomViso2/BucketMaxFeatures	int	2	Maximal number of features per bucket.
OdomViso2/BucketWidth	double	50	Width of bucket.
OdomViso2/BucketHeight	double	50	Height of bucket.

OdomORBSLAM

Key	Type	Default	Description
OdomORBSLAM/VocPath	string	""	Path to ORB vocabulary (*.txt).
OdomORBSLAM/Bf	double	0.076	Fake IR projector baseline (m) used only when stereo is not used.
OdomORBSLAM/ThDepth	double	40.0	Close/Far threshold. Baseline times.
OdomORBSLAM/Fps	float	0.0	Camera FPS (0 to estimate from input data).
OdomORBSLAM/MaxFeatures	int	1000	Maximum ORB features extracted per frame.
OdomORBSLAM/MapSize	int	3000	Maximum size of the feature map (0 means infinite). Only supported with ORB_SLAM2.
OdomORBSLAM/Inertial	bool	false	Enable IMU. Only supported with ORB_SLAM3.
OdomORBSLAM/GyroNoise	double	0.01	IMU gyroscope "white noise".
OdomORBSLAM/AccNoise	double	0.1	IMU accelerometer "white noise".
OdomORBSLAM/GyroWalk	double	0.000001	IMU gyroscope "random walk".
OdomORBSLAM/AccWalk	double	0.0001	IMU accelerometer "random walk".
OdomORBSLAM/SamplingRate	double	0	IMU sampling rate (0 to estimate from input data).

OdomOKVIS

Key	Type	Default	Description
OdomOKVIS/ConfigPath	string	""	Path of OKVIS config file.

OdomLOAM

Key	Type	Default	Description
OdomLOAM/Sensor	int	2	Velodyne sensor: 0=VLP-16, 1=HDL-32, 2=HDL-64E
OdomLOAM/ScanPeriod	float	0.1	Scan period (s)
OdomLOAM/Resolution	float	0.2	Map resolution
OdomLOAM/LinVar	float	0.01	Linear output variance.
OdomLOAM/AngVar	float	0.01	Angular output variance.
OdomLOAM/LocalMapping	bool	true	Local mapping. It adds more time to compute odometry, but accuracy is significantly improved.

OdomMSCKF

Key	Type	Default	Description
OdomMSCKF/GridRow	int	4
OdomMSCKF/GridCol	int	5
OdomMSCKF/GridMinFeatureNum	int	3
OdomMSCKF/GridMaxFeatureNum	int	4
OdomMSCKF/PyramidLevels	int	3
OdomMSCKF/PatchSize	int	15
OdomMSCKF/FastThreshold	int	10
OdomMSCKF/MaxIteration	int	30
OdomMSCKF/TrackPrecision	double	0.01
OdomMSCKF/RansacThreshold	double	3
OdomMSCKF/StereoThreshold	double	5
OdomMSCKF/PositionStdThreshold	double	8.0
OdomMSCKF/RotationThreshold	double	0.2618
OdomMSCKF/TranslationThreshold	double	0.4
OdomMSCKF/TrackingRateThreshold	double	0.5
OdomMSCKF/OptTranslationThreshold	double	0
OdomMSCKF/NoiseGyro	double	0.005
OdomMSCKF/NoiseAcc	double	0.05
OdomMSCKF/NoiseGyroBias	double	0.001
OdomMSCKF/NoiseAccBias	double	0.01
OdomMSCKF/NoiseFeature	double	0.035
OdomMSCKF/InitCovVel	double	0.25
OdomMSCKF/InitCovGyroBias	double	0.01
OdomMSCKF/InitCovAccBias	double	0.01
OdomMSCKF/InitCovExRot	double	0.00030462
OdomMSCKF/InitCovExTrans	double	0.000025
OdomMSCKF/MaxCamStateSize	int	20

OdomVINSFusion

Key	Type	Default	Description
OdomVINSFusion/ConfigPath	string	""	Path of VINS-Fusion config file.

OdomOpenVINS

Key	Type	Default	Description
OdomOpenVINS/ConfigPath	string	""	Path of OpenVINS config file (*.yaml). Same format used than OpenVINS library. Note that any parameter from that config file will overwrite the same parameter in OdomOpenVINS group.
OdomOpenVINS/UseStereo	bool	true	If we have more than 1 camera, if we should try to track stereo constraints between pairs.
OdomOpenVINS/UseKLT	bool	true	If true we will use KLT, otherwise use a ORB descriptor + robust matching.
OdomOpenVINS/NumPts	int	200	Number of points (per camera) we will extract and try to track.
OdomOpenVINS/MinPxDist	int	15	Eistance between features (features near each other provide less information).
OdomOpenVINS/FiTriangulate1d	bool	false	If we should perform 1d triangulation instead of 3d.
OdomOpenVINS/FiRefineFeatures	bool	true	If we should perform Levenberg-Marquardt refinement.
OdomOpenVINS/FiMaxRuns	int	5	Max runs for Levenberg-Marquardt.
OdomOpenVINS/FiMaxBaseline	double	40	Max baseline ratio to accept triangulated features.
OdomOpenVINS/FiMaxCondNumber	double	10000	Max condition number of linear triangulation matrix accept triangulated features.
OdomOpenVINS/UseFEJ	bool	true	If first-estimate Jacobians should be used (enable for good consistency).
OdomOpenVINS/Integration	int	1	0=discrete, 1=rk4, 2=analytical (if rk4 or analytical used then analytical covariance propagation is used).
OdomOpenVINS/CalibCamExtrinsics	bool	false	Bool to determine whether or not to calibrate imu-to-camera pose.
OdomOpenVINS/CalibCamIntrinsics	bool	false	Bool to determine whether or not to calibrate camera intrinsics.
OdomOpenVINS/CalibCamTimeoffset	bool	false	Bool to determine whether or not to calibrate camera to IMU time offset.
OdomOpenVINS/CalibIMUIntrinsics	bool	false	Bool to determine whether or not to calibrate the IMU intrinsics.
OdomOpenVINS/CalibIMUGSensitivity	bool	false	Bool to determine whether or not to calibrate the Gravity sensitivity.
OdomOpenVINS/MaxClones	int	11	Max clone size of sliding window.
OdomOpenVINS/MaxSLAM	int	50	Max number of estimated SLAM features.
OdomOpenVINS/MaxSLAMInUpdate	int	25	Max number of SLAM features we allow to be included in a single EKF update..
OdomOpenVINS/MaxMSCKFInUpdate	int	50	Max number of MSCKF features we will use at a given image timestep..
OdomOpenVINS/FeatRepMSCKF	int	0	What representation our features are in (msckf features).
OdomOpenVINS/FeatRepSLAM	int	4	What representation our features are in (slam features).
OdomOpenVINS/DtSLAMDelay	double	0.0	Delay, in seconds, that we should wait from init before we start estimating SLAM features.
OdomOpenVINS/GravityMag	double	9.81	Gravity magnitude in the global frame (i.e. should be 9.81 typically).
OdomOpenVINS/LeftMaskPath	string	""	Mask for left image.
OdomOpenVINS/RightMaskPath	string	""	Mask for right image.
OdomOpenVINS/InitWindowTime	double	2.0	Amount of time we will initialize over (seconds).
OdomOpenVINS/InitIMUThresh	double	1.0	Variance threshold on our acceleration to be classified as moving.
OdomOpenVINS/InitMaxDisparity	double	10.0	Max disparity to consider the platform stationary (dependent on resolution).
OdomOpenVINS/InitMaxFeatures	int	50	How many features to track during initialization (saves on computation).
OdomOpenVINS/InitDynUse	bool	false	If dynamic initialization should be used.
OdomOpenVINS/InitDynMLEOptCalib	bool	false	If we should optimize calibration during intialization (not recommended).
OdomOpenVINS/InitDynMLEMaxIter	int	50	How many iterations the MLE refinement should use (zero to skip the MLE).
OdomOpenVINS/InitDynMLEMaxTime	double	0.05	How many seconds the MLE should be completed in.
OdomOpenVINS/InitDynMLEMaxThreads	int	6	How many threads the MLE should use.
OdomOpenVINS/InitDynNumPose	int	6	Number of poses to use within our window time (evenly spaced).
OdomOpenVINS/InitDynMinDeg	double	10.0	Orientation change needed to try to init.
OdomOpenVINS/InitDynInflationOri	double	10.0	What to inflate the recovered q_GtoI covariance by.
OdomOpenVINS/InitDynInflationVel	double	100.0	What to inflate the recovered v_IinG covariance by.
OdomOpenVINS/InitDynInflationBg	double	10.0	What to inflate the recovered bias_g covariance by.
OdomOpenVINS/InitDynInflationBa	double	100.0	What to inflate the recovered bias_a covariance by.
OdomOpenVINS/InitDynMinRecCond	double	1e-15	Reciprocal condition number thresh for info inversion.
OdomOpenVINS/TryZUPT	bool	true	If we should try to use zero velocity update.
OdomOpenVINS/ZUPTChi2Multiplier	double	0.0	Chi2 multiplier for zero velocity.
OdomOpenVINS/ZUPTMaxVelodicy	double	0.1	Max velocity we will consider to try to do a zupt (i.e. if above this, don't do zupt).
OdomOpenVINS/ZUPTNoiseMultiplier	double	10.0	Multiplier of our zupt measurement IMU noise matrix (default should be 1.0).
OdomOpenVINS/ZUPTMaxDisparity	double	0.5	Max disparity we will consider to try to do a zupt (i.e. if above this, don't do zupt).
OdomOpenVINS/ZUPTOnlyAtBeginning	bool	false	If we should only use the zupt at the very beginning static initialization phase.
OdomOpenVINS/AccelerometerNoiseDensity	double	0.01	[m/s^2/sqrt(Hz)] (accel "white noise").
OdomOpenVINS/AccelerometerRandomWalk	double	0.001	[m/s^3/sqrt(Hz)] (accel bias diffusion).
OdomOpenVINS/GyroscopeNoiseDensity	double	0.001	[rad/s/sqrt(Hz)] (gyro "white noise").
OdomOpenVINS/GyroscopeRandomWalk	double	0.0001	[rad/s^2/sqrt(Hz)] (gyro bias diffusion).
OdomOpenVINS/UpMSCKFSigmaPx	double	1.0	Pixel noise for MSCKF features.
OdomOpenVINS/UpMSCKFChi2Multiplier	double	1.0	Chi2 multiplier for MSCKF features.
OdomOpenVINS/UpSLAMSigmaPx	double	1.0	Pixel noise for SLAM features.
OdomOpenVINS/UpSLAMChi2Multiplier	double	1.0	Chi2 multiplier for SLAM features.

OdomOpen3D

Key	Type	Default	Description
OdomOpen3D/MaxDepth	float	3.0	Maximum depth.
OdomOpen3D/Method	int	0	Registration method: 0=PointToPlane, 1=Intensity, 2=Hybrid.

OdomCuVSLAM

Key	Type	Default	Description
OdomCuVSLAM/MulticamMode	int	0	cuVSLAM multicam_mode setting: 0=moderate, 1=performance, 2=precision.

OdomLIOSAM

Key	Type	Default	Description
OdomLIOSAM/ConfigPath	string	""	Path to LIO-SAM params.yaml config file. When set, sensor/IMU/feature parameters are loaded from the file and the individual parameters below are ignored.
OdomLIOSAM/Sensor	int	0	LiDAR sensor: 0=Velodyne, 1=Ouster, 2=Livox
OdomLIOSAM/NScan	int	16	Number of LiDAR channels (16, 32, 64, 128).
OdomLIOSAM/HorizonScan	int	1800	Horizontal resolution (Velodyne:1800, Ouster:512/1024/2048).
OdomLIOSAM/ImuAccNoise	float	0.01	IMU accelerometer white noise.
OdomLIOSAM/ImuGyrNoise	float	0.001	IMU gyroscope white noise.
OdomLIOSAM/ImuAccBiasN	float	0.0002	IMU accelerometer bias noise.
OdomLIOSAM/ImuGyrBiasN	float	0.00003	IMU gyroscope bias noise.
OdomLIOSAM/ImuGravity	float	9.80511	Gravity magnitude.
OdomLIOSAM/EdgeThreshold	float	1.0	Edge feature curvature threshold.
OdomLIOSAM/SurfThreshold	float	0.1	Surface feature curvature threshold.
OdomLIOSAM/LinVar	float	0.01	Linear output variance.
OdomLIOSAM/AngVar	float	0.01	Angular output variance.

Reg

Registration strategy shared by loop closures and proximity detection.

Key	Type	Default	Description
Reg/RepeatOnce	bool	true	Do a second registration with the output of the first registration as guess. Only done if no guess was provided for the first registration (like on loop closure). It can be useful if the registration approach used can use a guess to get better matches.
Reg/Strategy	int	0	0=Vis, 1=Icp, 2=VisIcp
Reg/Force3DoF	bool	false	Force 3 degrees-of-freedom transform (3Dof: x,y and yaw). Parameters z, roll and pitch will be set to 0.

Vis

Visual registration (feature extraction, matching and PnP).

Key	Type	Default	Description
Vis/EstimationType	int	1	Motion estimation approach: 0:3D->3D, 1:3D->2D (PnP), 2:2D->2D (Epipolar Geometry)
Vis/InlierDistance	float	0.1	[Vis/EstimationType = 0] Maximum distance for feature correspondences. Used by 3D->3D estimation approach.
Vis/RefineIterations	int	5	[Vis/EstimationType = 0] Number of iterations used to refine the transformation found by RANSAC. 0 means that the transformation is not refined.
Vis/PnPReprojError	float	2	[Vis/EstimationType = 1] PnP reprojection error.
Vis/PnPFlags	int	0	[Vis/EstimationType = 1] PnP flags: 0=Iterative, 1=EPNP, 2=P3P
Vis/PnPRefineIterations	int	0 with defined(RTABMAP_G2O) \|\| defined(RTABMAP_ORB_SLAM) 1 otherwise	[Vis/BundleAdjustment = 1] Refine iterations. Set to 0 if Vis/EstimationType is also used.
Vis/PnPVarianceMedianRatio	int	4	[Vis/EstimationType = 1] Ratio used to compute variance of the estimated transformation if 3D correspondences are provided (should be > 1). The higher it is, the smaller the covariance will be. With accurate depth estimation, this could be set to 2. For depth estimated by stereo, 4 or more maybe used to ignore large errors of very far points.
Vis/PnPMaxVariance	float	0.0	[Vis/EstimationType = 1] Max linear variance between 3D point correspondences after PnP. 0 means disabled.
Vis/PnPSamplingPolicy	unsigned int	1	[Vis/EstimationType = 1] Multi-camera random sampling policy: 0=AUTO, 1=ANY, 2=HOMOGENEOUS. With HOMOGENEOUS policy, RANSAC will be done uniformly against all cameras, so at least 2 matches per camera are required. With ANY policy, RANSAC is not constraint to sample on all cameras at the same time. AUTO policy will use HOMOGENEOUS if there are at least 2 matches per camera, otherwise it will fallback to ANY policy.
Vis/PnPSplitLinearCovComponents	bool	false	[Vis/EstimationType = 1] Compute variance for each linear component instead of using the combined XYZ variance for all linear components.
Vis/EpipolarGeometryVar	float	0.1	[Vis/EstimationType = 2] Epipolar geometry maximum variance to accept the transformation.
Vis/MinInliers	int	20	Minimum feature correspondences to compute/accept the transformation.
Vis/MeanInliersDistance	float	0.0	Maximum distance (m) of the mean distance of inliers from the camera to accept the transformation. 0 means disabled.
Vis/MinInliersDistribution	float	0.0	Minimum distribution value of the inliers in the image to accept the transformation. The distribution is the second eigen value of the PCA (Principal Component Analysis) on the keypoints of the normalized image [-0.5, 0.5]. The value would be between 0 and 0.5. 0 means disabled.
Vis/Iterations	int	300	Maximum iterations to compute the transform.
Vis/FeatureType	int	8 with CV_MAJOR_VERSION > 2 && !defined(HAVE_OPENCV_XFEATURES2D) 6 otherwise	0=SURF 1=SIFT 2=ORB 3=FAST/FREAK 4=FAST/BRIEF 5=GFTT/FREAK 6=GFTT/BRIEF 7=BRISK 8=GFTT/ORB 9=KAZE 10=ORB-OCTREE 11=SuperPoint 12=SURF/FREAK 13=GFTT/DAISY 14=SURF/DAISY 15=PyDetector 16=SuperPoint-Rpautrat
Vis/MaxFeatures	int	1000	0 no limits.
Vis/SSC	bool	false	If true, SSC (Suppression via Square Covering) is applied to limit keypoints.
Vis/MaxDepth	float	0	Max depth of the features (0 means no limit).
Vis/MinDepth	float	0	Min depth of the features (0 means no limit).
Vis/DepthAsMask	bool	true	Use depth image as mask when extracting features.
Vis/DepthMaskFloorThr	float	0.0	Filter floor from depth mask below specified threshold (m) before extracting features. 0 means disabled. Ignored if Vis/DepthAsMask is false.
Vis/RoiRatios	string	0.0 0.0 0.0 0.0	Region of interest ratios [left, right, top, bottom].
Vis/SubPixWinSize	int	3	See cv::cornerSubPix().
Vis/SubPixIterations	int	0	See cv::cornerSubPix(). 0 disables sub pixel refining.
Vis/SubPixEps	float	0.02	See cv::cornerSubPix().
Vis/GridRows	int	1	Number of rows of the grid used to extract uniformly "@ref param_VisMaxFeatures "Vis/MaxFeatures" / grid cells" features from each cell.
Vis/GridCols	int	1	Number of columns of the grid used to extract uniformly "@ref param_VisMaxFeatures "Vis/MaxFeatures" / grid cells" features from each cell.
Vis/CorType	int	0	Correspondences computation approach: 0=Features Matching, 1=Optical Flow
Vis/CorNNType	int	1	[Vis/CorType=0] kNNFlannNaive=0, kNNFlannKdTree=1, kNNFlannLSH=2, kNNBruteForce=3, kNNBruteForceGPU=4, BruteForceCrossCheck=5, SuperGlue=6, GMS=7. Used for features matching approach.
Vis/CorNNDR	float	0.8	[Vis/CorType=0] NNDR: nearest neighbor distance ratio. Used for knn features matching approach.
Vis/CorGuessWinSize	int	40	[Vis/CorType=0] Matching window size (pixels) around projected points when a guess transform is provided to find correspondences. 0 means disabled.
Vis/CorGuessMatchToProjection	bool	false	[Vis/CorType=0] Match frame's corners to source's projected points (when guess transform is provided) instead of projected points to frame's corners.
Vis/CorFlowWinSize	int	16	[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.
Vis/CorFlowIterations	int	30	[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.
Vis/CorFlowEps	float	0.01	[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.
Vis/CorFlowMaxLevel	int	3	[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach.
Vis/CorFlowUseMinEigenVals	bool	true	[Vis/CorType=1] See cv::calcOpticalFlowPyrLK(). Used for optical flow approach. Use minimum eigen values as an error measure, otherwise L1 distance between patches is used as an error measure.
Vis/CorFlowMinEigThreshold	float	1e-4	[Vis/CorFlowUseMinEigenVals=true] If the minimum eigenvalue of a feature's spatial gradient matrix is less than this threshold, then the feature is filtered out.
Vis/CorFlowErrorThreshold	float	20	[Vis/CorFlowUseMinEigenVals=false] Filter out features with error greater than this threshold.
Vis/CorFlowGpu	bool	false	[Vis/CorType=1] Enable GPU version of the optical flow approach (only available if OpenCV is built with CUDA). Note that Vis/CorFlowUseMinEigenVals is not used in the GPU implementation.
Vis/BundleAdjustment	int	1 with defined(RTABMAP_G2O) \|\| defined(RTABMAP_ORB_SLAM) 0 otherwise	Optimization with bundle adjustment. Value matches the Optimizer/Strategy parameter: 0=disabled (TORO is not BA-capable), 1=g2o, 2=GTSAM, 3=Ceres, 4=cvsba.

PyMatcher

Key	Type	Default	Description
PyMatcher/Path	string	""	Path to python script file (see available ones in rtabmap/corelib/src/python/*). See the header to see where the script should be copied.
PyMatcher/Iterations	int	20	Sinkhorn iterations. Used by SuperGlue.
PyMatcher/Threshold	float	0.2	Used by SuperGlue.
PyMatcher/Cuda	bool	true	Used by SuperGlue.
PyMatcher/Model	string	indoor	For SuperGlue, set only "indoor" or "outdoor". For OANet, set path to one of the pth file (e.g., "OANet/model/gl3d/sift-4000/model_best.pth").

GMS

Key	Type	Default	Description
GMS/WithRotation	bool	false	Take rotation transformation into account.
GMS/WithScale	bool	false	Take scale transformation into account.
GMS/ThresholdFactor	double	6.0	The higher, the less matches.

PyDescriptor

Key	Type	Default	Description
PyDescriptor/Path	string	""	Path to python script file (see available ones in rtabmap/corelib/src/pydescriptor/*). See the header to see where the script should be used.
PyDescriptor/Dim	int	4096	Descriptor dimension.

Icp

Geometric registration by iterative closest point.

Key	Type	Default	Description
Icp/Strategy	int	1 with defined(RTABMAP_POINTMATCHER) 0 otherwise	ICP implementation: 0=Point Cloud Library, 1=libpointmatcher, 2=CCCoreLib (CloudCompare).
Icp/MaxTranslation	float	0.2	Maximum ICP translation correction accepted (m).
Icp/MaxRotation	float	0.78	Maximum ICP rotation correction accepted (rad).
Icp/VoxelSize	float	0.05	Uniform sampling voxel size (0=disabled).
Icp/DownsamplingStep	int	1	Downsampling step size (1=no sampling). This is done before uniform sampling.
Icp/RangeMin	float	0	Minimum range filtering (0=disabled).
Icp/RangeMax	float	0	Maximum range filtering (0=disabled).
Icp/MaxCorrespondenceDistance	float	0.1 with defined(RTABMAP_POINTMATCHER) 0.05 otherwise	Max distance for point correspondences.
Icp/ReciprocalCorrespondences	bool	true	To be a valid correspondence, the corresponding point in target cloud to point in source cloud should be both their closest closest correspondence.
Icp/Iterations	int	30	Max iterations.
Icp/Epsilon	float	0	Set the transformation epsilon (maximum allowable difference between two consecutive transformations) in order for an optimization to be considered as having converged to the final solution.
Icp/CorrespondenceRatio	float	0.1	Ratio of matching correspondences to accept the transform.
Icp/Force4DoF	bool	false	Limit ICP to x, y, z and yaw DoF. Available if Icp/Strategy > 0.
Icp/FiltersEnabled	int	3	Flag to enable filters: 1="from" cloud only, 2="to" cloud only, 3=both.
Icp/PointToPlane	bool	true with defined(RTABMAP_POINTMATCHER) false otherwise	Use point to plane ICP.
Icp/PointToPlaneK	int	5	Number of neighbors to compute normals for point to plane if the cloud doesn't have already normals.
Icp/PointToPlaneRadius	float	0.0	Search radius to compute normals for point to plane if the cloud doesn't have already normals.
Icp/PointToPlaneGroundNormalsUp	float	0.0	Invert normals on ground if they are pointing down (useful for ring-like 3D LiDARs). 0 means disabled, 1 means only normals perfectly aligned with -z axis. This is only done with 3D scans.
Icp/PointToPlaneMinComplexity	float	0.02	Minimum structural complexity (0.0=low, 1.0=high) of the scan to do PointToPlane registration, otherwise PointToPoint registration is done instead and strategy from Icp/PointToPlaneLowComplexityStrategy is used. This check is done only when Icp/PointToPlane=true.
Icp/PointToPlaneComplexityCentered	bool	false	If false (default), the complexity metric uses the uncentered second-moment matrix (1/N) * sum(n_i * n_i^T), whose smallest eigenvalue directly measures how well the surface normals span R^N. If true, uses centered PCA (cv::PCA covariance) for backwards compatibility – but the centered metric is known to mis-classify perpendicular-surface scenes as degenerate when normals are consistently viewpoint-flipped (only N distinct directions in N-D collapse to rank N-1 after centering). For true degeneracies (parallel surfaces, e.g. corridors) the two metrics agree because the normal mean is zero. The Icp/PointToPlaneMinComplexity threshold of 0.02 works under either setting.
Icp/PointToPlaneLowComplexityStrategy	int	1	If structural complexity is below Icp/PointToPlaneMinComplexity: set to 0 so that the transform is automatically rejected, set to 1 (default, legacy) to recompute the transform with PointToPoint and limit its correction in axes with most constraints (e.g., for a corridor-like environment, the resulting transform will be limited in y and yaw, x will taken from the guess), set to 2 to recompute the transform with PointToPoint and accept it "as is", set to 3 to keep the PointToPlane transform and apply the same axis-constrained projection as strategy 1.
Icp/OutlierRatio	float	0.85	Outlier ratio. For libpointmatcher (Icp/Strategy=1), sets TrimmedDistOutlierFilter/ratio for convenience when configuration file is not set. For CCCoreLib (Icp/Strategy=2), sets "finalOverlapRatio". For PCL (Icp/Strategy=0), if 0<value<1, installs a RANSAC correspondence rejector with inlier threshold = value * Icp/MaxCorrespondenceDistance. The value should be between 0 and 1.
Icp/DebugExportFormat	string	""	Export scans used for ICP in the specified format (a warning on terminal will be shown with the file paths used). Supported formats are "pcd", "ply" or "vtk". If logger level is debug, from and to scans will stamped, so previous files won't be overwritten.
Icp/PMConfig	string	""	Configuration file (*.yaml) used by libpointmatcher. Note that data filters set for libpointmatcher are done after filtering done by rtabmap (i.e., Icp/VoxelSize, Icp/DownsamplingStep), so make sure to disable those in rtabmap if you want to use only those from libpointmatcher. Parameters Icp/Iterations, Icp/Epsilon and Icp/MaxCorrespondenceDistance are also ignored if configuration file is set.
Icp/PMMatcherKnn	int	1	KDTreeMatcher/knn: number of nearest neighbors to consider it the reference. For convenience when configuration file is not set.
Icp/PMMatcherEpsilon	float	0.0	KDTreeMatcher/epsilon: approximation to use for the nearest-neighbor search. For convenience when configuration file is not set.
Icp/PMMatcherIntensity	bool	false	KDTreeMatcher: among nearest neighbors, keep only the one with the most similar intensity. This only work with Icp/PMMatcherKnn>1.
Icp/CCSamplingLimit	unsigned int	50000	Maximum number of points per cloud (they are randomly resampled below this limit otherwise).
Icp/CCFilterOutFarthestPoints	bool	false	If true, the algorithm will automatically ignore farthest points from the reference, for better convergence.
Icp/CCMaxFinalRMS	float	0.2	Maximum final RMS error.

Stereo

Stereo correspondence.

Key	Type	Default	Description
Stereo/WinWidth	int	15	Window width.
Stereo/WinHeight	int	3	Window height.
Stereo/Iterations	int	30	Maximum iterations.
Stereo/MaxLevel	int	5	Maximum pyramid level.
Stereo/MinDisparity	float	0.5	Minimum disparity.
Stereo/MaxDisparity	float	128.0	Maximum disparity.
Stereo/OpticalFlow	bool	true	Use optical flow to find stereo correspondences, otherwise a simple block matching approach is used.
Stereo/SSD	bool	true	[Stereo/OpticalFlow=false] Use Sum of Squared Differences (SSD) window, otherwise Sum of Absolute Differences (SAD) window is used.
Stereo/Eps	double	0.01	[Stereo/OpticalFlow=true] Epsilon stop criterion.
Stereo/UseMinEigenVals	bool	true	[Stereo/OpticalFlow=true] Use minimum eigen values as an error measure, otherwise L1 distance between patches is used as an error measure.
Stereo/MinEigThreshold	double	1e-4	[Stereo/UseMinEigenVals=true] If the minimum eigenvalue of a feature's spatial gradient matrix is less than this threshold, then the feature is filtered out.
Stereo/ErrorThreshold	double	50	[Stereo/UseMinEigenVals=false] Filter out features with error greater than this threshold.
Stereo/Gpu	bool	false	[Stereo/OpticalFlow=true] Enable GPU version of the optical flow approach (only available if OpenCV is built with CUDA). Note that Stereo/UseMinEigenVals is not used in the GPU implementation.
Stereo/DenseStrategy	int	0	0=cv::StereoBM, 1=cv::StereoSGBM

StereoBM

Key	Type	Default	Description
StereoBM/BlockSize	int	15	See cv::StereoBM
StereoBM/MinDisparity	int	0	See cv::StereoBM
StereoBM/NumDisparities	int	128	See cv::StereoBM
StereoBM/PreFilterSize	int	9	See cv::StereoBM
StereoBM/PreFilterCap	int	31	See cv::StereoBM
StereoBM/UniquenessRatio	int	15	See cv::StereoBM
StereoBM/TextureThreshold	int	10	See cv::StereoBM
StereoBM/SpeckleWindowSize	int	100	See cv::StereoBM
StereoBM/SpeckleRange	int	4	See cv::StereoBM
StereoBM/Disp12MaxDiff	int	-1	See cv::StereoBM

StereoSGBM

Key	Type	Default	Description
StereoSGBM/BlockSize	int	15	See cv::StereoSGBM
StereoSGBM/MinDisparity	int	0	See cv::StereoSGBM
StereoSGBM/NumDisparities	int	128	See cv::StereoSGBM
StereoSGBM/PreFilterCap	int	31	See cv::StereoSGBM
StereoSGBM/UniquenessRatio	int	20	See cv::StereoSGBM
StereoSGBM/SpeckleWindowSize	int	100	See cv::StereoSGBM
StereoSGBM/SpeckleRange	int	4	See cv::StereoSGBM
StereoSGBM/Disp12MaxDiff	int	1	See cv::StereoSGBM
StereoSGBM/P1	int	2	See cv::StereoSGBM
StereoSGBM/P2	int	5	See cv::StereoSGBM
StereoSGBM/Mode	int	0 with CV_MAJOR_VERSION < 3 2 otherwise	See cv::StereoSGBM

Grid

Local occupancy grid generation from each node.

Key	Type	Default	Description
Grid/Sensor	int	1	Create occupancy grid from selected sensor: 0=laser scan, 1=depth image(s) or 2=both laser scan and depth image(s).
Grid/DepthDecimation	unsigned int	4	[Grid/DepthDecimation=true] Decimation of the depth image before creating cloud.
Grid/RangeMin	float	0.0	Minimum range from sensor.
Grid/RangeMax	float	5.0	Maximum range from sensor. 0=inf.
Grid/DepthRoiRatios	string	0.0 0.0 0.0 0.0	[Grid/Sensor>=1] Region of interest ratios [left, right, top, bottom].
Grid/FootprintLength	float	0.0	Footprint length used to filter points over the footprint of the robot.
Grid/FootprintWidth	float	0.0	Footprint width used to filter points over the footprint of the robot. Footprint length should be set.
Grid/FootprintHeight	float	0.0	Footprint height used to filter points over the footprint of the robot. Footprint length and width should be set.
Grid/ScanDecimation	int	1	[Grid/Sensor=0 or 2] Decimation of the laser scan before creating cloud.
Grid/CellSize	float	0.05	Resolution of the occupancy grid.
Grid/PreVoxelFiltering	bool	true	Input cloud is downsampled by voxel filter (voxel size is Grid/CellSize) before doing segmentation of obstacles and ground.
Grid/MapFrameProjection	bool	false	Projection in map frame. On a 3D terrain and a fixed local camera transform (the cloud is created relative to ground), you may want to disable this to do the projection in robot frame instead.
Grid/NormalsSegmentation	bool	true	Segment ground from obstacles using point normals, otherwise a fast passthrough is used.
Grid/MaxObstacleHeight	float	0.0	Maximum obstacles height (0=disabled).
Grid/MinGroundHeight	float	0.0	Minimum ground height (0=disabled).
Grid/MaxGroundHeight	float	0.0	Maximum ground height (0=disabled). Should be set if Grid/NormalsSegmentation is false.
Grid/MaxGroundAngle	float	45	[Grid/NormalsSegmentation=true] Maximum angle (degrees) between point's normal to ground's normal to label it as ground. Points with higher angle difference are considered as obstacles.
Grid/NormalK	int	20	[Grid/NormalsSegmentation=true] K neighbors to compute normals.
Grid/ClusterRadius	float	0.1	[Grid/NormalsSegmentation=true] Cluster maximum radius.
Grid/MinClusterSize	int	10	[Grid/NormalsSegmentation=true] Minimum cluster size to project the points.
Grid/FlatObstacleDetected	bool	true	[Grid/NormalsSegmentation=true] Flat obstacles detected.
Grid/3D	bool	true with defined(RTABMAP_OCTOMAP) false otherwise	A 3D occupancy grid is required if you want an OctoMap (3D ray tracing). Set to false if you want only a 2D map, the cloud will be projected on xy plane. A 2D map can be still generated if checked, but it requires more memory and time to generate it. Ignored if laser scan is 2D and Grid/Sensor is 0.
Grid/GroundIsObstacle	bool	false	[Grid/3D=true] Ground segmentation (Grid/NormalsSegmentation) is ignored, all points are obstacles. Use this only if you want an OctoMap with ground identified as an obstacle (e.g., with an UAV).
Grid/NoiseFilteringRadius	float	0.0	Noise filtering radius (0=disabled). Done after segmentation.
Grid/NoiseFilteringMinNeighbors	int	5	Noise filtering minimum neighbors.
Grid/Scan2dUnknownSpaceFilled	bool	false	Unknown space filled. Only used with 2D laser scans. Use Grid/RangeMax to set maximum range if laser scan max range is to set.
Grid/RayTracing	bool	false	Ray tracing is done for each occupied cell, filling unknown space between the sensor and occupied cells. If Grid/3D=true, RTAB-Map should be built with OctoMap support, otherwise 3D ray tracing is ignored.

GridGlobal

Assembly of the local grids into the global map.

Key	Type	Default	Description
GridGlobal/UpdateError	float	0.01	Graph changed detection error (m). Update map only if poses in new optimized graph have moved more than this value.
GridGlobal/FootprintRadius	float	0.0	Footprint radius (m) used to clear all obstacles under the graph.
GridGlobal/MinSize	float	0.0	Minimum map size (m).
GridGlobal/Eroded	bool	false	Erode obstacle cells.
GridGlobal/MaxNodes	int	0	Maximum nodes assembled in the map starting from the last node (0=unlimited).
GridGlobal/AltitudeDelta	float	0	Assemble only nodes that have the same altitude of +-delta meters of the current pose (0=disabled). This is used to generate 2D occupancy grid based on the current altitude (e.g., multi-floor building).
GridGlobal/OccupancyThr	float	0.5	Occupancy threshold (value between 0 and 1).
GridGlobal/ProbHit	float	0.7	Probability of a hit (value between 0.5 and 1).
GridGlobal/ProbMiss	float	0.4	Probability of a miss (value between 0 and 0.5).
GridGlobal/ProbClampingMin	float	0.1192	Probability clamping minimum (value between 0 and 1).
GridGlobal/ProbClampingMax	float	0.971	Probability clamping maximum (value between 0 and 1).
GridGlobal/FloodFillDepth	unsigned int	0	Flood fill filter (0=disabled), used to remove empty cells outside the map. The flood fill is done at the specified depth (between 1 and 16) of the OctoMap.

Marker

Fiducial marker (ArUco/AprilTag) detection and landmarks.

Key	Type	Default	Description
Marker/Strategy	int	0	Marker detection implementation: 0=OpenCV, 1=AprilTag
Marker/Dictionary	int	0	Dictionary to use: DICT_ARUCO_4X4_50=0, DICT_ARUCO_4X4_100=1, DICT_ARUCO_4X4_250=2, DICT_ARUCO_4X4_1000=3, DICT_ARUCO_5X5_50=4, DICT_ARUCO_5X5_100=5, DICT_ARUCO_5X5_250=6, DICT_ARUCO_5X5_1000=7, DICT_ARUCO_6X6_50=8, DICT_ARUCO_6X6_100=9, DICT_ARUCO_6X6_250=10, DICT_ARUCO_6X6_1000=11, DICT_ARUCO_7X7_50=12, DICT_ARUCO_7X7_100=13, DICT_ARUCO_7X7_250=14, DICT_ARUCO_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16, DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36H12=21
Marker/Length	float	0	The length (m) of the markers' side. Value <=0 means automatic marker length estimation using the depth image (the camera should look at the marker perpendicularly for initialization). If 0, the length is estimated only on the first marker detected, then re-used for all next detections (i.e., this assumes that markers have all the same length). With <0, the length is estimated once for each unique marker, then re-used for next detections with the same marker ID.
Marker/Lengths	string	""	List of markers to detect. Format is the marker's ID followed by its length (in meters), multiple markers are separated by a vertical line ("id1 length\|id2 length"). We can also define a range of markers with "id1:id2 length" (id2 included). If empty, all markers of the chosen dictionary can be detected and their length is set/estimated based on Marker/Length. For example, to detect markers 12 and 14 with lengths of 8 and 15 cm respectively, and all markers between 30 and 40 with a length of 10 cm, set "12 0.08\|14 0.15\|30:40 0.1".
Marker/MaxDepthError	float	0.01	Maximum depth error between all corners of a marker when estimating the marker length (when Marker/Length is 0). The smaller it is, the more perpendicular the camera should be toward the marker to initialize the length.
Marker/VarianceLinear	float	0.001	Linear variance to set on marker detections. If Marker/VarianceOrientationIgnored is enabled and Optimizer/Strategy=2 (GTSAM): it is the variance of the range factor, with 9999 to disable range factor and to do only bearing.
Marker/VarianceAngular	float	0.01	Angular variance to set on marker detections. If Marker/VarianceOrientationIgnored is enabled, it is ignored with Optimizer/Strategy=1 (g2o) and it corresponds to bearing variance with Optimizer/Strategy=2 (GTSAM).
Marker/VarianceOrientationIgnored	bool	false	When this setting is false, the landmark's orientation is optimized during graph optimization. When this setting is true, only the position of the landmark is optimized. This can be useful when the landmark's orientation estimation is not reliable. Note that for Optimizer/Strategy=1 (g2o), only Marker/VarianceLinear needs be set if we ignore orientation. For Optimizer/Strategy=2 (GTSAM), instead of optimizing the landmark's position directly, a bearing/range factor is used, with Marker/VarianceLinear as the variance of the range factor (with 9999 to optimize the position with only a bearing factor) and Marker/VarianceAngular as the variance of the bearing factor (pitch/yaw).
Marker/MaxRange	float	0.0	Maximum range in which markers will be detected. <=0 for unlimited range.
Marker/MinRange	float	0.0	Miniminum range in which markers will be detected. <=0 for unlimited range.
Marker/Priors	string	""	World prior locations of the markers. The map will be transformed in marker's world frame when a tag is detected. Format is the marker's ID followed by its position (angles in rad), multiple markers are separated by vertical line ("id1 x y z roll pitch yaw\|id2 x y z roll pitch yaw"). Example: "1 0 0 1 0 0 0\|2 1 0 1 0 0 1.57" (marker 2 is 1 meter forward than marker 1 with 90 deg yaw rotation).
Marker/PriorsVarianceLinear	float	0.001	Linear variance to set on marker priors.
Marker/PriorsVarianceAngular	float	0.001	Angular variance to set on marker priors.

MarkerAprilTag

Key	Type	Default	Description
MarkerAprilTag/NThreads	int	1	How many threads should be used?
MarkerAprilTag/QuadDecimate	float	1.0	Detection of quads can be done on a lower-resolution image, improving speed at a cost of pose accuracy and a slight decrease in detection rate. Decoding the binary payload is still done at full resolution.
MarkerAprilTag/QuadSigma	float	0.0	What Gaussian blur should be applied to the segmented image (used for quad detection?) Parameter is the standard deviation in pixels. Very noisy images benefit from non-zero values (e.g. 0.8).
MarkerAprilTag/RefineEdges	bool	true	When true, the edges of the each quad are adjusted to "snap to" strong gradients nearby. This is useful when decimation is employed, as it can increase the quality of the initial quad estimate substantially. Generally recommended to be on (true). Very computationally inexpensive. Option is ignored if MarkerAprilTag/QuadDecimate = 1.
MarkerAprilTag/DecodeSharpening	double	0.25	How much sharpening should be done to decoded images? This can help decode small tags but may or may not help in odd lighting conditions or low light conditions.
MarkerAprilTag/Debug	bool	false	When true, write a variety of debugging images to the working directory where the app started (not Rtabmap/WorkingDirectory) at various stages through the detection process. (Somewhat slow).

MarkerOpenCV

Key	Type	Default	Description
MarkerOpenCV/CornerRefinementMethod	int	0	Corner refinement method for OpenCV strategy (0: None, 1: Subpixel, 2:contour, 3: AprilTag2). For OpenCV <3.3.0, this is "doCornerRefinement" parameter: set 0 for false and 1 for true.

ImuFilter

Key	Type	Default	Description
ImuFilter/MadgwickGain	double	0.1	Gain of the filter. Higher values lead to faster convergence but more noise. Lower values lead to slower convergence but smoother signal, belongs in [0, 1].
ImuFilter/MadgwickZeta	double	0.0	Gyro drift gain (approx. rad/s), belongs in [-1, 1].
ImuFilter/ComplementaryGainAcc	double	0.01	Gain parameter for the complementary filter, belongs in [0, 1].
ImuFilter/ComplementaryBiasAlpha	double	0.01	Bias estimation gain parameter, belongs in [0, 1].
ImuFilter/ComplementaryDoBiasEstimation	bool	true	Parameter whether to do bias estimation or not.
ImuFilter/ComplementaryDoAdpativeGain	bool	true	Parameter whether to do adaptive gain or not.