
"""simple docstring"""







from typing import Dict, List, Optional, Union

import numpy as np

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


SCREAMING_SNAKE_CASE_  					= logging.get_logger(__name__)


if is_vision_available():
  import PIL






class      __a      (       lowerCAmelCase_      ):
       _lowerCamelCase				:				Union[str, Any]   			=      ['pixel_values']







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



          '''simple docstring'''

          super().__init__(**lowerCamelCase_		)

          _UpperCAmelCase 						=       size if size is not None else {"height": 2560, "width": 1920}
          if isinstance(lowerCamelCase_				,(tuple, list)		):
             # The previous feature extractor size parameter was in (width, height) format
             _UpperCAmelCase 						=       size[::-1]
          _UpperCAmelCase 						=       get_size_dict(lowerCamelCase_		)

          _UpperCAmelCase 						=       do_resize
          _UpperCAmelCase 						=       size
          _UpperCAmelCase 						=       resample
          _UpperCAmelCase 						=       do_thumbnail
          _UpperCAmelCase 						=       do_align_long_axis
          _UpperCAmelCase 						=       do_pad
          _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  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_ = None		):



          '''simple docstring'''

          _UpperCAmelCase						,				_UpperCAmelCase 						=       get_image_size(lowerCamelCase_		)
          _UpperCAmelCase						,				_UpperCAmelCase 						=       size["height"], size["width"]

          if (output_width < output_height and input_width > input_height) or (
              output_width > output_height and input_width < input_height
          ):
             _UpperCAmelCase 						=       np.rotaa(lowerCamelCase_				,3		)

          if data_format is not None:
             _UpperCAmelCase 						=       to_channel_dimension_format(lowerCamelCase_				,lowerCamelCase_		)

          return image







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_ = False				,lowerCamelCase_ = None				,):



          '''simple docstring'''

          _UpperCAmelCase						,				_UpperCAmelCase 						=       size["height"], size["width"]
          _UpperCAmelCase						,				_UpperCAmelCase 						=       get_image_size(lowerCamelCase_		)

          _UpperCAmelCase 						=       output_width - input_width
          _UpperCAmelCase 						=       output_height - input_height

          if random_padding:
             _UpperCAmelCase 						=       np.random.randint(low=0				,high=delta_height + 1		)
             _UpperCAmelCase 						=       np.random.randint(low=0				,high=delta_width + 1		)
          else:
             _UpperCAmelCase 						=       delta_height // 2
             _UpperCAmelCase 						=       delta_width // 2

          _UpperCAmelCase 						=       delta_height - pad_top
          _UpperCAmelCase 						=       delta_width - pad_left

          _UpperCAmelCase 						=       ((pad_top, pad_bottom), (pad_left, pad_right))
          return pad(lowerCamelCase_				,lowerCamelCase_				,data_format=lowerCamelCase_		)







       def  _snake_case      (       self				,*lowerCamelCase_				,**lowerCamelCase_		):



          '''simple docstring'''

          logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead."		)
          return self.pad_image(*lowerCamelCase_				,**lowerCamelCase_		)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_ = PILImageResampling.BICUBIC				,lowerCamelCase_ = None				,**lowerCamelCase_				,):



          '''simple docstring'''

          _UpperCAmelCase						,				_UpperCAmelCase 						=       get_image_size(lowerCamelCase_		)
          _UpperCAmelCase						,				_UpperCAmelCase 						=       size["height"], size["width"]

          # We always resize to the smallest of either the input or output size.
          _UpperCAmelCase 						=       min(lowerCamelCase_				,lowerCamelCase_		)
          _UpperCAmelCase 						=       min(lowerCamelCase_				,lowerCamelCase_		)

          if height == input_height and width == input_width:
             return image

          if input_height > input_width:
             _UpperCAmelCase 						=       int(input_width * height / input_height		)
          elif input_width > input_height:
             _UpperCAmelCase 						=       int(input_height * width / input_width		)

          return resize(
              lowerCamelCase_				,size=(height, width)				,resample=lowerCamelCase_				,reducing_gap=2.0				,data_format=lowerCamelCase_				,**lowerCamelCase_		)







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_ = PILImageResampling.BICUBIC				,lowerCamelCase_ = None				,**lowerCamelCase_				,):



          '''simple docstring'''

          _UpperCAmelCase 						=       get_size_dict(lowerCamelCase_		)
          _UpperCAmelCase 						=       min(size["height"]				,size["width"]		)
          _UpperCAmelCase 						=       get_resize_output_image_size(lowerCamelCase_				,size=lowerCamelCase_				,default_to_square=lowerCamelCase_		)
          _UpperCAmelCase 						=       resize(lowerCamelCase_				,size=lowerCamelCase_				,resample=lowerCamelCase_				,data_format=lowerCamelCase_				,**lowerCamelCase_		)
          return resized_image







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_ = None				,**lowerCamelCase_				,):



          '''simple docstring'''

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







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_				,lowerCamelCase_ = None				,**lowerCamelCase_				,):



          '''simple docstring'''

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







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = False				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = None				,lowerCamelCase_ = ChannelDimension.FIRST				,**lowerCamelCase_				,):



          '''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
          if isinstance(lowerCamelCase_				,(tuple, list)		):
             # Previous feature extractor had size in (width, height) format
             _UpperCAmelCase 						=       size[::-1]
          _UpperCAmelCase 						=       get_size_dict(lowerCamelCase_		)
          _UpperCAmelCase 						=       resample if resample is not None else self.resample
          _UpperCAmelCase 						=       do_thumbnail if do_thumbnail is not None else self.do_thumbnail
          _UpperCAmelCase 						=       do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
          _UpperCAmelCase 						=       do_pad if do_pad is not None else self.do_pad
          _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(lowerCamelCase_		)

          if not valid_images(lowerCamelCase_		):
             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_rescale and rescale_factor is None:
             raise ValueError("Rescale factor must be specified if do_rescale is True."		)

          if do_pad and size is None:
             raise ValueError("Size must be specified if do_pad 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(lowerCamelCase_		) for image in images]

          if do_align_long_axis:
             _UpperCAmelCase 						=       [self.align_long_axis(lowerCamelCase_				,size=lowerCamelCase_		) for image in images]

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

          if do_thumbnail:
             _UpperCAmelCase 						=       [self.thumbnail(image=lowerCamelCase_				,size=lowerCamelCase_		) for image in images]

          if do_pad:
             _UpperCAmelCase 						=       [self.pad_image(image=lowerCamelCase_				,size=lowerCamelCase_				,random_padding=lowerCamelCase_		) for image in images]

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

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

          _UpperCAmelCase 						=       [to_channel_dimension_format(lowerCamelCase_				,lowerCamelCase_		) for image in images]

          _UpperCAmelCase 						=       {"pixel_values": images}
          return BatchFeature(data=lowerCamelCase_				,tensor_type=lowerCamelCase_		)



"""simple docstring"""







from typing import List

import PIL
import torch
from PIL import Image

from ...configuration_utils import ConfigMixin
from ...models.modeling_utils import ModelMixin
from ...utils import PIL_INTERPOLATION






class      __a      (       lowerCAmelCase_					,						lowerCAmelCase_      ):







       def __init__(       self		):



          '''simple docstring'''

          super().__init__()

          self.register_buffer("watermark_image"				,torch.zeros((62, 62, 4)		)		)
          _UpperCAmelCase 						=       None







       def  _snake_case      (       self				,lowerCamelCase_				,lowerCamelCase_=None		):



          '''simple docstring'''

          _UpperCAmelCase 						=       images[0].height
          _UpperCAmelCase 						=       images[0].width

          _UpperCAmelCase 						=       sample_size or h

          _UpperCAmelCase 						=       min(h / sample_size				,w / sample_size		)
          _UpperCAmelCase						,				_UpperCAmelCase 						=       (int(h / coef		), int(w / coef		)) if coef < 1 else (h, w)

          _UpperCAmelCase						,				_UpperCAmelCase 						=       1024**2, img_w * img_h
          _UpperCAmelCase 						=       (Sa / Sa) ** 0.5
          _UpperCAmelCase						,				_UpperCAmelCase						,				_UpperCAmelCase 						=       int(K * 62		), img_w - int(14 * K		), img_h - int(14 * K		)

          if self.watermark_image_as_pil is None:
             _UpperCAmelCase 						=       self.watermark_image.to(torch.uinta		).cpu().numpy()
             _UpperCAmelCase 						=       Image.fromarray(lowerCamelCase_				,mode="RGBA"		)
             _UpperCAmelCase 						=       watermark_image

          _UpperCAmelCase 						=       self.watermark_image_as_pil.resize(
              (wm_size, wm_size)				,PIL_INTERPOLATION["bicubic"]				,reducing_gap=lowerCamelCase_		)

          for pil_img in images:
             pil_img.paste(lowerCamelCase_				,box=(wm_x - wm_size, wm_y - wm_size, wm_x, wm_y)				,mask=wm_img.split()[-1]		)

          return images

