IC Python API:RLPy RMatrix4

From Reallusion Wiki!
Jump to: navigation, search

Contents

Main article: Modules. Last modified: 04/15/2020

Description

This class represent the transform data of RTransform. This class provides access to RLPy's internal 4x4 matrix operators and related functions.

Constructor & Destructor

__init__ ( self, M00 ,M01, M02, M03, M10, M11, M12, M13, M20, M21, M22, M23, M30, M31, M32, M33 )

The constructor. Initialize a new RMatrix4 with RMatrix4 Item Value.

Parameters

M00 [IN] initialization value - float
M01 [IN] initialization value - float
M02 [IN] initialization value - float
M03 [IN] initialization value - float
M10 [IN] initialization value - float
M11 [IN] initialization value - float
M12 [IN] initialization value - float
M13 [IN] initialization value - float
M20 [IN] initialization value - float
M21 [IN] initialization value - float
M22 [IN] initialization value - float
M23 [IN] initialization value - float
M30 [IN] initialization value - float
M31 [IN] initialization value - float
M32 [IN] initialization value - float
M33 [IN] initialization value - float

Returns

Returns the row vector of the matrix - RMatrix4
1 matrix4 = RLPy.RMatrix4( 1,   2,  3,  4,
2                          5,   6,  7,  8,
3                          9,  10, 11, 12,
4                          13, 14, 15, 16 )

__init__ ( self, Oreder, rx, ty, rz )

The constructor. Initialize a new RMatrix4 with Order and angle.

Parameters

Oreder [IN] Euler order - RLPy.Rotation_Order
rx [IN] Angle of x-axis in radians - float
ry [IN] Angle of y-axis in radians - float
rz [IN] Angle of z-axis in radians - float

Returns

Returns the row vector of the matrix - RMatrix4
1 euler_angle_x = 90 * RLPy.RMath.CONST_DEG_TO_RAD
2 euler_angle_y = 0
3 euler_angle_z = 0
4 matrix4 = RLPy.RMatrix4( RLPy.EEulerOrder_XYZ, euler_angle_x, euler_angle_y, euler_angle_z )

__init__ ( self, rkRotate )

The constructor. Initialize a new RMatrix4 with RMatrix3.

Parameters

rkRotate [IN] Rotation 3x3 matrix - RMatrix3

Returns

Returns the row vector of the matrix - RMatrix4
1 rotate = RLPy.RMatrix3( 1, 0, 0,
2                         0, 2, 0,
3                         0, 0, 3 )
4 matrix4 = RLPy.RMatrix4( rotate )

__init__ ( self, kRotate, kTranslate, kScale )

The constructor. Initialize a new RMatrix4 with RTS.

Parameters

rkRotate [IN] Rotation matrix - RMatrix3
rkTranslate [IN] Translate vector - RVector3
rkScale [IN] Scale vector - RVector3

Returns

Returns the row vector of the matrix - RMatrix4
1 rotate = RLPy.RMatrix3( 1, 0, 0,
2                         0, 2, 0,
3                         0, 0, 3 )
4 translate = RLPy.RVector3( 1,2,3 )
5 scale = RLPy.RVector3( 2,2,2 )
6 matrix4 = RLPy.RMatrix4( rotate, translate, scale )

__init__ ( self, args )

The constructor. Initialize a new 4x4 matrix object with another RMatrix4 object.

Parameters

args [IN] a 4x4 matrix object - RMatrix4

Returns

Returns the row vector of the matrix - RMatrix4
1 matrix4 = RLPy.RMatrix4( 1,   2,  3,  4,
2                          5,   6,  7,  8,
3                          9,  10, 11, 12,
4                          13, 14, 15, 16 )
5 matrix4_copy = RLPy.RMatrix4( matrix4 )
6 print( matrix4_copy == matrix4 ) # true

Operators

+

The "addition" operator.

See Also: +=

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 2, 2, 2, 2,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 matrix4_result = matrix4_a + matrix4_b
10 
11 print( matrix4_result.GetRow(0)[0] == 1+2 ) # true
12 print( matrix4_result.GetRow(0)[1] == 2+2 ) # true
13 print( matrix4_result.GetRow(0)[2] == 3+2 ) # true
14 print( matrix4_result.GetRow(0)[3] == 4+2 ) # true

-

The "subtraction" operator.

