o 5ήc(@szddlmZddlZddlZddlZddlmZddlmZddlm Z ddlm Z gdZ d d Z d d Z e j  dLddZe j  dLddZddZe j  dMddZe j  dNddZe jdOddZe jdOddZe j    dPd d!Ze jdQd"d#Ze j  dQd$d%Ze j   dPd&d'Ze j  dQd(d)Zd*d+Ze j  dRd,d-Ze j  dRd.d/Ze j  dLd0d1Ze j  dSd3d4Ze j  dLd5d6Z e j  dLd7d8Z!d9d:Z"e j  dTd;d<Z#e j  dTd=d>Z$e j  ?dUd@dAZ%e j  dTdBdCZ&e j  dTdDdEZ'e j  dTdFdGZ(e j dVdHdIZ)e j  dWdJdKZ*dS)X)IterableN)normalize_axis_index) _ni_support) _nd_image)_ni_docstrings) correlate1d convolve1dgaussian_filter1dgaussian_filterprewittsobelgeneric_laplacelaplacegaussian_laplacegeneric_gradient_magnitudegaussian_gradient_magnitude correlateconvolveuniform_filter1duniform_filterminimum_filter1dmaximum_filter1dminimum_filtermaximum_filter rank_filter median_filterpercentile_filtergeneric_filter1dgeneric_filtercCs||d kp||ddkS)Nr)originlenwr!r!=/tmp/pip-target-vg8gfxp4/lib/python/scipy/ndimage/_filters.py_invalid_origin2sr%cKs^|jjdk}|jjdk}|rb|rb||j|jf|jt|d||j||j|jfdt|d|8_||j|jf|jt|d||j||j|jfdt|d|7_|S|r||j|f|jt|d|||j|f|jt|d||St|rtd|||jf|j|d||||jf|j|d||S)zBComplex convolution via a linear combination of real convolutions.c)outputcvalNz>> from scipy.ndimage import correlate1d >>> correlate1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 3]) array([ 8, 26, 8, 12, 7, 28, 36, 9]) r&F)copy)axismoder"Tcomplex_outputr)rrzno filter weights givenz[Invalid origin; origin must satisfy -(len(weights) // 2) <= origin <= (len(weights)-1) // 2)r,asarrayr)r*conjastype complex128dictr _get_outputr6rfloat64ndimshape RuntimeErrorflags contiguousr:rr%lenr/_extend_mode_to_coder) r1r2r;r'r<r(r"r4r5r3r!r!r$rSs:       rcCsZ|ddd}| }t|d@s|d8}t|}|jjdkr#|}t|||||||S)aVCalculate a 1-D convolution along the given axis. The lines of the array along the given axis are convolved with the given weights. Parameters ---------- %(input)s weights : ndarray 1-D sequence of numbers. %(axis)s %(output)s %(mode_reflect)s %(cval)s %(origin)s Returns ------- convolve1d : ndarray Convolved array with same shape as input Examples -------- >>> from scipy.ndimage import convolve1d >>> convolve1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 3]) array([14, 24, 4, 13, 12, 36, 27, 0]) Nr7rr&)rLr,r@r)r*rAr)r1r2r;r'r<r(r"r!r!r$r s   r c Cs|dkrtdt|d}||}t| |d}td||d}||}|dkr3|St|d}d|d<t|ddd}tt|| d} || } t|D]} | |}q\|dddf| |}||S)z5 Computes a 1-D Gaussian convolution kernel. rzorder must be non-negativergr Nr7) r/r,arangeexpsumzerosdiagonesrangedot) sigmaorderradiusexponent_rangesigma2xphi_xqDPQ_deriv_r!r!r$_gaussian_kernel1ds$   rb@c CsBt|}t||d} t||| ddd} t|| ||||dS)a-1-D Gaussian filter. Parameters ---------- %(input)s sigma : scalar standard deviation for Gaussian kernel %(axis)s order : int, optional An order of 0 corresponds to convolution with a Gaussian kernel. A positive order corresponds to convolution with that derivative of a Gaussian. %(output)s %(mode_reflect)s %(cval)s truncate : float, optional Truncate the filter at this many standard deviations. Default is 4.0. Returns ------- gaussian_filter1d : ndarray Examples -------- >>> from scipy.ndimage import gaussian_filter1d >>> gaussian_filter1d([1.0, 2.0, 3.0, 4.0, 5.0], 1) array([ 1.42704095, 2.06782203, 3. , 3.93217797, 4.57295905]) >>> gaussian_filter1d([1.0, 2.0, 3.0, 4.0, 5.0], 4) array([ 2.91948343, 2.95023502, 3. , 3.04976498, 3.08051657]) >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> x = rng.standard_normal(101).cumsum() >>> y3 = gaussian_filter1d(x, 3) >>> y6 = gaussian_filter1d(x, 6) >>> plt.plot(x, 'k', label='original data') >>> plt.plot(y3, '--', label='filtered, sigma=3') >>> plt.plot(y6, ':', label='filtered, sigma=6') >>> plt.legend() >>> plt.grid() >>> plt.show() g?Nr7r)floatintrbr) r1rVr;rWr'r<r(truncatesdlwr2r!r!r$r s.r c st|}t||}t||jt||jt||jtt|jfddttDtdkrUD]\}}}}t |||||||||}q?|S|d|d<|S)aMultidimensional Gaussian filter. Parameters ---------- %(input)s sigma : scalar or sequence of scalars Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes. order : int or sequence of ints, optional The order of the filter along each axis is given as a sequence of integers, or as a single number. An order of 0 corresponds to convolution with a Gaussian kernel. A positive order corresponds to convolution with that derivative of a Gaussian. %(output)s %(mode_multiple)s %(cval)s truncate : float Truncate the filter at this many standard deviations. Default is 4.0. Returns ------- gaussian_filter : ndarray Returned array of same shape as `input`. Notes ----- The multidimensional filter is implemented as a sequence of 1-D convolution filters. The intermediate arrays are stored in the same data type as the output. Therefore, for output types with a limited precision, the results may be imprecise because intermediate results may be stored with insufficient precision. Examples -------- >>> from scipy.ndimage import gaussian_filter >>> a = np.arange(50, step=2).reshape((5,5)) >>> a array([[ 0, 2, 4, 6, 8], [10, 12, 14, 16, 18], [20, 22, 24, 26, 28], [30, 32, 34, 36, 38], [40, 42, 44, 46, 48]]) >>> gaussian_filter(a, sigma=1) array([[ 4, 6, 8, 9, 11], [10, 12, 14, 15, 17], [20, 22, 24, 25, 27], [29, 31, 33, 34, 36], [35, 37, 39, 40, 42]]) >>> from scipy import misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = gaussian_filter(ascent, sigma=5) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() c4g|]}|dkr||||fqS)gV瞯R "z#gaussian_filter..r.) r,r@rrE_normalize_sequencerGlistrTrLr )r1rVrWr'r<r(rfr;r!rmr$r s$ D     r c t|}t|jt||}t||j}t|gd|||dfddt|jD}|D]}t|gd|||||dq4|S)a@Calculate a Prewitt filter. Parameters ---------- %(input)s %(axis)s %(output)s %(mode_multiple)s %(cval)s Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.prewitt(ascent) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() r7rrrcg|]}|kr|qSr!r!rjr;r!r$rr}zprewitt..)rrr r,r@rrGrrErtrrTr1r;r'r<r(rornrlr!ryr$r ^   r c rv)a<Calculate a Sobel filter. Parameters ---------- %(input)s %(axis)s %(output)s %(mode_multiple)s %(cval)s Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.sobel(ascent) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() rwrcrxr!r!rjryr!r$rrrzzsobel..)rr rr{r|r!ryr$r r}r r!c Cs|duri}t|}t||}tt|j}t|dkr]t|t|}|||d||d|g|Ri|tdt|D]} |||| |j || |g|Ri|} || 7}q@|S|d|d<|S)a N-D Laplace filter using a provided second derivative function. Parameters ---------- %(input)s derivative2 : callable Callable with the following signature:: derivative2(input, axis, output, mode, cval, *extra_arguments, **extra_keywords) See `extra_arguments`, `extra_keywords` below. %(output)s %(mode_multiple)s %(cval)s %(extra_keywords)s %(extra_arguments)s Nrr.) r,r@rrErurTrGrLrtr)) r1 derivative2r'r<r(extra_argumentsextra_keywordsrnrorltmpr!r!r$rs,     rcCsdd}t|||||S)aSN-D Laplace filter based on approximate second derivatives. Parameters ---------- %(input)s %(output)s %(mode_multiple)s %(cval)s Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.laplace(ascent) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() cSst|gd||||dS)N)rrr)r)r1r;r'r<r(r!r!r$r~szlaplace..derivative2)r)r1r'r<r(r~r!r!r$rsrc K*t|}dd}t||||||f|dS)aMultidimensional Laplace filter using Gaussian second derivatives. Parameters ---------- %(input)s sigma : scalar or sequence of scalars The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes. %(output)s %(mode_multiple)s %(cval)s Extra keyword arguments will be passed to gaussian_filter(). Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> ascent = misc.ascent() >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> result = ndimage.gaussian_laplace(ascent, sigma=1) >>> ax1.imshow(result) >>> result = ndimage.gaussian_laplace(ascent, sigma=3) >>> ax2.imshow(result) >>> plt.show() c[.dg|j}d||<t||||||fi|S)Nrr rGr r1r;r'r<r(rVr3rWr!r!r$r~s z%gaussian_laplace..derivative2rr)r,r@r)r1rVr'r<r(r3r~r!r!r$rs # rc Cs|duri}t|}t||}tt|j}t|dkrst|t|}|||d||d|g|Ri|t |||tdt|D]!} |||| |j || |g|Ri|} t | | | || 7}qGtj ||dd|S|d|d<|S)aGradient magnitude using a provided gradient function. Parameters ---------- %(input)s derivative : callable Callable with the following signature:: derivative(input, axis, output, mode, cval, *extra_arguments, **extra_keywords) See `extra_arguments`, `extra_keywords` below. `derivative` can assume that `input` and `output` are ndarrays. Note that the output from `derivative` is modified inplace; be careful to copy important inputs before returning them. %(output)s %(mode_multiple)s %(cval)s %(extra_keywords)s %(extra_arguments)s Nrrunsafe)casting.) r,r@rrErurTrGrLrtmultiplyr)sqrt) r1 derivativer'r<r(rrrnrorlrr!r!r$r s2     rc Kr)aMultidimensional gradient magnitude using Gaussian derivatives. Parameters ---------- %(input)s sigma : scalar or sequence of scalars The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes. %(output)s %(mode_multiple)s %(cval)s Extra keyword arguments will be passed to gaussian_filter(). Returns ------- gaussian_gradient_magnitude : ndarray Filtered array. Has the same shape as `input`. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.gaussian_gradient_magnitude(ascent, sigma=5) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() c[r)Nrrrrr!r!r$rus  z/gaussian_gradient_magnitude..derivativer)r,r@r)r1rVr'r<r(r3rr!r!r$rOs $ rcCst|}t|}|jjdk}|jjdk}|s|r=|r"|s"|}t|||d} tj||dd}tt ||||fi| St ||j } tj|tj d}dd|j D} t| |j kr_td|r|ttddd g|j }tt| D]} | |  | | <|j | d @s| | d 8<qut| | D] \}} t|| rtd q|jjs|}t||}t||}|r|}t|j|}t|tst|trtd t|}t|||||| |r||d <|}|S)Nr&)r<r" convolutionTr=r?cSg|]}|dkr|qSrr!rjr!r!r$rrrzz*_correlate_or_convolve..z)filter weights array has incorrect shape.r7rzfInvalid origin; origin must satisfy -(weights.shape[k] // 2) <= origin[k] <= (weights.shape[k]-1) // 2z$A sequence of modes is not supported.) r,r@r)r*rArDrrEr6_correlate_or_convolvertrGrFrHrLrItupleslicerTzipr%r/rJrKr:may_share_memory isinstancestrrrMrr)r1r2r'r<r(r"rr4r5r3originswshaperlr# temp_neededtempr!r!r$rs^        rcCt||||||dS)a Multidimensional correlation. The array is correlated with the given kernel. Parameters ---------- %(input)s weights : ndarray array of weights, same number of dimensions as input %(output)s %(mode_reflect)s %(cval)s %(origin_multiple)s Returns ------- result : ndarray The result of correlation of `input` with `weights`. See Also -------- convolve : Convolve an image with a kernel. Examples -------- Correlation is the process of moving a filter mask often referred to as kernel over the image and computing the sum of products at each location. >>> from scipy.ndimage import correlate >>> input_img = np.arange(25).reshape(5,5) >>> print(input_img) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19] [20 21 22 23 24]] Define a kernel (weights) for correlation. In this example, it is for sum of center and up, down, left and right next elements. >>> weights = [[0, 1, 0], ... [1, 1, 1], ... [0, 1, 0]] We can calculate a correlation result: For example, element ``[2,2]`` is ``7 + 11 + 12 + 13 + 17 = 60``. >>> correlate(input_img, weights) array([[ 6, 10, 15, 20, 24], [ 26, 30, 35, 40, 44], [ 51, 55, 60, 65, 69], [ 76, 80, 85, 90, 94], [ 96, 100, 105, 110, 114]]) Frr1r2r'r<r(r"r!r!r$rs ;rcCr)a Multidimensional convolution. The array is convolved with the given kernel. Parameters ---------- %(input)s weights : array_like Array of weights, same number of dimensions as input %(output)s %(mode_reflect)s cval : scalar, optional Value to fill past edges of input if `mode` is 'constant'. Default is 0.0 origin : int, optional Controls the origin of the input signal, which is where the filter is centered to produce the first element of the output. Positive values shift the filter to the right, and negative values shift the filter to the left. Default is 0. Returns ------- result : ndarray The result of convolution of `input` with `weights`. See Also -------- correlate : Correlate an image with a kernel. Notes ----- Each value in result is :math:`C_i = \sum_j{I_{i+k-j} W_j}`, where W is the `weights` kernel, j is the N-D spatial index over :math:`W`, I is the `input` and k is the coordinate of the center of W, specified by `origin` in the input parameters. Examples -------- Perhaps the simplest case to understand is ``mode='constant', cval=0.0``, because in this case borders (i.e., where the `weights` kernel, centered on any one value, extends beyond an edge of `input`) are treated as zeros. >>> a = np.array([[1, 2, 0, 0], ... [5, 3, 0, 4], ... [0, 0, 0, 7], ... [9, 3, 0, 0]]) >>> k = np.array([[1,1,1],[1,1,0],[1,0,0]]) >>> from scipy import ndimage >>> ndimage.convolve(a, k, mode='constant', cval=0.0) array([[11, 10, 7, 4], [10, 3, 11, 11], [15, 12, 14, 7], [12, 3, 7, 0]]) Setting ``cval=1.0`` is equivalent to padding the outer edge of `input` with 1.0's (and then extracting only the original region of the result). >>> ndimage.convolve(a, k, mode='constant', cval=1.0) array([[13, 11, 8, 7], [11, 3, 11, 14], [16, 12, 14, 10], [15, 6, 10, 5]]) With ``mode='reflect'`` (the default), outer values are reflected at the edge of `input` to fill in missing values. >>> b = np.array([[2, 0, 0], ... [1, 0, 0], ... [0, 0, 0]]) >>> k = np.array([[0,1,0], [0,1,0], [0,1,0]]) >>> ndimage.convolve(b, k, mode='reflect') array([[5, 0, 0], [3, 0, 0], [1, 0, 0]]) This includes diagonally at the corners. >>> k = np.array([[1,0,0],[0,1,0],[0,0,1]]) >>> ndimage.convolve(b, k) array([[4, 2, 0], [3, 2, 0], [1, 1, 0]]) With ``mode='nearest'``, the single nearest value in to an edge in `input` is repeated as many times as needed to match the overlapping `weights`. >>> c = np.array([[2, 0, 1], ... [1, 0, 0], ... [0, 0, 0]]) >>> k = np.array([[0, 1, 0], ... [0, 1, 0], ... [0, 1, 0], ... [0, 1, 0], ... [0, 1, 0]]) >>> ndimage.convolve(c, k, mode='nearest') array([[7, 0, 3], [5, 0, 2], [3, 0, 1]]) Trrr!r!r$rs jrc Cst|}t||j}|dkrtd|jjdk}tj|||d}|d|dks1|d||kr5t dt |}|sIt ||||||||St |j |||j |t ||t |j|||j|t|||S)aCalculate a 1-D uniform filter along the given axis. The lines of the array along the given axis are filtered with a uniform filter of given size. Parameters ---------- %(input)s size : int length of uniform filter %(axis)s %(output)s %(mode_reflect)s %(cval)s %(origin)s Examples -------- >>> from scipy.ndimage import uniform_filter1d >>> uniform_filter1d([2, 8, 0, 4, 1, 9, 9, 0], size=3) array([4, 3, 4, 1, 4, 6, 6, 3]) rincorrect filter sizer&r=r rinvalid origin)r,r@rrGrIr)r*rrEr/rMrrr+r-)r1sizer;r'r<r(r"r>r!r!r$rbs.       rc st|}tj|||jjdkd}t||jt||jt||jtt |jfddt t Dt dkr\D]\}}}}t |t |||||||}qE|S|d|d<|S)aMultidimensional uniform filter. Parameters ---------- %(input)s size : int or sequence of ints, optional The sizes of the uniform filter are given for each axis as a sequence, or as a single number, in which case the size is equal for all axes. %(output)s %(mode_multiple)s %(cval)s %(origin_multiple)s Returns ------- uniform_filter : ndarray Filtered array. Has the same shape as `input`. Notes ----- The multidimensional filter is implemented as a sequence of 1-D uniform filters. The intermediate arrays are stored in the same data type as the output. Therefore, for output types with a limited precision, the results may be imprecise because intermediate results may be stored with insufficient precision. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.uniform_filter(ascent, size=20) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() r&r=crirr!rjrnrorsizesr!r$rrrsz"uniform_filter..r.) r,r@rrEr)r*rtrGrurTrLrre)r1rr'r<r(r"r;r!rr$rs( ,    rc Cst|}t|rtdt||j}|dkrtdt||}|d|dks2|d||kr6t dt |}t |||||||d|S)aCalculate a 1-D minimum filter along the given axis. The lines of the array along the given axis are filtered with a minimum filter of given size. Parameters ---------- %(input)s size : int length along which to calculate 1D minimum %(axis)s %(output)s %(mode_reflect)s %(cval)s %(origin)s Notes ----- This function implements the MINLIST algorithm [1]_, as described by Richard Harter [2]_, and has a guaranteed O(n) performance, `n` being the `input` length, regardless of filter size. References ---------- .. [1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777 .. [2] http://www.richardhartersworld.com/cri/2001/slidingmin.html Examples -------- >>> from scipy.ndimage import minimum_filter1d >>> minimum_filter1d([2, 8, 0, 4, 1, 9, 9, 0], size=3) array([2, 0, 0, 0, 1, 1, 0, 0]) Complex type not supportedrrr rr r,r@r. TypeErrorrrGrIrrEr/rMrmin_or_max_filter1dr1rr;r'r<r(r"r!r!r$rs %     rc Cst|}t|rtdt||j}|dkrtdt||}|d|dks2|d||kr6t dt |}t |||||||d|S)a0Calculate a 1-D maximum filter along the given axis. The lines of the array along the given axis are filtered with a maximum filter of given size. Parameters ---------- %(input)s size : int Length along which to calculate the 1-D maximum. %(axis)s %(output)s %(mode_reflect)s %(cval)s %(origin)s Returns ------- maximum1d : ndarray, None Maximum-filtered array with same shape as input. None if `output` is not None Notes ----- This function implements the MAXLIST algorithm [1]_, as described by Richard Harter [2]_, and has a guaranteed O(n) performance, `n` being the `input` length, regardless of filter size. References ---------- .. [1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777 .. [2] http://www.richardhartersworld.com/cri/2001/slidingmin.html Examples -------- >>> from scipy.ndimage import maximum_filter1d >>> maximum_filter1d([2, 8, 0, 4, 1, 9, 9, 0], size=3) array([8, 8, 8, 4, 9, 9, 9, 9]) rrrr rrrrr!r!r$rs *     rc  s|dur|durtjdtdd|durA|dur#|dur tdd} n;tj|td}|s2td| r>|j }d}d} n d} ntj|tj d}d} |durWt |j t}ntj|td}t|}t |rltd t||}t||} | r|} t|j|}t||j| rt||jt||jtt|jfd d ttD|rt} nt} td krֈD]\} }}}| |t|| |||||}qn|d |d <nxdd |j D}t||jkrtdt|D]\}}|d|d ks |d||krtdq|jjs|}|dur4t|j |jkr+td|jjs4|}t|t sDt|t!rDtdt"|}t#$|||||||| r^|| d <| }|S)N&ignoring size because footprint is setr stacklevelzno footprint providedTr?z$All-zero footprint is not supported.Frcrirr!rjrr!r$rrdrsz&_min_or_max_filter..r.cSrrr!rjr!r!r$rrqrzz$footprint array has incorrect shape.r rz#structure array has incorrect shapezAA sequence of modes is not supported for non-separable footprints)%warningswarn UserWarningrIr,r@boolanyr/allrHrFrSr.rrrErr)rtrGrurTrLrrrerrJrKr:rrrrMrmin_or_max_filter)r1r footprint structurer'r<r(r"minimum separablerrfilter_r;fshapelenfr!rr$_min_or_max_filter<s      $     rc Ct|||d||||d S)aCalculate a multidimensional minimum filter. Parameters ---------- %(input)s %(size_foot)s %(output)s %(mode_multiple)s %(cval)s %(origin_multiple)s Returns ------- minimum_filter : ndarray Filtered array. Has the same shape as `input`. Notes ----- A sequence of modes (one per axis) is only supported when the footprint is separable. Otherwise, a single mode string must be provided. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.minimum_filter(ascent, size=20) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() Nrrr1rrr'r<r(r"r!r!r$r&rc Cr)aCalculate a multidimensional maximum filter. Parameters ---------- %(input)s %(size_foot)s %(output)s %(mode_multiple)s %(cval)s %(origin_multiple)s Returns ------- maximum_filter : ndarray Filtered array. Has the same shape as `input`. Notes ----- A sequence of modes (one per axis) is only supported when the footprint is separable. Otherwise, a single mode string must be provided. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.maximum_filter(ascent, size=20) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() Nrrrr!r!r$rrrrankc  Csh|dur|durtjdtddt|}t|rtdt||j } |dur@|dur1t dt||j } tj | t d}ntj|t d}dd|j D} t| |j krZt d t| | D]\}} | d |d kss| d || krwtd q_|jjs|}t|d d } |dkr| d }n-|dkr|}|dkr|d7}|d ks|dkrt d|dkr| d }n tt| |d}|d kr|| 7}|d ks|| krt d|d krt|d||||| S|| d krt|d||||| St||}t||}|r |}t|j|}t|tst|trt dt |}t!"||||||| |r2||d<|}|S)Nrrrr$no footprint or filter size providedr?cSrrr!rjr!r!r$rrrzz _rank_filter..+filter footprint array has incorrect shape.r rrrmedian percentiler9gY@dzinvalid percentilez%rank not within filter footprint sizezBA sequence of modes is not supported by non-separable rank filters.)#rrrr,r@r.rrrtrGrIrSrrHrLrr/rJrKr:whererPrerdrrrErr)rrrrMrr)r1rrrr'r<r(r" operationrrrr filter_sizerrrr!r!r$ _rank_filters|         rc Cs"t|}t||||||||d S)abCalculate a multidimensional rank filter. Parameters ---------- %(input)s rank : int The rank parameter may be less than zero, i.e., rank = -1 indicates the largest element. %(size_foot)s %(output)s %(mode_reflect)s %(cval)s %(origin_multiple)s Returns ------- rank_filter : ndarray Filtered array. Has the same shape as `input`. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.rank_filter(ascent, rank=42, size=20) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() r)operatorindexr)r1rrrr'r<r(r"r!r!r$r"s $rc Cst|d||||||d S)a Calculate a multidimensional median filter. Parameters ---------- %(input)s %(size_foot)s %(output)s %(mode_reflect)s %(cval)s %(origin_multiple)s Returns ------- median_filter : ndarray Filtered array. Has the same shape as `input`. See Also -------- scipy.signal.medfilt2d Notes ----- For 2-dimensional images with ``uint8``, ``float32`` or ``float64`` dtypes the specialised function `scipy.signal.medfilt2d` may be faster. It is however limited to constant mode with ``cval=0``. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.median_filter(ascent, size=20) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() rrrrr!r!r$rKs,rc Cst||||||||d S)aCalculate a multidimensional percentile filter. Parameters ---------- %(input)s percentile : scalar The percentile parameter may be less than zero, i.e., percentile = -20 equals percentile = 80 %(size_foot)s %(output)s %(mode_reflect)s %(cval)s %(origin_multiple)s Returns ------- percentile_filter : ndarray Filtered array. Has the same shape as `input`. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> plt.gray() # show the filtered result in grayscale >>> ax1 = fig.add_subplot(121) # left side >>> ax2 = fig.add_subplot(122) # right side >>> ascent = misc.ascent() >>> result = ndimage.percentile_filter(ascent, percentile=20, size=20) >>> ax1.imshow(ascent) >>> ax2.imshow(result) >>> plt.show() rr)r1rrrr'r<r(r"r!r!r$r{s$rc Cs| duri} t|}t|rtdt||}|dkr"tdt||j}|d|dks8|d||kr.rrr)rrrr,r@r.rrrtrGrIrSrrHrLrr/rJrKr:rErMrr)r1rrrr'r<r(r"rrrrrrr!r!r$rs:6     r)r7Nr8r9r)r7rNr8r9rc)rNr8r9rc)r7Nr8r9)Nr8r9r!N)Nr8r9)Nr8r9r)rNr8r9r)NNNr8r9r)NNNr8r9rr)r7Nr8r9rr!N)NNNr8r9rr!N)+collections.abcrrr,rnumpy.core.multiarrayrrrr__all__r%r6 docfillerrr rbr r r r rrrrrrrrrrrrrrrrrrrrrr!r!r!r$s       6 ( 5 U $ $ )  / . 05 > m - > 3 8O ) ) B ( / ' R