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 <vector>
#include <algorithm>
 
#include <GL/glew.h>
 
#include <GLGraphics/Console.h>
 
 
#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 <GLGraphics/gel_glut.h>
 
#include <HMesh/Manifold.h>
#include <HMesh/AttributeVector.h>
#include <HMesh/mesh_optimization.h>
#include <HMesh/curvature.h>
#include <HMesh/triangulate.h>
#include <HMesh/flatten.h>
#include <HMesh/dual.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/off_save.h>
#include <HMesh/mesh_optimization.h>
#include <HMesh/triangulate.h>
#include <HMesh/cleanup.h>
#include <HMesh/cleanup.h>
#include <HMesh/refine_edges.h>
#include <HMesh/subdivision.h>
 
#include <Util/Timer.h>
#include <Util/ArgExtracter.h>
 
#include "polarize.h"
#include "harmonics.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;
 
// Single global instance so glut can get access
Console theConsole;
bool console_visible = false;
 
 
inline VisObj& get_vis_obj(int i)
{
    static VisObj vo[9];
    return vo[i];
}
 
Console::variable<int> active(0);
 
inline VisObj& avo()
{
    return get_vis_obj(active);
}
 
inline Manifold& active_mesh()
{
    return avo().mesh();
}
 
inline GLViewController& active_view_control()
{
    return avo().view_control();
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
bool MyConsoleHelp(const 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 true;
}
 
bool wantshelp(const 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.
void console_align(const 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");
    }
	
    int dest = 0;
	
    if(args.size()>0){
        istringstream a0(args[0]);
        a0 >> dest;
        --dest;
		
        if(dest <0 || dest>8)
        {
            theConsole.printf("dest mesh out of range (1-9)");
            return;
        }
    }
    else
    {
        theConsole.printf("neither source nor destination mesh?!");
        return;
    }
	
    int src = 0;
    if(args.size()>1){
        istringstream a1(args[1]);
        a1 >> src;
        --src;
		
        if(src <0 || src>8)
        {
            theConsole.printf("src mesh out of range (1-9)");
            return;
        }
    }
    else
    {
        theConsole.printf("no src mesh?");
        return;
    }
    get_vis_obj(dest).view_control() = get_vis_obj(src).view_control();
}
 
void console_polarize(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: polarize");
        return;
    }
    int divisions = 10;
	
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> divisions;
    }
 
    avo().save_old();
 
	double vmin, vmax;
    VertexAttributeVector<double> fun;
    VertexAttributeVector<double> par;
    make_height_fun(active_mesh(), fun, vmin, vmax);
    polarize_mesh(active_mesh(), fun, vmin, vmax, divisions, par);
}
 
void console_flatten(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: flatten <floater|harmonic|barycentric>");
        theConsole.printf("This function flattens a meshs with a simple boundary. It is mostly for showing mesh");
        theConsole.printf("parametrization methods. The current mesh MUST have a SINGLE boundary loop");
        theConsole.printf("This loop is mapped to the unit circle in a regular fashion (equal angle intervals).");
        theConsole.printf("All non boundary vertices are placed at the origin. Then the system is relaxed iteratively");
        theConsole.printf("using the weight scheme given as argument.");
        return;
    }
	
    avo().save_old();
	
    WeightScheme ws = BARYCENTRIC_W;
    if(args.size()>0){
        if(args[0] == "floater")
            ws = FLOATER_W;
        else if(args[0] == "harmonic")
            ws = HARMONIC_W;
        else if(args[0] == "lscm")
            ws = LSCM_W;
    }
    else
        return;
	
    flatten(active_mesh(), ws);
	
    return;
}
 
void console_save(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: save <name.x3d|name.obj> ");
		
        return;
    }
    const 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())==".off"){
            off_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;
        }
        theConsole.printf("unknown format");
        return; 
    }
    theConsole.printf("usage: save <name.x3d|name.obj> ");
}
 
 
void console_refine_edges(const 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;
    }
	
    avo().save_old();
	
    float thresh = 0.5f;
	
    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;
	
}
 
void console_refine_faces(const 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;
    }
    avo().save_old();
	
    triangulate_by_vertex_face_split(active_mesh());
	
    return;
	
}
 
void console_cc_subdivide(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: refine.catmull_clark ");
        theConsole.printf("Does one step of Catmull-Clark subdivision");
		
        return;
    }
    avo().save_old();
	
    cc_split(active_mesh(),active_mesh());
    cc_smooth(active_mesh());
	
    return;
}
 
void console_doosabin_subdivide(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: refine.doo_sabin ");
        theConsole.printf("Does one step of Doo-Sabin Subdivision");
		
        return;
    }
    avo().save_old();
	
    cc_split(active_mesh(),active_mesh());
    dual(active_mesh());
    
    return;
}
 
void console_dual(const 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;
    }
    avo().save_old();
	
    dual(active_mesh());
	
    return;
}
 
 
void console_minimize_curvature(const 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;
    }
    avo().save_old();
	
    bool anneal=false;
    if(args.size() > 0)
    {
        istringstream a0(args[0]);
        a0 >> anneal;
    }
	
    minimize_curvature(active_mesh(), anneal);
    avo().post_create_display_list();
    return;
}
 
void console_minimize_dihedral(const 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;
    }
    avo().save_old();
	
    int iter = 1000;
    if(args.size() > 0)
    {
        istringstream a0(args[0]);
        a0 >> iter;
    }
	
    bool anneal = false;
    if(args.size() > 1)
    {
        istringstream a0(args[1]);
        a0 >> anneal;
    }
	
    bool use_alpha = true;
    if(args.size() > 2)
    {
        istringstream a0(args[2]);
        a0 >> use_alpha;
    }
	
    float gamma = 4.0f;
    if(args.size() > 3)
    {
        istringstream a0(args[3]);
        a0 >> gamma;
    }
	
	
    minimize_dihedral_angle(active_mesh(), iter, anneal, use_alpha, gamma);
    return;
}
 
void console_maximize_min_angle(const 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;
    }
    avo().save_old();
	
    float thresh = 0.0f;
    if(args.size() > 0)
    {
        istringstream a0(args[0]);
        a0 >> thresh;
    }
    bool anneal = false;
    if(args.size() > 1)
    {
        istringstream a0(args[1]);
        a0 >> anneal;
    }
    maximize_min_angle(active_mesh(),thresh,anneal);
    return;
}
 
 
void console_optimize_valency(const 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;
    }
    avo().save_old();
	
    bool anneal = false;
    if(args.size() > 0)
    {
        istringstream a0(args[0]);
        a0 >> anneal;
    }
    optimize_valency(active_mesh(), anneal);
    return;
}
 
void console_analyze(const 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;
}
 
 
void console_partial_reconstruct(const std::vector<std::string> & args)
{
    if(args.size() != 3)
        theConsole.printf("usage: haramonics.partial_reconstruct <e0> <e1> <s>");
	
    if(wantshelp(args)) {
        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.");
    }
    avo().save_old();
	
    if(args.size() != 3)
        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;
}
 
void console_reset_shape(const 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().save_old();
    avo().harmonics_reset_shape();
    return;
}
 
 
void console_close_holes(const 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;
    }
    avo().save_old();
	
    close_holes(active_mesh());
    return;
}
 
