CoordinateFrameN.hpp

//============================================================================
//
// This file is part of the Thea toolkit.
//
// This software is distributed under the BSD license, as detailed in the
// accompanying LICENSE.txt file. Portions are derived from other works:
// their respective licenses and copyright information are reproduced in
// LICENSE.txt and/or in the relevant source files.
//
// Author: Siddhartha Chaudhuri
// First version: 2011
//
//============================================================================

#ifndef __Thea_CoordinateFrameN_hpp__
#define __Thea_CoordinateFrameN_hpp__

#include "Common.hpp"
#include "RigidTransformN.hpp"

namespace Thea {

// Forward declarations
template <int N, typename T> class CoordinateFrameN;

namespace Internal {

template <int N, typename T>
class /* THEA_DLL_LOCAL */ CoordinateFrameNBase : public RigidTransformN<N, T>
{
  public:
    typedef CoordinateFrameN<N, T>             CoordinateFrameT;  
    typedef RigidTransformN<N, T>              RigidTransformT;   
    typedef AffineTransformN<N, T>             AffineTransformT;  
    typedef typename RigidTransformT::VectorT  VectorT;
    typedef typename RigidTransformT::MatrixT  MatrixT;

    THEA_DECL_SMART_POINTERS(CoordinateFrameT)

    
    CoordinateFrameNBase() {}

    CoordinateFrameNBase(RigidTransformT const & src) : RigidTransformT(src) {}

    static CoordinateFrameT _fromAffine(AffineTransformT const & aff_)
    {
      return CoordinateFrameT(RigidTransformT::_fromAffine(aff_));
    }

    VectorT getAxis(intx i) const { return this->getRotation().col(i); }

    CoordinateFrameT inverse() const
    {
      return CoordinateFrameT(RigidTransformT::inverse());
    }

    CoordinateFrameT operator*(CoordinateFrameT const & rhs) const
    {
      return CoordinateFrameT(this->RigidTransformT::operator*(rhs));
    }

    VectorT operator*(VectorT const & p) const
    {
      return this->RigidTransformT::operator*(p);
    }

    VectorT pointToWorldSpace(VectorT const & p) const
    {
      return this->RigidTransformT::operator*(p);
    }

    VectorT pointToObjectSpace(VectorT const & p) const
    {
      return (p - this->getTranslation()).transpose() * this->getRotation();
    }

    VectorT vectorToWorldSpace(VectorT const & v) const
    {
      return this->getRotation() * v;
    }

    VectorT vectorToObjectSpace(VectorT const & v) const
    {
      return v.transpose() * this->getRotation();
    }

    VectorT normalToWorldSpace(VectorT const & n) const
    {
      return this->getRotation() * n;
    }

    VectorT normalToObjectSpace(VectorT const & n) const
    {
      return n.transpose() * this->getRotation();
    }

    static CoordinateFrameT const & identity()
    {
      static CoordinateFrameT const idty(RigidTransformT::identity());
      return idty;
    }

  private:
    // Hide these functions from the default interface
    RigidTransformT operator*(RigidTransformT const & rhs) const      { return RigidTransformT(); }
    static RigidTransformT translation(VectorT const & translation_)  { return RigidTransformT(); }

}; // class CoordinateFrameNBase

} // namespace Internal

template <int N, typename T = Real>
class /* THEA_API */ CoordinateFrameN : public Internal::CoordinateFrameNBase<N, T>
{
  private:
    typedef Internal::CoordinateFrameNBase<N, T> BaseT;

  public:
    typedef typename BaseT::RigidTransformT  RigidTransformT;
    typedef typename BaseT::VectorT          VectorT;
    typedef typename BaseT::MatrixT          MatrixT;

    CoordinateFrameN() {}

    CoordinateFrameN(RigidTransformT const & src) : BaseT(src) {}

}; // class CoordinateFrameN

template <int N, typename T>
std::ostream &
operator<<(std::ostream & os, CoordinateFrameN<N, T> const & cf)
{
  return os << cf.toString();
}

} // namespace Thea

#include "CoordinateFrame2.hpp"
#include "CoordinateFrame3.hpp"

#endif