matrix3d.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
// matrix3.template.h file to make changes.
 
#ifndef PXR_BASE_GF_MATRIX3D_H
#define PXR_BASE_GF_MATRIX3D_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/vec3d.h"
#include "pxr/base/gf/traits.h"
#include "pxr/base/tf/hash.h"
 
#include <iosfwd>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <>
struct GfIsGfMatrix<class GfMatrix3d> { static const bool value = true; };
 
class GfMatrix3d;
class GfMatrix3f;
class GfRotation;
class GfQuaternion;
class GfQuatd;
 
class GfMatrix3d
{
public:
    typedef double ScalarType;
 
    static const size_t numRows = 3;
    static const size_t numColumns = 3;
 
    GfMatrix3d() = default;
 
    GfMatrix3d(double m00, double m01, double m02, 
               double m10, double m11, double m12, 
               double m20, double m21, double m22) {
        Set(m00, m01, m02, 
            m10, m11, m12, 
            m20, m21, m22);
    }
 
    GfMatrix3d(const double m[3][3]) {
        Set(m);
    }
 
    explicit GfMatrix3d(double s) {
        SetDiagonal(s);
    }
 
    explicit GfMatrix3d(int s) {
        SetDiagonal(s);
    }
 
    explicit GfMatrix3d(const GfVec3d& v) {
        SetDiagonal(v);
    }
 
    GF_API
    explicit GfMatrix3d(const std::vector< std::vector<double> >& v);
 
    GF_API
    explicit GfMatrix3d(const std::vector< std::vector<float> >& v);
 
    GF_API
    GfMatrix3d(const GfRotation& rot);
 
    GF_API
    explicit GfMatrix3d(const GfQuatd& rot);
 
    GF_API
    explicit GfMatrix3d(const class GfMatrix3f& m);
 
    void SetRow(int i, const GfVec3d & v) {
        _mtx[i][0] = v[0];
        _mtx[i][1] = v[1];
        _mtx[i][2] = v[2];
    }
 
    void SetColumn(int i, const GfVec3d & v) {
        _mtx[0][i] = v[0];
        _mtx[1][i] = v[1];
        _mtx[2][i] = v[2];
    }
 
    GfVec3d GetRow(int i) const {
        return GfVec3d(_mtx[i][0], _mtx[i][1], _mtx[i][2]);
    }
 
    GfVec3d GetColumn(int i) const {
        return GfVec3d(_mtx[0][i], _mtx[1][i], _mtx[2][i]);
    }
 
    GfMatrix3d& Set(double m00, double m01, double m02, 
                    double m10, double m11, double m12, 
                    double m20, double m21, double m22) {
        _mtx[0][0] = m00; _mtx[0][1] = m01; _mtx[0][2] = m02; 
        _mtx[1][0] = m10; _mtx[1][1] = m11; _mtx[1][2] = m12; 
        _mtx[2][0] = m20; _mtx[2][1] = m21; _mtx[2][2] = m22;
        return *this;
    }
 
    GfMatrix3d& Set(const double m[3][3]) {
        _mtx[0][0] = m[0][0];
        _mtx[0][1] = m[0][1];
        _mtx[0][2] = m[0][2];
        _mtx[1][0] = m[1][0];
        _mtx[1][1] = m[1][1];
        _mtx[1][2] = m[1][2];
        _mtx[2][0] = m[2][0];
        _mtx[2][1] = m[2][1];
        _mtx[2][2] = m[2][2];
        return *this;
    }
 
    GfMatrix3d& SetIdentity() {
        return SetDiagonal(1);
    }
 
    GfMatrix3d& SetZero() {
        return SetDiagonal(0);
    }
 
    GF_API
    GfMatrix3d& SetDiagonal(double s);
 
    GF_API
    GfMatrix3d& SetDiagonal(const GfVec3d&);
 
    GF_API
    double* Get(double m[3][3]) 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(GfMatrix3d const &m) {
        return TfHash::Combine(
            m._mtx[0][0],
            m._mtx[0][1],
            m._mtx[0][2],
            m._mtx[1][0],
            m._mtx[1][1],
            m._mtx[1][2],
            m._mtx[2][0],
            m._mtx[2][1],
            m._mtx[2][2]
        );
    }
 