See Also: -=

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 2, 2, 2, 2,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 matrix4_result = matrix4_a - matrix4_b
10 
11 print( matrix4_result.GetRow(0)[0] == 1-2 ) # true
12 print( matrix4_result.GetRow(0)[1] == 2-2 ) # true
13 print( matrix4_result.GetRow(0)[2] == 3-2 ) # true
14 print( matrix4_result.GetRow(0)[3] == 4-2 ) # true

*

The "multiplication" operator.

See Also: *=

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 2, 0, 0, 0,
 6                            2, 0, 0, 0,
 7                            2, 0, 0, 0,
 8                            2, 0, 0, 0 )
 9 matrix4_result = matrix4_a * matrix4_b
10 
11 print( matrix4_result.GetRow(0)[0] == 1*2 + 2*2 + 3*2 + 4*2  ) # true

/

The "division" operator.

See Also: /=

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_result = matrix4_a / 2
 6 
 7 print( matrix4_result.GetRow(0)[0] == 1/2 ) # true
 8 print( matrix4_result.GetRow(0)[1] == 2/2 ) # true
 9 print( matrix4_result.GetRow(0)[2] == 3/2 ) # true
10 print( matrix4_result.GetRow(0)[3] == 4/2 ) # true

-

The "unary minus" .

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_result = -matrix4_a
 6 
 7 print( matrix4_result.GetRow(0)[0] == -1 ) # true
 8 print( matrix4_result.GetRow(0)[1] == -2 ) # true
 9 print( matrix4_result.GetRow(0)[2] == -3 ) # true
10 print( matrix4_result.GetRow(0)[3] == -4 ) # true

==

The "equal to" operator. Performs a one-by-one comparison of the matrix array.

See Also: !=

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 1, 2, 3, 4,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 
10 print( matrix4_a == matrix4_b ) # true

!=

The "not equal to" operator. Performs a one-by-one comparison of the matrix array.

