Refactoring of some parameters (LocalLoopDetection* to Proximity*) and variables in code

2026-09-01 17:10:26 +08:00 · 2015-11-25 12:15:41 -05:00
parent 56383d4cfb
commit da1129cf79
14 changed files with 290 additions and 308 deletions
--- a/corelib/include/rtabmap/core/Memory.h
+++ b/corelib/include/rtabmap/core/Memory.h
@@ -239,7 +239,6 @@ private:
 	bool _badSignaturesIgnored;
 	int _imageDecimation;
 	float _laserScanDownsampleStepSize;
-	bool _localSpaceLinksKeptInWM;
 	bool _reextractLoopClosureFeatures;
 	float _rehearsalMaxDistance;
 	float _rehearsalMaxAngle;
--- a/corelib/include/rtabmap/core/Parameters.h
+++ b/corelib/include/rtabmap/core/Parameters.h
@@ -200,7 +200,6 @@ class RTABMAP_EXP Parameters
 	RTABMAP_PARAM(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.");
 	RTABMAP_PARAM(Mem, ImageDecimation,         int, 1,          "Image decimation (>=1) when creating a signature.");
 	RTABMAP_PARAM(Mem, LaserScanDownsampleStepSize, int, 1,  "If > 1, downsample the laser scans when creating a signature.");
-	RTABMAP_PARAM(Mem, LocalSpaceLinksKeptInWM, bool, true,      "If local space links are kept in WM.");

 	// KeypointMemory (Keypoint-based)
 	RTABMAP_PARAM_COND(Kp, NNStrategy,       int, RTABMAP_NONFREE, 1, 3, "kNNFlannNaive=0, kNNFlannKdTree=1, kNNFlannLSH=2, kNNBruteForce=3, kNNBruteForceGPU=4");
@@ -300,17 +299,17 @@ class RTABMAP_EXP Parameters
 	RTABMAP_PARAM(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.");
 	RTABMAP_PARAM(RGBD, LocalImmunizationRatio,   float, 0.25, "Ratio of working memory for which local nodes are immunized from transfer.");
 	RTABMAP_PARAM(RGBD, ScanMatchingIdsSavedInLinks, bool, true,      "Save scan matching IDs in link's user data.");
-	RTABMAP_PARAM(RGBD, IcpOdomRefining,          bool, false,  "If the newest added node's pose is refined using ICP with the previous node to correct odometry from pose to pose (laser scans required!).");
-	RTABMAP_PARAM(RGBD, IcpLoopClosureRefining,   bool, false, 	"If the estimated loop closure transformation is refined using ICP (laser scans required!).");	
+	RTABMAP_PARAM(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 ICP (laser scans required!).");
+	RTABMAP_PARAM(RGBD, LoopClosureLinkRefining,      bool, false, 	"If the estimated loop closure transformation is refined using ICP (laser scans required!).");
 	RTABMAP_PARAM(RGBD, LoopClosureReextractFeatures,  bool, true,    "Extract features even if there are some already in the nodes.");

 	// Local/Proximity loop closure detection
-	RTABMAP_PARAM(RGBD, LocalLoopDetectionTime,     bool, false, 	"Detection over all locations in STM.");
-	RTABMAP_PARAM(RGBD, LocalLoopDetectionSpace,    bool, true, 	"Detection over locations (in Working Memory or STM) near in space.");
-	RTABMAP_PARAM(RGBD, LocalLoopDetectionPathScansMerged,   bool, true, 	"Merge close laser scans on each path. If false, only the nearest laser scan on the path is used for ICP.");
-	RTABMAP_PARAM(RGBD, LocalLoopDetectionMaxGraphDepth,   int, 50,      "Maximum depth from the current/last loop closure location and the local loop closure hypotheses. Set 0 to ignore.");
-	RTABMAP_PARAM(RGBD, LocalLoopDetectionPathFilteringRadius,   float, 0.5, "Path filtering radius.");
-	RTABMAP_PARAM(RGBD, LocalLoopDetectionPathOdomPosesUsed,   bool, true, "When comparing to a local path, merge the scan using the odometry poses instead of the ones in the optimized local graph.");
+	RTABMAP_PARAM(RGBD, ProximityByTime,              bool, false, 	"Detection over all locations in STM.");
+	RTABMAP_PARAM(RGBD, ProximityBySpace,             bool, true, 	"Detection over locations (in Working Memory or STM) near in space.");
+	RTABMAP_PARAM(RGBD, ProximityPathScansMerged,     bool, true, 	"Merge close laser scans on each path. If false, only the nearest laser scan on the path is used for ICP.");
+	RTABMAP_PARAM(RGBD, ProximityMaxGraphDepth,       int, 50,      "Maximum depth from the current/last loop closure location and the local loop closure hypotheses. Set 0 to ignore.");
+	RTABMAP_PARAM(RGBD, ProximityPathFilteringRadius, float, 0.5,   "Path filtering radius.");
+	RTABMAP_PARAM(RGBD, ProximityPathRawPosesUsed,    bool, true,   "When comparing to a local path, merge the scan using the odometry poses (with neighbor link optimizations) instead of the ones in the optimized local graph.");

 	// Graph optimization
 	RTABMAP_PARAM(RGBD, OptimizeStrategy,          int, 0,       "Graph optimization strategy: 0=TORO and 1=g2o.");
--- a/corelib/include/rtabmap/core/Registration.h
+++ b/corelib/include/rtabmap/core/Registration.h
@@ -39,7 +39,7 @@ public:
 	virtual ~Registration() {}
 	virtual void parseParameters(const ParametersMap & parameters)
 	{
-		Parameters::parse(parameters, Parameters::kRegVarianceFromInliersCount(), _bowVarianceFromInliersCount);
+		Parameters::parse(parameters, Parameters::kRegVarianceFromInliersCount(), _varianceFromInliersCount);
 	}
 	virtual Transform computeTransformation(
 			const Signature & from,
@@ -51,13 +51,13 @@ public:
 			float * inliersRatioOut = 0) = 0;
 protected:
 	Registration(const ParametersMap & parameters = ParametersMap()) :
-		_bowVarianceFromInliersCount(Parameters::defaultRegVarianceFromInliersCount())
+		_varianceFromInliersCount(Parameters::defaultRegVarianceFromInliersCount())
 	{
 		this->parseParameters(parameters);
 	}

 protected:
-	bool _bowVarianceFromInliersCount;
+	bool _varianceFromInliersCount;

 };

--- a/corelib/include/rtabmap/core/RegistrationIcp.h
+++ b/corelib/include/rtabmap/core/RegistrationIcp.h
@@ -61,16 +61,16 @@ public:
 			float * inliersRatioOut = 0);

 private:
-	float _icpMaxTranslation;
-	float _icpMaxRotation;
+	float _maxTranslation;
+	float _maxRotation;
 	bool _icp2D;
-	float _icpVoxelSize;
-	int _icpDownsamplingStep;
-	float _icpMaxCorrespondenceDistance;
-	int _icpMaxIterations;
-	float _icpCorrespondenceRatio;
-	bool _icpPointToPlane;
-	int _icpPointToPlaneNormalNeighbors;
+	float _voxelSize;
+	int _downsamplingStep;
+	float _maxCorrespondenceDistance;
+	int _maxIterations;
+	float _correspondenceRatio;
+	bool _pointToPlane;
+	int _pointToPlaneNormalNeighbors;
 };

 }
--- a/corelib/include/rtabmap/core/RegistrationVis.h
+++ b/corelib/include/rtabmap/core/RegistrationVis.h
@@ -51,29 +51,29 @@ public:
 			float * varianceOut = 0,
 			float * inliersRatioOut = 0);

-	float getBowInlierDistance() const {return _bowInlierDistance;}
-	int getBowIterations() const {return _bowIterations;}
-	int getBowMinInliers() const {return _bowMinInliers;}
-	bool getBowForce2D() const {return _bowForce2D;}
+	float getBowInlierDistance() const {return _inlierDistance;}
+	int getBowIterations() const {return _iterations;}
+	int getBowMinInliers() const {return _minInliers;}
+	bool getBowForce2D() const {return _force2D;}

 private:
-	int _bowMinInliers;
-	float _bowInlierDistance;
-	int _bowIterations;
-	int _bowRefineIterations;
-	bool _bowForce2D;
-	float _bowEpipolarGeometryVar;
-	int _bowEstimationType;
-	double _bowPnPReprojError;
-	int _bowPnPFlags;
+	int _minInliers;
+	float _inlierDistance;
+	int _iterations;
+	int _refineIterations;
+	bool _force2D;
+	float _epipolarGeometryVar;
+	int _estimationType;
+	double _PnPReprojError;
+	int _PnPFlags;

