signature:
def project_coords ( coords , from_shape , to_shape ) :
    """Project coordinates from one image shape to another .
 This performs a relative projection , e . g . a point at 60 % of the old
 image width will be at 60 % of the new image width after projection .
 Parameters
 coords : ndarray or tuple of number
 Coordinates to project . Either a ` ` ( N , 2 ) ` ` numpy array or a tuple
 of ` ( x , y ) ` coordinates .
 from _ shape : tuple of int or ndarray
 Old image shape .
 to _ shape : tuple of int or ndarray
 New image shape .
 Returns
 ndarray
 Projected coordinates as ` ` ( N , 2 ) ` ` ` ` float32 ` ` numpy array ."""

implementation:
from_shape = normalize_shape ( from_shape )
to_shape = normalize_shape ( to_shape )
if from_shape [ 0 : 2 ] == to_shape [ 0 : 2 ] :
    return coords
from_height , from_width = from_shape [ 0 : 2 ]
to_height , to_width = to_shape [ 0 : 2 ]
assert all ( [ v > 0 for v in [ from_height , from_width , to_height , to_width ] ] )
# make sure to not just call np . float32 ( coords ) here as the following lines
# perform in - place changes and np . float32 ( . ) only copies if the input
# was * not * a float32 array
coords_proj = np . array ( coords ) . astype ( np . float32 )
coords_proj [ : , 0 ] = ( coords_proj [ : , 0 ] / from_width ) * to_width
coords_proj [ : , 1 ] = ( coords_proj [ : , 1 ] / from_height ) * to_height
return coords_proj


signature:
def AdditiveGaussianNoise ( loc = 0 , scale = 0 , per_channel = False , name = None , deterministic = False , random_state = None ) :
    """Add gaussian noise ( aka white noise ) to images .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . AddElementwise ` ` .
 Parameters
 loc : number or tuple of number or list of number or imgaug . parameters . StochasticParameter , optional
 Mean of the normal distribution that generates the noise .
 * If a number , exactly that value will be used .
 * If a tuple ` ` ( a , b ) ` ` , a random value from the range ` ` a < = x < = b ` ` will
 be sampled per image .
 * If a list , then a random value will be sampled from that list per
 image .
 * If a StochasticParameter , a value will be sampled from the
 parameter per image .
 scale : number or tuple of number or list of number or imgaug . parameters . StochasticParameter , optional
 Standard deviation of the normal distribution that generates the noise .
 Must be ` ` > = 0 ` ` . If 0 then only ` loc ` will be used .
 * If an int or float , exactly that value will be used .
 * If a tuple ` ` ( a , b ) ` ` , a random value from the range ` ` a < = x < = b ` ` will
 be sampled per image .
 * If a list , then a random value will be sampled from that list per
 image .
 * If a StochasticParameter , a value will be sampled from the
 parameter per image .
 per _ channel : bool or float , optional
 Whether to use the same noise value per pixel for all channels ( False )
 or to sample a new value for each channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . AdditiveGaussianNoise ( scale = 0.1*255)
 adds gaussian noise from the distribution ` ` N ( 0 , 0.1*255 ) ` ` to images .
 > > > aug = iaa . AdditiveGaussianNoise ( scale = ( 0 , 0.1*255 ) )
 adds gaussian noise from the distribution ` ` N ( 0 , s ) ` ` to images ,
 where s is sampled per image from the range ` ` 0 < = s < = 0.1*255 ` ` .
 > > > aug = iaa . AdditiveGaussianNoise ( scale = 0.1*255 , per _ channel = True )
 adds gaussian noise from the distribution ` ` N ( 0 , 0.1*255 ) ` ` to images ,
 where the noise value is different per pixel * and * channel ( e . g . a
 different one for red , green and blue channels for the same pixel ) .
 > > > aug = iaa . AdditiveGaussianNoise ( scale = 0.1*255 , per _ channel = 0.5)
 adds gaussian noise from the distribution ` ` N ( 0 , 0.1*255 ) ` ` to images ,
 where the noise value is sometimes ( 50 percent of all cases ) the same
 per pixel for all channels and sometimes different ( other 50 percent ) ."""

