WebSVN – gelsvn – Diff – /trunk/apps/MeshEdit/polarize.cpp

 #include <HMesh/curvature.h>
 #include <HMesh/quadric_simplify.h>
 #include <HMesh/mesh_optimization.h>
 #include <HMesh/smooth.h>
+#include <complex>
 using namespace CGLA;
 using namespace std;
 using namespace HMesh;
 void shortest_edge_triangulate_face(Manifold& m, FaceID f0, VertexAttributeVector<int>& level_set_id_vertex)
         for(int i = 0; i < N ; ++i){
             for(int j = 3; j < N-2; ++j){
                 int jj = (j+i)%N;
                 if(!connected(m, verts[i], verts[jj]) &&
                    (level_set_id_vertex[verts[i]] != level_set_id_vertex[verts[jj]]) &&
-                    (level_set_id_vertex[verts[(i+1)%N]] == level_set_id_vertex[verts[i]]) &&
+                   (level_set_id_vertex[verts[(i+1)%N]] == level_set_id_vertex[verts[i]]) &&
-                    (level_set_id_vertex[verts[(i+N-1)%N]] == level_set_id_vertex[verts[i]]) &&
+                   (level_set_id_vertex[verts[(i+N-1)%N]] == level_set_id_vertex[verts[i]]) &&
-                    (level_set_id_vertex[verts[(jj+1)%N]] == level_set_id_vertex[verts[jj]]) &&
+                   (level_set_id_vertex[verts[(jj+1)%N]] == level_set_id_vertex[verts[jj]]) &&
-                    (level_set_id_vertex[verts[(jj+N-1)%N]] == level_set_id_vertex[verts[jj]]))
+                   (level_set_id_vertex[verts[(jj+N-1)%N]] == level_set_id_vertex[verts[jj]]))
                     vpairs.push_back(pair<int,int>(i, jj));
+            }
+        }
         if(vpairs.empty()) continue;
             return DBL_MAX;
         return sqr_length(m.pos(w.next().vertex())-m.pos(w.opp().next().vertex()))/(1e-6+abs(fun[w.next().vertex()]-fun[w.opp().next().vertex()])) - sqr_length(m.pos(w.vertex())-m.pos(w.opp().vertex()))/(1e-6+abs(fun[w.vertex()]-fun[w.opp().vertex()]));
+    }
 };
+class TriangleQualityValence: public EnergyFun
+{
+    VertexAttributeVector<int>& idv;
+    MinAngleEnergy mae;
+    ValencyEnergy vae;
+public:
+    TriangleQualityValence(VertexAttributeVector<int>& _idv): idv(_idv), mae(-1) {}
+    virtual double delta_energy(const Manifold& m, HalfEdgeID h) const
+    {
+        HalfEdgeWalker w = m.halfedgewalker(h);
+        if(idv[w.next().vertex()] == idv[w.opp().next().vertex()] ||
+           idv[w.vertex()] == idv[w.opp().vertex()])
+            return DBL_MAX;
+        VertexID v1 = w.opp().vertex();
+        VertexID v2 = w.vertex();
+        VertexID vo1 = w.next().vertex();
+        VertexID vo2 = w.opp().next().vertex();
+        int val1  = valency(m, v1);
+        int val2  = valency(m, v2);
+        int valo1 = valency(m, vo1);
+        int valo2 = valency(m, vo2);
+        // The optimal valency is four for a boundary vertex
+        // and six elsewhere.
+        int t1 = boundary(m, v1) ? 4 : 6;
+        int t2 = boundary(m, v2) ? 4 : 6;
+        int to1 = boundary(m, vo1) ? 4 : 6;
+        int to2 = boundary(m, vo2) ? 4 : 6;
+        int before =
+        max(max(sqr(val1-t1),sqr(val2-t2)), max(sqr(valo1-to1), sqr(valo2-to2)));
+        int after =
+        max(max(sqr(valo1+1-to1),sqr(val1-1-t1)), max(sqr(val2-1-t2),sqr(valo2+1-to2)));
+        return static_cast<double>(after-before);
+        //        return vae.delta_energy(m,h);
+        float la = length(m.pos(w.next().vertex())-m.pos(w.opp().next().vertex()));
+        float lb = length(m.pos(w.vertex())-m.pos(w.opp().vertex()));
+        return la-lb;
+        return mae.delta_energy(m,h);
+    }
+};
 class TriangleQuality: public EnergyFun
