Export dialog: hiding not used options, exporting can be now canceled on texturing phase

corelib/include/rtabmap/core/ProgressState.h

@@ -0,0 +1,43 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef CORELIB_INCLUDE_RTABMAP_CORE_PROGRESSSTATE_H_
+#define CORELIB_INCLUDE_RTABMAP_CORE_PROGRESSSTATE_H_
+
+
+class ProgressState
+{
+public:
+	virtual bool callback(const std::string & msg) const
+	{
+		return true;
+	}
+	virtual ~ProgressState(){}
+};
+
+
+#endif /* CORELIB_INCLUDE_RTABMAP_CORE_PROGRESSSTATE_H_ */

corelib/include/rtabmap/core/util3d_surface.h

@@ -37,6 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <pcl/pcl_base.h>
 #include <rtabmap/core/Transform.h>
 #include <rtabmap/core/CameraModel.h>
+#include <rtabmap/core/ProgressState.h>
 #include <set>
 #include <list>
 
@@ -136,7 +137,8 @@ pcl::TextureMesh::Ptr RTABMAP_EXP createTextureMesh(
 		const pcl::PolygonMesh::Ptr & mesh,
 		const std::map<int, Transform> & poses,
 		const std::map<int, CameraModel> & cameraModels,
-		float maxDistance = 0.0f); // max camera distance to polygon to apply texture
+		float maxDistance = 0.0f, // max camera distance to polygon to apply texture
+		const ProgressState * state = 0);
 
 pcl::PointCloud<pcl::Normal>::Ptr RTABMAP_EXP computeNormals(
 		const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

corelib/src/GainCompensator.cpp

@@ -305,11 +305,11 @@ void feedImpl(
 
 	gains = cv::Mat_<double>();
 	cv::solve(A, b, gains);
-	//if(ULogger::kDebug)
+	if(ULogger::kInfo)
 	{
 		for(int i=0; i<gains.rows; ++i)
 		{
-			UWARN("Gain index=%d (id=%d) = %f", i, indexToId[i], gains(i, 0));
+			UINFO("Gain index=%d (id=%d) = %f", i, indexToId[i], gains(i, 0));
 		}
 	}
 }

corelib/src/pcl18/surface/impl/texture_mapping.hpp

@@ -40,6 +40,7 @@
 
 #include <pcl/common/distances.h>
 #include <pcl18/surface/texture_mapping.h>
+#include <pcl/search/octree.h>
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 template<typename PointInT> std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >
@@ -1012,17 +1013,20 @@ class FaceInfo
 {
 public:
 	FaceInfo(float d,
+			bool facingCam,
 			const pcl::PointXY & uv1,
 			const pcl::PointXY & uv2,
 			const pcl::PointXY & uv3,
 			const pcl::PointXY & center) :
 				distance(d),
+				facingTheCam(facingCam),
 				uv_coord1(uv1),
 				uv_coord2(uv2),
 				uv_coord3(uv3),
 				uv_center(center)
 	{}
 	float distance;
+	bool facingTheCam;
 	pcl::PointXY uv_coord1;
 	pcl::PointXY uv_coord2;
 	pcl::PointXY uv_coord3;
@@ -1039,12 +1043,15 @@ bool ptInTriangle(const pcl::PointXY & p0, const pcl::PointXY & p1, const pcl::P
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
-template<typename PointInT> void
+template<typename PointInT> bool
-pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh &mesh, const pcl::texture_mapping::CameraVector &cameras)
+pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (
+		pcl::TextureMesh &mesh,
+		const pcl::texture_mapping::CameraVector &cameras,
+		const ProgressState * state)
 {
 
 	if (mesh.tex_polygons.size () != 1)
-		return;
+		return false;
 
 	typename pcl::PointCloud<PointInT>::Ptr mesh_cloud (new pcl::PointCloud<PointInT>);
 
@@ -1061,10 +1068,10 @@ pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh
 	// pre compute all cam inverse and visibility
 	std::vector<std::map<int, FaceInfo > > visibleFaces(cameras.size());
 	std::vector<Eigen::Affine3f> invCamTransform(cameras.size());
-	UDEBUG("Precompute visible faces per cam");
+	UINFO("Precompute visible faces per cam (%d faces, %d cams)", (int)faces.size(), (int)cameras.size());
 	for (unsigned int current_cam = 0; current_cam < cameras.size(); ++current_cam)
 	{
-		UINFO("Processing camera %d...", current_cam);
+		UDEBUG("Texture camera %d...", current_cam);
 
 		typename pcl::PointCloud<PointInT>::Ptr camera_cloud (new pcl::PointCloud<PointInT>);
 		pcl::transformPointCloud(*mesh_cloud, *camera_cloud, cameras[current_cam].pose.inverse());
@@ -1072,36 +1079,53 @@ pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh
 		std::vector<int> visibilityIndices;
 		visibilityIndices.resize (faces.size ());
 		pcl::PointCloud<pcl::PointXY>::Ptr projections (new pcl::PointCloud<pcl::PointXY>);
+		projections->resize(faces.size()*3);
+		std::map<float, int> sortedVisibleFaces;
 		int oi=0;
 		for(unsigned int idx_face=0; idx_face<faces.size(); ++idx_face)
 		{
 			pcl::Vertices & face = faces[idx_face];
-			pcl::PointXY uv_coords[3];
+
+			int j=oi*3;
+			pcl::PointXY & uv_coords1 = projections->at(j);
+			pcl::PointXY & uv_coords2 = projections->at(j+1);
+			pcl::PointXY & uv_coords3 = projections->at(j+2);
 			PointInT & pt0 = camera_cloud->points[face.vertices[0]];
 			PointInT & pt1 = camera_cloud->points[face.vertices[1]];
 			PointInT & pt2 = camera_cloud->points[face.vertices[2]];
-			float angle;
 			if (isFaceProjected (cameras[current_cam],
 					pt0,
 					pt1,
 					pt2,
-					uv_coords[0],
+					uv_coords1,
-					uv_coords[1],
+					uv_coords2,
-					uv_coords[2],
+					uv_coords3))
-					angle))
 			{
+				// check if the polygon is facing the camera, assuming counterclockwise normal
+				Eigen::Vector3f v0(
+						pt1.x - pt0.x,
+						pt1.y - pt0.y,
+						pt1.z - pt0.z);
+				Eigen::Vector3f v1(
+						pt2.x - pt0.x,
+						pt2.y - pt0.y,
+						pt2.z - pt0.z);
+				Eigen::Vector3f normal = v0.cross(v1);
+				float angle = normal.dot(Eigen::Vector3f(0.0f,0.0f,-1.0f));
+				bool facingTheCam = angle>0.0f;
+
 				float distanceToCam = std::min(std::min(pt0.z, pt1.z), pt2.z);
 				pcl::PointXY center;
-				center.x = (uv_coords[0].x+uv_coords[1].x+uv_coords[2].x)/3.0f;
+				center.x = (uv_coords1.x+uv_coords2.x+uv_coords3.x)/3.0f;
-				center.y = (uv_coords[0].y+uv_coords[1].y+uv_coords[2].y)/3.0f;
+				center.y = (uv_coords1.y+uv_coords2.y+uv_coords3.y)/3.0f;
-				visibleFaces[current_cam].insert(std::make_pair(idx_face, FaceInfo(distanceToCam, uv_coords[0], uv_coords[1], uv_coords[2], center)));
+				visibleFaces[current_cam].insert(visibleFaces[current_cam].end(), std::make_pair(idx_face, FaceInfo(distanceToCam, facingTheCam, uv_coords1, uv_coords2, uv_coords3, center)));
-				visibilityIndices[oi++] = idx_face;
+				sortedVisibleFaces.insert(std::make_pair(distanceToCam, idx_face));
-				projections->push_back(uv_coords[0]);
+				visibilityIndices[oi] = idx_face;
-				projections->push_back(uv_coords[1]);
+				++oi;
-				projections->push_back(uv_coords[2]);
 			}
 		}
 		visibilityIndices.resize(oi);
+		projections->resize(oi*3);
 		UASSERT(projections->size() == visibilityIndices.size()*3);
 
 		//filter occluded polygons
@@ -1115,9 +1139,11 @@ pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh
 		// then (idx_pcam == current_cam), check for self occlusions. At this stage, we skip faces that were already marked as occluded
 		// project all faces
 		int occludedFaces = 0;
-		for (unsigned int idx_vis = 0; idx_vis <  visibilityIndices.size(); ++idx_vis)
+		for (std::map<float, int>::iterator jter=sortedVisibleFaces.begin(); jter!=sortedVisibleFaces.end(); ++jter)
+		//for (unsigned int idx = 0; idx<visibilityIndices.size(); ++idx)
 		{
-			int idx_face = visibilityIndices[idx_vis];
+			int idx_face = jter->second;
+			//int idx_face = visibilityIndices[idx];
 			std::map<int, FaceInfo>::iterator iter= visibleFaces[current_cam].find(idx_face);
 			if(iter != visibleFaces[current_cam].end())
 			{
@@ -1210,13 +1236,36 @@ pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh
 			}
 		}
 
-		UDEBUG("Filtered %d occluded and %d spurious polygons out of %d...", occludedFaces, clusterFaces, (int)visibilityIndices.size());
+		std::string msg = uFormat("Processed camera %d/%d: %d occluded and %d spurious polygons out of %d", (int)current_cam+1, (int)cameras.size(), occludedFaces, clusterFaces, (int)visibilityIndices.size());
+		UINFO(msg.c_str());
+		if(state && !state->callback(msg))
+		{
+			//cancelled!
+			UWARN("Texturing cancelled!");
+			return false;
+		}
 	}
 
-	UDEBUG("Process %d polygons...", (int)faces.size());
+	std::string msg = uFormat("Texturing %d polygons...", (int)faces.size());
+	UINFO(msg.c_str());
+	if(state && !state->callback(msg))
+	{
+		//cancelled!
+		UWARN("Texturing cancelled!");
+		return false;
+	}
 	for(unsigned int idx_face=0; idx_face<faces.size(); ++idx_face)
 	{
-		UDEBUG("face %d", idx_face);
+		if((idx_face+1)%1000 == 0)
+		{
+			UDEBUG("face %d/%d", idx_face+1, (int)faces.size());
+			if(state && !state->callback(""))
+			{
+				//cancelled!
+				UWARN("Texturing cancelled!");
+				return false;
+			}
+		}
 		pcl::Vertices & face = faces[idx_face];
 
 		int cameraIndex = -1;
@@ -1225,7 +1274,7 @@ pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh
 		for (unsigned int current_cam = 0; current_cam < cameras.size(); ++current_cam)
 		{
 			std::map<int, FaceInfo>::iterator iter = visibleFaces[current_cam].find(idx_face);
-			if (iter != visibleFaces[current_cam].end())
+			if (iter != visibleFaces[current_cam].end() && iter->second.facingTheCam)
 			{
 				float distanceToCam = iter->second.distance;
 
@@ -1244,35 +1293,21 @@ pcl::TextureMapping<PointInT>::textureMeshwithMultipleCameras2 (pcl::TextureMesh
 
 		if(cameraIndex >= 0)
 		{
-			if(mesh.tex_polygons[cameraIndex].capacity() < mesh.tex_polygons[cameraIndex].size()+1)
-			{
-				mesh.tex_polygons[cameraIndex].reserve(mesh.tex_polygons[cameraIndex].size()+10);
-			}
 			mesh.tex_polygons[cameraIndex].push_back(face);
-			if(mesh.tex_coordinates[cameraIndex].capacity() < mesh.tex_coordinates[cameraIndex].size()+3)
-			{
-				mesh.tex_coordinates[cameraIndex].reserve(mesh.tex_coordinates[cameraIndex].size()+30);
-			}
 			mesh.tex_coordinates[cameraIndex].push_back(Eigen::Vector2f(uv_coords[0].x, uv_coords[0].y));
 			mesh.tex_coordinates[cameraIndex].push_back(Eigen::Vector2f(uv_coords[1].x, uv_coords[1].y));
 			mesh.tex_coordinates[cameraIndex].push_back(Eigen::Vector2f(uv_coords[2].x, uv_coords[2].y));
 		}
 		else
 		{
-			if(mesh.tex_polygons[cameras.size()].capacity() < mesh.tex_polygons[cameras.size()].size()+1)
-			{
-				mesh.tex_polygons[cameras.size()].reserve(mesh.tex_polygons[cameras.size()].size()+10);
-			}
 			mesh.tex_polygons[cameras.size()].push_back(face);
-			if(mesh.tex_coordinates[cameras.size()].capacity() < mesh.tex_coordinates[cameras.size()].size()+3)
-			{
-				mesh.tex_coordinates[cameras.size()].reserve(mesh.tex_coordinates[cameras.size()].size()+30);
-			}
 			mesh.tex_coordinates[cameras.size()].push_back(Eigen::Vector2f(-1.0,-1.0));
 			mesh.tex_coordinates[cameras.size()].push_back(Eigen::Vector2f(-1.0,-1.0));
 			mesh.tex_coordinates[cameras.size()].push_back(Eigen::Vector2f(-1.0,-1.0));
 		}
 	}
+	UINFO("Process %d polygons...done!", (int)faces.size());
+	return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -1396,28 +1431,13 @@ pcl::TextureMapping<PointInT>::checkPointInsideTriangle(const pcl::PointXY &p1,
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 template<typename PointInT> inline bool
-pcl::TextureMapping<PointInT>::isFaceProjected (const Camera &camera, const PointInT &p1, const PointInT &p2, const PointInT &p3, pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3, float & angle)
+pcl::TextureMapping<PointInT>::isFaceProjected (const Camera &camera, const PointInT &p1, const PointInT &p2, const PointInT &p3, pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3)
 {
-	// check if the polygon is facing the camera, assuming counterclockwise normal
+	return getPointUVCoordinates(p1, camera, proj1)
-	Eigen::Vector3f v0(
+			&&
-			p2.x - p1.x,
+			getPointUVCoordinates(p2, camera, proj2)
-			p2.y - p1.y,
+			&&
-			p2.z - p1.z);
+			getPointUVCoordinates(p3, camera, proj3);
-	Eigen::Vector3f v1(
-			p3.x - p1.x,
-			p3.y - p1.y,
-			p3.z - p1.z);
-	Eigen::Vector3f normal = v0.cross(v1);
-	normal.normalize();
-	angle = normal.dot(Eigen::Vector3f(0.0f,0.0f,-1.0f));
-
-  return  angle > 0.0f && // toward the camera
-		  (getPointUVCoordinates(p1, camera, proj1)
-		  &&
-		  getPointUVCoordinates(p2, camera, proj2)
-		  &&
-		  getPointUVCoordinates(p3, camera, proj3)
-  );
 }
 
 #define PCL_INSTANTIATE_TextureMapping(T)                \

corelib/src/pcl18/surface/texture_mapping.h

@@ -43,6 +43,7 @@
 #include <pcl/surface/reconstruction.h>
 #include <pcl/common/transforms.h>
 #include <pcl/TextureMesh.h>
+#include <rtabmap/core/ProgressState.h>
 #include <rtabmap/utilite/ULogger.h>
 #include <rtabmap/utilite/UStl.h>
 #include <rtabmap/utilite/UConversion.h>
@@ -341,9 +342,10 @@ namespace pcl
       void 
       textureMeshwithMultipleCameras (pcl::TextureMesh &mesh, 
                                       const pcl::texture_mapping::CameraVector &cameras);
-      void
+      bool
       textureMeshwithMultipleCameras2 (pcl::TextureMesh &mesh,
-                                      const pcl::texture_mapping::CameraVector &cameras);
+                                      const pcl::texture_mapping::CameraVector &cameras,
+									  const ProgressState * callback = 0);
 
     protected:
       /** \brief mesh scale control. */
@@ -414,7 +416,7 @@ namespace pcl
       inline bool
       isFaceProjected (const Camera &camera, 
                        const PointInT &p1, const PointInT &p2, const PointInT &p3, 
-                       pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3, float & angle);
+                       pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3);
 
       /** \brief Returns True if a point lays within a triangle
         * \details see http://www.blackpawn.com/texts/pointinpoly/default.html

corelib/src/util3d_surface.cpp

@@ -607,7 +607,8 @@ pcl::TextureMesh::Ptr createTextureMesh(
 		const pcl::PolygonMesh::Ptr & mesh,
 		const std::map<int, Transform> & poses,
 		const std::map<int, CameraModel> & cameraModels,
-		float maxDistance)
+		float maxDistance,
+		const ProgressState * state)
 {
 	UASSERT(mesh->polygons.size());
 	pcl::TextureMesh::Ptr textureMesh(new pcl::TextureMesh);
@@ -664,87 +665,87 @@ pcl::TextureMesh::Ptr createTextureMesh(
 	// Texture by projection
 	pcl::TextureMapping<pcl::PointXYZ> tm; // TextureMapping object that will perform the sort
 	tm.setMaxDistance(maxDistance);
-	tm.textureMeshwithMultipleCameras2(*textureMesh, cameras);
+	if(tm.textureMeshwithMultipleCameras2(*textureMesh, cameras, state))
-
-	// compute normals for the mesh if not already here
-	bool hasNormals = false;
-	bool hasColors = false;
-	for(unsigned int i=0; i<textureMesh->cloud.fields.size(); ++i)
 	{
-		if(textureMesh->cloud.fields[i].name.compare("normal_x") == 0)
+		// compute normals for the mesh if not already here
+		bool hasNormals = false;
+		bool hasColors = false;
+		for(unsigned int i=0; i<textureMesh->cloud.fields.size(); ++i)
 		{
-			hasNormals = true;
+			if(textureMesh->cloud.fields[i].name.compare("normal_x") == 0)
+			{
+				hasNormals = true;
+			}
+			else if(textureMesh->cloud.fields[i].name.compare("rgb") == 0)
+			{
+				hasColors = true;
+			}
 		}
-		else if(textureMesh->cloud.fields[i].name.compare("rgb") == 0)
+		if(!hasNormals)
 		{
-			hasColors = true;
+			// use polygons
+			if(hasColors)
+			{
+				pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
+				pcl::fromPCLPointCloud2(mesh->cloud, *cloud);
+
+				for(unsigned int i=0; i<mesh->polygons.size(); ++i)
+				{
+					pcl::Vertices & v = mesh->polygons[i];
+					UASSERT(v.vertices.size()>2);
+					Eigen::Vector3f v0(
+							cloud->at(v.vertices[1]).x - cloud->at(v.vertices[0]).x,
+							cloud->at(v.vertices[1]).y - cloud->at(v.vertices[0]).y,
+							cloud->at(v.vertices[1]).z - cloud->at(v.vertices[0]).z);
+					int last = v.vertices.size()-1;
+					Eigen::Vector3f v1(
+							cloud->at(v.vertices[last]).x - cloud->at(v.vertices[0]).x,
+							cloud->at(v.vertices[last]).y - cloud->at(v.vertices[0]).y,
+							cloud->at(v.vertices[last]).z - cloud->at(v.vertices[0]).z);
+					Eigen::Vector3f normal = v0.cross(v1);
+					normal.normalize();
+					// flat normal (per face)
+					for(unsigned int j=0; j<v.vertices.size(); ++j)
+					{
+						cloud->at(v.vertices[j]).normal_x = normal[0];
+						cloud->at(v.vertices[j]).normal_y = normal[1];
+						cloud->at(v.vertices[j]).normal_z = normal[2];
+					}
+				}
+				pcl::toPCLPointCloud2 (*cloud, textureMesh->cloud);
+			}
+			else
+			{
+				pcl::PointCloud<pcl::PointNormal>::Ptr cloud (new pcl::PointCloud<pcl::PointNormal>);
+				pcl::fromPCLPointCloud2(mesh->cloud, *cloud);
+
+				for(unsigned int i=0; i<mesh->polygons.size(); ++i)
+				{
+					pcl::Vertices & v = mesh->polygons[i];
+					UASSERT(v.vertices.size()>2);
+					Eigen::Vector3f v0(
+							cloud->at(v.vertices[1]).x - cloud->at(v.vertices[0]).x,
+							cloud->at(v.vertices[1]).y - cloud->at(v.vertices[0]).y,
+							cloud->at(v.vertices[1]).z - cloud->at(v.vertices[0]).z);
+					int last = v.vertices.size()-1;
+					Eigen::Vector3f v1(
+							cloud->at(v.vertices[last]).x - cloud->at(v.vertices[0]).x,
+							cloud->at(v.vertices[last]).y - cloud->at(v.vertices[0]).y,
+							cloud->at(v.vertices[last]).z - cloud->at(v.vertices[0]).z);
+					Eigen::Vector3f normal = v0.cross(v1);
+					normal.normalize();
+					// flat normal (per face)
+					for(unsigned int j=0; j<v.vertices.size(); ++j)
+					{
+						cloud->at(v.vertices[j]).normal_x = normal[0];
+						cloud->at(v.vertices[j]).normal_y = normal[1];
+						cloud->at(v.vertices[j]).normal_z = normal[2];
+					}
+				}
+				pcl::toPCLPointCloud2 (*cloud, textureMesh->cloud);
+			}
 		}
 	}
-	if(!hasNormals)
-	{
-		// use polygons
-		if(hasColors)
-		{
-			pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBNormal>);
-			pcl::fromPCLPointCloud2(mesh->cloud, *cloud);
-
-			for(unsigned int i=0; i<mesh->polygons.size(); ++i)
-			{
-				pcl::Vertices & v = mesh->polygons[i];
-				UASSERT(v.vertices.size()>2);
-				Eigen::Vector3f v0(
-						cloud->at(v.vertices[1]).x - cloud->at(v.vertices[0]).x,
-						cloud->at(v.vertices[1]).y - cloud->at(v.vertices[0]).y,
-						cloud->at(v.vertices[1]).z - cloud->at(v.vertices[0]).z);
-				int last = v.vertices.size()-1;
-				Eigen::Vector3f v1(
-						cloud->at(v.vertices[last]).x - cloud->at(v.vertices[0]).x,
-						cloud->at(v.vertices[last]).y - cloud->at(v.vertices[0]).y,
-						cloud->at(v.vertices[last]).z - cloud->at(v.vertices[0]).z);
-				Eigen::Vector3f normal = v0.cross(v1);
-				normal.normalize();
-				// flat normal (per face)
-				for(unsigned int j=0; j<v.vertices.size(); ++j)
-				{
-					cloud->at(v.vertices[j]).normal_x = normal[0];
-					cloud->at(v.vertices[j]).normal_y = normal[1];
-					cloud->at(v.vertices[j]).normal_z = normal[2];
-				}
-			}
-			pcl::toPCLPointCloud2 (*cloud, textureMesh->cloud);
-		}
-		else
-		{
-			pcl::PointCloud<pcl::PointNormal>::Ptr cloud (new pcl::PointCloud<pcl::PointNormal>);
-			pcl::fromPCLPointCloud2(mesh->cloud, *cloud);
-
-			for(unsigned int i=0; i<mesh->polygons.size(); ++i)
-			{
-				pcl::Vertices & v = mesh->polygons[i];
-				UASSERT(v.vertices.size()>2);
-				Eigen::Vector3f v0(
-						cloud->at(v.vertices[1]).x - cloud->at(v.vertices[0]).x,
-						cloud->at(v.vertices[1]).y - cloud->at(v.vertices[0]).y,
-						cloud->at(v.vertices[1]).z - cloud->at(v.vertices[0]).z);
-				int last = v.vertices.size()-1;
-				Eigen::Vector3f v1(
-						cloud->at(v.vertices[last]).x - cloud->at(v.vertices[0]).x,
-						cloud->at(v.vertices[last]).y - cloud->at(v.vertices[0]).y,
-						cloud->at(v.vertices[last]).z - cloud->at(v.vertices[0]).z);
-				Eigen::Vector3f normal = v0.cross(v1);
-				normal.normalize();
-				// flat normal (per face)
-				for(unsigned int j=0; j<v.vertices.size(); ++j)
-				{
-					cloud->at(v.vertices[j]).normal_x = normal[0];
-					cloud->at(v.vertices[j]).normal_y = normal[1];
-					cloud->at(v.vertices[j]).normal_z = normal[2];
-				}
-			}
-			pcl::toPCLPointCloud2 (*cloud, textureMesh->cloud);
-		}
-	}
-
 	return textureMesh;
 }
 

guilib/src/CMakeLists.txt

@@ -29,6 +29,7 @@ SET(headers_ui
 	./ParametersToolBox.h
 	./DepthCalibrationDialog.h
 	./3rdParty/QMultiComboBox.h
+	./TexturingState.h
 )
 
 SET(uis

guilib/src/ExportCloudsDialog.cpp

@@ -28,8 +28,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "ExportCloudsDialog.h"
 #include "ui_exportCloudsDialog.h"
 
-#include "rtabmap/gui/ProgressDialog.h"
 #include "rtabmap/gui/CloudViewer.h"
+#include "TexturingState.h"
 #include "rtabmap/utilite/ULogger.h"
 #include "rtabmap/utilite/UConversion.h"
 #include "rtabmap/utilite/UThread.h"
@@ -82,7 +82,8 @@ ExportCloudsDialog::ExportCloudsDialog(QWidget *parent) :
 	connect(_ui->comboBox_meshingApproach, SIGNAL(currentIndexChanged(int)), this, SIGNAL(configChanged()));
 	connect(_ui->comboBox_meshingApproach, SIGNAL(currentIndexChanged(int)), this, SLOT(updateReconstructionFlavor()));
 
-	connect(_ui->groupBox_regenerate, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_regenerate, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_regenerate, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->spinBox_decimation, SIGNAL(valueChanged(int)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_maxDepth, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_minDepth, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
@@ -92,11 +93,13 @@ 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->checkBox_bilateral, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_bilateral, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	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->checkBox_filtering, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_filtering, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->doubleSpinBox_filteringRadius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->spinBox_filteringMinNeighbors, SIGNAL(valueChanged(int)), this, SIGNAL(configChanged()));
 
@@ -104,12 +107,14 @@ ExportCloudsDialog::ExportCloudsDialog(QWidget *parent) :
 	connect(_ui->checkBox_assemble, SIGNAL(clicked(bool)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->doubleSpinBox_voxelSize_assembled, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 
-	connect(_ui->groupBox_subtraction, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_subtraction, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_subtraction, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->doubleSpinBox_subtractPointFilteringRadius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_subtractPointFilteringAngle, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->spinBox_subtractFilteringMinPts, SIGNAL(valueChanged(int)), this, SIGNAL(configChanged()));
 
-	connect(_ui->groupBox_mls, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_smoothing, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_smoothing, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->doubleSpinBox_mlsRadius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->spinBox_polygonialOrder, SIGNAL(valueChanged(int)), this, SIGNAL(configChanged()));
 	connect(_ui->comboBox_upsamplingMethod, SIGNAL(currentIndexChanged(int)), this, SIGNAL(configChanged()));
@@ -121,15 +126,17 @@ ExportCloudsDialog::ExportCloudsDialog(QWidget *parent) :
 	connect(_ui->comboBox_upsamplingMethod, SIGNAL(currentIndexChanged(int)), _ui->stackedWidget_upsampling, SLOT(setCurrentIndex(int)));
 	connect(_ui->comboBox_upsamplingMethod, SIGNAL(currentIndexChanged(int)), this, SLOT(updateMLSGrpVisibility()));
 
-	connect(_ui->groupBox_gain, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_gainCompensation, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_gainCompensation, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->doubleSpinBox_gainRadius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_gainOverlap, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_gainAlpha, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_gainBeta, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->checkBox_gainLinkedLocationsOnly, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
 
-	connect(_ui->groupBox_meshing, SIGNAL(clicked(bool)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_meshing, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
-	connect(_ui->groupBox_meshing, SIGNAL(toggled(bool)), this, SLOT(updateReconstructionFlavor()));
+	connect(_ui->checkBox_meshing, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
+	connect(_ui->checkBox_meshing, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
 	connect(_ui->doubleSpinBox_gp3Radius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_gp3Mu, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_meshDecimationFactor, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
@@ -142,6 +149,10 @@ ExportCloudsDialog::ExportCloudsDialog(QWidget *parent) :
 	connect(_ui->comboBox_meshingTextureFormat, SIGNAL(currentIndexChanged(int)), this, SIGNAL(configChanged()));
 	connect(_ui->comboBox_meshingTextureSize, SIGNAL(currentIndexChanged(int)), this, SIGNAL(configChanged()));
 	connect(_ui->doubleSpinBox_meshingTextureMaxDistance, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_cameraFilter, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
+	connect(_ui->checkBox_cameraFilter, SIGNAL(stateChanged(int)), this, SLOT(updateReconstructionFlavor()));
+	connect(_ui->doubleSpinBox_cameraFilterRadius, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
+	connect(_ui->doubleSpinBox_cameraFilterAngle, SIGNAL(valueChanged(double)), this, SIGNAL(configChanged()));
 
 	connect(_ui->checkBox_poisson_outputPolygons, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
 	connect(_ui->checkBox_poisson_manifold, SIGNAL(stateChanged(int)), this, SIGNAL(configChanged()));
@@ -199,7 +210,7 @@ void ExportCloudsDialog::saveSettings(QSettings & settings, const QString & grou
 	settings.setValue("binary", _ui->checkBox_binary->isChecked());
 	settings.setValue("normals_k", _ui->spinBox_normalKSearch->value());
 
-	settings.setValue("regenerate", _ui->groupBox_regenerate->isChecked());
+	settings.setValue("regenerate", _ui->checkBox_regenerate->isChecked());
 	settings.setValue("regenerate_decimation", _ui->spinBox_decimation->value());
 	settings.setValue("regenerate_max_depth", _ui->doubleSpinBox_maxDepth->value());
 	settings.setValue("regenerate_min_depth", _ui->doubleSpinBox_minDepth->value());
@@ -208,23 +219,23 @@ void ExportCloudsDialog::saveSettings(QSettings & settings, const QString & grou
 	settings.setValue("regenerate_roi", _ui->lineEdit_roiRatios->text());
 	settings.setValue("regenerate_distortion_model", _ui->lineEdit_distortionModel->text());
 
-	settings.setValue("bilateral", _ui->groupBox_bilateral->isChecked());
+	settings.setValue("bilateral", _ui->checkBox_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", _ui->checkBox_filtering->isChecked());
 	settings.setValue("filtering_radius", _ui->doubleSpinBox_filteringRadius->value());
 	settings.setValue("filtering_min_neighbors", _ui->spinBox_filteringMinNeighbors->value());
 
 	settings.setValue("assemble", _ui->checkBox_assemble->isChecked());
 	settings.setValue("assemble_voxel",_ui->doubleSpinBox_voxelSize_assembled->value());
 
-	settings.setValue("subtract",_ui->groupBox_subtraction->isChecked());
+	settings.setValue("subtract",_ui->checkBox_subtraction->isChecked());
 	settings.setValue("subtract_point_radius",_ui->doubleSpinBox_subtractPointFilteringRadius->value());
 	settings.setValue("subtract_point_angle",_ui->doubleSpinBox_subtractPointFilteringAngle->value());
 	settings.setValue("subtract_min_neighbors",_ui->spinBox_subtractFilteringMinPts->value());
 
-	settings.setValue("mls", _ui->groupBox_mls->isChecked());
+	settings.setValue("mls", _ui->checkBox_smoothing->isChecked());
 	settings.setValue("mls_radius", _ui->doubleSpinBox_mlsRadius->value());
 	settings.setValue("mls_polygonial_order", _ui->spinBox_polygonialOrder->value());
 	settings.setValue("mls_upsampling_method", _ui->comboBox_upsamplingMethod->currentIndex());
@@ -234,14 +245,14 @@ void ExportCloudsDialog::saveSettings(QSettings & settings, const QString & grou
 	settings.setValue("mls_dilation_voxel_size", _ui->doubleSpinBox_dilationVoxelSize->value());
 	settings.setValue("mls_dilation_iterations", _ui->spinBox_dilationSteps->value());
 
-	settings.setValue("gain", _ui->groupBox_gain->isChecked());
+	settings.setValue("gain", _ui->checkBox_gainCompensation->isChecked());
 	settings.setValue("gain_radius", _ui->doubleSpinBox_gainRadius->value());
 	settings.setValue("gain_overlap", _ui->doubleSpinBox_gainOverlap->value());
 	settings.setValue("gain_alpha", _ui->doubleSpinBox_gainAlpha->value());
 	settings.setValue("gain_beta", _ui->doubleSpinBox_gainBeta->value());
 	settings.setValue("gain_linked_locations", _ui->checkBox_gainLinkedLocationsOnly->isChecked());
 
-	settings.setValue("mesh", _ui->groupBox_meshing->isChecked());
+	settings.setValue("mesh", _ui->checkBox_meshing->isChecked());
 	settings.setValue("mesh_radius", _ui->doubleSpinBox_gp3Radius->value());
 	settings.setValue("mesh_mu", _ui->doubleSpinBox_gp3Mu->value());
 	settings.setValue("mesh_decimation_factor", _ui->doubleSpinBox_meshDecimationFactor->value());
@@ -255,6 +266,9 @@ void ExportCloudsDialog::saveSettings(QSettings & settings, const QString & grou
 	settings.setValue("mesh_textureFormat", _ui->comboBox_meshingTextureFormat->currentIndex());
 	settings.setValue("mesh_textureSize", _ui->comboBox_meshingTextureSize->currentIndex());
 	settings.setValue("mesh_textureMaxDistance", _ui->doubleSpinBox_meshingTextureMaxDistance->value());
+	settings.setValue("mesh_textureCameraFiltering", _ui->checkBox_cameraFilter->isChecked());
+	settings.setValue("mesh_textureCameraFilteringRadius", _ui->doubleSpinBox_cameraFilterRadius->value());
+	settings.setValue("mesh_textureCameraFilteringAngle", _ui->doubleSpinBox_cameraFilterAngle->value());
 
 
 	settings.setValue("mesh_angle_tolerance", _ui->doubleSpinBox_mesh_angleTolerance->value());
@@ -288,7 +302,7 @@ void ExportCloudsDialog::loadSettings(QSettings & settings, const QString & grou
 	_ui->checkBox_binary->setChecked(settings.value("binary", _ui->checkBox_binary->isChecked()).toBool());
 	_ui->spinBox_normalKSearch->setValue(settings.value("normals_k", _ui->spinBox_normalKSearch->value()).toInt());
 
-	_ui->groupBox_regenerate->setChecked(settings.value("regenerate", _ui->groupBox_regenerate->isChecked()).toBool());
+	_ui->checkBox_regenerate->setChecked(settings.value("regenerate", _ui->checkBox_regenerate->isChecked()).toBool());
 	_ui->spinBox_decimation->setValue(settings.value("regenerate_decimation", _ui->spinBox_decimation->value()).toInt());
 	_ui->doubleSpinBox_maxDepth->setValue(settings.value("regenerate_max_depth", _ui->doubleSpinBox_maxDepth->value()).toDouble());
 	_ui->doubleSpinBox_minDepth->setValue(settings.value("regenerate_min_depth", _ui->doubleSpinBox_minDepth->value()).toDouble());
@@ -297,23 +311,23 @@ void ExportCloudsDialog::loadSettings(QSettings & settings, const QString & grou
 	_ui->lineEdit_roiRatios->setText(settings.value("regenerate_roi", _ui->lineEdit_roiRatios->text()).toString());
 	_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->checkBox_bilateral->setChecked(settings.value("bilateral", _ui->checkBox_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->checkBox_filtering->setChecked(settings.value("filtering", _ui->checkBox_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());
 
 	_ui->checkBox_assemble->setChecked(settings.value("assemble", _ui->checkBox_assemble->isChecked()).toBool());
 	_ui->doubleSpinBox_voxelSize_assembled->setValue(settings.value("assemble_voxel", _ui->doubleSpinBox_voxelSize_assembled->value()).toDouble());
 
-	_ui->groupBox_subtraction->setChecked(settings.value("subtract",_ui->groupBox_subtraction->isChecked()).toBool());
+	_ui->checkBox_subtraction->setChecked(settings.value("subtract",_ui->checkBox_subtraction->isChecked()).toBool());
 	_ui->doubleSpinBox_subtractPointFilteringRadius->setValue(settings.value("subtract_point_radius",_ui->doubleSpinBox_subtractPointFilteringRadius->value()).toDouble());
 	_ui->doubleSpinBox_subtractPointFilteringAngle->setValue(settings.value("subtract_point_angle",_ui->doubleSpinBox_subtractPointFilteringAngle->value()).toDouble());
 	_ui->spinBox_subtractFilteringMinPts->setValue(settings.value("subtract_min_neighbors",_ui->spinBox_subtractFilteringMinPts->value()).toInt());
 
-	_ui->groupBox_mls->setChecked(settings.value("mls", _ui->groupBox_mls->isChecked()).toBool());
+	_ui->checkBox_smoothing->setChecked(settings.value("mls", _ui->checkBox_smoothing->isChecked()).toBool());
 	_ui->doubleSpinBox_mlsRadius->setValue(settings.value("mls_radius", _ui->doubleSpinBox_mlsRadius->value()).toDouble());
 	_ui->spinBox_polygonialOrder->setValue(settings.value("mls_polygonial_order", _ui->spinBox_polygonialOrder->value()).toInt());
 	_ui->comboBox_upsamplingMethod->setCurrentIndex(settings.value("mls_upsampling_method", _ui->comboBox_upsamplingMethod->currentIndex()).toInt());
@@ -323,14 +337,14 @@ void ExportCloudsDialog::loadSettings(QSettings & settings, const QString & grou
 	_ui->doubleSpinBox_dilationVoxelSize->setValue(settings.value("mls_dilation_voxel_size", _ui->doubleSpinBox_dilationVoxelSize->value()).toDouble());
 	_ui->spinBox_dilationSteps->setValue(settings.value("mls_dilation_iterations", _ui->spinBox_dilationSteps->value()).toInt());
 
-	_ui->groupBox_gain->setChecked(settings.value("gain", _ui->groupBox_gain->isChecked()).toBool());
+	_ui->checkBox_gainCompensation->setChecked(settings.value("gain", _ui->checkBox_gainCompensation->isChecked()).toBool());
 	_ui->doubleSpinBox_gainRadius->setValue(settings.value("gain_radius", _ui->doubleSpinBox_gainRadius->value()).toDouble());
 	_ui->doubleSpinBox_gainOverlap->setValue(settings.value("gain_overlap", _ui->doubleSpinBox_gainOverlap->value()).toDouble());
 	_ui->doubleSpinBox_gainAlpha->setValue(settings.value("gain_alpha", _ui->doubleSpinBox_gainAlpha->value()).toDouble());
 	_ui->doubleSpinBox_gainBeta->setValue(settings.value("gain_beta", _ui->doubleSpinBox_gainBeta->value()).toDouble());
 	_ui->checkBox_gainLinkedLocationsOnly->setChecked(settings.value("gain_linked_locations", _ui->checkBox_gainLinkedLocationsOnly->isChecked()).toBool());
 
-	_ui->groupBox_meshing->setChecked(settings.value("mesh", _ui->groupBox_meshing->isChecked()).toBool());
+	_ui->checkBox_meshing->setChecked(settings.value("mesh", _ui->checkBox_meshing->isChecked()).toBool());
 	_ui->doubleSpinBox_gp3Radius->setValue(settings.value("mesh_radius", _ui->doubleSpinBox_gp3Radius->value()).toDouble());
 	_ui->doubleSpinBox_gp3Mu->setValue(settings.value("mesh_mu", _ui->doubleSpinBox_gp3Mu->value()).toDouble());
 	_ui->doubleSpinBox_meshDecimationFactor->setValue(settings.value("mesh_decimation_factor",_ui->doubleSpinBox_meshDecimationFactor->value()).toDouble());
@@ -344,6 +358,9 @@ void ExportCloudsDialog::loadSettings(QSettings & settings, const QString & grou
 	_ui->comboBox_meshingTextureFormat->setCurrentIndex(settings.value("mesh_textureFormat", _ui->comboBox_meshingTextureFormat->currentIndex()).toInt());
 	_ui->comboBox_meshingTextureSize->setCurrentIndex(settings.value("mesh_textureSize", _ui->comboBox_meshingTextureSize->currentIndex()).toInt());
 	_ui->doubleSpinBox_meshingTextureMaxDistance->setValue(settings.value("mesh_textureMaxDistance", _ui->doubleSpinBox_meshingTextureMaxDistance->value()).toDouble());
+	_ui->checkBox_cameraFilter->setChecked(settings.value("mesh_textureCameraFiltering", _ui->checkBox_cameraFilter->isChecked()).toBool());
+	_ui->doubleSpinBox_cameraFilterRadius->setValue(settings.value("mesh_textureCameraFilteringRadius", _ui->doubleSpinBox_cameraFilterRadius->value()).toDouble());
+	_ui->doubleSpinBox_cameraFilterAngle->setValue(settings.value("mesh_textureCameraFilteringAngle", _ui->doubleSpinBox_cameraFilterAngle->value()).toDouble());
 
 	_ui->doubleSpinBox_mesh_angleTolerance->setValue(settings.value("mesh_angle_tolerance", _ui->doubleSpinBox_mesh_angleTolerance->value()).toDouble());
 	_ui->checkBox_mesh_quad->setChecked(settings.value("mesh_quad", _ui->checkBox_mesh_quad->isChecked()).toBool());
@@ -374,7 +391,7 @@ void ExportCloudsDialog::restoreDefaults()
 	_ui->checkBox_binary->setChecked(true);
 	_ui->spinBox_normalKSearch->setValue(10);
 
-	_ui->groupBox_regenerate->setChecked(false);
+	_ui->checkBox_regenerate->setChecked(false);
 	_ui->spinBox_decimation->setValue(1);
 	_ui->doubleSpinBox_maxDepth->setValue(4);
 	_ui->doubleSpinBox_minDepth->setValue(0);
@@ -383,23 +400,23 @@ void ExportCloudsDialog::restoreDefaults()
 	_ui->lineEdit_roiRatios->setText("0.0 0.0 0.0 0.0");
 	_ui->lineEdit_distortionModel->setText("");
 
-	_ui->groupBox_bilateral->setChecked(false);
+	_ui->checkBox_bilateral->setChecked(false);
 	_ui->doubleSpinBox_bilateral_sigmaS->setValue(10.0);
 	_ui->doubleSpinBox_bilateral_sigmaR->setValue(0.1);
 
-	_ui->groupBox_filtering->setChecked(false);
+	_ui->checkBox_filtering->setChecked(false);
 	_ui->doubleSpinBox_filteringRadius->setValue(0.02);
 	_ui->spinBox_filteringMinNeighbors->setValue(2);
 
 	_ui->checkBox_assemble->setChecked(true);
 	_ui->doubleSpinBox_voxelSize_assembled->setValue(0.0);
 
-	_ui->groupBox_subtraction->setChecked(false);
+	_ui->checkBox_subtraction->setChecked(false);
 	_ui->doubleSpinBox_subtractPointFilteringRadius->setValue(0.02);
 	_ui->doubleSpinBox_subtractPointFilteringAngle->setValue(0);
 	_ui->spinBox_subtractFilteringMinPts->setValue(5);
 
-	_ui->groupBox_mls->setChecked(false);
+	_ui->checkBox_smoothing->setChecked(false);
 	_ui->doubleSpinBox_mlsRadius->setValue(0.04);
 	_ui->spinBox_polygonialOrder->setValue(2);
 	_ui->comboBox_upsamplingMethod->setCurrentIndex(0);
@@ -409,14 +426,14 @@ void ExportCloudsDialog::restoreDefaults()
 	_ui->doubleSpinBox_dilationVoxelSize->setValue(0.01);
 	_ui->spinBox_dilationSteps->setValue(0);
 
-	_ui->groupBox_gain->setChecked(false);
+	_ui->checkBox_gainCompensation->setChecked(false);
 	_ui->doubleSpinBox_gainRadius->setValue(0.02);
 	_ui->doubleSpinBox_gainOverlap->setValue(0.05);
 	_ui->doubleSpinBox_gainAlpha->setValue(0.01);
 	_ui->doubleSpinBox_gainBeta->setValue(10);
 	_ui->checkBox_gainLinkedLocationsOnly->setChecked(true);
 
-	_ui->groupBox_meshing->setChecked(false);
+	_ui->checkBox_meshing->setChecked(false);
 	_ui->doubleSpinBox_gp3Radius->setValue(0.2);
 	_ui->doubleSpinBox_gp3Mu->setValue(2.5);
 	_ui->doubleSpinBox_meshDecimationFactor->setValue(0.0);
@@ -430,6 +447,9 @@ void ExportCloudsDialog::restoreDefaults()
 	_ui->comboBox_meshingTextureFormat->setCurrentIndex(0);
 	_ui->comboBox_meshingTextureSize->setCurrentIndex(5); // 4096
 	_ui->doubleSpinBox_meshingTextureMaxDistance->setValue(3.0);
+	_ui->checkBox_cameraFilter->setChecked(false);
+	_ui->doubleSpinBox_cameraFilterRadius->setValue(0.1);
+	_ui->doubleSpinBox_cameraFilterAngle->setValue(30);
 
 	_ui->doubleSpinBox_mesh_angleTolerance->setValue(15.0);
 	_ui->checkBox_mesh_quad->setChecked(false);
@@ -453,21 +473,34 @@ void ExportCloudsDialog::restoreDefaults()
 
 void ExportCloudsDialog::updateReconstructionFlavor()
 {
-	_ui->groupBox_mls->setVisible(_ui->comboBox_pipeline->currentIndex() == 1);
+	_ui->checkBox_smoothing->setVisible(_ui->comboBox_pipeline->currentIndex() == 1);
-	_ui->groupBox_mls->setEnabled(_ui->comboBox_pipeline->currentIndex() == 1);
+	_ui->checkBox_smoothing->setEnabled(_ui->comboBox_pipeline->currentIndex() == 1);
 	_ui->label_denseReconstruction->setEnabled(_ui->comboBox_pipeline->currentIndex() == 1);
 	_ui->doubleSpinBox_meshDecimationFactor->setEnabled(_ui->comboBox_pipeline->currentIndex() == 1);
 	_ui->label_meshDecimation->setEnabled(_ui->comboBox_pipeline->currentIndex() == 1);
 	_ui->groupBox_organized->setVisible(_ui->comboBox_pipeline->currentIndex() == 0);
 
+	_ui->groupBox_regenerate->setVisible(_ui->checkBox_regenerate->isChecked());
+	_ui->groupBox_bilateral->setVisible(_ui->checkBox_bilateral->isChecked());
+	_ui->groupBox_filtering->setVisible(_ui->checkBox_filtering->isChecked());
+	_ui->groupBox_gain->setVisible(_ui->checkBox_gainCompensation->isChecked());
+	_ui->groupBox_mls->setVisible(_ui->checkBox_smoothing->isEnabled() && _ui->checkBox_smoothing->isChecked());
+	_ui->groupBox_meshing->setVisible(_ui->checkBox_meshing->isChecked());
+	_ui->groupBox_subtraction->setVisible(_ui->checkBox_subtraction->isChecked());
+	_ui->groupBox_textureMapping->setVisible(_ui->checkBox_textureMapping->isChecked());
+	_ui->groupBox_cameraFilter->setVisible(_ui->checkBox_cameraFilter->isChecked());
+
 	// dense texturing options
 	_ui->groupBox_gp3->setVisible(_ui->comboBox_pipeline->currentIndex() == 1 && _ui->comboBox_meshingApproach->currentIndex()==0);
 	_ui->groupBox_poisson->setVisible(_ui->comboBox_pipeline->currentIndex() == 1 && _ui->comboBox_meshingApproach->currentIndex()==1);
-	if(_ui->groupBox_meshing->isChecked())
+	if(_ui->checkBox_meshing->isChecked())
 	{
 		_ui->comboBox_meshingApproach->setEnabled(_ui->comboBox_pipeline->currentIndex() == 1);
-		_ui->comboBox_meshingApproach->setCurrentIndex(_ui->checkBox_assemble->isChecked()?1:0);
 		_ui->comboBox_meshingApproach->setItemData(1, _ui->checkBox_assemble->isChecked()?1 | 32:0,Qt::UserRole - 1);
+		if(!_ui->checkBox_assemble->isChecked())
+		{
+			_ui->comboBox_meshingApproach->setCurrentIndex(0);
+		}
 
 		_ui->checkBox_poisson_outputPolygons->setDisabled(
 					_ui->checkBox_binary->isEnabled() ||
@@ -523,9 +556,9 @@ void ExportCloudsDialog::enableRegeneration(bool enabled)
 {
 	if(!enabled)
 	{
-		_ui->groupBox_regenerate->setChecked(false);
+		_ui->checkBox_regenerate->setChecked(false);
 	}
-	_ui->groupBox_regenerate->setEnabled(enabled);
+	_ui->checkBox_regenerate->setEnabled(enabled);
 }
 
 void ExportCloudsDialog::exportClouds(
@@ -715,7 +748,7 @@ void ExportCloudsDialog::viewClouds(
 					UASSERT(cachedSignatures.contains(textureId) && !cachedSignatures.value(textureId).sensorData().imageCompressed().empty());
 					cachedSignatures.value(textureId).sensorData().uncompressDataConst(&globalTexture, 0);
 					UASSERT(!globalTexture.empty());
-					if (_ui->groupBox_gain->isChecked() && _compensator && _compensator->getIndex(textureId) >= 0)
+					if (_ui->checkBox_gainCompensation->isChecked() && _compensator && _compensator->getIndex(textureId) >= 0)
 					{
 						_compensator->apply(textureId, globalTexture);
 					}
@@ -837,7 +870,7 @@ bool ExportCloudsDialog::getExportedClouds(
 		_progressDialog->resetProgress();
 		_progressDialog->show();
 		int mul = 1;
-		if(_ui->groupBox_meshing->isChecked())
+		if(_ui->checkBox_meshing->isChecked())
 		{
 			mul+=1;
 		}
@@ -846,7 +879,7 @@ bool ExportCloudsDialog::getExportedClouds(
 			mul+=1;
 		}
 
-		if(_ui->groupBox_subtraction->isChecked())
+		if(_ui->checkBox_subtraction->isChecked())
 		{
 			mul+=1;
 		}
@@ -855,7 +888,7 @@ bool ExportCloudsDialog::getExportedClouds(
 		{
 			mul+=1;
 		}
-		if(_ui->groupBox_gain->isChecked())
+		if(_ui->checkBox_gainCompensation->isChecked())
 		{
 			mul+=1;
 		}
@@ -879,7 +912,7 @@ bool ExportCloudsDialog::getExportedClouds(
 		if(clouds.empty())
 		{
 			_progressDialog->setAutoClose(false);
-			if(_ui->groupBox_regenerate->isEnabled() && !_ui->groupBox_regenerate->isChecked())
+			if(_ui->checkBox_regenerate->isEnabled() && !_ui->checkBox_regenerate->isChecked())
 			{
 				QMessageBox::warning(this, tr("Creating clouds..."), tr("Could create clouds for %1 node(s). You "
 						"may want to activate clouds regeneration option.").arg(poses.size()));
@@ -892,7 +925,7 @@ bool ExportCloudsDialog::getExportedClouds(
 			return false;
 		}
 
-		if(_ui->groupBox_gain->isChecked() && clouds.size() > 1)
+		if(_ui->checkBox_gainCompensation->isChecked() && clouds.size() > 1)
 		{
 			UASSERT(_compensator == 0);
 			_compensator = new GainCompensator(_ui->doubleSpinBox_gainRadius->value(), _ui->doubleSpinBox_gainOverlap->value(), _ui->doubleSpinBox_gainAlpha->value(), _ui->doubleSpinBox_gainBeta->value());
@@ -931,7 +964,7 @@ bool ExportCloudsDialog::getExportedClouds(
 				_compensator->feed(clouds, links);
 			}
 
-			if(!(_ui->groupBox_meshing->isChecked() &&
+			if(!(_ui->checkBox_meshing->isChecked() &&
 				 _ui->checkBox_textureMapping->isEnabled() &&
 				 _ui->checkBox_textureMapping->isChecked()))
 			{
@@ -958,7 +991,7 @@ bool ExportCloudsDialog::getExportedClouds(
 		pcl::PointCloud<pcl::PointXYZ>::Ptr rawAssembledCloud(new pcl::PointCloud<pcl::PointXYZ>);
 		std::vector<int> rawCameraIndices;
 		if(_ui->checkBox_assemble->isChecked() &&
-		   !(_ui->comboBox_pipeline->currentIndex()==0 && _ui->groupBox_meshing->isChecked()))
+		   !(_ui->comboBox_pipeline->currentIndex()==0 && _ui->checkBox_meshing->isChecked()))
 		{
 			_progressDialog->appendText(tr("Assembling %1 clouds...").arg(clouds.size()));
 			QApplication::processEvents();
@@ -1020,7 +1053,7 @@ bool ExportCloudsDialog::getExportedClouds(
 		}
 
 		std::map<int, Transform> viewPoints = poses;
-		if(_ui->groupBox_mls->isEnabled() && _ui->groupBox_mls->isChecked())
+		if(_ui->checkBox_smoothing->isEnabled() && _ui->checkBox_smoothing->isChecked())
 		{
 			_progressDialog->appendText(tr("Smoothing the surface using Moving Least Squares (MLS) algorithm... "
 					"[search radius=%1m voxel=%2m]").arg(_ui->doubleSpinBox_mlsRadius->value()).arg(_ui->doubleSpinBox_voxelSize_assembled->value()));
@@ -1053,7 +1086,7 @@ bool ExportCloudsDialog::getExportedClouds(
 		{
 			pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr cloudWithNormals = iter->second.first;
 
-			if(_ui->groupBox_mls->isEnabled() && _ui->groupBox_mls->isChecked())
+			if(_ui->checkBox_smoothing->isEnabled() && _ui->checkBox_smoothing->isChecked())
 			{
 				pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudWithoutNormals(new pcl::PointCloud<pcl::PointXYZRGB>);
 				if(iter->second.second->size())
@@ -1109,7 +1142,7 @@ bool ExportCloudsDialog::getExportedClouds(
 							cloudWithNormals);
 				}
 			}
-			else if(iter->second.first->isOrganized() && _ui->groupBox_filtering->isChecked())
+			else if(iter->second.first->isOrganized() && _ui->checkBox_filtering->isChecked())
 			{
 				cloudWithNormals = util3d::extractIndices(iter->second.first, iter->second.second, false, true);
 			}
@@ -1129,8 +1162,8 @@ bool ExportCloudsDialog::getExportedClouds(
 		std::map<int, cv::Size> organizedCloudSizes;
 
 		//mesh
-		UDEBUG("Meshing=%d", _ui->groupBox_meshing->isChecked()?1:0);
+		UDEBUG("Meshing=%d", _ui->checkBox_meshing->isChecked()?1:0);
-		if(_ui->groupBox_meshing->isChecked())
+		if(_ui->checkBox_meshing->isChecked())
 		{
 			if(_ui->comboBox_pipeline->currentIndex() == 0)
 			{
@@ -1720,11 +1753,47 @@ bool ExportCloudsDialog::getExportedClouds(
 					else
 					{
 						UDEBUG("Texture by projection");
+
+						if(cameraPoses.size() && _ui->checkBox_cameraFilter->isChecked())
+						{
+							int before = (int)cameraPoses.size();
+							cameraPoses = graph::radiusPosesFiltering(cameraPoses,
+									_ui->doubleSpinBox_cameraFilterRadius->value(),
+									_ui->doubleSpinBox_cameraFilterAngle->value());
+							for(std::map<int, CameraModel>::iterator modelIter = cameraModels.begin(); modelIter!=cameraModels.end();)
+							{
+								if(cameraPoses.find(modelIter->first)==cameraPoses.end())
+								{
+									cameraModels.erase(modelIter++);
+								}
+								else
+								{
+									++modelIter;
+								}
+							}
+							_progressDialog->appendText(tr("Camera filtering: keeping %1/%2 cameras for texturing.").arg(cameraPoses.size()).arg(before));
+							QApplication::processEvents();
+							uSleep(100);
+							QApplication::processEvents();
+						}
+
+						if(_canceled)
+						{
+							return false;
+						}
+
+						TexturingState texturingState(_progressDialog);
 						textureMesh = util3d::createTextureMesh(
 								iter->second,
 								cameraPoses,
 								cameraModels,
-								_ui->doubleSpinBox_meshingTextureMaxDistance->value());
+								_ui->doubleSpinBox_meshingTextureMaxDistance->value(),
+								&texturingState);
+
+						if(_canceled)
+						{
+							return false;
+						}
 
 						// Remove occluded polygons (polygons with no texture)
 						if(_ui->checkBox_cleanMesh->isChecked() &&
@@ -1922,7 +1991,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 		{
 			pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGBNormal>);
 			pcl::IndicesPtr indices(new std::vector<int>);
-			if(_ui->groupBox_regenerate->isChecked())
+			if(_ui->checkBox_regenerate->isChecked())
 			{
 				if(cachedSignatures.contains(iter->first))
 				{
@@ -1948,7 +2017,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 						}
 
 						// bilateral filtering
-						if(_ui->groupBox_bilateral->isChecked())
+						if(_ui->checkBox_bilateral->isChecked())
 						{
 							depth = util2d::fastBilateralFiltering(depth,
 									_ui->doubleSpinBox_bilateral_sigmaS->value(),
@@ -1983,7 +2052,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 						if(cloudWithoutNormals->size())
 						{
 							// Don't voxelize if we create organized mesh
-							if(!(_ui->comboBox_pipeline->currentIndex()==0 && _ui->groupBox_meshing->isChecked()) && _ui->doubleSpinBox_voxelSize_assembled->value()>0.0)
+							if(!(_ui->comboBox_pipeline->currentIndex()==0 && _ui->checkBox_meshing->isChecked()) && _ui->doubleSpinBox_voxelSize_assembled->value()>0.0)
 							{
 								cloudWithoutNormals = util3d::voxelize(cloudWithoutNormals, indices, _ui->doubleSpinBox_voxelSize_assembled->value());
 								indices->resize(cloudWithoutNormals->size());
@@ -2011,7 +2080,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 							pcl::PointCloud<pcl::Normal>::Ptr normals = util3d::computeNormals(cloudWithoutNormals, indices, _ui->spinBox_normalKSearch->value(), viewPoint);
 							pcl::concatenateFields(*cloudWithoutNormals, *normals, *cloud);
 
-							if(_ui->groupBox_subtraction->isChecked() &&
+							if(_ui->checkBox_subtraction->isChecked() &&
 							   _ui->doubleSpinBox_subtractPointFilteringRadius->value() > 0.0)
 							{
 								pcl::IndicesPtr beforeSubtractionIndices = indices;
@@ -2047,7 +2116,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 			else if(uContains(cachedClouds, iter->first))
 			{
 				pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudWithoutNormals;
-				if(!_ui->groupBox_meshing->isChecked() &&
+				if(!_ui->checkBox_meshing->isChecked() &&
 				   _ui->doubleSpinBox_voxelSize_assembled->value() > 0.0)
 				{
 					cloudWithoutNormals = util3d::voxelize(
@@ -2102,7 +2171,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 
 			if(indices->size())
 			{
-				if(_ui->groupBox_filtering->isChecked() &&
+				if(_ui->checkBox_filtering->isChecked() &&
 					_ui->doubleSpinBox_filteringRadius->value() > 0.0f &&
 					_ui->spinBox_filteringMinNeighbors->value() > 0)
 				{
@@ -2121,7 +2190,7 @@ std::map<int, std::pair<pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr, pcl::Indic
 
 		if(points>0)
 		{
-			if(_ui->groupBox_regenerate->isChecked())
+			if(_ui->checkBox_regenerate->isChecked())
 			{
 				_progressDialog->appendText(tr("Generated cloud %1 with %2 points and %3 indices (%4/%5).")
 						.arg(iter->first).arg(points).arg(totalIndices).arg(index).arg(poses.size()));
@@ -2511,7 +2580,7 @@ cv::Mat ExportCloudsDialog::mergeTextures(pcl::TextureMesh & mesh, const QMap<in
 							UASSERT(!image.empty());
 							cv::Mat resizedImage;
 							cv::resize(image, resizedImage, emptyImage.size(), 0.0f, 0.0f, cv::INTER_AREA);
-							if(_ui->groupBox_gain->isChecked() && _compensator && _compensator->getIndex(textures[t]) >= 0)
+							if(_ui->checkBox_gainCompensation->isChecked() && _compensator && _compensator->getIndex(textures[t]) >= 0)
 							{
 								_compensator->apply(textures[t], resizedImage);
 							}
@@ -2595,7 +2664,7 @@ void ExportCloudsDialog::saveTextureMeshes(
 								cachedSignatures.value(textureId).sensorData().uncompressDataConst(&image, 0);
 								UASSERT(!image.empty());
 								imageSize = image.size();
-								if(_ui->groupBox_gain->isChecked() && _compensator && _compensator->getIndex(textureId) >= 0)
+								if(_ui->checkBox_gainCompensation->isChecked() && _compensator && _compensator->getIndex(textureId) >= 0)
 								{
 									_compensator->apply(textureId, image);
 								}
@@ -2715,7 +2784,7 @@ void ExportCloudsDialog::saveTextureMeshes(
 									cachedSignatures.value(textureId).sensorData().uncompressDataConst(&image, 0);
 									UASSERT(!image.empty());
 									imageSize = image.size();
-									if(_ui->groupBox_gain->isChecked() && _compensator && _compensator->getIndex(textureId) >= 0)
+									if(_ui->checkBox_gainCompensation->isChecked() && _compensator && _compensator->getIndex(textureId) >= 0)
 									{
 										_compensator->apply(textureId, image);
 									}

guilib/src/MainWindow.cpp

@@ -285,7 +285,6 @@ MainWindow::MainWindow(PreferencesDialog * prefDialog, QWidget * parent) :
 	_ui->rawLikelihoodPlot->showLegend(false);
 
 	_initProgressDialog = new ProgressDialog(this);
-	_initProgressDialog->setWindowTitle(tr("Progress dialog"));
 	_initProgressDialog->setMinimumWidth(800);
 	connect(_initProgressDialog, SIGNAL(canceled()), this, SLOT(cancelProgress()));
 

guilib/src/TexturingState.h

@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#ifndef GUILIB_SRC_TEXTURINGSTATE_H_
+#define GUILIB_SRC_TEXTURINGSTATE_H_
+
+#include "rtabmap/gui/ProgressDialog.h"
+#include "rtabmap/core/ProgressState.h"
+#include <QApplication>
+
+namespace rtabmap {
+
+class TexturingState : public QObject, public ProgressState
+{
+	Q_OBJECT
+
+public:
+	TexturingState(ProgressDialog * dialog): dialog_(dialog), canceled_(false)
+	{
+		connect(dialog_, SIGNAL(canceled()), this, SLOT(cancel()));
+	}
+	virtual ~TexturingState() {}
+	virtual bool callback(const std::string & msg) const
+	{
+		if(!msg.empty())
+		{
+			dialog_->appendText(msg.c_str());
+		}
+		QApplication::processEvents();
+		return !canceled_;
+	}
+
+public slots:
+	void cancel()
+	{
+		canceled_ = true;
+	}
+
+private:
+	ProgressDialog * dialog_;
+	bool canceled_;
+};
+
+}
+
+#endif /* GUILIB_SRC_TEXTURINGSTATE_H_ */

guilib/src/ui/exportCloudsDialog.ui

@@ -23,24 +23,14 @@
       <property name="geometry">
        <rect>
         <x>0</x>
-        <y>-1643</y>
+        <y>-1879</y>
         <width>773</width>
-        <height>2810</height>
+        <height>3158</height>
        </rect>
       </property>
       <layout class="QVBoxLayout" name="verticalLayout_13">
        <item>
         <layout class="QGridLayout" name="gridLayout_8" columnstretch="0,1">
-         <item row="3" column="0">
-          <widget class="QSpinBox" name="spinBox_normalKSearch">
-           <property name="minimum">
-            <number>3</number>
-           </property>
-           <property name="value">
-            <number>20</number>
-           </property>
-          </widget>
-         </item>
          <item row="2" column="0">
           <widget class="QCheckBox" name="checkBox_assemble">
            <property name="text">
@@ -68,6 +58,94 @@
            </property>
           </widget>
          </item>
+         <item row="3" column="1">
+          <widget class="QLabel" name="label_normal">
+           <property name="text">
+            <string>Set the number of k nearest neighbors to use for the normal estimation.</string>
+           </property>
+           <property name="wordWrap">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="8" column="0">
+          <widget class="QCheckBox" name="checkBox_gainCompensation">
+           <property name="text">
+            <string/>
+           </property>
+          </widget>
+         </item>
+         <item row="5" column="1">
+          <widget class="QLabel" name="label_binaryFile_8">
+           <property name="text">
+            <string>Regenerate clouds. This can be used to regenerate the point clouds at higher density than those used for online visualization.</string>
+           </property>
+           <property name="wordWrap">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="8" column="1">
+          <widget class="QLabel" name="label_binaryFile_11">
+           <property name="text">
+            <string>Gain compensation. Normalize brightness of images.</string>
+           </property>
+           <property name="wordWrap">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="3" column="0">
+          <widget class="QSpinBox" name="spinBox_normalKSearch">
+           <property name="minimum">
+            <number>3</number>
+           </property>
+           <property name="value">
+            <number>20</number>
+           </property>
+          </widget>
+         </item>
+         <item row="4" column="1">
+          <widget class="QLabel" name="label_voxel">
+           <property name="text">
+            <string>Voxel size. Set 0 to disable. When organized meshes are assembled, this is the radius in which the vertices of the polygons are merged.</string>
+           </property>
+           <property name="wordWrap">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="1">
+          <widget class="QLabel" name="label_binaryFile">
+           <property name="text">
+            <string>Binary file.</string>
+           </property>
+           <property name="wordWrap">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <widget class="QComboBox" name="comboBox_pipeline">
+           <item>
+            <property name="text">
+             <string>Organized Point Cloud</string>
+            </property>
+           </item>
+           <item>
+            <property name="text">
+             <string>Dense Point Cloud</string>
+            </property>
+           </item>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QLabel" name="label_12">
+           <property name="text">
+            <string>Reconstruction flavor.</string>
+           </property>
+          </widget>
+         </item>
          <item row="4" column="0">
           <widget class="QDoubleSpinBox" name="doubleSpinBox_voxelSize_assembled">
            <property name="suffix">
@@ -87,57 +165,64 @@
            </property>
           </widget>
          </item>
-         <item row="3" column="1">
+         <item row="7" column="1">
-          <widget class="QLabel" name="label_normal">
+          <widget class="QLabel" name="label_binaryFile_10">
            <property name="text">
-            <string>Set the number of k nearest neighbors to use for the normal estimation.</string>
+            <string>Cloud smoothing using Moving Least Squares algorithm (MLS).</string>
            </property>
            <property name="wordWrap">
             <bool>true</bool>
            </property>
           </widget>
          </item>
-         <item row="0" column="1">
+         <item row="5" column="0">
-          <widget class="QLabel" name="label_12">
+          <widget class="QCheckBox" name="checkBox_regenerate">
            <property name="text">
-            <string>Reconstruction flavor.</string>
+            <string/>
            </property>
           </widget>
          </item>
-         <item row="0" column="0">
+         <item row="6" column="0">
-          <widget class="QComboBox" name="comboBox_pipeline">
+          <widget class="QCheckBox" name="checkBox_filtering">
-           <item>
+           <property name="text">
-            <property name="text">
+            <string/>
-             <string>Organized Point Cloud</string>
+           </property>
-            </property>
-           </item>
-           <item>
-            <property name="text">
-             <string>Dense Point Cloud</string>
-            </property>
-           </item>
           </widget>
          </item>
-         <item row="1" column="1">
+         <item row="7" column="0">
-          <widget class="QLabel" name="label_binaryFile">
+          <widget class="QCheckBox" name="checkBox_smoothing">
            <property name="text">
-            <string>Binary file.</string>
+            <string/>
+           </property>
+          </widget>
+         </item>
+         <item row="6" column="1">
+          <widget class="QLabel" name="label_binaryFile_9">
+           <property name="text">
+            <string>Cloud filtering. Remove sparse points that are far from surfaces.</string>
            </property>
            <property name="wordWrap">
             <bool>true</bool>
            </property>
           </widget>
          </item>
-         <item row="4" column="1">
+         <item row="9" column="1">
-          <widget class="QLabel" name="label_voxel">
+          <widget class="QLabel" name="label_binaryFile_12">
            <property name="text">
-            <string>Voxel size. Set 0 to disable. When organized meshes are assembled, this is the radius in which the vertices of the polygons are merged.</string>
+            <string>Meshing.</string>
            </property>
            <property name="wordWrap">
             <bool>true</bool>
            </property>
           </widget>
          </item>
+         <item row="9" column="0">
+          <widget class="QCheckBox" name="checkBox_meshing">
+           <property name="text">
+            <string/>
+           </property>
+          </widget>
+         </item>
         </layout>
        </item>
        <item>
@@ -146,18 +231,35 @@
           <string>Regenerate Clouds</string>
          </property>
          <property name="checkable">
-          <bool>true</bool>
+          <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_14">
           <item>
            <layout class="QGridLayout" name="gridLayout" columnstretch="0,0,1">
-            <item row="0" column="2">
+            <item row="6" column="0">
-             <widget class="QLabel" name="label_108">
+             <widget class="QToolButton" name="toolButton_distortionModel">
               <property name="text">
-               <string>3D cloud decimation (1-2-4-8-...). Negative decimation is done from RGB size instead of depth size (if depth is smaller than RGB, it may be interpolated depending of the decimation value).</string>
+               <string>...</string>
               </property>
-              <property name="wordWrap">
+             </widget>
-               <bool>true</bool>
+            </item>
+            <item row="4" column="1">
+             <widget class="QSpinBox" name="spinBox_fillDepthHoles">
+              <property name="suffix">
+               <string> pixels</string>
+              </property>
+             </widget>
+            </item>
+            <item row="0" column="1">
+             <widget class="QSpinBox" name="spinBox_decimation">
+              <property name="minimum">
+               <number>-32</number>
+              </property>
+              <property name="maximum">
+               <number>32</number>
+              </property>
+              <property name="value">
+               <number>1</number>
               </property>
              </widget>
             </item>
@@ -180,23 +282,19 @@
               </property>
              </widget>
             </item>
+            <item row="0" column="2">
+             <widget class="QLabel" name="label_108">
+              <property name="text">
+               <string>3D cloud decimation (1-2-4-8-...). Negative decimation is done from RGB size instead of depth size (if depth is smaller than RGB, it may be interpolated depending of the decimation value).</string>
+              </property>
+              <property name="wordWrap">
+               <bool>true</bool>
+              </property>
+             </widget>
+            </item>
             <item row="6" column="1">
              <widget class="QLineEdit" name="lineEdit_distortionModel"/>
             </item>
-            <item row="6" column="0">
-             <widget class="QToolButton" name="toolButton_distortionModel">
-              <property name="text">
-               <string>...</string>
-              </property>
-             </widget>
-            </item>
-            <item row="4" column="1">
-             <widget class="QSpinBox" name="spinBox_fillDepthHoles">
-              <property name="suffix">
-               <string> pixels</string>
-              </property>
-             </widget>
-            </item>
             <item row="5" column="1">
              <widget class="QSpinBox" name="spinBox_fillDepthHolesError">
               <property name="suffix">
@@ -256,19 +354,6 @@
               </property>
              </widget>
             </item>
-            <item row="0" column="1">
-             <widget class="QSpinBox" name="spinBox_decimation">
-              <property name="minimum">
-               <number>-32</number>
-              </property>
-              <property name="maximum">
-               <number>32</number>
-              </property>
-              <property name="value">
-               <number>1</number>
-              </property>
-             </widget>
-            </item>
             <item row="6" column="2">
              <widget class="QLabel" name="label_134">
               <property name="text">
@@ -305,6 +390,40 @@
             <item row="3" column="1">
              <widget class="QLineEdit" name="lineEdit_roiRatios"/>
             </item>
+            <item row="7" column="1">
+             <widget class="QCheckBox" name="checkBox_bilateral">
+              <property name="text">
+               <string/>
+              </property>
+             </widget>
+            </item>
+            <item row="7" column="2">
+             <widget class="QLabel" name="label_136">
+              <property name="text">
+               <string>Bilateral filtering of the depth image. Reduce noise in depth images.</string>
+              </property>
+              <property name="wordWrap">
+               <bool>true</bool>
+              </property>
+             </widget>
+            </item>
+            <item row="8" column="2">
+             <widget class="QLabel" name="label_137">
+              <property name="text">
+               <string>Cloud subtraction. Superposed points from different nodes are filtered.</string>
+              </property>
+              <property name="wordWrap">
+               <bool>true</bool>
+              </property>
+             </widget>
+            </item>
+            <item row="8" column="1">
+             <widget class="QCheckBox" name="checkBox_subtraction">
+              <property name="text">
+               <string/>
+              </property>
+             </widget>
+            </item>
            </layout>
           </item>
           <item>
@@ -313,7 +432,7 @@
              <string>Bilateral Filtering of the Depth Image</string>
             </property>
             <property name="checkable">
-             <bool>true</bool>
+             <bool>false</bool>
             </property>
             <layout class="QGridLayout" name="gridLayout_13" columnstretch="0,1">
              <item row="1" column="0">
@@ -395,7 +514,7 @@
              <string>Cloud Subtraction</string>
             </property>
             <property name="checkable">
-             <bool>true</bool>
+             <bool>false</bool>
             </property>
             <layout class="QGridLayout" name="gridLayout_11" columnstretch="0,1">
              <item row="2" column="1">
@@ -488,10 +607,10 @@
        <item>
         <widget class="QGroupBox" name="groupBox_filtering">
          <property name="title">
-          <string>Cloud Filtering (remove noisy points)</string>
+          <string>Cloud Filtering</string>
          </property>
          <property name="checkable">
-          <bool>true</bool>
+          <bool>false</bool>
          </property>
          <layout class="QGridLayout" name="gridLayout_9" columnstretch="0,1">
           <item row="0" column="0">
@@ -555,13 +674,13 @@
        <item>
         <widget class="QGroupBox" name="groupBox_mls">
          <property name="title">
-          <string>Cloud Smoothing using Moving Least Squares algorithm (MLS)</string>
+          <string>Cloud Smoothing</string>
          </property>
          <property name="checkable">
-          <bool>true</bool>
+          <bool>false</bool>
          </property>
          <property name="checked">
-          <bool>true</bool>
+          <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout">
           <item>
@@ -943,7 +1062,7 @@ Guidelines: 4 times the voxel size, 0.025 for voxel=0.</string>
           <string>Gain Compensation</string>
          </property>
          <property name="checkable">
-          <bool>true</bool>
+          <bool>false</bool>
          </property>
          <layout class="QGridLayout" name="gridLayout_12" columnstretch="0,1">
           <item row="2" column="1">
@@ -1100,32 +1219,12 @@ Guidelines: 4 times the voxel size, 0.025 for voxel=0.</string>
           <string>Meshing</string>
          </property>
          <property name="checkable">
-          <bool>true</bool>
+          <bool>false</bool>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_15">
           <item>
            <layout class="QGridLayout" name="gridLayout_10" columnstretch="0,1">
-            <item row="8" column="0">
+            <item row="3" column="1">
-             <widget class="QSpinBox" name="spinBox_mesh_minClusterSize">
-              <property name="minimum">
-               <number>-1</number>
-              </property>
-              <property name="maximum">
-               <number>99999</number>
-              </property>
-             </widget>
-            </item>
-            <item row="5" column="1">
-             <widget class="QLabel" name="label_meshDecimation">
-              <property name="text">
-               <string>Mesh quadric decimation factor (0=no decimation). Used to reduce the number of polygons. Higher the factor, lower the output resolution (less polygons). Can be used when dense reconstruction flavor is selected.</string>
-              </property>
-              <property name="wordWrap">
-               <bool>true</bool>
-              </property>
-             </widget>
-            </item>
-            <item row="1" column="1">
              <widget class="QLabel" name="label_textureMapping">
               <property name="text">
                <string>Texture mapping. Images of the cameras will be projected on the mesh(es). Output is a *.obj format. Available on Export or when clouds are not assembled.</string>
@@ -1149,7 +1248,14 @@ Guidelines: 4 times the voxel size, 0.025 for voxel=0.</string>
               </item>
              </widget>
             </item>
-            <item row="6" column="0">
+            <item row="3" column="0">
+             <widget class="QCheckBox" name="checkBox_textureMapping">
+              <property name="text">
+               <string/>
+              </property>
+             </widget>
+            </item>
+            <item row="2" column="0">
              <widget class="QDoubleSpinBox" name="doubleSpinBox_transferColorRadius">
               <property name="suffix">
                <string> m</string>
@@ -1171,84 +1277,38 @@ Guidelines: 4 times the voxel size, 0.025 for voxel=0.</string>
               </property>
              </widget>
             </item>
-            <item row="7" column="0">
+            <item row="4" column="1">
-             <widget class="QCheckBox" name="checkBox_cleanMesh">
+             <widget class="QLabel" name="label_meshClean">
               <property name="text">
-               <string/>
+               <string>Clean mesh from polygons without color or texture.</string>
-              </property>
-             </widget>
-            </item>
-            <item row="2" column="0">
-             <widget class="QComboBox" name="comboBox_meshingTextureFormat">
-              <item>
-               <property name="text">
-                <string>.jpg</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>.png</string>
-               </property>
-              </item>
-             </widget>
-            </item>
-            <item row="3" column="1">
-             <widget class="QLabel" name="label_meshingTextureSize">
-              <property name="text">
-               <string>Output texture size. If not set or when clouds are not assembled, all textures are saved separately. Warning: values higher than 2048 may not be compatible with all GPUs.</string>
               </property>
               <property name="wordWrap">
                <bool>true</bool>
               </property>
              </widget>
             </item>
-            <item row="3" column="0">
+            <item row="5" column="0">
-             <widget class="QComboBox" name="comboBox_meshingTextureSize">
+             <widget class="QSpinBox" name="spinBox_mesh_minClusterSize">
-              <item>
+              <property name="minimum">
-               <property name="text">
+               <number>-1</number>
-                <string>Disabled</string>
+              </property>
-               </property>
+              <property name="maximum">
-              </item>
+               <number>99999</number>
-              <item>
+              </property>
-               <property name="text">
+             </widget>
-                <string>256x256</string>
+            </item>
-               </property>
+            <item row="4" column="0">
-              </item>
+             <widget class="QCheckBox" name="checkBox_cleanMesh">
-              <item>
+              <property name="text">
-               <property name="text">
+               <string/>
-                <string>512x512</string>
+              </property>
-               </property>
+             </widget>
-              </item>
+            </item>
-              <item>
+            <item row="5" column="1">
-               <property name="text">
+             <widget class="QLabel" name="label_16">
-                <string>1024x1024</string>
+              <property name="text">
-               </property>
+               <string>Minimum polygon cluster size (-1 means that only the biggest cluster is kept).</string>
-              </item>
+              </property>
-              <item>
-               <property name="text">
-                <string>2048x2048</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>4096x4096</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>8192x8192</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>16384x16384</string>
-               </property>
-              </item>
-              <item>
-               <property name="text">
-                <string>32768x32768</string>
-               </property>
-              </item>
              </widget>
             </item>
             <item row="0" column="1">
@@ -1261,24 +1321,7 @@ Guidelines: 4 times the voxel size, 0.025 for voxel=0.</string>
               </property>
              </widget>
             </item>
-            <item row="6" column="1">
-             <widget class="QLabel" name="label_meshDecimation_2">
-              <property name="text">
-               <string>Transferring color radius. Radius used to transfer color from original cloud to resampled reconstructed surface (e.g., Poisson or mesh decimation). Negative means disabled, 0 means take the nearest point.</string>
-              </property>
-              <property name="wordWrap">
-               <bool>true</bool>
-              </property>
-             </widget>
-            </item>
             <item row="1" column="0">
-             <widget class="QCheckBox" name="checkBox_textureMapping">
-              <property name="text">
-               <string/>
-              </property>
-             </widget>
-            </item>
-            <item row="5" column="0">
              <widget class="QDoubleSpinBox" name="doubleSpinBox_meshDecimationFactor">
               <property name="decimals">
                <number>2</number>
@@ -1297,67 +1340,243 @@ Guidelines: 4 times the voxel size, 0.025 for voxel=0.</string>
               </property>
              </widget>
             </item>
-            <item row="7" column="1">
-             <widget class="QLabel" name="label_meshClean">
-              <property name="text">
-               <string>Clean mesh from polygons without color or texture.</string>
-              </property>
-              <property name="wordWrap">
-               <bool>true</bool>
-              </property>
-             </widget>
-            </item>
             <item row="2" column="1">
-             <widget class="QLabel" name="label_meshingTextureFormat">
+             <widget class="QLabel" name="label_meshDecimation_2">
               <property name="text">
-               <string>Texture format.</string>
+               <string>Transferring color radius. Radius used to transfer color from original cloud to resampled reconstructed surface (e.g., Poisson or mesh decimation). Negative means disabled, 0 means take the nearest point.</string>
               </property>
               <property name="wordWrap">
                <bool>true</bool>
               </property>
              </widget>
             </item>
-            <item row="8" column="1">
+            <item row="1" column="1">
-             <widget class="QLabel" name="label_16">
+             <widget class="QLabel" name="label_meshDecimation">
               <property name="text">
-               <string>Minimum polygon cluster size (-1 means that only the biggest cluster is kept).</string>
+               <string>Mesh quadric decimation factor (0=no decimation). Used to reduce the number of polygons. Higher the factor, lower the output resolution (less polygons). Can be used when dense reconstruction flavor is selected. Can reduce a lot texturing time.</string>
-              </property>
-             </widget>
-            </item>
-            <item row="4" column="1">
-             <widget class="QLabel" name="label_meshingTextureSize_2">
-              <property name="text">
-               <string>Maximum distance from the camera for polygons to be textured by this camera (0 means infinite). Only used with dense reconstruction flavor.</string>
               </property>
               <property name="wordWrap">
                <bool>true</bool>
               </property>
              </widget>
             </item>
-            <item row="4" column="0">
-             <widget class="QDoubleSpinBox" name="doubleSpinBox_meshingTextureMaxDistance">
-              <property name="suffix">
-               <string> m</string>
-              </property>
-              <property name="decimals">
-               <number>1</number>
-              </property>
-              <property name="minimum">
-               <double>0.000000000000000</double>
-              </property>
-              <property name="maximum">
-               <double>99.000000000000000</double>
-              </property>
-              <property name="singleStep">
-               <double>1.000000000000000</double>
-              </property>
-              <property name="value">
-               <double>3.000000000000000</double>
-              </property>
-             </widget>
-            </item>
            </layout>
           </item>
+          <item>
+           <widget class="QGroupBox" name="groupBox_textureMapping">
+            <property name="title">
+             <string>Texturing</string>
+            </property>
+            <property name="checkable">
+             <bool>false</bool>
+            </property>
+            <property name="checked">
+             <bool>false</bool>
+            </property>
+            <layout class="QVBoxLayout" name="verticalLayout_16">
+             <item>
+              <layout class="QGridLayout" name="gridLayout_15" columnstretch="0,1">
+               <item row="0" column="0">
+                <widget class="QComboBox" name="comboBox_meshingTextureFormat">
+                 <item>
+                  <property name="text">
+                   <string>.jpg</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>.png</string>
+                  </property>
+                 </item>
+                </widget>
+               </item>
+               <item row="0" column="1">
+                <widget class="QLabel" name="label_meshingTextureFormat">
+                 <property name="text">
+                  <string>Texture format.</string>
+                 </property>
+                 <property name="wordWrap">
+                  <bool>true</bool>
+                 </property>
+                </widget>
+               </item>
+               <item row="1" column="0">
+                <widget class="QComboBox" name="comboBox_meshingTextureSize">
+                 <item>
+                  <property name="text">
+                   <string>Disabled</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>256x256</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>512x512</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>1024x1024</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>2048x2048</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>4096x4096</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>8192x8192</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>16384x16384</string>
+                  </property>
+                 </item>
+                 <item>
+                  <property name="text">
+                   <string>32768x32768</string>
+                  </property>
+                 </item>
+                </widget>
+               </item>
+               <item row="1" column="1">
+                <widget class="QLabel" name="label_meshingTextureSize">
+                 <property name="text">
+                  <string>Output texture size. If not set or when clouds are not assembled, all textures are saved separately. Warning: values higher than 2048 may not be compatible with all GPUs.</string>
+                 </property>
+                 <property name="wordWrap">
+                  <bool>true</bool>
+                 </property>
+                </widget>
+               </item>
+               <item row="2" column="0">
+                <widget class="QDoubleSpinBox" name="doubleSpinBox_meshingTextureMaxDistance">
+                 <property name="suffix">
+                  <string> m</string>
+                 </property>
+                 <property name="decimals">
+                  <number>1</number>
+                 </property>
+                 <property name="minimum">
+                  <double>0.000000000000000</double>
+                 </property>
+                 <property name="maximum">
+                  <double>99.000000000000000</double>
+                 </property>
+                 <property name="singleStep">
+                  <double>1.000000000000000</double>
+                 </property>
+                 <property name="value">
+                  <double>3.000000000000000</double>
+                 </property>
+                </widget>
+               </item>
+               <item row="2" column="1">
+                <widget class="QLabel" name="label_meshingTextureSize_2">
+                 <property name="text">
+                  <string>Maximum distance from the camera for polygons to be textured by this camera (0 means infinite). Only used with dense reconstruction flavor.</string>
+                 </property>
+                 <property name="wordWrap">
+                  <bool>true</bool>
+                 </property>
+                </widget>
+               </item>
+               <item row="3" column="0">
+                <widget class="QCheckBox" name="checkBox_cameraFilter">
+                 <property name="text">
+                  <string/>
+                 </property>
+                </widget>
+               </item>
+               <item row="3" column="1">
+                <widget class="QLabel" name="label_meshingTextureSize_3">
+                 <property name="text">
+                  <string>Camera filtering. By comparing poses in the same area, only one camera in a fixed radius and angle is used for texturing.</string>
+                 </property>
+                 <property name="wordWrap">
+                  <bool>true</bool>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <widget class="QGroupBox" name="groupBox_cameraFilter">
+               <property name="title">
+                <string>Camera Filtering</string>
+               </property>
+               <layout class="QGridLayout" name="gridLayout_16" columnstretch="0,1">
+                <item row="0" column="0">
+                 <widget class="QDoubleSpinBox" name="doubleSpinBox_cameraFilterRadius">
+                  <property name="suffix">
+                   <string> m</string>
+                  </property>
+                  <property name="minimum">
+                   <double>0.010000000000000</double>
+                  </property>
+                  <property name="value">
+                   <double>0.100000000000000</double>
+                  </property>
+                 </widget>
+                </item>
+                <item row="0" column="1">
+                 <widget class="QLabel" name="label_37">
+                  <property name="text">
+                   <string>Radius.</string>
+                  </property>
+                  <property name="wordWrap">
+                   <bool>true</bool>
+                  </property>
+                  <property name="textInteractionFlags">
+                   <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+                  </property>
+                 </widget>
+                </item>
+                <item row="1" column="0">
+                 <widget class="QDoubleSpinBox" name="doubleSpinBox_cameraFilterAngle">
+                  <property name="suffix">
+                   <string> deg</string>
+                  </property>
+                  <property name="decimals">
+                   <number>0</number>
+                  </property>
+                  <property name="maximum">
+                   <double>180.000000000000000</double>
+                  </property>
+                  <property name="value">
+                   <double>30.000000000000000</double>
+                  </property>
+                 </widget>
+                </item>
+                <item row="1" column="1">
+                 <widget class="QLabel" name="label_48">
+                  <property name="text">
+                   <string>Angle.</string>
+                  </property>
+                  <property name="wordWrap">
+                   <bool>true</bool>
+                  </property>
+                  <property name="textInteractionFlags">
+                   <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+                  </property>
+                 </widget>
+                </item>
+               </layout>
+              </widget>
+             </item>
+            </layout>
+           </widget>
+          </item>
           <item>
            <widget class="QGroupBox" name="groupBox_gp3">
             <property name="title">