Mat.h

Go to the documentation of this file.

//
// Copyright(C) 2013-2016  OpenCascade [www.opencascade.org]
//
// This library is free software; you can redistribute it and / or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street,
// Fifth Floor, Boston, MA  02110 - 1301  USA
//

#pragma once

#include <Geom/GeomEnums.h>
#include <Geom/geom_defines.h>

namespace Geom
{
class XYZ;
class Trsf;
class GTrsf;
}  // namespace Geom

class gp_GTrsf;


namespace Geom
{
class GEOM_EXPORT Mat
{
public:
    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    Mat();

    Mat(const double a11,
        const double a12,
        const double a13,
        const double a21,
        const double a22,
        const double a23,
        const double a31,
        const double a32,
        const double a33);
    Mat(const XYZ& Col1, const XYZ& Col2, const XYZ& Col3);
    void setCol(const int Col, const XYZ& Value);
    void setCols(const XYZ& Col1, const XYZ& Col2, const XYZ& Col3);

    void setCross(const XYZ& Ref);

    void setDiagonal(const double X1, const double X2, const double X3);

    void setDot(const XYZ& Ref);
    void setIdentity();
    bool isIdentity() const;

    void setRotation(const XYZ& Axis, const double Ang);
    void setRow(const int Row, const XYZ& Value);
    void setRows(const XYZ& Row1, const XYZ& Row2, const XYZ& Row3);

    void setScale(const double S);
    void setValue(const int Row, const int Col, const double Value);
    XYZ column(const int Col) const;
    double determinant() const;
    XYZ diagonal() const;
    XYZ row(const int Row) const;
    const double& value(const int Row, const int Col) const;

    const double& operator()(const int Row, const int Col) const { return value(Row, Col); }

    double& changeValue(const int Row, const int Col);

    double& operator()(const int Row, const int Col) { return changeValue(Row, Col); }

    bool isSingular() const;

    void add(const Mat& Other);

    void operator+=(const Mat& Other) { add(Other); }

    Mat added(const Mat& Other) const;

    Mat operator+(const Mat& Other) const { return added(Other); }

    void divide(const double Scalar);

    void operator/=(const double Scalar) { divide(Scalar); }

    Mat divided(const double Scalar) const;

    Mat operator/(const double Scalar) const { return divided(Scalar); }

    void invert();

    Mat inverted() const;

    Mat multiplied(const Mat& Other) const;

    Mat operator*(const Mat& Other) const { return multiplied(Other); }

    void multiply(const Mat& Other);

    void operator*=(const Mat& Other) { multiply(Other); }

    void preMultiply(const Mat& Other);

    Mat multiplied(const double Scalar) const;

    Mat operator*(const double Scalar) const { return multiplied(Scalar); }

    void multiply(const double Scalar);

    void operator*=(const double Scalar) { multiply(Scalar); }

    void power(const int N);

    Mat powered(const int N) const;

    void subtract(const Mat& Other);

    void operator-=(const Mat& Other) { subtract(Other); }

    Mat subtracted(const Mat& Other) const;

    Mat operator-(const Mat& Other) const { return subtracted(Other); }

    bool operator==(const Mat& Other) const;

    bool operator!=(const Mat& Other) const { return !(operator==(Other)); }

    void transpose();

    Mat transposed() const;

    friend class XYZ;
    friend class CA_Transfrom;
    friend class gp_GTrsf;
    friend class Geom::GTrsf;

    Geom::XYZ computeEulerAngles() const;

    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //

private:
    double matrix[3][3];
};
}  // namespace Geom