euler::solid_t Class Reference

#include <solid.h>

List of all members.

Public Member Functions
	solid_t ()
	~solid_t ()
void	rsweep_wire (loop_t *l, int resolution=8)
	rotational sweep a wire (translational sweep only affects one surface, and is defined in euler::face_t).
void	tsweep_face (face_t *f, vector_t const &disp=vector_t(0.f, 0.f, 1.f))
void	rsweep_face (face_t *f, float theta1=0, float theta2=2 *pi, int resolution=10)
edge_t *	mev (edge_t *e1, edge_t *e2, point_t const &p)
	subdivide edge cycle (at p0=p1==p2) into p0p+[e2, e1) at p0 (change in place), and pp0+[e1, e2) at p (as cycle at new vertex).
void	kev (edge_t *e)
	inverse of mev: edge cycle (at tail of e) is merged to that at head of e.
loop_t *	mef (edge_t *e1, edge_t *e2)
	subdivide edge loop (of l1==l2) into v1v2+[e2, e1) (change in place), and v2v1+[e1,e2) (as new edge loop of new face)
loop_t *	mef (edge_t *e)
	same as mef(e, e).
void	kef (edge_t *e)
	inverse of mef: face is merged to that of opposite half edge.
void	kfmrh (face_t *f1, face_t *f2)
void	kfsmr (face_t *f1, face_t *f2)
void	kffmh (face_t *f1, face_t *f2)
void	print_off_file (std::ostream &os) const
solid_t &	operator+= (vector_t const &v)
Static Public Member Functions
static bool	assert_consistent_B_rep ()
static solid_t *	disk (point_t const &cntr=point_t(), float r=1.0f, int segs=8)
	actually a lamina (of two faces touch tightly to each other)
static solid_t *	block (point_t const &ur=point_t(1.0f, 1.0f, 1.0f))
	make a block with lower left corner at origin, and upper right as given
static solid_t *	mvfs (point_t const &p)
Public Attributes
id_t	id
face_t *	f
solid_t *	pre
solid_t *	nxt
Static Public Attributes
static solid_t *	solid = 0
Private Member Functions
vertex_t *	new_vertex (point_t const &p)
face_t *	new_face ()
std::pair< edge_t *, edge_t * >	add_edge_pair (vertex_t *v1, edge_t *nxt1, vertex_t *v2, edge_t *nxt2)
void	del_vertex (vertex_t *v)
void	del_face (face_t *)
void	del_edge_pair (edge_t *e)
void	add_face_to (face_t *f1, face_t *f2)
void	_kev (edge_t *e)
edge_t *	mev (edge_t *e1, edge_t *e2, vertex_t *v)
Private Attributes
vertex_t *	vfirst
vertex_t *	vlast
Static Private Attributes
static id_t	cur_id = 0
Friends
class	loop_t

---

Detailed Description

Examples:

test-block.cc, test-cube-with-hole-2.cc, test-cube-with-hole.cc, test-cube.cc, test-cylinder-2.cc, test-cylinder.cc, test-sphere.cc, and test-torus.cc.

Definition at line 33 of file solid.h.

---

Constructor & Destructor Documentation

euler::solid_t::solid_t (   )  [inline]

Definition at line 44 of file solid.h. References pre, and solid. : vfirst(0), vlast(0), id(cur_id++), f(0), pre(0), nxt(solid) { if(solid) solid->pre = this; solid = this; }

euler::solid_t::~solid_t (   )

Definition at line 66 of file solid.cpp. References cur_id, f, euler::vertex_t::nxt, euler::face_t::nxt, nxt, pre, solid, and vfirst. { if(solid == this) solid = nxt; if(pre) pre->nxt = nxt; if(nxt) nxt->pre = pre; while(f) { face_t* temp = f; f = f->nxt; delete temp; } vertex_t *v = vfirst; while(v) { vertex_t* temp = v; v = v->nxt; delete temp; } if(id == cur_id-1) cur_id--; }

---

Member Function Documentation

void euler::solid_t::_kev (  edge_t *  e  )  [private]

