Describes an axis in the plane (2D space). An axis is defined by: More...

#include <gp_Ax2d.hxx>

Public Member Functions
	gp_Ax2d ()
	Creates an axis object representing X axis of the reference co-ordinate system. More...

	gp_Ax2d (const gp_Pnt2d &P, const gp_Dir2d &V)
	Creates an Ax2d. More...

void	SetLocation (const gp_Pnt2d &Locat)
	Changes the "Location" point (origin) of <me>. More...

void	SetDirection (const gp_Dir2d &V)
	Changes the direction of <me>. More...

const gp_Pnt2d &	Location () const
	Returns the origin of <me>. More...

const gp_Dir2d &	Direction () const
	Returns the direction of <me>. More...

Standard_Boolean	IsCoaxial (const gp_Ax2d &Other, const Standard_Real AngularTolerance, const Standard_Real LinearTolerance) const
	Returns True if : . the angle between <me> and <Other> is lower or equal to <AngularTolerance> and . the distance between <me>.Location() and <Other> is lower or equal to <LinearTolerance> and . the distance between <Other>.Location() and <me> is lower or equal to LinearTolerance. More...

Standard_Boolean	IsNormal (const gp_Ax2d &Other, const Standard_Real AngularTolerance) const
	Returns true if this axis and the axis Other are normal to each other. That is, if the angle between the two axes is equal to Pi/2 or -Pi/2. Note: the tolerance criterion is given by AngularTolerance. More...

Standard_Boolean	IsOpposite (const gp_Ax2d &Other, const Standard_Real AngularTolerance) const
	Returns true if this axis and the axis Other are parallel, and have opposite orientations. That is, if the angle between the two axes is equal to Pi or -Pi. Note: the tolerance criterion is given by AngularTolerance. More...

Standard_Boolean	IsParallel (const gp_Ax2d &Other, const Standard_Real AngularTolerance) const
	Returns true if this axis and the axis Other are parallel, and have either the same or opposite orientations. That is, if the angle between the two axes is equal to 0, Pi or -Pi. Note: the tolerance criterion is given by AngularTolerance. More...

Standard_Real	Angle (const gp_Ax2d &Other) const
	Computes the angle, in radians, between this axis and the axis Other. The value of the angle is between -Pi and Pi. More...

void	Reverse ()
	Reverses the direction of <me> and assigns the result to this axis. More...

gp_Ax2d	Reversed () const
	Computes a new axis placement with a direction opposite to the direction of <me>. More...

void	Mirror (const gp_Pnt2d &P)

gp_Ax2d	Mirrored (const gp_Pnt2d &P) const
	Performs the symmetrical transformation of an axis placement with respect to the point P which is the center of the symmetry. More...

void	Mirror (const gp_Ax2d &A)

gp_Ax2d	Mirrored (const gp_Ax2d &A) const
	Performs the symmetrical transformation of an axis placement with respect to an axis placement which is the axis of the symmetry. More...

void	Rotate (const gp_Pnt2d &P, const Standard_Real Ang)

gp_Ax2d	Rotated (const gp_Pnt2d &P, const Standard_Real Ang) const
	Rotates an axis placement. More...

void	Scale (const gp_Pnt2d &P, const Standard_Real S)

gp_Ax2d	Scaled (const gp_Pnt2d &P, const Standard_Real S) const
	Applies a scaling transformation on the axis placement. The "Location" point of the axisplacement is modified. The "Direction" is reversed if the scale is negative. More...

void	Transform (const gp_Trsf2d &T)

gp_Ax2d	Transformed (const gp_Trsf2d &T) const
	Transforms an axis placement with a Trsf. More...

void	Translate (const gp_Vec2d &V)

gp_Ax2d	Translated (const gp_Vec2d &V) const
	Translates an axis placement in the direction of the vector <V>. The magnitude of the translation is the vector's magnitude. More...

void	Translate (const gp_Pnt2d &P1, const gp_Pnt2d &P2)

gp_Ax2d	Translated (const gp_Pnt2d &P1, const gp_Pnt2d &P2) const
	Translates an axis placement from the point <P1> to the point <P2>. More...

Detailed Description

Describes an axis in the plane (2D space). An axis is defined by:

its origin (also referred to as its "Location point"), and
its unit vector (referred to as its "Direction"). An axis implicitly defines a direct, right-handed coordinate system in 2D space by:
its origin,
its "Direction" (giving the "X Direction" of the coordinate system), and
the unit vector normal to "Direction" (positive angle measured in the trigonometric sense). An axis is used:
to describe 2D geometric entities (for example, the axis which defines angular coordinates on a circle). It serves for the same purpose as the STEP function "axis placement one axis", or
to define geometric transformations (axis of symmetry, axis of rotation, and so on). Note: to define a left-handed 2D coordinate system, use gp_Ax22d.

Constructor & Destructor Documentation

◆ gp_Ax2d() [1/2]

gp_Ax2d::gp_Ax2d ( )

Creates an axis object representing X axis of the reference co-ordinate system.

◆ gp_Ax2d() [2/2]

gp_Ax2d::gp_Ax2d	(	const gp_Pnt2d &	P,
		const gp_Dir2d &	V
	)

Creates an Ax2d.

is the "Location" point of the axis placement and V is the "Direction" of the axis placement.

