Public 成员函数
	GTrsf ()

	GTrsf (GTrsf2d theT)

void	SetMirror (GPnt theP)

void	SetMirror (GAx1 theA1)

void	SetMirror (GAx2 theA2)

void	SetRotation (GAx1 theA1, double theAng)

void	SetRotation (GQuaternion theR)

void	SetRotationPart (GQuaternion theR)

void	SetScale (GPnt theP, double theS)

void	SetDisplacement (GAx3 theFromSystem1, GAx3 theToSystem2)

void	SetTransformation (GAx3 theFromSystem1, GAx3 theToSystem2)

void	SetTransformation (GAx3 theToSystem)

void	SetTransformation (GQuaternion R, GVec theT)

void	SetTranslation (GVec theV)

void	SetTranslation (GPnt theP1, GPnt theP2)

void	SetTranslationPart (GVec theV)

void	SetScaleFactor (double theS)

void	SetForm (GTrsfForm theP)

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)

boolean	IsNegative ()

GTrsfForm	Form ()

double	ScaleFactor ()

GXYZ	TranslationPart ()

boolean	GetRotation (GXYZ theAxis, double[] theAngle)

GQuaternion	GetRotation ()

GMat	VectorialPart ()

GMat	HVectorialPart ()

double	Value (int theRow, int theCol)

void	Invert ()

GTrsf	Inverted ()

GTrsf	Multiplied (GTrsf theT)

void	Multiply (GTrsf theT)

void	PreMultiply (GTrsf theT)

void	Power (int theN)

GTrsf	Powered (int theN)

void	Transforms (double[] theX, double[] theY, double[] theZ)

void	Transforms (GXYZ theCoord)

详细描述

Defines a non-persistent transformation in 3D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point, a line, a plane. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow : V1 V2 V3 T XYZ XYZ | a11 a12 a13 a14 | | x | | x'| | a21 a22 a23 a24 | | y | | y'| | a31 a32 a33 a34 | | z | = | z'| | 0 0 0 1 | | 1 | | 1 | where {V1, V2, V3} defines the vectorial part of the transformation and T defines the translation part of the transformation. This transformation never change the nature of the objects.

构造及析构函数说明

◆ GTrsf() [1/2]

GTrsf.GTrsf ( )

Returns the identity transformation.

◆ GTrsf() [2/2]

GTrsf.GTrsf ( GTrsf2d theT )

Creates a 3D transformation from the 2D transformation theT. The resulting transformation has a homogeneous vectorial part, V3, and a translation part, T3, built from theT: a11 a12 0 a13 V3 = a21 a22 0 T3 = a23 0 0 1. 0 It also has the same scale factor as theT. This guarantees (by projection) that the transformation which would be performed by theT in a plane (2D space) is performed by the resulting transformation in the xOy plane of the 3D space, (i.e. in the plane defined by the origin (0., 0., 0.) and the vectors DX (1., 0., 0.), and DY (0., 1., 0.)). The scale factor is applied to the entire space.

成员函数说明

◆ Form()

GTrsfForm GTrsf.Form ( )

Returns the nature of the transformation. It can be: an identity transformation, a rotation, a translation, a mirror transformation (relative to a point, an axis or a plane), a scaling transformation, or a compound transformation.

◆ GetRotation() [1/2]

GQuaternion GTrsf.GetRotation ( )

Returns quaternion representing rotational part of the transformation.

◆ GetRotation() [2/2]

boolean GTrsf.GetRotation	(	GXYZ	theAxis,
		double[]	theAngle
	)

Returns the boolean True if there is non-zero rotation. In the presence of rotation, the output parameters store the axis and the angle of rotation. The method always returns positive value "theAngle", i.e., 0. < theAngle <= PI. Note that this rotation is defined only by the vectorial part of the transformation; generally you would need to check also the translational part to obtain the axis (gp_Ax1) of rotation.

◆ HVectorialPart()

