






"""simple docstring"""







import unittest
from timeit import timeit






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	first_num if first_num >= second_num else second_num
       UpperCAmelCase					=	max_num
       while (common_mult % first_num > 0) or (common_mult % second_num > 0):
              common_mult += max_num
       return common_mult






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       return b if a == 0 else greatest_common_divisor(b % a		,					lowerCAmelCase						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       return first_num // greatest_common_divisor(lowerCAmelCase		,					lowerCAmelCase						) * second_num






def 					_lowerCAmelCase				(					):







       '''simple docstring'''
       UpperCAmelCase					=	(
           """from __main__ import least_common_multiple_slow, least_common_multiple_fast"""
       )
       print(
           """least_common_multiple_slow():"""		,					timeit("""least_common_multiple_slow(1000, 999)"""		,					setup=lowerCAmelCase						)		,					)
       print(
           """least_common_multiple_fast():"""		,					timeit("""least_common_multiple_fast(1000, 999)"""		,					setup=lowerCAmelCase						)		,					)





class      UpperCamelCase_       (				unittest.TestCase     ):
  _A				:    List[str] =		(
      (10, 20),
      (13, 15),
      (4, 31),
      (10, 42),
      (43, 34),
      (5, 12),
      (12, 25),
      (10, 25),
      (6, 9),
  )
  _A				:    int =		(20, 195, 124, 210, 1462, 60, 300, 50, 18)



  def 						UpperCamelCase_ (					self )	->	Any:



         """simple docstring"""





         for i, (first_num, second_num) in enumerate(self.test_inputs ):
                UpperCAmelCase					=	least_common_multiple_slow(snake_case__       ,						snake_case__ )
                UpperCAmelCase					=	least_common_multiple_fast(snake_case__       ,						snake_case__ )
                with self.subTest(i=snake_case__ ):
                       self.assertEqual(snake_case__       ,						self.expected_results[i] )
                       self.assertEqual(snake_case__       ,						self.expected_results[i] )


if __name__ == "__main__":
 benchmark()
 unittest.main()








"""simple docstring"""







import cva
import numpy as np

from digital_image_processing.filters.convolve import img_convolve
from digital_image_processing.filters.sobel_filter import sobel_filter

lowerCAmelCase_		:			List[Any]				   =					1_8_0






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	k_size // 2
       UpperCAmelCase			,				UpperCAmelCase					=	np.mgrid[0 - center : k_size - center, 0 - center : k_size - center]
       UpperCAmelCase					=	(
           1
           / (2 * np.pi * sigma)
           * np.exp(-(np.square(lowerCAmelCase						) + np.square(lowerCAmelCase						)) / (2 * np.square(lowerCAmelCase						))						)
       )
       return g






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	np.zeros(lowerCAmelCase						)

       for row in range(1		,					image_shape[0] - 1						):
              for col in range(1		,					image_shape[1] - 1						):
                     UpperCAmelCase					=	gradient_direction[row, col]

                     if (
                         0 <= direction < PI / 8
                         or 15 * PI / 8 <= direction <= 2 * PI
                         or 7 * PI / 8 <= direction <= 9 * PI / 8
                     ):
                            UpperCAmelCase					=	sobel_grad[row, col - 1]
                            UpperCAmelCase					=	sobel_grad[row, col + 1]
                            if sobel_grad[row, col] >= w and sobel_grad[row, col] >= e:
                                   UpperCAmelCase					=	sobel_grad[row, col]

                     elif (
                         PI / 8 <= direction < 3 * PI / 8
                         or 9 * PI / 8 <= direction < 11 * PI / 8
                     ):
                            UpperCAmelCase					=	sobel_grad[row + 1, col - 1]
                            UpperCAmelCase					=	sobel_grad[row - 1, col + 1]
                            if sobel_grad[row, col] >= sw and sobel_grad[row, col] >= ne:
                                   UpperCAmelCase					=	sobel_grad[row, col]

                     elif (
                         3 * PI / 8 <= direction < 5 * PI / 8
                         or 11 * PI / 8 <= direction < 13 * PI / 8
                     ):
                            UpperCAmelCase					=	sobel_grad[row - 1, col]
                            UpperCAmelCase					=	sobel_grad[row + 1, col]
                            if sobel_grad[row, col] >= n and sobel_grad[row, col] >= s:
                                   UpperCAmelCase					=	sobel_grad[row, col]

                     elif (
                         5 * PI / 8 <= direction < 7 * PI / 8
                         or 13 * PI / 8 <= direction < 15 * PI / 8
                     ):
                            UpperCAmelCase					=	sobel_grad[row - 1, col - 1]
                            UpperCAmelCase					=	sobel_grad[row + 1, col + 1]
                            if sobel_grad[row, col] >= nw and sobel_grad[row, col] >= se:
                                   UpperCAmelCase					=	sobel_grad[row, col]

       return destination






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       for row in range(1		,					image_shape[0] - 1						):
              for col in range(1		,					image_shape[1] - 1						):
                     if destination[row, col] >= threshold_high:
                            UpperCAmelCase					=	strong
                     elif destination[row, col] <= threshold_low:
                            UpperCAmelCase					=	0
                     else:
                            UpperCAmelCase					=	weak






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       for row in range(1		,					image_shape[0]						):
              for col in range(1		,					image_shape[1]						):
                     if destination[row, col] == weak:
                            if 255 in (
                                destination[row, col + 1],
                                destination[row, col - 1],
                                destination[row - 1, col],
                                destination[row + 1, col],
                                destination[row - 1, col - 1],
                                destination[row + 1, col - 1],
                                destination[row - 1, col + 1],
                                destination[row + 1, col + 1],
                            ):
                                   UpperCAmelCase					=	strong
                            else:
                                   UpperCAmelCase					=	0






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase=15		,					lowerCAmelCase=30		,					lowerCAmelCase=128		,					lowerCAmelCase=255						):







       '''simple docstring'''
       # gaussian_filter
       UpperCAmelCase					=	img_convolve(lowerCAmelCase		,					gen_gaussian_kernel(9		,					sigma=1.4						)						)
       # get the gradient and degree by sobel_filter
       UpperCAmelCase			,				UpperCAmelCase					=	sobel_filter(lowerCAmelCase						)
       UpperCAmelCase					=	PI + np.radadeg(lowerCAmelCase						)

       UpperCAmelCase					=	suppress_non_maximum(image.shape		,					lowerCAmelCase		,					lowerCAmelCase						)

       detect_high_low_threshold(
           image.shape		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase						)

       track_edge(image.shape		,					lowerCAmelCase		,					lowerCAmelCase		,					lowerCAmelCase						)

       return destination


if __name__ == "__main__":
 # read original image in gray mode
 lowerCAmelCase_		:			Optional[Any]				   =					cva.imread(R'''../image_data/lena.jpg''', 0)
 # canny edge detection
 lowerCAmelCase_		:			Dict				   =					canny(lena)
 cva.imshow('''canny''', canny_destination)
 cva.waitKey(0)
