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

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/meshedit.cpp – Rev 394 → 397