



'''simple docstring'''


import numpy as np
from cva import COLOR_BGR2GRAY, CV_8UC3, cvtColor, filteraD, imread, imshow, waitKey







def 				__lowerCamelCase				(   A__    ,						A__    ,						A__    ,						A__    ,						A__    ,						A__    )       ->	np.ndarray:






   """simple docstring"""





   if (ksize % 2) == 0:
      UpperCamelCase					=  ksize + 1
   UpperCamelCase					=  np.zeros((ksize, ksize)    ,						dtype=np.floataa    )

   # each value
   for y in range(__snake_case    ):
      for x in range(__snake_case    ):
         # distance from center
         UpperCamelCase					=  x - ksize // 2
         UpperCamelCase					=  y - ksize // 2

         # degree to radiant
         UpperCamelCase					=  theta / 180 * np.pi
         UpperCamelCase					=  np.cos(_theta    )
         UpperCamelCase					=  np.sin(_theta    )

         # get kernel x
         UpperCamelCase					=  cos_theta * px + sin_theta * py

         # get kernel y
         UpperCamelCase					=  -sin_theta * px + cos_theta * py

         # fill kernel
         UpperCamelCase					=  np.exp(
             -(_x**2 + gamma**2 * _y**2) / (2 * sigma**2)    ) * np.cos(2 * np.pi * _x / lambd + psi    )

   return gabor


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   # read original image
   _lowerCamelCase	:       Tuple      	=	imread("../image_data/lena.jpg")
   # turn image in gray scale value
   _lowerCamelCase	:       Dict      	=	cvtColor(img, COLOR_BGR2GRAY)

   # Apply multiple Kernel to detect edges
   _lowerCamelCase	:       List[Any]      	=	np.zeros(gray.shape[:2])
   for theta in [0, 30, 60, 90, 120, 150]:
      _lowerCamelCase	:       Tuple      	=	gabor_filter_kernel(10, 8, theta, 10, 0, 0)
      out += filteraD(gray, CV_8UC3, kernel_aa)
   _lowerCamelCase	:       Optional[Any]      	=	out / out.max() * 255
   _lowerCamelCase	:       Optional[int]      	=	out.astype(np.uinta)

   imshow("Original", gray)
   imshow("Gabor filter with 20x20 mask and 6 directions", out)

   waitKey(0)



"""simple docstring"""





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()






