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 <string>
#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 <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/obj_save.h>
#include <HMesh/mesh_optimization.h>
#include <HMesh/triangulate.h>
#include <HMesh/close_holes.h>
#include <HMesh/caps_and_needles.h>
#include <HMesh/refine_edges.h>
#include <HMesh/subdivision.h>
 
#include <GLConsole/GLConsole.h>
#include <Util/Timer.h>
#include "harmonics.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>
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);
	return get_vis_obj(active);
}
 
inline Manifold& active_mesh()
{
	return avo().mesh();
}
 
inline GLViewController& active_view_control()
{
	return avo().view_control();
}
 
// 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 ESC 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 arg1=? or arg1=help 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("");
    theConsole.Printf("Keyboard commands (when console is not active):");
    theConsole.Printf("w   : switch to display.render_mode = wireframe");
    theConsole.Printf("i   : switch to display.render_mode = isophotes");
    theConsole.Printf("r   : switch to display.render_mode = reflection");
    theConsole.Printf("m   : switch to display.render_mode = metallic");
    theConsole.Printf("g   : switch to display.render_mode = glazed");
    theConsole.Printf("n   : switch to display.render_mode = normal");
    theConsole.Printf("h   : switch to display.render_mode = harmonics");
    theConsole.Printf("f   : toggle smooth/flat shading");
    theConsole.Printf("1-9 : switch between active meshes.");
    theConsole.Printf("d   : (display.render_mode = harmonics) diffuse light on and off");
    theConsole.Printf("h   : (display.render_mode = harmonics) highlight on and off ");
    theConsole.Printf("+/- : (display.render_mode = harmonics) which eigenvector to show");
    theConsole.Printf("q   : quit program");
    theConsole.Printf("ESC : open console");
    theConsole.Printf("");
    theConsole.Printf("Mouse: Left button rotates, middle zooms, right pans");
    theConsole.Printf("----------------- HELP -----------------");
    theConsole.Printf("");
    return "";
}
 
bool wantshelp(std::vector<std::string> &args)
{
	if(args.size()==0) return false;
	string str = args[0];
	if(str=="help" || str=="HELP" || str=="Help" || str=="?") return true;
	return false;
}
 
/// Function that aligns two meshes.
char* console_align(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: align <dest> <src>");
		theConsole.Printf("This function aligns dest mesh with src");
		theConsole.Printf("In practice the GLViewController of src is copied to dst.");
		theConsole.Printf("both arguments are mandatory and must be numbers between 1 and 9.");
		theConsole.Printf("Note that results might be unexpexted if the meshes are not on the same scale");
		return "";
	}
	
	int dest = 0;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> dest;
		--dest;
		if(dest <0 || dest>8) return "dest mesh out of range (1-9)";
	}
	else return "neither source nor destination mesh?!";
	int src = 0;
	if(args.size()>1)
	{
		istringstream a1(args[1]);
		a1 >> src;
		--src;
		if(src <0 || src>8) return "src mesh out of range (1-9)";
	}	
	else return "no src mesh?";
	
	get_vis_obj(dest).view_control() = get_vis_obj(src).view_control();
	
	return "";
}
 
 
char* console_save(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: save <name.x3d|name.obj> ");
		return "";
	}
	string& file_name = args[0];
	if(args.size() == 1)
	{
		if(file_name.substr(file_name.length()-4,file_name.length())==".obj")
		{
			obj_save(file_name, active_mesh());
			return "";
		}
		else if(file_name.substr(file_name.length()-4,file_name.length())==".x3d")
		{
			x3d_save(file_name, active_mesh());
			return "";
		}
		return "unknown format";
	}
	return "usage: save <name.x3d|name.obj> ";
}
 
char* console_refine_edges(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: refine.split_edges <length>");
		theConsole.Printf("splits edges longer than <length>; default is 0.5 times average length");
		return "";
	}
	
	float thresh = 0.5;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> thresh;
	}
	float avg_length = average_edge_length(active_mesh());
	refine_edges(active_mesh(), thresh * avg_length);
	return "";
	
}
 
char* console_refine_faces(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: refine.split_faces ");
		theConsole.Printf("usage:  Takes no arguments. Inserts a vertex at the centre of each face.");
		return "";
	}
	
	safe_triangulate(active_mesh());
	return "";
	
}
 
char* console_cc_subdivide(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: refine.catmull_clark ");
		theConsole.Printf("Splits each polygon into four (Catmull Clark style)");
		return "";
	}
	cc_split(active_mesh(),active_mesh());
	return "";
}
 
char* console_dual(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: dual ");
		theConsole.Printf("Produces the dual by converting each face to a vertex placed at the barycenter.");
		return "";
	}
	
	Manifold& m = active_mesh();
	
	// make sure every face knows its number
	m.enumerate_faces();
	
	vector<Vec3f> vertices(m.no_faces());
	vector<int> faces;
	vector<int> indices;
	
	// Create new vertices. Each face becomes a vertex whose position
	// is the centre of the face
	int i=0;
	for(FaceIter f=m.faces_begin(); f!=m.faces_end(); ++f,++i)
		vertices[i] = centre(f);
	
	// Create new faces. Each vertex is a new face with N=valency of vertex
	// edges.
	i=0;
	for(VertexIter v=m.vertices_begin(); v!= m.vertices_end(); ++v,++i)
		if(!is_boundary(v))
		{
			VertexCirculator vc(v);
			vector<int> index_tmp;
			for(; !vc.end(); ++vc)
				index_tmp.push_back(vc.get_face()->touched);
			
			// Push vertex indices for this face onto indices vector.
			// The circulator moves around the face in a clockwise fashion
			// so we just reverse the ordering.
			indices.insert(indices.end(), index_tmp.rbegin(), index_tmp.rend());
			
			// Insert face valency in the face vector.
			faces.push_back(vc.no_steps());
		}
	
	// Clear the manifold before new geometry is inserted.
	m.clear();
	
	// And build
	build_manifold(m, vertices.size(), &vertices[0], faces.size(),
				   &faces[0],&indices[0]);
	
	return "";
}
 
 
char* console_minimize_curvature(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: optimize.minimize_curvature <anneal>");
		theConsole.Printf("Flip edges to minimize mean curvature.");
		theConsole.Printf("If anneal is true, simulated annealing (slow) is used rather than a greedy scheme");
		return "";
	}
	bool anneal=false;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> anneal;
	}
	
	minimize_curvature(active_mesh(), anneal);
	avo().post_create_display_list();
	return "";
}
 
char* console_minimize_dihedral(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: optimize.minimize_dihedral <iter> <anneal> <use_alpha> <gamma> ");
		theConsole.Printf("Flip edges to minimize dihedral angles.");
		theConsole.Printf("Iter is the max number of iterations. anneal tells us whether to use ");
		theConsole.Printf("simulated annealing and not greedy optimization. use_alpha (default=true) ");
		theConsole.Printf("means to use angle and not cosine of anglegamma (default=4) is the power ");
		theConsole.Printf("to which we raise the dihedral angle");
		return "";
	}
	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()>2)
	{
		istringstream a0(args[0]);
		a0 >> use_alpha;
	}
	
	float gamma = 4.0;
	if(args.size()>3)
	{
		istringstream a0(args[0]);
		a0 >> gamma;
	}
	
	
	minimize_dihedral_angle(active_mesh(), iter, anneal, use_alpha, gamma);
	return "";
}
 
