






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 center_crop, 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_vision_available, logging


if is_vision_available():
							import PIL


A__     :      Dict             =			logging.get_logger(__name__)
class 				_UpperCAmelCase (	A__     ):

				"""simple docstring"""




				lowercase__    							=	["""pixel_values"""]




				def __init__(					self						:   Union[str, Any],  lowerCamelCase						:   bool = True,  lowerCamelCase						:   Dict[str, int] = None,  lowerCamelCase						:   PILImageResampling = PIL.Image.NEAREST,  lowerCamelCase						:   bool = False,  lowerCamelCase						:   Dict[str, int] = None,  lowerCamelCase						:   Union[int, float] = 1 / 255,  lowerCamelCase						:   bool = False,  lowerCamelCase						:   bool = True,  lowerCamelCase						:   bool = True,  lowerCamelCase						:   Optional[Union[float, List[float]]] = None,  lowerCamelCase						:   Optional[Union[float, List[float]]] = None,  lowerCamelCase						:   bool = True,  **lowerCamelCase						:   Optional[Any],  ):

								'''simple docstring'''
								super().__init__(**lowerCamelCase  )
								lowercase__       			=      size if size is not None else {'''height''': 346, '''width''': 346}
								lowercase__       			=      get_size_dict(lowerCamelCase  )
								lowercase__       			=      crop_size if crop_size is not None else {'''height''': 289, '''width''': 289}
								lowercase__       			=      get_size_dict(lowerCamelCase,  param_name='''crop_size'''  )

								lowercase__       			=      do_resize
								lowercase__       			=      size
								lowercase__       			=      resample
								lowercase__       			=      do_center_crop
								lowercase__       			=      crop_size
								lowercase__       			=      do_rescale
								lowercase__       			=      rescale_factor
								lowercase__       			=      rescale_offset
								lowercase__       			=      do_normalize
								lowercase__       			=      image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
								lowercase__       			=      image_std if image_std is not None else IMAGENET_STANDARD_STD
								lowercase__       			=      include_top




				def     lowercase__       (					self						:   Optional[Any],  lowerCamelCase						:   np.ndarray,  lowerCamelCase						:   Dict[str, int],  lowerCamelCase						:   PILImageResampling = PIL.Image.NEAREST,  lowerCamelCase						:   Optional[Union[str, ChannelDimension]] = None,  **lowerCamelCase						:   Any,  ):

								'''simple docstring'''
								lowercase__       			=      get_size_dict(lowerCamelCase  )
								if "height" not in size or "width" not in size:
												raise ValueError(F"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""  )
								return resize(
								    lowerCamelCase,  size=(size['''height'''], size['''width''']),  resample=lowerCamelCase,  data_format=lowerCamelCase,  **lowerCamelCase  )




				def     lowercase__       (					self						:   int,  lowerCamelCase						:   np.ndarray,  lowerCamelCase						:   Dict[str, int],  lowerCamelCase						:   Optional[Union[str, ChannelDimension]] = None,  **lowerCamelCase						:   Optional[int],  ):

								'''simple docstring'''
								lowercase__       			=      get_size_dict(lowerCamelCase  )
								if "height" not in size or "width" not in size:
												raise ValueError(F"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""  )
								return center_crop(lowerCamelCase,  size=(size['''height'''], size['''width''']),  data_format=lowerCamelCase,  **lowerCamelCase  )




				def     lowercase__       (					self						:   List[str],  lowerCamelCase						:   np.ndarray,  lowerCamelCase						:   Union[int, float],  lowerCamelCase						:   bool = True,  lowerCamelCase						:   Optional[Union[str, ChannelDimension]] = None,  **lowerCamelCase						:   Tuple,  ):

								'''simple docstring'''
								if offset:
												lowercase__       			=      (image - 127.5) * scale
												if data_format is not None:
																lowercase__       			=      to_channel_dimension_format(lowerCamelCase,  lowerCamelCase  )
												lowercase__       			=      rescaled_image.astype(np.floataa  )
								else:
												lowercase__       			=      rescale(lowerCamelCase,  scale=lowerCamelCase,  data_format=lowerCamelCase,  **lowerCamelCase  )
								return rescaled_image




				def     lowercase__       (					self						:   Any,  lowerCamelCase						:   np.ndarray,  lowerCamelCase						:   Union[float, List[float]],  lowerCamelCase						:   Union[float, List[float]],  lowerCamelCase						:   Optional[Union[str, ChannelDimension]] = None,  **lowerCamelCase						:   Any,  ):

								'''simple docstring'''
								return normalize(lowerCamelCase,  mean=lowerCamelCase,  std=lowerCamelCase,  data_format=lowerCamelCase,  **lowerCamelCase  )




				def     lowercase__       (					self						:   int,  lowerCamelCase						:   ImageInput,  lowerCamelCase						:   bool = None,  lowerCamelCase						:   Dict[str, int] = None,  lowerCamelCase						:   List[str]=None,  lowerCamelCase						:   bool = None,  lowerCamelCase						:   Dict[str, int] = None,  lowerCamelCase						:   bool = None,  lowerCamelCase						:   float = None,  lowerCamelCase						:   bool = None,  lowerCamelCase						:   bool = None,  lowerCamelCase						:   Optional[Union[float, List[float]]] = None,  lowerCamelCase						:   Optional[Union[float, List[float]]] = None,  lowerCamelCase						:   bool = None,  lowerCamelCase						:   Optional[Union[str, TensorType]] = None,  lowerCamelCase						:   ChannelDimension = ChannelDimension.FIRST,  **lowerCamelCase						:   Optional[Any],  ):

								'''simple docstring'''
								lowercase__       			=      do_resize if do_resize is not None else self.do_resize
								lowercase__       			=      resample if resample is not None else self.resample
								lowercase__       			=      do_center_crop if do_center_crop is not None else self.do_center_crop
								lowercase__       			=      do_rescale if do_rescale is not None else self.do_rescale
								lowercase__       			=      rescale_factor if rescale_factor is not None else self.rescale_factor
								lowercase__       			=      rescale_offset if rescale_offset is not None else self.rescale_offset
								lowercase__       			=      do_normalize if do_normalize is not None else self.do_normalize
								lowercase__       			=      image_mean if image_mean is not None else self.image_mean
								lowercase__       			=      image_std if image_std is not None else self.image_std
								lowercase__       			=      include_top if include_top is not None else self.include_top

								lowercase__       			=      size if size is not None else self.size
								lowercase__       			=      get_size_dict(lowerCamelCase  )
								lowercase__       			=      crop_size if crop_size is not None else self.crop_size
								lowercase__       			=      get_size_dict(lowerCamelCase,  param_name='''crop_size'''  )

								lowercase__       			=      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 or resample is None:
												raise ValueError('''Size and resample 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.
								lowercase__       			=      [to_numpy_array(lowerCamelCase  ) for image in images]

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

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

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

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

								if include_top:
												lowercase__       			=      [self.normalize(image=lowerCamelCase,  mean=[0, 0, 0],  std=lowerCamelCase  ) for image in images]

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

								lowercase__       			=      {'''pixel_values''': images}
								return BatchFeature(data=lowerCamelCase,  tensor_type=lowerCamelCase  )












from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


A__     :      int             =			{
    'configuration_sam': [
        'SAM_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SamConfig',
        'SamMaskDecoderConfig',
        'SamPromptEncoderConfig',
        'SamVisionConfig',
    ],
    'processing_sam': ['SamProcessor'],
}


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__     :      List[Any]             =			[
							    'SAM_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'SamModel',
							    'SamPreTrainedModel',
							]
try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__     :      int             =			[
							    'TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFSamModel',
							    'TFSamPreTrainedModel',
							]
try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__     :      Tuple             =			['SamImageProcessor']


if TYPE_CHECKING:
							from .configuration_sam import (
							    SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    SamConfig,
							    SamMaskDecoderConfig,
							    SamPromptEncoderConfig,
							    SamVisionConfig,
							)
							from .processing_sam import SamProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .image_processing_sam import SamImageProcessor

else:
							import sys

							A__     :      Dict             =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




