Line.hpp

/* $Id$ */

#ifndef _GEOM_LINE_HPP_
#define _GEOM_LINE_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;
    template<int dimension>
    class Line : public Atom<dimension> {
        typedef typename Atom<dimension>::HomogenousVecD HomogenousVecD;
        typedef typename Atom<dimension>::HomogenousMatrixD HomogenousMatrixD;
        typedef typename Atom<dimension>::HomogenousSymMatrixD HomogenousSymMatrixD;
        typedef typename Atom<dimension>::VecD VecD;
        typedef Repere<dimension> RepereD;
      public: // Drivers
        class Driver : public Atom<dimension>::Driver {
          public:
            Driver() : Atom<dimension>::Driver(), rangeDimension(0, dimension){}
            virtual ~Driver() {}
            virtual HomogenousVecD pointAt(double t) const = 0;
            virtual HomogenousVecD origin() const = 0;
            virtual HomogenousSymMatrixD originCov() const = 0;
            virtual HomogenousVecD direction() const = 0;
            virtual HomogenousSymMatrixD directionCov() const = 0;
            virtual Driver* cloneLineDriver() const = 0;
          protected:
            ublas::range rangeDimension;
        };
        class EuclideanDriver : public Driver, public Transferrable<dimension> {
          public:
            EuclideanDriver(const HomogenousVecD& origin, const HomogenousVecD& direction, const RepereD* reference = RepereD::global());
            EuclideanDriver(const VecD& origin, const VecD& direction, const RepereD* reference = RepereD::global());
            void setCov(HomogenousSymMatrixD m_originCov, HomogenousSymMatrixD m_directionCov);
            virtual HomogenousVecD pointAt(double t) const;
            virtual HomogenousVecD origin() const;
            virtual HomogenousSymMatrixD originCov() const;
            virtual HomogenousVecD direction() const;
            virtual HomogenousSymMatrixD directionCov() const;
            virtual Driver* cloneLineDriver() const;
            virtual void changeReference( const RepereD* reference );
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const { return m_hasCov; }
          private:
            HomogenousVecD m_origin, m_direction;
            HomogenousSymMatrixD m_originCov, m_directionCov;
            const RepereD* m_reference;
            bool m_hasCov;
        };
        class TwoPointsPointerDriver : public Driver {
          public:
            TwoPointsPointerDriver(const Point<dimension>* p1, const Point<dimension>* p2);
            ~TwoPointsPointerDriver();
            virtual HomogenousVecD pointAt(double t) const;
            virtual HomogenousVecD origin() const;
            virtual HomogenousSymMatrixD originCov() const;
            virtual HomogenousVecD direction() const;
            virtual HomogenousSymMatrixD directionCov() const;
            virtual Driver* cloneLineDriver() const;
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const;
          private:
            struct Private;
            Private* const d;
        };
      public:
        Line( Driver* d );
        Line( const Line& l );
        inline Line& operator=(const Line& rhs);
        virtual ~Line();
        virtual typename Atom<dimension>::Type type() const { return Atom<dimension>::T_Line; }
        virtual BoundingBox<dimension> boundingBox() const;
        inline HomogenousVecD pointAt(double t) const;
        inline HomogenousSymMatrixD pointAtCov(double t, double tCov) const;
        inline HomogenousVecD origin() const;
        inline HomogenousSymMatrixD originCov() const;
        inline HomogenousVecD direction() const;
        inline HomogenousSymMatrixD directionCov() const;
        inline HomogenousVecD project(const HomogenousVecD& p) const;
        inline HomogenousVecD project(const Point<dimension>& p) const;
        inline void projectCov( const HomogenousVecD& p, const HomogenousSymMatrixD& pCov, HomogenousVecD& v, HomogenousSymMatrixD& vCov) const;
        inline void projectCov( const Point<dimension>& p, HomogenousVecD& v, HomogenousSymMatrixD& cov) const;
        inline void closestPoint( const Line<dimension>& l, HomogenousVecD& v1, HomogenousVecD& v2) const;
        inline void closestPointCov( const Line<dimension>& l, HomogenousVecD& v1, HomogenousSymMatrixD& cov1, HomogenousVecD& v2, HomogenousSymMatrixD& cov2) const;
        inline Driver* clonedDriver() const;
      public:
        GEN_DISTANCE_FUNCTIONS
        GEN_ANGLE_FUNCTIONS
        GEN_VISITOR_FUNCTIONS
      protected:
        void setDriver(Driver* d);
      private:
        inline void closestPointJac( const HomogenousVecD& O1, const HomogenousVecD& u1, const HomogenousVecD& O2, const HomogenousVecD& u2, HomogenousMatrixD& O1Jac, HomogenousMatrixD& u1Jac, HomogenousMatrixD& O2Jac, HomogenousMatrixD& u2Jac) const;
        Driver* m_driver;
    };
    // Fes usefull typedef
    typedef Line<3> Line3D;
    typedef Line<2> Line2D;
  }
}

#include "geom/LineImpl.hpp"

#endif