See Also: ==

 1 matrix4_a = RLPy.RMatrix4( 1, 2, 3, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 2, 2, 2, 2,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 
10 print( matrix4_a != matrix4_b ) # true

>

The "greater than" operator. Performs a one-by-one comparison of the matrix array.

See Also: >=

 1 matrix4_a = RLPy.RMatrix4( 1, 0, 0, 0,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 2, 0, 0, 0,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 
10 print( matrix4_b > matrix4_a ) # true

>=

The "greater than or equal to" operator. Performs a one-by-one comparison of the matrix array.

See Also: >

 1 matrix4_a = RLPy.RMatrix4( 1, 1, 1, 4,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 1, 1, 1, 8,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 
10 print( matrix4_b >= matrix4_a ) # true

<

The "less than" operator. Performs a one-by-one comparison of the matrix array.

See Also: <=

 1 matrix4_a = RLPy.RMatrix4( 2, 0, 0, 0,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 3, 0, 0, 0,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 
10 print( matrix4_a < matrix4_b ) # true

<=

The "less than" operator. Performs a one-by-one comparison of the matrix array.

See Also: <

 1 matrix4_a = RLPy.RMatrix4( 2, 2, 1, 0,
 2                            0, 0, 0, 0,
 3                            0, 0, 0, 0,
 4                            0, 0, 0, 0 )
 5 matrix4_b = RLPy.RMatrix4( 2, 2, 5, 0,
 6                            0, 0, 0, 0,
 7                            0, 0, 0, 0,
 8                            0, 0, 0, 0 )
 9 
10 print( matrix4_a <= matrix4_b ) # true

+=

The "addition assignment" operator.

See Also: +

 1 matrix4 =  RLPy.RMatrix4( 1, 2, 3, 4,
 2                           0, 0, 0, 0,
 3                           0, 0, 0, 0, 
 4                           0, 0, 0, 0 )
 5 matrix4 += RLPy.RMatrix4( 2, 2, 2, 2,
 6                           0, 0, 0, 0,
 7                           0, 0, 0, 0,
 8                           0, 0, 0, 0 )
 9 
10 print( matrix4.GetRow(0)[0] == 1+2 ) # true
11 print( matrix4.GetRow(0)[1] == 2+2 ) # true
12 print( matrix4.GetRow(0)[2] == 3+2 ) # true
13 print( matrix4.GetRow(0)[3] == 4+2 ) # true

-=

The "subtraction assignment" operator.

See Also: -

 1 matrix4 =  RLPy.RMatrix4( 1, 2, 3, 4,
 2                           0, 0, 0, 0,
 3                           0, 0, 0, 0,
 4                           0, 0, 0, 0 )
 5 matrix4 -= RLPy.RMatrix4( 2, 2, 2, 2,
 6                           0, 0, 0, 0,
 7                           0, 0, 0, 0,
 8                           0, 0, 0, 0 )
 9 
10 print( matrix4.GetRow(0)[0] == 1-2 ) # true
11 print( matrix4.GetRow(0)[1] == 2-2 ) # true
12 print( matrix4.GetRow(0)[2] == 3-2 ) # true
13 print( matrix4.GetRow(0)[3] == 4-2 ) # true

*=

The "multiplication assignment" operator. For the calculation method, refer to the * operator.

See Also: *

 1 matrix4 = RLPy.RMatrix4( 1, 2, 3, 4,
 2                          0, 0, 0, 0,
 3                          0, 0, 0, 0,
 4                          0, 0, 0, 0 )
 5 matrix4 *= 2
 6 
 7 print( matrix4.GetRow(0)[0] == 1*2 ) # true
 8 print( matrix4.GetRow(0)[1] == 2*2 ) # true
 9 print( matrix4.GetRow(0)[2] == 3*2 ) # true
10 print( matrix4.GetRow(0)[3] == 4*2 ) # true

/=

The "division assignment" operator. For the calculation method, refer to the / operator.

See Also: /

 1 matrix4 = RLPy.RMatrix4( 1, 2, 3, 4,
 2                          0, 0, 0, 0,
 3                          0, 0, 0, 0,
 4                          0, 0, 0, 0 )
 5 matrix4 /= 2
 6 
 7 print( matrix4.GetRow(0)[0] == 1/2 ) # true
 8 print( matrix4.GetRow(0)[1] == 2/2 ) # true
 9 print( matrix4.GetRow(0)[2] == 3/2 ) # true
10 print( matrix4.GetRow(0)[3] == 4/2 ) # true

Member Functions

MakeIdentity (self)

This function can be used to initialize the 3x3 matrix. It is equivalent to setting the matrix to:

[1  0  0  0]
[0  1  0  0]
[0  0  1  0]
[0  0  0  1]

Returns

This object - RMatrix4
1 matrix4 = RLPy.RMatrix4()
2 matrix4.MakeIdentity()

M (self, args)

Get the value of an element in a 4x4 matrix by row and column index.

Parameters

nRow [IN] Index of the row in the matrix - int
nCol [IN] Index of the column in the matrix - int

Returns

The matrix element specified by row and col - float
1 matrix4 = RLPy.RMatrix4()
2 matrix4.MakeIdentity()
3 
4 print(matrix4.M(0,0)) #

E (self, args)

Get the value of an element in a 3x3 matrix by index number (from 0 to 15);

Parameters

nRow [IN] Index of the matrix.

Returns

The matrix element specified by index - float
1 matrix4 = RLPy.RMatrix4()
2 matrix4.MakeIdentity()
3 
4 print(matrix4.E(0)) #

GetRow (self, nR)

Retreive a row inside a 4x4 matrix.

Parameters

nRow [IN] Index of the row in the matrix.

Returns

The row vector of the matrix - RVector4
1 matrix4 = RLPy.RMatrix4()
2 matrix4.MakeIdentity()
3 row0 = matrix4.GetRow(0)
4 
5 print(row0[0])
6 print(row0[1])
7 print(row0[2])
8 print(row0[3])

GetColumn (self, nC)

Retrieve a column inside a 4x4 matrix.

Parameters

nRow [IN] Index of the column in the matrix.

Returns

The column vector of the matrix - RVector4
1 matrix4 = RLPy.RMatrix4()
2 matrix4.MakeIdentity()
3 col0 = matrix4.GetColumn(0)
4 
5 print(col0[0])
6 print(col0[1])
7 print(col0[2])
8 print(col0[3])

Transpose (self)

Obtain the transposed matrix by transposing the current m * n matrix into an n * m matrix by row-column swapping.

Returns

A new matrix containing this matrix's transpose - RMatrix4
 1 matrix4_orgin = RLPy.RMatrix4(  1,  2,  3,  4,
 2                                 5,  6,  7,  8,
 3                                 9, 10, 11, 12,
 4                                13, 14, 15, 16 )
 5 matrix4_transpose = matrix4_orgin.Transpose()
 6 row0 = matrix4_orgin.GetRow(0)
 7 col0 = matrix4_transpose.GetColumn(0)
 8 
 9 print(row0[0] == col0[0])
10 print(row0[1] == col0[1])
11 print(row0[2] == col0[2])
12 print(row0[3] == col0[3])

TransposeTimes (self, mM)

Multiply a transposed version of a 4x4 matrix with itself.

Parameters

mM [IN] the matrix - RMatrix4

Returns

A new matrix. (this^T * mM) - RMatrix4
 1 matrix4_orgin = RLPy.RMatrix4(  1,  2,  3,  4,
 2                                 5,  6,  7,  8,
 3                                 9, 10, 11, 12,
 4                                13, 14, 15, 16 )
 5 matrix4_transpose_value = RLPy.RMatrix4( 2, 0, 0, 0,
 6                                          0, 2, 0, 0,
 7                                          0, 0, 2, 0,
 8                                          0, 0, 0, 2 )
 9 matrix4_transpose_times = matrix4_orgin.TransposeTimes(matrix4_transpose_value)
10 row0 = matrix4_orgin.GetRow(0)
11 col0 = matrix4_transpose_times.GetColumn(0)
12 
13 print(row0[0]*2 == col0[0])
14 print(row0[1]*2 == col0[1])
15 print(row0[2]*2 == col0[2])
16 print(row0[3]*2 == col0[3])

TimesTranspose (self, mM)

Multiply this 4x4 matrix with a transposed version of itself.

Parameters

mM [IN] the matrix - RMatrix4

Returns

A new matrix. (this * M^T) - RMatrix4
 1 matrix4_orgin = RLPy.RMatrix4(  1,  2,  3,  4,
 2                                 5,  6,  7,  8,
 3                                 9, 10, 11, 12,
 4                                13, 14, 15, 16 )
 5 matrix4_transpose_value = RLPy.RMatrix4( 3, 0, 0, 0,
 6                                          0, 3, 0, 0,
 7                                          0, 0, 3, 0,
 8                                          0, 0, 0, 3 )
 9 matrix4_times_transpose = matrix4_orgin.TimesTranspose(matrix4_transpose_value)
10 row0 = matrix4_orgin.GetColumn(0)
11 col0 = matrix4_times_transpose.GetColumn(0)
12 
13 print(row0[0]*3 == col0[0])
14 print(row0[1]*3 == col0[1])
15 print(row0[2]*3 == col0[2])
16 print(row0[3]*3 == col0[3])

Inverse (self)

Obtain the inverse (reciprocal) of this 4x4 matrix (A^-1).

Returns

A new matrix containing this matrix's inverse - RMatrix4
 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 )
 5 matrix4_inverse = matrix4_value.Inverse()
 6 row0_inverse = matrix4_inverse.GetRow(0)
 7 
 8 print(row0_inverse[0])
 9 print(row0_inverse[1])
10 print(row0_inverse[2])
11 print(row0_inverse[3])

Adjoint (self)

Adjugate this 4x4 matrix.

Returns

A new matrix containing this matrix's adjoint - RMatrix4
 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 )
 5 matrix4_Adjoint = matrix4_value.Adjoint()
 6 row0_Adjoint = matrix4_Adjoint.GetRow(0)
 7 
 8 print(row0_Adjoint[0])
 9 print(row0_Adjoint[1])
10 print(row0_Adjoint[2])
11 print(row0_Adjoint[3])

AdjointTranspose (self)

Adjugate and transpose this 4x4 matrix.

Returns

A new matrix - RMatrix4
 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 )
 5 matrix4_Adjoint_transpose = matrix4_value.AdjointTranspose()
 6 col0_Adjoint_transpose = matrix4_Adjoint_transpose.GetColumn(0)
 7 
 8 print(col0_Adjoint_transpose[0] == row0_Adjoint[0])
 9 print(col0_Adjoint_transpose[1] == row0_Adjoint[1])
10 print(col0_Adjoint_transpose[2] == row0_Adjoint[2])
11 print(col0_Adjoint_transpose[3] == row0_Adjoint[3])

InverseTranspose (self)

Invert and transpose this 4x4 matrix.

Returns

A new matrix - RMatrix4
 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 )
 5 matrix4_inverse_transpose = matrix4_value.InverseTranspose()
 6 col0_inverse_transpose = matrix4_inverse_transpose.GetColumn(0)
 7 
 8 print(col0_inverse_transpose[0] == row0_inverse[0])
 9 print(col0_inverse_transpose[1] == row0_inverse[1])
