code: def get_resize_output_image_size(
      input_image: np.ndarray,
      size: Union[int, Tuple[int, int], List[int], Tuple[int]],
      default_to_square: bool = True,
      max_size: Optional[int] = None,
      input_data_format: Optional[Union[str, ChannelDimension]] = None,
  ) -> tuple:
      """
      Find the target (height, width) dimension of the output image after resizing given the input image and the desired
      size.
  
      Args:
          input_image (`np.ndarray`):
              The image to resize.
          size (`int` or `Tuple[int, int]` or List[int] or Tuple[int]):
              The size to use for resizing the image. If `size` is a sequence like (h, w), output size will be matched to
              this.
  
              If `size` is an int and `default_to_square` is `True`, then image will be resized to (size, size). If
              `size` is an int and `default_to_square` is `False`, then smaller edge of the image will be matched to this
              number. i.e, if height > width, then image will be rescaled to (size * height / width, size).
          default_to_square (`bool`, *optional*, defaults to `True`):
              How to convert `size` when it is a single int. If set to `True`, the `size` will be converted to a square
              (`size`,`size`). If set to `False`, will replicate
              [`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize)
              with support for resizing only the smallest edge and providing an optional `max_size`.
          max_size (`int`, *optional*):
              The maximum allowed for the longer edge of the resized image: if the longer edge of the image is greater
              than `max_size` after being resized according to `size`, then the image is resized again so that the longer
              edge is equal to `max_size`. As a result, `size` might be overruled, i.e the smaller edge may be shorter
              than `size`. Only used if `default_to_square` is `False`.
          input_data_format (`ChannelDimension`, *optional*):
              The channel dimension format of the input image. If unset, will use the inferred format from the input.
  
      Returns:
          `tuple`: The target (height, width) dimension of the output image after resizing.
      """
      if isinstance(size, (tuple, list)):
          if len(size) == 2:
              return tuple(size)
          elif len(size) == 1:
              # Perform same logic as if size was an int
              size = size[0]
          else:
              raise ValueError(
                  "size must have 1 or 2 elements if it is a list or tuple"
              )
  
      if default_to_square:
          return (size, size)
  
      height, width = get_image_size(input_image, input_data_format)
      short, long = (
          (width, height) if width <= height else (height, width)
      )
      requested_new_short = size
  
      new_short, new_long = requested_new_short, int(
          requested_new_short * long / short
      )
  
      if max_size is not None:
          if max_size <= requested_new_short:
              raise ValueError(
                  f"max_size = {max_size} must be strictly greater than the requested "
                  f"size for the smaller edge size = {size}"
              )
          if new_long > max_size:
              new_short, new_long = (
                  int(max_size * new_short / new_long),
                  max_size,
              )
  
      return (
          (new_long, new_short)
          if width <= height
          else (new_short, new_long)
      )
  
imports: import warnings
  from typing import Iterable, List, Optional, Tuple, Union
  import numpy
  from .image_utils import ChannelDimension, ImageInput, get_channel_dimension_axis, get_image_size, infer_channel_dimension_format
  from .utils import ExplicitEnum, TensorType, is_jax_tensor, is_tf_tensor, is_torch_tensor
  from .utils.import_utils import is_flax_available, is_tf_available, is_torch_available, is_vision_available, requires_backends
label_desc: Use image node_id 5 for calling a global function with example usage: get_resize_output_image_size(input_image, size, default_to_square, max_size, input_data_format) and returns: unknown, size,  size, tuple