matrix4f.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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_MATRIX4F_H
#define PXR_BASE_GF_MATRIX4F_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/vec4f.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/vec3f.h"
#include "pxr/base/tf/hash.h"
 
#include <iosfwd>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <>
struct GfIsGfMatrix<class GfMatrix4f> { static const bool value = true; };
 
class GfMatrix4d;
class GfMatrix4f;
class GfQuatf;
class GfRotation;
class GfMatrix3f;
 
class GfMatrix4f
{
public:
    typedef float ScalarType;
 
    static const size_t numRows = 4;
    static const size_t numColumns = 4;
 
    GfMatrix4f() = default;
 
    GfMatrix4f(float m00, float m01, float m02, float m03, 
               float m10, float m11, float m12, float m13, 
               float m20, float m21, float m22, float m23, 
               float m30, float m31, float m32, float m33) {
        Set(m00, m01, m02, m03, 
            m10, m11, m12, m13, 
            m20, m21, m22, m23, 
            m30, m31, m32, m33);
    }
 
    GfMatrix4f(const float m[4][4]) {
        Set(m);
    }
 
    explicit GfMatrix4f(float s) {
        SetDiagonal(s);
    }
 
    explicit GfMatrix4f(const GfVec4f& v) {
        SetDiagonal(v);
    }
 
    GF_API
    explicit GfMatrix4f(const std::vector< std::vector<double> >& v);
 
    GF_API
    explicit GfMatrix4f(const std::vector< std::vector<float> >& v);
 
    GF_API
    explicit GfMatrix4f(const std::vector<double>& r0,
                        const std::vector<double>& r1,
                        const std::vector<double>& r2,
                        const std::vector<double>& r3);
 
    GF_API
    explicit GfMatrix4f(const std::vector<float>& r0,
                        const std::vector<float>& r1,
                        const std::vector<float>& r2,
                        const std::vector<float>& r3);
 
    GF_API
    GfMatrix4f(const GfRotation& rotate,
               const GfVec3f& translate);
 
    GF_API
    GfMatrix4f(const GfMatrix3f& rotmx,
               const GfVec3f& translate);
    GF_API
    explicit GfMatrix4f(const class GfMatrix4d& m);
 
    void SetRow(int i, const GfVec4f & 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 GfVec4f & v) {
        _mtx[0][i] = v[0];
        _mtx[1][i] = v[1];
        _mtx[2][i] = v[2];
        _mtx[3][i] = v[3];
    }
 
    GfVec4f GetRow(int i) const {
        return GfVec4f(_mtx[i][0], _mtx[i][1], _mtx[i][2], _mtx[i][3]);
    }
 
    GfVec4f GetColumn(int i) const {
        return GfVec4f(_mtx[0][i], _mtx[1][i], _mtx[2][i], _mtx[3][i]);
    }
 
    GfMatrix4f& Set(float m00, float m01, float m02, float m03, 
                    float m10, float m11, float m12, float m13, 
                    float m20, float m21, float m22, float m23, 
                    float m30, float m31, float m32, float 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;
    }
 
    GfMatrix4f& Set(const float 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;
    }
 
    GfMatrix4f& SetIdentity() {
        return SetDiagonal(1);
    }
 
    GfMatrix4f& SetZero() {
        return SetDiagonal(0);
    }
 
    GF_API
    GfMatrix4f& SetDiagonal(float s);
 
    GF_API
    GfMatrix4f& SetDiagonal(const GfVec4f&);
 
    GF_API
    float* Get(float m[4][4]) const;
 
    float* data() {
        return _mtx.GetData();
    }
 
    const float* data() const {
        return _mtx.GetData();
    }
 
    float* GetArray()  {
        return _mtx.GetData();
    }
 
    const float* GetArray() const {
        return _mtx.GetData();
    }
 
    float* operator [](int i) { return _mtx[i]; }
 
    const float* operator [](int i) const { return _mtx[i]; }
 