10 print(col0_inverse_transpose[2] == row0_inverse[2])
11 print(col0_inverse_transpose[3] == row0_inverse[3])

Determinant (self)

Obtain the scalar value for this 4x4 matrix (|A|).

Rlpy rmatrix4 determinant.jpg

Returns

The determinant of the matrix - float
1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
2                                1, 1,-1,-2,
3                                1,-1,-1, 2,
4                                1,-2, 1,-1 )
5 print(matrix4_value.Determinant())

MaxColumn (self)

Find the maximum absolute value within this 4x4 matrix, and return the column in which the value is located. If all of the elements within the 4x4 matrix are 0 then return -1.

Returns

Return index of column of M containing maximum abs entry, or -1 if M = 0 - int
1 matrix4_column_value = RLPy.RMatrix4( 1, 2, 3,-5,
2                                       0, 0, 0, 0,
3                                       0, 0, 0, 0,
4                                       0, 0, 0, 0 )
5 print(matrix4_column_value.MaxColumn()) # column:3 -> abs(-5)

MaxRow (self)

Find the maximum absolute value within this 4x4 matrix, and return the row in which the value is located. If all of the elements within the 4x4 matrix are 0 then return -1.

Returns

Return index of row of M containing maximum abs entry, or -1 if M = 0 - int
1 matrix4_row_value = RLPy.RMatrix4( 1, 0, 0, 0,
2                                    2, 0, 0, 0,
3                                    3, 0, 0, 0,
4                                   -5, 0, 0, 0 )
5 print(matrix4_value.MaxRow()) # Row:3 -> abs(-5)

