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



	using namespace CGLA;
 
	void Manifold::get_bbox(Vec3f& pmin, Vec3f& pmax) 
	{
		VertexIter vi = vertices_begin();
		pmin = pmax = vi->pos;
		for(++vi;vi != vertices_end(); ++vi)
			{
				pmin = v_min(vi->pos, pmin);
				pmax = v_max(vi->pos, pmax);
			}
	}
 
  void Manifold::get_bsphere(CGLA::Vec3f& c, float& r) 
  {

	VertexIter Manifold::split_edge(HalfEdgeIter h)
	{
		HalfEdgeIter ho = h->opp;
		VertexIter v  = h->vert;
		VertexIter vo = ho->vert;
		Vec3f np = (v->pos+vo->pos)/2.0f;
 
		VertexIter vn = create_vertex(np);
		vn->he = h;
 
		HalfEdgeIter hn = create_halfedge();

 		h->face->last = hn;
 		ho->face->last = ho;
		hn->face = h->face;
		hno->face = ho->face;
 
		check_boundary_consistency(vn);
		check_boundary_consistency(v);
		check_boundary_consistency(vo);
		return vn;
	}
 
 
	void Manifold::remove_face_if_degenerate(HalfEdgeIter h0)

				if(h0->face != NULL_FACE_ITER)
					erase_face(h0->face);
				erase_halfedge(h0);
				erase_halfedge(h1);
				
				check_boundary_consistency(v0);
				check_boundary_consistency(v1);
 
			}
	}
 
	bool Manifold::collapse_precond(VertexIter v1, HalfEdgeIter h)

		// TETRAHEDRON TEST
		if(k==2 && (link1.size()+link2.size()==6)) 
			return false;
 
		// Test that we are not merging holes (see 6)
		if(is_boundary(v1) && is_boundary(v2) &&
			 (h->face != NULL_FACE_ITER) &&
			 (h->opp->face != NULL_FACE_ITER))
			return false;
		
		

	{
		HalfEdgeIter ho = h->opp;
		VertexIter n = h->vert;
 
		if(avg_vertices)
			n->pos = ((v->pos + n->pos) / 2.0f);
		
		HalfEdgeIter hn = h->next;
		HalfEdgeIter hp = h->prev;
		HalfEdgeIter hon = ho->next;
		HalfEdgeIter hop = ho->prev;
 
		bool neighbour_is_boundary = is_boundary(n);
 
		VertexCirculator vc(v);
		for(;!vc.end();++vc)
			vc.get_opp_halfedge()->vert = n;
 

 		erase_halfedge(ho);
 
		remove_face_if_degenerate(hn);
		remove_face_if_degenerate(hon);
 
		check_boundary_consistency(n);
	}
 
	bool Manifold::is_valid()
	{
		HalfEdgeIter he0 = halfedges_begin();

			{
				hx->face = f1;
				hx = hx->next;
			}
 
		check_boundary_consistency(v);
		check_boundary_consistency(vo);
 
 		erase_halfedge(h);
 		erase_halfedge(ho);
		erase_face(f2);
		

	VertexIter Manifold::safe_triangulate(FaceIter f)
	{
		Vec3f p;
		FaceCirculator fc(f);
		for(;!fc.end(); ++fc)
			p += fc.get_vertex()->pos;
		int n = fc.no_steps();
		p /= n;
		VertexIter v = create_vertex(p);
		face_insert_point(f,v);
		return v;

		h2->vert = vc;
 
		va->he = ha;
		vb->he = hc;
 
		check_boundary_consistency(va);
		check_boundary_consistency(vb);
		return true;
	}
 
		/** Give each vertex a unique id corresponding to its iterator 
				position */

Rev 59	Rev 62
Line 11...	Line 11...
11	`using namespace CGLA;`	11	`using namespace CGLA;`
12		12
13	`void Manifold::get_bbox(Vec3f& pmin, Vec3f& pmax)`	13	`void Manifold::get_bbox(Vec3f& pmin, Vec3f& pmax)`
14	`{`	14	`{`
15	`VertexIter vi = vertices_begin();`	15	`VertexIter vi = vertices_begin();`
16	`pmin = pmax = vi->get_pos();`	16	`pmin = pmax = vi->pos;`
17	`for(++vi;vi != vertices_end(); ++vi)`	17	`for(++vi;vi != vertices_end(); ++vi)`
18	`{`	18	`{`
19	`pmin = v_min(vi->get_pos(), pmin);`	19	`pmin = v_min(vi->pos, pmin);`
20	`pmax = v_max(vi->get_pos(), pmax);`	20	`pmax = v_max(vi->pos, pmax);`
21	`}`	21	`}`
22	`}`	22	`}`
23		23
24	`void Manifold::get_bsphere(CGLA::Vec3f& c, float& r)`	24	`void Manifold::get_bsphere(CGLA::Vec3f& c, float& r)`
25	`{`	25	`{`
Line 34...	Line 34...
34	`VertexIter Manifold::split_edge(HalfEdgeIter h)`	34	`VertexIter Manifold::split_edge(HalfEdgeIter h)`
35	`{`	35	`{`
36	`HalfEdgeIter ho = h->opp;`	36	`HalfEdgeIter ho = h->opp;`
37	`VertexIter v = h->vert;`	37	`VertexIter v = h->vert;`
38	`VertexIter vo = ho->vert;`	38	`VertexIter vo = ho->vert;`
39	`Vec3f np = (v->get_pos()+vo->get_pos())/2.0f;`	39	`Vec3f np = (v->pos+vo->pos)/2.0f;`
40		40
41	`VertexIter vn = create_vertex(np);`	41	`VertexIter vn = create_vertex(np);`
42	`vn->he = h;`	42	`vn->he = h;`
43		43
44	`HalfEdgeIter hn = create_halfedge();`	44	`HalfEdgeIter hn = create_halfedge();`
Line 60...	Line 60...
60	`h->face->last = hn;`	60	`h->face->last = hn;`
61	`ho->face->last = ho;`	61	`ho->face->last = ho;`
62	`hn->face = h->face;`	62	`hn->face = h->face;`
63	`hno->face = ho->face;`	63	`hno->face = ho->face;`
64		64
65	`vn->check_boundary_consistency();`	65	`check_boundary_consistency(vn);`
66	`v->check_boundary_consistency();`	66	`check_boundary_consistency(v);`
67	`vo->check_boundary_consistency();`	67	`check_boundary_consistency(vo);`
68	`return vn;`	68	`return vn;`
69	`}`	69	`}`
70		70
71		71
72	`void Manifold::remove_face_if_degenerate(HalfEdgeIter h0)`	72	`void Manifold::remove_face_if_degenerate(HalfEdgeIter h0)`
Line 88...	Line 88...
88	`if(h0->face != NULL_FACE_ITER)`	88	`if(h0->face != NULL_FACE_ITER)`
89	`erase_face(h0->face);`	89	`erase_face(h0->face);`
90	`erase_halfedge(h0);`	90	`erase_halfedge(h0);`
91	`erase_halfedge(h1);`	91	`erase_halfedge(h1);`
92		92
93	`v0->check_boundary_consistency();`	93	`check_boundary_consistency(v0);`
94	`v1->check_boundary_consistency();`	94	`check_boundary_consistency(v1);`
95		95
96	`}`	96	`}`
97	`}`	97	`}`
98		98
99	`bool Manifold::collapse_precond(VertexIter v1, HalfEdgeIter h)`	99	`bool Manifold::collapse_precond(VertexIter v1, HalfEdgeIter h)`
Line 202...	Line 202...
202	`// TETRAHEDRON TEST`	202	`// TETRAHEDRON TEST`
203	`if(k==2 && (link1.size()+link2.size()==6))`	203	`if(k==2 && (link1.size()+link2.size()==6))`
204	`return false;`	204	`return false;`
205		205
206	`// Test that we are not merging holes (see 6)`	206	`// Test that we are not merging holes (see 6)`
207	`if(v1->is_boundary() && v2->is_boundary() &&`	207	`if(is_boundary(v1) && is_boundary(v2) &&`
208	`(h->face != NULL_FACE_ITER) &&`	208	`(h->face != NULL_FACE_ITER) &&`
209	`(h->opp->face != NULL_FACE_ITER))`	209	`(h->opp->face != NULL_FACE_ITER))`
210	`return false;`	210	`return false;`
211		211
212		212
Line 219...	Line 219...
219	`{`	219	`{`
220	`HalfEdgeIter ho = h->opp;`	220	`HalfEdgeIter ho = h->opp;`
221	`VertexIter n = h->vert;`	221	`VertexIter n = h->vert;`
222		222
223	`if(avg_vertices)`	223	`if(avg_vertices)`
224	`n->set_pos((v->get_pos() + n->get_pos()) / 2.0f);`	224	`n->pos = ((v->pos + n->pos) / 2.0f);`
225		225
226	`HalfEdgeIter hn = h->next;`	226	`HalfEdgeIter hn = h->next;`
227	`HalfEdgeIter hp = h->prev;`	227	`HalfEdgeIter hp = h->prev;`
228	`HalfEdgeIter hon = ho->next;`	228	`HalfEdgeIter hon = ho->next;`
229	`HalfEdgeIter hop = ho->prev;`	229	`HalfEdgeIter hop = ho->prev;`
230		230
231	`bool neighbour_is_boundary = n->is_boundary();`	231	`bool neighbour_is_boundary = is_boundary(n);`
232		232
233	`VertexCirculator vc(v);`	233	`VertexCirculator vc(v);`
234	`for(;!vc.end();++vc)`	234	`for(;!vc.end();++vc)`
235	`vc.get_opp_halfedge()->vert = n;`	235	`vc.get_opp_halfedge()->vert = n;`
236		236
Line 251...	Line 251...
251	`erase_halfedge(ho);`	251	`erase_halfedge(ho);`
252		252
253	`remove_face_if_degenerate(hn);`	253	`remove_face_if_degenerate(hn);`
254	`remove_face_if_degenerate(hon);`	254	`remove_face_if_degenerate(hon);`
255		255
256	`n->check_boundary_consistency();`	256	`check_boundary_consistency(n);`
257	`}`	257	`}`
258		258
259	`bool Manifold::is_valid()`	259	`bool Manifold::is_valid()`
260	`{`	260	`{`
261	`HalfEdgeIter he0 = halfedges_begin();`	261	`HalfEdgeIter he0 = halfedges_begin();`
Line 462...	Line 462...
462	`{`	462	`{`
463	`hx->face = f1;`	463	`hx->face = f1;`
464	`hx = hx->next;`	464	`hx = hx->next;`
465	`}`	465	`}`
466		466
467	`v->check_boundary_consistency();`	467	`check_boundary_consistency(v);`
468	`vo->check_boundary_consistency();`	468	`check_boundary_consistency(vo);`
469		469
470	`erase_halfedge(h);`	470	`erase_halfedge(h);`
471	`erase_halfedge(ho);`	471	`erase_halfedge(ho);`
472	`erase_face(f2);`	472	`erase_face(f2);`
473		473
Line 478...	Line 478...
478	`VertexIter Manifold::safe_triangulate(FaceIter f)`	478	`VertexIter Manifold::safe_triangulate(FaceIter f)`
479	`{`	479	`{`
480	`Vec3f p;`	480	`Vec3f p;`
481	`FaceCirculator fc(f);`	481	`FaceCirculator fc(f);`
482	`for(;!fc.end(); ++fc)`	482	`for(;!fc.end(); ++fc)`
483	`p += fc.get_vertex()->get_pos();`	483	`p += fc.get_vertex()->pos;`
484	`int n = fc.no_steps();`	484	`int n = fc.no_steps();`
485	`p /= n;`	485	`p /= n;`
486	`VertexIter v = create_vertex(p);`	486	`VertexIter v = create_vertex(p);`
487	`face_insert_point(f,v);`	487	`face_insert_point(f,v);`
488	`return v;`	488	`return v;`
Line 589...	Line 589...
589	`h2->vert = vc;`	589	`h2->vert = vc;`
590		590
591	`va->he = ha;`	591	`va->he = ha;`
592	`vb->he = hc;`	592	`vb->he = hc;`
593		593
594	`va->check_boundary_consistency();`	594	`check_boundary_consistency(va);`
595	`vb->check_boundary_consistency();`	595	`check_boundary_consistency(vb);`
596	`return true;`	596	`return true;`
597	`}`	597	`}`
598		598
599	`/** Give each vertex a unique id corresponding to its iterator`	599	`/** Give each vertex a unique id corresponding to its iterator`
600	`position */`	600	`position */`

Subversion Repositories gelsvn

(root)/trunk/src/HMesh/Manifold.cpp @ 59 – Rev 59 → 62