Matrix4x4.h

Go to the documentation of this file.

#ifndef MATRIX4x4_H
#define MATRIX4x4_H

#include <iostream>

#include "AffPoint.h"
#include "AffVector.h"
#include "Matrix3x3.h"

namespace cryph
{

class ProjPoint;
class ViewVolume;

class Matrix4x4
{
public:
    Matrix4x4();

    Matrix4x4(const Matrix4x4& m);

    Matrix4x4(
        double m11, double m12, double m13, double m14,
        double m21, double m22, double m23, double m24,
        double m31, double m32, double m33, double m34,
        double m41, double m42, double m43, double m44);

    Matrix4x4(const Matrix3x3& M);

    Matrix4x4(const Matrix3x3& M, const AffVector& t);

    Matrix4x4(const Matrix3x3& M, const AffPoint& FixedPoint);

    // From an affine matrix M and a point whose pre- and post-image are known
    Matrix4x4(const Matrix3x3& M,
            const AffPoint& PreImage, const AffPoint& PostImage);

    virtual ~Matrix4x4();

    static Matrix4x4 fromColMajor(const float* m);

    static Matrix4x4 fromColMajor(const double* m);

    static Matrix4x4 fromRowMajor(const float* m);

    static Matrix4x4 fromRowMajor(const double* m);

    static Matrix4x4 generalRotationDegrees(const AffPoint& B,
        const AffVector& axis, double angle);

    static Matrix4x4 generalRotationRadians(const AffPoint& B,
        const AffVector& axis, double angle);

    static Matrix4x4 mirror(const AffPoint& B, const AffVector& n);

    static Matrix4x4 xRotationDegrees(double angle);

    static Matrix4x4 yRotationDegrees(double angle);

    static Matrix4x4 zRotationDegrees(double angle);

    static Matrix4x4 xRotationRadians(double angle);

    static Matrix4x4 yRotationRadians(double angle);

    static Matrix4x4 zRotationRadians(double angle);

    static Matrix4x4 translation(const AffVector& trans);

    static Matrix4x4 translation(double dx, double dy, double dz);

    static Matrix4x4 scale(double sx, double sy, double sz);

    static Matrix4x4 lookAt(const cryph::AffPoint& eye,
                            const cryph::AffPoint& center,
                            const cryph::AffVector& up);

    static Matrix4x4 orthogonal(double xmin, double xmax, double ymin,
                double ymax, double zmin, double zmax);

    static Matrix4x4 oblique(double zpp, double xmin, double xmax, double ymin,
                double ymax, double zmin, double zmax,
                const cryph::AffVector& projDir);

    static Matrix4x4 perspective(double zpp, double xmin, double xmax,
            double ymin, double ymax, double zmin, double zmax, double h=0.0);

    static bool getECvw(const cryph::AffPoint& eye,
            const cryph::AffPoint& center, const cryph::AffVector& up,
            cryph::AffVector& v, cryph::AffVector& w);

    Matrix4x4 operator=(const Matrix4x4& rhs);

    Matrix4x4 operator*=(const Matrix4x4& rhs);

    Matrix4x4 operator*=(double f);

    Matrix4x4 operator+=(const Matrix4x4& rhs);

    AffPoint operator*(const AffPoint& p) const;

    ProjPoint operator*(const ProjPoint& p) const;

    AffVector operator*(const AffVector& v) const;

    Matrix4x4 operator*(const Matrix4x4& m2) const;

    Matrix4x4 operator+(const Matrix4x4& m2) const;

    Matrix4x4 operator-(const Matrix4x4& m2) const;

    friend Matrix4x4 operator*(double f, const Matrix4x4& m);

    friend std::ostream& operator<<(std::ostream& os, const Matrix4x4& m);
    friend std::istream& operator>>(std::istream& is, Matrix4x4& m);

    double determinant() const;

    double elementAt(int r, int c) const;

    float* extractColMajor(float m[16]) const;

    double* extractColMajor(double m[16]) const;

    float* extractRowMajor(float m[16]) const;

    double* extractRowMajor(double m[16]) const;

    void extractAffineMt(Matrix3x3& M, AffVector& t) const;

    int extractAxisAngle(AffPoint& B, AffVector& w, double& theta,
                    AffVector& postTranslation) const;

    bool inverse(Matrix4x4& mInv) const;

    int isAffineTransformation() const;

    void multiply(const double a[], double b[], int nElements=4) const;

    void multiply(const float a[], float b[], int nElements=4) const;

    void setElementAt(int r, int c, double newValue);

    Matrix3x3 subMatrix(int skipRow, int skipCol) const;

    // 1. Special Matrices
    static const Matrix4x4 IdentityMatrix; 
    static const Matrix4x4 ZeroMatrix; 
    // 2. Return codes for extraction of base point, unit axis vector,
    //    and rotation angle from 4x4 matrices that are 'supposed to
    //    describe' affine transformations whose upper 3x3 matrix is
    //    'supposed to be' orthogonal and right-handed. (See the Matrix3x3
    //    method "extractAxisAngle".)

    // 2.1: Abnormal internal errors that should never be returned:
    static const int InternalBasePointComputationError;

    // 2.2: "Normal" errors if user provides inappropriate matrix:
    static const int NotAffine;
    // (Note that the Matrix3x3 error codes may be returned as well.)

    // 2.3: Successful extraction of unit axis vector and angle:
    //      If the 3x3 extraction of (unit axis vector, angle) is successful,
    //      then the 4x4 utility tries to determine a base point. If
    //      successful, then "Matrix4x4::Extracted_BwTheta" is returned,
    //      otherwise the 3x3 code ("Matrix3x3::Extracted_wTheta") is returned,
    //      signifying that the (unit axis vector, angle) information was
    //      successfully computed and returned, but only an approximation to
    //      a rotation axis base point was able to be determined. In this case,
    //      'postTranslation' will contain a non-zero vector which, if added to
    //      a point after rotation, will yield the correct point.
    static const int Extracted_BwTheta;

protected:
    double mElem[4][4];

private:
    void copy(const Matrix4x4& rhs);

    static int determineBasePoint(AffVector ImMRows[], int maxWCompLoc,
                    int r1, int r2, const AffVector& trans, AffPoint& B);

    void installMt(const Matrix3x3& M, const AffVector& t);
};

}

#endif