o eC@s:dZddlmZmZmZddlmZddlZ ddl Z ddl Z ddl Z ddlZ ddlZ ddlZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZd d lmZdZ ddZ!dyddZ"dyddZ#ddZ$ddZ%dzddZ&dzddZ'dzddZ(dzd d!Z)d{d"d#Z*d$d%Z+d&d'Z,d(d)Z-d*d+Z.d,d-Z/d.d/Z0d0d1Z1d2d3Z2d4d5Z3d6d7Z4d8d9Z5d:d;Z6dd?Z8d@dAZ9dBdCZ:dDdEZ;dFdGZ< H    Id|dJdKZ= H     Ld}dMdNZ>GdOdPdPej?Z@GdQdRdRejAZAGdSdTdTejBZCGdUdVdVejDZEGdWdXdXejBZFGdYdZdZeFZGGd[d\d\eFZHGd]d^d^eFZIGd_d`d`eFZJGdadbdbejBZKGdcddddeKZLGdedfdfeKZMGdgdhdheKZNGdidjdjeKZOGdkdldleKZPGdmdndneKZQGdodpdpeKZRGdqdrdreKZSGdsdtdteKZTGdudvdveKZUGdwdxdxejVZVdS)~a  Augmenters that have identical outputs to well-known PIL functions. The ``like`` in ``pillike`` indicates that the augmenters in this module have identical outputs and mostly identical inputs to corresponding PIL functions, but do not *have to* wrap these functions internally. They may use internally different (e.g. faster) techniques to produce these outputs. Some of the augmenters in this module may also exist in other modules under similar name. These other augmenters may currently have the same outputs as the corresponding PIL functions, but that is not guaranteed for the future. Use the augmenters in this module if identical outputs to PIL are required. List of augmenters: * :class:`Solarize` * :class:`Posterize` * :class:`Equalize` * :class:`Autocontrast` * :class:`EnhanceColor` * :class:`EnhanceContrast` * :class:`EnhanceBrightness` * :class:`EnhanceSharpness` * :class:`FilterBlur` * :class:`FilterSmooth` * :class:`FilterSmoothMore` * :class:`FilterEdgeEnhance` * :class:`FilterEdgeEnhanceMore` * :class:`FilterFindEdges` * :class:`FilterContour` * :class:`FilterEmboss` * :class:`FilterSharpen` * :class:`FilterDetail` * :class:`Affine` Standard usage of these augmenters follows roughly the schema:: import numpy as np import imgaug.augmenters as iaa aug = iaa.pillike.Affine(translate_px={"x": (-5, 5)}) image = np.full((32, 32, 3), 255, dtype=np.uint8) images_aug = aug(images=[image, image, image]) Added in 0.4.0. )print_functiondivisionabsolute_importN)_normalize_cv2_input_arr_)meta) arithmetic)color)contrast) geometric)size) parametersicCsn|jdko |jddk}|r|dddddf}|jdks3|jdkr*|jddvs3Jd||jf||fS)Nrrr )rzaCan apply %s only to images of shape (H, W) or (H, W, 1) or (H, W, 3) or (H, W, 4). Got shape %s.)ndimshape)image func_nameis_hw1rID:\Projects\ConvertPro\env\Lib\site-packages\imgaug/augmenters/pillike.py_ensure_valid_shapeOs rcCtj||dS)aInvert all array components above a threshold in-place. This function has identical outputs to ``PIL.ImageOps.solarize``. It does however work in-place. Added in 0.4.0. **Supported dtypes**: See ``~imgaug.augmenters.arithmetic.invert_(min_value=None and max_value=None)``. Parameters ---------- image : ndarray Image array of shape ``(H,W,[C])``. The array *might* be modified in-place. threshold : int, optional A threshold to use in order to invert only numbers above or below the threshold. Returns ------- ndarray Inverted image. This *can* be the same array as input in `image`, modified in-place.  threshold)rZinvert_rrrrr solarize_]srcCr)aInvert all array components above a threshold. This function has identical outputs to ``PIL.ImageOps.solarize``. Added in 0.4.0. **Supported dtypes**: See ``~imgaug.augmenters.arithmetic.invert_(min_value=None and max_value=None)``. Parameters ---------- image : ndarray Image array of shape ``(H,W,[C])``. threshold : int, optional A threshold to use in order to invert only numbers above or below the threshold. Returns ------- ndarray Inverted image. r)rinvertrrrrsolarize}sr!cC t||S)aReduce the number of bits for each color channel in-place. This function has identical outputs to ``PIL.ImageOps.posterize``. It does however work in-place. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.color.quantize_uniform_to_n_bits_`. Parameters ---------- image : ndarray Image array of shape ``(H,W,[C])``. bits : int The number of bits to keep per component. Values in the interval ``[1, 8]`` are valid. Returns ------- ndarray Posterized image. This *can* be the same array as input in `image`, modified in-place. colorlib posterizerbitsrrr posterize_s r(cCr")a Reduce the number of bits for each color channel. This function has identical outputs to ``PIL.ImageOps.posterize``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.color.quantize_uniform_to_n_bits`. Parameters ---------- image : ndarray Image array of shape ``(H,W,[C])``. bits : int The number of bits to keep per component. Values in the interval ``[1, 8]`` are valid. Returns ------- ndarray Posterized image. r#r&rrrr%s r%cCs4|j}|dkr t|S|tkrt|}t||S)a^Equalize the image histogram. See :func:`~imgaug.augmenters.pillike.equalize_` for details. This function is identical in inputs and outputs to ``PIL.ImageOps.equalize``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.equalize_`. Parameters ---------- image : ndarray ``uint8`` ``(H,W,[C])`` image to equalize. mask : None or ndarray, optional An optional mask. If given, only the pixels selected by the mask are included in the analysis. Returns ------- ndarray Equalized image. r)r npcopy_EQUALIZE_USE_PIL_BELOW equalize_)rmaskr rrrequalizes    r.csjdkrdnjd}|dvr#fddt|D}tj|ddSjjdks2Jd jjf|d urR|jdksCJd |jf|jjdksRJd |jjfj}|d kr[S|dkrh|tkrht |St |S)aEqualize the image histogram in-place. This function applies a non-linear mapping to the input image, in order to create a uniform distribution of grayscale values in the output image. This function has identical outputs to ``PIL.ImageOps.equalize``. It does however work in-place. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray ``uint8`` ``(H,W,[C])`` image to equalize. mask : None or ndarray, optional An optional mask. If given, only the pixels selected by the mask are included in the analysis. Returns ------- ndarray Equalized image. *Might* have been modified in-place. r rr)rrcs&g|]}tdddd|fqSN)r,).0crrr (szequalize_..)Zaxisuint8z,Expected image of dtype uint8, got dtype %s.Nz*Expected 2-dimensional mask, got shape %s.z+Expected mask of dtype uint8, got dtype %s.rr) rrr)arangestackdtypenamer r+_equalize_pil__equalize_no_pil_)rr- nb_channelsresultr rr2rr,s,*       r,c Cs|jdkrdn|jd}tjdd|ftjd}t|D]}|jdkr/|ddddtjf}n|dddd||df}tt |gdg|dgddg}t | ddkrit d tj|ddd|f<qt|ddd}|st d tj|ddd|f<q|d}t|} ||dd|f<|| dd|ddd|f<|ddd|ft|<qtj|dd|d tj}t||}|S) Nr rrr7r)out)rrr)emptyint32rangenewaxiscv2calcHistrlennonzeror5astypesumcumsumintclipr4iaZ apply_lut_) rr-r;lutc_idximage_cZhistostepnrKrrrr:?s0       r:cCs@|dur tj|d}ttjjtj||d|d<|S)NL)r-.)PILImage fromarrayconvertr)ZasarrayImageOpsr.)rr-rrrr9_s r9cCsj|jjdksJd|jjfd|jvrt|S|jdkp$|jddk}|r/|r/t|||St|||S)aMaximize (normalize) image contrast. This function calculates a histogram of the input image, removes **cutoff** percent of the lightest and darkest pixels from the histogram, and remaps the image so that the darkest pixel becomes black (``0``), and the lightest becomes white (``255``). This function has identical outputs to ``PIL.ImageOps.autocontrast``. The speed is almost identical. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image for which to enhance the contrast. cutoff : number How many percent to cut off at the low and high end of the histogram. E.g. ``20`` will cut off the lowest and highest ``20%`` of values. Expected value range is ``[0, 100]``. ignore : None or int or iterable of int Intensity values to ignore, i.e. to treat as background. If ``None``, no pixels will be ignored. Otherwise exactly the given intensity value(s) will be ignored. Returns ------- ndarray Contrast-enhanced image. r4z:Can apply autocontrast only to uint8 images, got dtype %s.rr r)r7r8rr)r*r_autocontrast_pil_autocontrast_no_pil)rcutoffignoreZstandard_channelsrrr autocontrastms2    r^cCs ttjjtj|||dS)N)r\r])r)arrayrUrYr^rVrW)rr\r]rrrrZs  rZc Cs|dur t|s |g}t|}|jdkr|dtjf}|jdkr'|jdnd}t|D]}|jdkrC|ddddtjf}n|dddd||df}t t |gdgddgddg}|durjd||<|rt |}|d} | |d} | |} t | d kd} t| dkrd } n| d} | dkrd|d| <| | || <t |ddd}|| }t |d kd}t|dkrd}nd |d}d||dd<|dkr|d |||<t|D]\} }|rnqtd ddD]}||rnq|| krtd}n%d || }| |}tdtj||}t|dd tj}|}tj|tjd }t||}||dddd||df<q.|jdkrS|d S|S)Nr .rrrr=rdr?go@r>).r)rN is_iterabler)Z empty_likerrDrsmxrangerErFrrKrHrG enumeraterCr5rIfloat64rMr4r_Z apply_lut)rr\r]r<r;rPrQhcsrScutZlo_cutZ lo_cut_nzloZcs_revZhi_cutZ hi_cut_nzhiZlo_valrOscaleoffsetZixZ image_c_augrrrr[sr                 r[cCs||jjdksJd|jjfd|jvrt|St|d\}}t|tj | |}|r<|ddddtj f}|S)Nr4zCCan apply PIL image enhancement only to uint8 images, got dtype %s.rz%imgaug.augmenters.pillike.enhance_*()) r7r8rr)r*rr_rUrVrWZenhancerD)rclsfactorrr<rrr_apply_enhance_funcs&   rpcCt|tjj|S)asChange the strength of colors in an image. This function has identical outputs to ``PIL.ImageEnhance.Color``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. factor : number Colorfulness of the output image. Values close to ``0.0`` lead to grayscale images, values above ``1.0`` increase the strength of colors. Sane values are roughly in ``[0.0, 3.0]``. Returns ------- ndarray Color-modified image. )rprU ImageEnhanceColorrrorrr enhance_color-(rucCrq)aChange the contrast of an image. This function has identical outputs to ``PIL.ImageEnhance.Contrast``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. factor : number Strength of contrast in the image. Values below ``1.0`` decrease the contrast, leading to a gray image around ``0.0``. Values above ``1.0`` increase the contrast. Sane values are roughly in ``[0.5, 1.5]``. Returns ------- ndarray Contrast-modified image. )rprUrrZContrastrtrrrenhance_contrastXs)rwcCrq)aChange the brightness of images. This function has identical outputs to ``PIL.ImageEnhance.Brightness``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. factor : number Brightness of the image. Values below ``1.0`` decrease the brightness, leading to a black image around ``0.0``. Values above ``1.0`` increase the brightness. Sane values are roughly in ``[0.5, 1.5]``. Returns ------- ndarray Brightness-modified image. )rprUrrZ Brightnessrtrrrenhance_brightnessrvrxcCrq)aOChange the sharpness of an image. This function has identical outputs to ``PIL.ImageEnhance.Sharpness``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. factor : number Sharpness of the image. Values below ``1.0`` decrease the sharpness, values above ``1.0`` increase it. Sane values are roughly in ``[0.0, 2.0]``. Returns ------- ndarray Sharpness-modified image. )rprUrrZ Sharpnessrtrrrenhance_sharpnessrvrycCs|jjdksJd|jjfd|jvrt|St|d\}}tj|}| |}t |}|r>|ddddtj f}|S)Nr4z9Can apply PIL filters only to uint8 images, got dtype %s.rz$imgaug.augmenters.pillike.filter_*()) r7r8rr)r*rrUrVrWfilterr_rD)rZkernelr image_pilZimage_filteredr<rrr_filter_by_kernels      r|cCt|tjjS)aApply a blur filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.BLUR`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Blurred image. )r|rU ImageFilterZBLURr2rrr filter_blur"rcCr})aApply a smoothness filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.SMOOTH`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Smoothened image. )r|rUr~ZSMOOTHr2rrr filter_smoothrrcCr})aApply a strong smoothness filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.SMOOTH_MORE`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Smoothened image. )r|rUr~Z SMOOTH_MOREr2rrrfilter_smooth_more;rrcCr})aApply an edge enhancement filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.EDGE_ENHANCE`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Image with enhanced edges. )r|rUr~Z EDGE_ENHANCEr2rrrfilter_edge_enhance`rrcCr})aApply a stronger edge enhancement filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.EDGE_ENHANCE_MORE`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Smoothened image. )r|rUr~ZEDGE_ENHANCE_MOREr2rrrfilter_edge_enhance_mores#rcCr})aApply an edge detection filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.FIND_EDGES`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Image with detected edges. )r|rUr~Z FIND_EDGESr2rrrfilter_find_edgesrrcCr})aApply a contour filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.CONTOUR`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Image with pronounced contours. )r|rUr~ZCONTOURr2rrrfilter_contourrrcCr})aApply an emboss filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.EMBOSS`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Embossed image. )r|rUr~ZEMBOSSr2rrr filter_embossrrcCr})aApply a sharpening filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.SHARPEN`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Sharpened image. )r|rUr~ZSHARPENr2rrrfilter_sharpenrrcCr})aApply a detail enhancement filter kernel to the image. This is the same as using PIL's ``PIL.ImageFilter.DETAIL`` kernel. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Returns ------- ndarray Image with enhanced details. )r|rUr~ZDETAILr2rrr filter_detail?rr?rrcCst|d}t|d}t|||g\}} } d|}tjddd|dgddd|dggdgtjd} tj|ddgd|dggdgtjd} tjdd|gdd|ggdgtjd} tjdt| dgt| ddggdgtjd}tjt|t|dgt| t|dggdgtjd}tjdd|dgdd|dggdgtjd}tjgdgdgdgtjd}| ||| | |fD]}t||}qtj |}|S) Ng-C6?rrr)rrrr>)rrr)rrr) maxr)Zdeg2radr_float32tanhcossinmatmulZlinalginv)scale_xscale_ytranslate_x_pxtranslate_y_px rotate_deg shear_x_deg shear_y_deg center_pxZ rotate_radZ shear_x_radZ shear_y_radZmatrix_centerizeZ matrix_scaleZmatrix_translateZ matrix_shearZ matrix_rotateZmatrix_decenterizematrixZ other_matrixrrr_create_affine_matrixgs      r?rc  Cs |jjdksJd|jjfd|jvrt|S|dur|nd}t|r-ttt |}t |d\}} t j |} |jdd\} } | | d| | df}t||||||||d}|ddddfj}t| j| jt j j||d }| r|ddddtjf}|S) a Apply an affine transformation to an image. This function has identical outputs to ``PIL.Image.transform`` with ``method=PIL.Image.AFFINE``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no Parameters ---------- image : ndarray The image to modify. Expected to be ``uint8`` with shape ``(H,W)`` or ``(H,W,C)`` with ``C`` being ``3`` or ``4``. scale_x : number, optional Affine scale factor along the x-axis, where ``1.0`` denotes an identity transform and ``2.0`` is a strong zoom-in effect. scale_y : number, optional Affine scale factor along the y-axis, where ``1.0`` denotes an identity transform and ``2.0`` is a strong zoom-in effect. translate_x_px : number, optional Affine translation along the x-axis in pixels. Positive values translate the image towards the right. translate_y_px : number, optional Affine translation along the y-axis in pixels. Positive values translate the image towards the bottom. rotate_deg : number, optional Affine rotation in degrees *around the top left* of the image. shear_x_deg : number, optional Affine shearing in degrees along the x-axis with center point being the top-left of the image. shear_y_deg : number, optional Affine shearing in degrees along the y-axis with center point being the top-left of the image. fillcolor : None or int or tuple of int, optional Color tuple or intensity value to use when filling up newly created pixels. ``None`` fills with zeros. ``int`` will only fill the ``0`` th channel with that intensity value and all other channels with ``0`` (this is the default behaviour of PIL, use a tuple to fill all channels). center : tuple of number, optional Center xy-coordinate of the affine transformation, given as *relative* values, i.e. ``(0.0, 0.0)`` sets the transformation center to the top-left image corner, ``(1.0, 0.0)`` sets it to the the top-right image corner and ``(0.5, 0.5)`` sets it to the image center. The transformation center is relevant e.g. for rotations ("rotate around this center point"). PIL uses the image top-left corner as the transformation center if no centerization is included in the affine transformation matrix. Returns ------- ndarray Image after affine transformation. r4zGCan apply PIL affine transformation only to uint8 images, got dtype %s.rNz'imgaug.augmenters.pillike.warp_affine()r r)rrrrrrrr) fillcolor)r7r8rr)r*rNrbtuplemaprLrrUrVrWrZflatr_Z transformr ZAFFINErD)rrrrrrrrrcenterrr{heightwidthrrr<rrr warp_affinesDV    rc(eZdZdZ   dfdd ZZS) Solarizea]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()``. Added in 0.4.0. **Supported dtypes**: See ``~imgaug.augmenters.arithmetic.invert_(min_value=None and max_value=None)``. Parameters ---------- p : float or imgaug.parameters.StochasticParameter, optional See :class:`~imgaug.augmenters.arithmetic.Invert`. threshold : None or number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :class:`~imgaug.augmenters.arithmetic.Invert`. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.Solarize(0.5, threshold=(32, 128)) 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. rrN deprecatedc s(tt|j|ddd|d||||d dS)NFT) p per_channelZ min_valueZ max_valuerZinvert_above_thresholdseedr8 random_state deterministic)superr__init__)selfrrrr8rr __class__rrrZs  zSolarize.__init__)rrNNrr__name__ __module__ __qualname____doc__r __classcell__rrrrr)s 0rc@seZdZdZdS) PosterizeaAugmenter with identical outputs to PIL's ``posterize()`` function. This augmenter quantizes each array component to ``N`` bits. This class is currently an alias for :class:`~imgaug.augmenters.color.Posterize`, which again is an alias for :class:`~imgaug.augmenters.color.UniformColorQuantizationToNBits`, i.e. all three classes are right now guarantueed to have the same outputs as PIL's function. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.color.Posterize`. N)rrrrrrrrresrcs6eZdZdZ  d fdd ZddZdd ZZS) EqualizeaEqualize the image histogram. This augmenter has identical outputs to ``PIL.ImageOps.equalize``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.equalize_`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.Equalize() Equalize the histograms of all input images. Nrcstt|j||||ddSNrr8rr)rrrrrr8rrrrrrs  zEqualize.__init__cCs&|jdur|jD]}t||d<q|SN.)imagesr,rbatchrparentshooksrrrr_augment_batch_s  zEqualize._augment_batch_cCgSz=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.rrrrrget_parameterszEqualize.get_parametersNNrr)rrrrrrrrrrrrrys(rcr) Autocontrasta Adjust contrast by cutting off ``p%`` of lowest/highest histogram values. This augmenter has identical outputs to ``PIL.ImageOps.autocontrast``. See :func:`~imgaug.augmenters.pillike.autocontrast` for more details. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.autocontrast`. Parameters ---------- cutoff : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Percentage of values to cut off from the low and high end of each image's histogram, before stretching it to ``[0, 255]``. * If ``int``: The value will be used for all images. * If ``tuple`` ``(a, b)``: A value will be uniformly sampled from the discrete interval ``[a..b]`` per image. * If ``list``: A random value will be sampled from the list per image. * If ``StochasticParameter``: A value will be sampled from that parameter 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``. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.Autocontrast() 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. >>> aug = iaa.pillike.Autocontrast((10, 20), per_channel=True) 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*. rFNrc sFtj|dddddg}t}tt|j|||dggd||||d dS)Nr\)r1TZ value_rangeZtuple_to_uniformZlist_to_choicer4)Zuint16Zuint32Zuint64Zint8Zint16rBZint64float16rrfrrrfZfloat96Zfloat128Zfloat256bool)Zdtypes_allowedZdtypes_disallowedrr8rr)iapZhandle_discrete_paramr^rrr) rr\rrr8rrZparams1dfuncrrrrs  zAutocontrast.__init__)rFNNrrrrrrrrs Crcs:eZdZ  d fdd ZddZddZd d ZZS) _EnhanceBaseNrcs8tt|j||||d||_tj|d|ddd|_dS)NrroTr)rrrrrZhandle_continuous_paramro)rrrofactor_value_rangerr8rrrrrrs  z_EnhanceBase.__init__cCsJ|jdur|S|t|j|}t|j|D] \}}||||d<q|Sr)r _draw_samplesrGzipr)rrrrrZfactorsrrorrrrs z_EnhanceBase._augment_batch_cCs|jj|f|dS)Nr)ro draw_samples)rZnb_rowsrrrrr)sz_EnhanceBase._draw_samplescCs|jgSr)rorrrrr-sz_EnhanceBase.get_parametersr)rrrrrrrrrrrrrs  rc(eZdZdZ   dfdd ZZS) EnhanceColoraConvert images to grayscale. This augmenter has identical outputs to ``PIL.ImageEnhance.Color``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.enhance_color`. Parameters ---------- factor : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Colorfulness of the output image. Values close to ``0.0`` lead to grayscale images, values above ``1.0`` increase the strength of colors. Sane values are roughly in ``[0.0, 3.0]``. * If ``number``: The value will be used for all images. * If ``tuple`` ``(a, b)``: A value will be uniformly sampled per image from the interval ``[a, b)``. * If ``list``: A random value will be picked from the list per image. * If ``StochasticParameter``: Per batch of size ``N``, the parameter will be queried once to return ``(N,)`` samples. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.EnhanceColor() Create an augmenter to remove a random fraction of color from input images. rag@Nrc "tt|jt|d||||ddSN)raN)rrorrr8rr)rrrrurrorr8rrrrrrh  zEnhanceColor.__init__)rNNrrrrrrrr2s 5rcr)EnhanceContrastaMChange the contrast of images. This augmenter has identical outputs to ``PIL.ImageEnhance.Contrast``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.enhance_contrast`. Parameters ---------- factor : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Strength of contrast in the image. Values below ``1.0`` decrease the contrast, leading to a gray image around ``0.0``. Values above ``1.0`` increase the contrast. Sane values are roughly in ``[0.5, 1.5]``. * If ``number``: The value will be used for all images. * If ``tuple`` ``(a, b)``: A value will be uniformly sampled per image from the interval ``[a, b)``. * If ``list``: A random value will be picked from the list per image. * If ``StochasticParameter``: Per batch of size ``N``, the parameter will be queried once to return ``(N,)`` samples. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.EnhanceContrast() Create an augmenter that worsens the contrast of an image by a random factor. rg?Nrc rr)rrrrwrrrrrrzEnhanceContrast.__init__rNNrrrrrrrrs 6rcr)EnhanceBrightnessaNChange the brightness of images. This augmenter has identical outputs to ``PIL.ImageEnhance.Brightness``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.enhance_brightness`. Parameters ---------- factor : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Brightness of the image. Values below ``1.0`` decrease the brightness, leading to a black image around ``0.0``. Values above ``1.0`` increase the brightness. Sane values are roughly in ``[0.5, 1.5]``. * If ``number``: The value will be used for all images. * If ``tuple`` ``(a, b)``: A value will be uniformly sampled per image from the interval ``[a, b)``. * If ``list``: A random value will be picked from the list per image. * If ``StochasticParameter``: Per batch of size ``N``, the parameter will be queried once to return ``(N,)`` samples. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.EnhanceBrightness() Create an augmenter that worsens the brightness of an image by a random factor. rNrc rr)rrrrxrrrrrrzEnhanceBrightness.__init__rrrrrrrrrcr)EnhanceSharpnessaChange the sharpness of images. This augmenter has identical outputs to ``PIL.ImageEnhance.Sharpness``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.enhance_sharpness`. Parameters ---------- factor : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Sharpness of the image. Values below ``1.0`` decrease the sharpness, values above ``1.0`` increase it. Sane values are roughly in ``[0.0, 2.0]``. * If ``number``: The value will be used for all images. * If ``tuple`` ``(a, b)``: A value will be uniformly sampled per image from the interval ``[a, b)``. * If ``list``: A random value will be picked from the list per image. * If ``StochasticParameter``: Per batch of size ``N``, the parameter will be queried once to return ``(N,)`` samples. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.EnhanceSharpness() Create an augmenter that randomly decreases or increases the sharpness of an image. rag@Nrc rr)rrrryrrrrr.rzEnhanceSharpness.__init__)rNNrrrrrrrrrrcs2eZdZ  d fdd ZddZddZZS) _FilterBaseNrcs"tt|j||||d||_dSr)rrrr)rrrr8rrrrrr<s  z_FilterBase.__init__cCs(|jdur|jD] }|||d<q|Sr)rrrrrrrEs  z_FilterBase._augment_batch_cCrrrrrrrrLrz_FilterBase.get_parametersr)rrrrrrrrrrrr:s  rc&eZdZdZ  dfdd ZZS) FilterBluraRApply a blur filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.BLUR``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_blur`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterBlur() Create an augmenter that applies a blur filter kernel to images. Nrctt|jt||||ddSN)rrr8rr)rrrrrrrrrz  zFilterBlur.__init__rrrrrrrQ )rcr) FilterSmoothafApply a smoothening filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.SMOOTH``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_smooth`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterSmooth() Create an augmenter that applies a smoothening filter kernel to images. Nrcrr)rrrrrrrrrrzFilterSmooth.__init__rrrrrrrrrcr)FilterSmoothMoreaApply a strong smoothening filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.BLUR``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_smooth_more`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterSmoothMore() Create an augmenter that applies a strong smoothening filter kernel to images. Nrcrr)rrrrrrrrrrzFilterSmoothMore.__init__rrrrrrr *rcr)FilterEdgeEnhanceaApply an edge enhance filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.EDGE_ENHANCE``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_edge_enhance`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterEdgeEnhance() Create an augmenter that applies a edge enhancement filter kernel to images. Nrcrr)rrrrrrrrrrzFilterEdgeEnhance.__init__rrrrrrr +rcr)FilterEdgeEnhanceMoreaApply a strong edge enhancement filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.EDGE_ENHANCE_MORE``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_edge_enhance_more`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterEdgeEnhanceMore() Create an augmenter that applies a strong edge enhancement filter kernel to images. Nrcrr)rrrrrrrrrGrzFilterEdgeEnhanceMore.__init__rrrrrrrrrcr)FilterFindEdgesauApply a edge detection kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.FIND_EDGES``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_find_edges`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterFindEdges() Create an augmenter that applies an edge detection filter kernel to images. Nrcrr)rrrrrrrrrzrzFilterFindEdges.__init__rrrrrrrPrrcr) FilterContourayApply a contour detection filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.CONTOUR``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_contour`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterContour() Create an augmenter that applies a contour detection filter kernel to images. Nrcrr)rrrrrrrrrrzFilterContour.__init__rrrrrrrrrcr) FilterEmbossa^Apply an emboss filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.EMBOSS``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_emboss`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterEmboss() Create an augmenter that applies an emboss filter kernel to images. Nrcrr)rrrrrrrrrrzFilterEmboss.__init__rrrrrrrrrcr) FilterSharpenagApply a sharpening filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.SHARPEN``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_sharpen`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterSharpen() Create an augmenter that applies a sharpening filter kernel to images. Nrcrr)rrrrrrrrr rzFilterSharpen.__init__rrrrrrrrrcr) FilterDetailaxApply a detail enhancement filter kernel to images. This augmenter has identical outputs to calling ``PIL.Image.filter`` with kernel ``PIL.ImageFilter.DETAIL``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.filter_detail`. Parameters ---------- seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.FilterDetail() Create an augmenter that applies a detail enhancement filter kernel to images. Nrcrr)rrrrrrrrrD rzFilterDetail.__init__rrrrrrr rrcsXeZdZdZ    dfdd Zfd d Z  dd dZfddZddZZ S)AffineaApply PIL-like affine transformations to images. This augmenter has identical outputs to ``PIL.Image.transform`` with parameter ``method=PIL.Image.AFFINE``. .. warning:: This augmenter can currently only transform image-data. Batches containing heatmaps, segmentation maps and coordinate-based augmentables will be rejected with an error. Use :class:`~imgaug.augmenters.geometric.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)``. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.pillike.warp_affine`. Parameters ---------- scale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter or dict {"x": number/tuple/list/StochasticParameter, "y": number/tuple/list/StochasticParameter}, optional See :class:`~imgaug.augmenters.geometric.Affine`. translate_percent : None or number or tuple of number or list of number or imgaug.parameters.StochasticParameter or dict {"x": number/tuple/list/StochasticParameter, "y": number/tuple/list/StochasticParameter}, optional See :class:`~imgaug.augmenters.geometric.Affine`. translate_px : None or int or tuple of int or list of int or imgaug.parameters.StochasticParameter or dict {"x": int/tuple/list/StochasticParameter, "y": int/tuple/list/StochasticParameter}, optional See :class:`~imgaug.augmenters.geometric.Affine`. rotate : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :class:`~imgaug.augmenters.geometric.Affine`. shear : number or tuple of number or list of number or imgaug.parameters.StochasticParameter or dict {"x": int/tuple/list/StochasticParameter, "y": int/tuple/list/StochasticParameter}, optional See :class:`~imgaug.augmenters.geometric.Affine`. fillcolor : number or tuple of number or list of number or imgaug.ALL or imgaug.parameters.StochasticParameter, optional See parameter ``cval`` in :class:`~imgaug.augmenters.geometric.Affine`. center : {'uniform', 'normal', 'center', 'left-top', 'left-center', 'left-bottom', 'center-top', 'center-center', 'center-bottom', 'right-top', 'right-center', 'right-bottom'} or tuple of float or StochasticParameter or tuple of StochasticParameter, optional The center point of the affine transformation, given as relative xy-coordinates. Set this to ``(0.0, 0.0)`` or ``left-top`` to use the top left image corner as the transformation center. Set this to ``(0.5, 0.5)`` or ``center-center`` to use the image center as the transformation center. See also paramerer ``position`` in :class:`~imgaug.augmenters.size.PadToFixedSize` for details about valid datatypes of this parameter. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.pillike.Affine(scale={"x": (0.8, 1.2), "y": (0.5, 1.5)}) 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). >>> aug = iaa.pillike.Affine(translate_px={"x": 0, "y": [-10, 10]}, >>> fillcolor=128) 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(rotate=(-20, 20), fillcolor=(0, 256)) Rotate an image by ``-20`` to ``20`` degress and fill up all newly created pixels with a random RGB color. See the similar augmenter :class:`~imgaug.augmenters.geometric.Affine` for more examples. rNrarrrc s<tt|j|||||d|ddd|| | | dt||_dS)NrZconstantFauto)rltranslate_percent translate_pxrotateshearordercvalmodeZ fit_outputbackendrr8rr)rrrsizelibZ_handle_position_parameterr) rrlrrrrrrrr8rrrrrr s zAffine.__init__csR|}t|dkst|dkrd|vsJdd|ftt|||||S)Nrrrzpillike.Affine can currently only process image data. Got a batch containing: %s. Use imgaug.augmenters.geometric.Affine for batches containing non-image data.z, )Zget_column_namesrGjoinrrr)rrrrrcolsrrrr s"  zAffine._augment_batch_Fc Cs|dusJdt|D]B\}}|dur|jn||}|j|||d}t||d|d|d|d|d|d |d t|j||j||j|fd |d <q |S) NFzWGot unexpectedly return_matrices=True. pillike.Affine does not yet produce that output.)Z arr_shape image_shaperrrrrrr) rrrrrrrrr.)rerZget_affine_parametersrrrcenter_xcenter_y) rrsamplesZ image_shapesZreturn_matricesirrparamsrrr_augment_images_by_samples s.    z!Affine._augment_images_by_samplescstt|||}t|jtr$|jdj||d}|jdj||d}n|jj|df|d}|dddf}|dddf}||_||_|S)Nrrrr ) rrr isinstancerrrrr )rZ nb_samplesrr xxyyZxyrrrr s$     zAffine._draw_samplescCs|j|j|j|j|j|jgSr)rl translaterrrrrrrrr szAffine.get_parameters) rNNrararrNNrr)NF) rrrrrrr rrrrrrrrM sg   r)rr/)rN)rrrrrrrr) rrrrrrrNr)Wr __future__rrrZ six.movesmovesrcnumpyr)rEZ PIL.ImagerUZ PIL.ImageOpsZPIL.ImageEnhanceZPIL.ImageFilterZimgaugrNZ imgaug.imgaugrrrr r$r Z contrastlibr r rrrr+rrr!r(r%r.r,r:r9r^rZr[rprurwrxryr|rrrrrrrrrrrrInvertrrZ AugmenterrZ_ContrastFuncWrapperrrrrrrrrrrrrrrrrrrrrrrs1             & C A[+,+,%%%%&%%%%( B <=[!ABBC2234433223