




"""simple docstring"""




import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import DonutImageProcessor






class     __magic_name__							(       unittest.TestCase				):






				'''simple docstring'''





				def __init__(       self		, _a		, _a=7		, _a=3		, _a=18		, _a=30		, _a=400		, _a=True		, _a=None		, _a=True		, _a=False		, _a=True		, _a=True		, _a=[0.5, 0.5, 0.5]		, _a=[0.5, 0.5, 0.5]		, ):





							"""simple docstring"""
							lowerCamelCase			      =					parent
							lowerCamelCase			      =					batch_size
							lowerCamelCase			      =					num_channels
							lowerCamelCase			      =					image_size
							lowerCamelCase			      =					min_resolution
							lowerCamelCase			      =					max_resolution
							lowerCamelCase			      =					do_resize
							lowerCamelCase			      =					size if size is not None else {"""height""": 18, """width""": 20}
							lowerCamelCase			      =					do_thumbnail
							lowerCamelCase			      =					do_align_axis
							lowerCamelCase			      =					do_pad
							lowerCamelCase			      =					do_normalize
							lowerCamelCase			      =					image_mean
							lowerCamelCase			      =					image_std





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							return {
							    "do_resize": self.do_resize,
							    "size": self.size,
							    "do_thumbnail": self.do_thumbnail,
							    "do_align_long_axis": self.do_align_axis,
							    "do_pad": self.do_pad,
							    "do_normalize": self.do_normalize,
							    "image_mean": self.image_mean,
							    "image_std": self.image_std,
							}






@require_torch
@require_vision
class     __magic_name__							(       UpperCAmelCase__						,					unittest.TestCase				):






				'''simple docstring'''
				__UpperCamelCase			  =						DonutImageProcessor if is_vision_available() else None





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					DonutImageProcessingTester(self )





				@property
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							return self.image_processor_tester.prepare_image_processor_dict()





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.image_processing_class(**self.image_processor_dict )
							self.assertTrue(hasattr(_a		, """do_resize""" ) )
							self.assertTrue(hasattr(_a		, """size""" ) )
							self.assertTrue(hasattr(_a		, """do_thumbnail""" ) )
							self.assertTrue(hasattr(_a		, """do_align_long_axis""" ) )
							self.assertTrue(hasattr(_a		, """do_pad""" ) )
							self.assertTrue(hasattr(_a		, """do_normalize""" ) )
							self.assertTrue(hasattr(_a		, """image_mean""" ) )
							self.assertTrue(hasattr(_a		, """image_std""" ) )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							lowerCamelCase			      =					self.image_processing_class.from_dict(self.image_processor_dict )
							self.assertEqual(image_processor.size		, {"""height""": 18, """width""": 20} )

							lowerCamelCase			      =					self.image_processing_class.from_dict(self.image_processor_dict		, size=42 )
							self.assertEqual(image_processor.size		, {"""height""": 42, """width""": 42} )

							# Previous config had dimensions in (width, height) order
							lowerCamelCase			      =					self.image_processing_class.from_dict(self.image_processor_dict		, size=(42, 84) )
							self.assertEqual(image_processor.size		, {"""height""": 84, """width""": 42} )





				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							pass





				@is_flaky()
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							# Initialize image_processing
							lowerCamelCase			      =					self.image_processing_class(**self.image_processor_dict )
							# create random PIL images
							lowerCamelCase			      =					prepare_image_inputs(self.image_processor_tester		, equal_resolution=_a )
							for image in image_inputs:
										self.assertIsInstance(_a		, Image.Image )

							# Test not batched input
							lowerCamelCase			      =					image_processing(image_inputs[0]		, return_tensors="""pt""" ).pixel_values
							self.assertEqual(
							    encoded_images.shape		, (
							        1,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.size["""height"""],
							        self.image_processor_tester.size["""width"""],
							    )		, )

							# Test batched
							lowerCamelCase			      =					image_processing(_a		, return_tensors="""pt""" ).pixel_values
							self.assertEqual(
							    encoded_images.shape		, (
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.size["""height"""],
							        self.image_processor_tester.size["""width"""],
							    )		, )





				@is_flaky()
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							# Initialize image_processing
							lowerCamelCase			      =					self.image_processing_class(**self.image_processor_dict )
							# create random numpy tensors
							lowerCamelCase			      =					prepare_image_inputs(self.image_processor_tester		, equal_resolution=_a		, numpify=_a )
							for image in image_inputs:
										self.assertIsInstance(_a		, np.ndarray )

							# Test not batched input
							lowerCamelCase			      =					image_processing(image_inputs[0]		, return_tensors="""pt""" ).pixel_values
							self.assertEqual(
							    encoded_images.shape		, (
							        1,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.size["""height"""],
							        self.image_processor_tester.size["""width"""],
							    )		, )

							# Test batched
							lowerCamelCase			      =					image_processing(_a		, return_tensors="""pt""" ).pixel_values
							self.assertEqual(
							    encoded_images.shape		, (
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.size["""height"""],
							        self.image_processor_tester.size["""width"""],
							    )		, )





				@is_flaky()
				def    _lowerCAmelCase				(       self ):





							"""simple docstring"""
							# Initialize image_processing
							lowerCamelCase			      =					self.image_processing_class(**self.image_processor_dict )
							# create random PyTorch tensors
							lowerCamelCase			      =					prepare_image_inputs(self.image_processor_tester		, equal_resolution=_a		, torchify=_a )
							for image in image_inputs:
										self.assertIsInstance(_a		, torch.Tensor )

							# Test not batched input
							lowerCamelCase			      =					image_processing(image_inputs[0]		, return_tensors="""pt""" ).pixel_values
							self.assertEqual(
							    encoded_images.shape		, (
							        1,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.size["""height"""],
							        self.image_processor_tester.size["""width"""],
							    )		, )

							# Test batched
							lowerCamelCase			      =					image_processing(_a		, return_tensors="""pt""" ).pixel_values
							self.assertEqual(
							    encoded_images.shape		, (
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        self.image_processor_tester.size["""height"""],
							        self.image_processor_tester.size["""width"""],
							    )		, )









