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

 /*
  *  MeshEdit is a small application which allows you to load and edit a mesh.
  *  The mesh will be stored in GEL's half edge based Manifold data structure.
  *  A number of editing operations are supported. Most of these are accessible from the
  *  console that pops up when you hit 'esc'.
+ *
  *  Created by J. Andreas Bærentzen on 15/08/08.
  *  Copyright 2008 __MyCompanyName__. All rights reserved.
+ *
  */
 #include <iostream>
 #include <CGLA/eigensolution.h>
 #include <CGLA/Vec2d.h>
 #include <CGLA/Vec3d.h>
 #include <CGLA/Mat3x3d.h>
 #include <CGLA/Mat2x2d.h>
 #include <CGLA/Mat2x3d.h>
 #include <LinAlg/Matrix.h>
 #include <LinAlg/Vector.h>
 #include <LinAlg/LapackFunc.h>
 #include <Util/Timer.h>
 #include <Util/ArgExtracter.h>
 #include <GL/glew.h>
 #include <GLGraphics/gel_glut.h>
 #include <GLGraphics/draw.h>
 #include <GLGraphics/glsl_shader.h>
 #include <GLGraphics/GLViewController.h>
 #include <HMesh/Manifold.h>
 #include <HMesh/VertexCirculator.h>
 #include <HMesh/FaceCirculator.h>
 #include <HMesh/build_manifold.h>
 #include <HMesh/mesh_optimization.h>
 #include <HMesh/triangulate.h>
 #include <HMesh/load.h>
+#include <HMesh/quadric_simplify.h>
+#include <HMesh/smooth.h>
 #include <HMesh/x3d_save.h>
+#include <HMesh/mesh_optimization.h>
 #include <GLConsole/GLConsole.h>
 #include "harmonics.h"
 #include "wireframe.h"
 // Single global instance so glut can get access
 GLConsole theConsole;
 ////////////////////////////////////////////////////////////////////////////////
 char* ConsoleHelp(std::vector<std::string> &args)
+{
     theConsole.Printf("");
     theConsole.Printf("----------------- HELP -----------------");
     theConsole.Printf("Press ~ key to open and close console");
     theConsole.Printf("Press TAB to see the available commands and functions");
     theConsole.Printf("Functions are shown in green and variables in yellow");
     theConsole.Printf("Setting a value: [command] = value");
     theConsole.Printf("Getting a value: [command]");
     theConsole.Printf("Functions: [function] [arg1] [arg2] ...");
     theConsole.Printf("Entering just the function name will give a description.");
     theConsole.Printf("History: Up and Down arrow keys move through history.");
     theConsole.Printf("Tab Completion: TAB does tab completion and makes suggestions.");
     theConsole.Printf("----------------- HELP -----------------");
     theConsole.Printf("");
     return "";
+}
 using namespace std;
 using namespace HMesh;
 using namespace Geometry;
 using namespace GLGraphics;
 using namespace CGLA;
 using namespace Util;
 using namespace LinAlg;
 namespace
+{
 	GLViewController* view_ctrl;
 	int WINX=800, WINY=800;
 	Manifold mani;
 	bool create_display_list = true;
+}
+char* console_minimize_curvature(std::vector<std::string> &args)
+{
+	bool anneal=false;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> anneal;
+	}
+	minimize_curvature(mani, anneal);
+	return "";
+}
+char* console_minimize_dihedral(std::vector<std::string> &args)
+{
+	int iter = 1000;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> iter;
+	}
+	bool anneal = false;
+	if(args.size()>1)
+	{
+		istringstream a0(args[0]);
+		a0 >> anneal;
+	}
+	bool use_alpha = true;
+	if(args.size()>22)
+	{
+		istringstream a0(args[0]);
+		a0 >> use_alpha;
+	}
+	float gamma = 4.0;
+	if(args.size()>3)
+	{
+		istringstream a0(args[0]);
+		a0 >> gamma;
+	}
+	minimize_dihedral_angle(mani, iter, anneal, use_alpha, gamma);
+	return "";
+}
+char* console_optimize_valency(std::vector<std::string> &args)
+{
+	bool anneal=false;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> anneal;
+	}
+	optimize_valency(mani, anneal);
+	return "";
+}
 char* console_partial_reconstruct(std::vector<std::string> &args)