OneNorm (self)

Return the sum of the column elements that contain the largest absolute values.

Returns

Return Norm - float
1 matrix4_row_value = RLPy.RMatrix4( 1, 0, 0, 0,
2                                    2, 0, 0, 0,
3                                    3, 0, 0, 0,
4                                   -5, 0, 0, 0 )
5 print(matrix4_row_value.OneNorm()) # 11 -> 1+2+abs(-5)

InfNorm (self)

Return the sum of the row elements that contain the largest absolute values.

Returns

Return InfNorm - float
1 matrix4_column_value = RLPy.RMatrix4( 1, 2, 3,-5,
2                                       0, 0, 0, 0,
3                                       0, 0, 0, 0,
4                                       0, 0, 0, 0 )
5 print(matrix4_column_value.InfNorm()) # 11 -> 1+2+abs(-5)

FromRTS (self, kRotate, kTranslate, kScale)

Apply rotate, translate, and scale data to a 4x4 matrix.

Parameters

kRotate [IN] Rotate Matrix - RMatrix3
kTranslate [IN] Translate vector - RVector3
kScale [IN] Scale vector - RVector3

Returns

Return a new matrix from RTS - RMatrix4
 1 rotate = RLPy.RMatrix3( 1, 0, 0,
 2                         0, 1, 0,
 3                         0, 0, 1 )
 4 translate = RLPy.RVector3( 1, 0, 0 )
 5 scale = RLPy.RVector3( 2, 2, 2 )
 6 matrix4_result =  RLPy.RMatrix4().FromRTS( rotate, translate, scale )
 7 row0 = matrix4_result.GetRow(0)
 8 
 9 print(row0[0])
10 print(row0[1])
11 print(row0[2])
12 print(row0[3])

GetSimpleRTS (self, rkRotate, rkTranslate, rkScale)

Retrieve rotation, translation, and scale data from this 4x4 matrix.

Parameters

rkRotate [IN] Angle of x-axis in radians - float
rkTranslate [IN] Angle of y-axis in radians - float
rkScale [IN] Angle of z-axis in radians - float

Returns

 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 )
 5 rotate = RLPy.RMatrix3()
 6 translate = RLPy.RVector3()
 7 scale = RLPy.RVector3()
 8 matrix4_value.GetSimpleRTS( rotate, translate, scale )
 9 row0 = rotate.GetRow(0)
