Matrix.h

浏览该文件的文档.

/************************************************************************
* @file Matrix.h
*
* @brief  矩阵类
*
* @details 矩阵类
*
* @author dixu
*
* @version 1.0
*
* @date 2014-9-11
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef BIMHOMEBASE_MATRIX_H
#define BIMHOMEBASE_MATRIX_H
 
#include <string>
 
#include "Vector3D.h"
#ifndef BH_GLOBAL_H
#include <BHGlobal.h>
#endif
 
namespace Base
{
    enum class ScaleType
    {
        Other = -1,
        NoScaling = 0,
        NonUniformRight = 1,
        NonUniformLeft = 2,
        Uniform = 3
    };
 
    class BaseExport Matrix4D
    {
        typedef float_traits<double> traits_type;   
    public:
 
        Matrix4D();
 
        Matrix4D(float a11, float a12, float a13, float a14,
            float a21, float a22, float a23, float a24,
            float a31, float a32, float a33, float a34,
            float a41, float a42, float a43, float a44);
 
        Matrix4D(double a11, double a12, double a13, double a14,
            double a21, double a22, double a23, double a24,
            double a31, double a32, double a33, double a34,
            double a41, double a42, double a43, double a44);
 
        Matrix4D(const Matrix4D& rclMtrx);
 
        Matrix4D(const Vector3f& rclBase, const Vector3f& rclDir, float fAngle);
 
        Matrix4D(const Vector3d& rclBase, const Vector3d& rclDir, double fAngle);
 
        ~Matrix4D()
        {
        }
 
 
        inline void multVec(const Vector3d& src, Vector3d& dst) const;
 
        inline void multVec(const Vector3f& src, Vector3f& dst) const;
 
        inline Vector3d getRow(unsigned short usNdx) const;
 
        inline Vector3d getCol(unsigned short usNdx) const;
 
        inline Vector3d trace() const;
 
        inline void setRow(unsigned short usNdx, const Vector3d& v);
 
        inline void setCol(unsigned short usNdx, const Vector3d& v);
 
        inline void setTrace(const Vector3d& v);
 
        double determinant() const;
 
        double determinant3() const;
 
        std::string analyse() const;
 
        Matrix4D& Outer(const Vector3d& rV1, const Vector3d& rV2);
 
        Matrix4D& Outer(const Vector3f& rV1, const Vector3f& rV2);
 
        Matrix4D& Hat(const Vector3f& rV);
 
        Matrix4D& Hat(const Vector3d& rV);
        void getMatrix(double dMtrx[16]) const;
 
        void setMatrix(const double dMtrx[16]);
 
        void getGLMatrix(double dMtrx[16]) const;
 
        void setGLMatrix(const double dMtrx[16]);
 
        unsigned long getMemSpace();
 
        void setToUnity();
 
        bool isUnity() const;
 
        void nullify();
 
        bool isNull() const;
 
        void move(float x, float y, float z)
        {
            move(Vector3f(x, y, z));
        }
 
        void move(double x, double y, double z)
        {
            move(Vector3d(x, y, z));
        }
 
        void move(const Vector3f& rclVct);
 
        void move(const Vector3d& rclVct);
 
        void scale(float x, float y, float z)
        {
            scale(Vector3f(x, y, z));
        }
 
        void scale(double x, double y, double z)
        {
            scale(Vector3d(x, y, z));
        }
 
        void scale(const Vector3f& rclVct);
 
        void scale(const Vector3d& rclVct);
 
        void scale(float scalexyz)
        {
            scale(Vector3f(scalexyz, scalexyz, scalexyz));
        }
 
        void scale(double scalexyz)
        {
            scale(Vector3d(scalexyz, scalexyz, scalexyz));
        }
 
        ScaleType hasScale(double tol = 0.0) const;
 
        void rotX(double fAngle);
 
        void rotY(double fAngle);
 
        void rotZ(double fAngle);
 
        void rotLine(const Vector3f& rclVct, float fAngle);
 
        void rotLine(const Vector3d& rclVct, double fAngle);
 
        void rotLine(const Vector3f& rclBase, const Vector3f& rclDir, float fAngle);
 
        void rotLine(const Vector3d& rclBase, const Vector3d& rclDir, double fAngle);
 
        bool toAxisAngle(Vector3f& rclBase, Vector3f& rclDir, float& fAngle, float& fTranslation) const;
 
        bool toAxisAngle(Vector3d& rclBase, Vector3d& rclDir, double& fAngle, double& fTranslation) const;
 
        void transform(const Vector3f& rclVct, const Matrix4D& rclMtrx);
 
        void transform(const Vector3d& rclVct, const Matrix4D& rclMtrx);
 
        void inverse();
 
        void inverseOrthogonal();
 
        void inverseGauss();
 
        void transpose();
 
        void Print() const;
 
        std::string toString() const;
 
        void fromString(const std::string& str);
 
        inline Matrix4D operator + (const Matrix4D& rclMtrx) const;
 
 
        inline Matrix4D& operator += (const Matrix4D& rclMtrx);
 
        inline Matrix4D operator - (const Matrix4D& rclMtrx) const;
 
        inline Matrix4D& operator -= (const Matrix4D& rclMtrx);
 
        inline Matrix4D operator * (const Matrix4D& rclMtrx) const;
 
        inline Matrix4D& operator *= (const Matrix4D& rclMtrx);
 
        inline Vector3f operator * (const Vector3f& rclVct) const;
 
        inline Vector3d operator * (const Vector3d& rclVct) const;
 
        inline Matrix4D operator * (double scalar) const;
 
        inline Matrix4D& operator *= (double scalar);
 
        inline bool operator != (const Matrix4D& rclMtrx) const;
 
        inline bool operator == (const Matrix4D& rclMtrx) const;
 
        inline Matrix4D& operator = (const Matrix4D& rclMtrx);
 
        inline double* operator [] (unsigned short usNdx);
 
        inline const double* operator[] (unsigned short usNdx) const;
 
    private:
        double dMtrx4D[4][4]; 
    };
 
    inline Matrix4D Matrix4D::operator + (const Matrix4D& rclMtrx) const
    {
        Matrix4D clMat;
        unsigned short iz, is;
 
        for (iz = 0; iz < 4; iz++)
        {
            for (is = 0; is < 4; is++)
            {
                clMat.dMtrx4D[iz][is] = dMtrx4D[iz][is] + rclMtrx[iz][is];
            }
        }
 
        return clMat;
    }
 
    inline Matrix4D& Matrix4D::operator += (const Matrix4D& rclMtrx)
    {
        unsigned short iz, is;
 
        for (iz = 0; iz < 4; iz++)
        {
            for (is = 0; is < 4; is++)
            {
                dMtrx4D[iz][is] += rclMtrx[iz][is];
            }
        }
 
        return *this;
    }
 
    inline Matrix4D Matrix4D::operator - (const Matrix4D& rclMtrx) const
    {
        Matrix4D  clMat;
        unsigned short  iz, is;
 
        for (iz = 0; iz < 4; iz++)
        {
            for (is = 0; is < 4; is++)
            {
                clMat.dMtrx4D[iz][is] = dMtrx4D[iz][is] - rclMtrx[iz][is];
            }
        }
 
        return clMat;
    }
 
    inline Matrix4D& Matrix4D::operator -= (const Matrix4D& rclMtrx)
    {
        unsigned short iz, is;
 
        for (iz = 0; iz < 4; iz++)
        {
            for (is = 0; is < 4; is++)
            {
                dMtrx4D[iz][is] -= rclMtrx[iz][is];
            }
        }
 
        return *this;
    }
 
    inline Matrix4D& Matrix4D::operator *= (const Matrix4D& rclMtrx)
    {
        Matrix4D  clMat;
        unsigned short ie, iz, is;
 
        for (iz = 0; iz < 4; iz++)
            for (is = 0; is < 4; is++)
            {
                clMat.dMtrx4D[iz][is] = 0;
                for (ie = 0; ie < 4; ie++)
                    clMat.dMtrx4D[iz][is] += dMtrx4D[iz][ie] *
                    rclMtrx.dMtrx4D[ie][is];
            }
 
        (*this) = clMat;
 
        return *this;
    }
 
    inline Matrix4D Matrix4D::operator * (const Matrix4D& rclMtrx) const
    {
        Matrix4D  clMat;
        unsigned short ie, iz, is;
 
        for (iz = 0; iz < 4; iz++)
            for (is = 0; is < 4; is++)
            {
                clMat.dMtrx4D[iz][is] = 0;
                for (ie = 0; ie < 4; ie++)
                    clMat.dMtrx4D[iz][is] += dMtrx4D[iz][ie] *
                    rclMtrx.dMtrx4D[ie][is];
            }
 
        return clMat;
    }
 
    inline Matrix4D& Matrix4D::operator = (const Matrix4D& rclMtrx)
    {
        unsigned short iz, is;
 
        for (iz = 0; iz < 4; iz++)
        {
            for (is = 0; is < 4; is++)
            {
                dMtrx4D[iz][is] = rclMtrx.dMtrx4D[iz][is];
            }
        }
 
        return *this;
    }
 
    inline Vector3f Matrix4D::operator * (const Vector3f& rclVct) const
    {
        double x = static_cast<double>(rclVct.x);
        double y = static_cast<double>(rclVct.y);
        double z = static_cast<double>(rclVct.z);
        return Vector3f(
            static_cast<float>(dMtrx4D[0][0] * x + dMtrx4D[0][1] * y +
                dMtrx4D[0][2] * z + dMtrx4D[0][3]),
            static_cast<float>(dMtrx4D[1][0] * x + dMtrx4D[1][1] * y +
                dMtrx4D[1][2] * z + dMtrx4D[1][3]),
            static_cast<float>(dMtrx4D[2][0] * x + dMtrx4D[2][1] * y +
                dMtrx4D[2][2] * z + dMtrx4D[2][3])
        );
    }
 
    inline Vector3d Matrix4D::operator * (const Vector3d& rclVct) const
    {
        return Vector3d((dMtrx4D[0][0] * rclVct.x + dMtrx4D[0][1] * rclVct.y +
            dMtrx4D[0][2] * rclVct.z + dMtrx4D[0][3]),
            (dMtrx4D[1][0] * rclVct.x + dMtrx4D[1][1] * rclVct.y +
                dMtrx4D[1][2] * rclVct.z + dMtrx4D[1][3]),
            (dMtrx4D[2][0] * rclVct.x + dMtrx4D[2][1] * rclVct.y +
                dMtrx4D[2][2] * rclVct.z + dMtrx4D[2][3]));
    }
 
    inline void Matrix4D::multVec(const Vector3d& src, Vector3d& dst) const
    {
        double x = (dMtrx4D[0][0] * src.x + dMtrx4D[0][1] * src.y +
            dMtrx4D[0][2] * src.z + dMtrx4D[0][3]);
        double y = (dMtrx4D[1][0] * src.x + dMtrx4D[1][1] * src.y +
            dMtrx4D[1][2] * src.z + dMtrx4D[1][3]);
        double z = (dMtrx4D[2][0] * src.x + dMtrx4D[2][1] * src.y +
            dMtrx4D[2][2] * src.z + dMtrx4D[2][3]);
        dst.Set(x, y, z);
    }
 
    inline void Matrix4D::multVec(const Vector3f& src, Vector3f& dst) const
    {
        double sx = static_cast<double>(src.x);
        double sy = static_cast<double>(src.y);
        double sz = static_cast<double>(src.z);
 
        double x = (dMtrx4D[0][0] * sx + dMtrx4D[0][1] * sy +
            dMtrx4D[0][2] * sz + dMtrx4D[0][3]);
        double y = (dMtrx4D[1][0] * sx + dMtrx4D[1][1] * sy +
            dMtrx4D[1][2] * sz + dMtrx4D[1][3]);
        double z = (dMtrx4D[2][0] * sx + dMtrx4D[2][1] * sy +
            dMtrx4D[2][2] * sz + dMtrx4D[2][3]);
        dst.Set(static_cast<float>(x),
            static_cast<float>(y),
            static_cast<float>(z));
    }
 
    inline Matrix4D Matrix4D::operator * (double scalar) const
    {
        Matrix4D  matrix;
        for (unsigned short i = 0; i < 4; i++)
        {
            for (unsigned short j = 0; j < 4; j++)
            {
                matrix.dMtrx4D[i][j] = dMtrx4D[i][j] * scalar;
            }
        }
 
        return matrix;
    }
 
    inline Matrix4D& Matrix4D::operator *= (double scalar)
    {
        for (unsigned short i = 0; i < 4; i++)
        {
            for (unsigned short j = 0; j < 4; j++)
            {
                dMtrx4D[i][j] *= scalar;
            }
        }
        return *this;
    }
 
    inline bool Matrix4D::operator == (const Matrix4D& rclMtrx) const
    {
        unsigned short iz, is;
 
        for (iz = 0; iz < 4; iz++)
        {
            for (is = 0; is < 4; is++)
            {
                if (fabs(dMtrx4D[iz][is] - rclMtrx.dMtrx4D[iz][is]) > traits_type::epsilon())
                    return false;
            }
        }
 
        return true;
    }
 
    inline bool Matrix4D::operator != (const Matrix4D& rclMtrx) const
    {
        return !((*this) == rclMtrx);
    }
 
    inline Vector3f& operator *= (Vector3f& rclVect,
        const Matrix4D& rclMtrx)
    {
        rclVect = rclMtrx * rclVect;
        return rclVect;
    }
 
    inline double* Matrix4D::operator [] (unsigned short usNdx)
    {
        return dMtrx4D[usNdx];
    }
 
    inline const double* Matrix4D::operator [] (unsigned short usNdx) const
    {
        return dMtrx4D[usNdx];
    }
 
    inline Vector3d Matrix4D::getRow(unsigned short usNdx) const
    {
        return Vector3d(dMtrx4D[usNdx][0], dMtrx4D[usNdx][1], dMtrx4D[usNdx][2]);
    }
 
    inline Vector3d Matrix4D::getCol(unsigned short usNdx) const
    {
        return Vector3d(dMtrx4D[0][usNdx], dMtrx4D[1][usNdx], dMtrx4D[2][usNdx]);
    }
 
    inline Vector3d Matrix4D::trace() const
    {
        return Vector3d(dMtrx4D[0][0], dMtrx4D[1][1], dMtrx4D[2][2]);
    }
 
    inline void Matrix4D::setRow(unsigned short usNdx, const Vector3d& v)
    {
        dMtrx4D[usNdx][0] = v.x;
        dMtrx4D[usNdx][1] = v.y;
        dMtrx4D[usNdx][2] = v.z;
    }
 
    inline void Matrix4D::setCol(unsigned short usNdx, const Vector3d& v)
    {
        dMtrx4D[0][usNdx] = v.x;
        dMtrx4D[1][usNdx] = v.y;
        dMtrx4D[2][usNdx] = v.z;
    }
 
    inline void Matrix4D::setTrace(const Vector3d& v)
    {
        dMtrx4D[0][0] = v.x;
        dMtrx4D[1][1] = v.y;
        dMtrx4D[2][2] = v.z;
    }
 
} // namespace Base
 
 
#endif // BIMHOMEBASE_MATRIX_H