matrix4d.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
// This file is generated by a script.  Do not edit directly.  Edit the
// matrix4.template.h file to make changes.
 
#ifndef PXR_BASE_GF_MATRIX4D_H
#define PXR_BASE_GF_MATRIX4D_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/gf/api.h"
#include "pxr/base/gf/declare.h"
#include "pxr/base/gf/matrixData.h"
#include "pxr/base/gf/vec4d.h"
#include "pxr/base/gf/traits.h"
#include "pxr/base/gf/homogeneous.h"
#include "pxr/base/gf/limits.h"
#include "pxr/base/gf/math.h"
#include "pxr/base/gf/vec3d.h"
#include "pxr/base/tf/hash.h"
 
#include <iosfwd>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <>
struct GfIsGfMatrix<class GfMatrix4d> { static const bool value = true; };
 
class GfMatrix4d;
class GfMatrix4f;
class GfQuatd;
class GfRotation;
class GfMatrix3d;
 
class GfMatrix4d
{
public:
    typedef double ScalarType;
 
    static const size_t numRows = 4;
    static const size_t numColumns = 4;
 
    GfMatrix4d() = default;
 
    GfMatrix4d(double m00, double m01, double m02, double m03, 
               double m10, double m11, double m12, double m13, 
               double m20, double m21, double m22, double m23, 
               double m30, double m31, double m32, double m33) {
        Set(m00, m01, m02, m03, 
            m10, m11, m12, m13, 
            m20, m21, m22, m23, 
            m30, m31, m32, m33);
    }
 
    GfMatrix4d(const double m[4][4]) {
        Set(m);
    }
 
    explicit GfMatrix4d(double s) {
        SetDiagonal(s);
    }
 
    explicit GfMatrix4d(const GfVec4d& v) {
        SetDiagonal(v);
    }
 
    GF_API
    explicit GfMatrix4d(const std::vector< std::vector<double> >& v);
 
    GF_API
    explicit GfMatrix4d(const std::vector< std::vector<float> >& v);
 
    GF_API
    explicit GfMatrix4d(const std::vector<double>& r0,
                        const std::vector<double>& r1,
                        const std::vector<double>& r2,
                        const std::vector<double>& r3);
 
    GF_API
    explicit GfMatrix4d(const std::vector<float>& r0,
                        const std::vector<float>& r1,
                        const std::vector<float>& r2,
                        const std::vector<float>& r3);
 
    GF_API
    GfMatrix4d(const GfRotation& rotate,
               const GfVec3d& translate);
 
    GF_API
    GfMatrix4d(const GfMatrix3d& rotmx,
               const GfVec3d& translate);
    GF_API
    explicit GfMatrix4d(const class GfMatrix4f& m);
 
    void SetRow(int i, const GfVec4d & v) {
        _mtx[i][0] = v[0];
        _mtx[i][1] = v[1];
        _mtx[i][2] = v[2];
        _mtx[i][3] = v[3];
    }
 
    void SetColumn(int i, const GfVec4d & v) {
        _mtx[0][i] = v[0];
        _mtx[1][i] = v[1];
        _mtx[2][i] = v[2];
        _mtx[3][i] = v[3];
    }
 
    GfVec4d GetRow(int i) const {
        return GfVec4d(_mtx[i][0], _mtx[i][1], _mtx[i][2], _mtx[i][3]);
    }
 
    GfVec4d GetColumn(int i) const {
        return GfVec4d(_mtx[0][i], _mtx[1][i], _mtx[2][i], _mtx[3][i]);
    }
 
    GfMatrix4d& Set(double m00, double m01, double m02, double m03, 
                    double m10, double m11, double m12, double m13, 
                    double m20, double m21, double m22, double m23, 
                    double m30, double m31, double m32, double m33) {
        _mtx[0][0] = m00; _mtx[0][1] = m01; _mtx[0][2] = m02; _mtx[0][3] = m03; 
        _mtx[1][0] = m10; _mtx[1][1] = m11; _mtx[1][2] = m12; _mtx[1][3] = m13; 
        _mtx[2][0] = m20; _mtx[2][1] = m21; _mtx[2][2] = m22; _mtx[2][3] = m23; 
        _mtx[3][0] = m30; _mtx[3][1] = m31; _mtx[3][2] = m32; _mtx[3][3] = m33;
        return *this;
    }
 
