_Matrix3.h

Go to the documentation of this file.

#ifndef __VECMATH_MATRIX3_HPP
#define __VECMATH_MATRIX3_HPP

#include <vecmath/Export>
template <class Type> class VECMATH_EXPORT _Matrix3;

#ifndef __VECMATH_VECTOR3_HPP
#include <vecmath/_Vector3.h>
#endif

#ifndef __VECMATH_VECTOR4_HPP
#include <vecmath/_Vector4.h>
#endif

#ifndef __VECMATH_QUAT4_HPP
#include <vecmath/_Quat4.h>
#endif

//#ifndef __VECMATH_AXISANGLE4_HPP
//#include <vecmath/_AxisAngle4.h>
//#endif


//#define DEBUGMATRIX3(d) d
#define DEBUGMATRIX3(d)

//template <class Type> ostream& operator <<(ostream& os, const _Matrix3<Type>& m);
//template <class Type> ostream& operator <<(ostream& os, const _Matrix3<Type>* m);

template <class Type> class VECMATH_EXPORT _Matrix3 {
public:
        static const Type EPS;// = 1e-16;
    static const Type ERR_EPS;// = 1e-08;

        Type    m00, m01, m02,
            m10, m11, m12,
            m20, m21, m22;

    _Matrix3<Type>() {}

    _Matrix3<Type>(Type s) {
        set(s);
        DEBUGMATRIX3(cout << "_Matrix3 constructor scale " << endl << *this << endl);
    }

    // thinking about leaving the matrix unmodified for empty contructor
    // to safe couple of vasted cycles
    explicit _Matrix3<Type>(Type m00    , Type m01 = 0, Type m02 = 0,
                            Type m10 = 0, Type m11 = 0, Type m12 = 0,
                            Type m20 = 0, Type m21 = 0, Type m22 = 0) {
        set(m00, m01, m02,
            m10, m11, m12,
            m20, m21, m22);
        DEBUGMATRIX3(cout << "_Matrix3 constructor R9 " << endl << *this << endl);
    }

    _Matrix3<Type>(const _Matrix3<double>& m) {
        set(m);
        DEBUGMATRIX3(cout << "_Matrix3 constructor &double " << endl << *this << endl);
    }

    _Matrix3<Type>(const _Matrix3<float>& m) {
        set(m);
        DEBUGMATRIX3(cout << "_Matrix3 constructor &float " << endl << *this << endl);
    }

    _Matrix3<Type>(const Type v[9]) {
        set(v);
        DEBUGMATRIX3(cout << "_Matrix3 constructor t[9] " << endl << *this << endl);
    }

#if 0
    //extension
    _Matrix3<Type>(const _AxisAngle4<double>& a) {
        set(a);
        DEBUGMATRIX3(cout << "_Matrix3 constructor &AxisAngle4d " << endl << *this << endl);
    }
    //extension
    _Matrix3<Type>(const _AxisAngle4<float>& a) {
        set(a);
        DEBUGMATRIX3(cout << "_Matrix3 constructor &AxisAngle4f " << endl << *this << endl);
    }
#endif

    void add(Type d);
    void add(Type d, const _Matrix3<Type>& m);
    void add(const _Matrix3<Type>& m);
    void add(const _Matrix3<Type>& m, const _Matrix3<Type>& m1);

    static void compute_svd(double ad[], double ad1[], double ad2[], bool flag);

    Type determinant(void) const {
        return determinant3x3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
    }

    bool epsilonEquals(const _Matrix3<Type>& m, Type d) const;
    bool equals(const _Matrix3<Type>& m) const;
    void getColumn(int column, _Vector3<Type>& v) const;
    void getColumn(int column, Type ad[]) const;
    Type getElement(int row, int column) const;
    void getRow(int row, _Vector3<Type>& v) const;
    void getRow(int row, Type ad[3]) const;

    void get(float ad[9]) const {
        ad[0] = m00;
        ad[1] = m01;
        ad[2] = m02;
        ad[3] = m10;
        ad[4] = m11;
        ad[5] = m12;
        ad[6] = m20;
        ad[7] = m21;
        ad[8] = m22;
    }

    void get(double ad[9]) const {
        ad[0] = m00;
        ad[1] = m01;
        ad[2] = m02;
        ad[3] = m10;
        ad[4] = m11;
        ad[5] = m12;
        ad[6] = m20;
        ad[7] = m21;
        ad[8] = m22;
    }

    Type getScale() const {
        double tmp_scale[3];
        double tmp_rot[9];
        getScaleRotate(tmp_scale, tmp_rot);
        return Math::max3(tmp_scale);
    }

    void getScaleRotate(double ad[3], double ad1[9]) const {
        double tmp[9];

        get(tmp);
        compute_svd(tmp, ad, ad1, false);
    }

    void invert() {
        invert(*this);
    }

    void invert(const _Matrix3<Type>& m);

    void mul(Type d);
    void mul(Type d, const _Matrix3<Type>& m);

    void mul(const _Matrix3<Type>& m) {
        mul(*this, m);
    }

    void mul(const _Matrix3<Type>& m, const _Matrix3<Type>& m1);

    void mulNormalize(const _Matrix3<Type>& m) {
        mulNormalize(*this, m);
    }

    void mulNormalize(const _Matrix3<Type>& m, const _Matrix3<Type>& m1);
    void mulTransposeBoth(const _Matrix3<Type> m, const _Matrix3<Type>& m1);
    void mulTransposeLeft(const _Matrix3<Type>& m, const _Matrix3<Type>& m1);
    void mulTransposeRight(const _Matrix3<Type>& m, const _Matrix3<Type>& m1);

    void negate() {
        negate(*this);
    }

    void negate(const _Matrix3<Type>& m);
    void normalize();
    void normalize(const _Matrix3<Type>& m);

    void normalizeCP() {
        normalizeCP(*this);
    }

    void normalizeCP(const _Matrix3<Type>& m);
    void rotX(Type angle);
    void rotY(Type angle);
    void rotZ(Type angle);

    void set(Type mm00, Type mm01, Type mm02,
             Type mm10, Type mm11, Type mm12,
             Type mm20, Type mm21, Type mm22) {
        m00 = mm00, m01 = mm01, m02 = mm02;
        m10 = mm10, m11 = mm11, m12 = mm12;
        m20 = mm20, m21 = mm21, m22 = mm22;
    }

    void set(Type d) {
        set(d  , 0.0, 0.0,
            0.0,   d, 0.0,
            0.0, 0.0,   d);
    }

#if 0
    void set(const _AxisAngle4<double>& aa) {
        setAxisAngle(aa.x, aa.y, aa.z, aa.angle);
    }

    void set(const _AxisAngle4<float>& aa) {
        setAxisAngle(aa.x, aa.y, aa.z, aa.angle);
    }
#endif

public:
    void set(const _Matrix3<double>& m) {
        set(m.m00, m.m01, m.m02,
            m.m10, m.m11, m.m12,
            m.m20, m.m21, m.m22);
    }

    void set(const _Matrix3<float>& m) {
        set(m.m00, m.m01, m.m02,
            m.m10, m.m11, m.m12,
            m.m20, m.m21, m.m22);
    }

#if 0
    // extension
    void set(const _Matrix4<double>& m) {
        set(m.m00, m.m01, m.m02,
            m.m10, m.m11, m.m12,
            m.m20, m.m21, m.m22);
    }

    // extension
    void set(const _Matrix4<float>& m) {
        set(m.m00, m.m01, m.m02,
            m.m10, m.m11, m.m12,
            m.m20, m.m21, m.m22);
    }
#endif

    void set(const _Quat4<double>& q) {
        setQuat(q.x, q.y, q.z, q.w);
    }

    void set(const _Quat4<float>& q) {
        setQuat(q.x, q.y, q.z, q.w);
    }

    void set(const double at[9]) {
        set(at[0], at[1], at[2],
            at[3], at[4], at[5],
            at[6], at[7], at[8]);
    }

    void set(const float at[9]) {
        set(at[0], at[1], at[2],
            at[3], at[4], at[5],
            at[6], at[7], at[8]);
    }

    void setColumn(int column, Type x, Type y, Type z) {
        switch (column) {
        case 0:
            m00 = x;
            m10 = y;
            m20 = z;
            break;
        case 1:
            m01 = x;
            m11 = y;
            m21 = z;
            break;
        case 2:
            m02 = x;
            m12 = y;
            m22 = z;
            break;
        default:
            break;
        }
    }

    void setColumn(int column, const _Vector3<Type>& at) {
        switch(column) {
        case 0:
            m00 = at.x;
            m10 = at.y;
            m20 = at.z;
            break;
        case 1:
            m01 = at.x;
            m11 = at.y;
            m21 = at.z;
            break;
        case 2:
            m02 = at.x;
            m12 = at.y;
            m22 = at.z;
            break;
        default:
            break;
        }
    }

    void setColumn(int column, const Type v[3]) {
        switch(column) {
        case 0:
            m00 = v[0];
            m10 = v[1];
            m20 = v[2];
            break;
        case 1:
            m01 = v[0];
            m11 = v[1];
            m21 = v[2];
            break;
        case 2:
            m02 = v[0];
            m12 = v[1];
            m22 = v[2];
            break;
        default:
            break;
        }
    }

    void setElement(int row, int column, Type value) {
        switch(row) {
        case 0:
            switch(column) {
            case 0: m00 = value; break;
            case 1: m01 = value; break;
            case 2: m02 = value; break;
            }
            break;
        case 1:
            switch(column) {
            case 0: m10 = value; break;
            case 1: m11 = value; break;
            case 2: m12 = value; break;
            }
            break;
        case 2:
            switch(column) {
            case 0: m20 = value; break;
            case 1: m21 = value; break;
            case 2: m22 = value; break;
            }
            break;
        }
    }

    void setIdentity() {
        set(1.0);
    }

    void setRow(int row, Type x, Type y, Type z);
    void setRow(int row, const _Vector3<Type>& v);
    void setRow(int row, const Type v[]);

    void setScale(Type d) {
        double tmp_scale[3];
        double tmp_rot[9];
        getScaleRotate(tmp_scale, tmp_rot);
        set(tmp_rot[0] * d, tmp_rot[1] * d, tmp_rot[2] * d,
            tmp_rot[3] * d, tmp_rot[4] * d, tmp_rot[5] * d,
            tmp_rot[6] * d, tmp_rot[7] * d, tmp_rot[8] * d);
    }

    void setZero() {
        set(0.0);
    }

    void sub(const _Matrix3<Type>& m);
    void sub(const _Matrix3<Type>& m, const _Matrix3<Type>& m1);

    // extension
    void set(const _Vector3<Type>& v) {
        set(v.x, 0.0, 0.0,
            0.0, v.y, 0.0,
            0.0, 0.0, v.z);
    }

    // extension
    void swapRow(int row1, int row2) {
        if (row1 > row2)
            Math::swap(row1, row2);
        else if (row1 == row2)
            return;

        if (row1 < row2) {
            if (row1 == 0) {
                if (row2 == 1) {
                    Math::swap(m00, m10);
                    Math::swap(m01, m11);
                    Math::swap(m02, m12);
                } else {
                    Math::swap(m00, m20);
                    Math::swap(m01, m21);
                    Math::swap(m02, m22);
                }
            } else {
                Math::swap(m10, m20);
                Math::swap(m11, m21);
                Math::swap(m12, m22);
            }
        }
    }

    // extension
    void swapColumn(int col1, int col2) {
        if (col1 > col2)
            Math::swap(col1, col2);
        else if (col1 == col2)
            return;

        if (col1 < col2) {
            if (col1 == 0) {
                if (col2 == 1) {
                    Math::swap(m00, m01);
                    Math::swap(m10, m11);
                    Math::swap(m20, m21);
                } else {
                    Math::swap(m00, m02);
                    Math::swap(m10, m12);
                    Math::swap(m20, m22);
                }
            } else {
                Math::swap(m01, m02);
                Math::swap(m11, m12);
                Math::swap(m21, m22);
            }
        }
    }

//      String& toString() {
//          return m00 + ", " + m01 + ", " + m02 + "\n" + m10 + ", " + m11 + ", " + m12 + "\n" + m20 + ", " + m21 + ", " + m22 + "\n";
//      }

    void transform(_Tuple3<Type>& t) const {
        transform(t, t);
    }

    void transform(const _Tuple3<Type>& t, _Tuple3<Type>& t1) const;

    void transpose(void) {
        Math::swap(m10, m01);
        Math::swap(m20, m02);
        Math::swap(m12, m21);
    }

    void transpose(const _Matrix3<Type>& m);

    operator const Type * () const {
        return &m00;
    }

    Type& operator ()(int row, int column) const {
        return (Type &)(*((operator const Type *()) + row * 3 + column));
        //return ((Type*)this)[row * 3 + column];
    }

//    friend ostream & operator << <>(ostream &, const _Matrix3<Type>& );
//    friend ostream & operator << <>(ostream &, const _Matrix3<Type>* );

    static Type determinant2x2(Type a, Type b, Type c, Type d) {
        return a * d - b * c;
    }

    static Type determinant3x3(Type a1, Type a2, Type a3,
                              Type b1, Type b2, Type b3,
                              Type c1, Type c2, Type c3) {
        return (a1 * determinant2x2(b2, b3, c2, c3) -
                b1 * determinant2x2(a2, a3, c2, c3) +
                c1 * determinant2x2(a2, a3, b2, b3));
    }

private:
    void setAxisAngle(Type x, Type y, Type z, Type angle);
    void setQuat(Type x, Type y, Type z, Type w);
};

#endif

---