# weldx.WXRotation.apply#

WXRotation.apply(self, vectors, inverse=False)#

Apply this rotation to a set of vectors.

If the original frame rotates to the final frame by this rotation, then its application to a vector can be seen in two ways:

• As a projection of vector components expressed in the final frame to the original frame.

• As the physical rotation of a vector being glued to the original frame as it rotates. In this case the vector components are expressed in the original frame before and after the rotation.

In terms of rotation matricies, this application is the same as `self.as_matrix().dot(vectors)`.

Parameters:
• vectors (array_like, shape (3,) or (N, 3)) – Each `vectors[i]` represents a vector in 3D space. A single vector can either be specified with shape `(3, )` or `(1, 3)`. The number of rotations and number of vectors given must follow standard numpy broadcasting rules: either one of them equals unity or they both equal each other.

• inverse (boolean, optional) – If True then the inverse of the rotation(s) is applied to the input vectors. Default is False.

Returns:

rotated_vectors – Result of applying rotation on input vectors. Shape depends on the following cases:

• If object contains a single rotation (as opposed to a stack with a single rotation) and a single vector is specified with shape `(3,)`, then `rotated_vectors` has shape `(3,)`.

• In all other cases, `rotated_vectors` has shape `(N, 3)`, where `N` is either the number of rotations or vectors.

Return type:

ndarray, shape (3,) or (N, 3)

Examples

```>>> from scipy.spatial.transform import Rotation as R
>>> import numpy as np
```

Single rotation applied on a single vector:

```>>> vector = np.array([1, 0, 0])
>>> r = R.from_rotvec([0, 0, np.pi/2])
>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.apply(vector)
array([2.22044605e-16, 1.00000000e+00, 0.00000000e+00])
>>> r.apply(vector).shape
(3,)
```

Single rotation applied on multiple vectors:

```>>> vectors = np.array([
... [1, 0, 0],
... [1, 2, 3]])
>>> r = R.from_rotvec([0, 0, np.pi/4])
>>> r.as_matrix()
array([[ 0.70710678, -0.70710678,  0.        ],
[ 0.70710678,  0.70710678,  0.        ],
[ 0.        ,  0.        ,  1.        ]])
>>> r.apply(vectors)
array([[ 0.70710678,  0.70710678,  0.        ],
[-0.70710678,  2.12132034,  3.        ]])
>>> r.apply(vectors).shape
(2, 3)
```

Multiple rotations on a single vector:

```>>> r = R.from_rotvec([[0, 0, np.pi/4], [np.pi/2, 0, 0]])
>>> vector = np.array([1,2,3])
>>> r.as_matrix()
array([[[ 7.07106781e-01, -7.07106781e-01,  0.00000000e+00],
[ 7.07106781e-01,  7.07106781e-01,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]],
[[ 1.00000000e+00,  0.00000000e+00,  0.00000000e+00],
[ 0.00000000e+00,  2.22044605e-16, -1.00000000e+00],
[ 0.00000000e+00,  1.00000000e+00,  2.22044605e-16]]])
>>> r.apply(vector)
array([[-0.70710678,  2.12132034,  3.        ],
[ 1.        , -3.        ,  2.        ]])
>>> r.apply(vector).shape
(2, 3)
```

Multiple rotations on multiple vectors. Each rotation is applied on the corresponding vector:

```>>> r = R.from_euler('zxy', [
... [0, 0, 90],
... [45, 30, 60]], degrees=True)
>>> vectors = [
... [1, 2, 3],
... [1, 0, -1]]
>>> r.apply(vectors)
array([[ 3.        ,  2.        , -1.        ],
[-0.09026039,  1.11237244, -0.86860844]])
>>> r.apply(vectors).shape
(2, 3)
```

It is also possible to apply the inverse rotation:

```>>> r = R.from_euler('zxy', [
... [0, 0, 90],
... [45, 30, 60]], degrees=True)
>>> vectors = [
... [1, 2, 3],
... [1, 0, -1]]
>>> r.apply(vectors, inverse=True)
array([[-3.        ,  2.        ,  1.        ],
[ 1.09533535, -0.8365163 ,  0.3169873 ]])
```