@skip_mps
class     _UpperCAmelCase(    lowerCamelCase      ,     lowerCamelCase      ,     unittest.TestCase	):
		lowercase__						=      StableDiffusionPanoramaPipeline
		lowercase__						=      TEXT_TO_IMAGE_PARAMS
		lowercase__						=      TEXT_TO_IMAGE_BATCH_PARAMS
		lowercase__						=      TEXT_TO_IMAGE_IMAGE_PARAMS
		lowercase__						=      TEXT_TO_IMAGE_IMAGE_PARAMS



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							torch.manual_seed(0)
							_UpperCamelCase							 =  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				,		)
							_UpperCamelCase							 =  DDIMScheduler()
							torch.manual_seed(0)
							_UpperCamelCase							 =  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				,		)
							torch.manual_seed(0)
							_UpperCamelCase							 =  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				,		)
							_UpperCamelCase							 =  CLIPTextModel(__a)
							_UpperCamelCase							 =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

							_UpperCamelCase							 =  {
							    '''unet''': unet,
							    '''scheduler''': scheduler,
							    '''vae''': vae,
							    '''text_encoder''': text_encoder,
							    '''tokenizer''': tokenizer,
							    '''safety_checker''': None,
							    '''feature_extractor''': None,
							}
							return components



		def 						UpperCAmelCase							(					self				,		__a				,		__a=0)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  torch.manual_seed(__a)
							_UpperCamelCase							 =  {
							    '''prompt''': '''a photo of the dolomites''',
							    '''generator''': generator,
							    # Setting height and width to None to prevent OOMs on CPU.
							    '''height''': None,
							    '''width''': None,
							    '''num_inference_steps''': 1,
							    '''guidance_scale''': 6.0,
							    '''output_type''': '''numpy''',
							}
							return inputs



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]
							assert image.shape == (1, 64, 64, 3)

							_UpperCamelCase							 =  np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757])

							assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2



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






							'''simple docstring'''
							super().test_inference_batch_consistent(batch_sizes=[1, 2])



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							super().test_inference_batch_single_identical(batch_size=2				,		expected_max_diff=3.25e-3)



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






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  '''french fries'''
							_UpperCamelCase							 =  sd_pipe(**__a				,		negative_prompt=__a)
							_UpperCamelCase							 =  output.images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							_UpperCamelCase							 =  np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757])

							assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a				,		view_batch_size=2)
							_UpperCamelCase							 =  output.images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							_UpperCamelCase							 =  np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757])

							assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  EulerAncestralDiscreteScheduler(
							    beta_start=0.0_0085				,		beta_end=0.012				,		beta_schedule='''scaled_linear''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							_UpperCamelCase							 =  np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952])

							assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2




		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							_UpperCamelCase							 =  self.get_dummy_components()
							_UpperCamelCase							 =  PNDMScheduler(
							    beta_start=0.0_0085				,		beta_end=0.012				,		beta_schedule='''scaled_linear'''				,		skip_prk_steps=__a)
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline(**__a)
							_UpperCamelCase							 =  sd_pipe.to(__a)
							sd_pipe.set_progress_bar_config(disable=__a)

							_UpperCamelCase							 =  self.get_dummy_inputs(__a)
							_UpperCamelCase							 =  sd_pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							_UpperCamelCase							 =  np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539])

							assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2






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



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



		def 						UpperCAmelCase							(					self				,		__a=0)       ->       List[str]:






							'''simple docstring'''
							_UpperCamelCase							 =  torch.manual_seed(__a)
							_UpperCamelCase							 =  {
							    '''prompt''': '''a photo of the dolomites''',
							    '''generator''': generator,
							    '''num_inference_steps''': 3,
							    '''guidance_scale''': 7.5,
							    '''output_type''': '''numpy''',
							}
							return inputs



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  '''stabilityai/stable-diffusion-2-base'''
							_UpperCamelCase							 =  DDIMScheduler.from_pretrained(__a				,		subfolder='''scheduler''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(__a				,		scheduler=__a				,		safety_checker=__a)
							pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing()

							_UpperCamelCase							 =  self.get_inputs()
							_UpperCamelCase							 =  pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 5_12, 20_48, 3)

							_UpperCamelCase							 =  np.array(
							    [
							        0.3696_8392,
							        0.2702_5372,
							        0.3244_6766,
							        0.2837_9387,
							        0.3636_3274,
							        0.3073_3347,
							        0.2710_0027,
							        0.2705_4125,
							        0.2553_6096,
							    ])

							assert np.abs(expected_slice - image_slice).max() < 1e-2



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(
							    '''stabilityai/stable-diffusion-2-base'''				,		safety_checker=__a)
							_UpperCamelCase							 =  LMSDiscreteScheduler.from_config(pipe.scheduler.config)
							pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing()

							_UpperCamelCase							 =  self.get_inputs()
							_UpperCamelCase							 =  pipe(**__a).images
							_UpperCamelCase							 =  image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 5_12, 20_48, 3)

							_UpperCamelCase							 =  np.array(
							    [
							        [
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							            0.0,
							        ]
							    ])

							assert np.abs(expected_slice - image_slice).max() < 1e-3



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  0

							def callback_fn(__a				,		__a				,		__a) -> None:
												_UpperCamelCase							 =  True
												nonlocal number_of_steps
												number_of_steps += 1
												if step == 1:
																	_UpperCamelCase							 =  latents.detach().cpu().numpy()
																	assert latents.shape == (1, 4, 64, 2_56)
																	_UpperCamelCase							 =  latents[0, -3:, -3:, -1]

																	_UpperCamelCase							 =  np.array(
																	    [
																	        0.1868_1869,
																	        0.3390_7816,
																	        0.536_1276,
																	        0.1443_2865,
																	        -0.0285_6611,
																	        -0.7394_1123,
																	        0.2339_7987,
																	        0.4732_2682,
																	        -0.3782_3164,
																	    ])
																	assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2
												elif step == 2:
																	_UpperCamelCase							 =  latents.detach().cpu().numpy()
																	assert latents.shape == (1, 4, 64, 2_56)
																	_UpperCamelCase							 =  latents[0, -3:, -3:, -1]

																	_UpperCamelCase							 =  np.array(
																	    [
																	        0.1853_9645,
																	        0.3398_7248,
																	        0.537_8559,
																	        0.1443_7142,
																	        -0.0245_5261,
																	        -0.733_8317,
																	        0.2399_0755,
																	        0.4735_6272,
																	        -0.378_6505,
																	    ])

																	assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2

							_UpperCamelCase							 =  False

							_UpperCamelCase							 =  '''stabilityai/stable-diffusion-2-base'''
							_UpperCamelCase							 =  DDIMScheduler.from_pretrained(__a				,		subfolder='''scheduler''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(__a				,		scheduler=__a				,		safety_checker=__a)
							_UpperCamelCase							 =  pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing()

							_UpperCamelCase							 =  self.get_inputs()
							pipe(**__a				,		callback=__a				,		callback_steps=1)
							assert callback_fn.has_been_called
							assert number_of_steps == 3




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






							'''simple docstring'''
							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							_UpperCamelCase							 =  '''stabilityai/stable-diffusion-2-base'''
							_UpperCamelCase							 =  DDIMScheduler.from_pretrained(__a				,		subfolder='''scheduler''')
							_UpperCamelCase							 =  StableDiffusionPanoramaPipeline.from_pretrained(__a				,		scheduler=__a				,		safety_checker=__a)
							_UpperCamelCase							 =  pipe.to(__a)
							pipe.set_progress_bar_config(disable=__a)
							pipe.enable_attention_slicing(1)
							pipe.enable_sequential_cpu_offload()

							_UpperCamelCase							 =  self.get_inputs()
							_UpperCamelCase							 =  pipe(**__a)

							_UpperCamelCase							 =  torch.cuda.max_memory_allocated()
							# make sure that less than 5.2 GB is allocated
							assert mem_bytes < 5.5 * 10**9