char* console_maximize_min_angle(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: optimize.maximize_min_angle <thresh> <anneal>");
		theConsole.Printf("Flip edges to maximize min angle - to make mesh more Delaunay.");
		theConsole.Printf("If the dot product of the normals between adjacent faces < thresh");
		theConsole.Printf("no flip will be made. anneal selects simulated annealing rather ");
		theConsole.Printf("nthan greedy optimization.");
		return "";
	}
	float thresh=0.0;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> thresh;
	}
	bool anneal=false;
	if(args.size()>1)
	{
		istringstream a0(args[0]);
		a0 >> anneal;
	}
	maximize_min_angle(active_mesh(),thresh,anneal);
	return "";
}
 
 
char* console_optimize_valency(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: optimize.valency <anneal> ");
		theConsole.Printf("Optimizes valency for triangle meshes. Anneal selects simulated annealing rather than greedy optim.");
		return "";
	}
	bool anneal=false;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> anneal;
	}
	optimize_valency(active_mesh(), anneal);
	return "";
}
 
char* console_analyze(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  harmonics.analyze");
		theConsole.Printf("Creates the Laplace Beltrami operator for the mesh and finds all eigensolutions.");
		theConsole.Printf("It also projects the vertices onto the eigenvectors - thus transforming the mesh");
		theConsole.Printf("to this basis.");
		theConsole.Printf("Note that this will stall the computer for a large mesh - as long as we use Lapack.");
		return "";
	}
	avo().harmonics_analyze_mesh();
	return "";
}
 
 
char* console_partial_reconstruct(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: haramonics.partial_reconstruct <e0> <e1> <s>");
		theConsole.Printf("Reconstruct from projections onto eigenvectors. The two first arguments indicate");
		theConsole.Printf("the eigenvector interval that we reconstruct from. The last argument is the ");
		theConsole.Printf("scaling factor. Thus, for a vertex, v, the formula for computing the position, p, is:");
		theConsole.Printf("for (i=e0; i<=e1;++i) p += proj[i] * Q[i][v] * s;");
		theConsole.Printf("where proj[i] is the 3D vector containing the x, y, and z projections of the mesh onto");
		theConsole.Printf("eigenvector i. Q[i][v] is the v'th coordinate of the i'th eigenvector.");
		theConsole.Printf("Note that if vertex coordinates are not first reset, the result is probably unexpected.");
		return "";
	}
	int E0,E1;
	float scale;
	istringstream a0(args[0]);
	a0 >> E0;
	istringstream a1(args[1]);
	a1 >> E1;
	istringstream a2(args[2]);
	a2 >> scale;
	avo().harmonics_partial_reconstruct(E0,E1,scale);
	return "";
}
 
char* console_reset_shape(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: harmonics.reset_shape ");
		theConsole.Printf("Simply sets all vertices to 0,0,0. Call this before doing partial_reconstruct");
		theConsole.Printf("unless you know what you are doing.");
		return "";
	}
	avo().harmonics_reset_shape();
	return "";
}
 
 
char* console_close_holes(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: cleanup.close_holes");
		theConsole.Printf("This function closes holes. It simply follows the loop of halfvectors which");
		theConsole.Printf("enclose the hole and add a face to which they all point.");
		return "";
	}
	close_holes(active_mesh());
	return "";
}
 
char* console_reload(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  reload <file>");
		theConsole.Printf("Reloads 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";
	return "";
}
 
 
char* console_simplify(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: simplify <fraction> ");
		theConsole.Printf("Performs Garland Heckbert (quadric based) mesh simplification.");
		theConsole.Printf("The only argument is the fraction of vertices to keep.");
		return "";
	}
	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;
	active_mesh().get_bbox(p0, p7);
	Vec3f d = p7-p0;
	float s = 1.0/d.max_coord();
	Vec3f pcentre = (p7+p0)/2.0;
	for(VertexIter vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
		vi->pos = (vi->pos - pcentre) * s;
	quadric_simplify(active_mesh(),keep_fraction,0.0001f,true);
	for(VertexIter vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
		vi->pos = vi->pos*d.max_coord() + pcentre;
	return "";
}
 
char* console_vertex_noise(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: noise.perturb_vertices <amplitude>");
		theConsole.Printf("adds a random vector to each vertex. To ensure uniformness, the vector must lie in the");
		theConsole.Printf("unit sphere. The length of the vector is multiplied by the average edge length and then amplitude");
		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;
	}
	
	srand(0);
	for(VertexIter vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
	{
		Vec3f v;
		do {
			v = Vec3f(rand(),rand(),rand());
			v /= RAND_MAX;
		} while(sqr_length(v) > 1.0);
		v -= Vec3f(0.5);
		v *= 2.0;
		v *= noise_amplitude;
		v *= avg_length;
		vi->pos += v;
	}		
	return "";
}
 
char* console_noisy_flips(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  noise.perturb_topology <iter>");
		theConsole.Printf("Perform random flips. iter (default=1) is the number of iterations.");
		theConsole.Printf("mostly for making nasty synthetic test cases.");
		return "";
	}
	int iter=1;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> iter;
	}
	
	randomize_mesh(active_mesh(),  iter);
	return "";
}
 
char* console_laplacian_smooth(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  smooth.laplacian <weight>");
		theConsole.Printf("Perform Laplacian smoothing. weight is the scaling factor for the Laplacian.");
		return "";
	}
	float t=1.0;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> t;
	}
	/// Simple laplacian smoothing with an optional weight.
	laplacian_smooth(active_mesh(), t);
	return "";
}
 
char* console_taubin_smooth(std::vector<std::string> &args)
{
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  smooth.taubin <iter>");
		theConsole.Printf("Perform Taubin smoothing. iter (default=1) is the number of iterations.");
		return "";
	}
	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(active_mesh(),  iter);
	return "";
}
 
char* console_fvm_smooth(std::vector<std::string> &args)
{	
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: smooth.fuzzy_vector_median <iter>");
		theConsole.Printf("Smooth normals using fuzzy vector median smoothing. iter (default=1) is the number of iterations");
		theConsole.Printf("This function does a very good job of preserving sharp edges.");
		return "";
	}
	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(active_mesh(),  iter);
	return "";
	
}
 
char* console_triangulate(std::vector<std::string> &args)
{	
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  triangulate");
		theConsole.Printf("This function triangulates all non triangular faces of the mesh.");
		theConsole.Printf("you may want to call it after hole closing. For a polygon it simply connects");
		theConsole.Printf("the two closest vertices in a recursive manner until only triangles remain");
		return "";
	}
	shortest_edge_triangulate(active_mesh());
	return "";
}
 
 
char* console_remove_caps(std::vector<std::string> &args)
{	
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage:  cleanup.remove_caps thresh");
		theConsole.Printf("Remove caps (triangles with one very big angle). The thresh argument is the fraction of PI to");
		theConsole.Printf("use as threshold for big angle. Default is 0.85. Caps are removed by flipping.");
		return "";
	}
	float t=0.85;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> t;
	}
	
	remove_caps_from_trimesh(active_mesh(), static_cast<float>(M_PI) *t);
	return "";
}
 
