from collections.abc import Callable

import numpy as np



def lowerCamelCase						(     SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			):
    __UpperCamelCase  :Any    						=	int(np.ceil((x_end - xa) / step_size			)			)
    __UpperCamelCase  :List[Any]    						=	np.zeros((n + 1,)			)
    __UpperCamelCase  :Tuple    						=	ya
    __UpperCamelCase  :Dict    						=	xa

    for k in range(SCREAMING_SNAKE_CASE			):
        __UpperCamelCase  :List[str]    						=	y[k] + step_size * ode_func(SCREAMING_SNAKE_CASE						,    y[k]			)
        x += step_size

    return y


if __name__ == "__main__":
    import doctest

    doctest.testmod()






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											=      imread(r'''digital_image_processing/image_data/lena_small.jpg''')
__lowercase											=      cvtColor(img, COLOR_BGR2GRAY)



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase  :Optional[Any]    						=	cn.convert_to_negative(SCREAMING_SNAKE_CASE			)
    # assert negative_img array for at least one True
    assert negative_img.any()



def lowerCamelCase						(     ):
    '''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(SCREAMING_SNAKE_CASE						,    110			)			).startswith(
            '''<PIL.Image.Image image mode=RGB size=100x100 at'''			)



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase  :List[Any]    						=	canny.gen_gaussian_kernel(9						,    sigma=1.4			)
    # Assert ambiguous array
    assert resp.all()



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase  :List[str]    						=	imread('''digital_image_processing/image_data/lena_small.jpg'''						,    0			)
    # assert ambiguous array for all == True
    assert canny_img.all()
    __UpperCamelCase  :str    						=	canny.canny(SCREAMING_SNAKE_CASE			)
    # assert canny array for at least one True
    assert canny_array.any()



def lowerCamelCase						(     ):
    '''simple docstring'''







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



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase  :List[str]    						=	array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]			)
    __UpperCamelCase  :Optional[Any]    						=	conv.img_convolve(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			).astype(SCREAMING_SNAKE_CASE			)
    assert res.any()



def lowerCamelCase						(     ):
    '''simple docstring'''







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



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase						, __UpperCamelCase  :Dict    						=	sob.sobel_filter(SCREAMING_SNAKE_CASE			)
    assert grad.any() and theta.any()



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase  :Dict    						=	sp.make_sepia(SCREAMING_SNAKE_CASE						,    20			)
    assert sepia.all()



def lowerCamelCase						(     SCREAMING_SNAKE_CASE = "digital_image_processing/image_data/lena_small.jpg"			):
    '''simple docstring'''







    __UpperCamelCase  :Dict    						=	bs.Burkes(imread(SCREAMING_SNAKE_CASE						,    1			)						,    120			)
    burkes.process()
    assert burkes.output_img.any()



def lowerCamelCase						(     SCREAMING_SNAKE_CASE = "digital_image_processing/image_data/lena_small.jpg"						,    ):
    '''simple docstring'''







    __UpperCamelCase  :List[str]    						=	rs.NearestNeighbour(imread(SCREAMING_SNAKE_CASE						,    1			)						,    400						,    200			)
    nn.process()
    assert nn.output.any()



def lowerCamelCase						(     ):
    '''simple docstring'''







    __UpperCamelCase  :Union[str, Any]    						=	'''digital_image_processing/image_data/lena.jpg'''

    # Reading the image and converting it to grayscale.
    __UpperCamelCase  :Optional[int]    						=	imread(SCREAMING_SNAKE_CASE						,    0			)

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

    __UpperCamelCase  :int    						=	lbp.get_neighbors_pixel(
        SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			)

    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  :Tuple    						=	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  :Optional[int]    						=	lbp.local_binary_value(SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE			)

    assert lbp_image.any()





