


'''simple docstring'''






import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


__A :  Optional[int]    							=				False






@skip_mps
class        __snake_case	(       _SCREAMING_SNAKE_CASE     ,_SCREAMING_SNAKE_CASE     ,_SCREAMING_SNAKE_CASE     ,unittest.TestCase):







    """simple docstring"""



    lowercase       			= StableDiffusionAttendAndExcitePipeline
    lowercase       			= False
    lowercase       			= TEXT_TO_IMAGE_PARAMS
    lowercase       			= TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'})
    lowercase       			= TEXT_TO_IMAGE_IMAGE_PARAMS
    lowercase       			= TEXT_TO_IMAGE_IMAGE_PARAMS

    @classmethod
    def __lowercase       (       cls   :  Dict		)       ->  Any:
      super().setUpClass()
      torch.use_deterministic_algorithms(lowerCamelCase		)

    @classmethod
    def __lowercase       (       cls   :  Union[str, Any]		)       ->  List[str]:
      super().tearDownClass()
      torch.use_deterministic_algorithms(lowerCamelCase		)

    def __lowercase       (       self   :  Tuple		)       ->  List[Any]:
      torch.manual_seed(0		)
      lowerCAmelCase_      :				Any      =       UNetaDConditionModel(
          block_out_channels=(32, 64)   ,						layers_per_block=1   ,						sample_size=32   ,						in_channels=4   ,						out_channels=4   ,						down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   ,						up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   ,						cross_attention_dim=32   ,						attention_head_dim=(2, 4)   ,						use_linear_projection=lowerCamelCase   ,						)
      lowerCAmelCase_      :				Optional[Any]      =       DDIMScheduler(
          beta_start=0.00_085   ,						beta_end=0.012   ,						beta_schedule="""scaled_linear"""   ,						clip_sample=lowerCamelCase   ,						set_alpha_to_one=lowerCamelCase   ,						)
      torch.manual_seed(0		)
      lowerCAmelCase_      :				List[Any]      =       AutoencoderKL(
          block_out_channels=[32, 64]   ,						in_channels=3   ,						out_channels=3   ,						down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   ,						up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   ,						latent_channels=4   ,						sample_size=1_28   ,						)
      torch.manual_seed(0		)
      lowerCAmelCase_      :				List[Any]      =       CLIPTextConfig(
          bos_token_id=0   ,						eos_token_id=2   ,						hidden_size=32   ,						intermediate_size=37   ,						layer_norm_eps=1E-05   ,						num_attention_heads=4   ,						num_hidden_layers=5   ,						pad_token_id=1   ,						vocab_size=10_00   ,						hidden_act="""gelu"""   ,						projection_dim=5_12   ,						)
      lowerCAmelCase_      :				List[str]      =       CLIPTextModel(lowerCamelCase		)
      lowerCAmelCase_      :				List[Any]      =       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""		)

      lowerCAmelCase_      :				int      =       {
          """unet""": unet,
          """scheduler""": scheduler,
          """vae""": vae,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """safety_checker""": None,
          """feature_extractor""": None,
      }

      return components

    def __lowercase       (       self   :  Tuple   ,						lowerCamelCase   :  Any   ,						lowerCamelCase   :  List[Any]=0		)       ->  Tuple:
      if str(lowerCamelCase		).startswith("""mps"""		):
        lowerCAmelCase_      :				List[str]      =       torch.manual_seed(lowerCamelCase		)
      else:
        lowerCAmelCase_      :				Optional[int]      =       torch.Generator(device=lowerCamelCase		).manual_seed(lowerCamelCase		)
      lowerCAmelCase_      :				List[str]      =       {
          """prompt""": """a cat and a frog""",
          """token_indices""": [2, 5],
          """generator""": generator,
          """num_inference_steps""": 1,
          """guidance_scale""": 6.0,
          """output_type""": """numpy""",
          """max_iter_to_alter""": 2,
          """thresholds""": {0: 0.7},
      }
      return inputs

    def __lowercase       (       self   :  Tuple		)       ->  str:
      lowerCAmelCase_      :				Any      =       """cpu"""

      lowerCAmelCase_      :				Optional[int]      =       self.get_dummy_components()
      lowerCAmelCase_      :				List[str]      =       self.pipeline_class(**lowerCamelCase		)
      pipe.to(lowerCamelCase		)
      pipe.set_progress_bar_config(disable=lowerCamelCase		)

      lowerCAmelCase_      :				Dict      =       self.get_dummy_inputs(lowerCamelCase		)
      lowerCAmelCase_      :				Any      =       pipe(**lowerCamelCase		).images
      lowerCAmelCase_      :				Union[str, Any]      =       image[0, -3:, -3:, -1]

      self.assertEqual(image.shape   ,						(1, 64, 64, 3)		)
      lowerCAmelCase_      :				int      =       np.array(
          [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496]		)
      lowerCAmelCase_      :				int      =       np.abs(image_slice.flatten() - expected_slice		).max()
      self.assertLessEqual(lowerCamelCase   ,						1E-3		)

    def __lowercase       (       self   :  List[str]		)       ->  List[Any]:
      super().test_cpu_offload_forward_pass(expected_max_diff=5E-4		)

    def __lowercase       (       self   :  Any		)       ->  Any:
      # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
      self._test_inference_batch_consistent(batch_sizes=[1, 2]		)

    def __lowercase       (       self   :  List[str]		)       ->  Dict:
      self._test_inference_batch_single_identical(batch_size=2   ,						expected_max_diff=7E-4		)

    def __lowercase       (       self   :  Tuple		)       ->  Optional[int]:
      super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3		)

    def __lowercase       (       self   :  Dict		)       ->  str:
      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4		)

    def __lowercase       (       self   :  List[Any]		)       ->  int:
      super().test_save_load_local(expected_max_difference=5E-4		)





    def __lowercase       (       self   :  Optional[Any]		)       ->  Any:
      super().test_save_load_optional_components(expected_max_difference=4E-4		)







