OrientedPlanImpl.hpp

/* $Id$ */

namespace jafar {
  namespace geom {

    
    template<int dimension>
    OrientedPlan<dimension>::VectorsDriver::VectorsDriver(const typename geom::Atom<dimension>::HomogenousVecD* repere, const typename geom::Atom<dimension>::HomogenousVecD& origin , const RepereD* reference ) : HyperPlaneD::Driver( ), m_reference(reference)
    {
      for(int i = 0; i < dimension; i++)
      {
        ublas::matrix_column<MatrixD> mc( m_matrix, i);
        HomogenousVecD v = repere[i];
        for(int j = 0; j < i; j++)
        {
          ublas::matrix_column<MatrixD> u( m_matrix, j);
          v -= ublas::inner_prod(repere[i], u) * u;
        }
        v(dimension) = 0.0;
        mc = v / ublas::norm_2(v);
      }
      ublas::matrix_column<MatrixD> mcOrig( m_matrix, dimension);
      mcOrig = origin;
      mcOrig /= mcOrig( dimension);
    }
//     template<int dimension>
//       OrientedPlan<dimension>::PolyLineDriver::PolyLineDriver(const PolyLine<dimension>* polyLine ) : HyperPlaneD::Driver( ), m_polyLine(polyLine)
//     {
//       jblas::vec3 AB = vB - vA;
//       jblas::vec3 AC = vC - vA;
//       jblas::vec3 n;
//       n(0) = AB(1)*AC(2) - AB(2)*AC(1);
//       n(1) = AB(2)*AC(0) - AB(0)*AC(2);
//       n(2) = AB(0)*AC(1) - AB(1)*AC(0);
//       OrientedPlan<dimension>::VectorsDriver::VectorsDriver(, vA);
//     }
    template<int dimension>
    typename OrientedPlan<dimension>::HomogenousVecD OrientedPlan<dimension>::VectorsDriver::origin() const
    {
      return ublas::matrix_column<const MatrixD>( m_matrix, dimension);
    }
    template<int dimension>
    typename OrientedPlan<dimension>::HomogenousVecD OrientedPlan<dimension>::VectorsDriver::vec(unsigned int index) const
    {
      return ublas::matrix_column<const MatrixD>( m_matrix, index);
    }
    template<int dimension>
    void OrientedPlan<dimension>::VectorsDriver::localToReference(typename OrientedPlan<dimension>::MatrixD& dst) const
    {
      dst.assign(m_matrix);
    }
    template<int dimension>
    typename OrientedPlan<dimension>::HomogenousVecD OrientedPlan<dimension>::VectorsDriver::normal() const
    {
      return vec(dimension - 1);
    }
    template<int dimension>
    typename OrientedPlan<dimension>::HomogenousVecD OrientedPlan<dimension>::VectorsDriver::equation() const
    {
      HomogenousVecD eqn;
      ublas::subrange(eqn, 0, dimension ) = normal();
      eqn(dimension) = - ublas::inner_prod(ublas::subrange(eqn, 0, dimension ), ublas::subrange(origin(), 0, dimension));
      return eqn;
    }
    template<int dimension>
    void OrientedPlan<dimension>::VectorsDriver::changeReference( const RepereD* reference )
    {
      MatrixD m;
      reference->repereToLocal(m, this->m_reference);
      
      m_matrix = ublas::prod(m, m_matrix);
      
      this->m_reference = reference;
    }
    template<int dimension>
    const Repere<dimension>* OrientedPlan<dimension>::VectorsDriver::reference( ) const
    {
      return m_reference;
    }
    template<int dimension>
    typename HyperPlane<dimension>::Driver* OrientedPlan<dimension>::VectorsDriver::clone() const
    {
      return new VectorsDriver(*this);
    }
    template<int dimension>
    typename OrientedPlan<dimension>::Driver* OrientedPlan<dimension>::VectorsDriver::cloneOrientedPlanDriver() const
    {
      return new VectorsDriver(*this);
    }
    template<int dimension>
    typename HyperPlane<dimension>::Driver* OrientedPlan<dimension>::VectorsDriver::asHyperPlaneDriver()
    {
      return this;
    }
    
    // RepereDriver
    template<int dimension>
    class OrientedPlan<dimension>::RepereDriver : public RepereD::Driver {
      typedef typename Atom<dimension>::HomogenousVecD HomogenousVecD;
      typedef typename Atom<dimension>::HomogenousMatrixD HomogenousMatrixD;
      public:
        RepereDriver(const OrientedPlan<dimension>* op) : RepereD::Driver( ), m_parent(op)
        {
          
        }
        virtual const RepereD* reference() const
        {
          return m_parent->reference();
        }
        virtual HomogenousVecD origin() const
        {
          return m_parent->origin();
        }
        virtual HomogenousVecD vec(unsigned int index) const
        {
          return m_parent->vec(index);
        }
        virtual void localToReference(MatrixD& m) const
        {
          return m_parent->localToReference(m);
        }
        virtual bool hasCov() const {
          return m_parent->hasCov();
        }
      private:
        const OrientedPlan<dimension>* m_parent;
    };
    template<int dimension>
    OrientedPlan<dimension>::OrientedPlan() : HyperPlaneD(0), m_driver(0)
    {
      m_repere = new RepereD( new RepereDriver(this));
    }
    template<int dimension>
    template<typename _TDriver_>
    OrientedPlan<dimension>::OrientedPlan( _TDriver_* d) : HyperPlaneD(d), m_driver(d)
    {
      m_repere = new RepereD( new RepereDriver(this));
    }
    template<int dimension>
    OrientedPlan<dimension>::OrientedPlan(const OrientedPlan& op) : HyperPlaneD(0), m_driver(op.m_driver->cloneOrientedPlanDriver())
    {
      HyperPlaneD::setDriver( m_driver->asHyperPlaneDriver() );
      m_repere = new RepereD( new RepereDriver(this));
      this->setId( op.id() );
    }
    template<int dimension>
    inline OrientedPlan<dimension>& OrientedPlan<dimension>::operator=(const OrientedPlan& rhs)
    {
      m_driver = rhs.m_driver->cloneOrientedPlanDriver();
      HyperPlaneD::setDriver( m_driver->asHyperPlaneDriver() );
      this->setId( rhs.id() );
      return *this;
    }
    template<int dimension>
    OrientedPlan<dimension>::~OrientedPlan()
    {
      delete m_repere;
    }
    template<int dimension>
    inline typename OrientedPlan<dimension>::HomogenousVecD OrientedPlan<dimension>::vec(unsigned int index) const
    {
      return m_driver->vec( index );
    }
    template<int dimension>
    inline void OrientedPlan<dimension>::localToReference(MatrixD& m) const
    {
      m_driver->localToReference(m);
    }
    template<int dimension>
    inline const Repere<dimension>* OrientedPlan<dimension>::repere() const
    {
      return m_repere;
    }

    
  }
}