


'''simple docstring'''



import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

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


enable_full_determinism()






@skip_mps
class 	UpperCamelCase__(       lowerCAmelCase						,    unittest.TestCase	):
				__magic_name__    :				Optional[int]  		=	TextToVideoSDPipeline
				__magic_name__    :				List[Any]  		=	TEXT_TO_IMAGE_PARAMS
				__magic_name__    :				List[str]  		=	TEXT_TO_IMAGE_BATCH_PARAMS
				# No `output_type`.
				__magic_name__    :				List[Any]  		=	frozenset(
				    [
				        "num_inference_steps",
				        "generator",
				        "latents",
				        "return_dict",
				        "callback",
				        "callback_steps",
				    ]	)




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

										"""simple docstring"""




										torch.manual_seed(0				)
										UpperCAmelCase					    =     UNetaDConditionModel(
										    block_out_channels=(32, 64, 64, 64)				,   layers_per_block=2				,   sample_size=32				,   in_channels=4				,   out_channels=4				,   down_block_types=('''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''CrossAttnDownBlock3D''', '''DownBlock3D''')				,   up_block_types=('''UpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''', '''CrossAttnUpBlock3D''')				,   cross_attention_dim=32				,   attention_head_dim=4				,   )
										UpperCAmelCase					    =     DDIMScheduler(
										    beta_start=0.00085				,   beta_end=0.012				,   beta_schedule='''scaled_linear'''				,   clip_sample=lowerCAmelCase				,   set_alpha_to_one=lowerCAmelCase				,   )
										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				,   sample_size=128				,   )
										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=1000				,   hidden_act='''gelu'''				,   projection_dim=512				,   )
										UpperCAmelCase					    =     CLIPTextModel(lowerCAmelCase				)
										UpperCAmelCase					    =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

										UpperCAmelCase					    =     {
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''vae''': vae,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										}
										return components




				def 					a__(		self      :			str				,   lowerCAmelCase      :			int				,   lowerCAmelCase      :			Optional[Any]=0				)->					Dict:

										"""simple docstring"""




										if str(lowerCAmelCase				).startswith('''mps'''				):
																UpperCAmelCase					    =     torch.manual_seed(lowerCAmelCase				)
										else:
																UpperCAmelCase					    =     torch.Generator(device=lowerCAmelCase				).manual_seed(lowerCAmelCase				)
										UpperCAmelCase					    =     {
										    '''prompt''': '''A painting of a squirrel eating a burger''',
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''guidance_scale''': 6.0,
										    '''output_type''': '''pt''',
										}
										return inputs




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

										"""simple docstring"""




										UpperCAmelCase					    =     '''cpu'''  # ensure determinism for the device-dependent torch.Generator
										UpperCAmelCase					    =     self.get_dummy_components()
										UpperCAmelCase					    =     TextToVideoSDPipeline(**lowerCAmelCase				)
										UpperCAmelCase					    =     sd_pipe.to(lowerCAmelCase				)
										sd_pipe.set_progress_bar_config(disable=lowerCAmelCase				)

										UpperCAmelCase					    =     self.get_dummy_inputs(lowerCAmelCase				)
										UpperCAmelCase					    =     '''np'''
										UpperCAmelCase					    =     sd_pipe(**lowerCAmelCase				).frames
										UpperCAmelCase					    =     frames[0][-3:, -3:, -1]

										assert frames[0].shape == (64, 64, 3)
										UpperCAmelCase					    =     np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]				)

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




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

										"""simple docstring"""




										self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCAmelCase				,   expected_max_diff=3E-3				)




				@unittest.skipIf(
				    torch_device != '''cuda''' or not is_xformers_available()				,   reason='''XFormers attention is only available with CUDA and `xformers` installed'''				,   )
				def 					a__(		self      :			List[str]				)->					str:

										"""simple docstring"""




										self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase				,   expected_max_diff=1E-2				)




				@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''				)
				def 					a__(		self      :			Union[str, Any]				)->					str:

										"""simple docstring"""




										pass




				@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''				)
				def 					a__(		self      :			List[Any]				)->					int:

										"""simple docstring"""




										pass




				@unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''				)
				def 					a__(		self      :			int				)->					Tuple:

										"""simple docstring"""




										pass





				def 					a__(		self      :			Dict				)->					Optional[Any]:

										"""simple docstring"""




										return super().test_progress_bar()







@slow
@skip_mps
class 	UpperCamelCase__(       unittest.TestCase	):




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

										"""simple docstring"""




										UpperCAmelCase					    =     load_numpy(
										    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'''				)

										UpperCAmelCase					    =     TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''				)
										UpperCAmelCase					    =     DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
										UpperCAmelCase					    =     pipe.to('''cuda'''				)

										UpperCAmelCase					    =     '''Spiderman is surfing'''
										UpperCAmelCase					    =     torch.Generator(device='''cpu'''				).manual_seed(0				)

										UpperCAmelCase					    =     pipe(lowerCAmelCase				,   generator=lowerCAmelCase				,   num_inference_steps=25				,   output_type='''pt'''				).frames
										UpperCAmelCase					    =     video_frames.cpu().numpy()

										assert np.abs(expected_video - video				).mean() < 5E-2





				def 					a__(		self      :			int				)->					str:

										"""simple docstring"""




										UpperCAmelCase					    =     load_numpy(
										    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'''				)

										UpperCAmelCase					    =     TextToVideoSDPipeline.from_pretrained('''damo-vilab/text-to-video-ms-1.7b'''				)
										UpperCAmelCase					    =     pipe.to('''cuda'''				)

										UpperCAmelCase					    =     '''Spiderman is surfing'''
										UpperCAmelCase					    =     torch.Generator(device='''cpu'''				).manual_seed(0				)

										UpperCAmelCase					    =     pipe(lowerCAmelCase				,   generator=lowerCAmelCase				,   num_inference_steps=2				,   output_type='''pt'''				).frames
										UpperCAmelCase					    =     video_frames.cpu().numpy()

										assert np.abs(expected_video - video				).mean() < 5E-2









'''simple docstring'''



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


def 				lowerCamelCase__				(	A       :      int				,       A       :      int				,       A       :      int				,       A       :      int				,       A       :      int				,       A       :      int					):




						'''simple docstring'''






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

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

																		# degree to radiant
																		UpperCAmelCase					    =     theta / 1_80 * 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
	_lowercase      :      Tuple            =					imread("""../image_data/lena.jpg""")
	# turn image in gray scale value
	_lowercase      :      int            =					cvtColor(img, COLOR_BGR2GRAY)

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

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

	waitKey(0)