@require_torch_gpu
@slow
class        __snake_case	(       unittest.TestCase):







    """simple docstring"""



    @classmethod
    def __lowercase       (       cls   :  Tuple		)       ->  List[str]:
      super().setUpClass()
      torch.use_deterministic_algorithms(lowerCamelCase		)

    @classmethod
    def __lowercase       (       cls   :  Tuple		)       ->  Tuple:
      super().tearDownClass()
      torch.use_deterministic_algorithms(lowerCamelCase		)

    def __lowercase       (       self   :  Tuple		)       ->  List[Any]:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()





    def __lowercase       (       self   :  List[str]		)       ->  Union[str, Any]:
      lowerCAmelCase_      :				List[Any]      =       torch.manual_seed(51		)

      lowerCAmelCase_      :				str      =       StableDiffusionAttendAndExcitePipeline.from_pretrained(
          """CompVis/stable-diffusion-v1-4"""   ,						safety_checker=lowerCamelCase   ,						torch_dtype=torch.floataa		)
      pipe.to("""cuda"""		)

      lowerCAmelCase_      :				List[Any]      =       """a painting of an elephant with glasses"""
      lowerCAmelCase_      :				str      =       [5, 7]

      lowerCAmelCase_      :				int      =       pipe(
          prompt=lowerCamelCase   ,						token_indices=lowerCamelCase   ,						guidance_scale=7.5   ,						generator=lowerCamelCase   ,						num_inference_steps=5   ,						max_iter_to_alter=5   ,						output_type="""numpy"""   ,						).images[0]

      lowerCAmelCase_      :				Optional[int]      =       load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy"""		)
      assert np.abs((expected_image - image).max()		) < 5E-1







'''simple docstring'''






from pathlib import Path

import cva
import numpy as np
from matplotlib import pyplot as plt







def     UpperCamelCase_      (   A__ :       np.ndarray							,   A__ :       np.ndarray							,   A__ :       np.ndarray							,   A__ :       int							,   A__ :       int ):
  '''simple docstring'''





  lowerCAmelCase_      :				List[Any]      =       cva.getAffineTransform(A__							,   A__ )
  return cva.warpAffine(A__							,   A__							,   (rows, cols) )


if __name__ == "__main__":
  # read original image
  __A :  Dict    							=				cva.imread(
      str(Path(__file__).resolve().parent.parent / "image_data" / "lena.jpg")
  )
  # turn image in gray scale value
  __A :  List[Any]    							=				cva.cvtColor(image, cva.COLOR_BGR2GRAY)
  # get image shape
  __A							,			__A :  Dict    							=				gray_img.shape

  # set different points to rotate image
  __A :  List[str]    							=				np.array([[50, 50], [200, 50], [50, 200]], np.floataa)
  __A :  Tuple    							=				np.array([[10, 100], [200, 50], [100, 250]], np.floataa)
  __A :  List[Any]    							=				np.array([[50, 50], [150, 50], [120, 200]], np.floataa)
  __A :  Optional[Any]    							=				np.array([[10, 100], [80, 50], [180, 250]], np.floataa)

  # add all rotated images in a list
  __A :  Optional[Any]    							=				[
      gray_img,
      get_rotation(gray_img, ptsa, ptsa, img_rows, img_cols),
      get_rotation(gray_img, ptsa, ptsa, img_rows, img_cols),
      get_rotation(gray_img, ptsa, ptsa, img_rows, img_cols),
  ]

  # plot different image rotations
  __A :  Dict    							=				plt.figure(1)
  __A :  Optional[Any]    							=				["Original", "Rotation 1", "Rotation 2", "Rotation 3"]
  for i, image in enumerate(images):
    plt.subplot(2, 2, i + 1), plt.imshow(image, "gray")
    plt.title(titles[i])
    plt.axis("off")
    plt.subplots_adjust(left=0.0, bottom=0.0_5, right=1.0, top=0.9_5)
  plt.show()



