AtomImpl.hpp

/* $Id$ */

#include "geom/Angle.hpp"
#include "geom/Distance.hpp"

#include "geom/Facet.hpp"
#include "geom/HyperPlane.hpp"
#include "geom/Line.hpp"
#include "geom/Point.hpp"
#include "geom/PolyLine.hpp"
#include "geom/Repere.hpp"
#include "geom/Segment.hpp"

#define GEOMETRIC_RELATION(Type) \
  { \
    const jafar::geom::Type<dimension>* o = dynamic_cast<const jafar::geom::Type<dimension>* >(&atom); \
    if(o) \
    { \
      return GeometricRelation( distance(*o), angle(*o) ); \
    } \
  }
  
#define ATOM_TO_ATOM_DISTANCE(Type) \
  { \
    const jafar::geom::Type<dimension>* o = dynamic_cast<const jafar::geom::Type<dimension>* >(&atom); \
    if(o) \
    { \
      return distance(*o); \
    } \
  }

namespace jafar {
  namespace geom {
    template<int dimension>
    inline const Repere<dimension>* Atom<dimension>::reference( ) const
    {
      if(m_driver)
      {
        return m_driver->reference();
      } else {
        return RepereD::global();
      }
    }
    #if 0
    template<int dimension>
    GeometricRelation Atom<dimension>::relation(const Atom<dimension>& atom) const
    {
      const Point<dimension>* pt = dynamic_cast<const Point<dimension>* >(&atom);
      if(pt)
      {
        return GeometricRelation( distance( *pt ) , 0.0);
      }
      GEOMETRIC_RELATION(Segment); // Allways before Line !
      GEOMETRIC_RELATION(Line);
      GEOMETRIC_RELATION(Facet);
      GEOMETRIC_RELATION(HyperPlane);
      GEOMETRIC_RELATION(PolyLine);
      GEOMETRIC_RELATION(Repere);
      return GeometricRelation();
    }
    #endif
    template<int dimension>
    double Atom<dimension>::distance( const Atom<dimension>& atom) const
    {
      ATOM_TO_ATOM_DISTANCE(Point);
      ATOM_TO_ATOM_DISTANCE(Segment);
      ATOM_TO_ATOM_DISTANCE(Line);
      ATOM_TO_ATOM_DISTANCE(Facet);
      ATOM_TO_ATOM_DISTANCE(HyperPlane);
      ATOM_TO_ATOM_DISTANCE(PolyLine);
      ATOM_TO_ATOM_DISTANCE(Repere);
      JFR_ASSERT(false, "Unknonw object: distance wasn't correctly computed.");
      return 0.0;
    }
    template<int dimension>
    void Atom<dimension>::setDriver(Driver* d)
    {
      delete m_driver;
      m_driver = d;
      m_transformable = dynamic_cast<TransformableD*>( m_driver);
    }
    
    template<int dimension>
    bool Atom<dimension>::hasCov() const
    {
      return m_driver->hasCov();
    }
    
    template<int dimension>
    std::string Atom<dimension>::toString() const
    {
      return "Type = " + type2String( type() );
    }
    
    template<int dimension>
    std::string Atom<dimension>::type2String( Type type )
    {
      switch(type)
      {
        case T_Point:
          return "Point";
        case T_Line:
          return "Line";
        case T_HyperPlane:
          return "HyperPlane";
        case T_OrientedPlan:
          return "OrientedPlan";
        case T_PolyLine:
          return "PolyLine";
        case T_Segment:
          return "Segment";
        case T_Facet:
          return "Facet";
        case T_Repere:
          return "Repere";
      }
      return "";
    }
    
    template<int dimension>
    void Atom<dimension>::applyTransformation( const HomogenousMatrixD& _transformation )
    {
      m_transformable->applyTransformation( _transformation );
    }
    
    template<int dimension>
    bool Atom<dimension>::isTransformable() const
    {
      return m_transformable;
    }
    
    template<int dimension>
    std::ostream& operator<<(std::ostream& s, const Atom<dimension>& atom)
    {
      s << "[atom type=(" << atom.type() << ", " << Atom<dimension>::type2String( atom.type()) << "), boundingBox=" << atom.boundingBox() << " ]";
      return s;
    }
  }
}