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

SCREAMING_SNAKE_CASE__		:       int       						=       imread(r"digital_image_processing/image_data/lena_small.jpg")
SCREAMING_SNAKE_CASE__		:       List[Any]       						=       cvtColor(img, COLOR_BGR2GRAY)







def      _a					(   ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__					:					Any      =		cn.convert_to_negative(lowercase__			)
     # assert negative_img array for at least one True
     assert negative_img.any()







def      _a					(   ):







     '''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(lowercase__  ,	1_10			)			).startswith(
              '<PIL.Image.Image image mode=RGB size=100x100 at'			)







def      _a					(   ):







     '''simple docstring'''


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







def      _a					(   ):







     '''simple docstring'''


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







def      _a					(   ):







     '''simple docstring'''


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







def      _a					(   ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__					:					Any      =		array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]			)
     SCREAMING_SNAKE_CASE__					:					Tuple      =		conv.img_convolve(lowercase__  ,	lowercase__			).astype(lowercase__			)
     assert res.any()







def      _a					(   ):







     '''simple docstring'''


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







def      _a					(   ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					int      =		sob.sobel_filter(lowercase__			)
     assert grad.any() and theta.any()







def      _a					(   ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__					:					List[str]      =		sp.make_sepia(lowercase__  ,	20			)
     assert sepia.all()







def      _a					(   lowercase__	:      str = "digital_image_processing/image_data/lena_small.jpg"			):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__					:					str      =		bs.Burkes(imread(lowercase__  ,	1			)  ,	1_20			)
     burkes.process()
     assert burkes.output_img.any()







def      _a					(   lowercase__	:      str = "digital_image_processing/image_data/lena_small.jpg"  ,	):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		rs.NearestNeighbour(imread(lowercase__  ,	1			)  ,	4_00  ,	2_00			)
     nn.process()
     assert nn.output.any()







def      _a					(   ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__					:					Dict      =		'digital_image_processing/image_data/lena.jpg'

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

     # Test for get_neighbors_pixel function() return not None
     SCREAMING_SNAKE_CASE__					:					str      =		0
     SCREAMING_SNAKE_CASE__					:					Dict      =		0
     SCREAMING_SNAKE_CASE__					:					Any      =		image[x_coordinate][y_coordinate]

     SCREAMING_SNAKE_CASE__					:					List[Any]      =		lbp.get_neighbors_pixel(
         lowercase__  ,	lowercase__  ,	lowercase__  ,	lowercase__			)

     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
     SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		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]			):
               SCREAMING_SNAKE_CASE__					:					str      =		lbp.local_binary_value(lowercase__  ,	lowercase__  ,	lowercase__			)

     assert lbp_image.any()





"""simple docstring"""

import math




def      lowercase__    (       lowerCAmelCase					:       str			,					lowerCAmelCase					:       Optional[Any]			)			->   List[Any]:






    """simple docstring"""




    if 0 not in (x, y):
        # We use the relation x^y = y*log10(x), where 10 is the base.
        return y * math.logaa(lowerCAmelCase			)
    else:
        if x == 0:  # 0 raised to any number is 0
            return 0
        elif y == 0:
            return 1  # any number raised to 0 is 1
    raise AssertionError('This should never happen'			)


if __name__ == "__main__":  # Main function
   # Read two numbers from input and typecast them to int using map function.
   # Here x is the base and y is the power.
   SCREAMING_SNAKE_CASE_            =    '''Enter the base and the power separated by a comma: '''
   SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_            =    map(int, input(prompt).split(''','''))
   SCREAMING_SNAKE_CASE_       ,    SCREAMING_SNAKE_CASE_            =    map(int, input(prompt).split(''','''))

   # We find the log of each number, using the function res(), which takes two
   # arguments.
   SCREAMING_SNAKE_CASE_            =    res(xa, ya)
   SCREAMING_SNAKE_CASE_            =    res(xa, ya)

   # We check for the largest number
   if resa > resa:
      print('''Largest number is''', xa, '''^''', ya)
   elif resa > resa:
      print('''Largest number is''', xa, '''^''', ya)
   else:
      print('''Both are equal''')



