



'''simple docstring'''





import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey






class       lowerCamelCase_					:
  """simple docstring"""




  def __init__(				self   :			Dict    ,			_a   :			Union[str, Any]    ,			_a   :			int     )      ->      Any:
    __lowerCamelCase : Tuple					 =				0
    # max greyscale value for #FFFFFF
    __lowerCamelCase : Tuple					 =				int(self.get_greyscale(255    ,			255    ,			255     )     )

    if not self.min_threshold < threshold < self.max_threshold:
      __lowerCamelCase : Tuple					 =				f'Factor value should be from 0 to {self.max_threshold}'
      raise ValueError(_a     )

    __lowerCamelCase : Optional[int]					 =				input_img
    __lowerCamelCase : Tuple					 =				threshold
    __lowerCamelCase ,__lowerCamelCase : Optional[Any]					 =				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
    __lowerCamelCase : Optional[Any]					 =				[
        [0 for _ in range(self.height + 4     )] for __ in range(self.width + 1     )
    ]
    __lowerCamelCase : List[Any]					 =				np.ones((self.width, self.height, 3)    ,			np.uinta     ) * 255




  @classmethod
  def 		_lowercase  (				cls   :			Any    ,			_a   :			int    ,			_a   :			int    ,			_a   :			int     )      ->      float:
    return 0.114 * blue + 0.587 * green + 0.2126 * red




  def 		_lowercase  (				self   :			int     )      ->      None:
    for y in range(self.height     ):
      for x in range(self.width     ):
        __lowerCamelCase : Any					 =				int(self.get_greyscale(*self.input_img[y][x]     )     )
        if self.threshold > greyscale + self.error_table[y][x]:
          __lowerCamelCase : str					 =				(0, 0, 0)
          __lowerCamelCase : Any					 =				greyscale + self.error_table[x][y]
        else:
          __lowerCamelCase : Union[str, Any]					 =				(255, 255, 255)
          __lowerCamelCase : int					 =				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
   _UpperCamelCase							       =		[
       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()











'''simple docstring'''





import decimal

def  a_  (							)   ->   int:
  __lowerCamelCase : int					 =				0
  __lowerCamelCase : Any					 =				decimal.Context(prec=105 )
  for i in range(2 ,100 ):
    __lowerCamelCase : str					 =				decimal.Decimal(_lowerCAmelCase )
    __lowerCamelCase : int					 =				number.sqrt(_lowerCAmelCase )
    if len(str(_lowerCAmelCase ) ) > 1:
      answer += int(str(_lowerCAmelCase )[0] )
      __lowerCamelCase : List[str]					 =				str(_lowerCAmelCase )[2:101]
      answer += sum(int(_lowerCAmelCase ) for x in sqrt_number_str )
  return answer


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   print(f'''{solution() = }''')






