Subversion Repositories gelsvn

Rev

Rev 332 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 332 Rev 595
Line -... Line 1...
- 
 
 1 
/* ----------------------------------------------------------------------- *
- 
 
 2 
 * This file is part of GEL, http://www.imm.dtu.dk/GEL
- 
 
 3 
 * Copyright (C) the authors and DTU Informatics
- 
 
 4 
 * For license and list of authors, see ../../doc/intro.pdf
- 
 
 5 
 * ----------------------------------------------------------------------- */
- 
 
 6 
 
1 
#include "subdivision.h"
 7 
#include "subdivision.h"
- 
 
 8 
 
2 
#include "FaceCirculator.h"
 9 
#include <vector>
- 
 
 10 
#include <CGLA/Vec3d.h>
- 
 
 11 
 
3 
#include "build_manifold.h"
 12 
#include "Manifold.h"
- 
 
 13 
#include "AttributeVector.h"
4 
 
 14 
 
5 
using namespace std;
 15 
namespace HMesh
- 
 
 16 
{
6 
using namespace CGLA;
 17 
    using namespace std;
7 
namespace HMesh
 18 
    using namespace CGLA;
8 
{
 19 
 
9 
		void cc_split(Manifold& m_in, Manifold& m_out)
 20 
    void cc_split(Manifold& m_in, Manifold& m_out)
10 
		{
 21 
    {
- 
 
 22 
        const int Invalid = -1;
- 
 
 23 
 
11 
				vector<Vec3f> new_points;
 24 
        vector<Vec3d> new_points;
- 
 
 25 
        new_points.reserve(m_in.no_vertices());
12 
 
 26 
 
13 
				for(VertexIter v=m_in.vertices_begin(); v != m_in.vertices_end();++v)
 27 
        VertexAttributeVector<int> vtouched(m_in.allocated_vertices(), Invalid);
- 
 
 28 
        HalfEdgeAttributeVector<int> htouched(m_in.allocated_halfedges(), Invalid);
14 
				{
 29 
 
- 
 
 30 
        int npsize = 0;
- 
 
 31 
        for(VertexIDIterator v = m_in.vertices_begin(); v != m_in.vertices_end(); ++v){
15 
						int idx = new_points.size();
 32 
            vtouched[*v] = npsize;
16 
						new_points.push_back(v->pos);
 33 
            new_points.push_back(m_in.pos(*v));
17 
						v->touched = idx;
 34 
            ++npsize;
18 
				}
 35 
        }
19
36 
 
20 
				for(HalfEdgeIter h=m_in.halfedges_begin();h!= m_in.halfedges_end();++h)
 37 
        for(HalfEdgeIDIterator h = m_in.halfedges_begin(); h != m_in.halfedges_end(); ++h){
21 
						h->touched = -1;
 38 
            if(htouched[*h] != Invalid)
- 
 
 39 
                continue;
22 
 
 40 
 
23 
				for(HalfEdgeIter h=m_in.halfedges_begin();h!= m_in.halfedges_end();++h)
 41 
            Walker w = m_in.walker(*h);
24 
						if(h->touched == -1)
 - 
 
25 
				{
 - 
 
26 
						int idx = new_points.size();
 42 
            htouched[*h] = htouched[w.opp().halfedge()] = npsize;
27 
						new_points.push_back((h->vert->pos + h->opp->vert->pos) / 2.0);
 43 
            new_points.push_back((m_in.pos(w.vertex()) + m_in.pos(w.opp().vertex())) * 0.5f);
28 
						h->touched = h->opp->touched = idx;
 44 
            ++npsize;
29 
				}
 45 
 
30
46 
        }
31 
				vector<int> indices;
 47 
        vector<int> indices;
32 
				vector<int> faces;
 48 
        vector<int> faces;
- 
 
 49 
 
33 
				for(FaceIter f=m_in.faces_begin(); f != m_in.faces_end(); ++f)
 50 
        for(FaceIDIterator f = m_in.faces_begin(); f != m_in.faces_end(); ++f){
34 
				{
 - 
 
35 
						int idx_center = new_points.size();
 51 
            for(Walker w = m_in.walker(*f); !w.full_circle(); w = w.circulate_face_cw()){
36 
						new_points.push_back(centre(f));
 52 
                indices.push_back(npsize);
37 
						for(FaceCirculator fc(f); !fc.end(); ++fc)
 53 
                indices.push_back(htouched[w.halfedge()]);
38 
						{
 - 
 
39 
								indices.push_back(idx_center);
 54 
                indices.push_back(vtouched[w.vertex()]);
40 
								indices.push_back(fc.get_halfedge()->prev->touched);
 55 
                indices.push_back(htouched[w.next().halfedge()]);
41 
								indices.push_back(fc.get_vertex()->touched);
 56 
                faces.push_back(4);
- 
 
 57 
            }
42 
								indices.push_back(fc.get_halfedge()->touched);
 58 
            new_points.push_back(centre(m_in, *f));
- 
 
 59 
            ++npsize;
- 
 
 60 
        }
- 
 
 61 
 
43 
								faces.push_back(4);
 62 
        m_out.clear();
- 
 
 63 
        m_out.build(npsize, reinterpret_cast<double*>(&new_points[0]), faces.size(), &faces[0], &indices[0]);
44 
						}
 64 
    }
- 
 
 65
- 
 
 66 
    void cc_smooth(Manifold& m)
45 
				}
 67 
    {
- 
 
 68 
        VertexAttributeVector<Vec3d> new_vertices(m.no_vertices(), Vec3d(0));
- 
 
 69 
        for(FaceIDIterator fi = m.faces_begin(); fi != m.faces_end(); ++fi)
- 
 
 70 
        {
- 
 
 71 
            FaceID f = *fi;
- 
 
 72 
            Walker w = m.walker(f);
- 
 
 73 
            for(; !w.full_circle(); w = w.next())
- 
 
 74 
            {
- 
 
 75 
                VertexID v = w.vertex();
- 
 
 76 
                float val = valency(m, v);
- 
 
 77 
                float A = (1.0f-3.0f/val)	* (1.0f/val);
- 
 
 78 
                float B = sqr(1.0f/val);
- 
 
 79 
                Walker w2 = m.walker(f);
- 
 
 80 
                for(; !w2.full_circle(); w2 = w2.next())
46 
				m_out.clear();
 81 
                {
47 
				build_manifold(m_out, new_points.size(),
 82 
                    VertexID v2 = w2.vertex();
48 
											 &new_points[0],
 83 
                    if(v==v2)
- 
 
 84 
                        new_vertices[v] += A * m.pos(v2);
49 
											 faces.size(),
 85 
                    else
- 
 
 86 
                        new_vertices[v] += B * m.pos(v2);
50 
											 &faces[0],
 87 
                }
- 
 
 88
- 
 
 89 
            }
- 
 
 90 
        }
- 
 
 91 
        for(VertexIDIterator vi = m.vertices_begin(); vi != m.vertices_end(); ++vi)
51 
											 &indices[0]);
 92 
            m.pos(*vi) = new_vertices[*vi];
52 
		}
 93 
    }
- 
 
 94 
 
53
95 
 
54 
}
 96 
}