Merge branch 'dev' into alpha

Author: larc

include/gproshan/app_viewer.h

@@ -80,10 +80,7 @@ class app_viewer : public viewer
 
 		// Features
 		static bool process_eigenfuntions(viewer * p_view);
-		static bool process_descriptor_heatmap(viewer * p_view, const descriptor::signature & sig);
-		static bool process_gps(viewer * p_view);
-		static bool process_hks(viewer * p_view);
-		static bool process_wks(viewer * p_view);
+		static bool process_descriptor_heatmap(viewer * p_view);
 		static bool process_key_points(viewer * p_view);
 		static bool process_key_components(viewer * p_view);
 

include/gproshan/features/key_components.h

@@ -2,7 +2,6 @@
 #define KEY_COMPONENTS_H
 
 #include "mesh/che.h"
-#include "features/key_points.h"
 
 #include <map>
 
@@ -14,21 +13,21 @@ namespace gproshan {
 class key_components
 {
 	private:
-		real_t radio;
-		size_t n_vertices;
-		size_t n_comp;
-		index_t * comp;
-		size_t * comp_size;
+		real_t radio		= 0;
+		size_t n_vertices	= 0;
+		size_t n_comp		= 0;
+		index_t * comp		= nullptr;
+		size_t * comp_size	= nullptr;
 		std::map<index_t, index_t> comp_idx;
 
 	public:
-		key_components(che * mesh, const key_points & kps, const real_t & r);
+		key_components(che * mesh, const std::vector<index_t> & kps, const real_t & r);
 		~key_components();
 		index_t operator()(const index_t & i);
 		operator const size_t & () const;
 
 	private:
-		void compute_kcs(che * mesh, const key_points & kps);
+		void compute_kcs(che * mesh, const std::vector<index_t> & kps);
 		index_t find(const index_t & x);
 		bool join(index_t x, index_t y);
 };

include/gproshan/features/key_points.h

@@ -3,34 +3,23 @@
 
 #include "mesh/che.h"
 
-#include <utility>
-
 
 // geometry processing and shape analysis framework
 namespace gproshan {
 
 
-typedef std::pair<real_t, index_t> real_idx_t;
-
 class key_points
 {
 	private:
-		size_t n_faces;
-		size_t n_vertices;
-		real_idx_t * face_areas;
-		index_t * kps;
-		bool * is_kp;
-		size_t n_kps;
+		std::vector<index_t> kps;
+		std::vector<bool> is_kp;
 
 	public:
 		key_points(che * mesh, const real_t & percent = 0.10);
-		~key_points();
-		const index_t & operator[](const index_t & i) const;
-		const bool & operator()(const index_t & i) const;
-		const size_t & size() const;
+		operator const std::vector<index_t> & () const;
 
 	private:
-		void compute_kps(che * mesh);
+		void compute_kps_areas(che * mesh, const real_t & percent);
 };
 
 

include/gproshan/viewer/camera.h

@@ -3,6 +3,8 @@
 
 #include "mesh/quaternion.h"
 
+#include <glm/glm.hpp>
+
 
 // geometry processing and shape analysis framework
 namespace gproshan {
@@ -11,21 +13,24 @@ namespace gproshan {
 class camera
 {
 	private:
-		quaternion p_click;
-		quaternion p_drag;
-		quaternion p_last;
-		quaternion r_last;
+		quaternion p_click	= 1;
+		quaternion p_drag	= 1;
+		quaternion p_last	= 1;
+		quaternion r_last	= 1;
 
 	public:
-		double zoom;
+		quaternion eye		= vertex(0, 0, 2);
+		quaternion center	= vertex(0, 0, 0);
+		quaternion up		= vertex(0, 1, 0);
+		double zoom			= 2;
 
 	public:
-		camera();
+		glm::mat4 look_at(const quaternion & r);
+		quaternion current_rotation() const;
 		void mouse(const bool & press, const double & x, const double & y, const int & w, const int & h);
 		void motion(const double & x, const double & y, const int & w, const int & h);
 		void zoom_in();
 		void zoom_out();
-		quaternion current_rotation() const;
 
 	private:
 		quaternion click_to_sphere(const double & x, const double & y, const int & w, const int & h);

include/gproshan/viewer/che_viewer.h

@@ -48,6 +48,10 @@ class che_viewer
 		void reload();
 		void update();
 		void update_vbo();
+		void update_vbo_geometry();
+		void update_vbo_normal();
+		void update_vbo_color();
+		void update_vbo_heatmap();
 		void update_instances_translations(const std::vector<vertex> & translations);
 		void draw(shader & program);
 		void draw_point_cloud(shader & program);

include/gproshan/viewer/viewer.h

@@ -69,10 +69,6 @@ class viewer
 
 		camera cam;
 
-		quaternion eye;
-		quaternion center;
-		quaternion up;
-
 		quaternion light;
 
 		glm::mat4 view_mat;

src/app_viewer.cpp

@@ -85,18 +85,16 @@ void app_viewer::init()
 
 	sub_menus.push_back("Features");
 	add_process(GLFW_KEY_2, {"2", "Eigenfunctions", process_eigenfuntions});
-	add_process(GLFW_KEY_3, {"3", "GPS", process_gps});
-	add_process(GLFW_KEY_4, {"4", "HKS", process_hks});
-	add_process(GLFW_KEY_5, {"5", "WKS", process_wks});
-	add_process(GLFW_KEY_6, {"6", "Key Points", process_key_points});
-	add_process(GLFW_KEY_7, {"7", "Key Components", process_key_components});
+	add_process(GLFW_KEY_3, {"3", "Descriptors", process_descriptor_heatmap});
+	add_process(GLFW_KEY_4, {"4", "Key Points", process_key_points});
+	add_process(GLFW_KEY_5, {"5", "Key Components", process_key_components});
 
 	sub_menus.push_back("Hole Filling");
 	add_process(GLFW_KEY_X, {"X", "Poisson: Membrane surface", process_poisson_laplacian_1});
 	add_process(GLFW_KEY_Y, {"Y", "Poisson: Thin-plate surface", process_poisson_laplacian_2});
 	add_process(GLFW_KEY_Z, {"Z", "Poisson: Minimum variation surface", process_poisson_laplacian_3});
-	add_process(GLFW_KEY_8, {"8", "Fill hole: planar mesh", process_fill_holes});
-	add_process(GLFW_KEY_9, {"0", "Fill hole: biharmonic splines", process_fill_holes_biharmonic_splines});
+	add_process(GLFW_KEY_6, {"6", "Fill hole: planar mesh", process_fill_holes});
+	add_process(GLFW_KEY_7, {"7", "Fill hole: biharmonic splines", process_fill_holes_biharmonic_splines});
 
 	sub_menus.push_back("Others");
 	add_process(GLFW_KEY_SEMICOLON, {"SEMICOLON", "Select multiple vertices", process_select_multiple});
@@ -269,6 +267,9 @@ bool app_viewer::process_fairing_spectral(viewer * p_view)
 		mesh->update_normals();
 	}
 
+	mesh.update_vbo_geometry();
+	mesh.update_vbo_normal();
+
 	return true;
 }
 
@@ -296,6 +297,9 @@ bool app_viewer::process_fairing_taubin(viewer * p_view)
 		mesh->update_normals();
 	}
 
+	mesh.update_vbo_geometry();
+	mesh.update_vbo_normal();
+
 	return true;
 }
 
@@ -335,6 +339,7 @@ bool app_viewer::process_geodesics(viewer * p_view)
 
 		params.radio = G.radio();
 		mesh->update_heatmap(&G[0]);
+		mesh.update_vbo_heatmap();
 	}
 
 	return true;