Definition at line 29 of file kev.cpp. References assert_consistent_B_rep(), del_edge_pair(), del_vertex(), euler::edge_t::nxt, euler::edge_t::o, and euler::edge_t::v. Referenced by euler::loop_t::kev(), and kev(). { assert(e->o); edge_t *front = e->o->nxt, *end = e->nxt; vertex_t *v1 = end->v, *v2 = e->v; del_edge_pair(e); if(e->o->nxt != e) if(!front->o) front->v = front->nxt->v = v1; else for(; front != end; front = front->o->nxt) front->v = v1; del_vertex(v2); solid_t::assert_consistent_B_rep(); }

std::pair< edge_t *, edge_t * > euler::solid_t::add_edge_pair (  vertex_t *  v1, edge_t *  nxt1, vertex_t *  v2, edge_t *  nxt2 )  [private]

1. add half edge (start at v1) to f1 before nxt1 2. add half edge (start at v2) to f2 before nxt2. 3. identify them as a pair. Definition at line 48 of file solid.cpp. References euler::edge_t::nxt, and euler::edge_t::pre. Referenced by mef(), and mev(). { // assert(nxt1->l->f == f1 && nxt2->l->f == f2); edge_t *nxt2_nxt = nxt2->nxt, *ne1 = new edge_t(v1, nxt1), *ne2 = new edge_t(v2, nxt2_nxt->pre); ne1->o = ne2; ne2->o = ne1; return std::make_pair(ne1, ne2); }

void euler::solid_t::add_face_to (  face_t *  f1, face_t *  f2 )  [private]

add loops of f1 after the outer (first) loop of f2, delete f1. specific work to restore the validness of solid. Definition at line 137 of file solid.cpp. References del_face(), euler::face_t::l, nxt, euler::loop_t::nxt, pre, and euler::loop_t::pre. Referenced by kef(), and kfmrh(). { assert(f1 != f2); for(loop_t* l=f1->l; l; l = l->nxt) { l->f = f2; } loop_t* nxt = f2->l->nxt; f2->l->nxt = f1->l; f1->l->pre = f2->l; loop_t*last = f1->l; while(last->nxt) last = last->nxt; last->nxt = nxt; if(nxt) nxt->pre = last; f1->l = 0; del_face(f1); }

bool euler::solid_t::assert_consistent_B_rep (   )  [static]

Definition at line 23 of file debug.cpp. References f, euler::edge_t::l, euler::face_t::l, nxt, euler::edge_t::nxt, euler::loop_t::nxt, euler::face_t::nxt, and solid. Referenced by _kev(), kef(), euler::face_t::kemr(), kfmrh(), mef(), euler::face_t::mekr(), and mev(). { solid_t* s = solid; while(s) { for(face_t *f = s->f; f; f=f->nxt) { for(loop_t* l = f->l; l; l=l->nxt) { edge_t* e = l->e, *e0 = e; do { if(e->l != l) { *(int*)(0) = 0; return false; } } while( (e=e->nxt) != e0 ); } } s = s->nxt; } return true; }

solid_t * euler::solid_t::block (  point_t const &  ur = point_t(1.0f, 1.0f, 1.0f)  )  [static]

make a block with lower left corner at origin, and upper right as given Definition at line 24 of file block.cpp. References euler::loop_t::del_single_vertex_edge_pair(), euler::loop_t::e, euler::loop_t::f, f, euler::face_t::l, mef(), euler::loop_t::mev(), mvfs(), and tsweep_face(). { solid_t* s = solid_t :: mvfs( point_t() ); loop_t *l = s->f->l; edge_t *e = l->e; e = l->mev( l->mev( l->mev( e, point_t(ur[0], 0.0, 0.0) ), point_t(ur[0], ur[1], 0.0) ), point_t(0, ur[1], 0.0) ); l->del_single_vertex_edge_pair(); face_t *f = s->mef(e, l->e)->f; s->tsweep_face( f, vector_t(0., 0., ur[2]) ); return s; }

void euler::solid_t::del_edge_pair (  edge_t *  e  )  [private]

Definition at line 113 of file solid.cpp. References euler::loop_t::e, euler::edge_t::l, euler::edge_t::nxt, euler::edge_t::o, and euler::edge_t::pre. Referenced by _kev(). { edge_t* e2 = e1->o; for(edge_t *& e = e1->l->e; e == e1 || e == e2; e = e->nxt); for(edge_t *& e = e2->l->e; e == e2 || e == e2; e = e->nxt); e1->pre->nxt = e1->nxt; e1->nxt->pre = e1->pre; e2->pre->nxt = e2->nxt; e2->nxt->pre = e2->pre; delete e1; delete e2; }

void euler::solid_t::del_face (  face_t *   )  [private]

Definition at line 89 of file solid.cpp. References f, euler::face_t::nxt, and euler::face_t::pre. Referenced by add_face_to(), and kffmh(). { if(f == face) f = face->nxt; if(face->pre) face->pre->nxt = face->nxt; if(face->nxt) face->nxt->pre = face->pre; delete face; }

void euler::solid_t::del_vertex (  vertex_t *  v  )  [private]

Definition at line 97 of file solid.cpp. References euler::vertex_t::nxt, euler::vertex_t::pre, and vfirst. Referenced by _kev(). { if(!vtx) return; if(vtx->pre) vtx->pre->nxt = vtx->nxt; if(vtx->nxt) vtx->nxt->pre = vtx->pre; if(vfirst == vtx) { if( !(vfirst=vtx->pre) ) vfirst = vtx->nxt; } delete vtx; }

solid_t * euler::solid_t::disk (  point_t const &  cntr = point_t(), float  r = 1.0f, int  segs = 8 )  [static]

actually a lamina (of two faces touch tightly to each other) Definition at line 23 of file disk.cpp. References euler::face_t::arc(), euler::loop_t::e, f, euler::face_t::l, mef(), mvfs(), and euler::pi. { solid_t* s = solid_t :: mvfs( point_t(cntr[0]+r, cntr[1], cntr[2]) ); edge_t* e = s->f->arc( s->f->l->e, cntr, r, 0, 2*pi - 2*pi/segs, segs - 1); s->mef(e, s->f->l->e); return s; }

void euler::solid_t::kef (  edge_t *  e  )

inverse of mef: face is merged to that of opposite half edge. Definition at line 23 of file kef.cpp. References add_face_to(), assert_consistent_B_rep(), euler::face_t::del_loop(), euler::loop_t::e, euler::loop_t::f, euler::face_t::l, euler::edge_t::l, euler::edge_t::nxt, euler::edge_t::o, and euler::edge_t::pre. { assert( e->l->f->l == e->l ); // e has to be on the outer (first) loop of the merged face. loop_t *l1 = e->o->l, *l2 = e->l; // l2 is to be merged into l1. add_face_to(e->l->f, e->o->l->f); edge_t *temp = e; do { temp->l = l1; } while ( (temp=temp->nxt) != e ); //merge l2 to l1. e->o->pre->nxt = e->nxt; e->nxt->pre = e->o->pre; e->pre->nxt = e->o->nxt; e->o->nxt->pre = e->pre; if(l1->e == e->o) l1->e = e->o->nxt; l2->e = 0; l1->f->del_loop(l2); delete e; delete e->o; solid_t::assert_consistent_B_rep(); }

void euler::solid_t::kev (  edge_t *  e  )

inverse of mev: edge cycle (at tail of e) is merged to that at head of e. Definition at line 23 of file kev.cpp. References _kev(), euler::loop_t::f, euler::edge_t::l, and euler::edge_t::o. { assert(e->l->f != e->o->l->f); return _kev(e); }

void euler::solid_t::kffmh (  face_t *  f1, face_t *  f2 )

Examples: test-cube-with-hole-2.cc, and test-torus.cc. Definition at line 25 of file kffmh.cpp. References del_face(), euler::loop_t::e, euler::face_t::l, euler::loop_t::nxt, euler::edge_t::o, euler::loop_t::total_vertices(), and euler::edge_t::v. Referenced by main(). { assert( ! f1->l->nxt && ! f2->l->nxt && f1->l->total_vertices() == f2->l->total_vertices() ); edge_t *e1 = f1->l->e, *e2 = f2->l->e, *e20 = e2; do { for(edge_t *e = e2->o; e != e2->nxt; e = e->pre->o) { e->v = e1->v; } } while( (e1 = e1->nxt, e2 = e2->pre) != e20 ); e1 = f1->l->e, e2 = f2->l->e, e20 = e2; do { e1->o->o = e2->o; e2->o->o = e1->o; } while( (e1 = e1->nxt, e2 = e2->pre) != e20 ); del_face(f1); del_face(f2); }

void euler::solid_t::kfmrh (  face_t *  f1, face_t *  f2 )

Examples: test-cube-with-hole.cc. Definition at line 27 of file kfmrh.cpp. References add_face_to(), assert_consistent_B_rep(), euler::face_t::l, and euler::loop_t::nxt. Referenced by kfsmr(), and main(). { assert(! f2->l->nxt); add_face_to(f2, f1); solid_t::assert_consistent_B_rep(); }

void euler::solid_t::kfsmr (  face_t *  f1, face_t *  f2 )  [inline]

Definition at line 64 of file solid.h. References kfmrh(). { kfmrh(f1, f2); }

loop_t* euler::solid_t::mef (  edge_t *  e  )  [inline]

same as mef(e, e). Definition at line 60 of file solid.h. References mef().

loop_t * euler::solid_t::mef (  edge_t *  e1, edge_t *  e2 )

subdivide edge loop (of l1==l2) into v1v2+[e2, e1) (change in place), and v2v1+[e1,e2) (as new edge loop of new face) Examples: test-cube-with-hole-2.cc, test-cube-with-hole.cc, and test-cube.cc. Definition at line 30 of file mef.cpp. References add_edge_pair(), assert_consistent_B_rep(), euler::loop_t::e, f, euler::edge_t::l, new_face(), euler::face_t::new_loop(), euler::edge_t::nxt, euler::edge_t::pre, and euler::edge_t::v. Referenced by block(), disk(), main(), mef(), and tsweep_face(). { pair<edge_t*, edge_t*> p = add_edge_pair(e2->v, e1, e1->v, e2); edge_t *&ne1 = p.first, *&ne2 = p.second; //split the edge cycle edge_t *ne2__pre = ne2->pre; ne2->pre = ne1->pre; ne1->pre->nxt = ne2; ne1->pre = ne2__pre; ne2__pre->nxt = ne1; //update hosting face and loop of new edge cycle face_t *f = new_face(); loop_t *nl = f->new_loop(); edge_t *e = ne1; do { e->l = nl; } while( (e = e->nxt) != ne1 ); // set both half edges as first in the cycle. ne1->l->e = ne1; ne2->l->e = ne2; solid_t::assert_consistent_B_rep(); return nl; }

edge_t * euler::solid_t::mev (  edge_t *  e1, edge_t *  e2, vertex_t *  v )  [private]

Definition at line 40 of file mev.cpp. References add_edge_pair(), assert_consistent_B_rep(), and euler::edge_t::v. { pair<edge_t*, edge_t*> pr = add_edge_pair(e1->v, e1, v, e2); // subdivide edge cycle by setting vertex of [e1, e2) to p. for(edge_t *&ne2 = pr.second, *e = pr.first->nxt; e != ne2; e = e->o->nxt) { e->v = ne2->v; } solid_t::assert_consistent_B_rep(); return pr.second; }

edge_t * euler::solid_t::mev (  edge_t *  e1, edge_t *  e2, point_t const &  p )

subdivide edge cycle (at p0=p1==p2) into p0p+[e2, e1) at p0 (change in place), and pp0+[e1, e2) at p (as cycle at new vertex). subdivide edge cycle (at p0=p1==p2) into p0p+[e2, e1) at p0 (change in plance), and pp0+[e1, e2) at p (as new edge cycle of new vertex). Definition at line 33 of file mev.cpp. References euler::loop_t::f, euler::edge_t::l, new_vertex(), euler::face_t::s, and euler::edge_t::v. Referenced by euler::loop_t::mev(). { assert(e1->v == e2->v); return mev(e1, e2, e1->l->f->s->new_vertex(p)); }

solid_t * euler::solid_t::mvfs (  point_t const &  p  )  [static]

Definition at line 26 of file mvfs.cpp. References new_face(), euler::face_t::new_loop(), and new_vertex(). Referenced by block(), and disk(). { solid_t *s = new solid_t; s->new_face()->new_loop( s->new_vertex(p) ); return s; }

face_t * euler::solid_t::new_face (   )  [private]

Definition at line 21 of file solid.cpp. References f, and euler::face_t::pre. Referenced by mef(), and mvfs(). { face_t* nf = new face_t(this); if(f) f->pre = nf; f = nf; return nf; }

vertex_t * euler::solid_t::new_vertex (  point_t const &  p  )  [private]

Definition at line 29 of file solid.cpp. References euler::vertex_t::nxt, euler::vertex_t::pre, vfirst, and vlast. Referenced by mev(), and mvfs(). { vertex_t *nv = new vertex_t(p); nv->pre = vlast; if(! vfirst) vfirst = nv; if(vlast) vlast->nxt = nv; vlast = nv; return nv; }

solid_t & euler::solid_t::operator+= (  vector_t const &  v  )

Definition at line 163 of file solid.cpp. References euler::vertex_t::nxt, and vfirst. { for(vertex_t *v = vfirst; v; v = v->nxt) { v->p += d; } return *this; }

void euler::solid_t::print_off_file (  std::ostream &  os  )  const

Examples: test-block.cc, test-cube-with-hole-2.cc, test-cylinder-2.cc, test-cylinder.cc, test-sphere.cc, and test-torus.cc. Definition at line 23 of file print_off_file.cpp. References f, euler::vertex_t::id, euler::edge_t::nxt, euler::face_t::nxt, euler::vertex_t::nxt, euler::edge_t::v, and vfirst. Referenced by main(). { os << "4OFF\n"; int nvertices = 0, nfaces = 0; for(vertex_t* vtx = vfirst; vtx; vtx=vtx->nxt) nvertices++; for(face_t* fac = f; fac; fac=fac->nxt) nfaces++; os << nvertices << ' ' << nfaces << ' ' << 0 << endl; for(vertex_t* vtx = vfirst; vtx; vtx=vtx->nxt) os << vtx->p[0] << '\t' << vtx->p[1] << '\t' << vtx->p[2] << '\t' << vtx->p[3] << "\t #" << vtx->id << endl; os << endl << endl; for(face_t* fac = f; fac; fac=fac->nxt) { int nvertices = fac->l->total_vertices(); os << nvertices << '\t'; edge_t *e = fac->l->e, *e0 = e; do { os << e->v->id << ' '; } while( (e=e->nxt) != e0 ); os << endl; } }

void euler::solid_t::rsweep_face (  face_t *  f, float  theta1 = 0, float  theta2 = 2*pi, int  resolution = 10 )

Face (or laminal) rotational sweep (around x-axis, and original face on xy-plane). 360 rotation needs postprocessing to identify and kill the 2 end faces using kffmh. Assume a simple face is given Examples: test-cube-with-hole-2.cc, and test-torus.cc. Definition at line 88 of file rotational_sweep.cpp. References euler::loop_t::e, f, euler::face_t::l, euler::loop_t::mev(), euler::loop_t::nxt, euler::vertex_t::p, euler::edge_t::pre, euler::loop_t::total_vertices(), and euler::edge_t::v. Referenced by main(). { assert(!f->l->nxt); float step = (theta2 - theta1) / resolution; float theta = theta1; std::vector<float> r; loop_t *l = f->l; // same operation applied to l, which is changed each iteration. int vertex_total = l->total_vertices(); for(int seg = 0; seg < resolution; seg++) { theta += step; edge_t *e = l->e, *e0 = e; int i = 0; do { if(r.size() < vertex_total) { r.push_back(e->v->p[1]); } float y = r[i] * cos( theta ), z = r[i] * sin( theta ); e = l->mev(e, point_t( e->v->p[0], y, z ))->pre->pre; i++; } while( e != e0 ); e0 = e = e->pre; edge_t *nxt_e = e->nxt->nxt->nxt, *end_e = mef(e, nxt_e)->e->o; while( (e=nxt_e) != end_e ) { nxt_e = e->nxt->nxt->nxt; mef(e, nxt_e); } l->set_loop_head( l->e->nxt ); } }

void euler::solid_t::rsweep_wire (  loop_t *  l, int  resolution = 8 )

rotational sweep a wire (translational sweep only affects one surface, and is defined in euler::face_t). Rotational sweep of a *wire* assume given loop is a wire on some face, and half edge of the first vertex is on the half edge list head. the wire, on the half plane y>0. is to be rotated around x-axis. Examples: test-cylinder-2.cc, and test-sphere.cc. Definition at line 35 of file rotational_sweep.cpp. References euler::loop_t::e, euler::loop_t::mev(), euler::edge_t::nxt, euler::vertex_t::p, euler::pi, euler::loop_t::total_vertices(), and euler::edge_t::v. Referenced by main(). { int vertex_total = l->total_vertices() / 2 + 1; edge_t *e = l->e, *e0 = e, *e00 = e0; std::vector<float> r; float theta = 0.0; for(int seg=0; seg < resolution-1; seg++) { theta += 2 * pi / resolution; e = e0; for(int i=0; i < vertex_total; i++) { if(r.size() <= i) r.push_back(e->v->p[1]); float y = r[i] * cos( theta ), z = r[i] * sin( theta ); e = l->mev(e, point_t( e->v->p[0], y, z ) )->nxt->nxt; } e = e0->pre; for(int i=0; i < vertex_total-1; i++) { edge_t *nxt_e = e->nxt->nxt->nxt; mef(e, nxt_e); e = nxt_e; } assert_consistent_B_rep(); e0 = e0->pre->pre->o; } edge_t *e1 = e00->o->nxt, *e2 = e0; for(int i=0; i < vertex_total-1; i++) { edge_t *nxt_e1 = e1->pre; mef(e1, e2); e1 = nxt_e1; e2 = e2->nxt; } mef(e2, e1); }

void euler::solid_t::tsweep_face (  face_t *  f, vector_t const &  disp = vector_t(0.f, 0.f, 1.f) )

Examples: test-cylinder.cc. Definition at line 22 of file translation_sweep.cpp. References euler::loop_t::e, f, euler::face_t::l, mef(), euler::edge_t::nxt, euler::loop_t::nxt, euler::edge_t::o, euler::vertex_t::p, euler::edge_t::pre, and euler::edge_t::v. Referenced by block(), and main(). { for(loop_t *l = f->l; l; l=l->nxt) { edge_t *e = l->e, *e0 = e; while( (e = l->mev(e, e->v->p + disp)->pre->pre) != e0 ); e0 = e = e->pre; edge_t *nxt_e = e->nxt->nxt->nxt, *end_e = mef(e, nxt_e)->e->o; while( (e=nxt_e) != end_e ) { nxt_e = e->nxt->nxt->nxt; mef(e, nxt_e); } } }

---

Friends And Related Function Documentation

friend class loop_t [friend]

Definition at line 86 of file solid.h.

---

Member Data Documentation

id_t euler::solid_t::cur_id = 0 [static, private]

Definition at line 91 of file solid.h. Referenced by ~solid_t().

face_t* euler::solid_t::f

Examples: test-cube-with-hole-2.cc, test-cube-with-hole.cc, test-cube.cc, test-cylinder-2.cc, test-cylinder.cc, test-sphere.cc, and test-torus.cc. Definition at line 40 of file solid.h. Referenced by assert_consistent_B_rep(), block(), del_face(), disk(), main(), mef(), new_face(), euler::operator<<(), print_off_file(), rsweep_face(), tsweep_face(), and ~solid_t().

id_t euler::solid_t::id

Definition at line 39 of file solid.h. Referenced by euler::operator<<().

solid_t * euler::solid_t::nxt

Definition at line 41 of file solid.h. Referenced by add_face_to(), assert_consistent_B_rep(), and ~solid_t().

solid_t* euler::solid_t::pre

Definition at line 41 of file solid.h. Referenced by add_face_to(), solid_t(), and ~solid_t().

solid_t * euler::solid_t::solid = 0 [static]

Definition at line 37 of file solid.h. Referenced by assert_consistent_B_rep(), solid_t(), and ~solid_t().

vertex_t* euler::solid_t::vfirst [private]

Definition at line 35 of file solid.h. Referenced by del_vertex(), new_vertex(), operator+=(), print_off_file(), and ~solid_t().

vertex_t * euler::solid_t::vlast [private]

Definition at line 35 of file solid.h. Referenced by new_vertex().

---

The documentation for this class was generated from the following files:

• solid.h
• block.cpp
• debug.cpp
• disk.cpp
• euler.cpp
• kef.cpp
• kev.cpp
• kffmh.cpp
• kfmrh.cpp
• mef.cpp
• mev.cpp
• mvfs.cpp
• print_off_file.cpp
• rotational_sweep.cpp
• solid.cpp
• translation_sweep.cpp

---