solid.h

Go to the documentation of this file.

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


#ifndef _SOLID_H
#define _SOLID_H

#include "node_fwd_dcl.h"
#include <utility>
#include <iosfwd>


namespace euler
{
  class face_t;
  class loop_t;
  class edge_t;
  class vertex_t;
  class point_t;
  typedef short id_t;

  class solid_t
  {
      vertex_t *vfirst, *vlast;   // head and last vertices.
  public:
      static solid_t *solid;
      static bool assert_consistent_B_rep();
      id_t id;
      face_t *f;
      solid_t *pre, *nxt;

  public:
      solid_t() : vfirst(0), vlast(0), id(cur_id++), f(0), pre(0), nxt(solid) { if(solid) solid->pre = this; solid = this; }
      ~solid_t();


      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
      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);

      static solid_t* mvfs(point_t const& p);
      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)                                { return mef(e, 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) { kfmrh(f1, f2); }

      void kffmh(face_t* f1, face_t* f2);
      
      void print_off_file(std::ostream& os) const;
      

      solid_t& operator+=(vector_t const& v);
      
  private:
      vertex_t* new_vertex(point_t const&p);  // append to vertex list.
      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);    // add loops of f1 after the outer (first) loop of f2, delete f1. 

      friend class loop_t;
      void _kev(edge_t* e);
      edge_t* mev(edge_t* e1, edge_t* e2, vertex_t* v);
      
  private:
      static id_t cur_id;
  };

}//end namespace euler


#endif

---