@@ -388,6 +393,8 @@ bool app_viewer::process_voronoi(viewer * p_view)
 		mesh->heatmap(i) /= mesh.selected.size() + 1;
 	}
 
+	mesh.update_vbo_heatmap();
+
 	return false;
 }
 
@@ -414,6 +421,8 @@ bool app_viewer::process_compute_toplesets(viewer * p_view)
 			mesh->heatmap(v) = real_t(toplesets[v]) / (n_toplesets);
 	}
 
+	mesh.update_vbo_heatmap();
+
 	gproshan_debug_var(n_toplesets);
 
 	delete [] toplesets;
@@ -630,13 +639,16 @@ bool app_viewer::process_eigenfuntions(viewer * p_view)
 	return true;
 }
 
-bool app_viewer::process_descriptor_heatmap(viewer * p_view, const descriptor::signature & sig)
+bool app_viewer::process_descriptor_heatmap(viewer * p_view)
 {
 	app_viewer * view = (app_viewer *) p_view;
 	che_viewer & mesh = view->active_mesh();
 
 	static int n_eigs = 50;
 	static bool status = true;
+	static descriptor::signature sig = descriptor::GPS;
+
+	ImGui::Combo("descriptor", (int *) &sig, "GPS\0HKS\0WKS\0\0");
 	ImGui::InputInt("n_eigs", &n_eigs);
 	if(!status) ImGui::TextColored({1, 0, 0, 1}, "Error computing features.");
 
@@ -660,61 +672,49 @@ bool app_viewer::process_descriptor_heatmap(viewer * p_view, const descriptor::s
 			#pragma omp parallel for
 			for(index_t v = 0; v < mesh->n_vertices; ++v)
 				mesh->heatmap(v) /= max_s;
+
+			mesh.update_vbo_heatmap();
 		}
 		else status = false;
 	}
 
 	return true;
 }
 
