WebSVN – gelsvn – Diff – /trunk/src/HMesh/build_manifold.cpp


 
#include <iostream>
 
#include "HMesh/Manifold.h"
#include "HMesh/VertexCirculator.h"
#include "HMesh/FaceCirculator.h"
#include "build_manifold.h"
 
using namespace std;
using namespace CGLA;
using namespace HMesh;
 
namespace HMesh
{
 
 
	class EdgeKey
	{
		int v0;
		int v1;
 
	public:
	
		EdgeKey(int va, int vb)
		{
			if(va<vb) 
				{
					v0 = va;
					v1 = vb;
				}
			else
				{
					v0 = vb;
					v1 = va;
				}
		}
 
		bool operator<(const EdgeKey& k2) const
		{
			if(v0<k2.v0)
				return true;
			else if(v0>k2.v0)
				return false;
			else
				return v1<k2.v1;
			return false;
		}
	};
 
	struct Edge
	{
		HalfEdgeIter h0;
		HalfEdgeIter h1;
		int count;
		Edge(): h0(NULL_HALFEDGE_ITER), h1(NULL_HALFEDGE_ITER), count(0) {}
	};
 
	
 
 
	void build_manifold(Manifold& m,
											int no_vertices,
											const Vec3f* vertvec,
											int no_faces,
											const int* facevec,
											const int* indices,
											const int* touch)
	{
		std::vector<VertexIter> vertices(no_vertices);
 
		if(touch==0)
			{
				for(int i=0;i<no_vertices;++i)
					vertices[i] = m.create_vertex(vertvec[i]);
			}
		else
			{
				for(int i=0;i<no_vertices;++i)
					{
						vertices[i] = m.create_vertex(vertvec[i]);
						vertices[i]->touched = touch[i];
					}
			}
 
		typedef std::map<EdgeKey, Edge> EdgeMap;
		EdgeMap edge_map;
 
		int n=0;
		for(int i=0;i<no_faces;++i)
			{
				FaceIter face = m.create_face();
				int N = facevec[i];
				
				//HalfEdgeIter h[N];
				vector<HalfEdgeIter> h(N);
				for(int j=0;j<N;++j)
					{
						int v_idx  = indices[j+n];
						int v_idx1 = indices[(j+1)%N+n];
 
						assert(v_idx < no_vertices);
						assert(v_idx1 < no_vertices);
						
						EdgeKey ek = EdgeKey(v_idx, v_idx1);
						EdgeMap::iterator em_iter = edge_map.find(ek);
						if(em_iter == edge_map.end())
							{
								Edge e;
								e.count = 1;
								e.h0 = m.create_halfedge();
								e.h1 = m.create_halfedge();
 
								glue(e.h0, e.h1);
 
								vertices[v_idx]->he = e.h0;
								vertices[v_idx1]->he = e.h1;
 
								e.h0->vert = vertices[v_idx1];
								e.h1->vert = vertices[v_idx];
 
								edge_map[ek] = e;
 
								h[j]=e.h0;
							}
						else
							{
								h[j] = em_iter->second.h1;	
								em_iter->second.count++;
								assert(em_iter->second.count !=3);
								assert(em_iter->second.count ==2);
							}
					}
 
				for(int j=0;j<N;++j)
					{
						h[j]->face = face;
						link(h[j], h[(j+1)%N]);
					}
				face->last = h[0];
 
				n += N;
			}
 
		VertexIter vi = m.vertices_begin();
		while(vi != m.vertices_end())
			{
				if(vi->he == NULL_HALFEDGE_ITER)
					{
						VertexIter v_old = vi;
						++vi;
						m.erase_vertex(v_old);
					}
				else
					++vi;
			}
 
 
		for(vi = m.vertices_begin(); vi != m.vertices_end(); ++vi)			
				check_boundary_consistency(vi);
	}
 
 
 
}
 

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

Subversion Repositories gelsvn

(root)/trunk/src/HMesh/build_manifold.cpp @ 183 – Rev 182 → 183