WebSVN – gelsvn – Diff – /branches/cpp11-devel/apps/MeshEdit/meshedit.cpp

     avo().save_old();
 	double vmin, vmax;
     VertexAttributeVector<double> fun;
-    VertexAttributeVector<double> par;
+    VertexAttributeVector<Vec2d> par;
     make_height_fun(active_mesh(), fun, vmin, vmax);
     polarize_mesh(active_mesh(), fun, vmin, vmax, divisions, par);
+}
 void transform_mesh(Manifold& mani, const Mat4x4d& m)
+}
 void console_cc_subdivide(const std::vector<std::string> & args)
+{
     if(wantshelp(args)) {
-        theConsole.printf("usage: refine.catmull_clark ");
+        theConsole.printf("usage: subdivide.catmull_clark ");
         theConsole.printf("Does one step of Catmull-Clark subdivision");
         return;
+    }
     avo().save_old();
     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: refine.doo_sabin ");
+        theConsole.printf("usage: subdivide.doo_sabin ");
         theConsole.printf("Does one step of Doo-Sabin Subdivision");
         return;
+    }
     avo().save_old();
     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 ");
     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 -= Vec3d(0.5);
-        v *= 2.0;
         v *= noise_amplitude;
         v *= avg_length;
         active_mesh().pos(*vi) += v;
+    }
     return;
     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.
-    for(int i=0;i<iter;++i)
+    laplacian_smooth(active_mesh(), t, iter);
-        laplacian_smooth(active_mesh(), t);
+    cout << "It took "<< tim.get_secs();
     return;
+}
 void console_mean_curvature_smooth(const std::vector<std::string> & args){
     taubin_smooth(active_mesh(),  iter);
     return;
+}
-void console_fvm_smooth(const std::vector<std::string> & args)
+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;
     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);
+    anisotropic_smooth(active_mesh(),  iter, BILATERAL_NORMAL_SMOOTH);
     return;
+}
 void console_triangulate(const std::vector<std::string> & args)
     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)
     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
     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("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.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("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("refine.doo_sabin", console_doosabin_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,"");

Subversion Repositories gelsvn

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