    GfMatrix4d& Set(const double m[4][4]) {
        _mtx[0][0] = m[0][0];
        _mtx[0][1] = m[0][1];
        _mtx[0][2] = m[0][2];
        _mtx[0][3] = m[0][3];
        _mtx[1][0] = m[1][0];
        _mtx[1][1] = m[1][1];
        _mtx[1][2] = m[1][2];
        _mtx[1][3] = m[1][3];
        _mtx[2][0] = m[2][0];
        _mtx[2][1] = m[2][1];
        _mtx[2][2] = m[2][2];
        _mtx[2][3] = m[2][3];
        _mtx[3][0] = m[3][0];
        _mtx[3][1] = m[3][1];
        _mtx[3][2] = m[3][2];
        _mtx[3][3] = m[3][3];
        return *this;
    }
 
    GfMatrix4d& SetIdentity() {
        return SetDiagonal(1);
    }
 
    GfMatrix4d& SetZero() {
        return SetDiagonal(0);
    }
 
    GF_API
    GfMatrix4d& SetDiagonal(double s);
 
    GF_API
    GfMatrix4d& SetDiagonal(const GfVec4d&);
 
    GF_API
    double* Get(double m[4][4]) const;
 
    double* data() {
        return _mtx.GetData();
    }
 
    const double* data() const {
        return _mtx.GetData();
    }
 
    double* GetArray()  {
        return _mtx.GetData();
    }
 
    const double* GetArray() const {
        return _mtx.GetData();
    }
 
    double* operator [](int i) { return _mtx[i]; }
 
    const double* operator [](int i) const { return _mtx[i]; }
 
    friend inline size_t hash_value(GfMatrix4d const &m) {
        return TfHash::Combine(
            m._mtx[0][0],
            m._mtx[0][1],
            m._mtx[0][2],
            m._mtx[0][3],
            m._mtx[1][0],
            m._mtx[1][1],
            m._mtx[1][2],
            m._mtx[1][3],
            m._mtx[2][0],
            m._mtx[2][1],
            m._mtx[2][2],
            m._mtx[2][3],
            m._mtx[3][0],
            m._mtx[3][1],
            m._mtx[3][2],
            m._mtx[3][3]
        );
    }
 
    GF_API
    bool operator ==(const GfMatrix4d& m) const;
 
    GF_API
    bool operator ==(const GfMatrix4f& m) const;
 
    bool operator !=(const GfMatrix4d& m) const {
        return !(*this == m);
    }
 
    bool operator !=(const GfMatrix4f& m) const {
        return !(*this == m);
    }
 
    GF_API
    GfMatrix4d GetTranspose() const;
 
    GF_API
    GfMatrix4d GetInverse(double* det = NULL, double eps = 0) const;
 
    GF_API
    double GetDeterminant() const;
 
    void SetRow3(int i, const GfVec3d & v) {
        _mtx[i][0] = v[0];
        _mtx[i][1] = v[1];
        _mtx[i][2] = v[2];
    }
 
    GfVec3d GetRow3(int i) const {
        return GfVec3d(_mtx[i][0], _mtx[i][1], _mtx[i][2]);
    }
 
    double GetDeterminant3() const {
        return _GetDeterminant3(0, 1, 2, 0, 1, 2);
    }
 
    bool HasOrthogonalRows3() const {
        // XXX Should add GfAreOrthogonal(v0, v1, v2) (which also
        //     GfRotation::Decompose() could use).
        GfVec3d axis0(GetRow3(0)), axis1(GetRow3(1)), axis2(GetRow3(2));
        return (GfAbs(GfDot(axis0, axis1)) < GF_MIN_ORTHO_TOLERANCE && 
                GfAbs(GfDot(axis0, axis2)) < GF_MIN_ORTHO_TOLERANCE && 
                GfAbs(GfDot(axis1, axis2)) < GF_MIN_ORTHO_TOLERANCE);
    }
 
    GF_API
    bool Orthonormalize(bool issueWarning=true);
 