10 
11 print(row0[0])
12 print(row0[1])
13 print(row0[2])
14 
15 print(translate[0])
16 print(translate[1])
17 print(translate[2])
18 
19 print(scale[0])
20 print(scale[1])
21 print(scale[2])

GetSimpleRotate (self, rkRotate)

Retrieve rotation data from this 4x4 matrix.

Parameters

rkRotate [IN] Rotation Matrix - RMatrix3

Returns

3x3 matrix rotation data of this 4x4 matrix.
 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 
 5 rotate = RLPy.RMatrix3()
 6 matrix4_value.GetSimpleRotate( rotate )
 7 row0 = rotate.GetRow(0)
 8 
 9 print(row0[0])
10 print(row0[1])
11 print(row0[2])

SetTranslateZero (self)

Set the translation data in this 4x4 matrix to 0.

 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 
 5 matrix4_value.SetTranslateZero()
 6 row3 = matrix4_value.GetRow(3)
 7 
 8 print(row3[0] == 0)
 9 print(row3[1] == 0)
10 print(row3[2] == 0)

RotationX (self, fAngle)

Rotation matrix for rotations around x-axis.

Parameters

fAngle [IN] angle in radians - float

Returns

Return a new matrix of for rotations around x-axis - RMatrix4
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix4_orgin.RotationX( 90 * RLPy.RMath.CONST_DEG_TO_RAD )

RotationY (self, fAngle)

Rotation matrix for rotations around y-axis.

Parameters

fAngle [IN] angle in radians - float

Returns

Return a new matrix of for rotations around y-axis - RMatrix4
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix4_orgin.RotationY( 90 * RLPy.RMath.CONST_DEG_TO_RAD )

RotationZ (self, fAngle)

Rotation matrix for rotations around z-axis.

Parameters

fAngle [IN] angle in radians - float

Returns

Return a new matrix of for rotations around z-axis - RMatrix4
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix4_orgin.RotationZ( 90 * RLPy.RMath.CONST_DEG_TO_RAD )

RotateAxisAngle (self, rkAxis, fAngle)

Rotation matrix from axis angle.

Parameters

rkAxis [IN] axis vector - RVector3
fAngle [IN] angle in radians - float

Returns

Return a new matrix from specified axis angle - RMatrix4
 1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
 2                                1, 1,-1,-2,
 3                                1,-1,-1, 2,
 4                                1,-2, 1,-1 
 5 x_axis_vector = RLPy.RVector3( 1, 0, 0 )  # axis = "X"
 6 y_axis_vector = RLPy.RVector3( 0, 1, 0 )  # axis = "Y"
 7 z_axis_vector = RLPy.RVector3( 0, 0, 1 )  # axis = "Z"    
 8 matrix4_value.RotateAxisAngle( x_axis_vector, 90 * RLPy.RMath.CONST_DEG_TO_RAD )
 9 matrix4_value.RotateAxisAngle( y_axis_vector, 90 * RLPy.RMath.CONST_DEG_TO_RAD )
10 matrix4_value.RotateAxisAngle( z_axis_vector, 90 * RLPy.RMath.CONST_DEG_TO_RAD )

FromEulerAngle (self, Oreder, rx, ry, rz)

Convert Euler angle to a 4x4 matrix according to a rotation axis order.

Parameters

Oreder [IN] Euler order - RLPY.EEulerOrder
  • EEulerOrder_XYZ = _RLPy.EEulerOrder_XYZ
  • EEulerOrder_ZYX = _RLPy.EEulerOrder_ZYX
  • EEulerOrder_XZY = _RLPy.EEulerOrder_XZY
  • EEulerOrder_YZX = _RLPy.EEulerOrder_YZX
  • EEulerOrder_YXZ = _RLPy.EEulerOrder_YXZ
  • EEulerOrder_ZXY = _RLPy.EEulerOrder_ZXY
rx [IN] Angle of x-axis in radians - float
ry [IN] Angle of y-axis in radians - float
rz [IN] Angle of z-axis in radians - float

Returns

Return a new matrix from specified axis angle - RMatrix4
 1 euler_angle_x = 90 * RLPy.RMath.CONST_DEG_TO_RAD
 2 euler_angle_y = 0
 3 euler_angle_z = 0
 4 matrix4_result = RLPy.RMatrix4().FromEulerAngle( RLPy.EEulerOrder_XYZ, euler_angle_x, euler_angle_y, euler_angle_z)
 5 row0 = matrix4_result[0].GetRow(0)
 6 
 7 print(row0[0])
 8 print(row0[1])
 9 print(row0[2])
