



"""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


A:   List[Any]								=		logging.get_logger(__name__)



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   List[str]						=						['pixel_values']

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





    '''simple docstring'''




    super().__init__(**_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Dict	=	size if size is not None else {"""shortest_edge""": 256}
    UpperCAmelCase	:					int	=	get_size_dict(_SCREAMING_SNAKE_CASE      ,     default_to_square=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					int	=	crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
    UpperCAmelCase	:					List[str]	=	get_size_dict(_SCREAMING_SNAKE_CASE      ,     param_name="""crop_size"""						)
    UpperCAmelCase	:					Optional[int]	=	do_resize
    UpperCAmelCase	:					int	=	size
    UpperCAmelCase	:					Any	=	resample
    UpperCAmelCase	:					Dict	=	do_center_crop
    UpperCAmelCase	:					Dict	=	crop_size
    UpperCAmelCase	:					Tuple	=	do_rescale
    UpperCAmelCase	:					Optional[Any]	=	rescale_factor
    UpperCAmelCase	:					Any	=	do_normalize
    UpperCAmelCase	:					Dict	=	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
    UpperCAmelCase	:					Union[str, Any]	=	image_std if image_std is not None else IMAGENET_STANDARD_STD

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC      ,     _SCREAMING_SNAKE_CASE = None      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      np.ndarray:





    '''simple docstring'''




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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      np.ndarray:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	get_size_dict(_SCREAMING_SNAKE_CASE						)
    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(_SCREAMING_SNAKE_CASE      ,     size=(size["""height"""], size["""width"""])      ,     data_format=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     **_SCREAMING_SNAKE_CASE						)  ->      np.ndarray:





    '''simple docstring'''




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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      np.ndarray:





    '''simple docstring'''




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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = ChannelDimension.FIRST      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	do_resize if do_resize is not None else self.do_resize
    UpperCAmelCase	:					str	=	size if size is not None else self.size
    UpperCAmelCase	:					Union[str, Any]	=	get_size_dict(_SCREAMING_SNAKE_CASE      ,     default_to_square=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Any	=	resample if resample is not None else self.resample
    UpperCAmelCase	:					int	=	do_center_crop if do_center_crop is not None else self.do_center_crop
    UpperCAmelCase	:					Dict	=	crop_size if crop_size is not None else self.crop_size
    UpperCAmelCase	:					List[Any]	=	get_size_dict(_SCREAMING_SNAKE_CASE      ,     param_name="""crop_size"""						)
    UpperCAmelCase	:					int	=	do_rescale if do_rescale is not None else self.do_rescale
    UpperCAmelCase	:					Tuple	=	rescale_factor if rescale_factor is not None else self.rescale_factor
    UpperCAmelCase	:					str	=	do_normalize if do_normalize is not None else self.do_normalize
    UpperCAmelCase	:					Union[str, Any]	=	image_mean if image_mean is not None else self.image_mean
    UpperCAmelCase	:					int	=	image_std if image_std is not None else self.image_std

    UpperCAmelCase	:					List[Any]	=	make_list_of_images(_SCREAMING_SNAKE_CASE						)

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

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

    if do_center_crop:
     UpperCAmelCase	:					Dict	=	[self.center_crop(image=_SCREAMING_SNAKE_CASE      ,     size=_SCREAMING_SNAKE_CASE						) for image in images]

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

    if do_normalize:
     UpperCAmelCase	:					str	=	[self.normalize(image=_SCREAMING_SNAKE_CASE      ,     mean=_SCREAMING_SNAKE_CASE      ,     std=_SCREAMING_SNAKE_CASE						) for image in images]

    UpperCAmelCase	:					Optional[Any]	=	[to_channel_dimension_format(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) for image in images]

    UpperCAmelCase	:					str	=	{"""pixel_values""": images}
    return BatchFeature(data=_SCREAMING_SNAKE_CASE      ,     tensor_type=_SCREAMING_SNAKE_CASE						)




   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					List[Any]	=	outputs.logits

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

     if is_torch_tensor(_SCREAMING_SNAKE_CASE						):
      UpperCAmelCase	:					Any	=	target_sizes.numpy()

     UpperCAmelCase	:					Tuple	=	[]

     for idx in range(len(_SCREAMING_SNAKE_CASE						)						):
      UpperCAmelCase	:					Dict	=	torch.nn.functional.interpolate(
          logits[idx].unsqueeze(dim=0						)      ,     size=target_sizes[idx]      ,     mode="""bilinear"""      ,     align_corners=_SCREAMING_SNAKE_CASE						)
      UpperCAmelCase	:					Tuple	=	resized_logits[0].argmax(dim=0						)
      semantic_segmentation.append(_SCREAMING_SNAKE_CASE						)
    else:
     UpperCAmelCase	:					List[Any]	=	logits.argmax(dim=1						)
     UpperCAmelCase	:					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


A:   List[str]								=		{
    "configuration_clipseg": [
        "CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "CLIPSegConfig",
        "CLIPSegTextConfig",
        "CLIPSegVisionConfig",
    ],
    "processing_clipseg": ["CLIPSegProcessor"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A:   Optional[int]								=		[
          "CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST",
          "CLIPSegModel",
          "CLIPSegPreTrainedModel",
          "CLIPSegTextModel",
          "CLIPSegVisionModel",
          "CLIPSegForImageSegmentation",
      ]

if TYPE_CHECKING:
      from .configuration_clipseg import (
          CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
          CLIPSegConfig,
          CLIPSegTextConfig,
          CLIPSegVisionConfig,
      )
      from .processing_clipseg import CLIPSegProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_clipseg import (
                CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
                CLIPSegForImageSegmentation,
                CLIPSegModel,
                CLIPSegPreTrainedModel,
                CLIPSegTextModel,
                CLIPSegVisionModel,
            )

else:
      import sys

      A:   Tuple								=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