void console_reload(const std::vector<std::string> & args)
{
    if(wantshelp(args)) 
    {
        theConsole.printf("usage:  load <file>");
        theConsole.printf("(Re)loads the current file if no argument is given, but");
        theConsole.printf("if an argument is given, then that becomes the current file");
        return;
    }
    avo().save_old();
	
    if(!avo().reload(args.size() > 0 ? args[0]:""))
        theConsole.printf("failed to load");
	
    return;
}
 
 
void console_add_mesh(const std::vector<std::string> & args)
{
    if(wantshelp(args)) 
    {
        theConsole.printf("usage:  add_mesh <file>");
        theConsole.printf("Loads the file but without clearing the mesh. Thus, the loaded mesh is added to the");
        theConsole.printf("current model.");
        return;
    }
    avo().save_old();
	
    if(!avo().add_mesh(args.size() > 0 ? args[0]:""))
        theConsole.printf("failed to load");
	
    return;
}
void console_valid(const std::vector<std::string> & args)
{
    if(wantshelp(args)) 
    {
        theConsole.printf("usage:  validity");
        theConsole.printf("Tests validity of Manifold");
        return;
    }
	if(valid(active_mesh()))
		theConsole.printf("Mesh is valid");
	else
		theConsole.printf("Mesh is invalid - check console output");
	return;
}
 
void console_info(const std::vector<std::string> & args)
{
    if(wantshelp(args)) 
    {
        theConsole.printf("usage:  info");
        theConsole.printf("Provides information about mesh.");
        return;
    }
    Vec3d p0, p7;
    bbox(active_mesh(), p0, p7);
    stringstream bbox_corners;
    bbox_corners << p0 << " - " << p7 << endl;
	theConsole.printf("Bounding box corners : %s", bbox_corners.str().c_str());
    map<int,int> val_hist;
    
    for(VertexIDIterator vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
    {
        int val = valency(active_mesh(), *vi);
        if(val_hist.find(val) == val_hist.end())
            val_hist[val] = 0;
        ++val_hist[val];
    }
    
    theConsole.printf("Valency histogam");
    for(map<int,int>::iterator iter = val_hist.begin(); iter != val_hist.end(); ++iter)
    {
        stringstream vhl;
        vhl << iter->first << ", " << iter->second;
        theConsole.printf("%d, %d", iter->first, iter->second);
    }
 
	theConsole.printf("Mesh contains %d faces", active_mesh().no_faces());
	theConsole.printf("Mesh contains %d halfedges", active_mesh().no_halfedges());
	theConsole.printf("Mesh contains %d vertices", active_mesh().no_vertices());
	return;
}
 
 
void console_simplify(const 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;
    }
    avo().save_old();
	
    float keep_fraction;
    if(args.size() == 0)
    {
        theConsole.print("you must specify fraction of vertices to keep");
        return;
    }
    istringstream a0(args[0]);
    a0 >> keep_fraction;
	
    Vec3d p0, p7;
    bbox(active_mesh(), p0, p7);
    Vec3d d = p7-p0;
    float s = 1.0/d.max_coord();
    Vec3d pcentre = (p7+p0)/2.0;
    for(VertexIDIterator vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi){
        active_mesh().pos(*vi) = (active_mesh().pos(*vi) - pcentre) * s;
    }
    cout << "Timing the Garland Heckbert (quadric based) mesh simplication..." << endl;
    Timer timer;
    timer.start();
	
    //simplify
    quadric_simplify(active_mesh(),keep_fraction,0.0001f,true);
	
    cout << "Simplification complete, process time: " << timer.get_secs() << " seconds" << endl;
	
    //clean up the mesh, a lot of edges were just collapsed 
    active_mesh().cleanup();
	
    for(VertexIDIterator vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
        active_mesh().pos(*vi) = active_mesh().pos(*vi)*d.max_coord() + pcentre;
    return;
}
 
void console_vertex_noise(const std::vector<std::string> & args)
{
    if(wantshelp(args)) 
    {
        theConsole.printf("usage: noise.perturb_vertices <amplitude>");
        theConsole.printf("adds a random vector to each vertex. A random vector in the unit cube is generated and");
        theConsole.printf("to ensure an isotropic distribution, vectors outside the unit ball are discarded.");
        theConsole.printf("The vector is multiplied by the average edge length and then by the amplitude specified.");
        theConsole.printf("If no amplitude is specified, the default (0.5) is used.");
        return;
    }
    avo().save_old();
	
    float avg_length = average_edge_length(active_mesh());
	
    float noise_amplitude = 0.5f;
    if(args.size() > 0) {
        istringstream a0(args[0]);
        a0 >> noise_amplitude;
    }
	
    gel_srand(0);
    for(VertexIDIterator vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi){
        Vec3d v;
        do{
            v = Vec3d(gel_rand(),gel_rand(),gel_rand());
            v /= (float)(GEL_RAND_MAX);
        } 
        while(sqr_length(v) > 1.0);
		
        v -= Vec3d(0.5);
        v *= 2.0;
        v *= noise_amplitude;
        v *= avg_length;
        active_mesh().pos(*vi) += v;
    }		
    return;
}
 
void console_perpendicular_vertex_noise(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: noise.perturb_vertices_perpendicular <amplitude>");
        theConsole.printf("adds the normal times a random scalar times amplitude times");
        theConsole.printf("times average edge length to the vertex. (default amplitude=0.5)");
        return;
    }
    avo().save_old();
	
    float avg_length = average_edge_length(active_mesh());
	
    float noise_amplitude = 0.5;
    if(args.size() > 0) 
    {
        istringstream a0(args[0]);
        a0 >> noise_amplitude;
    }
	
    VertexAttributeVector<Vec3d> normals(active_mesh().allocated_vertices());
    for(VertexIDIterator vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
        normals[*vi] = normal(active_mesh(), *vi);
	
    gel_srand(0);
    for(VertexIDIterator vi = active_mesh().vertices_begin(); vi != active_mesh().vertices_end(); ++vi)
    {
        float rval = 0.5-gel_rand() / float(GEL_RAND_MAX);
        active_mesh().pos(*vi) += normals[*vi]*rval*noise_amplitude*avg_length*2.0;
    }
    return;
}
 
void console_noisy_flips(const 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;
    }
    avo().save_old();
	
    int iter = 1;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> iter;
    }
	
    randomize_mesh(active_mesh(),  iter);
    return;
}
 
void console_laplacian_smooth(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage:  smooth.laplacian <weight> <iter>");
        theConsole.printf("Perform Laplacian smoothing. weight is the scaling factor for the Laplacian.");
        theConsole.printf("default weight = 1.0. Default number of iterations = 1");
        return;
    }
    avo().save_old();
	
    float t=1.0;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> t;
    }
    int iter = 1;
    if(args.size()>1){
        istringstream a0(args[1]);
        a0 >> iter;
    }
    /// Simple laplacian smoothing with an optional weight.
    for(int i=0;i<iter;++i) 
        laplacian_smooth(active_mesh(), t);
    return;
}
 
 
void console_mean_curvature_smooth(const std::vector<std::string> & args){
    if(wantshelp(args)) {
        theConsole.printf("usage:  smooth.mean_curvature <weight> <iter>");
        theConsole.printf("Perform mean curvature smoothing. weight is the scaling factor for the");
        theConsole.printf("mean curvature vector which has been normalized by dividing by edge lengths");
        theConsole.printf("this allows for larger steps as suggested by Desbrun et al.");
        theConsole.printf("default weight = 1.0. Default number of iterations = 1");
        return;
    }
    avo().save_old();
	
    double t=1.0;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> t;
    }
    int iter=1;
    if(args.size() > 1){
        istringstream a0(args[1]);
        a0 >> iter;
    }	
    VertexAttributeVector<Vec3d> new_pos(active_mesh().allocated_vertices());
    for(int j = 0; j < iter; ++j){
        for(VertexIDIterator v = active_mesh().vertices_begin(); v != active_mesh().vertices_end(); ++v) {
            Vec3d m;
            double w_sum;
            unnormalized_mean_curvature_normal(active_mesh(), *v, m, w_sum);
            new_pos[*v] = Vec3d(active_mesh().pos(*v))  + (t * m/w_sum);
        }
        for(VertexIDIterator v = active_mesh().vertices_begin(); v != active_mesh().vertices_end(); ++v)
            active_mesh().pos(*v) = new_pos[*v];
    }
    return;
}
 