GMat GTrsf.HVectorialPart ( )

Computes the homogeneous vectorial part of the transformation. It is a 3*3 matrix which doesn't include the scale factor. In other words, the vectorial part of this transformation is equal to its homogeneous vectorial part, multiplied by the scale factor. The coefficients of this matrix must be multiplied by the scale factor to obtain the coefficients of the transformation.

◆ Inverted()

GTrsf GTrsf.Inverted ( )

Computes the reverse transformation Raises an exception if the matrix of the transformation is not inversible, it means that the scale factor is lower or equal to Resolution from package gp. Computes the transformation composed with T and <me>. In a C++ implementation you can also write Tcomposed = <me> * T. Example : gp_Trsf T1, T2, Tcomp; ............... Tcomp = T2.Multiplied(T1); // or (Tcomp = T2 * T1) gp_Pnt P1(10.,3.,4.); gp_Pnt P2 = P1.Transformed(Tcomp); // using Tcomp gp_Pnt P3 = P1.Transformed(T1); // using T1 then T2 P3.Transform(T2); // P3 = P2 !!!

◆ IsNegative()

boolean GTrsf.IsNegative ( )

Returns true if the determinant of the vectorial part of this transformation is negative.

◆ Multiply()

void GTrsf.Multiply ( GTrsf theT )

Computes the transformation composed with <me> and theT. <me> = <me> * theT

◆ Powered()

GTrsf GTrsf.Powered ( int theN )

Computes the following composition of transformations <me> * <me> * .......* <me>, theN time. if theN = 0 <me> = Identity if theN < 0 <me> = <me>.Inverse() *...........* <me>.Inverse(). Raises if theN < 0 and if the matrix of the transformation not inversible.

◆ PreMultiply()

void GTrsf.PreMultiply ( GTrsf theT )

Computes the transformation composed with <me> and T. <me> = theT * <me>

◆ ScaleFactor()

double GTrsf.ScaleFactor ( )

Returns the scale factor.

◆ SetDisplacement()

void GTrsf.SetDisplacement	(	GAx3	theFromSystem1,
		GAx3	theToSystem2
	)

Modifies this transformation so that it transforms the coordinate system defined by theFromSystem1 into the one defined by theToSystem2. After this modification, this transformation transforms: - the origin of theFromSystem1 into the origin of theToSystem2, - the "X Direction" of theFromSystem1 into the "X Direction" of theToSystem2, - the "Y Direction" of theFromSystem1 into the "Y Direction" of theToSystem2, and - the "main Direction" of theFromSystem1 into the "main Direction" of theToSystem2. Warning When you know the coordinates of a point in one coordinate system and you want to express these coordinates in another one, do not use the transformation resulting from this function. Use the transformation that results from SetTransformation instead. SetDisplacement and SetTransformation create related transformations: the vectorial part of one is the inverse of the vectorial part of the other.

◆ SetMirror() [1/3]

void GTrsf.SetMirror ( GAx1 theA1 )

Makes the transformation into a symmetrical transformation. theA1 is the center of the axial symmetry.

◆ SetMirror() [2/3]

void GTrsf.SetMirror ( GAx2 theA2 )

Makes the transformation into a symmetrical transformation. theA2 is the center of the planar symmetry and defines the plane of symmetry by its origin, "X Direction" and "Y Direction".

◆ SetMirror() [3/3]

void GTrsf.SetMirror ( GPnt theP )

Makes the transformation into a symmetrical transformation. theP is the center of the symmetry.

◆ SetRotation() [1/2]

void GTrsf.SetRotation	(	GAx1	theA1,
		double	theAng
	)

Changes the transformation into a rotation. theA1 is the rotation axis and theAng is the angular value of the rotation in radians.

◆ SetRotation() [2/2]

void GTrsf.SetRotation ( GQuaternion theR )

Changes the transformation into a rotation defined by quaternion. Note that rotation is performed around origin, i.e. no translation is involved.

