solid.cpp

Go to the documentation of this file.

/**
 *\file         solid.cpp
 *
 *\brief        
 *
 *\author       Xianming Chen\n
 *              Computer Science Department\n
 *              University of Utah
 *
 *\date         16 Aug 2006\n
 *              Copyright (c) 2006, University of Utah
 */


#include "euler.h"
#include "print.h"


namespace euler
{
  face_t* solid_t :: new_face()
  {
    face_t* nf = new face_t(this);
    if(f) f->pre = nf;
    f = nf;

    return nf;
  }
  vertex_t* solid_t :: new_vertex( point_t const& p) 
  {
    vertex_t *nv = new vertex_t(p);
    nv->pre = vlast;

    if(! vfirst) vfirst = nv;

    if(vlast) vlast->nxt = nv;
    vlast = nv;

    return nv;
  }


  /**
   * 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.
   */
  std::pair<edge_t*, edge_t*> solid_t :: add_edge_pair(vertex_t* v1, edge_t* nxt1,
                                                       vertex_t* v2, edge_t* nxt2)
  {
    //    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);
  }



  solid_t :: ~solid_t() 
  { 
    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--; 
  }


  void solid_t :: del_face(face_t* face)
  {
    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 solid_t :: del_vertex(vertex_t* vtx)
  {
    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;
  }


  void solid_t :: del_edge_pair(edge_t* e1)
  {
    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;
  }
  






  /**
   * add loops of f1 after the outer (first) loop of f2, delete f1. 
   * specific work to restore the validness of solid.
   *
   */
  void solid_t :: add_face_to(face_t* f1, face_t *f2) 
  { 
    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);
  }
  


  solid_t& solid_t :: operator+=(vector_t const& d)
  {
    for(vertex_t *v = vfirst; v; v = v->nxt)
    {
      v->p += d;
    }

    return *this;
  }
  


  


}//end namespace euler

---