parameters: (cls, seq, angles, degrees=False)
return_statement: return cls(quat[0] if is_single else quat, normalized=True, copy=False)
docstring: Initialize from Euler angles.
  
          Rotations in 3 dimensions can be represented by a sequece of 3
          rotations around a sequence of axes. In theory, any three axes spanning
          the 3D Euclidean space are enough. In practice the axes of rotation are
          chosen to be the basis vectors.
  
          The three rotations can either be in a global frame of reference
          (extrinsic) or in a body centred frame of refernce (intrinsic), which
          is attached to, and moves with, the object under rotation [1]_.
  
          Parameters
          ----------
          seq : string
              Specifies sequence of axes for rotations. Up to 3 characters
              belonging to the set {'X', 'Y', 'Z'} for intrinsic rotations, or
              {'x', 'y', 'z'} for extrinsic rotations. Extrinsic and intrinsic
              rotations cannot be mixed in one function call.
          angles : float or array_like, shape (N,) or (N, [1 or 2 or 3])
              Euler angles specified in radians (`degrees` is False) or degrees
              (`degrees` is True).
              For a single character `seq`, `angles` can be:
  
                  - a single value
                  - array_like with shape (N,), where each `angle[i]`
                    corresponds to a single rotation
                  - array_like with shape (N, 1), where each `angle[i, 0]`
                    corresponds to a single rotation
  
              For 2- and 3-character wide `seq`, `angles` can be:
  
                  - array_like with shape (W,) where `W` is the width of
                    `seq`, which corresponds to a single rotation with `W` axes
                  - array_like with shape (N, W) where each `angle[i]`
                    corresponds to a sequence of Euler angles describing a single
                    rotation
  
          degrees : boolean, optional
              If True, then the given angles are assumed to be in degrees.
              Default is False.
  
          Returns
          -------
          rotation : `Rotation` instance
              Object containing the rotation represented by the sequence of
              rotations around given axes with given angles.
  
          References
          ----------
          .. [1] `Euler angle definitions
                  <https://en.wikipedia.org/wiki/Euler_angles#Definition_by_intrinsic_rotations>`_
  
          Examples
          --------
          >>> from scipy.spatial.transform import Rotation as R
  
          Initialize a single rotation along a single axis:
  
          >>> r = R.from_euler('x', 90, degrees=True)
          >>> r.as_quat().shape
          (4,)
  
          Initialize a single rotation with a given axis sequence:
  
          >>> r = R.from_euler('zyx', [90, 45, 30], degrees=True)
          >>> r.as_quat().shape
          (4,)
  
          Initialize a stack with a single rotation around a single axis:
  
          >>> r = R.from_euler('x', [90], degrees=True)
          >>> r.as_quat().shape
          (1, 4)
  
          Initialize a stack with a single rotation with an axis sequence:
  
          >>> r = R.from_euler('zyx', [[90, 45, 30]], degrees=True)
          >>> r.as_quat().shape
          (1, 4)
  
          Initialize multiple elementary rotations in one object:
  
          >>> r = R.from_euler('x', [90, 45, 30], degrees=True)
          >>> r.as_quat().shape
          (3, 4)
  
          Initialize multiple rotations in one object:
  
          >>> r = R.from_euler('zyx', [[90, 45, 30], [35, 45, 90]], degrees=True)
          >>> r.as_quat().shape
          (2, 4)
