o &j *@sdZddlmZmZmZddlZddlZddlZddl Z ddl Z ddl m Z ddlmZddlmZdsd d Zdsd d Z  dtddZ duddZ dtddZ  dvddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zdwd)d*Z  dtd+d,Z!  dtd-d.Z"d/d0Z#d1d2Z$d3d4Z%d5d6Z& dxd7d8Z' dxd9d:Z(e j)d;dd?Z*Gd@d;d;ej+Z,GdAdBdBe-Z.GdCdDdDej+Z/GdEdFdFe/Z0GdGdHdHe/Z1GdIdJdJej+Z2GdKdLdLe2Z3GdMdNdNej+Z4GdOdPdPe4Z5GdQdRdRe4Z6GdSdTdTe6Z7GdUdVdVe2Z8GdWdXdXe8Z9GdYdZdZe4Z:Gd[d\d\e:Z;Gd]d^d^e2ZGdcdddde>Z?Gdedfdfe2Z@Gdgdhdhe@ZAGdidjdje>ZBGdkdldleBZCGdmdndne@ZDGdodpdpeDZEGdqdrdrej+ZFdS)yad Augmenters that somehow change the size of the images. List of augmenters: * :class:`Resize` * :class:`CropAndPad` * :class:`Crop` * :class:`Pad` * :class:`PadToFixedSize` * :class:`CenterPadToFixedSize` * :class:`CropToFixedSize` * :class:`CenterCropToFixedSize` * :class:`CropToMultiplesOf` * :class:`CenterCropToMultiplesOf` * :class:`PadToMultiplesOf` * :class:`CenterPadToMultiplesOf` * :class:`CropToPowersOf` * :class:`CenterCropToPowersOf` * :class:`PadToPowersOf` * :class:`CenterPadToPowersOf` * :class:`CropToAspectRatio` * :class:`CenterCropToAspectRatio` * :class:`PadToAspectRatio` * :class:`CenterPadToAspectRatio` * :class:`CropToSquare` * :class:`CenterCropToSquare` * :class:`PadToSquare` * :class:`CenterPadToSquare` * :class:`KeepSizeByResize` )print_functiondivisionabsolute_importN)_normalize_cv2_input_arr_)meta) parametersTc Csn|rt|d|d||||\}}}}|dd\}}|}||} |} ||} t| |} t| | } || | | fS)Nrrr)_crop_prevent_zero_sizemax) shapetoprightbottomleftprevent_zero_sizeheightwidthx1x2y1y2rW/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/imgaug/augmenters/size.py_crop_trbl_to_xyxy/s    rc Cs4t|j|||||d\}}}} ||| ||dfS)N)r.)rr ) arrr rrrrrrrrrrr _crop_arr_EsrconstantFc Cs`|jdd\}}t|g|R}t||d|d|d|d||d} |r.t| ||f} | S)Nrrrr rrrmodecval)r rpadiaimresize_single_image) r croppingspaddingspad_modepad_cval keep_sizerrZimage_cr image_cr_parrr_crop_and_pad_arrKs  r+cCt||||||SN_crop_and_pad_hms_or_segmaps_)Zheatmap croppings_img paddings_imgr'r(r)rrr_crop_and_pad_heatmap_]r3cCr-r.r/)Zsegmapr1r2r'r(r)rrr_crop_and_pad_segmap_dr4r5c Cs"t|tjrd}|dur|nd}nt|tjsJdt|d}|dur'|nd}t||}|j}|j} t|| |j} t|| |j} t|jd|jdg| R} t || d| d| d| d} t | | d| d| d| d||d } t ||| |r| |dd}|St |j|||_|S) Narr_0to1r,z maximum symmetricmeanmedian linear_rampminimumwrapedgerreflectzz*_handle_pad_mode_param..zIAt least one in list %s is not a valid pad mode. Valid pad modes are: %s.z[Expected pad_mode to be ia.ALL or string or list of strings or StochasticParameter, got %s.)r#ALLiapChoicerH is_stringjoin Deterministicr7allstrStochasticParameter Exceptionr8)r'rrcr_handle_pad_mode_params0        rpcCs|dkrtddtddfS|dkr.tjtjddddddtjtjddddddfS|d kr.z\Both position values must be within the value range [0.0, 1.0]. Got type %s with value %.8f.cSs$g|]}t|rt|n|qSr)r#is_single_numberrgrkr|rrrrd>s  cSsg|]}t|tjqSr)r7rgrnr|rrrrdBszdExpected tuple with two entries that are both either StochasticParameter or float/int. Got types %s.cSrzrr{r|rrrrdGreaBExpected one of the following as position parameter: string 'uniform', string 'normal', string 'center', a string matching regex ^(left|center|right)-(top|center|bottom)$, a single StochasticParameter or a tuple of two entries, both being either StochasticParameter or floats or int. Got instead type %s with content '%s'.z...)rgUniformZClipZNormalrkr#rirematchsplitr7rnrIlenrmr~ror8rl)positionmappingr}Z only_sparamsrrr_handle_position_parameters    rcCs4t|dr|j}t|dvsJdt||fdS)Nr )rrzPExpected image with two or three dimensions, but got %d dimensions and shape %s.)hasattrr rr rrr_assert_two_or_three_dims[s  rcsddlm}ttdd||||fDs!Jd||||ft}|dks7|dks7|dks7|dkr|j\} } } jjdkrKt |rUt | | nt t | | tddjD} | rkddtjd tjd dd dd dd ddddtjdtjddtjtjtjtjtjtjtjtji} | ddu}jjdv}jdkojddk}|ss|ss|ssjj|rȇfddDn dkrtntjdksjddkrjdkr|stgjdtjt||||| d}jdkr|jdkr|dt jf}|Sg}d}|r n tgjd|jdkrjd||df}||d}tjt|||||| |d}t |}|||d7}|jdks2t j |dd}|S||f||fgjdkrddkrjdkr|rfddt !jdD}t j"|dd}|St j#d}|Sd krjdkr|rfddt !jdD}t j"|dd}|St j#d }|St j#d!}|St $S)"a Pad an image-like array on its top/right/bottom/left side. This function is a wrapper around :func:`numpy.pad`. Added in 0.4.0. (Previously named ``imgaug.imgaug.pad()``.) **Supported dtypes**: * ``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 to the top side of the image. Must be ``0`` or greater. right : int, optional Amount of pixels to add to the right side of the image. Must be ``0`` or greater. bottom : int, optional Amount of pixels to add to the bottom side of the image. Must be ``0`` or greater. left : int, optional Amount of pixels to add to 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 or iterable of 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. If an iterable is used, it is expected to contain one value per channel. The number of values and number of channels are expected to match. Returns ------- (H',W') ndarray or (H',W',C) ndarray Padded array with height ``H'=H+top+bottom`` and width ``W'=W+left+right``. rNcSsg|]}|dkqSrrr`rrrrdrezpad..zXExpected padding amounts that are >=0, but got %d, %d, %d, %d (top, right, bottom, left)float128cSsg|]}|dkqSrr)raaxisrrrrdrerr\rYrUrWrXrZr]rVr[)Zuint32Zuint64Zint64Zfloat16rboolrcs$g|]}dkr t|nt|qS)f)floatrP)racval_c)kindrrrdsrr)r rrrZ borderTyperT.)rrrc2g|]}tjd|fdd|dqS).rrr Zconstant_valuesrQr"racrr!r paddings_nprrrd rcr).rrr Z end_valuesrrrrrrdrr)r )%Z imgaug.dtypesZdtypesrrlr# is_iterableZget_value_range_of_dtypedtypenamerQrZclipr minanyr cv2ZBORDER_CONSTANTZBORDER_REPLICATEZBORDER_REFLECT_101ZBORDER_REFLECTgetndimrrrPrIZcopyMakeBorderrZnewaxisZ atleast_3dappendZ concatenateZarangestackr"copy)rr rrrr r!ZiadtZ is_multi_cvalZ min_value_Z max_valueZhas_zero_sized_axisZmapping_mode_np_to_cv2Z bad_mode_cv2Zbad_datatype_cv2Z bad_shape_cv2Zarr_padresultZchannel_start_idxZarr_crZ arr_pad_cZ arr_pad_chansr)rr!rr rrr"cs F  "   /           r"c Cs@t||\}}}}t|||||||d} |r| ||||ffS| S)aPad an image array on its sides so that it matches a target aspect ratio. See :func:`~imgaug.imgaug.compute_paddings_for_aspect_ratio` for an explanation of how the required padding amounts are distributed per image axis. Added in 0.4.0. (Previously named ``imgaug.imgaug.pad_to_aspect_ratio()``.) **Supported dtypes**: See :func:`~imgaug.augmenters.size.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:`~imgaug.imgaug.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 ``int``. Returns ------- (H',W') ndarray or (H',W',C) ndarray Padded image as ``(H',W')`` or ``(H',W',C)`` ndarray, fulfilling 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``. r)&compute_paddings_to_reach_aspect_ratior") r aspect_ratior r!return_pad_amountspad_top pad_right pad_bottompad_left arr_paddedrrrpad_to_aspect_ratio,s4  rc CsBt|||\}}}} t||||| ||d} |r| |||| ffS| S)aPad an image array until its side lengths are multiples of given values. See :func:`~imgaug.imgaug.compute_paddings_for_aspect_ratio` for an explanation of how the required padding amounts are distributed per image axis. Added in 0.4.0. (Previously named ``imgaug.imgaug.pad_to_multiples_of()``.) **Supported dtypes**: See :func:`~imgaug.augmenters.size.pad`. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray Image-like array to pad. height_multiple : None or int The desired multiple of the height. The computed padding amount will reflect a padding that increases the y axis size until it is a multiple of this value. width_multiple : None or int The desired multiple of the width. The computed padding amount will reflect a padding that increases the x axis size until it is a multiple of this value. mode : str, optional Padding mode to use. See :func:`~imgaug.imgaug.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 ------- (H',W') ndarray or (H',W',C) ndarray Padded image as ``(H',W')`` or ``(H',W',C)`` ndarray. 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``. r)&compute_paddings_to_reach_multiples_ofr") rheight_multiplewidth_multipler r!rrrrrrrrrpad_to_multiples_ofps 9  rc Cst||dksJd|fd}d}d}d}t|dr|jn|}|dd\}}|dkr3d}|d7}|dkr=d}|d7}||} | |krb|||} |tt| d7}|tt| d7}n"| |krd|||} |tt| d7}|tt| d7}||||fS)aiCompute pad amounts required to fulfill an aspect ratio. "Pad amounts" here denotes the number of pixels that have to be added to each side to fulfill the desired constraint. The aspect ratio is given as ``ratio = width / height``. Depending on which dimension is smaller (height or width), only the corresponding sides (top/bottom or left/right) will be padded. The axis-wise padding amounts are always distributed equally over the sides of the respective axis (i.e. left and right, top and bottom). For odd pixel amounts, one pixel will be left over after the equal distribution and could be added to either side of the axis. This function will always add such a left over pixel to the bottom (y-axis) or right (x-axis) side. Added in 0.4.0. (Previously named ``imgaug.imgaug.compute_paddings_to_reach_aspect_ratio()``.) Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray or tuple of int Image-like array or shape tuple 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 ------- tuple of int Required padding amounts to reach the target aspect ratio, given as a ``tuple`` of the form ``(top, right, bottom, left)``. r-Expected to get an aspect ratio >0, got %.4f.r rr)rrr rPrQceilfloor) rrrrrrr rraspect_ratio_currentrNrrrrs4$   rc Cst||dksJd|ft|dr|jn|}|ddks&Jd|f|dd\}}||}d}d}d}d} ||kr^|||} t| |d} tt| d}tt| d}n#||kr|||} t| |d} tt| d} tt| d}|||| fS)aCompute crop amounts required to fulfill an aspect ratio. "Crop amounts" here denotes the number of pixels that have to be removed from each side to fulfill the desired constraint. The aspect ratio is given as ``ratio = width / height``. Depending on which dimension is smaller (height or width), only the corresponding sides (top/bottom or left/right) will be cropped. The axis-wise padding amounts are always distributed equally over the sides of the respective axis (i.e. left and right, top and bottom). For odd pixel amounts, one pixel will be left over after the equal distribution and could be added to either side of the axis. This function will always add such a left over pixel to the bottom (y-axis) or right (x-axis) side. If an aspect ratio cannot be reached exactly, this function will return rather one pixel too few than one pixel too many. Added in 0.4.0. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray or tuple of int Image-like array or shape tuple for which to compute crop 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 ------- tuple of int Required cropping amounts to reach the target aspect ratio, given as a ``tuple`` of the form ``(top, right, bottom, left)``. rrr z6Expected to get an array with height >0, got shape %s.rr)rrr rrPrQrr) rrr rrrr rrrZ crop_amountrrr'compute_croppings_to_reach_aspect_ratios2&    rc Cdd}t||dur|dksJd|f|dur&|dks&Jd|ft|dr.|jn|}|dd\}}|||\}}|||\} } || || fS)agCompute pad amounts until img height/width are multiples of given values. See :func:`~imgaug.imgaug.compute_paddings_for_aspect_ratio` for an explanation of how the required padding amounts are distributed per image axis. Added in 0.4.0. (Previously named ``imgaug.imgaug.compute_paddings_to_reach_multiples_of()``.) Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray or tuple of int Image-like array or shape tuple for which to compute pad amounts. height_multiple : None or int The desired multiple of the height. The computed padding amount will reflect a padding that increases the y axis size until it is a multiple of this value. width_multiple : None or int The desired multiple of the width. The computed padding amount will reflect a padding that increases the x axis size until it is a multiple of this value. Returns ------- tuple of int Required padding amounts to reach multiples of the provided values, given as a ``tuple`` of the form ``(top, right, bottom, left)``. cSs\|durdS|dkr |}n||dkrd}n|||}tt|dtt|dfSNrrrrPrQrr) axis_sizemultipleto_padrrr_compute_axis_valuejs  $zCcompute_paddings_to_reach_multiples_of.._compute_axis_valueNrz1Can only pad to multiples of 1 or larger, got %d.r rrrr rrrrr rrr rrrrrrrIs&!    rc Cr)aCompute croppings to reach multiples of given heights/widths. See :func:`~imgaug.imgaug.compute_paddings_for_aspect_ratio` for an explanation of how the required cropping amounts are distributed per image axis. Added in 0.4.0. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray or tuple of int Image-like array or shape tuple for which to compute crop amounts. height_multiple : None or int The desired multiple of the height. The computed croppings will reflect a crop operation that decreases the y axis size until it is a multiple of this value. width_multiple : None or int The desired multiple of the width. The computed croppings amount will reflect a crop operation that decreases the x axis size until it is a multiple of this value. Returns ------- tuple of int Required cropping amounts to reach multiples of the provided values, given as a ``tuple`` of the form ``(top, right, bottom, left)``. cSsX|durdS|dkr d}n ||dkrd}n||}tt|dtt|dfSrr)rrto_croprrrrs $zDcompute_croppings_to_reach_multiples_of.._compute_axis_valueNrz2Can only crop to multiples of 1 or larger, got %d.r rrrrrr'compute_croppings_to_reach_multiples_ofs&     rc fdd}t||dur|dksJd|f|dur(|dks(Jd|ft|dr0|jn|}|dd\}}|||\}} |||\} } || | | fS) aKCompute paddings to reach powers of given base values. For given axis size ``S``, padded size ``S'`` (``S' >= S``) and base ``B`` this function computes paddings that fulfill ``S' = B^E``, where ``E`` is any exponent from the discrete interval ``[0 .. inf)``. See :func:`~imgaug.imgaug.compute_paddings_for_aspect_ratio` for an explanation of how the required padding amounts are distributed per image axis. Added in 0.4.0. (Previously named ``imgaug.imgaug.compute_paddings_to_reach_exponents_of()``.) Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray or tuple of int Image-like array or shape tuple for which to compute pad amounts. height_base : None or int The desired base of the height. width_base : None or int The desired base of the width. allow_zero_exponent : bool, optional Whether ``E=0`` in ``S'=B^E`` is a valid value. If ``True``, axes with size ``0`` or ``1`` will be padded up to size ``B^0=1`` and axes with size ``1 < S <= B`` will be padded up to ``B^1=B``. If ``False``, the minimum output axis size is always at least ``B``. Returns ------- tuple of int Required padding amounts to fulfill ``S' = B^E`` given as a ``tuple`` of the form ``(top, right, bottom, left)``. cs|durdS|dkrrdn|}n||kr||}nt|t|}|tt||}tt|dtt|dfSNrrrr)rQlogrPrr)rbaserexponentallow_zero_exponentrrrs $z@compute_paddings_to_reach_powers_of.._compute_axis_valueNrz+Can only pad to base larger than 1, got %d.r rrr r height_base width_baserrr rrr rrrrrr#compute_paddings_to_reach_powers_ofs '   rc r) aZCompute croppings to reach powers of given base values. For given axis size ``S``, cropped size ``S'`` (``S' <= S``) and base ``B`` this function computes croppings that fulfill ``S' = B^E``, where ``E`` is any exponent from the discrete interval ``[0 .. inf)``. See :func:`~imgaug.imgaug.compute_paddings_for_aspect_ratio` for an explanation of how the required cropping amounts are distributed per image axis. .. note:: For axes where ``S == 0``, this function alwayws returns zeros as croppings. For axes where ``1 <= S < B`` see parameter `allow_zero_exponent`. Added in 0.4.0. Parameters ---------- arr : (H,W) ndarray or (H,W,C) ndarray or tuple of int Image-like array or shape tuple for which to compute crop amounts. height_base : None or int The desired base of the height. width_base : None or int The desired base of the width. allow_zero_exponent : bool Whether ``E=0`` in ``S'=B^E`` is a valid value. If ``True``, axes with size ``1 <= S < B`` will be cropped to size ``B^0=1``. If ``False``, axes with sizes ``S < B`` will not be changed. Returns ------- tuple of int Required cropping amounts to fulfill ``S' = B^E`` given as a ``tuple`` of the form ``(top, right, bottom, left)``. cs||durdS|dkr d}n||krr|dnd}nt|t|}||t|}tt|dtt|dfSr)rQrrPrr)rrrrrrrr<s$zAcompute_croppings_to_reach_powers_of.._compute_axis_valueNrz,Can only crop to base larger than 1, got %d.r rrrrrrr$compute_croppings_to_reach_powers_ofs ,   rResizez/Resize has the exactly same interface as Scale.)Zalt_funccommentcOst|i|S)z>Augmenter that resizes images to specified heights and widths.)r)argskwargsrrrScale^srcs|eZdZdZ   dfdd ZeddZed d Zd d Zd dZ ddZ ddZ ddZ eddZ ddZZS)raAugmenter that resizes images to specified heights and widths. **Supported dtypes**: See :func:`~imgaug.imgaug.imresize_many_images`. Parameters ---------- size : 'keep' or int or float or tuple of int or tuple of float or list of int or list of float or imgaug.parameters.StochasticParameter or dict The new size of the images. * If this has the string value ``keep``, the original height and width values will be kept (image is not resized). * If this is an ``int``, this value will always be used as the new height and width of the images. * If this is a ``float`` ``v``, then per image the image's height ``H`` and width ``W`` will be changed to ``H*v`` and ``W*v``. * If this is a ``tuple``, it is expected to have two entries ``(a, b)``. If at least one of these are ``float`` s, a value will be sampled from range ``[a, b]`` and used as the ``float`` value to resize the image (see above). If both are ``int`` s, a value will be sampled from the discrete range ``[a..b]`` and used as the integer value to resize the image (see above). * If this is a ``list``, a random value from the ``list`` will be picked to resize the image. All values in the ``list`` must be ``int`` s or ``float`` s (no mixture is possible). * If this is a ``StochasticParameter``, then this parameter will first be queried once per image. The resulting value will be used for both height and width. * If this is a ``dict``, it may contain the keys ``height`` and ``width`` or the keys ``shorter-side`` and ``longer-side``. Each key may have the same datatypes as above and describes the scaling on x and y-axis or the shorter and longer axis, respectively. Both axis are sampled independently. Additionally, one of the keys may have the value ``keep-aspect-ratio``, which means that the respective side of the image will be resized so that the original aspect ratio is kept. This is useful when only resizing one image size by a pixel value (e.g. resize images to a height of ``64`` pixels and resize the width so that the overall aspect ratio is maintained). interpolation : imgaug.ALL or int or str or list of int or list of str or imgaug.parameters.StochasticParameter, optional Interpolation to use. * If ``imgaug.ALL``, then a random interpolation from ``nearest``, ``linear``, ``area`` or ``cubic`` will be picked (per image). * If ``int``, then this interpolation will always be used. Expected to be any of the following: ``cv2.INTER_NEAREST``, ``cv2.INTER_LINEAR``, ``cv2.INTER_AREA``, ``cv2.INTER_CUBIC`` * If string, then this interpolation will always be used. Expected to be any of the following: ``nearest``, ``linear``, ``area``, ``cubic`` * If ``list`` of ``int`` / ``str``, then a random one of the values will be picked per image as the interpolation. * If a ``StochasticParameter``, then this parameter will be queried per image and is expected to return an ``int`` or ``str``. 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.Resize(32) Resize all images to ``32x32`` pixels. >>> aug = iaa.Resize(0.5) Resize all images to ``50`` percent of their original size. >>> aug = iaa.Resize((16, 22)) Resize all images to a random height and width within the discrete interval ``[16..22]`` (uniformly sampled per image). >>> aug = iaa.Resize((0.5, 0.75)) Resize all any input image so that its height (``H``) and width (``W``) become ``H*v`` and ``W*v``, where ``v`` is uniformly sampled from the interval ``[0.5, 0.75]``. >>> aug = iaa.Resize([16, 32, 64]) Resize all images either to ``16x16``, ``32x32`` or ``64x64`` pixels. >>> aug = iaa.Resize({"height": 32}) Resize all images to a height of ``32`` pixels and keeps the original width. >>> aug = iaa.Resize({"height": 32, "width": 48}) Resize all images to a height of ``32`` pixels and a width of ``48``. >>> aug = iaa.Resize({"height": 32, "width": "keep-aspect-ratio"}) Resize all images to a height of ``32`` pixels and resizes the x-axis (width) so that the aspect ratio is maintained. >>> aug = iaa.Resize( >>> {"shorter-side": 224, "longer-side": "keep-aspect-ratio"}) Resize all images to a height/width of ``224`` pixels, depending on which axis is shorter and resize the other axis so that the aspect ratio is maintained. >>> aug = iaa.Resize({"height": (0.5, 0.75), "width": [16, 32, 64]}) Resize all images to a height of ``H*v``, where ``H`` is the original height and ``v`` is a random value sampled from the interval ``[0.5, 0.75]``. The width/x-axis of each image is resized to either ``16`` or ``32`` or ``64`` pixels. >>> aug = iaa.Resize(32, interpolation=["linear", "cubic"]) Resize all images to ``32x32`` pixels. Randomly use either ``linear`` or ``cubic`` interpolation. cubicN deprecatedcs<tt|j||||d||d\|_|_|||_dS)Nseedr random_state deterministicF)superr__init___handle_size_argsize size_order_handle_interpolation_arg interpolation)selfrrrrrr __class__rrrs zResize.__init__c sZfdd}dd}d}|dkrtd}n t|r-|dks'Jd|ft|}n|st|trt|dkrBtd}n||d d gr[|d d}|d d}|||}n||d d grv|d d} |d d} || | }d }nt dt |ft|t rt|dksJdt|f|ddkr|ddksJd|d|dft |dst |drt |d|d}n^t|d|d}nSt|trt|dkrtd}nAtdd|D} tdd|D} | s| sJdtdd|Ds Jdt|}nt|tjr|}n t dt|f|r)|S||fS)Ncsdd}||kp ||k}|sJdg}||fD]}|dvr"t|}n|d}||qt|S)Nkeep-aspect-ratiozPExpected at least one value to not be "keep-aspect-ratio", but got it two times.)rkeepT)rgrkrrrI)Zval1Zval2ZkaaZ not_both_kaaZ size_tuplekentryclsrr_dict_to_size_tuples    z4Resize._handle_size_arg.._dict_to_size_tuplecstfdd|DS)Ncr_rr)rakeydict_rrrd rezFResize._handle_size_arg.._contains_any_key..)r)rkeysrrr_contains_any_key sz2Resize._handle_size_arg.._contains_any_keyZHWrrz Expected only values > 0, got %srrz shorter-sidez longer-sideSLzExpected dictionary containing no keys, the keys "height" and/or "width", or the keys "shorter-side" and/or "longer-side". Got keys: %s.rz8Expected size tuple to contain exactly 2 values, got %d.rz=Expected size tuple to only contain values >0, got %d and %d.cSg|]}t|qSrr#is_single_integerr`rrrrd9z+Resize._handle_size_arg..cSrr)r#is_single_floatr`rrrrd:rz(Expected to get only integers or floats.cSg|]}|dkqSrrr`rrrrd=rezExpected all values to be >0.a(Expected number, tuple of two numbers, list of numbers, dictionary of form {'height': number/tuple/list/'keep-aspect-ratio'/'keep', 'width': }, dictionary of form {'shorter-side': number/tuple/list/'keep-aspect-ratio'/'keep', 'longer-side': } or StochasticParameter, got %s.)rgrkr#r~r7dictrrr ValueErrorrmrIrrDiscreteUniformrHrlrhrnr8) rrZsubcallrrrrrrZshorterZlongerZall_intZ all_floatrrrrsz                  zResize._handle_size_argcCs|tjkrtgd}|St|rt|}|St|r&t|}|St|r2t|}|St|tj r; |St dt |f)N)nearestZlinearZarearzBExpected int or string or iterable or StochasticParameter, got %s.) r#rfrgrhrrkrirr7rnror8)rrrrrrQs,     z Resize._handle_interpolation_argc Cs|j}|||}|jdur||j||_|jdur$||jd||_|jdur<||jd|d|ddg|f|_dD]}t||}|dur]tj |j |d} | || } t ||| q>|S)Nr6rrrZ keypointsZbounding_boxesZpolygonsZ line_stringssamples) nb_rows _draw_samplesimages_augment_images_by_samplesheatmaps_augment_maps_by_samplessegmentation_mapsr9 functoolspartial_augment_keypoints_by_samples_apply_to_cbaois_as_keypointsr;) rbatchrparentshooksrr augm_name augm_valuefunccbaoisrrr_augment_batch_es4       zResize._augment_batch_cCsd}d}t|rd}|j}|\}}}g}t|D]%\} } || j|| || |j\} } tj| | | f|| d} || q|rUt dd|Ddk}|rUt j ||d}|S)NFTrcSh|]}|jqSrrraimagerrr z4Resize._augment_images_by_samples..rr) r# is_np_arrayr enumerate_compute_height_widthr rr$rrrQarray)rrrZinput_was_arrayZ input_dtype samples_a samples_b samples_iprirhwZimage_rsZ all_same_sizerrrrs(     z!Resize._augment_images_by_samplescCsg}|\}}}t|D]o\}} t| |} | j} | j} || |||||j\} }tt| | d| d}tt|| d| d}t|d}t|d}|ddurc| j ||f||d}n| ||f}| |f| dd|_| |q |S)Nrrrr) rr9r r rrPrQrRr r<r)r augmentablesr?rr samples_h samples_wr$r%r>rZ arr_shapeZ img_shapeZh_imgZw_imgr&r'Zaugmentable_resizerrrr s*       zResize._augment_maps_by_samplesc Csng}|\}}}t|D])\}}||j|||||j\} } | | f|jdd} || } || q |S)Nr)rr r rrCr) rkpsoisrrr"r#Z _samples_ipr%rDr&r'rJZkeypoints_on_image_rsrrrr s   z$Resize._augment_keypoints_by_samplescCs~|d}t|jtr$|jdj||dd}|jdj||dd}n |jj||dd}|}|jj||dd}|||fS)Nrrrrr) duplicater7rrI draw_samplesr)r nb_imagesrrngsr)r*r$rrrrs     zResize._draw_samplesc Cs.|dd\}}|dkr||kr||}}n ||}}n||}}t|rC|dks1Jd|ftt||}|dkr@|nd}n|dkrI|}t|rk|dksYJd|ftt||}|dkrh|nd}n|dkrq|}|dkr||} tt|| }|dkr||} tt|| }||fS) NrrrzExpected 'h' to be >0, got %.4frrzExpected 'w' to be >0, got %.4fr)r#rrPrQrR) rZ image_shapeZsample_aZsample_brZimhZimwr&r'Z h_per_w_origZ w_per_h_origrrrr s2     zResize._compute_height_widthcC|j|j|jgS=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.)rrrrrrrget_parameterszResize.get_parameters)rNNrr)__name__ __module__ __qualname____doc__r classmethodrrrrr r rr r5 __classcell__rrrrrfs&  V    &c@s,eZdZddZeddZeddZdS)_CropAndPadSamplingResultc Cs@||_||_||_||_||_||_||_||_| |_| |_ dSr. rFrLrMrErrrrr'r() rrFrLrMrErrrrr'r(rrrrs z"_CropAndPadSamplingResult.__init__cC|j|j|j|jfS)z8Get absolute pixel amounts of croppings as a TRBL tuple.)rFrLrMrEr4rrrr%z#_CropAndPadSamplingResult.croppingscCr?)z7Get absolute pixel amounts of paddings as a TRBL tuple.)rrrrr4rrrr&r@z"_CropAndPadSamplingResult.paddingsN)r7r8r9rpropertyr%r&rrrrr=s  r=cs~eZdZdZ    dfdd Zed d Zed d Zed dZddZ ddZ ddZ ddZ ddZ ddZZS) CropAndPada-Crop/pad images by pixel amounts or fractions of image sizes. Cropping removes pixels at the sides (i.e. extracts a subimage from a given full image). Padding adds pixels to the sides (e.g. black pixels). This augmenter will never crop images below a height or width of ``1``. .. note:: This augmenter automatically resizes images back to their original size after it has augmented them. To deactivate this, add the parameter ``keep_size=False``. **Supported dtypes**: if (keep_size=False): * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: yes; tested * ``uint64``: yes; tested * ``int8``: yes; tested * ``int16``: yes; tested * ``int32``: yes; tested * ``int64``: yes; tested * ``float16``: yes; tested * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: yes; tested * ``bool``: yes; tested if (keep_size=True): minimum of ( ``imgaug.augmenters.size.CropAndPad(keep_size=False)``, :func:`~imgaug.imgaug.imresize_many_images` ) Parameters ---------- px : None or int or imgaug.parameters.StochasticParameter or tuple, optional The number of pixels to crop (negative values) or pad (positive values) on each side of the image. Either this or the parameter `percent` may be set, not both at the same time. * If ``None``, then pixel-based cropping/padding will not be used. * If ``int``, then that exact number of pixels will always be cropped/padded. * If ``StochasticParameter``, then that parameter will be used for each image. Four samples will be drawn per image (top, right, bottom, left), unless `sample_independently` is set to ``False``, as then only one value will be sampled per image and used for all sides. * If a ``tuple`` of two ``int`` s with values ``a`` and ``b``, then each side will be cropped/padded by a random amount sampled uniformly per image and side from the inteval ``[a, b]``. If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of four entries, then the entries represent top, right, bottom, left. Each entry may be a single ``int`` (always crop/pad by exactly that value), a ``tuple`` of two ``int`` s ``a`` and ``b`` (crop/pad by an amount within ``[a, b]``), a ``list`` of ``int`` s (crop/pad by a random value that is contained in the ``list``) or a ``StochasticParameter`` (sample the amount to crop/pad from that parameter). percent : None or number or imgaug.parameters.StochasticParameter or tuple, optional The number of pixels to crop (negative values) or pad (positive values) on each side of the image given as a *fraction* of the image height/width. E.g. if this is set to ``-0.1``, the augmenter will always crop away ``10%`` of the image's height at both the top and the bottom (both ``10%`` each), as well as ``10%`` of the width at the right and left. Expected value range is ``(-1.0, inf)``. Either this or the parameter `px` may be set, not both at the same time. * If ``None``, then fraction-based cropping/padding will not be used. * If ``number``, then that fraction will always be cropped/padded. * If ``StochasticParameter``, then that parameter will be used for each image. Four samples will be drawn per image (top, right, bottom, left). If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of two ``float`` s with values ``a`` and ``b``, then each side will be cropped/padded by a random fraction sampled uniformly per image and side from the interval ``[a, b]``. If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of four entries, then the entries represent top, right, bottom, left. Each entry may be a single ``float`` (always crop/pad by exactly that percent value), a ``tuple`` of two ``float`` s ``a`` and ``b`` (crop/pad by a fraction from ``[a, b]``), a ``list`` of ``float`` s (crop/pad by a random value that is contained in the list) or a ``StochasticParameter`` (sample the percentage to crop/pad from that parameter). pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional Padding mode to use. The available modes match the numpy padding modes, i.e. ``constant``, ``edge``, ``linear_ramp``, ``maximum``, ``median``, ``minimum``, ``reflect``, ``symmetric``, ``wrap``. The modes ``constant`` and ``linear_ramp`` use extra values, which are provided by ``pad_cval`` when necessary. See :func:`~imgaug.imgaug.pad` for more details. * If ``imgaug.ALL``, then a random mode from all available modes will be sampled per image. * If a ``str``, it will be used as the pad mode for all images. * If a ``list`` of ``str``, a random one of these will be sampled per image and used as the mode. * If ``StochasticParameter``, a random mode will be sampled from this parameter per image. pad_cval : number or tuple of number list of number or imgaug.parameters.StochasticParameter, optional The constant value to use if the pad mode is ``constant`` or the end value to use if the mode is ``linear_ramp``. See :func:`~imgaug.imgaug.pad` for more details. * If ``number``, then that value will be used. * If a ``tuple`` of two ``number`` s and at least one of them is a ``float``, then a random number will be uniformly sampled per image from the continuous interval ``[a, b]`` and used as the value. If both ``number`` s are ``int`` s, the interval is discrete. * If a ``list`` of ``number``, then a random value will be chosen from the elements of the ``list`` and used as the value. * If ``StochasticParameter``, a random value will be sampled from that parameter per image. keep_size : bool, optional After cropping and padding, the result image will usually have a different height/width compared to the original input image. If this parameter is set to ``True``, then the cropped/padded image will be resized to the input image's size, i.e. the augmenter's output shape is always identical to the input shape. sample_independently : bool, optional If ``False`` *and* the values for `px`/`percent` result in exactly *one* probability distribution for all image sides, only one single value will be sampled from that probability distribution and used for all sides. I.e. the crop/pad amount then is the same for all sides. If ``True``, four values will be sampled independently, one per side. 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.CropAndPad(px=(-10, 0)) Crop each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[-10..0]``. >>> aug = iaa.CropAndPad(px=(0, 10)) Pad each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. The padding happens by zero-padding, i.e. it adds black pixels (default setting). >>> aug = iaa.CropAndPad(px=(0, 10), pad_mode="edge") Pad each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. The padding uses the ``edge`` mode from numpy's pad function, i.e. the pixel colors around the image sides are repeated. >>> aug = iaa.CropAndPad(px=(0, 10), pad_mode=["constant", "edge"]) Similar to the previous example, but uses zero-padding (``constant``) for half of the images and ``edge`` padding for the other half. >>> aug = iaa.CropAndPad(px=(0, 10), pad_mode=ia.ALL, pad_cval=(0, 255)) Similar to the previous example, but uses any available padding mode. In case the padding mode ends up being ``constant`` or ``linear_ramp``, and random intensity is uniformly sampled (once per image) from the discrete interval ``[0..255]`` and used as the intensity of the new pixels. >>> aug = iaa.CropAndPad(px=(0, 10), sample_independently=False) Pad each side by a random pixel value sampled uniformly once per image from the discrete interval ``[0..10]``. Each sampled value is used for *all* sides of the corresponding image. >>> aug = iaa.CropAndPad(px=(0, 10), keep_size=False) Pad each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. Afterwards, do **not** resize the padded image back to the input image's size. This will increase the image's height and width by a maximum of ``20`` pixels. >>> aug = iaa.CropAndPad(px=((0, 10), (0, 5), (0, 10), (0, 5))) Pad the top and bottom by a random pixel value sampled uniformly from the discrete interval ``[0..10]``. Pad the left and right analogously by a random value sampled from ``[0..5]``. Each value is always sampled independently. >>> aug = iaa.CropAndPad(percent=(0, 0.1)) Pad each side by a random fraction sampled uniformly from the continuous interval ``[0.0, 0.10]``. The fraction is sampled once per image and side. E.g. a sampled fraction of ``0.1`` for the top side would pad by ``0.1*H``, where ``H`` is the height of the input image. >>> aug = iaa.CropAndPad( >>> percent=([0.05, 0.1], [0.05, 0.1], [0.05, 0.1], [0.05, 0.1])) Pads each side by either ``5%`` or ``10%``. The values are sampled once per side and image. >>> aug = iaa.CropAndPad(px=(-10, 10)) Sample uniformly per image and side a value ``v`` from the discrete range ``[-10..10]``. Then either crop (negative sample) or pad (positive sample) the side by ``v`` pixels. NrrTrc stt|j||| | d|dur|durd}|||\|_|_|_|_|_|_ t ||_ t j |dddddd|_||_||_d|_d|_d|_d|_dS) Nr)g皙?r(TZ value_rangeZtuple_to_uniformZlist_to_choiceZ allow_floatsrr,r)rrBr_handle_px_and_percent_argsr all_sidesr rrrrpr'rghandle_discrete_paramr(r)sample_independently_pad_mode_heatmaps_pad_mode_segmentation_maps_pad_cval_heatmaps_pad_cval_segmentation_maps rpxpercentr'r(r)rHrrrrrrrrs(    zCropAndPad.__init__c Csd}d\}}}}|dur|durd}n)|dur|durtd|dur0d}||\}}}}}n d}||\}}}}}||||||fS)NNNNNnoopz,Can only pad by pixels or percent, not both.rNrO)ro_handle_px_arg_handle_percent_arg) rrNrOrFr rrrr rrrrE&s z&CropAndPad._handle_px_and_percent_argscCsd}d\}}}}t|rt|}nTt|trOt|dvs'Jdt|fdd}t|dkr6||}n1||d}||d}||d}||d }nt|tjr^|}}}}n td t |f|||||fS) NrPrrzAExpected 'px' given as a tuple to contain 2 or 4 entries, got %d.cSst|r t|St|trGt|dksJdt|t|do*t|d}|s=Jdt|dt|dft|d|dSt|t rrt|dksVJdt dd|DsmJd d d d|Dt |St|tj rz|Std t|f) Nr#Expected tuple of 2 values, got %d.rrz*Expected tuple of integers, got %s and %s.+Expected non-empty list, but got empty one.cSrrrravalrrrrdVrzCCropAndPad._handle_px_arg..handle_param..z$Expected list of ints, got types %s.r^cSg|]}tt|qSrrmr8r`rrrrdXRExpected int, tuple of two ints, list of ints or StochasticParameter, got type %s.)r#rrgrkr7rIrr8rrHrlrjrhrnro)pZ only_intsrrr handle_paramFs@        z/CropAndPad._handle_px_arg..handle_paramrrrrzdExpected int, tuple of 4 ints/tuples/lists/StochasticParameters or StochasticParameter, got type %s.) r#rrgrkr7rIrrnror8)rrNrFr rrrr^rrrrR9s2          zCropAndPad._handle_px_argcCsd}d\}}}}t|r|dksJd|ft|}nTt|trZt|dvs2Jdt|fdd}t|dkrA||}n1||d }||d }||d}||d }nt|tjri|}}}}n td t |f|||||fS) NrPz)Expected 'percent' to be >-1.0, got %.4f.rTzFExpected 'percent' given as a tuple to contain 2 or 4 entries, got %d.cSsft|r t|St|tr`t|dksJdt|ft|do+t|d}|s>Jdt|dt|df|ddkrJ|ddksVJd|d|dft|d|dSt|t rt|dksoJdt d d |DsJd d d d |Dt dd |DsJdd dd |Dt |St|tj r|Stdt|f)NrrUrrz)Expected tuple of numbers, got %s and %s.r_z2Expected tuple of values >-1.0, got %.4f and %.4f.rVcSrr)r#r~rWrrrrdrzHCropAndPad._handle_percent_arg..handle_param..z'Expected list of numbers, got types %s.r^cSrYrrZr`rrrrdr[cSr)r_rrWrrrrdrez-Expected list of values >-1.0, got values %s.cSsg|]}d|fqS)z%.4frr`rrrrdrr\)r#r~rgrkr7rIrr8rrHrlrjrhrnro)r]Z only_numbersrrrr^~sT        z4CropAndPad._handle_percent_arg..handle_paramrrrrzjExpected number, tuple of 4 numbers/tuples/lists/StochasticParameters or StochasticParameter, got type %s.) r#r~rgrkr7rIrrnror8)rrOrFr rrrr^rrrrSps8          zCropAndPad._handle_percent_argc Cs|}|||}|jdur||j||_|jdur(||j|j|j||_|jdur9||j|j |j ||_dD]}t ||}|durZt j |j|d} ||| } t||| q;|SNrr)get_rowwise_shapesrrrrr rIrKr rJrLr9r r r rr;) rrrrrshapesrrrrrrrrrs:       zCropAndPad._augment_batch_c Csg}t|D]\}}||}t||j|j|j|j|j}||qt |rI|jr4t j ||j d}|St dd|D}|dkrIt j ||j d}|S)NrcSrrrrrrrrrz8CropAndPad._augment_images_by_samples..r)rr+r%r&r'r(r)rr#rrQr!rr) rrrrr%r samples_ir* nb_shapesrrrrs     z%CropAndPad._augment_images_by_samplesc Csbg}t|D](\}}||}t||j|j|dur|n|j|dur"|n|j|jd}||q|S)N)r1r2r'r(r))rr0r%r&r'r(r)r) rr(r'r(rrr%r>Z samples_imgrrrr s" z#CropAndPad._augment_maps_by_samplescCsBg}t|D]\}}||}t||j|j|jd}||q|S)N)r1r2r))rrGr%r&r)r)rkeypoints_on_imagesrrr%Zkeypoints_on_imagerc kpsoi_augrrrr s z(CropAndPad._augment_keypoints_by_samplesc#Cs8t|}|jdkrtj|fdtjd}}}}n|jdur_|jrM|jj|df|d}|dddf}|dddf}|dddf}|dddf}n6|jj|f|d} | }}}}n$|jj|f|d}|j j|f|d}|j j|f|d}|j j|f|d}|jd krnS|jd krtj d d |Dtj d} | dddf} | dddf} t| |tj}t| |tj}t| |tj}t| |tj}ntd dd} | d|}| d|}| d|}| d|}| |}| |}| |}| |}|jj|f|d}|jj|f|d}g}t|D]y\}}|dd\}}t||||||||||\}}}} |dkpI|dk}!|!r^|||kr^td|||f| dkpf|dk}"|"r{| ||kr{td| ||f|t|||| ||||||||||||d q |S)NrQrrrr,rrrrNrOcSsg|]}|ddqS)rrr)rar rrrrd,r[z,CropAndPad._draw_samples..z Invalid modecSst|}|dk}d||<|SNr)rQr)rmaskrrr_only_above_zero7s z2CropAndPad._draw_samples.._only_above_zeroraExpected generated crop amounts in CropAndPad for top and bottom image side to be less than the image's height, but got %d (top) and %d (bottom) vs. image height %d. This will result in an image with output height=1 (if input height was >=1) or output height=0 (if input height was 0).aExpected generated crop amounts in CropAndPad for left and right image side to be less than the image's width, but got %d (left) and %d (right) vs. image width %d. This will result in an image with output width=1 (if input width was >=1) or output width=0 (if input width was 0).r>)rr rQfullZint32rFrHr.r rrrr!Zfloat32rRZastyperor'r(rr r#warnrr=)#rrrbrr rrrrsampleZ shapes_arrZheightswidthsrirFrLrMrErrrrr'r(rr%r rrZ crop_top_iZ crop_right_iZ crop_bottom_iZ crop_left_iZ any_crop_yZ any_crop_xrrrr s              zCropAndPad._draw_samplescCs |j|j|j|j|j|j|jgSr2)rFr rrrr'r(r4rrrr5{szCropAndPad.get_parameters NNrrTTNNrr)r7r8r9r:rr;rErRrSrrr r rr5r<rrrrrBs(n  6 >! qrBcs*eZdZdZ    d fdd ZZS) Pada&Pad images, i.e. adds columns/rows of pixels to them. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropAndPad`. Parameters ---------- px : None or int or imgaug.parameters.StochasticParameter or tuple, optional The number of pixels to pad on each side of the image. Expected value range is ``[0, inf)``. Either this or the parameter `percent` may be set, not both at the same time. * If ``None``, then pixel-based padding will not be used. * If ``int``, then that exact number of pixels will always be padded. * If ``StochasticParameter``, then that parameter will be used for each image. Four samples will be drawn per image (top, right, bottom, left), unless `sample_independently` is set to ``False``, as then only one value will be sampled per image and used for all sides. * If a ``tuple`` of two ``int`` s with values ``a`` and ``b``, then each side will be padded by a random amount sampled uniformly per image and side from the inteval ``[a, b]``. If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of four entries, then the entries represent top, right, bottom, left. Each entry may be a single ``int`` (always pad by exactly that value), a ``tuple`` of two ``int`` s ``a`` and ``b`` (pad by an amount within ``[a, b]``), a ``list`` of ``int`` s (pad by a random value that is contained in the ``list``) or a ``StochasticParameter`` (sample the amount to pad from that parameter). percent : None or int or float or imgaug.parameters.StochasticParameter or tuple, optional The number of pixels to pad on each side of the image given as a *fraction* of the image height/width. E.g. if this is set to ``0.1``, the augmenter will always pad ``10%`` of the image's height at both the top and the bottom (both ``10%`` each), as well as ``10%`` of the width at the right and left. Expected value range is ``[0.0, inf)``. Either this or the parameter `px` may be set, not both at the same time. * If ``None``, then fraction-based padding will not be used. * If ``number``, then that fraction will always be padded. * If ``StochasticParameter``, then that parameter will be used for each image. Four samples will be drawn per image (top, right, bottom, left). If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of two ``float`` s with values ``a`` and ``b``, then each side will be padded by a random fraction sampled uniformly per image and side from the interval ``[a, b]``. If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of four entries, then the entries represent top, right, bottom, left. Each entry may be a single ``float`` (always pad by exactly that fraction), a ``tuple`` of two ``float`` s ``a`` and ``b`` (pad by a fraction from ``[a, b]``), a ``list`` of ``float`` s (pad by a random value that is contained in the list) or a ``StochasticParameter`` (sample the percentage to pad from that parameter). pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional Padding mode to use. The available modes match the numpy padding modes, i.e. ``constant``, ``edge``, ``linear_ramp``, ``maximum``, ``median``, ``minimum``, ``reflect``, ``symmetric``, ``wrap``. The modes ``constant`` and ``linear_ramp`` use extra values, which are provided by ``pad_cval`` when necessary. See :func:`~imgaug.imgaug.pad` for more details. * If ``imgaug.ALL``, then a random mode from all available modes will be sampled per image. * If a ``str``, it will be used as the pad mode for all images. * If a ``list`` of ``str``, a random one of these will be sampled per image and used as the mode. * If ``StochasticParameter``, a random mode will be sampled from this parameter per image. pad_cval : number or tuple of number list of number or imgaug.parameters.StochasticParameter, optional The constant value to use if the pad mode is ``constant`` or the end value to use if the mode is ``linear_ramp``. See :func:`~imgaug.imgaug.pad` for more details. * If ``number``, then that value will be used. * If a ``tuple`` of two ``number`` s and at least one of them is a ``float``, then a random number will be uniformly sampled per image from the continuous interval ``[a, b]`` and used as the value. If both ``number`` s are ``int`` s, the interval is discrete. * If a ``list`` of ``number``, then a random value will be chosen from the elements of the ``list`` and used as the value. * If ``StochasticParameter``, a random value will be sampled from that parameter per image. keep_size : bool, optional After padding, the result image will usually have a different height/width compared to the original input image. If this parameter is set to ``True``, then the padded image will be resized to the input image's size, i.e. the augmenter's output shape is always identical to the input shape. sample_independently : bool, optional If ``False`` *and* the values for `px`/`percent` result in exactly *one* probability distribution for all image sides, only one single value will be sampled from that probability distribution and used for all sides. I.e. the pad amount then is the same for all sides. If ``True``, four values will be sampled independently, one per side. 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.Pad(px=(0, 10)) Pad each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. The padding happens by zero-padding, i.e. it adds black pixels (default setting). >>> aug = iaa.Pad(px=(0, 10), pad_mode="edge") Pad each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. The padding uses the ``edge`` mode from numpy's pad function, i.e. the pixel colors around the image sides are repeated. >>> aug = iaa.Pad(px=(0, 10), pad_mode=["constant", "edge"]) Similar to the previous example, but uses zero-padding (``constant``) for half of the images and ``edge`` padding for the other half. >>> aug = iaa.Pad(px=(0, 10), pad_mode=ia.ALL, pad_cval=(0, 255)) Similar to the previous example, but uses any available padding mode. In case the padding mode ends up being ``constant`` or ``linear_ramp``, and random intensity is uniformly sampled (once per image) from the discrete interval ``[0..255]`` and used as the intensity of the new pixels. >>> aug = iaa.Pad(px=(0, 10), sample_independently=False) Pad each side by a random pixel value sampled uniformly once per image from the discrete interval ``[0..10]``. Each sampled value is used for *all* sides of the corresponding image. >>> aug = iaa.Pad(px=(0, 10), keep_size=False) Pad each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. Afterwards, do **not** resize the padded image back to the input image's size. This will increase the image's height and width by a maximum of ``20`` pixels. >>> aug = iaa.Pad(px=((0, 10), (0, 5), (0, 10), (0, 5))) Pad the top and bottom by a random pixel value sampled uniformly from the discrete interval ``[0..10]``. Pad the left and right analogously by a random value sampled from ``[0..5]``. Each value is always sampled independently. >>> aug = iaa.Pad(percent=(0, 0.1)) Pad each side by a random fraction sampled uniformly from the continuous interval ``[0.0, 0.10]``. The fraction is sampled once per image and side. E.g. a sampled fraction of ``0.1`` for the top side would pad by ``0.1*H``, where ``H`` is the height of the input image. >>> aug = iaa.Pad( >>> percent=([0.05, 0.1], [0.05, 0.1], [0.05, 0.1], [0.05, 0.1])) Pads each side by either ``5%`` or ``10%``. The values are sampled once per side and image. NrrTrc sXfdd|dur|durd}|}|}tt|j||||||||| | d dS)Ncs|dur|St|r|dksJd|f|St|tjr |St|tr0tfdd|DSt|tr>fdd|DStdt|f)NrzExpected value >0, got %.4fcg|]}|qSrrraZv_recursive_validaterrrdR rez.recursive_validate..crprrrqrrrrrdT reNExpected None or int or float or StochasticParameter or list or tuple, got %s.) r#r~r7rgrnrIrHror8rSrrrrrsI s     z(Pad.__init__..recursive_validater,rC) rNrOr'r(r)rHrrrr)rrorrMrrrrrE s   z Pad.__init__rnr7r8r9r:rr<rrrrrosDrocs*eZdZdZ    dfdd ZZS)CropaCrop images, i.e. remove columns/rows of pixels at the sides of images. This augmenter allows to extract smaller-sized subimages from given full-sized input images. The number of pixels to cut off may be defined in absolute values or as fractions of the image sizes. This augmenter will never crop images below a height or width of ``1``. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropAndPad`. Parameters ---------- px : None or int or imgaug.parameters.StochasticParameter or tuple, optional The number of pixels to crop on each side of the image. Expected value range is ``[0, inf)``. Either this or the parameter `percent` may be set, not both at the same time. * If ``None``, then pixel-based cropping will not be used. * If ``int``, then that exact number of pixels will always be cropped. * If ``StochasticParameter``, then that parameter will be used for each image. Four samples will be drawn per image (top, right, bottom, left), unless `sample_independently` is set to ``False``, as then only one value will be sampled per image and used for all sides. * If a ``tuple`` of two ``int`` s with values ``a`` and ``b``, then each side will be cropped by a random amount sampled uniformly per image and side from the inteval ``[a, b]``. If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of four entries, then the entries represent top, right, bottom, left. Each entry may be a single ``int`` (always crop by exactly that value), a ``tuple`` of two ``int`` s ``a`` and ``b`` (crop by an amount within ``[a, b]``), a ``list`` of ``int`` s (crop by a random value that is contained in the ``list``) or a ``StochasticParameter`` (sample the amount to crop from that parameter). percent : None or int or float or imgaug.parameters.StochasticParameter or tuple, optional The number of pixels to crop on each side of the image given as a *fraction* of the image height/width. E.g. if this is set to ``0.1``, the augmenter will always crop ``10%`` of the image's height at both the top and the bottom (both ``10%`` each), as well as ``10%`` of the width at the right and left. Expected value range is ``[0.0, 1.0)``. Either this or the parameter `px` may be set, not both at the same time. * If ``None``, then fraction-based cropping will not be used. * If ``number``, then that fraction will always be cropped. * If ``StochasticParameter``, then that parameter will be used for each image. Four samples will be drawn per image (top, right, bottom, left). If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of two ``float`` s with values ``a`` and ``b``, then each side will be cropped by a random fraction sampled uniformly per image and side from the interval ``[a, b]``. If however `sample_independently` is set to ``False``, only one value will be sampled per image and used for all sides. * If a ``tuple`` of four entries, then the entries represent top, right, bottom, left. Each entry may be a single ``float`` (always crop by exactly that fraction), a ``tuple`` of two ``float`` s ``a`` and ``b`` (crop by a fraction from ``[a, b]``), a ``list`` of ``float`` s (crop by a random value that is contained in the list) or a ``StochasticParameter`` (sample the percentage to crop from that parameter). keep_size : bool, optional After cropping, the result image will usually have a different height/width compared to the original input image. If this parameter is set to ``True``, then the cropped image will be resized to the input image's size, i.e. the augmenter's output shape is always identical to the input shape. sample_independently : bool, optional If ``False`` *and* the values for `px`/`percent` result in exactly *one* probability distribution for all image sides, only one single value will be sampled from that probability distribution and used for all sides. I.e. the crop amount then is the same for all sides. If ``True``, four values will be sampled independently, one per side. 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.Crop(px=(0, 10)) Crop each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. >>> aug = iaa.Crop(px=(0, 10), sample_independently=False) Crop each side by a random pixel value sampled uniformly once per image from the discrete interval ``[0..10]``. Each sampled value is used for *all* sides of the corresponding image. >>> aug = iaa.Crop(px=(0, 10), keep_size=False) Crop each side by a random pixel value sampled uniformly per image and side from the discrete interval ``[0..10]``. Afterwards, do **not** resize the cropped image back to the input image's size. This will decrease the image's height and width by a maximum of ``20`` pixels. >>> aug = iaa.Crop(px=((0, 10), (0, 5), (0, 10), (0, 5))) Crop the top and bottom by a random pixel value sampled uniformly from the discrete interval ``[0..10]``. Crop the left and right analogously by a random value sampled from ``[0..5]``. Each value is always sampled independently. >>> aug = iaa.Crop(percent=(0, 0.1)) Crop each side by a random fraction sampled uniformly from the continuous interval ``[0.0, 0.10]``. The fraction is sampled once per image and side. E.g. a sampled fraction of ``0.1`` for the top side would crop by ``0.1*H``, where ``H`` is the height of the input image. >>> aug = iaa.Crop( >>> percent=([0.05, 0.1], [0.05, 0.1], [0.05, 0.1], [0.05, 0.1])) Crops each side by either ``5%`` or ``10%``. The values are sampled once per side and image. NTrc sTfdd|dur|durd}|}|}tt|j||||||||ddS)Ncs|dur|St|r|dksJd|f| St|tjr%t|dSt|tr5tfdd|DSt|trCfdd|DStdt |f)NrzExpected value >0, got %.4f.rcrprrrqrecursive_negaterrrd rez;Crop.__init__..recursive_negate..crprrrqrxrrrd rert) r#r~r7rgrnZMultiplyrIrHror8rSrxrrry s      z'Crop.__init__..recursive_negateru)rNrOr)rHrrrr)rrwr) rrNrOr)rHrrrrrrxrr s   z Crop.__init__)NNTTNNrrrvrrrrrwj srwcsfeZdZdZ    dfdd Zd d Zd d Zd dZddZddZ e ddZ ddZ Z S)PadToFixedSizeavPad images to a predefined minimum width and/or height. If images are already at the minimum width/height or are larger, they will not be padded. Note that this also means that images will not be cropped if they exceed the required width/height. The augmenter randomly decides per image how to distribute the required padding amounts over the image axis. E.g. if 2px have to be padded on the left or right to reach the required width, the augmenter will sometimes add 2px to the left and 0px to the right, sometimes add 2px to the right and 0px to the left and sometimes add 1px to both sides. Set `position` to ``center`` to prevent that. **Supported dtypes**: See :func:`~imgaug.augmenters.size.pad`. Parameters ---------- width : int or None Pad images up to this minimum width. If ``None``, image widths will not be altered. height : int or None Pad images up to this minimum height. If ``None``, image heights will not be altered. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.CropAndPad.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.CropAndPad.__init__`. position : {'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 Sets the center point of the padding, which determines how the required padding amounts are distributed to each side. For a ``tuple`` ``(a, b)``, both ``a`` and ``b`` are expected to be in range ``[0.0, 1.0]`` and describe the fraction of padding applied to the left/right (low/high values for ``a``) and the fraction of padding applied to the top/bottom (low/high values for ``b``). A padding position at ``(0.5, 0.5)`` would be the center of the image and distribute the padding equally to all sides. A padding position at ``(0.0, 1.0)`` would be the left-bottom and would apply 100% of the required padding to the bottom and left sides of the image so that the bottom left corner becomes more and more the new image center (depending on how much is padded). * If string ``uniform`` then the share of padding is randomly and uniformly distributed over each side. Equivalent to ``(Uniform(0.0, 1.0), Uniform(0.0, 1.0))``. * If string ``normal`` then the share of padding is distributed based on a normal distribution, leading to a focus on the center of the images. Equivalent to ``(Clip(Normal(0.5, 0.45/2), 0, 1), Clip(Normal(0.5, 0.45/2), 0, 1))``. * If string ``center`` then center point of the padding is identical to the image center. Equivalent to ``(0.5, 0.5)``. * If a string matching regex ``^(left|center|right)-(top|center|bottom)$``, e.g. ``left-top`` or ``center-bottom`` then sets the center point of the padding to the X-Y position matching that description. * If a tuple of float, then expected to have exactly two entries between ``0.0`` and ``1.0``, which will always be used as the combination the position matching (x, y) form. * If a ``StochasticParameter``, then that parameter will be queried once per call to ``augment_*()`` to get ``Nx2`` center positions in ``(x, y)`` form (with ``N`` the number of images). * If a ``tuple`` of ``StochasticParameter``, then expected to have exactly two entries that will both be queried per call to ``augment_*()``, each for ``(N,)`` values, to get the center positions. First parameter is used for ``x`` coordinates, second for ``y`` coordinates. 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.PadToFixedSize(width=100, height=100) For image sides smaller than ``100`` pixels, pad to ``100`` pixels. Do nothing for the other edges. The padding is randomly (uniformly) distributed over the sides, so that e.g. sometimes most of the required padding is applied to the left, sometimes to the right (analogous top/bottom). >>> aug = iaa.PadToFixedSize(width=100, height=100, position="center") For image sides smaller than ``100`` pixels, pad to ``100`` pixels. Do nothing for the other image sides. The padding is always equally distributed over the left/right and top/bottom sides. >>> aug = iaa.PadToFixedSize(width=100, height=100, pad_mode=ia.ALL) For image sides smaller than ``100`` pixels, pad to ``100`` pixels and use any possible padding mode for that. Do nothing for the other image sides. The padding is always equally distributed over the left/right and top/bottom sides. >>> aug = iaa.Sequential([ >>> iaa.PadToFixedSize(width=100, height=100), >>> iaa.CropToFixedSize(width=100, height=100) >>> ]) Pad images smaller than ``100x100`` until they reach ``100x100``. Analogously, crop images larger than ``100x100`` until they reach ``100x100``. The output images therefore have a fixed size of ``100x100``. rrrqNrc sjtt|j|||| d||f|_t||_t||_tj |dddddd|_ d|_ d|_ d|_ d|_dS)Nrr(TrDrr,r)rrzrrrrrpr'rgrGr(rIrJrKrL) rrrr'r(rrrrrrrrr s    zPadToFixedSize.__init__c Cs|||}|jdur||j||_|jdur$||j||j|j|_|jdur5||j||j|j|_dD]}t||}|durVt j |j |d}| ||} t ||| q7|Sr`)rrrrr rIrKr r9r r r rr; rrrrrrrrrrrrrr s4         zPadToFixedSize._augment_batch_c Csg}|\}}}}}tt||D]4\} \} } | \} } | jdd\}}|||| | || || }t| d||| || dd} || q|SNrrrrrFr))rzipr _calculate_paddingsr+r)rrrrsizespad_xspad_ys pad_modes pad_cvalsr%rr width_min height_min height_image width_imager&rrrr s  z)PadToFixedSize._augment_images_by_samplesc Csg}|\}}}}}tt||D].\}\} } | \} } | jdd\} }|| || | ||||}t| d|dd}||q|Sr|)rrr rrGr)rrerrrrrrr%rDrrrrrr2Zkeypoints_paddedrrrr  s  z,PadToFixedSize._augment_keypoints_by_samplesc Cs|\}}}}} tt||D]?\} \} } | \} }| jdd\}}||||| || || }t|| d||dur;|n|| |durD|n| | dd|| <q|S)Nrr}F)r'r(r))rrr rr0)rr(rr'r(rrrrrr%r>rrrZ height_imgZ width_imgr2rrrr  s"   z'PadToFixedSize._augment_maps_by_samplesc Cs|j}|d}t|jtr'|jdj||dd}|jdj||dd}n|jj|df|dd}|dddf}|dddf}|jj||dd}|jj||dd} |jg||||| fS)Nrrr,rrr) rr-r7rrIr.r'r(r) rrrr/r0rrZpadsrrrrrr. s*     zPadToFixedSize._draw_samplesc Cs|d}d}d} d} |dur ||kr ||} td|| } | | }|dur8||kr8||} td|| }| |} ||| | fS)NrrrP) rrrrrZpad_xs_iZpad_ys_irrrrZ pad_total_xZ pad_total_yrrrrF s z"PadToFixedSize._calculate_paddingscCs |jd|jd|j|j|jgSr3rr)rr'r(rr4rrrr5Z szPadToFixedSize.get_parametersrrrqNNrr)r7r8r9r:rrrr r rr;rr5r<rrrrrz' s " rzc(eZdZdZ   dfdd ZZS) CenterPadToFixedSizea,Pad images equally on all sides up to given minimum heights/widths. This is an alias for :class:`~imgaug.augmenters.size.PadToFixedSize` with ``position="center"``. It spreads the pad amounts equally over all image sides, while :class:`~imgaug.augmenters.size.PadToFixedSize` by defaults spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- width : int or None See :func:`PadToFixedSize.__init__`. height : int or None See :func:`PadToFixedSize.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`PadToFixedSize.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`PadToFixedSize.__init__`. 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.CenterPadToFixedSize(height=20, width=30) Create an augmenter that pads images up to ``20x30``, with the padded rows added *equally* on the top and bottom (analogous for the padded columns). rrNrc &tt|j||||d||||d dS)Nrx rrr'r(rrrrr)rrr) rrrr'r(rrrrrrrr s  zCenterPadToFixedSize.__init__rrNNrrrvrrrrr` s 8rcsdeZdZdZ   dfdd ZddZd d Zd d Zd dZe ddZ ddZ ddZ Z S)CropToFixedSizeaCrop images down to a predefined maximum width and/or height. If images are already at the maximum width/height or are smaller, they will not be cropped. Note that this also means that images will not be padded if they are below the required width/height. The augmenter randomly decides per image how to distribute the required cropping amounts over the image axis. E.g. if 2px have to be cropped on the left or right to reach the required width, the augmenter will sometimes remove 2px from the left and 0px from the right, sometimes remove 2px from the right and 0px from the left and sometimes remove 1px from both sides. Set `position` to ``center`` to prevent that. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: yes; tested * ``uint64``: yes; tested * ``int8``: yes; tested * ``int16``: yes; tested * ``int32``: yes; tested * ``int64``: yes; tested * ``float16``: yes; tested * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: yes; tested * ``bool``: yes; tested Parameters ---------- width : int or None Crop images down to this maximum width. If ``None``, image widths will not be altered. height : int or None Crop images down to this maximum height. If ``None``, image heights will not be altered. position : {'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 Sets the center point of the cropping, which determines how the required cropping amounts are distributed to each side. For a ``tuple`` ``(a, b)``, both ``a`` and ``b`` are expected to be in range ``[0.0, 1.0]`` and describe the fraction of cropping applied to the left/right (low/high values for ``a``) and the fraction of cropping applied to the top/bottom (low/high values for ``b``). A cropping position at ``(0.5, 0.5)`` would be the center of the image and distribute the cropping equally over all sides. A cropping position at ``(1.0, 0.0)`` would be the right-top and would apply 100% of the required cropping to the right and top sides of the image. * If string ``uniform`` then the share of cropping is randomly and uniformly distributed over each side. Equivalent to ``(Uniform(0.0, 1.0), Uniform(0.0, 1.0))``. * If string ``normal`` then the share of cropping is distributed based on a normal distribution, leading to a focus on the center of the images. Equivalent to ``(Clip(Normal(0.5, 0.45/2), 0, 1), Clip(Normal(0.5, 0.45/2), 0, 1))``. * If string ``center`` then center point of the cropping is identical to the image center. Equivalent to ``(0.5, 0.5)``. * If a string matching regex ``^(left|center|right)-(top|center|bottom)$``, e.g. ``left-top`` or ``center-bottom`` then sets the center point of the cropping to the X-Y position matching that description. * If a tuple of float, then expected to have exactly two entries between ``0.0`` and ``1.0``, which will always be used as the combination the position matching (x, y) form. * If a ``StochasticParameter``, then that parameter will be queried once per call to ``augment_*()`` to get ``Nx2`` center positions in ``(x, y)`` form (with ``N`` the number of images). * If a ``tuple`` of ``StochasticParameter``, then expected to have exactly two entries that will both be queried per call to ``augment_*()``, each for ``(N,)`` values, to get the center positions. First parameter is used for ``x`` coordinates, second for ``y`` coordinates. 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.CropToFixedSize(width=100, height=100) For image sides larger than ``100`` pixels, crop to ``100`` pixels. Do nothing for the other sides. The cropping amounts are randomly (and uniformly) distributed over the sides of the image. >>> aug = iaa.CropToFixedSize(width=100, height=100, position="center") For sides larger than ``100`` pixels, crop to ``100`` pixels. Do nothing for the other sides. The cropping amounts are always equally distributed over the left/right sides of the image (and analogously for top/bottom). >>> aug = iaa.Sequential([ >>> iaa.PadToFixedSize(width=100, height=100), >>> iaa.CropToFixedSize(width=100, height=100) >>> ]) Pad images smaller than ``100x100`` until they reach ``100x100``. Analogously, crop images larger than ``100x100`` until they reach ``100x100``. The output images therefore have a fixed size of ``100x100``. rqNrcs0tt|j||||d||f|_t||_dS)Nr)rrrrrr)rrrrrrrrrrrr" s   zCropToFixedSize.__init__c Cs|||}|jdur||j||_|jdur ||j||_|jdur-||j||_dD]}t||}|durNtj|j |d}| ||} t ||| q/|Sr`) rrrrr r r9r r r rr;r{rrrr4 s0       zCropToFixedSize._augment_batch_c C~g}|\}}}tt||D].\}\}} | \} } |jdd\} } || | | | ||||}t||ddd}||q|SNrrr}Fr~)rrr _calculate_crop_amountsr+r)rrrrr offset_xs offset_ysr%rrr'r&rrr%Z image_croppedrrrrT s  z*CropToFixedSize._augment_images_by_samplesc Crr)rrr rrGr)rr+rrrrrr%rDrr'r&rrr1Z kpsoi_croppedrrrr f s  z-CropToFixedSize._augment_keypoints_by_samplesc Cst|\}}}tt||D]+\}\}}|\} } |jdd\} } || | | | ||||} t|| ddd||<q |Sr)rrr rr0)rr(rrrrr%r>rr'r&rrr1rrrr x s  z(CropToFixedSize._augment_maps_by_samplesc Cstd}d}d} d} |dur||krt|||}|||} |dur4||kr4t|||} ||| }||| | fSrgr) rrrZ height_maxZ width_maxZoffset_yZoffset_xrFrLrMrErrrr s   z'CropToFixedSize._calculate_crop_amountscCs|j}|d}t|jtr'|jdj||dd}|jdj||dd}n|jj|df|dd}|dddf}|dddf}d|}d|}|jg|||fS)Nrrr,rrr)rr-r7rrIr.r)rrrr/r0rroffsetsrrrr s"     zCropToFixedSize._draw_samplescCs|jd|jd|jgSr)rrr4rrrr5 szCropToFixedSize.get_parametersrqNNrr)r7r8r9r:rrrr r r;rrr5r<rrrrr sz  rc&eZdZdZ  dfdd ZZS)CenterCropToFixedSizeaTake a crop from the center of each image. This is an alias for :class:`~imgaug.augmenters.size.CropToFixedSize` with ``position="center"``. .. note:: If images already have a width and/or height below the provided width and/or height then this augmenter will do nothing for the respective axis. Hence, resulting images can be smaller than the provided axis sizes. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- width : int or None See :func:`CropToFixedSize.__init__`. height : int or None See :func:`CropToFixedSize.__init__`. 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 >>> crop = iaa.CenterCropToFixedSize(height=20, width=10) Create an augmenter that takes ``20x10`` sized crops from the center of images. Nrc "tt|j||d||||ddS)Nrxrrrrrrr)rrr)rrrrrrrrrrr  zCenterCropToFixedSize.__init__NNrrrvrrrrr s 7rc<eZdZdZ   d fdd ZfddZd d ZZS) CropToMultiplesOfa Crop images down until their height/width is a multiple of a value. .. note:: For a given axis size ``A`` and multiple ``M``, if ``A`` is in the interval ``[0 .. M]``, the axis will not be changed. As a result, this augmenter can still produce axis sizes that are not multiples of the given values. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- width_multiple : int or None Multiple for the width. Images will be cropped down until their width is a multiple of this value. If ``None``, image widths will not be altered. height_multiple : int or None Multiple for the height. Images will be cropped down until their height is a multiple of this value. If ``None``, image heights will not be altered. position : {'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 See :func:`CropToFixedSize.__init__`. 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.CropToMultiplesOf(height_multiple=10, width_multiple=6) Create an augmenter that crops images to multiples of ``10`` along the y-axis (i.e. 10, 20, 30, ...) and to multiples of ``6`` along the x-axis (i.e. 6, 12, 18, ...). The rows to be cropped will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rqNrc .tt|jdd|||||d||_||_dSNr)rrrrr)rrrrrrrrrrrr2   zCropToMultiplesOf.__init__c tt|||\}}}|}g}|D],}|dd\} } t||j|jd} | | d| d| | d| df} || q|||fSNrr)rrrr)rrrrarrrr rrr_sizesrrrbrr rrr%new_sizerrrr= &   zCropToMultiplesOf._draw_samplescCr1r2)rrrr4rrrr5W r6z CropToMultiplesOf.get_parametersrr7r8r9r:rrr5r<rrrrr s= rcr)CenterCropToMultiplesOfaCrop images equally on all sides until H/W are multiples of given values. This is the same as :class:`~imgaug.augmenters.size.CropToMultiplesOf`, but uses ``position="center"`` by default, which spreads the crop amounts equally over all image sides, while :class:`~imgaug.augmenters.size.CropToMultiplesOf` by default spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- width_multiple : int or None See :func:`CropToMultiplesOf.__init__`. height_multiple : int or None See :func:`CropToMultiplesOf.__init__`. 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.CenterCropToMultiplesOf(height_multiple=10, width_multiple=6) Create an augmenter that crops images to multiples of ``10`` along the y-axis (i.e. 10, 20, 30, ...) and to multiples of ``6`` along the x-axis (i.e. 6, 12, 18, ...). The rows to be cropped will be spread *equally* over the top and bottom sides (analogous for the left/right sides). Nrc r)Nrx)rrrrrrr)rrr)rrrrrrrrrrr s  z CenterCropToMultiplesOf.__init__rrvrrrrr\ 6rc>eZdZdZ    d fdd Zfd d Zd d ZZS)PadToMultiplesOfa& Pad images until their height/width is a multiple of a value. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- width_multiple : int or None Multiple for the width. Images will be padded until their width is a multiple of this value. If ``None``, image widths will not be altered. height_multiple : int or None Multiple for the height. Images will be padded until their height is a multiple of this value. If ``None``, image heights will not be altered. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. position : {'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 See :func:`PadToFixedSize.__init__`. 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.PadToMultiplesOf(height_multiple=10, width_multiple=6) Create an augmenter that pads images to multiples of ``10`` along the y-axis (i.e. 10, 20, 30, ...) and to multiples of ``6`` along the x-axis (i.e. 6, 12, 18, ...). The rows to be padded will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rrrqNrc 2tt|jdd||||||| d ||_||_dSNr)rrrrr) rrrr'r(rrrrrrrrr   zPadToMultiplesOf.__init__ctt|||\}}}}}|}g} |D],} | dd\} } t| |j|jd} | | d| d| | d| df}| |q| ||||fSr)rrrrarrrrrrrrrrrrrbrr rrr&rrrrr &   zPadToMultiplesOf._draw_samplescC|j|j|j|j|jgSr2)rrr'r(rr4rrrr5zPadToMultiplesOf.get_parametersrrrrrrr s= rcr) CenterPadToMultiplesOfa3 Pad images equally on all sides until H/W are multiples of given values. This is the same as :class:`~imgaug.augmenters.size.PadToMultiplesOf`, but uses ``position="center"`` by default, which spreads the pad amounts equally over all image sides, while :class:`~imgaug.augmenters.size.PadToMultiplesOf` by default spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- width_multiple : int or None See :func:`PadToMultiplesOf.__init__`. height_multiple : int or None See :func:`PadToMultiplesOf.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToMultiplesOf.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToMultiplesOf.__init__`. 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.CenterPadToMultiplesOf(height_multiple=10, width_multiple=6) Create an augmenter that pads images to multiples of ``10`` along the y-axis (i.e. 10, 20, 30, ...) and to multiples of ``6`` along the x-axis (i.e. 6, 12, 18, ...). The rows to be padded will be spread *equally* over the top and bottom sides (analogous for the left/right sides). rrNrc r)Nrx) rrr'r(rrrrr)rrr) rrrr'r(rrrrrrrrEs  zCenterPadToMultiplesOf.__init__rrvrrrrr s <rcr) CropToPowersOfa# Crop images until their height/width is a power of a base. This augmenter removes pixels from an axis with size ``S`` leading to the new size ``S'`` until ``S' = B^E`` is fulfilled, where ``B`` is a provided base (e.g. ``2``) and ``E`` is an exponent from the discrete interval ``[1 .. inf)``. .. note:: This augmenter does nothing for axes with size less than ``B^1 = B``. If you have images with ``S < B^1``, it is recommended to combine this augmenter with a padding augmenter that pads each axis up to ``B``. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- width_base : int or None Base for the width. Images will be cropped down until their width fulfills ``width' = width_base ^ E`` with ``E`` being any natural number. If ``None``, image widths will not be altered. height_base : int or None Base for the height. Images will be cropped down until their height fulfills ``height' = height_base ^ E`` with ``E`` being any natural number. If ``None``, image heights will not be altered. position : {'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 See :func:`CropToFixedSize.__init__`. 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.CropToPowersOf(height_base=3, width_base=2) Create an augmenter that crops each image down to powers of ``3`` along the y-axis (i.e. 3, 9, 27, ...) and powers of ``2`` along the x-axis (i.e. 2, 4, 8, 16, ...). The rows to be cropped will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rqNrc rr)rrrrr)rrrrrrrrrrrrrzCropToPowersOf.__init__c rNrr)rrrr)rrrrarrrrrrrrrrzCropToPowersOf._draw_samplescCr1r2)rrrr4rrrr5r6zCropToPowersOf.get_parametersrrrrrrrSsD rcr)CenterCropToPowersOfaCrop images equally on all sides until H/W is a power of a base. This is the same as :class:`~imgaug.augmenters.size.CropToPowersOf`, but uses ``position="center"`` by default, which spreads the crop amounts equally over all image sides, while :class:`~imgaug.augmenters.size.CropToPowersOf` by default spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- width_base : int or None See :func:`CropToPowersOf.__init__`. height_base : int or None See :func:`CropToPowersOf.__init__`. 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.CropToPowersOf(height_base=3, width_base=2) Create an augmenter that crops each image down to powers of ``3`` along the y-axis (i.e. 3, 9, 27, ...) and powers of ``2`` along the x-axis (i.e. 2, 4, 8, 16, ...). The rows to be cropped will be spread *equally* over the top and bottom sides (analogous for the left/right sides). Nrc r)Nrx)rrrrrrr)rrr)rrrrrrrrrrrrzCenterCropToPowersOf.__init__rrvrrrrrrrcr) PadToPowersOfah Pad images until their height/width is a power of a base. This augmenter adds pixels to an axis with size ``S`` leading to the new size ``S'`` until ``S' = B^E`` is fulfilled, where ``B`` is a provided base (e.g. ``2``) and ``E`` is an exponent from the discrete interval ``[1 .. inf)``. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- width_base : int or None Base for the width. Images will be padded down until their width fulfills ``width' = width_base ^ E`` with ``E`` being any natural number. If ``None``, image widths will not be altered. height_base : int or None Base for the height. Images will be padded until their height fulfills ``height' = height_base ^ E`` with ``E`` being any natural number. If ``None``, image heights will not be altered. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. position : {'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 See :func:`PadToFixedSize.__init__`. 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.PadToPowersOf(height_base=3, width_base=2) Create an augmenter that pads each image to powers of ``3`` along the y-axis (i.e. 3, 9, 27, ...) and powers of ``2`` along the x-axis (i.e. 2, 4, 8, 16, ...). The rows to be padded will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rrrqNrc rr)rrrrr) rrrr'r(rrrrrrrrrErzPadToPowersOf.__init__crr)rrrrarrrrrrrrrSrzPadToPowersOf._draw_samplescCrr2)rrr'r(rr4rrrr5mrzPadToPowersOf.get_parametersrrrrrrrsD rcr) CenterPadToPowersOfaPad images equally on all sides until H/W is a power of a base. This is the same as :class:`~imgaug.augmenters.size.PadToPowersOf`, but uses ``position="center"`` by default, which spreads the pad amounts equally over all image sides, while :class:`~imgaug.augmenters.size.PadToPowersOf` by default spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- width_base : int or None See :func:`PadToPowersOf.__init__`. height_base : int or None See :func:`PadToPowersOf.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToPowersOf.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToPowersOf.__init__`. 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.CenterPadToPowersOf(height_base=5, width_base=2) Create an augmenter that pads each image to powers of ``3`` along the y-axis (i.e. 3, 9, 27, ...) and powers of ``2`` along the x-axis (i.e. 2, 4, 8, 16, ...). The rows to be padded will be spread *equally* over the top and bottom sides (analogous for the left/right sides). rrNrc r)Nrx) rrr'r(rrrrr)rrr) rrrr'r(rrrrrrrrs  zCenterPadToPowersOf.__init__rrvrrrrrts ;rcr) CropToAspectRatioa. Crop images until their width/height matches an aspect ratio. This augmenter removes either rows or columns until the image reaches the desired aspect ratio given in ``width / height``. The cropping operation is stopped once the desired aspect ratio is reached or the image side to crop reaches a size of ``1``. If any side of the image starts with a size of ``0``, the image will not be changed. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- aspect_ratio : number The desired aspect ratio, given as ``width/height``. E.g. a ratio of ``2.0`` denotes an image that is twice as wide as it is high. position : {'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 See :func:`CropToFixedSize.__init__`. 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.CropToAspectRatio(2.0) Create an augmenter that crops each image until its aspect ratio is as close as possible to ``2.0`` (i.e. two times as many pixels along the x-axis than the y-axis). The rows to be cropped will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rqNrc s(tt|jdd|||||d||_dSr)rrrr)rrrrrrrrrrrs  zCropToAspectRatio.__init__c stt|||\}}}|}g}|D]5}|dd\} } | dks&| dkr)d} nt||jd} | | d| d| | d| df} || q|||fS)Nrrr}rrr)rrrrarrrrrrrrs(  zCropToAspectRatio._draw_samplescC |j|jgSr2)rrr4rrrr5 z CropToAspectRatio.get_parametersrrrrrrrs6 rcr)CenterCropToAspectRatioaYCrop images equally on all sides until they reach an aspect ratio. This is the same as :class:`~imgaug.augmenters.size.CropToAspectRatio`, but uses ``position="center"`` by default, which spreads the crop amounts equally over all image sides, while :class:`~imgaug.augmenters.size.CropToAspectRatio` by default spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- aspect_ratio : number See :func:`CropToAspectRatio.__init__`. 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.CenterCropToAspectRatio(2.0) Create an augmenter that crops each image until its aspect ratio is as close as possible to ``2.0`` (i.e. two times as many pixels along the x-axis than the y-axis). The rows to be cropped will be spread *equally* over the top and bottom sides (analogous for the left/right sides). Nrcs tt|j|d||||ddS)Nrxrrrrrr)rrr)rrrrrrrrrrQ  z CenterCropToAspectRatio.__init__rrvrrrrrs 3rcr)PadToAspectRatioa Pad images until their width/height matches an aspect ratio. This augmenter adds either rows or columns until the image reaches the desired aspect ratio given in ``width / height``. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- aspect_ratio : number The desired aspect ratio, given as ``width/height``. E.g. a ratio of ``2.0`` denotes an image that is twice as wide as it is high. position : {'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 See :func:`PadToFixedSize.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. 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.PadToAspectRatio(2.0) Create an augmenter that pads each image until its aspect ratio is as close as possible to ``2.0`` (i.e. two times as many pixels along the x-axis than the y-axis). The rows to be padded will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rrrqNrc s,tt|jdd|||||||d ||_dSr)rrrr) rrr'r(rrrrrrrrrs  zPadToAspectRatio.__init__cstt|||\}}}}}|}g} |D]*} | dd\} } t| |jd} | | d| d| | d| df}| |q| ||||fS)Nrrrrr)rrrrarrrrrrrrs$  zPadToAspectRatio._draw_samplescCs|j|j|j|jgSr2)rr'r(rr4rrrr5s zPadToAspectRatio.get_parametersrrrrrrrZs9 rcr) CenterPadToAspectRatioaPad images equally on all sides until H/W matches an aspect ratio. This is the same as :class:`~imgaug.augmenters.size.PadToAspectRatio`, but uses ``position="center"`` by default, which spreads the pad amounts equally over all image sides, while :class:`~imgaug.augmenters.size.PadToAspectRatio` by default spreads them randomly. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- aspect_ratio : number See :func:`PadToAspectRatio.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToAspectRatio.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToAspectRatio.__init__`. deterministic : bool, 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 See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.PadToAspectRatio(2.0) Create am augmenter that pads each image until its aspect ratio is as close as possible to ``2.0`` (i.e. two times as many pixels along the x-axis than the y-axis). The rows to be padded will be spread *equally* over the top and bottom sides (analogous for the left/right sides). rrNrc s$tt|j|d||||||ddS)Nrx)rrr'r(rrrr)rrr)rrr'r(rrrrrrrrs  zCenterPadToAspectRatio.__init__rrvrrrrr 0rcs(eZdZdZ   dfdd ZZS) CropToSquareacCrop images until their width and height are identical. This is identical to :class:`~imgaug.augmenters.size.CropToAspectRatio` with ``aspect_ratio=1.0``. Images with axis sizes of ``0`` will not be altered. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. Parameters ---------- position : {'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 See :func:`CropToFixedSize.__init__`. 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.CropToSquare() Create an augmenter that crops each image until its square, i.e. height and width match. The rows to be cropped will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rqNrcs tt|jd|||||ddS)Nrrr)rrr)rrrrrrrrrr,rzCropToSquare.__init__rrvrrrrrrrcr)CenterCropToSquareaCrop images equally on all sides until their height/width are identical. In contrast to :class:`~imgaug.augmenters.size.CropToSquare`, this augmenter always tries to spread the columns/rows to remove equally over both sides of the respective axis to be cropped. :class:`~imgaug.augmenters.size.CropToAspectRatio` by default spreads the croppings randomly. This augmenter is identical to :class:`~imgaug.augmenters.size.CropToSquare` with ``position="center"``, and thereby the same as :class:`~imgaug.augmenters.size.CropToAspectRatio` with ``aspect_ratio=1.0, position="center"``. Images with axis sizes of ``0`` will not be altered. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.CropToFixedSize`. 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.CenterCropToSquare() Create an augmenter that crops each image until its square, i.e. height and width match. The rows to be cropped will be spread *equally* over the top and bottom sides (analogous for the left/right sides). Nrcstt|jd||||ddS)Nrx)rrrrr)rrr)rrrrrrrrrks  zCenterCropToSquare.__init__rrvrrrrr5s 5rcs(eZdZdZ   d fdd ZZS) PadToSquareaPad images until their height and width are identical. This augmenter is identical to :class:`~imgaug.augmenters.size.PadToAspectRatio` with ``aspect_ratio=1.0``. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- position : {'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 See :func:`PadToFixedSize.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToFixedSize.__init__`. 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.PadToSquare() Create an augmenter that pads each image until its square, i.e. height and width match. The rows to be padded will be spread *randomly* over the top and bottom sides (analogous for the left/right sides). rrrqNrc s$tt|jd|||||||ddS)Nrr)rr'r(rrrrr)rrr)rr'r(rrrrrrrrrs  zPadToSquare.__init__rrvrrrrrss 4rcr) CenterPadToSquareaPad images equally on all sides until their height & width are identical. This is the same as :class:`~imgaug.augmenters.size.PadToSquare`, but uses ``position="center"`` by default, which spreads the pad amounts equally over all image sides, while :class:`~imgaug.augmenters.size.PadToSquare` by default spreads them randomly. This augmenter is thus also identical to :class:`~imgaug.augmenters.size.PadToAspectRatio` with ``aspect_ratio=1.0, position="center"``. Added in 0.4.0. **Supported dtypes**: See :class:`~imgaug.augmenters.size.PadToFixedSize`. Parameters ---------- name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. pad_mode : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToAspectRatio.__init__`. pad_cval : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.augmenters.size.PadToAspectRatio.__init__`. deterministic : bool, 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 See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.CenterPadToSquare() Create an augmenter that pads each image until its square, i.e. height and width match. The rows to be padded will be spread *equally* over the top and bottom sides (analogous for the left/right sides). rrNrc r)Nrx)r'r(rrrrr)rrr)rr'r(rrrrrrrrrzCenterPadToSquare.__init__rrvrrrrrs -rcseZdZdZdZdZdedddddffdd Zd d Zed d Z eddZ eddZ eddZ ddZ ddZddZddZddZZS)KeepSizeByResizeaResize images back to their input sizes after applying child augmenters. Combining this with e.g. a cropping augmenter as the child will lead to images being resized back to the input size after the crop operation was applied. Some augmenters have a ``keep_size`` argument that achieves the same goal (if set to ``True``), though this augmenter offers control over the interpolation mode and which augmentables to resize (images, heatmaps, segmentation maps). **Supported dtypes**: See :func:`~imgaug.imgaug.imresize_many_images`. Parameters ---------- children : Augmenter or list of imgaug.augmenters.meta.Augmenter or None, optional One or more augmenters to apply to images. These augmenters may change the image size. interpolation : KeepSizeByResize.NO_RESIZE or {'nearest', 'linear', 'area', 'cubic'} or {cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_AREA, cv2.INTER_CUBIC} or list of str or list of int or StochasticParameter, optional The interpolation mode to use when resizing images. Can take any value that :func:`~imgaug.imgaug.imresize_single_image` accepts, e.g. ``cubic``. * If this is ``KeepSizeByResize.NO_RESIZE`` then images will not be resized. * If this is a single ``str``, it is expected to have one of the following values: ``nearest``, ``linear``, ``area``, ``cubic``. * If this is a single integer, it is expected to have a value identical to one of: ``cv2.INTER_NEAREST``, ``cv2.INTER_LINEAR``, ``cv2.INTER_AREA``, ``cv2.INTER_CUBIC``. * If this is a ``list`` of ``str`` or ``int``, it is expected that each ``str``/``int`` is one of the above mentioned valid ones. A random one of these values will be sampled per image. * If this is a ``StochasticParameter``, it will be queried once per call to ``_augment_images()`` and must return ``N`` ``str`` s or ``int`` s (matching the above mentioned ones) for ``N`` images. interpolation_heatmaps : KeepSizeByResize.SAME_AS_IMAGES or KeepSizeByResize.NO_RESIZE or {'nearest', 'linear', 'area', 'cubic'} or {cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_AREA, cv2.INTER_CUBIC} or list of str or list of int or StochasticParameter, optional The interpolation mode to use when resizing heatmaps. Meaning and valid values are similar to `interpolation`. This parameter may also take the value ``KeepSizeByResize.SAME_AS_IMAGES``, which will lead to copying the interpolation modes used for the corresponding images. The value may also be returned on a per-image basis if `interpolation_heatmaps` is provided as a ``StochasticParameter`` or may be one possible value if it is provided as a ``list`` of ``str``. interpolation_segmaps : KeepSizeByResize.SAME_AS_IMAGES or KeepSizeByResize.NO_RESIZE or {'nearest', 'linear', 'area', 'cubic'} or {cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_AREA, cv2.INTER_CUBIC} or list of str or list of int or StochasticParameter, optional The interpolation mode to use when resizing segmentation maps. Similar to `interpolation_heatmaps`. **Note**: For segmentation maps, only ``NO_RESIZE`` or nearest neighbour interpolation (i.e. ``nearest``) make sense in the vast majority of all cases. 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.KeepSizeByResize( >>> iaa.Crop((20, 40), keep_size=False) >>> ) Apply random cropping to input images, then resize them back to their original input sizes. The resizing is done using this augmenter instead of the corresponding internal resizing operation in ``Crop``. >>> aug = iaa.KeepSizeByResize( >>> iaa.Crop((20, 40), keep_size=False), >>> interpolation="nearest" >>> ) Same as in the previous example, but images are now always resized using nearest neighbour interpolation. >>> aug = iaa.KeepSizeByResize( >>> iaa.Crop((20, 40), keep_size=False), >>> interpolation=["nearest", "cubic"], >>> interpolation_heatmaps=iaa.KeepSizeByResize.SAME_AS_IMAGES, >>> interpolation_segmaps=iaa.KeepSizeByResize.NO_RESIZE >>> ) Similar to the previous example, but images are now sometimes resized using linear interpolation and sometimes using nearest neighbour interpolation. Heatmaps are resized using the same interpolation as was used for the corresponding image. Segmentation maps are not resized and will therefore remain at their size after cropping. NO_RESIZESAME_AS_IMAGESrrNrc sdttj||||d|_fdd} t|jd_| |d_| |d_| |d_ dS)Nrcstjtjg}|r|jkrjS||vrt|St|trQt |dks)Jd||r3tjgt fdd|D}|sLJdt t |ft |St|tj rY|Stdt tjt|f)NrzHExpected a list of at least one interpolation method. Got an empty list.cr_rrraipZvalid_ips_hererrrdqrezFKeepSizeByResize.__init__.._validate_param..z9Expected each interpolations to be one of '%s', got '%s'.ziExpected interpolation to be one of '%s' or a list of these values or a StochasticParameter. Got type %s.)r#ZIMRESIZE_VALID_INTERPOLATIONSrrrrgrkr7rHrrlrmrhrnror8)rXZallow_same_as_imagesZvalid_ips_and_resizeZonly_valid_ipsr4rr_validate_parambs>    z2KeepSizeByResize.__init__.._validate_paramZthenFT) rrrchildrenrZhandle_children_listrrinterpolation_heatmapsinterpolation_segmaps) rrrrrrrrrrrr4rrWs    zKeepSizeByResize.__init__c CsB||||d}|jdurt|j}||}||j|}|jj|||g|d}|jdur>| |j|d|||_|j durS| |j |d|d|d|_ |j durh| |j |d|d|d|_ d D]$}t ||} | durtj|j|||d d } || | } t||| qjWd|S1swY|S) N)rrrr heatmaps_arrrr segmentation_maps_arrrrr) shapes_originterpolations)Zpropagation_hooks_ctxrr#r _get_shapesrrrZaugment_batch__keep_size_imagesr_keep_size_mapsr r9r r _keep_size_keypointsrr;) rrrrrimages_were_arrayrrrrrrrrrrsT               ''z KeepSizeByResize._augment_batch_c Cs|\}}}t|||}g}|D]\} } } | tjkr|| q|t| | dd| q|rGtdd|D} | dkrGtj||dj d}|S)NrrcSrrrrrrrrrz5KeepSizeByResize._keep_size_images..rr) rrrrr#r$rrQr!r) rrrrrrrgenrrr input_shaperdrrrrs    z"KeepSizeByResize._keep_size_imagesc Csbg}t||||}|D]#\}}} } |dkr||q |j| dd|d}| |_||q |S)Nrrrr)rrr<r ) rr(Zshapes_orig_imagesZshapes_orig_arrsrrrr>rr@Zimg_shape_origrrrrs   z KeepSizeByResize._keep_size_mapsc CsJg}t|||}|D]\}}}|tjkr||q |||q |Sr.)rrrrrC) rZ kpsois_augrrrrrfrrrrrrs   z%KeepSizeByResize._keep_size_keypointscCsht}|jD] }dd|jD||j<q|jdur#dd|jD|d<|jdur2dd|jD|d<|S)NcSsg|]}|jqSrrracellrrrrdrz0KeepSizeByResize._get_shapes..cSg|]}|jjqSr)r6r rrrrrdrcSrr)rr rrrrrdrr)rcolumnsrTrrr )rrrcolumnrrrrs    zKeepSizeByResize._get_shapescs|d}jj|f|dd}jtjkrt|}njj|f|dd}fdd|D}||||<jtjkrBt|}njj|f|dd}fdd|D}||||<|||fS) Nrrr,rcg|]}|jkqSrrrr4rrrd z2KeepSizeByResize._draw_samples..rcrrrrr4rrrdr) r-rr.rrrrQrr)rr/rr0rZinterpolations_heatmapsZsame_as_imgs_idxZinterpolations_segmapsrr4rrs2           zKeepSizeByResize._draw_samplescCs*|}|j|_d|_|j|_|S)NT)rrZto_deterministicrrZ derive_rng_)raugrrr_to_deterministic's   z"KeepSizeByResize._to_deterministiccCrr2)rrr4rrrr5.rzKeepSizeByResize.get_parameterscCs|jgS)zASee :func:`~imgaug.augmenters.meta.Augmenter.get_children_lists`.)rr4rrrget_children_lists2sz#KeepSizeByResize.get_children_listscCs&d}||jj|j|j|j|j|jfS)NzW%s(interpolation=%s, interpolation_heatmaps=%s, name=%s, children=%s, deterministic=%s))rr7rrrrr)rpatternrrr__str__6s  zKeepSizeByResize.__str__)r7r8r9r:rrrrr;rrrrrrr5rrr<rrrrrs0j.+    .r)T)rrF)rr,F)rNF)rrrrrr)F)Gr: __future__rrrrr numpyrQrZimgaugr#Z imgaug.imgaugrrr rgrrr+r3r5r0rGr=r r:rOrprrr"rrrrrrrrrrZ Augmenterrobjectr=rBrorwrzrrrrrrrrrrrrrrrrrrrrrrrrs          +/ ? J D JGH@@ I N lj>;G@hAlJo?sGc<f;:>?7