WebSVN – gelsvn – Diff – /trunk/apps/MeshEdit/meshedit.cpp

 #include <HMesh/subdivision.h>
 #include <GLConsole/GLConsole.h>
 #include <Util/Timer.h>
 #include "harmonics.h"
+#include "curvature.h"
 #include "Renderer.h"
 #include "VisObj.h"
 using namespace std;
 using namespace HMesh;
 using namespace Geometry;
 using namespace GLGraphics;
 using namespace CGLA;
 using namespace Util;
 using namespace LinAlg;
-template<typename T>
+using namespace CVarUtils;
-T& get_CVar_ref(const std::string& s)
-{
-	return *reinterpret_cast<T*> (GetCVarData(s));
-}
 inline VisObj& get_vis_obj(int i)
+{
 	static VisObj vo[9];
 	return vo[i];
+}
 inline VisObj& avo()
+{
-	static CVar<int> active("active_mesh",0);
+	static int& active = CreateCVar("active_mesh",0);
 	return get_vis_obj(active);
+}
 inline Manifold& active_mesh()
+{
+{
 	return avo().view_control();
+}
 // Single global instance so glut can get access
+Trie CVarTrie;
 GLConsole theConsole;
 ////////////////////////////////////////////////////////////////////////////////
 char* ConsoleHelp(std::vector<std::string> &args)
+{
 		return "unknown format";
+	}
 	return "usage: save <name.x3d|name.obj> ";
+}
+char* console_save_history(std::vector<std::string> &args)
+{
+	if(wantshelp(args))
+	{
+		theConsole.Printf("usage: save_history <file> ... writes history to file");
+		return "";
+	}
+	if(args.size()>0)
+	{
+		string& file_name = args[0];
+		theConsole.SaveHistoryScript(file_name.c_str());
+		return "";
+	}
+	return "must supply file name\n";
+}
+char* console_exec_script(std::vector<std::string> &args)
+{
+	if(wantshelp(args))
+	{
+		theConsole.Printf("usage: source <file> ... runs script");
+		return "";
+	}
+	if(args.size()>0)
+	{
+		string& file_name = args[0];
+		theConsole.ExecuteScript(file_name.c_str());
+		return "";
+	}
+	return "must supply file name\n";
+}
 char* console_refine_edges(std::vector<std::string> &args)
+{
 	if(wantshelp(args))
+	{
 		theConsole.Printf("usage: refine.split_edges <length>");
 char* console_reload(std::vector<std::string> &args)
+{
 	if(wantshelp(args))
+	{
-		theConsole.Printf("usage:  reload <file>");
+		theConsole.Printf("usage:  load <file>");
-		theConsole.Printf("Reloads the current file if no argument is given, but");
+		theConsole.Printf("(Re)loads the current file if no argument is given, but");
 		theConsole.Printf("if an argument is given, then that becomes the current file");
 		return "";
+	}
 	if(!avo().reload(args.size()>0 ? args[0]:""))
 		return "failed to load";
 		vi->pos += v;
+	}
 	return "";
+}
+char* console_perpendicular_vertex_noise(std::vector<std::string> &args)
+{
+	if(wantshelp(args))
+	{
+		theConsole.Printf("usage: noise.perturb_vertices_perpendicular <amplitude>");
+		theConsole.Printf("adds the normal times a random scalar times amplitude times");
+		theConsole.Printf("times average edge length to the vertex. (default amplitude=0.5)");
+		return "";
+	}
+	float avg_length = average_edge_length(active_mesh());
+	float noise_amplitude = 0.5;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> noise_amplitude;
+	}
+	vector<Vec3f> normals(active_mesh().no_vertices());
+	int i=0;
+	for(VertexIter vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi,++i)
+		normals[i] = normal(vi);
+	i=0;
+	srandom(0);
+	for(VertexIter vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi,++i)
+	{
+		float rval = 0.5-random()/float(RAND_MAX);
+		vi->pos += normals[i]*rval*noise_amplitude*avg_length*2.0;
+	}
+	return "";
+}
 char* console_noisy_flips(std::vector<std::string> &args)