-	int _reextractNNType;
-	float _reextractNNDR;
-	int _reextractFeatureType;
-	int _reextractMaxWords;
-	float _reextractMaxDepth;
-	float _reextractMinDepth;
-	std::string _reextractRoiRatios;
+	int _NNType;
+	float _NNDR;
+	int _featureType;
+	int _maxWords;
+	float _maxDepth;
+	float _minDepth;
+	std::string _roiRatios;

 	int _subPixWinSize;
 	int _subPixIterations;
--- a/corelib/include/rtabmap/core/Rtabmap.h
+++ b/corelib/include/rtabmap/core/Rtabmap.h
@@ -189,17 +189,17 @@ private:
 	float _rgbdLinearUpdate;
 	float _rgbdAngularUpdate;
 	float _newMapOdomChangeDistance;
-	bool _loopClosureIcpRefining;
-	bool _odomIcpRefining;
-	bool _localLoopClosureDetectionTime;
-	bool _localLoopClosureDetectionSpace;
+	bool _loopClosureRefining;
+	bool _neighborLinkRefining;
+	bool _proximityByTime;
+	bool _proximityBySpace;
 	bool _scanMatchingIdsSavedInLinks;
 	float _localRadius;
 	float _localImmunizationRatio;
-	int _localDetectMaxGraphDepth;
-	float _localPathFilteringRadius;
-	bool _localPathOdomPosesUsed;
-	bool _localPathScansMerged;
+	int _proximityMaxGraphDepth;
+	float _proximityFilteringRadius;
+	bool _proximityRawPosesUsed;
+	bool _proximityScansMerged;
 	std::string _databasePath;
 	bool _optimizeFromGraphEnd;
 	float _optimizationMaxLinearError;
--- a/corelib/src/Memory.cpp
+++ b/corelib/src/Memory.cpp
@@ -82,7 +82,6 @@ Memory::Memory(const ParametersMap & parameters) :
 	_badSignaturesIgnored(Parameters::defaultMemBadSignaturesIgnored()),
 	_imageDecimation(Parameters::defaultMemImageDecimation()),
 	_laserScanDownsampleStepSize(Parameters::defaultMemLaserScanDownsampleStepSize()),
-	_localSpaceLinksKeptInWM(Parameters::defaultMemLocalSpaceLinksKeptInWM()),
 	_reextractLoopClosureFeatures(Parameters::defaultRGBDLoopClosureReextractFeatures()),
 	_rehearsalMaxDistance(Parameters::defaultRGBDLinearUpdate()),
 	_rehearsalMaxAngle(Parameters::defaultRGBDAngularUpdate()),
@@ -399,7 +398,6 @@ void Memory::parseParameters(const ParametersMap & parameters)
 	Parameters::parse(parameters, Parameters::kMemSTMSize(), _maxStMemSize);
 	Parameters::parse(parameters, Parameters::kMemImageDecimation(), _imageDecimation);
 	Parameters::parse(parameters, Parameters::kMemLaserScanDownsampleStepSize(), _laserScanDownsampleStepSize);
-	Parameters::parse(parameters, Parameters::kMemLocalSpaceLinksKeptInWM(), _localSpaceLinksKeptInWM);
 	Parameters::parse(parameters, Parameters::kRGBDLoopClosureReextractFeatures(), _reextractLoopClosureFeatures);
 	Parameters::parse(parameters, Parameters::kRGBDLinearUpdate(), _rehearsalMaxDistance);
 	Parameters::parse(parameters, Parameters::kRGBDAngularUpdate(), _rehearsalMaxAngle);
@@ -748,27 +746,6 @@ void Memory::moveSignatureToWMFromSTM(int id, int * reducedTo)
 	UASSERT(_stMem.find(id) != _stMem.end());
 	Signature * s = this->_getSignature(id);
 	UASSERT(s!=0);
-	if(!_localSpaceLinksKeptInWM)
-	{
-		// remove local space links outside STM
-		std::map<int, Link> links = s->getLinks(); // get a copy because we will remove some links in "s"
-		for(std::map<int, Link>::iterator iter=links.begin(); iter!=links.end(); ++iter)
-		{
-			if(iter->second.type() == Link::kLocalSpaceClosure)
-			{
-				Signature * sTo = this->_getSignature(iter->first);
-				if(sTo)
-				{
-					sTo->removeLink(s->id());
-				}
-				else
-				{
-					UERROR("Link %d of %d not in WM/STM?!?", iter->first, s->id());
-				}
-				s->removeLink(iter->first);
-			}
-		}
-	}

 	if(_reduceGraph)
 	{
--- a/corelib/src/Parameters.cpp
+++ b/corelib/src/Parameters.cpp
@@ -76,9 +76,12 @@ const std::map<std::string, std::pair<bool, std::string> > & Parameters::getRemo
 	if(removedParameters_.empty())
 	{
 		// removed parameters
-		removedParameters_.insert(std::make_pair("Mem/LaserScanVoxelSize",        std::make_pair(false, Parameters::kMemLaserScanDownsampleStepSize())));

-		removedParameters_.insert(std::make_pair("RGBD/PoseScanMatching",         std::make_pair(true,  Parameters::kRGBDIcpOdomRefining())));
+		// 0.11.0
+		removedParameters_.insert(std::make_pair("Mem/LaserScanVoxelSize",        std::make_pair(false, Parameters::kMemLaserScanDownsampleStepSize())));
+		removedParameters_.insert(std::make_pair("Mem/LocalSpaceLinksKeptInWM",   std::make_pair(false, "")));
+
+		removedParameters_.insert(std::make_pair("RGBD/PoseScanMatching",         std::make_pair(true,  Parameters::kRGBDNeighborLinkRefining())));

 		removedParameters_.insert(std::make_pair("Odom/FeatureType",              std::make_pair(true,  Parameters::kVisFeatureType())));
 		removedParameters_.insert(std::make_pair("Odom/EstimationType",           std::make_pair(true,  Parameters::kVisEstimationType())));
@@ -101,7 +104,7 @@ const std::map<std::string, std::pair<bool, std::string> > & Parameters::getRemo
 		removedParameters_.insert(std::make_pair("OdomSubPix/Iterations",         std::make_pair(true,  Parameters::kVisSubPixIterations())));
 		removedParameters_.insert(std::make_pair("OdomSubPix/Eps",                std::make_pair(true,  Parameters::kVisSubPixEps())));

-		removedParameters_.insert(std::make_pair("LccReextract/Activated",         std::make_pair(false,  Parameters::kRGBDLoopClosureReextractFeatures())));
+		removedParameters_.insert(std::make_pair("LccReextract/Activated",         std::make_pair(true,   Parameters::kRGBDLoopClosureReextractFeatures())));
 		removedParameters_.insert(std::make_pair("LccReextract/FeatureType",       std::make_pair(false,  Parameters::kVisFeatureType())));
 		removedParameters_.insert(std::make_pair("LccReextract/MaxWords",          std::make_pair(false,  Parameters::kVisMaxFeatures())));
 		removedParameters_.insert(std::make_pair("LccReextract/MaxDepth",          std::make_pair(false,  Parameters::kVisMaxDepth())));
@@ -120,7 +123,7 @@ const std::map<std::string, std::pair<bool, std::string> > & Parameters::getRemo
 		removedParameters_.insert(std::make_pair("LccBow/PnPFlags",                 std::make_pair(false,  Parameters::kVisPnPFlags())));
 		removedParameters_.insert(std::make_pair("LccBow/EpipolarGeometryVar",      std::make_pair(true,   Parameters::kVisEpipolarGeometryVar())));

-		removedParameters_.insert(std::make_pair("LccIcp/Type",                         std::make_pair(true,  Parameters::kRGBDIcpLoopClosureRefining())));
+		removedParameters_.insert(std::make_pair("LccIcp/Type",                         std::make_pair(true,  Parameters::kRGBDLoopClosureLinkRefining())));

 		removedParameters_.insert(std::make_pair("LccIcp3/Decimation",                  std::make_pair(false, "")));
 		removedParameters_.insert(std::make_pair("LccIcp3/MaxDepth",                    std::make_pair(false, "")));
@@ -136,6 +139,31 @@ const std::map<std::string, std::pair<bool, std::string> > & Parameters::getRemo
 		removedParameters_.insert(std::make_pair("LccIcp2/Iterations",                  std::make_pair(true,  Parameters::kIcpIterations())));
 		removedParameters_.insert(std::make_pair("LccIcp2/CorrespondenceRatio",         std::make_pair(true,  Parameters::kIcpCorrespondenceRatio())));
 		removedParameters_.insert(std::make_pair("LccIcp2/VoxelSize",                   std::make_pair(true,  Parameters::kIcpVoxelSize())));
+
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionByTime",              std::make_pair(true,  Parameters::kRGBDProximityByTime())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionBySpace",             std::make_pair(true,  Parameters::kRGBDProximityBySpace())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionPathScansMerged",     std::make_pair(true,  Parameters::kRGBDProximityPathScansMerged())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionMaxGraphDepth",       std::make_pair(true,  Parameters::kRGBDProximityMaxGraphDepth())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionPathFilteringRadius", std::make_pair(true,  Parameters::kRGBDProximityPathFilteringRadius())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionPathRawPosesUsed",    std::make_pair(true,  Parameters::kRGBDProximityPathRawPosesUsed())));
+
+		// before 0.11.0
+		removedParameters_.insert(std::make_pair("GFTT/MaxCorners",                  std::make_pair(true, Parameters::kVisMaxFeatures())));
+		removedParameters_.insert(std::make_pair("LccBow/MaxDepth",                  std::make_pair(true, Parameters::kVisMaxDepth())));
+		removedParameters_.insert(std::make_pair("LccReextract/LoopClosureFeatures", std::make_pair(true, Parameters::kRGBDLoopClosureReextractFeatures())));
+		removedParameters_.insert(std::make_pair("Rtabmap/DetectorStrategy",         std::make_pair(true, Parameters::kKpDetectorStrategy())));
+		removedParameters_.insert(std::make_pair("RGBD/ScanMatchingSize",            std::make_pair(true, Parameters::kRGBDNeighborLinkRefining())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionRadius",    std::make_pair(true, Parameters::kRGBDLocalRadius())));
+		removedParameters_.insert(std::make_pair("RGBD/ToroIterations",              std::make_pair(true, Parameters::kRGBDOptimizeIterations())));
+		removedParameters_.insert(std::make_pair("Mem/RehearsedNodesKept",           std::make_pair(true, Parameters::kMemNotLinkedNodesKept())));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionMaxDiffID", std::make_pair(true, Parameters::kRGBDProximityMaxGraphDepth())));
+		removedParameters_.insert(std::make_pair("RGBD/PlanVirtualLinksMaxDiffID",   std::make_pair(false, "")));
+		removedParameters_.insert(std::make_pair("RGBD/LocalLoopDetectionMaxDiffID", std::make_pair(false, "")));
+		removedParameters_.insert(std::make_pair("Odom/Type",                        std::make_pair(true, Parameters::kVisFeatureType())));
+		removedParameters_.insert(std::make_pair("Odom/MaxWords",                    std::make_pair(true, Parameters::kVisMaxFeatures())));
+		removedParameters_.insert(std::make_pair("Odom/LocalHistory",                std::make_pair(true, Parameters::kOdomBowLocalHistorySize())));
+		removedParameters_.insert(std::make_pair("Odom/NearestNeighbor",             std::make_pair(true, Parameters::kVisNNType())));
+		removedParameters_.insert(std::make_pair("Odom/NNDR",                        std::make_pair(true, Parameters::kVisNNDR())));
 	}
 	return removedParameters_;
 }
