Subversion Repositories gelsvn

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
24 jab 1 
 
2 
#include <iostream>
3 
 
4 
#include "HMesh/Manifold.h"
5 
#include "HMesh/VertexCirculator.h"
6 
#include "HMesh/FaceCirculator.h"
7 
#include "build_manifold.h"
8 
 
9 
using namespace std;
10 
using namespace CGLA;
11 
using namespace HMesh;
12 
 
13 
namespace HMeshUtil
14 
{
15 
 
16 
 
17 
	class EdgeKey
18 
	{
19 
		int v0;
20 
		int v1;
21 
 
22 
	public:
23 
 
24 
		EdgeKey(int va, int vb)
25 
		{
26 
			if(va<vb)
27 
				{
28 
					v0 = va;
29 
					v1 = vb;
30 
				}
31 
			else
32 
				{
33 
					v0 = vb;
34 
					v1 = va;
35 
				}
36 
		}
37 
 
38 
		bool operator<(const EdgeKey& k2) const
39 
		{
40 
			if(v0<k2.v0)
41 
				return true;
42 
			else if(v0>k2.v0)
43 
				return false;
44 
			else
45 
				return v1<k2.v1;
46 
			return false;
47 
		}
48 
	};
49 
 
50 
	struct Edge
51 
	{
52 
		HalfEdgeIter h0;
53 
		HalfEdgeIter h1;
54 
		int count;
55 
		Edge(): h0(0), h1(0), count(0) {}
56 
	};
57 
 
58 
 
59 
 
60 
 
61 
	void build_manifold(Manifold& m,
62 
											int no_vertices,
63 
											const Vec3f* vertvec,
64 
											int no_faces,
65 
											const int* facevec,
66 
											const int* indices,
67 
											const int* touch)
68 
	{
69 
		std::vector<VertexIter> vertices(no_vertices);
70 
 
71 
		if(touch==0)
72 
			{
73 
				for(int i=0;i<no_vertices;++i)
74 
					vertices[i] = m.create_vertex(vertvec[i]);
75 
			}
76 
		else
77 
			{
78 
				for(int i=0;i<no_vertices;++i)
79 
					{
80 
						vertices[i] = m.create_vertex(vertvec[i]);
81 
						vertices[i]->touched = touch[i];
82 
					}
83 
			}
84 
 
85 
		typedef std::map<EdgeKey, Edge> EdgeMap;
86 
		EdgeMap edge_map;
87 
 
88 
		int n=0;
89 
		for(int i=0;i<no_faces;++i)
90 
			{
91 
				FaceIter face = m.create_face();
92 
				int N = facevec[i];
93 
 
94 
				HalfEdgeIter h[N];
95 
				for(int j=0;j<N;++j)
96 
					{
97 
						int v_idx  = indices[j+n];
98 
						int v_idx1 = indices[(j+1)%N+n];
99 
 
100 
						assert(v_idx < no_vertices);
101 
						assert(v_idx1 < no_vertices);
102 
 
103 
						EdgeKey ek = EdgeKey(v_idx, v_idx1);
104 
						EdgeMap::iterator em_iter = edge_map.find(ek);
105 
						if(em_iter == edge_map.end())
106 
							{
107 
								Edge e;
108 
								e.count = 1;
109 
								e.h0 = m.create_halfedge();
110 
								e.h1 = m.create_halfedge();
111 
 
112 
								glue(e.h0, e.h1);
113 
 
114 
								vertices[v_idx]->he = e.h0;
115 
								vertices[v_idx1]->he = e.h1;
116 
 
117 
								e.h0->vert = vertices[v_idx1];
118 
								e.h1->vert = vertices[v_idx];
119 
 
120 
								edge_map[ek] = e;
121 
 
122 
								h[j]=e.h0;
123 
							}
124 
						else
125 
							{
126 
								h[j] = em_iter->second.h1;
127 
								em_iter->second.count++;
128 
								assert(em_iter->second.count !=3);
129 
								assert(em_iter->second.count ==2);
130 
							}
131 
					}
132 
 
133 
				for(int j=0;j<N;++j)
134 
					{
135 
						h[j]->face = face;
136 
						link(h[j], h[(j+1)%N]);
137 
					}
138 
				face->last = h[0];
139 
 
140 
				n += N;
141 
			}
142 
 
143 
		VertexIter vi = m.vertices_begin();
144 
		while(vi != m.vertices_end())
145 
			{
146 
				if(vi->he == NULL_HALFEDGE_ITER)
147 
					{
148 
						VertexIter v_old = vi;
149 
						++vi;
150 
						m.vertex_db.erase(v_old);
151 
					}
152 
				else
153 
					++vi;
154 
			}
155 
 
156 
 
157 
		for(vi = m.vertices_begin(); vi != m.vertices_end(); ++vi)
158 
			vi->check_boundary_consistency();
159 
	}
160 
 
161 
 
162 
 
163 
}