RSFace.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_RSFACE_H
#define BALL_STRUCTURE_RSFACE_H

#ifndef BALL_STRUCTURE_GRAPHFACE_H
# include <BALL/STRUCTURE/graphFace.h>
#endif

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

namespace BALL
{
  class RSVertex;
  class RSEdge;
  class ReducedSurface;
  class RSComputer;
  class SolventExcludedSurface;
  class SESComputer;
  class SESSingularityCleaner;
  class SESEdge;
  class SESFace;
  class SESVertex;
  class TriangulatedSES;
  class SASTriangulator;
  class SolventAccessibleSurface;
  class SASEdge;
  class SASFace;
  class SASVertex;
  class TriangulatedSAS;
  class SESTriangulator;

  class BALL_EXPORT RSFace  : public GraphTriangle< RSVertex,RSEdge,RSFace >
  {
    public:

    friend class RSEdge;
    friend class RSVertex;
    friend class ReducedSurface;
    friend class RSComputer;
    friend class SESEdge;
    friend class SESFace;
    friend class SESVertex;
    friend class SolventExcludedSurface;
    friend class SESComputer;
    friend class SESSingularityCleaner;
    friend class TriangulatedSES;
    friend class SESTriangulator;
    friend class SASEdge;
    friend class SASFace;
    friend class SASVertex;
    friend class SolventAccessibleSurface;
    friend class TriangulatedSAS;
    friend class SASTriangulator;

    BALL_CREATE(RSFace)

    

    RSFace()
      ;

    RSFace(const RSFace& rsface, bool deep = false)
      ;

    RSFace(RSVertex* vertex1,
        RSVertex* vertex2,
        RSVertex* vertex3,
        RSEdge* edge1,
        RSEdge* edge2,
        RSEdge* edge3,
        const TVector3<double>& center,
        const TVector3<double>& normal,
        bool singular,
        Index index)
      throw(Exception::DivisionByZero);

    virtual ~RSFace()
      ;



    void set(const RSFace& rsface, bool deep = false)
      ;

    RSFace& operator = (const RSFace& rsface)
      ;

    void set(RSVertex* vertex1,
        RSVertex* vertex2,
        RSVertex* vertex3,
        RSEdge* edge1,
        RSEdge* edge2,
        RSEdge* edge3,
        const TVector3<double>& center,
        const TVector3<double>& normal,
        bool singular,
        Index index)
      throw(Exception::DivisionByZero);



    virtual bool operator == (const RSFace& rsface) const
      ;

    virtual bool operator != (const RSFace& rsface) const
      ;

    virtual bool operator *=(const RSFace& rsface) const
      ;
    
    bool isSingular() const
      ;



    void setCenter(const TVector3<double>& center)
      ;

    TVector3<double> getCenter() const
      ;

    void setNormal(const TVector3<double>& normal)
      throw(Exception::DivisionByZero);

    TVector3<double> getNormal() const
      ;

    void setSingular(bool singular)
      ;

    void remove
        (HashSet<RSEdge*>&    edges,
         HashSet<RSVertex*>&  vertices,
         HashSet<RSFace*>&    faces)
      ;


    protected:

    /*_ @name Attributes
    */

    /*_ The center of the probe sphere defining the RSFace
    */
    TVector3<double> center_;
    /*_ The vector orthogonal to the RSFace
    */
    TVector3<double> normal_;
    /*_ singular
    */
    bool singular_;


  };


  BALL_EXPORT std::ostream& operator << (std::ostream& s, const RSFace& rsface);


} // namespace BALL

#endif // BALL_STRUCTURE_RSFACE_H