10 print(row0[3])

SetSR (self, mSR)

Set scale and rotation part of the matrix.

Parameters

mSR [IN] 3x3 matrix - RMatrix3

Returns

Return a new 4x4 matrix - RMatrix4
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix3_rotate_value = RLPy.RMatrix3( 1, 0, 0,
4                                       0, 1, 0,
5                                       0, 0, 1 )
6 matrix4_orgin.SetSR(matrix3_rotate_value)

GetSR (self)

Get scale and rotation part of the matrix.

Returns

Return a 3x3 matrix - RMatrix3
1 matrix4_value = RLPy.RMatrix4( 1, 2, 1, 1,
2                                1, 1,-1,-2,
3                                1,-1,-1, 2,
4                                1,-2, 1,-1 
5 result = matrix4_value.GetSR()
6 row0 = result.GetRow(0)
7 print(row0[0])
8 print(row0[1])
9 print(row0[2])

SetTranslate (self, vTranslate)

Set translate of the matrix.

Parameters

vTranslate [IN] Translate vector - RVector3

Returns

New matrix with the specified translation - RMatrix4
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix4_orgin.SetTranslate(RLPy.RVector3( 1, 2, 3 ) )

GetTranslate (self)

Get translate of the matrix.

Returns

Return a translate vector - RVector3
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix4_orgin.SetTranslate(RLPy.RVector3( 1, 2, 3 ) )
4 result = matrix4_orgin.GetTranslate()
5 
6 print(result[0] == 1)
7 print(result[1] == 2)
8 print(result[2] == 3)

AccuScale (self, rkScale)

Accumulate this 4x4 matrix with scale vector.

Parameters

rkScale [IN] Scale vector - RVector3

Returns

Accumulate of this 4x4 matrix with scale vector - RMatrix4
 1 matrix4_orgin = RLPy.RMatrix4()
 2 matrix4_orgin.MakeIdentity()
 3 matrix4_orgin.AccuScale(RLPy.RVector3( 2, 2, 2 ) )
 4 matrix4_orgin.AccuScale(RLPy.RVector3( 3, 3, 3 ) )
 5 result = matrix4_orgin.GetSR()
 6 row0 = result.GetRow(0)
 7 print(row0[0] == 2*3)
 8 row1 = result.GetRow(1)
 9 print(row1[1] == 2*3)
10 row2 = result.GetRow(2)
11 print(row2[2] == 2*3)

AccuRotate (self, rkRotate)

Accumulate this 4x4 matrix with rotation matrix.

Parameters

rkRotate [IN] Rotation matrix - RMatrix3

Returns

Accumulate this 4x4 matrix and rotation matrix - RMatrix4
 1 matrix4_orgin = RLPy.RMatrix4()
 2 matrix4_orgin.MakeIdentity()
 3 matrix3_orgin = RLPy.RMatrix3()
 4 matrix3_orgin.FromAxisAngle( RLPy.RVector3( 0, 1, 0 ), 90 * RLPy.RMath.CONST_DEG_TO_RAD )
 5 matrix4_orgin.AccuRotate(matrix3_orgin)
 6 matrix4_orgin.AccuRotate(matrix3_orgin)
 7 rotate = RLPy.RMatrix3()
 8 matrix4_orgin.GetSimpleRotate( rotate )
 9 row0 = rotate.GetRow(0)
10 print(row0[0])
11 print(row0[1])
12 print(row0[2])

AccuTranslate (self, rkTranslate)

Accumulate this 4x4 matrix with translate vector.

Parameters

rkTranslate [IN] Translate vector - RVector3

Returns

Accumulate of this 4x4 matrix and translation vector - RMatrix4
1 matrix4_orgin = RLPy.RMatrix4()
2 matrix4_orgin.MakeIdentity()
3 matrix4_orgin.AccuTranslate(RLPy.RVector3( 1, 2, 3 ) )
4 matrix4_orgin.AccuTranslate(RLPy.RVector3( 2, 2, 2 ) )
5 row3 = matrix4_orgin.GetRow(3)
6 print(row3[0] == 1+2)
7 print(row3[1] == 2+2)
8 print(row3[2] == 2+3)