
'''simple docstring'''

import colorsys

from PIL import Image  # type: ignore






def 	_snake_case						(      A_       :    float     ,		A_       :    float     ,		A_       :    int   ):
  """simple docstring"""







  a_      :	List[Any]      =							x
  a_      :	str      =							y
  for step in range(A_   ):  # noqa: B007
    a_      :	Dict      =							a * a - b * b + x
    a_      :	List[Any]      =							2 * a * b + y
    a_      :	int      =							a_new

    # divergence happens for all complex number with an absolute value
    # greater than 4
    if a * a + b * b > 4:
      break
  return step / (max_step - 1)






def 	_snake_case						(      A_       :    float   ):
  """simple docstring"""







  if distance == 1:
    return (0, 0, 0)
  else:
    return (255, 255, 255)






def 	_snake_case						(      A_       :    float   ):
  """simple docstring"""







  if distance == 1:
    return (0, 0, 0)
  else:
    return tuple(round(i * 255   ) for i in colorsys.hsv_to_rgb(A_     ,		1     ,		1   )   )






def 	_snake_case						(      A_       :    int = 800     ,		A_       :    int = 600     ,		A_       :    float = -0.6     ,		A_       :    float = 0     ,		A_       :    float = 3.2     ,		A_       :    int = 50     ,		A_       :    bool = True     ,		):
  """simple docstring"""







  a_      :	Optional[int]      =							Image.new("""RGB"""     ,		(image_width, image_height)   )
  a_      :	List[str]      =							img.load()

  # loop through the image-coordinates
  for image_x in range(A_   ):
    for image_y in range(A_   ):
      # determine the figure-coordinates based on the image-coordinates
      a_      :	Dict      =							figure_width / image_width * image_height
      a_      :	Optional[Any]      =							figure_center_x + (image_x / image_width - 0.5) * figure_width
      a_      :	Dict      =							figure_center_y + (image_y / image_height - 0.5) * figure_height

      a_      :	Any      =							get_distance(A_     ,		A_     ,		A_   )

      # color the corresponding pixel based on the selected coloring-function
      if use_distance_color_coding:
        a_      :	List[Any]      =							get_color_coded_rgb(A_   )
      else:
        a_      :	Dict      =							get_black_and_white_rgb(A_   )

  return img


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    # colored version, full figure
    __snake_case:  List[Any]								=			get_image()

    # uncomment for colored version, different section, zoomed in
    # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4,
    # figure_width = 0.8)

    # uncomment for black and white version, full figure
    # img = get_image(use_distance_color_coding = False)

    # uncomment to save the image
    # img.save("mandelbrot.png")

    img.show()




'''simple docstring'''

import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import DonutImageProcessor


class  _UpperCAmelCase ( unittest.TestCase    ):

     """simple docstring"""

     def __init__(      self							,		lowerCAmelCase_							,		lowerCAmelCase_=7							,		lowerCAmelCase_=3							,		lowerCAmelCase_=18							,		lowerCAmelCase_=30							,		lowerCAmelCase_=4_00							,		lowerCAmelCase_=True							,		lowerCAmelCase_=None							,		lowerCAmelCase_=True							,		lowerCAmelCase_=False							,		lowerCAmelCase_=True							,		lowerCAmelCase_=True							,		lowerCAmelCase_=[0.5, 0.5, 0.5]							,		lowerCAmelCase_=[0.5, 0.5, 0.5]							,		):

       '''simple docstring'''

       a_      :	Optional[int]      =							parent
       a_      :	Union[str, Any]      =							batch_size
       a_      :	Any      =							num_channels
       a_      :	Tuple      =							image_size
       a_      :	Any      =							min_resolution
       a_      :	Dict      =							max_resolution
       a_      :	Optional[Any]      =							do_resize
       a_      :	Tuple      =							size if size is not None else {"""height""": 18, """width""": 20}
       a_      :	int      =							do_thumbnail
       a_      :	Optional[int]      =							do_align_axis
       a_      :	Tuple      =							do_pad
       a_      :	int      =							do_normalize
       a_      :	Tuple      =							image_mean
       a_      :	Optional[Any]      =							image_std






     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       return {
           "do_resize": self.do_resize,
           "size": self.size,
           "do_thumbnail": self.do_thumbnail,
           "do_align_long_axis": self.do_align_axis,
           "do_pad": self.do_pad,
           "do_normalize": self.do_normalize,
           "image_mean": self.image_mean,
           "image_std": self.image_std,
       }