    GF_API
    GfMatrix4d GetOrthonormalized(bool issueWarning=true) const;
 
    GF_API
    double GetHandedness() const;
 
    bool IsRightHanded() const {
        return GetHandedness() == 1.0;
    }
 
    bool IsLeftHanded() const {
        return GetHandedness() == -1.0;
    }
 
    GF_API
    GfMatrix4d& operator *=(const GfMatrix4d& m);
 
    GF_API
    GfMatrix4d& operator *=(double);
 
    friend GfMatrix4d operator *(const GfMatrix4d& m1, double d)
    {
        GfMatrix4d m = m1;
        return m *= d;
    }
 
    // Returns the product of a matrix and a double.
    friend GfMatrix4d operator *(double d, const GfMatrix4d& m)
    {
        return m * d;
    }
 
    GF_API
    GfMatrix4d& operator +=(const GfMatrix4d& m);
 
    GF_API
    GfMatrix4d& operator -=(const GfMatrix4d& m);
 
    GF_API
    friend GfMatrix4d operator -(const GfMatrix4d& m);
 
    friend GfMatrix4d operator +(const GfMatrix4d& m1, const GfMatrix4d& m2)
    {
        GfMatrix4d tmp(m1);
        tmp += m2;
        return tmp;
    }
 
    friend GfMatrix4d operator -(const GfMatrix4d& m1, const GfMatrix4d& m2)
    {
        GfMatrix4d tmp(m1);
        tmp -= m2;
        return tmp;
    }
 
    friend GfMatrix4d operator *(const GfMatrix4d& m1, const GfMatrix4d& m2)
    {
        GfMatrix4d tmp(m1);
        tmp *= m2;
        return tmp;
    }
 
    friend GfMatrix4d operator /(const GfMatrix4d& m1, const GfMatrix4d& m2)
    {
        return(m1 * m2.GetInverse());
    }
 
    friend inline GfVec4d operator *(const GfMatrix4d& m, const GfVec4d& vec) {
        return GfVec4d(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[0][1] + vec[2] * m._mtx[0][2] + vec[3] * m._mtx[0][3],
                       vec[0] * m._mtx[1][0] + vec[1] * m._mtx[1][1] + vec[2] * m._mtx[1][2] + vec[3] * m._mtx[1][3],
                       vec[0] * m._mtx[2][0] + vec[1] * m._mtx[2][1] + vec[2] * m._mtx[2][2] + vec[3] * m._mtx[2][3],
                       vec[0] * m._mtx[3][0] + vec[1] * m._mtx[3][1] + vec[2] * m._mtx[3][2] + vec[3] * m._mtx[3][3]);
    }
 
    friend inline GfVec4d operator *(const GfVec4d &vec, const GfMatrix4d& m) {
        return GfVec4d(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[1][0] + vec[2] * m._mtx[2][0] + vec[3] * m._mtx[3][0],
                       vec[0] * m._mtx[0][1] + vec[1] * m._mtx[1][1] + vec[2] * m._mtx[2][1] + vec[3] * m._mtx[3][1],
                       vec[0] * m._mtx[0][2] + vec[1] * m._mtx[1][2] + vec[2] * m._mtx[2][2] + vec[3] * m._mtx[3][2],
                       vec[0] * m._mtx[0][3] + vec[1] * m._mtx[1][3] + vec[2] * m._mtx[2][3] + vec[3] * m._mtx[3][3]);
    }
 
    GF_API
    GfMatrix4d& SetScale(double scaleFactor);
 
    GF_API
    GfMatrix4d RemoveScaleShear() const;
 
 
    GF_API
    GfMatrix4d& SetRotate(const GfQuatd &rot);
 
    GF_API
    GfMatrix4d& SetRotateOnly(const GfQuatd &rot);
 
    GF_API
    GfMatrix4d& SetRotate(const GfRotation &rot);
 
    GF_API
    GfMatrix4d& SetRotateOnly(const GfRotation &rot);
 
    GF_API
    GfMatrix4d& SetRotate(const GfMatrix3d &mx);
 
    GF_API
    GfMatrix4d& SetRotateOnly(const GfMatrix3d &mx);
 
