# scipy.spatial.transform.Rotation.apply

Rotation.apply()

  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 ndarray, shape (3,) or (N, 3)

      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.

  Examples

      >>> from scipy.spatial.transform import Rotation as R

  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 ]])