matrix2f.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
// matrix2.template.h file to make changes.

#ifndef PXR_BASE_GF_MATRIX2F_H
#define PXR_BASE_GF_MATRIX2F_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/vec2f.h"
#include "pxr/base/gf/traits.h"

#include <boost/functional/hash.hpp>

#include <iosfwd>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

template <>
struct GfIsGfMatrix<class GfMatrix2f> { static const bool value = true; };

class GfMatrix2d;
class GfMatrix2f;

class GfMatrix2f
{
public:
    typedef float ScalarType;

    static const size_t numRows = 2;
    static const size_t numColumns = 2;

    GfMatrix2f() = default;

    GfMatrix2f(float m00, float m01, 
               float m10, float m11) {
        Set(m00, m01, 
            m10, m11);
    }

    GfMatrix2f(const float m[2][2]) {
        Set(m);
    }

    explicit GfMatrix2f(float s) {
        SetDiagonal(s);
    }

    explicit GfMatrix2f(int s) {
        SetDiagonal(s);
    }

    explicit GfMatrix2f(const GfVec2f& v) {
        SetDiagonal(v);
    }

    GF_API
    explicit GfMatrix2f(const std::vector< std::vector<double> >& v);

    GF_API
    explicit GfMatrix2f(const std::vector< std::vector<float> >& v);

    GF_API
    explicit GfMatrix2f(const class GfMatrix2d& m);

    void SetRow(int i, const GfVec2f & v) {
        _mtx[i][0] = v[0];
        _mtx[i][1] = v[1];
    }

    void SetColumn(int i, const GfVec2f & v) {
        _mtx[0][i] = v[0];
        _mtx[1][i] = v[1];
    }

    GfVec2f GetRow(int i) const {
        return GfVec2f(_mtx[i][0], _mtx[i][1]);
    }

    GfVec2f GetColumn(int i) const {
        return GfVec2f(_mtx[0][i], _mtx[1][i]);
    }

    GfMatrix2f& Set(float m00, float m01, 
                    float m10, float m11) {
        _mtx[0][0] = m00; _mtx[0][1] = m01; 
        _mtx[1][0] = m10; _mtx[1][1] = m11;
        return *this;
    }

    GfMatrix2f& Set(const float m[2][2]) {
        _mtx[0][0] = m[0][0];
        _mtx[0][1] = m[0][1];
        _mtx[1][0] = m[1][0];
        _mtx[1][1] = m[1][1];
        return *this;
    }

    GfMatrix2f& SetIdentity() {
        return SetDiagonal(1);
    }

    GfMatrix2f& SetZero() {
        return SetDiagonal(0);
    }

    GF_API
    GfMatrix2f& SetDiagonal(float s);

    GF_API
    GfMatrix2f& SetDiagonal(const GfVec2f&);

    GF_API
    float* Get(float m[2][2]) 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(GfMatrix2f const &m) {
        int nElems = 2 * 2;
        size_t h = 0;
        const float *p = m.GetArray();
        while (nElems--)
            boost::hash_combine(h, *p++);
        return h;
    }

    GF_API
    bool operator ==(const GfMatrix2d& m) const;

    GF_API
    bool operator ==(const GfMatrix2f& m) const;

    bool operator !=(const GfMatrix2d& m) const {
        return !(*this == m);
    }

    bool operator !=(const GfMatrix2f& m) const {
        return !(*this == m);
    }

    GF_API
    GfMatrix2f GetTranspose() const;

    GF_API
    GfMatrix2f GetInverse(double* det = NULL, double eps = 0) const;

    GF_API
    double GetDeterminant() const;


    GF_API
    GfMatrix2f& operator *=(const GfMatrix2f& m);

    GF_API
    GfMatrix2f& operator *=(double);

    friend GfMatrix2f operator *(const GfMatrix2f& m1, double d)
    {
        GfMatrix2f m = m1;
        return m *= d;
    }

    // Returns the product of a matrix and a float.
    friend GfMatrix2f operator *(double d, const GfMatrix2f& m)
    {
        return m * d;
    }

    GF_API
    GfMatrix2f& operator +=(const GfMatrix2f& m);

    GF_API
    GfMatrix2f& operator -=(const GfMatrix2f& m);

    GF_API
    friend GfMatrix2f operator -(const GfMatrix2f& m);

    friend GfMatrix2f operator +(const GfMatrix2f& m1, const GfMatrix2f& m2)
    {
        GfMatrix2f tmp(m1);
        tmp += m2;
        return tmp;
    }

    friend GfMatrix2f operator -(const GfMatrix2f& m1, const GfMatrix2f& m2)
    {
        GfMatrix2f tmp(m1);
        tmp -= m2;
        return tmp;
    }

    friend GfMatrix2f operator *(const GfMatrix2f& m1, const GfMatrix2f& m2)
    {
        GfMatrix2f tmp(m1);
        tmp *= m2;
        return tmp;
    }

    friend GfMatrix2f operator /(const GfMatrix2f& m1, const GfMatrix2f& m2)
    {
        return(m1 * m2.GetInverse());
    }

    friend inline GfVec2f operator *(const GfMatrix2f& m, const GfVec2f& vec) {
        return GfVec2f(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[0][1],
                       vec[0] * m._mtx[1][0] + vec[1] * m._mtx[1][1]);
    }

    friend inline GfVec2f operator *(const GfVec2f &vec, const GfMatrix2f& m) {
        return GfVec2f(vec[0] * m._mtx[0][0] + vec[1] * m._mtx[1][0],
                       vec[0] * m._mtx[0][1] + vec[1] * m._mtx[1][1]);
    }


private:
    GfMatrixData<float, 2, 2> _mtx;

    // Friend declarations
    friend class GfMatrix2d;
};


GF_API 
bool GfIsClose(GfMatrix2f const &m1, GfMatrix2f const &m2, double tolerance);

GF_API std::ostream& operator<<(std::ostream &, GfMatrix2f const &);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_GF_MATRIX2F_H