-bool app_viewer::process_gps(viewer * p_view)
-{
-	return process_descriptor_heatmap(p_view, descriptor::GPS);
-}
-
-bool app_viewer::process_hks(viewer * p_view)
-{
-	return process_descriptor_heatmap(p_view, descriptor::HKS);
-}
-
-bool app_viewer::process_wks(viewer * p_view)
-{
-	return process_descriptor_heatmap(p_view, descriptor::WKS);
-}
-
 bool app_viewer::process_key_points(viewer * p_view)
 {
-	gproshan_log(APP_VIEWER);
 	app_viewer * view = (app_viewer *) p_view;
 	che_viewer & mesh = view->active_mesh();
 
-	key_points kps(mesh);
-
-	mesh.selected.clear();
-	mesh.selected.reserve(kps.size());
-
-	for(index_t i = 0; i < kps.size(); ++i)
-		mesh.selected.push_back(kps[i]);
+	static real_t percent = 0.1;
+	if(ImGui_InputReal("percent", &percent, 0.01, 0.1, "%.2f"))
+	{
+		key_points kps(mesh, percent);
+		mesh.selected = kps;
+	}
 
-	return false;
+	return true;
 }
 
 bool app_viewer::process_key_components(viewer * p_view)
 {
-	gproshan_log(APP_VIEWER);
 	app_viewer * view = (app_viewer *) p_view;
 	che_viewer & mesh = view->active_mesh();
 
-	key_points kps(mesh);
-	key_components kcs(mesh, kps, .25);
+	static real_t radio = 0.25;
+	if(ImGui_InputReal("radio", &radio, 0.01, 0.1, "%.2f"))
+	{
+		// use the mesh selected points as key points.
+		key_components kcs(mesh, mesh.selected, radio);
 
-	gproshan_debug_var(kcs);
+		#pragma omp parallel for
+		for(index_t v = 0; v < mesh->n_vertices; ++v)
+			mesh->heatmap(v) = (real_t) kcs(v) / kcs;
 
-	#pragma omp parallel for
-	for(index_t v = 0; v < mesh->n_vertices; ++v)
-		mesh->heatmap(v) = (real_t) kcs(v) / kcs;
+		mesh.update_vbo_heatmap();
+	}
 
-	return false;
+	return true;
 }
 
 

src/features/key_components.cpp

@@ -11,7 +11,7 @@ using namespace std;
 namespace gproshan {
 
 
-key_components::key_components(che * mesh, const key_points & kps, const real_t & r): radio(r)
+key_components::key_components(che * mesh, const std::vector<index_t> & kps, const real_t & r): radio(r)
 {
 	n_vertices = mesh->n_vertices;
 
@@ -48,13 +48,14 @@ key_components::operator const size_t & () const
 	return n_comp;
 }
 
-void key_components::compute_kcs(che * mesh, const key_points & kps)
+void key_components::compute_kcs(che * mesh, const std::vector<index_t> & kps)
 {
-	geodesics fm(mesh, vector<index_t>(&kps[0], &kps[0] + kps.size()));
+	geodesics fm(mesh, kps);
 
 	radio *= fm.radio();
 	for(index_t i = 0; i < n_vertices && fm[fm(i)] <= radio; ++i)
-		for_star(he, mesh, fm(i)) join(fm(i), mesh->vt(next(he)));
+		for_star(he, mesh, fm(i))
+			join(fm(i), mesh->vt(next(he)));
 
 	for(index_t i = 0; i < n_vertices; ++i)
 		if(comp[i] == i && comp_size[i] > 1)