
from cva import destroyAllWindows, imread, imshow, waitKey







def        A__					(						lowerCamelCase						)  ->	Union[str, Any]:
				# getting number of pixels in the image
				UpperCamelCase_,   UpperCamelCase_:							Tuple	=						img.shape[0], img.shape[1]

				# converting each pixel's color to its negative
				for i in range(lowerCamelCase						):
								for j in range(lowerCamelCase						):
												UpperCamelCase_:							int	=						[2_55, 2_55, 2_55] - img[i][j]

				return img


if __name__ == "__main__":
							# read original image
							lowerCamelCase_						: Optional[Any]         =  imread("""image_data/lena.jpg""", 1)

							# convert to its negative
							lowerCamelCase_						: Optional[Any]         =  convert_to_negative(img)

							# show result image
							imshow("""negative of original image""", img)
							waitKey(0)
							destroyAllWindows()








import unittest

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

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()

class        _UpperCamelCase				(					unittest.TestCase  ):






			'''simple docstring'''

			@property
			def       lowerCAmelCase__	(       self :       int      ):
							torch.manual_seed(0      )
							UpperCamelCase_:							Any	=						UNetaDModel(
							    block_out_channels=(32, 64)						,	layers_per_block=2						,	sample_size=32						,	in_channels=3						,	out_channels=3						,	down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")						,	up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")						,	)
							return model

			@property
			def       lowerCAmelCase__	(       self :       Union[str, Any]      ):
							torch.manual_seed(0      )
							UpperCamelCase_:							Union[str, Any]	=						VQModel(
							    block_out_channels=[32, 64]						,	in_channels=3						,	out_channels=3						,	down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]						,	up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]						,	latent_channels=3						,	)
							return model

			@property
			def       lowerCAmelCase__	(       self :       Any      ):
							torch.manual_seed(0      )
							UpperCamelCase_:							List[str]	=						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						,	)
							return CLIPTextModel(snake_case_      )




			def       lowerCAmelCase__	(       self :       Dict      ):
							UpperCamelCase_:							Union[str, Any]	=						self.dummy_uncond_unet
							UpperCamelCase_:							Optional[Any]	=						DDIMScheduler()
							UpperCamelCase_:							List[str]	=						self.dummy_vq_model

							UpperCamelCase_:							List[Any]	=						LDMPipeline(unet=snake_case_						,	vqvae=snake_case_						,	scheduler=snake_case_      )
							ldm.to(snake_case_      )
							ldm.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							str	=						torch.manual_seed(0      )
							UpperCamelCase_:							int	=						ldm(generator=snake_case_						,	num_inference_steps=2						,	output_type="""numpy"""      ).images

							UpperCamelCase_:							Dict	=						torch.manual_seed(0      )
							UpperCamelCase_:							str	=						ldm(generator=snake_case_						,	num_inference_steps=2						,	output_type="""numpy"""						,	return_dict=snake_case_      )[0]

							UpperCamelCase_:							List[Any]	=						image[0, -3:, -3:, -1]
							UpperCamelCase_:							Optional[int]	=						image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							UpperCamelCase_:							str	=						np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]      )
							UpperCamelCase_:							Optional[Any]	=						1e-2 if torch_device != """mps""" else 3e-2

							assert np.abs(image_slice.flatten() - expected_slice      ).max() < tolerance
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < tolerance




@slow
@require_torch
class        _UpperCamelCase				(					unittest.TestCase  ):






			'''simple docstring'''

			def       lowerCAmelCase__	(       self :       Union[str, Any]      ):
							UpperCamelCase_:							Dict	=						LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""      )
							ldm.to(snake_case_      )
							ldm.set_progress_bar_config(disable=snake_case_      )

							UpperCamelCase_:							List[str]	=						torch.manual_seed(0      )
							UpperCamelCase_:							Optional[int]	=						ldm(generator=snake_case_						,	num_inference_steps=5						,	output_type="""numpy"""      ).images

							UpperCamelCase_:							List[Any]	=						image[0, -3:, -3:, -1]

							assert image.shape == (1, 256, 256, 3)
							UpperCamelCase_:							List[str]	=						np.array([0.4399, 0.4_4975, 0.4_6825, 0.474, 0.4359, 0.4581, 0.4_5095, 0.4341, 0.4447]      )
							UpperCamelCase_:							Dict	=						1e-2 if torch_device != """mps""" else 3e-2

							assert np.abs(image_slice.flatten() - expected_slice      ).max() < tolerance