+{
 	int E0,E1;
 	float scale;
 	istringstream a0(args[0]);
 	a0 >> E0;
 	istringstream a1(args[1]);
 	a1 >> E1;
 	istringstream a2(args[2]);
 	a2 >> scale;
 	partial_reconstruct(mani, E0,E1,scale);
 	return "";
+}
 char* console_reset_shape(std::vector<std::string> &args)
+{
 	reset_shape(mani);
 	return "";
+}
 void reshape(int W, int H)
+{
 	view_ctrl->reshape(W,H);
+}
+char* console_simplify(std::vector<std::string> &args)
+{
+	float keep_fraction;
+	if(args.size()==0) return "you must specify fraction of vertices to keep";
+	istringstream a0(args[0]);
+	a0 >> keep_fraction;
+	Vec3f p0, p7;
+	mani.get_bbox(p0, p7);
+	Vec3f d = p7-p0;
+	float s = 1.0/d.max_coord();
+	Vec3f pcentre = (p7+p0)/2.0;
+	for(VertexIter vi = mani.vertices_begin(); vi != mani.vertices_end(); ++vi)
+		vi->pos = (vi->pos - pcentre) * s;
+	quadric_simplify(mani,keep_fraction,0.0001f,true);
+	for(VertexIter vi = mani.vertices_begin(); vi != mani.vertices_end(); ++vi)
+		vi->pos = vi->pos*d.max_coord() + pcentre;
+	return "";
+}
+char* console_laplacian_smooth(std::vector<std::string> &args)
+{
+	float t=1.0;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> t;
+	}
+	/// Simple laplacian smoothing with an optional weight.
+	laplacian_smooth(mani, t);
+	return "";
+}
+char* console_taubin_smooth(std::vector<std::string> &args)
+{
+	int iter=1;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> iter;
+	}
+	/// Taubin smoothing is similar to laplacian smoothing but reduces shrinkage
+	taubin_smooth(mani,  iter);
+	return "";
+}
+char* console_fvm_smooth(std::vector<std::string> &args)
+{
+	int iter=1;
+	if(args.size()>0)
+	{
+		istringstream a0(args[0]);
+		a0 >> iter;
+	}
+	/** Fuzzy vector median smoothing is effective when it comes to
+	 preserving sharp edges. */
+	fvm_smooth(mani,  iter);
+	return "";
+}
 void display()
+{
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	static CVar<int> do_wireframe("display.wireframe",0);
 	glPushMatrix();
 	view_ctrl->set_gl_modelview();
 	if(create_display_list)
+	{
 		create_display_list = false;
 		glNewList(1,GL_COMPILE);
 		if(do_wireframe)
+			{
 				enable_wireframe();
 				draw(mani);
+			}
 		else
 			draw_eigenvalues(mani);
 		glEndList();
+	}
 	glCallList(1);
 	glPopMatrix();
 	glUseProgram(0);
 	theConsole.RenderConsole();
 	glutSwapBuffers();
+}
 void animate()
+{
 	usleep( (int)1e4 );
 	view_ctrl->try_spin();
 	glutPostRedisplay();
+}
 void mouse(int button, int state, int x, int y)
+{
 	Vec2i pos(x,y);
 	if (state==GLUT_DOWN)
+	{
 		if (button==GLUT_LEFT_BUTTON)
 			view_ctrl->grab_ball(ROTATE_ACTION,pos);
 		else if (button==GLUT_MIDDLE_BUTTON)
 			view_ctrl->grab_ball(ZOOM_ACTION,pos);
 		else if (button==GLUT_RIGHT_BUTTON)
 			view_ctrl->grab_ball(PAN_ACTION,pos);
+	}
 	else if (state==GLUT_UP)
 		view_ctrl->release_ball();
+}
 void motion(int x, int y) {
 	Vec2i pos(x,y);
 	view_ctrl->roll_ball(Vec2i(x,y));
+}
 void keyboard_spec(int key, int x, int y)
+{
    int mod = glutGetModifiers();
     if( theConsole.isOpen() ) {
         // If shift held, scroll the console
         if( mod == GLUT_ACTIVE_SHIFT ) {
             switch (key){
                 case GLUT_KEY_UP:
                     theConsole.ScrollDownLine();
                     break;
                 case GLUT_KEY_DOWN:
                     theConsole.ScrollUpLine();
                     break;
+            }
         } else {
             theConsole.StandardKeyBindings( key );
+        }
+    }
+}
 template<typename T>
 T& get_CVar_ref(const std::string& s)
