# coding=utf-8
# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Feature extractor class for GLPN."""

from typing import Optional, Union

import numpy as np
from PIL import Image

from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from ...image_utils import ImageFeatureExtractionMixin, ImageInput, is_torch_tensor
from ...utils import TensorType, logging


logger = logging.get_logger(__name__)


class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin):
    r"""
    Constructs a GLPN feature extractor.

    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 based on certain `size_divisor`.
        size_divisor (`int` or `Tuple(int)`, *optional*, defaults to 32):
            Make sure the input is divisible by this value. Only has an effect if `do_resize` is set to `True`.
        resample (`int`, *optional*, defaults to `PIL.Image.BILINEAR`):
            An optional resampling filter. This can be one of `PIL.Image.NEAREST`, `PIL.Image.BOX`,
            `PIL.Image.BILINEAR`, `PIL.Image.HAMMING`, `PIL.Image.BICUBIC` or `PIL.Image.LANCZOS`. Only has an effect
            if `do_resize` is set to `True`.
        do_rescale (`bool`, *optional*, defaults to `True`):
             Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.).
    """

    model_input_names = ["pixel_values"]

    def __init__(self, do_resize=True, size_divisor=32, resample=Image.BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

    def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)

        width, height = image.size
        new_h, new_w = height // size_divisor * size_divisor, width // size_divisor * size_divisor

        image = self.resize(image, size=(new_w, new_h), resample=resample)

        return image

    def __call__(
        self, images: ImageInput, return_tensors: Optional[Union[str, TensorType]] = None, **kwargs
    ) -> BatchFeature:
        """
        Main method to prepare for the model one or several image(s).

        <Tip warning={true}>

        NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
        PIL images.

        </Tip>

        Args:
            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
                tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
                number of channels, H and W are image height and width.

            return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
                If set, will return tensors of a particular framework. Acceptable values are:

                - `'tf'`: Return TensorFlow `tf.constant` objects.
                - `'pt'`: Return PyTorch `torch.Tensor` objects.
                - `'np'`: Return NumPy `np.ndarray` objects.
                - `'jax'`: Return JAX `jnp.ndarray` objects.

        Returns:
            [`BatchFeature`]: A [`BatchFeature`] with the following fields:

            - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
              width).
        """
        # Input type checking for clearer error
        valid_images = False

        # Check that images has a valid type
        if isinstance(images, (Image.Image, np.ndarray)) or is_torch_tensor(images):
            valid_images = True
        elif isinstance(images, (list, tuple)):
            if len(images) == 0 or isinstance(images[0], (Image.Image, np.ndarray)) or is_torch_tensor(images[0]):
                valid_images = True

        if not valid_images:
            raise ValueError(
                "Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), "
                "`List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples)."
            )

        is_batched = bool(
            isinstance(images, (list, tuple))
            and (isinstance(images[0], (Image.Image, np.ndarray)) or is_torch_tensor(images[0]))
        )

        if not is_batched:
            images = [images]

        # transformations (resizing + rescaling)
        if self.do_resize and self.size_divisor is not None:
            images = [
                self._resize(image=image, size_divisor=self.size_divisor, resample=self.resample) for image in images
            ]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]

        # return as BatchFeature
        data = {"pixel_values": images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)

        return encoded_inputs

05fc28bc4d2bc6282280fa59d4254e38ca8f6763
<mask token>


class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin
    ):
    <mask token>
    <mask token>

    def __init__(self, do_resize=True, size_divisor=32, resample=Image.
        BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

    def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)
        width, height = image.size
        new_h, new_w = (height // size_divisor * size_divisor, width //
            size_divisor * size_divisor)
        image = self.resize(image, size=(new_w, new_h), resample=resample)
        return image

    def __call__(self, images: ImageInput, return_tensors: Optional[Union[
        str, TensorType]]=None, **kwargs) ->BatchFeature:
        """
        Main method to prepare for the model one or several image(s).

        <Tip warning={true}>

        NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
        PIL images.

        </Tip>

        Args:
            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
                tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
                number of channels, H and W are image height and width.

            return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
                If set, will return tensors of a particular framework. Acceptable values are:

                - `'tf'`: Return TensorFlow `tf.constant` objects.
                - `'pt'`: Return PyTorch `torch.Tensor` objects.
                - `'np'`: Return NumPy `np.ndarray` objects.
                - `'jax'`: Return JAX `jnp.ndarray` objects.

        Returns:
            [`BatchFeature`]: A [`BatchFeature`] with the following fields:

            - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
              width).
        """
        valid_images = False
        if isinstance(images, (Image.Image, np.ndarray)) or is_torch_tensor(
            images):
            valid_images = True
        elif isinstance(images, (list, tuple)):
            if len(images) == 0 or isinstance(images[0], (Image.Image, np.
                ndarray)) or is_torch_tensor(images[0]):
                valid_images = True
        if not valid_images:
            raise ValueError(
                'Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), `List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples).'
                )
        is_batched = bool(isinstance(images, (list, tuple)) and (isinstance
            (images[0], (Image.Image, np.ndarray)) or is_torch_tensor(
            images[0])))
        if not is_batched:
            images = [images]
        if self.do_resize and self.size_divisor is not None:
            images = [self._resize(image=image, size_divisor=self.
                size_divisor, resample=self.resample) for image in images]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]
        data = {'pixel_values': images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)
        return encoded_inputs