◆ SetRotationPart()

void GTrsf.SetRotationPart ( GQuaternion theR )

Replaces the rotation part with specified quaternion.

◆ SetScale()

void GTrsf.SetScale	(	GPnt	theP,
		double	theS
	)

Changes the transformation into a scale. theP is the center of the scale and theS is the scaling value. Raises ConstructionError If <theS> is null.

◆ SetScaleFactor()

void GTrsf.SetScaleFactor ( double theS )

Modifies the scale factor. Raises ConstructionError If theS is null.

◆ SetTransformation() [1/3]

void GTrsf.SetTransformation	(	GAx3	theFromSystem1,
		GAx3	theToSystem2
	)

Modifies this transformation so that it transforms the coordinates of any point, (x, y, z), relative to a source coordinate system into the coordinates (x', y', z') which are relative to a target coordinate system, but which represent the same point The transformation is from the coordinate system "theFromSystem1" to the coordinate system "theToSystem2". Example : gp_Ax3 theFromSystem1, theToSystem2; double x1, y1, z1; // are the coordinates of a point in the local system theFromSystem1 double x2, y2, z2; // are the coordinates of a point in the local system theToSystem2 gp_Pnt P1 (x1, y1, z1) gp_Trsf T; T.SetTransformation (theFromSystem1, theToSystem2); gp_Pnt P2 = P1.Transformed (T); P2.Coord (x2, y2, z2);

◆ SetTransformation() [2/3]

void GTrsf.SetTransformation ( GAx3 theToSystem )

Modifies this transformation so that it transforms the coordinates of any point, (x, y, z), relative to a source coordinate system into the coordinates (x', y', z') which are relative to a target coordinate system, but which represent the same point The transformation is from the default coordinate system {P(0.,0.,0.), VX (1.,0.,0.), VY (0.,1.,0.), VZ (0., 0. ,1.) } to the local coordinate system defined with the Ax3 theToSystem. Use in the same way as the previous method. FromSystem1 is defaulted to the absolute coordinate system.

◆ SetTransformation() [3/3]

void GTrsf.SetTransformation	(	GQuaternion	R,
		GVec	theT
	)

Sets transformation by directly specified rotation and translation.

◆ SetTranslation() [1/2]

void GTrsf.SetTranslation	(	GPnt	theP1,
		GPnt	theP2
	)

Makes the transformation into a translation where the translation vector is the vector (theP1, theP2) defined from point theP1 to point theP2.

◆ SetTranslation() [2/2]

void GTrsf.SetTranslation ( GVec theV )

Changes the transformation into a translation. theV is the vector of the translation.

◆ SetTranslationPart()

void GTrsf.SetTranslationPart ( GVec theV )

Replaces the translation vector with the vector theV.

◆ SetValues()

void GTrsf.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
	)

Sets the coefficients of the transformation. The transformation of the point x,y,z is the point x',y',z' with : x' = a11 x + a12 y + a13 z + a14 y' = a21 x + a22 y + a23 z + a24 z' = a31 x + a32 y + a33 z + a34 The method Value(i,j) will return aij. Raises ConstructionError if the determinant of the aij is null. The matrix is orthogonalized before future using.

◆ Transforms()

void GTrsf.Transforms ( GXYZ theCoord )

Transformation of a triplet XYZ with a Trsf

◆ TranslationPart()

GXYZ GTrsf.TranslationPart ( )

Returns the translation part of the transformation's matrix

◆ Value()

double GTrsf.Value	(	int	theRow,
		int	theCol
	)

Returns the coefficients of the transformation's matrix. It is a 3 rows * 4 columns matrix. This coefficient includes the scale factor. Raises OutOfRanged if theRow < 1 or theRow > 3 or theCol < 1 or theCol > 4

◆ VectorialPart()

GMat GTrsf.VectorialPart ( )

Returns the vectorial part of the transformation. It is a 3*3 matrix which includes the scale factor.

Public 成员函数