@require_torch
@require_vision
class  _UpperCAmelCase ( lowerCAmelCase__	,unittest.TestCase    ):

     """simple docstring"""

     a_    	=					DonutImageProcessor if is_vision_available() else None


     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       a_      :	Optional[int]      =							DonutImageProcessingTester(self )


     @property
     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       return self.image_processor_tester.prepare_image_processor_dict()


     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       a_      :	Any      =							self.image_processing_class(**self.image_processor_dict )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""do_resize""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""size""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""do_thumbnail""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""do_align_long_axis""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""do_pad""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""do_normalize""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""image_mean""" ) )
       self.assertTrue(hasattr(lowerCAmelCase_							,		"""image_std""" ) )


     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       a_      :	List[str]      =							self.image_processing_class.from_dict(self.image_processor_dict )
       self.assertEqual(image_processor.size							,		{"""height""": 18, """width""": 20} )

       a_      :	str      =							self.image_processing_class.from_dict(self.image_processor_dict							,		size=42 )
       self.assertEqual(image_processor.size							,		{"""height""": 42, """width""": 42} )

       # Previous config had dimensions in (width, height) order
       a_      :	Any      =							self.image_processing_class.from_dict(self.image_processor_dict							,		size=(42, 84) )
       self.assertEqual(image_processor.size							,		{"""height""": 84, """width""": 42} )


     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       pass


     @is_flaky()
     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       a_      :	Dict      =							self.image_processing_class(**self.image_processor_dict )
       # create random PIL images
       a_      :	str      =							prepare_image_inputs(self.image_processor_tester							,		equal_resolution=lowerCAmelCase_ )
       for image in image_inputs:
         self.assertIsInstance(lowerCAmelCase_							,		Image.Image )

       # Test not batched input
       a_      :	Dict      =							image_processing(image_inputs[0]							,		return_tensors="""pt""" ).pixel_values
       self.assertEqual(
           encoded_images.shape							,		(
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size["""height"""],
               self.image_processor_tester.size["""width"""],
           )							,		)

       # Test batched
       a_      :	int      =							image_processing(lowerCAmelCase_							,		return_tensors="""pt""" ).pixel_values
       self.assertEqual(
           encoded_images.shape							,		(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size["""height"""],
               self.image_processor_tester.size["""width"""],
           )							,		)


     @is_flaky()
     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       a_      :	List[str]      =							self.image_processing_class(**self.image_processor_dict )
       # create random numpy tensors
       a_      :	int      =							prepare_image_inputs(self.image_processor_tester							,		equal_resolution=lowerCAmelCase_							,		numpify=lowerCAmelCase_ )
       for image in image_inputs:
         self.assertIsInstance(lowerCAmelCase_							,		np.ndarray )

       # Test not batched input
       a_      :	Optional[Any]      =							image_processing(image_inputs[0]							,		return_tensors="""pt""" ).pixel_values
       self.assertEqual(
           encoded_images.shape							,		(
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size["""height"""],
               self.image_processor_tester.size["""width"""],
           )							,		)

       # Test batched
       a_      :	Dict      =							image_processing(lowerCAmelCase_							,		return_tensors="""pt""" ).pixel_values
       self.assertEqual(
           encoded_images.shape							,		(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size["""height"""],
               self.image_processor_tester.size["""width"""],
           )							,		)






     @is_flaky()
     def 							_lowerCAmelCase  (      self ):

       '''simple docstring'''

       a_      :	Union[str, Any]      =							self.image_processing_class(**self.image_processor_dict )
       # create random PyTorch tensors
       a_      :	Optional[Any]      =							prepare_image_inputs(self.image_processor_tester							,		equal_resolution=lowerCAmelCase_							,		torchify=lowerCAmelCase_ )
       for image in image_inputs:
         self.assertIsInstance(lowerCAmelCase_							,		torch.Tensor )

       # Test not batched input
       a_      :	Optional[int]      =							image_processing(image_inputs[0]							,		return_tensors="""pt""" ).pixel_values
       self.assertEqual(
           encoded_images.shape							,		(
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size["""height"""],
               self.image_processor_tester.size["""width"""],
           )							,		)

       # Test batched
       a_      :	Any      =							image_processing(lowerCAmelCase_							,		return_tensors="""pt""" ).pixel_values
       self.assertEqual(
           encoded_images.shape							,		(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size["""height"""],
               self.image_processor_tester.size["""width"""],
           )							,		)


