SESFace.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
 
#ifndef BALL_STRUCTURE_SESFACE_H
#define BALL_STRUCTURE_SESFACE_H
 
#ifndef BALL_STRUCTURE_GRAPHFACE_H
# include <BALL/STRUCTURE/graphFace.h>
#endif
 
#ifndef BALL_STRUCTURE_RSEDGE_H
# include <BALL/STRUCTURE/RSEdge.h>
#endif
 
#ifndef BALL_STRUCTURE_RSFACE_H
# include <BALL/STRUCTURE/RSFace.h>
#endif
 
#ifndef BALL_STRUCTURE_RSVERTEX_H
# include <BALL/STRUCTURE/RSVertex.h>
#endif
 
namespace BALL
{
  class SESEdge;
  class SESVertex;
  class SolventExcludedSurface;
  class TriangulatedSES;
  class SESComputer;
  class SESSingularityCleaner;
  class SESTriangulator;

  class BALL_EXPORT SESFace : public GraphFace< SESVertex,SESEdge,SESFace >
  {
    public:

    friend class SESEdge;
    friend class SESVertex;
    friend class SolventExcludedSurface;
    friend class SESComputer;
    friend class SESSingularityCleaner;
    friend class TriangulatedSES;
    friend class SESTriangulator;
 
    BALL_CREATE(SESFace)
 
    

    enum Type
    {
      TYPE_SPHERIC  = 0,
      TYPE_TORIC = 1,
      TYPE_CONTACT = 2,
      TYPE_TORIC_SINGULAR = 3
    };



    SESFace()
      ;

    SESFace(const SESFace& sesface, bool deep = false)
      ;

    SESFace
        (Type       type,
         RSVertex*  rsvertex,
         RSEdge*    rsedge,
         RSFace*    rsface)
      ;

    virtual ~SESFace()
      ;



    void set(const SESFace& sesface, bool deep = false)
      ;

    SESFace& operator = (const SESFace& sesface)
      ;

    void setType(Type type)
      ;

    Type getType() const
      ;

    void setRSVertex(RSVertex* rsvertex)
      ;

    RSVertex* getRSVertex() const
      ;

    void setRSEdge(RSEdge* rsedge)
      ;

    RSEdge* getRSEdge() const
      ;

    void setRSFace(RSFace* rsface)
      ;

    RSFace* getRSFace() const
      ;



    void normalize(bool singular)
      ;



    virtual bool operator == (const SESFace&) const
      ;

    virtual bool operator != (const SESFace&) const
      ;

    virtual bool operator *= (const SESFace&) const
      ;

    bool isNeighbouredTo(SESFace* face) const
      ;

    bool isFree() const
      ;

    bool hasSingularEdges() const
      ;

 
    private:
 
    void normalizeNonSingularToricFace_()
      ;
 
    void normalizeSingularToricFace_()
      ;
 
    void findTriangle_
        (bool first,
         SESEdge*& edge0,
         SESEdge*& edge1,
         SESEdge*& edge2,
         SESVertex*& vertex0,
         SESVertex*& vertex1,
         SESVertex*& vertex2)
      ;
 
    protected:

 
    /*_ The type of the face.
    */
    Type type_;
    /*_ A pointer to the corresponding RSVertex
        (if type_ is TYPE_CONTACT).
    */
    RSVertex* rsvertex_;
    /*_ A pointer to the corresponding RSEdge
        (if type_ is TYPE_TORIC or TYPE_TORIC_SINGULAR).
    */
    RSEdge* rsedge_;
    /*_ A pointer to the corresponding RSFace
        (if type_ is TYPE_SPHERIC).
    */
    RSFace* rsface_;

  };


  BALL_EXPORT std::ostream& operator << (std::ostream& s, const SESFace& sesface);

 
   
} // namespace BALL
 
#endif // BALL_STRUCTURE_SESFACE_H