Matrix.h

// Matrix.h: interface for the CMatrix class.
//

#if !defined(LST_MATRIX_H__INCLUDED_)
#define LST_MATRIX_H__INCLUDED_

#pragma once

#include "Utility/DPoint.h"
#include <cmath>

namespace Larson
{
        class CMatrix
        {
        public:
                CMatrix() { setToIdentity();  };
                CMatrix(double* mat) { setTransform(mat); };
                CMatrix(double r0c0, double r0c1, double r1c0, double r1c1, double r2c0, double r2c1) 
                { 
                        setTransform(r0c0, r0c1, r1c0, r1c1, r2c0, r2c1);
                }

                ~CMatrix() { };

                void setToIdentity() {  matrix[0] = 1.0; matrix[1] = 0.0;
                                                                matrix[2] = 0.0; matrix[3] = 1.0;
                                                                matrix[4] = 0.0; matrix[5] = 0.0;
                };

                //                                       a            b            c            d            e            f 
                void setTransform(double r0c0, double r0c1, double r1c0, double r1c1, double r2c0, double r2c1) 
                {
                        matrix[0] = r0c0; matrix[1] = r0c1;     // a   b
                        matrix[2] = r1c0; matrix[3] = r1c1;     // c   d
                        matrix[4] = r2c0; matrix[5] = r2c1;     // e   f
                }

                void setTransform(double* mat) { 

                        matrix[0] = mat[0];
                        matrix[1] = mat[1];
                        matrix[2] = mat[2];
                        matrix[3] = mat[3];
                        matrix[4] = mat[4];
                        matrix[5] = mat[5];
                }

                void multiply(CMatrix &mat)
                {
                        double a1 = matrix[0];
                        double b1 = matrix[1];
                        double c1 = matrix[2];
                        double d1 = matrix[3];

                        matrix[0] = mat.matrix[0] * a1 + mat.matrix[1] * c1;
                        matrix[1] = mat.matrix[0] * b1 + mat.matrix[1] * d1;
                        matrix[2] = mat.matrix[2] * a1 + mat.matrix[3] * c1;
                        matrix[3] = mat.matrix[2] * b1 + mat.matrix[3] * d1;
                        matrix[4] = mat.matrix[4] * a1 + mat.matrix[5] * c1 + matrix[4];
                        matrix[5] = mat.matrix[4] * b1 + mat.matrix[5] * d1 + matrix[5];
                }

                void scale(DPoint scl) { scale(scl.x, scl.y); };
                void scale(double x, double y) 
                { 
                        CMatrix scaleMatrix( x, 0.0, 0.0, y, 0.0, 0.0);

                        multiply(scaleMatrix);
                }

                void rotate(double radians) 
                { 
                        CMatrix rotateMatrix(cos(radians), sin(radians), -sin(radians), cos(radians), 0.0, 0.0);

                        multiply(rotateMatrix);
                }

                void translate(DPoint trans) { translate(trans.x, trans.y); };
                void translate(double x, double y)
                {
                        CMatrix transMatrix(1.0, 0.0, 0.0, 1.0, x, y);

                        multiply(transMatrix);
                }

                bool operator==(CMatrix& mat) 
                {
                        int i;

                        for (i = 0; i < 6; i++)
                        {
                                if (matrix[i] != mat.matrix[i])
                                        return false;
                        }
                        return true;
                }

                bool operator!=(CMatrix& mat) 
                {
                        int i;

                        for (i = 0; i < 6; i++)
                        {
                                if (matrix[i] != mat.matrix[i])
                                        return true;
                        }
                        return false;
                }
                        
                void operator*=(CMatrix& mat) { multiply(mat); };
                
                inline DPoint transformPt(DPoint point)
                {
                        DPoint newPt;

                        newPt.x = (point.x * matrix[0]) + (point.y * matrix[2]) + matrix[4];    // ax + cy + tx
                        newPt.y = (point.x * matrix[1]) + (point.y * matrix[3]) + matrix[5];    // bx + dy + ty

                        return newPt;
                }

                inline DPoint transformVec(DPoint vec)
                {
                        DPoint newVec;

                        newVec.x = (vec.x * matrix[0]) + (vec.y * matrix[2]);
                        newVec.y = (vec.x * matrix[1]) + (vec.y * matrix[3]);

                        return newVec;
                }

                double matrix[6];
        };
};

#endif //       LST_MATRIX_H__INCLUDED_