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 <Base/Matrix.h>
#include <Geom/Mat.h>
#include <Geom/XYZ.h>

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 ---------------------- //
    //                                                       //

private:
    double _scale;
    Trsf::FormEnum _shape;
    Geom::Mat _matrix;
    Geom::XYZ _loc;
};

}  // namespace Geom