a ReS@svddlmZmZmZmZmZmZmZmZm Z m Z m Z ddl m Z mZmZmZmZmZmZmZmZddlZddlmZmZddlmZddlmZddlmZgd Z d5d d Z!iZ"d dZ#dZ$ej%e$dddZ&ddZ'dZ(ej%e(dddZ)ddZ*dZ+ej%e+dddZ,ddZ-dd Z.d!d"Z/d#d$Z0d%d&Z1d'd(Z2d)d*Z3d6d,d-Z4d7d.d/Z5d8d1d2Z6d9d3d4Z7dS):) logical_andasarraypi zeros_like piecewisearrayarctan2tanzerosarangefloor) sqrtexpgreaterlesscosaddsin less_equal greater_equalN) cspline2dsepfir2d)comb)float_factorial)BSpline) spline_filterbspline gauss_splinecubic quadratic cspline1d qspline1dcspline1d_evalqspline1d_eval@c Cs|jj}tgddd}|dvrp|d}t|j|}t|j|}t|||}t|||}|d||}n2|dvrt||}t|||}||}ntd|S) a3Smoothing spline (cubic) filtering of a rank-2 array. Filter an input data set, `Iin`, using a (cubic) smoothing spline of fall-off `lmbda`. Parameters ---------- Iin : array_like input data set lmbda : float, optional spline smooghing fall-off value, default is `5.0`. Returns ------- res : ndarray filterd input data Examples -------- We can filter an multi dimentional signal (ex: 2D image) using cubic B-spline filter: >>> import numpy as np >>> from scipy.signal import spline_filter >>> import matplotlib.pyplot as plt >>> orig_img = np.eye(20) # create an image >>> orig_img[10, :] = 1.0 >>> sp_filter = spline_filter(orig_img, lmbda=0.1) >>> f, ax = plt.subplots(1, 2, sharex=True) >>> for ind, data in enumerate([[orig_img, "original image"], ... [sp_filter, "spline filter"]]): ... ax[ind].imshow(data[0], cmap='gray_r') ... ax[ind].set_title(data[1]) >>> plt.tight_layout() >>> plt.show() )?g@r&f@)FDr)y?)r'dzInvalid data type for Iin) dtypecharrastyperrealimagr TypeError) ZIinZlmbdaZintypeZhcolZckrZckiZoutrZoutioutr3J/var/www/sunrise/env/lib/python3.9/site-packages/scipy/signal/_bsplines.pyrs&        rcsz tWStyYn0dd}dd}dr@d}nd}|dd|g}|td|dD]"}||dddqd||ddd dtfd d fd d t|D}||ft<||fS) aReturns the function defined over the left-side pieces for a bspline of a given order. The 0th piece is the first one less than 0. The last piece is a function identical to 0 (returned as the constant 0). (There are order//2 + 2 total pieces). Also returns the condition functions that when evaluated return boolean arrays for use with `numpy.piecewise`. cs<|dkrfddS|dkr*fddSfddSdS)Nrcstt|t|SN)rrrxval1val2r3r4_s z>_bspline_piecefunctions..condfuncgen..cs t|Sr5)rr6)r:r3r4r;bcstt|t|Sr5)rrrr6r8r3r4r;ds r3)numr9r:r3r8r4 condfuncgen]s  z,_bspline_piecefunctions..condfuncgenr<grr@csdd|dkrdSfddtdDfddtdDfdd}|S) Nr<rc s6g|].}dd|dttd|ddqS)rr<)exact)floatr.0k)fvalorderr3r4 szA_bspline_piecefunctions..piecefuncgen..rcsg|]} |qSr3r3rD)boundr3r4rIr=cs6d}tdD] }||||7}q|S)Nrrange)r7resrF)MkcoeffsrHshiftsr3r4thefuncsz>_bspline_piecefunctions..piecefuncgen..thefuncrL)r>rR)rJrGrH)rOrPrQr4 piecefuncgen{s   z-_bspline_piecefunctions..piecefuncgencsg|] }|qSr3r3rD)rSr3r4rIr=z+_bspline_piecefunctions..)_splinefunc_cacheKeyErrorrMappendr)rHr?lastZ startbound condfuncsr>funclistr3)rJrGrHrSr4_bspline_piecefunctionsMs(      rZa5`scipy.signal.bspline` is deprecated in SciPy 1.11 and will be removed in SciPy 1.13. The exact equivalent (for a float array `x`) is >>> from scipy.interpolate import BSpline >>> knots = np.arange(-(n+1)/2, (n+3)/2) >>> out = BSpline.basis_element(knots)(x) >>> out[(x < knots[0]) | (x > knots[-1])] = 0.0 )messagecs<tt|td t|\}}fdd|D}t||S)awB-spline basis function of order n. Parameters ---------- x : array_like a knot vector n : int The order of the spline. Must be non-negative, i.e., n >= 0 Returns ------- res : ndarray B-spline basis function values See Also -------- cubic : A cubic B-spline. quadratic : A quadratic B-spline. Notes ----- Uses numpy.piecewise and automatic function-generator. Examples -------- We can calculate B-Spline basis function of several orders: >>> import numpy as np >>> from scipy.signal import bspline, cubic, quadratic >>> bspline(0.0, 1) 1 >>> knots = [-1.0, 0.0, -1.0] >>> bspline(knots, 2) array([0.125, 0.75, 0.125]) >>> np.array_equal(bspline(knots, 2), quadratic(knots)) True >>> np.array_equal(bspline(knots, 3), cubic(knots)) True r,csg|] }|qSr3r3)rEfuncaxr3r4rIr=zbspline..)absrrCrZr)r7nrYrXZcondlistr3r^r4rs- rcCs>t|}|dd}dtdt|t|d d|S)aGaussian approximation to B-spline basis function of order n. Parameters ---------- x : array_like a knot vector n : int The order of the spline. Must be non-negative, i.e., n >= 0 Returns ------- res : ndarray B-spline basis function values approximated by a zero-mean Gaussian function. Notes ----- The B-spline basis function can be approximated well by a zero-mean Gaussian function with standard-deviation equal to :math:`\sigma=(n+1)/12` for large `n` : .. math:: \frac{1}{\sqrt {2\pi\sigma^2}}exp(-\frac{x^2}{2\sigma}) References ---------- .. [1] Bouma H., Vilanova A., Bescos J.O., ter Haar Romeny B.M., Gerritsen F.A. (2007) Fast and Accurate Gaussian Derivatives Based on B-Splines. In: Sgallari F., Murli A., Paragios N. (eds) Scale Space and Variational Methods in Computer Vision. SSVM 2007. Lecture Notes in Computer Science, vol 4485. Springer, Berlin, Heidelberg .. [2] http://folk.uio.no/inf3330/scripting/doc/python/SciPy/tutorial/old/node24.html Examples -------- We can calculate B-Spline basis functions approximated by a gaussian distribution: >>> import numpy as np >>> from scipy.signal import gauss_spline, bspline >>> knots = np.array([-1.0, 0.0, -1.0]) >>> gauss_spline(knots, 3) array([0.15418033, 0.6909883, 0.15418033]) # may vary >>> bspline(knots, 3) array([0.16666667, 0.66666667, 0.16666667]) # may vary rg(@r<)rr rr)r7raZsignsqr3r3r4rs0 ra`scipy.signal.cubic` is deprecated in SciPy 1.11 and will be removed in SciPy 1.13. The exact equivalent (for a float array `x`) is >>> from scipy.interpolate import BSpline >>> out = BSpline.basis_element([-2, -1, 0, 1, 2])(x) >>> out[(x < -2 | (x > 2)] = 0.0 cCstt|td}t|}t|d}|rN||}dd|dd|||<|t|d@}|r||}dd|d||<|S)a-A cubic B-spline. This is a special case of `bspline`, and equivalent to ``bspline(x, 3)``. Parameters ---------- x : array_like a knot vector Returns ------- res : ndarray Cubic B-spline basis function values See Also -------- bspline : B-spline basis function of order n quadratic : A quadratic B-spline. Examples -------- We can calculate B-Spline basis function of several orders: >>> import numpy as np >>> from scipy.signal import bspline, cubic, quadratic >>> bspline(0.0, 1) 1 >>> knots = [-1.0, 0.0, -1.0] >>> bspline(knots, 2) array([0.125, 0.75, 0.125]) >>> np.array_equal(bspline(knots, 2), quadratic(knots)) True >>> np.array_equal(bspline(knots, 3), cubic(knots)) True r\rgUUUUUU??r<gUUUUUU?r`rrCrranyr7r_rNcond1Zax1cond2Zax2r3r3r4rs) rcCs>t|td}tjgddd}||}d||dk|dkB<|S)Nr\)rrr<FZ extrapolaterrir<)rrCr basis_elementr7br2r3r3r4_cubicFs  roa`scipy.signal.quadratic` is deprecated in SciPy 1.11 and will be removed in SciPy 1.13. The exact equivalent (for a float array `x`) is >>> from scipy.interpolate import BSpline >>> out = BSpline.basis_element([-1.5, -0.5, 0.5, 1.5])(x) >>> out[(x < -1.5 | (x > 1.5)] = 0.0 cCsztt|td}t|}t|d}|rB||}d|d||<|t|d@}|rv||}|ddd||<|S)a-A quadratic B-spline. This is a special case of `bspline`, and equivalent to ``bspline(x, 2)``. Parameters ---------- x : array_like a knot vector Returns ------- res : ndarray Quadratic B-spline basis function values See Also -------- bspline : B-spline basis function of order n cubic : A cubic B-spline. Examples -------- We can calculate B-Spline basis function of several orders: >>> import numpy as np >>> from scipy.signal import bspline, cubic, quadratic >>> bspline(0.0, 1) 1 >>> knots = [-1.0, 0.0, -1.0] >>> bspline(knots, 2) array([0.125, 0.75, 0.125]) >>> np.array_equal(bspline(knots, 2), quadratic(knots)) True >>> np.array_equal(bspline(knots, 3), cubic(knots)) True r\rbg?r<?rArdrfr3r3r4r Ys) r cCsBtt|td}tjgddd}||}d||dk|dkB<|S)Nr\)r@rbrpFrkrrqrp)r`rrCrrlrmr3r3r4 _quadratics rrcCsdd|d|tdd|}ttd|dt|}d|dt|d|}|td|d|tdd||}||fS)Nr`rc0)r r)ZlamxiZomegrhor3r3r4 _coeff_smooths $,rycCs.|t|||t||dt|dS)Nrrj)rr)rFcsrxomegar3r3r4_hcs"r|cCs||d||d||dd||td||d}d||d||t|}t|}|||t|||t||S)Nrr<)rr r`r)rFrzrxr{Zc0gammaZakr3r3r4_hss " rc Cst|\}}dd|t|||}t|}t|f|jj}t|}td||||dt t|d|||||d<td||||dtd||||dt t|d|||||d<t d|D]D}|||d|t|||d||||d||<qt|f|jj} t t ||||t |d||||ddd| |d<t t |d|||t |d||||ddd| |d<t |dddD]F}|||d|t|| |d||| |d| |<q| S)Nrr<rrjrc) ryrlenr r,r-r r|rreducerMr) signallambrxr{rzKZyprFrayr3r3r4_cubic_smooth_coeffsB &   & rcCsdtd}t|}t|f|jj}|t|}|d|t|||d<td|D] }|||||d||<qXt|f|j}||d||d||d<t|dddD] }|||d||||<q|dS)Nrircrrr<rjr( r rr r,r-r rrrMrZzirZyplusZpowersrFoutputr3r3r4 _cubic_coeffs   rcCsddtd}t|}t|f|jj}|t|}|d|t|||d<td|D] }|||||d||<q\t|f|jj}||d||d||d<t|dddD] }|||d||||<q|dS)Nr<rArrrjg @rrr3r3r4_quadratic_coeffs  rrKcCs|dkrt||St|SdS)a Compute cubic spline coefficients for rank-1 array. Find the cubic spline coefficients for a 1-D signal assuming mirror-symmetric boundary conditions. To obtain the signal back from the spline representation mirror-symmetric-convolve these coefficients with a length 3 FIR window [1.0, 4.0, 1.0]/ 6.0 . Parameters ---------- signal : ndarray A rank-1 array representing samples of a signal. lamb : float, optional Smoothing coefficient, default is 0.0. Returns ------- c : ndarray Cubic spline coefficients. See Also -------- cspline1d_eval : Evaluate a cubic spline at the new set of points. Examples -------- We can filter a signal to reduce and smooth out high-frequency noise with a cubic spline: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import cspline1d, cspline1d_eval >>> rng = np.random.default_rng() >>> sig = np.repeat([0., 1., 0.], 100) >>> sig += rng.standard_normal(len(sig))*0.05 # add noise >>> time = np.linspace(0, len(sig)) >>> filtered = cspline1d_eval(cspline1d(sig), time) >>> plt.plot(sig, label="signal") >>> plt.plot(time, filtered, label="filtered") >>> plt.legend() >>> plt.show() rKN)rrrrr3r3r4r!s, r!cCs|dkrtdnt|SdS)aFCompute quadratic spline coefficients for rank-1 array. Parameters ---------- signal : ndarray A rank-1 array representing samples of a signal. lamb : float, optional Smoothing coefficient (must be zero for now). Returns ------- c : ndarray Quadratic spline coefficients. See Also -------- qspline1d_eval : Evaluate a quadratic spline at the new set of points. Notes ----- Find the quadratic spline coefficients for a 1-D signal assuming mirror-symmetric boundary conditions. To obtain the signal back from the spline representation mirror-symmetric-convolve these coefficients with a length 3 FIR window [1.0, 6.0, 1.0]/ 8.0 . Examples -------- We can filter a signal to reduce and smooth out high-frequency noise with a quadratic spline: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import qspline1d, qspline1d_eval >>> rng = np.random.default_rng() >>> sig = np.repeat([0., 1., 0.], 100) >>> sig += rng.standard_normal(len(sig))*0.05 # add noise >>> time = np.linspace(0, len(sig)) >>> filtered = qspline1d_eval(qspline1d(sig), time) >>> plt.plot(sig, label="signal") >>> plt.plot(time, filtered, label="filtered") >>> plt.legend() >>> plt.show() rKz.Smoothing quadratic splines not supported yet.N) ValueErrorrrr3r3r4r"s- r"r&cCs t||t|}t||jd}|jdkr0|St|}|dk}||dk}||B}t||| ||<t|d|d||||<||}|jdkr|St||jd} t|dt d} t dD]4} | | } | d|d} | || t || 7} q| ||<|S)aEvaluate a cubic spline at the new set of points. `dx` is the old sample-spacing while `x0` was the old origin. In other-words the old-sample points (knot-points) for which the `cj` represent spline coefficients were at equally-spaced points of: oldx = x0 + j*dx j=0...N-1, with N=len(cj) Edges are handled using mirror-symmetric boundary conditions. Parameters ---------- cj : ndarray cublic spline coefficients newx : ndarray New set of points. dx : float, optional Old sample-spacing, the default value is 1.0. x0 : int, optional Old origin, the default value is 0. Returns ------- res : ndarray Evaluated a cubic spline points. See Also -------- cspline1d : Compute cubic spline coefficients for rank-1 array. Examples -------- We can filter a signal to reduce and smooth out high-frequency noise with a cubic spline: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import cspline1d, cspline1d_eval >>> rng = np.random.default_rng() >>> sig = np.repeat([0., 1., 0.], 100) >>> sig += rng.standard_normal(len(sig))*0.05 # add noise >>> time = np.linspace(0, len(sig)) >>> filtered = cspline1d_eval(cspline1d(sig), time) >>> plt.plot(sig, label="signal") >>> plt.plot(time, filtered, label="filtered") >>> plt.legend() >>> plt.show() r\rrr<r}) rrCrr,sizerr#r r.intrMcliprocjZnewxZdxZx0rNNrgrhZcond3resultZjloweriZthisjZindjr3r3r4r#Ns*2     r#cCst|||}t|}|jdkr&|St|}|dk}||dk}||B}t||| ||<t|d|d||||<||}|jdkr|St|} t|dtd} tdD]4} | | } | d|d} | || t || 7} q| ||<|S)aEvaluate a quadratic spline at the new set of points. Parameters ---------- cj : ndarray Quadratic spline coefficients newx : ndarray New set of points. dx : float, optional Old sample-spacing, the default value is 1.0. x0 : int, optional Old origin, the default value is 0. Returns ------- res : ndarray Evaluated a quadratic spline points. See Also -------- qspline1d : Compute quadratic spline coefficients for rank-1 array. Notes ----- `dx` is the old sample-spacing while `x0` was the old origin. In other-words the old-sample points (knot-points) for which the `cj` represent spline coefficients were at equally-spaced points of:: oldx = x0 + j*dx j=0...N-1, with N=len(cj) Edges are handled using mirror-symmetric boundary conditions. Examples -------- We can filter a signal to reduce and smooth out high-frequency noise with a quadratic spline: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import qspline1d, qspline1d_eval >>> rng = np.random.default_rng() >>> sig = np.repeat([0., 1., 0.], 100) >>> sig += rng.standard_normal(len(sig))*0.05 # add noise >>> time = np.linspace(0, len(sig)) >>> filtered = qspline1d_eval(qspline1d(sig), time) >>> plt.plot(sig, label="signal") >>> plt.plot(time, filtered, label="filtered") >>> plt.legend() >>> plt.show() rrr<rprc) rrrrr$r r.rrMrrrrr3r3r4r$s*4     r$)r%)rK)rK)r&r)r&r)8numpyrrrrrrrr r r r Znumpy.core.umathr rrrrrrrrnpZ_splinerrZ scipy.specialrZscipy._lib._utilrZscipy.interpolater__all__rrTrZZ msg_bsplineZ deprecaterrZ msg_cubicrroZ msg_quadraticr rrryr|rrrrr!r"r#r$r3r3r3r4s@4,    8D  25  5  5 2 3 J