o eG*@sdZddlmZmZmZddlmZmZddlZ ddl Z ddl Z ddl Z ddlmZddlZddlmZddlmZdd lmZdd lmZd d ZGd ddejZd/ddZddZddZ ddZ!ddZ"GdddejZ#Gddde#Z$Gddde#Z%Gdd d e#Z&e 'eGd!d"d"e(Z)d#d$Z*Gd%d&d&e)Z+Gd'd(d(e)Z,Gd)d*d*e)Z-Gd+d,d,e)Z.Gd-d.d.e)Z/dS)0z Augmenters that apply changes to images based on segmentation methods. List of augmenters: * :class:`Superpixels` * :class:`Voronoi` * :class:`UniformVoronoi` * :class:`RegularGridVoronoi` * :class:`RelativeRegularGridVoronoi` )print_functiondivisionabsolute_import)ABCMetaabstractmethodN)meta)random) parameters)dtypescCsj|dur3t|jd|jd}||kr3||}t|jd|}t|jd|}tj|||f|d}|S)a'Ensure that images do not exceed a required maximum sidelength. This downscales to `max_size` if any side violates that maximum. The other side is downscaled too so that the aspect ratio is maintained. **Supported dtypes**: See :func:`~imgaug.imgaug.imresize_single_image`. Parameters ---------- image : ndarray Image to potentially downscale. max_size : int Maximum length of any side of the image. interpolation : string or int See :func:`~imgaug.imgaug.imresize_single_image`. Nrr interpolation)maxshapeintiaimresize_single_image)imagemax_sizersizeZ resize_factorZ new_heightZ new_widthrND:\Projects\ConvertPro\env\Lib\site-packages\imgaug/augmenters/segmentation.py_ensure_image_max_size"srcsFeZdZdZ    dfdd Zd d Zed d ZddZZ S) SuperpixelsaoTransform images parially/completely to their superpixel representation. This implementation uses skimage's version of the SLIC algorithm. .. note:: This augmenter is fairly slow. See :ref:`performance`. **Supported dtypes**: if (image size <= max_size): * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: yes; tested * ``uint64``: limited (1) * ``int8``: yes; tested * ``int16``: yes; tested * ``int32``: yes; tested * ``int64``: limited (1) * ``float16``: no (2) * ``float32``: no (2) * ``float64``: no (3) * ``float128``: no (2) * ``bool``: yes; tested - (1) Superpixel mean intensity replacement requires computing these means as ``float64`` s. This can cause inaccuracies for large integer values. - (2) Error in scikit-image. - (3) Loss of resolution in scikit-image. if (image size > max_size): minimum of ( ``imgaug.augmenters.segmentation.Superpixels(image size <= max_size)``, :func:`~imgaug.augmenters.segmentation._ensure_image_max_size` ) Parameters ---------- p_replace : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Defines for any segment the probability that the pixels within that segment are replaced by their average color (otherwise, the pixels are not changed). Examples: * A probability of ``0.0`` would mean, that the pixels in no segment are replaced by their average color (image is not changed at all). * A probability of ``0.5`` would mean, that around half of all segments are replaced by their average color. * A probability of ``1.0`` would mean, that all segments are replaced by their average color (resulting in a voronoi image). Behaviour based on chosen datatypes for this parameter: * If a ``number``, then that ``number`` will always be used. * If ``tuple`` ``(a, b)``, then a random probability will be sampled from the interval ``[a, b]`` per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, it is expected to return values between ``0.0`` and ``1.0`` and will be queried *for each individual segment* to determine whether it is supposed to be averaged (``>0.5``) or not (``<=0.5``). Recommended to be some form of ``Binomial(...)``. n_segments : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Rough target number of how many superpixels to generate (the algorithm may deviate from this number). Lower value will lead to coarser superpixels. Higher values are computationally more intensive and will hence lead to a slowdown. * If a single ``int``, then that value will always be used as the number of segments. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. max_size : int or None, optional Maximum image size at which the augmentation is performed. If the width or height of an image exceeds this value, it will be downscaled before the augmentation so that the longest side matches `max_size`. This is done to speed up the process. The final output image has the same size as the input image. Note that in case `p_replace` is below ``1.0``, the down-/upscaling will affect the not-replaced pixels too. Use ``None`` to apply no down-/upscaling. interpolation : int or str, optional Interpolation method to use during downscaling when `max_size` is exceeded. Valid methods are the same as in :func:`~imgaug.imgaug.imresize_single_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.Superpixels(p_replace=1.0, n_segments=64) Generate around ``64`` superpixels per image and replace all of them with their average color (standard superpixel image). >>> aug = iaa.Superpixels(p_replace=0.5, n_segments=64) Generate around ``64`` superpixels per image and replace half of them with their average color, while the other half are left unchanged (i.e. they still show the input image's content). >>> aug = iaa.Superpixels(p_replace=(0.25, 1.0), n_segments=(16, 128)) Generate between ``16`` and ``128`` superpixels per image and replace ``25`` to ``100`` percent of them with their average color. ??2xlinearN deprecatedc sTtt|j||||dtj|dddd|_tj|dddddd|_||_||_ dS) Nseedname random_state deterministic p_replaceTtuple_to_uniformlist_to_choice n_segmentsrNF value_ranger+r,Z allow_floats) superr__init__iaphandle_probability_paramr)handle_discrete_paramr-rr) selfr)r-rrr%r&r'r( __class__rrr2s  zSuperpixels.__init__cCs*|jdur|S|j}tj|gdgd|dt|}|d|}|jj|f|dd}t|dd}t t ||ddD]S\} \} } | j dkrKq?|j j|| f| d} t | dkr^q?| j} t| |j|j} tjj| || dd}|| || }| |jkrtj|| dd |jd }||j| <q?|S) N) booluint8uint16uint32uint64int8int16int32int64) uint128uint256int128int256float16float32float64float96float128float256allowedZ disallowedZ augmenterrrr' )r-Z compactnessr r )imagesiadt gate_dtypeslen duplicater- draw_samplesnpclip enumerateziprr)rrrrrskimageZ segmentationZslic_replace_segmentsrr)r6batchr'parentshooksrPZ nb_imagesrssZn_segments_samplesirrsreplace_samples orig_shapesegments image_augrrr_augment_batch_sL   "      zSuperpixels._augment_batch_cCst|j\}}}t|}|jd}t|D]J} tj j |d|d| fd} t | D]5\} } || t |dkra| j } |d| f}|jjdvrYtt| }tt|||}n| }|||| k<q,q|S)Nr r.)Zintensity_imager)r`ub)rQZget_value_range_of_dtypedtyperVcopyrsmxrangerZmeasureZ regionpropsrXrSmean_intensitykindrroundminr)clsrrdrbZ min_valueZ _center_valueZ max_valueZimage_sp nb_channelscZregionsZridxregionrnZ image_sp_cvaluerrrr[s(      zSuperpixels._replace_segmentscC|j|j|j|jgSz=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.)r)r-rrr6rrrget_parametersA zSuperpixels.get_parameters)rrr!r"NNr#r#) __name__ __module__ __qualname____doc__r2rf classmethodr[rz __classcell__rrr7rrFs < #rc Cs|j}|dkr|dtjf}t|dkr|dkr|dS|S|jdd\}}t|||\}}t|||t|}t||||} |dkrG| dS| S)aAverage colors within voronoi cells of an image. Parameters ---------- image : ndarray The image to convert to a voronoi image. May be ``HxW`` or ``HxWxC``. Note that for ``RGBA`` images the alpha channel will currently also by averaged. cell_coordinates : ndarray A ``Nx2`` float array containing the center coordinates of voronoi cells on the image. Values are expected to be in the interval ``[0.0, height-1.0]`` for the y-axis (x-axis analogous). If this array contains no coordinate, the image will not be changed. replace_mask : None or ndarray, optional Boolean mask of the same length as `cell_coordinates`, denoting for each cell whether its pixels are supposed to be replaced by the cell's average color (``True``) or left untouched (``False``). If this is set to ``None``, all cells will be replaced. Returns ------- ndarray Voronoi image. r .r).r)ndimrVnewaxisrSr _match_pixels_with_voronoi_cells_compute_avg_segment_colors_render_segments) rcell_coordinates replace_maskZ input_dimsheightwidth pixel_coordsids_of_nearest_cells cell_colorsrerrrsegment_voronoiHs(  rcCsDddlm}||}t||}|tjd}||d}||fS)Nr)cKDTreerr)Z scipy.spatialr_generate_pixel_coordsastyperVrGquery)rrrZKDTreetreerZpixel_coords_subpixelrrrrr}s  rcCs2tt|t|\}}tj||fSN)rVmeshgridarangeZc_ravel)rrxxyyrrrrsrc Cs|jd}tj||ftjd}tj|ftjd}t||D]\}}|ddd} |||t| 7<||d7<qt|dd}||ddtjf}| tj S)Nr )rir) rrVZzerosrHr<rYtuplerWrrr:) rrids_of_nearest_segmentsZ nb_segmentsrsrZ cell_countersZ pixel_coordZid_of_nearest_cellZpixel_coord_yxrrrrs   rc Cst|}|j\}}}|dur|nd}|dust|s&||ddf}n-t|d} tt|| d} ||ddf}|||df} | | ddf|| <||||f}|S)Nrr)rVrjranyZnonzerowhereisinreshape) rrZavg_segment_colorsrrrrs keep_maskdataZ ids_to_keepindices_to_keepZ image_datarrrrs   rcsBeZdZdZ    dfdd Zd d Zd d Zd dZZS)VoronoiaAverage colors of an image within Voronoi cells. This augmenter performs the following steps: 1. Query `points_sampler` to sample random coordinates of cell centers. On the image. 2. Estimate for each pixel to which voronoi cell (i.e. segment) it belongs. Each pixel belongs to the cell with the closest center coordinate (euclidean distance). 3. Compute for each cell the average color of the pixels within it. 4. Replace the pixels of `p_replace` percent of all cells by their average color. Do not change the pixels of ``(1 - p_replace)`` percent of all cells. (The percentages are average values over many images. Some images may get more/less cells replaced by their average color.) This code is very loosely based on https://codegolf.stackexchange.com/questions/50299/draw-an-image-as-a-voronoi-map/50345#50345 **Supported dtypes**: if (image size <= max_size): * ``uint8``: yes; fully tested * ``uint16``: no; not tested * ``uint32``: no; not tested * ``uint64``: no; not tested * ``int8``: no; not tested * ``int16``: no; not tested * ``int32``: no; not tested * ``int64``: no; not tested * ``float16``: no; not tested * ``float32``: no; not tested * ``float64``: no; not tested * ``float128``: no; not tested * ``bool``: no; not tested if (image size > max_size): minimum of ( ``imgaug.augmenters.segmentation.Voronoi(image size <= max_size)``, :func:`~imgaug.augmenters.segmentation._ensure_image_max_size` ) Parameters ---------- points_sampler : IPointsSampler A points sampler which will be queried per image to generate the coordinates of the centers of voronoi cells. p_replace : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Defines for any segment the probability that the pixels within that segment are replaced by their average color (otherwise, the pixels are not changed). Examples: * A probability of ``0.0`` would mean, that the pixels in no segment are replaced by their average color (image is not changed at all). * A probability of ``0.5`` would mean, that around half of all segments are replaced by their average color. * A probability of ``1.0`` would mean, that all segments are replaced by their average color (resulting in a voronoi image). Behaviour based on chosen datatypes for this parameter: * If a ``number``, then that ``number`` will always be used. * If ``tuple`` ``(a, b)``, then a random probability will be sampled from the interval ``[a, b]`` per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, it is expected to return values between ``0.0`` and ``1.0`` and will be queried *for each individual segment* to determine whether it is supposed to be averaged (``>0.5``) or not (``<=0.5``). Recommended to be some form of ``Binomial(...)``. max_size : int or None, optional Maximum image size at which the augmentation is performed. If the width or height of an image exceeds this value, it will be downscaled before the augmentation so that the longest side matches `max_size`. This is done to speed up the process. The final output image has the same size as the input image. Note that in case `p_replace` is below ``1.0``, the down-/upscaling will affect the not-replaced pixels too. Use ``None`` to apply no down-/upscaling. interpolation : int or str, optional Interpolation method to use during downscaling when `max_size` is exceeded. Valid methods are the same as in :func:`~imgaug.imgaug.imresize_single_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 >>> points_sampler = iaa.RegularGridPointsSampler(n_cols=20, n_rows=40) >>> aug = iaa.Voronoi(points_sampler) Create an augmenter that places a ``20x40`` (``HxW``) grid of cells on the image and replaces all pixels within each cell by the cell's average color. The process is performed at an image size not exceeding ``128`` px on any side (default). If necessary, the downscaling is performed using ``linear`` interpolation (default). >>> points_sampler = iaa.DropoutPointsSampler( >>> iaa.RelativeRegularGridPointsSampler( >>> n_cols_frac=(0.05, 0.2), >>> n_rows_frac=0.1), >>> 0.2) >>> aug = iaa.Voronoi(points_sampler, p_replace=0.9, max_size=None) Create a voronoi augmenter that generates a grid of cells dynamically adapted to the image size. Larger images get more cells. On the x-axis, the distance between two cells is ``w * W`` pixels, where ``W`` is the width of the image and ``w`` is always ``0.1``. On the y-axis, the distance between two cells is ``h * H`` pixels, where ``H`` is the height of the image and ``h`` is sampled uniformly from the interval ``[0.05, 0.2]``. To make the voronoi pattern less regular, about ``20`` percent of the cell coordinates are randomly dropped (i.e. the remaining cells grow in size). In contrast to the first example, the image is not resized (if it was, the sampling would happen *after* the resizing, which would affect ``W`` and ``H``). Not all voronoi cells are replaced by their average color, only around ``90`` percent of them. The remaining ``10`` percent's pixels remain unchanged. rr!r"Nr#c s^tt|j||||dt|tsJdt|f||_tj|dddd|_ ||_ ||_ dS)Nr$zFExpected 'points_sampler' to be an instance of IPointsSampler, got %s.r)Tr*) r1rr2 isinstanceIPointsSamplertypepoints_samplerr3r4r)rr) r6rr)rrr%r&r'r(r7rrr2Rs   zVoronoi.__init__c Csl|jdur|S|j}tj|dggd|d|t|}tt||D]\}\}} ||| |j|<q$|S)Nr:)r9r;r<r=rBrCr>r?r@rArDrErFrGrHrIrJrKrL)rPrQrRrTrSrXrY_augment_single_image) r6r\r'r]r^rPr_r`rrarrrrffs  zVoronoi._augment_batch_c Cs|d}|j}t||j|j}|j|g|dd}|jt |f|d}|dk}t |||}||jkrDt j ||dd|jd}|S)Nr rrrr ) rTrrrrr sample_pointsr)rUrSrrr) r6rr'r_rcrr)rrerrrr|s    zVoronoi._augment_single_imagecCrwrx)rr)rrryrrrrzr{zVoronoi.get_parameters)rr!r"NNr#r#) r|r}r~rr2rfrrzrrrr7rrsrcs*eZdZdZ    d fdd ZZS) UniformVoronoiaUniformly sample Voronoi cells on images and average colors within them. This augmenter is a shortcut for the combination of :class:`~imgaug.augmenters.segmentation.Voronoi` with :class:`~imgaug.augmenters.segmentation.UniformPointsSampler`. Hence, it generates a fixed amount of ``N`` random coordinates of voronoi cells on each image. The cell coordinates are sampled uniformly using the image height and width as maxima. **Supported dtypes**: See :class:`~imgaug.augmenters.segmentation.Voronoi`. Parameters ---------- n_points : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Number of points to sample on each image. * If a single ``int``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. p_replace : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Defines for any segment the probability that the pixels within that segment are replaced by their average color (otherwise, the pixels are not changed). Examples: * A probability of ``0.0`` would mean, that the pixels in no segment are replaced by their average color (image is not changed at all). * A probability of ``0.5`` would mean, that around half of all segments are replaced by their average color. * A probability of ``1.0`` would mean, that all segments are replaced by their average color (resulting in a voronoi image). Behaviour based on chosen datatypes for this parameter: * If a ``number``, then that ``number`` will always be used. * If ``tuple`` ``(a, b)``, then a random probability will be sampled from the interval ``[a, b]`` per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, it is expected to return values between ``0.0`` and ``1.0`` and will be queried *for each individual segment* to determine whether it is supposed to be averaged (``>0.5``) or not (``<=0.5``). Recommended to be some form of ``Binomial(...)``. max_size : int or None, optional Maximum image size at which the augmentation is performed. If the width or height of an image exceeds this value, it will be downscaled before the augmentation so that the longest side matches `max_size`. This is done to speed up the process. The final output image has the same size as the input image. Note that in case `p_replace` is below ``1.0``, the down-/upscaling will affect the not-replaced pixels too. Use ``None`` to apply no down-/upscaling. interpolation : int or str, optional Interpolation method to use during downscaling when `max_size` is exceeded. Valid methods are the same as in :func:`~imgaug.imgaug.imresize_single_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.UniformVoronoi((100, 500)) Sample for each image uniformly the number of voronoi cells ``N`` from the interval ``[100, 500]``. Then generate ``N`` coordinates by sampling uniformly the x-coordinates from ``[0, W]`` and the y-coordinates from ``[0, H]``, where ``H`` is the image height and ``W`` the image width. Then use these coordinates to group the image pixels into voronoi cells and average the colors within them. The process is performed at an image size not exceeding ``128`` px on any side (default). If necessary, the downscaling is performed using ``linear`` interpolation (default). >>> aug = iaa.UniformVoronoi(250, p_replace=0.9, max_size=None) Same as above, but always samples ``N=250`` cells, replaces only ``90`` percent of them with their average color (the pixels of the remaining ``10`` percent are not changed) and performs the transformation at the original image size (``max_size=None``). rirr!r"Nr#c s(tt|jt||||||||ddSN)rr)rrr%r&r'r()r1rr2UniformPointsSampler) r6n_pointsr)rrr%r&r'r(r7rrr2s  zUniformVoronoi.__init__)rrr!r"NNr#r#r|r}r~rr2rrrr7rrsmrcs,eZdZdZ     d fd d ZZS) RegularGridVoronoiaISample Voronoi cells from regular grids and color-average them. This augmenter is a shortcut for the combination of :class:`~imgaug.augmenters.segmentation.Voronoi`, :class:`~imgaug.augmenters.segmentation.RegularGridPointsSampler` and :class:`~imgaug.augmenters.segmentation.DropoutPointsSampler`. Hence, it generates a regular grid with ``R`` rows and ``C`` columns of coordinates on each image. Then, it drops ``p`` percent of the ``R*C`` coordinates to randomize the grid. Each image pixel then belongs to the voronoi cell with the closest coordinate. **Supported dtypes**: See :class:`~imgaug.augmenters.segmentation.Voronoi`. Parameters ---------- n_rows : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Number of rows of coordinates to place on each image, i.e. the number of coordinates on the y-axis. Note that for each image, the sampled value is clipped to the interval ``[1..H]``, where ``H`` is the image height. * If a single ``int``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. n_cols : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Number of columns of coordinates to place on each image, i.e. the number of coordinates on the x-axis. Note that for each image, the sampled value is clipped to the interval ``[1..W]``, where ``W`` is the image width. * If a single ``int``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. p_drop_points : number or tuple of number or imgaug.parameters.StochasticParameter, optional The probability that a coordinate will be removed from the list of all sampled coordinates. A value of ``1.0`` would mean that (on average) ``100`` percent of all coordinates will be dropped, while ``0.0`` denotes ``0`` percent. Note that this sampler will always ensure that at least one coordinate is left after the dropout operation, i.e. even ``1.0`` will only drop all *except one* coordinate. * If a ``float``, then that value will be used for all images. * If a ``tuple`` ``(a, b)``, then a value ``p`` will be sampled from the interval ``[a, b]`` per image. * If a ``StochasticParameter``, then this parameter will be used to determine per coordinate whether it should be *kept* (sampled value of ``>0.5``) or shouldn't be kept (sampled value of ``<=0.5``). If you instead want to provide the probability as a stochastic parameter, you can usually do ``imgaug.parameters.Binomial(1-p)`` to convert parameter `p` to a 0/1 representation. p_replace : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Defines for any segment the probability that the pixels within that segment are replaced by their average color (otherwise, the pixels are not changed). Examples: * A probability of ``0.0`` would mean, that the pixels in no segment are replaced by their average color (image is not changed at all). * A probability of ``0.5`` would mean, that around half of all segments are replaced by their average color. * A probability of ``1.0`` would mean, that all segments are replaced by their average color (resulting in a voronoi image). Behaviour based on chosen datatypes for this parameter: * If a ``number``, then that number will always be used. * If ``tuple`` ``(a, b)``, then a random probability will be sampled from the interval ``[a, b]`` per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, it is expected to return values between ``0.0`` and ``1.0`` and will be queried *for each individual segment* to determine whether it is supposed to be averaged (``>0.5``) or not (``<=0.5``). Recommended to be some form of ``Binomial(...)``. max_size : int or None, optional Maximum image size at which the augmentation is performed. If the width or height of an image exceeds this value, it will be downscaled before the augmentation so that the longest side matches `max_size`. This is done to speed up the process. The final output image has the same size as the input image. Note that in case `p_replace` is below ``1.0``, the down-/upscaling will affect the not-replaced pixels too. Use ``None`` to apply no down-/upscaling. interpolation : int or str, optional Interpolation method to use during downscaling when `max_size` is exceeded. Valid methods are the same as in :func:`~imgaug.imgaug.imresize_single_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.RegularGridVoronoi(10, 20) Place a regular grid of ``10x20`` (``height x width``) coordinates on each image. Randomly drop on average ``20`` percent of these points to create a less regular pattern. Then use the remaining coordinates to group the image pixels into voronoi cells and average the colors within them. The process is performed at an image size not exceeding ``128`` px on any side (default). If necessary, the downscaling is performed using ``linear`` interpolation (default). >>> aug = iaa.RegularGridVoronoi( >>> (10, 30), 20, p_drop_points=0.0, p_replace=0.9, max_size=None) Same as above, generates a grid with randomly ``10`` to ``30`` rows, drops none of the generates points, replaces only ``90`` percent of the voronoi cells with their average color (the pixels of the remaining ``10`` percent are not changed) and performs the transformation at the original image size (``max_size=None``). rOrrr!r"Nr#c 0tt|jtt||||||||| | ddSr)r1rr2DropoutPointsSamplerRegularGridPointsSampler) r6n_rowsn_cols p_drop_pointsr)rrr%r&r'r(r7rrr2  zRegularGridVoronoi.__init__) rrrrr!r"NNr#r#rrrr7rrsrcs,eZdZdZ     d fdd ZZS) RelativeRegularGridVoronoia"Sample Voronoi cells from image-dependent grids and color-average them. This augmenter is a shortcut for the combination of :class:`~imgaug.augmenters.segmentation.Voronoi`, :class:`~imgaug.augmenters.segmentation.RegularGridPointsSampler` and :class:`~imgaug.augmenters.segmentation.DropoutPointsSampler`. Hence, it generates a regular grid with ``R`` rows and ``C`` columns of coordinates on each image. Then, it drops ``p`` percent of the ``R*C`` coordinates to randomize the grid. Each image pixel then belongs to the voronoi cell with the closest coordinate. .. note:: In contrast to the other voronoi augmenters, this one uses ``None`` as the default value for `max_size`, i.e. the color averaging is always performed at full resolution. This enables the augmenter to make use of the additional points on larger images. It does however slow down the augmentation process. **Supported dtypes**: See :class:`~imgaug.augmenters.segmentation.Voronoi`. Parameters ---------- n_rows_frac : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Relative number of coordinates to place on the y-axis. For a value ``y`` and image height ``H`` the number of actually placed coordinates (i.e. computed rows) is given by ``int(round(y*H))``. Note that for each image, the number of coordinates is clipped to the interval ``[1,H]``, where ``H`` is the image height. * If a single ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the interval ``[a, b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. n_cols_frac : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Relative number of coordinates to place on the x-axis. For a value ``x`` and image height ``W`` the number of actually placed coordinates (i.e. computed columns) is given by ``int(round(x*W))``. Note that for each image, the number of coordinates is clipped to the interval ``[1,W]``, where ``W`` is the image width. * If a single ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the interval ``[a, b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. p_drop_points : number or tuple of number or imgaug.parameters.StochasticParameter, optional The probability that a coordinate will be removed from the list of all sampled coordinates. A value of ``1.0`` would mean that (on average) ``100`` percent of all coordinates will be dropped, while ``0.0`` denotes ``0`` percent. Note that this sampler will always ensure that at least one coordinate is left after the dropout operation, i.e. even ``1.0`` will only drop all *except one* coordinate. * If a ``float``, then that value will be used for all images. * If a ``tuple`` ``(a, b)``, then a value ``p`` will be sampled from the interval ``[a, b]`` per image. * If a ``StochasticParameter``, then this parameter will be used to determine per coordinate whether it should be *kept* (sampled value of ``>0.5``) or shouldn't be kept (sampled value of ``<=0.5``). If you instead want to provide the probability as a stochastic parameter, you can usually do ``imgaug.parameters.Binomial(1-p)`` to convert parameter `p` to a 0/1 representation. p_replace : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Defines for any segment the probability that the pixels within that segment are replaced by their average color (otherwise, the pixels are not changed). Examples: * A probability of ``0.0`` would mean, that the pixels in no segment are replaced by their average color (image is not changed at all). * A probability of ``0.5`` would mean, that around half of all segments are replaced by their average color. * A probability of ``1.0`` would mean, that all segments are replaced by their average color (resulting in a voronoi image). Behaviour based on chosen datatypes for this parameter: * If a ``number``, then that ``number`` will always be used. * If ``tuple`` ``(a, b)``, then a random probability will be sampled from the interval ``[a, b]`` per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, it is expected to return values between ``0.0`` and ``1.0`` and will be queried *for each individual segment* to determine whether it is supposed to be averaged (``>0.5``) or not (``<=0.5``). Recommended to be some form of ``Binomial(...)``. max_size : int or None, optional Maximum image size at which the augmentation is performed. If the width or height of an image exceeds this value, it will be downscaled before the augmentation so that the longest side matches `max_size`. This is done to speed up the process. The final output image has the same size as the input image. Note that in case `p_replace` is below ``1.0``, the down-/upscaling will affect the not-replaced pixels too. Use ``None`` to apply no down-/upscaling. interpolation : int or str, optional Interpolation method to use during downscaling when `max_size` is exceeded. Valid methods are the same as in :func:`~imgaug.imgaug.imresize_single_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.RelativeRegularGridVoronoi(0.1, 0.25) Place a regular grid of ``R x C`` coordinates on each image, where ``R`` is the number of rows and computed as ``R=0.1*H`` with ``H`` being the height of the input image. ``C`` is the number of columns and analogously estimated from the image width ``W`` as ``C=0.25*W``. Larger images will lead to larger ``R`` and ``C`` values. On average, ``20`` percent of these grid coordinates are randomly dropped to create a less regular pattern. Then, the remaining coordinates are used to group the image pixels into voronoi cells and the colors within them are averaged. >>> aug = iaa.RelativeRegularGridVoronoi( >>> (0.03, 0.1), 0.1, p_drop_points=0.0, p_replace=0.9, max_size=512) Same as above, generates a grid with randomly ``R=r*H`` rows, where ``r`` is sampled uniformly from the interval ``[0.03, 0.1]`` and ``C=0.1*W`` rows. No points are dropped. The augmenter replaces only ``90`` percent of the voronoi cells with their average color (the pixels of the remaining ``10`` percent are not changed). Images larger than ``512`` px are temporarily downscaled (*before* sampling the grid points) so that no side exceeds ``512`` px. This improves performance, but degrades the quality of the resulting image. g?g333333?rrNr"r#c rr)r1rr2r RelativeRegularGridPointsSampler) r6 n_rows_frac n_cols_fracrr)rrr%r&r'r(r7rrr2]rz#RelativeRegularGridVoronoi.__init__) rrrrNr"NNr#r#rrrr7rrs%rc@seZdZdZeddZdS)rzInterface for all point samplers. Point samplers return coordinate arrays of shape ``Nx2``. These coordinates can be used in other augmenters, see e.g. :class:`~imgaug.augmenters.segmentation.Voronoi`. cCsdS)aRGenerate coordinates of points on images. Parameters ---------- images : ndarray or list of ndarray One or more images for which to generate points. If this is a ``list`` of arrays, each one of them is expected to have three dimensions. If this is an array, it must be four-dimensional and the first axis is expected to denote the image index. For ``RGB`` images the array would hence have to be of shape ``(N, H, W, 3)``. 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 A random state to use for any probabilistic function required during the point sampling. See :func:`~imgaug.random.RNG` for details. Returns ------- ndarray An ``(N,2)`` ``float32`` array containing ``(x,y)`` subpixel coordinates, all of which being within the intervals ``[0.0, width]`` and ``[0.0, height]``. Nr)r6rPr'rrrrxszIPointsSampler.sample_pointsN)r|r}r~rrrrrrrrnsrcCst|dks Jdt|trAtdd|Ds'Jdddd|Dftdd|Ds?Jd dd d|DfdSt|sOJd t|f|jd ks^Jd |j|j fdS)Nrz&Expected at least one image, got zero.cSsg|]}t|qSr)r is_np_array.0rrrr z0_verify_sample_points_images..z4Expected list of numpy arrays, got list of types %s.z, cSsg|]}tt|qSr)strrrrrrrscSsg|]}|jdkqS))rrrrrrrz@Expected each image to have three dimensions, got dimensions %s.cSsg|]}t|jqSr)rrrrrrrrz]Expected either a list of numpy arrays or a single numpy array of shape NxHxWxC. Got type %s.zXExpected a four-dimensional array of shape NxHxWxC. Got shape %d dimensions (shape: %s).) rSrlistalljoinrrrrr)rPrrr_verify_sample_points_imagess0   rc@s\eZdZdZddZddZddZedd Zed d Z ed d Z ddZ ddZ dS)raSampler that generates a regular grid of coordinates on an image. 'Regular grid' here means that on each axis all coordinates have the same distance from each other. Note that the distance may change between axis. Parameters ---------- n_rows : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Number of rows of coordinates to place on each image, i.e. the number of coordinates on the y-axis. Note that for each image, the sampled value is clipped to the interval ``[1..H]``, where ``H`` is the image height. * If a single ``int``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. n_cols : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Number of columns of coordinates to place on each image, i.e. the number of coordinates on the x-axis. Note that for each image, the sampled value is clipped to the interval ``[1..W]``, where ``W`` is the image width. * If a single ``int``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. Examples -------- >>> import imgaug.augmenters as iaa >>> sampler = iaa.RegularGridPointsSampler( >>> n_rows=(5, 20), >>> n_cols=50) Create a point sampler that generates regular grids of points. These grids contain ``r`` points on the y-axis, where ``r`` is sampled uniformly from the discrete interval ``[5..20]`` per image. On the x-axis, the grids always contain ``50`` points. cCs4tj|dddddd|_tj|dddddd|_dS)Nrr.TFr/r)r3r5rr)r6rrrrrr2s z!RegularGridPointsSampler.__init__cCs0t|}t||||\}}||||Sr)iarandomRNGr _draw_samples_generate_point_grids)r6rPr' n_rows_lst n_cols_lstrrrrs z&RegularGridPointsSampler.sample_pointscCsH|d}|jjt||dd}|jjt||dd}||||S)Nr rrNr)rTrrUrSr_clip_rows_and_cols)r6rPr'r_rrrrrrs z&RegularGridPointsSampler._draw_samplescCshtdd|D}tdd|D}t|d|}t|d|}t|dd}t|dd}||fS)NcSg|]}|jdqSrrrrrrrrz@RegularGridPointsSampler._clip_rows_and_cols..cSrrrrrrrrrr)rVr@rW)rrrrrPheightswidthsrrrrsz,RegularGridPointsSampler._clip_rows_and_colscCs4g}t|||D]\}}}|||||q|Sr)rYappend_generate_point_grid)rrrPrrZgridsrZn_rows_iZn_cols_irrrrsz.RegularGridPointsSampler._generate_point_gridscCs|jdd\}}||}d|d}||d}|d|kr'|dkr0nnt|g} ntj|||d} ||} d| d} || d} | d| krV| dkr_nnt| g} ntj| | |d} t| | \} } t| | gj}|S)Nrr r-C6?)num)rrVrGZlinspacerZvstackrT)rrrrrrrZ y_spacingZy_startZy_endrZ x_spacingZx_startZx_endrgridrrrrs       z-RegularGridPointsSampler._generate_point_gridcCd|j|jfS)Nz RegularGridPointsSampler(%s, %s))rrryrrr__repr__#sz!RegularGridPointsSampler.__repr__cC|Srrryrrr__str__&z RegularGridPointsSampler.__str__N) r|r}r~rr2rrrrrrrrrrrrrs2    rc@s8eZdZdZddZddZddZdd Zd d Zd S) raW Regular grid coordinate sampler; places more points on larger images. This is similar to ``RegularGridPointsSampler``, but the number of rows and columns is given as fractions of each image's height and width. Hence, more coordinates are generated for larger images. Parameters ---------- n_rows_frac : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Relative number of coordinates to place on the y-axis. For a value ``y`` and image height ``H`` the number of actually placed coordinates (i.e. computed rows) is given by ``int(round(y*H))``. Note that for each image, the number of coordinates is clipped to the interval ``[1,H]``, where ``H`` is the image height. * If a single ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the interval ``[a, b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. n_cols_frac : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Relative number of coordinates to place on the x-axis. For a value ``x`` and image height ``W`` the number of actually placed coordinates (i.e. computed columns) is given by ``int(round(x*W))``. Note that for each image, the number of coordinates is clipped to the interval ``[1,W]``, where ``W`` is the image width. * If a single ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the interval ``[a, b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. Examples -------- >>> import imgaug.augmenters as iaa >>> sampler = iaa.RelativeRegularGridPointsSampler( >>> n_rows_frac=(0.01, 0.1), >>> n_cols_frac=0.2) Create a point sampler that generates regular grids of points. These grids contain ``round(y*H)`` points on the y-axis, where ``y`` is sampled uniformly from the interval ``[0.01, 0.1]`` per image and ``H`` is the image height. On the x-axis, the grids always contain ``0.2*W`` points, where ``W`` is the image width. cCsDd}tj|dd|dfddd|_tj|dd|dfddd|_dS)NrrrrT)r0r+r,r)r3Zhandle_continuous_paramrr)r6rrZepsrrrr2`s z)RelativeRegularGridPointsSampler.__init__cCs0t|}t||||\}}t|||Sr)rrrrrr)r6rPr'rrrrrris z.RelativeRegularGridPointsSampler.sample_pointsc Cst|}|d}|jj||dd}|jj||dd}tdd|D}tdd|D}t||} t||} t | | |\} } | tj| tjfS)Nr rrNrcSrrrrrrrrzrzBRelativeRegularGridPointsSampler._draw_samples..cSrrrrrrrr{r) rSrTrrUrrVr@rprrr) r6rPr'n_augmentablesr_rrrrrrrrrrrs  z.RelativeRegularGridPointsSampler._draw_samplescCr)Nz(RelativeRegularGridPointsSampler(%s, %s))rrryrrrrsz)RelativeRegularGridPointsSampler.__repr__cCrrrryrrrrrz(RelativeRegularGridPointsSampler.__str__N) r|r}r~rr2rrrrrrrrr*s5   rc@sXeZdZdZddZeddZddZdd Zd d Z ed d Z ddZ ddZ dS)ra&Remove a defined fraction of sampled points. Parameters ---------- other_points_sampler : IPointsSampler Another point sampler that is queried to generate a list of points. The dropout operation will be applied to that list. p_drop : number or tuple of number or imgaug.parameters.StochasticParameter The probability that a coordinate will be removed from the list of all sampled coordinates. A value of ``1.0`` would mean that (on average) ``100`` percent of all coordinates will be dropped, while ``0.0`` denotes ``0`` percent. Note that this sampler will always ensure that at least one coordinate is left after the dropout operation, i.e. even ``1.0`` will only drop all *except one* coordinate. * If a ``float``, then that value will be used for all images. * If a ``tuple`` ``(a, b)``, then a value ``p`` will be sampled from the interval ``[a, b]`` per image. * If a ``StochasticParameter``, then this parameter will be used to determine per coordinate whether it should be *kept* (sampled value of ``>0.5``) or shouldn't be kept (sampled value of ``<=0.5``). If you instead want to provide the probability as a stochastic parameter, you can usually do ``imgaug.parameters.Binomial(1-p)`` to convert parameter `p` to a 0/1 representation. Examples -------- >>> import imgaug.augmenters as iaa >>> sampler = iaa.DropoutPointsSampler( >>> iaa.RegularGridPointsSampler(10, 20), >>> 0.2) Create a point sampler that first generates points following a regular grid of ``10`` rows and ``20`` columns, then randomly drops ``20`` percent of these points. cCs2t|tsJdt|f||_|||_dS)N^Expected to get an instance of IPointsSampler as argument 'other_points_sampler', got type %s.)rrrother_points_sampler&_convert_p_drop_to_inverted_mask_paramp_drop)r6rrrrrr2s zDropoutPointsSampler.__init__cCst|rtd|}|St|rpt|dks"Jdt|f|d|dks6Jd|d|dfd|dkrBdkrQnn d|dkrPdks]nJd|d|dfttd|dd|d}|St|tjry |St dt |f) Nrr zKExpected 'p_drop' given as an iterable to contain exactly 2 values, got %d.rzeExpected 'p_drop' given as iterable to contain exactly 2 values (a, b) with a < b. Got %.4f and %.4f.rziExpected 'p_drop' given as iterable to only contain values in the interval [0.0, 1.0], got %.4f and %.4f.zBExpected p_drop to be float or int or StochasticParameter, got %s.) rZis_single_numberr3ZBinomial is_iterablerSZUniformrZStochasticParameter Exceptionr)rrrrrrrs>   8 " z;DropoutPointsSampler._convert_p_drop_to_inverted_mask_paramcCsJt|}t||d}|j||d}|||d}|||S)Nr rr)rrrrTrrr_apply_dropout_masks)r6rPr'r_points_on_images drop_masksrrrrs   z"DropoutPointsSampler.sample_pointscs*|t|}fddt||D}|S)Ncsg|] \}}||qSr)_draw_samples_for_imagerpoints_on_imageraryrrrsz6DropoutPointsSampler._draw_samples..)rTrSrY)r6rr'r_rrryrrs  z"DropoutPointsSampler._draw_samplescCs |jt|f|}|dk}|S)Nr)rrUrS)r6rr'Z drop_samplesrrrrrs z,DropoutPointsSampler._draw_samples_for_imagecCstg}t||D]0\}}t|dkr|}nt|s*t|dd}t|}d||<||ddf}||q|S)Nrrr T)rYrSrVrrjr)rrrZ keep_masksZpoints_on_images_droppedrrZ poi_droppedidxrrrrs    z)DropoutPointsSampler._apply_dropout_maskscCr)NzDropoutPointsSampler(%s, %s))rrryrrrrzDropoutPointsSampler.__repr__cCrrrryrrrrrzDropoutPointsSampler.__str__N) r|r}r~rr2rrrrrrrrrrrrrs)    rc@sDeZdZdZddZddZddZedd Zd d Z d d Z dS)ra}Sample points uniformly on images. This point sampler generates `n_points` points per image. The x- and y-coordinates are both sampled from uniform distributions matching the respective image width and height. Parameters ---------- n_points : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Number of points to sample on each image. * If a single ``int``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value from the discrete interval ``[a..b]`` will be sampled per image. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then that parameter will be queried to draw one value per image. Examples -------- >>> import imgaug.augmenters as iaa >>> sampler = iaa.UniformPointsSampler(500) Create a point sampler that generates an array of ``500`` random points for each input image. The x- and y-coordinates of each point are sampled from uniform distributions. cCstj|dddddd|_dS)Nrr.TFr/)r3r5r)r6rrrrr2+s zUniformPointsSampler.__init__c Csnt|}t||d}|t||d}t|}d|}|ddd|}| |d}| |||S)Nr rrrr) rrrrTrrSrVsumuniformr$_convert_relative_coords_to_absolute) r6rPr'r_n_points_imagewiseZn_points_totalZn_components_totalZcoords_relativeZcoords_relative_xyrrrr0s    z"UniformPointsSampler.sample_pointscCs$|jj|f|d}t|dd}|S)NrNr)rrUrVrW)r6rr'rZn_points_clippedrrrr?s z"UniformPointsSampler._draw_samplescCsg}d}t||D]I\}}|jdd\}} ||||df} ||||df} tt| | d| } tt| |d|} |tj| | gdd||7}q |S)Nrr rr)Zaxis)rYrrVrWrprstack)rrZ coords_rel_xyrrPZcoords_absoluter`rZn_points_imagerrrrZxx_intZyy_intrrrrEs z9UniformPointsSampler._convert_relative_coords_to_absolutecCs d|jfS)NzUniformPointsSampler(%s))rryrrrrVs zUniformPointsSampler.__repr__cCrrrryrrrrYrzUniformPointsSampler.__str__N) r|r}r~rr2rrrrrrrrrrr s  rc@s<eZdZdZddZddZeddZdd Zd d Z d S) SubsamplingPointsSampleraEnsure that the number of sampled points is below a maximum. This point sampler will sample points from another sampler and then -- in case more points were generated than an allowed maximum -- will randomly pick `n_points_max` of these. Parameters ---------- other_points_sampler : IPointsSampler Another point sampler that is queried to generate a ``list`` of points. The dropout operation will be applied to that ``list``. n_points_max : int Maximum number of allowed points. If `other_points_sampler` generates more points than this maximum, a random subset of size `n_points_max` will be selected. Examples -------- >>> import imgaug.augmenters as iaa >>> sampler = iaa.SubsamplingPointsSampler( >>> iaa.RelativeRegularGridPointsSampler(0.1, 0.2), >>> 50 >>> ) Create a points sampler that places ``y*H`` points on the y-axis (with ``y`` being ``0.1`` and ``H`` being an image's height) and ``x*W`` on the x-axis (analogous). Then, if that number of placed points exceeds ``50`` (can easily happen for larger images), a random subset of ``50`` points will be picked and returned. cCsNt|tsJdt|f||_t|dd|_|jdkr%tddSdS)NrrrzdGot n_points_max=0 in SubsamplingPointsSampler. This will result in no points ever getting returned.) rrrrrVrW n_points_maxrwarn)r6rrrrrr2s  z!SubsamplingPointsSampler.__init__csVt|}t||t|d}j||d}fddt||ddDS)Nrrcs g|] \}}|j|qSr) _subsamplerrryrrrsz:SubsamplingPointsSampler.sample_points..)rrrrTrSrrrY)r6rPr'r_rrryrrs  z&SubsamplingPointsSampler.sample_pointscCs8t||kr|Stt|}||d|}||S)Nr)rSrVrZ permutation)rrrrr'indicesrrrrrs z#SubsamplingPointsSampler._subsamplecCr)Nz SubsamplingPointsSampler(%s, %d))rrryrrrrrz!SubsamplingPointsSampler.__repr__cCrrrryrrrrrz SubsamplingPointsSampler.__str__N) r|r}r~rr2rrrrrrrrrr]s!   rr)0r __future__rrrabcrrnumpyrVZskimage.segmentationrZZskimage.measuresixZ six.movesmovesrkZimgaugrrr rr r3r rQrZ Augmenterrrrrrrrrrr add_metaclassobjectrrrrrrrrrrrsN      $ 5 W{(7&bQ