EIC code displayed by LXR master/​include/​opencascade/​Geom2d_Transformation.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:03:33

 // Created on: 1993-03-24
 // Created by: JCV
 // Copyright (c) 1993-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _Geom2d_Transformation_HeaderFile
 #define _Geom2d_Transformation_HeaderFile
 
 #include <Standard.hxx>
 
 #include <gp_Trsf2d.hxx>
 #include <Standard_Transient.hxx>
 #include <Standard_Real.hxx>
 #include <gp_TrsfForm.hxx>
 #include <Standard_Integer.hxx>
 class gp_Pnt2d;
 class gp_Ax2d;
 class gp_Vec2d;
 
 
 class Geom2d_Transformation;
 DEFINE_STANDARD_HANDLE(Geom2d_Transformation, Standard_Transient)
 
 
 //! The class Transformation allows to create Translation,
 //! Rotation, Symmetry, Scaling and complex transformations
 //! obtained by combination of the previous elementary
 //! transformations.
 //! The Transformation class can also be used to
 //! construct complex transformations by combining
 //! these elementary transformations.
 //! However, these transformations can never change
 //! the type of an object. For example, the projection
 //! transformation can change a circle into an ellipse,
 //! and therefore change the real type of the object.
 //! Such a transformation is forbidden in this
 //! environment and cannot be a Geom2d_Transformation.
 //! The transformation can be represented as follow :
 //!
 //! V1   V2     T
 //! | a11  a12    a14 |   | x |      | x'|
 //! | a21  a22    a24 |   | y |      | y'|
 //! |  0    0      1  |   | 1 |      | 1 |
 //!
 //! where {V1, V2} defines the vectorial part of the
 //! transformation and T defines the translation part of
 //! the transformation.
 //! - Geom2d_Transformation transformations provide
 //! the same kind of "geometric" services as
 //! gp_Trsf2d ones but have more complex data
 //! structures. The geometric objects provided by the
 //! Geom2d package use gp_Trsf2d transformations
 //! in the syntaxes Transform and Transformed.
 //! - Geom2d_Transformation transformations are
 //! used in a context where they can be shared by
 //! several objects contained inside a common data structure.
 class Geom2d_Transformation : public Standard_Transient
 {
 
 public:
 
   
   //! Creates an identity transformation.
   Standard_EXPORT Geom2d_Transformation();
   
   //! Creates a persistent copy of T.
   Standard_EXPORT Geom2d_Transformation(const gp_Trsf2d& T);
   
 
   //! Makes the transformation into a symmetrical transformation
   //! with respect to a point P.
   //! P is the center of the symmetry.
   Standard_EXPORT void SetMirror (const gp_Pnt2d& P);
   
 
   //! Makes the transformation into a symmetrical transformation
   //! with respect to an axis A.
   //! A is the center of the axial symmetry.
   Standard_EXPORT void SetMirror (const gp_Ax2d& A);
   
   //! Assigns to this transformation the geometric
   //! properties of a rotation at angle Ang (in radians) about point P.
   Standard_EXPORT void SetRotation (const gp_Pnt2d& P, const Standard_Real Ang);
   
 
   //! Makes the transformation into a scale. P is the center of
   //! the scale and S is the scaling value.
   Standard_EXPORT void SetScale (const gp_Pnt2d& P, const Standard_Real S);
   
 
   //! Makes a transformation allowing passage from the coordinate
   //! system "FromSystem1" to the coordinate system "ToSystem2".
   Standard_EXPORT void SetTransformation (const gp_Ax2d& FromSystem1, const gp_Ax2d& ToSystem2);
   
 
   //! Makes the transformation allowing passage from the basic
   //! coordinate system
   //! {P(0.,0.,0.), VX (1.,0.,0.), VY (0.,1.,0.)}
   //! to the local coordinate system defined with the Ax2d ToSystem.
   Standard_EXPORT void SetTransformation (const gp_Ax2d& ToSystem);
   
 
   //! Makes the transformation into a translation.
   //! V is the vector of the translation.
   Standard_EXPORT void SetTranslation (const gp_Vec2d& V);
   
 
   //! Makes the transformation into a translation from the point
   //! P1 to the point P2.
   Standard_EXPORT void SetTranslation (const gp_Pnt2d& P1, const gp_Pnt2d& P2);
   
 
   //! Makes the transformation into a transformation T from
   //! package gp.
   Standard_EXPORT void SetTrsf2d (const gp_Trsf2d& T);
   
   //! Checks whether this transformation is an indirect
   //! transformation: returns true if the determinant of the
   //! matrix of the vectorial part of the transformation is less than 0.
   Standard_EXPORT Standard_Boolean IsNegative() const;
   
   //! Returns the nature of this transformation as a value
   //! of the gp_TrsfForm enumeration.
   //! Returns the nature of the transformation. It can be
   //! Identity, Rotation, Translation, PntMirror, Ax1Mirror,
   //! Scale, CompoundTrsf
   Standard_EXPORT gp_TrsfForm Form() const;
   
   //! Returns the scale value of the transformation.
   Standard_EXPORT Standard_Real ScaleFactor() const;
   
   //! Converts this transformation into a gp_Trsf2d transformation.
   //! Returns a non persistent copy of <me>.
   //! -C++: return const&
   Standard_EXPORT gp_Trsf2d Trsf2d() const;
   
 
   //! Returns the coefficients of the global matrix of transformation.
   //! It is a 2 rows X 3 columns matrix.
   //!
   //! Raised if  Row < 1 or Row > 2  or  Col < 1 or Col > 2
   //!
   //! Computes the reverse transformation.
   Standard_EXPORT Standard_Real Value (const Standard_Integer Row, const Standard_Integer Col) const;
   
   //! Computes the inverse of this transformation.
   //! and  assigns the result to this transformatio
   //!
   //! Raised if the transformation is singular. This means that
   //! the ScaleFactor is lower or equal to Resolution from
   //! package gp.
   Standard_EXPORT void Invert();
   
   //! Computes the inverse of this transformation and creates a new one.
   //! Raises ConstructionError  if the transformation is singular. This means that
   //! the ScaleFactor is lower or equal to Resolution from package gp.
   Standard_NODISCARD Standard_EXPORT Handle(Geom2d_Transformation) Inverted() const;
   
 
   //! Computes the transformation composed with Other and <me>.
   //! <me> * Other.
   //! Returns a new transformation
   Standard_NODISCARD Standard_EXPORT
     Handle(Geom2d_Transformation) Multiplied (const Handle(Geom2d_Transformation)& Other) const;
 Standard_NODISCARD Handle(Geom2d_Transformation) operator * (const Handle(Geom2d_Transformation)& Other) const
 {
   return Multiplied(Other);
 }
   
 
   //! Computes the transformation composed with Other and <me> .
   //! <me> = <me> * Other.
   //!
   //! Computes the following composition of transformations
   //! if N > 0  <me> * <me> * .......* <me>.
   //! if N = 0  Identity
   //! if N < 0  <me>.Invert() * .........* <me>.Invert()
   Standard_EXPORT void Multiply (const Handle(Geom2d_Transformation)& Other);
 void operator *= (const Handle(Geom2d_Transformation)& Other)
 {
   Multiply(Other);
 }
   
 
   //! Raised if N < 0 and if the transformation is not inversible
   Standard_EXPORT void Power (const Standard_Integer N);
   
 
   //! Raised if N < 0 and if the transformation is not inversible
   Standard_EXPORT Handle(Geom2d_Transformation) Powered (const Standard_Integer N) const;
   
 
   //! Computes the matrix of the transformation composed with
   //! <me> and Other.     <me> = Other * <me>
   Standard_EXPORT void PreMultiply (const Handle(Geom2d_Transformation)& Other);
   
 
   //! Applies the transformation <me> to the triplet {X, Y}.
   Standard_EXPORT void Transforms (Standard_Real& X, Standard_Real& Y) const;
   
   //! Creates a new object, which is a copy of this transformation.
   Standard_EXPORT Handle(Geom2d_Transformation) Copy() const;
 
 
 
 
   DEFINE_STANDARD_RTTIEXT(Geom2d_Transformation,Standard_Transient)
 
 protected:
 
 
 
 
 private:
 
 
   gp_Trsf2d gpTrsf2d;
 
 
 };
 
 
 
 
 
 
 
 #endif // _Geom2d_Transformation_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team