"""simple docstring"""




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

import numpy as np

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,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
					import torch


lowerCAmelCase							:			int     							=							logging.get_logger(__name__)






class     __magic_name__							(       UpperCAmelCase__				):






				'''simple docstring'''
				__UpperCamelCase			  =						["pixel_values"]





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





							"""simple docstring"""
							super().__init__(**_a )
							lowerCamelCase			      =					size if size is not None else {"""shortest_edge""": 256}
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							lowerCamelCase			      =					crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
							lowerCamelCase			      =					get_size_dict(_a		, param_name="""crop_size""" )
							lowerCamelCase			      =					do_resize
							lowerCamelCase			      =					size
							lowerCamelCase			      =					resample
							lowerCamelCase			      =					do_center_crop
							lowerCamelCase			      =					crop_size
							lowerCamelCase			      =					do_rescale
							lowerCamelCase			      =					rescale_factor
							lowerCamelCase			      =					do_normalize
							lowerCamelCase			      =					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
							lowerCamelCase			      =					image_std if image_std is not None else IMAGENET_STANDARD_STD





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = PILImageResampling.BICUBIC		, _a = None		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							if "shortest_edge" not in size:
										raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}' )
							lowerCamelCase			      =					get_resize_output_image_size(_a		, size=size["""shortest_edge"""]		, default_to_square=_a )
							return resize(_a		, size=_a		, resample=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = None		, **_a		, ):





							"""simple docstring"""
							lowerCamelCase			      =					get_size_dict(_a )
							if "height" not in size or "width" not in size:
										raise ValueError(f'The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}' )
							return center_crop(_a		, size=(size["""height"""], size["""width"""])		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a = None		, **_a ):





							"""simple docstring"""
							return rescale(_a		, scale=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       self		, _a		, _a		, _a		, _a = None		, **_a		, ):





							"""simple docstring"""
							return normalize(_a		, mean=_a		, std=_a		, data_format=_a		, **_a )





				def    _lowerCAmelCase				(       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			      =					do_resize if do_resize is not None else self.do_resize
							lowerCamelCase			      =					size if size is not None else self.size
							lowerCamelCase			      =					get_size_dict(_a		, default_to_square=_a )
							lowerCamelCase			      =					resample if resample is not None else self.resample
							lowerCamelCase			      =					do_center_crop if do_center_crop is not None else self.do_center_crop
							lowerCamelCase			      =					crop_size if crop_size is not None else self.crop_size
							lowerCamelCase			      =					get_size_dict(_a		, param_name="""crop_size""" )
							lowerCamelCase			      =					do_rescale if do_rescale is not None else self.do_rescale
							lowerCamelCase			      =					rescale_factor if rescale_factor is not None else self.rescale_factor
							lowerCamelCase			      =					do_normalize if do_normalize is not None else self.do_normalize
							lowerCamelCase			      =					image_mean if image_mean is not None else self.image_mean
							lowerCamelCase			      =					image_std if image_std is not None else self.image_std

							lowerCamelCase			      =					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:
										raise ValueError("""Size 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.""" )

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

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

							if do_center_crop:
										lowerCamelCase			      =					[self.center_crop(image=_a		, size=_a ) for image in images]

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

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

							lowerCamelCase			      =					[to_channel_dimension_format(_a		, _a ) for image in images]

							lowerCamelCase			      =					{"""pixel_values""": images}
							return BatchFeature(data=_a		, tensor_type=_a )





				def    _lowerCAmelCase				(       self		, _a		, _a = None ):





							"""simple docstring"""
							lowerCamelCase			      =					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			      =					target_sizes.numpy()

										lowerCamelCase			      =					[]

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

							return semantic_segmentation