char* console_remove_needles(std::vector<std::string> &args)
{	
	if(wantshelp(args)) 
	{
		theConsole.Printf("usage: cleanup.remove_needles <thresh>");
		theConsole.Printf("Removes very short edges by collapse. thresh is multiplied by the average edge length");
		theConsole.Printf("to get the length shorter than which we collapse. Default = 0.1");
		return "";
	}
	float thresh = 0.1;
	if(args.size()>0)
	{
		istringstream a0(args[0]);
		a0 >> thresh;
	}
	float avg_length = average_edge_length(active_mesh());
	remove_needles_from_trimesh(active_mesh(), thresh * avg_length);
	return "";
}
 
void reshape(int W, int H)
{
	active_view_control().reshape(W,H);
}
 
void display() 
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	static CVar<string> display_render_mode("display.render_mode","");
	static CVar<int> display_smooth("display.smooth_shading",1);
	
	glPushMatrix();
	
	avo().display(display_render_mode, display_smooth);
	
	glPopMatrix();
	
	glUseProgram(0);
	theConsole.RenderConsole();
	
	glutSwapBuffers();
}
 
void animate() 
{	
	//usleep( (int)1e4 );
	active_view_control().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) 
			active_view_control().grab_ball(ROTATE_ACTION,pos);
		else if (button==GLUT_MIDDLE_BUTTON) 
			active_view_control().grab_ball(ZOOM_ACTION,pos);
		else if (button==GLUT_RIGHT_BUTTON) 
			active_view_control().grab_ball(PAN_ACTION,pos);
	}
	else if (state==GLUT_UP)
		active_view_control().release_ball();
}
 
void motion(int x, int y) {
	Vec2i pos(x,y);
	active_view_control().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 );
		}
	}
}
 
 
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;
		}
		if(key == 13)	avo().post_create_display_list();
		
	}	
	else {
		string& display_render_mode = get_CVar_ref<string>("display.render_mode");
		int& display_smooth = get_CVar_ref<int>("display.smooth_shading");
		int& active  = get_CVar_ref<int>("active_mesh");
		
		
		switch(key) {
			case 'q': exit(0);
			case '\033':
				theConsole.ToggleConsole();
				break;
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				active = key - '1'; break;
			case 'f': display_smooth = !display_smooth; break;
			case 'w':
				display_render_mode = "wire"; break;
			case 'n':
				display_render_mode = "normal"; break;
			case 'i':
				display_render_mode = "isophotes"; break;
			case 'r':
				display_render_mode = "reflection"; break;
			case 'h':
				display_render_mode = "harmonics"; break;
			case 'm':
				display_render_mode = "metal"; break;
			case 'g':
				display_render_mode = "glazed"; break;
		}
		
		if(display_render_mode.substr(0,4) == "harm")
			avo().harmonics_parse_key(key);
		
		avo().post_create_display_list();		
	}
}
 
void init_glut(int argc, char** argv)
{
	glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH|GLUT_ALPHA);
	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);
	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
	
	// 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("harmonics.reset_shape", console_reset_shape);
	static CVar<ConsoleFunc> ha("harmonics.analyze", console_analyze);
	static CVar<ConsoleFunc> pr("harmonics.partial_reconstruct", console_partial_reconstruct);
	static CVar<ConsoleFunc> simpl("simplify", console_simplify);
	static CVar<ConsoleFunc> lsmooth("smooth.laplacian", console_laplacian_smooth);
	static CVar<ConsoleFunc> tsmooth("smooth.taubin", console_taubin_smooth);
	static CVar<ConsoleFunc> fsmooth("smooth.fuzzy_vector_median", console_fvm_smooth);
	
	static CVar<ConsoleFunc> opt_val("optimize.valency", console_optimize_valency);
	static CVar<ConsoleFunc> min_dih("optimize.minimize_dihedral_angles", console_minimize_dihedral);
	static CVar<ConsoleFunc> min_curv("optimize.minimize_curvature", console_minimize_curvature);
	static CVar<ConsoleFunc> max_min_angle("optimize.maximize_min_angle", console_maximize_min_angle);
	static CVar<ConsoleFunc> close_holes_fun("cleanup.close_holes", console_close_holes);
	static CVar<ConsoleFunc> reload_fun("reload", console_reload);
	
	static CVar<ConsoleFunc> rem_caps_fun("cleanup.remove_caps", console_remove_caps);
	static CVar<ConsoleFunc> rem_needles_fun("cleanup.remove_needles", console_remove_needles);
	static CVar<ConsoleFunc> triangulate_fun("triangulate", console_triangulate);
	static CVar<ConsoleFunc> refine_fun("refine.split_edges", console_refine_edges);
	static CVar<ConsoleFunc> refine_face_fun("refine.split_faces", console_refine_faces);
	static CVar<ConsoleFunc> subd_fun("refine.catmull_clark", console_cc_subdivide);
	static CVar<ConsoleFunc> save_fun("save", console_save);
	static CVar<ConsoleFunc> noise_fun("noise.perturb_vertices", console_vertex_noise);
	static CVar<ConsoleFunc> noise_fun2("noise.perturb_topology", console_noisy_flips);
	
	static CVar<ConsoleFunc> dualize("dual", console_dual);
	
	static CVar<ConsoleFunc> align_fun("align", console_align);
	
	
}
 
int main(int argc, char** argv)
{
	ArgExtracter ae(argc, argv);
	
	init_glut(argc,argv);
	init_gl();
	
	Harmonics::init();
	
	if(argc>1)
	{		
		string file = ae.get_last_arg();
		avo().reload(file);
	}
	
	
	glutMainLoop();
}
 
 
 

