code: def transform_bbox(
      trans_mat: torch.Tensor,
      boxes: torch.Tensor,
      mode: str = "xyxy",
      restore_coordinates: Optional[bool] = None,
  ) -> torch.Tensor:
      r"""Apply a transformation matrix to a box or batch of boxes.
  
      Args:
          trans_mat: The transformation matrix to be applied with a shape of :math:`(3, 3)`
              or batched as :math:`(B, 3, 3)`.
          boxes: The boxes to be transformed with a common shape of :math:`(N, 4)` or batched as :math:`(B, N, 4)`, the
              polygon shape of :math:`(B, N, 4, 2)` is also supported.
          mode: The format in which the boxes are provided. If set to 'xyxy' the boxes are assumed to be in the format
              ``xmin, ymin, xmax, ymax``. If set to 'xywh' the boxes are assumed to be in the format
              ``xmin, ymin, width, height``
          restore_coordinates: In case the boxes are flipped, adding a post processing step to restore the
              coordinates to a valid bounding box.
  
      Returns:
          The set of transformed points in the specified mode
      """
  
      if not isinstance(mode, str):
          raise TypeError(f"Mode must be a string. Got {type(mode)}")
  
      if mode not in ("xyxy", "xywh"):
          raise ValueError(
              f"Mode must be one of 'xyxy', 'xywh'. Got {mode}"
          )
  
      # (B, N, 4, 2) shaped polygon boxes do not need to be restored.
      if restore_coordinates is None and not (
          boxes.shape[-2:] == torch.Size([4, 2])
      ):
          warnings.warn(
              "Previous behaviour produces incorrect box coordinates if a flip transformation performed on boxes."
              "The previous wrong behaviour has been corrected and will be removed in the future versions."
              "If you wish to keep the previous behaviour, please set `restore_coordinates=False`."
              "Otherwise, set `restore_coordinates=True` as an acknowledgement."
          )
  
      # convert boxes to format xyxy
      if mode == "xywh":
          boxes[..., 2] = boxes[..., 0] + boxes[..., 2]  # x + w
          boxes[..., 3] = boxes[..., 1] + boxes[..., 3]  # y + h
  
      transformed_boxes: torch.Tensor = transform_points(
          trans_mat, boxes.view(boxes.shape[0], -1, 2)
      )
      transformed_boxes = transformed_boxes.view_as(boxes)
  
      if (restore_coordinates is None or restore_coordinates) and not (
          boxes.shape[-2:] == torch.Size([4, 2])
      ):
          restored_boxes = transformed_boxes.clone()
          # In case the boxes are flipped, we ensure it is ordered like left-top -> right-bot points
          restored_boxes[..., 0] = torch.min(
              transformed_boxes[..., [0, 2]], dim=-1
          )[0]
          restored_boxes[..., 1] = torch.min(
              transformed_boxes[..., [1, 3]], dim=-1
          )[0]
          restored_boxes[..., 2] = torch.max(
              transformed_boxes[..., [0, 2]], dim=-1
          )[0]
          restored_boxes[..., 3] = torch.max(
              transformed_boxes[..., [1, 3]], dim=-1
          )[0]
          transformed_boxes = restored_boxes
  
      if mode == "xywh":
          transformed_boxes[..., 2] = (
              transformed_boxes[..., 2] - transformed_boxes[..., 0]
          )
          transformed_boxes[..., 3] = (
              transformed_boxes[..., 3] - transformed_boxes[..., 1]
          )
  
      return transformed_boxes
  
file_path: kornia/kornia/geometry/bbox.py
imports: from __future__ import annotations
  import warnings
  from typing import Optional
  import torch
  from kornia.core import arange, ones_like, stack, where, zeros
  from .linalg import transform_points
label_desc: Use image node_id 9 for calling a global function with example usage: transform_bbox(trans_mat, boxes, mode, restore_coordinates) and returns: transformed_boxes