AffineTransformN.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_AffineTransformN_hpp__
#define __Thea_AffineTransformN_hpp__

#include "Common.hpp"
#include "MatVec.hpp"
#include <sstream>

namespace Thea {

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

namespace Internal {

template <int N, typename T>
class /* THEA_DLL_LOCAL */ AffineTransformNBase
{
  public:
    typedef AffineTransformN<N, T>  AffineTransformT;  
    typedef Vector<N, T>            VectorT;           
    typedef Matrix<N, N, T>         MatrixT;           

    THEA_DECL_SMART_POINTERS(AffineTransformT)

    
    AffineTransformNBase() {}

    AffineTransformNBase(MatrixT const & linear_, VectorT const & translation_) : linear(linear_), trans(translation_) {}

    template <typename U> AffineTransformN<N, U> cast() const
    {
      return AffineTransformN<N, U>(linear.template cast<U>(), trans.template cast<U>());
    }

    static AffineTransformT scaling(VectorT const & s)
    {
      return AffineTransformT(Math::scaling(s), VectorT::Zero());
    }

    static AffineTransformT scaling(T const & s)
    {
      return AffineTransformT(Math::scaling<N>(s), VectorT::Zero());;
    }

    static AffineTransformT translation(VectorT const & v)
    {
      return AffineTransformT(MatrixT::Identity(), v);
    }

    void setIdentity() { *this = identity(); }

    MatrixT const & getLinear() const { return linear; }

    MatrixT & getLinear() { return linear; }

    void setLinear(MatrixT const & linear_) { linear = linear_; }

    VectorT const & getTranslation() const { return trans; }

    VectorT & getTranslation() { return trans; }

    void setTranslation(VectorT const & translation_) { trans = translation_; }

    Matrix<N + 1, N + 1, T> homogeneous() const
    {
      Matrix<N + 1, N + 1, T> m = Matrix<N + 1, N + 1, T>::Identity();
      for (intx i = 0; i < N; ++i)
      {
        for (intx j = 0; j < N; ++j)
          m(i, j) = linear(i, j);

        m(i, N) = trans[i];
      }

      return m;
    }

    Matrix<N, N + 1, T> toMatrix() const
    {
      Matrix<N, N + 1, T> m;
      for (intx i = 0; i < N; ++i)
      {
        for (intx j = 0; j < N; ++j)
          m(i, j) = linear(i, j);

        m(i, N) = trans[i];
      }

      return m;
    }

    AffineTransformT inverse() const
    {
      MatrixT inv = linear.inverse();
      return AffineTransformT(inv, inv * (-trans));
    }

    T operator()(intx i, intx j) const
    {
      debugAssertM(i >= 0 && i < N && j >= 0 && j <= N, "AffineTransformT: Index out of bounds");
      return j == N ? trans[i] : linear(i, j);
    }

    T & operator()(intx i, intx j)
    {
      debugAssertM(i >= 0 && i < N && j >= 0 && j <= N, "AffineTransformT: Index out of bounds");
      return j == N ? trans[i] : linear(i, j);
    }

    AffineTransformT operator*(AffineTransformT const & rhs) const
    {
      return AffineTransformT(linear * rhs.linear, linear * rhs.trans + trans);
    }

    VectorT operator*(VectorT const & v) const { return linear * v + trans; }

    std::string toString() const
    {
      std::ostringstream oss;
      oss << "[L: " << Thea::toString(linear) << ", T: " << Thea::toString(trans) << ']';
      return oss.str();
    }

    static AffineTransformT const & identity()
    {
      static AffineTransformT const idty(MatrixT::Identity(), VectorT::Zero());
      return idty;
    }

  private:
    MatrixT linear;  
    VectorT trans;   

}; // class AffineTransformNBase

} // namespace Internal

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

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

    AffineTransformN() {}

    AffineTransformN(MatrixT const & linear_, VectorT const & translation_ = VectorT::Zero()) : BaseT(linear_, translation_) {}

    AffineTransformN(AffineTransformN const & src) : BaseT(src) {}

}; // class AffineTransformN

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

} // namespace Thea

#include "AffineTransform2.hpp"
#include "AffineTransform3.hpp"

#endif