o e@sdZddlmZmZmZddlZddlmZddl Z ddl m Z ddl ZddlmZddlmZddlmZd d lmZd d lmZd"ddZddZddZGdddejZGdddejZGdddejZGdddejZ Gdddej!Z"Gddde#Z$Gd d!d!ejZ%dS)#z Augmenters that blur images. List of augmenters: * :class:`GaussianBlur` * :class:`AverageBlur` * :class:`MedianBlur` * :class:`BilateralBlur` * :class:`MotionBlur` * :class:`MeanShiftBlur` )print_functiondivisionabsolute_importN)ndimage)_normalize_cv2_input_arr_)meta) convolutional) parameters)dtypesautoMbP?c Cs|jdk}|d|krZ|sZ|j}tj|gdgdddgd}|}|dkr4|jj|vr1dnd }n|dkrH|jj|vsGJd |jjfn|d krM |d kr|jd kr_|jtjd d }n |jdkrl|jtjd d }|durut d|j dkrt j |ddddf|dd|ddddf<n|j d} t| D]} t j |dddd| f|dd|dddd| f<qn|jd kr|jtjd d }n)|jdkr|jtjd d }n|jdkr|jtjd d }n |jdkr|jtjd d }|durt|}nt|s Jdt|f|ddkr|dn|}|dkr@tjt|||f||tjd} |j dkr>| j dkr>| dtjfn| }|jd krL|dk}|S|j|jjkrZt||}|S)a\Blur an image using gaussian blurring in-place. This operation *may* change the input image in-place. **Supported dtypes**: if (backend="auto"): * ``uint8``: yes; fully tested (1) * ``uint16``: yes; tested (1) * ``uint32``: yes; tested (2) * ``uint64``: yes; tested (2) * ``int8``: yes; tested (1) * ``int16``: yes; tested (1) * ``int32``: yes; tested (1) * ``int64``: yes; tested (2) * ``float16``: yes; tested (1) * ``float32``: yes; tested (1) * ``float64``: yes; tested (1) * ``float128``: no * ``bool``: yes; tested (1) - (1) Handled by ``cv2``. See ``backend="cv2"``. - (2) Handled by ``scipy``. See ``backend="scipy"``. if (backend="cv2"): * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: no (2) * ``uint64``: no (3) * ``int8``: yes; tested (4) * ``int16``: yes; tested * ``int32``: yes; tested (5) * ``int64``: no (6) * ``float16``: yes; tested (7) * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: no (8) * ``bool``: yes; tested (1) - (1) Mapped internally to ``float32``. Otherwise causes ``TypeError: src data type = 0 is not supported``. - (2) Causes ``TypeError: src data type = 6 is not supported``. - (3) Causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error: (-213:The function/feature is not implemented) Unsupported combination of source format (=4), and buffer format (=5) in function 'getLinearRowFilter'``. - (4) Mapped internally to ``int16``. Otherwise causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error: (-213:The function/feature is not implemented) Unsupported combination of source format (=1), and buffer format (=5) in function 'getLinearRowFilter'``. - (5) Mapped internally to ``float64``. Otherwise causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error: (-213:The function/feature is not implemented) Unsupported combination of source format (=4), and buffer format (=5) in function 'getLinearRowFilter'``. - (6) Causes ``cv2.error: OpenCV(3.4.5) (...)/filter.cpp:2957: error: (-213:The function/feature is not implemented) Unsupported combination of source format (=4), and buffer format (=5) in function 'getLinearRowFilter'``. - (7) Mapped internally to ``float32``. Otherwise causes ``TypeError: src data type = 23 is not supported``. - (8) Causes ``TypeError: src data type = 13 is not supported``. if (backend="scipy"): * ``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 (1) * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: no (2) * ``bool``: yes; tested (3) - (1) Mapped internally to ``float32``. Otherwise causes ``RuntimeError: array type dtype('float16') not supported``. - (2) Causes ``RuntimeError: array type dtype('float128') not supported``. - (3) Mapped internally to ``float32``. Otherwise too inaccurate. Parameters ---------- image : numpy.ndarray The image to blur. Expected to be of shape ``(H, W)`` or ``(H, W, C)``. sigma : number Standard deviation of the gaussian blur. Larger numbers result in more large-scale blurring, which is overall slower than small-scale blurring. ksize : None or int, optional Size in height/width of the gaussian kernel. This argument is only understood by the ``cv2`` backend. If it is set to ``None``, an appropriate value for `ksize` will automatically be derived from `sigma`. The value is chosen tighter for larger sigmas to avoid as much as possible very large kernel sizes and therey improve performance. backend : {'auto', 'cv2', 'scipy'}, optional Backend library to use. If ``auto``, then the likely best library will be automatically picked per image. That is usually equivalent to ``cv2`` (OpenCV) and it will fall back to ``scipy`` for datatypes not supported by OpenCV. eps : number, optional A threshold used to decide whether `sigma` can be considered zero. Returns ------- numpy.ndarray The blurred image. Same shape and dtype as the input. (Input image *might* have been altered in-place.) r) booluint8uint16uint32int8int16int32int64uint64float16float32float64)uint128uint256int128int256float96float128float256NallowedZ disallowedZ augmenter)rrrr r cv2scipyzRequested 'cv2' backend, but provided %s input image, which cannot be handled by that backend. Choose a different backend or set backend to 'auto' or use a different datatype.rFcopyrzRequested 'scipy' backend or picked it automatically by backend='auto' n blur_gaussian_(), but also provided 'ksize' argument, which is not understood by that backend and will be ignored.r Zmirror)moderrz1Expected 'ksize' argument to be a number, got %s.r)ZsigmaXZsigmaYZ borderType.?)sizedtypeiadt gate_dtypesnameastypenpriawarnndimrZgaussian_filtershapesmxrangerr_compute_gaussian_blur_ksizeis_single_integertyper$ GaussianBlurrZBORDER_REFLECT_101newaxisrestore_dtypes_) imagesigmaksizebackendepshas_zero_sized_axesr,Zdts_not_supported_by_cv2Zbackend_to_use nb_channelsZchannelZ image_warpedrEFD:\Projects\ConvertPro\env\Lib\site-packages\imgaug/augmenters/blur.pyblur_gaussian_s {               rGcCs d|jddvr |S|jjdksJd|jjf|jdk}|jdko*|jddk}|jdko6|jddk}|sE|sE|sEJd|jf|rSt|d tjfd }n|r[t|d }t|d}t|d}t|}t j ||||d }|rz|d }|S|r|d ddf}|S) aApply a pyramidic mean shift filter to the input image in-place. This produces an output image that has similarity with one modified by a bilateral filter. That is different from mean shift *segmentation*, which averages the colors in segments found by mean shift clustering. This function is a thin wrapper around ``cv2.pyrMeanShiftFiltering``. .. note:: This function does *not* change the image's colorspace to ``RGB`` before applying the mean shift filter. A non-``RGB`` colorspace will hence influence the results. .. note:: This function is quite slow. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: no (1) * ``uint32``: no (1) * ``uint64``: no (1) * ``int8``: no (1) * ``int16``: no (1) * ``int32``: no (1) * ``int64``: no (1) * ``float16``: no (1) * ``float32``: no (1) * ``float64``: no (1) * ``float128``: no (1) * ``bool``: no (1) - (1) Not supported by ``cv2.pyrMeanShiftFiltering``. Parameters ---------- image : ndarray ``(H,W)`` or ``(H,W,1)`` or ``(H,W,3)`` image to blur. Images with no or one channel will be temporarily tiled to have three channels. spatial_window_radius : number Spatial radius for pixels that are assumed to be similar. color_window_radius : number Color radius for pixels that are assumed to be similar. Returns ------- ndarray Blurred input image. Same shape and dtype as the input. (Input image *might* have been altered in-place.) rr rz,Expected image with dtype "uint8", got "%s".r)rz9Expected (H,W) or (H,W,1) or (H,W,3) image, got shape %s..)rrr))spsrdst).r) r5r,r/r4r1Ztiler<maxrr$ZpyrMeanShiftFiltering)r>spatial_window_radiuscolor_window_radiusZ shape_is_hwZ shape_is_hw1Z shape_is_hw3rErErFblur_mean_shift_sD;    rOcCs>|dkr d|}n |dkrd|}nd|}tt|d}|S)N@gffffff @@g333333@g@)intrL)r?r@rErErFr8rs  r8c8eZdZdZ   d fdd ZddZd d ZZS) r;aAugmenter to blur images using gaussian kernels. **Supported dtypes**: See ``~imgaug.augmenters.blur.blur_gaussian_(backend="auto")``. Parameters ---------- sigma : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Standard deviation of the gaussian kernel. Values in the range ``0.0`` (no blur) to ``3.0`` (strong blur) are common. * If a single ``float``, that value will always be used as the standard deviation. * If a tuple ``(a, b)``, then a random value from the interval ``[a, b]`` will be picked per image. * If a list, then a random value will be sampled per image from that list. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images. 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.GaussianBlur(sigma=1.5) Blur all images using a gaussian kernel with a standard deviation of ``1.5``. >>> aug = iaa.GaussianBlur(sigma=(0.0, 3.0)) Blur images using a gaussian kernel with a random standard deviation sampled uniformly (per image) from the interval ``[0.0, 3.0]``. grPN deprecatedcs8tt|j||||dtj|ddddd|_d|_dS)Nseedr/ random_state deterministicr?)rNT value_rangetuple_to_uniformlist_to_choicer)superr;__init__iaphandle_continuous_paramr?rB)selfr?rXr/rYrZ __class__rErFr`s  zGaussianBlur.__init__c CsZ|jdur|S|j}t|}|jj|f|d}t||D]\}} t|| |jd|d<q|S)NrY)r?rB.)imageslenr? draw_samplesziprGrB) rcbatchrYparentshooksrg nb_imagessamplesr>sigrErErF_augment_batch_s  zGaussianBlur._augment_batch_cC|jgSz=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.)r?rcrErErFget_parameterszGaussianBlur.get_parameters)rUNNrVrV__name__ __module__ __qualname____doc__r`rqru __classcell__rErErdrFr;s6 r;crT) AverageBluraBlur an image by computing simple means over neighbourhoods. The padding behaviour around the image borders is cv2's ``BORDER_REFLECT_101``. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: yes; tested * ``uint32``: no (1) * ``uint64``: no (2) * ``int8``: yes; tested (3) * ``int16``: yes; tested * ``int32``: no (4) * ``int64``: no (5) * ``float16``: yes; tested (6) * ``float32``: yes; tested * ``float64``: yes; tested * ``float128``: no * ``bool``: yes; tested (7) - (1) rejected by ``cv2.blur()`` - (2) loss of resolution in ``cv2.blur()`` (result is ``int32``) - (3) ``int8`` is mapped internally to ``int16``, ``int8`` itself leads to cv2 error "Unsupported combination of source format (=1), and buffer format (=4) in function 'getRowSumFilter'" in ``cv2`` - (4) results too inaccurate - (5) loss of resolution in ``cv2.blur()`` (result is ``int32``) - (6) ``float16`` is mapped internally to ``float32`` - (7) ``bool`` is mapped internally to ``float32`` Parameters ---------- k : int or tuple of int or tuple of tuple of int or imgaug.parameters.StochasticParameter or tuple of StochasticParameter, optional Kernel size to use. * If a single ``int``, then that value will be used for the height and width of the kernel. * If a tuple of two ``int`` s ``(a, b)``, then the kernel size will be sampled from the interval ``[a..b]``. * If a tuple of two tuples of ``int`` s ``((a, b), (c, d))``, then per image a random kernel height will be sampled from the interval ``[a..b]`` and a random kernel width will be sampled from the interval ``[c..d]``. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images, each representing the kernel size for the n-th image. * If a tuple ``(a, b)``, where either ``a`` or ``b`` is a tuple, then ``a`` and ``b`` will be treated according to the rules above. This leads to different values for height and width of the kernel. 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.AverageBlur(k=5) Blur all images using a kernel size of ``5x5``. >>> aug = iaa.AverageBlur(k=(2, 5)) Blur images using a varying kernel size, which is sampled (per image) uniformly from the interval ``[2..5]``. >>> aug = iaa.AverageBlur(k=((5, 7), (1, 3))) Blur images using a varying kernel size, which's height is sampled (per image) uniformly from the interval ``[5..7]`` and which's width is sampled (per image) uniformly from ``[1..3]``. rNrVcstt|j||||dd|_t|rtt||_ dSt |rt |dks2Jdt |ft dd|DrLt t|dt|d|_ dSt d d|Drcd |_|d|df|_ dSddg}t|drztt|d|d<n2t |drt d d|dDrt t|ddt|dd|d<n td t|dft|drtt|d|d<n2t |drt d d|dDrt t|ddt|dd|d<n tdt|dfd |_||_ dSt|tjr||_ dStdt|f)NrWsingler z;Expected iterable 'k' to contain exactly 2 entries, got %d.cSg|]}t|qSrEr2is_single_number.0ZkirErErF Fz(AverageBlur.__init__..rrcSsg|]}t|tjqSrE) isinstanceraStochasticParameterrrErErFrHtwocSrrErrrErErFrPrz4k[0] expected to be int or tuple of two ints, got %scSrrErrrErErFr[rz4k[1] expected to be int or tuple of two ints, got %szGExpected int, tuple/list with 2 entries or StochasticParameter. Got %s.)r_r}r`r(r2rraZ DeterministicrSk is_iterablerhallZDiscreteUniform Exceptionr:rr)rcrrXr/rYrZZk_tuplerdrErFr`7sl   "      zAverageBlur.__init__cs|jdur|S|j}tj|gdgd|dt|}|jdkr.|jj|f|d}||f}n|d}|jdj|f|dd|jdj|f|ddf}tt ||d|d} | D]\} \dkpidk} dkoqdk} j dk} | s| s| sj }j j d vrj tjd d nj j d krj tjd d jdksjd dkrttf}|jdkr|dtjf}nfddtjd D}tj|d d}|j dkr|dk}n |j dvrt||}||j| <q[|S)N)rrrrrrrr) rrrrrrrrrr r!r"rrfr rr)rrFr&rrH.cs(g|]}ttd|ffqS.)r$blurrrcr>Zksize_hZksize_wrErFrsz/AverageBlur._augment_batch_..Zaxisrr*)rr)rgr-r.rhr(rri duplicate enumeraterjr+r,r/r0r1rrr4r5r$rrr<r6r7stackr=)rcrkrYrlrmrgrnrorssgeniZkernel_impossibleZkernel_does_nothingrCZ input_dtype image_augchannelsrErrFrqmsf              zAverageBlur._augment_batch_cCrrrsrrtrErErFrurvzAverageBlur.get_parametersr~NNrVrVrwrErErdrFr}sZ6Cr}crT) MedianBlura Blur an image by computing median values over neighbourhoods. Median blurring can be used to remove small dirt from images. At larger kernel sizes, its effects have some similarity with Superpixels. **Supported dtypes**: * ``uint8``: yes; fully tested * ``uint16``: ? * ``uint32``: ? * ``uint64``: ? * ``int8``: ? * ``int16``: ? * ``int32``: ? * ``int64``: ? * ``float16``: ? * ``float32``: ? * ``float64``: ? * ``float128``: ? * ``bool``: ? Parameters ---------- k : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Kernel size. * If a single ``int``, then that value will be used for the height and width of the kernel. Must be an odd value. * If a tuple of two ints ``(a, b)``, then the kernel size will be an odd value sampled from the interval ``[a..b]``. ``a`` and ``b`` must both be odd values. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images, each representing the kernel size for the nth image. Expected to be discrete. If a sampled value is not odd, then that value will be increased by ``1``. 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.MedianBlur(k=5) Blur all images using a kernel size of ``5x5``. >>> aug = iaa.MedianBlur(k=(3, 7)) Blur images using varying kernel sizes, which are sampled uniformly from the interval ``[3..7]``. Only odd values will be sampled, i.e. ``3`` or ``5`` or ``7``. r~NrVcstt|j||||dtj|dddddd|_t|r.|ddks,Jd t|fdSt |r@t d d |DsBJd dSdS) NrWrrNTFr\r]r^Z allow_floatsr rz0Expected k to be odd, got %d. Add or subtract 1.cSsg|]}|ddkqS)r rrErrErErFr rz'MedianBlur.__init__..zlExpected all values in iterable k to be odd, but at least one was not. Add or subtract 1 to/from that value.) r_rr`rahandle_discrete_paramrr2r9rSrr)rcrrXr/rYrZrdrErFr`s(   zMedianBlur.__init__c s|jdur|S|j}t|}|jj|f|d}tt||D]Z\}\jdk} dkrx| sxddkr9dnjdksGjddkr\t t } | jdkr[| dt j f} nfdd tjdD} t j| dd } | |j|<q|S) Nrfrrr rHr.cs$g|]}ttd|fqSr)r$ medianBlurrrr>r@rErFr's z.MedianBlur._augment_batch_..r)rgrhrrirrjr+r4r5r$rrr1r<r6r7r) rcrkrYrlrmrgrnrorrCrrrErrFrqs.      zMedianBlur._augment_batch_cCrrrsrrtrErErFru1rvzMedianBlur.get_parametersrrwrErErdrFrsGrcs8eZdZdZ   d fdd Zdd Zd d ZZS) BilateralBluraRBlur/Denoise an image using a bilateral filter. Bilateral filters blur homogenous and textured areas, while trying to preserve edges. See http://docs.opencv.org/2.4/modules/imgproc/doc/filtering.html#bilateralfilter for more information regarding the parameters. **Supported dtypes**: * ``uint8``: yes; not tested * ``uint16``: ? * ``uint32``: ? * ``uint64``: ? * ``int8``: ? * ``int16``: ? * ``int32``: ? * ``int64``: ? * ``float16``: ? * ``float32``: ? * ``float64``: ? * ``float128``: ? * ``bool``: ? Parameters ---------- d : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Diameter of each pixel neighborhood with value range ``[1 .. inf)``. High values for `d` lead to significantly worse performance. Values equal or less than ``10`` seem to be good. Use ``<5`` for real-time applications. * If a single ``int``, then that value will be used for the diameter. * If a tuple of two ``int`` s ``(a, b)``, then the diameter will be a value sampled from the interval ``[a..b]``. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images, each representing the diameter for the n-th image. Expected to be discrete. sigma_color : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Filter sigma in the color space with value range ``[1, inf)``. A large value of the parameter means that farther colors within the pixel neighborhood (see `sigma_space`) will be mixed together, resulting in larger areas of semi-equal color. * If a single ``int``, then that value will be used for the diameter. * If a tuple of two ``int`` s ``(a, b)``, then the diameter will be a value sampled from the interval ``[a, b]``. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images, each representing the diameter for the n-th image. Expected to be discrete. sigma_space : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Filter sigma in the coordinate space with value range ``[1, inf)``. A large value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see `sigma_color`). * If a single ``int``, then that value will be used for the diameter. * If a tuple of two ``int`` s ``(a, b)``, then the diameter will be a value sampled from the interval ``[a, b]``. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images, each representing the diameter for the n-th image. Expected to be discrete. 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.BilateralBlur( >>> d=(3, 10), sigma_color=(10, 250), sigma_space=(10, 250)) Blur all images using a bilateral filter with a `max distance` sampled uniformly from the interval ``[3, 10]`` and wide ranges for `sigma_color` and `sigma_space`. r  NrVcs`tt|j||||dtj|dddddd|_tj|ddddd|_tj|d dddd|_dS) NrWdrTFr sigma_colorr[ sigma_space) r_rr`rarrrbrr)rcrrrrXr/rYrZrdrErFr`s  zBilateralBlur.__init__cCs|jdur|S|j}tdd|DsJddd|Dft|}|d}|jj|f|dd}|jj|f|dd} |jj|f|d d} tt ||| | } | D] \} \} }}}| j dk}|dkrt|stt t | ||||j| <qT|S) NcSsg|] }|jddkqS)r r)r5rr>rErErFrsz1BilateralBlur._augment_batch_..zWBilateralBlur can currently only be applied to images with 3 channels. Got channels: %scSsg|]}|jdqS)r rrrErErFrrr)rrfrr )rgrrhrrrirrrrjr+r$ZbilateralFilterr)rcrkrYrlrmrgrnrZ samples_dZsamples_sigma_colorZsamples_sigma_spacerrr>ZdiZ sigma_color_iZ sigma_space_irCrErErFrqs<         zBilateralBlur._augment_batch_cCs|j|j|jgSrs)rrrrtrErErFruszBilateralBlur.get_parameters)rrrNNrVrVrwrErErdrFr7shrcs(eZdZdZ   d fdd ZZS) MotionBluraBlur images in a way that fakes camera or object movements. **Supported dtypes**: See :class:`~imgaug.augmenters.convolutional.Convolve`. Parameters ---------- k : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Kernel size to use. * If a single ``int``, then that value will be used for the height and width of the kernel. * If a tuple of two ``int`` s ``(a, b)``, then the kernel size will be sampled from the interval ``[a..b]``. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, then ``N`` samples will be drawn from that parameter per ``N`` input images, each representing the kernel size for the n-th image. angle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Angle of the motion blur in degrees (clockwise, relative to top center direction). * If a number, exactly that value will be used. * If a tuple ``(a, b)``, a random value from the interval ``[a, b]`` will be uniformly sampled per image. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from the parameter per image. direction : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Forward/backward direction of the motion blur. Lower values towards ``-1.0`` will point the motion blur towards the back (with angle provided via `angle`). Higher values towards ``1.0`` will point the motion blur forward. A value of ``0.0`` leads to a uniformly (but still angled) motion blur. * If a number, exactly that value will be used. * If a tuple ``(a, b)``, a random value from the interval ``[a, b]`` will be uniformly sampled per image. * If a list, then a random value will be sampled from that list per image. * If a ``StochasticParameter``, a value will be sampled from the parameter per image. order : int or iterable of int or imgaug.ALL or imgaug.parameters.StochasticParameter, optional Interpolation order to use when rotating the kernel according to `angle`. See :func:`~imgaug.augmenters.geometric.Affine.__init__`. Recommended to be ``0`` or ``1``, with ``0`` being faster, but less continuous/smooth as `angle` is changed, particularly around multiple of ``45`` degrees. 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.MotionBlur(k=15) Apply motion blur with a kernel size of ``15x15`` pixels to images. >>> aug = iaa.MotionBlur(k=15, angle=[-45, 45]) Apply motion blur with a kernel size of ``15x15`` pixels and a blur angle of either ``-45`` or ``45`` degrees (randomly picked per image). r)rrih?rNrVc sjtj|dddddd} tj|ddddd} tj|dd ddd} t| | | |} tt|j| ||||d dS) Nr)r)NTFrangler[ direction)g zo g zo ?rW)rarrb_MotionBlurMatrixGeneratorr_rr`) rcrrrorderrXr/rYrZZk_paramZ angle_paramZdirection_paramZ matrix_genrdrErFr`/s(  zMotionBlur.__init__)rrrrNNrVrV)rxryrzr{r`r|rErErdrFrs Wrc@seZdZddZddZdS)rcCs||_||_||_||_dS)N)rrrr)rcrrrrrErErFr`Is z#_MotionBlurMatrixGenerator.__init__c Csddlm}t|jj|d}|jj|d}|jj|d}|ddkr%|n|d}t|dd}|dd}tj ||ftj d }tj t |dt ||d |dd|df<|j ||jd } | |d tjtj d }|t|g|S)Nr) geometricrfr rrrg@)r,)num)rotatergo@)rrSrZ draw_samplerrr1ZclipZzerosrZlinspacefloatZAffinerZ augment_imager0rsum) rcZ_imagerDrYZ iaa_geometricZk_sampleZ angle_sampleZdirection_samplematrixZrotrErErF__call__Ps6     z#_MotionBlurMatrixGenerator.__call__N)rxryrzr`rrErErErFrGs rcs@eZdZdZ   d fdd ZddZd d Zd d ZZS) MeanShiftBlura Apply a pyramidic mean shift filter to each image. See also :func:`blur_mean_shift_` for details. This augmenter expects input images of shape ``(H,W)`` or ``(H,W,1)`` or ``(H,W,3)``. .. note:: This augmenter is quite slow. Added in 0.4.0. **Supported dtypes**: See :func:`~imgaug.augmenters.blur.blur_mean_shift_`. Parameters ---------- spatial_radius : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Spatial radius for pixels that are assumed to be similar. * If ``number``: Exactly that value will be used for all images. * If ``tuple`` ``(a, b)``: A random value will be uniformly sampled per image from the interval ``[a, b)``. * If ``list``: A random value will be sampled from that ``list`` per image. * If ``StochasticParameter``: The parameter will be queried once per batch for ``(N,)`` values with ``N`` denoting the number of images. color_radius : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Color radius for pixels that are assumed to be similar. * If ``number``: Exactly that value will be used for all images. * If ``tuple`` ``(a, b)``: A random value will be uniformly sampled per image from the interval ``[a, b)``. * If ``list``: A random value will be sampled from that ``list`` per image. * If ``StochasticParameter``: The parameter will be queried once per batch for ``(N,)`` values with ``N`` denoting the number of images. 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.MeanShiftBlur() Create a mean shift blur augmenter. rQgD@NrVcsHtt|j||||dtj|ddddd|_tj|ddddd|_dS)NrWspatial_radius)g{Gz?NTr[ color_radius)r_rr`rarbrMrN)rcrrrXr/rYrZrdrErFr`s  zMeanShiftBlur.__init__cCsR|jdur'|||}t|jD]\}}t||d||d|d|j|<q|S)NrrrMrN)rg _draw_samplesrrO)rcrkrYrlrmrorr>rErErFrqs    zMeanShiftBlur._augment_batch_cCs*|j}|jj|f|d|jj|f|dfS)Nrf)nb_rowsrMrirN)rcrkrYrrErErFrs  zMeanShiftBlur._draw_samplescCs |j|jgSrsrrtrErErFrus zMeanShiftBlur.get_parameters)rrNNrVrV) rxryrzr{r`rqrrur|rErErdrFrssF  r)Nr r)&r{ __future__rrrnumpyr1r%rr$Z six.movesmovesr6Zimgaugr2Z imgaug.imgaugrrrr Ziaa_convolutionalr rar r-rGrOr8Z Augmenterr;r}rrZConvolverobjectrrrErErErFs4         qdXZ!p,