    friend inline size_t hash_value(GfMatrix4f 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
    GfMatrix4f GetTranspose() const;
 
    GF_API
    GfMatrix4f GetInverse(double* det = NULL, double eps = 0) const;
 
    GF_API
    double GetDeterminant() const;
 
    void SetRow3(int i, const GfVec3f & v) {
        _mtx[i][0] = v[0];
        _mtx[i][1] = v[1];
        _mtx[i][2] = v[2];
    }
 
    GfVec3f GetRow3(int i) const {
        return GfVec3f(_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).
        GfVec3f 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
    GfMatrix4f 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
    GfMatrix4f& operator *=(const GfMatrix4f& m);
 
    GF_API
    GfMatrix4f& operator *=(double);
 
    friend GfMatrix4f operator *(const GfMatrix4f& m1, double d)
    {
        GfMatrix4f m = m1;
        return m *= d;
    }
 
    // Returns the product of a matrix and a float.
    friend GfMatrix4f operator *(double d, const GfMatrix4f& m)
    {
        return m * d;
    }
 
    GF_API
    GfMatrix4f& operator +=(const GfMatrix4f& m);
 
    GF_API
    GfMatrix4f& operator -=(const GfMatrix4f& m);
 
    GF_API
    friend GfMatrix4f operator -(const GfMatrix4f& m);
 
    friend GfMatrix4f operator +(const GfMatrix4f& m1, const GfMatrix4f& m2)
    {
        GfMatrix4f tmp(m1);
        tmp += m2;
        return tmp;
    }
 
    friend GfMatrix4f operator -(const GfMatrix4f& m1, const GfMatrix4f& m2)
    {
        GfMatrix4f tmp(m1);
        tmp -= m2;
        return tmp;
    }
 
    friend GfMatrix4f operator *(const GfMatrix4f& m1, const GfMatrix4f& m2)
    {
        GfMatrix4f tmp(m1);
        tmp *= m2;
        return tmp;
    }
 
    friend GfMatrix4f operator /(const GfMatrix4f& m1, const GfMatrix4f& m2)
    {
        return(m1 * m2.GetInverse());
    }
 
    friend inline GfVec4f operator *(const GfMatrix4f& m, const GfVec4f& vec) {
        return GfVec4f(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 GfVec4f operator *(const GfVec4f &vec, const GfMatrix4f& m) {
        return GfVec4f(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
    GfMatrix4f& SetScale(float scaleFactor);
 
    GF_API
    GfMatrix4f RemoveScaleShear() const;
 
 
    GF_API
    GfMatrix4f& SetRotate(const GfQuatf &rot);
 
    GF_API
    GfMatrix4f& SetRotateOnly(const GfQuatf &rot);
 
    GF_API
    GfMatrix4f& SetRotate(const GfRotation &rot);
 
    GF_API
    GfMatrix4f& SetRotateOnly(const GfRotation &rot);
 
    GF_API
    GfMatrix4f& SetRotate(const GfMatrix3f &mx);
 
    GF_API
    GfMatrix4f& SetRotateOnly(const GfMatrix3f &mx);
 
    GF_API
    GfMatrix4f& SetScale(const GfVec3f &scaleFactors);
 
    GF_API
    GfMatrix4f& SetTranslate(const GfVec3f &trans);
 
    GF_API
    GfMatrix4f& SetTranslateOnly(const GfVec3f &t);
 
    GF_API
    GfMatrix4f& SetTransform(const GfRotation& rotate,
                             const GfVec3f& translate);
 
    GF_API
    GfMatrix4f& SetTransform(const GfMatrix3f& rotmx,
                             const GfVec3f& translate);
 
    GF_API
    GfMatrix4f& SetLookAt(const GfVec3f &eyePoint,
                          const GfVec3f &centerPoint,
                          const GfVec3f &upDirection);
 
    GF_API
    GfMatrix4f& SetLookAt(const GfVec3f &eyePoint,
                          const GfRotation &orientation);
 
    GF_API
    bool Factor(GfMatrix4f* r, GfVec3f* s, GfMatrix4f* u,
                GfVec3f* t, GfMatrix4f* p,
                float eps = 1e-5) const;
 
    GfVec3f ExtractTranslation() const {
        return GfVec3f(_mtx[3][0], _mtx[3][1], _mtx[3][2]);
    }
 
    GF_API
    GfRotation ExtractRotation() const;
 
    GF_API
    GfQuatf  ExtractRotationQuat() const;
 
    GF_API
    GfVec3f DecomposeRotation(const GfVec3f &axis0,
                              const GfVec3f &axis1,
                              const GfVec3f &axis2) const;
 
    GF_API
    GfMatrix3f 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]));
    }
 
    GfVec3f Transform(const GfVec3f &vec) const {
        return (GfProject(GfVec4f(
            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]);
    }
 
    GfVec3f TransformDir(const GfVec3f &vec) const {
        return GfVec3f(
            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]);
    }
 
    GfVec3f TransformAffine(const GfVec3f &vec) const {
        return GfVec3f(
            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(float r, const GfVec3f& i);
 
 
private:
    GfMatrixData<float, 4, 4> _mtx;
 
    // Friend declarations
    friend class GfMatrix4d;
};
 
 
GF_API 
bool GfIsClose(GfMatrix4f const &m1, GfMatrix4f const &m2, double tolerance);
 
GF_API std::ostream& operator<<(std::ostream &, GfMatrix4f const &);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_MATRIX4F_H