Subversion Repositories gelsvn

Rev

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