






'''simple docstring'''

import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
     import torch

if is_vision_available():
     import PIL


SCREAMING_SNAKE_CASE__											=     logging.get_logger(__name__)







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)->				Tuple[int, int]:
      def constraint_to_multiple_of(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase=0	,		__UpperCamelCase=None					):
            UpperCamelCase       						=      round(val / multiple					) * multiple

            if max_val is not None and x > max_val:
                  UpperCamelCase       						=      math.floor(val / multiple					) * multiple

            if x < min_val:
                  UpperCamelCase       						=      math.ceil(val / multiple					) * multiple

            return x

      UpperCamelCase       						=      (output_size, output_size) if isinstance(__UpperCamelCase	,		__UpperCamelCase					) else output_size

      UpperCamelCase						,UpperCamelCase       						=      get_image_size(__UpperCamelCase					)
      UpperCamelCase						,UpperCamelCase       						=      output_size

      # determine new height and width
      UpperCamelCase       						=      output_height / input_height
      UpperCamelCase       						=      output_width / input_width

      if keep_aspect_ratio:
            # scale as little as possible
            if abs(1 - scale_width					) < abs(1 - scale_height					):
                  # fit width
                  UpperCamelCase       						=      scale_width
            else:
                  # fit height
                  UpperCamelCase       						=      scale_height

      UpperCamelCase       						=      constraint_to_multiple_of(scale_height * input_height	,		multiple=__UpperCamelCase					)
      UpperCamelCase       						=      constraint_to_multiple_of(scale_width * input_width	,		multiple=__UpperCamelCase					)

      return (new_height, new_width)






