Transform

References
[StructLayout(LayoutKind.Sequential, Pack = 8, Size = 128)] [Serializable] public struct Transform : IComparable<Transform>, IEquatable<Transform>, ICloneable
Represents the values in a 4x4 transform matrix.

This is parallel to C++ ON_Xform.

Constructors

Transform

#Since v5.0
Initializes a new transform matrix with a specified value along the diagonal.
public Transform(
diagonalValue
Value to assign to all diagonal cells except M33 which is set to 1.0.
)

Transform

#Since v6.0
Initializes a new transform matrix with a specified value.
public Transform(
Transform
value
Value to assign to all cells.
)

Properties

Determinant

#Since v5.0
The determinant of this 4x4 matrix.
public double Determinant { get; }

Identity

#Since v5.0
Gets a new identity transform matrix. An identity matrix defines no transformation.
public static Transform Identity { get; }

IsAffine

#Since v6.12
Tests for an affine transformation. A transformation is affine if it is valid and its last row is [0, 0, 0, 1]. An affine transformation can be broken into a linear transformation and a translation.
public bool IsAffine { get; }

IsIdentity

#Since v6.0
Return true if this Transform is the identity transform
public bool IsIdentity { get; }

IsLinear

#Since v6.12
Tests for a linear transformation. A transformation is affine if it is valid and its last row is [0, 0, 0, 1]. If in addition its last column is ( 0, 0, 0, 1)^T then it is linear. An affine transformation can be broken into a linear transformation and a translation.
public bool IsLinear { get; }

IsRotation

#Since v6.12
Returns true if this is a proper rotation.
public bool IsRotation { get; }

IsValid

#Since v5.0
Gets a value indicating whether or not this Transform is a valid matrix. A valid transform matrix is not allowed to have any invalid numbers.
public bool IsValid { get; }

IsZero

#Since v6.1
True if matrix is Zero4x4, ZeroTransformation, or some other type of zero. The value xform[3][3] can be anything.
public bool IsZero { get; }

IsZero4x4

#Since v6.1
True if all values are 0
public bool IsZero4x4 { get; }

IsZeroTransformation

#Since v6.1
True if all values are 0, except for M33 which is 1.
public bool IsZeroTransformation { get; }

M00

#Since v5.0
Gets or sets this[0,0].
public double M00 { get; set; }

M01

#Since v5.0
Gets or sets this[0,1].
public double M01 { get; set; }

M02

#Since v5.0
Gets or sets this[0,2].
public double M02 { get; set; }

M03

#Since v5.0
Gets or sets this[0,3].
public double M03 { get; set; }

M10

#Since v5.0
Gets or sets this[1,0].
public double M10 { get; set; }

M11

#Since v5.0
Gets or sets this[1,1].
public double M11 { get; set; }

M12

#Since v5.0
Gets or sets this[1,2].
public double M12 { get; set; }

M13

#Since v5.0
Gets or sets this[1,3].
public double M13 { get; set; }

M20

#Since v5.0
Gets or sets this[2,0].
public double M20 { get; set; }

M21

#Since v5.0
Gets or sets this[2,1].
public double M21 { get; set; }

M22

#Since v5.0
Gets or sets this[2,2].
public double M22 { get; set; }

M23

#Since v5.0
Gets or sets this[2,3].
public double M23 { get; set; }

M30

#Since v5.0
Gets or sets this[3,0].
public double M30 { get; set; }

M31

#Since v5.0
Gets or sets this[3,1].
public double M31 { get; set; }

M32

#Since v5.0
Gets or sets this[3,2].
public double M32 { get; set; }

M33

#Since v5.0
Gets or sets this[3,3].
public double M33 { get; set; }

RigidType

#Since v6.12
Gets a value indicating whether or not the Transform is rigid. A rigid transformation can be broken into a proper rotation and a translation, while an isometry transformation could also include a reflection.
public TransformRigidType RigidType { get; }

SimilarityType

#Since v5.0
Gets a value indicating whether or not the Transform maintains similarity. The easiest way to think of Similarity is that any circle, when transformed, remains a circle. Whereas a non-similarity Transform deforms circles into ellipses.
public TransformSimilarityType SimilarityType { get; }

Unset

#Since v5.0
Gets an XForm filled with RhinoMath.UnsetValue.
public static Transform Unset { get; }

