o e5@sdZddlmZmZmZddlZddlZddl m Z m Z m Z m Z mZddl mZddl mZGd d d e jZGd d d e jZGd dde jZGdddeZGddde jZGddde jZGdddeZGddde jZdS)a  Augmenters that create weather effects. List of augmenters: * :class:`FastSnowyLandscape` * :class:`CloudLayer` * :class:`Clouds` * :class:`Fog` * :class:`SnowflakesLayer` * :class:`Snowflakes` * :class:`RainLayer` * :class:`Rain` )print_functiondivisionabsolute_importN)meta arithmeticblurcontrastcolor) parameters)dtypescsJeZdZdZddejddddffdd Zdd Zd d Zd d Z Z S)FastSnowyLandscapeaConvert non-snowy landscapes to snowy ones. This augmenter expects to get an image that roughly shows a landscape. This augmenter is based on the method proposed in https://medium.freecodecamp.org/image-augmentation-make-it-rain-make-it-snow-how-to-modify-a-photo-with-machine-learning-163c0cb3843f?gi=bca4a13e634c **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) This augmenter is based on a colorspace conversion to HLS. Hence, only RGB ``uint8`` inputs are sensible. Parameters ---------- lightness_threshold : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional All pixels with lightness in HLS colorspace that is below this value will have their lightness increased by `lightness_multiplier`. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the discrete interval ``[a..b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. lightness_multiplier : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Multiplier for pixel's lightness value in HLS colorspace. Affects all pixels selected via `lightness_threshold`. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the discrete interval ``[a..b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. from_colorspace : str, optional The source colorspace of the input images. See :func:`~imgaug.augmenters.color.ChangeColorspace.__init__`. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.FastSnowyLandscape( >>> lightness_threshold=140, >>> lightness_multiplier=2.5 >>> ) Search for all pixels in the image with a lightness value in HLS colorspace of less than ``140`` and increase their lightness by a factor of ``2.5``. >>> aug = iaa.FastSnowyLandscape( >>> lightness_threshold=[128, 200], >>> lightness_multiplier=(1.5, 3.5) >>> ) Search for all pixels in the image with a lightness value in HLS colorspace of less than ``128`` or less than ``200`` (one of these values is picked per image) and multiply their lightness by a factor of ``x`` with ``x`` being sampled from ``uniform(1.5, 3.5)`` (once per image). >>> aug = iaa.FastSnowyLandscape( >>> lightness_threshold=(100, 255), >>> lightness_multiplier=(1.0, 4.0) >>> ) Similar to the previous example, but the lightness threshold is sampled from ``uniform(100, 255)`` (per image) and the multiplier from ``uniform(1.0, 4.0)`` (per image). This seems to produce good and varied results. )d)?g@N deprecatedcsNtt|j||||dtj|ddddd|_tj|ddddd|_||_dS)Nseedname random_state deterministiclightness_threshold)rrT) value_rangeZtuple_to_uniformZlist_to_choicelightness_multiplier)rN)superr__init__iaphandle_continuous_paramrrfrom_colorspace)selfrrrrrrr __class__ID:\Projects\ConvertPro\env\Lib\site-packages\imgaug/augmenters/weather.pyrs  zFastSnowyLandscape.__init__cCsBt|}|d}|j|f|d}|j|f|d}||fS)Nr rr)len duplicater draw_samplesr)r Z augmentablesrZnb_augmentablesrssthresh_samples lmul_samplesr#r#r$ _draw_sampless   z FastSnowyLandscape._draw_samplescCs|jdur|S|j}|||\}}tt|||}|D];\} \} } } t| tj|j} | j}| t j } | d}||| k| 9<t | |} t| |jtj}||j| <q|S)N).r)imagesr+ enumeratezipcolorlibZchange_colorspace_Z CSPACE_HLSrdtypeastypenpfloat64iadtZrestore_dtypes_)r batchrparentshooksr,r)r*geniimageZthreshZlmulZ image_hlsZ cvt_dtypeZ lightnessZ image_rgbr#r#r$_augment_batch_s&      z"FastSnowyLandscape._augment_batch_cCs |j|jgSz=See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.)rrr r#r#r$get_parameterss z!FastSnowyLandscape.get_parameters) __name__ __module__ __qualname____doc__r/Z CSPACE_RGBrr+r;r> __classcell__r#r#r!r$rsl rcsjeZdZdZ  dfdd ZddZdd Zd d Zd d Ze ddZ e ddZ e ddZ Z S) CloudLayeraAdd a single layer of clouds to an image. **Supported dtypes**: * ``uint8``: yes; indirectly tested (1) * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: yes; not tested * ``float32``: yes; not tested * ``float64``: yes; not tested * ``float128``: yes; not tested (2) * ``bool``: no - (1) Indirectly tested via tests for :class:`Clouds`` and :class:`Fog` - (2) Note that random values are usually sampled as ``int64`` or ``float64``, which ``float128`` images would exceed. Note also that random values might have to upscaled, which is done via :func:`~imgaug.imgaug.imresize_many_images` and has its own limited dtype support (includes however floats up to ``64bit``). Parameters ---------- intensity_mean : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Mean intensity of the clouds (i.e. mean color). Recommended to be in the interval ``[190, 255]``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. intensity_freq_exponent : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Exponent of the frequency noise used to add fine intensity to the mean intensity. Recommended to be in the interval ``[-2.5, -1.5]``. See :func:`~imgaug.parameters.FrequencyNoise.__init__` for details. intensity_coarse_scale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Standard deviation of the gaussian distribution used to add more localized intensity to the mean intensity. Sampled in low resolution space, i.e. affects final intensity on a coarse level. Recommended to be in the interval ``(0, 10]``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. alpha_min : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Minimum alpha when blending cloud noise with the image. High values will lead to clouds being "everywhere". Recommended to usually be at around ``0.0`` for clouds and ``>0`` for fog. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. alpha_multiplier : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Multiplier for the sampled alpha values. High values will lead to denser clouds wherever they are visible. Recommended to be in the interval ``[0.3, 1.0]``. Note that this parameter currently overlaps with `density_multiplier`, which is applied a bit later to the alpha mask. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. alpha_size_px_max : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Controls the image size at which the alpha mask is sampled. Lower values will lead to coarser alpha masks and hence larger clouds (and empty areas). See :func:`~imgaug.parameters.FrequencyNoise.__init__` for details. alpha_freq_exponent : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Exponent of the frequency noise used to sample the alpha mask. Similarly to `alpha_size_max_px`, lower values will lead to coarser alpha patterns. Recommended to be in the interval ``[-4.0, -1.5]``. See :func:`~imgaug.parameters.FrequencyNoise.__init__` for details. sparsity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Exponent applied late to the alpha mask. Lower values will lead to coarser cloud patterns, higher values to finer patterns. Recommended to be somewhere around ``1.0``. Do not deviate far from that value, otherwise the alpha mask might get weird patterns with sudden fall-offs to zero that look very unnatural. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. density_multiplier : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Late multiplier for the alpha mask, similar to `alpha_multiplier`. Set this higher to get "denser" clouds wherever they are visible. Recommended to be around ``[0.5, 1.5]``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Nrcsztt|j| | | | dt|d|_||_||_t|d|_t|d|_ ||_ ||_ t|d|_ t| d|_ dS)Nrintensity_mean alpha_minalpha_multipliersparsitydensity_multiplier)rrDrrrrEintensity_freq_exponentintensity_coarse_scalerFrGalpha_size_px_maxalpha_freq_exponentrHrI)r rErJrKrFrGrLrMrHrIrrrrr!r#r$r[s&  zCloudLayer.__init__c CT|jdur|S|j}|t|}tt||D]\}\}} ||| |j|<q|SNr,r&r%r-r. draw_on_image r r5rr6r7r,r(r9r:rsr#r#r$r;r zCloudLayer._augment_batch_c C(|j|j|j|j|j|j|j|j|jg Sr<) rErFrGrLrMrJrHrIrKr=r#r#r$r>}zCloudLayer.get_parameterscCstj|gdgdd|||\}}|dtjf}|dtjf}|jjdkr8||j}d||||St|dd}td|||j|||jddtj S) N)uint8Zfloat16float32r3Zfloat96Zfloat128Zfloat256) boolZuint16Zuint32Zuint64Zuint128Zuint256Zint8Zint16Zint32Zint64Zint128Zint256)allowedZ disallowed.frrr) r4Z gate_dtypes generate_mapsr2newaxisr0kindr1cliprW)r r:ralpha intensityr#r#r$rQs(   zCloudLayer.draw_on_imagec Cs|j|}|j|}|j|}|j}|j}|j}|j|} |j|} |j dd\} } | d\} }| | | |t j d|jd|}|| | |||}||}|| | ||||| | | }||fS)Nrr )scale)rE draw_samplerFrGrLrJrMrHrIshaper&_generate_intensity_map_coarserZNormalrK_generate_intensity_map_fine_generate_alpha_mask)r r:rZintensity_mean_sampleZalpha_min_sampleZalpha_multiplier_samplerLrJrMZsparsity_sampleZdensity_multiplier_sampleheightwidthZ rss_alphaZ rss_intensityZintensity_coarseZintensity_finerar`r#r#r$r\s8     zCloudLayer.generate_mapsc Cs4d\}}||||f|}tj|||fdd}|S)Nrkcubic interpolation)r'iaimresize_single_image) clsrhrirEZintensity_local_offsetrZheight_intensityZwidth_intensityrar#r#r$res z)CloudLayer._generate_intensity_map_coarsecCs<tj|t||ddd}|||f|}|d|ddS)NrrlexponentZ size_px_maxZupscale_methodr rg@)rFrequencyNoisemaxr')rqrhrirErsrZintensity_details_generatorZintensity_detailsr#r#r$rfs z'CloudLayer._generate_intensity_map_finec CsJtj||dd} | ||f| } ||| } | ||} t| dd} | S)Nrlrrr)rrtr'r2r_) rqrhrirFrGrsrLrHrIrZalpha_generatorZ alpha_localr`r#r#r$rgs  zCloudLayer._generate_alpha_maskNNrr)r?r@rArBrr;r>rQr\ classmethodrerfrgrCr#r#r!r$rDs      rDc&eZdZdZ  dfdd ZZS)Cloudsa Add clouds to images. This is a wrapper around :class:`~imgaug.augmenters.weather.CloudLayer`. It executes 1 to 2 layers per image, leading to varying densities and frequency patterns of clouds. This augmenter seems to be fairly robust w.r.t. the image size. Tested with ``96x128``, ``192x256`` and ``960x1280``. **Supported dtypes**: * ``uint8``: yes; 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) Parameters of this augmenter are optimized for the value range of ``uint8``. While other dtypes may be accepted, they will lead to images augmented in ways inappropriate for the respective dtype. 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.Clouds() Create an augmenter that adds clouds to images. Nrcsbtddddddddd|||d tdd dddd d d d |||d g}tt|jd|d||||ddS)N)r)g r)g?g?r rk皙?r)?r) rErJrKrFrGrLrMrHrIrrr)r|g)@)rgffffff?)rg?)rr FchildrenZ random_orderrrrr)rDrrzr)r rrrrZlayersr!r#r$r0sH  zClouds.__init__rwr?r@rArBrrCr#r#r!r$rzs <rzcry)FogaAdd fog to images. This is a wrapper around :class:`~imgaug.augmenters.weather.CloudLayer`. It executes a single layer per image with a configuration leading to fairly dense clouds with low-frequency patterns. This augmenter seems to be fairly robust w.r.t. the image size. Tested with ``96x128``, ``192x256`` and ``960x1280``. **Supported dtypes**: * ``uint8``: yes; 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) Parameters of this augmenter are optimized for the value range of ``uint8``. While other dtypes may be accepted, they will lead to images augmented in ways inappropriate for the respective dtype. 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.Fog() Create an augmenter that adds fog to images. Nrcs.tt|jddddddddd ||||d dS) N)r)r|gr )ffffff??333333?r~)gr|r)皙?r) rErJrKrFrGrLrMrHrIrrrr)rrr)r rrrrr!r#r$rs  z Fog.__init__rwrr#r#r!r$r\s ;rcseZdZdZ   dfdd ZddZd d Zd d Zed dZ eddZ eddZ eddZ eddZ eddZeddZeddZZS)SnowflakesLayeraHAdd a single layer of falling snowflakes to images. **Supported dtypes**: * ``uint8``: yes; indirectly tested (1) * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no - (1) indirectly tested via tests for :class:`Snowflakes` Parameters ---------- density : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Density of the snowflake layer, as a probability of each pixel in low resolution space to be a snowflake. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be in the interval ``[0.01, 0.075]``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. density_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Size uniformity of the snowflakes. Higher values denote more similarly sized snowflakes. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be around ``0.5``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. flake_size : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Size of the snowflakes. This parameter controls the resolution at which snowflakes are sampled. Higher values mean that the resolution is closer to the input image's resolution and hence each sampled snowflake will be smaller (because of the smaller pixel size). Valid values are in the interval ``(0.0, 1.0]``. Recommended values: * On 96x128 a value of ``(0.1, 0.4)`` worked well. * On 192x256 a value of ``(0.2, 0.7)`` worked well. * On 960x1280 a value of ``(0.7, 0.95)`` worked well. Datatype behaviour: * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. flake_size_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Controls the size uniformity of the snowflakes. Higher values mean that the snowflakes are more similarly sized. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be around ``0.5``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. angle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Angle in degrees of motion blur applied to the snowflakes, where ``0.0`` is motion blur that points straight upwards. Recommended to be in the interval ``[-30, 30]``. See also :func:`~imgaug.augmenters.blur.MotionBlur.__init__`. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. speed : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Perceived falling speed of the snowflakes. This parameter controls the motion blur's kernel size. It follows roughly the form ``kernel_size = image_size * speed``. Hence, values around ``1.0`` denote that the motion blur should "stretch" each snowflake over the whole image. Valid values are in the interval ``[0.0, 1.0]``. Recommended values: * On 96x128 a value of ``(0.01, 0.05)`` worked well. * On 192x256 a value of ``(0.007, 0.03)`` worked well. * On 960x1280 a value of ``(0.001, 0.03)`` worked well. Datatype behaviour: * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. blur_sigma_fraction : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Standard deviation (as a fraction of the image size) of gaussian blur applied to the snowflakes. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be in the interval ``[0.0001, 0.001]``. May still require tinkering based on image size. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. blur_sigma_limits : tuple of float, optional Controls allowed min and max values of `blur_sigma_fraction` after(!) multiplication with the image size. First value is the minimum, second value is the maximum. Values outside of that range will be clipped to be within that range. This prevents extreme values for very small or large 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. rg@Nrc stt|j| | | | d||_tj|ddd|_tj|ddd|_tj|ddd|_t|d|_ tj|d dd|_ tj|d dd|_ ||_ d |_ dS) Nrdensity_uniformity)rvr)r flake_size)-C6?rflake_size_uniformityanglespeedblur_sigma_fractionrj)rrrdensityrrrrrrrrblur_sigma_limitsgate_noise_size) r rrrrrrrrrrrrr!r#r$rRs0  zSnowflakesLayer.__init__c CrNrOrPrRr#r#r$r;orTzSnowflakesLayer._augment_batch_c CrUr<) rrrrrrrrrr=r#r#r$r>zrVzSnowflakesLayer.get_parameterscCs||jdks Jd|jf|jddvs Jd|jd|jf|d}|j|}|j|}|j|}|j|}|j|}|j\} } } t d|dd} t dt | | } t dt | | }| | ||j|d }tdd|j}||||j|d}tj|| | fd d }t | | |}t ||jd |jd}|||}|j||||d }|||| }||||S) Nz@Expected input image to be three-dimensional, got %d dimensions.r rrzLExpected to get image with a channel axis of size 1 or 3, got %d (shape: %s)rMbP?rrrlrm)rrr)ndimrdr&rrcrrrrr2r_ruint_generate_noiserrBetar_gaterrorpr_blur _motion_blur_postprocess_noise_blend)r r:rr(Zflake_size_sampleflake_size_uniformity_sampleZ angle_sample speed_sampleZblur_sigma_fraction_samplerhri nb_channelsZdownscale_factorZ height_downZ width_downnoise gate_noisesigmanoise_small_blurnoise_small_blur_rgbr#r#r$rQsb         zSnowflakesLayer.draw_on_imagecCs(tj||d}|tj||ftjdS)N)pr)r0)rZSalt augment_imager2ZzerosrW)rqrhrirrrr#r#r$rszSnowflakesLayer._generate_noisecCsV|||}tj||jdddd}t|dd}t|tj|ddtjS)Nrr rlrmrvrr) r'rorprdr2r_r1rXrW)rqrrZ gate_sizerZ gate_noise_upr#r#r$rs zSnowflakesLayer._gatecCstj||dS)N)r)rZblur_gaussian_rqrrr#r#r$rszSnowflakesLayer._blurcCsLt|jdd}t||}|dkr|Stjt|d|d|d}||S)Nrr rrr)kr directionr)rurdrrZ MotionBlurr)rqrrrrsizerZblurerr#r#r$rs  zSnowflakesLayer._motion_blurcCs`ddd|}ddd|}t||}|tj|}t|dtjfdd|f}|S)Nrr r.)r Z GammaContrastrr1r2rXtiler])rqrrrZgainZgain_adjrr#r#r$rs z"SnowflakesLayer._postprocess_noisecCs@|tj}||dd||}||dd||}|S)Ng?r)r1r2rX _blend_by_sum _blend_by_max)rqr:rr image_f32r#r#r$rs zSnowflakesLayer._blendcCs||}t|ddtjSNrr)r2r_r1rWrqrrr#r#r$rszSnowflakesLayer._blend_by_sumcCs"t||}t|ddtjSr)r2maximumr_r1rWrr#r#r$rs zSnowflakesLayer._blend_by_maxrNNrr)r?r@rArBrr;r>rQrxrrrrrrrrrCr#r#r!r$rs4)  5       rcs,eZdZdZ     d fd d ZZS) SnowflakesaAdd falling snowflakes to images. This is a wrapper around :class:`~imgaug.augmenters.weather.SnowflakesLayer`. It executes 1 to 3 layers per image. **Supported dtypes**: * ``uint8``: yes; 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) Parameters of this augmenter are optimized for the value range of ``uint8``. While other dtypes may be accepted, they will lead to images augmented in ways inappropriate for the respective dtype. Parameters ---------- density : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Density of the snowflake layer, as a probability of each pixel in low resolution space to be a snowflake. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be in the interval ``[0.01, 0.075]``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. density_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Size uniformity of the snowflakes. Higher values denote more similarly sized snowflakes. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be around ``0.5``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. flake_size : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Size of the snowflakes. This parameter controls the resolution at which snowflakes are sampled. Higher values mean that the resolution is closer to the input image's resolution and hence each sampled snowflake will be smaller (because of the smaller pixel size). Valid values are in the interval ``(0.0, 1.0]``. Recommended values: * On ``96x128`` a value of ``(0.1, 0.4)`` worked well. * On ``192x256`` a value of ``(0.2, 0.7)`` worked well. * On ``960x1280`` a value of ``(0.7, 0.95)`` worked well. Datatype behaviour: * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. flake_size_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Controls the size uniformity of the snowflakes. Higher values mean that the snowflakes are more similarly sized. Valid values are in the interval ``[0.0, 1.0]``. Recommended to be around ``0.5``. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. angle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Angle in degrees of motion blur applied to the snowflakes, where ``0.0`` is motion blur that points straight upwards. Recommended to be in the interval ``[-30, 30]``. See also :func:`~imgaug.augmenters.blur.MotionBlur.__init__`. * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. speed : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Perceived falling speed of the snowflakes. This parameter controls the motion blur's kernel size. It follows roughly the form ``kernel_size = image_size * speed``. Hence, values around ``1.0`` denote that the motion blur should "stretch" each snowflake over the whole image. Valid values are in the interval ``[0.0, 1.0]``. Recommended values: * On ``96x128`` a value of ``(0.01, 0.05)`` worked well. * On ``192x256`` a value of ``(0.007, 0.03)`` worked well. * On ``960x1280`` a value of ``(0.001, 0.03)`` worked well. Datatype behaviour: * If a ``number``, then that value will always be used. * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. * If a ``list``, then a random value will be sampled from that ``list`` per image. * If a ``StochasticParameter``, then a value will be sampled per image from that parameter. seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. name : None or str, optional See :func:`~imgaug.augmenters.meta.Augmenter.__init__`. random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional Old name for parameter `seed`. Its usage will not yet cause a deprecation warning, but it is still recommended to use `seed` now. Outdated since 0.4.0. deterministic : bool, optional Deprecated since 0.4.0. See method ``to_deterministic()`` for an alternative and for details about what the "deterministic mode" actually does. Examples -------- >>> import imgaug.augmenters as iaa >>> aug = iaa.Snowflakes(flake_size=(0.1, 0.4), speed=(0.01, 0.05)) Add snowflakes to small images (around ``96x128``). >>> aug = iaa.Snowflakes(flake_size=(0.2, 0.7), speed=(0.007, 0.03)) Add snowflakes to medium-sized images (around ``192x256``). >>> aug = iaa.Snowflakes(flake_size=(0.7, 0.95), speed=(0.001, 0.03)) Add snowflakes to large images (around ``960x1280``). g{Gzt?g333333?rr皙?rrrigy&1|?Q?Nrc sPt||||||d|| | d tt|jdfddtdDd||| | ddS) N)rr) rrrrrrrrrrrcg|]}qSr#deepcopy.0_layerr#r$ z'Snowflakes.__init__..rFr)rrrrrange) r rrrrrrrrrrr!rr$r&  zSnowflakes.__init__) rrrrrrNNrrrr#r#r!r$rs'rcsLeZdZdZ   d fdd ZeddZed d Zed d ZZ S) RainLayera Add a single layer of falling raindrops to images. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; indirectly tested (1) * ``uint16``: no * ``uint32``: no * ``uint64``: no * ``int8``: no * ``int16``: no * ``int32``: no * ``int64``: no * ``float16``: no * ``float32``: no * ``float64``: no * ``float128``: no * ``bool``: no - (1) indirectly tested via tests for :class:`Rain` Parameters ---------- density : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. density_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. drop_size : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as `flake_size` in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. drop_size_uniformity : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as `flake_size_uniformity` in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. angle : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. speed : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. blur_sigma_fraction : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Same as in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. blur_sigma_limits : tuple of float, optional Same as in :class:`~imgaug.augmenters.weather.SnowflakesLayer`. 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. rNrc s,tt|j||||||||| | | | d dS)N)rrrrr)rrr) r rr drop_sizedrop_size_uniformityrrrrrrrrr!r#r$rs  zRainLayer.__init__cCs|SrOr#rr#r#r$rszRainLayer._blurcCs t|dtjfdd|f}|S)N.r)r2rr])rqrrrrr#r#r$r"szRainLayer._postprocess_noisecCst|jdd}|dkr|nd}dd|}|d}td|dd}|tj}d||||}t|dd tjS) Nrirngo@g?rr)r2sumZflatr_r1rXrW)rqr:rrZ noise_sumZdrop_mean_colorrr#r#r$r*s   zRainLayer._blendr) r?r@rArBrrxrrrrCr#r#r!r$rsH  rcs,eZdZdZ     d fdd ZZS) Raina Add falling snowflakes to images. This is a wrapper around :class:`~imgaug.augmenters.weather.RainLayer`. It executes 1 to 3 layers per image. .. note:: This augmenter currently seems to work best for medium-sized images around ``192x256``. For smaller images, you may want to increase the `speed` value to e.g. ``(0.1, 0.3)``, otherwise the drops tend to look like snowflakes. For larger images, you may want to increase the `drop_size` to e.g. ``(0.10, 0.20)``. Added in 0.4.0. **Supported dtypes**: * ``uint8``: yes; 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) Parameters of this augmenter are optimized for the value range of ``uint8``. While other dtypes may be accepted, they will lead to images augmented in ways inappropriate for the respective dtype. Parameters ---------- drop_size : number or tuple of number or list of number or imgaug.parameters.StochasticParameter See :class:`~imgaug.augmenters.weather.RainLayer`. speed : number or tuple of number or list of number or imgaug.parameters.StochasticParameter See :class:`~imgaug.augmenters.weather.RainLayer`. 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.Rain(speed=(0.1, 0.3)) Add rain to small images (around ``96x128``). >>> aug = iaa.Rain() Add rain to medium sized images (around ``192x256``). >>> aug = iaa.Rain(drop_size=(0.10, 0.20)) Add rain to large images (around ``960x1280``). rg{Gz?g{Gz?g{Gz?rNrc sPtdd|dd|d|||d tt|j|fddtd Dd ||||d dS) N)rgQ?r)rr)i)rr) rrrrrrrrrrcrr#rrrr#r$rrz!Rain.__init__..rFr)rrrrr)r Z nb_iterationsrrrrrrr!rr$rrz Rain.__init__)rrrNNrrrr#r#r!r$r>sPr)rB __future__rrrnumpyr2Zimgaugrorrrr r r/r rr r4Z AugmenterrrDZSomeOfrzrrrrrr#r#r#r$s*  ,1hO_Bu