


import warnings
from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from PIL import Image

from .configuration_utils import ConfigMixin, register_to_config
from .utils import CONFIG_NAME, PIL_INTERPOLATION, deprecate




class A  (       A__					):
      UpperCamelCase__							:  str				=						CONFIG_NAME






      @register_to_config
      def __init__( self						:					List[Any]      ,       lowercase_						:					List[str] = True      ,       lowercase_						:					List[str] = 8      ,       lowercase_						:					Tuple = "lanczos"      ,       lowercase_						:					int = True      ,       lowercase_						:					str = False      ,       ) ->						Tuple:
             """simple docstring"""




             super().__init__()






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					Any			) ->						PIL.Image.Image:
             """simple docstring"""




             if images.ndim == 3:
                    _lowerCamelCase	:		Optional[Any]          =images[None, ...]
             _lowerCamelCase	:		Any          =(images * 255).round().astype('uint8'			)
             if images.shape[-1] == 1:
                    # special case for grayscale (single channel) images
                    _lowerCamelCase	:		Union[str, Any]          =[Image.fromarray(image.squeeze()      ,       mode='L'			) for image in images]
             else:
                    _lowerCamelCase	:		Optional[int]          =[Image.fromarray(snake_case_			) for image in images]

             return pil_images






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					List[str]			) ->						np.ndarray:
             """simple docstring"""




             if not isinstance(snake_case_      ,       snake_case_			):
                    _lowerCamelCase	:		List[str]          =[images]
             _lowerCamelCase	:		Optional[Any]          =[np.array(snake_case_			).astype(np.floataa			) / 255.0 for image in images]
             _lowerCamelCase	:		Dict          =np.stack(snake_case_      ,       axis=0			)

             return images






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					Tuple			) ->						torch.FloatTensor:
             """simple docstring"""




             if images.ndim == 3:
                    _lowerCamelCase	:		List[Any]          =images[..., None]

             _lowerCamelCase	:		Optional[Any]          =torch.from_numpy(images.transpose(0      ,       3      ,       1      ,       2			)			)
             return images






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					Any			) ->						np.ndarray:
             """simple docstring"""




             _lowerCamelCase	:		Union[str, Any]          =images.cpu().permute(0      ,       2      ,       3      ,       1			).float().numpy()
             return images






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					Optional[int]			) ->						Dict:
             """simple docstring"""




             return 2.0 * images - 1.0






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					List[Any]			) ->						List[str]:
             """simple docstring"""




             return (images / 2 + 0.5).clamp(0      ,       1			)






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					List[str]			) ->						PIL.Image.Image:
             """simple docstring"""




             _lowerCamelCase	:		Union[str, Any]          =image.convert('RGB'			)
             return image






      def 	lowerCamelCase	( self						:					str      ,       lowercase_						:					Tuple      ,       lowercase_						:					Optional[int] = None      ,       lowercase_						:					Optional[int] = None      ,       ) ->						PIL.Image.Image:
             """simple docstring"""




             if height is None:
                    _lowerCamelCase	:		Union[str, Any]          =image.height
             if width is None:
                    _lowerCamelCase	:		Optional[Any]          =image.width

             _lowerCamelCase     ,					_lowerCamelCase	:		Optional[int]          =(
                 x - x % self.config.vae_scale_factor for x in (width, height)
             )  # resize to integer multiple of vae_scale_factor
             _lowerCamelCase	:		Optional[Any]          =image.resize((width, height)      ,       resample=PIL_INTERPOLATION[self.config.resample]			)
             return image






      def 	lowerCamelCase	( self						:					int      ,       lowercase_						:					List[str]      ,       lowercase_						:					int = None      ,       lowercase_						:					Any = None      ,       ) ->						torch.Tensor:
             """simple docstring"""




             _lowerCamelCase	:		List[str]          =(PIL.Image.Image, np.ndarray, torch.Tensor)
             if isinstance(snake_case_      ,       snake_case_			):
                    _lowerCamelCase	:		Optional[Any]          =[image]
             elif not (isinstance(snake_case_      ,       snake_case_			) and all(isinstance(snake_case_      ,       snake_case_			) for i in image			)):
                    raise ValueError(
                        F'''Input is in incorrect format: {[type(snake_case_			) for i in image]}. Currently, we only support {', '.join(snake_case_			)}'''			)

             if isinstance(image[0]      ,       PIL.Image.Image			):
                    if self.config.do_convert_rgb:
                           _lowerCamelCase	:		Optional[int]          =[self.convert_to_rgb(snake_case_			) for i in image]
                    if self.config.do_resize:
                           _lowerCamelCase	:		str          =[self.resize(snake_case_      ,       snake_case_      ,       snake_case_			) for i in image]
                    _lowerCamelCase	:		Optional[int]          =self.pil_to_numpy(snake_case_			)  # to np
                    _lowerCamelCase	:		List[Any]          =self.numpy_to_pt(snake_case_			)  # to pt

             elif isinstance(image[0]      ,       np.ndarray			):
                    _lowerCamelCase	:		int          =np.concatenate(snake_case_      ,       axis=0			) if image[0].ndim == 4 else np.stack(snake_case_      ,       axis=0			)
                    _lowerCamelCase	:		Dict          =self.numpy_to_pt(snake_case_			)
                    _lowerCamelCase     ,					_lowerCamelCase     ,					_lowerCamelCase     ,					_lowerCamelCase	:		Any          =image.shape
                    if self.config.do_resize and (
                        height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
                    ):
                           raise ValueError(
                               F'''Currently we only support resizing for PIL image - please resize your numpy array to be divisible by {self.config.vae_scale_factor}'''
                               F'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''			)

             elif isinstance(image[0]      ,       torch.Tensor			):
                    _lowerCamelCase	:		List[Any]          =torch.cat(snake_case_      ,       axis=0			) if image[0].ndim == 4 else torch.stack(snake_case_      ,       axis=0			)
                    _lowerCamelCase     ,					_lowerCamelCase     ,					_lowerCamelCase     ,					_lowerCamelCase	:		int          =image.shape

                    # don't need any preprocess if the image is latents
                    if channel == 4:
                           return image

                    if self.config.do_resize and (
                        height % self.config.vae_scale_factor != 0 or width % self.config.vae_scale_factor != 0
                    ):
                           raise ValueError(
                               F'''Currently we only support resizing for PIL image - please resize your pytorch tensor to be divisible by {self.config.vae_scale_factor}'''
                               F'''currently the sizes are {height} and {width}. You can also pass a PIL image instead to use resize option in VAEImageProcessor'''			)

        # expected range [0,1], normalize to [-1,1]
             _lowerCamelCase	:		Tuple          =self.config.do_normalize
             if image.min() < 0:
                    warnings.warn(
                        'Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] '
                        F'''when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]'''      ,       snake_case_      ,       )
                    _lowerCamelCase	:		Dict          =False

             if do_normalize:
                    _lowerCamelCase	:		str          =self.normalize(snake_case_			)

             return image






      def 	lowerCamelCase	( self						:					Dict      ,       lowercase_						:					List[Any]      ,       lowercase_						:					List[Any] = "pil"      ,       lowercase_						:					Union[str, Any] = None      ,       ) ->						Union[str, Any]:
             """simple docstring"""




             if not isinstance(snake_case_      ,       torch.Tensor			):
                    raise ValueError(
                        F'''Input for postprocessing is in incorrect format: {type(snake_case_			)}. We only support pytorch tensor'''			)
             if output_type not in ["latent", "pt", "np", "pil"]:
                    _lowerCamelCase	:		List[str]          =(
                        F'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
                        '`pil`, `np`, `pt`, `latent`'
                    )
                    deprecate('Unsupported output_type'      ,       '1.0.0'      ,       snake_case_      ,       standard_warn=snake_case_			)
                    _lowerCamelCase	:		Optional[int]          ='np'

             if output_type == "latent":
                    return image

             if do_denormalize is None:
                    _lowerCamelCase	:		Dict          =[self.config.do_normalize] * image.shape[0]

             _lowerCamelCase	:		Tuple          =torch.stack(
                 [self.denormalize(image[i]			) if do_denormalize[i] else image[i] for i in range(image.shape[0]			)]			)

             if output_type == "pt":
                    return image

             _lowerCamelCase	:		List[str]          =self.pt_to_numpy(snake_case_			)

             if output_type == "np":
                    return image

             if output_type == "pil":
                    return self.numpy_to_pil(snake_case_			)




class A  (       A__					):
      UpperCamelCase__							:  Tuple				=						CONFIG_NAME






      @register_to_config
      def __init__( self						:					Any      ,       lowercase_						:					int = True      ,       lowercase_						:					Optional[int] = 8      ,       lowercase_						:					List[Any] = "lanczos"      ,       lowercase_						:					Dict = True      ,       ) ->						Any:
             """simple docstring"""




             super().__init__()






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					Any			) ->						int:
             """simple docstring"""




             if images.ndim == 3:
                    _lowerCamelCase	:		Union[str, Any]          =images[None, ...]
             _lowerCamelCase	:		Union[str, Any]          =(images * 255).round().astype('uint8'			)
             if images.shape[-1] == 1:
                    # special case for grayscale (single channel) images
                    _lowerCamelCase	:		str          =[Image.fromarray(image.squeeze()      ,       mode='L'			) for image in images]
             else:
                    _lowerCamelCase	:		str          =[Image.fromarray(image[:, :, :3]			) for image in images]

             return pil_images






      @staticmethod
      def 	lowerCamelCase	( lowercase_						:					int			) ->						Optional[int]:
             """simple docstring"""




             return image[:, :, 1] * 2**8 + image[:, :, 2]






      def 	lowerCamelCase	( self						:					List[str]      ,       lowercase_						:					List[Any]			) ->						Tuple:
             """simple docstring"""




             if images.ndim == 3:
                    _lowerCamelCase	:		str          =images[None, ...]
             _lowerCamelCase	:		Tuple          =images[:, :, :, 3:]
             if images.shape[-1] == 6:
                    _lowerCamelCase	:		List[str]          =(images_depth * 255).round().astype('uint8'			)
                    _lowerCamelCase	:		List[Any]          =[
                        Image.fromarray(self.rgblike_to_depthmap(snake_case_			)      ,       mode='I;16'			) for image_depth in images_depth
                    ]
             elif images.shape[-1] == 4:
                    _lowerCamelCase	:		List[str]          =(images_depth * 6_5535.0).astype(np.uintaa			)
                    _lowerCamelCase	:		Any          =[Image.fromarray(snake_case_      ,       mode='I;16'			) for image_depth in images_depth]
             else:
                    raise Exception('Not supported'			)

             return pil_images






      def 	lowerCamelCase	( self						:					Dict      ,       lowercase_						:					Any      ,       lowercase_						:					Tuple = "pil"      ,       lowercase_						:					Dict = None      ,       ) ->						int:
             """simple docstring"""




             if not isinstance(snake_case_      ,       torch.Tensor			):
                    raise ValueError(
                        F'''Input for postprocessing is in incorrect format: {type(snake_case_			)}. We only support pytorch tensor'''			)
             if output_type not in ["latent", "pt", "np", "pil"]:
                    _lowerCamelCase	:		str          =(
                        F'''the output_type {output_type} is outdated and has been set to `np`. Please make sure to set it to one of these instead: '''
                        '`pil`, `np`, `pt`, `latent`'
                    )
                    deprecate('Unsupported output_type'      ,       '1.0.0'      ,       snake_case_      ,       standard_warn=snake_case_			)
                    _lowerCamelCase	:		Union[str, Any]          ='np'

             if do_denormalize is None:
                    _lowerCamelCase	:		Union[str, Any]          =[self.config.do_normalize] * image.shape[0]

             _lowerCamelCase	:		Union[str, Any]          =torch.stack(
                 [self.denormalize(image[i]			) if do_denormalize[i] else image[i] for i in range(image.shape[0]			)]			)

             _lowerCamelCase	:		Union[str, Any]          =self.pt_to_numpy(snake_case_			)

             if output_type == "np":
                    if image.shape[-1] == 6:
                           _lowerCamelCase	:		List[str]          =np.stack([self.rgblike_to_depthmap(im[:, :, 3:]			) for im in image]      ,       axis=0			)
                    else:
                           _lowerCamelCase	:		List[Any]          =image[:, :, :, 3:]
                    return image[:, :, :, :3], image_depth

             if output_type == "pil":
                    return self.numpy_to_pil(snake_case_			), self.numpy_to_depth(snake_case_			)
             else:
                    raise Exception(F'''This type {output_type} is not supported'''			)






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase						 =	{'configuration_visual_bert': ['VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VisualBertConfig']}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase						 =	[
     'VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'VisualBertForMultipleChoice',
     'VisualBertForPreTraining',
     'VisualBertForQuestionAnswering',
     'VisualBertForRegionToPhraseAlignment',
     'VisualBertForVisualReasoning',
     'VisualBertLayer',
     'VisualBertModel',
     'VisualBertPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_visual_bert import (
      VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      VisualBertForMultipleChoice,
      VisualBertForPreTraining,
      VisualBertForQuestionAnswering,
      VisualBertForRegionToPhraseAlignment,
      VisualBertForVisualReasoning,
      VisualBertLayer,
      VisualBertModel,
      VisualBertPreTrainedModel,
  )


else:
 import sys

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