ZeroTransformation

#Since v6.1
ZeroTransformation diagonal = (0,0,0,1)
public static Transform ZeroTransformation { get; }

Indexers

this[]

#
Gets or sets the matrix value at the given row and column indices.
public double this[
row,
Index of row to access, must be 0, 1, 2 or 3.
column
Index of column to access, must be 0, 1, 2 or 3.
] { get; set; }
The new value at [row, column]
The value at [row, column]

Methods

Affineize

#Since v6.12
Replaces the last row with (0 0 0 1), discarding any perspective part of this transform
public void Affineize()

ChangeBasis

#Since v5.0
Gets a change of basis transformation. The change of basis transformation is not the same as the rotation transformation that rotates one orthonormal frame to another. If you have geometry defined with respect to planes, this method takes two planes and computes the transformation to change coordinates from one plane to another.
public static Transform ChangeBasis(
plane0,
Coordinate system in which the geometry is currently described.
plane1
Target coordinate system in which we want the geometry to be described.
)
Remarks: Change of basis transformations and rotation transformations are often confused. This is a change of basis transformation. If Q = P0 + a0*X0 + b0*Y0 + c0*Z0 = P1 + a1*X1 + b1*Y1 + c1*Z1, then this transform will map the coordinates (a0,b0,c0) to (a1,b1,c1).
A change of basis transformation if success, Unset on failure.

ChangeBasis

#Since v8.17
Gets a change of basis transformation. The change of basis transformation is not the same as the rotation transformation that rotates one orthonormal frame to another.
public static Transform ChangeBasis(
P0,
Initial center.
X0,
Initial basis X (can be any 3d basis).
Y0,
Initial basis Y (can be any 3d basis).
Z0,
Initial basis Z (can be any 3d basis).
P1,
Final center.
X1,
Final basis X (can be any 3d basis).
Y1,
Final basis Y (can be any 3d basis).
Z1
Final basis Z (can be any 3d basis).
)
Remarks: Change of basis transformations and rotation transformations are often confused. This is a change of basis transformation. If Q = P0 + a0*X0 + b0*Y0 + c0*Z0 = P1 + a1*X1 + b1*Y1 + c1*Z1, then this transform will map the point (a0,b0,c0) to (a1,b1,c1).
A change of basis transformation if success, Unset on failure.

ChangeBasis

#Since v5.0
Gets a change of basis transformation. The change of basis transformation is not the same as the rotation transformation that rotates one orthonormal frame to another.
public static Transform ChangeBasis(
X0,
Initial basis X (can be any 3d basis).
Y0,
Initial basis Y (can be any 3d basis).
Z0,
Initial basis Z (can be any 3d basis).
X1,
Final basis X (can be any 3d basis).
Y1,
Final basis Y (can be any 3d basis).
Z1
Final basis Z (can be any 3d basis).
)
Remarks: Change of basis transformations and rotation transformations are often confused. This is a change of basis transformation. If Q = a0*X0 + b0*Y0 + c0*Z0 = a1*X1 + b1*Y1 + c1*Z1, then this transform will map the point (a0,b0,c0) to (a1,b1,c1).
A change of basis transformation if success, Unset on failure.

Clone

#Since v6.0
Returns a deep copy of the transform. For languages that treat structures as value types, this can be accomplished by a simple assignment.
[ConstOperation] public Transform Clone()
A deep copy of this data structure.

CompareTo

#Since v5.0
Compares this transform with another transform.

M33 has highest value, then M32, etc..

[ConstOperation] public int CompareTo(
other
Another transform.
)
-1 if this < other; 0 if both are equal; 1 otherwise.

DecomposeAffine

#Since v6.12
Decomposes an affine transformation. A transformation is affine if it is valid and its last row is [0, 0, 0, 1]. An affine transformation can be broken into a linear transformation and a translation. Note, a perspective transformation is not affine.
[ConstOperation] public bool DecomposeAffine(
linear,
Linear transformation.
translation
Translation vector.
)
Remarks: If X.DecomposeAffine(L, T) is true then X == L* Translation(T). DecomposeAffine(L, T) may fail for affine transformations if L is not invertible, and is more computationally expensive then X.DecomposeAffine(T, L).
True if successful decomposition.

DecomposeAffine