void console_taubin_smooth(const 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;
    }
    avo().save_old();
	
    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;
}
 
void console_fvm_smooth(const 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;
    }
    avo().save_old();
	
    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;
}
 
void console_triangulate(const 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;
    }
    avo().save_old();
	
    shortest_edge_triangulate(active_mesh());
    active_mesh().cleanup();
	valid(active_mesh());
    return;
}
 
void console_remove_faces(const std::vector<std::string> & args)
{
    avo().save_old();
    
    gel_srand(0);
 
//    for (FaceIDIterator f= active_mesh().faces_begin(); f != active_mesh().faces_end(); ++f) {
//        if(gel_rand() < 0.5 * GEL_RAND_MAX)
//        {
//            active_mesh().remove_face(*f);
//        }
//    }
 
//    for (VertexIDIterator v= active_mesh().vertices_begin(); v != active_mesh().vertices_end(); ++v) {
//        if(gel_rand() < 0.005 * GEL_RAND_MAX)
//        {
//            active_mesh().remove_vertex(*v);
//        }
//    }
    for (HalfEdgeIDIterator h= active_mesh().halfedges_begin(); h != active_mesh().halfedges_end(); ++h) {
        if(gel_rand() < 0.005 * GEL_RAND_MAX)
        {
            active_mesh().remove_edge(*h);
        }
    }
 
    active_mesh().cleanup();
    valid(active_mesh());
	
    return;
}
 
 
void console_remove_caps(const 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;
    }
    avo().save_old();
	
    float t = 0.85f;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> t;
    }
    remove_caps(active_mesh(), static_cast<float>(M_PI) *t);
    active_mesh().cleanup();
	
    return;
}
 
void console_remove_needles(const 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;
    }
    avo().save_old();
	
    float thresh = 0.1f;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> thresh;
    }
    float avg_length = average_edge_length(active_mesh());
    remove_needles(active_mesh(), thresh * avg_length);
    active_mesh().cleanup();
	
    return;
}
 
void console_undo(const std::vector<std::string> & args)
{	
    if(wantshelp(args)) {
        theConsole.printf("usage:  undo");
        theConsole.printf("This function undoes one operation. Repeated undo does nothing");
        return;
    }
    avo().restore_old();
    return;
}
 
 
void reshape(int W, int H)
{
    active_view_control().reshape(W,H);
}
 
Console::variable<string> display_render_mode("normal");
Console::variable<int> display_smooth_shading;
Console::variable<float> display_gamma(2.2);
 
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
 
    glPushMatrix();
 
    avo().display(display_render_mode, theConsole, display_smooth_shading, display_gamma);
	
    glPopMatrix();
	
    if(console_visible)
    {
        glUseProgram(0);
        theConsole.display();
	}
    
    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 && glutGetModifiers() == 0)
            active_view_control().grab_ball(ROTATE_ACTION,pos);
        else if (button==GLUT_MIDDLE_BUTTON || glutGetModifiers() == GLUT_ACTIVE_CTRL) 
            active_view_control().grab_ball(ZOOM_ACTION,pos);
        else if (button==GLUT_RIGHT_BUTTON || glutGetModifiers() == GLUT_ACTIVE_ALT)
            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)
{
    if (console_visible)
        theConsole.special(key);
    glutPostRedisplay();
}
 
 
void keyboard(unsigned char key, int x, int y) 
{
    //toggle console with ESC
    if (key == 27)
    {
        console_visible = !console_visible;
        glutPostRedisplay();
        return;
    }
    
    if (console_visible)
    {
        theConsole.keyboard(key);
        if(key == 13)
        {
            avo().post_create_display_list();
            glutPostRedisplay();
        }
        return;
    }
    else {		
		
        switch(key) {
			case 'q': exit(0);
			case '\033':
                console_visible = false;
				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_shading = !display_smooth_shading; 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 't':
				display_render_mode = "toon"; break;
			case 'g':
				display_render_mode = "glazed"; break;
			case 'a':
				display_render_mode = "ambient_occlusion"; break;
			case 'c':
				display_render_mode = "copper"; break;
			case 'C':
				display_render_mode = "curvature_lines"; break;
			case 'M':
				display_render_mode = "mean_curvature"; break;
			case 'G':
				display_render_mode = "gaussian_curvature"; break;
        }
		
        if(string(display_render_mode).substr(0,3) == "har")
            avo().harmonics_parse_key(key);
		
        if(key != '\033') avo().post_create_display_list();
    }
    
    glutPostRedisplay();
}
 
void init_glut(int argc, char** argv)
{  
    glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH|GLUT_ALPHA);
    glutInitWindowSize(WINX, WINY);
    glutInit(&argc, argv);
    glutCreateWindow("MeshEdit");
    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(1,1,1, 0.f);
    glColor4f(1.0f, 1.0f, 1.0f, 0.f);
    float material[4] = {1,1,1,1};
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, material);
    glEnable(GL_DEPTH_TEST);
	
    theConsole.reg_cmdN("harmonics.reset_shape", console_reset_shape, "");
    theConsole.reg_cmdN("harmonics.analyze", console_analyze, "");
    theConsole.reg_cmdN("harmonics.partial_reconstruct", console_partial_reconstruct,"");
    theConsole.reg_cmdN("simplify", console_simplify,"");
    theConsole.reg_cmdN("smooth.mean_curvature", console_mean_curvature_smooth,"");
    theConsole.reg_cmdN("smooth.laplacian", console_laplacian_smooth,"");
    theConsole.reg_cmdN("smooth.taubin", console_taubin_smooth,"");
    theConsole.reg_cmdN("smooth.fuzzy_vector_median", console_fvm_smooth,"");
	
    theConsole.reg_cmdN("optimize.valency", console_optimize_valency,"");
    theConsole.reg_cmdN("optimize.minimize_dihedral_angles", console_minimize_dihedral,"");
    theConsole.reg_cmdN("optimize.minimize_curvature", console_minimize_curvature,"");
    theConsole.reg_cmdN("optimize.maximize_min_angle", console_maximize_min_angle,"");
    theConsole.reg_cmdN("cleanup.close_holes", console_close_holes,"");
    theConsole.reg_cmdN("load_mesh", console_reload,"");
    theConsole.reg_cmdN("add_mesh", console_add_mesh,"");
	
    theConsole.reg_cmdN("cleanup.remove_caps", console_remove_caps,"");
    theConsole.reg_cmdN("cleanup.remove_needles", console_remove_needles,"");
    theConsole.reg_cmdN("triangulate", console_triangulate,"");
    theConsole.reg_cmdN("refine.split_edges", console_refine_edges,"");
    theConsole.reg_cmdN("refine.split_faces", console_refine_faces,"");
    theConsole.reg_cmdN("refine.catmull_clark", console_cc_subdivide,"");
    theConsole.reg_cmdN("refine.doo_sabin", console_doosabin_subdivide,"");
    theConsole.reg_cmdN("save_mesh", console_save,"");
    theConsole.reg_cmdN("noise.perturb_vertices", console_vertex_noise,"");
    theConsole.reg_cmdN("noise.perturb_vertices_perpendicular", console_perpendicular_vertex_noise,"");
    theConsole.reg_cmdN("noise.perturb_topology", console_noisy_flips,"");
 
    theConsole.reg_cmdN("remove_faces", console_remove_faces,"");
 
    theConsole.reg_cmdN("dual", console_dual,"");
    theConsole.reg_cmdN("flatten", console_flatten,"");
	
    theConsole.reg_cmdN("align", console_align,"");
	
    theConsole.reg_cmdN("undo", console_undo,"");
	
	theConsole.reg_cmdN("validity", console_valid,"");
	theConsole.reg_cmdN("info", console_info,"");
 
    theConsole.reg_cmdN("polarize", console_polarize ,"");
    
    active.reg(theConsole, "active_mesh", "The active mesh");
    display_render_mode.reg(theConsole, "display.render_mode", "Display render mode");
    display_smooth_shading.reg(theConsole, "display.smooth_shading", "1 for smooth shading 0 for flat");
    display_gamma.reg(theConsole, "display.gamma", "The gamma setting for the display");
 
}
 