+{
 	return *reinterpret_cast<T*> (GetCVarData(s));
+}
 void keyboard(unsigned char key, int x, int y)
+{
 	if(theConsole.isOpen())
 		switch(key) {
 			case '\033':
 				theConsole.ToggleConsole();
 			default:
 				//send keystroke to console
 				if( theConsole.isOpen() ){
 					theConsole.EnterCommandCharacter(key);
+				}
 				break;
+		}
 	else {
 		int& display_eigenvalue = get_CVar_ref<int>("display.eigenvalue");
 		int& display_wireframe = get_CVar_ref<int>("display.wireframe");
 		int& display_diffuse = get_CVar_ref<int>("display.diffuse");
 		int& display_highlight = get_CVar_ref<int>("display.highlight");
 		switch(key) {
 			case 'q': exit(0);
 			case '\033':
 				theConsole.ToggleConsole();
 				break;
 			case '+':
 				display_eigenvalue = min(display_eigenvalue+1, MAX_E);
 				break;
 			case '-':
 				display_eigenvalue = max(display_eigenvalue-1, 0);
 				break;
 			case '1': E = 1; reconstruct(mani,E);
 				break;
 			case '>': if(E < MAX_E) partial_reconstruct(mani,E,++E);
 				break;
 			case '<': E = max(E-1, 0); reconstruct(mani,E);
 				break;
 			case 'd':
 				display_diffuse = !display_diffuse;
 				break;
 			case 'h':
 				display_highlight = !display_highlight;
 				break;
 			case 'w':
 				display_wireframe = !display_wireframe;
 				break;
+		}
+	}
 	create_display_list = true;
+}
 void init_glut(int argc, char** argv)
+{
 	glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
 	glutInitWindowSize(WINX, WINY);
 	glutInit(&argc, argv);
 	glutCreateWindow("Shape Harmonics");
 	glutDisplayFunc(display);
 	glutKeyboardFunc(keyboard);
 	glutSpecialFunc(keyboard_spec);
 	glutReshapeFunc(reshape);
 	glutMouseFunc(mouse);
 	glutMotionFunc(motion);
 	glutIdleFunc(animate);
+}
 void init_gl()
+{
 	glewInit();
 	glEnable(GL_LIGHTING);
 	glEnable(GL_LIGHT0);
 	Vec3f c(0,0,0);
 	float r = 5;
 	mani.get_bsphere(c,r);
 	view_ctrl = new GLViewController(WINX,WINY, c,r*2);
 	initialize_wireframe_shaders();
 	// Set the value of a uniform
 	//glUniform2f(glGetUniformLocation(prog_P0,"WIN_SCALE"), win_size_x/2.0, win_size_y/2.0);
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
 	glClearColor(0.50f, 0.50f, 0.50f, 0.f);
 	glColor4f(1.0f, 1.0f, 1.0f, 0.f);
 	glEnable(GL_DEPTH_TEST);
 	static CVar<ConsoleFunc> help( "help", ConsoleHelp );
 	static CVar<ConsoleFunc> rs("reset_shape", console_reset_shape);
 	static CVar<ConsoleFunc> pr("partial_reconstruct", console_partial_reconstruct);
+	static CVar<ConsoleFunc> simpl("simplify", console_simplify);
+	static CVar<ConsoleFunc> lsmooth("laplacian_smooth", console_laplacian_smooth);
+	static CVar<ConsoleFunc> tsmooth("taubin_smooth", console_taubin_smooth);
+	static CVar<ConsoleFunc> fsmooth("fvm_smooth", console_fvm_smooth);
+	static CVar<ConsoleFunc> opt_val("optimize_valency", console_optimize_valency);
+	static CVar<ConsoleFunc> min_dih("minimize_dihedral", console_minimize_dihedral);
+	static CVar<ConsoleFunc> min_curv("minimize_curvature", console_minimize_curvature);
+}
 int main(int argc, char** argv)
+{
 	ArgExtracter ae(argc, argv);
 	ae.extract("-E", E);
     if(argc>1)
+	{
 		string file = ae.get_last_arg();
 		load(file, mani);
+	}
 	init_glut(argc,argv);
 	init_gl();
 	init_harmonics(mani);
 	glutMainLoop();
+}

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/meshedit.cpp – Rev 386 → 387