implementation:
loc2 = iap . handle_continuous_param ( loc , "loc" , value_range = None , tuple_to_uniform = True , list_to_choice = True )
scale2 = iap . handle_continuous_param ( scale , "scale" , value_range = ( 0 , None ) , tuple_to_uniform = True , list_to_choice = True )
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return AddElementwise ( iap . Normal ( loc = loc2 , scale = scale2 ) , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def AdditivePoissonNoise ( lam = 0 , per_channel = False , name = None , deterministic = False , random_state = None ) :
    """Create an augmenter to add poisson noise to images .
 Poisson noise is comparable to gaussian noise as in ` ` AdditiveGaussianNoise ` ` , but the values are sampled from
 a poisson distribution instead of a gaussian distribution . As poisson distributions produce only positive numbers ,
 the sign of the sampled values are here randomly flipped .
 Values of around ` ` 10.0 ` ` for ` lam ` lead to visible noise ( for uint8 ) .
 Values of around ` ` 20.0 ` ` for ` lam ` lead to very visible noise ( for uint8 ) .
 It is recommended to usually set ` per _ channel ` to True .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . AddElementwise ` ` .
 Parameters
 lam : number or tuple of number or list of number or imgaug . parameters . StochasticParameter , optional
 Lambda parameter of the poisson distribution . Recommended values are around ` ` 0.0 ` ` to ` ` 10.0 ` ` .
 * If a number , exactly that value will be used .
 * If a tuple ` ` ( a , b ) ` ` , a random value from the range ` ` a < = x < = b ` ` will
 be sampled per image .
 * If a list , then a random value will be sampled from that list per image .
 * If a StochasticParameter , a value will be sampled from the
 parameter per image .
 per _ channel : bool or float , optional
 Whether to use the same noise value per pixel for all channels ( False )
 or to sample a new value for each channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . AdditivePoissonNoise ( lam = 5.0)
 Adds poisson noise sampled from ` ` Poisson ( 5.0 ) ` ` to images .
 > > > aug = iaa . AdditivePoissonNoise ( lam = ( 0.0 , 10.0 ) )
 Adds poisson noise sampled from ` ` Poisson ( x ) ` ` to images , where ` ` x ` ` is randomly sampled per image from the
 interval ` ` [ 0.0 , 10.0 ] ` ` .
 > > > aug = iaa . AdditivePoissonNoise ( lam = 5.0 , per _ channel = True )
 Adds poisson noise sampled from ` ` Poisson ( 5.0 ) ` ` to images ,
 where the values are different per pixel * and * channel ( e . g . a
 different one for red , green and blue channels for the same pixel ) .
 > > > aug = iaa . AdditivePoissonNoise ( lam = ( 0.0 , 10.0 ) , per _ channel = True )
 Adds poisson noise sampled from ` ` Poisson ( x ) ` ` to images ,
 with ` ` x ` ` being sampled from ` ` uniform ( 0.0 , 10.0 ) ` ` per image , pixel and channel .
 This is the * recommended * configuration .
 > > > aug = iaa . AdditivePoissonNoise ( lam = 2 , per _ channel = 0.5)
 Adds poisson noise sampled from the distribution ` ` Poisson ( 2 ) ` ` to images ,
 where the values are sometimes ( 50 percent of all cases ) the same
 per pixel for all channels and sometimes different ( other 50 percent ) ."""

implementation:
lam2 = iap . handle_continuous_param ( lam , "lam" , value_range = ( 0 , None ) , tuple_to_uniform = True , list_to_choice = True )
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return AddElementwise ( iap . RandomSign ( iap . Poisson ( lam = lam2 ) ) , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def Dropout ( p = 0 , per_channel = False , name = None , deterministic = False , random_state = None ) :
    """Augmenter that sets a certain fraction of pixels in images to zero .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . MultiplyElementwise ` ` .
 Parameters
 p : float or tuple of float or imgaug . parameters . StochasticParameter , optional
 The probability of any pixel being dropped ( i . e . set to zero ) .
 * If a float , then that value will be used for all images . A value
 of 1.0 would mean that all pixels will be dropped and 0.0 that
 no pixels would be dropped . A value of 0.05 corresponds to 5
 percent of all pixels dropped .
 * If a tuple ` ` ( a , b ) ` ` , then a value p will be sampled from the
 range ` ` a < = p < = b ` ` per image and be used as the pixel ' s dropout
 probability .
 * If a StochasticParameter , then this parameter will be used to
 determine per pixel whether it should be dropped ( sampled value
 of 0 ) or shouldn ' t ( sampled value of 1 ) .
 If you instead want to provide the probability as a stochastic
 parameter , you can usually do ` ` imgaug . parameters . Binomial ( 1 - p ) ` `
 to convert parameter ` p ` to a 0/1 representation .
 per _ channel : bool or float , optional
 Whether to use the same value ( is dropped / is not dropped )
 for all channels of a pixel ( False ) or to sample a new value for each
 channel ( True ) .
 If this value is a float p , then for p percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . Dropout ( 0.02)
 drops 2 percent of all pixels .
 > > > aug = iaa . Dropout ( ( 0.0 , 0.05 ) )
 drops in each image a random fraction of all pixels , where the fraction
 is in the range ` ` 0.0 < = x < = 0.05 ` ` .
 > > > aug = iaa . Dropout ( 0.02 , per _ channel = True )
 drops 2 percent of all pixels in a channel - wise fashion , i . e . it is unlikely
 for any pixel to have all channels set to zero ( black pixels ) .
 > > > aug = iaa . Dropout ( 0.02 , per _ channel = 0.5)
 same as previous example , but the ` per _ channel ` feature is only active
 for 50 percent of all images ."""

implementation:
if ia . is_single_number ( p ) :
    p2 = iap . Binomial ( 1 - p )
elif ia . is_iterable ( p ) :
    ia . do_assert ( len ( p ) == 2 )
    ia . do_assert ( p [ 0 ] < p [ 1 ] )
    ia . do_assert ( 0 <= p [ 0 ] <= 1.0 )
    ia . do_assert ( 0 <= p [ 1 ] <= 1.0 )
    p2 = iap . Binomial ( iap . Uniform ( 1 - p [ 1 ] , 1 - p [ 0 ] ) )
elif isinstance ( p , iap . StochasticParameter ) :
    p2 = p
else :
    raise Exception ( "Expected p to be float or int or StochasticParameter, got %s." % ( type ( p ) , ) )
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return MultiplyElementwise ( p2 , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def CoarseDropout ( p = 0 , size_px = None , size_percent = None , per_channel = False , min_size = 4 , name = None , deterministic = False , random_state = None ) :
    """Augmenter that sets rectangular areas within images to zero .
 In contrast to Dropout , these areas can have larger sizes .
 ( E . g . you might end up with three large black rectangles in an image . )
 Note that the current implementation leads to correlated sizes ,
 so when there is one large area that is dropped , there is a high likelihood
 that all other dropped areas are also large .
 This method is implemented by generating the dropout mask at a
 lower resolution ( than the image has ) and then upsampling the mask
 before dropping the pixels .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . MultiplyElementwise ` ` .
 Parameters
 p : float or tuple of float or imgaug . parameters . StochasticParameter , optional
 The probability of any pixel being dropped ( i . e . set to zero ) .
 * If a float , then that value will be used for all pixels . A value
 of 1.0 would mean , that all pixels will be dropped . A value of
 0.0 would lead to no pixels being dropped .
 * If a tuple ` ` ( a , b ) ` ` , then a value p will be sampled from the
 range ` ` a < = p < = b ` ` per image and be used as the pixel ' s dropout
 probability .
 * If a StochasticParameter , then this parameter will be used to
 determine per pixel whether it should be dropped ( sampled value
 of 0 ) or shouldn ' t ( sampled value of 1 ) .
 size _ px : int or tuple of int or imgaug . parameters . StochasticParameter , optional
 The size of the lower resolution image from which to sample the dropout
 mask in absolute pixel dimensions .
 * If an integer , then that size will be used for both height and
 width . E . g . a value of 3 would lead to a ` ` 3x3 ` ` mask , which is then
 upsampled to ` ` HxW ` ` , where ` ` H ` ` is the image size and W the image width .
 * If a tuple ` ` ( a , b ) ` ` , then two values ` ` M ` ` , ` ` N ` ` will be sampled from the
 range ` ` [ a . . b ] ` ` and the mask will be generated at size ` ` MxN ` ` , then
 upsampled to ` ` HxW ` ` .
 * If a StochasticParameter , then this parameter will be used to
 determine the sizes . It is expected to be discrete .
 size _ percent : float or tuple of float or imgaug . parameters . StochasticParameter , optional
 The size of the lower resolution image from which to sample the dropout
 mask * in percent * of the input image .
 * If a float , then that value will be used as the percentage of the
 height and width ( relative to the original size ) . E . g . for value
 p , the mask will be sampled from ` ` ( p * H ) x ( p * W ) ` ` and later upsampled
 to ` ` HxW ` ` .
 * If a tuple ` ` ( a , b ) ` ` , then two values ` ` m ` ` , ` ` n ` ` will be sampled from the
 interval ` ` ( a , b ) ` ` and used as the percentages , i . e the mask size
 will be ` ` ( m * H ) x ( n * W ) ` ` .
 * If a StochasticParameter , then this parameter will be used to
 sample the percentage values . It is expected to be continuous .
 per _ channel : bool or float , optional
 Whether to use the same value ( is dropped / is not dropped )
 for all channels of a pixel ( False ) or to sample a new value for each
 channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 min _ size : int , optional
 Minimum size of the low resolution mask , both width and height . If
 ` size _ percent ` or ` size _ px ` leads to a lower value than this , ` min _ size `
 will be used instead . This should never have a value of less than 2,
 otherwise one may end up with a ` ` 1x1 ` ` low resolution mask , leading easily
 to the whole image being dropped .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . CoarseDropout ( 0.02 , size _ percent = 0.5)
 drops 2 percent of all pixels on an lower - resolution image that has
 50 percent of the original image ' s size , leading to dropped areas that
 have roughly 2x2 pixels size .
 > > > aug = iaa . CoarseDropout ( ( 0.0 , 0.05 ) , size _ percent = ( 0.05 , 0.5 ) )
 generates a dropout mask at 5 to 50 percent of image ' s size . In that mask ,
 0 to 5 percent of all pixels are dropped ( random per image ) .
 > > > aug = iaa . CoarseDropout ( ( 0.0 , 0.05 ) , size _ px = ( 2 , 16 ) )
 same as previous example , but the lower resolution image has 2 to 16 pixels
 size .
 > > > aug = iaa . CoarseDropout ( 0.02 , size _ percent = 0.5 , per _ channel = True )
 drops 2 percent of all pixels at 50 percent resolution ( 2x2 sizes )
 in a channel - wise fashion , i . e . it is unlikely
 for any pixel to have all channels set to zero ( black pixels ) .
 > > > aug = iaa . CoarseDropout ( 0.02 , size _ percent = 0.5 , per _ channel = 0.5)
 same as previous example , but the ` per _ channel ` feature is only active
 for 50 percent of all images ."""

implementation:
if ia . is_single_number ( p ) :
    p2 = iap . Binomial ( 1 - p )
elif ia . is_iterable ( p ) :
    ia . do_assert ( len ( p ) == 2 )
    ia . do_assert ( p [ 0 ] < p [ 1 ] )
    ia . do_assert ( 0 <= p [ 0 ] <= 1.0 )
    ia . do_assert ( 0 <= p [ 1 ] <= 1.0 )
    p2 = iap . Binomial ( iap . Uniform ( 1 - p [ 1 ] , 1 - p [ 0 ] ) )
elif isinstance ( p , iap . StochasticParameter ) :
    p2 = p
else :
    raise Exception ( "Expected p to be float or int or StochasticParameter, got %s." % ( type ( p ) , ) )
if size_px is not None :
    p3 = iap . FromLowerResolution ( other_param = p2 , size_px = size_px , min_size = min_size )
elif size_percent is not None :
    p3 = iap . FromLowerResolution ( other_param = p2 , size_percent = size_percent , min_size = min_size )
else :
    raise Exception ( "Either size_px or size_percent must be set." )
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return MultiplyElementwise ( p3 , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def ImpulseNoise ( p = 0 , name = None , deterministic = False , random_state = None ) :
    """Creates an augmenter to apply impulse noise to an image .
 This is identical to ` ` SaltAndPepper ` ` , except that per _ channel is always set to True .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . SaltAndPepper ` ` ."""

implementation: return SaltAndPepper ( p = p , per_channel = True , name = name , deterministic = deterministic , random_state = random_state )


signature:
def SaltAndPepper ( p = 0 , per_channel = False , name = None , deterministic = False , random_state = None ) :
    """Adds salt and pepper noise to an image , i . e . some white - ish and black - ish pixels .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . ReplaceElementwise ` ` .
 Parameters
 p : float or tuple of float or list of float or imgaug . parameters . StochasticParameter , optional
 Probability of changing a pixel to salt / pepper noise .
 * If a float , then that value will be used for all images as the
 probability .
 * If a tuple ` ` ( a , b ) ` ` , then a probability will be sampled per image
 from the range ` ` a < = x < = b ` ` .
 * If a list , then a random value will be sampled from that list
 per image .
 * If a StochasticParameter , then this parameter will be used as
 the * mask * , i . e . it is expected to contain values between
 0.0 and 1.0 , where 1.0 means that salt / pepper is to be added
 at that location .
 per _ channel : bool or float , optional
 Whether to use the same value for all channels ( False )
 or to sample a new value for each channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . SaltAndPepper ( 0.05)
 Replaces 5 percent of all pixels with salt / pepper ."""

implementation:
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return ReplaceElementwise ( mask = p , replacement = iap . Beta ( 0.5 , 0.5 ) * 255 , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def Pepper ( p = 0 , per_channel = False , name = None , deterministic = False , random_state = None ) :
    """Adds pepper noise to an image , i . e . black - ish pixels .
 This is similar to dropout , but slower and the black pixels are not uniformly black .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . ReplaceElementwise ` ` .
 Parameters
 p : float or tuple of float or list of float or imgaug . parameters . StochasticParameter , optional
 Probability of changing a pixel to pepper noise .
 * If a float , then that value will be used for all images as the
 probability .
 * If a tuple ` ` ( a , b ) ` ` , then a probability will be sampled per image
 from the range ` ` a < = x < = b ` ` .
 * If a list , then a random value will be sampled from that list
 per image .
 * If a StochasticParameter , then this parameter will be used as
 the * mask * , i . e . it is expected to contain values between
 0.0 and 1.0 , where 1.0 means that pepper is to be added
 at that location .
 per _ channel : bool or float , optional
 Whether to use the same value for all channels ( False )
 or to sample a new value for each channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . Pepper ( 0.05)
 Replaces 5 percent of all pixels with pepper ."""

implementation:
replacement01 = iap . ForceSign ( iap . Beta ( 0.5 , 0.5 ) - 0.5 , positive = False , mode = "invert" ) + 0.5
replacement = replacement01 * 255
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return ReplaceElementwise ( mask = p , replacement = replacement , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def CoarsePepper ( p = 0 , size_px = None , size_percent = None , per_channel = False , min_size = 4 , name = None , deterministic = False , random_state = None ) :
    """Adds coarse pepper noise to an image , i . e . rectangles that contain noisy black - ish pixels .
 dtype support : :
 See ` ` imgaug . augmenters . arithmetic . ReplaceElementwise ` ` .
 Parameters
 p : float or tuple of float or list of float or imgaug . parameters . StochasticParameter , optional
 Probability of changing a pixel to pepper noise .
 * If a float , then that value will be used for all images as the
 probability .
 * If a tuple ` ` ( a , b ) ` ` , then a probability will be sampled per image
 from the range ` ` a < = x < = b . ` `
 * If a list , then a random value will be sampled from that list
 per image .
 * If a StochasticParameter , then this parameter will be used as
 the * mask * , i . e . it is expected to contain values between
 0.0 and 1.0 , where 1.0 means that pepper is to be added
 at that location .
 size _ px : int or tuple of int or imgaug . parameters . StochasticParameter , optional
 The size of the lower resolution image from which to sample the noise
 mask in absolute pixel dimensions .
 * If an integer , then that size will be used for both height and
 width . E . g . a value of 3 would lead to a ` ` 3x3 ` ` mask , which is then
 upsampled to ` ` HxW ` ` , where ` ` H ` ` is the image size and W the image width .
 * If a tuple ` ` ( a , b ) ` ` , then two values ` ` M ` ` , ` ` N ` ` will be sampled from the
 range ` ` [ a . . b ] ` ` and the mask will be generated at size ` ` MxN ` ` , then
 upsampled to ` ` HxW ` ` .
 * If a StochasticParameter , then this parameter will be used to
 determine the sizes . It is expected to be discrete .
 size _ percent : float or tuple of float or imgaug . parameters . StochasticParameter , optional
 The size of the lower resolution image from which to sample the noise
 mask * in percent * of the input image .
 * If a float , then that value will be used as the percentage of the
 height and width ( relative to the original size ) . E . g . for value
 p , the mask will be sampled from ` ` ( p * H ) x ( p * W ) ` ` and later upsampled
 to ` ` HxW ` ` .
 * If a tuple ` ` ( a , b ) ` ` , then two values ` ` m ` ` , ` ` n ` ` will be sampled from the
 interval ` ` ( a , b ) ` ` and used as the percentages , i . e the mask size
 will be ` ` ( m * H ) x ( n * W ) ` ` .
 * If a StochasticParameter , then this parameter will be used to
 sample the percentage values . It is expected to be continuous .
 per _ channel : bool or float , optional
 Whether to use the same value ( is dropped / is not dropped )
 for all channels of a pixel ( False ) or to sample a new value for each
 channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 min _ size : int , optional
 Minimum size of the low resolution mask , both width and height . If
 ` size _ percent ` or ` size _ px ` leads to a lower value than this , ` min _ size `
 will be used instead . This should never have a value of less than 2,
 otherwise one may end up with a 1x1 low resolution mask , leading easily
 to the whole image being replaced .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > aug = iaa . CoarsePepper ( 0.05 , size _ percent = ( 0.01 , 0.1 ) )
 Replaces 5 percent of all pixels with pepper in an image that has
 1 to 10 percent of the input image size , then upscales the results
 to the input image size , leading to large rectangular areas being replaced ."""

implementation:
mask = iap . handle_probability_param ( p , "p" , tuple_to_uniform = True , list_to_choice = True )
if size_px is not None :
    mask_low = iap . FromLowerResolution ( other_param = mask , size_px = size_px , min_size = min_size )
elif size_percent is not None :
    mask_low = iap . FromLowerResolution ( other_param = mask , size_percent = size_percent , min_size = min_size )
else :
    raise Exception ( "Either size_px or size_percent must be set." )
replacement01 = iap . ForceSign ( iap . Beta ( 0.5 , 0.5 ) - 0.5 , positive = False , mode = "invert" ) + 0.5
replacement = replacement01 * 255
if name is None :
    name = "Unnamed%s" % ( ia . caller_name ( ) , )
return ReplaceElementwise ( mask = mask_low , replacement = replacement , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def ContrastNormalization ( alpha = 1.0 , per_channel = False , name = None , deterministic = False , random_state = None ) :
    """Augmenter that changes the contrast of images .
 dtype support :
 See ` ` imgaug . augmenters . contrast . LinearContrast ` ` .
 Parameters
 alpha : number or tuple of number or list of number or imgaug . parameters . StochasticParameter , optional
 Strength of the contrast normalization . Higher values than 1.0
 lead to higher contrast , lower values decrease the contrast .
 * If a number , then that value will be used for all images .
 * If a tuple ` ` ( a , b ) ` ` , then a value will be sampled per image from
 the range ` ` a < = x < = b ` ` and be used as the alpha value .
 * If a list , then a random value will be sampled per image from
 that list .
 * If a StochasticParameter , then this parameter will be used to
 sample the alpha value per image .
 per _ channel : bool or float , optional
 Whether to use the same value for all channels ( False )
 or to sample a new value for each channel ( True ) .
 If this value is a float ` ` p ` ` , then for ` ` p ` ` percent of all images
 ` per _ channel ` will be treated as True , otherwise as False .
 name : None or str , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 deterministic : bool , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 random _ state : None or int or numpy . random . RandomState , optional
 See : func : ` imgaug . augmenters . meta . Augmenter . _ _ init _ _ ` .
 Examples
 > > > iaa . ContrastNormalization ( ( 0.5 , 1.5 ) )
 Decreases oder improves contrast per image by a random factor between
 0.5 and 1.5 . The factor 0.5 means that any difference from the center value
 ( i . e . 128 ) will be halved , leading to less contrast .
 > > > iaa . ContrastNormalization ( ( 0.5 , 1.5 ) , per _ channel = 0.5)
 Same as before , but for 50 percent of all images the normalization is done
 independently per channel ( i . e . factors can vary per channel for the same
 image ) . In the other 50 percent of all images , the factor is the same for
 all channels ."""

implementation:
# placed here to avoid cyclic dependency
from . import contrast as contrast_lib
return contrast_lib . LinearContrast ( alpha = alpha , per_channel = per_channel , name = name , deterministic = deterministic , random_state = random_state )


signature:
def is_single_float ( val ) :
    """Checks whether a variable is a float .
 Parameters
 val
 The variable to check .
 Returns
 bool
 True if the variable is a float . Otherwise False ."""

implementation: return isinstance ( val , numbers . Real ) and not is_single_integer ( val ) and not isinstance ( val , bool )


signature:
def is_integer_array ( val ) :
    """Checks whether a variable is a numpy integer array .
 Parameters
 val
 The variable to check .
 Returns
 bool
 True if the variable is a numpy integer array . Otherwise False ."""

implementation: return is_np_array ( val ) and issubclass ( val . dtype . type , np . integer )


signature:
def is_float_array ( val ) :
    """Checks whether a variable is a numpy float array .
 Parameters
 val
 The variable to check .
 Returns
 bool
 True if the variable is a numpy float array . Otherwise False ."""

implementation: return is_np_array ( val ) and issubclass ( val . dtype . type , np . floating )


signature:
def is_callable ( val ) :
    """Checks whether a variable is a callable , e . g . a function .
 Parameters
 val
 The variable to check .
 Returns
 bool
 True if the variable is a callable . Otherwise False ."""

implementation:
# python 3 . x with x < = 2 does not support callable ( ) , apparently
if sys . version_info [ 0 ] == 3 and sys . version_info [ 1 ] <= 2 :
    return hasattr ( val , '__call__' )
else :
    return callable ( val )


signature:
def flatten ( nested_iterable ) :
    """Flattens arbitrarily nested lists / tuples .
 Code partially taken from https : / / stackoverflow . com / a / 10824420.
 Parameters
 nested _ iterable
 A list or tuple of arbitrarily nested values .
 Yields
 any
 Non - list and non - tuple values in ` nested _ iterable ` ."""

implementation:
# don ' t just check if something is iterable here , because then strings
# and arrays will be split into their characters and components
if not isinstance ( nested_iterable , ( list , tuple ) ) :
    yield nested_iterable
else :
    for i in nested_iterable :
        if isinstance ( i , ( list , tuple ) ) :
            for j in flatten ( i ) :
                yield j
        else :
            yield i


signature:
def new_random_state ( seed = None , fully_random = False ) :
    """Returns a new random state .
 Parameters
 seed : None or int , optional
 Optional seed value to use .
 The same datatypes are allowed as for ` ` numpy . random . RandomState ( seed ) ` ` .
 fully _ random : bool , optional
 Whether to use numpy ' s random initialization for the
 RandomState ( used if set to True ) . If False , a seed is sampled from
 the global random state , which is a bit faster and hence the default .
 Returns
 numpy . random . RandomState
 The new random state ."""

implementation:
if seed is None :
    if not fully_random : # sample manually a seed instead of just RandomState ( ) ,
    # because the latter one
    # is way slower .
        seed = CURRENT_RANDOM_STATE . randint ( SEED_MIN_VALUE , SEED_MAX_VALUE , 1 ) [ 0 ]
return np . random . RandomState ( seed )


signature:
def copy_random_state ( random_state , force_copy = False ) :
    """Creates a copy of a random state .
 Parameters
 random _ state : numpy . random . RandomState
 The random state to copy .
 force _ copy : bool , optional
 If True , this function will always create a copy of every random
 state . If False , it will not copy numpy ' s default random state ,
 but all other random states .
 Returns
 rs _ copy : numpy . random . RandomState
 The copied random state ."""

implementation:
if random_state == np . random and not force_copy :
    return random_state
else :
    rs_copy = dummy_random_state ( )
    orig_state = random_state . get_state ( )
    rs_copy . set_state ( orig_state )
    return rs_copy


signature:
def derive_random_states ( random_state , n = 1 ) :
    """Create N new random states based on an existing random state or seed .
 Parameters
 random _ state : numpy . random . RandomState
 Random state or seed from which to derive new random states .
 n : int , optional
 Number of random states to derive .
 Returns
 list of numpy . random . RandomState
 Derived random states ."""

implementation:
seed_ = random_state . randint ( SEED_MIN_VALUE , SEED_MAX_VALUE , 1 ) [ 0 ]
return [ new_random_state ( seed_ + i ) for i in sm . xrange ( n ) ]


signature:
def _quokka_normalize_extract ( extract ) :
    """Generate a normalized rectangle to be extract from the standard quokka image .
 Parameters
 extract : ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 Unnormalized representation of the image subarea to be extracted .
 * If string ` ` square ` ` , then a squared area ` ` ( x : 0 to max 643 , y : 0 to max 643 ) ` `
 will be extracted from the image .
 * If a tuple , then expected to contain four numbers denoting ` ` x1 ` ` , ` ` y1 ` ` , ` ` x2 ` `
 and ` ` y2 ` ` .
 * If a BoundingBox , then that bounding box ' s area will be extracted from the image .
 * If a BoundingBoxesOnImage , then expected to contain exactly one bounding box
 and a shape matching the full image dimensions ( i . e . ( 643 , 960 , * ) ) . Then the
 one bounding box will be used similar to BoundingBox .
 Returns
 bb : imgaug . BoundingBox
 Normalized representation of the area to extract from the standard quokka image ."""

implementation:
# TODO get rid of this deferred import
from imgaug . augmentables . bbs import BoundingBox , BoundingBoxesOnImage
if extract == "square" :
    bb = BoundingBox ( x1 = 0 , y1 = 0 , x2 = 643 , y2 = 643 )
elif isinstance ( extract , tuple ) and len ( extract ) == 4 :
    bb = BoundingBox ( x1 = extract [ 0 ] , y1 = extract [ 1 ] , x2 = extract [ 2 ] , y2 = extract [ 3 ] )
elif isinstance ( extract , BoundingBox ) :
    bb = extract
elif isinstance ( extract , BoundingBoxesOnImage ) :
    do_assert ( len ( extract . bounding_boxes ) == 1 )
    do_assert ( extract . shape [ 0 : 2 ] == ( 643 , 960 ) )
    bb = extract . bounding_boxes [ 0 ]
else :
    raise Exception ( "Expected 'square' or tuple of four entries or BoundingBox or BoundingBoxesOnImage " + "for parameter 'extract', got %s." % ( type ( extract ) , ) )
return bb


signature:
def _compute_resized_shape ( from_shape , to_shape ) :
    """Computes the intended new shape of an image - like array after resizing .
 Parameters
 from _ shape : tuple or ndarray
 Old shape of the array . Usually expected to be a tuple of form ` ` ( H , W ) ` ` or ` ` ( H , W , C ) ` ` or
 alternatively an array with two or three dimensions .
 to _ shape : None or tuple of ints or tuple of floats or int or float or ndarray
 New shape of the array .
 * If None , then ` from _ shape ` will be used as the new shape .
 * If an int ` ` V ` ` , then the new shape will be ` ` ( V , V , [ C ] ) ` ` , where ` ` C ` ` will be added if it
 is part of ` from _ shape ` .
 * If a float ` ` V ` ` , then the new shape will be ` ` ( H * V , W * V , [ C ] ) ` ` , where ` ` H ` ` and ` ` W ` ` are the old
 height / width .
 * If a tuple ` ` ( H ' , W ' , [ C ' ] ) ` ` of ints , then ` ` H ' ` ` and ` ` W ' ` ` will be used as the new height
 and width .
 * If a tuple ` ` ( H ' , W ' , [ C ' ] ) ` ` of floats ( except ` ` C ` ` ) , then ` ` H ' ` ` and ` ` W ' ` ` will
 be used as the new height and width .
 * If a numpy array , then the array ' s shape will be used .
 Returns
 to _ shape _ computed : tuple of int
 New shape ."""

implementation:
if is_np_array ( from_shape ) :
    from_shape = from_shape . shape
if is_np_array ( to_shape ) :
    to_shape = to_shape . shape
to_shape_computed = list ( from_shape )
if to_shape is None :
    pass
elif isinstance ( to_shape , tuple ) :
    do_assert ( len ( from_shape ) in [ 2 , 3 ] )
    do_assert ( len ( to_shape ) in [ 2 , 3 ] )
    if len ( from_shape ) == 3 and len ( to_shape ) == 3 :
        do_assert ( from_shape [ 2 ] == to_shape [ 2 ] )
    elif len ( to_shape ) == 3 :
        to_shape_computed . append ( to_shape [ 2 ] )
    do_assert ( all ( [ v is None or is_single_number ( v ) for v in to_shape [ 0 : 2 ] ] ) , "Expected the first two entries in to_shape to be None or numbers, " + "got types %s." % ( str ( [ type ( v ) for v in to_shape [ 0 : 2 ] ] ) , ) )
    for i , from_shape_i in enumerate ( from_shape [ 0 : 2 ] ) :
        if to_shape [ i ] is None :
            to_shape_computed [ i ] = from_shape_i
        elif is_single_integer ( to_shape [ i ] ) :
            to_shape_computed [ i ] = to_shape [ i ]
        else : # float
            to_shape_computed [ i ] = int ( np . round ( from_shape_i * to_shape [ i ] ) )
elif is_single_integer ( to_shape ) or is_single_float ( to_shape ) :
    to_shape_computed = _compute_resized_shape ( from_shape , ( to_shape , to_shape ) )
else :
    raise Exception ( "Expected to_shape to be None or ndarray or tuple of floats or tuple of ints or single int " + "or single float, got %s." % ( type ( to_shape ) , ) )
return tuple ( to_shape_computed )


signature:
def quokka ( size = None , extract = None ) :
    """Returns an image of a quokka as a numpy array .
 Parameters
 size : None or float or tuple of int , optional
 Size of the output image . Input into : func : ` imgaug . imgaug . imresize _ single _ image ` .
 Usually expected to be a tuple ` ` ( H , W ) ` ` , where ` ` H ` ` is the desired height
 and ` ` W ` ` is the width . If None , then the image will not be resized .
 extract : None or ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 Subarea of the quokka image to extract :
 * If None , then the whole image will be used .
 * If string ` ` square ` ` , then a squared area ` ` ( x : 0 to max 643 , y : 0 to max 643 ) ` ` will
 be extracted from the image .
 * If a tuple , then expected to contain four numbers denoting ` ` x1 ` ` , ` ` y1 ` ` , ` ` x2 ` `
 and ` ` y2 ` ` .
 * If a BoundingBox , then that bounding box ' s area will be extracted from the image .
 * If a BoundingBoxesOnImage , then expected to contain exactly one bounding box
 and a shape matching the full image dimensions ( i . e . ` ` ( 643 , 960 , * ) ` ` ) . Then the
 one bounding box will be used similar to BoundingBox .
 Returns
 img : ( H , W , 3 ) ndarray
 The image array of dtype uint8."""

implementation:
img = imageio . imread ( QUOKKA_FP , pilmode = "RGB" )
if extract is not None :
    bb = _quokka_normalize_extract ( extract )
    img = bb . extract_from_image ( img )
if size is not None :
    shape_resized = _compute_resized_shape ( img . shape , size )
    img = imresize_single_image ( img , shape_resized [ 0 : 2 ] )
return img


signature:
def quokka_heatmap ( size = None , extract = None ) :
    """Returns a heatmap ( here : depth map ) for the standard example quokka image .
 Parameters
 size : None or float or tuple of int , optional
 See : func : ` imgaug . quokka ` .
 extract : None or ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 See : func : ` imgaug . quokka ` .
 Returns
 result : imgaug . HeatmapsOnImage
 Depth map as an heatmap object . Values close to 0.0 denote objects that are close to
 the camera . Values close to 1.0 denote objects that are furthest away ( among all shown
 objects ) ."""

implementation:
# TODO get rid of this deferred import
from imgaug . augmentables . heatmaps import HeatmapsOnImage
img = imageio . imread ( QUOKKA_DEPTH_MAP_HALFRES_FP , pilmode = "RGB" )
img = imresize_single_image ( img , ( 643 , 960 ) , interpolation = "cubic" )
if extract is not None :
    bb = _quokka_normalize_extract ( extract )
    img = bb . extract_from_image ( img )
if size is None :
    size = img . shape [ 0 : 2 ]
shape_resized = _compute_resized_shape ( img . shape , size )
img = imresize_single_image ( img , shape_resized [ 0 : 2 ] )
img_0to1 = img [ ... , 0 ]
# depth map was saved as 3 - channel RGB
img_0to1 = img_0to1 . astype ( np . float32 ) / 255.0
img_0to1 = 1 - img_0to1
# depth map was saved as 0 being furthest away
return HeatmapsOnImage ( img_0to1 , shape = img_0to1 . shape [ 0 : 2 ] + ( 3 , ) )


signature:
def quokka_segmentation_map ( size = None , extract = None ) :
    """Returns a segmentation map for the standard example quokka image .
 Parameters
 size : None or float or tuple of int , optional
 See : func : ` imgaug . quokka ` .
 extract : None or ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 See : func : ` imgaug . quokka ` .
 Returns
 result : imgaug . SegmentationMapOnImage
 Segmentation map object ."""

implementation:
# TODO get rid of this deferred import
from imgaug . augmentables . segmaps import SegmentationMapOnImage
with open ( QUOKKA_ANNOTATIONS_FP , "r" ) as f :
    json_dict = json . load ( f )
xx = [ ]
yy = [ ]
for kp_dict in json_dict [ "polygons" ] [ 0 ] [ "keypoints" ] :
    x = kp_dict [ "x" ]
    y = kp_dict [ "y" ]
    xx . append ( x )
    yy . append ( y )
img_seg = np . zeros ( ( 643 , 960 , 1 ) , dtype = np . float32 )
rr , cc = skimage . draw . polygon ( np . array ( yy ) , np . array ( xx ) , shape = img_seg . shape )
img_seg [ rr , cc ] = 1.0
if extract is not None :
    bb = _quokka_normalize_extract ( extract )
    img_seg = bb . extract_from_image ( img_seg )
segmap = SegmentationMapOnImage ( img_seg , shape = img_seg . shape [ 0 : 2 ] + ( 3 , ) )
if size is not None :
    shape_resized = _compute_resized_shape ( img_seg . shape , size )
    segmap = segmap . resize ( shape_resized [ 0 : 2 ] )
    segmap . shape = tuple ( shape_resized [ 0 : 2 ] ) + ( 3 , )
return segmap


signature:
def quokka_keypoints ( size = None , extract = None ) :
    """Returns example keypoints on the standard example quokke image .
 The keypoints cover the eyes , ears , nose and paws .
 Parameters
 size : None or float or tuple of int or tuple of float , optional
 Size of the output image on which the keypoints are placed . If None , then the keypoints
 are not projected to any new size ( positions on the original image are used ) .
 Floats lead to relative size changes , ints to absolute sizes in pixels .
 extract : None or ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 Subarea to extract from the image . See : func : ` imgaug . quokka ` .
 Returns
 kpsoi : imgaug . KeypointsOnImage
 Example keypoints on the quokka image ."""

implementation:
# TODO get rid of this deferred import
from imgaug . augmentables . kps import Keypoint , KeypointsOnImage
left , top = 0 , 0
if extract is not None :
    bb_extract = _quokka_normalize_extract ( extract )
    left = bb_extract . x1
    top = bb_extract . y1
with open ( QUOKKA_ANNOTATIONS_FP , "r" ) as f :
    json_dict = json . load ( f )
keypoints = [ ]
for kp_dict in json_dict [ "keypoints" ] :
    keypoints . append ( Keypoint ( x = kp_dict [ "x" ] - left , y = kp_dict [ "y" ] - top ) )
if extract is not None :
    shape = ( bb_extract . height , bb_extract . width , 3 )
else :
    shape = ( 643 , 960 , 3 )
kpsoi = KeypointsOnImage ( keypoints , shape = shape )
if size is not None :
    shape_resized = _compute_resized_shape ( shape , size )
    kpsoi = kpsoi . on ( shape_resized )
return kpsoi


signature:
def quokka_bounding_boxes ( size = None , extract = None ) :
    """Returns example bounding boxes on the standard example quokke image .
 Currently only a single bounding box is returned that covers the quokka .
 Parameters
 size : None or float or tuple of int or tuple of float , optional
 Size of the output image on which the BBs are placed . If None , then the BBs
 are not projected to any new size ( positions on the original image are used ) .
 Floats lead to relative size changes , ints to absolute sizes in pixels .
 extract : None or ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 Subarea to extract from the image . See : func : ` imgaug . quokka ` .
 Returns
 bbsoi : imgaug . BoundingBoxesOnImage
 Example BBs on the quokka image ."""

implementation:
# TODO get rid of this deferred import
from imgaug . augmentables . bbs import BoundingBox , BoundingBoxesOnImage
left , top = 0 , 0
if extract is not None :
    bb_extract = _quokka_normalize_extract ( extract )
    left = bb_extract . x1
    top = bb_extract . y1
with open ( QUOKKA_ANNOTATIONS_FP , "r" ) as f :
    json_dict = json . load ( f )
bbs = [ ]
for bb_dict in json_dict [ "bounding_boxes" ] :
    bbs . append ( BoundingBox ( x1 = bb_dict [ "x1" ] - left , y1 = bb_dict [ "y1" ] - top , x2 = bb_dict [ "x2" ] - left , y2 = bb_dict [ "y2" ] - top ) )
if extract is not None :
    shape = ( bb_extract . height , bb_extract . width , 3 )
else :
    shape = ( 643 , 960 , 3 )
bbsoi = BoundingBoxesOnImage ( bbs , shape = shape )
if size is not None :
    shape_resized = _compute_resized_shape ( shape , size )
    bbsoi = bbsoi . on ( shape_resized )
return bbsoi


signature:
def quokka_polygons ( size = None , extract = None ) :
    """Returns example polygons on the standard example quokke image .
 The result contains one polygon , covering the quokka ' s outline .
 Parameters
 size : None or float or tuple of int or tuple of float , optional
 Size of the output image on which the polygons are placed . If None ,
 then the polygons are not projected to any new size ( positions on the
 original image are used ) . Floats lead to relative size changes , ints
 to absolute sizes in pixels .
 extract : None or ' square ' or tuple of number or imgaug . BoundingBox or imgaug . BoundingBoxesOnImage
 Subarea to extract from the image . See : func : ` imgaug . quokka ` .
 Returns
 psoi : imgaug . PolygonsOnImage
 Example polygons on the quokka image ."""

implementation:
# TODO get rid of this deferred import
from imgaug . augmentables . polys import Polygon , PolygonsOnImage
left , top = 0 , 0
if extract is not None :
    bb_extract = _quokka_normalize_extract ( extract )
    left = bb_extract . x1
    top = bb_extract . y1
with open ( QUOKKA_ANNOTATIONS_FP , "r" ) as f :
    json_dict = json . load ( f )
polygons = [ ]
for poly_json in json_dict [ "polygons" ] :
    polygons . append ( Polygon ( [ ( point [ "x" ] - left , point [ "y" ] - top ) for point in poly_json [ "keypoints" ] ] ) )
if extract is not None :
    shape = ( bb_extract . height , bb_extract . width , 3 )
else :
    shape = ( 643 , 960 , 3 )
psoi = PolygonsOnImage ( polygons , shape = shape )
if size is not None :
    shape_resized = _compute_resized_shape ( shape , size )
    psoi = psoi . on ( shape_resized )
return psoi


signature:
def angle_between_vectors ( v1 , v2 ) :
    """Returns the angle in radians between vectors ` v1 ` and ` v2 ` .
 From http : / / stackoverflow . com / questions / 2827393 / angles - between - two - n - dimensional - vectors - in - python
 Parameters
 v1 : ( N , ) ndarray
 First vector .
 v2 : ( N , ) ndarray
 Second vector .
 Returns
 out : float
 Angle in radians .
 Examples
 > > > angle _ between _ vectors ( np . float32 ( [ 1 , 0 , 0 ] ) , np . float32 ( [ 0 , 1 , 0 ] ) )
 1.570796 . . .
 > > > angle _ between _ vectors ( np . float32 ( [ 1 , 0 , 0 ] ) , np . float32 ( [ 1 , 0 , 0 ] ) )
 0.0
 > > > angle _ between _ vectors ( np . float32 ( [ 1 , 0 , 0 ] ) , np . float32 ( [ - 1 , 0 , 0 ] ) )
 3.141592 . . ."""

implementation:
l1 = np . linalg . norm ( v1 )
l2 = np . linalg . norm ( v2 )
v1_u = ( v1 / l1 ) if l1 > 0 else np . float32 ( v1 ) * 0
v2_u = ( v2 / l2 ) if l2 > 0 else np . float32 ( v2 ) * 0
return np . arccos ( np . clip ( np . dot ( v1_u , v2_u ) , - 1.0 , 1.0 ) )


signature:
def compute_line_intersection_point ( x1 , y1 , x2 , y2 , x3 , y3 , x4 , y4 ) :
    """Compute the intersection point of two lines .
 Taken from https : / / stackoverflow . com / a / 20679579 .
 Parameters
 x1 : number
 x coordinate of the first point on line 1 . ( The lines extends beyond this point . )
 y1 : number
 y coordinate of the first point on line 1 . ( The lines extends beyond this point . )
 x2 : number
 x coordinate of the second point on line 1 . ( The lines extends beyond this point . )
 y2 : number
 y coordinate of the second point on line 1 . ( The lines extends beyond this point . )
 x3 : number
 x coordinate of the first point on line 2 . ( The lines extends beyond this point . )
 y3 : number
 y coordinate of the first point on line 2 . ( The lines extends beyond this point . )
 x4 : number
 x coordinate of the second point on line 2 . ( The lines extends beyond this point . )
 y4 : number
 y coordinate of the second point on line 2 . ( The lines extends beyond this point . )
 Returns
 tuple of number or bool
 The coordinate of the intersection point as a tuple ` ` ( x , y ) ` ` .
 If the lines are parallel ( no intersection point or an infinite number of them ) , the result is False ."""


signature:
def draw_text ( img , y , x , text , color = ( 0 , 255 , 0 ) , size = 25 ) :
    """Draw text on an image .
 This uses by default DejaVuSans as its font , which is included in this library .
 dtype support : :
 * ` ` uint8 ` ` : yes ; fully tested
 * ` ` uint16 ` ` : no
 * ` ` uint32 ` ` : no
 * ` ` uint64 ` ` : no
 * ` ` int8 ` ` : no
 * ` ` int16 ` ` : no
 * ` ` int32 ` ` : no
 * ` ` int64 ` ` : no
 * ` ` float16 ` ` : no
 * ` ` float32 ` ` : yes ; not tested
 * ` ` float64 ` ` : no
 * ` ` float128 ` ` : no
 * ` ` bool ` ` : no
 TODO check if other dtypes could be enabled
 Parameters
 img : ( H , W , 3 ) ndarray
 The image array to draw text on .
 Expected to be of dtype uint8 or float32 ( value range 0.0 to 255.0 ) .
 y : int
 x - coordinate of the top left corner of the text .
 x : int
 y - coordinate of the top left corner of the text .
 text : str
 The text to draw .
 color : iterable of int , optional
 Color of the text to draw . For RGB - images this is expected to be an RGB color .
 size : int , optional
 Font size of the text to draw .
 Returns
 img _ np : ( H , W , 3 ) ndarray
 Input image with text drawn on it ."""

implementation:
do_assert ( img . dtype in [ np . uint8 , np . float32 ] )
input_dtype = img . dtype
if img . dtype == np . float32 :
    img = img . astype ( np . uint8 )
img = PIL_Image . fromarray ( img )
font = PIL_ImageFont . truetype ( DEFAULT_FONT_FP , size )
context = PIL_ImageDraw . Draw ( img )
context . text ( ( x , y ) , text , fill = tuple ( color ) , font = font )
img_np = np . asarray ( img )
# PIL / asarray returns read only array
if not img_np . flags [ "WRITEABLE" ] :
    try : # this seems to no longer work with np 1.16 ( or was pillow updated ? )
        img_np . setflags ( write = True )
    except ValueError as ex :
        if "cannot set WRITEABLE flag to True of this array" in str ( ex ) :
            img_np = np . copy ( img_np )
if img_np . dtype != input_dtype :
    img_np = img_np . astype ( input_dtype )
return img_np


signature:
def imresize_many_images ( images , sizes = None , interpolation = None ) :
    """Resize many images to a specified size .
 dtype support : :
 * ` ` uint8 ` ` : yes ; fully tested
 * ` ` uint16 ` ` : yes ; tested
 * ` ` uint32 ` ` : no ( 1)
 * ` ` uint64 ` ` : no ( 2)
 * ` ` int8 ` ` : yes ; tested ( 3)
 * ` ` int16 ` ` : yes ; tested
 * ` ` int32 ` ` : limited ; tested ( 4)
 * ` ` int64 ` ` : no ( 2)
 * ` ` float16 ` ` : yes ; tested ( 5)
 * ` ` float32 ` ` : yes ; tested
 * ` ` float64 ` ` : yes ; tested
 * ` ` float128 ` ` : no ( 1)
 * ` ` bool ` ` : yes ; tested ( 6)
 - ( 1 ) rejected by ` ` cv2 . imresize ` `
 - ( 2 ) results too inaccurate
 - ( 3 ) mapped internally to ` ` int16 ` ` when interpolation ! = " nearest "
 - ( 4 ) only supported for interpolation = " nearest " , other interpolations lead to cv2 error
 - ( 5 ) mapped internally to ` ` float32 ` `
 - ( 6 ) mapped internally to ` ` uint8 ` `
 Parameters
 images : ( N , H , W , [ C ] ) ndarray or list of ( H , W , [ C ] ) ndarray
 Array of the images to resize .
 Usually recommended to be of dtype uint8.
 sizes : float or iterable of int or iterable of float
 The new size of the images , given either as a fraction ( a single float ) or as
 a ` ` ( height , width ) ` ` tuple of two integers or as a ` ` ( height fraction , width fraction ) ` `
 tuple of two floats .
 interpolation : None or str or int , optional
 The interpolation to use during resize .
 If int , then expected to be one of :
 * ` ` cv2 . INTER _ NEAREST ` ` ( nearest neighbour interpolation )
 * ` ` cv2 . INTER _ LINEAR ` ` ( linear interpolation )
 * ` ` cv2 . INTER _ AREA ` ` ( area interpolation )
 * ` ` cv2 . INTER _ CUBIC ` ` ( cubic interpolation )
 If string , then expected to be one of :
 * ` ` nearest ` ` ( identical to ` ` cv2 . INTER _ NEAREST ` ` )
 * ` ` linear ` ` ( identical to ` ` cv2 . INTER _ LINEAR ` ` )
 * ` ` area ` ` ( identical to ` ` cv2 . INTER _ AREA ` ` )
 * ` ` cubic ` ` ( identical to ` ` cv2 . INTER _ CUBIC ` ` )
 If None , the interpolation will be chosen automatically . For size
 increases , area interpolation will be picked and for size decreases ,
 linear interpolation will be picked .
 Returns
 result : ( N , H ' , W ' , [ C ] ) ndarray
 Array of the resized images .
 Examples
 > > > imresize _ many _ images ( np . zeros ( ( 2 , 16 , 16 , 3 ) , dtype = np . uint8 ) , 2.0)
 Converts 2 RGB images of height and width 16 to images of height and width 16*2 = 32.
 > > > imresize _ many _ images ( np . zeros ( ( 2 , 16 , 16 , 3 ) , dtype = np . uint8 ) , ( 16 , 32 ) )
 Converts 2 RGB images of height and width 16 to images of height 16 and width 32.
 > > > imresize _ many _ images ( np . zeros ( ( 2 , 16 , 16 , 3 ) , dtype = np . uint8 ) , ( 2.0 , 4.0 ) )
 Converts 2 RGB images of height and width 16 to images of height 32 and width 64."""

implementation:
# we just do nothing if the input contains zero images
# one could also argue that an exception would be appropriate here
if len ( images ) == 0 :
    return images
# verify that all input images have height / width > 0
do_assert ( all ( [ image . shape [ 0 ] > 0 and image . shape [ 1 ] > 0 for image in images ] ) , ( "Cannot resize images, because at least one image has a height and/or width of zero. " + "Observed shapes were: %s." ) % ( str ( [ image . shape for image in images ] ) , ) )
# verify that sizes contains only values > 0
if is_single_number ( sizes ) and sizes <= 0 :
    raise Exception ( "Cannot resize to the target size %.8f, because the value is zero or lower than zero." % ( sizes , ) )
elif isinstance ( sizes , tuple ) and ( sizes [ 0 ] <= 0 or sizes [ 1 ] <= 0 ) :
    sizes_str = [ "int %d" % ( sizes [ 0 ] , ) if is_single_integer ( sizes [ 0 ] ) else "float %.8f" % ( sizes [ 0 ] , ) , "int %d" % ( sizes [ 1 ] , ) if is_single_integer ( sizes [ 1 ] ) else "float %.8f" % ( sizes [ 1 ] , ) , ]
    sizes_str = "(%s, %s)" % ( sizes_str [ 0 ] , sizes_str [ 1 ] )
    raise Exception ( "Cannot resize to the target sizes %s. At least one value is zero or lower than zero." % ( sizes_str , ) )
# change after the validation to make the above error messages match the original input
if is_single_number ( sizes ) :
    sizes = ( sizes , sizes )
else :
    do_assert ( len ( sizes ) == 2 , "Expected tuple with exactly two entries, got %d entries." % ( len ( sizes ) , ) )
    do_assert ( all ( [ is_single_number ( val ) for val in sizes ] ) , "Expected tuple with two ints or floats, got types %s." % ( str ( [ type ( val ) for val in sizes ] ) , ) )
# if input is a list , call this function N times for N images
# but check beforehand if all images have the same shape , then just convert to a single array and de - convert
# afterwards
if isinstance ( images , list ) :
    nb_shapes = len ( set ( [ image . shape for image in images ] ) )
    if nb_shapes == 1 :
        return list ( imresize_many_images ( np . array ( images ) , sizes = sizes , interpolation = interpolation ) )
    else :
        return [ imresize_many_images ( image [ np . newaxis , ... ] , sizes = sizes , interpolation = interpolation ) [ 0 , ... ] for image in images ]
shape = images . shape
do_assert ( images . ndim in [ 3 , 4 ] , "Expected array of shape (N, H, W, [C]), got shape %s" % ( str ( shape ) , ) )
nb_images = shape [ 0 ]
im_height , im_width = shape [ 1 ] , shape [ 2 ]
nb_channels = shape [ 3 ] if images . ndim > 3 else None
height , width = sizes [ 0 ] , sizes [ 1 ]
height = int ( np . round ( im_height * height ) ) if is_single_float ( height ) else height
width = int ( np . round ( im_width * width ) ) if is_single_float ( width ) else width
if height == im_height and width == im_width :
    return np . copy ( images )
ip = interpolation
do_assert ( ip is None or ip in IMRESIZE_VALID_INTERPOLATIONS )
if ip is None :
    if height > im_height or width > im_width :
        ip = cv2 . INTER_AREA
    else :
        ip = cv2 . INTER_LINEAR
elif ip in [ "nearest" , cv2 . INTER_NEAREST ] :
    ip = cv2 . INTER_NEAREST
elif ip in [ "linear" , cv2 . INTER_LINEAR ] :
    ip = cv2 . INTER_LINEAR
elif ip in [ "area" , cv2 . INTER_AREA ] :
    ip = cv2 . INTER_AREA
else : # if ip in [ " cubic " , cv2 . INTER _ CUBIC ] :
    ip = cv2 . INTER_CUBIC
# TODO find more beautiful way to avoid circular imports
from . import dtypes as iadt
if ip == cv2 . INTER_NEAREST :
    iadt . gate_dtypes ( images , allowed = [ "bool" , "uint8" , "uint16" , "int8" , "int16" , "int32" , "float16" , "float32" , "float64" ] , disallowed = [ "uint32" , "uint64" , "uint128" , "uint256" , "int64" , "int128" , "int256" , "float96" , "float128" , "float256" ] , augmenter = None )
else :
    iadt . gate_dtypes ( images , allowed = [ "bool" , "uint8" , "uint16" , "int8" , "int16" , "float16" , "float32" , "float64" ] , disallowed = [ "uint32" , "uint64" , "uint128" , "uint256" , "int32" , "int64" , "int128" , "int256" , "float96" , "float128" , "float256" ] , augmenter = None )
result_shape = ( nb_images , height , width )
if nb_channels is not None :
    result_shape = result_shape + ( nb_channels , )
result = np . zeros ( result_shape , dtype = images . dtype )
for i , image in enumerate ( images ) :
    input_dtype = image . dtype
    if image . dtype . type == np . bool_ :
        image = image . astype ( np . uint8 ) * 255
    elif image . dtype . type == np . int8 and ip != cv2 . INTER_NEAREST :
        image = image . astype ( np . int16 )
    elif image . dtype . type == np . float16 :
        image = image . astype ( np . float32 )
    result_img = cv2 . resize ( image , ( width , height ) , interpolation = ip )
    assert result_img . dtype == image . dtype
    # cv2 removes the channel axis if input was ( H , W , 1)
    # we re - add it ( but only if input was not ( H , W ) )
    if len ( result_img . shape ) == 2 and nb_channels is not None and nb_channels == 1 :
        result_img = result_img [ : , : , np . newaxis ]
    if input_dtype . type == np . bool_ :
        result_img = result_img > 127
    elif input_dtype . type == np . int8 and ip != cv2 . INTER_NEAREST : # TODO somehow better avoid circular imports here
        from . import dtypes as iadt
        result_img = iadt . restore_dtypes_ ( result_img , np . int8 )
    elif input_dtype . type == np . float16 : # TODO see above
        from . import dtypes as iadt
        result_img = iadt . restore_dtypes_ ( result_img , np . float16 )
    result [ i ] = result_img
return result


signature:
def imresize_single_image ( image , sizes , interpolation = None ) :
    """Resizes a single image .
 dtype support : :
 See : func : ` imgaug . imgaug . imresize _ many _ images ` .
 Parameters
 image : ( H , W , C ) ndarray or ( H , W ) ndarray
 Array of the image to resize .
 Usually recommended to be of dtype uint8.
 sizes : float or iterable of int or iterable of float
 See : func : ` imgaug . imgaug . imresize _ many _ images ` .
 interpolation : None or str or int , optional
 See : func : ` imgaug . imgaug . imresize _ many _ images ` .
 Returns
 out : ( H ' , W ' , C ) ndarray or ( H ' , W ' ) ndarray
 The resized image ."""

implementation:
grayscale = False
if image . ndim == 2 :
    grayscale = True
    image = image [ : , : , np . newaxis ]
do_assert ( len ( image . shape ) == 3 , image . shape )
rs = imresize_many_images ( image [ np . newaxis , : , : , : ] , sizes , interpolation = interpolation )
if grayscale :
    return np . squeeze ( rs [ 0 , : , : , 0 ] )
else :
    return rs [ 0 , ... ]


signature:
def pad ( arr , top = 0 , right = 0 , bottom = 0 , left = 0 , mode = "constant" , cval = 0 ) :
    """Pad an image - like array on its top / right / bottom / left side .
 This function is a wrapper around : func : ` numpy . pad ` .
 dtype support : :
 * ` ` uint8 ` ` : yes ; fully tested ( 1)
 * ` ` uint16 ` ` : yes ; fully tested ( 1)
 * ` ` uint32 ` ` : yes ; fully tested ( 2 ) ( 3)
 * ` ` uint64 ` ` : yes ; fully tested ( 2 ) ( 3)
 * ` ` int8 ` ` : yes ; fully tested ( 1)
 * ` ` int16 ` ` : yes ; fully tested ( 1)
 * ` ` int32 ` ` : yes ; fully tested ( 1)
 * ` ` int64 ` ` : yes ; fully tested ( 2 ) ( 3)
 * ` ` float16 ` ` : yes ; fully tested ( 2 ) ( 3)
 * ` ` float32 ` ` : yes ; fully tested ( 1)
 * ` ` float64 ` ` : yes ; fully tested ( 1)
 * ` ` float128 ` ` : yes ; fully tested ( 2 ) ( 3)
 * ` ` bool ` ` : yes ; tested ( 2 ) ( 3)
 - ( 1 ) Uses ` ` cv2 ` ` if ` mode ` is one of : ` ` " constant " ` ` , ` ` " edge " ` ` , ` ` " reflect " ` ` , ` ` " symmetric " ` ` .
 Otherwise uses ` ` numpy ` ` .
 - ( 2 ) Uses ` ` numpy ` ` .
 - ( 3 ) Rejected by ` ` cv2 ` ` .
 Parameters
 arr : ( H , W ) ndarray or ( H , W , C ) ndarray
 Image - like array to pad .
 top : int , optional
 Amount of pixels to add at the top side of the image . Must be 0 or greater .
 right : int , optional
 Amount of pixels to add at the right side of the image . Must be 0 or greater .
 bottom : int , optional
 Amount of pixels to add at the bottom side of the image . Must be 0 or greater .
 left : int , optional
 Amount of pixels to add at the left side of the image . Must be 0 or greater .
 mode : str , optional
 Padding mode to use . See : func : ` numpy . pad ` for details .
 In case of mode ` ` constant ` ` , the parameter ` cval ` will be used as the ` ` constant _ values ` `
 parameter to : func : ` numpy . pad ` .
 In case of mode ` ` linear _ ramp ` ` , the parameter ` cval ` will be used as the ` ` end _ values ` `
 parameter to : func : ` numpy . pad ` .
 cval : number , optional
 Value to use for padding if ` mode ` is ` ` constant ` ` . See : func : ` numpy . pad ` for details .
 The cval is expected to match the input array ' s dtype and value range .
 Returns
 arr _ pad : ( H ' , W ' ) ndarray or ( H ' , W ' , C ) ndarray
 Padded array with height ` ` H ' = H + top + bottom ` ` and width ` ` W ' = W + left + right ` ` ."""

implementation:
do_assert ( arr . ndim in [ 2 , 3 ] )
do_assert ( top >= 0 )
do_assert ( right >= 0 )
do_assert ( bottom >= 0 )
do_assert ( left >= 0 )
if top > 0 or right > 0 or bottom > 0 or left > 0 :
    mapping_mode_np_to_cv2 = { "constant" : cv2 . BORDER_CONSTANT , "edge" : cv2 . BORDER_REPLICATE , "linear_ramp" : None , "maximum" : None , "mean" : None , "median" : None , "minimum" : None , "reflect" : cv2 . BORDER_REFLECT_101 , "symmetric" : cv2 . BORDER_REFLECT , "wrap" : None , cv2 . BORDER_CONSTANT : cv2 . BORDER_CONSTANT , cv2 . BORDER_REPLICATE : cv2 . BORDER_REPLICATE , cv2 . BORDER_REFLECT_101 : cv2 . BORDER_REFLECT_101 , cv2 . BORDER_REFLECT : cv2 . BORDER_REFLECT }
    bad_mode_cv2 = mapping_mode_np_to_cv2 . get ( mode , None ) is None
    # these datatypes all simply generate a " TypeError : src data type = X is not supported " error
    bad_datatype_cv2 = arr . dtype . name in [ "uint32" , "uint64" , "int64" , "float16" , "float128" , "bool" ]
    if not bad_datatype_cv2 and not bad_mode_cv2 :
        cval = float ( cval ) if arr . dtype . kind == "f" else int ( cval )
        # results in TypeError otherwise for np inputs
        if arr . ndim == 2 or arr . shape [ 2 ] <= 4 : # without this , only the first channel is padded with the cval , all following channels with 0
            if arr . ndim == 3 :
                cval = tuple ( [ cval ] * arr . shape [ 2 ] )
            arr_pad = cv2 . copyMakeBorder ( arr , top = top , bottom = bottom , left = left , right = right , borderType = mapping_mode_np_to_cv2 [ mode ] , value = cval )
            if arr . ndim == 3 and arr_pad . ndim == 2 :
                arr_pad = arr_pad [ ... , np . newaxis ]
        else :
            result = [ ]
            channel_start_idx = 0
            while channel_start_idx < arr . shape [ 2 ] :
                arr_c = arr [ ... , channel_start_idx : channel_start_idx + 4 ]
                cval_c = tuple ( [ cval ] * arr_c . shape [ 2 ] )
                arr_pad_c = cv2 . copyMakeBorder ( arr_c , top = top , bottom = bottom , left = left , right = right , borderType = mapping_mode_np_to_cv2 [ mode ] , value = cval_c )
                arr_pad_c = np . atleast_3d ( arr_pad_c )
                result . append ( arr_pad_c )
                channel_start_idx += 4
            arr_pad = np . concatenate ( result , axis = 2 )
    else :
        paddings_np = [ ( top , bottom ) , ( left , right ) ]
        # paddings for 2d case
        if arr . ndim == 3 :
            paddings_np . append ( ( 0 , 0 ) )
        # add paddings for 3d case
        if mode == "constant" :
            arr_pad = np . pad ( arr , paddings_np , mode = mode , constant_values = cval )
        elif mode == "linear_ramp" :
            arr_pad = np . pad ( arr , paddings_np , mode = mode , end_values = cval )
        else :
            arr_pad = np . pad ( arr , paddings_np , mode = mode )
    return arr_pad
return np . copy ( arr )


signature:
def compute_paddings_for_aspect_ratio ( arr , aspect_ratio ) :
    """Compute the amount of pixels by which an array has to be padded to fulfill an aspect ratio .
 The aspect ratio is given as width / height .
 Depending on which dimension is smaller ( height or width ) , only the corresponding
 sides ( left / right or top / bottom ) will be padded . In each case , both of the sides will
 be padded equally .
 Parameters
 arr : ( H , W ) ndarray or ( H , W , C ) ndarray
 Image - like array for which to compute pad amounts .
 aspect _ ratio : float
 Target aspect ratio , given as width / height . E . g . 2.0 denotes the image having twice
 as much width as height .
 Returns
 result : tuple of int
 Required paddign amounts to reach the target aspect ratio , given as a tuple
 of the form ` ` ( top , right , bottom , left ) ` ` ."""

implementation:
do_assert ( arr . ndim in [ 2 , 3 ] )
do_assert ( aspect_ratio > 0 )
height , width = arr . shape [ 0 : 2 ]
do_assert ( height > 0 )
aspect_ratio_current = width / height
pad_top = 0
pad_right = 0
pad_bottom = 0
pad_left = 0
if aspect_ratio_current < aspect_ratio : # vertical image , height > width
    diff = ( aspect_ratio * height ) - width
    pad_right = int ( np . ceil ( diff / 2 ) )
    pad_left = int ( np . floor ( diff / 2 ) )
elif aspect_ratio_current > aspect_ratio : # horizontal image , width > height
    diff = ( ( 1 / aspect_ratio ) * width ) - height
    pad_top = int ( np . floor ( diff / 2 ) )
    pad_bottom = int ( np . ceil ( diff / 2 ) )
return pad_top , pad_right , pad_bottom , pad_left


signature:
def pad_to_aspect_ratio ( arr , aspect_ratio , mode = "constant" , cval = 0 , return_pad_amounts = False ) :
    """Pad an image - like array on its sides so that it matches a target aspect ratio .
 Depending on which dimension is smaller ( height or width ) , only the corresponding
 sides ( left / right or top / bottom ) will be padded . In each case , both of the sides will
 be padded equally .
 dtype support : :
 See : func : ` imgaug . imgaug . pad ` .
 Parameters
 arr : ( H , W ) ndarray or ( H , W , C ) ndarray
 Image - like array to pad .
 aspect _ ratio : float
 Target aspect ratio , given as width / height . E . g . 2.0 denotes the image having twice
 as much width as height .
 mode : str , optional
 Padding mode to use . See : func : ` numpy . pad ` for details .
 cval : number , optional
 Value to use for padding if ` mode ` is ` ` constant ` ` . See : func : ` numpy . pad ` for details .
 return _ pad _ amounts : bool , optional
 If False , then only the padded image will be returned . If True , a tuple with two
 entries will be returned , where the first entry is the padded image and the second
 entry are the amounts by which each image side was padded . These amounts are again a
 tuple of the form ( top , right , bottom , left ) , with each value being an integer .
 Returns
 arr _ padded : ( H ' , W ' ) ndarray or ( H ' , W ' , C ) ndarray
 Padded image as ( H ' , W ' ) or ( H ' , W ' , C ) ndarray , fulfulling the given aspect _ ratio .
 tuple of int
 Amounts by which the image was padded on each side , given as a tuple ` ` ( top , right , bottom , left ) ` ` .
 This tuple is only returned if ` return _ pad _ amounts ` was set to True .
 Otherwise only ` ` arr _ padded ` ` is returned ."""

implementation:
pad_top , pad_right , pad_bottom , pad_left = compute_paddings_for_aspect_ratio ( arr , aspect_ratio )
arr_padded = pad ( arr , top = pad_top , right = pad_right , bottom = pad_bottom , left = pad_left , mode = mode , cval = cval )
if return_pad_amounts :
    return arr_padded , ( pad_top , pad_right , pad_bottom , pad_left )
else :
    return arr_padded


signature:
def pool ( arr , block_size , func , cval = 0 , preserve_dtype = True ) :
    """Resize an array by pooling values within blocks .
 dtype support : :
 * ` ` uint8 ` ` : yes ; fully tested
 * ` ` uint16 ` ` : yes ; tested
 * ` ` uint32 ` ` : yes ; tested ( 2)
 * ` ` uint64 ` ` : no ( 1)
 * ` ` int8 ` ` : yes ; tested
 * ` ` int16 ` ` : yes ; tested
 * ` ` int32 ` ` : yes ; tested ( 2)
 * ` ` int64 ` ` : no ( 1)
 * ` ` float16 ` ` : yes ; tested
 * ` ` float32 ` ` : yes ; tested
 * ` ` float64 ` ` : yes ; tested
 * ` ` float128 ` ` : yes ; tested ( 2)
 * ` ` bool ` ` : yes ; tested
 - ( 1 ) results too inaccurate ( at least when using np . average as func )
 - ( 2 ) Note that scikit - image documentation says that the wrapped pooling function converts
 inputs to float64 . Actual tests showed no indication of that happening ( at least when
 using preserve _ dtype = True ) .
 Parameters
 arr : ( H , W ) ndarray or ( H , W , C ) ndarray
 Image - like array to pool . Ideally of datatype ` ` numpy . float64 ` ` .
 block _ size : int or tuple of int
 Spatial size of each group of values to pool , aka kernel size .
 If a single integer , then a symmetric block of that size along height and width will be used .
 If a tuple of two values , it is assumed to be the block size along height and width of the image - like ,
 with pooling happening per channel .
 If a tuple of three values , it is assumed to be the block size along height , width and channels .
 func : callable
 Function to apply to a given block in order to convert it to a single number ,
 e . g . : func : ` numpy . average ` , : func : ` numpy . min ` , : func : ` numpy . max ` .
 cval : number , optional
 Value to use in order to pad the array along its border if the array cannot be divided
 by ` block _ size ` without remainder .
 preserve _ dtype : bool , optional
 Whether to convert the array back to the input datatype if it is changed away from
 that in the pooling process .
 Returns
 arr _ reduced : ( H ' , W ' ) ndarray or ( H ' , W ' , C ' ) ndarray
 Array after pooling ."""

implementation:
# TODO find better way to avoid circular import
from . import dtypes as iadt
iadt . gate_dtypes ( arr , allowed = [ "bool" , "uint8" , "uint16" , "uint32" , "int8" , "int16" , "int32" , "float16" , "float32" , "float64" , "float128" ] , disallowed = [ "uint64" , "uint128" , "uint256" , "int64" , "int128" , "int256" , "float256" ] , augmenter = None )
do_assert ( arr . ndim in [ 2 , 3 ] )
is_valid_int = is_single_integer ( block_size ) and block_size >= 1
is_valid_tuple = is_iterable ( block_size ) and len ( block_size ) in [ 2 , 3 ] and [ is_single_integer ( val ) and val >= 1 for val in block_size ]
do_assert ( is_valid_int or is_valid_tuple )
if is_single_integer ( block_size ) :
    block_size = [ block_size , block_size ]
if len ( block_size ) < arr . ndim :
    block_size = list ( block_size ) + [ 1 ]
input_dtype = arr . dtype
arr_reduced = skimage . measure . block_reduce ( arr , tuple ( block_size ) , func , cval = cval )
if preserve_dtype and arr_reduced . dtype . type != input_dtype :
    arr_reduced = arr_reduced . astype ( input_dtype )
return arr_reduced


signature:
def avg_pool ( arr , block_size , cval = 0 , preserve_dtype = True ) :
    """Resize an array using average pooling .
 dtype support : :
 See : func : ` imgaug . imgaug . pool ` .
 Parameters
 arr : ( H , W ) ndarray or ( H , W , C ) ndarray
 Image - like array to pool . See : func : ` imgaug . pool ` for details .
 block _ size : int or tuple of int or tuple of int
 Size of each block of values to pool . See : func : ` imgaug . pool ` for details .
 cval : number , optional
 Padding value . See : func : ` imgaug . pool ` for details .
 preserve _ dtype : bool , optional
 Whether to preserve the input array dtype . See : func : ` imgaug . pool ` for details .
 Returns
 arr _ reduced : ( H ' , W ' ) ndarray or ( H ' , W ' , C ' ) ndarray
 Array after average pooling ."""

implementation: return pool ( arr , block_size , np . average , cval = cval , preserve_dtype = preserve_dtype )


signature:
def max_pool ( arr , block_size , cval = 0 , preserve_dtype = True ) :
    """Resize an array using max - pooling .
 dtype support : :
 See : func : ` imgaug . imgaug . pool ` .
 Parameters
 arr : ( H , W ) ndarray or ( H , W , C ) ndarray
 Image - like array to pool . See : func : ` imgaug . pool ` for details .
 block _ size : int or tuple of int or tuple of int
 Size of each block of values to pool . See ` imgaug . pool ` for details .
 cval : number , optional
 Padding value . See : func : ` imgaug . pool ` for details .
 preserve _ dtype : bool , optional
 Whether to preserve the input array dtype . See : func : ` imgaug . pool ` for details .
 Returns
 arr _ reduced : ( H ' , W ' ) ndarray or ( H ' , W ' , C ' ) ndarray
 Array after max - pooling ."""

implementation: return pool ( arr , block_size , np . max , cval = cval , preserve_dtype = preserve_dtype )


signature:
def draw_grid ( images , rows = None , cols = None ) :
    """Converts multiple input images into a single image showing them in a grid .
 dtype support : :
 * ` ` uint8 ` ` : yes ; fully tested
 * ` ` uint16 ` ` : yes ; fully tested
 * ` ` uint32 ` ` : yes ; fully tested
 * ` ` uint64 ` ` : yes ; fully tested
 * ` ` int8 ` ` : yes ; fully tested
 * ` ` int16 ` ` : yes ; fully tested
 * ` ` int32 ` ` : yes ; fully tested
 * ` ` int64 ` ` : yes ; fully tested
 * ` ` float16 ` ` : yes ; fully tested
 * ` ` float32 ` ` : yes ; fully tested
 * ` ` float64 ` ` : yes ; fully tested
 * ` ` float128 ` ` : yes ; fully tested
 * ` ` bool ` ` : yes ; fully tested
 Parameters
 images : ( N , H , W , 3 ) ndarray or iterable of ( H , W , 3 ) array
 The input images to convert to a grid .
 rows : None or int , optional
 The number of rows to show in the grid .
 If None , it will be automatically derived .
 cols : None or int , optional
 The number of cols to show in the grid .
 If None , it will be automatically derived .
 Returns
 grid : ( H ' , W ' , 3 ) ndarray
 Image of the generated grid ."""

implementation:
nb_images = len ( images )
do_assert ( nb_images > 0 )
if is_np_array ( images ) :
    do_assert ( images . ndim == 4 )
else :
    do_assert ( is_iterable ( images ) and is_np_array ( images [ 0 ] ) and images [ 0 ] . ndim == 3 )
    dts = [ image . dtype . name for image in images ]
    nb_dtypes = len ( set ( dts ) )
    do_assert ( nb_dtypes == 1 , ( "All images provided to draw_grid() must have the same dtype, " + "found %d dtypes (%s)" ) % ( nb_dtypes , ", " . join ( dts ) ) )
cell_height = max ( [ image . shape [ 0 ] for image in images ] )
cell_width = max ( [ image . shape [ 1 ] for image in images ] )
channels = set ( [ image . shape [ 2 ] for image in images ] )
do_assert ( len ( channels ) == 1 , "All images are expected to have the same number of channels, " + "but got channel set %s with length %d instead." % ( str ( channels ) , len ( channels ) ) )
nb_channels = list ( channels ) [ 0 ]
if rows is None and cols is None :
    rows = cols = int ( math . ceil ( math . sqrt ( nb_images ) ) )
elif rows is not None :
    cols = int ( math . ceil ( nb_images / rows ) )
elif cols is not None :
    rows = int ( math . ceil ( nb_images / cols ) )
do_assert ( rows * cols >= nb_images )
width = cell_width * cols
height = cell_height * rows
dt = images . dtype if is_np_array ( images ) else images [ 0 ] . dtype
grid = np . zeros ( ( height , width , nb_channels ) , dtype = dt )
cell_idx = 0
for row_idx in sm . xrange ( rows ) :
    for col_idx in sm . xrange ( cols ) :
        if cell_idx < nb_images :
            image = images [ cell_idx ]
            cell_y1 = cell_height * row_idx
            cell_y2 = cell_y1 + image . shape [ 0 ]
            cell_x1 = cell_width * col_idx
            cell_x2 = cell_x1 + image . shape [ 1 ]
            grid [ cell_y1 : cell_y2 , cell_x1 : cell_x2 , : ] = image
        cell_idx += 1
return grid


signature:
def show_grid ( images , rows = None , cols = None ) :
    """Converts the input images to a grid image and shows it in a new window .
 dtype support : :
 minimum of (
 : func : ` imgaug . imgaug . draw _ grid ` ,
 : func : ` imgaug . imgaug . imshow `
 Parameters
 images : ( N , H , W , 3 ) ndarray or iterable of ( H , W , 3 ) array
 See : func : ` imgaug . draw _ grid ` .
 rows : None or int , optional
 See : func : ` imgaug . draw _ grid ` .
 cols : None or int , optional
 See : func : ` imgaug . draw _ grid ` ."""

implementation:
grid = draw_grid ( images , rows = rows , cols = cols )
imshow ( grid )


signature:
def imshow ( image , backend = IMSHOW_BACKEND_DEFAULT ) :
    """Shows an image in a window .
 dtype support : :
 * ` ` uint8 ` ` : yes ; not tested
 * ` ` uint16 ` ` : ?
 * ` ` uint32 ` ` : ?
 * ` ` uint64 ` ` : ?
 * ` ` int8 ` ` : ?
 * ` ` int16 ` ` : ?
 * ` ` int32 ` ` : ?
 * ` ` int64 ` ` : ?
 * ` ` float16 ` ` : ?
 * ` ` float32 ` ` : ?
 * ` ` float64 ` ` : ?
 * ` ` float128 ` ` : ?
 * ` ` bool ` ` : ?
 Parameters
 image : ( H , W , 3 ) ndarray
 Image to show .
 backend : { ' matplotlib ' , ' cv2 ' } , optional
 Library to use to show the image . May be either matplotlib or OpenCV ( ' cv2 ' ) .
 OpenCV tends to be faster , but apparently causes more technical issues ."""

implementation:
do_assert ( backend in [ "matplotlib" , "cv2" ] , "Expected backend 'matplotlib' or 'cv2', got %s." % ( backend , ) )
if backend == "cv2" :
    image_bgr = image
    if image . ndim == 3 and image . shape [ 2 ] in [ 3 , 4 ] :
        image_bgr = image [ ... , 0 : 3 ] [ ... , : : - 1 ]
    win_name = "imgaug-default-window"
    cv2 . namedWindow ( win_name , cv2 . WINDOW_NORMAL )
    cv2 . imshow ( win_name , image_bgr )
    cv2 . waitKey ( 0 )
    cv2 . destroyWindow ( win_name )
else : # import only when necessary ( faster startup ; optional dependency ; less fragile - - see issue # 225)
    import matplotlib . pyplot as plt
    dpi = 96
    h , w = image . shape [ 0 ] / dpi , image . shape [ 1 ] / dpi
    w = max ( w , 6 )
    # if the figure is too narrow , the footer may appear and make the fig suddenly wider ( ugly )
    fig , ax = plt . subplots ( figsize = ( w , h ) , dpi = dpi )
    fig . canvas . set_window_title ( "imgaug.imshow(%s)" % ( image . shape , ) )
    ax . imshow ( image , cmap = "gray" )
    # cmap is only activate for grayscale images
    plt . show ( )


signature:
def warn_deprecated ( msg , stacklevel = 2 ) :
    """Generate a non - silent deprecation warning with stacktrace .
 The used warning is ` ` imgaug . imgaug . DeprecationWarning ` ` .
 Parameters
 msg : str
 The message of the warning .
 stacklevel : int , optional
 How many steps above this function to " jump " in the stacktrace for
 the displayed file and line number of the error message .
 Usually 2."""

implementation:
import warnings
warnings . warn ( msg , category = DeprecationWarning , stacklevel = stacklevel )


signature:
def is_activated ( self , images , augmenter , parents , default ) :
    """Returns whether an augmenter may be executed .
 Returns
 bool
 If True , the augmenter may be executed . If False , it may not be executed ."""

implementation:
if self . activator is None :
    return default
else :
    return self . activator ( images , augmenter , parents , default )


signature:
def is_propagating ( self , images , augmenter , parents , default ) :
    """Returns whether an augmenter may call its children to augment an
 image . This is independent of the augmenter itself possible changing
 the image , without calling its children . ( Most ( all ? ) augmenters with
 children currently dont perform any changes themselves . )
 Returns
 bool
 If True , the augmenter may be propagate to its children . If False , it may not ."""

implementation:
if self . propagator is None :
    return default
else :
    return self . propagator ( images , augmenter , parents , default )


signature:
def preprocess ( self , images , augmenter , parents ) :
    """A function to be called before the augmentation of images starts ( per augmenter ) .
 Returns
 ( N , H , W , C ) ndarray or ( N , H , W ) ndarray or list of ( H , W , C ) ndarray or list of ( H , W ) ndarray
 The input images , optionally modified ."""

implementation:
if self . preprocessor is None :
    return images
else :
    return self . preprocessor ( images , augmenter , parents )


signature:
def postprocess ( self , images , augmenter , parents ) :
    """A function to be called after the augmentation of images was
 performed .
 Returns
 ( N , H , W , C ) ndarray or ( N , H , W ) ndarray or list of ( H , W , C ) ndarray or list of ( H , W ) ndarray
 The input images , optionally modified ."""

implementation:
if self . postprocessor is None :
    return images
else :
    return self . postprocessor ( images , augmenter , parents )


signature:
def pool ( self ) :
    """Return the multiprocessing . Pool instance or create it if not done yet .
 Returns
 multiprocessing . Pool
 The multiprocessing . Pool used internally by this imgaug . multicore . Pool ."""

implementation:
if self . _pool is None :
    processes = self . processes
    if processes is not None and processes < 0 :
        try : # cpu count includes the hyperthreads , e . g . 8 for 4 cores + hyperthreading
            processes = multiprocessing . cpu_count ( ) - abs ( processes )
            processes = max ( processes , 1 )
        except ( ImportError , NotImplementedError ) :
            processes = None
    self . _pool = multiprocessing . Pool ( processes , initializer = _Pool_initialize_worker , initargs = ( self . augseq , self . seed ) , maxtasksperchild = self . maxtasksperchild )
return self . _pool


signature:
def map_batches ( self , batches , chunksize = None ) :
    """Augment batches .
 Parameters
 batches : list of imgaug . augmentables . batches . Batch
 The batches to augment .
 chunksize : None or int , optional
 Rough indicator of how many tasks should be sent to each worker . Increasing this number can improve
 performance .
 Returns
 list of imgaug . augmentables . batches . Batch
 Augmented batches ."""

implementation:
assert isinstance ( batches , list ) , ( "Expected to get a list as 'batches', got type %s. " + "Call imap_batches() if you use generators." ) % ( type ( batches ) , )
return self . pool . map ( _Pool_starworker , self . _handle_batch_ids ( batches ) , chunksize = chunksize )


signature:
def map_batches_async ( self , batches , chunksize = None , callback = None , error_callback = None ) :
    """Augment batches asynchonously .
 Parameters
 batches : list of imgaug . augmentables . batches . Batch
 The batches to augment .
 chunksize : None or int , optional
 Rough indicator of how many tasks should be sent to each worker . Increasing this number can improve
 performance .
 callback : None or callable , optional
 Function to call upon finish . See ` multiprocessing . Pool ` .
 error _ callback : None or callable , optional
 Function to call upon errors . See ` multiprocessing . Pool ` .
 Returns
 multiprocessing . MapResult
 Asynchonous result . See ` multiprocessing . Pool ` ."""

implementation:
assert isinstance ( batches , list ) , ( "Expected to get a list as 'batches', got type %s. " + "Call imap_batches() if you use generators." ) % ( type ( batches ) , )
return self . pool . map_async ( _Pool_starworker , self . _handle_batch_ids ( batches ) , chunksize = chunksize , callback = callback , error_callback = error_callback )


signature:
def imap_batches ( self , batches , chunksize = 1 ) :
    """Augment batches from a generator .
 Parameters
 batches : generator of imgaug . augmentables . batches . Batch
 The batches to augment , provided as a generator . Each call to the generator should yield exactly one
 batch .
 chunksize : None or int , optional
 Rough indicator of how many tasks should be sent to each worker . Increasing this number can improve
 performance .
 Yields
 imgaug . augmentables . batches . Batch
 Augmented batch ."""

implementation:
assert ia . is_generator ( batches ) , ( "Expected to get a generator as 'batches', got type %s. " + "Call map_batches() if you use lists." ) % ( type ( batches ) , )
# TODO change this to ' yield from ' once switched to 3.3 +
gen = self . pool . imap ( _Pool_starworker , self . _handle_batch_ids_gen ( batches ) , chunksize = chunksize )
for batch in gen :
    yield batch


signature:
def imap_batches_unordered ( self , batches , chunksize = 1 ) :
    """Augment batches from a generator in a way that does not guarantee to preserve order .
 Parameters
 batches : generator of imgaug . augmentables . batches . Batch
 The batches to augment , provided as a generator . Each call to the generator should yield exactly one
 batch .
 chunksize : None or int , optional
 Rough indicator of how many tasks should be sent to each worker . Increasing this number can improve
 performance .
 Yields
 imgaug . augmentables . batches . Batch
 Augmented batch ."""

implementation:
assert ia . is_generator ( batches ) , ( "Expected to get a generator as 'batches', got type %s. " + "Call map_batches() if you use lists." ) % ( type ( batches ) , )
# TODO change this to ' yield from ' once switched to 3.3 +
gen = self . pool . imap_unordered ( _Pool_starworker , self . _handle_batch_ids_gen ( batches ) , chunksize = chunksize )
for batch in gen :
    yield batch


signature:
def terminate ( self ) :
    """Terminate the pool immediately ."""

implementation:
if self . _pool is not None :
    self . _pool . terminate ( )
    self . _pool . join ( )
    self . _pool = None


signature:
def terminate ( self ) :
    """Stop all workers ."""

implementation:
if not self . join_signal . is_set ( ) :
    self . join_signal . set ( )
# give minimal time to put generated batches in queue and gracefully shut down
time . sleep ( 0.01 )
if self . main_worker_thread . is_alive ( ) :
    self . main_worker_thread . join ( )
if self . threaded :
    for worker in self . workers :
        if worker . is_alive ( ) :
            worker . join ( )
else :
    for worker in self . workers :
        if worker . is_alive ( ) :
            worker . terminate ( )
            worker . join ( )
    # wait until all workers are fully terminated
    while not self . all_finished ( ) :
        time . sleep ( 0.001 )
# empty queue until at least one element can be added and place None as signal that BL finished
if self . queue . full ( ) :
    self . queue . get ( )
self . queue . put ( pickle . dumps ( None , protocol = - 1 ) )
time . sleep ( 0.01 )
# clean the queue , this reportedly prevents hanging threads
while True :
    try :
        self . _queue_internal . get ( timeout = 0.005 )
    except QueueEmpty :
        break
if not self . _queue_internal . _closed :
    self . _queue_internal . close ( )
if not self . queue . _closed :
    self . queue . close ( )
self . _queue_internal . join_thread ( )
self . queue . join_thread ( )
time . sleep ( 0.025 )


signature:
def get_batch ( self ) :
    """Returns a batch from the queue of augmented batches .
 If workers are still running and there are no batches in the queue ,
 it will automatically wait for the next batch .
 Returns
 out : None or imgaug . Batch
 One batch or None if all workers have finished ."""

implementation:
if self . all_finished ( ) :
    return None
batch_str = self . queue_result . get ( )
batch = pickle . loads ( batch_str )
if batch is not None :
    return batch
else :
    self . nb_workers_finished += 1
    if self . nb_workers_finished >= self . nb_workers :
        try :
            self . queue_source . get ( timeout = 0.001 )
            # remove the None from the source queue
        except QueueEmpty :
            pass
        return None
    else :
        return self . get_batch ( )


signature:
def _augment_images_worker ( self , augseq , queue_source , queue_result , seedval ) :
    """Augment endlessly images in the source queue .
 This is a worker function for that endlessly queries the source queue ( input batches ) ,
 augments batches in it and sends the result to the output queue ."""

implementation:
np . random . seed ( seedval )
random . seed ( seedval )
augseq . reseed ( seedval )
ia . seed ( seedval )
loader_finished = False
while not loader_finished : # wait for a new batch in the source queue and load it
    try :
        batch_str = queue_source . get ( timeout = 0.1 )
        batch = pickle . loads ( batch_str )
        if batch is None :
            loader_finished = True
            # put it back in so that other workers know that the loading queue is finished
            queue_source . put ( pickle . dumps ( None , protocol = - 1 ) )
        else :
            batch_aug = augseq . augment_batch ( batch )
            # send augmented batch to output queue
            batch_str = pickle . dumps ( batch_aug , protocol = - 1 )
            queue_result . put ( batch_str )
    except QueueEmpty :
        time . sleep ( 0.01 )
queue_result . put ( pickle . dumps ( None , protocol = - 1 ) )
time . sleep ( 0.01 )


signature:
def terminate ( self ) :
    """Terminates all background processes immediately .
 This will also free their RAM ."""

implementation:
for worker in self . workers :
    if worker . is_alive ( ) :
        worker . terminate ( )
self . nb_workers_finished = len ( self . workers )
if not self . queue_result . _closed :
    self . queue_result . close ( )
time . sleep ( 0.01 )


signature:
def to_normalized_batch ( self ) :
    """Convert this unnormalized batch to an instance of Batch .
 As this method is intended to be called before augmentation , it
 assumes that none of the ` ` * _ aug ` ` attributes is yet set .
 It will produce an AssertionError otherwise .
 The newly created Batch ' s ` ` * _ unaug ` ` attributes will match the ones
 in this batch , just in normalized form .
 Returns
 imgaug . augmentables . batches . Batch
 The batch , with ` ` * _ unaug ` ` attributes being normalized ."""

implementation:
assert all ( [ attr is None for attr_name , attr in self . __dict__ . items ( ) if attr_name . endswith ( "_aug" ) ] ) , "Expected UnnormalizedBatch to not contain any augmented data " "before normalization, but at least one '*_aug' attribute was " "already set."
images_unaug = nlib . normalize_images ( self . images_unaug )
shapes = None
if images_unaug is not None :
    shapes = [ image . shape for image in images_unaug ]
return Batch ( images = images_unaug , heatmaps = nlib . normalize_heatmaps ( self . heatmaps_unaug , shapes ) , segmentation_maps = nlib . normalize_segmentation_maps ( self . segmentation_maps_unaug , shapes ) , keypoints = nlib . normalize_keypoints ( self . keypoints_unaug , shapes ) , bounding_boxes = nlib . normalize_bounding_boxes ( self . bounding_boxes_unaug , shapes ) , polygons = nlib . normalize_polygons ( self . polygons_unaug , shapes ) , line_strings = nlib . normalize_line_strings ( self . line_strings_unaug , shapes ) , data = self . data )


signature:
def fill_from_augmented_normalized_batch ( self , batch_aug_norm ) :
    """Fill this batch with ( normalized ) augmentation results .
 This method receives a ( normalized ) Batch instance , takes all
 ` ` * _ aug ` ` attributes out if it and assigns them to this
 batch * in unnormalized form * . Hence , the datatypes of all ` ` * _ aug ` `
 attributes will match the datatypes of the ` ` * _ unaug ` ` attributes .
 Parameters
 batch _ aug _ norm : imgaug . augmentables . batches . Batch
 Batch after normalization and augmentation .
 Returns
 imgaug . augmentables . batches . UnnormalizedBatch
 New UnnormalizedBatch instance . All ` ` * _ unaug ` ` attributes are
 taken from the old UnnormalizedBatch ( without deepcopying them )
 and all ` ` * _ aug ` ` attributes are taken from ` batch _ normalized `
 converted to unnormalized form ."""

implementation:
# we take here the . data from the normalized batch instead of from
# self for the rare case where one has decided to somehow change it
# during augmentation
batch = UnnormalizedBatch ( images = self . images_unaug , heatmaps = self . heatmaps_unaug , segmentation_maps = self . segmentation_maps_unaug , keypoints = self . keypoints_unaug , bounding_boxes = self . bounding_boxes_unaug , polygons = self . polygons_unaug , line_strings = self . line_strings_unaug , data = batch_aug_norm . data )
batch . images_aug = nlib . invert_normalize_images ( batch_aug_norm . images_aug , self . images_unaug )
batch . heatmaps_aug = nlib . invert_normalize_heatmaps ( batch_aug_norm . heatmaps_aug , self . heatmaps_unaug )
batch . segmentation_maps_aug = nlib . invert_normalize_segmentation_maps ( batch_aug_norm . segmentation_maps_aug , self . segmentation_maps_unaug )
batch . keypoints_aug = nlib . invert_normalize_keypoints ( batch_aug_norm . keypoints_aug , self . keypoints_unaug )
batch . bounding_boxes_aug = nlib . invert_normalize_bounding_boxes ( batch_aug_norm . bounding_boxes_aug , self . bounding_boxes_unaug )
batch . polygons_aug = nlib . invert_normalize_polygons ( batch_aug_norm . polygons_aug , self . polygons_unaug )
batch . line_strings_aug = nlib . invert_normalize_line_strings ( batch_aug_norm . line_strings_aug , self . line_strings_unaug )
return batch


signature:
def Positive ( other_param , mode = "invert" , reroll_count_max = 2 ) :
    """Converts another parameter ' s results to positive values .
 Parameters
 other _ param : imgaug . parameters . StochasticParameter
 Other parameter which ' s sampled values are to be
 modified .
 mode : { ' invert ' , ' reroll ' } , optional
 How to change the signs . Valid values are ` ` invert ` ` and ` ` reroll ` ` .
 ` ` invert ` ` means that wrong signs are simply flipped .
 ` ` reroll ` ` means that all samples with wrong signs are sampled again ,
 optionally many times , until they randomly end up having the correct
 sign .
 reroll _ count _ max : int , optional
 If ` mode ` is set to ` ` reroll ` ` , this determines how often values may
 be rerolled before giving up and simply flipping the sign ( as in
 ` ` mode = " invert " ` ` ) . This shouldn ' t be set too high , as rerolling is
 expensive .
 Examples
 > > > param = Positive ( Normal ( 0 , 1 ) , mode = " reroll " )
 Generates a normal distribution that has only positive values ."""

implementation: return ForceSign ( other_param = other_param , positive = True , mode = mode , reroll_count_max = reroll_count_max )


signature:
def Negative ( other_param , mode = "invert" , reroll_count_max = 2 ) :
    """Converts another parameter ' s results to negative values .
 Parameters
 other _ param : imgaug . parameters . StochasticParameter
 Other parameter which ' s sampled values are to be
 modified .
 mode : { ' invert ' , ' reroll ' } , optional
 How to change the signs . Valid values are ` ` invert ` ` and ` ` reroll ` ` .
 ` ` invert ` ` means that wrong signs are simply flipped .
 ` ` reroll ` ` means that all samples with wrong signs are sampled again ,
 optionally many times , until they randomly end up having the correct
 sign .
 reroll _ count _ max : int , optional
 If ` mode ` is set to ` ` reroll ` ` , this determines how often values may
 be rerolled before giving up and simply flipping the sign ( as in
 ` ` mode = " invert " ` ` ) . This shouldn ' t be set too high , as rerolling is
 expensive .
 Examples
 > > > param = Negative ( Normal ( 0 , 1 ) , mode = " reroll " )
 Generates a normal distribution that has only negative values ."""

implementation: return ForceSign ( other_param = other_param , positive = False , mode = mode , reroll_count_max = reroll_count_max )