



"""simple docstring"""

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

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




def __lowercase			(							):
    snake_case_ :     Optional[int]				=	cn.convert_to_negative(_a    )
    # assert negative_img array for at least one True
    assert negative_img.any()




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




def __lowercase			(							):
    snake_case_ :     Any				=	canny.gen_gaussian_kernel(9		,			sigma=1.4    )
    # Assert ambiguous array
    assert resp.all()




def __lowercase			(							):
    snake_case_ :     Any				=	imread('''digital_image_processing/image_data/lena_small.jpg'''		,			0    )
    # assert ambiguous array for all == True
    assert canny_img.all()
    snake_case_ :     Union[str, Any]				=	canny.canny(_a    )
    # assert canny array for at least one True
    assert canny_array.any()




def __lowercase			(							):
    assert gg.gaussian_filter(_a		,			5		,			sigma=0.9    ).all()




def __lowercase			(							):
    # laplace diagonals
    snake_case_ :     Tuple				=	array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]    )
    snake_case_ :     Optional[int]				=	conv.img_convolve(_a		,			_a    ).astype(_a    )
    assert res.any()




def __lowercase			(							):
    assert med.median_filter(_a		,			3    ).any()




def __lowercase			(							):
    snake_case_,	snake_case_ :     Any				=	sob.sobel_filter(_a    )
    assert grad.any() and theta.any()




def __lowercase			(							):
    snake_case_ :     Union[str, Any]				=	sp.make_sepia(_a		,			20    )
    assert sepia.all()




def __lowercase			(							_a = "digital_image_processing/image_data/lena_small.jpg"    ):
    snake_case_ :     Union[str, Any]				=	bs.Burkes(imread(_a		,			1    )		,			120    )
    burkes.process()
    assert burkes.output_img.any()




def __lowercase			(							_a = "digital_image_processing/image_data/lena_small.jpg"		,			):
    snake_case_ :     Optional[Any]				=	rs.NearestNeighbour(imread(_a		,			1    )		,			400		,			200    )
    nn.process()
    assert nn.output.any()






def __lowercase			(							):
    snake_case_ :     Tuple				=	'''digital_image_processing/image_data/lena.jpg'''

    # Reading the image and converting it to grayscale.
    snake_case_ :     Dict				=	imread(_a		,			0    )

    # Test for get_neighbors_pixel function() return not None
    snake_case_ :     List[Any]				=	0
    snake_case_ :     List[Any]				=	0
    snake_case_ :     Optional[int]				=	image[x_coordinate][y_coordinate]

    snake_case_ :     Any				=	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
    snake_case_ :     List[str]				=	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]    ):
            snake_case_ :     int				=	lbp.local_binary_value(_a		,			_a		,			_a    )

    assert lbp_image.any()










"""simple docstring"""

from functools import lru_cache




@lru_cache
def __lowercase			(							_a    ):
    if num < 0:
        raise ValueError('''Number should not be negative.'''    )

    return 1 if num in (0, 1) else num * factorial(num - 1    )


if __name__ == "__main__":
     import doctest

     doctest.testmod()