+{
     VertexAttributeVector<int>& idv;
     MinAngleEnergy mae;
     ValencyEnergy vae;
+    {
         HalfEdgeWalker w = m.halfedgewalker(h);
         if(idv[w.next().vertex()] == idv[w.opp().next().vertex()] ||
            idv[w.vertex()] == idv[w.opp().vertex()])
             return DBL_MAX;
-//        VertexID v1 = w.opp().vertex();
-//        VertexID v2 = w.vertex();
-//        VertexID vo1 = w.next().vertex();
-//        VertexID vo2 = w.opp().next().vertex();
-//
-//        int val1  = valency(m, v1);
-//        int val2  = valency(m, v2);
-//        int valo1 = valency(m, vo1);
-//        int valo2 = valency(m, vo2);
-//
-//        // The optimal valency is four for a boundary vertex
-//        // and six elsewhere.
-//        int t1 = boundary(m, v1) ? 4 : 6;
-//        int t2 = boundary(m, v2) ? 4 : 6;
-//        int to1 = boundary(m, vo1) ? 4 : 6;
-//        int to2 = boundary(m, vo2) ? 4 : 6;
-//
-//        int before =
-//        max(max(sqr(val1-t1),sqr(val2-t2)), max(sqr(valo1-to1), sqr(valo2-to2)));
-//        int after =
-//            max(max(sqr(valo1+1-to1),sqr(val1-1-t1)), max(sqr(val2-1-t2),sqr(valo2+1-to2)));
-//
-//        return static_cast<double>(after-before);
-//        return vae.delta_energy(m,h);
-//        float la = length(m.pos(w.next().vertex())-m.pos(w.opp().next().vertex()));
-//        float lb = length(m.pos(w.vertex())-m.pos(w.opp().vertex()));
-//        return la-lb;
         return mae.delta_energy(m,h);
+    }
 };
+Vec3f grad(HMesh::Manifold& m, HMesh::VertexAttributeVector<double>& fun, HMesh::FaceID f)
+{
+    if(no_edges(m,f) != 3)
+        return Vec3f(0.0);
+    Vec3f n = normal(m, f);
+    Vec3f gsum(0.0);
+    for(HalfEdgeWalker w = m.halfedgewalker(f); !w.full_circle(); w = w.next())
+    {
+        Vec3f gdir = normalize(cross(n, m.pos(w.vertex()) - m.pos(w.opp().vertex())));
+        float l = dot(m.pos(w.next().vertex())-m.pos(w.vertex()), gdir);
+        gdir *= fun[w.next().vertex()]/l;
+        gsum += gdir;
+    }
+    return gsum;
+}
+complex<double> complex_slerp(double t, const complex<double>& a, const complex<double>&b)
+{
+    double omega = (arg(a/b));
+    cout << omega << endl;
+    return (a*sin((1-t)*omega) + b*sin(t*omega))/sin(omega);
+}
+double mod_2pi(double x)
+{
+    return x-floor(x/(2.0 * M_PI))*2.0 * M_PI;
+}
+void extend_fun2(HMesh::Manifold& m, HMesh::HalfEdgeID h,
+                 HMesh::VertexAttributeVector<double>& fun,
+                 HMesh::VertexAttributeVector<double>& fun2)
+{
+    HalfEdgeWalker w = m.halfedgewalker(h);
+    FaceID f = w.face();
+    Vec3f a = m.pos(w.opp().vertex());
+    Vec3f b = m.pos(w.vertex());
+    Vec3f c = m.pos(w.next().vertex());
+    Vec3f g = grad(m, fun, f);
+    Vec3f n = normal(m, f);
+    Vec3f N = -normalize(cross(g, n));
+    float dot_nba = dot(N,b-a);
+    float v;
+    if(dot_nba > 1e-5)
+    {
+        float t = dot(N, c-a)/dot_nba;
+        double aval = fun2[w.opp().vertex()];
+        double bval = fun2[w.vertex()];
+        double val = (1-t)*aval + t*bval;
+        v = mod_2pi(val);
+        cout << t << " , " << v << endl;
+    }
+    else
+        v =  fun2[w.vertex()];
+    fun2[w.next().vertex()] = v;
+}
 inline bool same_level(float a, float b) {return abs(a-b) < 0.00001;}
 Vec3f laplacian(const Manifold& m, VertexID v)
