code: 
  
  '''simple docstring'''
  
  import numpy as np
  from cva import destroyAllWindows, imread, imshow, waitKey
  
  
  class       a_  :
  
      '''simple docstring'''
  
  
      def __init__(	self				,	A				,	A )	->     Optional[int]:
          _SCREAMING_SNAKE_CASE             =    0
          # max greyscale value for #FFFFFF
          _SCREAMING_SNAKE_CASE             =    int(self.get_greyscale(255				,	255				,	255 ) )
  
          if not self.min_threshold < threshold < self.max_threshold:
              _SCREAMING_SNAKE_CASE             =    f'Factor value should be from 0 to {self.max_threshold}'
              raise ValueError(A )
  
          _SCREAMING_SNAKE_CASE             =    input_img
          _SCREAMING_SNAKE_CASE             =    threshold
          _SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE             =    self.input_img.shape[1], self.input_img.shape[0]
  
          # error table size (+4 columns and +1 row) greater than input image because of
          # lack of if statements
          _SCREAMING_SNAKE_CASE             =    [
              [0 for _ in range(self.height + 4 )] for __ in range(self.width + 1 )
          ]
          _SCREAMING_SNAKE_CASE             =    np.ones((self.width, self.height, 3)				,	np.uinta ) * 255
  
  
      @classmethod
      def     snake_case_(	cls				,	A				,	A				,	A )	->     float:
          return 0.114 * blue + 0.587 * green + 0.2126 * red
  
  
  
  
  
      def     snake_case_(	self )	->     None:
          for y in range(self.height ):
              for x in range(self.width ):
                  _SCREAMING_SNAKE_CASE             =    int(self.get_greyscale(*self.input_img[y][x] ) )
                  if self.threshold > greyscale + self.error_table[y][x]:
                      _SCREAMING_SNAKE_CASE             =    (0, 0, 0)
                      _SCREAMING_SNAKE_CASE             =    greyscale + self.error_table[x][y]
                  else:
                      _SCREAMING_SNAKE_CASE             =    (255, 255, 255)
                      _SCREAMING_SNAKE_CASE             =    greyscale + self.error_table[x][y] - 255
                  self.error_table[y][x + 1] += int(8 / 32 * current_error )
                  self.error_table[y][x + 2] += int(4 / 32 * current_error )
                  self.error_table[y + 1][x] += int(8 / 32 * current_error )
                  self.error_table[y + 1][x + 1] += int(4 / 32 * current_error )
                  self.error_table[y + 1][x + 2] += int(2 / 32 * current_error )
                  self.error_table[y + 1][x - 1] += int(4 / 32 * current_error )
                  self.error_table[y + 1][x - 2] += int(2 / 32 * current_error )
  
  
  if __name__ == "__main__":
        # create Burke's instances with original images in greyscale
        lowercase_			       =				[
            Burkes(imread("""image_data/lena.jpg""", 1), threshold)
            for threshold in (1, 126, 130, 140)
        ]
  
        for burkes in burkes_instances:
              burkes.process()
  
        for burkes in burkes_instances:
              imshow(
                  f"""Original image with dithering threshold: {burkes.threshold}""",
                  burkes.output_img,
              )
  
        waitKey(0)
        destroyAllWindows()
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import math
  from timeit import timeit
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->int:
      _SCREAMING_SNAKE_CASE             =    0
      _SCREAMING_SNAKE_CASE             =    abs(__lowerCamelCase					)
      while True:
          _SCREAMING_SNAKE_CASE             =    n // 10
          digits += 1
          if n == 0:
              break
      return digits
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->int:
      return 1 if n == 0 else math.floor(math.log(abs(__lowerCamelCase					)      , 10					) + 1					)
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->int:
      return len(str(abs(__lowerCamelCase					)					)					)
  
  
  
  
  
  def lowerCamelCase		(  )		->None:
      from collections.abc import Callable
  
      def benchmark_a_function(__lowerCamelCase				:					Callable      , __lowerCamelCase				:					int					) -> None:
          _SCREAMING_SNAKE_CASE             =    F'{func.__name__}({value})'
          _SCREAMING_SNAKE_CASE             =    timeit(F'__main__.{call}'      , setup="""import __main__"""					)
          print(F'{call}: {func(__lowerCamelCase					)} -- {timing} seconds'					)
  
      for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
          for func in (num_digits, num_digits_fast, num_digits_faster):
              benchmark_a_function(__lowerCamelCase      , __lowerCamelCase					)
          print()
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
        benchmark()
  
  
  
  