hom_mat3d_rotateHomMat3dRotateHomMat3dRotatehom_mat3d_rotateT_hom_mat3d_rotate🔗

Short description🔗

hom_mat3d_rotateHomMat3dRotateHomMat3dRotatehom_mat3d_rotateT_hom_mat3d_rotate — Add a rotation to a homogeneous 3D transformation matrix.

Signature🔗

hom_mat3d_rotate( hom_mat3d HomMat3D, angle.rad Phi, string Axis, point3d.x Px, point3d.y Py, point3d.z Pz, out hom_mat3d HomMat3DRotate )

Description🔗

hom_mat3d_rotateHomMat3dRotate adds a rotation by the angle Phiphiphi around the axis passed in the parameter Axisaxisaxis to the homogeneous 3D transformation matrix HomMat3DhomMat3Dhom_mat_3d and returns the resulting matrix in HomMat3DRotatehomMat3DRotatehom_mat_3drotate. The axis can be specified by passing the strings ‘x’, ‘y’, or ‘z’, or by passing a vector [x,y,z] as a tuple.

The rotation is described by a 3×3 rotation matrix R. It is performed relative to the global (i.e., fixed) coordinate system; this corresponds to the following chain of transformation matrices:

Axisaxisaxis = 'x'"x":

\[\begin{eqnarray*} \textrm{HomMat3DRotate} = \mvHomMatrixThreeDRotTrans{\mvRotationMatrixVar{}{x}} {\mvVectorThreeDPlain{0}{0}{0}} \cdot \textrm{HomMat3D} \qquad \mvRotationMatrixVar{}{x} = \mvMatrix{ 1 & 0 & 0 \\ 0 & \cos(\textrm{Phi}) & - \sin(\textrm{Phi}) \\ 0 & \sin(\textrm{Phi}) & \cos(\textrm{Phi})} \end{eqnarray*}\]

Axisaxisaxis = 'y'"y":

\[\begin{eqnarray*} \textrm{HomMat3DRotate} = \mvHomMatrixThreeDRotTrans{\mvRotationMatrixVar{}{y}} {\mvVectorThreeDPlain{0}{0}{0}} \cdot \textrm{HomMat3D} \qquad \mvRotationMatrixVar{}{y} = \mvMatrix{ \cos(\textrm{Phi}) & 0 & \sin(\textrm{Phi}) \\ 0 & 1 & 0 \\ - \sin(\textrm{Phi}) & 0 & \cos(\textrm{Phi})} \end{eqnarray*}\]

Axisaxisaxis = 'z'"z":

\[\begin{eqnarray*} \textrm{HomMat3DRotate} = \mvHomMatrixThreeDRotTrans{\mvRotationMatrixVar{}{z}} {\mvVectorThreeDPlain{0}{0}{0}} \cdot \textrm{HomMat3D} \qquad \mvRotationMatrixVar{}{z} = \mvMatrix{ \cos(\textrm{Phi}) & - \sin(\textrm{Phi}) & 0 \\ \sin(\textrm{Phi}) & \cos(\textrm{Phi}) & 0 \\ 0 & 0 & 1} \end{eqnarray*}\]

Axisaxisaxis = [x, y, z][x, y, z]:

\[\begin{eqnarray*} \textrm{HomMat3DRotate} = \mvHomMatrixThreeDRotTrans{\mvRotationMatrixVar{}{a}} {\mvVectorThreeDPlain{0}{0}{0}} \cdot \textrm{HomMat3D} \qquad \mvRotationMatrixVar{}{a} = \mvVectorVar{u} \cdot \mvTranspose{\mvVectorVar{u}} + cos(\textrm{Phi}) \cdot (\mvIdentMatrixVar - \mvVectorVar{u} \cdot \mvTranspose{\mvVectorVar{u}}) + sin(\textrm{Phi}) \cdot \mvMatrixVar{S} \end{eqnarray*}\]

