!Цi|SSKrSSKJr SSKrSSKJr SSKJr SSK J r J r J r SSK Jr SSK Jr SS K Jr SS KJrJr SS KJrJrJr /S QrS rSSjrSSjrSSjrSSjrSSjrSSjr g)N)product)_have_c99_complex) idwt_single)ModesWavelet _check_dtype)swt)swt_axis) swt_max_level)idwt2idwtn) AxisError _as_wavelet_wavelets_per_axis)r r iswtswt2iswt2swtniswtnc [URS-URVs/sHn[R"U5U-PM sn5nUR UlUR UlU$s snf)Nr)rname filter_banknpasarray orthogonal biorthogonal)waveletsffwavs H/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/pywt/_swt.py_rescale_wavelet_filterbankr$sg ',,$/6/B/BC/B!2::a=2%/BC EC''CN++C J Ds#A0 c[(d[R"U5(a[R"U5nXUXTUS.n[ UR 40UD6n[ UR 40UD6n U(d</n [X5H)uupupU RU SU --U SU--45 M+ U $[X5VVs/sHunnUSU--PM n nnU $[U5n[R"UUS9n[U5nU(aJUR(d[R"S5 [US[R "S5- 5nUS:aX@R"-nSUs=::aUR":d O [%S5eUc['UR(U5nUR"S:Xa[+XX#U5nU$[-XX#XE5nU$s snnf) a` Multilevel 1D stationary wavelet transform. Parameters ---------- data : Input signal wavelet : Wavelet to use (Wavelet object or name) level : int, optional The number of decomposition steps to perform. start_level : int, optional The level at which the decomposition will begin (it allows one to skip a given number of transform steps and compute coefficients starting from start_level) (default: 0) axis: int, optional Axis over which to compute the SWT. If not given, the last axis is used. trim_approx : bool, optional If True, approximation coefficients at the final level are retained. norm : bool, optional If True, transform is normalized so that the energy of the coefficients will be equal to the energy of ``data``. In other words, ``np.linalg.norm(data.ravel())`` will equal the norm of the concatenated transform coefficients when ``trim_approx`` is True. Returns ------- coeffs : list List of approximation and details coefficients pairs in order similar to wavedec function:: [(cAn, cDn), ..., (cA2, cD2), (cA1, cD1)] where n equals input parameter ``level``. If ``start_level = m`` is given, then the beginning m steps are skipped:: [(cAm+n, cDm+n), ..., (cAm+1, cDm+1), (cAm, cDm)] If ``trim_approx`` is ``True``, then the output list is exactly as in ``pywt.wavedec``, where the first coefficient in the list is the approximation coefficient at the final level and the rest are the detail coefficients:: [cAn, cDn, ..., cD2, cD1] Notes ----- The implementation here follows the "algorithm a-trous" and requires that the signal length along the transformed axis be a multiple of ``2**level``. If this is not the case, the user should pad up to an appropriate size using a function such as ``numpy.pad``. A primary benefit of this transform in comparison to its decimated counterpart (``pywt.wavedecn``), is that it is shift-invariant. This comes at cost of redundancy in the transform (the size of the output coefficients is larger than the input). When the following three conditions are true: 1. The wavelet is orthogonal 2. ``swt`` is called with ``norm=True`` 3. ``swt`` is called with ``trim_approx=True`` the transform has the following additional properties that may be desirable in applications: 1. energy is conserved 2. variance is partitioned across scales When used with ``norm=True``, this transform is closely related to the multiple-overlap DWT (MODWT) as popularized for time-series analysis, although the underlying implementation is slightly different from the one published in [1]_. Specifically, the implementation used here requires a signal that is a multiple of ``2**level`` in length. References ---------- .. [1] DB Percival and AT Walden. Wavelet Methods for Time Series Analysis. Cambridge University Press, 2000. )rlevel start_level trim_approxaxisnorm?dtypezinorm=True, but the wavelet is not orthogonal: The conditions for energy preservation are not satisfied.rr!Axis greater than data dimensions)rr iscomplexobjrr realimagzipappendr arrayrrwarningswarnr$sqrtndimrr shape_swt _swt_axis)datarr&r'r)r(r*kwargs coeffs_real coeffs_imag coeffs_cplxcA_rcD_rcA_icD_icrcidtrets r#r r sl  !6!6zz$$[%0N$)).v. $)).v. K.1+.K* lt""D2d7ND2d7N#CD/L ,/{+HJ+HxB2:+H J d B 88D #D'"G !! MMN O.gq|D axii  tyy ;<< }djj./ yyA~4%kB Ju4M J9JsGc[US[[45(+nU(aUSOUSSnURS:aHU(aU/USSVs/sHnSU0PM sn-nOUVVs/sH upXS.PM nnn[ XqU4US9$US:waUS:wa [ S5e[ (d[R"U5(aU(a7UV s/sHoRPM n n UV s/sHoRPM n n OXUV V s/sHupU RU R4PM n n n UV V s/sHupU RU R4PM n n n XS .n[U 40UD6nUS [U 40UD6--$U(aUSSnURS:wa [S 5e[U5n[R"UUS S 9n[U5n[!U5nU(a [#U[R$"S55n[&R("S5n[+USS5GHyn[-[/SUS- 55nUnU(aUU*nO UU*unn[R0"U[U5S9nUR2UR2:waUR2R4S:XdUR2R4S:Xa[R6nO[R8n[R0"UUS9n[R0"UUS9n[+U5H~n[R:"U[U5U5nUSSS2nUSSS2n[=UUUUUU5n[=UUUUUU5n[R>"US5nUU-S- UU'M GM| U$s snfs snnfs sn fs sn fs sn n fs sn n f)a Multilevel 1D inverse discrete stationary wavelet transform. Parameters ---------- coeffs : array_like Coefficients list of tuples:: [(cAn, cDn), ..., (cA2, cD2), (cA1, cD1)] where cA is approximation, cD is details. Index 1 corresponds to ``start_level`` from ``pywt.swt``. wavelet : Wavelet object or name string Wavelet to use norm : bool, optional Controls the normalization used by the inverse transform. This must be set equal to the value that was used by ``pywt.swt`` to preserve the energy of a round-trip transform. Returns ------- 1D array of reconstructed data. Examples -------- >>> import pywt >>> coeffs = pywt.swt([1,2,3,4,5,6,7,8], 'db2', level=2) >>> pywt.iswt(coeffs, 'db2') array([ 1., 2., 3., 4., 5., 6., 7., 8.]) rrNd)arKaxesr*r/rr*r+ziswt only supports 1D dataTr-copyr. periodizationr,cg@) isinstancetuplelistr9rrrrr0r1r2r ValueErrorr r5lenrr$r8r from_objectrangeintpowrr-kind complex128float64arangerroll) coeffsrr*r)r(cArK coeffs_ndrLrTr?r@cacdr>yrHoutput num_levelsmodej step_size last_indexcD_r-firstindices even_indices odd_indicesx1x2s r#rrsjB!UDM::K!vay|B ww{ &*=*Qa*==I6<=fdaq)fI=YtgDAA trz;<<  !4!4 +126a666K2+126a666K2K= 32CCs$N(,N-N3.N8 $N=7$Oc F[U5n[R"U5n[U5S:wa [ S5e[U5[[ U55:wa [ S5eUR [[R"U55:a [ S5e[XX#XEU5n/nU(aURUS5 USSnUHKn U(aURU SU S U S 45 M)URU S U SU S U S 445 MM U$) a Multilevel 2D stationary wavelet transform. Parameters ---------- data : array_like 2D array with input data wavelet : Wavelet object or name string, or 2-tuple of wavelets Wavelet to use. This can also be a tuple of wavelets to apply per axis in ``axes``. level : int The number of decomposition steps to perform. start_level : int, optional The level at which the decomposition will start (default: 0) axes : 2-tuple of ints, optional Axes over which to compute the SWT. Repeated elements are not allowed. trim_approx : bool, optional If True, approximation coefficients at the final level are retained. norm : bool, optional If True, transform is normalized so that the energy of the coefficients will be equal to the energy of ``data``. In other words, ``np.linalg.norm(data.ravel())`` will equal the norm of the concatenated transform coefficients when ``trim_approx`` is True. Returns ------- coeffs : list Approximation and details coefficients (for ``start_level = m``). If ``trim_approx`` is ``False``, approximation coefficients are retained for all levels:: [ (cA_m+level, (cH_m+level, cV_m+level, cD_m+level) ), ..., (cA_m+1, (cH_m+1, cV_m+1, cD_m+1) ), (cA_m, (cH_m, cV_m, cD_m) ) ] where cA is approximation, cH is horizontal details, cV is vertical details, cD is diagonal details and m is ``start_level``. If ``trim_approx`` is ``True``, approximation coefficients are only retained at the final level of decomposition. This matches the format used by ``pywt.wavedec2``:: [ cA_m+level, (cH_m+level, cV_m+level, cD_m+level), ..., (cH_m+1, cV_m+1, cD_m+1), (cH_m, cV_m, cD_m), ] Notes ----- The implementation here follows the "algorithm a-trous" and requires that the signal length along the transformed axes be a multiple of ``2**level``. If this is not the case, the user should pad up to an appropriate size using a function such as ``numpy.pad``. A primary benefit of this transform in comparison to its decimated counterpart (``pywt.wavedecn``), is that it is shift-invariant. This comes at cost of redundancy in the transform (the size of the output coefficients is larger than the input). When the following three conditions are true: 1. The wavelet is orthogonal 2. ``swt2`` is called with ``norm=True`` 3. ``swt2`` is called with ``trim_approx=True`` the transform has the following additional properties that may be desirable in applications: 1. energy is conserved 2. variance is partitioned across scales r.zExpected 2 axesz'The axes passed to swt2 must be unique.z8Input array has fewer dimensions than the specified axesrrNdaadddaa) rVrrrYrXsetr9uniquerr4) r=rr&r'rNr(r*coefsrIrTs r#rrsl ;D ::d D 4yA~*++ 4yCD N"BCC yy3ryy'' ! ! Dt LE C 58ab    JJ$4!D'2 3 JJ$!D'1T7AdG!<= >  Jc N [US[[45(+nU(aUSOUSSnURS:wdUS:waWU(a%U/USSVVVs/sH upgnXgUS.PM snnn-n O!UV VVVs/sHun upgnXXxS.PM n nnn n[ XX2S9$[ (Gdt[ R"U5(GaXU(aUR/n XSSVVVs/sH(upgoRURUR4PM* snnn- n UR/n XSSVVVs/sH(upgoRURUR4PM* snnn- n OUV VVVs/sH8un upgnU RURURUR44PM: n nnn nUV VVVs/sH8un upgnU RURURUR44PM: n nnn nXS .n [U 40U D6nUS [U 40U D6--$U(aUSSn[U5n[ R"X_S S 9nURS:wa [S 5e[U5n[USS9nU(a0UVs/sH#n[!U[ R""S55PM% nn[%U5GHn['[)SUU- S- 55nUnU(a UUunnnO UUununnnUR*UR*:wdUR*UR*:wa [-S5e[ R."U/UUU4Vs/sHn[U5PM sn-6nUR0U:waUR3U5n[%U5GHn[%U5GHn[5UUR*SU5n[5UUR*SU5n [5UUR*SSU-5n![5UUR*SSU-5n"[5UU-UR*SSU-5n#[5UU-UR*SSU-5n$[7UU!U"4UU!U"4UU!U"4UU!U"444US5n%[7UU!U$4UU!U$4UU!U$4UU!U$444US5n&[7UU#U"4UU#U"4UU#U"4UU#U"444US5n'[7UU#U$4UU#U$4UU#U$4UU#U$444US5n([ R8"U&SSS9n&[ R8"U'SSS9n'[ R8"U(SSS9n([ R8"U(SSS9n(U%U&-U'-U(-S- UUU 4'GM GM GM U$s snnnfs snnnn fs snnnfs snnnfs snnnn fs snnnn fs snfs snf)a5 Multilevel 2D inverse discrete stationary wavelet transform. Parameters ---------- coeffs : list Approximation and details coefficients:: [ (cA_n, (cH_n, cV_n, cD_n) ), ..., (cA_2, (cH_2, cV_2, cD_2) ), (cA_1, (cH_1, cV_1, cD_1) ) ] where cA is approximation, cH is horizontal details, cV is vertical details, cD is diagonal details and n is the number of levels. Index 1 corresponds to ``start_level`` from ``pywt.swt2``. wavelet : Wavelet object or name string, or 2-tuple of wavelets Wavelet to use. This can also be a 2-tuple of wavelets to apply per axis. norm : bool, optional Controls the normalization used by the inverse transform. This must be set equal to the value that was used by ``pywt.swt2`` to preserve the energy of a round-trip transform. Returns ------- 2D array of reconstructed data. Examples -------- >>> import pywt >>> coeffs = pywt.swt2([[1,2,3,4],[5,6,7,8], ... [9,10,11,12],[13,14,15,16]], ... 'db1', level=2) >>> pywt.iswt2(coeffs, 'db1') array([[ 1., 2., 3., 4.], [ 5., 6., 7., 8.], [ 9., 10., 11., 12.], [ 13., 14., 15., 16.]]) rr.rOrN)rxryrz)r{rxryrzrMrPr+TrQzKiswt2 only supports 2D arrays. see iswtn for a general n-dimensionsal ISWTrrrN4Mismatch in shape of intermediate coefficient arraysrSr))rUrVrWr9rrrr0r1r2rr r5rXrYrr$r8r[r\r]r: RuntimeError result_typer-astypeslicer rb))rcrr*rNr(rdhvrKrerLr?r@r>rhrHrirjwaveletsr"rlrmrncHcVrorprT common_dtypefirst_hfirst_w indices_h indices_w even_idx_h even_idx_w odd_idx_h odd_idx_wrurvx3x4s) r#rr}sh!UDM::K!vay|B ww!|tx' /5abz ;/9GA!() ;/9 ;;I.45-3\Q q!"!=-3 5Yd>>  !4!4 77)K 12JOJqVVQVVQVV4JO OK77)K 12JOJqVVQVVQVV4JO OK17806 9A!FFQVVQVVQVV$<=06 817806 9A!FFQVVQVVQVV$<=06 8$3 + ( (2k4V4444 b B XXb .F {{a "# #VJ!'7H ')'0RWWQZ@' ): Az!|A~./  !!9LRR$QiOA|B HH bhh"((&:FH H ~~ FB|<|!l1o|< <? <<< ']]<0FZ(G ,!'288A; B !'288A; B "7BHHQK9E "7BHHQK9E !'I"5rxx{AiKP !'I"5rxx{AiKP F:z#9:z:56z:56z:5689$_ 6 F:y#89z945z945z94578$_ 6 F9j#89y*45y*45y*4578$_ 6 F9i#78y)34y)34y)3467$_ 6WWR+WWR+WWR+WWR+02R" r0AQ/Fy)+,M-)'x MG ;5 PO88*)$=s0U0 <U7 %/U? 1/V /?V :?V *VV" c v^[R"T5m[(d[R"T5(aXUXTUS.n[ TR 40UD6n[ TR 40UD6n U(aUSSU S--/n Sn O/n Sn [XSXS5H1upU RU Vs0sHoXSX--_M sn5 M3 U $TR[R"S5:Xa [S5eTRS:a [S5eUc[TR5nUVs/sHoS:aUTR-OUPM nn[U4S jU55(a [S 5e[!U5[![#U55:wa [S 5e[!U5n[%X5nU(a[R&"UVs/sHnUR(PM sn5(d[*R,"S 5 UVs/sH&n[/US[R0"S 5- 5PM( nn/n[X3U-5HnST4/n[UU5HFunn/nUH6unn[3UUSUUS9SunnUR5US-U4US-U4/5 M8 UnMH [7U5nURU5 USU-mU(dMUR9SU-5 M U(aURT5 UR;5 U$s snfs snfs snfs snf)aY n-dimensional stationary wavelet transform. Parameters ---------- data : array_like n-dimensional array with input data. wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple of wavelets to apply per axis in ``axes``. level : int The number of decomposition steps to perform. start_level : int, optional The level at which the decomposition will start (default: 0) axes : sequence of ints, optional Axes over which to compute the SWT. A value of ``None`` (the default) selects all axes. Axes may not be repeated. trim_approx : bool, optional If True, approximation coefficients at the final level are retained. norm : bool, optional If True, transform is normalized so that the energy of the coefficients will be equal to the energy of ``data``. In other words, ``np.linalg.norm(data.ravel())`` will equal the norm of the concatenated transform coefficients when ``trim_approx`` is True. Returns ------- [{coeffs_level_n}, ..., {coeffs_level_1}]: list of dict Results for each level are arranged in a dictionary, where the key specifies the transform type on each dimension and value is a n-dimensional coefficients array. For example, for a 2D case the result at a given level will look something like this:: {'aa': # A(LL) - approx. on 1st dim, approx. on 2nd dim 'ad': # V(LH) - approx. on 1st dim, det. on 2nd dim 'da': # H(HL) - det. on 1st dim, approx. on 2nd dim 'dd': # D(HH) - det. on 1st dim, det. on 2nd dim } For user-specified ``axes``, the order of the characters in the dictionary keys map to the specified ``axes``. If ``trim_approx`` is ``True``, the first element of the list contains the array of approximation coefficients from the final level of decomposition, while the remaining coefficient dictionaries contain only detail coefficients. This matches the behavior of `pywt.wavedecn`. Notes ----- The implementation here follows the "algorithm a-trous" and requires that the signal length along the transformed axes be a multiple of ``2**level``. If this is not the case, the user should pad up to an appropriate size using a function such as ``numpy.pad``. A primary benefit of this transform in comparison to its decimated counterpart (``pywt.wavedecn``), is that it is shift-invariant. This comes at cost of redundancy in the transform (the size of the output coefficients is larger than the input). When the following three conditions are true: 1. The wavelet is orthogonal 2. ``swtn`` is called with ``norm=True`` 3. ``swtn`` is called with ``trim_approx=True`` the transform has the following additional properties that may be desirable in applications: 1. energy is conserved 2. variance is partitioned across scales )rr&r'r(rNr*rr+rNobjectz"Input must be a numeric array-likezInput data must be at least 1Dc3X># UHoS:=(d UTR:v M! g7f)rN)r9).0rLr=s r# swtn..s# 1Dqq5 "AN "Ds'*r/'The axes passed to swtn must be unique.zpnorm=True, but the wavelets used are not orthogonal: The conditions for energy preservation are not satisfied.r.)r&r'r)rLrK)rrrr0rr1r2r3r4r- TypeErrorr9rXr[anyrrYr|rallrr6r7r$r8r<extenddictpopreverse)r=rr&r'rNr(r*r>r1r2cplxoffsetrdictidictkrLnum_axesrr"rIircr) new_coeffssubbandxrdros` r#rrsX ::d D  !6!6$[%0NDII((DII(( Gb47l*+DFDFW tG}=LE KK6;>  zzRXXh''<== yy1}9:: |TYY37 84aUA M )4D 8 1D 111;<< 4yCD N"BCC4yH!'0H vv:#s~~:;; MMN O ()'0Qrwwqz\B' ) C ;e 3 4t* x0MD'J$ "1gQA(,../1B!!GcM2#6$+cM2#6#89%  F1f 6cHn% ; JJsX~ &#5$ 4KKM J_= 9;)s2L' ; L,L1-L6c  [SUS55n[US[5(+nU(aUSO USSU-n[(d[R "U5(aU(a&USR /nUSR/nUSSnO/n/nXpV V V s/sH1oR5V V s0sHupXR _M sn n PM3 sn n n - nXV V V s/sH1oR5V V s0sHupXR_M sn n PM3 sn n n - nXUS.n [U40U D6n U S[U40U D6--$U(aUSSn[U5n[R"XnS S 9nURnUc[UR5nUVs/sHnUS:aUU-OUPM nn[U5[[U55:wa [!S 5eU[U5:wa [!S 5e[U5n[#X5nU(a0UVs/sH#n[%U[R&"S 55PM% nn[)S5/U-n[)S5/U-n[)S5/U-n[)S5/U-n[U5GHn[+[-S UU- S- 55nUnU(dUUR/SU-5nUUn[R0"U/UR35V s/sHoR4PM sn -6nUR4U:waUR7U5nUR5V V s/sHupU R8PM nn n [[U55S:wa [;S5e[=UVs/sH nUSUPM sn5n [?[U5/U-6GHjn![AU!U U5H@un"n#n[)U"U#U5UU'[)U"U#S U-5UU'[)U"U-U#S U-5UU'MB URC5n$SU[=U5'Sn%[?S/U-6Hn&[AU&U5Hun'nU'(a UUUU'MUUUU'M! 0n(UR5Hun)n*U*[=U5U(U)'M U$[=U5U(SU-'[EU(USUS9n+[AU&U5H%un'nU'(dM[RF"U+SUS9n+M' U[=U5==U+- ss'U%S- n%M U[=U5==U%-ss'GMm U(aGMWUUSU-'GM U$s sn n fs sn n n fs sn n fs sn n n fs snfs snfs sn fs sn n fs snf)aW Multilevel nD inverse discrete stationary wavelet transform. Parameters ---------- coeffs : list [{coeffs_level_n}, ..., {coeffs_level_1}]: list of dict wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple of wavelets to apply per axis in ``axes``. axes : sequence of ints, optional Axes over which to compute the inverse SWT. Axes may not be repeated. The default is ``None``, which means transform all axes (``axes = range(data.ndim)``). norm : bool, optional Controls the normalization used by the inverse transform. This must be set equal to the value that was used by ``pywt.swtn`` to preserve the energy of a round-trip transform. Returns ------- nD array of reconstructed data. Examples -------- >>> import pywt >>> coeffs = pywt.swtn([[1,2,3,4],[5,6,7,8], ... [9,10,11,12],[13,14,15,16]], ... 'db1', level=2) >>> pywt.iswtn(coeffs, 'db1') array([[ 1., 2., 3., 4.], [ 5., 6., 7., 8.], [ 9., 10., 11., 12.], [ 13., 14., 15., 16.]]) c38# UHn[U5v M g7f)N)rY)rkeys r#riswtn..s8ZcSZsrOrrLrN)rrNr*r+TrQrzYThe number of axes used in iswtn must match the number of dimensions transformed in swtn.r.rrrSrr)$maxrUrrrr0r1r2itemsrr r5r9r[rYr|rXrr$r8rr\r]rrvaluesr-rr:rrVrr3rRrrb),rcrrNr*ndim_transformr(rdr?r@rTrrr>rhrHrir9rLrjrr"rrrsrtodd_even_slicesrlrmrndetailsrshapesaxcoeff_trans_shapefirstsrqshapprox ntransformsoddso details_slicervaluers, r#rrsYN8VBZ88N D11K!vay^1C'DB  !4!4 !!9>>*K!!9>>*KABZFKK6J6awwy9ytqFFy96JJ 6J6awwy9ytqFFy96JJ $DA + ( (2k4V4444 b B XXb .F ;;D |V[[!.2 3dAAH1 $dD 3 4yCD N"BCCT"EF FVJ!'0H ')'0RWWQZ@' ) T{od"G$K?4'L;/$&KT{od*O : Az!|A~./  q c.01A)~~ Fw~~'78'7!gg'78 8; <<< ']]<0F'.mmo6oda!''o6 s6{ q FH H"4"@4R6!9R=4"@Az!2 5n DFF!$V->!E r2#E2y9 #(AiK#@ R "'iQy["I B"F [[]F%&F5> "K6*^";= t_EAr.9"o+.:2.>+ - !# ")--/JC).u_/E)FM#&#24:/*5, c.01 -?N t_EArqGGAqr2-uW~&!+&q +>, 5> "k 1 "AGB{,-F1Ic.( )qr M}:J9J 4)$9 7 #AsN"U :UU 'U ?UU U!*U&8U+ U0U6 U U )NrrOFF)FrO)rrFF)Fr)rNFF)NF)!r6 itertoolsrnumpyr _c99_configr_extensions._dwtr_extensions._pywtrrr _extensions._swtr r;r r<r _multidimr r_utilsrrr__all__r$rrrrrrr#rsy*);;)3+#>> L8: %}@qh4