#Since v6.12
Decomposes an affine transformation. A transformation is affine if it is valid and its last row is [0, 0, 0, 1]. An affine transformation can be broken into a linear transformation and a translation. Note, a perspective transformation is not affine.
[ConstOperation] public bool DecomposeAffine(
translation,
Translation vector.
linear
Linear transformation.
)
Remarks: If X.DecomposeAffine(T, L) is true then X == Translation(T)*L. DecomposeAffine(T,L) succeeds for all affine transformations and is a simple copying of values.
True if successful decomposition.

DecomposeAffine

#Since v6.12
An affine transformation can be decomposed into a Symmetric, Rotation and Translation. Then the Symmetric component may be further decomposed as non-uniform scale in an orthonormal coordinate system.
[ConstOperation] public bool DecomposeAffine(
translation,
Translation vector.
rotation,
Proper rotation transformation.
orthogonal,
Orthogonal basis.
diagonal
Diagonal elements of a Diagonal transformation.
)
True if successful decomposition.

DecomposeRigid

#Since v6.12
Decomposes a rigid transformation. The transformation must be affine.
[ConstOperation] public TransformRigidType DecomposeRigid(
translation,
Translation vector.
rotation,
Proper rotation transformation, where R*Transpose(R)=I and det(R)=1.
tolerance
The evaluation tolerance.
)
Remarks: If X.DecomposeRigid(T, R) is 1, then X ~ Translation(T)*R. If X.DecomposeRigid(T, R) is -1, then X ~ Transform(-1) * Translation(T)*R. DecomposeRigid will find the closest rotation to the linear part of this transformation.
The rigid type.

DecomposeSimilarity

#Since v6.12
Decomposes a similarity transformation. The transformation must be affine. A similarity transformation can be broken into a sequence of a dilation, translation, rotation, and a reflection.
[ConstOperation] public TransformSimilarityType DecomposeSimilarity(
translation,
Translation vector.
out double
dilation,
Dilation, where dilation lt; 0 if this is an orientation reversing similarity.
rotation,
A proper rotation transformation, where R*Transpose(R)=I and Determinant(R)=1.
tolerance
The evaluation tolerance.
)
Remarks: If X.DecomposeSimilarity(T, d, R, tol) !=0 then X ~ Translation(T)*Diagonal(d)*R note when d gt;0 the transformation is orientation preserving. If dilation lt; 0 then Diagonal(dilation) is actually a reflection combined with a true dilation, or Diagonal(dilation) = Diagonal(-1) * Diagonal(|diagonal|).
The similarity type.

DecomposeSymmetric

#Since v6.12
A Symmetric linear transformation can be decomposed A = Q * Diag * Q ^ T, where Diag is a diagonal transformation. Diag[i][i] is an eigenvalue of A and the i-th column of Q is a corresponding unit length eigenvector. Note, this transformation must be Linear and Symmetric.
[ConstOperation] public bool DecomposeSymmetric(
matrix,
An orthonormal matrix of eigenvectors (Q).
diagonal
A vector of eigenvalues.
)
Remarks: If success, this== Q*Diagonal(diagonal) * QT, where QT == Q.Transpose(). If L.IsLinear and LT==L.Transpose then LT*L is symmetric and is a common source of symmetric transformations.
true if successful, false otherwise.

DecomposeTextureMapping

#Since v8.0
Decomposition of a uvw transform into components
[ConstOperation] public void DecomposeTextureMapping(
offset,
Offset
repeat,
Repear
rotation
Rotation
)

Diagonal

#Since v6.12
Constructs a new transformation with diagonal (d0,d1,d2,1.0).
public static Transform Diagonal(
d0,
Transform.M00 value.
d1,
Transform.M11 value.
d2
Transform.M22 value.
)
A transformation with diagonal (d0,d1,d2,1.0).

Diagonal

#Since v6.12
Constructs a new transformation with diagonal (d0,d1,d2,1.0).
public static Transform Diagonal(
diagonal
The diagonal values.
)
A transformation with diagonal (d0,d1,d2,1.0).

Equals

#
Determines if another object is a transform and its value equals this transform value.
[ConstOperation] public override bool Equals(
obj
Another object.
)
true if obj is a transform and has the same value as this transform; otherwise, false.
ValueType.Equals

Equals