docstring_summary: Initialize from Euler angles.
docstring_tokens: Initialize from Euler angles .
function: def from_euler(cls, seq, angles, degrees=False):
          """Initialize from Euler angles.
  
          Rotations in 3 dimensions can be represented by a sequece of 3
          rotations around a sequence of axes. In theory, any three axes spanning
          the 3D Euclidean space are enough. In practice the axes of rotation are
          chosen to be the basis vectors.
  
          The three rotations can either be in a global frame of reference
          (extrinsic) or in a body centred frame of refernce (intrinsic), which
          is attached to, and moves with, the object under rotation [1]_.
  
          Parameters
          ----------
          seq : string
              Specifies sequence of axes for rotations. Up to 3 characters
              belonging to the set {'X', 'Y', 'Z'} for intrinsic rotations, or
              {'x', 'y', 'z'} for extrinsic rotations. Extrinsic and intrinsic
              rotations cannot be mixed in one function call.
          angles : float or array_like, shape (N,) or (N, [1 or 2 or 3])
              Euler angles specified in radians (`degrees` is False) or degrees
              (`degrees` is True).
              For a single character `seq`, `angles` can be:
  
                  - a single value
                  - array_like with shape (N,), where each `angle[i]`
                    corresponds to a single rotation
                  - array_like with shape (N, 1), where each `angle[i, 0]`
                    corresponds to a single rotation
  
              For 2- and 3-character wide `seq`, `angles` can be:
  
                  - array_like with shape (W,) where `W` is the width of
                    `seq`, which corresponds to a single rotation with `W` axes
                  - array_like with shape (N, W) where each `angle[i]`
                    corresponds to a sequence of Euler angles describing a single
                    rotation
  
          degrees : boolean, optional
              If True, then the given angles are assumed to be in degrees.
              Default is False.
  
          Returns
          -------
          rotation : `Rotation` instance
              Object containing the rotation represented by the sequence of
              rotations around given axes with given angles.
  
          References
          ----------
          .. [1] `Euler angle definitions
                  <https://en.wikipedia.org/wiki/Euler_angles#Definition_by_intrinsic_rotations>`_
  
          Examples
          --------
          >>> from scipy.spatial.transform import Rotation as R
  
          Initialize a single rotation along a single axis:
  
          >>> r = R.from_euler('x', 90, degrees=True)
          >>> r.as_quat().shape
          (4,)
  
          Initialize a single rotation with a given axis sequence:
  
          >>> r = R.from_euler('zyx', [90, 45, 30], degrees=True)
          >>> r.as_quat().shape
          (4,)
  
          Initialize a stack with a single rotation around a single axis:
  
          >>> r = R.from_euler('x', [90], degrees=True)
          >>> r.as_quat().shape
          (1, 4)
  
          Initialize a stack with a single rotation with an axis sequence:
  
          >>> r = R.from_euler('zyx', [[90, 45, 30]], degrees=True)
          >>> r.as_quat().shape
          (1, 4)
  
          Initialize multiple elementary rotations in one object:
  
          >>> r = R.from_euler('x', [90, 45, 30], degrees=True)
          >>> r.as_quat().shape
          (3, 4)
  
          Initialize multiple rotations in one object:
  
          >>> r = R.from_euler('zyx', [[90, 45, 30], [35, 45, 90]], degrees=True)
          >>> r.as_quat().shape
          (2, 4)
  
          """
          num_axes = len(seq)
          if num_axes < 1 or num_axes > 3:
              raise ValueError("Expected axis specification to be a non-empty "
                               "string of upto 3 characters, got {}".format(seq))
  
          intrinsic = (re.match(r'^[XYZ]{1,3}$', seq) is not None)
          extrinsic = (re.match(r'^[xyz]{1,3}$', seq) is not None)
          if not (intrinsic or extrinsic):
              raise ValueError("Expected axes from `seq` to be from ['x', 'y', "
                               "'z'] or ['X', 'Y', 'Z'], got {}".format(seq))
  
          if any(seq[i] == seq[i+1] for i in range(num_axes - 1)):
              raise ValueError("Expected consecutive axes to be different, "
                               "got {}".format(seq))
  
          seq = seq.lower()
  
          angles = np.asarray(angles, dtype=float)
          if degrees:
              angles = np.deg2rad(angles)
  
          is_single = False
          # Prepare angles to have shape (num_rot, num_axes)
          if num_axes == 1:
              if angles.ndim == 0:
                  # (1, 1)
                  angles = angles.reshape((1, 1))
                  is_single = True
              elif angles.ndim == 1:
                  # (N, 1)
                  angles = angles[:, None]
              elif angles.ndim == 2 and angles.shape[-1] != 1:
                  raise ValueError("Expected `angles` parameter to have shape "
                                   "(N, 1), got {}.".format(angles.shape))
              elif angles.ndim > 2:
                  raise ValueError("Expected float, 1D array, or 2D array for "
                                   "parameter `angles` corresponding to `seq`, "
                                   "got shape {}.".format(angles.shape))
          else:  # 2 or 3 axes
              if angles.ndim not in [1, 2] or angles.shape[-1] != num_axes:
                  raise ValueError("Expected `angles` to be at most "
                                   "2-dimensional with width equal to number "
                                   "of axes specified, got {} for shape").format(
                                   angles.shape)
  
              if angles.ndim == 1:
                  # (1, num_axes)
                  angles = angles[None, :]
                  is_single = True
  
          # By now angles should have shape (num_rot, num_axes)
          # sanity check
          if angles.ndim != 2 or angles.shape[-1] != num_axes:
              raise ValueError("Expected angles to have shape (num_rotations, "
                               "num_axes), got {}.".format(angles.shape))
  
          quat = _elementary_quat_compose(seq, angles, intrinsic)
          return cls(quat[0] if is_single else quat, normalized=True, copy=False)
