WebSVN – gelsvn – Diff – /branches/cpp11-devel/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 <CGLA/Mat4x4d.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 = 50;
	
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> divisions;
    }
 
    double t=1;
	
    if(args.size() > 1){
        istringstream a0(args[1]);
        a0 >> t;
    }
 
    avo().save_old();
 
	double vmin, vmax;
    VertexAttributeVector<double> fun;
    VertexAttributeVector<Vec2d> par;
    make_adf_fun(active_mesh(), t, fun, vmin, vmax);
    polarize_mesh(active_mesh(), fun, vmin, vmax, divisions, par);
}
 
void console_simplify_polar(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: simplify.polar <frac>");
        return;
    }
    double frac = 0.9;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> frac;
    }
    
    
    avo().save_old();
    
    simplify_polar_mesh(avo().mesh(), frac);
}
 
void console_refit_polar(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: simplify.polar <mesh 1> <mesh 2> <iter>");
        return;
    }
    int m1=1;
    int m2=2;
    int iter=1;
    int dim = 64;
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> m1;
    }
    if(args.size() > 1){
        istringstream a0(args[1]);
        a0 >> m2;
    }
    if(args.size() > 2){
        istringstream a0(args[2]);
        a0 >> iter;
    }
 
    if(args.size() > 3){
        istringstream a0(args[3]);
        a0 >> dim;
    }
 
    
    
    avo().save_old();
    
    smooth_and_refit(get_vis_obj(m1-1).mesh() , get_vis_obj(m2-1).mesh(), iter, dim);
}
 
 
void transform_mesh(Manifold& mani, const Mat4x4d& m)
{
    for(VertexIDIterator vid = mani.vertices_begin(); vid != mani.vertices_end(); ++vid)
        mani.pos(*vid) = m.mul_3D_point(mani.pos(*vid));
}
 
void console_scale(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: scale sx sy sz");
        return;
    }
    
    Vec3d s;
 
    if(args.size() > 0){
        istringstream a0(args[0]);
        a0 >> s[0];
    }
    if(args.size() > 1){
        istringstream a0(args[0]);
        a0 >> s[1];
    }
    if(args.size() > 2){
        istringstream a0(args[0]);
        a0 >> s[2];
    }
    
    avo().save_old();
    transform_mesh(avo().mesh(),scaling_Mat4x4d(s));
    avo().refit();
}
 
 
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: subdivide.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_loop_subdivide(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: subdivide.loop");
        theConsole.printf("Does one step of Loop subdivision");
		
        return;
    }
    avo().save_old();
	
    loop_split(active_mesh(),active_mesh());
    loop_smooth(active_mesh());
	
    return;
}
 
void console_root3_subdivide(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: subdivide.root3");
        theConsole.printf("Does one step of sqrt(3) subdivision");
		
        return;
    }
    avo().save_old();
	
    root3_subdivide(active_mesh(),active_mesh());
	
    return;
}
 
 
void console_doosabin_subdivide(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: subdivide.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_butterfly_subdivide(const std::vector<std::string> & args)
{
    if(wantshelp(args)) {
        theConsole.printf("usage: subdivide.butterfly ");
        theConsole.printf("Does one step of Modified Butterfly Subdivision");
		
        return;
    }
    avo().save_old();
	
    butterfly_subdivide(active_mesh(),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);
            v -= Vec3d(0.5);
            v *= 2.0;
        }
        while(sqr_length(v) > 1.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;
    }
    Util::Timer tim;
    tim.start();
    /// Simple laplacian smoothing with an optional weight.
    laplacian_smooth(active_mesh(), t, iter);
    cout << "It took "<< tim.get_secs();
    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_anisotropic_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.
    anisotropic_smooth(active_mesh(),  iter, FVM_NORMAL_SMOOTH);
	
    return;
}
 
void console_bilateral_anisotropic_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;
    }
    
    anisotropic_smooth(active_mesh(),  iter, BILATERAL_NORMAL_SMOOTH);
	
    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();
    //avo().refit();
    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(true);
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(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_CULL_FACE);
    glCullFace(GL_BACK);
    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_anisotropic", console_fvm_anisotropic_smooth ,"");
    theConsole.reg_cmdN("smooth.bilateral_anisotropic", console_bilateral_anisotropic_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("subdivide.catmull_clark", console_cc_subdivide,"");
    theConsole.reg_cmdN("subdivide.loop", console_loop_subdivide,"");
    theConsole.reg_cmdN("subdivide.root3", console_root3_subdivide,"");
    theConsole.reg_cmdN("subdivide.doo_sabin", console_doosabin_subdivide,"");
    theConsole.reg_cmdN("subdivide.butterfly", console_butterfly_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 ,"");
    theConsole.reg_cmdN("polar.simplify", console_simplify_polar ,"");
    theConsole.reg_cmdN("polar.refit", console_refit_polar ,"");
    
    theConsole.reg_cmdN("transform.scale", console_scale, "Scale mesh");
    
    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();
   
    if(argc>1){		
        vector<string> files;
		ae.get_all_args(files);
		for(size_t i=1;i<files.size();++i)
			get_vis_obj(i-1).reload(files[i]);
    }
    glutMainLoop();
    return 0;
}
 
 
 
 
 
 

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

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/apps/MeshEdit/meshedit.cpp @ 644 – Rev 631 → 643