#Since v5.0
Determines if another transform equals this transform value.
[ConstOperation] public bool Equals(
other
Another transform.
)
true if other has the same value as this transform; otherwise, false.

GetEulerZYZ

#Since v6.11
Find the Euler angles for a rotation transformation.
[ConstOperation] public bool GetEulerZYZ(
out double
alpha,
Angle of rotation, in radians, about the Z axis.
out double
beta,
Angle of rotation, in radians, about the Y axis.
out double
gamma
Angle of rotation, in radians, about the Z axis.
)
Remarks: Note, alpha and gamma are in the range (-pi, pi] while beta in the range [0, pi]
If true, then this = RotationZYZ(alpha, beta, gamma) = R_z(alpha) * R_y(beta) * R_z(gamma) where R_*(angle) is rotation of angle radians about the corresponding *-world coordinate axis. If false, then this is not a rotation.

GetHashCode

#
Gets a non-unique hashing code for this transform.
[ConstOperation] public override int GetHashCode()
A number that can be used to hash this transform in a dictionary.

GetQuaternion

#Since v7.12
If this transform is a proper rotation, then find the equivalent quaternion.
public bool GetQuaternion(
quaternion
Quaternion that represents this rotation transformation.
)
true if this transform is a proper rotation, false otherwise.

GetYawPitchRoll

#Since v6.11
Find the Tait-Byran angles (also loosely called Euler angles) for a rotation transformation.
[ConstOperation] public bool GetYawPitchRoll(
out double
yaw,
Angle of rotation, in radians, about the Z axis.
out double
pitch,
Angle of rotation, in radians, about the Y axis.
out double
roll
Angle of rotation, in radians, about the X axis.
)
If true, then this = RotationZYX(yaw, pitch, roll) = R_z(yaw) * R_y(pitch) * R_x(roll) where R_*(angle) is rotation of angle radians about the corresponding world coordinate axis. If false, then this is not a rotation.

IsRigid

#Since v6.12
Gets a value indicating whether or not the Transform is rigid. A rigid transformation can be broken into a proper rotation and a translation, while an isometry transformation could also include a reflection.
[ConstOperation] public TransformRigidType IsRigid(
tolerance
The evaluation tolerance.
)
The rigid type.

IsSimilarity

#Since v6.12
Gets a value indicating whether or not the Transform maintains similarity. A similarity transformation can be broken into a sequence of a dilation, translation, rotation, and a reflection.
[ConstOperation] public TransformSimilarityType IsSimilarity(
tolerance
The evaluation tolerance.
)
The similarity type.

IsUniformlyScaled

#Since v9.0
Determines if this transform is uniformly scaled - that is, a similarity transformation that scales all directions equally and preserves angles, mapping circles to circles. This includes pure rotations, translations and mirroring.
[ConstOperation] public bool IsUniformlyScaled()
True if uniformly scaled, false otherwise.

IsZeroTransformationWithTolerance

#Since v7.1
True if all values are 0 within tolerance, except for M33 which is exactly 1.
[ConstOperation] public bool IsZeroTransformationWithTolerance(
zeroTolerance
The tolerance for 0 elements.
)
True if the transformation matrix is ON_Xform::ZeroTransformation, with xform[3][3] equal to 1: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 An element x of the matrix is "zero" if fabs(x) ≤ zeroTolerance. IsZeroTransformation is the same as IsZeroTransformationWithTolerance(0.0)

IsZeroTransformaton

#Since v6.12 Obsolete v7.1
True if all values are 0 within tolerance, except for M33 which is exactly 1.
[EditorBrowsable(EditorBrowsableState.Never)] [ConstOperation] public bool IsZeroTransformaton(
zeroTolerance
The zero tolerance.
)
obsoleteThis method remains with a typo in its name for backwards compatibility. Use IsZeroTransformationWithTolerance instead.
Returns true if all values are 0 within tolerance, except for M33 which is exactly 1.

Linearize

#Since v6.12
Affinitize() and replaces the last column with (0 0 0 1)^T, discarding any translation part of this transform.
public void Linearize()

Mirror

#Since v5.0
Constructs a new Mirror transformation.
public static Transform Mirror(
mirrorPlane
Plane that defines the mirror orientation and position.
)
A transformation matrix which mirrors geometry in a specified plane.

Mirror