+{
         if(!boundary(m, *v))
             m.pos(*v) = pos[*v];
+    }
+}
-void polarize_mesh(Manifold& m, VertexAttributeVector<float>& fun, float vmin, float vmax, const int divisions)
+void polarize_mesh(Manifold& m, VertexAttributeVector<double>& fun, double vmin, double vmax, const int divisions, VertexAttributeVector<double>& parametrization)
+{
+    vmax -= 0.01 * (vmax-vmin);
     float interval = (vmax-vmin)/divisions;
     VertexAttributeVector<int> status(m.total_vertices(), 0);
     // ----------------------------------------
     cout << "Tracing level set curves" << endl;
     vector<HalfEdgeID> hidvec;
     for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
                     break;
+                }
+    }
     while(did_work);
     // ----------------------------
     cout << "Numbering the level sets" << endl;
+    float max_length = 0;
+    double max_length_fun = 0;
+    int max_length_id =-1;
+    HalfEdgeID max_length_h;
     HalfEdgeAttributeVector<int> level_set_id(m.total_halfedges(), 0);
     VertexAttributeVector<int> level_set_id_vertex(m.total_vertices(), 0);
     int no_id=1;
     for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
+    {
         HalfEdgeWalker w = m.halfedgewalker(*hid);
         if(status[w.vertex()] == 1 && status[w.opp().vertex()] == 1 &&
            same_level(fun[w.vertex()], fun[w.opp().vertex()]) &&
            level_set_id[w.halfedge()] == 0)
+        {
+            float level_set_length = 0;
             while(level_set_id[w.halfedge()] != no_id)
+            {
+                level_set_length += length(m,w.halfedge());
                 level_set_id[w.halfedge()] = no_id;
                 level_set_id[w.opp().halfedge()] = no_id;
                 level_set_id_vertex[w.vertex()] = no_id;
                 w = w.next();
                 while(status[w.vertex()] != 1 || !same_level(fun[w.vertex()], fun[w.opp().vertex()]))
                     w = w.circulate_vertex_cw();
+            }
+            if(level_set_length > max_length)
+            {
+                max_length = level_set_length;
+                max_length_id = no_id;
+                max_length_h = w.halfedge();
+                max_length_fun = fun[w.vertex()];
+            }
-        ++no_id;
+            ++no_id;
+        }
+    }
+    cout << max_length << " " << max_length_id << endl;
     cout << "Number of level sets : " << (no_id-1);
     // ----------------------------
+    shortest_edge_triangulate(m);
+    // -------------
+    cout << "Parametrize level sets " << endl;
+    queue<HalfEdgeID> hq;
+    HalfEdgeAttributeVector<int> touched(m.active_halfedges(), 0);
+    HalfEdgeWalker w = m.halfedgewalker(max_length_h);
+    float param = 0;
+    do
+    {
+        parametrization[w.opp().vertex()] = 2.0 * M_PI * param / max_length;
+        param += length(m, w.halfedge());
+        w = w.next();
+        while(level_set_id[w.halfedge()] != max_length_id)
+            w = w.circulate_vertex_cw();
+        hq.push(w.halfedge());
+        hq.push(w.opp().halfedge());
+        touched[w.halfedge()] = 1;
+        touched[w.opp().halfedge()] = 1;
+    }
+    while(w.halfedge() != max_length_h);
+    while(!hq.empty())
+    {
+        HalfEdgeID h = hq.front();
+        hq.pop();
+        if(!touched[w.next().halfedge()])
+        {
+            extend_fun2(m, h, fun, parametrization);
+            touched[w.next().halfedge()] = 1;
+            touched[w.prev().halfedge()] = 1;
+            HalfEdgeWalker w = m.halfedgewalker(h);
+            if(!touched[w.next().opp().halfedge()])
+            {
+                touched[w.next().opp().halfedge()] = 1;
+                hq.push(w.next().opp().halfedge());
+            }
+            if(!touched[w.prev().opp().halfedge()])
+            {
+                touched[w.prev().opp().halfedge()] = 1;
+                hq.push(w.prev().opp().halfedge());
+            }
+        }
+    }
+    return;
     // ----------------------------
     cout << "Remove vertices not on level set curves" << endl;
     vector<VertexID> vid_vec;
     for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)
         if(status[*vid]==0)
             vid_vec.push_back(*vid);
         if(f != InvalidFaceID)
             shortest_edge_triangulate_face(m, f, level_set_id_vertex);
         else
             cout << "vertex not removed " << valency(m, vid_vec[i]) << endl;
