





"""simple docstring"""




import cva
import numpy as np


class  __UpperCamelCase       :






							def __init__(     self   ,      lowerCAmelCase__   ,      lowerCAmelCase__   )			->				Tuple:

								if k in (0.04, 0.06):
									a   :	int			=       k
									a   :	Dict			=       window_size
								else:
									raise ValueError("invalid k value"   )






							def __str__(     self   )			->				str:
								return str(self.k   )






							def 					__a     (     self   ,      lowerCAmelCase__   )			->				tuple[cva.Mat, list[list[int]]]:
								a   :	Optional[int]			=       cva.imread(lowerCAmelCase__   ,      0   )
								a, a   :	List[Any]			=       img.shape
								a   :	list[list[int]]			=       []
								a   :	List[Any]			=       img.copy()
								a   :	Union[str, Any]			=       cva.cvtColor(lowerCAmelCase__   ,      cva.COLOR_GRAY2RGB   )
								a, a   :	Optional[int]			=       np.gradient(lowerCAmelCase__   )
								a   :	int			=       dx**2
								a   :	Any			=       dy**2
								a   :	Any			=       dx * dy
								a   :	Dict			=       0.04
								a   :	List[Any]			=       self.window_size // 2
								for y in range(lowerCAmelCase__   ,      h - offset   ):
									for x in range(lowerCAmelCase__   ,      w - offset   ):
										a   :	List[str]			=       ixx[
										    y - offset : y + offset + 1, x - offset : x + offset + 1
										].sum()
										a   :	List[str]			=       iyy[
										    y - offset : y + offset + 1, x - offset : x + offset + 1
										].sum()
										a   :	Tuple			=       ixy[
										    y - offset : y + offset + 1, x - offset : x + offset + 1
										].sum()

										a   :	Any			=       (wxx * wyy) - (wxy**2)
										a   :	int			=       wxx + wyy
										a   :	List[str]			=       det - k * (trace**2)
										# Can change the value
										if r > 0.5:
											corner_list.append([x, y, r]   )
											color_img.itemset((y, x, 0)   ,      0   )
											color_img.itemset((y, x, 1)   ,      0   )
											color_img.itemset((y, x, 2)   ,      255   )
								return color_img, corner_list


if __name__ == "__main__":
		a		:				int  			=    HarrisCorner(0.04, 3)
		a			,				a		:				str  			=    edge_detect.detect('''path_to_image''')
		cva.imwrite('''detect.png''', color_img)









"""simple docstring"""




import unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible


class  __UpperCamelCase       (		unittest.TestCase		):






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	Optional[int]			=       [
								    "safety_checker/pytorch_model.bin",
								    "safety_checker/model.safetensors",
								    "vae/diffusion_pytorch_model.bin",
								    "vae/diffusion_pytorch_model.safetensors",
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	str			=       [
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Dict:
								a   :	List[str]			=       [
								    "safety_checker/pytorch_model.bin",
								    "safety_checker/model.safetensors",
								    "vae/diffusion_pytorch_model.bin",
								    "vae/diffusion_pytorch_model.safetensors",
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								    "unet/diffusion_pytorch_model.bin",
								    # Removed: 'unet/diffusion_pytorch_model.safetensors',
								]
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				List[Any]:
								a   :	Optional[Any]			=       [
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								]
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Tuple:
								a   :	Tuple			=       [
								    "safety_checker/pytorch_model.bin",
								    "safety_checker/model.safetensors",
								    "vae/diffusion_pytorch_model.bin",
								    "vae/diffusion_pytorch_model.safetensors",
								    "text_encoder/pytorch_model.bin",
								    # Removed: 'text_encoder/model.safetensors',
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Dict:
								a   :	Dict			=       [
								    "safety_checker/pytorch_model.fp16.bin",
								    "safety_checker/model.fp16.safetensors",
								    "vae/diffusion_pytorch_model.fp16.bin",
								    "vae/diffusion_pytorch_model.fp16.safetensors",
								    "text_encoder/pytorch_model.fp16.bin",
								    "text_encoder/model.fp16.safetensors",
								    "unet/diffusion_pytorch_model.fp16.bin",
								    "unet/diffusion_pytorch_model.fp16.safetensors",
								]
								a   :	Dict			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				List[str]:
								a   :	List[Any]			=       [
								    "unet/diffusion_pytorch_model.fp16.bin",
								    "unet/diffusion_pytorch_model.fp16.safetensors",
								]
								a   :	Any			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				int:
								# pass variant but use the non-variant filenames
								a   :	int			=       [
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								a   :	Tuple			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				str:
								a   :	str			=       [
								    "safety_checker/pytorch_model.fp16.bin",
								    "safety_checker/model.fp16.safetensors",
								    "vae/diffusion_pytorch_model.fp16.bin",
								    "vae/diffusion_pytorch_model.fp16.safetensors",
								    "text_encoder/pytorch_model.fp16.bin",
								    "text_encoder/model.fp16.safetensors",
								    "unet/diffusion_pytorch_model.fp16.bin",
								    # Removed: 'unet/diffusion_pytorch_model.fp16.safetensors',
								]
								a   :	Any			=       "fp16"
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				str:
								a   :	Union[str, Any]			=       [
								    "text_encoder/pytorch_model.fp16.bin",
								    "text_encoder/model.fp16.safetensors",
								]
								a   :	str			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				List[str]:
								# pass variant but use the non-variant filenames
								a   :	Optional[int]			=       [
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								]
								a   :	str			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	Any			=       [
								    "safety_checker/pytorch_model.fp16.bin",
								    "safety_checker/model.fp16.safetensors",
								    "vae/diffusion_pytorch_model.fp16.bin",
								    "vae/diffusion_pytorch_model.fp16.safetensors",
								    "text_encoder/pytorch_model.fp16.bin",
								    # 'text_encoder/model.fp16.safetensors',
								    "unet/diffusion_pytorch_model.fp16.bin",
								    "unet/diffusion_pytorch_model.fp16.safetensors",
								]
								a   :	Optional[int]			=       "fp16"
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )


