content: # Copyright 2024 The HuggingFace Inc. team.
  # SPDX-License-Identifier: Apache-2.0
  
  """Image processor class for SigLIP."""
  
  from typing import Dict, List, Optional, Union
  
  from transformers.image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
  from transformers.image_transforms import (
      convert_to_rgb,
      resize,
      to_channel_dimension_format,
  )
  from transformers.image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      infer_channel_dimension_format,
      is_scaled_image,
      make_list_of_images,
      to_numpy_array,
      valid_images,
      validate_preprocess_arguments,
  )
  from transformers.utils import TensorType, filter_out_non_signature_kwargs, is_vision_available, logging
  
  
  logger = logging.get_logger(__name__)
  
  
  if is_vision_available():
      import PIL
  
  
  class SiglipImageProcessor(BaseImageProcessor):
      r"""
      Constructs a SigLIP image processor.
  
      Args:
          do_resize (`bool`, *optional*, defaults to `True`):
              Whether to resize the image's (height, width) dimensions to the specified `size`. Can be overridden by
              `do_resize` in the `preprocess` method.
          size (`Dict[str, int]` *optional*, defaults to `{"height": 224, "width": 224}`):
              Size of the image after resizing. Can be overridden by `size` in the `preprocess` method.
          resample (`PILImageResampling`, *optional*, defaults to `Resampling.BICUBIC`):
              Resampling filter to use if resizing the image. Can be overridden by `resample` in the `preprocess` method.
          do_rescale (`bool`, *optional*, defaults to `True`):
              Whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by `do_rescale` in
              the `preprocess` method.
          rescale_factor (`int` or `float`, *optional*, defaults to `1/255`):
              Scale factor to use if rescaling the image. Can be overridden by `rescale_factor` in the `preprocess`
              method.
          do_normalize (`bool`, *optional*, defaults to `True`):
              Whether to normalize the image by the specified mean and standard deviation. Can be overridden by
              `do_normalize` in the `preprocess` method.
          image_mean (`float` or `List[float]`, *optional*, defaults to `[0.5, 0.5, 0.5]`):
              Mean to use if normalizing the image. This is a float or list of floats the length of the number of
              channels in the image. Can be overridden by the `image_mean` parameter in the `preprocess` method.
          image_std (`float` or `List[float]`, *optional*, defaults to `[0.5, 0.5, 0.5]`):
              Standard deviation to use if normalizing the image. This is a float or list of floats the length of the
              number of channels in the image. Can be overridden by the `image_std` parameter in the `preprocess` method.
              Can be overridden by the `image_std` parameter in the `preprocess` method.
          do_convert_rgb (`bool`, *optional*, defaults to `True`):
              Whether to convert the image to RGB.
      """
  
      model_input_names = ["pixel_values"]
  
      def __init__(
          self,
          do_resize: bool = True,
          size: Dict[str, int] = None,
          resample: PILImageResampling = PILImageResampling.BICUBIC,
          do_rescale: bool = True,
          rescale_factor: Union[int, float] = 1 / 255,
          do_normalize: bool = True,
          image_mean: Optional[Union[float, List[float]]] = None,
          image_std: Optional[Union[float, List[float]]] = None,
          do_convert_rgb: bool = None,
          **kwargs,
      ) -> None:
          super().__init__(**kwargs)
          size = size if size is not None else {"height": 224, "width": 224}
          image_mean = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
          image_std = image_std if image_std is not None else IMAGENET_STANDARD_STD
  
          self.do_resize = do_resize
          self.size = size
          self.resample = resample
          self.do_rescale = do_rescale
          self.rescale_factor = rescale_factor
          self.do_normalize = do_normalize
          self.image_mean = image_mean
          self.image_std = image_std
          self.do_convert_rgb = do_convert_rgb
  
      @filter_out_non_signature_kwargs()
      def preprocess(
          self,
          images: ImageInput,
          do_resize: bool = None,
          size: Dict[str, int] = None,
          resample: PILImageResampling = None,
          do_rescale: bool = None,
          rescale_factor: float = None,
          do_normalize: bool = None,
          image_mean: Optional[Union[float, List[float]]] = None,
          image_std: Optional[Union[float, List[float]]] = None,
          return_tensors: Optional[Union[str, TensorType]] = None,
          data_format: Optional[ChannelDimension] = ChannelDimension.FIRST,
          input_data_format: Optional[Union[str, ChannelDimension]] = None,
          do_convert_rgb: bool = None,
      ) -> PIL.Image.Image:
          """
          Preprocess an image or batch of images.
  
          Args:
              images (`ImageInput`):
                  Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If
                  passing in images with pixel values between 0 and 1, set `do_rescale=False`.
              do_resize (`bool`, *optional*, defaults to `self.do_resize`):
                  Whether to resize the image.
              size (`Dict[str, int]`, *optional*, defaults to `self.size`):
                  Size of the image after resizing.
              resample (`int`, *optional*, defaults to `self.resample`):
                  Resampling filter to use if resizing the image. This can be one of the enum `PILImageResampling`. Only
                  has an effect if `do_resize` is set to `True`.
              do_rescale (`bool`, *optional*, defaults to `self.do_rescale`):
                  Whether to rescale the image.
              rescale_factor (`float`, *optional*, defaults to `self.rescale_factor`):
                  Rescale factor to rescale the image by if `do_rescale` is set to `True`.
              do_normalize (`bool`, *optional*, defaults to `self.do_normalize`):
                  Whether to normalize the image.
              image_mean (`float` or `List[float]`, *optional*, defaults to `self.image_mean`):
                  Image mean to use for normalization. Only has an effect if `do_normalize` is set to `True`.
              image_std (`float` or `List[float]`, *optional*, defaults to `self.image_std`):
                  Image standard deviation to use for normalization. Only has an effect if `do_normalize` is set to
                  `True`.
              return_tensors (`str` or `TensorType`, *optional*):
                  The type of tensors to return. Can be one of:
                  - Unset: Return a list of `np.ndarray`.
                  - `TensorType.TENSORFLOW` or `'tf'`: Return a batch of type `tf.Tensor`.
                  - `TensorType.PYTORCH` or `'pt'`: Return a batch of type `torch.Tensor`.
                  - `TensorType.NUMPY` or `'np'`: Return a batch of type `np.ndarray`.
                  - `TensorType.JAX` or `'jax'`: Return a batch of type `jax.numpy.ndarray`.
              data_format (`ChannelDimension` or `str`, *optional*, defaults to `ChannelDimension.FIRST`):
                  The channel dimension format for the output image. Can be one of:
                  - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
                  - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
                  - Unset: Use the channel dimension format of the input image.
              input_data_format (`ChannelDimension` or `str`, *optional*):
                  The channel dimension format for the input image. If unset, the channel dimension format is inferred
                  from the input image. Can be one of:
                  - `"channels_first"` or `ChannelDimension.FIRST`: image in (num_channels, height, width) format.
                  - `"channels_last"` or `ChannelDimension.LAST`: image in (height, width, num_channels) format.
                  - `"none"` or `ChannelDimension.NONE`: image in (height, width) format.
              do_convert_rgb (`bool`, *optional*, defaults to `self.do_convert_rgb`):
                  Whether to convert the image to RGB.
          """
          do_resize = do_resize if do_resize is not None else self.do_resize
          size = size if size is not None else self.size
          size = get_size_dict(size, param_name="size", default_to_square=False)
          resample = resample if resample is not None else self.resample
          do_rescale = do_rescale if do_rescale is not None else self.do_rescale
          rescale_factor = rescale_factor if rescale_factor is not None else self.rescale_factor
          do_normalize = do_normalize if do_normalize is not None else self.do_normalize
          image_mean = image_mean if image_mean is not None else self.image_mean
          image_std = image_std if image_std is not None else self.image_std
          do_convert_rgb = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
  
          images = make_list_of_images(images)
  
          if not valid_images(images):
              raise ValueError(
                  "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                  "torch.Tensor, tf.Tensor or jax.ndarray."
              )
          validate_preprocess_arguments(
              do_rescale=do_rescale,
              rescale_factor=rescale_factor,
              do_normalize=do_normalize,
              image_mean=image_mean,
              image_std=image_std,
              do_resize=do_resize,
              size=size,
              resample=resample,
          )
          # All transformations expect numpy arrays.
          images = [to_numpy_array(image) for image in images]
  
          if do_convert_rgb:
              images = [convert_to_rgb(image) for image in images]
  
          if is_scaled_image(images[0]) and do_rescale:
              logger.warning_once(
                  "It looks like you are trying to rescale already rescaled images. If the input"
                  " images have pixel values between 0 and 1, set `do_rescale=False` to avoid rescaling them again."
              )
  
          if input_data_format is None:
              # We assume that all images have the same channel dimension format.
              input_data_format = infer_channel_dimension_format(images[0])
  
          if do_resize:
              height, width = size["height"], size["width"]
              images = [
                  resize(image=image, size=(height, width), resample=resample, input_data_format=input_data_format)
                  for image in images
              ]
  
          if do_rescale:
              images = [
                  self.rescale(image=image, scale=rescale_factor, input_data_format=input_data_format)
                  for image in images
              ]
  
          if do_normalize:
              images = [
                  self.normalize(image=image, mean=image_mean, std=image_std, input_data_format=input_data_format)
                  for image in images
              ]
  
          images = [
              to_channel_dimension_format(image, data_format, input_channel_dim=input_data_format) for image in images
          ]
  
          data = {"pixel_values": images}
          return BatchFeature(data=data, tensor_type=return_tensors)
  