+    }
     for(FaceIDIterator fid = m.faces_begin(); fid != m.faces_end(); ++fid)
         if(no_edges(m, *fid) > 3)
             shortest_edge_triangulate_face(m, *fid, level_set_id_vertex);
     VertexAttributeVector<Vec3f> recalled_positions;
     for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)
         recalled_positions[*vid] = m.pos(*vid);
-//    TriangleQuality tq_energy(level_set_id_vertex);
-//    priority_queue_optimization(m, tq_energy);
+    TriangleQuality tq_energy(level_set_id_vertex);
+    priority_queue_optimization(m, tq_energy);
+    //// ----------------------------
+    cout << "smooth level set curves" << endl;
-    for(int iter=0;iter< 100;++iter)
+    for(int iter=0;iter< 14;++iter)
+    {
+        TriangleQualityValence tqv_energy(level_set_id_vertex);
-        //// ----------------------------
+        TriangleQuality tq_energy(level_set_id_vertex);
-        cout << "smooth level set curves" << endl;
+        priority_queue_optimization(m, tqv_energy);
-        aw_laplacian_smooth(m,0.025);
+        priority_queue_optimization(m, tq_energy);
         VertexAttributeVector<Vec3f> new_pos(m.total_vertices(), Vec3f(0));
         VertexAttributeVector<float> new_pos_wsum(m.total_vertices(), 0.0);
         for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
+        {
             HalfEdgeWalker w = m.halfedgewalker(*hid);
             if(level_set_id[w.halfedge()] != 0)
+            {
-                float weight = 1;//(valency(m,w.opp().vertex()));
+                float weight = 1.0;//sqr(valency(m,w.opp().vertex())-2);
                 new_pos[w.vertex()] += weight*m.pos(w.opp().vertex());
                 new_pos_wsum[w.vertex()] += weight;
+            }
+        }
         for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)
+        {
-            float weight = 1;//(valency(m,*vid));
+            float weight = 1.0;//sqr(valency(m,*vid)-2);
             new_pos[*vid] += weight*m.pos(*vid);
             new_pos_wsum[*vid] += weight;
-            m.pos(*vid) = new_pos[*vid] / new_pos_wsum[*vid];
+            m.pos(*vid) = 0.75*m.pos(*vid) + 0.25 *new_pos[*vid] / new_pos_wsum[*vid];
+        }
-    }
+        priority_queue_optimization(m, tqv_energy);
+        priority_queue_optimization(m, tq_energy);
+        vector<HalfEdgeID> hidvec;
+        for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
+        {
+            HalfEdgeWalker w = m.halfedgewalker(*hid);
+            if(w.halfedge() < w.opp().halfedge() &&
+               level_set_id[w.halfedge()] != 0 &&
+               (
+                ((level_set_id[w.opp().halfedge()] == level_set_id[w.opp().next().halfedge()] ||
+                  level_set_id[w.halfedge()] == level_set_id[w.next().halfedge()]) &&
+                 valency(m, w.vertex())+valency(m,w.opp().vertex())>10) ||
+                valency(m, w.vertex())+valency(m,w.opp().vertex())>14
+                )
+               )
+                hidvec.push_back(w.halfedge());
+        }
+        for(int i=0;i<hidvec.size(); ++i)
+        {
+            HalfEdgeWalker w = m.halfedgewalker(hidvec[i]);
+            VertexID v = m.split_edge(hidvec[i]);
-        TriangleQuality tq_energy(level_set_id_vertex);
+            level_set_id_vertex[v] = level_set_id[w.halfedge()];
+            level_set_id[w.prev().halfedge()] = level_set_id[w.halfedge()];
+            level_set_id[w.prev().opp().halfedge()] = level_set_id[w.halfedge()];
-            priority_queue_optimization(m, tq_energy);
+            shortest_edge_triangulate_face(m, w.face(), level_set_id_vertex);
+            shortest_edge_triangulate_face(m, w.opp().face(), level_set_id_vertex);
+        }
+        priority_queue_optimization(m, tqv_energy);
-//                vector<HalfEdgeID> hidvec;
+        priority_queue_optimization(m, tq_energy);
-//                for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
+        for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
-//                {
+        {
-//                    HalfEdgeWalker w = m.halfedgewalker(*hid);
+            HalfEdgeWalker w = m.halfedgewalker(*hid);
-//                    if(w.halfedge() < w.opp().halfedge() &&
-//                       level_set_id[w.halfedge()] != 0 &&
+            if(level_set_id[w.halfedge()] != 0 &&
-//                       valency(m, w.vertex())+valency(m,w.opp().vertex())>20)
+               !(level_set_id[w.opp().halfedge()] == level_set_id[w.opp().next().halfedge()] ||
-//                        hidvec.push_back(w.halfedge());
+                 level_set_id[w.halfedge()] == level_set_id[w.next().halfedge()])  &&
-//                }
+               valency(m, w.vertex())<5 &&
-//
+               valency(m, w.opp().vertex())<5 &&
-//                for(int i=0;i<hidvec.size(); ++i)
+               precond_collapse_edge(m, w.halfedge()))
-//                {
+            {
-//                    HalfEdgeWalker w = m.halfedgewalker(hidvec[i]);
+                m.collapse_edge(w.halfedge(), true);
-//                    VertexID v = m.split_edge(hidvec[i]);
+                did_work = true;
-//                    level_set_id_vertex[v] = level_set_id[w.halfedge()];
-//                    level_set_id[w.prev().halfedge()] = level_set_id[w.halfedge()];
-//                    level_set_id[w.prev().opp().halfedge()] = level_set_id[w.halfedge()];
-//                    shortest_edge_triangulate_face(m, w.face(), level_set_id_vertex);
-//                    shortest_edge_triangulate_face(m, w.opp().face(), level_set_id_vertex);
-//                }
+            }
-//
+        }
-//            priority_queue_optimization(m, tq_energy);
-  //  }
+    }
-//    for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)
-//        m.pos(*vid) = recalled_positions[*vid];
-  return;
+    return;
     priority_queue<EdgeQElem> edge_queue;
     for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
