Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *

* This file is part of GEL, www.imm.dtu.dk/GEL

* Copyright (C) the authors (see AUTHORS.txt) and DTU Informatics

*

* Principal authors:

*  Christian Thode Larsen (thode2d@gmail.com)

*  J. Andreas Baerentzen (jab@imm.dtu.dk)

*

* See LICENSE.txt for licensing information

* ----------------------------------------------------------------------- */

#include "flatten.h"

#include <string>

#include <fstream>

#include <vector>

#include <CGLA/Vec3f.h>

#include "Manifold.h"

#include "AttributeVector.h"

namespace HMesh

{

    using namespace std;

    using namespace CGLA;

    void flatten(Manifold& m, WeightScheme ws)

    {

        HalfEdgeAttributeVector<float> edge_weights(m.total_halfedges(), 0);

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

            if(boundary(m, *h))

                continue;

            HalfEdgeWalker wv = m.halfedgewalker(*h);

            Vec3f p0 = m.pos(wv.vertex());

            Vec3f p1 = m.pos(wv.next().vertex());

            Vec3f p2 = m.pos(wv.opp().vertex());

            Vec3f p3 = m.pos(wv.opp().next().vertex());

            if(ws == FLOATER_W){

                float d = acos(min(1.0f, max(-1.0f, dot(normalize(p2-p0), normalize(p3-p0)))));

                float g = acos(min(1.0f, max(-1.0f, dot(normalize(p2-p0), normalize(p1-p0)))));

                edge_weights[wv.opp().halfedge()]  = (tan(d/2) + tan(g/2)) / (p0-p2).length();

                d = acos(min(1.0f, max(-1.0f, dot(normalize(p0-p2), normalize(p1-p2)))));

                g = acos(min(1.0f, max(-1.0f, dot(normalize(p0-p2), normalize(p3-p2)))));

                edge_weights[*h]  = (tan(d/2) + tan(g/2)) / (p0-p2).length();

            }

            else if(ws == HARMONIC_W){

                float a = acos(min(1.0f, max(-1.0f, dot(normalize(p0-p3), normalize(p2-p3)))));

                float b = acos(min(1.0f, max(-1.0f, dot(normalize(p2-p1), normalize(p0-p1)))));

                float w=0;

                if(a+b < M_PI)

                    w = sin(a+b)/(sin(a)+sin(b));

                edge_weights[*h]  = w;

                edge_weights[wv.opp().halfedge()]  = w;

            }

            else{

                edge_weights[*h]  = valency(m, wv.opp().vertex());

                edge_weights[wv.opp().halfedge()]  = valency(m, wv.vertex());

            }	

        }

        ofstream ofs("parametrized.obj");

        ofs << "mtllib parametrized.mtl\nusemtl mat\n" << endl;

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

            ofs << "v " << m.pos(*v)[0] << " " << m.pos(*v)[1] << " " << m.pos(*v)[2] << endl;

        ofs << endl;

        VertexIDIterator v = m.vertices_begin();

        for(; v != m.vertices_end(); ++v){

            if(boundary(m, *v))

                break;

        }

        int n = 0;

        HalfEdgeWalker bv = m.halfedgewalker(*v);

        do{

            ++n;

            bv = bv.next();

        }

        while(bv.vertex() != *v);

        int i = 0;

        do{

            float a = 2.0*M_PI*float(i)/n;

            m.pos(bv.vertex()) = Vec3f(cos(a), sin(a), 0);

            ++i;

            bv = bv.next();

        }

        while(bv.vertex() != *v);

        for(v = m.vertices_begin(); v != m.vertices_end(); ++v)

            if(!boundary(m, *v))

                m.pos(*v) = Vec3f(0.0);

        for(int i = 0; i < 10000; ++i){

            for(v = m.vertices_begin(); v != m.vertices_end(); ++v){

                if(!boundary(m, *v)){

                    Vec3f p_new(0);

                    float w_sum = 0;

                    for(HalfEdgeWalker wv = m.halfedgewalker(*v); !wv.full_circle(); wv = wv.circulate_vertex_cw()){

                        float w = edge_weights[wv.halfedge()];

                        p_new += m.pos(wv.vertex()) * w;

                        w_sum += w;

                    }

                    m.pos(*v) = p_new/w_sum;

                }

            }

        }

        VertexAttributeVector<int> vtouched(m.total_vertices(), 0);

        i = 0;

        for(v = m.vertices_begin(); v != m.vertices_end(); ++v, ++i){

            ofs << "vt " << (0.5*m.pos(*v)[0]+0.5) << " " << (0.5*m.pos(*v)[1]+0.5)  << endl;

            vtouched[*v] = i;

        }

        ofs << endl;

        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){

            ofs << "f ";

            for(HalfEdgeWalker w = m.halfedgewalker(*f); !w.full_circle(); w = w.circulate_face_cw()){

                int idx = vtouched[w.vertex()] + 1;

                ofs << idx << "/" << idx <<" ";

            }

            ofs << endl;

        }

    }

}