<mask token>


class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin
    ):
    """
    Constructs a GLPN feature extractor.

    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 based on certain `size_divisor`.
        size_divisor (`int` or `Tuple(int)`, *optional*, defaults to 32):
            Make sure the input is divisible by this value. Only has an effect if `do_resize` is set to `True`.
        resample (`int`, *optional*, defaults to `PIL.Image.BILINEAR`):
            An optional resampling filter. This can be one of `PIL.Image.NEAREST`, `PIL.Image.BOX`,
            `PIL.Image.BILINEAR`, `PIL.Image.HAMMING`, `PIL.Image.BICUBIC` or `PIL.Image.LANCZOS`. Only has an effect
            if `do_resize` is set to `True`.
        do_rescale (`bool`, *optional*, defaults to `True`):
             Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.).
    """
    model_input_names = ['pixel_values']

    def __init__(self, do_resize=True, size_divisor=32, resample=Image.
        BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

    def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)
        width, height = image.size
        new_h, new_w = (height // size_divisor * size_divisor, width //
            size_divisor * size_divisor)
        image = self.resize(image, size=(new_w, new_h), resample=resample)
        return image

    def __call__(self, images: ImageInput, return_tensors: Optional[Union[
        str, TensorType]]=None, **kwargs) ->BatchFeature:
        """
        Main method to prepare for the model one or several image(s).

        <Tip warning={true}>

        NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
        PIL images.

        </Tip>

        Args:
            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
                tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
                number of channels, H and W are image height and width.

            return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
                If set, will return tensors of a particular framework. Acceptable values are:

                - `'tf'`: Return TensorFlow `tf.constant` objects.
                - `'pt'`: Return PyTorch `torch.Tensor` objects.
                - `'np'`: Return NumPy `np.ndarray` objects.
                - `'jax'`: Return JAX `jnp.ndarray` objects.

        Returns:
            [`BatchFeature`]: A [`BatchFeature`] with the following fields:

            - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
              width).
        """
        valid_images = False
        if isinstance(images, (Image.Image, np.ndarray)) or is_torch_tensor(
            images):
            valid_images = True
        elif isinstance(images, (list, tuple)):
            if len(images) == 0 or isinstance(images[0], (Image.Image, np.
                ndarray)) or is_torch_tensor(images[0]):
                valid_images = True
        if not valid_images:
            raise ValueError(
                'Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), `List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples).'
                )
        is_batched = bool(isinstance(images, (list, tuple)) and (isinstance
            (images[0], (Image.Image, np.ndarray)) or is_torch_tensor(
            images[0])))
        if not is_batched:
            images = [images]
        if self.do_resize and self.size_divisor is not None:
            images = [self._resize(image=image, size_divisor=self.
                size_divisor, resample=self.resample) for image in images]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]
        data = {'pixel_values': images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)
        return encoded_inputs

<mask token>
logger = logging.get_logger(__name__)


class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin
    ):
    """
    Constructs a GLPN feature extractor.

    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 based on certain `size_divisor`.
        size_divisor (`int` or `Tuple(int)`, *optional*, defaults to 32):
            Make sure the input is divisible by this value. Only has an effect if `do_resize` is set to `True`.
        resample (`int`, *optional*, defaults to `PIL.Image.BILINEAR`):
            An optional resampling filter. This can be one of `PIL.Image.NEAREST`, `PIL.Image.BOX`,
            `PIL.Image.BILINEAR`, `PIL.Image.HAMMING`, `PIL.Image.BICUBIC` or `PIL.Image.LANCZOS`. Only has an effect
            if `do_resize` is set to `True`.
        do_rescale (`bool`, *optional*, defaults to `True`):
             Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.).
    """
    model_input_names = ['pixel_values']

    def __init__(self, do_resize=True, size_divisor=32, resample=Image.
        BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

    def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)
        width, height = image.size
        new_h, new_w = (height // size_divisor * size_divisor, width //
            size_divisor * size_divisor)
        image = self.resize(image, size=(new_w, new_h), resample=resample)
        return image

    def __call__(self, images: ImageInput, return_tensors: Optional[Union[
        str, TensorType]]=None, **kwargs) ->BatchFeature:
        """
        Main method to prepare for the model one or several image(s).

        <Tip warning={true}>

        NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
        PIL images.

        </Tip>

        Args:
            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
                tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
                number of channels, H and W are image height and width.

            return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
                If set, will return tensors of a particular framework. Acceptable values are:

                - `'tf'`: Return TensorFlow `tf.constant` objects.
                - `'pt'`: Return PyTorch `torch.Tensor` objects.
                - `'np'`: Return NumPy `np.ndarray` objects.
                - `'jax'`: Return JAX `jnp.ndarray` objects.

        Returns:
            [`BatchFeature`]: A [`BatchFeature`] with the following fields:

            - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
              width).
        """
        valid_images = False
        if isinstance(images, (Image.Image, np.ndarray)) or is_torch_tensor(
            images):
            valid_images = True
        elif isinstance(images, (list, tuple)):
            if len(images) == 0 or isinstance(images[0], (Image.Image, np.
                ndarray)) or is_torch_tensor(images[0]):
                valid_images = True
        if not valid_images:
            raise ValueError(
                'Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), `List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples).'
                )
        is_batched = bool(isinstance(images, (list, tuple)) and (isinstance
            (images[0], (Image.Image, np.ndarray)) or is_torch_tensor(
            images[0])))
        if not is_batched:
            images = [images]
        if self.do_resize and self.size_divisor is not None:
            images = [self._resize(image=image, size_divisor=self.
                size_divisor, resample=self.resample) for image in images]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]
        data = {'pixel_values': images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)
        return encoded_inputs

<mask token>
from typing import Optional, Union
import numpy as np
from PIL import Image
from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from ...image_utils import ImageFeatureExtractionMixin, ImageInput, is_torch_tensor
from ...utils import TensorType, logging
logger = logging.get_logger(__name__)


class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin
    ):
    """
    Constructs a GLPN feature extractor.

    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 based on certain `size_divisor`.
        size_divisor (`int` or `Tuple(int)`, *optional*, defaults to 32):
            Make sure the input is divisible by this value. Only has an effect if `do_resize` is set to `True`.
        resample (`int`, *optional*, defaults to `PIL.Image.BILINEAR`):
            An optional resampling filter. This can be one of `PIL.Image.NEAREST`, `PIL.Image.BOX`,
            `PIL.Image.BILINEAR`, `PIL.Image.HAMMING`, `PIL.Image.BICUBIC` or `PIL.Image.LANCZOS`. Only has an effect
            if `do_resize` is set to `True`.
        do_rescale (`bool`, *optional*, defaults to `True`):
             Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.).
    """
    model_input_names = ['pixel_values']

    def __init__(self, do_resize=True, size_divisor=32, resample=Image.
        BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

    def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)
        width, height = image.size
        new_h, new_w = (height // size_divisor * size_divisor, width //
            size_divisor * size_divisor)
        image = self.resize(image, size=(new_w, new_h), resample=resample)
        return image

    def __call__(self, images: ImageInput, return_tensors: Optional[Union[
        str, TensorType]]=None, **kwargs) ->BatchFeature:
        """
        Main method to prepare for the model one or several image(s).

        <Tip warning={true}>

        NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
        PIL images.

        </Tip>

        Args:
            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
                tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
                number of channels, H and W are image height and width.

            return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
                If set, will return tensors of a particular framework. Acceptable values are:

                - `'tf'`: Return TensorFlow `tf.constant` objects.
                - `'pt'`: Return PyTorch `torch.Tensor` objects.
                - `'np'`: Return NumPy `np.ndarray` objects.
                - `'jax'`: Return JAX `jnp.ndarray` objects.

        Returns:
            [`BatchFeature`]: A [`BatchFeature`] with the following fields:

            - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
              width).
        """
        valid_images = False
        if isinstance(images, (Image.Image, np.ndarray)) or is_torch_tensor(
            images):
            valid_images = True
        elif isinstance(images, (list, tuple)):
            if len(images) == 0 or isinstance(images[0], (Image.Image, np.
                ndarray)) or is_torch_tensor(images[0]):
                valid_images = True
        if not valid_images:
            raise ValueError(
                'Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), `List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples).'
                )
        is_batched = bool(isinstance(images, (list, tuple)) and (isinstance
            (images[0], (Image.Image, np.ndarray)) or is_torch_tensor(
            images[0])))
        if not is_batched:
            images = [images]
        if self.do_resize and self.size_divisor is not None:
            images = [self._resize(image=image, size_divisor=self.
                size_divisor, resample=self.resample) for image in images]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]
        data = {'pixel_values': images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)
        return encoded_inputs