+    {
         HalfEdgeWalker w = m.halfedgewalker(*hid);
+    {
         HalfEdgeID h = edge_queue.top().he;
         edge_queue.pop();
         HalfEdgeWalker w = m.halfedgewalker(h);
-        if(level_set_id[w.next().halfedge()] == 0 ||
+        if(no_edges(m, w.face())==3 && no_edges(m,w.opp().face())==3 &&
-           level_set_id[w.prev().halfedge()] == 0 ||
+           !(level_set_id[w.next().halfedge()] == level_set_id[w.opp().prev().halfedge()] ||
-           level_set_id[w.opp().next().halfedge()] == 0 ||
+             level_set_id[w.prev().halfedge()] == level_set_id[w.opp().next().halfedge()]))
-           level_set_id[w.opp().prev().halfedge()] == 0)
             m.merge_faces(w.face(), w.halfedge());
+    }
-    for(FaceIDIterator fid = m.faces_begin(); fid != m.faces_end(); ++fid)
-        if(no_edges(m,*fid) >= 6)
+    return;
-            shortest_edge_split_face(m, *fid, level_set_id_vertex);
-    for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
-    {
-        HalfEdgeWalker w = m.halfedgewalker(*hid);
-        if(level_set_id[w.halfedge()] != 0 &&
+    do{
-           valency(m, w.vertex())==3 &&
+        did_work = false;
-           valency(m, w.opp().vertex())==3 &&
-           ((level_set_id[w.next().halfedge()] == 0 &&level_set_id[w.opp().next().halfedge()] == 0) ||
-            (level_set_id[w.prev().halfedge()] == 0 &&level_set_id[w.opp().prev().halfedge()] == 0)) &&
+        for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
-           precond_collapse_edge(m, w.halfedge()))
+        {
+            HalfEdgeWalker w = m.halfedgewalker(*hid);
+            if(level_set_id[w.halfedge()] != 0 && no_edges(m, w.face())==3 &&
-            cout << "collapsing!!!" << endl;
+               precond_collapse_edge(m, w.halfedge()))
+            {
-            m.collapse_edge(w.halfedge(), true);
+                m.collapse_edge(w.halfedge(), true);
-            did_work = true;
+                did_work = true;
+            }
+        }
+    }
+    while(did_work);
-//    bool did_work = false;
-    return;
+    return;
     int k=0;
     do {
         ++k;
                 if(no_edges(m,*fid) >= 6)
+                {
                     shortest_edge_split_face(m, *fid, level_set_id_vertex);
                     did_work = true;
+                }
+        }
     } while (did_work && k<1);
+}
-void make_height_fun(const HMesh::Manifold& m, HMesh::VertexAttributeVector<float>& fun,
+void make_height_fun(const HMesh::Manifold& m, HMesh::VertexAttributeVector<double>& fun,
-                     float& vmin, float& vmax)
+                     double& vmin, double& vmax)
+{
     VertexIDIterator vid = m.vertices_begin();
     vmin = vmax = m.pos(*vid)[2];
     for(; vid != m.vertices_end(); ++vid)
+    {
-        float v = m.pos(*vid)[1];
+        double v = m.pos(*vid)[1];
         fun[*vid] = v;
         vmin = min(v, vmin);
         vmax = max(v, vmax);
+    }
+}
 //    for (int i=0; i<vid_vec.size(); ++i) {
 //        FaceID f = m.merge_one_ring(vid_vec[i]);
 //    }
 //    cout << "-" << endl;
 //    }
