code: def quaternion_to_rotation_matrix(quaternion: Tensor) -> Tensor:
      r"""Convert a quaternion to a rotation matrix.
  
      The quaternion should be in (w, x, y, z) format.
  
      Args:
          quaternion: a tensor containing a quaternion to be converted.
            The tensor can be of shape :math:`(*, 4)`.
  
      Return:
          the rotation matrix of shape :math:`(*, 3, 3)`.
  
      Example:
          >>> quaternion = tensor((0., 0., 0., 1.))
          >>> quaternion_to_rotation_matrix(quaternion)
          tensor([[-1.,  0.,  0.],
                  [ 0., -1.,  0.],
                  [ 0.,  0.,  1.]])
      """
      if not isinstance(quaternion, Tensor):
          raise TypeError(
              f"Input type is not a Tensor. Got {type(quaternion)}"
          )
  
      if not quaternion.shape[-1] == 4:
          raise ValueError(
              f"Input must be a tensor of shape (*, 4). Got {quaternion.shape}"
          )
  
      # normalize the input quaternion
      quaternion_norm: Tensor = normalize_quaternion(quaternion)
  
      # unpack the normalized quaternion components
      w = quaternion_norm[..., 0]
      x = quaternion_norm[..., 1]
      y = quaternion_norm[..., 2]
      z = quaternion_norm[..., 3]
  
      # compute the actual conversion
      tx: Tensor = 2.0 * x
      ty: Tensor = 2.0 * y
      tz: Tensor = 2.0 * z
      twx: Tensor = tx * w
      twy: Tensor = ty * w
      twz: Tensor = tz * w
      txx: Tensor = tx * x
      txy: Tensor = ty * x
      txz: Tensor = tz * x
      tyy: Tensor = ty * y
      tyz: Tensor = tz * y
      tzz: Tensor = tz * z
      one: Tensor = tensor(1.0)
  
      matrix_flat: Tensor = stack(
          (
              one - (tyy + tzz),
              txy - twz,
              txz + twy,
              txy + twz,
              one - (txx + tzz),
              tyz - twx,
              txz - twy,
              tyz + twx,
              one - (txx + tyy),
          ),
          dim=-1,
      )
  
      # this slightly awkward construction of the output shape is to satisfy torchscript
      output_shape = [*list(quaternion.shape[:-1]), 3, 3]
      matrix = matrix_flat.reshape(output_shape)
  
      return matrix
  
imports: from __future__ import annotations
  from typing import Optional
  import torch
  import torch.nn.functional
  from kornia.constants import pi
  from kornia.core import Tensor, concatenate, cos, pad, sin, stack, tensor, where, zeros_like
  from kornia.core.check import KORNIA_CHECK, KORNIA_CHECK_SHAPE
  from kornia.utils import deprecated
  from kornia.utils.helpers import _torch_inverse_cast
label_desc: Use image node_id 16 for calling a global function with example usage: quaternion_to_rotation_matrix(quaternion) and returns: matrix