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 
 
namespace Geom
{
class XYZ;
class GTrsf;
}  // namespace Geom
 
 
 
namespace Geom
{
class LX_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;
 
    void initFromQuaternion(double w, double x, double y, double z);
 
    bool toQuaternion(double& w, double& x, double& y, double& z);
 
    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //
 
    bool isEqual(const Mat& Other, double Tolerance) const;
 
private:
    double matrix[3][3];
};
}  // namespace Geom