-    // --------------------------
+// --------------------------
-    // Triangulate polygons by connecting only vertices on different curves.
+// Triangulate polygons by connecting only vertices on different curves.
-    //    shortest_edge_triangulate(m);
+//    shortest_edge_triangulate(m);
-    //    TriangleQuality tq_energy(level_set_id);
+//    TriangleQuality tq_energy(level_set_id);
-    //    priority_queue_optimization(m, tq_energy);
+//    priority_queue_optimization(m, tq_energy);
-    //        k=0;
+//        k=0;
-    //        do {
+//        do {
-    //            ++k;
+//            ++k;
-    //            did_work = false;
+//            did_work = false;
-    //            priority_queue<EdgeQElem> edge_queue;
+//            priority_queue<EdgeQElem> edge_queue;
-    //
+//
-    //            for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
+//            for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
-    //            {
+//            {
-    //                HalfEdgeWalker w = m.halfedgewalker(*hid);
+//                HalfEdgeWalker w = m.halfedgewalker(*hid);
-    //                if(status[w.opp().vertex()] == 0 && status[w.vertex()] == 1)
+//                if(status[w.opp().vertex()] == 0 && status[w.vertex()] == 1)
-    //                {
+//                {
-    //                    float weight = (abs(fun[w.vertex()] - fun[w.opp().vertex()]*length(m, w.halfedge())) + 1e-6);
+//                    float weight = (abs(fun[w.vertex()] - fun[w.opp().vertex()]*length(m, w.halfedge())) + 1e-6);
-    //                    edge_queue.push(EdgeQElem(weight, w.halfedge()));
+//                    edge_queue.push(EdgeQElem(weight, w.halfedge()));
-    //                }
+//                }
-    //
+//
-    //
+//
-    //                while(!edge_queue.empty())
+//                while(!edge_queue.empty())
-    //                {
+//                {
-    //                    HalfEdgeID he = edge_queue.top().he;
+//                    HalfEdgeID he = edge_queue.top().he;
-    //                    edge_queue.pop();
+//                    edge_queue.pop();
-    //                    if(m.in_use(he))
+//                    if(m.in_use(he))
-    //                    {
+//                    {
-    //                        if(precond_collapse_edge(m,he))
+//                        if(precond_collapse_edge(m,he))
-    //                        {
+//                        {
-    //                            m.collapse_edge(he);
+//                            m.collapse_edge(he);
-    //                            did_work = true;
+//                            did_work = true;
-    //                       }
+//                       }
-    //                    }
+//                    }
-    //                }
+//                }
-    //            }
+//            }
-    //        }while (did_work && k < 100);
+//        }while (did_work && k < 100);
-    //
+//
-    //            cout << "k=" << k << endl;
+//            cout << "k=" << k << endl;
-    //    priority_queue_optimization(m, energy);
+//    priority_queue_optimization(m, energy);
 //priority_queue<EdgeQElem> edge_queue;
 //HalfEdgeAttributeVector<int> time_stamp(m.total_halfedges(), 0);
 //for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
 //if(level_set_id[*hid]==0)

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/polarize.cpp @ 596 – Rev 568 → 572