geometricProperties.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: geometricProperties.h,v 1.25.18.1 2007/03/25 21:25:26 oliver Exp $
//

#ifndef BALL_STRUCTURE_GEOMETRICPROPERTIES_H
#define BALL_STRUCTURE_GEOMETRICPROPERTIES_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

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

#ifndef BALL_MATHS_SIMPLEBOX3_H
# include <BALL/MATHS/simpleBox3.h>
#endif

#ifndef BALL_KERNEL_ATOM_H
# include <BALL/KERNEL/atom.h>
#endif

#ifndef BALL_KERNEL_FRAGMENT_H
# include <BALL/KERNEL/fragment.h>
#endif

#ifndef BALL_CONCEPT_PROCESSOR_H
# include <BALL/CONCEPT/processor.h>
#endif

#ifndef BALL_DATATYPE_STRING_H
# include <BALL/DATATYPE/string.h>
#endif

#include <vector>

namespace BALL 
{

  class BALL_EXPORT BoundingBoxProcessor
    : public UnaryProcessor<Atom>
  {
    public:

      
    virtual bool start()
      ;

    virtual bool finish()
      ;

    virtual Processor::Result operator () (Atom& atom)
       { return operator() (atom.getPosition());}

    virtual Processor::Result operator () (const Vector3& v)
      ;




    SimpleBox3 getBox() const
      ;

    const Vector3& getLower() const
      ;

    const Vector3& getUpper() const
      ;

      
    private:

    Vector3 lower_;
    Vector3 upper_;
  };

  class BALL_EXPORT GeometricCenterProcessor
    : public UnaryProcessor<Atom> 
  {
    public:


    virtual bool start()
      ;

    virtual bool finish()
      ;

    virtual Processor::Result operator()(Atom& atom)
       { return operator()(atom.getPosition());}

    virtual Processor::Result operator()(const Vector3& v)
      ;



    Vector3& getCenter()
      ;


    private:

    Vector3 center_;
    Size    n_;
  };


  class BALL_EXPORT FragmentDistanceCollector
    : public UnaryProcessor<Composite> 
  {   
    public:


    FragmentDistanceCollector()
      ;

    FragmentDistanceCollector(const Composite& composite)
      ;

    FragmentDistanceCollector(const Composite& composite, float distance)
      ;
      
    virtual ~FragmentDistanceCollector()
      
    {}  
      


    virtual bool start()
      ;

    virtual bool finish()
      ;

    virtual Processor::Result operator()(Composite& composite)
      ;



    Size getNumberOfFragments()
      ;

    void setComposite(const Composite& composite)
      ;

    const Composite* getComposite() const
      ;

    float getDistance() const
      ;
    
    void setDistance(float distance)
      ;

    
    std::vector<Fragment*>  fragments;


    protected:

    std::vector<Fragment*>  all_fragments_;
    const Composite*  reference_composite_;
    float             squared_distance_;
  };



    
  BALL_EXPORT Angle calculateTorsionAngle(const Atom& a1, const Atom& a2, const Atom& a3, const Atom& a4)
    throw(Exception::IllegalPosition);

  BALL_EXPORT Angle calculateBondAngle(const Atom& a1, const Atom& a2, const Atom& a3)
    throw(Exception::IllegalPosition);

} // namespace BALL

#endif // BALL_STRUCTURE_GEOMETRICPROPERTIES_H

---