class_docstr: Constructs a MaskFormer feature extractor. The feature extractor can be used to prepare image(s) and optional
  targets for the model.
  
  This feature extractor inherits from [`FeatureExtractionMixin`] which contains most of the main methods. Users
  should refer to this superclass for more information regarding those methods.
  
  Args:
      do_resize (`bool`, *optional*, defaults to `True`):
          Whether to resize the input to a certain `size`.
      size (`int`, *optional*, defaults to 800):
          Resize the input to the given size. Only has an effect if `do_resize` is set to `True`. If size is a
          sequence like `(width, height)`, output size will be matched to this. If size is an int, 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)`.
      max_size (`int`, *optional*, defaults to 1333):
          The largest size an image dimension can have (otherwise it's capped). Only has an effect if `do_resize` is
          set to `True`.
      resample (`int`, *optional*, defaults to `PIL.Image.Resampling.BILINEAR`):
          An optional resampling filter. This can be one of `PIL.Image.Resampling.NEAREST`,
          `PIL.Image.Resampling.BOX`, `PIL.Image.Resampling.BILINEAR`, `PIL.Image.Resampling.HAMMING`,
          `PIL.Image.Resampling.BICUBIC` or `PIL.Image.Resampling.LANCZOS`. Only has an effect if `do_resize` is set
          to `True`.
      size_divisibility (`int`, *optional*, defaults to 32):
          Some backbones need images divisible by a certain number. If not passed, it defaults to the value used in
          Swin Transformer.
      do_normalize (`bool`, *optional*, defaults to `True`):
          Whether or not to normalize the input with mean and standard deviation.
      image_mean (`int`, *optional*, defaults to `[0.485, 0.456, 0.406]`):
          The sequence of means for each channel, to be used when normalizing images. Defaults to the ImageNet mean.
      image_std (`int`, *optional*, defaults to `[0.229, 0.224, 0.225]`):
          The sequence of standard deviations for each channel, to be used when normalizing images. Defaults to the
          ImageNet std.
      ignore_index (`int`, *optional*):
          Label to be assigned to background pixels in segmentation maps. If provided, segmentation map pixels
          denoted with 0 (background) will be replaced with `ignore_index`.
      reduce_labels (`bool`, *optional*, defaults to `False`):
          Whether or not to decrement all label values of segmentation maps by 1. Usually used for datasets where 0
          is used for background, and background itself is not included in all classes of a dataset (e.g. ADE20k).
          The background label will be replaced by `ignore_index`.
docstr: Resize the image to the given size. Size can be min_size (scalar) or (width, height) tuple. If size is an int,
  smaller edge of the image will be matched to this number.
  
  If given, also resize the target accordingly.
docstr_tok: ["Resize","the","image","to","the","given","size",".","Size","can","be","min_size","(","scalar",")","or","(","width",",","height",")","tuple",".","If","size","is","an","int",",","smaller","edge","of","the","image","will","be","matched","to","this","number",".","If","given",",","also","resize","the","target","accordingly","."]
code: def _resize_with_size_divisibility(
      self, image, size, target=None, max_size=None
  ):
      """
      Resize the image to the given size. Size can be min_size (scalar) or (width, height) tuple. If size is an int,
      smaller edge of the image will be matched to this number.
  
      If given, also resize the target accordingly.
      """
      if not isinstance(image, Image.Image):
          image = self.to_pil_image(image)
  
      def get_size_with_aspect_ratio(image_size, size, max_size=None):
          width, height = image_size
          if max_size is not None:
              min_original_size = float(min((width, height)))
              max_original_size = float(max((width, height)))
              if (
                  max_original_size / min_original_size * size
                  > max_size
              ):
                  size = int(
                      round(
                          max_size
                          * min_original_size
                          / max_original_size
                      )
                  )
  
          if (width <= height and width == size) or (
              height <= width and height == size
          ):
              return (height, width)
  
          if width < height:
              output_width = size
              output_height = int(size * height / width)
          else:
              output_height = size
              output_width = int(size * width / height)
  
          return (output_height, output_width)
  
      def get_size(image_size, size, max_size=None):
          if isinstance(size, (list, tuple)):
              return size
          else:
              # size returned must be (width, height) since we use PIL to resize images
              # so we revert the tuple
              return get_size_with_aspect_ratio(
                  image_size, size, max_size
              )[::-1]
  
      width, height = get_size(image.size, size, max_size)
  
      if self.size_divisibility > 0:
          height = (
              int(np.ceil(height / self.size_divisibility))
              * self.size_divisibility
          )
          width = (
              int(np.ceil(width / self.size_divisibility))
              * self.size_divisibility
          )
  
      size = (width, height)
      image = self.resize(image, size=size, resample=self.resample)
  
      if target is not None:
          target = self.resize(
              target, size=size, resample=Image.NEAREST
          )
  
      return image, target
  
imports: from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
  import numpy
  from PIL import Image
  from transformers.image_utils import PILImageResampling
  from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
  from ...image_utils import ImageFeatureExtractionMixin, ImageInput, is_torch_tensor
  from ...utils import TensorType, is_torch_available, logging
label_desc: Use image node_id 2 for calling the MaskFormerFeatureExtractor obj's underlying member method code with example usage: obj._resize_with_size_divisibility(image, size, target, max_size) and returns: image,  target, output_height,  output_width, height,  width, size, get_size_with_aspect_ratio