



'''simple docstring'''





import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import SegformerImageProcessor






class __A      (  unittest.TestCase						):



 '''simple docstring'''







 def __init__(self			,       A			,       A=7			,       A=3			,       A=30			,       A=400			,       A=True			,       A=None			,       A=True			,       A=[0.5, 0.5, 0.5]			,       A=[0.5, 0.5, 0.5]			,       A=False			,       )   ->					Optional[int]:


      """simple docstring"""



      _a     =  size if size is not None else {"height": 30, "width": 30}
      _a     =  parent
      _a     =  batch_size
      _a     =  num_channels
      _a     =  min_resolution
      _a     =  max_resolution
      _a     =  do_resize
      _a     =  size
      _a     =  do_normalize
      _a     =  image_mean
      _a     =  image_std
      _a     =  do_reduce_labels



 def  a__  (self	)   ->					Tuple:


      """simple docstring"""



      return {
          "do_resize": self.do_resize,
          "size": self.size,
          "do_normalize": self.do_normalize,
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_reduce_labels": self.do_reduce_labels,
      }





def lowerCAmelCase  ():



     """simple docstring"""



     _a     =  load_dataset('''hf-internal-testing/fixtures_ade20k'''  ,     split='''test''')

     _a     =  Image.open(dataset[0]['''file'''])
     _a     =  Image.open(dataset[1]['''file'''])

     return image, map




def lowerCAmelCase  ():



     """simple docstring"""



     _a     =  load_dataset('''hf-internal-testing/fixtures_ade20k'''  ,     split='''test''')

     _a     =  Image.open(dataset[0]['''file'''])
     _a     =  Image.open(dataset[1]['''file'''])
     _a     =  Image.open(dataset[2]['''file'''])
     _a     =  Image.open(dataset[3]['''file'''])

     return [imagea, imagea], [mapa, mapa]






