AnyCAD Rapid SDK
2020
The Rapid CAD SDK

Public Member Functions  
synchronized void  delete () 
GTrsf ()  
GTrsf (GTrsf2d T)  
void  SetMirror (GPnt P) 
void  SetMirror (GAx1 A1) 
void  SetMirror (GAx2 A2) 
void  SetRotation (GAx1 A1, double Ang) 
void  SetRotation (GQuaternion R) 
void  SetScale (GPnt P, double S) 
void  SetDisplacement (GAx3 FromSystem1, GAx3 ToSystem2) 
void  SetTransformation (GAx3 FromSystem1, GAx3 ToSystem2) 
void  SetTransformation (GAx3 ToSystem) 
void  SetTransformation (GQuaternion R, GVec T) 
void  SetTranslation (GVec V) 
void  SetTranslation (GPnt P1, GPnt P2) 
void  SetTranslationPart (GVec V) 
void  SetScaleFactor (double S) 
void  SetForm (GTrsfForm P) 
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 Row, int Col) 
void  Invert () 
GTrsf  Inverted () 
GTrsf  Multiplied (GTrsf T) 
void  Multiply (GTrsf T) 
void  PreMultiply (GTrsf T) 
void  Power (int N) 
GTrsf  Powered (int N) 
void  Transforms (double[] X, double[] Y, double[] Z) 
void  Transforms (GXYZ Coord) 
Protected Member Functions  
GTrsf (long cPtr, boolean cMemoryOwn)  
void  finalize () 
Static Protected Member Functions  
static long  getCPtr (GTrsf obj) 
Protected Attributes  
transient boolean  swigCMemOwn 
Defines a nonpersistent 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.GTrsf  (  ) 
Returns the identity transformation.
GTrsf.GTrsf  (  GTrsf2d  T  ) 
Creates a 3D transformation from the 2D transformation T. The resulting transformation has a homogeneous vectorial part, V3, and a translation part, T3, built from T: a11 a12 0 a13 V3 = a21 a22 0 T3 = a23 0 0 1. 0 It also has the same scale factor as T. This guarantees (by projection) that the transformation which would be performed by T 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.
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.
boolean GTrsf.GetRotation  (  GXYZ  theAxis, 
double[]  theAngle  
) 
Returns the boolean True if there is nonzero 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.
GQuaternion GTrsf.GetRotation  (  ) 
Returns quaternion representing rotational part of the transformation.
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.
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 : 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 !!!
boolean GTrsf.IsNegative  (  ) 
Returns true if the determinant of the vectorial part of this transformation is negative.
void GTrsf.Multiply  (  GTrsf  T  ) 
Computes the transformation composed with <me> and T. <me> = <me> * T
GTrsf GTrsf.Powered  (  int  N  ) 
Computes the following composition of transformations <me> * <me> * .......* <me>, N time. if N = 0 <me> = Identity if N < 0 <me> = <me>.Inverse() *...........* <me>.Inverse(). Raises if N < 0 and if the matrix of the transformation not inversible.
void GTrsf.PreMultiply  (  GTrsf  T  ) 
Computes the transformation composed with <me> and T. <me> = T * <me>
double GTrsf.ScaleFactor  (  ) 
Returns the scale factor.
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.
void GTrsf.SetMirror  (  GPnt  P  ) 
Makes the transformation into a symmetrical transformation. P is the center of the symmetry.
void GTrsf.SetMirror  (  GAx1  A1  ) 
Makes the transformation into a symmetrical transformation. A1 is the center of the axial symmetry.
void GTrsf.SetMirror  (  GAx2  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".
void GTrsf.SetRotation  (  GAx1  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.
void GTrsf.SetRotation  (  GQuaternion  R  ) 
Changes the transformation into a rotation defined by quaternion. Note that rotation is performed around origin, i.e. no translation is involved.
void GTrsf.SetScale  (  GPnt  P, 
double  S  
) 
Changes the transformation into a scale. P is the center of the scale and S is the scaling value. Raises ConstructionError If <S> is null.
void GTrsf.SetScaleFactor  (  double  S  ) 
Modifies the scale factor. Raises ConstructionError If S is null.
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);
void GTrsf.SetTransformation  (  GAx3  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.
void GTrsf.SetTransformation  (  GQuaternion  R, 
GVec  T  
) 
Sets transformation by directly specified rotation and translation.
void GTrsf.SetTranslation  (  GVec  V  ) 
Changes the transformation into a translation. V is the vector of the translation.
Makes the transformation into a translation where the translation vector is the vector (P1, P2) defined from point P1 to point P2.
void GTrsf.SetTranslationPart  (  GVec  V  ) 
Replaces the translation vector with the vector V.
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.
void GTrsf.Transforms  (  GXYZ  Coord  ) 
Transformation of a triplet XYZ with a Trsf
GXYZ GTrsf.TranslationPart  (  ) 
Returns the translation part of the transformation's matrix
double GTrsf.Value  (  int  Row, 
int  Col  
) 
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
GMat GTrsf.VectorialPart  (  ) 
Returns the vectorial part of the transformation. It is a 3*3 matrix which includes the scale factor.