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 
	class EdgeKey
17 
	{
18 
		int v0;
19 
		int v1;
20 
 
21 
	public:
22 
 
23 
		EdgeKey(int va, int vb)
24 
		{
25 
			if(va<vb)
26 
				{
27 
					v0 = va;
28 
					v1 = vb;
29 
				}
30 
			else
31 
				{
32 
					v0 = vb;
33 
					v1 = va;
34 
				}
35 
		}
36 
 
37 
		bool operator<(const EdgeKey& k2) const
38 
		{
39 
			if(v0<k2.v0)
40 
				return true;
41 
			else if(v0>k2.v0)
42 
				return false;
43 
			else
44 
				return v1<k2.v1;
45 
			return false;
46 
		}
47 
	};
48 
 
49 
	struct Edge
50 
	{
51 
		HalfEdgeIter h0;
52 
		HalfEdgeIter h1;
53 
		int count;
54 
		Edge(): h0(NULL_HALFEDGE_ITER), h1(NULL_HALFEDGE_ITER), count(0) {}
55 
	};
56 
 
57 
 
58 
 
59 
 
60 
	void build_manifold(Manifold& m,
61 
											int no_vertices,
62 
											const Vec3f* vertvec,
63 
											int no_faces,
64 
											const int* facevec,
65 
											const int* indices,
66 
											const int* touch)
67 
	{
68 
		std::vector<VertexIter> vertices(no_vertices);
69 
 
70 
		if(touch==0)
71 
			{
72 
				for(int i=0;i<no_vertices;++i)
73 
					vertices[i] = m.create_vertex(vertvec[i]);
74 
			}
75 
		else
76 
			{
77 
				for(int i=0;i<no_vertices;++i)
78 
					{
79 
						vertices[i] = m.create_vertex(vertvec[i]);
80 
						vertices[i]->touched = touch[i];
81 
					}
82 
			}
83 
 
84 
		typedef std::map<EdgeKey, Edge> EdgeMap;
85 
		EdgeMap edge_map;
86 
 
87 
		int n=0;
88 
		for(int i=0;i<no_faces;++i)
89 
			{
90 
				FaceIter face = m.create_face();
91 
				int N = facevec[i];
92 
 
93 
				//HalfEdgeIter h[N];
94 
				vector<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;
155 jab 150 
						m.erase_vertex(v_old);
149 jab 151 
					}
152 
				else
153 
					++vi;
154 
			}
155 
 
156 
 
157 
		for(vi = m.vertices_begin(); vi != m.vertices_end(); ++vi)
158 
				check_boundary_consistency(vi);
159 
	}
160 
 
161 
 
162 
 
163 
}