o &j@sdZddlmZmZmZddlZddlmZddl m Z m Z ddl Z ddl ZddlZddlmZddlZddlZddlZddlmZddlmZdd lmZdd lmZd d Z  deddZ dfddZ!dgddZ"  dhddZ#  diddZ$ddZ%ddZ&   djdd Z'   djd!d"Z(e)e 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/Gd-d.d.e+Z0Gd/d0d0e+Z1Gd1d2d2e+Z2Gd3d4d4e+Z3Gd5d6d6e+Z4Gd7d8d8e+Z5Gd9d:d:e+Z6Gd;d<dd>e+Z8Gd?d@d@e+Z9GdAdBdBe+Z:GdCdDdDe+Z;GdEdFdFe+ZGdKdLdLe+Z?GdMdNdNe+Z@GdOdPdPe+ZAGdQdRdRe+ZBGdSdTdTe+ZCdkdWdXZDdkdYdZZEGd[d\d\e+ZFGd]d^d^e+ZGGd_d`d`e+ZHGdadbdbe+ZIdcddZJdS)lzClasses and methods to use for parameters of augmenters. This module contains e.g. classes representing probability distributions (guassian, poisson etc.), classes representing noise sources and methods to normalize parameter-related user inputs. )print_functiondivisionabsolute_importN) defaultdict)ABCMetaabstractmethod)imgaug)dtypes)random) OpenSimplexcCs|durdSt|trvt|dksJdt|f|ddur(|ddur(dS|ddur@||dks>Jd||dfdS|ddurX|d|ksVJd||dfdS|d|krf|dkstnJd||d|dfdSt|r||dStd t|f) NTzGIf 'value_range' is a tuple, it must contain exactly 2 entries, got %d.rrzAParameter '%s' is outside of the expected value range (x <= %.4f)zAParameter '%s' is outside of the expected value range (%.4f <= x)zIParameter '%s' is outside of the expected value range (%.4f <= x <= %.4f)z)Unexpected input for value_range, got %s.) isinstancetupleleniaZ is_callable Exceptionstr)valuename value_rangerR/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/imgaug/parameters.py_check_value_rangesJ       rTcCsJt|rt|||t|S|rUt|trUt|dks&Jd|t|ftdd|DsNz+handle_continuous_param..zHExpected parameter '%s' with type tuple to only contain numbers, got %s.cSg|]}t|qSrtyperrrrr!PrrcSrrrrrrrr!Wr"AExpected iterable parameter '%s' to only contain numbers, got %s.cSr#rr$rrrrr!Yr&number , list of %sEExpected %s, tuple of two %s%s or StochasticParameter for %s, got %s.)rrr DeterministicrrrallUniform is_iterableChoiceStochasticParameterrr%)paramrrtuple_to_uniformlist_to_choiceparam_i allowed_typelist_strrrrhandle_continuous_paramDsL    r8c st|s rt|rt|||tt|S|rkt|trkt|dks/Jd|t|ft fdd|D}|sNJd|rCdnddd|Dft|d ||t|d ||t t|d t|d S|rt |rt|tst fd d|D}|sJd |rdndd d|Df|D]}t|||qt dd|DSt|t r|Srdnd}|rd|fnd} td||| |t|f)Nr rc$g|]}r t|nt|qSrrris_single_integerr allow_floatsrrr!t  z)handle_discrete_param..zAExpected parameter '%s' of type tuple to only contain %s, got %s.r(integercSr#rr$rrrrr!}r&rrcr9rr:rr<rrr!r>.zQExpected list provided for parameter '%s' to only contain strings, got types: %s.cSsg|]}t|jqSr)r%__name__rrrrr!r"csg|]}|vqSrrrK valid_valuesrrr!r&zmExpected list provided for parameter '%s' to only contain the following allowed strings: %s. Got strings: %s.z[Expected parameter '%s' to be%s a string, a list of strings or StochasticParameter, got %s.z imgaug.ALL,r*) rALLr0listrJjoinr,rr-r1rr%rM)r2rrOrrNrhandle_categorical_string_paramsF     rSrNcst|s rt|rt|||tt|dfSt|trt|dks/Jd|t|ft dd|DsCrbt dd|Drbt|d||t|d||t t|dt|ddfSt dd|Drs|d|dfSt |dd |f|d t |dd |f|d f}|St |rt|tst fd d|D}|sJd |rdnddd|Df|D]}t|||qt dd|DdfSt|tr|dfStdt|f)Nr rcSrrrr;rCrrrr!r"z5handle_discrete_kernel_size_param..cSrr)rrDrCrrrr!rrcSg|]}t|tqSrrr1rCrrrr!rVz%s[0]r<z%s[1]cr9rr:rr<rrr!r>r@r(r?cSr#rr$rrrrr!r&cSr#rrArCrrrr!r&zGExpected int, tuple/list with 2 entries or StochasticParameter. Got %s.)rr;rDrr,rBrrrr-rErGr/r0r1rr%)r2rrr=ZhandledrFr5rr<r!handle_discrete_kernel_size_paramsv         rYFcCsd}|dvr tt|St|rSd|krdks$nJd||fd||kr2d|ksFnd||krAd|krOnt|Sttt|St|S|rt|trt dd|DspJd|d d|Dft |d ksJd |t |fd |d krdkrnn d |d krdksnJd||d |d ftt |d |d S|rt |rt dd|DsJd|dd|Dft dd|DsJd|d dd|Dftt|St|tr|Std|t|f)Ngư>)TFrr?zRExpected probability of parameter '%s' to be in the interval [0.0, 1.0], got %.4f.cSrrrrrrrr! r"z,handle_probability_param..zFExpected parameter '%s' of type tuple to only contain numbers, got %s.cSr#rr$rrrrr!r&r zKExpected parameter '%s' of type tuple to contain exactly 2 entries, got %d.rrzxExpected parameter '%s' of type tuple to contain two probabilities in the interval [0.0, 1.0]. Got values %.4f and %.4f.cSrrrrrrrr!r"r'cSr#rr$rrrrr!r&cS$g|]}d|ko dknqS)rr[rrZp_irrrr!$ziExpected iterable parameter '%s' to only contain probabilities in the interval [0.0, 1.0], got values %s.rHcSg|]}d|fqSz%.4frr]rrrr!r"zAExpected boolean or number or StochasticParameter for %s, got %s.)r,rBrrnproundBinomialrrr-rr.r/rRr0r1rr%)r2rr3r4epsrrrhandle_probability_paramsd  < 8   recCs|jjdkr|S|tjS)Nf)dtypekindastyperafloat64)rLrrrforce_np_float_dtype*s  rkcCsl|jjtjv}|jjtjv}|r|r||fS|r ||tjfS|r*|tj|fS|tj|tjfSN)rgr%rZNP_FLOAT_TYPESrirarj)abZa_fZb_frrrboth_np_float_if_one_is_float0sro^rqc Cs|dur dgt|}n |durdgt|}|dur'ddt|||D}n ddt||D}tj||d}tj|||d}|S)NFcSs g|] \}}}|j||dqS))sizetitledraw_distribution_graph)rr5Zsize_ititle_irrrr!Fs z+draw_distributions_grid..cSsg|] \}}|j|dqS)rsrt)rr5rvrrrr!Js )sizes)rowscols)rziprimresize_many_imagesZ draw_grid) paramsryrz graph_sizes sample_sizestitlesZimagesZ images_rsgridrrrdraw_distributions_grid=s rc Cstt||||||ddS)N)r~rryrzr)rZimshowr)r}ryrzr~rrrrrshow_distributions_gridSsrc@seZdZdZddZd/ddZd/ddZed d Zd d Z d dZ ddZ d/ddZ ddZ ddZddZddZddZddZd/dd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd0d-d.ZdS)1r1aAbstract parent class for all stochastic parameters. Stochastic parameters are here all parameters from which values are supposed to be sampled. Usually the sampled values are to a degree random. E.g. a stochastic parameter may be the uniform distribution over the interval ``[-10, 10]``. Samples from that distribution (and therefore the stochastic parameter) could be ``5.2``, ``-3.7``, ``-9.7``, ``6.4``, etc. cCsdSrlrselfrrr__init__nszStochasticParameter.__init__NcCs|jd|ddS)as Draws a single sample value from this parameter. Parameters ---------- 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 A seed or random number generator to use during the sampling process. If ``None``, the global RNG will be used. See also :func:`~imgaug.augmenters.meta.Augmenter.__init__` for a similar parameter with more details. Returns ------- any A single sample value. r random_stater) draw_samples)rrrrr draw_sampleqszStochasticParameter.draw_samplecCs6t|}|t|s|nt|g|}||S)aODraw one or more samples from the parameter. Parameters ---------- size : tuple of int or int Number of samples by dimension. 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 A seed or random number generator to use during the sampling process. If ``None``, the global RNG will be used. See also :func:`~imgaug.augmenters.meta.Augmenter.__init__` for a similar parameter with more details. Returns ------- ndarray Sampled values. Usually a numpy ndarray of basically any dtype, though not strictly limited to numpy arrays. Its shape is expected to match `size`. )iarandomZRNG _draw_samplesrr;rZadvance_rrrrsamplesrrrrs z StochasticParameter.draw_samplescCstrl)NotImplementedError)rrrrrrrrsz!StochasticParameter._draw_samplescC0t|s t|trt||Stdt|f)NzmInvalid datatypes in: StochasticParameter + %s. Expected second argument to be number or StochasticParameter.rrrr1Addrr%rotherrrr__add__ zStochasticParameter.__add__cCr)NzmInvalid datatypes in: StochasticParameter - %s. Expected second argument to be number or StochasticParameter.rrrr1Subtractrr%rrrr__sub__rzStochasticParameter.__sub__cCr)NzmInvalid datatypes in: StochasticParameter * %s. Expected second argument to be number or StochasticParameter.rrrr1Multiplyrr%rrrr__mul__rzStochasticParameter.__mul__cCs@|durtdt|st|trt||Stdt|f)N?Modulo power is currently not supported by StochasticParameter.znInvalid datatypes in: StochasticParameter ** %s. Expected second argument to be number or StochasticParameter.rrrrr1Powerrr%rrzrrr__pow__ zStochasticParameter.__pow__cCr)NzmInvalid datatypes in: StochasticParameter / %s. Expected second argument to be number or StochasticParameter.rrrr1Dividerr%rrrr__div__rzStochasticParameter.__div__cCr)NzwInvalid datatypes in: StochasticParameter / %s (truediv). Expected second argument to be number or StochasticParameter.rrrrr __truediv__rzStochasticParameter.__truediv__cCs4t|s t|trtt||Stdt|f)NzyInvalid datatypes in: StochasticParameter // %s (floordiv). Expected second argument to be number or StochasticParameter.rrrr1 Discretizerrr%rrrr __floordiv__z StochasticParameter.__floordiv__cC0t|s t|trt||Stdt|f)NzmInvalid datatypes in: %s + StochasticParameter. Expected second argument to be number or StochasticParameter.rrrrr__radd__rzStochasticParameter.__radd__cCr)NzmInvalid datatypes in: %s - StochasticParameter. Expected second argument to be number or StochasticParameter.rrrrr__rsub__rzStochasticParameter.__rsub__cCr)NzmInvalid datatypes in: %s * StochasticParameter. Expected second argument to be number or StochasticParameter.rrrrr__rmul__rzStochasticParameter.__rmul__cCs@|durtdt|st|trt||Stdt|f)NrznInvalid datatypes in: %s ** StochasticParameter. Expected second argument to be number or StochasticParameter.rrrrr__rpow__rzStochasticParameter.__rpow__cCr)NzmInvalid datatypes in: %s / StochasticParameter. Expected second argument to be number or StochasticParameter.rrrrr__rdiv__rzStochasticParameter.__rdiv__cCr)NzxInvalid datatypes in: %s / StochasticParameter (rtruediv). Expected second argument to be number or StochasticParameter.rrrrr __rtruediv__rz StochasticParameter.__rtruediv__cCs4t|s t|trtt||Stdt|f)NzzInvalid datatypes in: StochasticParameter // %s (rfloordiv). Expected second argument to be number or StochasticParameter.rrrrr __rfloordiv__rz!StochasticParameter.__rfloordiv__cC t|S)zCreate a shallow copy of this parameter. Returns ------- imgaug.parameters.StochasticParameter Shallow copy. ) copy_modulecopyrrrrr zStochasticParameter.copycCr)zCreate a deep copy of this parameter. Returns ------- imgaug.parameters.StochasticParameter Deep copy. )rdeepcopyrrrrr)rzStochasticParameter.deepcopyrdc s`ddlm}g}t|dD]}|||ddqt|}| }| d| }tj ||d\} }| t | } |j|dd| t|t|t|ddd durat|d ur}fd d tdtd D} |d| |jddtjdd} || jt| dddf} Wdn1swY|| S)aGenerate an image visualizing the parameter's sample distribution. Parameters ---------- title : None or False or str, optional Title of the plot. ``None`` is automatically replaced by a title derived from ``str(param)``. If set to ``False``, no title will be shown. size : tuple of int Number of points to sample. This is always expected to have at least two values. The first defines the number of sampling runs, the second (and further) dimensions define the size assigned to each :func:`~imgaug.parameters.StochasticParameter.draw_samples` call. E.g. ``(10, 20, 15)`` will lead to ``10`` calls of ``draw_samples(size=(20, 15))``. The results will be merged to a single 1d array. bins : int Number of bins in the plot histograms. Returns ------- data : (H,W,3) ndarray Image of the plot. rNro)binsblueg?)widthcoloralphaFcsg|] }||dqS)2r)rirwrrr!gsz?StochasticParameter.draw_distribution_graph..r )padz.png)suffix.)Zmatplotlib.pyplotZpyplotsmxrangeappendrflattenraZ concatenateZfigureZ add_subplotZgcaZ histogramsumbarmaxminrr set_titlerRZ tight_layouttempfileNamedTemporaryFileZsavefigrimageioZimreadclose) rrsrrrZpltZpoints_ZfigaxZheightsZtitle_fragmentsrfdatarrwrru4s:       z+StochasticParameter.draw_distribution_graphrl)Nrr)rM __module__ __qualname____doc__rrrrrrrrrrrrrrrrrrrrrrurrrrr1bs0         r1c8eZdZdZfddZddZddZdd ZZS) r,aParameter that is a constant value. If ``N`` values are sampled from this parameter, it will return ``N`` times ``V``, where ``V`` is the constant value. Parameters ---------- value : number or str or imgaug.parameters.StochasticParameter A constant value to use. A string may be provided to generate arrays of strings. If this is a StochasticParameter, a single value will be sampled from it exactly once and then used as the constant value. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Deterministic(10) >>> param.draw_sample() 10 Will always sample the value 10. csVtt|t|tr||_dSt|st |r"||_dSt dt |f)Nz@Expected StochasticParameter object or number or string, got %s.) superr,rrr1rrrrrJrr%)rr __class__rrrs  zDeterministic.__init__cCsHi}t|jrdtji}n t|jrdtji}tj||jfi|S)Nrg)rr;rraint32rDfloat32full)rrrrkwargsrrrrs     zDeterministic._draw_samplescC|Srl__str__rrrr__repr__zDeterministic.__repr__cCs@t|jr d|jfSt|jrd|jfSdt|jfS)NzDeterministic(int %d)zDeterministic(float %.8f)zDeterministic(%s))rr;rrDrrrrrrs    zDeterministic.__str__ rMrrrrrrr __classcell__rrrrr,ws   r,cr) DeterministicListajParameter that repeats elements from a list in the given order. E.g. of samples of shape ``(A, B, C)`` are requested, this parameter will return the first ``A*B*C`` elements, reshaped to ``(A, B, C)`` from the provided list. If the list contains less than ``A*B*C`` elements, it will (by default) be tiled until it is long enough (i.e. the sampling will start again at the first element, if necessary multiple times). Added in 0.4.0. Parameters ---------- values : ndarray or iterable of number An iterable of values to sample from in the order within the iterable. cstt|t|sJdt|jft|dks Jdt|r,| |_ dSt t t ||_ |j jj}|dkrJ|j t j|_ dS|dkrX|j t j|_ dSdS)Nz2Expected to get an iterable as input, got type %s.rz-Expected to get at least one value, got zero.rrf)rrrrr/r%rMrZ is_np_arrayrvaluesraarrayrQrgrhrirr)rrrhrrrrs    zDeterministicList.__init__cCsTtt|}|j}||jjkr!tt||j}t||f}|d||Srl)rBraprodrrrceiltilereshape)rrrrZ nb_requestedrZ multiplierrrrrs  zDeterministicList._draw_samplescCrrlrrrrrrrzDeterministicList.__repr__cCsB|jjjdkrdd|jD}dd|fSdt|jfS)NrfcSr_r`r)rrrrrr!r"z-DeterministicList.__str__..zDeterministicList([%s])rHzDeterministicList(%s))rrgrhrRrtolist)rrrrrrszDeterministicList.__str__rrrrrrs   rcs:eZdZdZd fdd ZddZdd Zd d ZZS) r0a7Parameter that samples value from a list of allowed values. Parameters ---------- a : iterable List of allowed values. Usually expected to be ``int`` s, ``float`` s or ``str`` s. May also contain ``StochasticParameter`` s. Each ``StochasticParameter`` that is randomly picked will automatically be replaced by a sample of itself (or by ``N`` samples if the parameter was picked ``N`` times). replace : bool, optional Whether to perform sampling with or without replacing. p : None or iterable of number, optional Probabilities of each element in `a`. Must have the same length as `a` (if provided). Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Choice([5, 17, 25], p=[0.25, 0.5, 0.25]) >>> sample = param.draw_sample() >>> assert sample in [5, 17, 25] Create and sample from a parameter, which will produce with ``50%`` probability the sample ``17`` and in the other ``50%`` of all cases the sample ``5`` or ``25``.. TNcstt|t|sJdt|f||_||_|durAt|s-Jdt|ft|t|ksAJdt|t|f||_ dS)Nz1Expected a to be an iterable (e.g. list), got %s.z-Expected p to be None or an iterable, got %s.z;Expected lengths of a and p to be identical, got %d and %d.) rr0rrr/r%rmreplacerp)rrmrrrrrrs      zChoice.__init__cCstdd|jDr|dt|j}|dj|jt||j|jd}t dd}|D]}t |t r@t |}||d7<q-t }t|jD]\} } t | }||vre| j||f|d| d||<qIt d d} t|D]!\} }t |t rt |}| |} ||| || <| |d7<qp||}n |j|j||j|jd}|j} | jd d kr| j}|d kr|tj}|S|d kr|tj}|S|dkr|tj}|S)NcSrWrrX)rZa_irrrr!"r"z(Choice._draw_samples..rr)rrcSdSNrrrrrr)z&Choice._draw_samples..rrrcSrrrrrrrr@r rurf)anyrm duplicaterchoicerarrrrrr1rdict enumeraterrrgitemsizerhrirZuint32r)rrrrrngsrZparams_countersamplekeyZparam_to_samplesrr2Zparam_to_readcountZ readcountrgrhrrrr!sX          zChoice._draw_samplescCrrlrrrrrrZrzChoice.__repr__cC dt|jt|jt|jfS)NzChoice(a=%s, replace=%s, p=%s))rrmrrrrrrr]szChoice.__str__)TNrrrrrr0s 9r0cr) rcamBinomial distribution. Parameters ---------- p : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Probability of the binomial distribution. Expected to be in the interval ``[0.0, 1.0]``. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Binomial.draw_sample` or :func:`Binomial.draw_samples`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Binomial(Uniform(0.01, 0.2)) Create a binomial distribution that uses a varying probability between ``0.01`` and ``0.2``, randomly and uniformly estimated once per sampling call. ctt|t|d|_dS)Nr)rrcrr8r)rrrrrrszBinomial.__init__cCsH|jj|d}d|krdksnJd|f|d||tjS)Nrrr[zBExpected probability p to be in the interval [0.0, 1.0], got %.4f.r)rrbinomialrirar)rrrrrrrrrszBinomial._draw_samplescCrrlrrrrrrrzBinomial.__repr__cC d|jfS)Nz Binomial(%s))rrrrrr zBinomial.__str__rrrrrrcbs  rccr) rEatUniform distribution over the discrete interval ``[a..b]``. Parameters ---------- a : int or tuple of int or list of int or imgaug.parameters.StochasticParameter Lower bound of the interval. If ``a>b``, `a` and `b` will automatically be flipped. If ``a==b``, all generated values will be identical to `a`. * If a single ``int``, this ``int`` will be used as a constant value. * If a ``tuple`` of two ``int`` s ``(a, b)``, the value will be sampled from the discrete interval ``[a..b]`` once per call. * If a ``list`` of ``int``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`DiscreteUniform.draw_sample` or :func:`DiscreteUniform.draw_samples`. b : int or imgaug.parameters.StochasticParameter Upper bound of the interval. Analogous to `a`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.DiscreteUniform(10, Choice([20, 30, 40])) >>> sample = param.draw_sample() >>> assert 10 <= sample <= 40 Create a discrete uniform distribution which's interval differs between calls and can be ``[10..20]``, ``[10..30]`` or ``[10..40]``. c*tt|t|d|_t|d|_dSNrmrn)rrErrGrmrnrrmrnrrrr zDiscreteUniform.__init__cCsb|jj|d}|jj|d}||kr||}}n ||kr%tj||tjdS|j||d|tjdS)Nrrgr)rmrrnrarrZintegersrrrrrmrnrrrrs zDiscreteUniform._draw_samplescCrrlrrrrrrrzDiscreteUniform.__repr__cCd|j|jfS)NzDiscreteUniform(%s, %s)rmrnrrrrrzDiscreteUniform.__str__rrrrrrEs  $ rEcr) PoissonaParameter that resembles a poisson distribution. A poisson distribution with ``lambda=0`` has its highest probability at point ``0`` and decreases quickly from there. Poisson distributions are discrete and never negative. Parameters ---------- lam : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Lambda parameter of the poisson distribution. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Poisson.draw_sample` or :func:`Poisson.draw_samples`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Poisson(1) >>> sample = param.draw_sample() >>> assert sample >= 0 Create a poisson distribution with ``lambda=1`` and sample a value from it. cr)Nlam)rrrr8r)rrrrrrszPoisson.__init__cCs.|jj|d}t|d}|j||dtjS)Nrr)rrr)rrrZpoissonrirar)rrrrrrrrrs zPoisson._draw_samplescCrrlrrrrrrrzPoisson.__repr__cCr )Nz Poisson(%s))rrrrrrr zPoisson.__str__rrrrrrs  #rcr) NormalaParameter that resembles a normal/gaussian distribution. Parameters ---------- loc : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The mean of the normal distribution. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Laplace.draw_sample` or :func:`Laplace.draw_samples`. scale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The standard deviation of the normal distribution. If this parameter reaches ``0``, the output array will be filled with `loc`. Datatype behaviour is the analogous to `loc`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Normal(Choice([-1.0, 1.0]), 1.0) Create a gaussian distribution with a mean that differs by call. Samples values may sometimes follow ``N(-1.0, 1.0)`` and sometimes ``N(1.0, 1.0)``. c.tt|t|d|_t|ddd|_dSNlocscalerNr)rrrr8rrrrrrrrr+   zNormal.__init__cCd|jj|d}|jj|d}|dksJd|f|dkr&tj||tjdS|j|||dtjS)Nrr#Expected scale to be >=0, got %.4f.rrr)rrrrarrnormalrirrrrrrrrrr2 zNormal._draw_samplescCrrlrrrrrr:rzNormal.__repr__cCr)NzNormal(loc=%s, scale=%s)rrrrrrr=rzNormal.__str__rrrrrrs  #rcsDeZdZdZej ejffdd ZddZddZdd Z Z S) TruncatedNormalaaParameter that resembles a truncated normal distribution. A truncated normal distribution is similar to a normal distribution, except the domain is smoothly bounded to a min and max value. This is a wrapper around :func:`scipy.stats.truncnorm`. Parameters ---------- loc : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The mean of the normal distribution. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`TruncatedNormal.draw_sample` or :func:`TruncatedNormal.draw_samples`. scale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The standard deviation of the normal distribution. If this parameter reaches ``0``, the output array will be filled with `loc`. Datatype behaviour is the same as for `loc`. low : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The minimum value of the truncated normal distribution. Datatype behaviour is the same as for `loc`. high : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The maximum value of the truncated normal distribution. Datatype behaviour is the same as for `loc`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.TruncatedNormal(0, 5.0, low=-10, high=10) >>> samples = param.draw_samples(100, random_state=0) >>> assert np.all(samples >= -10) >>> assert np.all(samples <= 10) Create a truncated normal distribution with its minimum at ``-10.0`` and its maximum at ``10.0``. csFtt|t|d|_t|ddd|_t|d|_t|d|_dS)Nrrrrlowhigh)rr&rr8rrr'r()rrrr'r(rrrrvs  zTruncatedNormal.__init__c Cs|jj|d}|jj|d}|jj|d}|jj|d}|}||kr)||}}|dks4Jd|f|dkrAtj||tjdS|||}|||} t j j || ||d} | j ||d tjS)Nrrr )Z fill_valuerg)rmrnrrr)rrrr'r(generate_seed_rarrscipystatsZ truncnormZrvsri) rrrrrrr'r(seedrmrnZtnormrrrrs   zTruncatedNormal._draw_samplescCrrlrrrrrrrzTruncatedNormal.__repr__cCsd|j|j|j|jfS)Nz2TruncatedNormal(loc=%s, scale=%s, low=%s, high=%s))rrr'r(rrrrrszTruncatedNormal.__str__) rMrrrrainfrrrrrrrrrr&Bs 3 r&cr) LaplaceaParameter that resembles a (continuous) laplace distribution. This is a wrapper around numpy's :func:`numpy.random.laplace`. Parameters ---------- loc : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The position of the distribution peak, similar to the mean in normal distributions. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Laplace.draw_sample` or :func:`Laplace.draw_samples`. scale : number or tuple of number or list of number or imgaug.parameters.StochasticParameter The exponential decay factor, similar to the standard deviation in gaussian distributions. If this parameter reaches ``0``, the output array will be filled with `loc`. Datatype behaviour is the analogous to `loc`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Laplace(0, 1.0) Create a laplace distribution, which's peak is at ``0`` and decay is ``1.0``. crr)rr.rr8rrrrrrrrzLaplace.__init__cCr)Nrrz!Expected scale to be >=0, got %s.rr!)rrrrarrZlaplacerir#rrrrr$zLaplace._draw_samplescCrrlrrrrrrrzLaplace.__repr__cCr)NzLaplace(loc=%s, scale=%s)r%rrrrrrzLaplace.__str__rrrrrr.s  &r.cr) ChiSquarea9Parameter that resembles a (continuous) chi-square distribution. This is a wrapper around numpy's :func:`numpy.random.chisquare`. Parameters ---------- df : int or tuple of two int or list of int or imgaug.parameters.StochasticParameter Degrees of freedom. Expected value range is ``[1, inf)``. * If a single ``int``, this ``int`` will be used as a constant value. * If a ``tuple`` of two ``int`` s ``(a, b)``, the value will be sampled from the discrete interval ``[a..b]`` once per call. * If a ``list`` of ``int``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`ChiSquare.draw_sample` or :func:`ChiSquare.draw_samples`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.ChiSquare(df=2) Create a chi-square distribution with two degrees of freedom. c"tt|t|ddd|_dS)NdfrTr)rr/rrGr1)rr1rrrrzChiSquare.__init__cCs:|jj|d}|dksJd|f|j||dtjS)NrrzExpected df to be >=1, got %d.r!)r1rZ chisquarerirar)rrrrr1rrrrzChiSquare._draw_samplescCrrlrrrrrrrzChiSquare.__repr__cCr )NzChiSquare(df=%s))r1rrrrrr zChiSquare.__str__rrrrrr/s  r/cr) Weibulla! Parameter that resembles a (continuous) weibull distribution. This is a wrapper around numpy's :func:`numpy.random.weibull`. Parameters ---------- a : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Shape parameter of the distribution. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Weibull.draw_sample` or :func:`Weibull.draw_samples`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Weibull(a=0.5) Create a weibull distribution with shape 0.5. cr0)Nrm)-C6?Nr)rr4rr8rm)rrmrrrr)r2zWeibull.__init__cCs:|jj|d}|dksJd|f|j||dtjS)NrrzExpected a to be >0, got %.4f.r!)rmrZweibullrirar)rrrrrmrrrr/r3zWeibull._draw_samplescCrrlrrrrrr5rzWeibull.__repr__cCr )Nz Weibull(a=%s))rmrrrrr8r zWeibull.__str__rrrrrr4 s  r4cr) r.aIParameter that resembles a uniform distribution over ``[a, b)``. Parameters ---------- a : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Lower bound of the interval. If ``a>b``, `a` and `b` will automatically be flipped. If ``a==b``, all generated values will be identical to `a`. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Uniform.draw_sample` or :func:`Uniform.draw_samples`. b : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Upper bound of the interval. Analogous to `a`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Uniform(0, 10.0) >>> sample = param.draw_sample() >>> assert 0 <= sample < 10.0 Create and sample from a uniform distribution over ``[0, 10.0)``. cr r )rr.rr8rmrnr rrrrarzUniform.__init__cCs`|jj|d}|jj|d}||kr||}}n ||kr%tj||tjdS||||tjS)Nrr)rmrrnrarruniformrirrrrrhs zUniform._draw_samplescCrrlrrrrrrrrzUniform.__repr__cCr)NzUniform(%s, %s)rrrrrrurzUniform.__str__rrrrrr.=s  # r.c:eZdZdZd fdd ZddZddZd d ZZS) BetaaParameter that resembles a (continuous) beta distribution. Parameters ---------- alpha : number or tuple of number or list of number or imgaug.parameters.StochasticParameter alpha parameter of the beta distribution. Expected value range is ``(0, inf)``. Values below ``0`` are automatically clipped to ``0+epsilon``. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Beta.draw_sample` or :func:`Beta.draw_samples`. beta : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Beta parameter of the beta distribution. Analogous to `alpha`. epsilon : number Clipping parameter. If `alpha` or `beta` end up ``<=0``, they are clipped to ``0+epsilon``. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Beta(0.4, 0.6) Create a beta distribution with ``alpha=0.4`` and ``beta=0.6``. r5csLtt|t|d|_t|d|_t|s!Jdt|f||_ dS)Nrbetaz*Expected epsilon to a number, got type %s.) rr8rr8rr9rrr%epsilon)rrr9r:rrrrs     z Beta.__init__cCsL|jj|d}|jj|d}t||j}t||j}|j|||dtjS)Nrr!)rrr9rr:rirar)rrrrrr9rrrrs   zBeta._draw_samplescCrrlrrrrrrrz Beta.__repr__cCr)Nz Beta(%s, %s))rr9rrrrrrz Beta.__str__)r5rrrrrr8ys # r8cs>eZdZdZ  d fdd ZddZd d Zd d ZZS)FromLowerResolutiona}Parameter to sample from other parameters at lower image resolutions. This parameter is intended to be used with parameters that would usually sample one value per pixel (or one value per pixel and channel). Instead of sampling from the other parameter at full resolution, it samples at lower resolution, e.g. ``0.5*H x 0.5*W`` with ``H`` being the height and ``W`` being the width. After the low-resolution sampling this parameter then upscales the result to ``HxW``. This parameter is intended to produce coarse samples. E.g. combining this with :class:`Binomial` can lead to large rectangular areas of ``1`` s and ``0`` s. Parameters ---------- other_param : imgaug.parameters.StochasticParameter The other parameter which is to be sampled on a coarser image. size_percent : None or number or iterable of number or imgaug.parameters.StochasticParameter, optional Size of the 2d sampling plane in percent of the requested size. I.e. this is relative to the size provided in the call to ``draw_samples(size)``. Lower values will result in smaller sampling planes, which are then upsampled to `size`. This means that lower values will result in larger rectangles. The size may be provided as a constant value or a tuple ``(a, b)``, which will automatically be converted to the continuous uniform range ``[a, b)`` or a :class:`StochasticParameter`, which will be queried per call to :func:`FromLowerResolution.draw_sample` and :func:`FromLowerResolution.draw_samples`. size_px : None or number or iterable of numbers or imgaug.parameters.StochasticParameter, optional Size of the 2d sampling plane in pixels. Lower values will result in smaller sampling planes, which are then upsampled to the input `size` of ``draw_samples(size)``. This means that lower values will result in larger rectangles. The size may be provided as a constant value or a tuple ``(a, b)``, which will automatically be converted to the discrete uniform range ``[a..b]`` or a :class:`StochasticParameter`, which will be queried once per call to :func:`FromLowerResolution.draw_sample` and :func:`FromLowerResolution.draw_samples`. method : str or int or imgaug.parameters.StochasticParameter, optional Upsampling/interpolation method to use. This is used after the sampling is finished and the low resolution plane has to be upsampled to the requested `size` in ``draw_samples(size, ...)``. The method may be the same as in :func:`~imgaug.imgaug.imresize_many_images`. Usually ``nearest`` or ``linear`` are good choices. ``nearest`` will result in rectangles with sharp edges and ``linear`` in rectangles with blurry and round edges. The method may be provided as a :class:`StochasticParameter`, which will be queried once per call to :func:`FromLowerResolution.draw_sample` and :func:`FromLowerResolution.draw_samples`. min_size : int, optional Minimum size in pixels of the low resolution sampling plane. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.FromLowerResolution( >>> Binomial(0.05), >>> size_px=(2, 16), >>> method=Choice(["nearest", "linear"])) Samples from a binomial distribution with ``p=0.05``. The sampling plane will always have a size HxWxC with H and W being independently sampled from ``[2..16]`` (i.e. it may range from ``2x2xC`` up to ``16x16xC`` max, but may also be e.g. ``4x8xC``). The upsampling method will be ``nearest`` in ``50%`` of all cases and ``linear`` in the other 50 percent. The result will sometimes be rectangular patches of sharp ``1`` s surrounded by ``0`` s and sometimes blurry blobs of ``1``s, surrounded by values ``<1.0``. Nnearestrcstt||dus|dusJd|durYd|_d|_t|r(t||_nst |rGt |dksr@rrarrirr?rBrr{rrCrArgrhiadtZrestore_dtypes_rZuint16rr|zeros)rrrrnhwcZ hw_percentsZhw_pxsmethodsresultrZhw_pxrBh_smallw_smallrZsamples_upscaledrrrr7s^          z!FromLowerResolution._draw_samplescCrrlrrrrrrwrzFromLowerResolution.__repr__cCs:|jdkrd}||j|j|jfSd}||j|j|jfS)Nr=z?FromLowerResolution(size_percent=%s, method=%s, other_param=%s)z:FromLowerResolution(size_px=%s, method=%s, other_param=%s))r>r@rBrAr?)rpatternrrrrzs zFromLowerResolution.__str__)NNr<rrrrrrr;sJ7@r;cr7) ClipaClip another parameter to a defined value range. Parameters ---------- other_param : imgaug.parameters.StochasticParameter The other parameter, which's values are to be clipped. minval : None or number, optional The minimum value to use. If ``None``, no minimum will be used. maxval : None or number, optional The maximum value to use. If ``None``, no maximum will be used. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Clip(Normal(0, 1.0), minval=-2.0, maxval=2.0) Create a standard gaussian distribution, which's values never go below ``-2.0`` or above ``2.0``. Note that this will lead to small "bumps" of higher probability at ``-2.0`` and ``2.0``, as values below/above these will be clipped to them. For smoother limitations on gaussian distributions, see :class:`TruncatedNormal`. Ncsvtt|td||dust|sJdt|f|dus0t|s0Jdt|f||_||_||_ dS)NrAz6Expected 'minval' to be None or a number, got type %s.z6Expected 'maxval' to be None or a number, got type %s.) rrRr_assert_arg_is_stoch_paramrrr%rAminvalmaxval)rrArTrUrrrrs  z Clip.__init__cCs>|jj||d}|jdus|jdurtj||j|j|d}|S)Nr)out)rArrTrUracliprrrrrszClip._draw_samplescCrrlrrrrrrrz Clip.__repr__cCszt|j}|jdur|jdurd|t|jt|jfS|jdur*d|t|jfS|jdur8d|t|jfSd|fS)NzClip(%s, %.6f, %.6f)zClip(%s, %.6f, None)zClip(%s, None, %.6f)zClip(%s, None, None))rrArTrUfloatrZopstrrrrrs    z Clip.__str__)NNrrrrrrRs rRcr7) ra{Convert a continuous distribution to a discrete one. This will round the values and then cast them to integers. Values sampled from already discrete distributions are not changed. Parameters ---------- other_param : imgaug.parameters.StochasticParameter The other parameter, which's values are to be discretized. round : bool, optional Whether to round before converting to integer dtype. Added in 0.4.0. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Discretize(iap.Normal(0, 1.0)) Create a discrete standard gaussian distribution. Tcs(tt|td|||_||_dSNrA)rrrrSrArb)rrArbrrrrs  zDiscretize.__init__cCs|jj||d}|jjdvsJd|jj|jjf|jjdvr"|Sd|jjd}t|d}td|f}|jr?t|}| |S)Nr)rrrnrfzrExpected to get uint, int, bool or float dtype as samples in Discretize(), but got dtype '%s' (kind '%s') instead.)rrrnrr zint%d) rArrgrhrrrrarbri)rrrrrZbitsizergrrrrs     zDiscretize._draw_samplescCrrlrrrrrrrzDiscretize.__repr__cCst|j}d|t|jfS)NzDiscretize(%s, round=%s))rrArbrYrrrrs zDiscretize.__str__)Trrrrrrs rcr7) raMultiply the samples of another stochastic parameter. Parameters ---------- other_param : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be multiplied with `val`. Let ``S`` be the requested shape of samples, then the datatype behaviour is as follows: * If a single ``number``, this ``number`` will be used as a constant value to fill an array of shape ``S``. * If a ``tuple`` of two ``number`` s ``(a, b)``, an array of shape ``S`` will be filled with uniformly sampled values from the continuous interval ``[a, b)``. * If a ``list`` of ``number``, an array of shape ``S`` will be filled with randomly picked values from the ``list``. * If a :class:`StochasticParameter`, that parameter will be queried once per call to generate an array of shape ``S``. "per call" denotes a call of :func:`Multiply.draw_sample` or :func:`Multiply.draw_samples`. val : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Multiplier to use. Datatype behaviour is analogous to `other_param`, though if ``elementwise=False`` (the default), only a single sample will be generated per call instead of ``S``. elementwise : bool, optional Controls the sampling behaviour of `val`. If set to ``False``, a single samples will be requested from `val` and used as the constant multiplier. If set to ``True``, samples of shape ``S`` will be requested from `val` and multiplied elementwise with the samples of `other_param`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Multiply(iap.Uniform(0.0, 1.0), -1) Convert a uniform distribution from ``[0.0, 1.0)`` to ``(-1.0, 0.0]``. Fc0tt|t|d|_t|d|_||_dSNrArL)rrrr8rArL elementwiserrArLr]rrrr5   zMultiply.__init__cCsv|d}|jj||dd}|jot|jt }|r&|jj||dd}n |jj|dd}|r7t ||S||SNr rrr) rrArr]rrLr,rramultiplyrrrrrrr] val_samplesrrrr<s   zMultiply._draw_samplescCrrlrrrrrrMrzMultiply.__repr__cCdt|jt|j|jfS)NzMultiply(%s, %s, %s)rrArLr]rrrrrPzMultiply.__str__Frrrrrr s +rcr7) raDivide the samples of another stochastic parameter. This parameter will automatically prevent division by zero (uses 1.0) as the denominator in these cases. Parameters ---------- other_param : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be divided by `val`. Let ``S`` be the requested shape of samples, then the datatype behaviour is as follows: * If a single ``number``, this ``number`` will be used as a constant value to fill an array of shape ``S``. * If a ``tuple`` of two ``number`` s ``(a, b)``, an array of shape ``S`` will be filled with uniformly sampled values from the continuous interval ``[a, b)``. * If a ``list`` of ``number``, an array of shape ``S`` will be filled with randomly picked values from the ``list``. * If a :class:`StochasticParameter`, that parameter will be queried once per call to generate an array of shape ``S``. "per call" denotes a call of :func:`Divide.draw_sample` or :func:`Divide.draw_samples`. val : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Denominator to use. Datatype behaviour is analogous to `other_param`, though if ``elementwise=False`` (the default), only a single sample will be generated per call instead of ``S``. elementwise : bool, optional Controls the sampling behaviour of `val`. If set to ``False``, a single samples will be requested from `val` and used as the constant denominator. If set to ``True``, samples of shape ``S`` will be requested from `val` and used to divide the samples of `other_param` elementwise. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Divide(iap.Uniform(0.0, 1.0), 2) Convert a uniform distribution ``[0.0, 1.0)`` to ``[0, 0.5)``. Fcr[r\)rrrr8rArLr]r^rrrrr_zDivide.__init__cCs|d}|jj||dd}|jot|jt }|r5|jj||dd}d||dk<tt |t |S|jj |dd}|dkrDd}t |t |Sr`) rrArr]rrLr,radividerkrrX)rrrrrrr]rcZ val_samplerrrrs   zDivide._draw_samplescCrrlrrrrrrrzDivide.__repr__cCrd)NzDivide(%s, %s, %s)rerrrrrrfzDivide.__str__rgrrrrrrUs /rcr7) raAdd to the samples of another stochastic parameter. Parameters ---------- other_param : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Samples of `val` will be added to samples of this parameter. Let ``S`` be the requested shape of samples, then the datatype behaviour is as follows: * If a single ``number``, this ``number`` will be used as a constant value to fill an array of shape ``S``. * If a ``tuple`` of two ``number`` s ``(a, b)``, an array of shape ``S`` will be filled with uniformly sampled values from the continuous interval ``[a, b)``. * If a ``list`` of ``number``, an array of shape ``S`` will be filled with randomly picked values from the ``list``. * If a :class:`StochasticParameter`, that parameter will be queried once per call to generate an array of shape ``S``. "per call" denotes a call of :func:`Add.draw_sample` or :func:`Add.draw_samples`. val : number or tuple of two number or list of number or imgaug.parameters.StochasticParameter Value to add to the samples of `other_param`. Datatype behaviour is analogous to `other_param`, though if ``elementwise=False`` (the default), only a single sample will be generated per call instead of ``S``. elementwise : bool, optional Controls the sampling behaviour of `val`. If set to ``False``, a single samples will be requested from `val` and used as the constant multiplier. If set to ``True``, samples of shape ``S`` will be requested from `val` and added elementwise with the samples of `other_param`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Add(Uniform(0.0, 1.0), 1.0) Convert a uniform distribution from ``[0.0, 1.0)`` to ``[1.0, 2.0)``. Fcr[r\)rrrr8rArLr]r^rrrrr_z Add.__init__cCsv|d}|jj||dd}|jot|jt }|r&|jj||dd}n |jj|dd}|r7t ||S||Sr`) rrArr]rrLr,rraaddrbrrrrs  zAdd._draw_samplescCrrlrrrrrrrz Add.__repr__cCrd)NzAdd(%s, %s, %s)rerrrrrrfz Add.__str__rgrrrrrrs ,rcr7) raSubtract from the samples of another stochastic parameter. Parameters ---------- other_param : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Samples of `val` will be subtracted from samples of this parameter. Let ``S`` be the requested shape of samples, then the datatype behaviour is as follows: * If a single ``number``, this ``number`` will be used as a constant value to fill an array of shape ``S``. * If a ``tuple`` of two ``number`` s ``(a, b)``, an array of shape ``S`` will be filled with uniformly sampled values from the continuous interval ``[a, b)``. * If a ``list`` of ``number``, an array of shape ``S`` will be filled with randomly picked values from the ``list``. * If a :class:`StochasticParameter`, that parameter will be queried once per call to generate an array of shape ``S``. "per call" denotes a call of :func:`Subtract.draw_sample` or :func:`Subtract.draw_samples`. val : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Value to subtract from the other parameter. Datatype behaviour is analogous to `other_param`, though if ``elementwise=False`` (the default), only a single sample will be generated per call instead of ``S``. elementwise : bool, optional Controls the sampling behaviour of `val`. If set to ``False``, a single samples will be requested from `val` and used as the constant multiplier. If set to ``True``, samples of shape ``S`` will be requested from `val` and subtracted elementwise from the samples of `other_param`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Subtract(iap.Uniform(0.0, 1.0), 1.0) Convert a uniform distribution from ``[0.0, 1.0)`` to ``[-1.0, 0.0)``. Fcr[r\)rrrr8rArLr]r^rrrr,r_zSubtract.__init__cCsv|d}|jj||dd}|jot|jt }|r&|jj||dd}n |jj|dd}|r7t ||S||Sr`) rrArr]rrLr,rrasubtractrbrrrr3s   zSubtract._draw_samplescCrrlrrrrrrCrzSubtract.__repr__cCrd)NzSubtract(%s, %s, %s)rerrrrrFrfzSubtract.__str__rgrrrrrrs +rcr7) raExponentiate the samples of another stochastic parameter. Parameters ---------- other_param : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be exponentiated by `val`. Let ``S`` be the requested shape of samples, then the datatype behaviour is as follows: * If a single ``number``, this ``number`` will be used as a constant value to fill an array of shape ``S``. * If a ``tuple`` of two ``number`` s ``(a, b)``, an array of shape ``S`` will be filled with uniformly sampled values from the continuous interval ``[a, b)``. * If a ``list`` of ``number``, an array of shape ``S`` will be filled with randomly picked values from the ``list``. * If a :class:`StochasticParameter`, that parameter will be queried once per call to generate an array of shape ``S``. "per call" denotes a call of :func:`Power.draw_sample` or :func:`Power.draw_samples`. val : number or tuple of number or list of number or imgaug.parameters.StochasticParameter Value to use exponentiate the samples of `other_param`. Datatype behaviour is analogous to `other_param`, though if ``elementwise=False`` (the default), only a single sample will be generated per call instead of ``S``. elementwise : bool, optional Controls the sampling behaviour of `val`. If set to ``False``, a single samples will be requested from `val` and used as the constant multiplier. If set to ``True``, samples of shape ``S`` will be requested from `val` and used to exponentiate elementwise the samples of `other_param`. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Power(iap.Uniform(0.0, 1.0), 2) Converts a uniform range ``[0.0, 1.0)`` to a distribution that is peaked towards 1.0. Fcr[r\)rrrr8rArLr]r^rrrrxr_zPower.__init__c Cs|d}|jj||dd}|jot|jt }|r&|jj||dd}n |jj|dd}t||\}}|j }t | t j |j}|j |krN| |}|Sr`)rrArr]rrLr,rrorgrapowerricomplexreal) rrrrrrr]Z exponentsZ samples_dtyperNrrrrs    zPower._draw_samplescCrrlrrrrrrrzPower.__repr__cCrd)NzPower(%s, %s, %s)rerrrrrrfz Power.__str__rgrrrrrrKs ,rcr) AbsoluteaConvert the samples of another parameter to their absolute values. Parameters ---------- other_param : imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be modified. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Absolute(iap.Uniform(-1.0, 1.0)) Convert a uniform distribution from ``[-1.0, 1.0)`` to ``[0.0, 1.0]``. cs"tt|td|||_dSrZ)rrnrrSrA)rrArrrrs  zAbsolute.__init__cCs|jj||d}t|S)Nr)rArraabsoluterrrrrs zAbsolute._draw_samplescCrrlrrrrrrrzAbsolute.__repr__cCst|j}d|fS)Nz Absolute(%s))rrArYrrrrs  zAbsolute.__str__rrrrrrns  rncr7) RandomSigna,Convert a parameter's samples randomly to positive or negative values. Parameters ---------- other_param : imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be modified. p_positive : number Fraction of values that are supposed to be turned to positive values. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.RandomSign(iap.Poisson(1)) Create a poisson distribution with ``alpha=1`` that is mirrored/copied (not flipped) at the y-axis. ?csftt|td|t|sJdt|d|kr#dks+nJd|f||_||_dS)NrAz-Expected 'p_positive' to be a number, got %s.rZr[zAExpected 'p_positive' to be in the interval [0.0, 1.0], got %.4f.) rrprrSrrr%rA p_positive)rrArrrrrrs   zRandomSign.__init__cCs~|d}|jj||dd}|jjdvs!Jd|jj|jjf|djd|j|dt j }|dd}t ||}|S)Nr rr)rfrzJExpected to get samples of kind float or int, but got dtype %s of kind %s.rr!) rrArrgrhrrrrriraZint8ro)rrrrZrssrZ coinflipsZsignsrNrrrrs  zRandomSign._draw_samplescCrrlrrrrrrrzRandomSign.__repr__cCst|j}d||jfS)NzRandomSign(%s, %.2f))rrArrrYrrrr s zRandomSign.__str__)rqrrrrrrps rpcs>eZdZdZ  d fdd ZddZdd Zd d ZZS) ForceSignaConvert a parameter's samples to either positive or negative values. Parameters ---------- other_param : imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be modified. positive : bool Whether to force all signs to be positive (``True``) or negative (``False``). mode : {'invert', 'reroll'}, optional Method to change the signs. Valid values are ``invert`` and ``reroll``. ``invert`` means that wrong signs are simply flipped. ``reroll`` means that all samples with wrong signs are sampled again, optionally many times, until they randomly end up having the correct sign. reroll_count_max : int, optional If `mode` is set to ``reroll``, this determines how often values may be rerolled before giving up and simply flipping the sign (as in ``mode="invert"``). This shouldn't be set too high, as rerolling is expensive. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.ForceSign(iap.Poisson(1), positive=False) Create a poisson distribution with ``alpha=1`` that is flipped towards negative values. invertr cs~tt|td|||_|dvsJdt|f||_|dvs*Jd|f||_t |s:Jdt|||_ dS)NrA)TFz5Expected 'positive' to be True or False, got type %s.)rtZrerollz3Expected 'mode' to be "invert" or "reroll", got %s.z:Expected 'reroll_count_max' to be an integer, got type %s.) rrsrrSrAr%positivemoderr;reroll_count_max)rrArurvrwrrrr) s&     zForceSign.__init__cCs8|d|j}|jj||dd}|jdkr2|jr&||dkd9<|S||dkd9<|S|jr?t|dkd}n t|dkd}d}t|dkr||jkr|jj||d|d}||||<|d7}|jrxt|dkd}n t|dkd}t|dkr||jksUt|dkr||d9<|S)Nrrrrtr) rrwrArrvrurawherer)rrrrrrZ bad_samplesZ reroll_countZsamples_rerollrrrr> s4     zForceSign._draw_samplescCrrlrrrrrrf rzForceSign.__repr__cCs$t|j}d|t|j|j|jfS)NzForceSign(%s, %s, %s, %d))rrArurvrwrYrrrri  zForceSign.__str__rtr rrrrrrs s"(rsrtr cCt|d||dS)aConvert another parameter's results to positive values. Parameters ---------- other_param : imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be modified. mode : {'invert', 'reroll'}, optional How to change the signs. Valid values are ``invert`` and ``reroll``. ``invert`` means that wrong signs are simply flipped. ``reroll`` means that all samples with wrong signs are sampled again, optionally many times, until they randomly end up having the correct sign. reroll_count_max : int, optional If `mode` is set to ``reroll``, this determines how often values may be rerolled before giving up and simply flipping the sign (as in ``mode="invert"``). This shouldn't be set too high, as rerolling is expensive. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Positive(iap.Normal(0, 1), mode="reroll") Create a gaussian distribution that has only positive values. If any negative value is sampled in the process, that sample is resampled up to two times to get a positive one. If it isn't positive after the second resampling step, the sign is simply flipped. TrArurvrwrsrArvrwrrrPositiveo "rcCr{)aConvert another parameter's results to negative values. Parameters ---------- other_param : imgaug.parameters.StochasticParameter Other parameter which's sampled values are to be modified. mode : {'invert', 'reroll'}, optional How to change the signs. Valid values are ``invert`` and ``reroll``. ``invert`` means that wrong signs are simply flipped. ``reroll`` means that all samples with wrong signs are sampled again, optionally many times, until they randomly end up having the correct sign. reroll_count_max : int, optional If `mode` is set to ``reroll``, this determines how often values may be rerolled before giving up and simply flipping the sign (as in ``mode="invert"``). This shouldn't be set too high, as rerolling is expensive. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Negative(iap.Normal(0, 1), mode="reroll") Create a gaussian distribution that has only negative values. If any positive value is sampled in the process, that sample is resampled up to two times to get a negative one. If it isn't negative after the second resampling step, the sign is simply flipped. Fr|r}r~rrrNegative rrcsBeZdZdZdddgffdd ZddZd d Zd d ZZS) IterativeNoiseAggregatora Aggregate multiple iterations of samples from another parameter. This is supposed to be used in conjunction with :class:`SimplexNoise` or :class:`FrequencyNoise`. If a shape ``S`` is requested, it will request ``I`` times ``S`` samples from the underlying parameter, where ``I`` is the number of iterations. The ``I`` arrays will be combined to a single array of shape ``S`` using an aggregation method, e.g. simple averaging. Parameters ---------- other_param : StochasticParameter The other parameter from which to sample one or more times. iterations : int or iterable of int or list of int or imgaug.parameters.StochasticParameter, optional The number of iterations. * If a single ``int``, this ``int`` will be used as a constant value. * If a ``tuple`` of two ``int`` s ``(a, b)``, the value will be sampled from the discrete interval ``[a..b]`` once per call. * If a ``list`` of ``int``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`IterativeNoiseAggregator.draw_sample` or :func:`IterativeNoiseAggregator.draw_samples`. aggregation_method : imgaug.ALL or {'min', 'avg', 'max'} or list of str or imgaug.parameters.StochasticParameter, optional The method to use to aggregate the samples of multiple iterations to a single output array. All methods combine several arrays of shape ``S`` each to a single array of shape ``S`` and hence work elementwise. Known methods are ``min`` (take the minimum over all iterations), ``max`` (take the maximum) and ``avg`` (take the average). * If an ``str``, it must be one of the described methods and will be used for all calls.. * If a ``list`` of ``str``, it must contain one or more of the described methods and a random one will be samples once per call. * If ``imgaug.ALL``, then equivalent to the ``list`` ``["min", "max", "avg"]``. * If :class:`StochasticParameter`, a value will be sampled from that parameter once per call and must be one of the described methods.. "per call" denotes a call of :func:`IterativeNoiseAggregator.draw_sample` or :func:`IterativeNoiseAggregator.draw_samples`. Examples -------- >>> import imgaug.parameters as iap >>> noise = iap.IterativeNoiseAggregator( >>> iap.SimplexNoise(), >>> iterations=(2, 5), >>> aggregation_method="max") Create a parameter that -- upon each call -- generates ``2`` to ``5`` arrays of simplex noise with the same shape. Then it combines these noise maps to a single map using elementwise maximum. )rrravgcstt|td|||_dd}t|r#||gt||_nkt |t rAt |dks7Jdt |f||t ||_nMt |r|t |dksUJdt |ftdd |DsmJd d d d |Df||t|d|d |_nt |tr||_n tdt|f|tjkrt gd|_dSt|rt||_dSt |t rt |d ksJdt |ftdd |DsJdd dd |Dt ||_dSt |tr||_dStdt|f)NrAcSs4tdd|DsJdddd|DfdS)NcSr\ri'rrKrrrr! r^zTIterativeNoiseAggregator.__init__.._assert_within_bounds..zZExpected 'iterations' to only contain values within the interval [1, 1000], got values %s.rHcSr#r)rrKrrrr! r&)r-rR)Z _iterationsrrr_assert_within_bounds s z@IterativeNoiseAggregator.__init__.._assert_within_boundsrzIExpected 'iterations' of type list to contain at least one entry, got %d.r zNExpected iterable non-list 'iteratons' to contain exactly two entries, got %d.cSrrrUrKrrrr!! r"z5IterativeNoiseAggregator.__init__..zOExpected iterable non-list 'iterations' to only contain integers, got types %s.rHcSg|]}tt|qSrrr%rKrrrr!$ rzRExpected iterations to be int or tuple of two ints or StochasticParameter, got %s.)rrrz0Expected at least one aggregation method got %d.cSrrrIrKrrrr!6 r"z?Expected aggregation methods provided as strings, got types %s.cSrrrrrrrr!9 rz[Expected aggregation_method to be string or list of strings or StochasticParameter, got %s.)rrrrSrArr;r, iterationsrrQrr0r/r-rRrEr1rr%rPaggregation_methodrJ)rrArrrrrrr sx             z!IterativeNoiseAggregator.__init__c Cs|d}|jj|dd}|jj|dd}|dks"Jd|f|d|}tj|tjd}t|D]4}|j j |||d} |dkrK|| 7}q6|dkr]|dkrV| }q6t || }q6|dkrd| }q6t || }q6|dkrs||}|S) Nr rrrzAExpected to sample at least one iteration of aggregation. Got %d.rrr) rrrrrarHrrrrArminimummaximum) rrrrrrrZrngs_iterationsrNr noise_iterrrrrC s8   z&IterativeNoiseAggregator._draw_samplescCrrlrrrrrre rz!IterativeNoiseAggregator.__repr__cCs$t|j}d|t|jt|jfS)Nz$IterativeNoiseAggregator(%s, %s, %s))rrArrrYrrrrh ryz IterativeNoiseAggregator.__str__rrrrrr s@<"rcsLeZdZdZ  dfdd Zeddd Zd d Zd d ZddZ Z S)Sigmoida Apply a sigmoid function to the outputs of another parameter. This is intended to be used in combination with :class:`SimplexNoise` or :class:`FrequencyNoise`. It pushes the noise values away from ``~0.5`` and towards ``0.0`` or ``1.0``, making the noise maps more binary. Parameters ---------- other_param : imgaug.parameters.StochasticParameter The other parameter to which the sigmoid will be applied. threshold : number or tuple of number or iterable of number or imgaug.parameters.StochasticParameter, optional Sets the value of the sigmoid's saddle point, i.e. where values start to quickly shift from ``0.0`` to ``1.0``. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`Sigmoid.draw_sample` or :func:`Sigmoid.draw_samples`. activated : bool or number, optional Defines whether the sigmoid is activated. If this is ``False``, the results of `other_param` will not be altered. This may be set to a ``float`` ``p`` in value range``[0.0, 1.0]``, which will result in `activated` being ``True`` in ``p`` percent of all calls. mul : number, optional The results of `other_param` will be multiplied with this value before applying the sigmoid. For noise values (range ``[0.0, 1.0]``) this should be set to about ``20``. add : number, optional This value will be added to the results of `other_param` before applying the sigmoid. For noise values (range ``[0.0, 1.0]``) this should be set to about ``-10.0``, provided `mul` was set to ``20``. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.Sigmoid( >>> iap.SimplexNoise(), >>> activated=0.5, >>> mul=20, >>> add=-10) Applies a sigmoid to simplex noise in ``50%`` of all calls. The noise results are modified to match the sigmoid's expected value range. The sigmoid's outputs are in the range ``[0.0, 1.0]``.  Trrcstt|td|||_t|d|_t|d|_t |s)Jdt |f|dks4Jd|f||_ t |sEJdt |f||_ dS)NrA threshold activatedz+Expected 'mul' to be a number, got type %s.rz1Expected 'mul' to be greater than zero, got %.4f.z+Expected 'add' to be a number, got type %s.)rrrrSrAr8rrerrrr%mulri)rrArrrrirrrr s          zSigmoid.__init__cCst|||dddS)aCreate a Sigmoid adjusted for noise parameters. "noise" here denotes :class:`SimplexNoise` and :class:`FrequencyNoise`. Parameters ---------- other_param : imgaug.parameters.StochasticParameter See :func:`~imgaug.parameters.Sigmoid.__init__`. threshold : number or tuple of number or iterable of number or imgaug.parameters.StochasticParameter, optional See :func:`~imgaug.parameters.Sigmoid.__init__`. activated : bool or number, optional See :func:`~imgaug.parameters.Sigmoid.__init__`. Returns ------- Sigmoid A sigmoid adjusted to be used with noise. r)rri)r)rArrrrrcreate_for_noise szSigmoid.create_for_noisecCs|d}|jj||dd}|jjdkr|tj}|jj |dd}|j j |dd}|dkrCddt ||j |j | S|S)Nrrrrfrr rq)rrArrgrhrirarrrrexprri)rrrrrrNrrrrrr s   $zSigmoid._draw_samplescCrrlrrrrrr rzSigmoid.__repr__cCs4t|j}d|t|jt|jt|jt|jfS)NzSigmoid(%s, %s, %s, %s, %s))rrArrrrirYrrrr s zSigmoid.__str__)rTrr)rT) rMrrrr staticmethodrrrrrrrrrrn s: rcsReZdZdZdddgffdd ZddZd d Zd d Zd dZddZ Z S) SimplexNoisea Parameter that generates simplex noise of varying resolutions. This parameter expects to sample noise for 2d planes, i.e. for sizes ``(H, W, [C])`` and will return a value in the range ``[0.0, 1.0]`` per spatial location in that plane. The noise is sampled from low resolution planes and upscaled to the requested height and width. The size of the low resolution plane may be defined (large values can be slow) and the interpolation method for upscaling can be set. Parameters ---------- size_px_max : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Maximum height and width in pixels of the low resolution plane. Upon any sampling call, the requested shape will be downscaled until the height or width (whichever is larger) does not exceed this maximum value anymore. Then the noise will be sampled at that shape and later upscaled back to the requested shape. * If a single ``int``, this ``int`` will be used as a constant value. * If a ``tuple`` of two ``int`` s ``(a, b)``, the value will be sampled from the discrete interval ``[a..b]`` once per call. * If a ``list`` of ``int``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`SimplexNoise.draw_sample` or :func:`SimplexNoise.draw_samples`. upscale_method : str or int or list of str or list of int or imgaug.parameters.StochasticParameter, optional After generating the noise maps in low resolution environments, they have to be upscaled to the originally requested shape (i.e. usually the image size). This parameter controls the interpolation method to use. See also :func:`~imgaug.imgaug.imresize_many_images` for a description of possible values. * If ``imgaug.ALL``, then either ``nearest`` or ``linear`` or ``area`` or ``cubic`` is picked per iteration (all same probability). * If ``str``, then that value will always be used as the method (must be ``nearest`` or ``linear`` or ``area`` or ``cubic``). * If ``list`` of ``str``, then a random value will be picked from that list per call. * If :class:`StochasticParameter`, then a random value will be sampled from that parameter per call. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.SimplexNoise(upscale_method="linear") Create a parameter that produces smooth simplex noise of varying sizes. >>> param = iap.SimplexNoise( >>> size_px_max=(8, 16), >>> upscale_method="nearest") Create a parameter that produces rectangular simplex noise of rather high detail. )r linearr<cstt|t|ddd|_|tjkrtgd|_dSt |r)t ||_dSt |t r[t |dks=Jdt |ftdd|DsTJd d d d|Dt||_dSt |tre||_dStd t|f) N size_px_maxrrr<rZareaZcubicr-Expected at least one upscale method, got %d.cSrrrIrKrrrr!C r"z)SimplexNoise.__init__..9Expected all upscale methods to be strings, got types %s.rHcSrrrrrrrr!E rWExpected upscale_method to be string or list of strings or StochasticParameter, got %s.)rrrrGrrrPr0upscale_methodrJr,rrQrr-rRr1rr%)rrrrrrr3 s6     zSimplexNoise.__init__ct|dvs Jd|f|dd\t|dkrdn|d}fddt|D}t|dkr:|dStj|dd S) Nr rIExpected requested noise to have shape (H, W) or (H, W, C), got shape %s.rr rcg|] }qSr_draw_samples_hwrrheightrrrrrr!U z.SimplexNoise._draw_samples..rZaxisrraZarangestackrrrrZ nb_channelsZchannelsrrrrN s zSimplexNoise._draw_samplesc Csd}|d|}d}|jj|f|dd}tj||ftjd}t|D]8} ||||d| || } |dkr>|| 7}q%|dkrP| dkrI| }q%t || }q%| dkrW| }q%t || }q%|dkrf||}|S)Nrrrrrrr) rrrrarHrrr_draw_samples_iterationrr) rrrrrrrZupscale_methodsrNrrrrrr\ s.  zSimplexNoise._draw_samples_hwcCs8|}tt|d}t||}|jj|d}||kr,||} t|| } t|| } n|} |} t| d} t| d} tj| | ftjd} t | D]} t | D] }|j | |d| | |f<qPqI| dd}t |dd}|j ||fkr|d tj}t|d tjfd }tj|||f|d }|d dtj}|S)N)r,rrr)yxr[r rZ.rrrrE.ro@)r)r rBrrrrarHrrrZnoise2drWshaperiuint8rnewaxisrimresize_single_image)rrrrngrZopensimplex_seed generatormaxlenrdownscale_factorrOrPnoiserr noise_0to1noise_0to1_uint8 noise_0to1_3drrrrx s:      z$SimplexNoise._draw_samples_iterationcCrrlrrrrrr rzSimplexNoise.__repr__cCsdt|jt|jfS)NzSimplexNoise(%s, %s))rrrrrrrr szSimplexNoise.__str__) rMrrrrrrrrrrrrrrr sA+rcsXeZdZdZddddgffdd Zdd Zd d Zed d ZddZ ddZ Z S)FrequencyNoisea"Parameter to generate noise of varying frequencies. This parameter expects to sample noise for 2d planes, i.e. for sizes ``(H, W, [C])`` and will return a value in the range ``[0.0, 1.0]`` per spatial location in that plane. The exponent controls the frequencies and therefore noise patterns. Small values (around ``-4.0``) will result in large blobs. Large values (around ``4.0``) will result in small, repetitive patterns. The noise is sampled from low resolution planes and upscaled to the requested height and width. The size of the low resolution plane may be defined (high values can be slow) and the interpolation method for upscaling can be set. Parameters ---------- exponent : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional Exponent to use when scaling in the frequency domain. Sane values are in the range ``-4`` (large blobs) to ``4`` (small patterns). To generate cloud-like structures, use roughly ``-2``. * If a single ``number``, this ``number`` will be used as a constant value. * If a ``tuple`` of two ``number`` s ``(a, b)``, the value will be sampled from the continuous interval ``[a, b)`` once per call. * If a ``list`` of ``number``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. size_px_max : int or tuple of int or list of int or imgaug.parameters.StochasticParameter, optional Maximum height and width in pixels of the low resolution plane. Upon any sampling call, the requested shape will be downscaled until the height or width (whichever is larger) does not exceed this maximum value anymore. Then the noise will be sampled at that shape and later upscaled back to the requested shape. * If a single ``int``, this ``int`` will be used as a constant value. * If a ``tuple`` of two ``int`` s ``(a, b)``, the value will be sampled from the discrete interval ``[a..b]`` once per call. * If a ``list`` of ``int``, a random value will be picked from the ``list`` once per call. * If a :class:`StochasticParameter`, that parameter will be queried once per call. "per call" denotes a call of :func:`FrequencyNoise.draw_sample` or :func:`FrequencyNoise.draw_samples`. upscale_method : imgaug.ALL or str or list of str or imgaug.parameters.StochasticParameter, optional After generating the noise maps in low resolution environments, they have to be upscaled to the originally requested shape (i.e. usually the image size). This parameter controls the interpolation method to use. See also :func:`~imgaug.imgaug.imresize_many_images` for a description of possible values. * If ``imgaug.ALL``, then either ``nearest`` or ``linear`` or ``area`` or ``cubic`` is picked per iteration (all same probability). * If ``str``, then that value will always be used as the method (must be ``nearest`` or ``linear`` or ``area`` or ``cubic``). * If ``list`` of ``str``, then a random value will be picked from that list per call. * If :class:`StochasticParameter`, then a random value will be sampled from that parameter per call. Examples -------- >>> import imgaug.parameters as iap >>> param = iap.FrequencyNoise( >>> exponent=-2, >>> size_px_max=(16, 32), >>> upscale_method="linear") Create a parameter that produces noise with cloud-like patterns. )rD)rDrrr<cstt|t|d|_t|ddd|_|tjkr#t gd|_ dSt |r/t ||_ dSt |trat|dksCJdt|ftdd |DsZJd d d d |Dt ||_ dSt |trk||_ dStd t|f)NexponentrrrrrrcSrrrIrKrrrr! r"z+FrequencyNoise.__init__..rrHcSrrrrrrrr! rr)rrrr8rrGrrrPr0rrJr,rrQrr-rRr1rr%)rrrrrrrr s8      zFrequencyNoise.__init__cr) Nrrrr rcrrrrrrrr!% rz0FrequencyNoise._draw_samples..rrrrrrrr s zFrequencyNoise._draw_samplescCs|d}t||}|jj|dd}||kr(||}t||}t||} n|}|} t|d}t| d} |dj|| fd} |dj|| fd} | t|| d} | dtj} | t| } | t | } |j j|dd} | || f} d| d <| | }d|d <| |}| |}tj |j tjd }||_||_tj|j}t|}t|}||||}|jj|dd}|j ||fkr|d tj}t|d tjfd }tj|||f|d}|ddtj}|S)NrrrDrr!r r)rrrr.rrErr)rrrrrBr rapicossinr_create_distance_matrixrHrrlrmimagZfftZifft2rrrirrrrrr)rrrrrrrrrOrPZwn_rZwn_arrfrZtrealZtimagZ wn_freqs_mulZwn_invZ wn_inv_minZ wn_inv_maxrrrrrrrr, sX       zFrequencyNoise._draw_samples_hwcs&|\fdd}t|fS)Ncs6t||}t||}t|d|dS)Nr )rarsqrt)yyxxZhdistZwdistrJrKrr_freqo sz5FrequencyNoise._create_distance_matrix.._freq)raZ fromfunction)clsrrrrrrrk sz&FrequencyNoise._create_distance_matrixcCrrlrrrrrrv rzFrequencyNoise.__repr__cCr)NzFrequencyNoise(%s, %s, %s))rrrrrrrrry s zFrequencyNoise.__str__) rMrrrrrr classmethodrrrrrrrrr sO?  rcCst|ts Jd||fdS)Nz7Expected '%s' to be a StochasticParameter, got type %s.rX)Zarg_name arg_valuerrrrS s rS)NTT)NTTTrl)rTT)FF)NNrpNNrz)Kr __future__rrrrr collectionsrabcrrrnumpyrasixZ six.movesZmovesrr*Z scipy.statsrr*r rr rGr rZexternal.opensimplexr rr8rGrSrYrerkrorrZ add_metaclassobjectr1r,rr0rcrErrr&r.r/r4r.r8r;rRrrrrrrrnrprsrrrrrrrSrrrrs      ) % 7# 9 .   7Cq2=6;Z=13<<UC=L_LKY#? i *-)= T