augmenters.pillike

Solarize

Augmenter with identical outputs to PIL’s solarize() function.

This augmenter inverts all pixel values above a threshold.

The outputs are identical to PIL’s solarize().

API link: Solarize()

Example. Invert the colors in 50 percent of all images for pixels with a value between 32 and 128 or more. The threshold is sampled once per image. The thresholding operation happens per channel.

import imgaug.augmenters as iaa
aug = iaa.Solarize(0.5, threshold=(32, 128))

Posterize

Augmenter with identical outputs to PIL’s posterize() function.

This augmenter quantizes each array component to N bits.

This class is currently an alias for Posterize, which again is an alias for UniformColorQuantizationToNBits, i.e. all three classes are right now guarantueed to have the same outputs as PIL’s function.

API link: Posterize()

Equalize

Equalize the image histogram.

This augmenter has identical outputs to equalize().

API link: Equalize()

Example. Equalize the histograms of all input images:

import imgaug.augmenters as iaa
aug = iaa.pillike.Equalize()

Autocontrast

Adjust contrast by cutting off p% of lowest/highest histogram values.

This augmenter has identical outputs to autocontrast().

See autocontrast() for more details.

API link: Autocontrast()

Example. Modify the contrast of images by cutting off the 0 to 20% lowest and highest values from the histogram, then stretching it to full length:

import imgaug.augmenters as iaa
aug = iaa.pillike.Autocontrast()

Example. Modify the contrast of images by cutting off the 10 to 20% lowest and highest values from the histogram, then stretching it to full length. The cutoff value is sampled per channel instead of per image.

aug = iaa.pillike.Autocontrast((10, 20), per_channel=True)

EnhanceColor

Convert images to grayscale.

This augmenter has identical outputs to Color.

API link: EnhanceColor()

Example. Create an augmenter to remove a random fraction of color from input images:

import imgaug.augmenters as iaa
aug = iaa.pillike.EnhanceColor()

EnhanceContrast

Change the contrast of images.

This augmenter has identical outputs to Contrast.

API link: EnhanceContrast()

Example. Create an augmenter that worsens the contrast of an image by a random factor:

import imgaug.augmenters as iaa
aug = iaa.pillike.EnhanceContrast()

EnhanceBrightness

Change the brightness of images.

This augmenter has identical outputs to Brightness.

API link: EnhanceBrightness()

Example. Create an augmenter that worsens the brightness of an image by a random factor:

import imgaug.augmenters as iaa
aug = iaa.pillike.EnhanceBrightness()

EnhanceSharpness

Change the sharpness of images.

This augmenter has identical outputs to Sharpness.

API link: EnhanceSharpness()

Example. Create an augmenter that randomly decreases or increases the sharpness of an image:

import imgaug.augmenters as iaa
aug = iaa.pillike.EnhanceSharpness()

FilterBlur

Apply a blur filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.BLUR.

API link: FilterBlur()

Example. Create an augmenter that applies a blur filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterBlur()

FilterSmooth

Apply a smoothening filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.SMOOTH.

API link: FilterSmooth()

Example. Create an augmenter that applies a smoothening filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterSmooth()

FilterSmoothMore

Apply a strong smoothening filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.BLUR.

API link: FilterSmoothMore()

Example. Create an augmenter that applies a strong smoothening filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterSmoothMore()

FilterEdgeEnhance

Apply an edge enhance filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.EDGE_ENHANCE.

API link: FilterEdgeEnhance()

Example. Create an augmenter that applies a edge enhancement filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterEdgeEnhance()

FilterEdgeEnhanceMore

Apply a strong edge enhancement filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.EDGE_ENHANCE_MORE.

API link: FilterEdgeEnhanceMore()

Example. Create an augmenter that applies a strong edge enhancement filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterEdgeEnhanceMore()

FilterFindEdges

Apply a edge detection kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.FIND_EDGES.

API link: FilterFindEdges()

Example. Create an augmenter that applies an edge detection filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterFindEdges()

FilterContour

Apply a contour detection filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.CONTOUR.

API link: FilterContour()

Example. Create an augmenter that applies a contour detection filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterContour()

FilterEmboss

Apply an emboss filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.EMBOSS.

API link: FilterEmboss()

Example. Create an augmenter that applies an emboss filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterEmboss()

FilterSharpen

Apply a sharpening filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.SHARPEN.

API link: FilterSharpen()

Example. Create an augmenter that applies a sharpening filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterSharpen()

FilterDetail

Apply a detail enhancement filter kernel to images.

This augmenter has identical outputs to calling filter() with kernel PIL.ImageFilter.DETAIL.

API link: FilterDetail()

Example. Create an augmenter that applies a detail enhancement filter kernel to images:

import imgaug.augmenters as iaa
aug = iaa.pillike.FilterDetail()

Affine

Apply PIL-like affine transformations to images.

This augmenter has identical outputs to transform() with parameter method=PIL.Image.AFFINE.

Note

This augmenter can currently only transform image-data. Batches containing heatmaps, segmentation maps and coordinate-based augmentables will be rejected with an error. Use Affine if you have to transform such inputs.

Note

This augmenter uses the image center as the transformation center. This has to be explicitly enforced in PIL using corresponding translation matrices. Without such translation, PIL uses the image top left corner as the transformation center. To mirror that behaviour, use center=(0.0, 0.0).

API link: Affine()

Example. Create an augmenter that applies affine scaling (zoom in/out) to images. Along the x-axis they are scaled to 80-120% of their size, along the y-axis to 50-150% (both values randomly and uniformly chosen per image).

import imgaug.augmenters as iaa
aug = iaa.pillike.Affine(scale={"x": (0.8, 1.2), "y": (0.5, 1.5)})

Example. Create an augmenter that translates images along the y-axis by either -10px or 10px. Newly created pixels are always filled with the value 128 (along all channels).

aug = iaa.pillike.Affine(translate_px={"x": 0, "y": [-10, 10]},
                         fillcolor=128)

Example. Rotate an image by -20 to 20 degress and fill up all newly created pixels with a random RGB color:

aug = iaa.pillike.Affine(rotate=(-20, 20), fillcolor=(0, 256))

See the similar augmenter Affine for more examples.