@require_torch
@require_vision
class __A      (  __A       ,       unittest.TestCase						):



 '''simple docstring'''







 __lowerCamelCase   :	Optional[int]										=	SegformerImageProcessor if is_vision_available() else None



 def  a__  (self	)   ->					Union[str, Any]:


      """simple docstring"""



      _a     =  SegformerImageProcessingTester(self	)



 @property
 def  a__  (self	)   ->					Tuple:


      """simple docstring"""



      return self.image_processor_tester.prepare_image_processor_dict()



 def  a__  (self	)   ->					Any:


      """simple docstring"""



      _a     =  self.image_processing_class(**self.image_processor_dict	)
      self.assertTrue(hasattr(A			,       '''do_resize'''	)	)
      self.assertTrue(hasattr(A			,       '''size'''	)	)
      self.assertTrue(hasattr(A			,       '''do_normalize'''	)	)
      self.assertTrue(hasattr(A			,       '''image_mean'''	)	)
      self.assertTrue(hasattr(A			,       '''image_std'''	)	)
      self.assertTrue(hasattr(A			,       '''do_reduce_labels'''	)	)



 def  a__  (self	)   ->					int:


      """simple docstring"""



      _a     =  self.image_processing_class.from_dict(self.image_processor_dict	)
      self.assertEqual(image_processor.size			,       {'''height''': 30, '''width''': 30}	)
      self.assertEqual(image_processor.do_reduce_labels			,       A	)

      _a     =  self.image_processing_class.from_dict(self.image_processor_dict			,       size=42			,       reduce_labels=A	)
      self.assertEqual(image_processor.size			,       {'''height''': 42, '''width''': 42}	)
      self.assertEqual(image_processor.do_reduce_labels			,       A	)



 def  a__  (self	)   ->					Tuple:


      """simple docstring"""



      pass



 def  a__  (self	)   ->					Any:


      """simple docstring"""



      _a     =  self.image_processing_class(**self.image_processor_dict	)
      # create random PIL images
      _a     =  prepare_image_inputs(self.image_processor_tester			,       equal_resolution=A	)
      for image in image_inputs:
           self.assertIsInstance(A			,       Image.Image	)

      # Test not batched input
      _a     =  image_processing(image_inputs[0]			,       return_tensors='''pt'''	).pixel_values
      self.assertEqual(
          encoded_images.shape			,       (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )

      # Test batched
      _a     =  image_processing(A			,       return_tensors='''pt'''	).pixel_values
      self.assertEqual(
          encoded_images.shape			,       (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )



 def  a__  (self	)   ->					Union[str, Any]:


      """simple docstring"""



      _a     =  self.image_processing_class(**self.image_processor_dict	)
      # create random numpy tensors
      _a     =  prepare_image_inputs(self.image_processor_tester			,       equal_resolution=A			,       numpify=A	)
      for image in image_inputs:
           self.assertIsInstance(A			,       np.ndarray	)

      # Test not batched input
      _a     =  image_processing(image_inputs[0]			,       return_tensors='''pt'''	).pixel_values
      self.assertEqual(
          encoded_images.shape			,       (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )

      # Test batched
      _a     =  image_processing(A			,       return_tensors='''pt'''	).pixel_values
      self.assertEqual(
          encoded_images.shape			,       (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )



 def  a__  (self	)   ->					int:


      """simple docstring"""



      _a     =  self.image_processing_class(**self.image_processor_dict	)
      # create random PyTorch tensors
      _a     =  prepare_image_inputs(self.image_processor_tester			,       equal_resolution=A			,       torchify=A	)
      for image in image_inputs:
           self.assertIsInstance(A			,       torch.Tensor	)

      # Test not batched input
      _a     =  image_processing(image_inputs[0]			,       return_tensors='''pt'''	).pixel_values
      self.assertEqual(
          encoded_images.shape			,       (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )

      # Test batched
      _a     =  image_processing(A			,       return_tensors='''pt'''	).pixel_values
      self.assertEqual(
          encoded_images.shape			,       (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )



 def  a__  (self	)   ->					Optional[int]:


      """simple docstring"""



      _a     =  self.image_processing_class(**self.image_processor_dict	)
      # create random PyTorch tensors
      _a     =  prepare_image_inputs(self.image_processor_tester			,       equal_resolution=A			,       torchify=A	)
      _a     =  []
      for image in image_inputs:
           self.assertIsInstance(A			,       torch.Tensor	)
           maps.append(torch.zeros(image.shape[-2:]	).long()	)

      # Test not batched input
      _a     =  image_processing(image_inputs[0]			,       maps[0]			,       return_tensors='''pt'''	)
      self.assertEqual(
          encoding['''pixel_values'''].shape			,       (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(
          encoding['''labels'''].shape			,       (
              1,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(encoding['''labels'''].dtype			,       torch.long	)
      self.assertTrue(encoding['''labels'''].min().item() >= 0	)
      self.assertTrue(encoding['''labels'''].max().item() <= 255	)

      # Test batched
      _a     =  image_processing(A			,       A			,       return_tensors='''pt'''	)
      self.assertEqual(
          encoding['''pixel_values'''].shape			,       (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(
          encoding['''labels'''].shape			,       (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(encoding['''labels'''].dtype			,       torch.long	)
      self.assertTrue(encoding['''labels'''].min().item() >= 0	)
      self.assertTrue(encoding['''labels'''].max().item() <= 255	)

      # Test not batched input (PIL images)
      _a     =  prepare_semantic_single_inputs()

      _a     =  image_processing(A			,       A			,       return_tensors='''pt'''	)
      self.assertEqual(
          encoding['''pixel_values'''].shape			,       (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(
          encoding['''labels'''].shape			,       (
              1,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(encoding['''labels'''].dtype			,       torch.long	)
      self.assertTrue(encoding['''labels'''].min().item() >= 0	)
      self.assertTrue(encoding['''labels'''].max().item() <= 255	)

      # Test batched input (PIL images)
      _a     =  prepare_semantic_batch_inputs()

      _a     =  image_processing(A			,       A			,       return_tensors='''pt'''	)
      self.assertEqual(
          encoding['''pixel_values'''].shape			,       (
              2,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(
          encoding['''labels'''].shape			,       (
              2,
              self.image_processor_tester.size['''height'''],
              self.image_processor_tester.size['''width'''],
          )			,       )
      self.assertEqual(encoding['''labels'''].dtype			,       torch.long	)
      self.assertTrue(encoding['''labels'''].min().item() >= 0	)
      self.assertTrue(encoding['''labels'''].max().item() <= 255	)



 def  a__  (self	)   ->					List[str]:


      """simple docstring"""



      _a     =  self.image_processing_class(**self.image_processor_dict	)

      # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
      _a     =  prepare_semantic_single_inputs()
      _a     =  image_processing(A			,       A			,       return_tensors='''pt'''	)
      self.assertTrue(encoding['''labels'''].min().item() >= 0	)
      self.assertTrue(encoding['''labels'''].max().item() <= 150	)

      _a     =  True
      _a     =  image_processing(A			,       A			,       return_tensors='''pt'''	)
      self.assertTrue(encoding['''labels'''].min().item() >= 0	)
      self.assertTrue(encoding['''labels'''].max().item() <= 255	)








'''simple docstring'''





from typing import TYPE_CHECKING

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


lowercase_			=  {
    "configuration_segformer": ["SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "SegformerConfig", "SegformerOnnxConfig"]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase_			=  ["SegformerFeatureExtractor"]
  lowercase_			=  ["SegformerImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase_			=  [
      "SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "SegformerDecodeHead",
      "SegformerForImageClassification",
      "SegformerForSemanticSegmentation",
      "SegformerLayer",
      "SegformerModel",
      "SegformerPreTrainedModel",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase_			=  [
      "TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "TFSegformerDecodeHead",
      "TFSegformerForImageClassification",
      "TFSegformerForSemanticSegmentation",
      "TFSegformerModel",
      "TFSegformerPreTrainedModel",
  ]


if TYPE_CHECKING:
  from .configuration_segformer import SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SegformerConfig, SegformerOnnxConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_segformer import SegformerFeatureExtractor
    from .image_processing_segformer import SegformerImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_segformer import (
        SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        SegformerDecodeHead,
        SegformerForImageClassification,
        SegformerForSemanticSegmentation,
        SegformerLayer,
        SegformerModel,
        SegformerPreTrainedModel,
    )
  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_segformer import (
        TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFSegformerDecodeHead,
        TFSegformerForImageClassification,
        TFSegformerForSemanticSegmentation,
        TFSegformerModel,
        TFSegformerPreTrainedModel,
    )

else:
  import sys

  lowercase_			=  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