# coding=utf-8
# Copyright 2022 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Feature extractor class for GLPN."""

from typing import Optional, Union

import numpy as np
from PIL import Image

from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from ...image_utils import ImageFeatureExtractionMixin, ImageInput, is_torch_tensor
from ...utils import TensorType, logging


logger = logging.get_logger(__name__)


class GLPNFeatureExtractor(FeatureExtractionMixin, ImageFeatureExtractionMixin):
    r"""
    Constructs a GLPN feature extractor.

    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 based on certain `size_divisor`.
        size_divisor (`int` or `Tuple(int)`, *optional*, defaults to 32):
            Make sure the input is divisible by this value. Only has an effect if `do_resize` is set to `True`.
        resample (`int`, *optional*, defaults to `PIL.Image.BILINEAR`):
            An optional resampling filter. This can be one of `PIL.Image.NEAREST`, `PIL.Image.BOX`,
            `PIL.Image.BILINEAR`, `PIL.Image.HAMMING`, `PIL.Image.BICUBIC` or `PIL.Image.LANCZOS`. Only has an effect
            if `do_resize` is set to `True`.
        do_rescale (`bool`, *optional*, defaults to `True`):
             Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.).
    """

    model_input_names = ["pixel_values"]

    def __init__(self, do_resize=True, size_divisor=32, resample=Image.BILINEAR, do_rescale=True, **kwargs):
        super().__init__(**kwargs)
        self.do_resize = do_resize
        self.size_divisor = size_divisor
        self.resample = resample
        self.do_rescale = do_rescale

    def _resize(self, image, size_divisor, resample):
        if not isinstance(image, Image.Image):
            image = self.to_pil_image(image)

        width, height = image.size
        new_h, new_w = height // size_divisor * size_divisor, width // size_divisor * size_divisor

        image = self.resize(image, size=(new_w, new_h), resample=resample)

        return image

    def __call__(
        self, images: ImageInput, return_tensors: Optional[Union[str, TensorType]] = None, **kwargs
    ) -> BatchFeature:
        """
        Main method to prepare for the model one or several image(s).

        <Tip warning={true}>

        NumPy arrays and PyTorch tensors are converted to PIL images when resizing, so the most efficient is to pass
        PIL images.

        </Tip>

        Args:
            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
                tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
                number of channels, H and W are image height and width.

            return_tensors (`str` or [`~utils.TensorType`], *optional*, defaults to `'np'`):
                If set, will return tensors of a particular framework. Acceptable values are:

                - `'tf'`: Return TensorFlow `tf.constant` objects.
                - `'pt'`: Return PyTorch `torch.Tensor` objects.
                - `'np'`: Return NumPy `np.ndarray` objects.
                - `'jax'`: Return JAX `jnp.ndarray` objects.

        Returns:
            [`BatchFeature`]: A [`BatchFeature`] with the following fields:

            - **pixel_values** -- Pixel values to be fed to a model, of shape (batch_size, num_channels, height,
              width).
        """
        # Input type checking for clearer error
        valid_images = False

        # Check that images has a valid type
        if isinstance(images, (Image.Image, np.ndarray)) or is_torch_tensor(images):
            valid_images = True
        elif isinstance(images, (list, tuple)):
            if len(images) == 0 or isinstance(images[0], (Image.Image, np.ndarray)) or is_torch_tensor(images[0]):
                valid_images = True

        if not valid_images:
            raise ValueError(
                "Images must of type `PIL.Image.Image`, `np.ndarray` or `torch.Tensor` (single example), "
                "`List[PIL.Image.Image]`, `List[np.ndarray]` or `List[torch.Tensor]` (batch of examples)."
            )

        is_batched = bool(
            isinstance(images, (list, tuple))
            and (isinstance(images[0], (Image.Image, np.ndarray)) or is_torch_tensor(images[0]))
        )

        if not is_batched:
            images = [images]

        # transformations (resizing + rescaling)
        if self.do_resize and self.size_divisor is not None:
            images = [
                self._resize(image=image, size_divisor=self.size_divisor, resample=self.resample) for image in images
            ]
        if self.do_rescale:
            images = [self.to_numpy_array(image=image) for image in images]

        # return as BatchFeature
        data = {"pixel_values": images}
        encoded_inputs = BatchFeature(data=data, tensor_type=return_tensors)

        return encoded_inputs
