

'''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,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
   import PIL

if is_torch_available():
   import torch


SCREAMING_SNAKE_CASE_     = logging.get_logger(__name__)

class       SCREAMING_SNAKE_CASE       (				lowercase_       ):






      '''simple docstring'''






      SCREAMING_SNAKE_CASE__			:					Any     =					['pixel_values']




      def __init__(       self			:		List[Any]  ,       snake_case			:		int = True  ,       snake_case			:		Optional[int] = None  ,       snake_case			:		int = PILImageResampling.BILINEAR  ,       snake_case			:		Tuple = True  ,       snake_case			:		Optional[int] = 1 / 255  ,       snake_case			:		List[Any] = True  ,       snake_case			:		Optional[int] = None  ,       snake_case			:		Optional[int] = True  ,       **snake_case			:		Union[str, Any]  ,       ):



          """simple docstring"""





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

          _snake_case			:			List[Any]				       =		do_resize
          _snake_case			:			int				       =		size
          _snake_case			:			int				       =		resample
          _snake_case			:			Union[str, Any]				       =		do_rescale
          _snake_case			:			Optional[int]				       =		rescale_factor
          _snake_case			:			Union[str, Any]				       =		do_center_crop
          _snake_case			:			Union[str, Any]				       =		crop_size
          _snake_case			:			Union[str, Any]				       =		do_flip_channel_order




      def 						__UpperCAmelCase      (       self			:		Tuple  ,       snake_case			:		List[Any]  ,       snake_case			:		Tuple  ,       snake_case			:		Union[str, Any] = PIL.Image.BILINEAR  ,       snake_case			:		int = None  ,       **snake_case			:		Optional[int]  ,       ):



          """simple docstring"""





          _snake_case			:			Any				       =		get_size_dict(__lowerCAmelCase  ,       default_to_square=__lowerCAmelCase )
          if "shortest_edge" not in size:
              raise ValueError(F"""The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}""" )
          _snake_case			:			Tuple				       =		get_resize_output_image_size(__lowerCAmelCase  ,       size=size['shortest_edge']  ,       default_to_square=__lowerCAmelCase )
          return resize(__lowerCAmelCase  ,       size=__lowerCAmelCase  ,       resample=__lowerCAmelCase  ,       data_format=__lowerCAmelCase  ,       **__lowerCAmelCase )




      def 						__UpperCAmelCase      (       self			:		Tuple  ,       snake_case			:		int  ,       snake_case			:		Dict  ,       snake_case			:		str = None  ,       **snake_case			:		List[Any]  ,       ):



          """simple docstring"""





          _snake_case			:			Any				       =		get_size_dict(__lowerCAmelCase )
          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()}""" )
          return center_crop(__lowerCAmelCase  ,       size=(size['height'], size['width'])  ,       data_format=__lowerCAmelCase  ,       **__lowerCAmelCase )




      def 						__UpperCAmelCase      (       self			:		str  ,       snake_case			:		Optional[Any]  ,       snake_case			:		Dict  ,       snake_case			:		str = None  ,       **snake_case			:		Dict  ,       ):



          """simple docstring"""





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




      def 						__UpperCAmelCase      (       self			:		List[str]  ,       snake_case			:		Any  ,       snake_case			:		List[Any] = None ):



          """simple docstring"""





          return flip_channel_order(__lowerCAmelCase  ,       data_format=__lowerCAmelCase )




      def 						__UpperCAmelCase      (       self			:		Dict  ,       snake_case			:		Union[str, Any]  ,       snake_case			:		Any = None  ,       snake_case			:		List[Any] = None  ,       snake_case			:		str = None  ,       snake_case			:		str = None  ,       snake_case			:		Any = None  ,       snake_case			:		Dict = None  ,       snake_case			:		List[str] = None  ,       snake_case			:		Tuple = None  ,       snake_case			:		Union[str, Any] = None  ,       snake_case			:		Union[str, Any] = ChannelDimension.FIRST  ,       **snake_case			:		Optional[Any]  ,       ):



          """simple docstring"""





          _snake_case			:			List[str]				       =		do_resize if do_resize is not None else self.do_resize
          _snake_case			:			Optional[int]				       =		resample if resample is not None else self.resample
          _snake_case			:			str				       =		do_rescale if do_rescale is not None else self.do_rescale
          _snake_case			:			Any				       =		rescale_factor if rescale_factor is not None else self.rescale_factor
          _snake_case			:			Optional[int]				       =		do_center_crop if do_center_crop is not None else self.do_center_crop
          _snake_case			:			str				       =		(
              do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
          )

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

          _snake_case			:			Optional[Any]				       =		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_center_crop and crop_size is None:
              raise ValueError('Crop size must be specified if do_center_crop is True.' )

          # All transformations expect numpy arrays.
          _snake_case			:			Any				       =		[to_numpy_array(__lowerCAmelCase ) for image in images]

          if do_resize:
              _snake_case			:			str				       =		[self.resize(image=__lowerCAmelCase  ,       size=__lowerCAmelCase  ,       resample=__lowerCAmelCase ) for image in images]

          if do_center_crop:
              _snake_case			:			Tuple				       =		[self.center_crop(image=__lowerCAmelCase  ,       size=__lowerCAmelCase ) for image in images]

          if do_rescale:
              _snake_case			:			List[Any]				       =		[self.rescale(image=__lowerCAmelCase  ,       scale=__lowerCAmelCase ) for image in images]

          # the pretrained checkpoints assume images are BGR, not RGB
          if do_flip_channel_order:
              _snake_case			:			Optional[int]				       =		[self.flip_channel_order(image=__lowerCAmelCase ) for image in images]

          _snake_case			:			Tuple				       =		[to_channel_dimension_format(__lowerCAmelCase  ,       __lowerCAmelCase ) for image in images]

          _snake_case			:			Any				       =		{'pixel_values': images}
          return BatchFeature(data=__lowerCAmelCase  ,       tensor_type=__lowerCAmelCase )




      def 						__UpperCAmelCase      (       self			:		List[str]  ,       snake_case			:		Any  ,       snake_case			:		Optional[Any] = None ):



          """simple docstring"""





          _snake_case			:			int				       =		outputs.logits

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

              if is_torch_tensor(__lowerCAmelCase ):
                  _snake_case			:			str				       =		target_sizes.numpy()

              _snake_case			:			int				       =		[]

              for idx in range(len(__lowerCAmelCase ) ):
                  _snake_case			:			Optional[Any]				       =		torch.nn.functional.interpolate(
                      logits[idx].unsqueeze(dim=0 )  ,       size=target_sizes[idx]  ,       mode='bilinear'  ,       align_corners=__lowerCAmelCase )
                  _snake_case			:			Optional[Any]				       =		resized_logits[0].argmax(dim=0 )
                  semantic_segmentation.append(__lowerCAmelCase )
          else:
              _snake_case			:			int				       =		logits.argmax(dim=1 )
              _snake_case			:			List[str]				       =		[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )]

          return semantic_segmentation




"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowerCAmelCase       :			Optional[int]   	={
    """configuration_chinese_clip""": [
        """CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """ChineseCLIPConfig""",
        """ChineseCLIPOnnxConfig""",
        """ChineseCLIPTextConfig""",
        """ChineseCLIPVisionConfig""",
    ],
    """processing_chinese_clip""": ["""ChineseCLIPProcessor"""],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCAmelCase       :			List[Any]   	=["""ChineseCLIPFeatureExtractor"""]
       __lowerCAmelCase       :			List[Any]   	=["""ChineseCLIPImageProcessor"""]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCAmelCase       :			Tuple   	=[
           """CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """ChineseCLIPModel""",
           """ChineseCLIPPreTrainedModel""",
           """ChineseCLIPTextModel""",
           """ChineseCLIPVisionModel""",
       ]

if TYPE_CHECKING:
       from .configuration_chinese_clip import (
           CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
           ChineseCLIPConfig,
           ChineseCLIPOnnxConfig,
           ChineseCLIPTextConfig,
           ChineseCLIPVisionConfig,
       )
       from .processing_chinese_clip import ChineseCLIPProcessor

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_chinese_clip import (
                  CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  ChineseCLIPModel,
                  ChineseCLIPPreTrainedModel,
                  ChineseCLIPTextModel,
                  ChineseCLIPVisionModel,
              )

else:
       import sys

       __lowerCAmelCase       :			Optional[Any]   	=_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



