Added bilateral filtering option. CloudViewer: lighting and edge visibility options.

corelib/include/rtabmap/core/CameraInfo.h

@@ -46,6 +46,7 @@ public:
 		timeImageDecimation(0.0f),
 		timeScanFromDepth(0.0f),
 		timeUndistortDepth(0.0f),
+		timeBilateralFiltering(0.0f),
 		timeTotal(0.0f),
 		odomCovariance(cv::Mat::eye(6,6,CV_64FC1))
 	{
@@ -61,6 +62,7 @@ public:
 	float timeImageDecimation;
 	float timeScanFromDepth;
 	float timeUndistortDepth;
+	float timeBilateralFiltering;
 	float timeTotal;
 	Transform odomPose;
 	cv::Mat odomCovariance;

corelib/include/rtabmap/core/CameraThread.h

@@ -63,6 +63,8 @@ public:
 	void setStereoToDepth(bool enabled) {_stereoToDepth = enabled;}
 	void setImageRate(float imageRate);
 	void setDistortionModel(const std::string & path);
+	void enableBilateralFiltering(float sigmaS, float sigmaR);
+	void disableBilateralFiltering() {_bilateralFiltering = false;}
 
 	void setScanFromDepth(
 			bool enabled,
@@ -102,6 +104,9 @@ private:
 	int _scanNormalsK;
 	StereoDense * _stereoDense;
 	clams::DiscreteDepthDistortionModel * _distortionModel;
+	bool _bilateralFiltering;
+	float _bilateralSigmaS;
+	float _bilateralSigmaR;
 };
 
 } // namespace rtabmap

corelib/include/rtabmap/core/util2d.h

@@ -136,6 +136,12 @@ void RTABMAP_EXP fillRegisteredDepthHoles(
 		bool horizontal,
 		bool fillDoubleHoles = false);
 
+cv::Mat RTABMAP_EXP fastBilateralFiltering(
+		const cv::Mat & depth,
+		float sigmaS = 15.0f,
+		float sigmaR = 0.05f,
+		bool earlyDivision = false);
+
 } // namespace util3d
 } // namespace rtabmap
 

corelib/src/CameraThread.cpp

@@ -58,7 +58,10 @@ CameraThread::CameraThread(Camera * camera, const ParametersMap & parameters) :
 		_scanVoxelSize(0.0f),
 		_scanNormalsK(0),
 		_stereoDense(new StereoBM(parameters)),
-		_distortionModel(0)
+		_distortionModel(0),
+		_bilateralFiltering(false),
+		_bilateralSigmaS(10),
+		_bilateralSigmaR(0.1)
 {
 	UASSERT(_camera != 0);
 }
@@ -106,6 +109,14 @@ void CameraThread::setDistortionModel(const std::string & path)
 	}
 }
 
+void CameraThread::enableBilateralFiltering(float sigmaS, float sigmaR)
+{
+	UASSERT(sigmaS > 0.0f && sigmaR > 0.0f);
+	_bilateralFiltering = true;
+	_bilateralSigmaS = sigmaS;
+	_bilateralSigmaR = sigmaR;
+}
+
 void CameraThread::mainLoop()
 {
 	UTimer totalTime;
@@ -139,6 +150,13 @@ void CameraThread::mainLoop()
 			info.timeUndistortDepth = timer.ticks();
 		}
 