Rev 399	Rev 401
1	`/*`	1	`/*`
2	`* MeshEdit is a small application which allows you to load and edit a mesh.`	2	`* MeshEdit is a small application which allows you to load and edit a mesh.`
3	`* The mesh will be stored in GEL's half edge based Manifold data structure.`	3	`* The mesh will be stored in GEL's half edge based Manifold data structure.`
4	`* A number of editing operations are supported. Most of these are accessible from the`	4	`* A number of editing operations are supported. Most of these are accessible from the`
5	`* console that pops up when you hit 'esc'.`	5	`* console that pops up when you hit 'esc'.`
6	`*`	6	`*`
7	`* Created by J. Andreas Bærentzen on 15/08/08.`	7	`* Created by J. Andreas Bærentzen on 15/08/08.`
8	`* Copyright 2008 __MyCompanyName__. All rights reserved.`	8	`* Copyright 2008 __MyCompanyName__. All rights reserved.`
9	`*`	9	`*`
10	`*/`	10	`*/`
11		11
12	`#include <string>`	12	`#include <string>`
13	`#include <iostream>`	13	`#include <iostream>`
14	`#include <CGLA/eigensolution.h>`	14	`#include <CGLA/eigensolution.h>`
15	`#include <CGLA/Vec2d.h>`	15	`#include <CGLA/Vec2d.h>`
16	`#include <CGLA/Vec3d.h>`	16	`#include <CGLA/Vec3d.h>`
17	`#include <CGLA/Mat3x3d.h>`	17	`#include <CGLA/Mat3x3d.h>`
18	`#include <CGLA/Mat2x2d.h>`	18	`#include <CGLA/Mat2x2d.h>`
19	`#include <CGLA/Mat2x3d.h>`	19	`#include <CGLA/Mat2x3d.h>`
20		20
21	`#include <LinAlg/Matrix.h>`	21	`#include <LinAlg/Matrix.h>`
22	`#include <LinAlg/Vector.h>`	22	`#include <LinAlg/Vector.h>`
23	`#include <LinAlg/LapackFunc.h>`	23	`#include <LinAlg/LapackFunc.h>`
24		24
25	`#include <Util/Timer.h>`	25	`#include <Util/Timer.h>`
26	`#include <Util/ArgExtracter.h>`	26	`#include <Util/ArgExtracter.h>`
27		27
28	`#include <GL/glew.h>`	28	`#include <GL/glew.h>`
29	`#include <GLGraphics/gel_glut.h>`	29	`#include <GLGraphics/gel_glut.h>`
30		30
31	`#include <HMesh/Manifold.h>`	31	`#include <HMesh/Manifold.h>`
32	`#include <HMesh/VertexCirculator.h>`	32	`#include <HMesh/VertexCirculator.h>`
33	`#include <HMesh/FaceCirculator.h>`	33	`#include <HMesh/FaceCirculator.h>`
34	`#include <HMesh/build_manifold.h>`	34	`#include <HMesh/build_manifold.h>`
35	`#include <HMesh/mesh_optimization.h>`	35	`#include <HMesh/mesh_optimization.h>`
36	`#include <HMesh/triangulate.h>`	36	`#include <HMesh/triangulate.h>`
37	`#include <HMesh/load.h>`	37	`#include <HMesh/load.h>`
38	`#include <HMesh/quadric_simplify.h>`	38	`#include <HMesh/quadric_simplify.h>`
39	`#include <HMesh/smooth.h>`	39	`#include <HMesh/smooth.h>`
40	`#include <HMesh/x3d_save.h>`	40	`#include <HMesh/x3d_save.h>`
41	`#include <HMesh/obj_save.h>`	41	`#include <HMesh/obj_save.h>`
42	`#include <HMesh/mesh_optimization.h>`	42	`#include <HMesh/mesh_optimization.h>`
43	`#include <HMesh/triangulate.h>`	43	`#include <HMesh/triangulate.h>`
44	`#include <HMesh/close_holes.h>`	44	`#include <HMesh/close_holes.h>`
45	`#include <HMesh/caps_and_needles.h>`	45	`#include <HMesh/caps_and_needles.h>`
46	`#include <HMesh/refine_edges.h>`	46	`#include <HMesh/refine_edges.h>`
47	`#include <HMesh/subdivision.h>`	47	`#include <HMesh/subdivision.h>`
48		48
49	`#include <GLConsole/GLConsole.h>`	49	`#include <GLConsole/GLConsole.h>`
50	`#include <Util/Timer.h>`	50	`#include <Util/Timer.h>`
51	`#include "harmonics.h"`	51	`#include "harmonics.h"`
52	`#include "Renderer.h"`	52	`#include "Renderer.h"`
53	`#include "VisObj.h"`	53	`#include "VisObj.h"`
54		54
55	`using namespace std;`	55	`using namespace std;`
56	`using namespace HMesh;`	56	`using namespace HMesh;`
57	`using namespace Geometry;`	57	`using namespace Geometry;`
58	`using namespace GLGraphics;`	58	`using namespace GLGraphics;`
59	`using namespace CGLA;`	59	`using namespace CGLA;`
60	`using namespace Util;`	60	`using namespace Util;`
61	`using namespace LinAlg;`	61	`using namespace LinAlg;`
62		62
63	`template<typename T>`	63	`template<typename T>`
64	`T& get_CVar_ref(const std::string& s)`	64	`T& get_CVar_ref(const std::string& s)`
65	`{`	65	`{`
66	`return reinterpret_cast<T> (GetCVarData(s));`	66	`return reinterpret_cast<T> (GetCVarData(s));`
67	`}`	67	`}`
68		68
69	`inline VisObj& get_vis_obj(int i)`	69	`inline VisObj& get_vis_obj(int i)`
70	`{`	70	`{`
71	`static VisObj vo[9];`	71	`static VisObj vo[9];`
72	`return vo[i];`	72	`return vo[i];`
73	`}`	73	`}`
74		74
75	`inline VisObj& avo()`	75	`inline VisObj& avo()`
76	`{`	76	`{`
77	`static CVar<int> active("active_mesh",0);`	77	`static CVar<int> active("active_mesh",0);`
78	`return get_vis_obj(active);`	78	`return get_vis_obj(active);`
79	`}`	79	`}`
80		80
81	`inline Manifold& active_mesh()`	81	`inline Manifold& active_mesh()`
82	`{`	82	`{`
83	`return avo().mesh();`	83	`return avo().mesh();`
84	`}`	84	`}`
85		85
86	`inline GLViewController& active_view_control()`	86	`inline GLViewController& active_view_control()`
87	`{`	87	`{`
88	`return avo().view_control();`	88	`return avo().view_control();`
89	`}`	89	`}`
90		90
91	`// Single global instance so glut can get access`	91	`// Single global instance so glut can get access`
92	`GLConsole theConsole;`	92	`GLConsole theConsole;`
93		93
94	`////////////////////////////////////////////////////////////////////////////////`	94	`////////////////////////////////////////////////////////////////////////////////`
95	`char* ConsoleHelp(std::vector<std::string> &args)`	95	`char* ConsoleHelp(std::vector<std::string> &args)`
96	`{`	96	`{`
97	`theConsole.Printf("");`	97	`theConsole.Printf("");`
98	`theConsole.Printf("----------------- HELP -----------------");`	98	`theConsole.Printf("----------------- HELP -----------------");`
99	`theConsole.Printf("Press ESC key to open and close console");`	99	`theConsole.Printf("Press ESC key to open and close console");`
100	`theConsole.Printf("Press TAB to see the available commands and functions");`	100	`theConsole.Printf("Press TAB to see the available commands and functions");`
101	`theConsole.Printf("Functions are shown in green and variables in yellow");`	101	`theConsole.Printf("Functions are shown in green and variables in yellow");`
102	`theConsole.Printf("Setting a value: [command] = value");`	102	`theConsole.Printf("Setting a value: [command] = value");`
103	`theConsole.Printf("Getting a value: [command]");`	103	`theConsole.Printf("Getting a value: [command]");`
104	`theConsole.Printf("Functions: [function] [arg1] [arg2] ...");`	104	`theConsole.Printf("Functions: [function] [arg1] [arg2] ...");`
105	`theConsole.Printf("Entering arg1=? or arg1=help will give a description.");`	105	`theConsole.Printf("Entering arg1=? or arg1=help will give a description.");`
106	`theConsole.Printf("History: Up and Down arrow keys move through history.");`	106	`theConsole.Printf("History: Up and Down arrow keys move through history.");`
107	`theConsole.Printf("Tab Completion: TAB does tab completion and makes suggestions.");`	107	`theConsole.Printf("Tab Completion: TAB does tab completion and makes suggestions.");`
108	`theConsole.Printf("");`	108	`theConsole.Printf("");`
109	`theConsole.Printf("Keyboard commands (when console is not active):");`	109	`theConsole.Printf("Keyboard commands (when console is not active):");`
110	`theConsole.Printf("w : switch to display.render_mode = wireframe");`	110	`theConsole.Printf("w : switch to display.render_mode = wireframe");`
111	`theConsole.Printf("i : switch to display.render_mode = isophotes");`	111	`theConsole.Printf("i : switch to display.render_mode = isophotes");`
112	`theConsole.Printf("r : switch to display.render_mode = reflection");`	112	`theConsole.Printf("r : switch to display.render_mode = reflection");`
-		113	`theConsole.Printf("m : switch to display.render_mode = metallic");`
-		114	`theConsole.Printf("g : switch to display.render_mode = glazed");`
-		115	`theConsole.Printf("n : switch to display.render_mode = normal");`
113	`theConsole.Printf("h : switch to display.render_mode = harmonics");`	116	`theConsole.Printf("h : switch to display.render_mode = harmonics");`
114	`theConsole.Printf("f : toggle smooth/flat shading");`	117	`theConsole.Printf("f : toggle smooth/flat shading");`
115	`theConsole.Printf("1-9 : switch between active meshes.");`	118	`theConsole.Printf("1-9 : switch between active meshes.");`
116	`theConsole.Printf("d : (display.render_mode = harmonics) diffuse light on and off");`	119	`theConsole.Printf("d : (display.render_mode = harmonics) diffuse light on and off");`
117	`theConsole.Printf("h : (display.render_mode = harmonics) highlight on and off ");`	120	`theConsole.Printf("h : (display.render_mode = harmonics) highlight on and off ");`
118	`theConsole.Printf("+/- : (display.render_mode = harmonics) which eigenvector to show");`	121	`theConsole.Printf("+/- : (display.render_mode = harmonics) which eigenvector to show");`
119	`theConsole.Printf("q : quit program");`	122	`theConsole.Printf("q : quit program");`
120	`theConsole.Printf("ESC : open console");`	123	`theConsole.Printf("ESC : open console");`
121	`theConsole.Printf("");`	124	`theConsole.Printf("");`
122	`theConsole.Printf("Mouse: Left button rotates, middle zooms, right pans");`	125	`theConsole.Printf("Mouse: Left button rotates, middle zooms, right pans");`
123	`theConsole.Printf("----------------- HELP -----------------");`	126	`theConsole.Printf("----------------- HELP -----------------");`
124	`theConsole.Printf("");`	127	`theConsole.Printf("");`
125	`return "";`	128	`return "";`
126	`}`	129	`}`
127		130
128	`bool wantshelp(std::vector<std::string> &args)`	131	`bool wantshelp(std::vector<std::string> &args)`
129	`{`	132	`{`
130	`if(args.size()==0) return false;`	133	`if(args.size()==0) return false;`
131	`string str = args[0];`	134	`string str = args[0];`
132	`if(str=="help" \|\| str=="HELP" \|\| str=="Help" \|\| str=="?") return true;`	135	`if(str=="help" \|\| str=="HELP" \|\| str=="Help" \|\| str=="?") return true;`
133	`return false;`	136	`return false;`
134	`}`	137	`}`
135		138
136	`/// Function that aligns two meshes.`	139	`/// Function that aligns two meshes.`
137	`char* console_align(std::vector<std::string> &args)`	140	`char* console_align(std::vector<std::string> &args)`
138	`{`	141	`{`
139	`if(wantshelp(args))`	142	`if(wantshelp(args))`
140	`{`	143	`{`
141	`theConsole.Printf("usage: align <dest> <src>");`	144	`theConsole.Printf("usage: align <dest> <src>");`
142	`theConsole.Printf("This function aligns dest mesh with src");`	145	`theConsole.Printf("This function aligns dest mesh with src");`
143	`theConsole.Printf("In practice the GLViewController of src is copied to dst.");`	146	`theConsole.Printf("In practice the GLViewController of src is copied to dst.");`
144	`theConsole.Printf("both arguments are mandatory and must be numbers between 1 and 9.");`	147	`theConsole.Printf("both arguments are mandatory and must be numbers between 1 and 9.");`
145	`theConsole.Printf("Note that results might be unexpexted if the meshes are not on the same scale");`	148	`theConsole.Printf("Note that results might be unexpexted if the meshes are not on the same scale");`
146	`return "";`	149	`return "";`
147	`}`	150	`}`
148		151
149	`int dest = 0;`	152	`int dest = 0;`
150	`if(args.size()>0)`	153	`if(args.size()>0)`
151	`{`	154	`{`
152	`istringstream a0(args[0]);`	155	`istringstream a0(args[0]);`
153	`a0 >> dest;`	156	`a0 >> dest;`
154	`--dest;`	157	`--dest;`
155	`if(dest <0 \|\| dest>8) return "dest mesh out of range (1-9)";`	158	`if(dest <0 \|\| dest>8) return "dest mesh out of range (1-9)";`
156	`}`	159	`}`
157	`else return "neither source nor destination mesh?!";`	160	`else return "neither source nor destination mesh?!";`
158	`int src = 0;`	161	`int src = 0;`
159	`if(args.size()>1)`	162	`if(args.size()>1)`
160	`{`	163	`{`
161	`istringstream a1(args[1]);`	164	`istringstream a1(args[1]);`
162	`a1 >> src;`	165	`a1 >> src;`
163	`--src;`	166	`--src;`
164	`if(src <0 \|\| src>8) return "src mesh out of range (1-9)";`	167	`if(src <0 \|\| src>8) return "src mesh out of range (1-9)";`
165	`}`	168	`}`
166	`else return "no src mesh?";`	169	`else return "no src mesh?";`
167		170
168	`get_vis_obj(dest).view_control() = get_vis_obj(src).view_control();`	171	`get_vis_obj(dest).view_control() = get_vis_obj(src).view_control();`
169		172
170	`return "";`	173	`return "";`
171	`}`	174	`}`
172		175
173		176
174	`char* console_save(std::vector<std::string> &args)`	177	`char* console_save(std::vector<std::string> &args)`
175	`{`	178	`{`
176	`if(wantshelp(args))`	179	`if(wantshelp(args))`
177	`{`	180	`{`
178	`theConsole.Printf("usage: save <name.x3d\|name.obj> ");`	181	`theConsole.Printf("usage: save <name.x3d\|name.obj> ");`
179	`return "";`	182	`return "";`
180	`}`	183	`}`
181	`string& file_name = args[0];`	184	`string& file_name = args[0];`
182	`if(args.size() == 1)`	185	`if(args.size() == 1)`
183	`{`	186	`{`
184	`if(file_name.substr(file_name.length()-4,file_name.length())==".obj")`	187	`if(file_name.substr(file_name.length()-4,file_name.length())==".obj")`
185	`{`	188	`{`
186	`obj_save(file_name, active_mesh());`	189	`obj_save(file_name, active_mesh());`
187	`return "";`	190	`return "";`
188	`}`	191	`}`
189	`else if(file_name.substr(file_name.length()-4,file_name.length())==".x3d")`	192	`else if(file_name.substr(file_name.length()-4,file_name.length())==".x3d")`
190	`{`	193	`{`
191	`x3d_save(file_name, active_mesh());`	194	`x3d_save(file_name, active_mesh());`
192	`return "";`	195	`return "";`
193	`}`	196	`}`
194	`return "unknown format";`	197	`return "unknown format";`
195	`}`	198	`}`
196	`return "usage: save <name.x3d\|name.obj> ";`	199	`return "usage: save <name.x3d\|name.obj> ";`
197	`}`	200	`}`
198		201
199	`char* console_refine_edges(std::vector<std::string> &args)`	202	`char* console_refine_edges(std::vector<std::string> &args)`
200	`{`	203	`{`
201	`if(wantshelp(args))`	204	`if(wantshelp(args))`
202	`{`	205	`{`
203	`theConsole.Printf("usage: refine.split_edges <length>");`	206	`theConsole.Printf("usage: refine.split_edges <length>");`
204	`theConsole.Printf("splits edges longer than <length>; default is 0.5 times average length");`	207	`theConsole.Printf("splits edges longer than <length>; default is 0.5 times average length");`
205	`return "";`	208	`return "";`
206	`}`	209	`}`
207		210
208	`float thresh = 0.5;`	211	`float thresh = 0.5;`
209	`if(args.size()>0)`	212	`if(args.size()>0)`
210	`{`	213	`{`
211	`istringstream a0(args[0]);`	214	`istringstream a0(args[0]);`
212	`a0 >> thresh;`	215	`a0 >> thresh;`
213	`}`	216	`}`
214	`float avg_length = average_edge_length(active_mesh());`	217	`float avg_length = average_edge_length(active_mesh());`
215	`refine_edges(active_mesh(), thresh * avg_length);`	218	`refine_edges(active_mesh(), thresh * avg_length);`
216	`return "";`	219	`return "";`
217		220
218	`}`	221	`}`
219		222
220	`char* console_refine_faces(std::vector<std::string> &args)`	223	`char* console_refine_faces(std::vector<std::string> &args)`
221	`{`	224	`{`
222	`if(wantshelp(args))`	225	`if(wantshelp(args))`
223	`{`	226	`{`
224	`theConsole.Printf("usage: refine.split_faces ");`	227	`theConsole.Printf("usage: refine.split_faces ");`
225	`theConsole.Printf("usage: Takes no arguments. Inserts a vertex at the centre of each face.");`	228	`theConsole.Printf("usage: Takes no arguments. Inserts a vertex at the centre of each face.");`
226	`return "";`	229	`return "";`
227	`}`	230	`}`
228		231
229	`safe_triangulate(active_mesh());`	232	`safe_triangulate(active_mesh());`
230	`return "";`	233	`return "";`
231		234
232	`}`	235	`}`
233		236
234	`char* console_cc_subdivide(std::vector<std::string> &args)`	237	`char* console_cc_subdivide(std::vector<std::string> &args)`
235	`{`	238	`{`
236	`if(wantshelp(args))`	239	`if(wantshelp(args))`
237	`{`	240	`{`
238	`theConsole.Printf("usage: refine.catmull_clark ");`	241	`theConsole.Printf("usage: refine.catmull_clark ");`
239	`theConsole.Printf("Splits each polygon into four (Catmull Clark style)");`	242	`theConsole.Printf("Splits each polygon into four (Catmull Clark style)");`
240	`return "";`	243	`return "";`
241	`}`	244	`}`
242	`cc_split(active_mesh(),active_mesh());`	245	`cc_split(active_mesh(),active_mesh());`
243	`return "";`	246	`return "";`
244	`}`	247	`}`
245		248
246	`char* console_dual(std::vector<std::string> &args)`	249	`char* console_dual(std::vector<std::string> &args)`
247	`{`	250	`{`
248	`if(wantshelp(args))`	251	`if(wantshelp(args))`
249	`{`	252	`{`
250	`theConsole.Printf("usage: dual ");`	253	`theConsole.Printf("usage: dual ");`
251	`theConsole.Printf("Produces the dual by converting each face to a vertex placed at the barycenter.");`	254	`theConsole.Printf("Produces the dual by converting each face to a vertex placed at the barycenter.");`
252	`return "";`	255	`return "";`
253	`}`	256	`}`
254		257
255	`Manifold& m = active_mesh();`	258	`Manifold& m = active_mesh();`
256		259
257	`// make sure every face knows its number`	260	`// make sure every face knows its number`
258	`m.enumerate_faces();`	261	`m.enumerate_faces();`
259		262
260	`vector<Vec3f> vertices(m.no_faces());`	263	`vector<Vec3f> vertices(m.no_faces());`
261	`vector<int> faces;`	264	`vector<int> faces;`
262	`vector<int> indices;`	265	`vector<int> indices;`
263		266
264	`// Create new vertices. Each face becomes a vertex whose position`	267	`// Create new vertices. Each face becomes a vertex whose position`
265	`// is the centre of the face`	268	`// is the centre of the face`
266	`int i=0;`	269	`int i=0;`
267	`for(FaceIter f=m.faces_begin(); f!=m.faces_end(); ++f,++i)`	270	`for(FaceIter f=m.faces_begin(); f!=m.faces_end(); ++f,++i)`
268	`vertices[i] = centre(f);`	271	`vertices[i] = centre(f);`
269		272
270	`// Create new faces. Each vertex is a new face with N=valency of vertex`	273	`// Create new faces. Each vertex is a new face with N=valency of vertex`
271	`// edges.`	274	`// edges.`
272	`i=0;`	275	`i=0;`
273	`for(VertexIter v=m.vertices_begin(); v!= m.vertices_end(); ++v,++i)`	276	`for(VertexIter v=m.vertices_begin(); v!= m.vertices_end(); ++v,++i)`
274	`if(!is_boundary(v))`	277	`if(!is_boundary(v))`
275	`{`	278	`{`
276	`VertexCirculator vc(v);`	279	`VertexCirculator vc(v);`
277	`vector<int> index_tmp;`	280	`vector<int> index_tmp;`
278	`for(; !vc.end(); ++vc)`	281	`for(; !vc.end(); ++vc)`
279	`index_tmp.push_back(vc.get_face()->touched);`	282	`index_tmp.push_back(vc.get_face()->touched);`
280		283
281	`// Push vertex indices for this face onto indices vector.`	284	`// Push vertex indices for this face onto indices vector.`
282	`// The circulator moves around the face in a clockwise fashion`	285	`// The circulator moves around the face in a clockwise fashion`
283	`// so we just reverse the ordering.`	286	`// so we just reverse the ordering.`
284	`indices.insert(indices.end(), index_tmp.rbegin(), index_tmp.rend());`	287	`indices.insert(indices.end(), index_tmp.rbegin(), index_tmp.rend());`
285		288
286	`// Insert face valency in the face vector.`	289	`// Insert face valency in the face vector.`
287	`faces.push_back(vc.no_steps());`	290	`faces.push_back(vc.no_steps());`
288	`}`	291	`}`
289		292
290	`// Clear the manifold before new geometry is inserted.`	293	`// Clear the manifold before new geometry is inserted.`
291	`m.clear();`	294	`m.clear();`
292		295
293	`// And build`	296	`// And build`
294	`build_manifold(m, vertices.size(), &vertices[0], faces.size(),`	297	`build_manifold(m, vertices.size(), &vertices[0], faces.size(),`
295	`&faces[0],&indices[0]);`	298	`&faces[0],&indices[0]);`
296		299
297	`return "";`	300	`return "";`
298	`}`	301	`}`
299		302
300		303
301	`char* console_minimize_curvature(std::vector<std::string> &args)`	304	`char* console_minimize_curvature(std::vector<std::string> &args)`
302	`{`	305	`{`
303	`if(wantshelp(args))`	306	`if(wantshelp(args))`
304	`{`	307	`{`
305	`theConsole.Printf("usage: optimize.minimize_curvature <anneal>");`	308	`theConsole.Printf("usage: optimize.minimize_curvature <anneal>");`
306	`theConsole.Printf("Flip edges to minimize mean curvature.");`	309	`theConsole.Printf("Flip edges to minimize mean curvature.");`
307	`theConsole.Printf("If anneal is true, simulated annealing (slow) is used rather than a greedy scheme");`	310	`theConsole.Printf("If anneal is true, simulated annealing (slow) is used rather than a greedy scheme");`
308	`return "";`	311	`return "";`
309	`}`	312	`}`
310	`bool anneal=false;`	313	`bool anneal=false;`
311	`if(args.size()>0)`	314	`if(args.size()>0)`
312	`{`	315	`{`
313	`istringstream a0(args[0]);`	316	`istringstream a0(args[0]);`
314	`a0 >> anneal;`	317	`a0 >> anneal;`
315	`}`	318	`}`
316		319
317	`minimize_curvature(active_mesh(), anneal);`	320	`minimize_curvature(active_mesh(), anneal);`
318	`avo().post_create_display_list();`	321	`avo().post_create_display_list();`
319	`return "";`	322	`return "";`
320	`}`	323	`}`
321		324
322	`char* console_minimize_dihedral(std::vector<std::string> &args)`	325	`char* console_minimize_dihedral(std::vector<std::string> &args)`
323	`{`	326	`{`
324	`if(wantshelp(args))`	327	`if(wantshelp(args))`
325	`{`	328	`{`
326	`theConsole.Printf("usage: optimize.minimize_dihedral <iter> <anneal> <use_alpha> <gamma> ");`	329	`theConsole.Printf("usage: optimize.minimize_dihedral <iter> <anneal> <use_alpha> <gamma> ");`
327	`theConsole.Printf("Flip edges to minimize dihedral angles.");`	330	`theConsole.Printf("Flip edges to minimize dihedral angles.");`
328	`theConsole.Printf("Iter is the max number of iterations. anneal tells us whether to use ");`	331	`theConsole.Printf("Iter is the max number of iterations. anneal tells us whether to use ");`
329	`theConsole.Printf("simulated annealing and not greedy optimization. use_alpha (default=true) ");`	332	`theConsole.Printf("simulated annealing and not greedy optimization. use_alpha (default=true) ");`
330	`theConsole.Printf("means to use angle and not cosine of anglegamma (default=4) is the power ");`	333	`theConsole.Printf("means to use angle and not cosine of anglegamma (default=4) is the power ");`
331	`theConsole.Printf("to which we raise the dihedral angle");`	334	`theConsole.Printf("to which we raise the dihedral angle");`
332	`return "";`	335	`return "";`
333	`}`	336	`}`
334	`int iter = 1000;`	337	`int iter = 1000;`
335	`if(args.size()>0)`	338	`if(args.size()>0)`
336	`{`	339	`{`
337	`istringstream a0(args[0]);`	340	`istringstream a0(args[0]);`
338	`a0 >> iter;`	341	`a0 >> iter;`
339	`}`	342	`}`
340		343
341	`bool anneal = false;`	344	`bool anneal = false;`
342	`if(args.size()>1)`	345	`if(args.size()>1)`
343	`{`	346	`{`
344	`istringstream a0(args[0]);`	347	`istringstream a0(args[0]);`
345	`a0 >> anneal;`	348	`a0 >> anneal;`
346	`}`	349	`}`
347		350
348	`bool use_alpha = true;`	351	`bool use_alpha = true;`
349	`if(args.size()>2)`	352	`if(args.size()>2)`
350	`{`	353	`{`
351	`istringstream a0(args[0]);`	354	`istringstream a0(args[0]);`
352	`a0 >> use_alpha;`	355	`a0 >> use_alpha;`
353	`}`	356	`}`
354		357
355	`float gamma = 4.0;`	358	`float gamma = 4.0;`
356	`if(args.size()>3)`	359	`if(args.size()>3)`
357	`{`	360	`{`
358	`istringstream a0(args[0]);`	361	`istringstream a0(args[0]);`
359	`a0 >> gamma;`	362	`a0 >> gamma;`
360	`}`	363	`}`
361		364
362		365
363	`minimize_dihedral_angle(active_mesh(), iter, anneal, use_alpha, gamma);`	366	`minimize_dihedral_angle(active_mesh(), iter, anneal, use_alpha, gamma);`
364	`return "";`	367	`return "";`
365	`}`	368	`}`
366		369
367	`char* console_maximize_min_angle(std::vector<std::string> &args)`	370	`char* console_maximize_min_angle(std::vector<std::string> &args)`
368	`{`	371	`{`
369	`if(wantshelp(args))`	372	`if(wantshelp(args))`
370	`{`	373	`{`
371	`theConsole.Printf("usage: optimize.maximize_min_angle <thresh> <anneal>");`	374	`theConsole.Printf("usage: optimize.maximize_min_angle <thresh> <anneal>");`
372	`theConsole.Printf("Flip edges to maximize min angle - to make mesh more Delaunay.");`	375	`theConsole.Printf("Flip edges to maximize min angle - to make mesh more Delaunay.");`
373	`theConsole.Printf("If the dot product of the normals between adjacent faces < thresh");`	376	`theConsole.Printf("If the dot product of the normals between adjacent faces < thresh");`
374	`theConsole.Printf("no flip will be made. anneal selects simulated annealing rather ");`	377	`theConsole.Printf("no flip will be made. anneal selects simulated annealing rather ");`
375	`theConsole.Printf("nthan greedy optimization.");`	378	`theConsole.Printf("nthan greedy optimization.");`
376	`return "";`	379	`return "";`
377	`}`	380	`}`
378	`float thresh=0.0;`	381	`float thresh=0.0;`
379	`if(args.size()>0)`	382	`if(args.size()>0)`
380	`{`	383	`{`
381	`istringstream a0(args[0]);`	384	`istringstream a0(args[0]);`
382	`a0 >> thresh;`	385	`a0 >> thresh;`
383	`}`	386	`}`
384	`bool anneal=false;`	387	`bool anneal=false;`
385	`if(args.size()>1)`	388	`if(args.size()>1)`
386	`{`	389	`{`
387	`istringstream a0(args[0]);`	390	`istringstream a0(args[0]);`
388	`a0 >> anneal;`	391	`a0 >> anneal;`
389	`}`	392	`}`
390	`maximize_min_angle(active_mesh(),thresh,anneal);`	393	`maximize_min_angle(active_mesh(),thresh,anneal);`
391	`return "";`	394	`return "";`
392	`}`	395	`}`
393		396
394		397
395	`char* console_optimize_valency(std::vector<std::string> &args)`	398	`char* console_optimize_valency(std::vector<std::string> &args)`
396	`{`	399	`{`
397	`if(wantshelp(args))`	400	`if(wantshelp(args))`
398	`{`	401	`{`
399	`theConsole.Printf("usage: optimize.valency <anneal> ");`	402	`theConsole.Printf("usage: optimize.valency <anneal> ");`
400	`theConsole.Printf("Optimizes valency for triangle meshes. Anneal selects simulated annealing rather than greedy optim.");`	403	`theConsole.Printf("Optimizes valency for triangle meshes. Anneal selects simulated annealing rather than greedy optim.");`
401	`return "";`	404	`return "";`
402	`}`	405	`}`
403	`bool anneal=false;`	406	`bool anneal=false;`
404	`if(args.size()>0)`	407	`if(args.size()>0)`
405	`{`	408	`{`
406	`istringstream a0(args[0]);`	409	`istringstream a0(args[0]);`
407	`a0 >> anneal;`	410	`a0 >> anneal;`
408	`}`	411	`}`
409	`optimize_valency(active_mesh(), anneal);`	412	`optimize_valency(active_mesh(), anneal);`
410	`return "";`	413	`return "";`
411	`}`	414	`}`
412		415
413	`char* console_analyze(std::vector<std::string> &args)`	416	`char* console_analyze(std::vector<std::string> &args)`
414	`{`	417	`{`
415	`if(wantshelp(args))`	418	`if(wantshelp(args))`
416	`{`	419	`{`
417	`theConsole.Printf("usage: harmonics.analyze");`	420	`theConsole.Printf("usage: harmonics.analyze");`
418	`theConsole.Printf("Creates the Laplace Beltrami operator for the mesh and finds all eigensolutions.");`	421	`theConsole.Printf("Creates the Laplace Beltrami operator for the mesh and finds all eigensolutions.");`
419	`theConsole.Printf("It also projects the vertices onto the eigenvectors - thus transforming the mesh");`	422	`theConsole.Printf("It also projects the vertices onto the eigenvectors - thus transforming the mesh");`
420	`theConsole.Printf("to this basis.");`	423	`theConsole.Printf("to this basis.");`
421	`theConsole.Printf("Note that this will stall the computer for a large mesh - as long as we use Lapack.");`	424	`theConsole.Printf("Note that this will stall the computer for a large mesh - as long as we use Lapack.");`
422	`return "";`	425	`return "";`
423	`}`	426	`}`
424	`avo().harmonics_analyze_mesh();`	427	`avo().harmonics_analyze_mesh();`
425	`return "";`	428	`return "";`
426	`}`	429	`}`
427		430
428		431
429	`char* console_partial_reconstruct(std::vector<std::string> &args)`	432	`char* console_partial_reconstruct(std::vector<std::string> &args)`
430	`{`	433	`{`
431	`if(wantshelp(args))`	434	`if(wantshelp(args))`
432	`{`	435	`{`
433	`theConsole.Printf("usage: haramonics.partial_reconstruct <e0> <e1> <s>");`	436	`theConsole.Printf("usage: haramonics.partial_reconstruct <e0> <e1> <s>");`
434	`theConsole.Printf("Reconstruct from projections onto eigenvectors. The two first arguments indicate");`	437	`theConsole.Printf("Reconstruct from projections onto eigenvectors. The two first arguments indicate");`
435	`theConsole.Printf("the eigenvector interval that we reconstruct from. The last argument is the ");`	438	`theConsole.Printf("the eigenvector interval that we reconstruct from. The last argument is the ");`
436	`theConsole.Printf("scaling factor. Thus, for a vertex, v, the formula for computing the position, p, is:");`	439	`theConsole.Printf("scaling factor. Thus, for a vertex, v, the formula for computing the position, p, is:");`
437	`theConsole.Printf("for (i=e0; i<=e1;++i) p += proj[i] * Q[i][v] * s;");`	440	`theConsole.Printf("for (i=e0; i<=e1;++i) p += proj[i] * Q[i][v] * s;");`
438	`theConsole.Printf("where proj[i] is the 3D vector containing the x, y, and z projections of the mesh onto");`	441	`theConsole.Printf("where proj[i] is the 3D vector containing the x, y, and z projections of the mesh onto");`
439	`theConsole.Printf("eigenvector i. Q[i][v] is the v'th coordinate of the i'th eigenvector.");`	442	`theConsole.Printf("eigenvector i. Q[i][v] is the v'th coordinate of the i'th eigenvector.");`
440	`theConsole.Printf("Note that if vertex coordinates are not first reset, the result is probably unexpected.");`	443	`theConsole.Printf("Note that if vertex coordinates are not first reset, the result is probably unexpected.");`
441	`return "";`	444	`return "";`
442	`}`	445	`}`
443	`int E0,E1;`	446	`int E0,E1;`
444	`float scale;`	447	`float scale;`
445	`istringstream a0(args[0]);`	448	`istringstream a0(args[0]);`
446	`a0 >> E0;`	449	`a0 >> E0;`
447	`istringstream a1(args[1]);`	450	`istringstream a1(args[1]);`
448	`a1 >> E1;`	451	`a1 >> E1;`
449	`istringstream a2(args[2]);`	452	`istringstream a2(args[2]);`
450	`a2 >> scale;`	453	`a2 >> scale;`
451	`avo().harmonics_partial_reconstruct(E0,E1,scale);`	454	`avo().harmonics_partial_reconstruct(E0,E1,scale);`
452	`return "";`	455	`return "";`
453	`}`	456	`}`
454		457
455	`char* console_reset_shape(std::vector<std::string> &args)`	458	`char* console_reset_shape(std::vector<std::string> &args)`
456	`{`	459	`{`
457	`if(wantshelp(args))`	460	`if(wantshelp(args))`
458	`{`	461	`{`
459	`theConsole.Printf("usage: harmonics.reset_shape ");`	462	`theConsole.Printf("usage: harmonics.reset_shape ");`
460	`theConsole.Printf("Simply sets all vertices to 0,0,0. Call this before doing partial_reconstruct");`	463	`theConsole.Printf("Simply sets all vertices to 0,0,0. Call this before doing partial_reconstruct");`
461	`theConsole.Printf("unless you know what you are doing.");`	464	`theConsole.Printf("unless you know what you are doing.");`
462	`return "";`	465	`return "";`
463	`}`	466	`}`
464	`avo().harmonics_reset_shape();`	467	`avo().harmonics_reset_shape();`
465	`return "";`	468	`return "";`
466	`}`	469	`}`
467		470
468		471
469	`char* console_close_holes(std::vector<std::string> &args)`	472	`char* console_close_holes(std::vector<std::string> &args)`
470	`{`	473	`{`
471	`if(wantshelp(args))`	474	`if(wantshelp(args))`
472	`{`	475	`{`
473	`theConsole.Printf("usage: cleanup.close_holes");`	476	`theConsole.Printf("usage: cleanup.close_holes");`
474	`theConsole.Printf("This function closes holes. It simply follows the loop of halfvectors which");`	477	`theConsole.Printf("This function closes holes. It simply follows the loop of halfvectors which");`
475	`theConsole.Printf("enclose the hole and add a face to which they all point.");`	478	`theConsole.Printf("enclose the hole and add a face to which they all point.");`
476	`return "";`	479	`return "";`
477	`}`	480	`}`
478	`close_holes(active_mesh());`	481	`close_holes(active_mesh());`
479	`return "";`	482	`return "";`
480	`}`	483	`}`
481		484
482	`char* console_reload(std::vector<std::string> &args)`	485	`char* console_reload(std::vector<std::string> &args)`
483	`{`	486	`{`
484	`if(wantshelp(args))`	487	`if(wantshelp(args))`
485	`{`	488	`{`
486	`theConsole.Printf("usage: reload <file>");`	489	`theConsole.Printf("usage: reload <file>");`
487	`theConsole.Printf("Reloads the current file if no argument is given, but");`	490	`theConsole.Printf("Reloads the current file if no argument is given, but");`
488	`theConsole.Printf("if an argument is given, then that becomes the current file");`	491	`theConsole.Printf("if an argument is given, then that becomes the current file");`
489	`return "";`	492	`return "";`
490	`}`	493	`}`
491	`if(!avo().reload(args.size()>0 ? args[0]:""))`	494	`if(!avo().reload(args.size()>0 ? args[0]:""))`
492	`return "failed to load";`	495	`return "failed to load";`
493	`return "";`	496	`return "";`
494	`}`	497	`}`
495		498
496		499
497	`char* console_simplify(std::vector<std::string> &args)`	500	`char* console_simplify(std::vector<std::string> &args)`

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/meshedit.cpp – Rev 399 → 401