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

File indexing completed on 2026-09-12 09:17:22

 // Copyright (c) 1991-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 _gp_Ax22d_HeaderFile
 #define _gp_Ax22d_HeaderFile
 
 #include <gp_Ax2d.hxx>
 #include <gp_Dir2d.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Trsf2d.hxx>
 #include <gp_Vec2d.hxx>
 
 //! Describes a coordinate system in a plane (2D space).
 //! A coordinate system is defined by:
 //! -   its origin (also referred to as its "Location point"), and
 //! -   two orthogonal unit vectors, respectively, called the "X
 //! Direction" and the "Y Direction".
 //! A gp_Ax22d may be right-handed ("direct sense") or
 //! left-handed ("inverse" or "indirect sense").
 //! You use a gp_Ax22d to:
 //! - describe 2D geometric entities, in particular to position
 //! them. The local coordinate system of a geometric
 //! entity serves for the same purpose as the STEP
 //! function "axis placement two axes", or
 //! -   define geometric transformations.
 //! Note: we refer to the "X Axis" and "Y Axis" as the axes having:
 //! -   the origin of the coordinate system as their origin, and
 //! -   the unit vectors "X Direction" and "Y Direction",
 //! respectively, as their unit vectors.
 class gp_Ax22d
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! Creates an object representing the reference
   //! coordinate system (OXY).
   constexpr gp_Ax22d() noexcept
       : vydir(gp_Dir2d::D::Y)
   // vxdir default ctor creates X direction (1, 0)
   {
   }
 
   //! Creates a coordinate system with origin theP and where:
   //! -   theVx is the "X Direction", and
   //! -   the "Y Direction" is orthogonal to theVx and
   //! oriented so that the cross products theVx^"Y
   //! Direction" and theVx^theVy have the same sign.
   //! Raises ConstructionError if theVx and theVy are parallel (same or opposite orientation).
   constexpr gp_Ax22d(const gp_Pnt2d& theP, const gp_Dir2d& theVx, const gp_Dir2d& theVy)
       : point(theP),
         vydir(theVy),
         vxdir(theVx)
   {
     const double aValue = theVx.Crossed(theVy);
     if (aValue >= 0.0)
     {
       vydir.SetCoord(-vxdir.Y(), vxdir.X());
     }
     else
     {
       vydir.SetCoord(vxdir.Y(), -vxdir.X());
     }
   }
 
   //! Creates a coordinate system with origin theP and "X Direction"
   //! theV, which is:
   //! -   right-handed if theIsSense is true (default value), or
   //! -   left-handed if theIsSense is false
   constexpr gp_Ax22d(const gp_Pnt2d& theP, const gp_Dir2d& theV, const bool theIsSense = true)
       : point(theP),
         vxdir(theV)
   {
     if (theIsSense)
     {
       vydir.SetCoord(-theV.Y(), theV.X());
     }
     else
     {
       vydir.SetCoord(theV.Y(), -theV.X());
     }
   }
 
   //! Creates a coordinate system where its origin is the origin of
   //! theA and its "X Direction" is the unit vector of theA, which is:
   //! -   right-handed if theIsSense is true (default value), or
   //! -   left-handed if theIsSense is false.
   constexpr gp_Ax22d(const gp_Ax2d& theA, const bool theIsSense = true)
       : point(theA.Location()),
         vxdir(theA.Direction())
   {
     if (theIsSense)
     {
       vydir.SetCoord(-vxdir.Y(), vxdir.X());
     }
     else
     {
       vydir.SetCoord(vxdir.Y(), -vxdir.X());
     }
   }
 
   //! Assigns the origin and the two unit vectors of the
   //! coordinate system theA1 to this coordinate system.
   constexpr void SetAxis(const gp_Ax22d& theA1) noexcept
   {
     point = theA1.Location();
     vxdir = theA1.XDirection();
     vydir = theA1.YDirection();
   }
 
   //! Changes the XAxis and YAxis ("Location" point and "Direction")
   //! of <me>.
   //! The "YDirection" is recomputed in the same sense as before.
   constexpr void SetXAxis(const gp_Ax2d& theA1);
 
   //! Changes the XAxis and YAxis ("Location" point and "Direction") of <me>.
   //! The "XDirection" is recomputed in the same sense as before.
   constexpr void SetYAxis(const gp_Ax2d& theA1);
 
   //! Changes the "Location" point (origin) of <me>.
   constexpr void SetLocation(const gp_Pnt2d& theP) noexcept { point = theP; }
 
   //! Assigns theVx to the "X Direction" of
   //! this coordinate system. The other unit vector of this
   //! coordinate system is recomputed, normal to theVx ,
   //! without modifying the orientation (right-handed or
   //! left-handed) of this coordinate system.
   constexpr void SetXDirection(const gp_Dir2d& theVx);
 
   //! Assigns theVy to the "Y Direction" of
   //! this coordinate system. The other unit vector of this
   //! coordinate system is recomputed, normal to theVy,
   //! without modifying the orientation (right-handed or
   //! left-handed) of this coordinate system.
   constexpr void SetYDirection(const gp_Dir2d& theVy);
 
   //! Returns an axis, for which
   //! -   the origin is that of this coordinate system, and
   //! -   the unit vector is either the "X Direction" of this coordinate system.
   //! Note: the result is the "X Axis" of this coordinate system.
   gp_Ax2d XAxis() const { return gp_Ax2d(point, vxdir); }
 
   //! Returns an axis, for which
   //! -   the origin is that of this coordinate system, and
   //! - the unit vector is either the "Y Direction" of this coordinate system.
   //! Note: the result is the "Y Axis" of this coordinate system.
   gp_Ax2d YAxis() const { return gp_Ax2d(point, vydir); }
 
   //! Returns the "Location" point (origin) of <me>.
   constexpr const gp_Pnt2d& Location() const noexcept { return point; }
 
   //! Returns the "XDirection" of <me>.
   constexpr const gp_Dir2d& XDirection() const noexcept { return vxdir; }
 
   //! Returns the "YDirection" of <me>.
   constexpr const gp_Dir2d& YDirection() const noexcept { return vydir; }
 
   Standard_EXPORT void Mirror(const gp_Pnt2d& theP) noexcept;
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to the point theP which is the
   //! center of the symmetry.
   //! Warnings :
   //! The main direction of the axis placement is not changed.
   //! The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
   [[nodiscard]] Standard_EXPORT gp_Ax22d Mirrored(const gp_Pnt2d& theP) const noexcept;
 
   Standard_EXPORT void Mirror(const gp_Ax2d& theA) noexcept;
 
   //! Performs the symmetrical transformation of an axis
   //! placement with respect to an axis placement which
   //! is the axis of the symmetry.
   //! The transformation is performed on the "Location"
   //! point, on the "XDirection" and "YDirection".
   //! The resulting main "Direction" is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
   [[nodiscard]] Standard_EXPORT gp_Ax22d Mirrored(const gp_Ax2d& theA) const noexcept;
 
   void Rotate(const gp_Pnt2d& theP, const double theAng);
 
   //! Rotates an axis placement. <theA1> is the axis of the
   //! rotation. theAng is the angular value of the rotation
   //! in radians.
   [[nodiscard]] gp_Ax22d Rotated(const gp_Pnt2d& theP, const double theAng) const
   {
     gp_Ax22d aTemp = *this;
     aTemp.Rotate(theP, theAng);
     return aTemp;
   }
 
   void Scale(const gp_Pnt2d& theP, const double theS);
 
   //! Applies a scaling transformation on the axis placement.
   //! The "Location" point of the axisplacement is modified.
   //! Warnings:
   //! If the scale <theS> is negative:
   //! . the main direction of the axis placement is not changed.
   //! . The "XDirection" and the "YDirection" are reversed.
   //! So the axis placement stay right handed.
   [[nodiscard]] gp_Ax22d Scaled(const gp_Pnt2d& theP, const double theS) const
   {
     gp_Ax22d aTemp = *this;
     aTemp.Scale(theP, theS);
     return aTemp;
   }
 
   void Transform(const gp_Trsf2d& theT) noexcept;
 
   //! Transforms an axis placement with a Trsf.
   //! The "Location" point, the "XDirection" and the
   //! "YDirection" are transformed with theT. The resulting
   //! main "Direction" of <me> is the cross product between
   //! the "XDirection" and the "YDirection" after transformation.
   [[nodiscard]] gp_Ax22d Transformed(const gp_Trsf2d& theT) const
   {
     gp_Ax22d aTemp = *this;
     aTemp.Transform(theT);
     return aTemp;
   }
 
   constexpr void Translate(const gp_Vec2d& theV) noexcept { point.Translate(theV); }
 
   //! Translates an axis plaxement in the direction of the vector
   //! <theV>. The magnitude of the translation is the vector's magnitude.
   [[nodiscard]] constexpr gp_Ax22d Translated(const gp_Vec2d& theV) const noexcept
   {
     gp_Ax22d aTemp = *this;
     aTemp.Translate(theV);
     return aTemp;
   }
 
   constexpr void Translate(const gp_Pnt2d& theP1, const gp_Pnt2d& theP2) noexcept
   {
     point.Translate(theP1, theP2);
   }
 
   //! Translates an axis placement from the point <theP1> to the
   //! point <theP2>.
   [[nodiscard]] constexpr gp_Ax22d Translated(const gp_Pnt2d& theP1,
                                               const gp_Pnt2d& theP2) const noexcept
   {
     gp_Ax22d aTemp = *this;
     aTemp.Translate(theP1, theP2);
     return aTemp;
   }
 
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson(Standard_OStream& theOStream, int theDepth = -1) const;
 
 private:
   gp_Pnt2d point;
   gp_Dir2d vydir;
   gp_Dir2d vxdir;
 };
 
 //=================================================================================================
 
 inline constexpr void gp_Ax22d::SetXAxis(const gp_Ax2d& theA1)
 {
   const bool isSign = (vxdir.Crossed(vydir)) >= 0.0;
   point             = theA1.Location();
   vxdir             = theA1.Direction();
   if (isSign)
   {
     vydir.SetCoord(-vxdir.Y(), vxdir.X());
   }
   else
   {
     vydir.SetCoord(vxdir.Y(), -vxdir.X());
   }
 }
 
 //=================================================================================================
 
 inline constexpr void gp_Ax22d::SetYAxis(const gp_Ax2d& theA1)
 {
   const bool isSign = (vxdir.Crossed(vydir)) >= 0.0;
   point             = theA1.Location();
   vydir             = theA1.Direction();
   if (isSign)
   {
     vxdir.SetCoord(vydir.Y(), -vydir.X());
   }
   else
   {
     vxdir.SetCoord(-vydir.Y(), vydir.X());
   }
 }
 
 //=================================================================================================
 
 inline constexpr void gp_Ax22d::SetXDirection(const gp_Dir2d& theVx)
 {
   const bool isSign = (vxdir.Crossed(vydir)) >= 0.0;
   vxdir             = theVx;
   if (isSign)
   {
     vydir.SetCoord(-theVx.Y(), theVx.X());
   }
   else
   {
     vydir.SetCoord(theVx.Y(), -theVx.X());
   }
 }
 
 //=================================================================================================
 
 inline constexpr void gp_Ax22d::SetYDirection(const gp_Dir2d& theVy)
 {
   const bool isSign = (vxdir.Crossed(vydir)) >= 0.0;
   vydir             = theVy;
   if (isSign)
   {
     vxdir.SetCoord(theVy.Y(), -theVy.X());
   }
   else
   {
     vxdir.SetCoord(-theVy.Y(), theVy.X());
   }
 }
 
 //=================================================================================================
 
 inline void gp_Ax22d::Rotate(const gp_Pnt2d& theP, const double theAng)
 {
   gp_Pnt2d aTemp = point;
   aTemp.Rotate(theP, theAng);
   point = aTemp;
   vxdir.Rotate(theAng);
   vydir.Rotate(theAng);
 }
 
 //=================================================================================================
 
 inline void gp_Ax22d::Scale(const gp_Pnt2d& theP, const double theS)
 {
   gp_Pnt2d aTemp = point;
   aTemp.Scale(theP, theS);
   point = aTemp;
   if (theS < 0.0)
   {
     vxdir.Reverse();
     vydir.Reverse();
   }
 }
 
 //=================================================================================================
 
 inline void gp_Ax22d::Transform(const gp_Trsf2d& theT) noexcept
 {
   gp_Pnt2d aTemp = point;
   aTemp.Transform(theT);
   point = aTemp;
   vxdir.Transform(theT);
   vydir.Transform(theT);
 }
 
 #endif // _gp_Ax22d_HeaderFile

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