\[\begin{eqnarray*} \mvVectorVar{u} = \frac{\textrm{Axis}}{\|\textrm{Axis}\|} = \mvVectorThreeD{x'}{y'}{z'} \qquad \mvIdentMatrixVar = \mvMatrix{1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1} \qquad \mvMatrixVar{S} = \mvMatrix{0 & -z' & y' \\ z' & 0 & -x' \\ -y' & x' & 0} \end{eqnarray*}\]

The point (Pxpxpx,Pypypy,Pzpzpz) is the fixed point of the transformation, i.e., this point remains unchanged when transformed using HomMat3DRotatehomMat3DRotatehom_mat_3drotate. To obtain this behavior, first a translation is added to the input transformation matrix that moves the fixed point onto the origin of the global coordinate system. Then, the rotation is added, and finally a translation that moves the fixed point back to its original position. This corresponds to the following chain of transformations:

\[\begin{eqnarray*} \textrm{HomMat3DRotate} = \mvHomMatrixThreeDElements{ 1 & 0 & 0 & + \textrm{Px} \\ 0 & 1 & 0 & + \textrm{Py} \\ 0 & 0 & 1 & + \textrm{Pz}} \cdot \mvHomMatrixThreeDRotTrans{\mvRotationMatrixVar{}{}} {\mvVectorThreeDPlain{0}{0}{0}} \cdot \mvHomMatrixThreeDElements{ 1 & 0 & 0 & - \textrm{Px} \\ 0 & 1 & 0 & - \textrm{Py} \\ 0 & 0 & 1 & - \textrm{Pz}} \cdot \textrm{HomMat3D} \end{eqnarray*}\]

To perform the transformation in the local coordinate system, i.e., the one described by HomMat3DhomMat3Dhom_mat_3d, use hom_mat3d_rotate_localHomMat3dRotateLocal.

Attention🔗

Note that homogeneous matrices are stored row-by-row as a tuple; the last row is usually not stored because it is identical for all homogeneous matrices that describe an affine transformation. For example, the homogeneous matrix \(\mvHomMatrixThreeDElements{ ra & rb & rc & td \\ re & rf & rg & th \\ ri & rj & rk & tl}\) is stored as the tuple [ra, rb, rc, td, re, rf, rg, th, ri, rj, rk, tl]. However, it is also possible to process full 4×4 matrices, which represent a projective 4D transformation.

Execution information🔗

Execution information

Multithreading type: reentrant (runs in parallel with non-exclusive operators).
Multithreading scope: global (may be called from any thread).
Processed without parallelization.

Parameters🔗

HomMat3DhomMat3Dhom_mat_3d (input_control) hom_mat3d → (real)HTuple (double)HHomMat3D, HTuple (double)Sequence[float]Htuple (double)

Input transformation matrix.

Phiphiphi (input_control) angle.rad → (real / integer)HTuple (double / Hlong)HTuple (double / int / long)Union[float, int]Htuple (double / Hlong)

Rotation angle.

Default: 0.780.78
Suggested values: 0.1, 0.2, 0.3, 0.4, 0.78, 1.57, 3.140.1, 0.2, 0.3, 0.4, 0.78, 1.57, 3.14
Value range: 0 ≤ Phi ≤ 6.28318530718

Axisaxisaxis (input_control) string(-array) → (string / real / integer)HTuple (HString / double / Hlong)HTuple (string / double / int / long)MaybeSequence[Union[str, float, int]]Htuple (char* / double / Hlong)

Axis, to be rotated around.

Default: 'x'"x"
Suggested values: 'x', 'y', 'z'"x", "y", "z"

Pxpxpx (input_control) point3d.x → (real / integer)HTuple (double / Hlong)HTuple (double / int / long)Union[float, int]Htuple (double / Hlong)

Fixed point of the transformation (x coordinate).

Default: 00
Suggested values: 0, 16, 32, 64, 128, 256, 512, 10240, 16, 32, 64, 128, 256, 512, 1024

Pypypy (input_control) point3d.y → (real / integer)HTuple (double / Hlong)HTuple (double / int / long)Union[float, int]Htuple (double / Hlong)

Fixed point of the transformation (y coordinate).

Default: 00
Suggested values: 0, 16, 32, 64, 128, 256, 512, 10240, 16, 32, 64, 128, 256, 512, 1024

Pzpzpz (input_control) point3d.z → (real / integer)HTuple (double / Hlong)HTuple (double / int / long)Union[float, int]Htuple (double / Hlong)

Fixed point of the transformation (z coordinate).

Default: 00
Suggested values: 0, 16, 32, 64, 128, 256, 512, 10240, 16, 32, 64, 128, 256, 512, 1024

HomMat3DRotatehomMat3DRotatehom_mat_3drotate (output_control) hom_mat3d → (real)HTuple (double)HHomMat3D, HTuple (double)Sequence[float]Htuple (double)

Output transformation matrix.

Result🔗

If the parameters are valid, the operator hom_mat3d_rotateHomMat3dRotate returns 2 (H_MSG_TRUE). If necessary, an exception is raised.

Combinations with other operators🔗

Combinations

Possible predecessors

hom_mat3d_identityHomMat3dIdentity, hom_mat3d_translateHomMat3dTranslate, hom_mat3d_scaleHomMat3dScale, hom_mat3d_rotateHomMat3dRotate

Possible successors

hom_mat3d_translateHomMat3dTranslate, hom_mat3d_scaleHomMat3dScale, hom_mat3d_rotateHomMat3dRotate

Module🔗

Foundation