o eK\@sdZddlmZmZmZddlmZmZddlZ ddl Z ddl Z ddl Z ddl Z ddlZddlZddlmZddlZddlmZmZmZddlmZddlmZd d lmZ e!d d d Z"e!d ddZ#e!d ddZ$e!d ddZ%dSddZ&ddZ'ddZ(ddZ)ddZ*dd Z+d!d"Z,Gd#d$d$e-Z.e/eGd%d&d&e-Z0Gd'd(d(e0e1Z2Gd)d*d*e0e1Z3Gd+d,d,e3Z4Gd-d.d.e0Z5Gd/d0d0e0Z6Gd1d2d2e0Z7Gd3d4d4e7Z8Gd5d6d6e0Z9Gd7d8d8e9Z:Gd9d:d:e-Z;Gd;d<dd>e-Z=Gd?d@d@e-Z>GdAdBdBe-Z?GdCdDdDe-Z@GdEdFdFe-ZAGdGdHdHe-ZBGdIdJdJe-ZCGdKdLdLe0ZDdTdMdNZEGdOdPdPe0ZFGdQdRdRe0ZGdS)Ua Augmenters that don't apply augmentations themselves, but are needed for meta usage. List of augmenters: * :class:`Augmenter` (base class for all augmenters) * :class:`Sequential` * :class:`SomeOf` * :class:`OneOf` * :class:`Sometimes` * :class:`WithChannels` * :class:`Identity` * :class:`Noop` * :class:`Lambda` * :class:`AssertLambda` * :class:`AssertShape` * :class:`ChannelShuffle` Note: :class:`~imgaug.augmenters.color.WithColorspace` is in ``color.py``. )print_functiondivisionabsolute_import)ABCMetaabstractmethodN)BatchUnnormalizedBatch_BatchInAugmentation) parameters)random)basezimgaug.dtypes.clip_cC t|||S)zClip image in-place.)clip_augmented_images_image min_value max_valuerFD:\Projects\ConvertPro\env\Lib\site-packages\imgaug/augmenters/meta.pyclip_augmented_image_, rcCr)z Clip image.)clip_augmented_imagesrrrrclip_augmented_image2rrcs0t|rtj||dSfdd|DS)zClip images in-place.outcsg|] }tj||dqS)r)npclip.0rrrrr =sz*clip_augmented_images_..)ia is_np_arrayrrimagesrrrr!rr8s  rcCs0t|r t|}ndd|D}t|||S)z Clip images.cSg|]}t|qSrrcopyrrrrr"Gz)clip_augmented_images..)r#r$rr)rr%rrrrAs   r sequentialcCs|dur|dkrtgd||fdS|St|trCt|r9tdd|D}|s7Jddd d|D|St|d||fdSt|rwt|d krT|dkrT|Std d|D}|smJddd d|Dt|d||fdStd ||t |f)z/Normalize an augmenter list provided by a user.Nr+z%s-%snamecSg|]}t|tqSr isinstance Augmenterr childrrrr"Tz(handle_children_list..5Expected all children to be augmenters, got types %s., cSg|]}tt|qSrstrtyper vrrrr"XrcSr.rr/r2rrrr"^r4cSr7rr8r;rrrr"br=z^Expected None, Augmenter or list/tuple as children list %s for augmenter with name %s, got %s.) Sequentialr0r1r# is_iterablealljoinlen Exceptionr:)lstZaugmenter_nameZlst_namedefaultZonly_augmentersrrrhandle_children_listKsD    rFcCsXg}g}t|D]\}}t|dsJdt|f|js'||||q||fS)zERemove from a list all objects that don't follow ``obj.empty==True``.emptyz3Expected object with property 'empty'. Got type %s.) enumeratehasattrr:rGappend)objs objs_reducedidsiobjrrrreduce_to_nonemptyjs   rPcCs(t|}t||D]\}}|||<q |S)z&Inverse of :func:`reduce_to_nonempty`.)listzip)rKrMrLZobjs_invidxZobj_from_reducedrrrinvert_reduce_to_nonemptyxs rTcCspt|r|jdksJd|jf|jdSt|s%Jdt|ft|dkr-dSdd|D}t|S) zDCompute the maximum number of image channels among a list of images.zNExpected 'images' to be 4-dimensional if provided as array. Got %d dimensions.z5Expected 'images' to be an array or iterable, got %s.rNcSs(g|]}t|jdkr|jdndqS)rVr r rBshaper elrrrr"s(z3estimate_max_number_of_channels..)r#r$ndimrXr?r:rBmax)r&channelsrrrestimate_max_number_of_channelss     r^cCs"t|r t|Sdd|DS)z@Copy the arrays of a single input array or list of input arrays.cSr'rr()r arrayrrrr"r*zcopy_arrays..)r#r$rr))Zarraysrrr copy_arrayss  r`cCs4t|r|jdkr|dtjfS|Sdd|DS)NrV.cSs(g|]}|jdkr|dtjfn|qS)r .)r[rnewaxisr arrrrrr"s  z%_add_channel_axis..)r#r$r[rra)Zarrsrrr_add_channel_axiss  rdcCsLt|r|jdkrt|r|dSdd|DS|Sddt||DS)NrV.rcSsg|]}|dqS)rerrbrrrr"z._remove_added_channel_axis..cSs&g|]\}}|jdkr|dn|qS)r re)r[)r Z arr_addedZarr_origrrrr"s  )r#r$r[rR)Z arrs_addedZ arrs_origrrr_remove_added_channel_axiss   rgc@s*eZdZdZd ddZddZddZdS) _maybe_deterministic_ctxaContext that resets an RNG to its initial state upon exit. This allows to execute some sampling functions and leave the code block with the used RNG in the same state as before. Parameters ---------- random_state : imgaug.random.RNG or imgaug.augmenters.meta.Augmenter The RNG to reset. If this is an augmenter, then the augmenter's RNG will be used. deterministic : None or bool Whether to reset the RNG upon exit (``True``) or not (``False``). Allowed to be ``None`` iff `random_state` was an augmenter, in which case that augmenter's ``deterministic`` attribute will be used. NcCsD|dur|}|j|_|j|_n|dusJd||_||_d|_dS)Nz.Expected boolean as `deterministic`, got None.) random_state deterministic old_state)selfrirj augmenterrrr__init__s   z!_maybe_deterministic_ctx.__init__cCs|jr |jj|_dSdSN)rjristaterkrlrrr __enter__sz"_maybe_deterministic_ctx.__enter__cCs|jdur |j|j_dSdSro)rkrirp)rlZexception_typeZexception_valueZexception_tracebackrrr__exit__s z!_maybe_deterministic_ctx.__exit__ro)__name__ __module__ __qualname____doc__rnrrrsrrrrrhs   rhcs@eZdZdZ   dtfdd ZduddZejd d d dvd d ZdwddZ ddZ dvddZ dwddZ ddZ dwddZddZdwddZddZdwd d!Zd"d#Z  dwd$d%Zdwd&d'Z  dwd(d)Zd*d+Zd,d-Zd.d/Zd0d1Z dvd2d3Zd4d5Zd6d7Ze dwd8d9Zed:d;Z dxdd?Z"dyd@dAZ#dBdCZ$dDdEZ%dvdFdGZ&dHdIZ'edJdudKdLZ(dudMdNZ)dzdPdQZ*dzdRdSZ+ T d{dUdVZ, T d{dWdXZ-e.dYdZZ/d[d\Z0d|d]d^Z1d}d_d`Z2d~dadbZ3d~dcddZ4 O ddedfZ5edgdvdhdiZ6dvdjdkZ7dldmZ8dndoZ9dpdqZ:drdsZ;Z._normalize_batchcSs|dkr|}|jd|_|S|dkr|jd|_||}|S|dkr(|j}|S|dkr0g}|S|dkr9|j}|S|dkrB|j}|S|dkrK|j}|S|d krT|j}|S|d kr]|j}|S|d ksjJd t|f|j}|S) Nrr rrrrrrrrrzGot an unexpected type %s.) rZ$fill_from_augmented_normalized_batch images_aug heatmaps_augsegmentation_maps_aug keypoints_augbounding_boxes_augr: polygons_aug) batch_aug batch_origrbatch_unnormalizedrrr_unnormalize_batchsF      z5Augmenter.augment_batches.._unnormalize_batchhooksrc3s8tD]\}}||\}}||f|<|VqdSro)rH)rSrrrrbatchesZid_to_batch_origrr load_batchess z/Augmenter.augment_batches..load_batches )output_buffer_sizez)Got idx %d from Pool, which is not known.)r0rrr#r?r$r{Z is_generatorr:rHaugment_batch_imgaug.multicore multicoredictPoolpoolZ _processesZ imap_batchesr)rlrr backgroundrrSrrrrrrrrrrrrraugment_batchesGsl+ H      "zAugmenter.augment_batcheszaugment_batch_()a`augment_batch()` was renamed to `augment_batch_()` as it changes all `*_unaug` attributes of batches in-place. Note that `augment_batch_()` has now a `parents` parameter. Calls of the style `augment_batch(batch, hooks)` must be changed to `augment_batch(batch, hooks=hooks)`.)commentcCs|j||dS)zBAugment a single batch. Deprecated since 0.4.0. r)r)rlrrrrr augment_batchszAugmenter.augment_batchc Csd}d}t|tr |}n&t|tr|}|}|}nt|tr(|}|}n tdt|jf|j }|durQ|D]}|j |j ||d} t ||j | q;|j }g} |jsh|D]}| |t ||j dqXn"|dur|D]}|j|j |||jd} | s| |t ||j dqnt||js|j||j|dur|ng|d}Wdn1swY| D] }t ||j |j q|dur|j }|D]}|j|j ||d} t ||j | q|dur||}||}|S|dur||}|S|S)a Augment a single batch in-place. Added in 0.4.0. Parameters ---------- batch : imgaug.augmentables.batches.Batch or imgaug.augmentables.batches.UnnormalizedBatch or imgaug.augmentables.batch._BatchInAugmentation A single batch to augment. If :class:`imgaug.augmentables.batches.UnnormalizedBatch` or :class:`imgaug.augmentables.batches.Batch`, then the ``*_aug`` attributes may be modified in-place, while the ``*_unaug`` attributes will not be modified. If :class:`imgaug.augmentables.batches._BatchInAugmentation`, then all attributes may be modified in-place. parents : None or list of imgaug.augmenters.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imgaug.HooksImages, optional HooksImages object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.batches.Batch or imgaug.augmentables.batches.UnnormalizedBatch Augmented batch. NzBExpected UnnormalizedBatch, Batch or _BatchInAugmentation, got %s.)rmparents)rmrrErirr)r0r rrZto_batch_in_augmentationr ValueErrorr:rtcolumns preprocessvaluesetattr attr_namerrJZ is_activatedrhrG_augment_batch_ri postprocessZ fill_from_batch_in_augmentation_Z%fill_from_augmented_normalized_batch_) rlrrrZ batch_unnormZ batch_normZ batch_inaugrcolumnrZ set_to_nonerZ augm_valuerrrr)s%          zAugmenter.augment_batch_c Cs|j}t|dk}|jp |}|D]-}t||t|d|j|j|||d} t||j| Wdn1s8wYq|rG|jsG| |S)aAugment a single batch in-place. This is the internal version of :func:`Augmenter.augment_batch_`. It is called from :func:`Augmenter.augment_batch_` and should usually not be called directly. This method may transform the batches in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. Added in 0.4.0. Parameters ---------- batch : imgaug.augmentables.batches._BatchInAugmentation The normalized batch to augment. May be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_batch_`. hooks : imgaug.imgaug.HooksImages or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_batch_`. Returns ---------- imgaug.augmentables.batches._BatchInAugmentation The augmented batch. r Z _augment_rN) rrBrjrhgetattrr-rrrZadvance_) rlrrirrrZmultiple_columnsrjrrrrrrs(    zAugmenter._augment_batch_cCsVt|sJdt|jf|jdvsJd|jft||j|g|ddS)aAugment a single image. Parameters ---------- image : (H,W,C) ndarray or (H,W) ndarray The image to augment. Channel-axis is optional, but expected to be the last axis if present. In most cases, this array should be of dtype ``uint8``, which is supported by all augmenters. Support for other dtypes varies by augmenter -- see the respective augmenter-specific documentation for more details. hooks : None or imgaug.HooksImages, optional HooksImages object to dynamically interfere with the augmentation process. Returns ------- ndarray The corresponding augmented image. zExpected to get a single numpy array of shape (H,W) or (H,W,C) for `image`. Got instead type %d. Use `augment_images(images)` to augment a list of multiple images.)r rVzGExpected image to have shape (height, width, [channels]), got shape %s.rr) r#r$r:rtr[rXiabase&_warn_on_suspicious_single_image_shapeaugment_images)rlrrrrr augment_images   zAugmenter.augment_imagecCs"t||jt|d||djS)a@Augment a batch of images. Parameters ---------- images : (N,H,W,C) ndarray or (N,H,W) ndarray or list of (H,W,C) ndarray or list of (H,W) ndarray Images to augment. The input can be a list of numpy arrays or a single array. Each array is expected to have shape ``(H, W, C)`` or ``(H, W)``, where ``H`` is the height, ``W`` is the width and ``C`` are the channels. The number of channels may differ between images. If a list is provided, the height, width and channels may differ between images within the provided batch. In most cases, the image array(s) should be of dtype ``uint8``, which is supported by all augmenters. Support for other dtypes varies by augmenter -- see the respective augmenter-specific documentation for more details. parents : None or list of imgaug.augmenters.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imgaug.imgaug.HooksImages, optional :class:`~imgaug.imgaug.HooksImages` object to dynamically interfere with the augmentation process. Returns ------- ndarray or list Corresponding augmented images. If the input was an ``ndarray``, the output is also an ``ndarray``, unless the used augmentations have led to different output image sizes (as can happen in e.g. cropping). Examples -------- >>> import imgaug.augmenters as iaa >>> import numpy as np >>> aug = iaa.GaussianBlur((0.0, 3.0)) >>> # create empty example images >>> images = np.zeros((2, 64, 64, 3), dtype=np.uint8) >>> images_aug = aug.augment_images(images) Create ``2`` empty (i.e. black) example numpy images and apply gaussian blurring to them. r&rr)r&_warn_on_suspicious_multi_image_shapesrrr)rlr&rrrrrrs 0zAugmenter.augment_imagescC|S)a(Augment a batch of images in-place. This is the internal version of :func:`Augmenter.augment_images`. It is called from :func:`Augmenter.augment_images` and should usually not be called directly. It has to be implemented by every augmenter. This method may transform the images in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Parameters ---------- images : (N,H,W,C) ndarray or list of (H,W,C) ndarray Images to augment. They may be changed in-place. Either a list of ``(H, W, C)`` arrays or a single ``(N, H, W, C)`` array, where ``N`` is the number of images, ``H`` is the height of images, ``W`` is the width of images and ``C`` is the number of channels of images. In the case of a list as input, ``H``, ``W`` and ``C`` may change per image. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_images`. hooks : imgaug.imgaug.HooksImages or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_images`. Returns ---------- (N,H,W,C) ndarray or list of (H,W,C) ndarray The augmented images. rrlr&rirrrrr_augment_images<s.zAugmenter._augment_imagescC|jt|d||djS)aAugment a batch of heatmaps. Parameters ---------- heatmaps : imgaug.augmentables.heatmaps.HeatmapsOnImage or list of imgaug.augmentables.heatmaps.HeatmapsOnImage Heatmap(s) to augment. Either a single heatmap or a list of heatmaps. parents : None or list of imgaug.augmenters.meta.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imaug.imgaug.HooksHeatmaps, optional :class:`~imgaug.imgaug.HooksHeatmaps` object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.heatmaps.HeatmapsOnImage or list of imgaug.augmentables.heatmaps.HeatmapsOnImage Corresponding augmented heatmap(s). )rr)rrr)rlrrrrrraugment_heatmapsls  zAugmenter.augment_heatmapscCr)a!Augment a batch of heatmaps in-place. This is the internal version of :func:`Augmenter.augment_heatmaps`. It is called from :func:`Augmenter.augment_heatmaps` and should usually not be called directly. This method may augment heatmaps in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Parameters ---------- heatmaps : list of imgaug.augmentables.heatmaps.HeatmapsOnImage Heatmaps to augment. They may be changed in-place. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_heatmaps`. hooks : imgaug.imgaug.HooksHeatmaps or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_heatmaps`. Returns ---------- images : list of imgaug.augmentables.heatmaps.HeatmapsOnImage The augmented heatmaps. r)rlrrirrrrr_augment_heatmaps#zAugmenter._augment_heatmapscCr)aAugment a batch of segmentation maps. Parameters ---------- segmaps : imgaug.augmentables.segmaps.SegmentationMapsOnImage or list of imgaug.augmentables.segmaps.SegmentationMapsOnImage Segmentation map(s) to augment. Either a single segmentation map or a list of segmentation maps. parents : None or list of imgaug.augmenters.meta.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imgaug.HooksHeatmaps, optional :class:`~imgaug.imgaug.HooksHeatmaps` object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.segmaps.SegmentationMapsOnImage or list of imgaug.augmentables.segmaps.SegmentationMapsOnImage Corresponding augmented segmentation map(s). )rr)rrr)rlsegmapsrrrrraugment_segmentation_mapssz#Augmenter.augment_segmentation_mapscCr)aAugment a batch of segmentation in-place. This is the internal version of :func:`Augmenter.augment_segmentation_maps`. It is called from :func:`Augmenter.augment_segmentation_maps` and should usually not be called directly. This method may augment segmentation maps in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Parameters ---------- segmaps : list of imgaug.augmentables.segmaps.SegmentationMapsOnImage Segmentation maps to augment. They may be changed in-place. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_segmentation_maps`. hooks : imgaug.imgaug.HooksHeatmaps or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_segmentation_maps`. Returns ---------- images : list of imgaug.augmentables.segmaps.SegmentationMapsOnImage The augmented segmentation maps. r)rlrrirrrrr_augment_segmentation_mapss&z$Augmenter._augment_segmentation_mapscCr)a Augment a batch of keypoints/landmarks. This is the corresponding function to :func:`Augmenter.augment_images`, just for keypoints/landmarks (i.e. points on images). Usually you will want to call :func:`Augmenter.augment_images` with a list of images, e.g. ``augment_images([A, B, C])`` and then ``augment_keypoints()`` with the corresponding list of keypoints on these images, e.g. ``augment_keypoints([Ak, Bk, Ck])``, where ``Ak`` are the keypoints on image ``A``. Make sure to first convert the augmenter(s) to deterministic states before augmenting images and their corresponding keypoints, e.g. by >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.kps import Keypoint >>> from imgaug.augmentables.kps import KeypointsOnImage >>> A = B = C = np.zeros((10, 10), dtype=np.uint8) >>> Ak = Bk = Ck = KeypointsOnImage([Keypoint(2, 2)], (10, 10)) >>> seq = iaa.Fliplr(0.5) >>> seq_det = seq.to_deterministic() >>> imgs_aug = seq_det.augment_images([A, B, C]) >>> kps_aug = seq_det.augment_keypoints([Ak, Bk, Ck]) Otherwise, different random values will be sampled for the image and keypoint augmentations, resulting in different augmentations (e.g. images might be rotated by ``30deg`` and keypoints by ``-10deg``). Also make sure to call :func:`Augmenter.to_deterministic` again for each new batch, otherwise you would augment all batches in the same way. Note that there is also :func:`Augmenter.augment`, which automatically handles the random state alignment. Parameters ---------- keypoints_on_images : imgaug.augmentables.kps.KeypointsOnImage or list of imgaug.augmentables.kps.KeypointsOnImage The keypoints/landmarks to augment. Either a single instance of :class:`~imgaug.augmentables.kps.KeypointsOnImage` or a list of such instances. Each instance must contain the keypoints of a single image. parents : None or list of imgaug.augmenters.meta.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imgaug.imgaug.HooksKeypoints, optional :class:`~imgaug.imgaug.HooksKeypoints` object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.kps.KeypointsOnImage or list of imgaug.augmentables.kps.KeypointsOnImage Augmented keypoints. )rr)rrr)rlkeypoints_on_imagesrrrrraugment_keypointss;zAugmenter.augment_keypointscCr)aAugment a batch of keypoints in-place. This is the internal version of :func:`Augmenter.augment_keypoints`. It is called from :func:`Augmenter.augment_keypoints` and should usually not be called directly. This method may transform the keypoints in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Parameters ---------- keypoints_on_images : list of imgaug.augmentables.kps.KeypointsOnImage Keypoints to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_keypoints`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_keypoints`. Returns ---------- list of imgaug.augmentables.kps.KeypointsOnImage The augmented keypoints. r)rlrrirrrrr_augment_keypoints5s'zAugmenter._augment_keypointscCr)a@ Augment a batch of bounding boxes. This is the corresponding function to :func:`Augmenter.augment_images`, just for bounding boxes. Usually you will want to call :func:`Augmenter.augment_images` with a list of images, e.g. ``augment_images([A, B, C])`` and then ``augment_bounding_boxes()`` with the corresponding list of bounding boxes on these images, e.g. ``augment_bounding_boxes([Abb, Bbb, Cbb])``, where ``Abb`` are the bounding boxes on image ``A``. Make sure to first convert the augmenter(s) to deterministic states before augmenting images and their corresponding bounding boxes, e.g. by >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.bbs import BoundingBox >>> from imgaug.augmentables.bbs import BoundingBoxesOnImage >>> A = B = C = np.ones((10, 10), dtype=np.uint8) >>> Abb = Bbb = Cbb = BoundingBoxesOnImage([ >>> BoundingBox(1, 1, 9, 9)], (10, 10)) >>> seq = iaa.Fliplr(0.5) >>> seq_det = seq.to_deterministic() >>> imgs_aug = seq_det.augment_images([A, B, C]) >>> bbs_aug = seq_det.augment_bounding_boxes([Abb, Bbb, Cbb]) Otherwise, different random values will be sampled for the image and bounding box augmentations, resulting in different augmentations (e.g. images might be rotated by ``30deg`` and bounding boxes by ``-10deg``). Also make sure to call :func:`Augmenter.to_deterministic` again for each new batch, otherwise you would augment all batches in the same way. Note that there is also :func:`Augmenter.augment`, which automatically handles the random state alignment. Parameters ---------- bounding_boxes_on_images : imgaug.augmentables.bbs.BoundingBoxesOnImage or list of imgaug.augmentables.bbs.BoundingBoxesOnImage The bounding boxes to augment. Either a single instance of :class:`~imgaug.augmentables.bbs.BoundingBoxesOnImage` or a list of such instances, with each one of them containing the bounding boxes of a single image. parents : None or list of imgaug.augmenters.meta.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imgaug.imgaug.HooksKeypoints, optional :class:`~imgaug.imgaug.HooksKeypoints` object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.bbs.BoundingBoxesOnImage or list of imgaug.augmentables.bbs.BoundingBoxesOnImage Augmented bounding boxes. )rr)rrr)rlbounding_boxes_on_imagesrrrrraugment_bounding_boxes^s>z Augmenter.augment_bounding_boxescCr)a Augment a batch of polygons. This is the corresponding function to :func:`Augmenter.augment_images`, just for polygons. Usually you will want to call :func:`Augmenter.augment_images`` with a list of images, e.g. ``augment_images([A, B, C])`` and then ``augment_polygons()`` with the corresponding list of polygons on these images, e.g. ``augment_polygons([A_poly, B_poly, C_poly])``, where ``A_poly`` are the polygons on image ``A``. Make sure to first convert the augmenter(s) to deterministic states before augmenting images and their corresponding polygons, e.g. by >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.polys import Polygon, PolygonsOnImage >>> A = B = C = np.ones((10, 10), dtype=np.uint8) >>> Apoly = Bpoly = Cpoly = PolygonsOnImage( >>> [Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])], >>> shape=(10, 10)) >>> seq = iaa.Fliplr(0.5) >>> seq_det = seq.to_deterministic() >>> imgs_aug = seq_det.augment_images([A, B, C]) >>> polys_aug = seq_det.augment_polygons([Apoly, Bpoly, Cpoly]) Otherwise, different random values will be sampled for the image and polygon augmentations, resulting in different augmentations (e.g. images might be rotated by ``30deg`` and polygons by ``-10deg``). Also make sure to call ``to_deterministic()`` again for each new batch, otherwise you would augment all batches in the same way. Note that there is also :func:`Augmenter.augment`, which automatically handles the random state alignment. Parameters ---------- polygons_on_images : imgaug.augmentables.polys.PolygonsOnImage or list of imgaug.augmentables.polys.PolygonsOnImage The polygons to augment. Either a single instance of :class:`~imgaug.augmentables.polys.PolygonsOnImage` or a list of such instances, with each one of them containing the polygons of a single image. parents : None or list of imgaug.augmenters.meta.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as ``None``. It is set automatically for child augmenters. hooks : None or imgaug.imgaug.HooksKeypoints, optional :class:`~imgaug.imgaug.HooksKeypoints` object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.polys.PolygonsOnImage or list of imgaug.augmentables.polys.PolygonsOnImage Augmented polygons. )rr)rrr)rlpolygons_on_imagesrrrrraugment_polygonss<zAugmenter.augment_polygonscCr)a` Augment a batch of line strings. This is the corresponding function to :func:`Augmenter.augment_images``, just for line strings. Usually you will want to call :func:`Augmenter.augment_images` with a list of images, e.g. ``augment_images([A, B, C])`` and then ``augment_line_strings()`` with the corresponding list of line strings on these images, e.g. ``augment_line_strings([A_line, B_line, C_line])``, where ``A_line`` are the line strings on image ``A``. Make sure to first convert the augmenter(s) to deterministic states before augmenting images and their corresponding line strings, e.g. by >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.lines import LineString >>> from imgaug.augmentables.lines import LineStringsOnImage >>> A = B = C = np.ones((10, 10), dtype=np.uint8) >>> A_line = B_line = C_line = LineStringsOnImage( >>> [LineString([(0, 0), (1, 0), (1, 1), (0, 1)])], >>> shape=(10, 10)) >>> seq = iaa.Fliplr(0.5) >>> seq_det = seq.to_deterministic() >>> imgs_aug = seq_det.augment_images([A, B, C]) >>> lines_aug = seq_det.augment_line_strings([A_line, B_line, C_line]) Otherwise, different random values will be sampled for the image and line string augmentations, resulting in different augmentations (e.g. images might be rotated by ``30deg`` and line strings by ``-10deg``). Also make sure to call ``to_deterministic()`` again for each new batch, otherwise you would augment all batches in the same way. Note that there is also :func:`Augmenter.augment`, which automatically handles the random state alignment. Parameters ---------- line_strings_on_images : imgaug.augmentables.lines.LineStringsOnImage or list of imgaug.augmentables.lines.LineStringsOnImage The line strings to augment. Either a single instance of :class:`~imgaug.augmentables.lines.LineStringsOnImage` or a list of such instances, with each one of them containing the line strings of a single image. parents : None or list of imgaug.augmenters.meta.Augmenter, optional Parent augmenters that have previously been called before the call to this function. Usually you can leave this parameter as None. It is set automatically for child augmenters. hooks : None or imgaug.imgaug.HooksKeypoints, optional :class:`~imgaug.imgaug.HooksKeypoints` object to dynamically interfere with the augmentation process. Returns ------- imgaug.augmentables.lines.LineStringsOnImage or list of imgaug.augmentables.lines.LineStringsOnImage Augmented line strings. ) line_stringsr)rrZline_strings_aug)rlline_strings_on_imagesrrrrraugment_line_stringss?zAugmenter.augment_line_stringscCr)a Augment a batch of bounding boxes on images in-place. This is the internal version of :func:`Augmenter.augment_bounding_boxes`. It is called from :func:`Augmenter.augment_bounding_boxes` and should usually not be called directly. This method may transform the bounding boxes in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Added in 0.4.0. Parameters ---------- bounding_boxes_on_images : list of imgaug.augmentables.bbs.BoundingBoxesOnImage Polygons to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_bounding_boxes`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_bounding_boxes`. Returns ------- list of imgaug.augmentables.bbs.BoundingBoxesOnImage The augmented bounding boxes. rrlrrirrrrr_augment_bounding_boxes)s+z!Augmenter._augment_bounding_boxescCr)aAugment a batch of polygons on images in-place. This is the internal version of :func:`Augmenter.augment_polygons`. It is called from :func:`Augmenter.augment_polygons` and should usually not be called directly. This method may transform the polygons in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Parameters ---------- polygons_on_images : list of imgaug.augmentables.polys.PolygonsOnImage Polygons to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. Returns ------- list of imgaug.augmentables.polys.PolygonsOnImage The augmented polygons. r)rlrrirrrrr_augment_polygonsVs(zAugmenter._augment_polygonscCr)aAugment a batch of line strings in-place. This is the internal version of :func:`Augmenter.augment_line_strings`. It is called from :func:`Augmenter.augment_line_strings` and should usually not be called directly. This method may transform the line strings in-place. This method does not have to care about determinism or the Augmenter instance's ``random_state`` variable. The parameter ``random_state`` takes care of both of these. .. note:: This method exists mostly for legacy-support. Overwriting :func:`~imgaug.augmenters.meta.Augmenter._augment_batch` is now the preferred way of implementing custom augmentation routines. Parameters ---------- line_strings_on_images : list of imgaug.augmentables.lines.LineStringsOnImage Line strings to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_line_strings`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_line_strings`. Returns ------- list of imgaug.augmentables.lines.LineStringsOnImage The augmented line strings. rrlrrirrrrr_augment_line_stringss)zAugmenter._augment_line_stringscC|j||||dS)a Augment BBs by applying keypoint augmentation to their corners. Added in 0.4.0. Parameters ---------- bounding_boxes_on_images : list of imgaug.augmentables.bbs.BoundingBoxesOnImages or imgaug.augmentables.bbs.BoundingBoxesOnImages Bounding boxes to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. Returns ------- list of imgaug.augmentables.bbs.BoundingBoxesOnImage or imgaug.augmentables.bbs.BoundingBoxesOnImage The augmented bounding boxes. r_augment_cbaois_as_keypointsrrrr$_augment_bounding_boxes_as_keypointss z.Augmenter._augment_bounding_boxes_as_keypointscCs$tj|j|||d}|||||S)a Augment polygons by applying keypoint augmentation to their vertices. .. warning:: This method calls :func:`~imgaug.augmenters.meta.Augmenter._augment_keypoints` and expects it to do keypoint augmentation. The default for that method is to do nothing. It must therefore be overwritten, otherwise the polygon augmentation will also do nothing. Parameters ---------- polygons_on_images : list of imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.polys.PolygonsOnImage Polygons to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. recoverer : None or imgaug.augmentables.polys._ConcavePolygonRecoverer An instance used to repair invalid polygons after augmentation. Must offer the method ``recover_from(new_exterior, old_polygon, random_state=0)``. If ``None`` then invalid polygons are not repaired. Returns ------- list of imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.polys.PolygonsOnImage The augmented polygons. r) functoolspartialr_apply_to_polygons_as_keypoints)rlrrirr recovererfuncrrr_augment_polygons_as_keypointss(z(Augmenter._augment_polygons_as_keypointscCr)a Augment BBs by applying keypoint augmentation to their corners. Parameters ---------- line_strings_on_images : list of imgaug.augmentables.lines.LineStringsOnImages or imgaug.augmentables.lines.LineStringsOnImages Line strings to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_polygons`. Returns ------- list of imgaug.augmentables.lines.LineStringsOnImages or imgaug.augmentables.lines.LineStringsOnImages The augmented line strings. rrrrrr"_augment_line_strings_as_keypointss z,Augmenter._augment_line_strings_as_keypointscCs tj|j|||d}|||S)aV Augment bounding boxes by applying KP augmentation to their corners. Added in 0.4.0. Parameters ---------- cbaois : list of imgaug.augmentables.bbs.BoundingBoxesOnImage or list of imgaug.augmentables.polys.PolygonsOnImage or list of imgaug.augmentables.lines.LineStringsOnImage or imgaug.augmentables.bbs.BoundingBoxesOnImage or imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.lines.LineStringsOnImage Coordinate-based augmentables to augment. They may be changed in-place. random_state : imgaug.random.RNG The random state to use for all sampling tasks during the augmentation. parents : list of imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.augment_batch`. hooks : imgaug.imgaug.HooksKeypoints or None See :func:`~imgaug.augmenters.meta.Augmenter.augment_batch`. Returns ------- list of imgaug.augmentables.bbs.BoundingBoxesOnImage or list of imgaug.augmentables.polys.PolygonsOnImage or list of imgaug.augmentables.lines.LineStringsOnImage or imgaug.augmentables.bbs.BoundingBoxesOnImage or imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.lines.LineStringsOnImage The augmented coordinate-based augmentables. r)rrr_apply_to_cbaois_as_keypoints)rlcbaoisrirrrrrrrs  z&Augmenter._augment_cbaois_as_keypointsc Csxddlm}d}|durt|trdd|D}n|}|||}|dur)|S|dur1|nd}|||||}|S)a] Apply a callback to polygons in keypoint-representation. Added in 0.4.0. Parameters ---------- polygons_on_images : list of imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.polys.PolygonsOnImage Polygons to augment. They may be changed in-place. func : callable The function to apply. Receives a list of :class:`~imgaug.augmentables.kps.KeypointsOnImage` instances as its only parameter. recoverer : None or imgaug.augmentables.polys._ConcavePolygonRecoverer An instance used to repair invalid polygons after augmentation. Must offer the method ``recover_from(new_exterior, old_polygon, random_state=0)``. If ``None`` then invalid polygons are not repaired. random_state : None or imgaug.random.RNG The random state to use for the recoverer. Returns ------- list of imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.polys.PolygonsOnImage The augmented polygons. r )recover_psois_NcSg|]}|qSr)r)r Zpsoirrrr"drfz=Augmenter._apply_to_polygons_as_keypoints..)Zaugmentables.polysrr0rQrrr)) clsrrrrirZ psois_origZpsoisZrandom_state_recovererrrrr>s" !   z)Augmenter._apply_to_polygons_as_keypointscCs*ddlm}m}||}||}|||S)a Augment bounding boxes by applying KP augmentation to their corners. Added in 0.4.0. Parameters ---------- cbaois : list of imgaug.augmentables.bbs.BoundingBoxesOnImage or list of imgaug.augmentables.polys.PolygonsOnImage or list of imgaug.augmentables.lines.LineStringsOnImage or imgaug.augmentables.bbs.BoundingBoxesOnImage or imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.lines.LineStringsOnImage Coordinate-based augmentables to augment. They may be changed in-place. func : callable The function to apply. Receives a list of :class:`~imgaug.augmentables.kps.KeypointsOnImage` instances as its only parameter. Returns ------- list of imgaug.augmentables.bbs.BoundingBoxesOnImage or list of imgaug.augmentables.polys.PolygonsOnImage or list of imgaug.augmentables.lines.LineStringsOnImage or imgaug.augmentables.bbs.BoundingBoxesOnImage or imgaug.augmentables.polys.PolygonsOnImage or imgaug.augmentables.lines.LineStringsOnImage The augmented coordinate-based augmentables. r )convert_cbaois_to_kpsois invert_convert_cbaois_to_kpsois_)Zaugmentables.utilsrr)rrrrrZkpsoisZ kpsois_augrrrrzs z'Augmenter._apply_to_cbaois_as_keypointsc snt|sJdtt|fgd}dg|tfddDs.JddffddD}t|d ksFJd d|dvr_d vsRJd dg}t|d n  d d }t |d}tt  }t j} | d dkp| d dko| ddk} | rd}n|s|dkrtd|s|dkr|d urtdt| dd  dd  dd  dd  dd  dd d} |j| |d} |r| Sg} |dkrD]}|dkrt| d}| |d q| t| d|fqn,|D])}|d krdvrt| d}| |d q|vr'| t| d|fqt| dkr3| d St| S)a3Augment a batch. This method is a wrapper around :class:`~imgaug.augmentables.batches.UnnormalizedBatch` and :func:`~imgaug.augmenters.meta.Augmenter.augment_batch`. Hence, it supports the same datatypes as :class:`~imgaug.augmentables.batches.UnnormalizedBatch`. If `return_batch` was set to ``False`` (the default), the method will return a tuple of augmentables. It will return the same types of augmentables (but in augmented form) as input into the method. This behaviour is partly specific to the python version: * In **python 3.6+** (if ``return_batch=False``): * Any number of augmentables may be provided as input. * None of the provided named arguments *has to be* `image` or `images` (but of coarse you *may* provide them). * The return order matches the order of the named arguments, e.g. ``x_aug, y_aug, z_aug = augment(X=x, Y=y, Z=z)``. * In **python <3.6** (if ``return_batch=False``): * One or two augmentables may be used as input, not more than that. * One of the input arguments has to be `image` or `images`. * The augmented images are *always* returned first, independent of the input argument order, e.g. ``a_aug, b_aug = augment(b=b, images=a)``. This also means that the output of the function can only be one of the following three cases: a batch, list/array of images, tuple of images and something (like images + segmentation maps). If `return_batch` was set to ``True``, an instance of :class:`~imgaug.augmentables.batches.UnnormalizedBatch` will be returned. The output is the same for all python version and any number or combination of augmentables may be provided. So, to keep code downward compatible for python <3.6, use one of the following three options: * Use ``batch = augment(images=X, ..., return_batch=True)``. * Call ``images = augment(images=X)``. * Call ``images, other = augment(images=X, =Y)``. All augmentables must be provided as named arguments. E.g. ``augment()`` will crash, but ``augment(images=)`` will work. Parameters ---------- image : None or (H,W,C) ndarray or (H,W) ndarray, optional The image to augment. Only this or `images` can be set, not both. If `return_batch` is ``False`` and the python version is below 3.6, either this or `images` **must** be provided. images : None or (N,H,W,C) ndarray or (N,H,W) ndarray or iterable of (H,W,C) ndarray or iterable of (H,W) ndarray, optional The images to augment. Only this or `image` can be set, not both. If `return_batch` is ``False`` and the python version is below 3.6, either this or `image` **must** be provided. heatmaps : None or (N,H,W,C) ndarray or imgaug.augmentables.heatmaps.HeatmapsOnImage or iterable of (H,W,C) ndarray or iterable of imgaug.augmentables.heatmaps.HeatmapsOnImage, optional The heatmaps to augment. If anything else than :class:`~imgaug.augmentables.heatmaps.HeatmapsOnImage`, then the number of heatmaps must match the number of images provided via parameter `images`. The number is contained either in ``N`` or the first iterable's size. segmentation_maps : None or (N,H,W) ndarray or imgaug.augmentables.segmaps.SegmentationMapsOnImage or iterable of (H,W) ndarray or iterable of imgaug.augmentables.segmaps.SegmentationMapsOnImage, optional The segmentation maps to augment. If anything else than :class:`~imgaug.augmentables.segmaps.SegmentationMapsOnImage`, then the number of segmaps must match the number of images provided via parameter `images`. The number is contained either in ``N`` or the first iterable's size. keypoints : None or list of (N,K,2) ndarray or tuple of number or imgaug.augmentables.kps.Keypoint or iterable of (K,2) ndarray or iterable of tuple of number or iterable of imgaug.augmentables.kps.Keypoint or iterable of imgaug.augmentables.kps.KeypointOnImage or iterable of iterable of tuple of number or iterable of iterable of imgaug.augmentables.kps.Keypoint, optional The keypoints to augment. If a tuple (or iterable(s) of tuple), then iterpreted as ``(x,y)`` coordinates and must hence contain two numbers. A single tuple represents a single coordinate on one image, an iterable of tuples the coordinates on one image and an iterable of iterable of tuples the coordinates on several images. Analogous if :class:`~imgaug.augmentables.kps.Keypoint` instances are used instead of tuples. If an ndarray, then ``N`` denotes the number of images and ``K`` the number of keypoints on each image. If anything else than :class:`~imgaug.augmentables.kps.KeypointsOnImage` is provided, then the number of keypoint groups must match the number of images provided via parameter `images`. The number is contained e.g. in ``N`` or in case of "iterable of iterable of tuples" in the first iterable's size. bounding_boxes : None or (N,B,4) ndarray or tuple of number or imgaug.augmentables.bbs.BoundingBox or imgaug.augmentables.bbs.BoundingBoxesOnImage or iterable of (B,4) ndarray or iterable of tuple of number or iterable of imgaug.augmentables.bbs.BoundingBox or iterable of imgaug.augmentables.bbs.BoundingBoxesOnImage or iterable of iterable of tuple of number or iterable of iterable imgaug.augmentables.bbs.BoundingBox, optional The bounding boxes to augment. This is analogous to the `keypoints` parameter. However, each tuple -- and also the last index in case of arrays -- has size ``4``, denoting the bounding box coordinates ``x1``, ``y1``, ``x2`` and ``y2``. polygons : None or (N,#polys,#points,2) ndarray or imgaug.augmentables.polys.Polygon or imgaug.augmentables.polys.PolygonsOnImage or iterable of (#polys,#points,2) ndarray or iterable of tuple of number or iterable of imgaug.augmentables.kps.Keypoint or iterable of imgaug.augmentables.polys.Polygon or iterable of imgaug.augmentables.polys.PolygonsOnImage or iterable of iterable of (#points,2) ndarray or iterable of iterable of tuple of number or iterable of iterable of imgaug.augmentables.kps.Keypoint or iterable of iterable of imgaug.augmentables.polys.Polygon or iterable of iterable of iterable of tuple of number or iterable of iterable of iterable of tuple of imgaug.augmentables.kps.Keypoint, optional The polygons to augment. This is similar to the `keypoints` parameter. However, each polygon may be made up of several ``(x,y) ``coordinates (three or more are required for valid polygons). The following datatypes will be interpreted as a single polygon on a single image: * ``imgaug.augmentables.polys.Polygon`` * ``iterable of tuple of number`` * ``iterable of imgaug.augmentables.kps.Keypoint`` The following datatypes will be interpreted as multiple polygons on a single image: * ``imgaug.augmentables.polys.PolygonsOnImage`` * ``iterable of imgaug.augmentables.polys.Polygon`` * ``iterable of iterable of tuple of number`` * ``iterable of iterable of imgaug.augmentables.kps.Keypoint`` * ``iterable of iterable of imgaug.augmentables.polys.Polygon`` The following datatypes will be interpreted as multiple polygons on multiple images: * ``(N,#polys,#points,2) ndarray`` * ``iterable of (#polys,#points,2) ndarray`` * ``iterable of iterable of (#points,2) ndarray`` * ``iterable of iterable of iterable of tuple of number`` * ``iterable of iterable of iterable of tuple of imgaug.augmentables.kps.Keypoint`` line_strings : None or (N,#lines,#points,2) ndarray or imgaug.augmentables.lines.LineString or imgaug.augmentables.lines.LineStringOnImage or iterable of (#polys,#points,2) ndarray or iterable of tuple of number or iterable of imgaug.augmentables.kps.Keypoint or iterable of imgaug.augmentables.lines.LineString or iterable of imgaug.augmentables.lines.LineStringOnImage or iterable of iterable of (#points,2) ndarray or iterable of iterable of tuple of number or iterable of iterable of imgaug.augmentables.kps.Keypoint or iterable of iterable of imgaug.augmentables.lines.LineString or iterable of iterable of iterable of tuple of number or iterable of iterable of iterable of tuple of imgaug.augmentables.kps.Keypoint, optional The line strings to augment. See `polygons`, which behaves similarly. return_batch : bool, optional Whether to return an instance of :class:`~imgaug.augmentables.batches.UnnormalizedBatch`. If the python version is below 3.6 and more than two augmentables were provided (e.g. images, keypoints and polygons), then this must be set to ``True``. Otherwise an error will be raised. hooks : None or imgaug.imgaug.HooksImages, optional Hooks object to dynamically interfere with the augmentation process. Returns ------- tuple or imgaug.augmentables.batches.UnnormalizedBatch If `return_batch` was set to ``True``, a instance of ``UnnormalizedBatch`` will be returned. If `return_batch` was set to ``False``, a tuple of augmentables will be returned, e.g. ``(augmented images, augmented keypoints)``. The datatypes match the input datatypes of the corresponding named arguments. In python <3.6, augmented images are always the first entry in the returned tuple. In python 3.6+ the order matches the order of the named arguments. Examples -------- >>> import numpy as np >>> import imgaug as ia >>> import imgaug.augmenters as iaa >>> aug = iaa.Affine(rotate=(-25, 25)) >>> image = np.zeros((64, 64, 3), dtype=np.uint8) >>> keypoints = [(10, 20), (30, 32)] # (x,y) coordinates >>> images_aug, keypoints_aug = aug.augment( >>> image=image, keypoints=keypoints) Create a single image and a set of two keypoints on it, then augment both by applying a random rotation between ``-25`` deg and ``+25`` deg. The sampled rotation value is automatically aligned between image and keypoints. Note that in python <3.6, augmented images will always be returned first, independent of the order of the named input arguments. So ``keypoints_aug, images_aug = aug.augment(keypoints=keypoints, image=image)`` would **not** be correct (but in python 3.6+ it would be). >>> import numpy as np >>> import imgaug as ia >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.bbs import BoundingBox >>> aug = iaa.Affine(rotate=(-25, 25)) >>> images = [np.zeros((64, 64, 3), dtype=np.uint8), >>> np.zeros((32, 32, 3), dtype=np.uint8)] >>> keypoints = [[(10, 20), (30, 32)], # KPs on first image >>> [(22, 10), (12, 14)]] # KPs on second image >>> bbs = [ >>> [BoundingBox(x1=5, y1=5, x2=50, y2=45)], >>> [BoundingBox(x1=4, y1=6, x2=10, y2=15), >>> BoundingBox(x1=8, y1=9, x2=16, y2=30)] >>> ] # one BB on first image, two BBs on second image >>> batch_aug = aug.augment( >>> images=images, keypoints=keypoints, bounding_boxes=bbs, >>> return_batch=True) Create two images of size ``64x64`` and ``32x32``, two sets of keypoints (each containing two keypoints) and two sets of bounding boxes (the first containing one bounding box, the second two bounding boxes). These augmentables are then augmented by applying random rotations between ``-25`` deg and ``+25`` deg to them. The rotation values are sampled by image and aligned between all augmentables on the same image. The method finally returns an instance of :class:`~imgaug.augmentables.batches.UnnormalizedBatch` from which the augmented data can be retrieved via ``batch_aug.images_aug``, ``batch_aug.keypoints_aug``, and ``batch_aug.bounding_boxes_aug``. In python 3.6+, `return_batch` can be kept at ``False`` and the augmented data can be retrieved as ``images_aug, keypoints_aug, bbs_aug = augment(...)``. zExpected boolean as argument for 'return_batch', got type %s. Call augment() only with named arguments, e.g. augment(images=).)r&rrrrrrrcsg|]}|vqSrrr key)kwargsrrr"xrfz%Augmenter.augment..zaExpected augment() to be called with one of the following named arguments: %s. Got none of these.r6csg|]}|vr|qSrrr)expected_keys_callrrr"~r=rz>Got the following unknown keyword argument(s) in augment(): %sr&zUYou may only provide the argument 'image' OR 'images' to augment(), not both of them.NstandardrVr Z kwargs_keysr aRequested more than two outputs in augment(), but detected python version is below 3.6. More than two outputs are only supported for 3.6+ as earlier python versions offer no way to retrieve the order of the provided named arguments. To still use more than two outputs, add 'return_batch=True' as an argument and retrieve the outputs manually from the returned UnnormalizedBatch instance, e.g. via 'batch.images_aug' to get augmented images.aRequested two outputs from augment() that were not 'images', but detected python version is below 3.6. For security reasons, only single-output requests or requests with two outputs of which one is 'images' are allowed in <3.6. 'images' will then always be returned first. If you don't want this, use 'return_batch=True' mode in augment(), which returns a single UnnormalizedBatch instance instead and supports any combination of outputs.rrrrrrrrz%s_aug)r#r~r9r:anyrArBrrgetrrQkeyssys version_inforrrrrJtuple)rlZ return_batchrrZ expected_keysZ unknown_argsr&orderZnb_keysZvinfoZis_py36_or_newerrrresultrattrr)rrraugments U      $             zAugmenter.augmentcOs|j|i|S)z>> import numpy as np >>> import imgaug as ia >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.batches import Batch >>> >>> aug = iaa.Add(1) >>> images = np.zeros((16, 128, 128, 3), dtype=np.uint8) >>> batches = [Batch(images=np.copy(images)) for _ in range(100)] >>> with aug.pool(processes=-1, seed=2) as pool: >>> batches_aug = pool.map_batches(batches, chunksize=8) >>> print(np.sum(batches_aug[0].images_aug[0])) 49152 Create ``100`` batches of empty images. Each batch contains ``16`` images of size ``128x128``. The batches are then augmented on all CPU cores except one (``processes=-1``). After augmentation, the sum of pixel values from the first augmented image is printed. >>> import numpy as np >>> import imgaug as ia >>> import imgaug.augmenters as iaa >>> from imgaug.augmentables.batches import Batch >>> >>> aug = iaa.Add(1) >>> images = np.zeros((16, 128, 128, 3), dtype=np.uint8) >>> def generate_batches(): >>> for _ in range(100): >>> yield Batch(images=np.copy(images)) >>> >>> with aug.pool(processes=-1, seed=2) as pool: >>> batches_aug = pool.imap_batches(generate_batches(), chunksize=8) >>> batch_aug = next(batches_aug) >>> print(np.sum(batch_aug.images_aug[0])) 49152 Same as above. This time, a generator is used to generate batches of images. Again, the first augmented image's sum of pixels is printed. rN) processesmaxtasksperchildr)rrr)rlr r rrrrrrs GzAugmenter.poolc s:trCtjdkrfddtjdDnetjdkr&gnZtjdkr;ddddtjfgnEtdjftt sQJd t ft D]*\}}t|jdkraqUt|jdkrw|ddddtjf|<qUtd ||jf|j r|n| }g}D]}|||g||qt tj|}td d|D} td d|D} | |} | |t} tj| | df|ddjd } t|D]E}t D]>\}}t|D]5}|||||}| |t|}||jd}| |}||jd}|| ||||ddf<qqq| S)aUAugment images and draw the results as a single grid-like image. This method applies this augmenter to the provided images and returns a grid image of the results. Each cell in the grid contains a single augmented version of an input image. If multiple input images are provided, the row count is multiplied by the number of images and each image gets its own row. E.g. for ``images = [A, B]``, ``rows=2``, ``cols=3``:: A A A B B B A A A B B B for ``images = [A]``, ``rows=2``, ``cols=3``:: A A A A A A Parameters ------- images : (N,H,W,3) ndarray or (H,W,3) ndarray or (H,W) ndarray or list of (H,W,3) ndarray or list of (H,W) ndarray List of images to augment and draw in the grid. If a list, then each element is expected to have shape ``(H, W)`` or ``(H, W, 3)``. If a single array, then it is expected to have shape ``(N, H, W, 3)`` or ``(H, W, 3)`` or ``(H, W)``. rows : int Number of rows in the grid. If ``N`` input images are given, this value will automatically be multiplied by ``N`` to create rows for each image. cols : int Number of columns in the grid. Returns ------- (Hg, Wg, 3) ndarray The generated grid image with augmented versions of the input images. Here, ``Hg`` and ``Wg`` reference the output size of the grid, and *not* the sizes of the input images. rUcsg|]}|qSrr)r rNrrrr"]rfz'Augmenter.draw_grid..rrVr NzNUnexpected images shape, expected 2-, 3- or 4-dimensional array, got shape %s.z?Expected 'images' to be an ndarray or list of ndarrays. Got %s.zUUnexpected image shape at index %d, expected 2- or 3-dimensional array, got shape %s.cSg|]}|jdqS)rrXrrrrr"{r*cSr)r rrrrrr"|r*dtyper )r#r$rBrXrangerrarCr0rQr:rHrjto_deterministicrJr itertoolschainr\zerosr)rlr&rowscolsrNrZdetaugsZ augs_flatZ cell_heightZ cell_widthwidthheightgridrow_idxZimg_idxZcol_idx image_augZcell_y1Zcell_y2Zcell_x1Zcell_x2rrr draw_grid.sd -    zAugmenter.draw_gridcCs||||}t|dS)aAugment images and plot the results as a single grid-like image. This calls :func:`~imgaug.augmenters.meta.Augmenter.draw_grid` and simply shows the results. See that method for details. Parameters ---------- images : (N,H,W,3) ndarray or (H,W,3) ndarray or (H,W) ndarray or list of (H,W,3) ndarray or list of (H,W) ndarray List of images to augment and draw in the grid. If a list, then each element is expected to have shape ``(H, W)`` or ``(H, W, 3)``. If a single array, then it is expected to have shape ``(N, H, W, 3)`` or ``(H, W, 3)`` or ``(H, W)``. rows : int Number of rows in the grid. If ``N`` input images are given, this value will automatically be multiplied by ``N`` to create rows for each image. cols : int Number of columns in the grid. N)rr#Zimshow)rlr&rrrrrr show_gridszAugmenter.show_gridcsL|dus|dksJd|f|durddSfddt|DS)aDConvert this augmenter from a stochastic to a deterministic one. A stochastic augmenter samples pseudo-random values for each parameter, image and batch. A deterministic augmenter also samples new values for each parameter and image, but not batch. Instead, for consecutive batches it will sample the same values (provided the number of images and their sizes don't change). From a technical perspective this means that a deterministic augmenter starts each batch's augmentation with a random number generator in the same state (i.e. same seed), instead of advancing that state from batch to batch. Using determinism is useful to (a) get the same augmentations for two or more image batches (e.g. for stereo cameras), (b) to augment images and corresponding data on them (e.g. segmentation maps or bounding boxes) in the same way. Parameters ---------- n : None or int, optional Number of deterministic augmenters to return. If ``None`` then only one :class:`~imgaug.augmenters.meta.Augmenter` instance will be returned. If ``1`` or higher, a list containing ``n`` :class:`~imgaug.augmenters.meta.Augmenter` instances will be returned. Returns ------- imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter A single Augmenter object if `n` was None, otherwise a list of Augmenter objects (even if `n` was ``1``). Nr z'Expected 'n' to be None or >=1, got %s.rcsg|]}qSr)_to_deterministic)r _rqrrr"rfz.Augmenter.to_deterministic..)rsmxrange)rlnrrqrrs $zAugmenter.to_deterministiccCs|}|j|_d|_|S)aConvert this augmenter from a stochastic to a deterministic one. Augmenter-specific implementation of :func:`~imgaug.augmenters.meta.to_deterministic`. This function is expected to return a single new deterministic :class:`~imgaug.augmenters.meta.Augmenter` instance of this augmenter. Returns ------- det : imgaug.augmenters.meta.Augmenter Deterministic variation of this Augmenter object. Tr)ri derive_rng_rjrlaugrrrr!s zAugmenter._to_deterministicz&imgaug.augmenters.meta.Augmenter.seed_cC|j||ddS)zgOld name of :func:`~imgaug.augmenters.meta.Augmenter.seed_`. Deprecated since 0.4.0. entropydeterministic_tooN)seed_)rlrir-rrrreseedzAugmenter.reseedcCsvt|ts Jd||durtj}nt|}|jr|r$||_|D]}|D] }|j | |dq,q(dS)ai Seed this augmenter and all of its children. This method assigns a new random number generator to the augmenter and all of its children (if it has any). The new random number generator is *derived* from the provided seed or RNG -- or from the global random number generator if ``None`` was provided. Note that as child RNGs are *derived*, they do not all use the same seed. If this augmenter or any child augmenter had a random number generator that pointed to the global random state, it will automatically be replaced with a local random state. This is similar to what :func:`~imgaug.augmenters.meta.Augmenter.localize_random_state` does. This method is useful when augmentations are run in the background (i.e. on multiple cores). It should be called before sending this :class:`~imgaug.augmenters.meta.Augmenter` instance to a background worker or once within each worker with different seeds (i.e., if ``N`` workers are used, the function should be called ``N`` times). Otherwise, all background workers will use the same seeds and therefore apply the same augmentations. Note that :func:`Augmenter.augment_batches` and :func:`Augmenter.pool` already do this automatically. Added in 0.4.0. Parameters ---------- entropy : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional A seed or random number generator that is used to derive new random number generators for this augmenter and its children. If an ``int`` is provided, it will be interpreted as a seed. If ``None`` is provided, the global random number generator will be used. deterministic_too : bool, optional Whether to also change the seed of an augmenter ``A``, if ``A`` is deterministic. This is the case both when this augmenter object is ``A`` or one of its children is ``A``. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.Sequential([ >>> iaa.Crop(px=(0, 10)), >>> iaa.Crop(px=(0, 10)) >>> ]) >>> aug.seed_(1) Seed an augmentation sequence containing two crop operations. Even though the same seed was used, the two operations will still sample different pixel amounts to crop as the child-specific seed is merely derived from the provided seed. z:Expected 'deterministic_too' to be a boolean, got type %s.Nr+) r0boolrrrrjr)riget_children_listsr.r')rlr,r-rirDr)rrrr.s" :      zAugmenter.seed_TcCs|}|j|d|S)aAssign augmenter-specific RNGs to this augmenter and its children. See :func:`Augmenter.localize_random_state_` for more details. Parameters ---------- recursive : bool, optional See :func:`~imgaug.augmenters.meta.Augmenter.localize_random_state_`. Returns ------- imgaug.augmenters.meta.Augmenter Copy of the augmenter and its children, with localized RNGs.  recursive)rlocalize_random_state_)rlr4r)rrrlocalize_random_stateH s zAugmenter.localize_random_statecCsB|jr |j|_|r|D] }|D]}|j|dqq|S)aAssign augmenter-specific RNGs to this augmenter and its children. This method iterates over this augmenter and all of its children and replaces any pointer to the global RNG with a new local (i.e. augmenter-specific) RNG. A random number generator (RNG) is used for the sampling of random values. The global random number generator exists exactly once throughout the library and is shared by many augmenters. A local RNG (usually) exists within exactly one augmenter and is only used by that augmenter. Usually there is no need to change global into local RNGs. The only noteworthy exceptions are * Whenever you want to use determinism (so that the global RNG is not accidentally reverted). * Whenever you want to copy RNGs from one augmenter to another. (Copying the global RNG would usually not be useful. Copying the global RNG from augmenter A to B, then executing A and then B would result in B's (global) RNG's state having already changed because of A's sampling. So the samples of A and B would differ.) The case of determinism is handled automatically by :func:`~imgaug.augmenters.meta.Augmenter.to_deterministic`. Only when you copy RNGs (via :func:`~imgaug.augmenters.meta.Augmenter.copy_random_state`), you need to call this function first. Parameters ---------- recursive : bool, optional Whether to localize the RNGs of the augmenter's children too. Returns ------- imgaug.augmenters.meta.Augmenter Returns itself (with localized RNGs). r3)ri is_global_rngr'r2r5)rlr4rDr3rrrr5` s +  z Augmenter.localize_random_state_positioncCs |}|j|||||d|S)aMCopy the RNGs from a source augmenter sequence. Parameters ---------- source : imgaug.augmenters.meta.Augmenter See :func:`~imgaug.augmenters.meta.Augmenter.copy_random_state_`. recursive : bool, optional See :func:`~imgaug.augmenters.meta.Augmenter.copy_random_state_`. matching : {'position', 'name'}, optional See :func:`~imgaug.augmenters.meta.Augmenter.copy_random_state_`. matching_tolerant : bool, optional See :func:`~imgaug.augmenters.meta.Augmenter.copy_random_state_`. copy_determinism : bool, optional See :func:`~imgaug.augmenters.meta.Augmenter.copy_random_state_`. Returns ------- imgaug.augmenters.meta.Augmenter Copy of the augmenter itself (with copied RNGs). )r4matchingmatching_tolerantcopy_determinism)rcopy_random_state_)rlsourcer4r9r:r;r)rrrcopy_random_state szAugmenter.copy_random_statecCsj|r |g|jddn|g}|r|g|jddn|g}d}|dkr{dd|D} dd|D} t| t|kp?t| t|k} | rGtd| D]/} | | vro| | jrZt|| | j| | _|rn| | j| | _qI|sxtd | fqI|S|d krt|t|kr|std t ||D]\} }| jrt|| j|_|r| j|_q|Std |f) aCopy the RNGs from a source augmenter sequence (in-place). .. note:: The source augmenters are not allowed to use the global RNG. Call :func:`~imgaug.augmenters.meta.Augmenter.localize_random_state_` once on the source to localize all random states. Parameters ---------- source : imgaug.augmenters.meta.Augmenter The source augmenter(s) from where to copy the RNG(s). The source may have children (e.g. the source can be a :class:`~imgaug.augmenters.meta.Sequential`). recursive : bool, optional Whether to copy the RNGs of the source augmenter *and* all of its children (``True``) or just the source augmenter (``False``). matching : {'position', 'name'}, optional Defines the matching mode to use during recursive copy. This is used to associate source augmenters with target augmenters. If ``position`` then the target and source sequences of augmenters are turned into flattened lists and are associated based on their list indices. If ``name`` then the target and source augmenters are matched based on their names (i.e. ``augmenter.name``). matching_tolerant : bool, optional Whether to use tolerant matching between source and target augmenters. If set to ``False``: Name matching will raise an exception for any target augmenter which's name does not appear among the source augmenters. Position matching will raise an exception if source and target augmenter have an unequal number of children. copy_determinism : bool, optional Whether to copy the ``deterministic`` attributes from source to target augmenters too. Returns ------- imgaug.augmenters.meta.Augmenter The augmenter itself. TflatzYou called copy_random_state_() with a source that uses global RNGs. Call localize_random_state_() on the source first or initialize your augmenters with local random states, e.g. via Dropout(..., random_state=1234).r-cSi|]}|j|qSrr,r r)rrr  rfz0Augmenter.copy_random_state_..cSrArr,rBrrrrC rfzMatching mode 'name' with recursive=True was chosen in copy_random_state_, but either the source or target augmentation sequence contains multiple augmenters with the same name.z6Augmenter name '%s' not found among source augmenters.r8z@Source and target augmentation sequences have different lengths.zFUnknown matching method '%s'. Valid options are 'name' and 'position'.) get_all_childrenrBr#warnrir7rCr)rjrR)rlr=r4r9r:r;Z source_augsZ target_augsZglobal_rs_exc_msgZsource_augs_dictZtarget_augs_dictZdifferent_lengthsr-Z source_augZ target_augrrrr< spA   zAugmenter.copy_random_state_cCst)a Get the parameters of this augmenter. Returns ------- list List of parameters of arbitrary types (usually child class of :class:`~imgaug.parameters.StochasticParameter`, but not guaranteed to be). )NotImplementedErrorrqrrrget_parameters7 s zAugmenter.get_parameterscCgS)a)Get a list of lists of children of this augmenter. For most augmenters, the result will be a single empty list. For augmenters with children it will often be a list with one sublist containing all children. In some cases the augmenter will contain multiple distinct lists of children, e.g. an if-list and an else-list. This will lead to a result consisting of a single list with multiple sublists, each representing the respective sublist of children. E.g. for an if/else-augmenter that executes the children ``A1``, ``A2`` if a condition is met and otherwise executes the children ``B1``, ``B2``, ``B3`` the result will be ``[[A1, A2], [B1, B2, B3]]``. IMPORTANT: While the topmost list may be newly created, each of the sublist must be editable inplace resulting in a changed children list of the augmenter. E.g. if an Augmenter ``IfElse(condition, [A1, A2], [B1, B2, B3])`` returns ``[[A1, A2], [B1, B2, B3]]`` for a call to :func:`~imgaug.augmenters.meta.Augmenter.get_children_lists` and ``A2`` is removed inplace from ``[A1, A2]``, then the children lists of ``IfElse(...)`` must also change to ``[A1], [B1, B2, B3]``. This is used in :func:`~imgaug.augmeneters.meta.Augmenter.remove_augmenters_`. Returns ------- list of list of imgaug.augmenters.meta.Augmenter One or more lists of child augmenter. Can also be a single empty list. rrqrrrr2E rzAugmenter.get_children_listscCs\g}|D]%}|D] }|||j|d}t|dkr*|r%||q ||q q|S)a~Get all children of this augmenter as a list. If the augmenter has no children, the returned list is empty. Parameters ---------- flat : bool If set to ``True``, the returned list will be flat. Returns ------- list of imgaug.augmenters.meta.Augmenter The children as a nested or flat list. r?r)r2rJrDrBextend)rlr@rrDr)childrenrrrrDn s      zAugmenter.get_all_childrenc Cs|durg}g}|||r||||g}|D]"}|D]}|j|||d}t|dkr<|r7||q||qq|S)aFind augmenters that match a condition. This function will compare this augmenter and all of its children with a condition. The condition is a lambda function. Parameters ---------- func : callable A function that receives a :class:`~imgaug.augmenters.meta.Augmenter` instance and a list of parent :class:`~imgaug.augmenters.meta.Augmenter` instances and must return ``True``, if that augmenter is valid match or ``False`` otherwise. parents : None or list of imgaug.augmenters.meta.Augmenter, optional List of parent augmenters. Intended for nested calls and can usually be left as ``None``. flat : bool, optional Whether to return the result as a flat list (``True``) or a nested list (``False``). In the latter case, the nesting matches each augmenters position among the children. Returns ---------- list of imgaug.augmenters.meta.Augmenter Nested list if `flat` was set to ``False``. Flat list if `flat` was set to ``True``. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.Sequential([ >>> iaa.Fliplr(0.5, name="fliplr"), >>> iaa.Flipud(0.5, name="flipud") >>> ]) >>> print(aug.find_augmenters(lambda a, parents: a.name == "fliplr")) Return the first child augmenter (``Fliplr`` instance). N)rr@r)rJr2find_augmentersrBrI) rlrrr@r subparentsrDr)foundrrrrK s$*       zAugmenter.find_augmenterscCs|j|g||dS)a&Find augmenter(s) by name. Parameters ---------- name : str Name of the augmenter(s) to search for. regex : bool, optional Whether `name` parameter is a regular expression. flat : bool, optional See :func:`~imgaug.augmenters.meta.Augmenter.find_augmenters`. Returns ------- augmenters : list of imgaug.augmenters.meta.Augmenter Nested list if `flat` was set to ``False``. Flat list if `flat` was set to ``True``. )regexr@)find_augmenters_by_names)rlr-rNr@rrrfind_augmenters_by_name sz!Augmenter.find_augmenters_by_namecs4|rfdd}|j||dS|jfdd|dS)aFind augmenter(s) by names. Parameters ---------- names : list of str Names of the augmenter(s) to search for. regex : bool, optional Whether `names` is a list of regular expressions. If it is, an augmenter is considered a match if *at least* one of these expressions is a match. flat : boolean, optional See :func:`~imgaug.augmenters.meta.Augmenter.find_augmenters`. Returns ------- augmenters : list of imgaug.augmenters.meta.Augmenter Nested list if `flat` was set to ``False``. Flat list if `flat` was set to ``True``. cs"D] }t||jrdSqdS)NTF)rematchr-)r)_parentspatternnamesrrcomparer s z4Augmenter.find_augmenters_by_names..comparerr?cs |jvSror,)r)rrUrr s z4Augmenter.find_augmenters_by_names..)rK)rlrVrNr@rWrrUrrO s   z"Augmenter.find_augmenters_by_namescCs\|dur td|}||gr|std|rtSdS|s!|n|}|j|gd|S)aiRemove this augmenter or children that match a condition. Parameters ---------- func : callable Condition to match per augmenter. The function must expect the augmenter itself and a list of parent augmenters and returns ``True`` if that augmenter is supposed to be removed, or ``False`` otherwise. E.g. ``lambda a, parents: a.name == "fliplr" and len(parents) == 1`` removes an augmenter with name ``fliplr`` if it is the direct child of the augmenter upon which ``remove_augmenters()`` was initially called. copy : bool, optional Whether to copy this augmenter and all if its children before removing. If ``False``, removal is performed in-place. identity_if_topmost : bool, optional If ``True`` and the condition (lambda function) leads to the removal of the topmost augmenter (the one this function is called on initially), then that topmost augmenter will be replaced by an instance of :class:`~imgaug.augmenters.meta.Noop` (i.e. an augmenter that doesn't change its inputs). If ``False``, ``None`` will be returned in these cases. This can only be ``False`` if copy is set to ``True``. noop_if_topmost : bool, optional Deprecated since 0.4.0. Returns ------- imgaug.augmenters.meta.Augmenter or None This augmenter after the removal was performed. ``None`` is returned if the condition was matched for the topmost augmenter, `copy` was set to ``True`` and `noop_if_topmost` was set to ``False``. Examples -------- >>> import imgaug.augmenters as iaa >>> seq = iaa.Sequential([ >>> iaa.Fliplr(0.5, name="fliplr"), >>> iaa.Flipud(0.5, name="flipud"), >>> ]) >>> seq = seq.remove_augmenters(lambda a, parents: a.name == "fliplr") This removes the augmenter ``Fliplr`` from the ``Sequential`` object's children. NzMParameter 'noop_if_topmost' is deprecated. Use 'identity_if_topmost' instead.zdInplace removal of topmost augmenter requested, which is currently not possible. Set 'copy' to True.)r)r#r}rCIdentityrremove_augmenters_)rlrr)Zidentity_if_topmostZnoop_if_topmostr)rrrremove_augmenters s5  zAugmenter.remove_augmentersrZcCr*)zjOld name for :func:`~imgaug.meta.Augmenter.remove_augmenters_`. Deprecated since 0.4.0. )rrN)rZ)rlrrrrrremove_augmenters_inplaceJ r0z#Augmenter.remove_augmenters_inplacec Cs|durgn|}||g}|D]4}g}t|D]\}}|||r)|||fqt|D] \}\}}|||=q.|D]}|||q>> import imgaug.augmenters as iaa >>> seq = iaa.Sequential([ >>> iaa.Fliplr(0.5, name="fliplr"), >>> iaa.Flipud(0.5, name="flipud"), >>> ]) >>> seq.remove_augmenters_(lambda a, parents: a.name == "fliplr") This removes the augmenter ``Fliplr`` from the ``Sequential`` object's children. N)r2rHrJrZ) rlrrrLrD to_removerNr)Z count_removedrrrrZU s"    zAugmenter.remove_augmenters_cC t|S)zCreate a shallow copy of this Augmenter instance. Returns ------- imgaug.augmenters.meta.Augmenter Shallow copy of this Augmenter instance. ) copy_moduler)rqrrrr) s zAugmenter.copycCr^)zCreate a deep copy of this Augmenter instance. Returns ------- imgaug.augmenters.meta.Augmenter Deep copy of this Augmenter instance. )r_rrqrrrr s zAugmenter.deepcopycCs|Sro__str__rqrrr__repr__ szAugmenter.__repr__cCs4|}ddd|D}d|jj|j||jfS)Nr6cSrrr`)r paramrrrr" rfz%Augmenter.__str__..z.%s(name=%s, parameters=[%s], deterministic=%s))rGrAr|rtr-rj)rlparams params_strrrrra s zAugmenter.__str__NNrxrx)NFro)NN)FN)NNN)T)Tr8TF)FNT)FT)TTN)=rtrurvrwrnrr#rxrrrrrrrrrrrrrrrrrrrrrr classmethodrrr r rrr rr!r/r.r6r5r>r<rrGr2rDrKrPrOr[r\rZr)rrbra __classcell__rrrrr1s< +O  x B "7 0 % (A) DB E-*+" 0# ;  ? T` *  M 4 % ~  )  = $ H  0 r1c@sPeZdZdZ   dddZddZd d Zd d Zd dZddZ ddZ dS)r>aList augmenter containing child augmenters to apply to inputs. This augmenter is simply a list of other augmenters. To augment an image or any other data, it iterates over its children and applies each one of them independently to the data. (This also means that the second applied augmenter will already receive augmented input data and augment it further.) This augmenter offers the option to apply its children in random order using the `random_order` parameter. This should often be activated as it greatly increases the space of possible augmentations. .. note:: You are *not* forced to use :class:`~imgaug.augmenters.meta.Sequential` in order to use other augmenters. Each augmenter can be used on its own, e.g the following defines an augmenter for horizontal flips and then augments a single image: >>> import numpy as np >>> import imgaug.augmenters as iaa >>> image = np.zeros((32, 32, 3), dtype=np.uint8) >>> aug = iaa.Fliplr(0.5) >>> image_aug = aug.augment_image(image) **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 ---------- children : imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter or None, optional The augmenters to apply to images. random_order : bool, optional Whether to apply the child augmenters in random order. If ``True``, the order will be randomly sampled once per batch. 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 numpy as np >>> import imgaug.augmenters as iaa >>> imgs = [np.random.rand(10, 10)] >>> seq = iaa.Sequential([ >>> iaa.Fliplr(0.5), >>> iaa.Flipud(0.5) >>> ]) >>> imgs_aug = seq.augment_images(imgs) Create a :class:`~imgaug.augmenters.meta.Sequential` that always first applies a horizontal flip augmenter and then a vertical flip augmenter. Each of these two augmenters has a ``50%`` probability of actually flipping the image. >>> seq = iaa.Sequential([ >>> iaa.Fliplr(0.5), >>> iaa.Flipud(0.5) >>> ], random_order=True) >>> imgs_aug = seq.augment_images(imgs) Create a :class:`~imgaug.augmenters.meta.Sequential` that sometimes first applies a horizontal flip augmenter (followed by a vertical flip augmenter) and sometimes first a vertical flip augmenter (followed by a horizontal flip augmenter). Again, each of them has a ``50%`` probability of actually flipping the image. NFrxcCstj|||||d|durt|gn9t|tr"t||gn,t|rEtdd|Ds>Jdddd|Dt||n tdt |ft |s\Jdt |f||_ dS) Nrr-rirjcSr.rr/r2rrrr" r*z'Sequential.__init__..r5r6cSr7rr8r;rrrr" r=8Expected None or Augmenter or list of Augmenter, got %s.,Expected random_order to be boolean, got %s.) r1rnrQr0r#r?r@rArCr:r~ random_order)rlrJrmrr-rirjrrrrn s2    zSequential.__init__cCs|||||-|jr|t|}ntt|}|D]}||j|||g|d}qWd|S1s7wY|S)Nr)propagation_hooks_ctxrm permutationrBr#r$r)rlrrirrrindexrrrr, s   zSequential._augment_batch_cC8dd|D}|}||dd<|j|_d|_|S)NcSrrrrBrrrr"< rfz0Sequential._to_deterministic..Tr&rlrseqrrrr!;   zSequential._to_deterministiccC|jgSz=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.)rmrqrrrrGC zSequential.get_parameterscC||dS)zAdd an augmenter to the list of child augmenters. Parameters ---------- imgaug.augmenters.meta.Augmenter The augmenter to add. NrJrlrmrrraddG  zSequential.addcC|gSASee :func:`~imgaug.augmenters.meta.Augmenter.get_children_lists`.rrqrrrr2R zSequential.get_children_listscCs4ddd|D}d}||jj|j|j||jfS)Nr6cSrrr`rBrrrr"W rfz&Sequential.__str__..z=%s(name=%s, random_order=%s, children=[%s], deterministic=%s))rAr|rtr-rmrjrlZaugs_strrTrrrraV szSequential.__str__)NFNNrxrx) rtrurvrwrnrr!rGr|r2rarrrrr> sa  r>c@steZdZdZ   dddZeddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZdS)SomeOfaList augmenter that applies only some of its children to inputs. This augmenter is similar to :class:`~imgaug.augmenters.meta.Sequential`, but may apply only a fixed or random subset of its child augmenters to inputs. E.g. the augmenter could be initialized with a list of 20 child augmenters and then apply 5 randomly chosen child augmenters to images. The subset of augmenters to apply (and their order) is sampled once *per image*. If `random_order` is ``True``, the order will be sampled once *per batch* (similar to :class:`~imgaug.augmenters.meta.Sequential`). This augmenter currently does not support replacing (i.e. picking the same child multiple times) due to implementation difficulties in connection with deterministic augmenters. **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 ---------- n : int or tuple of int or list of int or imgaug.parameters.StochasticParameter or None, optional Count of augmenters to apply. * If ``int``, then exactly `n` of the child augmenters are applied to every image. * If tuple of two ``int`` s ``(a, b)``, then a random value will be uniformly sampled per image from the discrete interval ``[a..b]`` and denote the number of child augmenters to pick and apply. ``b`` may be set to ``None``, which is then equivalent to ``(a..C)`` with ``C`` denoting the number of children that the augmenter has. * If ``StochasticParameter``, then ``N`` numbers will be sampled for ``N`` images. The parameter is expected to be discrete. * If ``None``, then the total number of available children will be used (i.e. all children will be applied). children : imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter or None, optional The augmenters to apply to images. If this is a list of augmenters, it will be converted to a :class:`~imgaug.augmenters.meta.Sequential`. random_order : boolean, optional Whether to apply the child augmenters in random order. If ``True``, the order will be randomly sampled once per batch. 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 >>> imgs = [np.random.rand(10, 10)] >>> seq = iaa.SomeOf(1, [ >>> iaa.Fliplr(1.0), >>> iaa.Flipud(1.0) >>> ]) >>> imgs_aug = seq.augment_images(imgs) Apply either ``Fliplr`` or ``Flipud`` to images. >>> seq = iaa.SomeOf((1, 3), [ >>> iaa.Fliplr(1.0), >>> iaa.Flipud(1.0), >>> iaa.GaussianBlur(1.0) >>> ]) >>> imgs_aug = seq.augment_images(imgs) Apply one to three of the listed augmenters (``Fliplr``, ``Flipud``, ``GaussianBlur``) to images. They are always applied in the provided order, i.e. first ``Fliplr``, second ``Flipud``, third ``GaussianBlur``. >>> seq = iaa.SomeOf((1, None), [ >>> iaa.Fliplr(1.0), >>> iaa.Flipud(1.0), >>> iaa.GaussianBlur(1.0) >>> ], random_order=True) >>> imgs_aug = seq.augment_images(imgs) Apply one to all of the listed augmenters (``Fliplr``, ``Flipud``, ``GaussianBlur``) to images. They are applied in random order, i.e. sometimes ``GaussianBlur`` first, followed by ``Fliplr``, sometimes ``Fliplr`` followed by ``Flipud`` followed by ``Blur`` etc. The order is sampled once per batch. NFrxcCstj|||||d|durt|gn9t|tr"t||gn,t|rEtdd|Ds>Jdddd|Dt||n tdt |f| |\|_ |_ t |seJdt |f||_dS) NrjcSr.rr/r2rrrr" r*z#SomeOf.__init__..r5r6cSr7rr8r;rrrr" r=rkrl)r1rnrQr0r#r?r@rArCr: _handle_arg_nr%n_moder~rm)rlr%rJrmrr-rirjrrrrn s4    zSomeOf.__init__cCst|rt|}d}||fS|durd}d}||fSt|rxt|dks/Jdt|ft|drJ|ddurJt|ddf}d}||fSt|drlt|drltt|dt|d}d}||fStd d d |Dft|tj rd}||fStd t |f) NrjNoner z.zDExpected int, (int, None), (int, int) or StochasticParameter, got %s) r#Zis_single_numberintr?rBiapDiscreteUniformrCr0ZStochasticParameterr:)rr%rrrrr s>     zSomeOf._handle_arg_ncCs|jdkr |jg|S|jdkrt|g|S|jdkr/t|jdt|}|j|f|dS|jdkr=|jj|f|dStd|jf)NrjrrrrirzInvalid n_mode: %s)rr%rBrr draw_samplesrC)rl nb_imagesrircrrr_get_n s     z SomeOf._get_ncCs*|js tt|}|S|t|}|Sro)rmrarangerBro)rlriaugmenter_orderrrr_get_augmenter_order s zSomeOf._get_augmenter_ordercsx||}fdd|D}tj|tftjd}t|D]\}}|dkr/d||d|f<q|D]}||q2|S)Ncsg|] }t|tqSr)minrB)r r%rqrrr"' z0SomeOf._get_augmenter_active..rrr )rrrrBr1rHshuffle)rlnb_rowsrinnaugmenter_activerZn_truerowrrqr_get_augmenter_active$ s  zSomeOf._get_augmenter_activec Cs||||E||}||j|}|D],}|dd|fd}t|dkrB||} ||j| ||g|d} ||| }q|WdS1sOwYdS)Nrr) rnrrrZnonzerorBsubselect_rows_by_indicesr!invert_subselect_rows_by_indices_) rlrrirrrrZaugmenter_indexactive batch_subrrrr1 s(    $zSomeOf._augment_batch_cCrq)NcSrrrrrBrrrr"V rfz,SomeOf._to_deterministic..Tr&rsrrrr!U ruzSomeOf._to_deterministiccCrvrw)r%rqrrrrG] rxzSomeOf.get_parameterscCry)zAdd an augmenter to the list of child augmenters. Parameters ---------- augmenter : imgaug.augmenters.meta.Augmenter The augmenter to add. Nrzr{rrrr|a r}z SomeOf.addcCr~rrrqrrrr2l rzSomeOf.get_children_listscCs@ddd|D}d}||jj|jt|jt|j||jfS)Nr6cSrrr`rBrrrr"q rfz"SomeOf.__str__..zE%s(name=%s, n=%s, random_order=%s, augmenters=[%s], deterministic=%s))rAr|rtr-r9r%rmrjrrrrrap szSomeOf.__str__)NNFNNrxrx)rtrurvrwrnrhrrrrrr!rGr|r2rarrrrra s"r !   $ rc&eZdZdZ  dfdd ZZS)OneOfaAugmenter that always executes exactly one of its children. **Supported dtypes**: See :class:`imgaug.augmenters.meta.SomeOf`. Parameters ---------- children : imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter The choices of augmenters to apply. 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 >>> images = [np.ones((10, 10), dtype=np.uint8)] # dummy example images >>> seq = iaa.OneOf([ >>> iaa.Fliplr(1.0), >>> iaa.Flipud(1.0) >>> ]) >>> images_aug = seq.augment_images(images) Flip each image either horizontally or vertically. >>> images = [np.ones((10, 10), dtype=np.uint8)] # dummy example images >>> seq = iaa.OneOf([ >>> iaa.Fliplr(1.0), >>> iaa.Sequential([ >>> iaa.GaussianBlur(1.0), >>> iaa.Dropout(0.05), >>> iaa.AdditiveGaussianNoise(0.1*255) >>> ]), >>> iaa.Noop() >>> ]) >>> images_aug = seq.augment_images(images) Either flip each image horizontally, or add blur+dropout+noise or do nothing. Nrxc s"tt|jd|d||||ddS)Nr F)r%rJrmrr-rirj)rzrrn)rlrJrr-rirjrrrrn s  zOneOf.__init__rfrtrurvrwrnrirrrrr{ s :rcsPeZdZdZ   dfdd ZddZd d Zd d Zd dZddZ Z S) Sometimesa Apply child augmenter(s) with a probability of `p`. Let ``C`` be one or more child augmenters given to :class:`~imgaug.augmenters.meta.Sometimes`. Let ``p`` be the fraction of images (or other data) to augment. Let ``I`` be the input images (or other data). Let ``N`` be the number of input images (or other entities). Then (on average) ``p*N`` images of ``I`` will be augmented using ``C``. **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 ---------- p : float or imgaug.parameters.StochasticParameter, optional Sets the probability with which the given augmenters will be applied to input images/data. E.g. a value of ``0.5`` will result in ``50%`` of all input images (or other augmentables) being augmented. then_list : None or imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter, optional Augmenter(s) to apply to `p%` percent of all images. If this is a list of augmenters, it will be converted to a :class:`~imgaug.augmenters.meta.Sequential`. else_list : None or imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter, optional Augmenter(s) to apply to ``(1-p)`` percent of all images. These augmenters will be applied only when the ones in `then_list` are *not* applied (either-or-relationship). If this is a list of augmenters, it will be converted to a :class:`~imgaug.augmenters.meta.Sequential`. 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.Sometimes(0.5, iaa.GaussianBlur(0.3)) Apply ``GaussianBlur`` to ``50%`` of all input images. >>> aug = iaa.Sometimes(0.5, iaa.GaussianBlur(0.3), iaa.Fliplr(1.0)) Apply ``GaussianBlur`` to ``50%`` of all input images. Apply ``Fliplr`` to the other ``50%`` of all input images. ?NrxcsRtt|j||||dt|d|_t||jddd|_t||jddd|_ dS)Nrjpthen)rEelse) rzrrnrhandle_probability_paramrrFr- then_list else_list)rlrrrrr-rirjrrrrn s    zSometimes.__init__c Cs||||Z|jj|jf|d}t|dkd}t|dkd}||g}|j|jg} t|| D]$\} } | durWt | dkrW| | } | j | ||g|d} | | | }q3|WdS1sdwYdS)Nrr rr) rnrrrrwhererrrRrBrrr) rlrrirrZsamplesZindices_then_listZindices_else_listZ indice_listsZaugmenter_listsindicesZ augmentersrrrrrs,   $zSometimes._augment_batch_cCsV|}|jdur|jn|j|_|jdur|jn|j|_d|_|j|_|Srg)r)rrrrjrir'r(rrrr!;s     zSometimes._to_deterministiccCrvrw)rrqrrrrGGrxzSometimes.get_parameterscCs4g}|jdur ||j|jdur||j|S)rN)rrJr)rlrrrrr2Ks     zSometimes.get_children_listscCs&d}||jj|j|j|j|j|jfS)Nz?%s(p=%s, name=%s, then_list=%s, else_list=%s, deterministic=%s))r|rtrr-rrrjrlrTrrrraTs zSometimes.__str__)rNNNNrxrx) rtrurvrwrnrr!rGr2rarirrrrr sK   rcseZdZdZ   dfdd ZddZedd Zed d Zed d Z eddZ ddZ ddZ ddZ ddZddZddZddZZS) WithChannelsa Apply child augmenters to specific channels. Let ``C`` be one or more child augmenters given to this augmenter. Let ``H`` be a list of channels. Let ``I`` be the input images. Then this augmenter will pick the channels ``H`` from each image in ``I`` (resulting in new images) and apply ``C`` to them. The result of the augmentation will be merged back into the original images. **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 ---------- channels : None or int or list of int, optional Sets the channels to be extracted from each image. If ``None``, all channels will be used. Note that this is not stochastic - the extracted channels are always the same ones. children : imgaug.augmenters.meta.Augmenter or list of imgaug.augmenters.meta.Augmenter or None, optional One or more augmenters to apply to images, after the channels are extracted. 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.WithChannels([0], iaa.Add(10)) Assuming input images are RGB, then this augmenter will add ``10`` only to the first channel, i.e. it will make images appear more red. Nrxcstt|j||||d|durd|_n3t|r|g|_n)t|r>tdd|D}|s:Jddd|Df||_n tdt |ft ||j d|_ dS)NrjcSr'rr#is_single_integerr Zchannelrrrr"s z)WithChannels.__init__..z&Expected integers as channels, got %s.cSrrrrrrrr"rfz7Expected None, int or list of ints as channels, got %s.r) rzrrnr]r#rr?r@rCr:rFr-rJ)rlr]rJrr-rirjZ only_intsrrrrns,     zWithChannels.__init__c Cs>|jdurt|jdkr|S|||||}|jdur&||j|_|jj|||g|d}|jdurX||j|j| |j|j| |j|j| |j|j|_|j D]}|j dkrvt||j}||j|}t||j|q[|jdur||j|j|_Wd|SWd|S1swY|S)Nrrr&)r]rBrnrr&_reduce_images_to_channelsrJr_assert_lengths_not_changed_assert_shapes_not_changed_assert_dtypes_not_changed_recover_images_arrayrr-rr_replace_unaugmented_cellsrr!_invert_reduce_images_to_channels) rlrrirrZbatch_cprZ value_oldrrrrrsF        & &&zWithChannels._augment_batch_cCs,t|t|ksJdt|t|fdS)NzhExpected that number of images does not change during augmentation, but got %d vs. originally %d images.)rBrrr&rrrrs  z(WithChannels._assert_lengths_not_changedcCs~t|rt|r|jdd|jddk}n tddt||D}|s=Jdtdd|Dtdd|DfdS)Nr rVcSs,g|]\}}|jdd|jddkqSrr rr rrrrrr"s z;WithChannels._assert_shapes_not_changed..z\Heights/widths of images changed in WithChannels from %s to %s, but expected to be the same.cSg|] }|jddqSrrrrrrr"rcSrrrr rrrrr"r)r#r$rXr@rRr9)rrr&Z shapes_samerrrrsz'WithChannels._assert_shapes_not_changedcCsrt|rt|r|jj|jjk}n tddt||D}|s7Jdtdd|Dtdd|DfdS)NcSs g|] \}}|jj|jjkqSrrr-rrrrr"sz;WithChannels._assert_dtypes_not_changed..zTdtypes of images changed in WithChannels from %s to %s, but expected to be the same.cSg|]}|jjqSrrrrrrr" rfcSrrrrrrrr" rf)r#r$rr-r@rRr9)rrr&Z dtypes_samerrrrsz'WithChannels._assert_dtypes_not_changedcCst|r t|S|Sro)r#r$rr_rrrrrs  z"WithChannels._recover_images_arraycs8jdur|St|r|djfSfdd|DS)N.csg|] }|djfqS).r]rrqrrr"rz;WithChannels._reduce_images_to_channels..)r]r#r$)rlr&rrqrrs  z'WithChannels._reduce_images_to_channelscCs4|jdur|St||D] \}}||d|jf<q |S)N.)r]rR)rlrr&rrrrrr s z.WithChannels._invert_reduce_images_to_channelscsR|jdur|St|jdd|D}fdd|D}ddt|||D}|S)NcSs(g|]}t|jdkr|jdndqS)r r rW)r Zaugmrrrr".s z;WithChannels._replace_unaugmented_cells..csg|]}|qSrr)r nb_channelsZnb_channels_to_augrrr"4s cSs"g|] \}}}|dkr |n|qS)rr)r Zaugmentable_augZ augmentableZfraction_augmentedrrrr"6s)r]rBrR)rlZaugmentables_aug augmentablesZnb_channels_lstZfraction_augmented_lstrrrrr)s    z'WithChannels._replace_unaugmented_cellscCs*|}|j|_d|_|j|_|Srg)r)rJrrjrir'r(rrrr!<s   zWithChannels._to_deterministiccCrvrwrrqrrrrGCrxzWithChannels.get_parameterscCrvr)rJrqrrrr2GrxzWithChannels.get_children_listscCs"d}||jj|j|j|j|jfS)Nz7%s(channels=%s, name=%s, children=%s, deterministic=%s))r|rtr]r-rJrjrrrrraKs zWithChannels.__str__)NNNNrxrx)rtrurvrwrnrrhrrrrrrrr!rGr2rarirrrrr^s,@-     rc6eZdZdZ  d fdd ZddZdd ZZS) rYaAugmenter that does not change the input data. This augmenter is useful e.g. during validation/testing as it allows to re-use the training code without actually performing any augmentation. Added in 0.4.0. **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 ---------- 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.Identity() Create an augmenter that does not change inputs. Nrxctt|j||||ddSNrj)rzrYrnrrrrrn  zIdentity.__init__cCrror)rlrrirrrrrrszIdentity._augment_batch_cCrHrwrrqrrrrGzIdentity.get_parametersrfrtrurvrwrnrrGrirrrrrYTs5rYcr)NoopaAlias for augmenter :class:`Identity`. It is recommended to now use :class:`Identity`. :class:`Noop` might be deprecated in the future. **Supported dtypes**: See :class:`~imgaug.augmenters.meta.Identity`. 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.Noop() Create an augmenter that does not change inputs. Nrxcrr)rzrrnrrrrrnrz Noop.__init__rfrrrrrrs &rcsneZdZdZ      dfdd ZddZd d Zd d Zd dZddZ ddZ ddZ ddZ Z S)LambdaaAugmenter that calls a lambda function for each input batch. This is useful to add missing functions to a list of augmenters. **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 ---------- func_images : None or callable, optional The function to call for each batch of images. It must follow the form:: function(images, random_state, parents, hooks) and return the changed images (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_images`. If this is ``None`` instead of a function, the images will not be altered. func_heatmaps : None or callable, optional The function to call for each batch of heatmaps. It must follow the form:: function(heatmaps, random_state, parents, hooks) and return the changed heatmaps (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_heatmaps`. If this is ``None`` instead of a function, the heatmaps will not be altered. func_segmentation_maps : None or callable, optional The function to call for each batch of segmentation maps. It must follow the form:: function(segmaps, random_state, parents, hooks) and return the changed segmaps (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_segmentation_maps`. If this is ``None`` instead of a function, the segmentatio maps will not be altered. func_keypoints : None or callable, optional The function to call for each batch of keypoints. It must follow the form:: function(keypoints_on_images, random_state, parents, hooks) and return the changed keypoints (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_keypoints`. If this is ``None`` instead of a function, the keypoints will not be altered. func_bounding_boxes : "keypoints" or None or callable, optional The function to call for each batch of bounding boxes. It must follow the form:: function(bounding_boxes_on_images, random_state, parents, hooks) and return the changed bounding boxes (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_bounding_boxes`. If this is ``None`` instead of a function, the bounding boxes will not be altered. If this is the string ``"keypoints"`` instead of a function, the bounding boxes will automatically be augmented by transforming their corner vertices to keypoints and calling `func_keypoints`. Added in 0.4.0. func_polygons : "keypoints" or None or callable, optional The function to call for each batch of polygons. It must follow the form:: function(polygons_on_images, random_state, parents, hooks) and return the changed polygons (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_polygons`. If this is ``None`` instead of a function, the polygons will not be altered. If this is the string ``"keypoints"`` instead of a function, the polygons will automatically be augmented by transforming their corner vertices to keypoints and calling `func_keypoints`. func_line_strings : "keypoints" or None or callable, optional The function to call for each batch of line strings. It must follow the form:: function(line_strings_on_images, random_state, parents, hooks) and return the changed line strings (may be transformed in-place). This is essentially the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_line_strings`. If this is ``None`` instead of a function, the line strings will not be altered. If this is the string ``"keypoints"`` instead of a function, the line strings will automatically be augmented by transforming their corner vertices to keypoints and calling `func_keypoints`. Added in 0.4.0. 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 >>> >>> def func_images(images, random_state, parents, hooks): >>> images[:, ::2, :, :] = 0 >>> return images >>> >>> aug = iaa.Lambda( >>> func_images=func_images >>> ) Replace every second row in input images with black pixels. Leave other data (e.g. heatmaps, keypoints) unchanged. >>> def func_images(images, random_state, parents, hooks): >>> images[:, ::2, :, :] = 0 >>> return images >>> >>> def func_heatmaps(heatmaps, random_state, parents, hooks): >>> for heatmaps_i in heatmaps: >>> heatmaps.arr_0to1[::2, :, :] = 0 >>> return heatmaps >>> >>> def func_keypoints(keypoints_on_images, random_state, parents, hooks): >>> return keypoints_on_images >>> >>> aug = iaa.Lambda( >>> func_images=func_images, >>> func_heatmaps=func_heatmaps, >>> func_keypoints=func_keypoints >>> ) Replace every second row in images with black pixels, set every second row in heatmaps to zero and leave other data (e.g. keypoints) unchanged. Nrrxc sFtt|j|| | | d||_||_||_||_||_||_||_ dSr) rzrrn func_images func_heatmapsfunc_segmentation_mapsfunc_keypointsfunc_bounding_boxes func_polygonsfunc_line_strings) rlrrrrrrrrr-rirjrrrrnxs  zLambda.__init__cCs|jdur |||||S|Sro)rrrrrrs zLambda._augment_imagescCl|jdur4|||||}t|sJdt|ftdd|D}|s2Jddd|Df|S|S)NzcExpected callback function for heatmaps to return list of imgaug.HeatmapsOnImage instances, got %s.cSg|]}t|tjqSr)r0r#rrYrrrr" z,Lambda._augment_heatmaps..cSrrrrYrrrr"rf)rr#r?r:r@)rlrrirrrZ only_heatmapsrrrrs&   zLambda._augment_heatmapscCr)NzvExpected callback function for segmentation maps to return list of imgaug.SegmentationMapsOnImage() instances, got %s.cSrr)r0r#rrYrrrr"rz5Lambda._augment_segmentation_maps..cSrrrrYrrrr"rf)rr#r?r:r@)rlrrirrrZ only_segmapsrrrrs&  z!Lambda._augment_segmentation_mapscCr)NzvExpected callback function for keypoints to return list of imgaug.augmentables.kps.KeypointsOnImage instances, got %s.cSrr)r0r#rrYrrrr"rz-Lambda._augment_keypoints..cSrrrrYrrrr"rf)rr#r?r:r@)rlrrirrrZonly_keypointsrrrrs&  zLambda._augment_keypointscCsddlm}|jdkr|j|||||dS|jdurJ|||||}t|s1Jdt|ftdd|D}|sHJddd|Df|S|S) Nr)_ConcavePolygonRecovererr)rvExpected callback function for polygons to return list of imgaug.augmentables.polys.PolygonsOnImage instances, got %s.cSrr)r0r#rrYrrrr"rz,Lambda._augment_polygons..cSrrrrYrrrr"rf)Zimgaug.augmentables.polysrrrr#r?r:r@)rlrrirrrrZ only_polygonsrrrrs2    zLambda._augment_polygonscCs|jdkr |||||S|jdurA|||||}t|s(Jdt|ftdd|D}|s?Jddd|Df|S|S)Nrz}Expected callback function for line strings to return list of imgaug.augmentables.lines.LineStringsOnImage instances, got %s.cSrr)r0r#ZLineStringsOnImagerYrrrr"rz0Lambda._augment_line_strings..z~Expected callback function for line strings to return list of imgaug.augmentables.lines.LineStringsOnImages instances, got %s.cSrrrrYrrrr"rf)rrr#r?r:r@)rlrrirrrZonly_lsrrrrs.   zLambda._augment_line_stringsc Cs|jdkr |||||S|jdurj|||||}t|s(Jdt|ftdd|D}|s?Jddd|Df|D]&}|jD] }|j|jkrW|j|j|_|_|j |j krf|j |j |_ |_ qFqA|S|S)NrzExpected callback function for bounding boxes to return list of imgaug.augmentables.bbs.BoundingBoxesOnImage instances, got %s.cSrr)r0r#rrYrrrr"rz2Lambda._augment_bounding_boxes..rcSrrrrYrrrr"rf) rrr#r?r:r@rx1Zx2y1y2) rlrrirrrZonly_bbsZbboiZbbrrrrs>      zLambda._augment_bounding_boxescCrHrwrrqrrrrG rzLambda.get_parameters) NNNNrrrNNrxrx)rtrurvrwrnrrrrrrrrGrirrrrrs$0rcs.eZdZdZ      dfdd ZZS) AssertLambdaaAssert conditions based on lambda-function to be the case for input data. This augmenter applies a lambda function to each image or other input. The lambda function must return ``True`` or ``False``. If ``False`` is returned, an assertion error is produced. This is useful to ensure that generic assumption about the input data are actually the case and error out early otherwise. **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 ---------- func_images : None or callable, optional The function to call for each batch of images. It must follow the form:: function(images, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_images`. func_heatmaps : None or callable, optional The function to call for each batch of heatmaps. It must follow the form:: function(heatmaps, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_heatmaps`. func_segmentation_maps : None or callable, optional The function to call for each batch of segmentation maps. It must follow the form:: function(segmaps, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_segmentation_maps`. func_keypoints : None or callable, optional The function to call for each batch of keypoints. It must follow the form:: function(keypoints_on_images, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_keypoints`. func_bounding_boxes : None or callable, optional The function to call for each batch of bounding boxes. It must follow the form:: function(bounding_boxes_on_images, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_bounding_boxes`. Added in 0.4.0. func_polygons : None or callable, optional The function to call for each batch of polygons. It must follow the form:: function(polygons_on_images, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_polygons`. func_line_strings : None or callable, optional The function to call for each batch of line strings. It must follow the form:: function(line_strings_on_images, random_state, parents, hooks) and return either ``True`` (valid input) or ``False`` (invalid input). It essentially re-uses the interface of :func:`~imgaug.augmenters.meta.Augmenter._augment_line_strings`. Added in 0.4.0. 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. Nrxc s\dd} tt|j| |d| |d| |d| |d| |d| |d| |d || | | d dS) NcSs|dur t||dSdS)N)augmentable_name)_AssertLambdaCallback)varrrrr_defaults  z'AssertLambda.__init__.._defaultr&rrrrrr rrrrrrrrr-rirj)rzrrn) rlrrrrrrrrr-rirjrrrrrns  zAssertLambda.__init__) NNNNNNNNNrxrxrrrrrrsxrc@eZdZddZddZdS)rcCs||_||_dSrorr)rlrrrrrrns z_AssertLambdaCallback.__init__cCs$|||||sJd|jf|S)Nz@Input %s did not fulfill user-defined assertion in AssertLambda.r)rlrrirrrrrr s z_AssertLambdaCallback.__call__Nrtrurvrnr rrrrrs rcsFeZdZdZ      d fdd ZeddZed d ZZS) AssertShapeaAssert that inputs have a specified shape. **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 ---------- shape : tuple The expected shape, given as a ``tuple``. The number of entries in the ``tuple`` must match the number of dimensions, i.e. it must contain four entries for ``(N, H, W, C)``. If only a single entity is augmented, e.g. via :func:`~imgaug.augmenters.meta.Augmenter.augment_image`, then ``N`` is ``1`` in the input to this augmenter. Images that don't have a channel axis will automatically have one assigned, i.e. ``C`` is at least ``1``. For each component of the ``tuple`` one of the following datatypes may be used: * If a component is ``None``, any value for that dimensions is accepted. * If a component is ``int``, exactly that value (and no other one) will be accepted for that dimension. * If a component is a ``tuple`` of two ``int`` s with values ``a`` and ``b``, only a value within the interval ``[a, b)`` will be accepted for that dimension. * If an entry is a ``list`` of ``int`` s, only a value from that ``list`` will be accepted for that dimension. check_images : bool, optional Whether to validate input images via the given shape. check_heatmaps : bool, optional Whether to validate input heatmaps via the given shape. The number of heatmaps will be verified as ``N``. For each :class:`~imgaug.augmentables.heatmaps.HeatmapsOnImage` instance its array's height and width will be verified as ``H`` and ``W``, but not the channel count. check_segmentation_maps : bool, optional Whether to validate input segmentation maps via the given shape. The number of segmentation maps will be verified as ``N``. For each :class:`~imgaug.augmentables.segmaps.SegmentationMapOnImage` instance its array's height and width will be verified as ``H`` and ``W``, but not the channel count. check_keypoints : bool, optional Whether to validate input keypoints via the given shape. This will check (a) the number of keypoints and (b) for each :class:`~imgaug.augmentables.kps.KeypointsOnImage` instance the ``.shape`` attribute, i.e. the shape of the corresponding image. check_bounding_boxes : bool, optional Whether to validate input bounding boxes via the given shape. This will check (a) the number of bounding boxes and (b) for each :class:`~imgaug.augmentables.bbs.BoundingBoxesOnImage` instance the ``.shape`` attribute, i.e. the shape of the corresponding image. Added in 0.4.0. check_polygons : bool, optional Whether to validate input polygons via the given shape. This will check (a) the number of polygons and (b) for each :class:`~imgaug.augmentables.polys.PolygonsOnImage` instance the ``.shape`` attribute, i.e. the shape of the corresponding image. check_line_strings : bool, optional Whether to validate input line strings via the given shape. This will check (a) the number of line strings and (b) for each :class:`~imgaug.augmentables.lines.LineStringsOnImage` instance the ``.shape`` attribute, i.e. the shape of the corresponding image. Added in 0.4.0. 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 >>> seq = iaa.Sequential([ >>> iaa.AssertShape((None, 32, 32, 3)), >>> iaa.Fliplr(0.5) >>> ]) Verify first for each image batch if it contains a variable number of ``32x32`` images with ``3`` channels each. Only if that check succeeds, the horizontal flip will be executed. Otherwise an assertion error will be raised. >>> seq = iaa.Sequential([ >>> iaa.AssertShape((None, (32, 64), 32, [1, 3])), >>> iaa.Fliplr(0.5) >>> ]) Similar to the above example, but now the height may be in the interval ``[32, 64)`` and the number of channels may be either ``1`` or ``3``. TNrxc  st|dksJdt|t|f||_dd} tt|j| t||| t||| t||| t ||| t ||| t ||| t ||| | | | d dS)NrUz7Expected shape to have length 4, got %d with shape: %s.cSs |r|SdSror)rZdo_userrrrBs z&AssertShape.__init__.._defaultr) rBr9rXrzrrn_AssertShapeImagesCheck_AssertShapeHeatmapsCheck_AssertShapeSegmapCheck_AssertShapeKeypointsCheck_AssertShapeBoundingBoxesCheck_AssertShapePolygonsCheck_AssertShapeLineStringsCheck)rlrXZ check_imagesZcheck_heatmapsZcheck_segmentation_mapsZcheck_keypointsZcheck_bounding_boxesZcheck_polygonsZcheck_line_stringsrr-rirjrrrrrn7s@   zAssertShape.__init__cs|durut|r|ksJd|||fdSt|trMt|dks-Jdt|f|dkr;|dksKnJd|||d|dfdSt|trktfdd|DsiJd ||t|fdStd |t |fdS) Nz;Expected dim %d (entry index: %s) to have value %d, got %d.r zHExpected tuple argument 'expected' to contain exactly 2 entries, got %d.rr zMExpected dim %d (entry index: %s) to have value in interval [%d, %d), got %d.csg|]}|kqSrr)r valobservedrrr"irfz(AssertShape._compare..zBExpected dim %d (entry index: %s) to have any value of %s, got %d.zxInvalid datatype for shape entry %d, expected each entry to be an integer, a tuple (with two entries) or a list, got %s.) r#rr0rrBrQrr9rCr:)rrexpected dimensionZ image_indexrrr_compareWsF       zAssertShape._comparecCsl|ddur|t||dddt|D]\}}t|ddD]\}}||}|||||q"qdS)NrALLr )rrBrH)rZshapesZ shape_targetZaugm_idxrXZdim_idxrrrrr _check_shapesss zAssertShape._check_shapes) TTTTTTTNNrxrx) rtrurvrwrnrhrrrirrrrrs rc@r)rcC ||_dSrorrlrXrrrrn z _AssertShapeImagesCheck.__init__cCstdd|D|j|S)NcSg|]}|jqSrrr rOrrrr"z4_AssertShapeImagesCheck.__call__..rrrX)rlr& _random_staterS_hooksrrrr sz _AssertShapeImagesCheck.__call__Nrrrrrr rc@r)rcCrrorrrrrrnrz"_AssertShapeHeatmapsCheck.__init__cC$tdd|D|jdd|S)NcSrr)Zarr_0to1rXrrrrr"rfz6_AssertShapeHeatmapsCheck.__call__..rrVr)rlrrrSrrrrr  z"_AssertShapeHeatmapsCheck.__call__Nrrrrrrrrc@r)rcCrrorrrrrrnrz _AssertShapeSegmapCheck.__init__cCr)NcSrr)rcrXrrrrr"rfz4_AssertShapeSegmapCheck.__call__..rrVr)rlrrrSrrrrr rz _AssertShapeSegmapCheck.__call__Nrrrrrrrrc@r)rcCrrorrrrrrnrz#_AssertShapeKeypointsCheck.__init__cCr)NcSrrrrrrrr"rz7_AssertShapeKeypointsCheck.__call__..rrVr)rlrrrSrrrrr rz#_AssertShapeKeypointsCheck.__call__Nrrrrrrrrc@r)rcCrrorrrrrrnrz'_AssertShapeBoundingBoxesCheck.__init__cCr)NcSrrrrrrrr"rz;_AssertShapeBoundingBoxesCheck.__call__..rrVr)rlrrrSrrrrr   z'_AssertShapeBoundingBoxesCheck.__call__Nrrrrrrrrc@r)rcCrrorrrrrrnrz"_AssertShapePolygonsCheck.__init__cCr)NcSrrrrrrrr"rz6_AssertShapePolygonsCheck.__call__..rrVr)rlrrrSrrrrr rz"_AssertShapePolygonsCheck.__call__Nrrrrrrrrc@r)rcCrrorrrrrrnrz%_AssertShapeLineStringsCheck.__init__cCr)NcSrrrrrrrr"rz9_AssertShapeLineStringsCheck.__call__..rrVr)rlrrrSrrrrr rz%_AssertShapeLineStringsCheck.__call__Nrrrrrrrrcs8eZdZdZ   d fdd ZddZd d ZZS) ChannelShufflead Randomize the order of channels in input images. **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 ---------- p : float or imgaug.parameters.StochasticParameter, optional Probability of shuffling channels in any given image. May be a fixed probability as a ``float``, or a :class:`~imgaug.parameters.StochasticParameter` that returns ``0`` s and ``1`` s. channels : None or imgaug.ALL or list of int, optional Which channels are allowed to be shuffled with each other. If this is ``None`` or ``imgaug.ALL``, then all channels may be shuffled. If it is a ``list`` of ``int`` s, then only the channels with indices in that list may be shuffled. (Values start at ``0``. All channel indices in the list must exist in each image.) 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.ChannelShuffle(0.35) Shuffle all channels of ``35%`` of all images. >>> aug = iaa.ChannelShuffle(0.35, channels=[0, 1]) Shuffle only channels ``0`` and ``1`` of ``35%`` of all images. As the new channel orders ``0, 1`` and ``1, 0`` are both valid outcomes of the shuffling, it means that for ``0.35 * 0.5 = 0.175`` or ``17.5%`` of all images the order of channels ``0`` and ``1`` is inverted. ?Nrxcsttt|j||||dt|d|_|dup)|tjkp)t|t o)t dd|D}|s5Jdt |f||_ dS)NrjrcSr'rrr;rrrr"%r*z+ChannelShuffle.__init__..z3Expected None or imgaug.ALL or list of int, got %s.) rzrrnrrrr#rr0rQr@r:r])rlrr]rr-rirjZvalid_channelsrrrrns"   zChannelShuffle.__init__c Csx|jdur|S|j}t|}|jj|f|d}||}tt|||D]\} \} } } | dkr9t| | |j|j| <q$|S)NrgH.?) r&rBrrZ duplicaterHrRshuffle_channelsr]) rlrrirrr&rZ p_samplesZrssrNrZp_irsrrrr-s   zChannelShuffle._augment_batch_cCs |j|jgSrw)rr]rqrrrrG<s zChannelShuffle.get_parameters)rNNNrxrxrrrrrrsCrc Cs|jdks |jddkr|S|jd}t|}|dup-|tjkp-tt|t|dk}|r;| |}|d|fS| |}|}t ||D]\}} | ||<qG|d|fS)aRandomize the order of (color) channels in an image. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; indirectly tested (1) * ``uint32``: yes; indirectly tested (1) * ``uint64``: yes; indirectly tested (1) * ``int8``: yes; indirectly tested (1) * ``int16``: yes; indirectly tested (1) * ``int32``: yes; indirectly tested (1) * ``int64``: yes; indirectly tested (1) * ``float16``: yes; indirectly tested (1) * ``float32``: yes; indirectly tested (1) * ``float64``: yes; indirectly tested (1) * ``float128``: yes; indirectly tested (1) * ``bool``: yes; indirectly tested (1) - (1) Indirectly tested via :class:`ChannelShuffle`. Parameters ---------- image : (H,W,[C]) ndarray Image of any dtype for which to shuffle the channels. random_state : imgaug.random.RNG The random state to use for this shuffling operation. channels : None or imgaug.ALL or list of int, optional Which channels are allowed to be shuffled with each other. If this is ``None`` or ``imgaug.ALL``, then all channels may be shuffled. If it is a ``list`` of ``int`` s, then only the channels with indices in that list may be shuffled. (Values start at ``0``. All channel indices in the list must exist in the image.) Returns ------- ndarray The input image with shuffled channels. rVr r Nr.) r[rXrrr#rrBset differencerorR) rrir]rZ all_channelsZis_all_channelsZ channels_permZchannels_perm_fullZchannel_sourceZchannel_targetrrrrAs"+       rcr) RemoveCBAsByOutOfImageFractiona%Remove coordinate-based augmentables exceeding an out of image fraction. This augmenter inspects all coordinate-based augmentables (e.g. bounding boxes, line strings) within a given batch and removes any such augmentable which's out of image fraction is exactly a given value or greater than that. The out of image fraction denotes the fraction of the augmentable's area that is outside of the image, e.g. for a bounding box that has half of its area outside of the image it would be ``0.5``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; fully tested * ``uint32``: yes; fully tested * ``uint64``: yes; fully tested * ``int8``: yes; fully tested * ``int16``: yes; fully tested * ``int32``: yes; fully tested * ``int64``: yes; fully tested * ``float16``: yes; fully tested * ``float32``: yes; fully tested * ``float64``: yes; fully tested * ``float128``: yes; fully tested * ``bool``: yes; fully tested Parameters ---------- fraction : number Remove any augmentable for which ``fraction_{actual} >= fraction``, where ``fraction_{actual}`` denotes the estimated out of image fraction. 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.Sequential([ >>> iaa.Affine(translate_px={"x": (-100, 100)}), >>> iaa.RemoveCBAsByOutOfImageFraction(0.5) >>> ]) Translate all inputs by ``-100`` to ``100`` pixels on the x-axis, then remove any coordinate-based augmentable (e.g. bounding boxes) which has at least ``50%`` of its area outside of the image plane. >>> import imgaug as ia >>> import imgaug.augmenters as iaa >>> image = ia.quokka_square((100, 100)) >>> bb = ia.BoundingBox(x1=50-25, y1=0, x2=50+25, y2=100) >>> bbsoi = ia.BoundingBoxesOnImage([bb], shape=image.shape) >>> aug_without = iaa.Affine(translate_px={"x": 51}) >>> aug_with = iaa.Sequential([ >>> iaa.Affine(translate_px={"x": 51}), >>> iaa.RemoveCBAsByOutOfImageFraction(0.5) >>> ]) >>> >>> image_without, bbsoi_without = aug_without( >>> image=image, bounding_boxes=bbsoi) >>> image_with, bbsoi_with = aug_with( >>> image=image, bounding_boxes=bbsoi) >>> >>> assert len(bbsoi_without.bounding_boxes) == 1 >>> assert len(bbsoi_with.bounding_boxes) == 0 Create a bounding box on an example image, then translate the image so that ``50%`` of the bounding box's area is outside of the image and compare the effects and using ``RemoveCBAsByOutOfImageFraction`` with not using it. Nrxcs"tt|j||||d||_dSr)rzrrnfraction)rlr rr-rirjrrrrns  z'RemoveCBAsByOutOfImageFraction.__init__cCs@|jD]}|jdvrt|jD] \}}||j|j|<qq|SN)rrrr)rr-rHrZremove_out_of_image_fraction_r rlrrirrrrNZcbaoirrrrs   z.RemoveCBAsByOutOfImageFraction._augment_batch_cCrvrw)r rqrrrrGrxz-RemoveCBAsByOutOfImageFraction.get_parametersrfrrrrrrsZ  rcr) ClipCBAsToImagePlanesa Clip coordinate-based augmentables to areas within the image plane. This augmenter inspects all coordinate-based augmentables (e.g. bounding boxes, line strings) within a given batch and from each of them parts that are outside of the image plane. Parts within the image plane will be retained. This may e.g. shrink down bounding boxes. For keypoints, it removes any single points outside of the image plane. Any augmentable that is completely outside of the image plane will be removed. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; fully tested * ``uint32``: yes; fully tested * ``uint64``: yes; fully tested * ``int8``: yes; fully tested * ``int16``: yes; fully tested * ``int32``: yes; fully tested * ``int64``: yes; fully tested * ``float16``: yes; fully tested * ``float32``: yes; fully tested * ``float64``: yes; fully tested * ``float128``: yes; fully tested * ``bool``: yes; fully tested Parameters ---------- 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.Sequential([ >>> iaa.Affine(translate_px={"x": (-100, 100)}), >>> iaa.ClipCBAsToImagePlanes() >>> ]) Translate input data on the x-axis by ``-100`` to ``100`` pixels, then cut all coordinate-based augmentables (e.g. bounding boxes) down to areas that are within the image planes of their corresponding images. Nrxcrr)rzr rnrrrrrn5rzClipCBAsToImagePlanes.__init__cCs<|jD]}|jdvrt|jD] \}}||j|<qq|Sr )rr-rHrZclip_out_of_image_r rrrr=s  z%ClipCBAsToImagePlanes._augment_batch_cCrHrwrrqrrrrGGrz$ClipCBAsToImagePlanes.get_parametersrfrrrrrr s> r )r+ro)Hrw __future__rrrabcrrr)r_rQrrrnumpyrsixZ six.movesmovesr#Zimgaugr#Zimgaug.augmentables.batchesrrr r rr rrrrxrrrrrFrPrTr^r`rdrgobjectrh add_metaclassr1rQr>rrrrrYrrrrrrrrrrrrrrrr rrrrs          (a7EwF.LM       lBt