PointImpl.hpp

/* $Id$ */

#include "Line.hpp"
#include "Repere.hpp"

#include <jmath/ublasExtra.hpp>
#include <sstream>

#include <geom/BoundingBox.hpp>

namespace jafar {
  namespace geom {
    
    //-------------------------- HomogenousDriver --------------------------//
    template<int dimension>
    Point<dimension>::HomogenousDriver::HomogenousDriver(const HomogenousVecD& coordinates , const RepereD* reference ) :
        Driver(),
        m_coordinates(coordinates),
        m_coordinatesCov( jblas::zero_mat( dimension + 1, dimension + 1) ),
        m_reference(reference),
        m_cov( false )
    {
      m_coordinates /= m_coordinates(dimension);
    }
    
    template<int dimension>
    Point<dimension>::HomogenousDriver::HomogenousDriver(const HomogenousVecD& coordinates , const HomogenousSymMatrixD& matrix, const RepereD* reference ) :
        Driver(),
        m_coordinates(coordinates),
        m_coordinatesCov(matrix),
        m_reference(reference),
        m_cov( true )
    {
      
      m_coordinates /= m_coordinates(dimension);
    }
    
    template<int dimension>
    void Point<dimension>::HomogenousDriver::changeReference( const RepereD* reference )
    {
      typename Atom<dimension>::HomogenousMatrixD m;
      this->m_reference->localToRepere(m, reference);
      m_coordinates = ublas::prod(m, m_coordinates);
      this->m_reference = reference;
    }

    template<int dimension>
    const Repere<dimension>* Point<dimension>::HomogenousDriver::reference( ) const
    {
      return m_reference;
    }

    //-------------------------- EuclideanDriver --------------------------//
    template<int dimension>
    Point<dimension>::EuclideanDriver::EuclideanDriver(const VecD& coordinates, const RepereD* reference ) :
        Driver(),
        m_coordinatesCov( jblas::zero_mat( dimension + 1, dimension + 1) ),
        m_reference(reference),
        m_cov( false )
    {
      m_coordinates(dimension) = 1.0;
      ublas::vector_range<HomogenousVecD>(m_coordinates, this->rangeDimension) = coordinates;
    }
    
    template<int dimension>
    Point<dimension>::EuclideanDriver::EuclideanDriver(const VecD& coordinates, const SymMatrixD& matrix, const RepereD* reference ) :
        Driver(),
        m_coordinatesCov( jblas::zero_mat( dimension + 1, dimension + 1) ),
        m_reference(reference),
        m_cov( true )
    {
      m_coordinates(dimension) = 1.0;
      ublas::vector_range<HomogenousVecD>(m_coordinates, this->rangeDimension) = coordinates;
      ublas::matrix_range<HomogenousSymMatrixD>( m_coordinatesCov, this->rangeDimension, this->rangeDimension ) = matrix;
    }
    
    template<int dimension>
    void Point<dimension>::EuclideanDriver::changeReference( const RepereD* reference )
    {
      typename Atom<dimension>::HomogenousMatrixD m;
      this->m_reference->localToRepere(m, reference);
      m_coordinates = ublas::prod(m, m_coordinates);
      this->m_reference = reference;
    }
    template<int dimension>
    const Repere<dimension>* Point<dimension>::EuclideanDriver::reference( ) const
    {
      return m_reference;
    }
    
    //-------------------------- Point --------------------------//
    template<int dimension>
    inline Point<dimension>& Point<dimension>::operator=(const Point& rhs)
    {
      delete m_driver;
      if(rhs.m_driver)
      {
        m_driver = rhs.m_driver->clone();
        Atom<dimension>::setDriver(m_driver);
      } else {
        m_driver = 0;
        this->setDriver(0);
      }
      this->setId( rhs.id() );
      return *this;
    }
    template<int dimension>
    inline BoundingBox<dimension> Point<dimension>::boundingBox() const
    {
      HomogenousVecD v = this->reference()->convertInGlobal( this->homogenousCoordinates());
      return BoundingBox<dimension>(v, v);
    }
    template<int dimension>
    std::string Point<dimension>::toString() const
    {
      std::ostringstream oss;
      oss << Atom<dimension>::toString() << " Coordinates = " << homogenousCoordinates();
      return oss.str();
    }
  }
}