int main(int argc, char** argv)
{
    ArgExtracter ae(argc, argv);
	
    init_glut(argc, argv);
    init_gl();
	
    theConsole.print("Welcome to MeshEdit");
    theConsole.newline();
    
    Harmonics::init(theConsole);
	
    if(argc>1){		
        vector<string> files;
		ae.get_all_args(files);
		for(int i=1;i<files.size();++i)
			get_vis_obj(i-1).reload(files[i]);
    }
    glutMainLoop();
    return 0;
}
 
 
 
 
 
 

Rev 596	Rev 600
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 <vector>`	14	`#include <vector>`
15	`#include <algorithm>`	15	`#include <algorithm>`
16		16
17	`#include <GL/glew.h>`	17	`#include <GL/glew.h>`
18		18
19	`#include <GLGraphics/Console.h>`	19	`#include <GLGraphics/Console.h>`
20		20
21		21
22	`#include <CGLA/eigensolution.h>`	22	`#include <CGLA/eigensolution.h>`
23	`#include <CGLA/Vec2d.h>`	23	`#include <CGLA/Vec2d.h>`
24	`#include <CGLA/Vec3d.h>`	24	`#include <CGLA/Vec3d.h>`
25	`#include <CGLA/Mat3x3d.h>`	25	`#include <CGLA/Mat3x3d.h>`
26	`#include <CGLA/Mat2x2d.h>`	26	`#include <CGLA/Mat2x2d.h>`
27	`#include <CGLA/Mat2x3d.h>`	27	`#include <CGLA/Mat2x3d.h>`
28		28
29	`#include <LinAlg/Matrix.h>`	29	`#include <LinAlg/Matrix.h>`
30	`#include <LinAlg/Vector.h>`	30	`#include <LinAlg/Vector.h>`
31	`#include <LinAlg/LapackFunc.h>`	31	`#include <LinAlg/LapackFunc.h>`
32		32
33	`#include <GLGraphics/gel_glut.h>`	33	`#include <GLGraphics/gel_glut.h>`
34		34
35	`#include <HMesh/Manifold.h>`	35	`#include <HMesh/Manifold.h>`
36	`#include <HMesh/AttributeVector.h>`	36	`#include <HMesh/AttributeVector.h>`
37	`#include <HMesh/mesh_optimization.h>`	37	`#include <HMesh/mesh_optimization.h>`
38	`#include <HMesh/curvature.h>`	38	`#include <HMesh/curvature.h>`
39	`#include <HMesh/triangulate.h>`	39	`#include <HMesh/triangulate.h>`
40	`#include <HMesh/flatten.h>`	40	`#include <HMesh/flatten.h>`
41	`#include <HMesh/dual.h>`	41	`#include <HMesh/dual.h>`
42	`#include <HMesh/load.h>`	42	`#include <HMesh/load.h>`
43	`#include <HMesh/quadric_simplify.h>`	43	`#include <HMesh/quadric_simplify.h>`
44	`#include <HMesh/smooth.h>`	44	`#include <HMesh/smooth.h>`
45	`#include <HMesh/x3d_save.h>`	45	`#include <HMesh/x3d_save.h>`
46	`#include <HMesh/obj_save.h>`	46	`#include <HMesh/obj_save.h>`
47	`#include <HMesh/off_save.h>`	47	`#include <HMesh/off_save.h>`
48	`#include <HMesh/mesh_optimization.h>`	48	`#include <HMesh/mesh_optimization.h>`
49	`#include <HMesh/triangulate.h>`	49	`#include <HMesh/triangulate.h>`
50	`#include <HMesh/close_holes.h>`	50	`#include <HMesh/cleanup.h>`
51	`#include <HMesh/caps_and_needles.h>`	51	`#include <HMesh/cleanup.h>`
52	`#include <HMesh/refine_edges.h>`	52	`#include <HMesh/refine_edges.h>`
53	`#include <HMesh/subdivision.h>`	53	`#include <HMesh/subdivision.h>`
54		54
55	`#include <Util/Timer.h>`	55	`#include <Util/Timer.h>`
56	`#include <Util/ArgExtracter.h>`	56	`#include <Util/ArgExtracter.h>`
57		57
58	`#include "polarize.h"`	58	`#include "polarize.h"`
59	`#include "harmonics.h"`	59	`#include "harmonics.h"`
60	`#include "VisObj.h"`	60	`#include "VisObj.h"`
61		61
62	`using namespace std;`	62	`using namespace std;`
63	`using namespace HMesh;`	63	`using namespace HMesh;`
64	`using namespace Geometry;`	64	`using namespace Geometry;`
65	`using namespace GLGraphics;`	65	`using namespace GLGraphics;`
66	`using namespace CGLA;`	66	`using namespace CGLA;`
67	`using namespace Util;`	67	`using namespace Util;`
68	`using namespace LinAlg;`	68	`using namespace LinAlg;`
69		69
70	`// Single global instance so glut can get access`	70	`// Single global instance so glut can get access`
71	`Console theConsole;`	71	`Console theConsole;`
72	`bool console_visible = false;`	72	`bool console_visible = false;`
73		73
74		74
75	`inline VisObj& get_vis_obj(int i)`	75	`inline VisObj& get_vis_obj(int i)`
76	`{`	76	`{`
77	`static VisObj vo[9];`	77	`static VisObj vo[9];`
78	`return vo[i];`	78	`return vo[i];`
79	`}`	79	`}`
80		80
81	`Console::variable<int> active(0);`	81	`Console::variable<int> active(0);`
82		82
83	`inline VisObj& avo()`	83	`inline VisObj& avo()`
84	`{`	84	`{`
85	`return get_vis_obj(active);`	85	`return get_vis_obj(active);`
86	`}`	86	`}`
87		87
88	`inline Manifold& active_mesh()`	88	`inline Manifold& active_mesh()`
89	`{`	89	`{`
90	`return avo().mesh();`	90	`return avo().mesh();`
91	`}`	91	`}`
92		92
93	`inline GLViewController& active_view_control()`	93	`inline GLViewController& active_view_control()`
94	`{`	94	`{`
95	`return avo().view_control();`	95	`return avo().view_control();`
96	`}`	96	`}`
97		97
98		98
99		99
100	`////////////////////////////////////////////////////////////////////////////////`	100	`////////////////////////////////////////////////////////////////////////////////`
101	`bool MyConsoleHelp(const std::vector<std::string> & args)`	101	`bool MyConsoleHelp(const std::vector<std::string> & args)`
102	`{`	102	`{`
103	`theConsole.printf("");`	103	`theConsole.printf("");`
104	`theConsole.printf("----------------- HELP -----------------");`	104	`theConsole.printf("----------------- HELP -----------------");`
105	`theConsole.printf("Press ESC key to open and close console");`	105	`theConsole.printf("Press ESC key to open and close console");`
106	`theConsole.printf("Press TAB to see the available commands and functions");`	106	`theConsole.printf("Press TAB to see the available commands and functions");`
107	`theConsole.printf("Functions are shown in green and variables in yellow");`	107	`theConsole.printf("Functions are shown in green and variables in yellow");`
108	`theConsole.printf("Setting a value: [command] = value");`	108	`theConsole.printf("Setting a value: [command] = value");`
109	`theConsole.printf("Getting a value: [command]");`	109	`theConsole.printf("Getting a value: [command]");`
110	`theConsole.printf("Functions: [function] [arg1] [arg2] ...");`	110	`theConsole.printf("Functions: [function] [arg1] [arg2] ...");`
111	`theConsole.printf("Entering arg1=? or arg1=help will give a description.");`	111	`theConsole.printf("Entering arg1=? or arg1=help will give a description.");`
112	`theConsole.printf("History: Up and Down arrow keys move through history.");`	112	`theConsole.printf("History: Up and Down arrow keys move through history.");`
113	`theConsole.printf("Tab Completion: TAB does tab completion and makes suggestions.");`	113	`theConsole.printf("Tab Completion: TAB does tab completion and makes suggestions.");`
114	`theConsole.printf("");`	114	`theConsole.printf("");`
115	`theConsole.printf("Keyboard commands (when console is not active):");`	115	`theConsole.printf("Keyboard commands (when console is not active):");`
116	`theConsole.printf("w : switch to display.render_mode = wireframe");`	116	`theConsole.printf("w : switch to display.render_mode = wireframe");`
117	`theConsole.printf("i : switch to display.render_mode = isophotes");`	117	`theConsole.printf("i : switch to display.render_mode = isophotes");`
118	`theConsole.printf("r : switch to display.render_mode = reflection");`	118	`theConsole.printf("r : switch to display.render_mode = reflection");`
119	`theConsole.printf("m : switch to display.render_mode = metallic");`	119	`theConsole.printf("m : switch to display.render_mode = metallic");`
120	`theConsole.printf("g : switch to display.render_mode = glazed");`	120	`theConsole.printf("g : switch to display.render_mode = glazed");`
121	`theConsole.printf("n : switch to display.render_mode = normal");`	121	`theConsole.printf("n : switch to display.render_mode = normal");`
122	`theConsole.printf("h : switch to display.render_mode = harmonics");`	122	`theConsole.printf("h : switch to display.render_mode = harmonics");`
123	`theConsole.printf("f : toggle smooth/flat shading");`	123	`theConsole.printf("f : toggle smooth/flat shading");`
124	`theConsole.printf("1-9 : switch between active meshes.");`	124	`theConsole.printf("1-9 : switch between active meshes.");`
125	`theConsole.printf("d : (display.render_mode = harmonics) diffuse light on and off");`	125	`theConsole.printf("d : (display.render_mode = harmonics) diffuse light on and off");`
126	`theConsole.printf("h : (display.render_mode = harmonics) highlight on and off ");`	126	`theConsole.printf("h : (display.render_mode = harmonics) highlight on and off ");`
127	`theConsole.printf("+/- : (display.render_mode = harmonics) which eigenvector to show");`	127	`theConsole.printf("+/- : (display.render_mode = harmonics) which eigenvector to show");`
128	`theConsole.printf("q : quit program");`	128	`theConsole.printf("q : quit program");`
129	`theConsole.printf("ESC : open console");`	129	`theConsole.printf("ESC : open console");`
130	`theConsole.printf("");`	130	`theConsole.printf("");`
131	`theConsole.printf("Mouse: Left button rotates, middle zooms, right pans");`	131	`theConsole.printf("Mouse: Left button rotates, middle zooms, right pans");`
132	`theConsole.printf("----------------- HELP -----------------");`	132	`theConsole.printf("----------------- HELP -----------------");`
133	`theConsole.printf("");`	133	`theConsole.printf("");`
134	`return true;`	134	`return true;`
135	`}`	135	`}`
136		136
137	`bool wantshelp(const std::vector<std::string> & args)`	137	`bool wantshelp(const std::vector<std::string> & args)`
138	`{`	138	`{`
139	`if(args.size() == 0)`	139	`if(args.size() == 0)`
140	`return false;`	140	`return false;`
141		141
142	`string str = args[0];`	142	`string str = args[0];`
143		143
144	`if(str=="help" \|\| str=="HELP" \|\| str=="Help" \|\| str=="?")`	144	`if(str=="help" \|\| str=="HELP" \|\| str=="Help" \|\| str=="?")`
145	`return true;`	145	`return true;`
146		146
147	`return false;`	147	`return false;`
148	`}`	148	`}`
149		149
150	`/// Function that aligns two meshes.`	150	`/// Function that aligns two meshes.`
151	`void console_align(const std::vector<std::string> & args)`	151	`void console_align(const std::vector<std::string> & args)`
152	`{`	152	`{`
153	`if(wantshelp(args)) {`	153	`if(wantshelp(args)) {`
154	`theConsole.printf("usage: align <dest> <src>");`	154	`theConsole.printf("usage: align <dest> <src>");`
155	`theConsole.printf("This function aligns dest mesh with src");`	155	`theConsole.printf("This function aligns dest mesh with src");`
156	`theConsole.printf("In practice the GLViewController of src is copied to dst.");`	156	`theConsole.printf("In practice the GLViewController of src is copied to dst.");`
157	`theConsole.printf("both arguments are mandatory and must be numbers between 1 and 9.");`	157	`theConsole.printf("both arguments are mandatory and must be numbers between 1 and 9.");`
158	`theConsole.printf("Note that results might be unexpexted if the meshes are not on the same scale");`	158	`theConsole.printf("Note that results might be unexpexted if the meshes are not on the same scale");`
159	`}`	159	`}`
160		160
161	`int dest = 0;`	161	`int dest = 0;`
162		162
163	`if(args.size()>0){`	163	`if(args.size()>0){`
164	`istringstream a0(args[0]);`	164	`istringstream a0(args[0]);`
165	`a0 >> dest;`	165	`a0 >> dest;`
166	`--dest;`	166	`--dest;`
167		167
168	`if(dest <0 \|\| dest>8)`	168	`if(dest <0 \|\| dest>8)`
169	`{`	169	`{`
170	`theConsole.printf("dest mesh out of range (1-9)");`	170	`theConsole.printf("dest mesh out of range (1-9)");`
171	`return;`	171	`return;`
172	`}`	172	`}`
173	`}`	173	`}`
174	`else`	174	`else`
175	`{`	175	`{`
176	`theConsole.printf("neither source nor destination mesh?!");`	176	`theConsole.printf("neither source nor destination mesh?!");`
177	`return;`	177	`return;`
178	`}`	178	`}`
179		179
180	`int src = 0;`	180	`int src = 0;`
181	`if(args.size()>1){`	181	`if(args.size()>1){`
182	`istringstream a1(args[1]);`	182	`istringstream a1(args[1]);`
183	`a1 >> src;`	183	`a1 >> src;`
184	`--src;`	184	`--src;`
185		185
186	`if(src <0 \|\| src>8)`	186	`if(src <0 \|\| src>8)`
187	`{`	187	`{`
188	`theConsole.printf("src mesh out of range (1-9)");`	188	`theConsole.printf("src mesh out of range (1-9)");`
189	`return;`	189	`return;`
190	`}`	190	`}`
191	`}`	191	`}`
192	`else`	192	`else`
193	`{`	193	`{`
194	`theConsole.printf("no src mesh?");`	194	`theConsole.printf("no src mesh?");`
195	`return;`	195	`return;`
196	`}`	196	`}`
197	`get_vis_obj(dest).view_control() = get_vis_obj(src).view_control();`	197	`get_vis_obj(dest).view_control() = get_vis_obj(src).view_control();`
198	`}`	198	`}`
199		199
200	`void console_polarize(const std::vector<std::string> & args)`	200	`void console_polarize(const std::vector<std::string> & args)`
201	`{`	201	`{`
202	`if(wantshelp(args)) {`	202	`if(wantshelp(args)) {`
203	`theConsole.printf("usage: polarize");`	203	`theConsole.printf("usage: polarize");`
204	`return;`	204	`return;`
205	`}`	205	`}`
206	`int divisions = 10;`	206	`int divisions = 10;`
207		207
208	`if(args.size() > 0){`	208	`if(args.size() > 0){`
209	`istringstream a0(args[0]);`	209	`istringstream a0(args[0]);`
210	`a0 >> divisions;`	210	`a0 >> divisions;`
211	`}`	211	`}`
212		212
213	`avo().save_old();`	213	`avo().save_old();`
214		214
215	`double vmin, vmax;`	215	`double vmin, vmax;`
216	`VertexAttributeVector<double> fun;`	216	`VertexAttributeVector<double> fun;`
217	`VertexAttributeVector<double> par;`	217	`VertexAttributeVector<double> par;`
218	`make_height_fun(active_mesh(), fun, vmin, vmax);`	218	`make_height_fun(active_mesh(), fun, vmin, vmax);`
219	`polarize_mesh(active_mesh(), fun, vmin, vmax, divisions, par);`	219	`polarize_mesh(active_mesh(), fun, vmin, vmax, divisions, par);`
220	`}`	220	`}`
221		221
222	`void console_flatten(const std::vector<std::string> & args)`	222	`void console_flatten(const std::vector<std::string> & args)`
223	`{`	223	`{`
224	`if(wantshelp(args)) {`	224	`if(wantshelp(args)) {`
225	`theConsole.printf("usage: flatten <floater\|harmonic\|barycentric>");`	225	`theConsole.printf("usage: flatten <floater\|harmonic\|barycentric>");`
226	`theConsole.printf("This function flattens a meshs with a simple boundary. It is mostly for showing mesh");`	226	`theConsole.printf("This function flattens a meshs with a simple boundary. It is mostly for showing mesh");`
227	`theConsole.printf("parametrization methods. The current mesh MUST have a SINGLE boundary loop");`	227	`theConsole.printf("parametrization methods. The current mesh MUST have a SINGLE boundary loop");`
228	`theConsole.printf("This loop is mapped to the unit circle in a regular fashion (equal angle intervals).");`	228	`theConsole.printf("This loop is mapped to the unit circle in a regular fashion (equal angle intervals).");`
229	`theConsole.printf("All non boundary vertices are placed at the origin. Then the system is relaxed iteratively");`	229	`theConsole.printf("All non boundary vertices are placed at the origin. Then the system is relaxed iteratively");`
230	`theConsole.printf("using the weight scheme given as argument.");`	230	`theConsole.printf("using the weight scheme given as argument.");`
231	`return;`	231	`return;`
232	`}`	232	`}`
233		233
234	`avo().save_old();`	234	`avo().save_old();`
235		235
236	`WeightScheme ws = BARYCENTRIC_W;`	236	`WeightScheme ws = BARYCENTRIC_W;`
237	`if(args.size()>0){`	237	`if(args.size()>0){`
238	`if(args[0] == "floater")`	238	`if(args[0] == "floater")`
239	`ws = FLOATER_W;`	239	`ws = FLOATER_W;`
240	`else if(args[0] == "harmonic")`	240	`else if(args[0] == "harmonic")`
241	`ws = HARMONIC_W;`	241	`ws = HARMONIC_W;`
242	`else if(args[0] == "lscm")`	242	`else if(args[0] == "lscm")`
243	`ws = LSCM_W;`	243	`ws = LSCM_W;`
244	`}`	244	`}`
245	`else`	245	`else`
246	`return;`	246	`return;`
247		247
248	`flatten(active_mesh(), ws);`	248	`flatten(active_mesh(), ws);`
249		249
250	`return;`	250	`return;`
251	`}`	251	`}`
252		252
253	`void console_save(const std::vector<std::string> & args)`	253	`void console_save(const std::vector<std::string> & args)`
254	`{`	254	`{`
255	`if(wantshelp(args)) {`	255	`if(wantshelp(args)) {`
256	`theConsole.printf("usage: save <name.x3d\|name.obj> ");`	256	`theConsole.printf("usage: save <name.x3d\|name.obj> ");`
257		257
258	`return;`	258	`return;`
259	`}`	259	`}`
260	`const string& file_name = args[0];`	260	`const string& file_name = args[0];`
261	`if(args.size() == 1){`	261	`if(args.size() == 1){`
262	`if(file_name.substr(file_name.length()-4,file_name.length())==".obj"){`	262	`if(file_name.substr(file_name.length()-4,file_name.length())==".obj"){`
263	`obj_save(file_name, active_mesh());`	263	`obj_save(file_name, active_mesh());`
264		264
265	`return;`	265	`return;`
266	`}`	266	`}`
267	`else if(file_name.substr(file_name.length()-4,file_name.length())==".off"){`	267	`else if(file_name.substr(file_name.length()-4,file_name.length())==".off"){`
268	`off_save(file_name, active_mesh());`	268	`off_save(file_name, active_mesh());`
269		269
270	`return;`	270	`return;`
271	`}`	271	`}`
272	`else if(file_name.substr(file_name.length()-4,file_name.length())==".x3d"){`	272	`else if(file_name.substr(file_name.length()-4,file_name.length())==".x3d"){`
273	`x3d_save(file_name, active_mesh());`	273	`x3d_save(file_name, active_mesh());`
274		274
275	`return;`	275	`return;`
276	`}`	276	`}`
277	`theConsole.printf("unknown format");`	277	`theConsole.printf("unknown format");`
278	`return;`	278	`return;`
279	`}`	279	`}`
280	`theConsole.printf("usage: save <name.x3d\|name.obj> ");`	280	`theConsole.printf("usage: save <name.x3d\|name.obj> ");`
281	`}`	281	`}`
282		282
283		283
284	`void console_refine_edges(const std::vector<std::string> & args)`	284	`void console_refine_edges(const std::vector<std::string> & args)`
285	`{`	285	`{`
286	`if(wantshelp(args)) {`	286	`if(wantshelp(args)) {`
287	`theConsole.printf("usage: refine.split_edges <length>");`	287	`theConsole.printf("usage: refine.split_edges <length>");`
288	`theConsole.printf("splits edges longer than <length>; default is 0.5 times average length");`	288	`theConsole.printf("splits edges longer than <length>; default is 0.5 times average length");`
289	`return;`	289	`return;`
290	`}`	290	`}`
291		291
292	`avo().save_old();`	292	`avo().save_old();`
293		293
294	`float thresh = 0.5f;`	294	`float thresh = 0.5f;`
295		295
296	`if(args.size() > 0){`	296	`if(args.size() > 0){`
297	`istringstream a0(args[0]);`	297	`istringstream a0(args[0]);`
298	`a0 >> thresh;`	298	`a0 >> thresh;`
299	`}`	299	`}`
300		300
301	`float avg_length = average_edge_length(active_mesh());`	301	`float avg_length = average_edge_length(active_mesh());`
302		302
303	`refine_edges(active_mesh(), thresh * avg_length);`	303	`refine_edges(active_mesh(), thresh * avg_length);`
304		304
305	`return;`	305	`return;`
306		306
307	`}`	307	`}`
308		308
309	`void console_refine_faces(const std::vector<std::string> & args)`	309	`void console_refine_faces(const std::vector<std::string> & args)`
310	`{`	310	`{`
311	`if(wantshelp(args)) {`	311	`if(wantshelp(args)) {`
312	`theConsole.printf("usage: refine.split_faces ");`	312	`theConsole.printf("usage: refine.split_faces ");`
313	`theConsole.printf("usage: Takes no arguments. Inserts a vertex at the centre of each face.");`	313	`theConsole.printf("usage: Takes no arguments. Inserts a vertex at the centre of each face.");`
314		314
315	`return;`	315	`return;`
316	`}`	316	`}`
317	`avo().save_old();`	317	`avo().save_old();`
318		318
319	`triangulate_by_vertex_face_split(active_mesh());`	319	`triangulate_by_vertex_face_split(active_mesh());`
320		320
321	`return;`	321	`return;`
322		322
323	`}`	323	`}`
324		324
325	`void console_cc_subdivide(const std::vector<std::string> & args)`	325	`void console_cc_subdivide(const std::vector<std::string> & args)`
326	`{`	326	`{`
327	`if(wantshelp(args)) {`	327	`if(wantshelp(args)) {`
328	`theConsole.printf("usage: refine.catmull_clark ");`	328	`theConsole.printf("usage: refine.catmull_clark ");`
329	`theConsole.printf("Does one step of Catmull-Clark subdivision");`	329	`theConsole.printf("Does one step of Catmull-Clark subdivision");`
330		330
331	`return;`	331	`return;`
332	`}`	332	`}`
333	`avo().save_old();`	333	`avo().save_old();`
334		334
335	`cc_split(active_mesh(),active_mesh());`	335	`cc_split(active_mesh(),active_mesh());`
336	`cc_smooth(active_mesh());`	336	`cc_smooth(active_mesh());`
337		337
338	`return;`	338	`return;`
339	`}`	339	`}`
340		340
341	`void console_doosabin_subdivide(const std::vector<std::string> & args)`	341	`void console_doosabin_subdivide(const std::vector<std::string> & args)`
342	`{`	342	`{`
343	`if(wantshelp(args)) {`	343	`if(wantshelp(args)) {`
344	`theConsole.printf("usage: refine.doo_sabin ");`	344	`theConsole.printf("usage: refine.doo_sabin ");`
345	`theConsole.printf("Does one step of Doo-Sabin Subdivision");`	345	`theConsole.printf("Does one step of Doo-Sabin Subdivision");`
346		346
347	`return;`	347	`return;`
348	`}`	348	`}`
349	`avo().save_old();`	349	`avo().save_old();`
350		350
351	`cc_split(active_mesh(),active_mesh());`	351	`cc_split(active_mesh(),active_mesh());`
352	`dual(active_mesh());`	352	`dual(active_mesh());`
353		353
354	`return;`	354	`return;`
355	`}`	355	`}`
356		356
357	`void console_dual(const std::vector<std::string> & args)`	357	`void console_dual(const std::vector<std::string> & args)`
358	`{`	358	`{`
359	`if(wantshelp(args))`	359	`if(wantshelp(args))`
360	`{`	360	`{`
361	`theConsole.printf("usage: dual ");`	361	`theConsole.printf("usage: dual ");`
362	`theConsole.printf("Produces the dual by converting each face to a vertex placed at the barycenter.");`	362	`theConsole.printf("Produces the dual by converting each face to a vertex placed at the barycenter.");`
363	`return;`	363	`return;`
364	`}`	364	`}`
365	`avo().save_old();`	365	`avo().save_old();`
366		366
367	`dual(active_mesh());`	367	`dual(active_mesh());`
368		368
369	`return;`	369	`return;`
370	`}`	370	`}`
371		371
372		372
373	`void console_minimize_curvature(const std::vector<std::string> & args)`	373	`void console_minimize_curvature(const std::vector<std::string> & args)`
374	`{`	374	`{`
375	`if(wantshelp(args))`	375	`if(wantshelp(args))`
376	`{`	376	`{`
377	`theConsole.printf("usage: optimize.minimize_curvature <anneal>");`	377	`theConsole.printf("usage: optimize.minimize_curvature <anneal>");`
378	`theConsole.printf("Flip edges to minimize mean curvature.");`	378	`theConsole.printf("Flip edges to minimize mean curvature.");`
379	`theConsole.printf("If anneal is true, simulated annealing (slow) is used rather than a greedy scheme");`	379	`theConsole.printf("If anneal is true, simulated annealing (slow) is used rather than a greedy scheme");`
380	`return;`	380	`return;`
381	`}`	381	`}`
382	`avo().save_old();`	382	`avo().save_old();`
383		383
384	`bool anneal=false;`	384	`bool anneal=false;`
385	`if(args.size() > 0)`	385	`if(args.size() > 0)`
386	`{`	386	`{`
387	`istringstream a0(args[0]);`	387	`istringstream a0(args[0]);`
388	`a0 >> anneal;`	388	`a0 >> anneal;`
389	`}`	389	`}`
390		390
391	`minimize_curvature(active_mesh(), anneal);`	391	`minimize_curvature(active_mesh(), anneal);`
392	`avo().post_create_display_list();`	392	`avo().post_create_display_list();`
393	`return;`	393	`return;`
394	`}`	394	`}`
395		395
396	`void console_minimize_dihedral(const std::vector<std::string> & args)`	396	`void console_minimize_dihedral(const std::vector<std::string> & args)`
397	`{`	397	`{`
398	`if(wantshelp(args))`	398	`if(wantshelp(args))`
399	`{`	399	`{`
400	`theConsole.printf("usage: optimize.minimize_dihedral <iter> <anneal> <use_alpha> <gamma> ");`	400	`theConsole.printf("usage: optimize.minimize_dihedral <iter> <anneal> <use_alpha> <gamma> ");`
401	`theConsole.printf("Flip edges to minimize dihedral angles.");`	401	`theConsole.printf("Flip edges to minimize dihedral angles.");`
402	`theConsole.printf("Iter is the max number of iterations. anneal tells us whether to use ");`	402	`theConsole.printf("Iter is the max number of iterations. anneal tells us whether to use ");`
403	`theConsole.printf("simulated annealing and not greedy optimization. use_alpha (default=true) ");`	403	`theConsole.printf("simulated annealing and not greedy optimization. use_alpha (default=true) ");`
404	`theConsole.printf("means to use angle and not cosine of anglegamma (default=4) is the power ");`	404	`theConsole.printf("means to use angle and not cosine of anglegamma (default=4) is the power ");`
405	`theConsole.printf("to which we raise the dihedral angle");`	405	`theConsole.printf("to which we raise the dihedral angle");`
406	`return;`	406	`return;`
407	`}`	407	`}`
408	`avo().save_old();`	408	`avo().save_old();`
409		409
410	`int iter = 1000;`	410	`int iter = 1000;`
411	`if(args.size() > 0)`	411	`if(args.size() > 0)`
412	`{`	412	`{`
413	`istringstream a0(args[0]);`	413	`istringstream a0(args[0]);`
414	`a0 >> iter;`	414	`a0 >> iter;`
415	`}`	415	`}`
416		416
417	`bool anneal = false;`	417	`bool anneal = false;`
418	`if(args.size() > 1)`	418	`if(args.size() > 1)`
419	`{`	419	`{`
420	`istringstream a0(args[1]);`	420	`istringstream a0(args[1]);`
421	`a0 >> anneal;`	421	`a0 >> anneal;`
422	`}`	422	`}`
423		423
424	`bool use_alpha = true;`	424	`bool use_alpha = true;`
425	`if(args.size() > 2)`	425	`if(args.size() > 2)`
426	`{`	426	`{`
427	`istringstream a0(args[2]);`	427	`istringstream a0(args[2]);`
428	`a0 >> use_alpha;`	428	`a0 >> use_alpha;`
429	`}`	429	`}`
430		430
431	`float gamma = 4.0f;`	431	`float gamma = 4.0f;`
432	`if(args.size() > 3)`	432	`if(args.size() > 3)`
433	`{`	433	`{`
434	`istringstream a0(args[3]);`	434	`istringstream a0(args[3]);`
435	`a0 >> gamma;`	435	`a0 >> gamma;`
436	`}`	436	`}`
437		437
438		438
439	`minimize_dihedral_angle(active_mesh(), iter, anneal, use_alpha, gamma);`	439	`minimize_dihedral_angle(active_mesh(), iter, anneal, use_alpha, gamma);`
440	`return;`	440	`return;`
441	`}`	441	`}`
442		442
443	`void console_maximize_min_angle(const std::vector<std::string> & args)`	443	`void console_maximize_min_angle(const std::vector<std::string> & args)`
444	`{`	444	`{`
445	`if(wantshelp(args))`	445	`if(wantshelp(args))`
446	`{`	446	`{`
447	`theConsole.printf("usage: optimize.maximize_min_angle <thresh> <anneal>");`	447	`theConsole.printf("usage: optimize.maximize_min_angle <thresh> <anneal>");`
448	`theConsole.printf("Flip edges to maximize min angle - to make mesh more Delaunay.");`	448	`theConsole.printf("Flip edges to maximize min angle - to make mesh more Delaunay.");`
449	`theConsole.printf("If the dot product of the normals between adjacent faces < thresh");`	449	`theConsole.printf("If the dot product of the normals between adjacent faces < thresh");`
450	`theConsole.printf("no flip will be made. anneal selects simulated annealing rather ");`	450	`theConsole.printf("no flip will be made. anneal selects simulated annealing rather ");`
451	`theConsole.printf("nthan greedy optimization.");`	451	`theConsole.printf("nthan greedy optimization.");`
452	`return;`	452	`return;`
453	`}`	453	`}`
454	`avo().save_old();`	454	`avo().save_old();`
455		455
456	`float thresh = 0.0f;`	456	`float thresh = 0.0f;`
457	`if(args.size() > 0)`	457	`if(args.size() > 0)`
458	`{`	458	`{`
459	`istringstream a0(args[0]);`	459	`istringstream a0(args[0]);`
460	`a0 >> thresh;`	460	`a0 >> thresh;`
461	`}`	461	`}`
462	`bool anneal = false;`	462	`bool anneal = false;`
463	`if(args.size() > 1)`	463	`if(args.size() > 1)`
464	`{`	464	`{`
465	`istringstream a0(args[1]);`	465	`istringstream a0(args[1]);`
466	`a0 >> anneal;`	466	`a0 >> anneal;`
467	`}`	467	`}`
468	`maximize_min_angle(active_mesh(),thresh,anneal);`	468	`maximize_min_angle(active_mesh(),thresh,anneal);`
469	`return;`	469	`return;`
470	`}`	470	`}`
471		471
472		472
473	`void console_optimize_valency(const std::vector<std::string> & args)`	473	`void console_optimize_valency(const std::vector<std::string> & args)`
474	`{`	474	`{`
475	`if(wantshelp(args))`	475	`if(wantshelp(args))`
476	`{`	476	`{`
477	`theConsole.printf("usage: optimize.valency <anneal> ");`	477	`theConsole.printf("usage: optimize.valency <anneal> ");`
478	`theConsole.printf("Optimizes valency for triangle meshes. Anneal selects simulated annealing rather than greedy optim.");`	478	`theConsole.printf("Optimizes valency for triangle meshes. Anneal selects simulated annealing rather than greedy optim.");`
479	`return;`	479	`return;`
480	`}`	480	`}`
481	`avo().save_old();`	481	`avo().save_old();`
482		482
483	`bool anneal = false;`	483	`bool anneal = false;`
484	`if(args.size() > 0)`	484	`if(args.size() > 0)`
485	`{`	485	`{`
486	`istringstream a0(args[0]);`	486	`istringstream a0(args[0]);`
487	`a0 >> anneal;`	487	`a0 >> anneal;`
488	`}`	488	`}`
489	`optimize_valency(active_mesh(), anneal);`	489	`optimize_valency(active_mesh(), anneal);`
490	`return;`	490	`return;`
491	`}`	491	`}`
492		492
493	`void console_analyze(const std::vector<std::string> & args)`	493	`void console_analyze(const std::vector<std::string> & args)`
494	`{`	494	`{`
495	`if(wantshelp(args))`	495	`if(wantshelp(args))`
496	`{`	496	`{`
497	`theConsole.printf("usage: harmonics.analyze");`	497	`theConsole.printf("usage: harmonics.analyze");`
498	`theConsole.printf("Creates the Laplace Beltrami operator for the mesh and finds all eigensolutions.");`	498	`theConsole.printf("Creates the Laplace Beltrami operator for the mesh and finds all eigensolutions.");`
499	`theConsole.printf("It also projects the vertices onto the eigenvectors - thus transforming the mesh");`	499	`theConsole.printf("It also projects the vertices onto the eigenvectors - thus transforming the mesh");`
500	`theConsole.printf("to this basis.");`	500	`theConsole.printf("to this basis.");`

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/meshedit.cpp – Rev 596 → 600