Member Function Documentation

◆ Angle()

Standard_Real gp_Ax2d::Angle ( const gp_Ax2d & Other ) const

Computes the angle, in radians, between this axis and the axis Other. The value of the angle is between -Pi and Pi.

◆ Direction()

const gp_Dir2d& gp_Ax2d::Direction ( ) const

Returns the direction of <me>.

◆ IsCoaxial()

Standard_Boolean gp_Ax2d::IsCoaxial	(	const gp_Ax2d &	Other,
		const Standard_Real	AngularTolerance,
		const Standard_Real	LinearTolerance
	)		const

Returns True if : . the angle between <me> and <Other> is lower or equal to <AngularTolerance> and . the distance between <me>.Location() and <Other> is lower or equal to <LinearTolerance> and . the distance between <Other>.Location() and <me> is lower or equal to LinearTolerance.

◆ IsNormal()

Standard_Boolean gp_Ax2d::IsNormal	(	const gp_Ax2d &	Other,
		const Standard_Real	AngularTolerance
	)		const

Returns true if this axis and the axis Other are normal to each other. That is, if the angle between the two axes is equal to Pi/2 or -Pi/2. Note: the tolerance criterion is given by AngularTolerance.

◆ IsOpposite()

Standard_Boolean gp_Ax2d::IsOpposite	(	const gp_Ax2d &	Other,
		const Standard_Real	AngularTolerance
	)		const

Returns true if this axis and the axis Other are parallel, and have opposite orientations. That is, if the angle between the two axes is equal to Pi or -Pi. Note: the tolerance criterion is given by AngularTolerance.

◆ IsParallel()

Standard_Boolean gp_Ax2d::IsParallel	(	const gp_Ax2d &	Other,
		const Standard_Real	AngularTolerance
	)		const

Returns true if this axis and the axis Other are parallel, and have either the same or opposite orientations. That is, if the angle between the two axes is equal to 0, Pi or -Pi. Note: the tolerance criterion is given by AngularTolerance.

◆ Location()

const gp_Pnt2d& gp_Ax2d::Location ( ) const

Returns the origin of <me>.

◆ Mirror() [1/2]

void gp_Ax2d::Mirror ( const gp_Pnt2d & P )

◆ Mirror() [2/2]

void gp_Ax2d::Mirror ( const gp_Ax2d & A )

◆ Mirrored() [1/2]

gp_Ax2d gp_Ax2d::Mirrored ( const gp_Pnt2d & P ) const

Performs the symmetrical transformation of an axis placement with respect to the point P which is the center of the symmetry.

◆ Mirrored() [2/2]

gp_Ax2d gp_Ax2d::Mirrored ( const gp_Ax2d & A ) const

Performs the symmetrical transformation of an axis placement with respect to an axis placement which is the axis of the symmetry.

◆ Reverse()

void gp_Ax2d::Reverse ( )

Reverses the direction of <me> and assigns the result to this axis.

◆ Reversed()

gp_Ax2d gp_Ax2d::Reversed ( ) const

Computes a new axis placement with a direction opposite to the direction of <me>.

◆ Rotate()

void gp_Ax2d::Rotate	(	const gp_Pnt2d &	P,
		const Standard_Real	Ang
	)

◆ Rotated()

gp_Ax2d gp_Ax2d::Rotated	(	const gp_Pnt2d &	P,
		const Standard_Real	Ang
	)		const

Rotates an axis placement.

is the center of the rotation . Ang is the angular value of the rotation in radians.

◆ Scale()

void gp_Ax2d::Scale	(	const gp_Pnt2d &	P,
		const Standard_Real	S
	)

◆ Scaled()

gp_Ax2d gp_Ax2d::Scaled	(	const gp_Pnt2d &	P,
		const Standard_Real	S
	)		const

Applies a scaling transformation on the axis placement. The "Location" point of the axisplacement is modified. The "Direction" is reversed if the scale is negative.

◆ SetDirection()

void gp_Ax2d::SetDirection ( const gp_Dir2d & V )

Changes the direction of <me>.

◆ SetLocation()

void gp_Ax2d::SetLocation ( const gp_Pnt2d & Locat )

Changes the "Location" point (origin) of <me>.

◆ Transform()

void gp_Ax2d::Transform ( const gp_Trsf2d & T )

◆ Transformed()

gp_Ax2d gp_Ax2d::Transformed ( const gp_Trsf2d & T ) const

Transforms an axis placement with a Trsf.

◆ Translate() [1/2]

void gp_Ax2d::Translate ( const gp_Vec2d & V )

◆ Translate() [2/2]

void gp_Ax2d::Translate	(	const gp_Pnt2d &	P1,
		const gp_Pnt2d &	P2
	)

◆ Translated() [1/2]

gp_Ax2d gp_Ax2d::Translated ( const gp_Vec2d & V ) const

Translates an axis placement in the direction of the vector <V>. The magnitude of the translation is the vector's magnitude.

◆ Translated() [2/2]

gp_Ax2d gp_Ax2d::Translated	(	const gp_Pnt2d &	P1,
		const gp_Pnt2d &	P2
	)		const

Translates an axis placement from the point <P1> to the point <P2>.

The documentation for this class was generated from the following file:

gp_Ax2d.hxx

Public Member Functions