





'''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

A__				:   Tuple      =imread(r'''digital_image_processing/image_data/lena_small.jpg''')
A__				:   Union[str, Any]      =cvtColor(img, COLOR_BGR2GRAY)
def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase							     =							cn.convert_to_negative(lowerCAmelCase  )
      # assert negative_img array for at least one True
      assert negative_img.any()
def    UpperCamelCase__      (		):





      """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(lowerCAmelCase							,	1_10  )  ).startswith(
                """<PIL.Image.Image image mode=RGB size=100x100 at"""  )
def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase							     =							canny.gen_gaussian_kernel(9							,	sigma=1.4  )
      # Assert ambiguous array
      assert resp.all()
def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase							     =							imread("""digital_image_processing/image_data/lena_small.jpg"""							,	0  )
      # assert ambiguous array for all == True
      assert canny_img.all()
      _lowerCAmelCase							     =							canny.canny(lowerCAmelCase  )
      # assert canny array for at least one True
      assert canny_array.any()
def    UpperCamelCase__      (		):





      """simple docstring"""


      assert gg.gaussian_filter(lowerCAmelCase							,	5							,	sigma=0.9  ).all()
def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase							     =							array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]  )
      _lowerCAmelCase							     =							conv.img_convolve(lowerCAmelCase							,	lowerCAmelCase  ).astype(lowerCAmelCase  )
      assert res.any()
def    UpperCamelCase__      (		):





      """simple docstring"""


      assert med.median_filter(lowerCAmelCase							,	3  ).any()
def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase     ,							_lowerCAmelCase							     =							sob.sobel_filter(lowerCAmelCase  )
      assert grad.any() and theta.any()
def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase							     =							sp.make_sepia(lowerCAmelCase							,	20  )
      assert sepia.all()
def    UpperCamelCase__      (		lowerCAmelCase = "digital_image_processing/image_data/lena_small.jpg"  ):





      """simple docstring"""


      _lowerCAmelCase							     =							bs.Burkes(imread(lowerCAmelCase							,	1  )							,	1_20  )
      burkes.process()
      assert burkes.output_img.any()
def    UpperCamelCase__      (		lowerCAmelCase = "digital_image_processing/image_data/lena_small.jpg"							,	):





      """simple docstring"""


      _lowerCAmelCase							     =							rs.NearestNeighbour(imread(lowerCAmelCase							,	1  )							,	4_00							,	2_00  )
      nn.process()
      assert nn.output.any()





def    UpperCamelCase__      (		):





      """simple docstring"""


      _lowerCAmelCase							     =							"""digital_image_processing/image_data/lena.jpg"""

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

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

      _lowerCAmelCase							     =							lbp.get_neighbors_pixel(
          lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase  )

      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
      _lowerCAmelCase							     =							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]  ):
                  _lowerCAmelCase							     =							lbp.local_binary_value(lowerCAmelCase							,	lowerCAmelCase							,	lowerCAmelCase  )

      assert lbp_image.any()










"""simple docstring"""



def   __lowerCAmelCase						(						lowercase  :  int )	->						bool:


    """simple docstring"""





    if p < 2:
        raise ValueError("p should not be less than 2!" )
    elif p == 2:
        return True

    snake_case    :      Dict      					=    4
    snake_case    :      str      					=    (1 << p) - 1
    for _ in range(p - 2 ):
        snake_case    :      Any      					=    ((s * s) - 2) % m
    return s == 0


if __name__ == "__main__":
  print(lucas_lehmer_test(7))
  print(lucas_lehmer_test(11))