#Since v5.0
Create mirror transformation matrix The mirror transform maps a point Q to Q - (2*(Q-P)oN)*N, where P = pointOnMirrorPlane and N = normalToMirrorPlane.
public static Transform Mirror(
pointOnMirrorPlane,
Point on the mirror plane.
normalToMirrorPlane
Normal vector to the mirror plane.
)
A transformation matrix which mirrors geometry in a specified plane.

Multiply

#Since v5.0
Multiplies (combines) two transformations.

This is the same as the * operator between two transformations.

public static Transform Multiply(
a,
First transformation.
b
Second transformation.
)
A transformation matrix that combines the effect of both input transformations. The resulting Transform gives the same result as though you'd first apply B then A.

Orthogonalize

#Since v6.12
Force the linear part of this transformation to be a rotation (or a rotation with reflection). Use DecomposeRigid(T,R) to find the nearest rotation.
public bool Orthogonalize(
tolerance
The evaluation tolerance
)
true if successful, false otherwise.

PlanarProjection

#Since v5.0
Constructs a projection transformation.
public static Transform PlanarProjection(
plane
Plane onto which everything will be perpendicularly projected.
)
A transformation matrix which projects geometry onto a specified plane.

PlaneToPlane

#Since v5.0
Create a rotation transformation that orients plane0 to plane1. If you want to orient objects from one plane to another, use this form of transformation.
public static Transform PlaneToPlane(
plane0,
The plane to orient from.
plane1
the plane to orient to.
)
The translation transformation if successful, Transform.Unset on failure.

ProjectAlong

#Since v6.0
Construct a projection onto a plane along a specific direction.
public static Transform ProjectAlong(
plane,
Plane to project onto.
direction
Projection direction, must not be parallel to the plane.
)
Projection transformation or identity transformation if projection could not be calculated.

Rotation

#Since v5.0
Constructs a new rotation transformation with specified angle and rotation center. The axis of rotation is Vector3d.ZAxis.
public static Transform Rotation(
angleRadians,
Rotation angle in radians.
rotationCenter
3D center of rotation.
)
A rotation transformation matrix.

Rotation

#Since v5.0
Constructs a new rotation transformation with specified angle, rotation center and rotation axis.
public static Transform Rotation(
angleRadians,
Rotation angle in radians.
rotationAxis,
3D unit axis of rotation.
rotationCenter
3D center of rotation.
)
A rotation transformation matrix.

Rotation

#Since v5.0
Constructs a new rotation transformation with specified angle, rotation center and rotation axis.
public static Transform Rotation(
sinAngle,
Sine of the rotation angle.
cosAngle,
Cosine of the rotation angle.
rotationAxis,
3D unit axis of rotation.
rotationCenter
3D center of rotation.
)
A rotation transformation matrix.

Rotation

#Since v5.0
Constructs a new rotation transformation with start and end directions and rotation center.
public static Transform Rotation(
startDirection,
A start direction.
endDirection,
An end direction.
rotationCenter
3D center of rotation.
)
A rotation transformation matrix.

Rotation

#Since v5.0
Constructs a transformation that maps X0 to X1, Y0 to Y1, Z0 to Z1. The frames should be right hand orthonormal frames (unit vectors with Z = X x Y). The resulting rotation fixes the origin (0,0,0), maps initial X to final X, initial Y to final Y, and initial Z to final Z.
public static Transform Rotation(
x0,
Initial frame X.
y0,
Initial frame Y.
z0,
Initial frame Z.
x1,
Final frame X.
y1,
Final frame Y.
z1
Final frame Z.
)
A rotation transformation matrix.

RotationZYX

#Since v6.11
Create rotation transformation From Tait-Byran angles (also loosely known as Euler angles).
public static Transform RotationZYX(
yaw,
Angle, in radians, to rotate about the Z axis.
pitch,
Angle, in radians, to rotate about the Y axis.
roll
Angle, in radians, to rotate about the X axis.
)
Remarks: RotationZYX(yaw, pitch, roll) = R_z(yaw) * R_y(pitch) * R_x(roll) where R_*(angle) is rotation of angle radians about the corresponding world coordinate axis.
A transform matrix from Tait-Byran angles.

RotationZYZ