--- a/corelib/src/RegistrationIcp.cpp
+++ b/corelib/src/RegistrationIcp.cpp
@@ -40,16 +40,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace rtabmap {

 RegistrationIcp::RegistrationIcp(const ParametersMap & parameters) :
-	_icpMaxTranslation(Parameters::defaultIcpMaxTranslation()),
-	_icpMaxRotation(Parameters::defaultIcpMaxRotation()),
+	_maxTranslation(Parameters::defaultIcpMaxTranslation()),
+	_maxRotation(Parameters::defaultIcpMaxRotation()),
 	_icp2D(Parameters::defaultIcp2D()),
-	_icpVoxelSize(Parameters::defaultIcpVoxelSize()),
-	_icpDownsamplingStep(Parameters::defaultIcpDownsamplingStep()),
-	_icpMaxCorrespondenceDistance(Parameters::defaultIcpMaxCorrespondenceDistance()),
-	_icpMaxIterations(Parameters::defaultIcpIterations()),
-	_icpCorrespondenceRatio(Parameters::defaultIcpCorrespondenceRatio()),
-	_icpPointToPlane(Parameters::defaultIcpPointToPlane()),
-	_icpPointToPlaneNormalNeighbors(Parameters::defaultIcpPointToPlaneNormalNeighbors())
+	_voxelSize(Parameters::defaultIcpVoxelSize()),
+	_downsamplingStep(Parameters::defaultIcpDownsamplingStep()),
+	_maxCorrespondenceDistance(Parameters::defaultIcpMaxCorrespondenceDistance()),
+	_maxIterations(Parameters::defaultIcpIterations()),
+	_correspondenceRatio(Parameters::defaultIcpCorrespondenceRatio()),
+	_pointToPlane(Parameters::defaultIcpPointToPlane()),
+	_pointToPlaneNormalNeighbors(Parameters::defaultIcpPointToPlaneNormalNeighbors())
 {
 	this->parseParameters(parameters);
 }
@@ -58,23 +58,23 @@ void RegistrationIcp::parseParameters(const ParametersMap & parameters)
 {
 	Registration::parseParameters(parameters);

-	Parameters::parse(parameters, Parameters::kIcpMaxTranslation(), _icpMaxTranslation);
-	Parameters::parse(parameters, Parameters::kIcpMaxRotation(), _icpMaxRotation);
+	Parameters::parse(parameters, Parameters::kIcpMaxTranslation(), _maxTranslation);
+	Parameters::parse(parameters, Parameters::kIcpMaxRotation(), _maxRotation);
 	Parameters::parse(parameters, Parameters::kIcp2D(), _icp2D);
-	Parameters::parse(parameters, Parameters::kIcpVoxelSize(), _icpVoxelSize);
-	Parameters::parse(parameters, Parameters::kIcpDownsamplingStep(), _icpDownsamplingStep);
-	Parameters::parse(parameters, Parameters::kIcpMaxCorrespondenceDistance(), _icpMaxCorrespondenceDistance);
-	Parameters::parse(parameters, Parameters::kIcpIterations(), _icpMaxIterations);
-	Parameters::parse(parameters, Parameters::kIcpCorrespondenceRatio(), _icpCorrespondenceRatio);
-	Parameters::parse(parameters, Parameters::kIcpPointToPlane(), _icpPointToPlane);
-	Parameters::parse(parameters, Parameters::kIcpPointToPlaneNormalNeighbors(), _icpPointToPlaneNormalNeighbors);
+	Parameters::parse(parameters, Parameters::kIcpVoxelSize(), _voxelSize);
+	Parameters::parse(parameters, Parameters::kIcpDownsamplingStep(), _downsamplingStep);
+	Parameters::parse(parameters, Parameters::kIcpMaxCorrespondenceDistance(), _maxCorrespondenceDistance);
+	Parameters::parse(parameters, Parameters::kIcpIterations(), _maxIterations);
+	Parameters::parse(parameters, Parameters::kIcpCorrespondenceRatio(), _correspondenceRatio);
+	Parameters::parse(parameters, Parameters::kIcpPointToPlane(), _pointToPlane);
+	Parameters::parse(parameters, Parameters::kIcpPointToPlaneNormalNeighbors(), _pointToPlaneNormalNeighbors);

-	UASSERT_MSG(_icpVoxelSize >= 0, uFormat("value=%d", _icpVoxelSize).c_str());
-	UASSERT_MSG(_icpDownsamplingStep >= 0, uFormat("value=%d", _icpDownsamplingStep).c_str());
-	UASSERT_MSG(_icpMaxCorrespondenceDistance > 0.0f, uFormat("value=%f", _icpMaxCorrespondenceDistance).c_str());
-	UASSERT_MSG(_icpMaxIterations > 0, uFormat("value=%d", _icpMaxIterations).c_str());
-	UASSERT_MSG(_icpCorrespondenceRatio >=0.0f && _icpCorrespondenceRatio <=1.0f, uFormat("value=%f", _icpCorrespondenceRatio).c_str());
-	UASSERT_MSG(_icpPointToPlaneNormalNeighbors > 0, uFormat("value=%d", _icpPointToPlaneNormalNeighbors).c_str());
+	UASSERT_MSG(_voxelSize >= 0, uFormat("value=%d", _voxelSize).c_str());
+	UASSERT_MSG(_downsamplingStep >= 0, uFormat("value=%d", _downsamplingStep).c_str());
+	UASSERT_MSG(_maxCorrespondenceDistance > 0.0f, uFormat("value=%f", _maxCorrespondenceDistance).c_str());
+	UASSERT_MSG(_maxIterations > 0, uFormat("value=%d", _maxIterations).c_str());
+	UASSERT_MSG(_correspondenceRatio >=0.0f && _correspondenceRatio <=1.0f, uFormat("value=%f", _correspondenceRatio).c_str());
+	UASSERT_MSG(_pointToPlaneNormalNeighbors > 0, uFormat("value=%d", _pointToPlaneNormalNeighbors).c_str());
 }

 Transform RegistrationIcp::computeTransformation(
@@ -106,17 +106,17 @@ Transform RegistrationIcp::computeTransformation(
 			float * inliersRatioOut)
 {
 	UDEBUG("Guess transform = %s", guess.prettyPrint().c_str());
-	UDEBUG("Voxel size=%f", _icpVoxelSize);
+	UDEBUG("Voxel size=%f", _voxelSize);
 	UDEBUG("2D=%d", _icp2D?1:0);
-	UDEBUG("PointToPlane=%d", _icpPointToPlane?1:0);
-	UDEBUG("Normal neighborhood=%d", _icpPointToPlaneNormalNeighbors);
-	UDEBUG("Max corrrespondence distance=%f", _icpMaxCorrespondenceDistance);
-	UDEBUG("Max Iterations=%d", _icpMaxIterations);
-	UDEBUG("Variance from inliers count=%d", _bowVarianceFromInliersCount?1:0);
-	UDEBUG("Correspondence Ratio=%f", _icpCorrespondenceRatio);
-	UDEBUG("Max translation=%f", _icpMaxTranslation);
-	UDEBUG("Max rotation=%f", _icpMaxRotation);
-	UDEBUG("Downsampling step=%d", _icpDownsamplingStep);
+	UDEBUG("PointToPlane=%d", _pointToPlane?1:0);
+	UDEBUG("Normal neighborhood=%d", _pointToPlaneNormalNeighbors);
+	UDEBUG("Max corrrespondence distance=%f", _maxCorrespondenceDistance);
+	UDEBUG("Max Iterations=%d", _maxIterations);
+	UDEBUG("Variance from inliers count=%d", _varianceFromInliersCount?1:0);
+	UDEBUG("Correspondence Ratio=%f", _correspondenceRatio);
+	UDEBUG("Max translation=%f", _maxTranslation);
+	UDEBUG("Max rotation=%f", _maxRotation);
+	UDEBUG("Downsampling step=%d", _downsamplingStep);

 	std::string msg;
 	Transform transform;
@@ -127,11 +127,11 @@ Transform RegistrationIcp::computeTransformation(
 		int maxLaserScans = dataTo.laserScanMaxPts();
 		cv::Mat fromScan = dataFrom.laserScanRaw();
 		cv::Mat toScan = dataTo.laserScanRaw();
-		if(_icpDownsamplingStep>1)
+		if(_downsamplingStep>1)
 		{
-			fromScan = util3d::downsample(fromScan, _icpDownsamplingStep);
-			toScan = util3d::downsample(toScan, _icpDownsamplingStep);
-			maxLaserScans/=_icpDownsamplingStep;
+			fromScan = util3d::downsample(fromScan, _downsamplingStep);
+			toScan = util3d::downsample(toScan, _downsamplingStep);
+			maxLaserScans/=_downsamplingStep;
 		}

 		pcl::PointCloud<pcl::PointXYZ>::Ptr fromCloud = util3d::laserScanToPointCloud(fromScan, Transform());
@@ -143,10 +143,10 @@ Transform RegistrationIcp::computeTransformation(
 			pcl::PointCloud<pcl::PointXYZ>::Ptr fromCloudFiltered = fromCloud;
 			pcl::PointCloud<pcl::PointXYZ>::Ptr toCloudFiltered = toCloud;
 			bool filtered = false;
-			if(_icpVoxelSize > 0.0f)
+			if(_voxelSize > 0.0f)
 			{
-				fromCloudFiltered = util3d::voxelize(fromCloudFiltered, _icpVoxelSize);
-				toCloudFiltered = util3d::voxelize(toCloudFiltered, _icpVoxelSize);
+				fromCloudFiltered = util3d::voxelize(fromCloudFiltered, _voxelSize);
+				toCloudFiltered = util3d::voxelize(toCloudFiltered, _voxelSize);
 				filtered = true;
 			}

@@ -159,10 +159,10 @@ Transform RegistrationIcp::computeTransformation(
 			pcl::PointCloud<pcl::PointXYZ>::Ptr newCloudRegistered(new pcl::PointCloud<pcl::PointXYZ>());
 			if(!_icp2D) // 3D ICP
 			{
-				if(_icpPointToPlane)
+				if(_pointToPlane)
 				{
-					pcl::PointCloud<pcl::PointNormal>::Ptr fromCloudNormals = util3d::computeNormals(fromCloudFiltered, _icpPointToPlaneNormalNeighbors);
-					pcl::PointCloud<pcl::PointNormal>::Ptr toCloudNormals = util3d::computeNormals(toCloudFiltered, _icpPointToPlaneNormalNeighbors);
+					pcl::PointCloud<pcl::PointNormal>::Ptr fromCloudNormals = util3d::computeNormals(fromCloudFiltered, _pointToPlaneNormalNeighbors);
+					pcl::PointCloud<pcl::PointNormal>::Ptr toCloudNormals = util3d::computeNormals(toCloudFiltered, _pointToPlaneNormalNeighbors);

 					std::vector<int> indices;
 					toCloudNormals = util3d::removeNaNNormalsFromPointCloud(toCloudNormals);
@@ -174,8 +174,8 @@ Transform RegistrationIcp::computeTransformation(
 						icpT = util3d::icpPointToPlane(
 								toCloudNormals,
 								fromCloudNormals,
-							   _icpMaxCorrespondenceDistance,
-							   _icpMaxIterations,
+							   _maxCorrespondenceDistance,
+							   _maxIterations,
 							   hasConverged,
 							   *newCloudNormalsRegistered);
 						if(!filtered &&
@@ -185,7 +185,7 @@ Transform RegistrationIcp::computeTransformation(
 							util3d::computeVarianceAndCorrespondences(
 								newCloudNormalsRegistered,
 								fromCloudNormals,
-								_icpMaxCorrespondenceDistance,
+								_maxCorrespondenceDistance,
 								variance,
 								correspondences);
 							correspondencesComputed = true;
@@ -197,8 +197,8 @@ Transform RegistrationIcp::computeTransformation(
 					icpT = util3d::icp(
 							toCloudFiltered,
 							fromCloudFiltered,
-							_icpMaxCorrespondenceDistance,
-							_icpMaxIterations,
+							_maxCorrespondenceDistance,
+							_maxIterations,
 							hasConverged,
 							*newCloudRegistered);
 				}
@@ -208,8 +208,8 @@ Transform RegistrationIcp::computeTransformation(
 				icpT = util3d::icp2D(
 							toCloudFiltered,
 							fromCloudFiltered,
-						   _icpMaxCorrespondenceDistance,
-						   _icpMaxIterations,
+						   _maxCorrespondenceDistance,
+						   _maxIterations,
 						   hasConverged,
 						   *newCloudRegistered);
 			}
@@ -229,21 +229,21 @@ Transform RegistrationIcp::computeTransformation(
 			{
 				float ix,iy,iz, iroll,ipitch,iyaw;
 				icpT.getTranslationAndEulerAngles(ix,iy,iz,iroll,ipitch,iyaw);
-				if((_icpMaxTranslation>0.0f &&
-					(fabs(ix) > _icpMaxTranslation ||
-					 fabs(iy) > _icpMaxTranslation ||
-					 fabs(iz) > _icpMaxTranslation))
+				if((_maxTranslation>0.0f &&
+					(fabs(ix) > _maxTranslation ||
+					 fabs(iy) > _maxTranslation ||
+					 fabs(iz) > _maxTranslation))
 					||
-					(_icpMaxRotation>0.0f &&
-					 (fabs(iroll) > _icpMaxRotation ||
-					  fabs(ipitch) > _icpMaxRotation ||
-					  fabs(iyaw) > _icpMaxRotation)))
+					(_maxRotation>0.0f &&
+					 (fabs(iroll) > _maxRotation ||
+					  fabs(ipitch) > _maxRotation ||
+					  fabs(iyaw) > _maxRotation)))
 				{
 					msg = uFormat("Cannot compute transform (ICP correction too large -> %f m %f rad, limits=%f m, %f rad)",
 							uMax3(fabs(ix), fabs(iy), fabs(iz)),
 							uMax3(fabs(iroll), fabs(ipitch), fabs(iyaw)),
-							_icpMaxTranslation,
-							_icpMaxRotation);
+							_maxTranslation,
+							_maxRotation);
 					UINFO(msg.c_str());
 				}
 				else
@@ -262,7 +262,7 @@ Transform RegistrationIcp::computeTransformation(
 						util3d::computeVarianceAndCorrespondences(
 								toCloud,
 								fromCloud,
-								_icpMaxCorrespondenceDistance,
+								_maxCorrespondenceDistance,
 								variance,
 								correspondences);
 					}
@@ -287,7 +287,7 @@ Transform RegistrationIcp::computeTransformation(
 							maxLaserScans>0?maxLaserScans:dataTo.laserScanMaxPts()?dataTo.laserScanMaxPts():(int)(toCloud->size()>fromCloud->size()?toCloud->size():fromCloud->size()),
 							correspondencesRatio*100.0f);

-					if(_bowVarianceFromInliersCount)
+					if(_varianceFromInliersCount)
 					{
 						variance = correspondencesRatio > 0?1.0/double(correspondencesRatio):1.0;
 					}
@@ -305,10 +305,10 @@ Transform RegistrationIcp::computeTransformation(
 						*inliersRatioOut = correspondencesRatio;
 					}

-					if(correspondencesRatio < _icpCorrespondenceRatio)
+					if(correspondencesRatio < _correspondenceRatio)
 					{
 						msg = uFormat("Cannot compute transform (cor=%d corrRatio=%f/%f)",
-								correspondences, correspondencesRatio, _icpCorrespondenceRatio);
+								correspondences, correspondencesRatio, _correspondenceRatio);
 						UINFO(msg.c_str());
 					}
 					else
--- a/corelib/src/RegistrationVis.cpp
+++ b/corelib/src/RegistrationVis.cpp
@@ -39,22 +39,22 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace rtabmap {

 RegistrationVis::RegistrationVis(const ParametersMap & parameters) :
-		_bowMinInliers(Parameters::defaultVisMinInliers()),
-		_bowInlierDistance(Parameters::defaultVisInlierDistance()),
-		_bowIterations(Parameters::defaultVisIterations()),
-		_bowRefineIterations(Parameters::defaultVisRefineIterations()),
-		_bowForce2D(Parameters::defaultVisForce2D()),
-		_bowEpipolarGeometryVar(Parameters::defaultVisEpipolarGeometryVar()),
-		_bowEstimationType(Parameters::defaultVisEstimationType()),
-		_bowPnPReprojError(Parameters::defaultVisPnPReprojError()),
-		_bowPnPFlags(Parameters::defaultVisPnPFlags()),
-		_reextractNNType(Parameters::defaultVisNNType()),
-		_reextractNNDR(Parameters::defaultVisNNDR()),
-		_reextractFeatureType(Parameters::defaultVisFeatureType()),
-		_reextractMaxWords(Parameters::defaultVisMaxFeatures()),
-		_reextractMaxDepth(Parameters::defaultVisMaxDepth()),
-		_reextractMinDepth(Parameters::defaultVisMinDepth()),
-		_reextractRoiRatios(Parameters::defaultVisRoiRatios()),
+		_minInliers(Parameters::defaultVisMinInliers()),
+		_inlierDistance(Parameters::defaultVisInlierDistance()),
+		_iterations(Parameters::defaultVisIterations()),
+		_refineIterations(Parameters::defaultVisRefineIterations()),
+		_force2D(Parameters::defaultVisForce2D()),
+		_epipolarGeometryVar(Parameters::defaultVisEpipolarGeometryVar()),
+		_estimationType(Parameters::defaultVisEstimationType()),
+		_PnPReprojError(Parameters::defaultVisPnPReprojError()),
+		_PnPFlags(Parameters::defaultVisPnPFlags()),
+		_NNType(Parameters::defaultVisNNType()),
+		_NNDR(Parameters::defaultVisNNDR()),
+		_featureType(Parameters::defaultVisFeatureType()),
+		_maxWords(Parameters::defaultVisMaxFeatures()),
+		_maxDepth(Parameters::defaultVisMaxDepth()),
+		_minDepth(Parameters::defaultVisMinDepth()),
+		_roiRatios(Parameters::defaultVisRoiRatios()),
 		_subPixWinSize(Parameters::defaultKpSubPixWinSize()),
 		_subPixIterations(Parameters::defaultKpSubPixIterations()),
 		_subPixEps(Parameters::defaultKpSubPixEps())
@@ -66,29 +66,29 @@ void RegistrationVis::parseParameters(const ParametersMap & parameters)
 {
 	Registration::parseParameters(parameters);

-	Parameters::parse(parameters, Parameters::kVisMinInliers(), _bowMinInliers);
-	Parameters::parse(parameters, Parameters::kVisInlierDistance(), _bowInlierDistance);
-	Parameters::parse(parameters, Parameters::kVisIterations(), _bowIterations);
-	Parameters::parse(parameters, Parameters::kVisRefineIterations(), _bowRefineIterations);
-	Parameters::parse(parameters, Parameters::kVisForce2D(), _bowForce2D);
-	Parameters::parse(parameters, Parameters::kVisEstimationType(), _bowEstimationType);
-	Parameters::parse(parameters, Parameters::kVisEpipolarGeometryVar(), _bowEpipolarGeometryVar);
-	Parameters::parse(parameters, Parameters::kVisPnPReprojError(), _bowPnPReprojError);
-	Parameters::parse(parameters, Parameters::kVisPnPFlags(), _bowPnPFlags);
+	Parameters::parse(parameters, Parameters::kVisMinInliers(), _minInliers);
+	Parameters::parse(parameters, Parameters::kVisInlierDistance(), _inlierDistance);
+	Parameters::parse(parameters, Parameters::kVisIterations(), _iterations);
+	Parameters::parse(parameters, Parameters::kVisRefineIterations(), _refineIterations);
+	Parameters::parse(parameters, Parameters::kVisForce2D(), _force2D);
+	Parameters::parse(parameters, Parameters::kVisEstimationType(), _estimationType);
+	Parameters::parse(parameters, Parameters::kVisEpipolarGeometryVar(), _epipolarGeometryVar);
+	Parameters::parse(parameters, Parameters::kVisPnPReprojError(), _PnPReprojError);
+	Parameters::parse(parameters, Parameters::kVisPnPFlags(), _PnPFlags);

-	Parameters::parse(parameters, Parameters::kVisNNType(), _reextractNNType);
-	Parameters::parse(parameters, Parameters::kVisNNDR(), _reextractNNDR);
-	Parameters::parse(parameters, Parameters::kVisFeatureType(), _reextractFeatureType);
-	Parameters::parse(parameters, Parameters::kVisMaxFeatures(), _reextractMaxWords);
-	Parameters::parse(parameters, Parameters::kVisMaxDepth(), _reextractMaxDepth);
+	Parameters::parse(parameters, Parameters::kVisNNType(), _NNType);
+	Parameters::parse(parameters, Parameters::kVisNNDR(), _NNDR);
+	Parameters::parse(parameters, Parameters::kVisFeatureType(), _featureType);
+	Parameters::parse(parameters, Parameters::kVisMaxFeatures(), _maxWords);
+	Parameters::parse(parameters, Parameters::kVisMaxDepth(), _maxDepth);

 	Parameters::parse(parameters, Parameters::kKpSubPixWinSize(), _subPixWinSize);
 	Parameters::parse(parameters, Parameters::kKpSubPixIterations(), _subPixIterations);
 	Parameters::parse(parameters, Parameters::kKpSubPixEps(), _subPixEps);

-	UASSERT_MSG(_bowMinInliers >= 1, uFormat("value=%d", _bowMinInliers).c_str());
-	UASSERT_MSG(_bowInlierDistance > 0.0f, uFormat("value=%f", _bowInlierDistance).c_str());
-	UASSERT_MSG(_bowIterations > 0, uFormat("value=%d", _bowIterations).c_str());
+	UASSERT_MSG(_minInliers >= 1, uFormat("value=%d", _minInliers).c_str());
+	UASSERT_MSG(_inlierDistance > 0.0f, uFormat("value=%f", _inlierDistance).c_str());
+	UASSERT_MSG(_iterations > 0, uFormat("value=%d", _iterations).c_str());
 }

 Transform RegistrationVis::computeTransformation(
@@ -125,17 +125,17 @@ Transform RegistrationVis::computeTransformation(
 		uInsert(customParameters, ParametersPair(Parameters::kMemSTMSize(), "0"));
 		uInsert(customParameters, ParametersPair(Parameters::kKpIncrementalDictionary(), "true")); // make sure it is incremental
 		uInsert(customParameters, ParametersPair(Parameters::kKpNewWordsComparedTogether(), "false"));
-		uInsert(customParameters, ParametersPair(Parameters::kKpNNStrategy(), uNumber2Str(_reextractNNType))); // bruteforce
-		uInsert(customParameters, ParametersPair(Parameters::kKpNndrRatio(), uNumber2Str(_reextractNNDR)));
-		uInsert(customParameters, ParametersPair(Parameters::kKpDetectorStrategy(), uNumber2Str(_reextractFeatureType))); // FAST/BRIEF
-		uInsert(customParameters, ParametersPair(Parameters::kKpWordsPerImage(), uNumber2Str(_reextractMaxWords)));
-		uInsert(customParameters, ParametersPair(Parameters::kKpMaxDepth(), uNumber2Str(_reextractMaxDepth)));
-		uInsert(customParameters, ParametersPair(Parameters::kKpMinDepth(), uNumber2Str(_reextractMinDepth)));
+		uInsert(customParameters, ParametersPair(Parameters::kKpNNStrategy(), uNumber2Str(_NNType))); // bruteforce
+		uInsert(customParameters, ParametersPair(Parameters::kKpNndrRatio(), uNumber2Str(_NNDR)));
+		uInsert(customParameters, ParametersPair(Parameters::kKpDetectorStrategy(), uNumber2Str(_featureType))); // FAST/BRIEF
+		uInsert(customParameters, ParametersPair(Parameters::kKpWordsPerImage(), uNumber2Str(_maxWords)));
+		uInsert(customParameters, ParametersPair(Parameters::kKpMaxDepth(), uNumber2Str(_maxDepth)));
+		uInsert(customParameters, ParametersPair(Parameters::kKpMinDepth(), uNumber2Str(_minDepth)));
 		uInsert(customParameters, ParametersPair(Parameters::kKpSubPixEps(), uNumber2Str(_subPixEps)));
 		uInsert(customParameters, ParametersPair(Parameters::kKpSubPixIterations(), uNumber2Str(_subPixIterations)));
 		uInsert(customParameters, ParametersPair(Parameters::kKpSubPixWinSize(), uNumber2Str(_subPixWinSize)));
 		uInsert(customParameters, ParametersPair(Parameters::kKpBadSignRatio(), "0"));
-		uInsert(customParameters, ParametersPair(Parameters::kKpRoiRatios(), _reextractRoiRatios));
+		uInsert(customParameters, ParametersPair(Parameters::kKpRoiRatios(), _roiRatios));
 		uInsert(customParameters, ParametersPair(Parameters::kMemGenerateIds(), "true"));

 		Memory memory(customParameters);
@@ -186,7 +186,7 @@ Transform RegistrationVis::computeTransformation(
 		words3To = &toSignature.getWords3();
 	}

-	if(_bowEstimationType == 2) // Epipolar Geometry
+	if(_estimationType == 2) // Epipolar Geometry
 	{
 		if(!toSignature.sensorData().stereoCameraModel().isValid() &&
 		   (toSignature.sensorData().cameraModels().size() != 1 ||
@@ -194,8 +194,8 @@ Transform RegistrationVis::computeTransformation(
 		{
 			UERROR("Calibrated camera required (multi-cameras not supported).");
 		}
-		else if((int)wordsFrom->size() >= _bowMinInliers &&
-				(int)wordsTo->size() >= _bowMinInliers)
+		else if((int)wordsFrom->size() >= _minInliers &&
+				(int)wordsTo->size() >= _minInliers)
 		{
 			UASSERT(fromSignature.sensorData().stereoCameraModel().isValid() || (fromSignature.sensorData().cameraModels().size() == 1 && fromSignature.sensorData().cameraModels()[0].isValid()));
 			const CameraModel & cameraModel = fromSignature.sensorData().stereoCameraModel().isValid()?fromSignature.sensorData().stereoCameraModel().left():fromSignature.sensorData().cameraModels()[0];
@@ -207,9 +207,9 @@ Transform RegistrationVis::computeTransformation(
 					*wordsTo,
 					cameraModel,
 					cameraTransform,
-					_bowIterations,
-					_bowPnPReprojError,
-					_bowPnPFlags, // cv::SOLVEPNP_ITERATIVE
+					_iterations,
+					_PnPReprojError,
+					_PnPFlags, // cv::SOLVEPNP_ITERATIVE
 					1.0f,
 					0.99f,
 					*words3From, // for scale estimation
@@ -219,21 +219,21 @@ Transform RegistrationVis::computeTransformation(

 			if(!cameraTransform.isNull())
 			{
-				if((int)inliers3D.size() >= _bowMinInliers)
+				if((int)inliers3D.size() >= _minInliers)
 				{
-					if(variance <= _bowEpipolarGeometryVar)
+					if(variance <= _epipolarGeometryVar)
 					{
 						transform = cameraTransform;
 					}
 					else
 					{
-						msg = uFormat("Variance is too high! (max inlier distance=%f, variance=%f)", _bowEpipolarGeometryVar, variance);
+						msg = uFormat("Variance is too high! (max inlier distance=%f, variance=%f)", _epipolarGeometryVar, variance);
 						UINFO(msg.c_str());
 					}
 				}
 				else
 				{
-					msg = uFormat("Not enough inliers %d < %d", (int)inliers3D.size(), _bowMinInliers);
+					msg = uFormat("Not enough inliers %d < %d", (int)inliers3D.size(), _minInliers);
 					UINFO(msg.c_str());
 				}
 			}
@@ -254,7 +254,7 @@ Transform RegistrationVis::computeTransformation(
 			UWARN(msg.c_str());
 		}
 	}
-	else if(_bowEstimationType == 1) // PnP
+	else if(_estimationType == 1) // PnP
 	{
 		if(!toSignature.sensorData().stereoCameraModel().isValid() &&
 		   (toSignature.sensorData().cameraModels().size() != 1 ||
@@ -269,8 +269,8 @@ Transform RegistrationVis::computeTransformation(
 		else
 		{
 			// 3D to 2D
-			if((int)words3From->size() >= _bowMinInliers &&
-			   (int)wordsTo->size() >= _bowMinInliers)
+			if((int)words3From->size() >= _minInliers &&
+			   (int)wordsTo->size() >= _minInliers)
 			{
 				UASSERT(toSignature.sensorData().stereoCameraModel().isValid() || (toSignature.sensorData().cameraModels().size() == 1 && toSignature.sensorData().cameraModels()[0].isValid()));
 				const CameraModel & cameraModel = toSignature.sensorData().stereoCameraModel().isValid()?toSignature.sensorData().stereoCameraModel().left():toSignature.sensorData().cameraModels()[0];
@@ -280,10 +280,10 @@ Transform RegistrationVis::computeTransformation(
 						uMultimapToMap(*words3From),
 						uMultimapToMap(*wordsTo),
 						cameraModel,
-						_bowMinInliers,
-						_bowIterations,
-						_bowPnPReprojError,
-						_bowPnPFlags,
+						_minInliers,
+						_iterations,
+						_PnPReprojError,
+						_PnPFlags,
 						Transform::getIdentity(),
 						uMultimapToMap(*words3To),
 						&variance,
@@ -293,14 +293,14 @@ Transform RegistrationVis::computeTransformation(
 				if(transform.isNull())
 				{
 					msg = uFormat("Not enough inliers %d/%d between %d and %d",
-							inliersCount, _bowMinInliers, fromSignature.id(), toSignature.id());
+							inliersCount, _minInliers, fromSignature.id(), toSignature.id());
 					UINFO(msg.c_str());
 				}
 			}
 			else
 			{
 				msg = uFormat("Not enough features in images (old=%d, new=%d, min=%d)",
-						(int)words3From->size(), (int)wordsTo->size(), _bowMinInliers);
+						(int)words3From->size(), (int)wordsTo->size(), _minInliers);
 				UINFO(msg.c_str());
 			}
 		}
@@ -309,17 +309,17 @@ Transform RegistrationVis::computeTransformation(
 	else
 	{
 		// 3D -> 3D
-		if((int)words3From->size() >= _bowMinInliers &&
-		   (int)words3To->size() >= _bowMinInliers)
+		if((int)words3From->size() >= _minInliers &&
+		   (int)words3To->size() >= _minInliers)
 		{
 			std::vector<int> inliersV;
 			transform = util3d::estimateMotion3DTo3D(
 					uMultimapToMap(*words3From),
 					uMultimapToMap(*words3To),
-					_bowMinInliers,
-					_bowInlierDistance,
-					_bowIterations,
-					_bowRefineIterations,
+					_minInliers,
+					_inlierDistance,
+					_iterations,
+					_refineIterations,
 					&variance,
 					0,
 					&inliersV);
@@ -327,14 +327,14 @@ Transform RegistrationVis::computeTransformation(
 			if(transform.isNull())
 			{
 				msg = uFormat("Not enough inliers %d/%d between %d and %d",
-						inliersCount, _bowMinInliers, fromSignature.id(), toSignature.id());
+						inliersCount, _minInliers, fromSignature.id(), toSignature.id());
 				UINFO(msg.c_str());
 			}
 		}
 		else
 		{
 			msg = uFormat("Not enough 3D features in images (old=%d, new=%d, min=%d)",
-					(int)words3From->size(), (int)words3To->size(), _bowMinInliers);
+					(int)words3From->size(), (int)words3To->size(), _minInliers);
 			UINFO(msg.c_str());
 		}
 	}
@@ -353,14 +353,14 @@ Transform RegistrationVis::computeTransformation(
 					roll, pitch, yaw);
 			UWARN(msg.c_str());
 		}
-		else if(_bowForce2D)
+		else if(_force2D)
 		{
 			UDEBUG("Forcing 2D...");
 			transform = Transform(x,y,0, 0, 0, yaw);
 		}
 	}

-	if(_bowVarianceFromInliersCount)
+	if(_varianceFromInliersCount)
 	{
 		variance = inliersCount > 0?1.0/double(inliersCount):1.0;
 	}
--- a/corelib/src/Rtabmap.cpp
+++ b/corelib/src/Rtabmap.cpp
@@ -90,17 +90,17 @@ Rtabmap::Rtabmap() :
 	_rgbdLinearUpdate(Parameters::defaultRGBDLinearUpdate()),
 	_rgbdAngularUpdate(Parameters::defaultRGBDAngularUpdate()),
 	_newMapOdomChangeDistance(Parameters::defaultRGBDNewMapOdomChangeDistance()),
-	_loopClosureIcpRefining(Parameters::defaultRGBDIcpLoopClosureRefining()),
-	_odomIcpRefining(Parameters::defaultRGBDIcpOdomRefining()),
-	_localLoopClosureDetectionTime(Parameters::defaultRGBDLocalLoopDetectionTime()),
-	_localLoopClosureDetectionSpace(Parameters::defaultRGBDLocalLoopDetectionSpace()),
+	_loopClosureRefining(Parameters::defaultRGBDLoopClosureLinkRefining()),
+	_neighborLinkRefining(Parameters::defaultRGBDNeighborLinkRefining()),
+	_proximityByTime(Parameters::defaultRGBDProximityByTime()),
+	_proximityBySpace(Parameters::defaultRGBDProximityBySpace()),
 	_scanMatchingIdsSavedInLinks(Parameters::defaultRGBDScanMatchingIdsSavedInLinks()),
 	_localRadius(Parameters::defaultRGBDLocalRadius()),
 	_localImmunizationRatio(Parameters::defaultRGBDLocalImmunizationRatio()),
-	_localDetectMaxGraphDepth(Parameters::defaultRGBDLocalLoopDetectionMaxGraphDepth()),
-	_localPathFilteringRadius(Parameters::defaultRGBDLocalLoopDetectionPathFilteringRadius()),
-	_localPathOdomPosesUsed(Parameters::defaultRGBDLocalLoopDetectionPathOdomPosesUsed()),
-	_localPathScansMerged(Parameters::defaultRGBDLocalLoopDetectionPathScansMerged()),
+	_proximityMaxGraphDepth(Parameters::defaultRGBDProximityMaxGraphDepth()),
+	_proximityFilteringRadius(Parameters::defaultRGBDProximityPathFilteringRadius()),
+	_proximityRawPosesUsed(Parameters::defaultRGBDProximityPathRawPosesUsed()),
+	_proximityScansMerged(Parameters::defaultRGBDProximityPathScansMerged()),
 	_databasePath(""),
 	_optimizeFromGraphEnd(Parameters::defaultRGBDOptimizeFromGraphEnd()),
 	_optimizationMaxLinearError(Parameters::defaultRGBDOptimizeMaxError()),
@@ -397,16 +397,16 @@ void Rtabmap::parseParameters(const ParametersMap & parameters)
 	Parameters::parse(parameters, Parameters::kRGBDLinearUpdate(), _rgbdLinearUpdate);
 	Parameters::parse(parameters, Parameters::kRGBDAngularUpdate(), _rgbdAngularUpdate);
 	Parameters::parse(parameters, Parameters::kRGBDNewMapOdomChangeDistance(), _newMapOdomChangeDistance);
-	Parameters::parse(parameters, Parameters::kRGBDIcpOdomRefining(), _odomIcpRefining);
-	Parameters::parse(parameters, Parameters::kRGBDLocalLoopDetectionTime(), _localLoopClosureDetectionTime);
-	Parameters::parse(parameters, Parameters::kRGBDLocalLoopDetectionSpace(), _localLoopClosureDetectionSpace);
+	Parameters::parse(parameters, Parameters::kRGBDNeighborLinkRefining(), _neighborLinkRefining);
+	Parameters::parse(parameters, Parameters::kRGBDProximityByTime(), _proximityByTime);
+	Parameters::parse(parameters, Parameters::kRGBDProximityBySpace(), _proximityBySpace);
 	Parameters::parse(parameters, Parameters::kRGBDScanMatchingIdsSavedInLinks(), _scanMatchingIdsSavedInLinks);
 	Parameters::parse(parameters, Parameters::kRGBDLocalRadius(), _localRadius);
 	Parameters::parse(parameters, Parameters::kRGBDLocalImmunizationRatio(), _localImmunizationRatio);
-	Parameters::parse(parameters, Parameters::kRGBDLocalLoopDetectionMaxGraphDepth(), _localDetectMaxGraphDepth);
-	Parameters::parse(parameters, Parameters::kRGBDLocalLoopDetectionPathFilteringRadius(), _localPathFilteringRadius);
-	Parameters::parse(parameters, Parameters::kRGBDLocalLoopDetectionPathOdomPosesUsed(), _localPathOdomPosesUsed);
-	Parameters::parse(parameters, Parameters::kRGBDLocalLoopDetectionPathScansMerged(), _localPathScansMerged);
+	Parameters::parse(parameters, Parameters::kRGBDProximityMaxGraphDepth(), _proximityMaxGraphDepth);
+	Parameters::parse(parameters, Parameters::kRGBDProximityPathFilteringRadius(), _proximityFilteringRadius);
+	Parameters::parse(parameters, Parameters::kRGBDProximityPathRawPosesUsed(), _proximityRawPosesUsed);
+	Parameters::parse(parameters, Parameters::kRGBDProximityPathScansMerged(), _proximityScansMerged);
 	Parameters::parse(parameters, Parameters::kRGBDOptimizeFromGraphEnd(), _optimizeFromGraphEnd);
 	Parameters::parse(parameters, Parameters::kRGBDOptimizeMaxError(), _optimizationMaxLinearError);
 	Parameters::parse(parameters, Parameters::kRtabmapStartNewMapOnLoopClosure(), _startNewMapOnLoopClosure);
@@ -415,7 +415,7 @@ void Rtabmap::parseParameters(const ParametersMap & parameters)
 	Parameters::parse(parameters, Parameters::kRGBDPlanStuckIterations(), _pathStuckIterations);
 	Parameters::parse(parameters, Parameters::kRGBDPlanLinearVelocity(), _pathLinearVelocity);
 	Parameters::parse(parameters, Parameters::kRGBDPlanAngularVelocity(), _pathAngularVelocity);
-	Parameters::parse(parameters, Parameters::kRGBDIcpLoopClosureRefining(), _loopClosureIcpRefining);
+	Parameters::parse(parameters, Parameters::kRGBDLoopClosureLinkRefining(), _loopClosureRefining);

 	UASSERT(_rgbdLinearUpdate >= 0.0f);
 	UASSERT(_rgbdAngularUpdate >= 0.0f);
@@ -1000,7 +1000,7 @@ bool Rtabmap::process(
 			//============================================================
 			// Scan matching
 			//============================================================
-			if(_odomIcpRefining &&
+			if(_neighborLinkRefining &&
 				!signature->sensorData().laserScanCompressed().empty() &&
 				rehearsedId == 0) // don't do it if rehearsal happened
 			{
@@ -1143,7 +1143,7 @@ bool Rtabmap::process(
 		//============================================================
 		// Local loop closure in TIME
 		//============================================================
-		if(_localLoopClosureDetectionTime &&
+		if(_proximityByTime &&
 		   rehearsedId == 0 && // don't do it if rehearsal happened
 		   signature->getWords3().size() &&
 		   _memory->isIncremental()) // don't do it in localization mode
@@ -1160,7 +1160,7 @@ bool Rtabmap::process(
 					float variance = 1.0f;
 					int inliers = -1;
 					Transform transform = _memory->computeVisualTransform(signature->id(), *iter, &rejectedMsg, &inliers, &variance);
-					if(!transform.isNull() && _loopClosureIcpRefining)
+					if(!transform.isNull() && _loopClosureRefining)
 					{
 						transform = _memory->computeIcpTransform(signature->id(), *iter, transform, &rejectedMsg, 0, &variance);
 					}
@@ -1718,7 +1718,7 @@ bool Rtabmap::process(

 			transform = _memory->computeVisualTransform(signature->id(), _loopClosureHypothesis.first, &rejectedMsg, &loopClosureVisualInliers, &variance);

-			if(!transform.isNull() && _loopClosureIcpRefining)
+			if(!transform.isNull() && _loopClosureRefining)
 			{
 				transform = _memory->computeIcpTransform(signature->id(), _loopClosureHypothesis.first, transform, &rejectedMsg, 0, &variance);
 			}
@@ -1753,7 +1753,7 @@ bool Rtabmap::process(
 	int localSpaceClosuresAddedByICPOnly = 0;
 	int lastLocalSpaceClosureId = 0;
 	int localSpacePaths = 0;
-	if(_localLoopClosureDetectionSpace &&
+	if(_proximityBySpace &&
 	   _localRadius > 0 &&
 	   _rgbdSlamMode &&
 	   signature->getWeight() >= 0) // not an intermediate node
@@ -1782,7 +1782,7 @@ bool Rtabmap::process(
 				std::map<int, float> nearestIds;
 				if(_memory->isIncremental())
 				{
-					nearestIds = _memory->getNeighborsIdRadius(signature->id(), _localRadius, _optimizedPoses, _localDetectMaxGraphDepth);
+					nearestIds = _memory->getNeighborsIdRadius(signature->id(), _localRadius, _optimizedPoses, _proximityMaxGraphDepth);
 				}
 				else
 				{
@@ -1815,18 +1815,18 @@ bool Rtabmap::process(

 					// nearest pose must not be linked to current location and enough
 					if(!signature->hasLink(nearestId) &&
-						(_localPathFilteringRadius <= 0.0f ||
-						 _optimizedPoses.at(signature->id()).getDistanceSquared(_optimizedPoses.at(nearestId)) < _localPathFilteringRadius*_localPathFilteringRadius))
+						(_proximityFilteringRadius <= 0.0f ||
+						 _optimizedPoses.at(signature->id()).getDistanceSquared(_optimizedPoses.at(nearestId)) < _proximityFilteringRadius*_proximityFilteringRadius))
 					{
 						float variance = 1.0f;
 						Transform transform = _memory->computeVisualTransform(signature->id(), nearestId, 0, 0, &variance);
-						if(!transform.isNull() && _loopClosureIcpRefining)
+						if(!transform.isNull() && _loopClosureRefining)
 						{
 							transform  = _memory->computeIcpTransform(signature->id(), nearestId, transform, 0, 0, &variance);
 						}
 						if(!transform.isNull())
 						{
-							if(_localPathFilteringRadius <= 0 || transform.getNormSquared() <= _localPathFilteringRadius*_localPathFilteringRadius)
+							if(_proximityFilteringRadius <= 0 || transform.getNormSquared() <= _proximityFilteringRadius*_proximityFilteringRadius)
 							{
 								UINFO("[Visual] Add local loop closure in SPACE (%d->%d) %s",
 										signature->id(),
@@ -1846,7 +1846,7 @@ bool Rtabmap::process(
 							{
 								UWARN("Ignoring local loop closure with %d because resulting "
 									  "transform is to large!? (%fm > %fm)",
-										nearestId, transform.getNorm(), _localPathFilteringRadius);
+										nearestId, transform.getNorm(), _proximityFilteringRadius);
 							}
 						}
 					}
@@ -1879,10 +1879,10 @@ bool Rtabmap::process(

 						// nearest pose must be close and not linked to current location
 						if(!signature->hasLink(nearestId) &&
-						   (_localPathFilteringRadius <= 0.0f ||
-							_optimizedPoses.at(signature->id()).getDistanceSquared(_optimizedPoses.at(nearestId)) < _localPathFilteringRadius*_localPathFilteringRadius))
+						   (_proximityFilteringRadius <= 0.0f ||
+							_optimizedPoses.at(signature->id()).getDistanceSquared(_optimizedPoses.at(nearestId)) < _proximityFilteringRadius*_proximityFilteringRadius))
 						{
-							if(!_localPathScansMerged)
+							if(!_proximityScansMerged)
 							{
 								//only keep the nearest node
 								std::map<int, Transform> tmp;
@@ -1892,7 +1892,7 @@ bool Rtabmap::process(
 							else
 							{
 								// Assemble scans in the path and do ICP only
-								if(_localPathOdomPosesUsed)
+								if(_proximityRawPosesUsed)
 								{
 									//optimize the path's poses locally
 									path = optimizeGraph(nearestId, uKeysSet(path), std::map<int, Transform>(), false);
@@ -1904,10 +1904,10 @@ bool Rtabmap::process(
 										jter->second = t * jter->second;
 									}
 								}
-								if(path.size() > 2 && _localPathFilteringRadius > 0.0f)
+								if(path.size() > 2 && _proximityFilteringRadius > 0.0f)
 								{
 									// path filtering
-									std::map<int, Transform> filteredPath = graph::radiusPosesFiltering(path, _localPathFilteringRadius, 0, true);
+									std::map<int, Transform> filteredPath = graph::radiusPosesFiltering(path, _proximityFilteringRadius, 0, true);
 									// make sure the nearest and farthest poses are still here
 									filteredPath.insert(*path.find(nearestId));
 									filteredPath.insert(*path.begin());
@@ -1927,7 +1927,7 @@ bool Rtabmap::process(
 									Transform transform = _memory->computeScanMatchingTransform(signature->id(), nearestId, path, 0, 0, &variance);
 									if(!transform.isNull())
 									{
-										if(_localPathFilteringRadius <= 0 || transform.getNormSquared() <= _localPathFilteringRadius*_localPathFilteringRadius)
+										if(_proximityFilteringRadius <= 0 || transform.getNormSquared() <= _proximityFilteringRadius*_proximityFilteringRadius)
 										{
 											UINFO("[Scan matching] Add local loop closure in SPACE (%d->%d) %s",
 													signature->id(),
@@ -1973,7 +1973,7 @@ bool Rtabmap::process(
 										{
 											UWARN("Ignoring local loop closure with %d because resulting "
 												  "transform is to large!? (%fm > %fm)",
-													nearestId, transform.getNorm(), _localPathFilteringRadius);
+													nearestId, transform.getNorm(), _proximityFilteringRadius);
 										}
 									}
 								}
--- a/corelib/src/util3d_filtering.cpp
+++ b/corelib/src/util3d_filtering.cpp
@@ -69,7 +69,7 @@ cv::Mat downsample(
 			int finalSize = cloud.cols/step;
 			output = cv::Mat(1, finalSize, cloud.type());
 			int oi = 0;
-			for(unsigned int i=0; i<cloud.cols-step+1; i+=step)
+			for(int i=0; i<cloud.cols-step+1; i+=step)
 			{
 				cv::Mat(cloud, cv::Range::all(), cv::Range(i,i+1)).copyTo(cv::Mat(output, cv::Range::all(), cv::Range(oi,oi+1)));
 				++oi;
@@ -96,7 +96,7 @@ pcl::PointCloud<pcl::PointXYZ>::Ptr downsample(
 	}
 	else
 	{
-		if(cloud->size() > step)
+		if((int)cloud->size() > step)
 		{
 			int finalSize = cloud->size()/step;
 			output->resize(finalSize);
@@ -126,12 +126,12 @@ pcl::PointCloud<pcl::PointXYZRGB>::Ptr downsample(
 	}
 	else
 	{
-		if(cloud->size() > step)
+		if((int)cloud->size() > step)
 		{
 			int finalSize = cloud->size()/step;
 			output->resize(finalSize);
 			int oi = 0;
-			for(unsigned int i=0; i<cloud->size()-step+1; i+=step)
+			for(int i=0; i<(int)cloud->size()-step+1; i+=step)
 			{
 				(*output)[oi++] = cloud->at(i);
 			}