Trsf.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/Mat.h>
#include <Geom/XYZ.h>
namespace Base { class Matrix4D; }
 
namespace Geom
{
class Ax1;
class Ax2;
class Ax3;
class Pnt;
class Vec;
class GTrsf;
class Trsf2d;
}  // namespace Geom
 
 
namespace Geom
{
 
class LX_GEOM_EXPORT Trsf
{
public:
    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //
 
    // Methods PUBLIC
    //
    Trsf();
    explicit Trsf(const Geom::Trsf2d& T);
 
    Trsf(const Geom::Mat& mat, const Geom::XYZ& location, double scale);
    Trsf(const Base::Matrix4D& mtrx);
 
    Trsf(const Trsf& rhs);
 
    enum FormEnum
    {
        Identity,
        Rotation,
        Translation,
        PntMirror,
        Ax1Mirror,
        Ax2Mirror,
        Scale,
        CompoundTrsf,
        Other
    };
 
    void setMirror(const Geom::Pnt& P);
 
 
    void setMirror(const Geom::Ax1& A1);
 
 
    void setMirror(const Geom::Ax2& A2);
 
 
    void setRotation(const Geom::Ax1& A1, const double Ang);
 
 
    void setScale(const Geom::Pnt& P, const double S);
 
 
    void setDisplacement(const Geom::Ax3& FromSystem1, const Geom::Ax3& ToSystem2);
 
    void setTransformation(const Geom::Ax3& FromSystem1, const Geom::Ax3& ToSystem2);
 
    void setTransformation(const Geom::Ax3& ToSystem);
 
    void setTranslation(const Geom::Vec& V);
 
    void setTranslation(const Geom::Pnt& P1, const Geom::Pnt& P2);
 
    void setTranslationPart(const Geom::Vec& V);
 
    void translate(const Geom::Vec& V);
 
    void setScaleFactor(const double S);
 
    void setValues(double a11,
                   double a12,
                   double a13,
                   double a14,
                   double a21,
                   double a22,
                   double a23,
                   double a24,
                   double a31,
                   double a32,
                   double a33,
                   double a34,
                   double Tolang,
                   double TolDist);
    bool isNegative() const;
 
    bool isIdentity() const;
    void setIdentity();
 
    // TODO
    Trsf::FormEnum form() const;
    double scaleFactor() const;
 
    const Geom::XYZ& translationPart() const;
 
 
    Geom::Mat vectorialPart() const;
 
    const Geom::Mat& hVectorialPart() const;
 
    double value(const int Row, const int Col) const;
 
 
    void invert();
 
    Trsf inverted() const;
 
    Trsf multiplied(const Trsf& T) const;
    Trsf operator*(const Trsf& T) const { return multiplied(T); }
 
 
 
    void multiply(const Trsf& T);
    void operator*=(const Trsf& T) { multiply(T); }
 
 
 
    void preMultiply(const Trsf& T);
 
 
    void power(const int N);
 
    Trsf powered(const int N);
 
    void transforms(double& X, double& Y, double& Z) const;
    void transforms(Geom::XYZ& Coord) const;
 
    void toMatrix4D(Base::Matrix4D& mtrx);
 
    friend class gp_GTrsf;
    friend class Geom::GTrsf;
 
    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //
 
    bool isSameAs(const Trsf& T) const;
 
private:
    double _scale;
    Trsf::FormEnum _shape;
    Geom::Mat _matrix;
    Geom::XYZ _loc;
};
 
}  // namespace Geom