+		if(_bilateralFiltering && !data.depthRaw().empty())
+		{
+			UTimer timer;
+			data.setDepthOrRightRaw(util2d::fastBilateralFiltering(data.depthRaw(), _bilateralSigmaS, _bilateralSigmaR));
+			info.timeBilateralFiltering = timer.ticks();
+		}
+
 		if(_imageDecimation>1 && !data.imageRaw().empty())
 		{
 			UDEBUG("");

corelib/src/util2d.cpp

@@ -39,6 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <opencv2/video/tracking.hpp>
 #include <opencv2/highgui/highgui.hpp>
 #include <map>
+#include <Eigen/Core>
 
 namespace rtabmap
 {
@@ -1622,6 +1623,245 @@ void fillRegisteredDepthHoles(cv::Mat & registeredDepth, bool vertical, bool hor
 	}
 }
 
+// used only for fastBilateralFiltering() below
+class Array3D
+  {
+	public:
+	  Array3D (const size_t width, const size_t height, const size_t depth)
+	  {
+		x_dim_ = width;
+		y_dim_ = height;
+		z_dim_ = depth;
+		v_ = std::vector<Eigen::Vector2f> (width*height*depth, Eigen::Vector2f (0.0f, 0.0f));
+	  }
+
+	  inline Eigen::Vector2f&
+	  operator () (const size_t x, const size_t y, const size_t z)
+	  { return v_[(x * y_dim_ + y) * z_dim_ + z]; }
+
+	  inline const Eigen::Vector2f&
+	  operator () (const size_t x, const size_t y, const size_t z) const
+	  { return v_[(x * y_dim_ + y) * z_dim_ + z]; }
+
+	  inline void
+	  resize (const size_t width, const size_t height, const size_t depth)
+	  {
+		x_dim_ = width;
+		y_dim_ = height;
+		z_dim_ = depth;
+		v_.resize (x_dim_ * y_dim_ * z_dim_);
+	  }
+
+	  Eigen::Vector2f
+	  trilinear_interpolation (const float x,
+							   const float y,
+							   const float z)
+	  {
+	    const size_t x_index  = clamp (0, x_dim_ - 1, static_cast<size_t> (x));
+	    const size_t xx_index = clamp (0, x_dim_ - 1, x_index + 1);
+
+	    const size_t y_index  = clamp (0, y_dim_ - 1, static_cast<size_t> (y));
+	    const size_t yy_index = clamp (0, y_dim_ - 1, y_index + 1);
+
+	    const size_t z_index  = clamp (0, z_dim_ - 1, static_cast<size_t> (z));
+	    const size_t zz_index = clamp (0, z_dim_ - 1, z_index + 1);
+
+	    const float x_alpha = x - static_cast<float> (x_index);
+	    const float y_alpha = y - static_cast<float> (y_index);
+	    const float z_alpha = z - static_cast<float> (z_index);
+
+	    return
+	        (1.0f-x_alpha) * (1.0f-y_alpha) * (1.0f-z_alpha) * (*this)(x_index, y_index, z_index) +
+	        x_alpha        * (1.0f-y_alpha) * (1.0f-z_alpha) * (*this)(xx_index, y_index, z_index) +
+	        (1.0f-x_alpha) * y_alpha        * (1.0f-z_alpha) * (*this)(x_index, yy_index, z_index) +
+	        x_alpha        * y_alpha        * (1.0f-z_alpha) * (*this)(xx_index, yy_index, z_index) +
+	        (1.0f-x_alpha) * (1.0f-y_alpha) * z_alpha        * (*this)(x_index, y_index, zz_index) +
+	        x_alpha        * (1.0f-y_alpha) * z_alpha        * (*this)(xx_index, y_index, zz_index) +
+	        (1.0f-x_alpha) * y_alpha        * z_alpha        * (*this)(x_index, yy_index, zz_index) +
+	        x_alpha        * y_alpha        * z_alpha        * (*this)(xx_index, yy_index, zz_index);
+	  }
+
+	  static inline size_t
+	  clamp (const size_t min_value,
+			 const size_t max_value,
+			 const size_t x)
+	  {
+	    if (x >= min_value && x <= max_value)
+	    {
+	      return x;
+	    }
+	    else if (x < min_value)
+	    {
+	      return (min_value);
+	    }
+	    else
+	    {
+	      return (max_value);
+	    }
+	  }
+
+	  inline size_t
+	  x_size () const
+	  { return x_dim_; }
+
+	  inline size_t
+	  y_size () const
+	  { return y_dim_; }
+
+	  inline size_t
+	  z_size () const
+	  { return z_dim_; }
+
+	  inline std::vector<Eigen::Vector2f >::iterator
+	  begin ()
+	  { return v_.begin (); }
+
+	  inline std::vector<Eigen::Vector2f >::iterator
+	  end ()
+	  { return v_.end (); }
+
+	  inline std::vector<Eigen::Vector2f >::const_iterator
+	  begin () const
+	  { return v_.begin (); }
+
+	  inline std::vector<Eigen::Vector2f >::const_iterator
+	  end () const
+	  { return v_.end (); }
+
+	private:
+	  std::vector<Eigen::Vector2f > v_;
+	  size_t x_dim_, y_dim_, z_dim_;
+  };
+
+/**
+ * Converted pcl::FastBilateralFiltering class to 2d depth image
+ */
+cv::Mat fastBilateralFiltering(const cv::Mat & depth, float sigmaS, float sigmaR, bool earlyDivision)
+{
+	UASSERT(!depth.empty() && (depth.type() == CV_32FC1 || depth.type() == CV_16UC1));
+	UDEBUG("Begin: depth float=%d %dx%d sigmaS=%f sigmaR=%f earlDivision=%d",
+			depth.type()==CV_32FC1?1:0, depth.cols, depth.rows, sigmaS, sigmaR, earlyDivision?1:0);
+
+	cv::Mat output = depth.clone();
+
+	float base_max = -std::numeric_limits<float>::max ();
+	float base_min = std::numeric_limits<float>::max ();
+	bool found_finite = false;
+	for (size_t x = 0; x < output.cols; ++x)
+		for (size_t y = 0; y < output.rows; ++y)
+		{
+			float z = depth.type()==CV_32FC1?output.at<float>(y, x):float(output.at<unsigned short>(y, x))/1000.0f;
+			if (z > 0.0f && uIsFinite(z))
+			{
+				if (base_max < z)
+					base_max = z;
+				if (base_min > z)
+					base_min = z;
+				found_finite = true;
+			}
+		}
+	if (!found_finite)
+	{
+		UWARN("Given an empty depth image. Doing nothing.");
+		return cv::Mat();
+	}
+	UDEBUG("base_min=%f base_max=%f", base_min, base_max);
+
+	const float base_delta = base_max - base_min;
+
+	const size_t padding_xy = 2;
+	const size_t padding_z  = 2;
+
+	const size_t small_width  = static_cast<size_t> (static_cast<float> (depth.cols  - 1) / sigmaS) + 1 + 2 * padding_xy;
+	const size_t small_height = static_cast<size_t> (static_cast<float> (depth.rows - 1) / sigmaS) + 1 + 2 * padding_xy;
+	const size_t small_depth  = static_cast<size_t> (base_delta / sigmaR)   + 1 + 2 * padding_z;
+
+	UDEBUG("small_width=%d small_height=%d small_depth=%d", (int)small_width, (int)small_height, (int)small_depth);
+	Array3D data (small_width, small_height, small_depth);
+	for (size_t x = 0; x < depth.cols; ++x)
+	{
+		const size_t small_x = static_cast<size_t> (static_cast<float> (x) / sigmaS + 0.5f) + padding_xy;
+		for (size_t y = 0; y < depth.rows; ++y)
+		{
+			float v = depth.type()==CV_32FC1?output.at<float>(y,x):float(output.at<unsigned short>(y,x))/1000.0f;
+			if((v > 0 && uIsFinite(v)))
+			{
+				float z = v - base_min;
+
+				const size_t small_y = static_cast<size_t> (static_cast<float> (y) / sigmaS + 0.5f) + padding_xy;
+				const size_t small_z = static_cast<size_t> (static_cast<float> (z) / sigmaR + 0.5f) + padding_z;
+
+				Eigen::Vector2f& d = data (small_x, small_y, small_z);
+				d[0] += v;
+				d[1] += 1.0f;
+			}
+		}
+	}
+
+	std::vector<long int> offset (3);
+	offset[0] = &(data (1,0,0)) - &(data (0,0,0));
+	offset[1] = &(data (0,1,0)) - &(data (0,0,0));
+	offset[2] = &(data (0,0,1)) - &(data (0,0,0));
+
+	Array3D buffer (small_width, small_height, small_depth);
+
+	for (size_t dim = 0; dim < 3; ++dim)
+	{
+		const long int off = offset[dim];
+		for (size_t n_iter = 0; n_iter < 2; ++n_iter)
+		{
+		  std::swap (buffer, data);
+		  for(size_t x = 1; x < small_width - 1; ++x)
+			for(size_t y = 1; y < small_height - 1; ++y)
+			{
+			  Eigen::Vector2f* d_ptr = &(data (x,y,1));
+			  Eigen::Vector2f* b_ptr = &(buffer (x,y,1));
+
+			  for(size_t z = 1; z < small_depth - 1; ++z, ++d_ptr, ++b_ptr)
+				*d_ptr = (*(b_ptr - off) + *(b_ptr + off) + 2.0 * (*b_ptr)) / 4.0;
+			}
+		}
+	}
+
+	if (earlyDivision)
+	{
+		for (std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >::iterator d = data.begin (); d != data.end (); ++d)
+		  *d /= ((*d)[0] != 0) ? (*d)[1] : 1;
+	}
+
+	for (size_t x = 0; x < depth.cols; ++x)
+	  for (size_t y = 0; y < depth.rows; ++y)
+	  {
+		  float z = depth.type()==CV_32FC1?output.at<float>(y,x):float(output.at<unsigned short>(y,x))/1000.0f;
+		  if(z > 0 && uIsFinite(z))
+		  {
+			  z -= base_min;
+			  const Eigen::Vector2f D = data.trilinear_interpolation (static_cast<float> (x) / sigmaS + padding_xy,
+																	static_cast<float> (y) / sigmaS + padding_xy,
+																	z / sigmaR + padding_z);
+			  float v = earlyDivision ? D[0] : D[0] / D[1];
+			  if(v < base_min || v >= base_max)
+			  {
+				  v = 0.0f;
+			  }
+			  if(depth.type()==CV_32FC1)
+				  output.at<float>(y,x) = v;
+			  else
+			  {
+				  v*=1000.0f;
+				  if(v>65535.0f)
+				  {
+					  v = 65535.0f;
+				  }
+				  output.at<unsigned short>(y,x) = v;
+			  }
+		  }
+	  }
+
+	UDEBUG("End");
+	return output;
+}
+
 }
 
 }

