HyperPlane.hpp

/* $Id$ */

#ifndef _GEOM_HYPERPLANE_HPP_
#define _GEOM_HYPERPLANE_HPP_

#include "geom/Atom.hpp"
#include "geom/Transferrable.hpp"
#include "geom/Angle.hpp"

namespace jafar {
  namespace geom {
    template<int dimension>
    class Point;
    template<int dimension>
    class Line;
    template<int dimension>
    class HyperPlane : public Atom<dimension> {
      protected:
        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;
        typedef Point<dimension> PointD;
      public:
        class Driver : public Atom<dimension>::Driver {
          public:
            Driver() : Atom<dimension>::Driver()
            {}
            virtual ~Driver() {}
            virtual HomogenousVecD origin() const = 0;
            virtual HomogenousSymMatrixD  originCov() const = 0;
            virtual HomogenousVecD normal() const = 0;
            virtual HomogenousSymMatrixD  normalCov() const = 0;
            virtual HomogenousVecD equation() const = 0;
            virtual Driver* clone() const = 0;
        };
        class EquationDriver : public Driver {
          public:
            EquationDriver() {};
            EquationDriver(const VecD& eqn, double d, const RepereD* reference = RepereD::global());
            EquationDriver(const HomogenousVecD& eqn, const RepereD* reference = RepereD::global());
            virtual HomogenousVecD origin() const;
            virtual HomogenousSymMatrixD  originCov() const;
            virtual HomogenousVecD normal() const;
            virtual HomogenousSymMatrixD  normalCov() const;
            virtual HomogenousVecD equation() const;
            virtual void changeReference( const RepereD* reference );
            virtual const RepereD* reference( ) const;
            virtual Driver* clone() const;
            virtual bool hasCov() const { return false; }
          protected:
            HomogenousVecD m_eqn;
            const RepereD* m_reference;
        };
        class VectorsDriver : public Driver, public Transferrable<dimension> {
          public:
            VectorsDriver(const HomogenousVecD& origin, const HomogenousVecD& normal, const RepereD* reference = RepereD::global());
            VectorsDriver(const VecD& origin, const VecD& normal, const RepereD* reference = RepereD::global());
            void setCov(HomogenousSymMatrixD m_originCov, HomogenousSymMatrixD m_normalCov);
            virtual HomogenousVecD origin() const;
            virtual HomogenousSymMatrixD  originCov() const;
            virtual HomogenousVecD normal() const;
            virtual HomogenousSymMatrixD  normalCov() const;
            virtual HomogenousVecD equation() const;
            virtual void changeReference( const RepereD* reference );
            virtual const RepereD* reference( ) const;
            virtual Driver* clone() const;
            virtual bool hasCov() const { return m_hasCov; }
          private:
            HomogenousVecD m_origin, m_normal;
            HomogenousSymMatrixD m_originCov, m_normalCov;
            const RepereD* m_reference;
            bool m_hasCov;
        };
      public:
        HyperPlane(Driver* d);
        HyperPlane(const HyperPlane& );
        virtual ~HyperPlane();
        virtual typename Atom<dimension>::Type type() const { return Atom<dimension>::T_HyperPlane; }
        virtual BoundingBox<dimension> boundingBox() const;
        inline HomogenousVecD origin() const;
        inline HomogenousVecD normal() const;
        inline HomogenousSymMatrixD normalCov() const;
        inline HomogenousVecD equation() const;
        inline HomogenousVecD project(const HomogenousVecD& p) const;
        inline HomogenousVecD projectionVector(const HomogenousVecD& p) const;
        inline void projectionVectorCov(const HomogenousVecD& p, const HomogenousSymMatrixD& pCov, HomogenousVecD& vec, HomogenousSymMatrixD& cov) const;
        inline void projectionVectorCov(const Point<dimension>& p, HomogenousVecD& vec, HomogenousSymMatrixD& cov) const;
      public:
        GEN_DISTANCE_FUNCTIONS
        GEN_ANGLE_FUNCTIONS
        GEN_VISITOR_FUNCTIONS
      protected:
        void setDriver(Driver* driver);
        Driver* m_driver;
    };
    typedef HyperPlane<3> HyperPlane3D;
    typedef HyperPlane<2> HyperPlane2D;
  }
}

#include "HyperPlaneImpl.hpp"

#endif