
"""simple docstring"""



from pathlib import Path

import numpy as np
from PIL import Image






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					List[Any]						):






							"""simple docstring"""



							_lowerCAmelCase	,		_lowerCAmelCase	,		_lowerCAmelCase  	=			rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
							return 0.29_89 * r + 0.58_70 * g + 0.11_40 * b






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					Union[str, Any]						):






							"""simple docstring"""



							return (gray > 127) & (gray <= 255)






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					str     ,  SCREAMING_SNAKE_CASE:					List[Any]						):






							"""simple docstring"""



							_lowerCAmelCase  	=			np.zeros_like(A_						)
							_lowerCAmelCase  	=			np.zeros(
							    (image.shape[0] + kernel.shape[0] - 1, image.shape[1] + kernel.shape[1] - 1)						)

							# Copy image to padded image
							_lowerCAmelCase  	=			image

							# Iterate over image & apply kernel
							for x in range(image.shape[1]						):
														for y in range(image.shape[0]						):
																					_lowerCAmelCase  	=			(
																					    kernel * image_padded[y : y + kernel.shape[0], x : x + kernel.shape[1]]
																					).sum()
																					_lowerCAmelCase  	=			int(summation > 0						)
							return output


if __name__ == "__main__":
	# read original image
	_snake_case          =						Path(__file__).resolve().parent / 'image_data' / 'lena.jpg'
	_snake_case          =						np.array(Image.open(lena_path))
	# kernel to be applied
	_snake_case          =						np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
	_snake_case          =						dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element)
	# Save the output image
	_snake_case          =						Image.fromarray(output).convert('''RGB''')
	pil_img.save('''result_dilation.png''')








"""simple docstring"""



def 	__snake_case  (    SCREAMING_SNAKE_CASE:					int						):






							"""simple docstring"""



							_lowerCAmelCase  	=			generate_pascal_triangle(SCREAMING_SNAKE_CASE						)
							for row_idx in range(SCREAMING_SNAKE_CASE						):
														# Print left spaces
														for _ in range(num_rows - row_idx - 1						):
																					print(end=' '						)
														# Print row values
														for col_idx in range(row_idx + 1						):
																					if col_idx != row_idx:
																												print(triangle[row_idx][col_idx]     ,  end=' '						)
																					else:
																												print(triangle[row_idx][col_idx]     ,  end=''						)
														print()






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					int						):






							"""simple docstring"""



							if not isinstance(SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE						):
														raise TypeError('The input value of \'num_rows\' should be \'int\''						)

							if num_rows == 0:
														return []
							elif num_rows < 0:
														raise ValueError(
														    'The input value of \'num_rows\' should be greater than or equal to 0'						)

							_lowerCAmelCase  	=			[]
							for current_row_idx in range(SCREAMING_SNAKE_CASE						):
														_lowerCAmelCase  	=			populate_current_row(SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE						)
														triangle.append(SCREAMING_SNAKE_CASE						)
							return triangle






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					list[list[int]]     ,  SCREAMING_SNAKE_CASE:					int						):






							"""simple docstring"""



							_lowerCAmelCase  	=			[-1] * (current_row_idx + 1)
							# first and last elements of current row are equal to 1
							_lowerCAmelCase	,		_lowerCAmelCase  	=			1, 1
							for current_col_idx in range(1     ,  SCREAMING_SNAKE_CASE						):
														calculate_current_element(
														    SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE						)
							return current_row






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					list[list[int]]     ,  SCREAMING_SNAKE_CASE:					list[int]     ,  SCREAMING_SNAKE_CASE:					int     ,  SCREAMING_SNAKE_CASE:					int     ,  ):






							"""simple docstring"""



							_lowerCAmelCase  	=			triangle[current_row_idx - 1][current_col_idx - 1]
							_lowerCAmelCase  	=			triangle[current_row_idx - 1][current_col_idx]
							_lowerCAmelCase  	=			above_to_left_elt + above_to_right_elt






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					int						):






							"""simple docstring"""



							if not isinstance(SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE						):
														raise TypeError('The input value of \'num_rows\' should be \'int\''						)

							if num_rows == 0:
														return []
							elif num_rows < 0:
														raise ValueError(
														    'The input value of \'num_rows\' should be greater than or equal to 0'						)

							_lowerCAmelCase  	=			[[1]]

							for row_index in range(1     ,  SCREAMING_SNAKE_CASE						):
														_lowerCAmelCase  	=			[0] + result[-1] + [0]
														_lowerCAmelCase  	=			row_index + 1
														# Calculate the number of distinct elements in a row
														_lowerCAmelCase  	=			sum(divmod(SCREAMING_SNAKE_CASE     ,  2						)						)
														_lowerCAmelCase  	=			[
														    temp_row[i - 1] + temp_row[i] for i in range(1     ,  distinct_elements + 1						)
														]
														_lowerCAmelCase  	=			row_first_half[: (row_index + 1) // 2]
														row_second_half.reverse()
														_lowerCAmelCase  	=			row_first_half + row_second_half
														result.append(SCREAMING_SNAKE_CASE						)

							return result






def 	__snake_case  (    ):






							"""simple docstring"""



							from collections.abc import Callable
							from timeit import timeit

							def benchmark_a_function(SCREAMING_SNAKE_CASE:					Callable     ,  SCREAMING_SNAKE_CASE:					int						) -> None:
														_lowerCAmelCase  	=			f"""{func.__name__}({value})"""
														_lowerCAmelCase  	=			timeit(f"""__main__.{call}"""     ,  setup='import __main__'						)
														# print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
														print(f"""{call:38} -- {timing:.4f} seconds"""						)

							for value in range(15						):  # (1, 7, 14):
														for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
																					benchmark_a_function(SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE						)
														print()


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()