#Since v6.11
Create rotation transformation From Euler angles.
public static Transform RotationZYZ(
alpha,
Angle, in radians, to rotate about the Z axis.
beta,
Angle, in radians, to rotate about the Y axis.
gamma
Angle, in radians, to rotate about the X axis.
)
Remarks: RotationZYZ(alpha, beta, gamma) = R_z(alpha) * R_y(beta) * R_z(gamma) where R_*(angle) is rotation of angle radians about the corresponding *-world coordinate axis. Note, alpha and gamma are in the range (-pi, pi] while beta in the range [0, pi]
A transform matrix from Euler angles.

Scale

#Since v5.0
Constructs a new non-uniform scaling transformation with a specified scaling anchor point.
public static Transform Scale(
plane,
Defines the center and orientation of the scaling operation.
xScaleFactor,
Scaling factor along the anchor plane X-Axis direction.
yScaleFactor,
Scaling factor along the anchor plane Y-Axis direction.
zScaleFactor
Scaling factor along the anchor plane Z-Axis direction.
)
A transformation matrix which scales geometry non-uniformly.

Scale

#Since v5.0
Constructs a new uniform scaling transformation with a specified scaling anchor point.
public static Transform Scale(
anchor,
Defines the anchor point of the scaling operation.
scaleFactor
Scaling factor in all directions.
)
A transform matrix which scales geometry uniformly around the anchor point.

Shear

#Since v5.0
Constructs a Shear transformation.
public static Transform Shear(
plane,
Base plane for shear.
x,
Shearing vector along plane x-axis.
y,
Shearing vector along plane y-axis.
z
Shearing vector along plane z-axis.
)
A transformation matrix which shear geometry.
Explicit

ICloneable.Clone

#Since v6.0

TextureMapping

#Since v8.0
Construct a UVW Transform from components.
public static Transform TextureMapping(
offset,
repeat,
rotation
)

ToDoubleArray

#Since v8.0
Return the matrix as a linear array of 16 double values.
[ConstOperation] public double[] ToDoubleArray(
rowDominant
If true, returns { M00, M01, M02...}. If false, returns { M00, M10, M20...}.
)
An array of 16 doubles.

ToFloatArray

#Since v5.9
Return the matrix as a linear array of 16 float values.
[ConstOperation] public float[] ToFloatArray(
rowDominant
If true, returns { M00, M01, M02...}. If false, returns { M00, M10, M20...}.
)
An array of 16 floats.

ToString

#
Returns a string representation of this transform.
[ConstOperation] public override string ToString()
A textual representation.

TransformBoundingBox

#Since v5.0
Computes a new bounding box that is the smallest axis aligned bounding box that contains the transformed result of its 8 original corner points.
[ConstOperation] public BoundingBox TransformBoundingBox()
A new bounding box.

TransformList

#Since v5.0
Given a list, an array or any enumerable set of points, computes a new array of transformed points.
[ConstOperation] public Point3d[] TransformList(
points
A list, an array or any enumerable set of points to be left untouched and copied.
)
A new array.

Translation

#ExampleSince v5.0
Constructs a new translation (move) transformation. Right column is (dx, dy, dz, 1.0).
public static Transform Translation(
dx,
Distance to translate (move) geometry along the world X axis.
dy,
Distance to translate (move) geometry along the world Y axis.
dz
Distance to translate (move) geometry along the world Z axis.
)
A transform matrix which moves geometry with the specified distances.

Translation

#ExampleSince v5.0
Constructs a new translation (move) transformation.
public static Transform Translation(
motion
Translation (motion) vector.
)
A transform matrix which moves geometry along the motion vector.

Transpose

#Since v5.9
Flip row/column values
[ConstOperation] public Transform Transpose()

TryGetInverse

#Since v5.0
Attempts to get the inverse transform of this transform.
[ConstOperation] public bool TryGetInverse(
inverseTransform
The inverse transform. This out reference will be assigned during this call.
)
true on success. If false is returned and this Transform is Invalid, inserveTransform will be set to this Transform. If false is returned and this Transform is Valid, inverseTransform will be set to a pseudo inverse.

Operators

OperationResultDescription
Transform==TransformboolDetermines if two transformations are equal in value.
Transform!=TransformboolDetermines if two transformations are different in value.
Transform*Point3dPoint3dMultiplies a transformation by a point and gets a new point.
Transform*TransformTransformMultiplies (combines) two transformations.
Transform*Vector3dVector3dMultiplies a transformation by a vector and gets a new vector.