Subversion Repositories gelsvn

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
149 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 
 
150 jab 13 
namespace HMesh
149 jab 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(NULL_HALFEDGE_ITER), h1(NULL_HALFEDGE_ITER), 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 
				vector<HalfEdgeIter> h(N);
96 
				for(int j=0;j<N;++j)
97 
					{
98 
						int v_idx  = indices[j+n];
99 
						int v_idx1 = indices[(j+1)%N+n];
100 
 
101 
						assert(v_idx < no_vertices);
102 
						assert(v_idx1 < no_vertices);
103 
 
104 
						EdgeKey ek = EdgeKey(v_idx, v_idx1);
105 
						EdgeMap::iterator em_iter = edge_map.find(ek);
106 
						if(em_iter == edge_map.end())
107 
							{
108 
								Edge e;
109 
								e.count = 1;
110 
								e.h0 = m.create_halfedge();
111 
								e.h1 = m.create_halfedge();
112 
 
113 
								glue(e.h0, e.h1);
114 
 
115 
								vertices[v_idx]->he = e.h0;
116 
								vertices[v_idx1]->he = e.h1;
117 
 
118 
								e.h0->vert = vertices[v_idx1];
119 
								e.h1->vert = vertices[v_idx];
120 
 
121 
								edge_map[ek] = e;
122 
 
123 
								h[j]=e.h0;
124 
							}
125 
						else
126 
							{
127 
								h[j] = em_iter->second.h1;
128 
								em_iter->second.count++;
129 
								assert(em_iter->second.count !=3);
130 
								assert(em_iter->second.count ==2);
131 
							}
132 
					}
133 
 
134 
				for(int j=0;j<N;++j)
135 
					{
136 
						h[j]->face = face;
137 
						link(h[j], h[(j+1)%N]);
138 
					}
139 
				face->last = h[0];
140 
 
141 
				n += N;
142 
			}
143 
 
144 
		VertexIter vi = m.vertices_begin();
145 
		while(vi != m.vertices_end())
146 
			{
147 
				if(vi->he == NULL_HALFEDGE_ITER)
148 
					{
149 
						VertexIter v_old = vi;
150 
						++vi;
155 jab 151 
						m.erase_vertex(v_old);
149 jab 152 
					}
153 
				else
154 
					++vi;
155 
			}
156 
 
157 
 
158 
		for(vi = m.vertices_begin(); vi != m.vertices_end(); ++vi)
159 
				check_boundary_consistency(vi);
160 
	}
161 
 
162 
 
163 
 
164 
}