


import numpy as np
from cva import COLOR_BGR2GRAY, cvtColor, imread
from numpy import array, uinta
from PIL import Image

from digital_image_processing import change_contrast as cc
from digital_image_processing import convert_to_negative as cn
from digital_image_processing import sepia as sp
from digital_image_processing.dithering import burkes as bs
from digital_image_processing.edge_detection import canny
from digital_image_processing.filters import convolve as conv
from digital_image_processing.filters import gaussian_filter as gg
from digital_image_processing.filters import local_binary_pattern as lbp
from digital_image_processing.filters import median_filter as med
from digital_image_processing.filters import sobel_filter as sob
from digital_image_processing.resize import resize as rs

lowerCAmelCase__    :List[str]       =				imread(R'''digital_image_processing/image_data/lena_small.jpg''')
lowerCAmelCase__    :Union[str, Any]       =				cvtColor(img, COLOR_BGR2GRAY)

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


							'''simple docstring'''





							_UpperCAmelCase											=     cn.convert_to_negative(a__			)
							# assert negative_img array for at least one True
							assert negative_img.any()

def 			lowerCAmelCase__					(     )    ->						Tuple:


							'''simple docstring'''





							with Image.open('digital_image_processing/image_data/lena_small.jpg'			) as img:
														# Work around assertion for response
														assert str(cc.change_contrast(a__     ,    1_1_0			)			).startswith(
														    '<PIL.Image.Image image mode=RGB size=100x100 at'			)

def 			lowerCAmelCase__					(     )    ->						Tuple:


							'''simple docstring'''





							_UpperCAmelCase											=     canny.gen_gaussian_kernel(9     ,    sigma=1.4			)
							# Assert ambiguous array
							assert resp.all()

def 			lowerCAmelCase__					(     )    ->						Optional[int]:


							'''simple docstring'''





							_UpperCAmelCase											=     imread('digital_image_processing/image_data/lena_small.jpg'     ,    0			)
							# assert ambiguous array for all == True
							assert canny_img.all()
							_UpperCAmelCase											=     canny.canny(a__			)
							# assert canny array for at least one True
							assert canny_array.any()

def 			lowerCAmelCase__					(     )    ->						List[Any]:


							'''simple docstring'''





							assert gg.gaussian_filter(a__     ,    5     ,    sigma=0.9			).all()

def 			lowerCAmelCase__					(     )    ->						Optional[Any]:


							'''simple docstring'''





							_UpperCAmelCase											=     array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]			)
							_UpperCAmelCase											=     conv.img_convolve(a__     ,    a__			).astype(a__			)
							assert res.any()

def 			lowerCAmelCase__					(     )    ->						str:


							'''simple docstring'''





							assert med.median_filter(a__     ,    3			).any()

def 			lowerCAmelCase__					(     )    ->						List[str]:


							'''simple docstring'''





							_UpperCAmelCase						,			_UpperCAmelCase											=     sob.sobel_filter(a__			)
							assert grad.any() and theta.any()

def 			lowerCAmelCase__					(     )    ->						Dict:


							'''simple docstring'''





							_UpperCAmelCase											=     sp.make_sepia(a__     ,    2_0			)
							assert sepia.all()

def 			lowerCAmelCase__					(     a__:						int = "digital_image_processing/image_data/lena_small.jpg"			)    ->						str:


							'''simple docstring'''





							_UpperCAmelCase											=     bs.Burkes(imread(a__     ,    1			)     ,    1_2_0			)
							burkes.process()
							assert burkes.output_img.any()

def 			lowerCAmelCase__					(     a__:						Optional[int] = "digital_image_processing/image_data/lena_small.jpg"     ,    )    ->						int:


							'''simple docstring'''





							_UpperCAmelCase											=     rs.NearestNeighbour(imread(a__     ,    1			)     ,    4_0_0     ,    2_0_0			)
							nn.process()
							assert nn.output.any()







def 			lowerCAmelCase__					(     )    ->						Dict:


							'''simple docstring'''





							_UpperCAmelCase											=     'digital_image_processing/image_data/lena.jpg'

							# Reading the image and converting it to grayscale.
							_UpperCAmelCase											=     imread(a__     ,    0			)

							# Test for get_neighbors_pixel function() return not None
							_UpperCAmelCase											=     0
							_UpperCAmelCase											=     0
							_UpperCAmelCase											=     image[x_coordinate][y_coordinate]

							_UpperCAmelCase											=     lbp.get_neighbors_pixel(
							    a__     ,    a__     ,    a__     ,    a__			)

							assert neighbors_pixels is not None

							# Test for local_binary_pattern function()
							# Create a numpy array as the same height and width of read image
							_UpperCAmelCase											=     np.zeros((image.shape[0], image.shape[1])			)

							# Iterating through the image and calculating the local binary pattern value
							# for each pixel.
							for i in range(0     ,    image.shape[0]			):
														for j in range(0     ,    image.shape[1]			):
																					_UpperCAmelCase											=     lbp.local_binary_value(a__     ,    a__     ,    a__			)

							assert lbp_image.any()







'''simple docstring'''






def   UpperCamelCase__ (						lowerCAmelCase    ):





      """simple docstring"""


      if divisor % 5 == 0 or divisor % 2 == 0:
            return 0
      _lowerCAmelCase					=				1
      _lowerCAmelCase					=				1
      while repunit:
            _lowerCAmelCase					=				(10 * repunit + 1) % divisor
            repunit_index += 1
      return repunit_index
def   UpperCamelCase__ (						lowerCAmelCase = 1_00_00_00    ):





      """simple docstring"""


      _lowerCAmelCase					=				limit - 1
      if divisor % 2 == 0:
            divisor += 1
      while least_divisible_repunit(lowerCAmelCase    ) <= limit:
            divisor += 2
      return divisor


if __name__ == "__main__":
      print(F"""{solution() = }""")






