code: def rotation_matrix_to_quaternion(
      rotation_matrix: Tensor, eps: float = 1.0e-8
  ) -> Tensor:
      r"""Convert 3x3 rotation matrix to 4d quaternion vector.
  
      The quaternion vector has components in (w, x, y, z) format.
  
      Args:
          rotation_matrix: the rotation matrix to convert with shape :math:`(*, 3, 3)`.
          eps: small value to avoid zero division.
  
      Return:
          the rotation in quaternion with shape :math:`(*, 4)`.
  
      Example:
          >>> input = tensor([[1., 0., 0.],
          ...                       [0., 1., 0.],
          ...                       [0., 0., 1.]])
          >>> rotation_matrix_to_quaternion(input, eps=torch.finfo(input.dtype).eps)
          tensor([1., 0., 0., 0.])
      """
      if not isinstance(rotation_matrix, Tensor):
          raise TypeError(
              f"Input type is not a Tensor. Got {type(rotation_matrix)}"
          )
  
      if not rotation_matrix.shape[-2:] == (3, 3):
          raise ValueError(
              f"Input size must be a (*, 3, 3) tensor. Got {rotation_matrix.shape}"
          )
  
      def safe_zero_division(
          numerator: Tensor, denominator: Tensor
      ) -> Tensor:
          eps: float = torch.finfo(numerator.dtype).tiny
          return numerator / torch.clamp(denominator, min=eps)
  
      rotation_matrix_vec: Tensor = rotation_matrix.reshape(
          *rotation_matrix.shape[:-2], 9
      )
  
      m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.chunk(
          rotation_matrix_vec, chunks=9, dim=-1
      )
  
      trace: Tensor = m00 + m11 + m22
  
      def trace_positive_cond() -> Tensor:
          sq = torch.sqrt(trace + 1.0 + eps) * 2.0  # sq = 4 * qw.
          qw = 0.25 * sq
          qx = safe_zero_division(m21 - m12, sq)
          qy = safe_zero_division(m02 - m20, sq)
          qz = safe_zero_division(m10 - m01, sq)
          return concatenate((qw, qx, qy, qz), dim=-1)
  
      def cond_1() -> Tensor:
          sq = (
              torch.sqrt(1.0 + m00 - m11 - m22 + eps) * 2.0
          )  # sq = 4 * qx.
          qw = safe_zero_division(m21 - m12, sq)
          qx = 0.25 * sq
          qy = safe_zero_division(m01 + m10, sq)
          qz = safe_zero_division(m02 + m20, sq)
          return concatenate((qw, qx, qy, qz), dim=-1)
  
      def cond_2() -> Tensor:
          sq = (
              torch.sqrt(1.0 + m11 - m00 - m22 + eps) * 2.0
          )  # sq = 4 * qy.
          qw = safe_zero_division(m02 - m20, sq)
          qx = safe_zero_division(m01 + m10, sq)
          qy = 0.25 * sq
          qz = safe_zero_division(m12 + m21, sq)
          return concatenate((qw, qx, qy, qz), dim=-1)
  
      def cond_3() -> Tensor:
          sq = (
              torch.sqrt(1.0 + m22 - m00 - m11 + eps) * 2.0
          )  # sq = 4 * qz.
          qw = safe_zero_division(m10 - m01, sq)
          qx = safe_zero_division(m02 + m20, sq)
          qy = safe_zero_division(m12 + m21, sq)
          qz = 0.25 * sq
          return concatenate((qw, qx, qy, qz), dim=-1)
  
      where_2 = where(m11 > m22, cond_2(), cond_3())
      where_1 = where((m00 > m11) & (m00 > m22), cond_1(), where_2)
  
      quaternion: Tensor = where(
          trace > 0.0, trace_positive_cond(), where_1
      )
      return quaternion
  
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 14 for calling a global function with example usage: rotation_matrix_to_quaternion(rotation_matrix, eps) and returns: quaternion, unknown, concatenate, concatenate, concatenate, concatenate