guilib/include/rtabmap/gui/CloudViewer.h

@@ -139,7 +139,7 @@ public:
 			const pcl::TextureMesh::Ptr & textureMesh,
 			const Transform & pose = Transform::getIdentity());
 
-	bool addOctomap(const OctoMap * octomap, unsigned int treeDepth = 0, bool showEdges = true, bool lightingOn = false);
+	bool addOctomap(const OctoMap * octomap, unsigned int treeDepth = 0);
 	void removeOctomap();
 
 	bool addTextureMesh (
@@ -241,6 +241,8 @@ public:
 
 	void setBackfaceCulling(bool enabled, bool frontfaceCulling);
 	void setRenderingRate(double rate);
+	void setLighting(bool on);
+	void setEdgeVisibility(bool visible);
 	double getRenderingRate() const;
 
 	void getCameraPosition(
@@ -312,6 +314,8 @@ private:
     QAction * _aSetGridCellSize;
     QAction * _aSetBackgroundColor;
     QAction * _aSetRenderingRate;
+    QAction * _aSetLighting;
+    QAction * _aSetEdgeVisibility;
     QMenu * _menu;
     std::set<std::string> _graphes;
     std::set<std::string> _coordinates;

guilib/include/rtabmap/gui/PreferencesDialog.h

@@ -220,6 +220,9 @@ public:
 	bool isSourceDatabaseStampsUsed() const;
 	bool isSourceRGBDColorOnly() const;
 	QString getSourceDistortionModel() const;
+	bool isBilateralFiltering() const;
+	double getBilateralSigmaS() const;
+	double getBilateralSigmaR() const;
 	int getSourceImageDecimation() const;
 	bool isSourceStereoDepthGenerated() const;
 	bool isSourceScanFromDepth() const;

guilib/src/CloudViewer.cpp

@@ -127,6 +127,9 @@ CloudViewer::CloudViewer(QWidget *parent) :
 		_aSetGridCellCount(0),
 		_aSetGridCellSize(0),
 		_aSetBackgroundColor(0),
+		_aSetRenderingRate(0),
+		_aSetLighting(0),
+		_aSetEdgeVisibility(0),
 		_menu(0),
 		_trajectory(new pcl::PointCloud<pcl::PointXYZ>),
 		_maxTrajectorySize(100),
@@ -234,6 +237,12 @@ void CloudViewer::createMenu()
 	_aSetGridCellSize = new QAction("Set cell size...", this);
 	_aSetBackgroundColor = new QAction("Set background color...", this);	
 	_aSetRenderingRate = new QAction("Set rendering rate...", this);
+	_aSetLighting = new QAction("Lighting", this);
+	_aSetLighting->setCheckable(true);
+	_aSetLighting->setChecked(false);
+	_aSetEdgeVisibility = new QAction("Show edges", this);
+	_aSetEdgeVisibility->setCheckable(true);
+	_aSetEdgeVisibility->setChecked(false);
 
 	QMenu * cameraMenu = new QMenu("Camera", this);
 	cameraMenu->addAction(_aLockCamera);
@@ -270,6 +279,8 @@ void CloudViewer::createMenu()
 	_menu->addMenu(gridMenu);
 	_menu->addAction(_aSetBackgroundColor);
 	_menu->addAction(_aSetRenderingRate);
+	_menu->addAction(_aSetLighting);
+	_menu->addAction(_aSetEdgeVisibility);
 }
 
 void CloudViewer::saveSettings(QSettings & settings, const QString & group) const
@@ -531,7 +542,8 @@ bool CloudViewer::addCloudMesh(
 	UDEBUG("Adding %s with %d points and %d polygons", id.c_str(), (int)cloud->size(), (int)polygons.size());
 	if(_visualizer->addPolygonMesh<pcl::PointXYZ>(cloud, polygons, id))
 	{
-		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->LightingOff();
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
 		if(_backfaceCulling)
 		{
 			_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->BackfaceCullingOn();
@@ -561,7 +573,8 @@ bool CloudViewer::addCloudMesh(
 	UDEBUG("Adding %s with %d points and %d polygons", id.c_str(), (int)cloud->size(), (int)polygons.size());
 	if(_visualizer->addPolygonMesh<pcl::PointXYZRGB>(cloud, polygons, id))
 	{
-		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->LightingOff();
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
 		if(_backfaceCulling)
 		{
 			_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->BackfaceCullingOn();
@@ -591,7 +604,8 @@ bool CloudViewer::addCloudMesh(
 	UDEBUG("Adding %s with %d points and %d polygons", id.c_str(), (int)cloud->size(), (int)polygons.size());
 	if(_visualizer->addPolygonMesh<pcl::PointXYZRGBNormal>(cloud, polygons, id))
 	{
-		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->LightingOff();
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
 		if(_backfaceCulling)
 		{
 			_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->BackfaceCullingOn();
@@ -620,7 +634,8 @@ bool CloudViewer::addCloudMesh(
 	UDEBUG("Adding %s with %d polygons", id.c_str(), (int)mesh->polygons.size());
 	if(_visualizer->addPolygonMesh(*mesh, id))
 	{
-		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->LightingOff();
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
 		if(_backfaceCulling)
 		{
 			_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->BackfaceCullingOn();
@@ -650,7 +665,8 @@ bool CloudViewer::addCloudTextureMesh(
 	UDEBUG("Adding %s", id.c_str());
 	if(this->addTextureMesh(*textureMesh, id))
 	{
-		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->LightingOff();
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+		_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
 		if(_backfaceCulling)
 		{
 			_visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->BackfaceCullingOn();
@@ -671,7 +687,7 @@ bool CloudViewer::addCloudTextureMesh(
 	return false;
 }
 
-bool CloudViewer::addOctomap(const OctoMap * octomap, unsigned int treeDepth, bool showEdges, bool lightingOn)
+bool CloudViewer::addOctomap(const OctoMap * octomap, unsigned int treeDepth)
 {
 	UDEBUG("");
 #ifdef RTABMAP_OCTOMAP
@@ -751,8 +767,8 @@ bool CloudViewer::addOctomap(const OctoMap * octomap, unsigned int treeDepth, bo
 		octomapActor->SetMapper(mapper);
 
 		octomapActor->GetProperty()->SetRepresentationToSurface();
-		octomapActor->GetProperty()->SetEdgeVisibility(showEdges);
+		octomapActor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
-		octomapActor->GetProperty()->SetLighting(lightingOn);
+		octomapActor->GetProperty()->SetLighting(_aSetLighting->isChecked());
 
 		renderer->AddActor(octomapActor);
 		_octomapActor = octomapActor.GetPointer();
@@ -905,7 +921,10 @@ bool CloudViewer::addTextureMesh (
 	   int viewport)
 {
 #if PCL_VERSION_COMPARE(>=, 1, 7, 2)
-	return _visualizer->addTextureMesh(mesh, id, viewport);
+	if(!_visualizer->addTextureMesh(mesh, id, viewport))
+	{
+		return false;
+	}
 #else
 	// Copied from PCL 1.8
 
@@ -1141,8 +1160,11 @@ bool CloudViewer::addTextureMesh (
   // Save the viewpoint transformation matrix to the global actor map
   (*_visualizer->getCloudActorMap())[id].viewpoint_transformation_ = transformation;
 
-  return (true);
 #endif
+
+  _visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+  _visualizer->getCloudActorMap()->find(id)->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
+  return true;
 }
 
 bool CloudViewer::addOccupancyGridMap(
@@ -1201,7 +1223,6 @@ bool CloudViewer::addOccupancyGridMap(
 		mesh->tex_coordinates.push_back(coordinates);
 
 		this->addTextureMesh(*mesh, "map");
-		_visualizer->getCloudActorMap()->find("map")->second.actor->GetProperty()->LightingOff();
 		setCloudOpacity("map", opacity);
 
 		//removed tmp texture file
@@ -1734,6 +1755,28 @@ void CloudViewer::setRenderingRate(double rate)
 	_visualizer->getInteractorStyle()->GetInteractor()->SetDesiredUpdateRate(_renderingRate);
 }
 
+void CloudViewer::setLighting(bool on)
+{
+	_aSetLighting->setChecked(on);
+	pcl::visualization::CloudActorMapPtr cloudActorMap = _visualizer->getCloudActorMap();
+	for(pcl::visualization::CloudActorMap::iterator iter=cloudActorMap->begin(); iter!=cloudActorMap->end(); ++iter)
+	{
+		iter->second.actor->GetProperty()->SetLighting(_aSetLighting->isChecked());
+	}
+	this->update();
+}
+
+void CloudViewer::setEdgeVisibility(bool visible)
+{
+	_aSetEdgeVisibility->setChecked(visible);
+	pcl::visualization::CloudActorMapPtr cloudActorMap = _visualizer->getCloudActorMap();
+	for(pcl::visualization::CloudActorMap::iterator iter=cloudActorMap->begin(); iter!=cloudActorMap->end(); ++iter)
+	{
+		iter->second.actor->GetProperty()->SetEdgeVisibility(_aSetEdgeVisibility->isChecked());
+	}
+	this->update();
+}
+
 void CloudViewer::getCameraPosition(
 		float & x, float & y, float & z,
 		float & focalX, float & focalY, float & focalZ,
@@ -2468,6 +2511,14 @@ void CloudViewer::handleAction(QAction * a)
 			this->update();
 		}
 	}
+	else if(a == _aSetLighting)
+	{
+		this->setLighting(_aSetLighting->isChecked());
+	}
+	else if(a == _aSetEdgeVisibility)
+	{
+		this->setEdgeVisibility(_aSetEdgeVisibility->isChecked());
+	}
 }
 
 } /* namespace rtabmap */

guilib/src/DatabaseViewer.cpp

@@ -3227,7 +3227,7 @@ void DatabaseViewer::updateConstraintView(
 	ui_->label_type->setText(tr("%1 (%2)")
 			.arg(link.type())
 			.arg(link.type()==Link::kNeighbor?"Neighbor":
-				 link.type()==Link::kNeighbor?"Merged neighbor":
+				 link.type()==Link::kNeighborMerged?"Merged neighbor":
 				 link.type()==Link::kGlobalClosure?"Loop closure":
 				 link.type()==Link::kLocalSpaceClosure?"Space proximity link":
 				 link.type()==Link::kLocalTimeClosure?"Time proximity link":

guilib/src/ExportCloudsDialog.cpp

@@ -39,6 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "rtabmap/core/util3d_surface.h"
 #include "rtabmap/core/util3d_transforms.h"
 #include "rtabmap/core/util3d.h"
+#include "rtabmap/core/util2d.h"
 #include "rtabmap/core/Graph.h"
 #include "rtabmap/core/GainCompensator.h"
 #include "rtabmap/core/clams/discrete_depth_distortion_model.h"
@@ -83,6 +84,10 @@ ExportCloudsDialog::ExportCloudsDialog(QWidget *parent) :
 	connect(_ui->lineEdit_distortionModel, SIGNAL(textChanged(const QString &)), this, SIGNAL(configChanged()));
 	connect(_ui->toolButton_distortionModel, SIGNAL(clicked()), this, SLOT(selectDistortionModel()));
 
+	connect(_ui->groupBox_bilateral, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
+	connect(_ui->doubleSpinBox_bilateral_sigmaS, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
+	connect(_ui->doubleSpinBox_bilateral_sigmaR, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
+
 	connect(_ui->groupBox_filtering, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_filteringRadius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->spinBox_filteringMinNeighbors, SIGNAL(valueChanged(int)), this, SIGNAL(configChanged()));
@@ -181,6 +186,9 @@ void ExportCloudsDialog::saveSettings(QSettings & settings, const QString & grou
 	settings.setValue("regenerate_min_depth", _ui->doubleSpinBox_minDepth->value());
 	settings.setValue("regenerate_distortion_model", _ui->lineEdit_distortionModel->text());
 
+	settings.setValue("bilateral", _ui->groupBox_bilateral->isChecked());
+	settings.setValue("bilateral_sigma_s", _ui->doubleSpinBox_bilateral_sigmaS->value());
+	settings.setValue("bilateral_sigma_r", _ui->doubleSpinBox_bilateral_sigmaR->value());
 
 	settings.setValue("filtering", _ui->groupBox_filtering->isChecked());
 	settings.setValue("filtering_radius", _ui->doubleSpinBox_filteringRadius->value());
@@ -246,6 +254,10 @@ void ExportCloudsDialog::loadSettings(QSettings & settings, const QString & grou
 	_ui->doubleSpinBox_minDepth->setValue(settings.value("regenerate_min_depth", _ui->doubleSpinBox_minDepth->value()).toDouble());
 	_ui->lineEdit_distortionModel->setText(settings.value("regenerate_distortion_model", _ui->lineEdit_distortionModel->text()).toString());
 
+	_ui->groupBox_bilateral->setChecked(settings.value("bilateral", _ui->groupBox_bilateral->isChecked()).toBool());
+	_ui->doubleSpinBox_bilateral_sigmaS->setValue(settings.value("bilateral_sigma_s", _ui->doubleSpinBox_bilateral_sigmaS->value()).toDouble());
+	_ui->doubleSpinBox_bilateral_sigmaR->setValue(settings.value("bilateral_sigma_r", _ui->doubleSpinBox_bilateral_sigmaR->value()).toDouble());
+
 	_ui->groupBox_filtering->setChecked(settings.value("filtering", _ui->groupBox_filtering->isChecked()).toBool());
 	_ui->doubleSpinBox_filteringRadius->setValue(settings.value("filtering_radius", _ui->doubleSpinBox_filteringRadius->value()).toDouble());
 	_ui->spinBox_filteringMinNeighbors->setValue(settings.value("filtering_min_neighbors", _ui->spinBox_filteringMinNeighbors->value()).toInt());
@@ -309,6 +321,10 @@ void ExportCloudsDialog::restoreDefaults()
 	_ui->doubleSpinBox_minDepth->setValue(0);
 	_ui->lineEdit_distortionModel->setText("");
 
+	_ui->groupBox_bilateral->setChecked(false);
+	_ui->doubleSpinBox_bilateral_sigmaS->setValue(10.0);
+	_ui->doubleSpinBox_bilateral_sigmaR->setValue(0.1);
+
 	_ui->groupBox_filtering->setChecked(false);
 	_ui->doubleSpinBox_filteringRadius->setValue(0.02);
 	_ui->spinBox_filteringMinNeighbors->setValue(2);
@@ -1432,6 +1448,15 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 							d.setDepthOrRightRaw(depth);
 						}
 
+						// bilateral filtering
+						if(_ui->groupBox_bilateral->isChecked())
+						{
+							depth = util2d::fastBilateralFiltering(depth,
+									_ui->doubleSpinBox_bilateral_sigmaS->value(),
+									_ui->doubleSpinBox_bilateral_sigmaR->value());
+							d.setDepthOrRightRaw(depth);
+						}
+
 						UASSERT(iter->first == d.id());
 						pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudWithoutNormals;
 						cloudWithoutNormals = util3d::cloudRGBFromSensorData(

guilib/src/MainWindow.cpp

@@ -858,6 +858,7 @@ void MainWindow::processCameraInfo(const rtabmap::CameraInfo & info)
 	_ui->statsToolBox->updateStat("Camera/Time total/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeTotal*1000.0f, _preferencesDialog->isCacheSavedInFigures());
 	_ui->statsToolBox->updateStat("Camera/Time capturing/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeCapture*1000.0f, _preferencesDialog->isCacheSavedInFigures());
 	_ui->statsToolBox->updateStat("Camera/Time undistort depth/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeUndistortDepth*1000.0f, _preferencesDialog->isCacheSavedInFigures());
+	_ui->statsToolBox->updateStat("Camera/Time bilateral filtering/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeBilateralFiltering*1000.0f, _preferencesDialog->isCacheSavedInFigures());
 	_ui->statsToolBox->updateStat("Camera/Time decimation/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeImageDecimation*1000.0f, _preferencesDialog->isCacheSavedInFigures());
 	_ui->statsToolBox->updateStat("Camera/Time disparity/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeDisparity*1000.0f, _preferencesDialog->isCacheSavedInFigures());
 	_ui->statsToolBox->updateStat("Camera/Time mirroring/ms", _preferencesDialog->isTimeUsedInFigures()?info.stamp-_firstStamp:(float)info.id, info.timeMirroring*1000.0f, _preferencesDialog->isCacheSavedInFigures());
@@ -4150,6 +4151,12 @@ void MainWindow::startDetection()
 			_preferencesDialog->getSourceScanNormalsK());
 	if(_preferencesDialog->getSourceType() == PreferencesDialog::kSrcRGBD)
 	{
+		if(_preferencesDialog->isBilateralFiltering())
+		{
+			_camera->enableBilateralFiltering(
+					_preferencesDialog->getBilateralSigmaS(),
+					_preferencesDialog->getBilateralSigmaR());
+		}
 		_camera->setDistortionModel(_preferencesDialog->getSourceDistortionModel().toStdString());
 	}
 

guilib/src/PreferencesDialog.cpp

@@ -517,6 +517,9 @@ PreferencesDialog::PreferencesDialog(QWidget * parent) :
 	connect(_ui->lineEdit_openniOniPath, SIGNAL(textChanged(const QString &)), this, SLOT(makeObsoleteSourcePanel()));
 	connect(_ui->lineEdit_openni2OniPath, SIGNAL(textChanged(const QString &)), this, SLOT(makeObsoleteSourcePanel()));
 	connect(_ui->lineEdit_source_distortionModel, SIGNAL(textChanged(const QString &)), this, SLOT(makeObsoleteSourcePanel()));
+	connect(_ui->groupBox_bilateral, SIGNAL(toggled(bool)), this, SLOT(makeObsoleteSourcePanel()));
+	connect(_ui->doubleSpinBox_bilateral_sigmaS, SIGNAL(valueChanged(double)), this, SLOT(makeObsoleteSourcePanel()));
+	connect(_ui->doubleSpinBox_bilateral_sigmaR, SIGNAL(valueChanged(double)), this, SLOT(makeObsoleteSourcePanel()));
 
 	connect(_ui->groupBox_scanFromDepth, SIGNAL(toggled(bool)), this, SLOT(makeObsoleteSourcePanel()));
 	connect(_ui->spinBox_cameraScanFromDepth_decimation, SIGNAL(valueChanged(int)), this, SLOT(makeObsoleteSourcePanel()));
@@ -1349,6 +1352,9 @@ void PreferencesDialog::resetSettings(QGroupBox * groupBox)
 		_ui->lineEdit_cameraRGBDImages_path_depth->setText("");
 		_ui->doubleSpinBox_cameraRGBDImages_scale->setValue(1.0);
 		_ui->lineEdit_source_distortionModel->setText("");
+		_ui->groupBox_bilateral->setChecked(false);
+		_ui->doubleSpinBox_bilateral_sigmaS->setValue(10.0);
+		_ui->doubleSpinBox_bilateral_sigmaR->setValue(0.1);
 
 		_ui->source_comboBox_image_type->setCurrentIndex(kSrcDC1394-kSrcDC1394);
 		_ui->lineEdit_cameraStereoImages_path_left->setText("");
@@ -1656,6 +1662,9 @@ void PreferencesDialog::readCameraSettings(const QString & filePath)
 	_ui->comboBox_cameraRGBD->setCurrentIndex(settings.value("driver", _ui->comboBox_cameraRGBD->currentIndex()).toInt());
 	_ui->checkbox_rgbd_colorOnly->setChecked(settings.value("rgbdColorOnly", _ui->checkbox_rgbd_colorOnly->isChecked()).toBool());
 	_ui->lineEdit_source_distortionModel->setText(settings.value("distortion_model", _ui->lineEdit_source_distortionModel->text()).toString());
+	_ui->groupBox_bilateral->setChecked(settings.value("bilateral", _ui->groupBox_bilateral->isChecked()).toBool());
+	_ui->doubleSpinBox_bilateral_sigmaS->setValue(settings.value("bilateral_sigma_s", _ui->doubleSpinBox_bilateral_sigmaS->value()).toDouble());
+	_ui->doubleSpinBox_bilateral_sigmaR->setValue(settings.value("bilateral_sigma_r", _ui->doubleSpinBox_bilateral_sigmaR->value()).toDouble());
 	settings.endGroup(); // rgbd
 
 	settings.beginGroup("stereo");
@@ -2087,9 +2096,12 @@ void PreferencesDialog::writeCameraSettings(const QString & filePath) const
 	settings.setValue("imageDecimation",  _ui->spinBox_source_imageDecimation->value());
 
 	settings.beginGroup("rgbd");
-	settings.setValue("driver", 	   _ui->comboBox_cameraRGBD->currentIndex());
+	settings.setValue("driver", 	       _ui->comboBox_cameraRGBD->currentIndex());
-	settings.setValue("rgbdColorOnly", _ui->checkbox_rgbd_colorOnly->isChecked());
+	settings.setValue("rgbdColorOnly",     _ui->checkbox_rgbd_colorOnly->isChecked());
-	settings.setValue("distortion_model", _ui->lineEdit_source_distortionModel->text());
+	settings.setValue("distortion_model",  _ui->lineEdit_source_distortionModel->text());
+	settings.setValue("bilateral",	       _ui->groupBox_bilateral->isChecked());
+	settings.setValue("bilateral_sigma_s", _ui->doubleSpinBox_bilateral_sigmaS->value());
+	settings.setValue("bilateral_sigma_r", _ui->doubleSpinBox_bilateral_sigmaR->value());
 	settings.endGroup(); // rgbd
 
 	settings.beginGroup("stereo");
@@ -4148,6 +4160,18 @@ QString PreferencesDialog::getSourceDistortionModel() const
 {
 	return _ui->lineEdit_source_distortionModel->text();
 }
+bool PreferencesDialog::isBilateralFiltering() const
+{
+	return _ui->groupBox_bilateral->isChecked();
+}
+double PreferencesDialog::getBilateralSigmaS() const
+{
+	return _ui->doubleSpinBox_bilateral_sigmaS->value();
+}
+double PreferencesDialog::getBilateralSigmaR() const
+{
+	return _ui->doubleSpinBox_bilateral_sigmaR->value();
+}
 int PreferencesDialog::getSourceImageDecimation() const
 {
 	return _ui->spinBox_source_imageDecimation->value();
@@ -4669,10 +4693,18 @@ void PreferencesDialog::testOdometry()
 			_ui->doubleSpinBox_cameraSCanFromDepth_maxDepth->value(),
 			_ui->doubleSpinBox_cameraImages_scanVoxelSize->value(),
 			_ui->spinBox_cameraImages_scanNormalsK->value());
-	if(this->getSourceType() == PreferencesDialog::kSrcRGBD &&
+	if(this->getSourceType() == PreferencesDialog::kSrcRGBD)
-		!_ui->lineEdit_source_distortionModel->text().isEmpty())
 	{
-		cameraThread.setDistortionModel(_ui->lineEdit_source_distortionModel->text().toStdString());
+		if(_ui->groupBox_bilateral->isChecked())
+		{
+			cameraThread.enableBilateralFiltering(
+					_ui->doubleSpinBox_bilateral_sigmaS->value(),
+					_ui->doubleSpinBox_bilateral_sigmaR->value());
+		}
+		if(!_ui->lineEdit_source_distortionModel->text().isEmpty())
+		{
+			cameraThread.setDistortionModel(_ui->lineEdit_source_distortionModel->text().toStdString());
+		}
 	}
 	UEventsManager::createPipe(&cameraThread, &odomThread, "CameraEvent");
 	UEventsManager::createPipe(&odomThread, odomViewer, "OdometryEvent");
@@ -4709,10 +4741,18 @@ void PreferencesDialog::testCamera()
 				_ui->doubleSpinBox_cameraSCanFromDepth_maxDepth->value(),
 				_ui->doubleSpinBox_cameraImages_scanVoxelSize->value(),
 				_ui->spinBox_cameraImages_scanNormalsK->value());
-		if(this->getSourceType() == PreferencesDialog::kSrcRGBD &&
+		if(this->getSourceType() == PreferencesDialog::kSrcRGBD)
-			!_ui->lineEdit_source_distortionModel->text().isEmpty())
 		{
-			cameraThread.setDistortionModel(_ui->lineEdit_source_distortionModel->text().toStdString());
+			if(_ui->groupBox_bilateral->isChecked())
+			{
+				cameraThread.enableBilateralFiltering(
+						_ui->doubleSpinBox_bilateral_sigmaS->value(),
+						_ui->doubleSpinBox_bilateral_sigmaR->value());
+			}
+			if(!_ui->lineEdit_source_distortionModel->text().isEmpty())
+			{
+				cameraThread.setDistortionModel(_ui->lineEdit_source_distortionModel->text().toStdString());
+			}
 		}
 		UEventsManager::createPipe(&cameraThread, window, "CameraEvent");
 

guilib/src/ui/exportCloudsDialog.ui

@@ -25,7 +25,7 @@
         <x>0</x>
         <y>0</y>
         <width>773</width>
-        <height>1755</height>
+        <height>1902</height>
        </rect>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_13">
@@ -254,6 +254,88 @@
             </item>
            </layout>
           </item>
+          <item>
+           <widget class="QGroupBox" name="groupBox_bilateral">
+            <property name="title">
+             <string>Bilateral Filtering of the Depth Image</string>
+            </property>
+            <property name="checkable">
+             <bool>true</bool>
+            </property>
+            <layout class="QGridLayout" name="gridLayout_13" columnstretch="0,1">
+             <item row="1" column="0">
+              <widget class="QDoubleSpinBox" name="doubleSpinBox_bilateral_sigmaR">
+               <property name="suffix">
+                <string/>
+               </property>
+               <property name="decimals">
+                <number>4</number>
+               </property>
+               <property name="minimum">
+                <double>0.000100000000000</double>
+               </property>
+               <property name="maximum">
+                <double>1.000000000000000</double>
+               </property>
+               <property name="singleStep">
+                <double>0.001000000000000</double>
+               </property>
+               <property name="value">
+                <double>0.005000000000000</double>
+               </property>
+              </widget>
+             </item>
+             <item row="1" column="1">
+              <widget class="QLabel" name="label_194">
+               <property name="text">
+                <string>Standard deviation of the Gaussian for the intensity difference. Set the standard deviation of the Gaussian used to control how much an adjacent pixel is downweighted because of the intensity difference (depth in our case).</string>
+               </property>
+               <property name="wordWrap">
+                <bool>true</bool>
+               </property>
+               <property name="textInteractionFlags">
+                <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+               </property>
+              </widget>
+             </item>
+             <item row="0" column="0">
+              <widget class="QDoubleSpinBox" name="doubleSpinBox_bilateral_sigmaS">
+               <property name="suffix">
+                <string/>
+               </property>
+               <property name="decimals">
+                <number>1</number>
+               </property>
+               <property name="minimum">
+                <double>0.100000000000000</double>
+               </property>
+               <property name="maximum">
+                <double>100.000000000000000</double>
+               </property>
+               <property name="singleStep">
+                <double>1.000000000000000</double>
+               </property>
+               <property name="value">
+                <double>5.000000000000000</double>
+               </property>
+              </widget>
+             </item>
+             <item row="0" column="1">
+              <widget class="QLabel" name="label_195">
+               <property name="text">
+                <string>Size of the Gaussian bilateral filter window to use. Set the standard deviation of the Gaussian used by the bilateral filter for the spatial neighborhood/window.</string>
+               </property>
+               <property name="wordWrap">
+                <bool>true</bool>
+               </property>
+               <property name="textInteractionFlags">
+                <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </widget>
+          </item>
           <item>
            <widget class="QGroupBox" name="groupBox_subtraction">
             <property name="title">

guilib/src/ui/preferencesDialog.ui

@@ -63,7 +63,7 @@
           <property name="geometry">
            <rect>
             <x>0</x>
-            <y>0</y>
+            <y>-427</y>
             <width>673</width>
             <height>2520</height>
            </rect>
@@ -86,7 +86,7 @@
                 <enum>QFrame::Raised</enum>
                </property>
                <property name="currentIndex">
-                <number>1</number>
+                <number>5</number>
                </property>
                <widget class="QWidget" name="page_22">
                 <layout class="QVBoxLayout" name="verticalLayout_29" stretch="0,1">
@@ -2400,7 +2400,7 @@ when using the file type, logs are saved in LogRtabmap.txt (located in the worki
                     <item>
                      <widget class="QStackedWidget" name="stackedWidget_src">
                       <property name="currentIndex">
-                       <number>1</number>
+                       <number>0</number>
                       </property>
                       <widget class="QWidget" name="page_41">
                        <layout class="QVBoxLayout" name="verticalLayout_64">
@@ -2551,6 +2551,88 @@ when using the file type, logs are saved in LogRtabmap.txt (located in the worki
                              </item>
                             </layout>
                            </item>
+                           <item>
+                            <widget class="QGroupBox" name="groupBox_bilateral">
+                             <property name="title">
+                              <string>Bilateral Filtering of the Depth Image</string>
+                             </property>
+                             <property name="checkable">
+                              <bool>true</bool>
+                             </property>
+                             <layout class="QGridLayout" name="gridLayout_78" columnstretch="0,1">
+                              <item row="1" column="0">
+                               <widget class="QDoubleSpinBox" name="doubleSpinBox_bilateral_sigmaR">
+                                <property name="suffix">
+                                 <string/>
+                                </property>
+                                <property name="decimals">
+                                 <number>4</number>
+                                </property>
+                                <property name="minimum">
+                                 <double>0.000100000000000</double>
+                                </property>
+                                <property name="maximum">
+                                 <double>1.000000000000000</double>
+                                </property>
+                                <property name="singleStep">
+                                 <double>0.001000000000000</double>
+                                </property>
+                                <property name="value">
+                                 <double>0.005000000000000</double>
+                                </property>
+                               </widget>
+                              </item>
+                              <item row="1" column="1">
+                               <widget class="QLabel" name="label_344">
+                                <property name="text">
+                                 <string>Standard deviation of the Gaussian for the intensity difference. Set the standard deviation of the Gaussian used to control how much an adjacent pixel is downweighted because of the intensity difference (depth in our case).</string>
+                                </property>
+                                <property name="wordWrap">
+                                 <bool>true</bool>
+                                </property>
+                                <property name="textInteractionFlags">
+                                 <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+                                </property>
+                               </widget>
+                              </item>
+                              <item row="0" column="0">
+                               <widget class="QDoubleSpinBox" name="doubleSpinBox_bilateral_sigmaS">
+                                <property name="suffix">
+                                 <string/>
+                                </property>
+                                <property name="decimals">
+                                 <number>1</number>
+                                </property>
+                                <property name="minimum">
+                                 <double>0.100000000000000</double>
+                                </property>
+                                <property name="maximum">
+                                 <double>100.000000000000000</double>
+                                </property>
+                                <property name="singleStep">
+                                 <double>1.000000000000000</double>
+                                </property>
+                                <property name="value">
+                                 <double>5.000000000000000</double>
+                                </property>
+                               </widget>
+                              </item>
+                              <item row="0" column="1">
+                               <widget class="QLabel" name="label_345">
+                                <property name="text">
+                                 <string>Size of the Gaussian bilateral filter window to use. Set the standard deviation of the Gaussian used by the bilateral filter for the spatial neighborhood/window.</string>
+                                </property>
+                                <property name="wordWrap">
+                                 <bool>true</bool>
+                                </property>
+                                <property name="textInteractionFlags">
+                                 <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+                                </property>
+                               </widget>
+                              </item>
+                             </layout>
+                            </widget>
+                           </item>
                            <item>
                             <widget class="QStackedWidget" name="stackedWidget_rgbd">
                              <property name="currentIndex">
@@ -4637,7 +4719,7 @@ when using the file type, logs are saved in LogRtabmap.txt (located in the worki
                        <item>
                         <widget class="QLabel" name="label_16">
                          <property name="text">
-                          <string>If you want to use ICP registration, the sensor data should have laser scan. Laser scans can be created from the depth images (see option below) or loaded from the source selected. The latter parameters can be used to reduce the point cloud size directly in the capturing thread.</string>
+                          <string>If you want to use ICP registration, the sensor data should have laser scan. Laser scans can be created from the depth images (see option below) or loaded from the source selected. These parameters can be used to reduce the point cloud size directly in the capturing thread.</string>
                          </property>
                          <property name="wordWrap">
                           <bool>true</bool>