triangulatedSurface.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#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 setDensity(const double& density);
    
    double getDensity() const;
    
    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_;

    /*_ the density used by triangulation algorithms
    */
    double density_;


  };


  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