class        a_		(    lowerCamelCase       ):
  lowercase  	=   ["""pixel_values"""]

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR    ,	_SCREAMING_SNAKE_CASE = False    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = 1 / 255    ,	_SCREAMING_SNAKE_CASE = True    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   None:



        """simple docstring"""






        super().__init__(**_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      size if size is not None else {"""height""": 384, """width""": 384}
        UpperCamelCase       						=      get_size_dict(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      do_resize
        UpperCamelCase       						=      size
        UpperCamelCase       						=      keep_aspect_ratio
        UpperCamelCase       						=      ensure_multiple_of
        UpperCamelCase       						=      resample
        UpperCamelCase       						=      do_rescale
        UpperCamelCase       						=      rescale_factor
        UpperCamelCase       						=      do_normalize
        UpperCamelCase       						=      image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        UpperCamelCase       						=      image_std if image_std is not None else IMAGENET_STANDARD_STD

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = False    ,	_SCREAMING_SNAKE_CASE = 1    ,	_SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC    ,	_SCREAMING_SNAKE_CASE = None    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   np.ndarray:



        """simple docstring"""






        UpperCamelCase       						=      get_size_dict(_SCREAMING_SNAKE_CASE   )
        if "height" not in size or "width" not in size:
              raise ValueError(F"The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}"   )
        UpperCamelCase       						=      get_resize_output_image_size(
            _SCREAMING_SNAKE_CASE    ,	output_size=(size["""height"""], size["""width"""])    ,	keep_aspect_ratio=_SCREAMING_SNAKE_CASE    ,	multiple=_SCREAMING_SNAKE_CASE    ,	)
        return resize(_SCREAMING_SNAKE_CASE    ,	size=_SCREAMING_SNAKE_CASE    ,	resample=_SCREAMING_SNAKE_CASE    ,	data_format=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = None    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   Optional[Any]:



        """simple docstring"""






        return rescale(_SCREAMING_SNAKE_CASE    ,	scale=_SCREAMING_SNAKE_CASE    ,	data_format=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = None    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   np.ndarray:



        """simple docstring"""






        return normalize(_SCREAMING_SNAKE_CASE    ,	mean=_SCREAMING_SNAKE_CASE    ,	std=_SCREAMING_SNAKE_CASE    ,	data_format=_SCREAMING_SNAKE_CASE    ,	**_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = None    ,	_SCREAMING_SNAKE_CASE = ChannelDimension.FIRST    ,	**_SCREAMING_SNAKE_CASE    ,	)						->   PIL.Image.Image:



        """simple docstring"""






        UpperCamelCase       						=      do_resize if do_resize is not None else self.do_resize
        UpperCamelCase       						=      size if size is not None else self.size
        UpperCamelCase       						=      get_size_dict(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
        UpperCamelCase       						=      ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
        UpperCamelCase       						=      resample if resample is not None else self.resample
        UpperCamelCase       						=      do_rescale if do_rescale is not None else self.do_rescale
        UpperCamelCase       						=      rescale_factor if rescale_factor is not None else self.rescale_factor
        UpperCamelCase       						=      do_normalize if do_normalize is not None else self.do_normalize
        UpperCamelCase       						=      image_mean if image_mean is not None else self.image_mean
        UpperCamelCase       						=      image_std if image_std is not None else self.image_std

        UpperCamelCase       						=      make_list_of_images(_SCREAMING_SNAKE_CASE   )

        if not valid_images(_SCREAMING_SNAKE_CASE   ):
              raise ValueError(
                  """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                  """torch.Tensor, tf.Tensor or jax.ndarray."""   )

        if do_resize and size is None or resample is None:
              raise ValueError("""Size and resample must be specified if do_resize is True."""   )

        if do_rescale and rescale_factor is None:
              raise ValueError("""Rescale factor must be specified if do_rescale is True."""   )

        if do_normalize and (image_mean is None or image_std is None):
              raise ValueError("""Image mean and std must be specified if do_normalize is True."""   )

        # All transformations expect numpy arrays.
        UpperCamelCase       						=      [to_numpy_array(_SCREAMING_SNAKE_CASE   ) for image in images]

        if do_resize:
              UpperCamelCase       						=      [self.resize(image=_SCREAMING_SNAKE_CASE    ,	size=_SCREAMING_SNAKE_CASE    ,	resample=_SCREAMING_SNAKE_CASE   ) for image in images]

        if do_rescale:
              UpperCamelCase       						=      [self.rescale(image=_SCREAMING_SNAKE_CASE    ,	scale=_SCREAMING_SNAKE_CASE   ) for image in images]

        if do_normalize:
              UpperCamelCase       						=      [self.normalize(image=_SCREAMING_SNAKE_CASE    ,	mean=_SCREAMING_SNAKE_CASE    ,	std=_SCREAMING_SNAKE_CASE   ) for image in images]

        UpperCamelCase       						=      [to_channel_dimension_format(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ) for image in images]

        UpperCamelCase       						=      {"""pixel_values""": images}
        return BatchFeature(data=_SCREAMING_SNAKE_CASE    ,	tensor_type=_SCREAMING_SNAKE_CASE   )


  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE = None   )						->   Union[str, Any]:



        """simple docstring"""






        UpperCamelCase       						=      outputs.logits

        # Resize logits and compute semantic segmentation maps
        if target_sizes is not None:
              if len(_SCREAMING_SNAKE_CASE   ) != len(_SCREAMING_SNAKE_CASE   ):
                    raise ValueError(
                        """Make sure that you pass in as many target sizes as the batch dimension of the logits"""   )

              if is_torch_tensor(_SCREAMING_SNAKE_CASE   ):
                    UpperCamelCase       						=      target_sizes.numpy()

              UpperCamelCase       						=      []

              for idx in range(len(_SCREAMING_SNAKE_CASE   )   ):
                    UpperCamelCase       						=      torch.nn.functional.interpolate(
                        logits[idx].unsqueeze(dim=0   )    ,	size=target_sizes[idx]    ,	mode="""bilinear"""    ,	align_corners=_SCREAMING_SNAKE_CASE   )
                    UpperCamelCase       						=      resized_logits[0].argmax(dim=0   )
                    semantic_segmentation.append(_SCREAMING_SNAKE_CASE   )
        else:
              UpperCamelCase       						=      logits.argmax(dim=1   )
              UpperCamelCase       						=      [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]   )]

        return semantic_segmentation








'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import _LazyModule


SCREAMING_SNAKE_CASE__											=     {'tokenization_wav2vec2_phoneme': ['Wav2Vec2PhonemeCTCTokenizer']}


if TYPE_CHECKING:
     from .tokenization_wavaveca_phoneme import WavaVecaPhonemeCTCTokenizer
else:
     import sys

     SCREAMING_SNAKE_CASE__											=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
