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

Subversion Repositories gelsvn

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