matrixCTA.hpp

//
// Copyright (c) Singular Inversions Inc. 2000.
//
// File:        matrixCTA.hpp
// Description: FutMatrixCTAC class declaration
// Authors:     Andrew Beatty
// Created:     27/06/00
//
// This class represents an affine transform. An affine transform consists of
// a linear transform plus a translation. In homogeneous representation this is
// just a matrix of the form (as a 2D example):
//
//              [ m11 m12 t1 ]          [ x ]           [ x' ]
//              [ m21 m22 t2 ]  *       [ y ]   =       [ y' ]
//              [  0   0   1 ]          [ 1 ]           [ 1  ]
//
// Thus internally we store only (2D example):
//
//              [ m11 m12 ]                             [ t1 ]
//              [ m21 m22 ]             and             [ t2 ]
//
// Note that the group of affine transforms is closed under addition and 
// multplication (as defined on the homogeneous matrix representation) and 
// that the inverse of any non-singular affine transform is also an affine
// transform.
//
#ifndef FR2_MATRIXCTA_HPP
#define FR2_MATRIXCTA_HPP
 
#include "matrixCT.hpp"
#include "vect2.hpp"
 
namespace Fg {
 
// We just use the default copy constructor and operator=, but we add
// a constructor from the linear and translational components.
//
template <class T,const int size>
class FutMatrixCTAC
{
public:
        FutMatrixCTAC() {};
        FutMatrixCTAC(const FR2MatrixCTC<T,size,size>&,         // Construct from a
                                  const FR2MatrixCTC<T,size,1>&);               // linear plus trans.
 
        FutMatrixCTAC   operator*(const FutMatrixCTAC&) const;// Multiply two of these.
 
        FR2MatrixCTC<T,size,size>               m_mat;          // The linear transform component
        FR2MatrixCTC<T,size,1>                  m_vec;          // The translational component
};
 
//***********************************************************************
//                      Aliases
//***********************************************************************
//
typedef FutMatrixCTAC<float,2>          FutMatrix2FAC;
typedef FutMatrixCTAC<double,2>         FutMatrix2DAC;
typedef FutMatrixCTAC<float,3>          FutMatrix3FAC;
typedef FutMatrixCTAC<double,3>         FutMatrix3DAC;
 
//***********************************************************************
//                      Constructor 2
//***********************************************************************
//
template <class T,const int size>
inline FutMatrixCTAC<T,size>::FutMatrixCTAC(
 
        const FR2MatrixCTC<T,size,size>&        m,
        const FR2MatrixCTC<T,size,1>&           t)
        : m_mat(m), m_vec(t) {};
 
//***********************************************************************
//                      Operator*
//***********************************************************************
//
template <class T,const int size>
inline FutMatrixCTAC<T,size> FutMatrixCTAC<T,size>::operator*(
 
        const FutMatrixCTAC<T,size>&    m2) const
{
        FutMatrixCTAC<T,size>   retval;
 
        retval.m_mat =  m_mat * m2.m_mat;
        retval.m_vec =  m_vec + fr2MatMulCT<T,size,size,1>(m_mat,m2.m_vec);
 
        return retval;
}
 
//***********************************************************************
//                      Related Global Functions
//***********************************************************************
//
// If hard-coded 2-vects or 3-vects are being used (for speed) then we 
// want to be compatible with that as well.
//
template <class T>
inline FR2Vect2TC<T>    operator*(
 
        const FutMatrixCTAC<T,2>&       m,
        FR2Vect2TC<T>                           v)
{
        FR2Vect2TC<T>           retval;
 
        retval.x1 = m.m_mat[0][0] * v.x1 + m.m_mat[0][1] * v.x2 + m.m_vec[0][0];
        retval.x2 = m.m_mat[1][0] * v.x1 + m.m_mat[1][1] * v.x2 + m.m_vec[1][0];
 
        return retval;
}
 
template <class T>
inline FR2Vect3TC<T>    operator*(
 
        const FutMatrixCTAC<T,3>&       m,
        FR2Vect3TC<T>                           v)
{
        return FR2Vect3TC<T>(
 
                m.m_mat[0][0]*v.x1 + m.m_mat[0][1]*v.x2 + m.m_mat[0][2]*v.x3 +
                        m.m_vec[0][0],
                m.m_mat[1][0]*v.x1 + m.m_mat[1][1]*v.x2 + m.m_mat[1][2]*v.x3 +
                        m.m_vec[1][0],
                m.m_mat[2][0]*v.x1 + m.m_mat[2][1]*v.x2 + m.m_mat[2][2]*v.x3 +
                        m.m_vec[2][0]);
}
 
template<class T,const int size>
std::ostream& operator<<(std::ostream& s,const FutMatrixCTAC<T,size> &v)
{
    s << "mat: " << v.m_mat << '\n';
    s << "vec: " << v.m_vec << '\n';
        return s;
}
 
}
 
#endif