    GF_API
    GfMatrix4d& SetScale(const GfVec3d &scaleFactors);
 
    GF_API
    GfMatrix4d& SetTranslate(const GfVec3d &trans);
 
    GF_API
    GfMatrix4d& SetTranslateOnly(const GfVec3d &t);
 
    GF_API
    GfMatrix4d& SetTransform(const GfRotation& rotate,
                             const GfVec3d& translate);
 
    GF_API
    GfMatrix4d& SetTransform(const GfMatrix3d& rotmx,
                             const GfVec3d& translate);
 
    GF_API
    GfMatrix4d& SetLookAt(const GfVec3d &eyePoint,
                          const GfVec3d &centerPoint,
                          const GfVec3d &upDirection);
 
    GF_API
    GfMatrix4d& SetLookAt(const GfVec3d &eyePoint,
                          const GfRotation &orientation);
 
    GF_API
    bool Factor(GfMatrix4d* r, GfVec3d* s, GfMatrix4d* u,
                GfVec3d* t, GfMatrix4d* p,
                double eps = 1e-10) const;
 
    GfVec3d ExtractTranslation() const {
        return GfVec3d(_mtx[3][0], _mtx[3][1], _mtx[3][2]);
    }
 
    GF_API
    GfRotation ExtractRotation() const;
 
    GF_API
    GfQuatd  ExtractRotationQuat() const;
 
    GF_API
    GfVec3d DecomposeRotation(const GfVec3d &axis0,
                              const GfVec3d &axis1,
                              const GfVec3d &axis2) const;
 
    GF_API
    GfMatrix3d ExtractRotationMatrix() const;
 
    GfVec3d Transform(const GfVec3d &vec) const {
        return GfProject(GfVec4d(
            vec[0] * _mtx[0][0] + vec[1] * _mtx[1][0] + vec[2] * _mtx[2][0] + _mtx[3][0],
            vec[0] * _mtx[0][1] + vec[1] * _mtx[1][1] + vec[2] * _mtx[2][1] + _mtx[3][1],
            vec[0] * _mtx[0][2] + vec[1] * _mtx[1][2] + vec[2] * _mtx[2][2] + _mtx[3][2],
            vec[0] * _mtx[0][3] + vec[1] * _mtx[1][3] + vec[2] * _mtx[2][3] + _mtx[3][3]));
    }
 
    GfVec3d TransformDir(const GfVec3d &vec) const {
        return GfVec3d(
            vec[0] * _mtx[0][0] + vec[1] * _mtx[1][0] + vec[2] * _mtx[2][0],
            vec[0] * _mtx[0][1] + vec[1] * _mtx[1][1] + vec[2] * _mtx[2][1],
            vec[0] * _mtx[0][2] + vec[1] * _mtx[1][2] + vec[2] * _mtx[2][2]);
    }
 
    GfVec3d TransformAffine(const GfVec3d &vec) const {
        return GfVec3d(
            vec[0] * _mtx[0][0] + vec[1] * _mtx[1][0] + vec[2] * _mtx[2][0] + _mtx[3][0],
            vec[0] * _mtx[0][1] + vec[1] * _mtx[1][1] + vec[2] * _mtx[2][1] + _mtx[3][1],
            vec[0] * _mtx[0][2] + vec[1] * _mtx[1][2] + vec[2] * _mtx[2][2] + _mtx[3][2]);
    }
 
private:
    GF_API
    double _GetDeterminant3(size_t row1, size_t row2, size_t row3,
       size_t col1, size_t col2, size_t col3) const;
 
    void _Jacobi3(GfVec3d *eigenvalues, GfVec3d eigenvectors[3]) const;
 
    void _SetRotateFromQuat(double r, const GfVec3d& i);
 
 
private:
    GfMatrixData<double, 4, 4> _mtx;
 
    // Friend declarations
    friend class GfMatrix4f;
};
 
 
GF_API 
bool GfIsClose(GfMatrix4d const &m1, GfMatrix4d const &m2, double tolerance);
 
GF_API std::ostream& operator<<(std::ostream &, GfMatrix4d const &);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_MATRIX4D_H