



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






def  UpperCAmelCase__    (    lowercase__						,       lowercase__						,       lowercase__						,       lowercase__						,       lowercase__						,       lowercase__   ) ->      str:






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

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

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

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

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

                  # fill kernel
                  __lowercase					=				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
   UpperCamelCase__ =						imread("../image_data/lena.jpg")
   # turn image in gray scale value
   UpperCamelCase__ =						cvtColor(img, COLOR_BGR2GRAY)

   # Apply multiple Kernel to detect edges
   UpperCamelCase__ =						np.zeros(gray.shape[:2])
   for theta in [0, 30, 60, 90, 1_20, 1_50]:
      UpperCamelCase__ =						gabor_filter_kernel(10, 8, theta, 10, 0, 0)
      out += filteraD(gray, CV_8UC3, kernel_aa)
   UpperCamelCase__ =						out / out.max() * 2_55
   UpperCamelCase__ =						out.astype(np.uinta)

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

   waitKey(0)










import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin
@skip_mps
class 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  int      =			IFImgaImgSuperResolutionPipeline
			lowercase__      :  Optional[int]      =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
			lowercase__      :  Optional[int]      =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}			)
			lowercase__      :  Tuple      =			PipelineTesterMixin.required_optional_params - {"""latents"""}





			def 		snake_case__			(				self	:       Tuple   )						->					Any:
									"""simple docstring"""







									return self._get_superresolution_dummy_components()





			def 		snake_case__			(				self	:       List[str]			,     lowercase	:       Optional[int]			,     lowercase	:       Optional[Any]=0   )						->					Union[str, Any]:
									"""simple docstring"""







									if str(lowercase   ).startswith("""mps"""   ):
															__lowercase					=				torch.manual_seed(lowercase   )
									else:
															__lowercase					=				torch.Generator(device=lowercase   ).manual_seed(lowercase   )

									__lowercase					=				floats_tensor((1, 3, 32, 32)			,     rng=random.Random(lowercase   )   ).to(lowercase   )
									__lowercase					=				floats_tensor((1, 3, 16, 16)			,     rng=random.Random(lowercase   )   ).to(lowercase   )

									__lowercase					=				{
									    """prompt""": """A painting of a squirrel eating a burger""",
									    """image""": image,
									    """original_image""": original_image,
									    """generator""": generator,
									    """num_inference_steps""": 2,
									    """output_type""": """numpy""",
									}

									return inputs





			@unittest.skipIf(
			    torch_device != """cuda""" or not is_xformers_available()			,     reason="""XFormers attention is only available with CUDA and `xformers` installed"""			,     )
			def 		snake_case__			(				self	:       Optional[Any]   )						->					Tuple:
									"""simple docstring"""







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )





			def 		snake_case__			(				self	:       List[Any]   )						->					Union[str, Any]:
									"""simple docstring"""







									self._test_save_load_optional_components()





			@unittest.skipIf(torch_device != """cuda"""			,     reason="""float16 requires CUDA"""   )
			def 		snake_case__			(				self	:       List[Any]   )						->					Dict:
									"""simple docstring"""







									super().test_save_load_floataa(expected_max_diff=1E-1   )





			def 		snake_case__			(				self	:       Dict   )						->					int:
									"""simple docstring"""







									self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )





			def 		snake_case__			(				self	:       Optional[Any]   )						->					int:
									"""simple docstring"""







									self._test_save_load_local()







			def 		snake_case__			(				self	:       Optional[int]   )						->					Optional[int]:
									"""simple docstring"""







									self._test_inference_batch_single_identical(
									    expected_max_diff=1E-2			,     )





