triangulatedSAS.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_TRIANGULATEDSAS_H
#define BALL_STRUCTURE_TRIANGULATEDSAS_H

#ifndef BALL_STRUCTURE_SASEDGE_H
# include <BALL/STRUCTURE/SASEdge.h>
#endif

#ifndef BALL_STRUCTURE_SASFACE_H
# include <BALL/STRUCTURE/SASFace.h>
#endif

#ifndef BALL_TRUCTURE_SOLVENTEXCLUDEDSURFACE_H
# include <BALL/STRUCTURE/solventAccessibleSurface.h>
#endif

#ifndef BALL_STRUCTURE_TRIANGULATEDSURFACE_H
# include <BALL/STRUCTURE/triangulatedSurface.h>
#endif

#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_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

#ifndef BALL_DATATYPE_HASHGRID_H
# include <BALL/DATATYPE/hashGrid.h>
#endif

#include <list>
#include <vector>

namespace BALL
{
  class SASTriangulator;

  class BALL_EXPORT TriangulatedSAS : public TriangulatedSurface
  {
    
    public:

    friend class SASTriangulator;

    BALL_CREATE(TriangulatedSAS)

    

    TriangulatedSAS();

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

    TriangulatedSAS(SolventAccessibleSurface* sas, const double& density);

    virtual ~TriangulatedSAS();


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

    TriangulatedSAS& operator = (const TriangulatedSAS& surface);



    void setDensity(const double& density);

    double getDensity() const;

    void compute();


    protected:

    /*_ @name Attributes
    */

    SolventAccessibleSurface* sas_;

    double density_;


  };

  class BALL_EXPORT SASTriangulator
  {
    
    public:

    #ifdef debug_triangulation
    void printToHINFile(string filename);
    void Contour2HIN(const std::list<TriangleEdge*>& contour, const string& file);
    void SASEdge2HIN(SASEdge* edge, const string& file);
    #endif

    BALL_CREATE(SASTriangulator)

    

    SASTriangulator();

    SASTriangulator(TriangulatedSAS* tsas);

    virtual ~SASTriangulator();


    void run();

    private:

    void triangulateFace(SASFace* face);

    void createPlanes(SASFace* face,
                      std::list< std::pair<TPlane3<double>,double> >& planes);

    void tagPoints(TriangulatedSurface& part,
                   const std::list< std::pair<TPlane3<double>,double> >& planes);

    void removeInsideTriangles(TriangulatedSurface& part);

    HashGrid3<TrianglePoint*> createHashGrid(const TriangulatedSurface& part);

    void createPoints(TriangulatedSurface& part,
                      const std::list< std::pair<TPlane3<double>,double> >& planes,
                      HashGrid3<TrianglePoint*>& grid);

    void createNewTriangles(TriangulatedSurface& part, HashGrid3<TrianglePoint*>& grid);

    void onePointOutside(Index outside, Triangle* t,
                         TriangulatedSurface& part, HashGrid3<TrianglePoint*>& grid);

    void twoPointsOutside(Position outside1, Position outside2,
                          Triangle* t, TriangulatedSurface& part, HashGrid3<TrianglePoint*>& grid);

    TrianglePoint* vertexExists(const TVector3<double>& point, HashGrid3<TrianglePoint*>& grid);

    Size numberOfRefinements(const double& density, const double& radius);

    void buildTemplateSpheres();


    protected:


    TriangulatedSAS* tsas_;

    double sqrt_density_;

    std::vector< std::list< TVector3<double> > > edge_;

    HashMap<Size,TriangulatedSurface> template_spheres_;


  };

} // namespace BALL


#endif  // BALL_STRUCTURE_TRIANGULATEDSAS_H