Subversion Repositories gelsvn

#include "../Geometry/Implicit.h"

#include "triangulate.h"

#include "smooth.h"

    using namespace Geometry;

    void edge_equalize(Manifold& m, const Implicit& imp, int max_iter)

    {

        for(int iter=0;iter<max_iter;++iter)

        {

            float avg_edge_len=0;

            for(HalfEdgeIDIterator h = m.halfedges_begin(); h != m.halfedges_end();++h)

                avg_edge_len += length(m, *h);

            avg_edge_len /= m.no_halfedges();

            TAL_smoothing(m,1,1);

            for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)

                imp.push_to_surface(m.pos(*vid),0,avg_edge_len*0.5);

            vector<float> edge_lengths;

            int n=0;

            for(HalfEdgeIDIterator h = m.halfedges_begin(); h != m.halfedges_end();++h,++n)

                edge_lengths.push_back(length(m, *h));

            sort(edge_lengths.begin(), edge_lengths.end());

            float med_len = edge_lengths[n/2];

            vector<HalfEdgeID> short_edges, long_edges;

            for(HalfEdgeIDIterator h = m.halfedges_begin(); h != m.halfedges_end();++h)

                if(*h<m.walker(*h).opp().halfedge())

                {

                    float l = length(m,*h);

                    if(l> (4/3.0) * med_len)

                        long_edges.push_back(*h);

                    else if(l< (4/5.0) * med_len)

                        short_edges.push_back(*h);

                }

            for(int i=0;i<long_edges.size(); ++i)

                if(m.in_use(long_edges[i]))

                    m.split_edge(long_edges[i]);

            shortest_edge_triangulate(m);

            for(int i=0;i<short_edges.size(); ++i)

                if(m.in_use(short_edges[i]) && precond_collapse_edge(m, short_edges[i]))

                {

                    Walker w = m.walker(short_edges[i]);

                    Vec3d mid_point = 0.5*(m.pos(w.vertex())+m.pos(w.opp().vertex()));

                    bool illegal = false;

                    for(Walker wc=m.walker(w.vertex()); !wc.full_circle(); wc = wc.circulate_vertex_ccw())

                        if(length(m.pos(wc.vertex())-mid_point) > (4/3.0)* med_len)

                            illegal = true;

                    for(Walker wc=m.walker(w.opp().vertex()); !wc.full_circle(); wc = wc.circulate_vertex_ccw())

                        if(length(m.pos(wc.vertex())-mid_point) > (4/3.0)* med_len)

                            illegal = true;

                    if(!illegal)

                    {

                        if(boundary(m,w.vertex()) && !boundary(m,w.opp().vertex()))

                            m.collapse_edge(short_edges[i],false);

                        else if(!boundary(m,w.vertex()) && boundary(m,w.opp().vertex()));

                        else

                            m.collapse_edge(short_edges[i],true);

                    }

                }

            //        TAL_smoothing(m,.95,5);

            //        for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)

            //            imp.push_to_surface(m.pos(*vid));

            maximize_min_angle(m, 0.9);

        }

        m.cleanup();

    }