Ugs=ddlmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZmZddlmZmZmZddlmZgdZddZiZd Zd Zd Z d Z!d Z"dZ#dZ$dZ%dZ&ddZ'ddZ(ddZ)ddZ*dS))asarraypi zeros_likearrayarctan2tanonesarangefloorr_ atleast_1dsqrtexpgreatercosaddsin) cspline2dsepfir2d)lfiltersosfiltlfiltic)BSpline) spline_filter gauss_spline cspline1d qspline1dcspline1d_evalqspline1d_eval@c|jj}tgdddz }|dvr}|d}t |j|}t |j|}t|||}t|||}|d|zz|}nJ|dvr7t ||}t|||}||}ntd|S) a4Smoothing 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 filtered input data Examples -------- We can filter an multi dimensional 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) Iinlmbdaintypehcolckrckioutroutiouts U/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/scipy/signal/_bsplines.pyrrsLY^F # & & ,D jjoo%((%((T4((T4((b4i''// :  U##sD$''jj  3444 Jct|}|dzdz }dtdtz|zz t|dz dz |z zS)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 >>> knots = np.array([-1.0, 0.0, -1.0]) >>> gauss_spline(knots, 3) array([0.15418033, 0.6909883, 0.15418033]) # may vary rg(@)rrrr)xnsignsqs r8rrJsTZ  A!et^F tAFVO$$ $sAF7Q;+?'@'@ @@r9ct|t}tjgdd}||}d||dk|dkz<|S)Nr))rrr;F extrapolaterrAr;)rfloatr basis_elementr<br7s r8_cubicrI|sYA///UCCCA !A$$CCRAE Jr9ctt|t}tjgdd}||}d||dk|dkz<|S)Nr@)gg??FrCrrKrL)absrrErrFrGs r8 _quadraticrNsa GAU # # #$$A444%HHHA !A$$C"#CTa#g Jr9c Vdd|zz d|ztdd|zzzz}ttd|zdz t|}d|zdz t|z d|zz }|td|zd|ztdd|zzzz|z z}||fS)Nr`0)rr)lamxiomegrhos r8 _coeff_smoothrYs R#XS4C#I #6#66 6B 4c A &&R 1 1D 8a<$r(( "rCx 0C b3hcDS3Y,?,?!??2EFF FC 9r9c|t|z ||zzt||dzzzt|dzS)NrrB)rr)kcsrXomegas r8_hcr^sB UOsax (3uA+?+? ? ArNN r9c<||zd||zzzd||zz z dd|z|ztd|zzz |dzzz }d||zz d||zzz t|z }t|}|||zzt||z|t||zzzzS)Nrr;)rrrMr)r[r\rXr]c0gammaaks r8_hsrds r'Qs] #q39} 5 q3w}s1u9~~- -q 8 :B s]q39} -E :E QB r >S__us52:/FF GGr9c t|\}}dd|zt|zz ||zz}t|}t|}t d||||dzt jt |dz||||zz}t d||||dzt d||||dzzt jt |dz||||zz}t|tdd|zt|z||zft||f} | dd} t|dddd|zt|z||zf} | dd} t| |dd| \} } t||| f} t jt||||t|dz|||z|dddz}t jt|dz |||t|dz|||z|dddz}t|tdd|zt|z||zft||f} | dd} t| | ddd| \} } t| ddd||f} | S)Nrr;rrArBzi) rYrlenr r^rreducerr reshaperrd)signallambrXr]r\Kr[zi_2zi_1rgsosyp_ys r8_cubic_smooth_coeffrust$$JC QWs5zz ! !C#I -B F Aq A 2sE " "VAY . Js1q5"c511F: ; ; >> 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)rurrlrms r8rrs,X s{{"64000F###r9cJ|dkrtdt|S)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() rz.Smoothing quadratic splines not supported yet.) ValueErrorrrs r8rrAs+Z s{{IJJJ'''r9r#ct||z t|z }t||j}|jdkr|St |}|dk}||dz k}||z}t ||| ||<t |d|dz z||z ||<||}|jdkr|St||j} t|dz tdz} tdD]>} | | z} | d|dz } | || t|| z zz } ?| ||<|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`) rrErr)sizerirr r+intrangecliprIcjnewxdxx0resNcond1cond2cond3resultjlowerithisjindjs r8rrtsad DMMB %)) +D T * * *C x1}}  BA 1HE AENEem ET%[L11CJAQK$u+$=>>CJ ;D yA~~ BH - - -F 4!8__ # #C ( (1 ,F 1XX22 zz!QU##"T(VD5L1111CJ Jr9cpt||z |z }t|}|jdkr|St|}|dk}||dz k}||z}t ||| ||<t |d|dz z||z ||<||}|jdkr|St|} t |dz tdz} tdD]>} | | z} | d|dz } | || t|| z zz } ?| ||<|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;rLrR) rrrrir r r+rrrrNrs r8r r sOh DMMB " $D T  C x1}}  BA 1HE AENEem ET%[L11CJAQK$u+$=>>CJ ;D yA~~   F 4#:   % %c * *Q .F 1XX66 zz!QU##"T(Zu 5555CJ Jr9N)r!)r)r#r)+numpyrrrrrrr r r r r rrrrrr_splinerr _signaltoolsrrrscipy.interpolater__all__r_splinefunc_cacherrIrNrYr^rdrurrrrrr r9r8rs\FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF )(((((((3333333333%%%%%% I I I5555p/A/A/Ad HHH' ' ' TDD/$/$/$/$d0(0(0(0(fGGGGTIIIIIIr9