DG Kernel Documentation

Defines a 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 |

HRESULT SetMirror(DIPoint* P)

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

HRESULT SetMirror2(IKO_gp_Ax1* A1)

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

HRESULT SetMirror3(IKO_gp_Ax2* A2)

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

HRESULT SetRotation(IKO_gp_Ax1* A1, double Ang)

Changes the transformation into a rotation. A1 is the rotation axis and Ang is the angular value of the rotation in radians.

HRESULT SetRotation2(IKO_gp_Quaternion* rotation)

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

HRESULT SetScale(DIPoint* P, double S)

Changes the transformation into a scale. P is the center of the scale and S is the scaling value.

HRESULT SetDisplacement(IKO_gp_Ax3* FromSystem1, IKO_gp_Ax3* ToSystem2)

Modifies this transformation so that it transforms the coordinate system defined by FromSystem1 into the one defined by ToSystem2. After this modification, this transformation transforms: the origin of FromSystem1 into the origin of ToSystem2, the "X Direction" of FromSystem1 into the "X
Direction" of ToSystem2, the "Y Direction" of FromSystem1 into the "Y
Direction" of ToSystem2, and the "main Direction" of FromSystem1 into the "main
Direction" of ToSystem2. 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.

HRESULT SetTransformation(IKO_gp_Ax3* FromSystem1, IKO_gp_Ax3* ToSystem2)

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 "FromSystem1" to the coordinate system "ToSystem2". Example : In a C++ implementation : Real x1, y1, z1; // are the coordinates of a point in the // local system FromSystem1 Real x2, y2, z2; // are the coordinates of a point in the // local system ToSystem2 gp_Pnt P1 (x1, y1, z1) Trsf T; T.SetTransformation (FromSystem1, ToSystem2); gp_Pnt P2 = P1.Transformed (T); P2.Coord (x2, y2, z2);

HRESULT SetTransformation2(IKO_gp_Ax3* ToSystem)

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 ToSystem. Use in the same way as the previous method. FromSystem1 is defaulted to the absolute coordinate system.

HRESULT SetTransformation3(IKO_gp_Quaternion* R, DIVect* T)

Sets transformation by directly specified rotation and translation

HRESULT SetTranslation(DIVect* V)pt -[in,out] Point to mirror

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

HRESULT SetTranslation2(DIPoint* P1, DIPoint* P2)

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

HRESULT HRESULT SetTranslationPart(DIVect* V)

Replaces the translation vector with the vector V.

HRESULT SetScaleFactor(double S)

HRESULT 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)

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 + a43 z + a34 Tolang and TolDist are used to test for null angles and null distances to determine the form of the transformation (identity, translation, etc..). The method Value(i,j) will return aij. Raises ConstructionError if the determinant of the aij is null. Or if the matrix as not a uniform scale.

HRESULT TranslationPart(DIVect* V)

Returns the translation part of the transformation's matrix

HRESULT GetRotation(IKO_gp_Quaternion** rotation)

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.

HRESULT Value(int Row, int Col, double* d)

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 Row < 1 or Row > 3 or Col < 1 or Col > 4

HRESULT Invert()HRESULT Invert()

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 . In a C++ implementation you can also write Tcomposed = Example : Trsf T1, T2, Tcomp; ............... Tcomp = T2.Multiplied(T1); // or (Tcomp = T2 * T1) Pnt P1(10.,3.,4.); Pnt P2 = P1.Transformed(Tcomp); //using Tcomp Pnt P3 = P1.Transformed(T1); //using T1 then T2 P3.Transform(T2); // P3 = P2 !!!

HRESULT MultiplyHRESULT Multiply(IKO_gp_Trsf* T)

Computes the transformation composed with T and . In a C++ implementation you can also write Tcomposed = * T. Example : Trsf T1, T2, Tcomp; ............... //composition : Tcomp = T2.Multiplied(T1); // or (Tcomp = T2 * T1) // transformation of a point Pnt P1(10.,3.,4.); Pnt P2 = P1.Transformed(Tcomp); //using Tcomp Pnt P3 = P1.Transformed(T1); //using T1 then T2 P3.Transform(T2); // P3 = P2 !!! Computes the transformation composed with and T. = T *

HRESHRESULT Transforms(double* X, double* Y, double* Z)

Transformation of a triplet XYZ with this

HRESULT Transforms2(DIPoint* P)

Transformation of P with this