    GF_API
    bool operator ==(const GfMatrix3d& m) const;
 
    GF_API
    bool operator ==(const GfMatrix3f& m) const;
 
    bool operator !=(const GfMatrix3d& m) const {
        return !(*this == m);
    }
 
    bool operator !=(const GfMatrix3f& m) const {
        return !(*this == m);
    }
 
    GF_API
    GfMatrix3d GetTranspose() const;
 
    GF_API
    GfMatrix3d GetInverse(double* det = NULL, double eps = 0) const;
 
    GF_API
    double GetDeterminant() const;
 
    GF_API
    bool Orthonormalize(bool issueWarning=true);
 
    GF_API
    GfMatrix3d 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
    GfMatrix3d& operator *=(const GfMatrix3d& m);
 
    GF_API
    GfMatrix3d& operator *=(double);
 
    friend GfMatrix3d operator *(const GfMatrix3d& m1, double d)
    {
        GfMatrix3d m = m1;
        return m *= d;
    }
 
    // Returns the product of a matrix and a double.
    friend GfMatrix3d operator *(double d, const GfMatrix3d& m)
    {
        return m * d;
    }
 
    GF_API
    GfMatrix3d& operator +=(const GfMatrix3d& m);
 
    GF_API
    GfMatrix3d& operator -=(const GfMatrix3d& m);
 
    GF_API
    friend GfMatrix3d operator -(const GfMatrix3d& m);
 
    friend GfMatrix3d operator +(const GfMatrix3d& m1, const GfMatrix3d& m2)
    {
        GfMatrix3d tmp(m1);
        tmp += m2;
        return tmp;
    }
 
    friend GfMatrix3d operator -(const GfMatrix3d& m1, const GfMatrix3d& m2)
    {
        GfMatrix3d tmp(m1);
        tmp -= m2;
        return tmp;
    }
 
    friend GfMatrix3d operator *(const GfMatrix3d& m1, const GfMatrix3d& m2)
    {
        GfMatrix3d tmp(m1);
        tmp *= m2;
        return tmp;
    }
 
    friend GfMatrix3d operator /(const GfMatrix3d& m1, const GfMatrix3d& m2)
    {
        return(m1 * m2.GetInverse());
    }
 
    friend inline GfVec3d operator *(const GfMatrix3d& m, const GfVec3d& vec) {
        return GfVec3d(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[0][1] + vec[2] * m._mtx[0][2],
                       vec[0] * m._mtx[1][0] + vec[1] * m._mtx[1][1] + vec[2] * m._mtx[1][2],
                       vec[0] * m._mtx[2][0] + vec[1] * m._mtx[2][1] + vec[2] * m._mtx[2][2]);
    }
 
    friend inline GfVec3d operator *(const GfVec3d &vec, const GfMatrix3d& m) {
        return GfVec3d(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[1][0] + vec[2] * m._mtx[2][0],
                       vec[0] * m._mtx[0][1] + vec[1] * m._mtx[1][1] + vec[2] * m._mtx[2][1],
                       vec[0] * m._mtx[0][2] + vec[1] * m._mtx[1][2] + vec[2] * m._mtx[2][2]);
    }
 
    GF_API
    GfMatrix3d& SetScale(double scaleFactor);
 
 
    GF_API
    GfMatrix3d& SetRotate(const GfQuatd &rot);
 
    GF_API
    GfMatrix3d& SetRotate(const GfRotation &rot);
 
    GF_API
    GfMatrix3d& SetScale(const GfVec3d &scaleFactors);
 
    GF_API
    GfRotation ExtractRotation() const;
 
    GF_API
    GfVec3d DecomposeRotation(const GfVec3d &axis0,
                              const GfVec3d &axis1,
                              const GfVec3d &axis2 ) const;
 
    GF_API
    GfQuaternion ExtractRotationQuaternion() const;
 
 
private:
    void _SetRotateFromQuat(double r, const GfVec3d& i);
 
 
private:
    GfMatrixData<double, 3, 3> _mtx;
 
    // Friend declarations
    friend class GfMatrix3f;
};
 
 
GF_API 
bool GfIsClose(GfMatrix3d const &m1, GfMatrix3d const &m2, double tolerance);
 
GF_API std::ostream& operator<<(std::ostream &, GfMatrix3d const &);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_MATRIX3D_H