triangulatedSurface.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: triangulatedSurface.h,v 1.40.18.1 2007/03/25 21:25:34 oliver Exp $

#ifndef BALL_STRUCTURE_TRIANGULATEDSURFACE_H
#define BALL_STRUCTURE_TRIANGULATEDSURFACE_H

#ifndef BALL_STRUCTURE_TRIANGLE_H
# include <BALL/STRUCTURE/triangle.h>
#endif

#ifndef BALL_STRUCTURE_TRIANGLEEDGE_H
# include <BALL/STRUCTURE/triangleEdge.h>
#endif

#ifndef BALL_STRUCTURE_TRIANGLEPOINT_H
# include <BALL/STRUCTURE/trianglePoint.h>
#endif

#ifndef BALL_MATHS_PLANE3_H
# include <BALL/MATHS/plane3.h>
#endif

#ifndef BALL_MATHS_SURFACE_H
# include <BALL/MATHS/surface.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

#include <list>
#include <vector>

namespace BALL
{
  class BALL_EXPORT TriangulatedSurface
  {

    public:

    BALL_CREATE(TriangulatedSurface)

    

    typedef std::list<TrianglePoint*>::iterator
            PointIterator;
    typedef std::list<TrianglePoint*>::const_iterator
            ConstPointIterator;
    typedef std::list<TriangleEdge*>::iterator
            EdgeIterator;
    typedef std::list<TriangleEdge*>::const_iterator
            ConstEdgeIterator;
    typedef std::list<Triangle*>::iterator
            TriangleIterator;
    typedef std::list<Triangle*>::const_iterator
            ConstTriangleIterator;



    TriangulatedSurface()
      ;

    TriangulatedSurface(const TriangulatedSurface& surface, bool = true)
      ;

    virtual ~TriangulatedSurface()
      ;


    static TriangulatedSurface* createTube(unsigned int num_vertices, unsigned int subdiv = 0, bool closed = false, bool out = true);

    static TriangulatedSurface* createDisk(unsigned int num_vertices, bool out = true);


    void clear()
      ;

    void set(const TriangulatedSurface& surface, bool = true)
      ;

    TriangulatedSurface& operator = (const TriangulatedSurface& surface)
      ;



    void insert(TrianglePoint* point)
      ;

    void insert(TriangleEdge* edge)
      ;

    void insert(Triangle* triangle)
      ;

    BALL_DEPRECATED Size numberOfPoints() const
      ;

    Size getNumberOfPoints() const
      ;

    BALL_DEPRECATED Size numberOfEdges() const
      ;

    Size getNumberOfEdges() const
      ;

    BALL_DEPRECATED Size numberOfTriangles() const
      ;

    Size getNumberOfTriangles() const
      ;

    void remove(TrianglePoint* point, bool deep = true)
      ;

    void remove(PointIterator p, bool deep = true)
      ;

    void remove(TriangleEdge* edge, bool deep = true)
      ;

    void remove(EdgeIterator e, bool deep = true)
      ;

    void remove(Triangle* triangle, bool deep = true)
      ;

    void remove(TriangleIterator t, bool deep = true)
      ;

    void exportSurface(Surface& surface)
      ;

    TriangulatedSurface& operator += (const TriangulatedSurface& surface)
      ;

    void join(TriangulatedSurface& source)
      ;

    void shift(const TVector3<double>& c);

    void blowUp(const double& r);

    void setIndices();

    void cut(const TPlane3<double>& plane, const double& fuzzy = 0);

    void shrink();

    void deleteIsolatedEdges()
      ;

    void deleteIsolatedPoints()
      ;

    void getBorder(std::list<TriangleEdge*>& border);



    PointIterator beginPoint()
      ;
    ConstPointIterator beginPoint() const
      ;
    PointIterator endPoint()
      ;
    ConstPointIterator endPoint() const
      ;

    EdgeIterator beginEdge()
      ;
    ConstEdgeIterator beginEdge() const
      ;
    EdgeIterator endEdge()
      ;
    ConstEdgeIterator endEdge() const
      ;

    TriangleIterator beginTriangle()
      ;
    ConstTriangleIterator beginTriangle() const
      ;
    TriangleIterator endTriangle()
      ;
    ConstTriangleIterator endTriangle() const
      ;

    /*_ @name protected help functions
    */

    protected:

    /*_ Test whether a TriangulatedSurface object can be copied
    */
    bool canBeCopied() const
      ;

    /*_ Copy a TriangulatedSurface object
    */
    void copy(const TriangulatedSurface& surface)
      ;


    protected:

    /*_ @name Attributes
    */

    /*_ the number of points of the triangulated surface
    */
    Size number_of_points_;
    /*_ the points of the surface.
    */
    std::list<TrianglePoint*> points_;
    /*_ the number of edges of the triangulated surface
    */
    Size number_of_edges_;
    /*_ the edges of the surface.
    */
    std::list<TriangleEdge*> edges_;
    /*_ the number of triangles of the triangulated surface
    */
    Size number_of_triangles_;
    /*_ the triangles of the surface.
    */
    std::list<Triangle*> triangles_;


  };


  BALL_EXPORT std::ostream& operator << (std::ostream& s,
                                         const TriangulatedSurface& surface);





  class BALL_EXPORT TriangulatedSphere  : public TriangulatedSurface
  {

    public:

    BALL_CREATE(TriangulatedSphere)

    struct Face
    {
      TrianglePoint* p[6];
      TriangleEdge* e[9];
      Position pcount;
      Position ecount;
    };


    TriangulatedSphere()
      ;

    TriangulatedSphere(const TriangulatedSphere& sphere, bool = true)
      ;

    virtual ~TriangulatedSphere()
      ;


    void set(const TriangulatedSphere& sphere, bool = true)
      ;

    TriangulatedSphere& operator = (const TriangulatedSphere& sphere)
      ;



    void icosaeder(bool out = true);

    void pentakisDodecaeder(bool out = true);

    void refine(Position iterations, bool out = true);


    private:

    /*_ Refine a triangulated sphere once.
    */
    void refine(bool out);

    void buildFourTriangles
        (Face face,
         Triangle* face0,
         Triangle* face1,
         Triangle* face2,
         Triangle* face3)
      ;

    /*_ Set the incidences of a refined triangulated sphere.
    */
    void setIncidences();


  };
   
} // namespace BALL


#endif  // BALL_STRUCTURE_TRIANGULATEDSURFACE_H

---