



"""simple docstring"""







from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
							import PIL

lowerCAmelCase_   						=   logging.get_logger(__name__)



def      __UpperCAmelCase      (    __lowerCamelCase	)							->      List[List[ImageInput]]:
		if isinstance(__lowerCamelCase						,     (list, tuple)	) and isinstance(videos[0]						,     (list, tuple)	) and is_valid_image(videos[0][0]	):
				return videos

		elif isinstance(__lowerCamelCase						,     (list, tuple)	) and is_valid_image(videos[0]	):
				return [videos]

		elif is_valid_image(__lowerCamelCase	):
				return [[videos]]

		raise ValueError(f"""Could not make batched video from {videos}"""	)





class        __A       (	A_    ):







		'''simple docstring'''





		lowerCAmelCase			:					str   	=				["pixel_values"]







		def __init__(	self						:  List[Any]			,_snake_case						:  bool = True			,_snake_case						:  Dict[str, int] = None			,_snake_case						:  PILImageResampling = PILImageResampling.BILINEAR			,_snake_case						:  bool = True			,_snake_case						:  Dict[str, int] = None			,_snake_case						:  bool = True			,_snake_case						:  Union[int, float] = 1 / 255			,_snake_case						:  bool = True			,_snake_case						:  bool = True			,_snake_case						:  Optional[Union[float, List[float]]] = None			,_snake_case						:  Optional[Union[float, List[float]]] = None			,**_snake_case						:  List[str]			,)					->		None:






				"""simple docstring"""



				super().__init__(**_snake_case						)
				lowercase__   :    int				=			size if size is not None else {'''shortest_edge''': 256}
				lowercase__   :    Union[str, Any]				=			get_size_dict(_snake_case			,default_to_square=_snake_case						)
				lowercase__   :    List[str]				=			crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
				lowercase__   :    Optional[Any]				=			get_size_dict(_snake_case			,param_name='''crop_size'''						)

				lowercase__   :    List[Any]				=			do_resize
				lowercase__   :    Optional[int]				=			size
				lowercase__   :    Union[str, Any]				=			do_center_crop
				lowercase__   :    int				=			crop_size
				lowercase__   :    List[str]				=			resample
				lowercase__   :    int				=			do_rescale
				lowercase__   :    Tuple				=			rescale_factor
				lowercase__   :    List[Any]				=			offset
				lowercase__   :    Optional[int]				=			do_normalize
				lowercase__   :    List[Any]				=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
				lowercase__   :    Union[str, Any]				=			image_std if image_std is not None else IMAGENET_STANDARD_STD







		def 					UpperCAmelCase    (	self						:  Optional[int]			,_snake_case						:  np.ndarray			,_snake_case						:  Dict[str, int]			,_snake_case						:  PILImageResampling = PILImageResampling.BILINEAR			,_snake_case						:  Optional[Union[str, ChannelDimension]] = None			,**_snake_case						:  List[str]			,)					->		np.ndarray:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			get_size_dict(_snake_case			,default_to_square=_snake_case						)
				if "shortest_edge" in size:
						lowercase__   :    Optional[int]				=			get_resize_output_image_size(_snake_case			,size['''shortest_edge''']			,default_to_square=_snake_case						)
				elif "height" in size and "width" in size:
						lowercase__   :    Optional[Any]				=			(size['''height'''], size['''width'''])
				else:
						raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"""						)
				return resize(_snake_case			,size=_snake_case			,resample=_snake_case			,data_format=_snake_case			,**_snake_case						)







		def 					UpperCAmelCase    (	self						:  List[Any]			,_snake_case						:  np.ndarray			,_snake_case						:  Dict[str, int]			,_snake_case						:  Optional[Union[str, ChannelDimension]] = None			,**_snake_case						:  Union[str, Any]			,)					->		np.ndarray:






				"""simple docstring"""



				lowercase__   :    Dict				=			get_size_dict(_snake_case						)
				if "height" not in size or "width" not in size:
						raise ValueError(f"""Size must have 'height' and 'width' as keys. Got {size.keys()}"""						)
				return center_crop(_snake_case			,size=(size['''height'''], size['''width'''])			,data_format=_snake_case			,**_snake_case						)







		def 					UpperCAmelCase    (	self						:  List[str]			,_snake_case						:  np.ndarray			,_snake_case						:  Union[int, float]			,_snake_case						:  bool = True			,_snake_case						:  Optional[Union[str, ChannelDimension]] = None			,**_snake_case						:  Tuple			,)					->		Any:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			image.astype(np.floataa						)
				if offset:
						lowercase__   :    List[str]				=			image - (scale / 2)
				return rescale(_snake_case			,scale=_snake_case			,data_format=_snake_case			,**_snake_case						)







		def 					UpperCAmelCase    (	self						:  List[str]			,_snake_case						:  np.ndarray			,_snake_case						:  Union[float, List[float]]			,_snake_case						:  Union[float, List[float]]			,_snake_case						:  Optional[Union[str, ChannelDimension]] = None			,**_snake_case						:  Tuple			,)					->		np.ndarray:






				"""simple docstring"""



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







		def 					UpperCAmelCase    (	self						:  Union[str, Any]			,_snake_case						:  ImageInput			,_snake_case						:  bool = None			,_snake_case						:  Dict[str, int] = None			,_snake_case						:  PILImageResampling = None			,_snake_case						:  bool = None			,_snake_case						:  Dict[str, int] = None			,_snake_case						:  bool = None			,_snake_case						:  float = None			,_snake_case						:  bool = None			,_snake_case						:  bool = None			,_snake_case						:  Optional[Union[float, List[float]]] = None			,_snake_case						:  Optional[Union[float, List[float]]] = None			,_snake_case						:  Optional[ChannelDimension] = ChannelDimension.FIRST			,)					->		np.ndarray:






				"""simple docstring"""



				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_center_crop and crop_size is None:
						raise ValueError('''Crop size must be specified if do_center_crop 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.'''						)

				if offset and not do_rescale:
						raise ValueError('''For offset, do_rescale must also be set to True.'''						)

				# All transformations expect numpy arrays.
				lowercase__   :    Dict				=			to_numpy_array(_snake_case						)

				if do_resize:
						lowercase__   :    Union[str, Any]				=			self.resize(image=_snake_case			,size=_snake_case			,resample=_snake_case						)

				if do_center_crop:
						lowercase__   :    Optional[Any]				=			self.center_crop(_snake_case			,size=_snake_case						)

				if do_rescale:
						lowercase__   :    List[Any]				=			self.rescale(image=_snake_case			,scale=_snake_case			,offset=_snake_case						)

				if do_normalize:
						lowercase__   :    List[Any]				=			self.normalize(image=_snake_case			,mean=_snake_case			,std=_snake_case						)

				lowercase__   :    List[str]				=			to_channel_dimension_format(_snake_case			,_snake_case						)
				return image







		def 					UpperCAmelCase    (	self						:  List[Any]			,_snake_case						:  ImageInput			,_snake_case						:  bool = None			,_snake_case						:  Dict[str, int] = None			,_snake_case						:  PILImageResampling = None			,_snake_case						:  bool = None			,_snake_case						:  Dict[str, int] = None			,_snake_case						:  bool = None			,_snake_case						:  float = None			,_snake_case						:  bool = None			,_snake_case						:  bool = None			,_snake_case						:  Optional[Union[float, List[float]]] = None			,_snake_case						:  Optional[Union[float, List[float]]] = None			,_snake_case						:  Optional[Union[str, TensorType]] = None			,_snake_case						:  ChannelDimension = ChannelDimension.FIRST			,**_snake_case						:  Dict			,)					->		PIL.Image.Image:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			do_resize if do_resize is not None else self.do_resize
				lowercase__   :    int				=			resample if resample is not None else self.resample
				lowercase__   :    List[Any]				=			do_center_crop if do_center_crop is not None else self.do_center_crop
				lowercase__   :    str				=			do_rescale if do_rescale is not None else self.do_rescale
				lowercase__   :    int				=			rescale_factor if rescale_factor is not None else self.rescale_factor
				lowercase__   :    Optional[Any]				=			offset if offset is not None else self.offset
				lowercase__   :    Optional[Any]				=			do_normalize if do_normalize is not None else self.do_normalize
				lowercase__   :    Any				=			image_mean if image_mean is not None else self.image_mean
				lowercase__   :    List[str]				=			image_std if image_std is not None else self.image_std

				lowercase__   :    Union[str, Any]				=			size if size is not None else self.size
				lowercase__   :    Union[str, Any]				=			get_size_dict(_snake_case			,default_to_square=_snake_case						)
				lowercase__   :    Tuple				=			crop_size if crop_size is not None else self.crop_size
				lowercase__   :    Union[str, Any]				=			get_size_dict(_snake_case			,param_name='''crop_size'''						)

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

				lowercase__   :    Any				=			make_batched(_snake_case						)

				lowercase__   :    Optional[int]				=			[
				    [
				        self._preprocess_image(
				            image=_snake_case			,do_resize=_snake_case			,size=_snake_case			,resample=_snake_case			,do_center_crop=_snake_case			,crop_size=_snake_case			,do_rescale=_snake_case			,rescale_factor=_snake_case			,offset=_snake_case			,do_normalize=_snake_case			,image_mean=_snake_case			,image_std=_snake_case			,data_format=_snake_case			,)
				        for img in video
				    ]
				    for video in videos
				]

				lowercase__   :    Dict				=			{'''pixel_values''': videos}
				return BatchFeature(data=_snake_case			,tensor_type=_snake_case						)





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


_snake_case		=  logging.get_logger(__name__)






def 				A				(					_lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase  ):





							'''simple docstring'''




							def constraint_to_multiple_of(_lowerCamelCase				, _lowerCamelCase				, _lowerCamelCase=0				, _lowerCamelCase=None  ):
														_lowerCAmelCase     :							Tuple    =    round(val / multiple  ) * multiple

														if max_val is not None and x > max_val:
																					_lowerCAmelCase     :							Optional[int]    =    math.floor(val / multiple  ) * multiple

														if x < min_val:
																					_lowerCAmelCase     :							List[str]    =    math.ceil(val / multiple  ) * multiple

														return x

							_lowerCAmelCase     :							Union[str, Any]    =    (output_size, output_size) if isinstance(_lowerCamelCase				, _lowerCamelCase  ) else output_size

							_lowerCAmelCase   ,    _lowerCAmelCase     :							Optional[Any]    =    get_image_size(_lowerCamelCase  )
							_lowerCAmelCase   ,    _lowerCAmelCase     :							Any    =    output_size

							# determine new height and width
							_lowerCAmelCase     :							List[Any]    =    output_height / input_height
							_lowerCAmelCase     :							Any    =    output_width / input_width

							if keep_aspect_ratio:
														# scale as little as possible
														if abs(1 - scale_width  ) < abs(1 - scale_height  ):
																					# fit width
																					_lowerCAmelCase     :							Union[str, Any]    =    scale_width
														else:
																					# fit height
																					_lowerCAmelCase     :							Union[str, Any]    =    scale_height

							_lowerCAmelCase     :							List[str]    =    constraint_to_multiple_of(scale_height * input_height				, multiple=_lowerCamelCase  )
							_lowerCAmelCase     :							Dict    =    constraint_to_multiple_of(scale_width * input_width				, multiple=_lowerCamelCase  )

							return (new_height, new_width)



class   UpperCAmelCase_    (       a):
							lowerCamelCase__   			=		['pixel_values']







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

														'''simple docstring'''

														super().__init__(**__a)
														_lowerCAmelCase     :							Any    =    size if size is not None else {"height": 384, "width": 384}
														_lowerCAmelCase     :							Optional[int]    =    get_size_dict(__a)
														_lowerCAmelCase     :							Optional[Any]    =    do_resize
														_lowerCAmelCase     :							Dict    =    size
														_lowerCAmelCase     :							Any    =    keep_aspect_ratio
														_lowerCAmelCase     :							str    =    ensure_multiple_of
														_lowerCAmelCase     :							str    =    resample
														_lowerCAmelCase     :							Dict    =    do_rescale
														_lowerCAmelCase     :							Optional[int]    =    rescale_factor
														_lowerCAmelCase     :							Dict    =    do_normalize
														_lowerCAmelCase     :							Dict    =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
														_lowerCAmelCase     :							int    =    image_std if image_std is not None else IMAGENET_STANDARD_STD







							def    snake_case__      (   self,			__a,			__a,			__a = False,			__a = 1,			__a = PILImageResampling.BICUBIC,			__a = None,			**__a,			):

														'''simple docstring'''

														_lowerCAmelCase     :							List[Any]    =    get_size_dict(__a)
														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()}")
														_lowerCAmelCase     :							List[Any]    =    get_resize_output_image_size(
														    __a,			output_size=(size["height"], size["width"]),			keep_aspect_ratio=__a,			multiple=__a,			)
														return resize(__a,			size=__a,			resample=__a,			data_format=__a,			**__a)







							def    snake_case__      (   self,			__a,			__a,			__a = None,			**__a,			):

														'''simple docstring'''

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







							def    snake_case__      (   self,			__a,			__a,			__a,			__a = None,			**__a,			):

														'''simple docstring'''

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







							def    snake_case__      (   self,			__a,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = None,			__a = ChannelDimension.FIRST,			**__a,			):

														'''simple docstring'''

														_lowerCAmelCase     :							int    =    do_resize if do_resize is not None else self.do_resize
														_lowerCAmelCase     :							List[Any]    =    size if size is not None else self.size
														_lowerCAmelCase     :							str    =    get_size_dict(__a)
														_lowerCAmelCase     :							Dict    =    keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
														_lowerCAmelCase     :							Any    =    ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
														_lowerCAmelCase     :							int    =    resample if resample is not None else self.resample
														_lowerCAmelCase     :							Union[str, Any]    =    do_rescale if do_rescale is not None else self.do_rescale
														_lowerCAmelCase     :							Tuple    =    rescale_factor if rescale_factor is not None else self.rescale_factor
														_lowerCAmelCase     :							List[str]    =    do_normalize if do_normalize is not None else self.do_normalize
														_lowerCAmelCase     :							Dict    =    image_mean if image_mean is not None else self.image_mean
														_lowerCAmelCase     :							List[str]    =    image_std if image_std is not None else self.image_std

														_lowerCAmelCase     :							Optional[Any]    =    make_list_of_images(__a)

														if not valid_images(__a):
																					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.
														_lowerCAmelCase     :							List[Any]    =    [to_numpy_array(__a) for image in images]

														if do_resize:
																					_lowerCAmelCase     :							Any    =    [self.resize(image=__a,			size=__a,			resample=__a) for image in images]

														if do_rescale:
																					_lowerCAmelCase     :							List[str]    =    [self.rescale(image=__a,			scale=__a) for image in images]

														if do_normalize:
																					_lowerCAmelCase     :							Dict    =    [self.normalize(image=__a,			mean=__a,			std=__a) for image in images]

														_lowerCAmelCase     :							List[str]    =    [to_channel_dimension_format(__a,			__a) for image in images]

														_lowerCAmelCase     :							Optional[Any]    =    {"pixel_values": images}
														return BatchFeature(data=__a,			tensor_type=__a)







							def    snake_case__      (   self,			__a,			__a = None):

														'''simple docstring'''

														_lowerCAmelCase     :							Optional[Any]    =    outputs.logits

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

																					if is_torch_tensor(__a):
																												_lowerCAmelCase     :							List[Any]    =    target_sizes.numpy()

																					_lowerCAmelCase     :							Dict    =    []

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

														return semantic_segmentation
