RSEdge.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_RSEDGE_H
#define BALL_STRUCTURE_RSEDGE_H

#ifndef BALL_STRUCTURE_GRAPHEDGE_H
# include <BALL/STRUCTURE/graphEdge.h>
#endif

#ifndef BALL_MATHS_ANGLE_H
# include <BALL/MATHS/angle.h>
#endif

#ifndef BALL_MATHS_CIRCLE3_H
# include <BALL/MATHS/circle3.h>
#endif

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

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

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

    friend class RSFace;
    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 SolventAccessibleSurface;
    friend class SASVertex;
    friend class TriangulatedSAS;
    friend class SASTriangulator;

    BALL_CREATE(RSEdge)

    

    RSEdge()
      ;

    RSEdge(const RSEdge& rsedge, bool deep = false)
      ;

    RSEdge(RSVertex* vertex1,
        RSVertex* vertex2,
        RSFace* face1,
        RSFace* face2,
        const TVector3<double>& center_of_torus,
        const double& radius_of_torus,
        const TAngle<double>& angle,
        const TCircle3<double>& circle1,
        const TCircle3<double>& circle2,
        const TVector3<double>& intersection_point1,
        const TVector3<double>& intersection_point2,
        bool singular,
        Index index)
      ;

    virtual ~RSEdge()
      ;



    void set(const RSEdge& rsedge, bool deep = false)
      ;

    RSEdge& operator = (const RSEdge& rsedge)
      ;

    void set(RSVertex* vertex0,
        RSVertex* vertex1,
        RSFace* face0,
        RSFace* face1,
        const TVector3<double>& center_of_torus,
        const double& radius_of_torus,
        const TAngle<double>& angle,
        const TCircle3<double>& circle0,
        const TCircle3<double>& circle1,
        const TVector3<double>& intersection_point0,
        const TVector3<double>& intersection_point1,
        bool singular,
        Index index)
      ;



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

    TVector3<double> getCenterOfTorus() const
      ;

    void setMajorRadiusOfTorus(const double& radius)
      ;

    double getMajorRadiusOfTorus() const
      ;

    void setAngle(const TAngle<double>& angle)
      ;

    TAngle<double> getAngle() const
      ;

    void  setContactCircle(Position i, const TCircle3<double>&  circle)
      ;

    TCircle3<double> getContactCircle(Position i) const
      ;

    void setIntersectionPoint(Position i, const TVector3<double>& point)
      ;

    TVector3<double> getIntersectionPoint(Position i) const
      throw(Exception::GeneralException);

    void setSingular(bool singular)
      ;




    virtual bool operator == (const RSEdge& rsedge) const
      ;

    virtual bool operator != (const RSEdge& rsedge) const
      ;

    virtual bool operator *=(const RSEdge& rsedge) const
      ;

    bool isSingular() const
      ;

    bool isFree() const
      ;


    protected:

    /*_ @name Attributes
    */

    /*_ The center of the torus described by the probe when ir rolls over
        the RSEdge
    */
    TVector3<double> center_of_torus_;
    /*_ The major radius of the torus described by the probe when ir rolls
        over the RSEdge
    */
    double radius_of_torus_;
    /*_ The rotation angle between the starting and ending position of the
        probe sphere when it rolls over the RSEdge
    */
    TAngle<double> angle_;
    /*_ The contact circle of the probe sphere with the first RSVertex
    */
    TCircle3<double> circle0_;
    /*_ The contact circle of the probe sphere with the second RSVertex
    */
    TCircle3<double> circle1_;
    /*_ The intersection point of the probe sphere with the RSEdge near to
        the first RSVertex (in singular case).
    */
    TVector3<double> intersection_point0_;
    /*_ The intersection point of the probe sphere with the RSEdge near to
        the second RSVertex (in singular case).
    */
    TVector3<double> intersection_point1_;
    /*_ singular
    */
    bool singular_;


  };


  BALL_EXPORT std::ostream& operator << (std::ostream& s, const RSEdge& rsedge);



   
} // namespace BALL

#endif // BALL_STRUCTURE_RSEDGE_H