Plane3D.hpp

#ifndef _GEOM_PLANE3D_HPP
#define _GEOM_PLANE3D_HPP

#include "geom/HyperPlane.hpp"
#include "geom/Repere.hpp"
#include "jmath/ublasExtra.hpp"

namespace jafar {
  namespace geom {
    class Plane3D : public HyperPlane<3> {
    public:
      class PointsDriver : public HyperPlane<3>::EquationDriver {
      public:
        PointsDriver(const VecD& p1, const VecD& p2, const VecD& p3,
                     const RepereD* reference = Repere3D::global())
        {
          VecD p1p2 = p2 - p1;
          VecD p1p3 = p3 - p1;
          // n is a normal to the 3D plan
          VecD n; jmath::ublasExtra::crossProd(p1p2, p1p3, n);
          double norm = ublas::norm_2( n );
          m_eqn[3] = 0 - p1[0]*n[0] -p1[1]*n[1] - p1[2]*n[2];
          ublas::subrange(m_eqn, 0, 3 ) = n;
          m_eqn /= norm;
          m_n = m_eqn;
          m_n(3) = 0.0;
        }
      private:
        PointsDriver(const HomogenousVecD& eqn, const HomogenousVecD& n,
                     const RepereD* reference = RepereD::global()) :
          HyperPlane<3>::EquationDriver(eqn, reference), m_n(n) {}
        
      public:
        HomogenousVecD equation() const { return m_eqn; }
        HomogenousVecD origin() 
        {
          HomogenousVecD origin = - m_eqn(3) * m_n;
          origin(3) = 1.0;
          return origin;
        }
        HomogenousVecD normal() const { return m_n; }
        virtual Driver* clone() const 
        {
          return new PointsDriver(m_eqn, m_n, this->reference());
        }
        
      private:
        HomogenousVecD m_n;
      };
      Plane3D(Driver* d) : HyperPlane<3>(d) {};
      Plane3D(const Plane3D &p) :  
        HyperPlane<3>((HyperPlane<3>) p) 
      { 
        using namespace std;
        this->setDriver(p.m_driver->clone());
      }
    };
  }
}

#endif