!Цi#CSSKJr SSKrSSKJr SSKJr SSKJ r J r J r J r SSKJ r SSKJr SS KJr SS KJrJrJrJr SS KJrJr /S QrS rSr SSjrSSjrSSjrSSjrSrg))NumberN)_have_c99_complex)downcoef)dwt_axis dwt_single idwt_axis idwt_single) dwt_coeff_len) dwt_max_level)upcoef)ModesWavelet _check_dtypewavelist) AxisError _as_wavelet)dwtidwtrr r r padc^[U[5(a URnOp[U[5(a2U[ SS9;a[U5RnO8[ SUS35e[U[ 5(a US-S:Xd [ S5eUS:a [ S 5e[X5$) a" dwt_max_level(data_len, filter_len) Compute the maximum useful level of decomposition. Parameters ---------- data_len : int Input data length. filter_len : int, str or Wavelet The wavelet filter length. Alternatively, the name of a discrete wavelet or a Wavelet object can be specified. Returns ------- max_level : int Maximum level. Notes ----- The rational for the choice of levels is the maximum level where at least one coefficient in the output is uncorrupted by edge effects caused by signal extension. Put another way, decomposition stops when the signal becomes shorter than the FIR filter length for a given wavelet. This corresponds to: .. max_level = floor(log2(data_len/(filter_len - 1))) .. math:: \mathtt{max\_level} = \left\lfloor\log_2\left(\mathtt{ \frac{data\_len}{filter\_len - 1}}\right)\right\rfloor Examples -------- >>> import pywt >>> w = pywt.Wavelet('sym5') >>> pywt.dwt_max_level(data_len=1000, filter_len=w.dec_len) 6 >>> pywt.dwt_max_level(1000, w) 6 >>> pywt.dwt_max_level(1000, 'sym5') 6 discrete)kind'z~', is not a recognized discrete wavelet. A list of supported wavelet names can be obtained via pywt.wavelist(kind='discrete')rrzZfilter_len must be an integer, discrete Wavelet object, or the name of a discrete wavelet.zinvalid wavelet filter length) isinstancerdec_lenstrr ValueErrorr_dwt_max_level)data_len filter_lens H/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/pywt/_dwt.pyr r sX*g&&'' J $ $ z2 2 ,44JJ< 223 3V,,a11D *+ +A~899 ( //c[U[5(a URn[X[R "U55$)a- dwt_coeff_len(data_len, filter_len, mode='symmetric') Returns length of dwt output for given data length, filter length and mode Parameters ---------- data_len : int Data length. filter_len : int Filter length. mode : str, optional Signal extension mode, see :ref:`Modes `. Returns ------- len : int Length of dwt output. Notes ----- For all modes except periodization:: len(cA) == len(cD) == floor((len(data) + wavelet.dec_len - 1) / 2) for periodization mode ("per"):: len(cA) == len(cD) == ceil(len(data) / 2) )rrr_dwt_coeff_lenr from_object)r!r"modes r#r r Ss4>*g&&'' (0A0A$0G HHr$c[(ds[R"U5(aX[R"U5n[ UR XU5upE[ UR XU5upgUSU--USU--4$[U5n[R"XSS9n[R"U5n[U5nUS:aX0R-nSUs=::aUR:d O [S5eURS:Xa<[XU5up[R"X5[R"X5pX4$[XX#S9upX4$)a dwt(data, wavelet, mode='symmetric', axis=-1) Single level Discrete Wavelet Transform. Parameters ---------- data : array_like Input signal wavelet : Wavelet object or name Wavelet to use mode : str, optional Signal extension mode, see :ref:`Modes `. axis: int, optional Axis over which to compute the DWT. If not given, the last axis is used. Returns ------- (cA, cD) : tuple Approximation and detail coefficients. Notes ----- Length of coefficients arrays depends on the selected mode. For all modes except periodization: ``len(cA) == len(cD) == floor((len(data) + wavelet.dec_len - 1) / 2)`` For periodization mode ("per"): ``len(cA) == len(cD) == ceil(len(data) / 2)`` Examples -------- >>> import pywt >>> (cA, cD) = pywt.dwt([1, 2, 3, 4, 5, 6], 'db1') >>> cA array([ 2.12132034, 4.94974747, 7.77817459]) >>> cD array([-0.70710678, -0.70710678, -0.70710678]) ?Cdtypeorderrz!Axis greater than data dimensionsraxis)rnp iscomplexobjasarrayrrealimagrrr'rndimrrr) datawaveletr(r0cA_rcD_rcA_icD_idtcAcDs r#rrxs"X  !6!6zz$G48 G48 r$wr$w// d B ::dC 0D   T "D'"G axii  tyy ;<< yyA~D40B#RZZ%7B 8O$9 8Or$c UcUc [S5e[(d[R"U5(d[R"U5(aUc-[R"U5n[R "U5nO/Uc,[R"U5n[R "U5n[ URURX#U5S[ URURX#U5--$Ub [U5n[R"XSS9nUb [U5n[R"XSS9nUbUbURUR:wawURRS:XdURRS:Xa[RnO[RnURU5nURU5nO3Uc[R "U5nOUc[R "U5nURn[ R""U5n[%U5nUS:aXG-nSUs=::aU:d O ['S5eUS:Xa[)XX#5nU$[+XX#US 9nU$) ah idwt(cA, cD, wavelet, mode='symmetric', axis=-1) Single level Inverse Discrete Wavelet Transform. Parameters ---------- cA : array_like or None Approximation coefficients. If None, will be set to array of zeros with same shape as ``cD``. cD : array_like or None Detail coefficients. If None, will be set to array of zeros with same shape as ``cA``. wavelet : Wavelet object or name Wavelet to use mode : str, optional (default: 'symmetric') Signal extension mode, see :ref:`Modes `. axis: int, optional Axis over which to compute the inverse DWT. If not given, the last axis is used. Returns ------- rec: array_like Single level reconstruction of signal from given coefficients. Examples -------- >>> import pywt >>> (cA, cD) = pywt.dwt([1,2,3,4,5,6], 'db2', 'smooth') >>> pywt.idwt(cA, cD, 'db2', 'smooth') array([ 1., 2., 3., 4., 5., 6.]) One of the neat features of ``idwt`` is that one of the ``cA`` and ``cD`` arguments can be set to None. In that situation the reconstruction will be performed using only the other one. Mathematically speaking, this is equivalent to passing a zero-filled array as one of the arguments. >>> (cA, cD) = pywt.dwt([1,2,3,4,5,6], 'db2', 'smooth') >>> A = pywt.idwt(cA, None, 'db2', 'smooth') >>> D = pywt.idwt(None, cD, 'db2', 'smooth') >>> A + D array([ 1., 2., 3., 4., 5., 6.]) z5At least one coefficient parameter must be specified.r*r+r,crz(Axis greater than coefficient dimensionsrr/)rrr1r2r3 zeros_likerr4r5rr-r complex128float64astyper6rr'rrr r ) r>r?r8r(r0r=r-r6recs r#rrsb zbj&' '  "//""5"59L9L :BBr"B ZBBr"BRWWbggwd;4'>>? @ ~ "  ZZC 0 ~ "  ZZC 0 ~". 88rxx xx}}#rxx}}';  5!B5!B  ]]2   ]]2  77D   T "D'"G ax{  t BCC qy"'0 JD9 Jr$c [(dM[R"U5(a2[XRX#U5S[XR X#U5--$[ U5n[R"XSS9nURS:a [S5eUS;a[SUS35e[R"U5n[U5n[R"[US :HXX455$) a downcoef(part, data, wavelet, mode='symmetric', level=1) Partial Discrete Wavelet Transform data decomposition. Similar to ``pywt.dwt``, but computes only one set of coefficients. Useful when you need only approximation or only details at the given level. Parameters ---------- part : str Coefficients type: * 'a' - approximations reconstruction is performed * 'd' - details reconstruction is performed data : array_like Input signal. wavelet : Wavelet object or name Wavelet to use mode : str, optional Signal extension mode, see :ref:`Modes `. level : int, optional Decomposition level. Default is 1. Returns ------- coeffs : ndarray 1-D array of coefficients. See Also -------- upcoef r*r+r,rzdowncoef only supports 1d data.ad$Argument 1 must be 'a' or 'd', not ''.a)rr1r2rr4r5rr3r6rrr'r _downcoef)partr7r8r(levelr=s r#rr'sH  !6!6yy'?8D))WEBBC D d B ::dC 0D yy1}:;; 4?vRHII   T "D'"G ::i TDH IIr$c [(dM[R"U5(a2[XRX#U5S[XR X#U5--$[ U5n[R"XSS9nURS:a [S5e[U5nUS;a[SUS35e[R"[US :HXX455$) aO upcoef(part, coeffs, wavelet, level=1, take=0) Direct reconstruction from coefficients. Parameters ---------- part : str Coefficients type: * 'a' - approximations reconstruction is performed * 'd' - details reconstruction is performed coeffs : array_like Coefficients array to reconstruct wavelet : Wavelet object or name Wavelet to use level : int, optional Multilevel reconstruction level. Default is 1. take : int, optional Take central part of length equal to 'take' from the result. Default is 0. Returns ------- rec : ndarray 1-D array with reconstructed data from coefficients. See Also -------- downcoef Examples -------- >>> import pywt >>> data = [1,2,3,4,5,6] >>> (cA, cD) = pywt.dwt(data, 'db2', 'smooth') >>> pywt.upcoef('a', cA, 'db2') + pywt.upcoef('d', cD, 'db2') array([-0.25 , -0.4330127 , 1. , 2. , 3. , 4. , 5. , 6. , 1.78589838, -1.03108891]) >>> n = len(data) >>> pywt.upcoef('a', cA, 'db2', take=n) + pywt.upcoef('d', cD, 'db2', take=n) array([ 1., 2., 3., 4., 5., 6.]) r*r+r,rzupcoef only supports 1d coeffs.rHrIrJrK) rr1r2r r4r5rr3r6rr_upcoef)rMcoeffsr8rNtaker=s r#r r ZsX  !8!8t[['$?6$ WTBBC D f B ZZ 4F {{Q:;;'"G 4?vRHII ::gdck6EH IIr$c[R"U5n[R"U5n[R"U5R [R SS9nUR 5S:a [S5e[R"XRS45R5nUS;a[R"XUS9nU$US;aiUS :XaL[UR5Vs/sHnSURUS-4PM nn[R"XS S9n[R"XS S9nU$US :Xa[R"XS SS9nU$US :Xa[R"XS S9nU$US:XaSn[R"XU5nU$US:XaSn[R"XU5nU$US:Xa[R"XSSS9nU$[SUS[R35es snf)uExtend a 1D signal using a given boundary mode. This function operates like :func:`numpy.pad` but supports all signal extension modes that can be used by PyWavelets discrete wavelet transforms. Parameters ---------- x : ndarray The array to pad pad_widths : {sequence, array_like, int} Number of values padded to the edges of each axis. ``((before_1, after_1), … (before_N, after_N))`` unique pad widths for each axis. ``((before, after),)`` yields same before and after pad for each axis. ``(pad,)`` or int is a shortcut for ``before = after = pad width`` for all axes. mode : str, optional Signal extension mode, see :ref:`Modes `. Returns ------- pad : ndarray Padded array of rank equal to array with shape increased according to ``pad_widths``. Notes ----- The performance of padding in dimensions > 1 may be substantially slower for modes ``'smooth'`` and ``'antisymmetric'`` as these modes are not supported efficiently by the underlying :func:`numpy.pad` function. Note that the behavior of the ``'constant'`` mode here follows the PyWavelets convention which is different from NumPy (it is equivalent to ``mode='edge'`` in :func:`numpy.pad`). F)copyrzpad_widths must be > 0r) symmetricreflectr()periodic periodizationrYedgewrapzeroconstant)r(constant_valuessmoothcXSnX@USS-- nU[R"USSS5U--USUS&XS*S- nX`US*S- - nU[R"SUSS-5U--XS*S&U$)Nrrr)r1arange)vector pad_widthiaxiskwargsleft slope_leftright slope_rights r# pad_smoothpad..pad_smoothsA,'D ! q(8!99Jryy1q"5 BB =IaL !aL=1,-E 9Q<-!*;#< "Mr$ antisymmetriccUupEURU- U- n[R"XSUS*USS9USS&UnXF-S- nUn Un Sn XR::aY[US-[ US-U -UR55n U S-(a X|==S-ss'X- nU S- n XR::aMYSn U S:a?[[ SX- 5U 5n U S-(a X|==S-ss'X-n U S- n U S:aM?U$)NrrarUrWrr)sizer1rsliceminmax) rcrdrerfnpad_lnpad_r vsize_nonpadvpr_edgel_edge seg_widthn segment_slices r#pad_antisymmetricpad..pad_antisymmetrics%'NF!;;/&8LvlIbM>B({rs_*3JJ==/EE* #>0B"IJDNeP0Jf7Jtpr$