OrientedPlan.hpp

/* $Id$ */

#ifndef _GEOM_ORIENTED_PLAN_HPP_
#define _GEOM_ORIENTED_PLAN_HPP_

#include "geom/HyperPlane.hpp"
#include "geom/Transferrable.hpp"

namespace jafar {
  namespace geom {
    template<int dimension>
    class OrientedPlan : public HyperPlane<dimension> {
        typedef Repere<dimension> RepereD;
        typedef HyperPlane<dimension> HyperPlaneD;
        typedef typename geom::Atom<dimension>::HomogenousVecD HomogenousVecD;
        typedef typename geom::Atom<dimension>::VecD VecD;
        typedef boost::numeric::ublas::bounded_matrix<double,dimension + 1 ,dimension + 1> MatrixD;
        class RepereDriver;
      public:
        class Driver {
          public:
            virtual ~Driver() {}
            virtual HomogenousVecD vec(unsigned int index) const = 0;
            virtual void localToReference(MatrixD&) const = 0;
            virtual Driver* cloneOrientedPlanDriver() const = 0;
            virtual typename HyperPlaneD::Driver* asHyperPlaneDriver() =0;
        };
        class VectorsDriver : public Driver, public HyperPlaneD::Driver, public Transferrable<dimension>
        {
          public:
            VectorsDriver( const HomogenousVecD* repere, const HomogenousVecD& origin, const RepereD* reference = RepereD::global());
            virtual HomogenousVecD origin() const;
            virtual HomogenousVecD vec(unsigned int index) const;
            virtual void localToReference(MatrixD&) const;
            virtual HomogenousVecD normal() const;
            virtual HomogenousVecD equation() const;
            virtual void changeReference( const RepereD* reference );
            virtual const RepereD* reference( ) const;
            virtual typename HyperPlaneD::Driver* clone() const;
            virtual Driver* cloneOrientedPlanDriver() const ;
            virtual typename HyperPlaneD::Driver* asHyperPlaneDriver();
            virtual bool hasCov() const { return false; }
          private:
            MatrixD m_matrix;
            const RepereD* m_reference;
        };
//         class PolyLineDriver : public Driver, public HyperPlaneD::Driver, public Transferrable<dimension>
//         {
//           public:
//             PolyLineDriver( const PolyLine<dimension>* polyLine);
//             virtual HomogenousVecD vec(unsigned int index) const;
//             virtual void localToReference(MatrixD&) const;
//             virtual Driver* cloneOrientedPlanDriver() const;
//             virtual typename HyperPlaneD::Driver* asHyperPlaneDriver() const;
          
//           private:
//             const PolyLine<dimension>* m_polyLine;
//         };

      public:
        OrientedPlan();
        template<typename _TDriver_>
        OrientedPlan( _TDriver_* d);
        OrientedPlan(const OrientedPlan&);
        ~OrientedPlan();
        inline OrientedPlan& operator=(const OrientedPlan& rhs);
        virtual typename Atom<dimension>::Type type() const { return Atom<dimension>::T_OrientedPlan; }
        inline HomogenousVecD vec(unsigned int index) const;
        inline void localToReference(MatrixD&) const;
        inline const RepereD* repere() const;
      private:
        Driver* m_driver;
        RepereD* m_repere;
    };
  }
}

#include "OrientedPlanImpl.hpp"

#endif