function_tokens: def from_euler ( cls , seq , angles , degrees = False ) : num_axes = len ( seq ) if num_axes < 1 or num_axes > 3 : raise ValueError ( "Expected axis specification to be a non-empty " "string of upto 3 characters, got {}" . format ( seq ) ) intrinsic = ( re . match ( r'^[XYZ]{1,3}$' , seq ) is not None ) extrinsic = ( re . match ( r'^[xyz]{1,3}$' , seq ) is not None ) if not ( intrinsic or extrinsic ) : raise ValueError ( "Expected axes from `seq` to be from ['x', 'y', " "'z'] or ['X', 'Y', 'Z'], got {}" . format ( seq ) ) if any ( seq [ i ] == seq [ i + 1 ] for i in range ( num_axes - 1 ) ) : raise ValueError ( "Expected consecutive axes to be different, " "got {}" . format ( seq ) ) seq = seq . lower ( ) angles = np . asarray ( angles , dtype = float ) if degrees : angles = np . deg2rad ( angles ) is_single = False # Prepare angles to have shape (num_rot, num_axes) if num_axes == 1 : if angles . ndim == 0 : # (1, 1) angles = angles . reshape ( ( 1 , 1 ) ) is_single = True elif angles . ndim == 1 : # (N, 1) angles = angles [ : , None ] elif angles . ndim == 2 and angles . shape [ - 1 ] != 1 : raise ValueError ( "Expected `angles` parameter to have shape " "(N, 1), got {}." . format ( angles . shape ) ) elif angles . ndim > 2 : raise ValueError ( "Expected float, 1D array, or 2D array for " "parameter `angles` corresponding to `seq`, " "got shape {}." . format ( angles . shape ) ) else : # 2 or 3 axes if angles . ndim not in [ 1 , 2 ] or angles . shape [ - 1 ] != num_axes : raise ValueError ( "Expected `angles` to be at most " "2-dimensional with width equal to number " "of axes specified, got {} for shape" ) . format ( angles . shape ) if angles . ndim == 1 : # (1, num_axes) angles = angles [ None , : ] is_single = True # By now angles should have shape (num_rot, num_axes) # sanity check if angles . ndim != 2 or angles . shape [ - 1 ] != num_axes : raise ValueError ( "Expected angles to have shape (num_rotations, " "num_axes), got {}." . format ( angles . shape ) ) quat = _elementary_quat_compose ( seq , angles , intrinsic ) return cls ( quat [ 0 ] if is_single else quat , normalized = True , copy = False )