+{
 	if(wantshelp(args))
+	{
 		theConsole.Printf("usage:  noise.perturb_topology <iter>");
 char* console_laplacian_smooth(std::vector<std::string> &args)
+{
 	if(wantshelp(args))
+	{
-		theConsole.Printf("usage:  smooth.laplacian <weight>");
+		theConsole.Printf("usage:  smooth.laplacian <weight> <iter>");
 		theConsole.Printf("Perform Laplacian smoothing. weight is the scaling factor for the Laplacian.");
+		theConsole.Printf("default weight = 1.0. Default number of iterations = 1");
 		return "";
+	}
 	float t=1.0;
 	if(args.size()>0)
+	{
 		istringstream a0(args[0]);
 		a0 >> t;
+	}
+	int iter=1;
+	if(args.size()>1)
+	{
+		istringstream a0(args[1]);
+		a0 >> iter;
+	}
 	/// Simple laplacian smoothing with an optional weight.
-	laplacian_smooth(active_mesh(), t);
+	for(int i=0;i<iter;++i) laplacian_smooth(active_mesh(), t);
 	return "";
+}
+char* console_mean_curvature_smooth(std::vector<std::string> &args)
+{
+	if(wantshelp(args))
+	{
+		theConsole.Printf("usage:  smooth.mean_curvature <weight> <iter>");
+		theConsole.Printf("Perform mean curvature smoothing. weight is the scaling factor for the");
+		theConsole.Printf("mean curvature vector which has been normalized by dividing by edge lengths");
+		theConsole.Printf("this allows for larger steps as suggested by Desbrun et al.");
+		theConsole.Printf("default weight = 1.0. Default number of iterations = 1");
+		return "";
+	}
+	float t=1.0;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> t;
+	}
+	int iter=1;
+	if(args.size()>1)
+	{
+		istringstream a0(args[1]);
+		a0 >> iter;
+	}
+	vector<Vec3d> new_pos(active_mesh().no_vertices());
+	for(int j=0;j<iter;++j)
+	{
+		int i=0;
+		for(VertexIter v = active_mesh().vertices_begin(); v != active_mesh().vertices_end(); ++v,++i) {
+			Vec3d m;
+			double w_sum;
+			unnormalized_mean_curvature_normal(v, m, w_sum);
+			new_pos[i] = Vec3d(v->pos)  - (t * m/w_sum);
+		}
+		i=0;
+		for(VertexIter v = active_mesh().vertices_begin(); v != active_mesh().vertices_end(); ++v,++i)
+			v->pos = Vec3f(new_pos[i]);
+	}
+	return "";
+}
 char* console_taubin_smooth(std::vector<std::string> &args)
+{
 	if(wantshelp(args))
+	{
 		theConsole.Printf("usage:  smooth.taubin <iter>");
 void display()
+{
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	static CVar<string> display_render_mode("display.render_mode","");
+	static string& display_render_mode = CreateCVar<string>("display.render_mode","");
-	static CVar<int> display_smooth("display.smooth_shading",1);
+	static int& display_smooth= CreateCVar<int>("display.smooth_shading",1);
 	glPushMatrix();
 	avo().display(display_render_mode, display_smooth);
+}
 void keyboard_spec(int key, int x, int y)
+{
 	int mod = glutGetModifiers();
-	if( theConsole.isOpen() ) {
+	if( theConsole.IsOpen() ) {
 		// If shift held, scroll the console
 		if( mod == GLUT_ACTIVE_SHIFT ) {
 			switch (key){
 				case GLUT_KEY_UP:
 					theConsole.ScrollDownLine();
+}
 void keyboard(unsigned char key, int x, int y)
+{
-	if(theConsole.isOpen())
+	if(theConsole.IsOpen())
+	{
 		switch(key) {
 			case '\033':
 				theConsole.ToggleConsole();
 			default:
-				//send keystroke to console
-				if( theConsole.isOpen() ){
-					theConsole.EnterCommandCharacter(key);
+				theConsole.EnterCommandCharacter(key);
-				}
-				break;
+			break;
+		}
 		if(key == 13)	avo().post_create_display_list();
+	}
 	else {
-		string& display_render_mode = get_CVar_ref<string>("display.render_mode");
+		string& display_render_mode = GetCVarRef<string>("display.render_mode");
-		int& display_smooth = get_CVar_ref<int>("display.smooth_shading");
+		int& display_smooth = GetCVarRef<int>("display.smooth_shading");
-		int& active  = get_CVar_ref<int>("active_mesh");
+		int& active  = GetCVarRef<int>("active_mesh");
 		switch(key) {
 			case 'q': exit(0);
 			case '\033':
 	glColor4f(1.0f, 1.0f, 1.0f, 0.f);
 	float material[4] = {1,1,1,1};
 	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material);
 	glEnable(GL_DEPTH_TEST);
-	static CVar<ConsoleFunc> help( "help", ConsoleHelp );
+	CreateCVar( "help", ConsoleHelp );
-	static CVar<ConsoleFunc> rs("harmonics.reset_shape", console_reset_shape);
+	CreateCVar("harmonics.reset_shape", console_reset_shape);
-	static CVar<ConsoleFunc> ha("harmonics.analyze", console_analyze);
+	CreateCVar("harmonics.analyze", console_analyze);
-	static CVar<ConsoleFunc> pr("harmonics.partial_reconstruct", console_partial_reconstruct);
+	CreateCVar("harmonics.partial_reconstruct", console_partial_reconstruct);
-	static CVar<ConsoleFunc> simpl("simplify", console_simplify);
+	CreateCVar("simplify", console_simplify);
+	CreateCVar("smooth.mean_curvature", console_mean_curvature_smooth);
-	static CVar<ConsoleFunc> lsmooth("smooth.laplacian", console_laplacian_smooth);
+	CreateCVar("smooth.laplacian", console_laplacian_smooth);
-	static CVar<ConsoleFunc> tsmooth("smooth.taubin", console_taubin_smooth);
+	CreateCVar("smooth.taubin", console_taubin_smooth);
-	static CVar<ConsoleFunc> fsmooth("smooth.fuzzy_vector_median", console_fvm_smooth);
+	CreateCVar("smooth.fuzzy_vector_median", console_fvm_smooth);
-	static CVar<ConsoleFunc> opt_val("optimize.valency", console_optimize_valency);
+	CreateCVar("optimize.valency", console_optimize_valency);
-	static CVar<ConsoleFunc> min_dih("optimize.minimize_dihedral_angles", console_minimize_dihedral);
+	CreateCVar("optimize.minimize_dihedral_angles", console_minimize_dihedral);
-	static CVar<ConsoleFunc> min_curv("optimize.minimize_curvature", console_minimize_curvature);
+	CreateCVar("optimize.minimize_curvature", console_minimize_curvature);
-	static CVar<ConsoleFunc> max_min_angle("optimize.maximize_min_angle", console_maximize_min_angle);
+	CreateCVar("optimize.maximize_min_angle", console_maximize_min_angle);
-	static CVar<ConsoleFunc> close_holes_fun("cleanup.close_holes", console_close_holes);
+	CreateCVar("cleanup.close_holes", console_close_holes);
-	static CVar<ConsoleFunc> reload_fun("reload", console_reload);
+	CreateCVar("load", console_reload);
-	static CVar<ConsoleFunc> rem_caps_fun("cleanup.remove_caps", console_remove_caps);
+	CreateCVar("cleanup.remove_caps", console_remove_caps);
-	static CVar<ConsoleFunc> rem_needles_fun("cleanup.remove_needles", console_remove_needles);
+	CreateCVar("cleanup.remove_needles", console_remove_needles);
-	static CVar<ConsoleFunc> triangulate_fun("triangulate", console_triangulate);
+	CreateCVar("triangulate", console_triangulate);
-	static CVar<ConsoleFunc> refine_fun("refine.split_edges", console_refine_edges);
+	CreateCVar("refine.split_edges", console_refine_edges);
-	static CVar<ConsoleFunc> refine_face_fun("refine.split_faces", console_refine_faces);
+	CreateCVar("refine.split_faces", console_refine_faces);
-	static CVar<ConsoleFunc> subd_fun("refine.catmull_clark", console_cc_subdivide);
+	CreateCVar("refine.catmull_clark", console_cc_subdivide);
-	static CVar<ConsoleFunc> save_fun("save", console_save);
+	CreateCVar("save", console_save);
-	static CVar<ConsoleFunc> noise_fun("noise.perturb_vertices", console_vertex_noise);
+	CreateCVar("noise.perturb_vertices", console_vertex_noise);
+	CreateCVar("noise.perturb_vertices_perpendicular", console_perpendicular_vertex_noise);
-	static CVar<ConsoleFunc> noise_fun2("noise.perturb_topology", console_noisy_flips);
+	CreateCVar("noise.perturb_topology", console_noisy_flips);
-	static CVar<ConsoleFunc> dualize("dual", console_dual);
+	CreateCVar("dual", console_dual);
-	static CVar<ConsoleFunc> align_fun("align", console_align);
+	CreateCVar("align", console_align);
+	CreateCVar("save_history", console_save_history);
+	CreateCVar("source", console_exec_script);
+}
 int main(int argc, char** argv)

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/meshedit.cpp @ 415 – Rev 411 → 412