Point.hpp

/* $Id$ */

#ifndef _GEOM_POINT_HPP_
#define _GEOM_POINT_HPP_


#include <kernel/jafarMacro.hpp>
#include "geom/Atom.hpp"
#include "geom/Distance.hpp"
#include "geom/Angle.hpp"
#include "geom/Transferrable.hpp"

namespace jafar {
  namespace geom {
    template<int dimension>
    class Point : public Atom<dimension> {
        typedef typename Atom<dimension>::HomogenousVecD HomogenousVecD;
        typedef typename Atom<dimension>::HomogenousSymMatrixD HomogenousSymMatrixD;
        typedef typename Atom<dimension>::VecD VecD;
        typedef typename Atom<dimension>::HomogenousMatrixD HomogenousMatrixD;
        typedef typename Atom<dimension>::SymMatrixD SymMatrixD;
        typedef Repere<dimension> RepereD;
      public:
        class Driver : public Atom<dimension>::Driver {
          public:
            Driver() : Atom<dimension>::Driver(), rangeDimension(0, dimension) { }
            virtual ~Driver() {}
            virtual Driver* clone() const = 0;
            virtual HomogenousVecD homogenousCoordinates() const = 0;
            virtual HomogenousSymMatrixD homogenousCoordinatesCov() const = 0;
          protected:
            ublas::range rangeDimension;
        };
        class EuclideanDriver : public Driver, public Transferrable<dimension>, public Transformable<dimension> {
          public:
            EuclideanDriver(const VecD& coordinates, const RepereD* reference = RepereD::global());
            EuclideanDriver(const VecD& coordinates, const SymMatrixD& matrix, const RepereD* reference = RepereD::global());
            virtual ~EuclideanDriver() {}
            virtual Driver* clone() const
            {
              return new EuclideanDriver(*this);
            }
            virtual HomogenousVecD homogenousCoordinates() const
            {
              return m_coordinates;
            }
            virtual HomogenousSymMatrixD homogenousCoordinatesCov() const
            {
              return m_coordinatesCov;
            }
            virtual void changeReference( const RepereD* reference );
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const { return m_cov; }
            void applyTransformation( const HomogenousMatrixD& _transformation )
            {
              m_coordinates = ublas::prod( _transformation, m_coordinates );
              JFR_ASSERT( not m_cov, "Transformation of covariance not supported" );
            }
          private:
            HomogenousVecD m_coordinates;
            HomogenousSymMatrixD m_coordinatesCov;
            const RepereD* m_reference;
            bool m_cov;
        };
        class HomogenousDriver : public Driver, public Transferrable<dimension>, public Transformable<dimension> {
          public:
            HomogenousDriver(const HomogenousVecD& coordinates, const RepereD* reference = RepereD::global());
            HomogenousDriver(const HomogenousVecD& coordinates, const HomogenousSymMatrixD& matrix, const RepereD* reference = RepereD::global());
            virtual ~HomogenousDriver() {}
            virtual Driver* clone() const
            {
              return new HomogenousDriver(*this);
            }
            virtual HomogenousVecD homogenousCoordinates() const
            {
              return m_coordinates;
            }
            virtual HomogenousSymMatrixD homogenousCoordinatesCov() const
            {
              return m_coordinatesCov;
            }
            virtual void changeReference( const RepereD* reference );
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const { return m_cov; }
            void applyTransformation( const HomogenousMatrixD& _transformation )
            {
              m_coordinates = ublas::prod( _transformation, m_coordinates );
              JFR_ASSERT( not m_cov, "Transformation of covariance not supported" );
            }
          private:
            HomogenousVecD m_coordinates;
            HomogenousSymMatrixD m_coordinatesCov;
            const RepereD* m_reference;
            bool m_cov;
        };
      public:
        inline Point() : Atom<dimension>(0), m_driver(0) {}
        inline Point(Driver* driver) : Atom<dimension>((typename Atom<dimension>::Driver*)driver),  m_driver(driver)
        {
        }
        inline Point(const Point& p) : Atom<dimension>(0), m_driver(0)
        {
          *this = p;
        }
        virtual ~Point() { }
        virtual typename Atom<dimension>::Type type() const { return Atom<dimension>::T_Point; }
        virtual BoundingBox<dimension> boundingBox() const;
        inline HomogenousVecD homogenousCoordinates() const {
          return m_driver->homogenousCoordinates();
        }
        inline HomogenousSymMatrixD homogenousCoordinatesCov() const {
          JFR_ASSERT( this->hasCov(), "This point has no covariance");
          HomogenousSymMatrixD m;
          return m_driver->homogenousCoordinatesCov();
        }
        inline Point& operator=(const Point& rhs);
      public:
        GEN_DISTANCE_FUNCTIONS
        GEN_ANGLE_FUNCTIONS
        GEN_VISITOR_FUNCTIONS
      public:
        virtual std::string toString() const;
      private:
        Driver* m_driver;
    };
    template<int dimension>
    std::ostream& operator <<(std::ostream& s, Point<dimension> const& seg) {
      s << "Point [" << seg.homogenousCoordinates() << " ]";
      return s;
    }
  }
}

#include "PointImpl.hpp"

#endif