AffineTransform.h

#ifndef AFFINETRANSFORM_H
#define AFFINETRANSFORM_H


/*
** ---------------------------------------------------------------
** Includes:
*/
#include <iostream>
#include "defs.h"
#include "Ray.h"
#include "Vector3.h"
#include "Vector4.h"

/*
** ---------------------------------------------------------------
** Definitions:
*/


using namespace std;


//class AffineTransform;

//typedef AffineTransform PercpectiveTransform;


class AffineTransform {


public:


        AffineTransform (void);
        AffineTransform (const Vector4 &r1,const Vector4 &r2,const Vector4 &r3,const Vector4 &r4);
        AffineTransform(const AffineTransform &vector); 
        ~AffineTransform(void);

        Real &operator()(int row, int col);
        Real operator()(int row, int col) const;
        Vector4 row(int i) const;
        Vector4 column(int j) const;
        
        AffineTransform &operator=(const AffineTransform &u);   
        
        void translate(Real tx, Real ty, Real tz);
        void scale(Real sx, Real sy, Real sz);
        void rotate(char axis, Real angle);

        static AffineTransform makeIdentity();
        static AffineTransform makeTranslation(Real tx, Real ty, Real tz);
        static AffineTransform makeScaling(Real sx, Real sy, Real sz);
        static AffineTransform makeRotation(char axis, Real angle);

        Vector4 transform(const Vector4 &w);

private :

        Vector4 r1, r2, r3, r4;
};

AffineTransform operator*(AffineTransform &a, AffineTransform &b);
AffineTransform transpose(const AffineTransform &m);


istream &operator>>(istream &is, AffineTransform &m);
ostream &operator<<(ostream &os, const AffineTransform &m);

inline
AffineTransform::AffineTransform(void)
{
}

inline
AffineTransform::AffineTransform (const Vector4 &r1_,
                                  const Vector4 &r2_,
                                  const Vector4 &r3_,
                                  const Vector4 &r4_)

        : r1(r1_),
          r2(r2_),
          r3(r3_),
          r4(r4_)
{
}

inline
AffineTransform::AffineTransform(const AffineTransform &m)
        : r1(m.row(0)),
          r2(m.row(1)),
          r3(m.row(2)),
          r4(m.row(3))
{
}

inline AffineTransform &
AffineTransform::operator=(const AffineTransform &m)
{
        int i, j;
        for (i = 0; i < 4; i++) {

                r1 = m.row(0);
                r2 = m.row(1);
                r3 = m.row(2);
                r4 = m.row(3);
        }

        return *this;
}

inline Real &
AffineTransform::operator()(int row_, int col_)
{
        return row(row_)(col_);
}

inline Real
AffineTransform::operator()(int row_, int col_) const
{
        return row(row_)(col_);
}

inline Vector4
AffineTransform::row(int i) const
{
        Vector4 row_;
        switch (i) {
        case 0 : 
         row_ = r1;
         break;
        case 1 :
         row_ = r2;
         break;
        case 2 :
         row_ = r3;
         break;
        case 3 :
         row_ = r4;
         break;
        default :
         throw "range violation\n";
        }
        return row_;
}

inline Vector4
AffineTransform::column(int j) const
{
        Vector4 column_;
        switch (j) {
        case 0 : 
         column_(0) = r1(0);column_(1) = r2(0);column_(2) = r3(0);column_(3) = r4(0);
         break;
        case 1 :
         column_(0) = r1(1);column_(1) = r2(1);column_(2) = r3(1);column_(3) = r4(1);
         break;
        case 2 :
         column_(0) = r1(2);column_(1) = r2(2);column_(2) = r3(2);column_(3) = r4(2);
         break;
        case 3 :
         column_(0) = r1(3);column_(1) = r2(3);column_(2) = r3(3);column_(3) = r4(3);
         break;
        default :
         throw "range violation\n";
        }
        return column_;
}

inline void
AffineTransform::translate(Real tx, Real ty, Real tz)
{
        AffineTransform T = AffineTransform::makeTranslation(tx,ty,tz);
        AffineTransform thisT = transpose(*this);
        T = T*thisT;

        r1 = T.row(0);r2 = T.row(1);r3 = T.row(2);r4 = T.row(3);
}

inline void
AffineTransform::scale(Real sx, Real sy, Real sz)
{
        AffineTransform T = AffineTransform::makeScaling(sx,sy,sz);
        AffineTransform thisT = transpose(*this);
        T = T*thisT;

        r1 = T.row(0);r2 = T.row(1);r3 = T.row(2);r4 = T.row(3);
}

inline void
AffineTransform::rotate(char axis, Real angle)
{
        AffineTransform T = AffineTransform::makeRotation(axis,angle);
        AffineTransform thisT = transpose(*this);
        T = T*thisT;

        r1 = T.row(0);r2 = T.row(1);r3 = T.row(2);r4 = T.row(3);
}

inline Vector4
AffineTransform::transform(const Vector4 &w)
{
        return Vector4(w*r1,w*r2,w*r3,w*r4);
}

#endif //AFFINETRANSFORM_H

---