Subversion Repositories gelsvn

Rev

Rev 67 | Details | Compare with Previous | Last modification | View Log | RSS feed

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