!ЦivSrSSKrSSKrSSKJr SSKJr SSKrSSKJ r J r J r SSK J r SSKJrJr SS KJrJrJrJrJr SS KJrJrJrJr /S QrS rS%S jrS&SjrS'Sjr S(Sjr!Sr"S)Sjr#Sr$S*Sjr%Sr&Sr'Sr(Sr)S+Sjr*S,Sjr+S)Sjr,Sr-S-Sjr.S-Sjr/S,Sjr0S r1"S!S"5r2S)S#jr3S$r4g).zY Multilevel 1D and 2D Discrete Wavelet Transform and Inverse Discrete Wavelet Transform. N)copy)product)dwt dwt_coeff_lenidwt) dwt_max_level)ModesWavelet) _fix_coeffsdwt2dwtnidwt2idwtn) AxisError _as_wavelet_modes_per_axis_wavelets_per_axis)wavedecwaverecwavedec2waverec2wavedecnwaverecncoeffs_to_arrayarray_to_coeffs ravel_coeffsunravel_coeffsdwtn_max_level wavedecn_sizewavedecn_shapes fswavedecn fswaverecnFswavedecnResultc x[R"U5(aU4n[R"U5(aU4n[R"[X5VVs/sHup4[ X45PM snn5nUcUnU$US:a[ SU-5eX%:a[ R"SUS35 U$s snnf)Nrz2Level value of %d is too low . Minimum level is 0.zLevel value of z@ is too high: all coefficients will experience boundary effects.)npisscalarminzipr ValueErrorwarningswarn)sizesdec_lenslevelsd max_levels O/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/pywt/_multilevel.py _check_levelr4s {{5  {{8<E8LM8L a+8LMNI } L  @5 HJ J   eW%! ! " LNsB6 cr[R"U5n[U5nURUn[ XQRU5n/nUn[U5H"n[XqX$5upyURU 5 M$ URU5 UR5 U$![a [ S5ef=f)a9 Multilevel 1D Discrete Wavelet Transform of data. Parameters ---------- data: array_like Input data wavelet : Wavelet object or name string Wavelet to use mode : str, optional Signal extension mode, see :ref:`Modes `. level : int, optional Decomposition level (must be >= 0). If level is None (default) then it will be calculated using the ``dwt_max_level`` function. axis: int, optional Axis over which to compute the DWT. If not given, the last axis is used. Returns ------- [cA_n, cD_n, cD_n-1, ..., cD2, cD1] : list Ordered list of coefficients arrays where ``n`` denotes the level of decomposition. The first element (``cA_n``) of the result is approximation coefficients array and the following elements (``cD_n`` - ``cD_1``) are details coefficients arrays. Examples -------- >>> from pywt import wavedec >>> coeffs = wavedec([1,2,3,4,5,6,7,8], 'db1', level=2) >>> cA2, cD2, cD1 = coeffs >>> cD1 array([-0.70710678, -0.70710678, -0.70710678, -0.70710678]) >>> cD2 array([-2., -2.]) >>> cA2 array([ 5., 13.]) !Axis greater than data dimensions) r&asarrayrshape IndexErrorrr4dec_lenrangerappendreverse) datawaveletmoder/axis axes_shape coeffs_listair1s r3rr1sR ::d D'"G=ZZ%  __e `. axis: int, optional Axis over which to compute the inverse DWT. If not given, the last axis is used. Notes ----- It may sometimes be desired to run ``waverec`` with some sets of coefficients omitted. This can best be done by setting the corresponding arrays to zero arrays of matching shape and dtype. Explicitly removing list entries or setting them to None is not supported. Specifically, to ignore detail coefficients at level 2, one could do:: coeffs[-2] = np.zeros_like(coeffs[-2]) Examples -------- >>> import pywt >>> coeffs = pywt.wavedec([1,2,3,4,5,6,7,8], 'db1', level=2) >>> pywt.waverec(coeffs, 'db1') array([ 1., 2., 3., 4., 5., 6., 7., 8.]) (Expected sequence of coefficient arrays.rz7Coefficient list too short (minimum 1 arrays required).rN$Unexpected detail coefficient type: z. Detail coefficients must be arrays as returned by wavedec. If you are using pywt.array_to_coeffs or pywt.unravel_coeffs, please specify output_format='wavedec'c38# UHn[U5v M g7fNslice.0r0s r3 waverec..s:'Qa'zcoefficient shape mismatchz(Axis greater than coefficient dimensions) isinstancelisttupler*lenr&ndarraytyper8r9rr)coeffsr?r@rArDdsr1s r3rrpsNF ftUm , ,CDD 6{Q EG G V ay 1Ivabzr  =Arzz!:!:6tAwi@**+ + M  L774=AGGDMA$55%:!''::;AWWT]aggdm3$%ABB4 wd +" H  L JKK Ls$AD&'+D&&D<c[R"U5nURS:a [S5e[ U5n[ U5S:wa [S5e[ U5[ [ U55:wa [S5eUVs/sHoPRUPM nn[X5nUVs/sHoRPM n n[XiU5n/n Un [U5H"n [XX$5upU RU 5 M$ U RU 5 U R!5 U $s snf![a [S5ef=fs snf)a Multilevel 2D Discrete Wavelet Transform. Parameters ---------- data : ndarray 2D input data wavelet : Wavelet object or name string, or 2-tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. mode : str or 2-tuple of str, optional Signal extension mode, see :ref:`Modes `. This can also be a tuple containing a mode to apply along each axis in ``axes``. level : int, optional Decomposition level (must be >= 0). If level is None (default) then it will be calculated using the ``dwt_max_level`` function. axes : 2-tuple of ints, optional Axes over which to compute the DWT. Repeated elements are not allowed. Returns ------- [cAn, (cHn, cVn, cDn), ... (cH1, cV1, cD1)] : list Coefficients list. For user-specified ``axes``, ``cH*`` corresponds to ``axes[0]`` while ``cV*`` corresponds to ``axes[1]``. The first element returned is the approximation coefficients for the nth level of decomposition. Remaining elements are tuples of detail coefficients in descending order of decomposition level. (i.e. ``cH1`` are the horizontal detail coefficients at the first level) Examples -------- >>> import pywt >>> import numpy as np >>> coeffs = pywt.wavedec2(np.ones((4,4)), 'db1') >>> # Levels: >>> len(coeffs)-1 2 >>> pywt.waverec2(coeffs, 'db1') array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]) z2Expected input data to have at least 2 dimensions.zExpected 2 axesz+The axes passed to wavedec2 must be unique.r6)r&r7ndimr*rTrUsetr8r9rrr:r4r;r r<r=)r>r?r@r/axesax axes_sizeswaveletsw dec_lengthsrCrDrErYs r3rrs1Z ::d D yy1}MNN ;D 4yA~*++ 4yCD N"FGG=/34tjjnt 4"'0H&./h99hK/ % 8EK A 5\Q,2q '5 =;<<=0s$D1D, D11E ,D11Ec.^ [U[[45(d [S5e[ U5[ [ U55:wa [S5e[ U5S:a [S5e[ U5S:XaUS$USUSSpT[ R"U5nUHn[U[[45(a[ U5S:wa[S[U5S 35e[S U55nS U5n[U5m [U 4S jU55(d [S 5e[S[URT 555n[XHU4XU5nM U$![a [S5[S54nN9f=f)a_ Multilevel 2D Inverse Discrete Wavelet Transform. coeffs : list or tuple Coefficients list [cAn, (cHn, cVn, cDn), ... (cH1, cV1, cD1)] wavelet : Wavelet object or name string, or 2-tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. mode : str or 2-tuple of str, optional Signal extension mode, see :ref:`Modes `. This can also be a tuple containing a mode to apply along each axis in ``axes``. axes : 2-tuple of ints, optional Axes over which to compute the IDWT. Repeated elements are not allowed. Returns ------- 2D array of reconstructed data. Notes ----- It may sometimes be desired to run ``waverec2`` with some sets of coefficients omitted. This can best be done by setting the corresponding arrays to zero arrays of matching shape and dtype. Explicitly removing list or tuple entries or setting them to None is not supported. Specifically, to ignore all detail coefficients at level 2, one could do:: coeffs[-2] == tuple([np.zeros_like(v) for v in coeffs[-2]]) Examples -------- >>> import pywt >>> import numpy as np >>> coeffs = pywt.wavedec2(np.ones((4,4)), 'db1') >>> # Levels: >>> len(coeffs)-1 2 >>> pywt.waverec2(coeffs, 'db1') array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]) rGz+The axes passed to waverec2 must be unique.r6Coefficient list too short (minimum 1 array required).rNrHz. Detail coefficients must be a 3-tuple of arrays as returned by wavedec2. If you are using pywt.array_to_coeffs or pywt.unravel_coeffs, please specify output_format='wavedec2'c3X# UH nUb[R"U5OSv M" g7frJ)r&r7rNcoeffs r3rOwaverec2..Cs*" e(-'8"**U#dB s(*c3B# UHocMURv M g7frJ)r8rhs r3rOrjEsDQEKEKKQsc3,># UH oT:Hv M g7frJ)rNr0d_shapes r3rOrjKs6XG|Xsz*All detail shapes must be the same length.c3R# UHup[SXS-:XaSOS5v M g7f)NrrK)rNa_lend_lens r3rOrjMs/D-B\Ut5AI+=R4HH-Bs%')rRrSrTr*rUr]r&r7rWnextallr)r8 StopIterationrLr) rXr?r@r^rDrYr1d_shapesidxsrns @r3rrsX ftUm , ,CDD 4yCD N"FGG 6{Q DF F V ay 1Ivabzr 1 A !dE]++s1v{6tAwi@::; ; " " "DQD D8nG6X666 !MNND-0'-BDDD 17A,t 4'* H ,;d +D ,s E11 FFc[U5S:a [S5e[U5n[R"U5(aU4nUc [ U5nO [ U5n[U5[[ U55:wa [S5eUVs/sHo0UPM nn[U5nXU4$s snf![a [S5ef=f)Nrz Expected at least 1D input data.z+The axes passed to wavedecn must be unique.r6) rUr*r&r'r;rTr]r9r)r8r^r\r_ axes_shapesndim_transforms r3_prep_axes_wavedecnr{Ts 5zA~;<< u:D {{4x |T{T{ 4yCD N"FGG=+/04RRy4 0YN n ,, 1 =;<<=s B3B.B3.B33C c[R"U5n[URU5upEn[ X5nUVs/sHoR PM n n[ XYU5n/n Un [U5H4n [XX$5n U RSU-5n U RU 5 M6 U RU 5 U R5 U $s snf)a8 Multilevel nD Discrete Wavelet Transform. Parameters ---------- data : ndarray nD input data wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. mode : str or tuple of str, optional Signal extension mode, see :ref:`Modes `. This can also be a tuple containing a mode to apply along each axis in ``axes``. level : int, optional Decomposition level (must be >= 0). If level is None (default) then it will be calculated using the ``dwt_max_level`` function. axes : sequence of ints, optional Axes over which to compute the DWT. Axes may not be repeated. The default is None, which means transform all axes (``axes = range(data.ndim)``). Returns ------- [cAn, {details_level_n}, ... {details_level_1}] : list Coefficients list. Coefficients are listed in descending order of decomposition level. ``cAn`` are the approximation coefficients at level ``n``. Each ``details_level_i`` element is a dictionary containing detail coefficients at level ``i`` of the decomposition. As a concrete example, a 3D decomposition would have the following set of keys in each ``details_level_i`` dictionary:: {'aad', 'ada', 'daa', 'add', 'dad', 'dda', 'ddd'} where the order of the characters in each key map to the specified ``axes``. Examples -------- >>> import numpy as np >>> from pywt import wavedecn, waverecn >>> coeffs = wavedecn(np.ones((4, 4, 4)), 'db1') >>> # Levels: >>> len(coeffs)-1 2 >>> waverecn(coeffs, 'db1') array([[[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]]) rD) r&r7r{r8rr:r4r;rpopr<r=)r>r?r@r/r^ryrzrarbrcrCrDrErXs r3rrhs@ ::d D(;DJJ(M%D~!'0H&./h99hK/ 5 9EK A 5\a$- JJs^+ ,6" q 0sC cRUcgU(dU$U[[U55n[R"URUR5n[R "US:US:-5(a[ U5 [S5eU[SUR55$)Nrrz$incompatible coefficient array sizesc38# UHn[U5v M g7frJrKrMs r3rO$_match_coeff_dims..s9=aq=rQ) rsiterr&subtractr8anyprintr*rT)a_coeff d_coeff_dictd_coeff size_diffss r3_match_coeff_dimsrs 4\ 234GW]]GMM:J vvzA~*q.122 j?@@ 597==99 ::c[U5S:a [S5eUSUSSpT[U5S:a2[SU55(d[S[US5S35e[ [ [ U55nU(dUS$Uc[U5(d [S5e/nUb1[R"U5nURUR5 UH4nXgR5VV s/sHupU RPM sn n- nM6 [R"U5n [U 5S:XaU Sn O [S 5e[R"U5(aU4nUc [U 5nO [!U5n[U5[[#U55:wa [S 5e[U5n [%U5H5upUc U(dMU S:a ['XG5nXGS U -'[)XqX#5nM7 U$s sn nf) a Multilevel nD Inverse Discrete Wavelet Transform. coeffs : array_like Coefficients list [cAn, {details_level_n}, ... {details_level_1}] wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. mode : str or tuple of str, optional Signal extension mode, see :ref:`Modes `. This can also be a tuple containing a mode to apply along each axis in ``axes``. axes : sequence of ints, optional Axes over which to compute the IDWT. Axes may not be repeated. Returns ------- nD array of reconstructed data. Notes ----- It may sometimes be desired to run ``waverecn`` with some sets of coefficients omitted. This can best be done by setting the corresponding arrays to zero arrays of matching shape and dtype. Explicitly removing list or dictionary entries or setting them to None is not supported. Specifically, to ignore all detail coefficients at level 2, one could do:: coeffs[-2] = {k: np.zeros_like(v) for k, v in coeffs[-2].items()} Examples -------- >>> import numpy as np >>> from pywt import wavedecn, waverecn >>> coeffs = wavedecn(np.ones((4, 4, 4)), 'db1') >>> # Levels: >>> len(coeffs)-1 2 >>> waverecn(coeffs, 'db1') array([[[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]]]) rrerNc3B# UHn[U[5v M g7frJ)rRdict)rNr1s r3rOwaverecn.. s?Bqz!T22BrHz. Detail coefficients must be a dictionary of arrays as returned by wavedecn. If you are using pywt.array_to_coeffs or pywt.unravel_coeffs, please specify output_format='wavedecn'z4At least one coefficient must contain a valid value.z:All coefficients must have a matching number of dimensionsz+The axes passed to waverecn must be unique.rD)rUr*rtrWrSmapr rr&r7r<r\itemsuniquer'r;rTr] enumeraterr)rXr?r@r^rDrY coeff_ndimsr1kvunique_coeff_ndimsr\rzidxs r3rrsr 6{Q DF F 1Ivabzr 2w{3?B???241;-@6 67 7 c+r" #B ayyR BD DK} JJqM166" 7795941955 ;/ !#!!$ HJ J {{4x |T{T{ 4yCD N"FGGYNB- 9Q  7!!'A"##  !d )  H?6s6H c[U5S:XaU$[U5n[S[U55H/nXcM XRS:wa [ S5eSX0X'M1 U$)z4Convert wavedec coefficients to the wavedecn format.rrzexpected a 1D coefficient arrayr1)rUrr;r\r*)rXns r3_coeffs_wavedec_to_wavedecnrEsk 6{a &\F 1c&k " 9   9>>Q >? ?&)$ # Mrc,[U5S:XaU$[U5n[S[U55H^n[X[[ 45(a[X5S:wa [ S5eXup#nUbUbUc [ S5eX2US.X'M` U$)z5Convert wavedec2 coefficients to the wavedecn format.rrrfz)expected a 3-tuple of detail coefficientsz\Expected numpy arrays of detail coefficients. Setting coefficients to None is not supported.)addadd)rUrr;rRrTrSr*)rXrrrrs r3_coeffs_wavedec2_to_wavedecnrSs 6{a &\F 1c&k "&)eT]33s69~7JHI Iy  :rz9: :r2 # Mrc [R"USR5n[R"U5n[U5nUSRnUSSH]nX!==[R"USU-R5U- ss'UR 5HupgXGR- nM M_ [ UR55n[R"U5U:HnX(4$)Nrrr1) r&r7r8rUsizerrTtolistprod) rXr^ arr_shaperzncoeffsr1rris_tight_packings r3_determine_coeff_array_shaperds 6!9??+I ::d DYNQinnG ABZ2::aN(:&;&A&AB4HHGGIDA vv Gi&&()I *g5  &&rc[U[5(a[U5S:Xa [S5eUSc [S5e[US[R 5(d [S5eUSR n[U5S:a|[US[5(aOc[US[R 5(a [U5nO5[US[[45(a [U5nO [S5e[U5S:XaXUS4$[[USR55S5nUc&X2:a [S5e[R"U5n[U5U:wa [S 5eXX#4$) zoHelper function to check type of coeffs and axes. This code is used by both coeffs_to_array and ravel_coeffs. rz2input must be a list of coefficients from wavedecnN6coeffs_to_array does not support missing coefficients.z(first list element must be a numpy arrayrzinvalid coefficient listzlcoeffs corresponds to a DWT performed over only a subset of the axes. In this case, axes must be specified.zFThe length of axes doesn't match the number of dimensions transformed.) rRrSrUr*r&rVr\rrrTrkeysarange)rXr^r\rzs r3_prepare_coeffs_axesrtso fd # #s6{a'7MNN ay)* * fQi , ,CDD !9>>D 6{Q fQi & &  q 2:: . .08F q E4= 1 11&9F78 8 6{aT4''fQinn./23N |  CD Dyy 4yN"    --rc ~[X5upp4USnURn[U5S:XaU[[ S5/U-5/4$[ X5upxUc1U(d [ S5e[R"XuRS9n O[R"XqURS9n [UV s/sHn [ U 5PM sn 5n XYU '/n U RU 5 USSn U GH;nU R05 [R"UR5Vs/sHoSLPM sn5(a [ S5eUSU-RnUHnUUn[ S5/U-n[U5HgunnUUnUS:Xa[ URU5UU'M.US:Xa'[ UUUUURU-5UU'M[[ S U35e [U5nXU'UU S U'M [U5Vs/sHnUUUU-PM nnGM> X4$s sn fs snfs snf) aW Arrange a wavelet coefficient list from ``wavedecn`` into a single array. Parameters ---------- coeffs : array-like Dictionary of wavelet coefficients as returned by pywt.wavedecn padding : float or None, optional The value to use for the background if the coefficients cannot be tightly packed. If None, raise an error if the coefficients cannot be tightly packed. axes : sequence of ints, optional Axes over which the DWT that created ``coeffs`` was performed. The default value of None corresponds to all axes. Returns ------- coeff_arr : array-like Wavelet transform coefficient array. coeff_slices : list List of slices corresponding to each coefficient. As a 2D example, ``coeff_arr[coeff_slices[1]['dd']]`` would extract the first level detail coefficients from ``coeff_arr``. See Also -------- array_to_coeffs : the inverse of coeffs_to_array Notes ----- Assume a 2D coefficient dictionary, c, from a two-level transform. Then all 2D coefficients will be stacked into a single larger 2D array as follows:: +---------------+---------------+-------------------------------+ | | | | | c[0] | c[1]['da'] | | | | | | +---------------+---------------+ c[2]['da'] | | | | | | c[1]['ad'] | c[1]['dd'] | | | | | | +---------------+---------------+ ------------------------------+ | | | | | | | | | | c[2]['ad'] | c[2]['dd'] | | | | | | | | | | +-------------------------------+-------------------------------+ If the transform was not performed with mode "periodization" or the signal length was not a multiple of ``2**level``, coefficients at each subsequent scale will not be exactly 1/2 the size of those at the previous level due to additional coefficients retained to handle the boundary condition. In these cases, the default setting of `padding=0` indicates to pad the individual coefficient arrays with 0 as needed so that they can be stacked into a single, contiguous array. Examples -------- >>> import pywt >>> cam = pywt.data.camera() >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3) >>> arr, coeff_slices = pywt.coeffs_to_array(coeffs) rrNz+array coefficients cannot be tightly packeddtyperr1rDzunexpected letter: rp)rr8rUrTrLrr*r&emptyrfullr<rvaluesrr;)rXpaddingr^r\rza_coeffsa_shaperr coeff_arrr0a_slices coeff_slicesrY coeff_dictr1rnkey slice_arrayrEletax_irs r3rrsWP*>f)K&F$ayHnnG 6{a%t  45666#?v"LIJK KHHYnn= GGIhnnE 01eAh01H"hL! B B 66j&7&7&9:&99&9: ; ;-. .S>1288C3A ;/D0K#C.3Aw#:(-aggdm(>> import pywt >>> from numpy.testing import assert_array_almost_equal >>> cam = pywt.data.camera() >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3) >>> arr, coeff_slices = pywt.coeffs_to_array(coeffs) >>> coeffs_from_arr = pywt.array_to_coeffs(arr, coeff_slices, ... output_format='wavedecn') >>> cam_recon = pywt.waverecn(coeffs_from_arr, wavelet='db2') >>> assert_array_almost_equal(cam, cam_recon) r empty list of coefficient slicesrrr1rrrrrUnrecognized output format: )r&r7rUr*r<r;r)arrr output_formatrXrr1rrs r3rr!s ~ **S/C F <A;<< cq/*+1c,' ( I %OC()A j (!_T*+!_T*+!_T*+-Aj (A$--/v0.}o>@ @ a) Mrc[X5upEn[X5n[X$5nUV s/sHoRPM n n [ [ U5[ U 5U5n/n [U5Hn [S[U5S9V s/sHn SRU 5PM nn UVs0sHo[U5_M nn[XGU5H0unnn[UUURUS9nUH nUUUU'M M2 UR5Hunn[U5UU'M U R!U5 UR#SU-5nM U R!U5 U R%5 U $s sn fs sn fs snf)aSubband shapes for a multilevel nD discrete wavelet transform. Parameters ---------- shape : sequence of ints The shape of the data to be transformed. wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. mode : str or tuple of str, optional Signal extension mode, see :ref:`Modes `. This can also be a tuple containing a mode to apply along each axis in ``axes``. level : int, optional Decomposition level (must be >= 0). If level is None (default) then it will be calculated using the ``dwt_max_level`` function. axes : sequence of ints, optional Axes over which to compute the DWT. Axes may not be repeated. The default is None, which means transform all axes (``axes = range(data.ndim)``). Returns ------- shapes : [cAn, {details_level_n}, ... {details_level_1}] : list Coefficients shape list. Mirrors the output of ``wavedecn``, except it contains only the shapes of the coefficient arrays rather than the arrays themselves. Examples -------- >>> import pywt >>> pywt.wavedecn_shapes((64, 32), wavelet='db2', level=3, axes=(0, )) [(10, 32), {'d': (10, 32)}, {'d': (18, 32)}, {'d': (33, 32)}] r)repeat) filter_lenr@rD)r{rrr:r4r(maxr;rrUjoinrSr)rrrTr<r}r=)r8r?r@r/r^ryrzramodesrbrcshapesrEc detail_keysr new_shapesrAwavr0rs r3r!r!zsaD)>> import numpy as np >>> import pywt >>> data_shape = (64, 32) >>> shapes = pywt.wavedecn_shapes(data_shape, 'db2', mode='periodization') >>> pywt.wavedecn_size(shapes) 2048 >>> coeffs = pywt.wavedecn(np.ones(data_shape), 'sym4', mode='symmetric') >>> pywt.wavedecn_size(coeffs) 3087 c[U[R5(a UR$[R"U5$)z?Size corresponding to ``x`` as either a shape tuple or ndarray.)rRr&rVrr)xs r3_sizewavedecn_size.._sizes* a $ $66M771: rrrNz4Setting coefficient arrays to None is not supported.)rr*)rrrr1rrs r3r r se6 F1IG ABZGGIDAy JLL uQx G  Nrc[X5up#n[X5n[X55VVs/sHupg[XgR5PM nnn[ U5$s snnf)aCompute the maximum level of decomposition for n-dimensional data. This returns the maximum number of levels of decomposition suitable for use with ``wavedec``, ``wavedec2`` or ``wavedecn``. Parameters ---------- shape : sequence of ints Input data shape. wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. axes : sequence of ints, optional Axes over which to compute the DWT. Axes may not be repeated. Returns ------- level : int Maximum level. Notes ----- The level returned is the smallest ``dwt_max_level`` over all axes. Examples -------- >>> import pywt >>> pywt.dwtn_max_level((64, 32), 'db2') 3 )r{rr)r r:r() r8r?r^ryrzrarr max_levelss r3rrsa@)>> import pywt >>> cam = pywt.data.camera() >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3) >>> arr, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs) rrrNrrp)rrrUravelrLr8r r&rrr<rrr*sortedr)rXr^r\rzra_sizearr_sizera_slicer coeff_shapesrYoffsetrr1rrsls r3rr sP*>f)K&F$ayH ]]F 6{a~~%-!2X^^4FFFV$H(X^^>> import pywt >>> from numpy.testing import assert_array_almost_equal >>> cam = pywt.data.camera() >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3) >>> arr, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs) >>> coeffs_from_arr = pywt.unravel_coeffs(arr, coeff_slices, coeff_shapes, ... output_format='wavedecn') >>> cam_recon = pywt.waverecn(coeffs_from_arr, wavelet='db2') >>> assert_array_almost_equal(cam, cam_recon) rrz empty list of coefficient shapesz1coeff_shapes and coeff_slices have unequal lengthr)rswtr1)rswt2rrr)rswtnr)r&r7rUr*r<reshaper;r) rrrrrXr slice_dict shape_dictr1rrs r3rr_sV **S/C F <A;<< \ a ;<< \ c,/ /LMM cq/*22<?CD1c,' (!_ !_ . .sO$,,Z_=A 2 2%&..z$/?@%&..z$/?@%&..z$/?@BA2 2A$--/v~~jm40.}o>@ @ a!)" Mrc[U5[[U55:wa [S5eUVs/sHo RUPM ngs snf![a [S5ef=f)z-Axes checks common to fswavedecn, fswaverecn.z-The axes passed to fswavedecn must be unique.r6N)rUr]rr8r9)r>r^r_s r3_check_fswavedecn_axesrs] 4yCD N"GHH="&'$BB$'' =;<<=sAA  A AA(c$\rSrSrSrSr\S5r\RS5r\S5r \S5r \S5r \S 5r \S 5r \S 5r\S 5r\S 5rSr\S5r\RS5rSrSrSrSrSrg)r$ia/Object representing fully separable wavelet transform coefficients. Parameters ---------- coeffs : ndarray The coefficient array. coeff_slices : list List of slices corresponding to each detail or approximation coefficient array. wavelets : list of pywt.DiscreteWavelet objects The wavelets used. Will be a list with length equal to ``len(axes)``. mode_enums : list of int The border modes used. Will be a list with length equal to ``len(axes)``. axes : tuple of int The set of axes over which the transform was performed. cXlX lXPl[R"SU55(d [ S5eX0l[R"SU55(d [ S5eX@lg)Nc3B# UHn[U[5v M g7frJ)rRr )rNrbs r3rO,FswavedecnResult.__init__..s?hjG,,hrz*wavelets must contain pywt.Wavelet objectsc3B# UHn[U[5v M g7frJ)rRint)rNms r3rOrs=*QjC((*rzmode_enums must be integers)_coeffs _coeff_slices_axesr&rtr* _wavelets _mode_enums)selfrXrra mode_enumsr^s r3__init__FswavedecnResult.__init__sg ) vv?h???<> >!vv=*===-/ /%rcUR$)z6ndarray: All coefficients stacked into a single array.)rrs r3rXFswavedecnResult.coeffss||rcnURURR:wa [S5eXlg)Nz?new coefficient array must match the existing coefficient shape)r8rr*)rrs r3rXrs/ 77dll(( (12 2 rcUR$)z!List: List of coefficient slices.)rrs r3rFswavedecnResult.coeff_slicess!!!rc.URR$)zint: Number of data dimensions.)rXr\rs r3r\FswavedecnResult.ndims{{rc,[UR5$)z int: Number of axes transformed.)rUr^rs r3rzFswavedecnResult.ndim_transforms499~rcUR$)z8List of str: The axes the transform was performed along.)rrs r3r^FswavedecnResult.axesszzrc^URVs/sHn[U5S- PM sn$s snf)zAList of int: Levels of decomposition along each transformed axis.r)rrU)rr0s r3levelsFswavedecnResult.levelss,%)$5$56$5qA $5666s*cUR$z@List of pywt.DiscreteWavelet: wavelet for each transformed axis.)rrs r3raFswavedecnResult.waveletss~~rcXURVs/sHoRPM sn$s snfr )rname)rrbs r3 wavelet_namesFswavedecnResult.wavelet_namess"!%/1///s'c[RVs0sHn[[U5U_M nnURVs/sHo2UPM sn$s snfs snf)z>List of str: The border mode used along each transformed axis.)r rgetattrr)rr@ names_dictrs r3rFswavedecnResult.modess[#(++/"-$eT*D0"- /'+'7'78'7!1 '788/8s AAc[S5/UR-n[[URU55HunupEUR UUX$'M [ U5$rJ)rLr\rr)r^rrT)rrrrr_levs r3 _get_coef_slFswavedecnResult._get_coef_sl sWDk_tyy (%c$))V&<=LAy&&q)#.BF>Ryrc\URSUR-5nURU$)z(ndarray: The approximation coefficients.r)rr\r)rrs r3approxFswavedecnResult.approxs+  uTYY /||BrcURSUR-5nURURUR:wa [ S5eXRU'g)Nr7x does not match the shape of the requested coefficient)rr\rr8r*)rrDrs r3rrsS   uTYY / <<  ! !QWW ,IK K Rrc [U5n[U5[UR5:wa [S5e[R "UVs/sHn[ U[R5PM sn5(ac[R"[R"U5S-S:5(d.[R"UVs/sHo"S:PM sn5(a [S5e[UVs/sHn[U5PM sn5n[R"[XR5VVs/sH up#X#:PM snn5(a [S5egs snfs snfs snfs snnf)Nz0levels must match the number of transformed axesrrz.Index must be a tuple of non-negative integersz8Specified indices exceed the number of transform levels.)rTrUr^r*r&rtrRnumbersNumberrr7rr)r)rrrmaxlevs r3_validate_index FswavedecnResult._validate_index s"v v;#dii. (BD D6J6C 376JKKrzz&)A-122626Ca6233MN NF3FSCF34 663v{{3KL3KKC3<3KL M MJL L NK24Ms $E!E&4E+8E0 cdURU5 URU5nURU$)zRetrieve a coefficient subband. Parameters ---------- levels : tuple of int The number of degrees of decomposition along each transformed axis. )r!rr)rrrs r3 __getitem__FswavedecnResult.__getitem__4s1 V$   v &||BrcLURU5 URU5nURURnURURUR:wa [ S5eURU:wa[ R"SU35 X RU'g)aAssign values to a coefficient subband. Parameters ---------- levels : tuple of int The number of degrees of decomposition along each transformed axis. x : ndarray The data corresponding to assign. It must match the expected shape and dtype of the specified subband. rz7dtype mismatch: converting the provided array todtype N)r!rrrr8r*r+r,)rrrr current_dtypes r3 __setitem__FswavedecnResult.__setitem__As V$   v & R(.. <<  ! !QWW ,IK K 77m # MM##0/3 4 Rrc[[SUR565nURS[ UR 5-5 [ U5$)z{Return a list of all detail coefficient keys. Returns ------- keys : list of str List of all detail coefficient keys. c3># UHn[US-5v M g7f)rN)r;)rNls r3rO/FswavedecnResult.detail_keys..`s>+QeAaCjj+sr)rSrrremoverUr^r)rrs r3rFswavedecnResult.detail_keysXs@G>$++>?@ E#dii.()d|r)rrrrrN)__name__ __module__ __qualname____firstlineno____doc__rpropertyrXsetterrr\rzr^rrar rrrr!r$r(r__static_attributes__rmrr3r$r$s& & ]] ""  770099     ]]L(  . rr$c 0[R"U5nUc)[[R"UR55n[ X5 Ub "U5(aU/[U5-n[U5[U5:wa [S5e[X$5n[X5n[S5/[U5-nUn[[XCXe55Hun upp[XX+U S9n U Vs/sHoRU PM nn[R "S/U-5n[#[U55Vs/sHn[UUUUS-5PM snXy'[R$"XS9nM ['XXeU5$s snfs snf)a+ Fully Separable Wavelet Decomposition. This is a variant of the multilevel discrete wavelet transform where all levels of decomposition are performed along a single axis prior to moving onto the next axis. Unlike in ``wavedecn``, the number of levels of decomposition are not required to be the same along each axis which can be a benefit for anisotropic data. Parameters ---------- data: array_like Input data wavelet : Wavelet object or name string, or tuple of wavelets Wavelet to use. This can also be a tuple containing a wavelet to apply along each axis in ``axes``. mode : str or tuple of str, optional Signal extension mode, see :ref:`Modes `. This can also be a tuple containing a mode to apply along each axis in ``axes``. levels : int or sequence of ints, optional Decomposition levels along each axis (must be >= 0). If an integer is provided, the same number of levels are used for all axes. If ``levels`` is None (default), ``dwt_max_level`` will be used to compute the maximum number of levels possible for each axis. axes : sequence of ints, optional Axes over which to compute the transform. Axes may not be repeated. The default is to transform along all axes. Returns ------- fswavedecn_result : FswavedecnResult object Contains the wavelet coefficients, slice objects to allow obtaining the coefficients per detail or approximation level, and more. See ``FswavedecnResult`` for details. Examples -------- >>> import numpy as np >>> from pywt import fswavedecn >>> fs_result = fswavedecn(np.ones((32, 32)), 'sym2', levels=(1, 3)) >>> print(fs_result.detail_keys()) [(0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3)] >>> approx_coeffs = fs_result.approx >>> detail_1_2 = fs_result[(1, 2)] Notes ----- This transformation has been variously referred to as the (fully) separable wavelet transform (e.g. refs [1]_, [3]_), the tensor-product wavelet ([2]_) or the hyperbolic wavelet transform ([4]_). It is well suited to data with anisotropic smoothness. In [2]_ it was demonstrated that fully separable transform performs at least as well as the DWT for image compression. Computation time is a factor 2 larger than that for the DWT. See Also -------- fswaverecn : inverse of fswavedecn References ---------- .. [1] PH Westerink. Subband Coding of Images. Ph.D. dissertation, Dept. Elect. Eng., Inf. Theory Group, Delft Univ. Technol., Delft, The Netherlands, 1989. (see Section 2.3) http://resolver.tudelft.nl/uuid:a4d195c3-1f89-4d66-913d-db9af0969509 .. [2] CP Rosiene and TQ Nguyen. Tensor-product wavelet vs. Mallat decomposition: A comparative analysis, in Proc. IEEE Int. Symp. Circuits and Systems, Orlando, FL, Jun. 1999, pp. 431-434. .. [3] V Velisavljevic, B Beferull-Lozano, M Vetterli and PL Dragotti. Directionlets: Anisotropic Multidirectional Representation With Separable Filtering. IEEE Transactions on Image Processing, Vol. 15, No. 7, July 2006. .. [4] RA DeVore, SV Konyagin and VN Temlyakov. "Hyperbolic wavelet approximation," Constr. Approx. 14 (1998), 1-26. Nz-levels must match the length of the axes list)r@r/rArr)rA)r&r7rTrr\rr'rUr*rrrLrr)rr8cumsumr; concatenater$)r>r?r@rr^rrar coeffs_arrax_countr_rrrXrc_shapes c_offsetsr1s r3r"r"esl` ::d D |RYYtyy)*4& ~V,,c$i' 6{c$iHII D 'E!'0H$K?SY.LJ*3 h .+0&&2CtRH *00AGGBK0IIqeh./ 9>s8}9M"O9MAE)A, !A# /9M"O ^^F4 +0 Jht LL1"Os ;FFcURnURnURnURnURn[ X5 [ U5[ U5:wa [S5eUn[S5/UR-n[[X5U55HNunupn /n X(H$n XU 'U RU[U55 M& [S5Xy'[XXS9nMP U$)a!Fully Separable Inverse Wavelet Reconstruction. Parameters ---------- fswavedecn_result : FswavedecnResult object FswavedecnResult object from ``fswavedecn``. Returns ------- reconstructed : ndarray Array of reconstructed data. Notes ----- This transformation has been variously referred to as the (fully) separable wavelet transform (e.g. refs [1]_, [3]_), the tensor-product wavelet ([2]_) or the hyperbolic wavelet transform ([4]_). It is well suited to data with anisotropic smoothness. In [2]_ it was demonstrated that the fully separable transform performs at least as well as the DWT for image compression. Computation time is a factor 2 larger than that for the DWT. See Also -------- fswavedecn : inverse of fswaverecn References ---------- .. [1] PH Westerink. Subband Coding of Images. Ph.D. dissertation, Dept. Elect. Eng., Inf. Theory Group, Delft Univ. Technol., Delft, The Netherlands, 1989. (see Section 2.3) http://resolver.tudelft.nl/uuid:a4d195c3-1f89-4d66-913d-db9af0969509 .. [2] CP Rosiene and TQ Nguyen. Tensor-product wavelet vs. Mallat decomposition: A comparative analysis, in Proc. IEEE Int. Symp. Circuits and Systems, Orlando, FL, Jun. 1999, pp. 431-434. .. [3] V Velisavljevic, B Beferull-Lozano, M Vetterli and PL Dragotti. Directionlets: Anisotropic Multidirectional Representation With Separable Filtering. IEEE Transactions on Image Processing, Vol. 15, No. 7, July 2006. .. [4] RA DeVore, SV Konyagin and VN Temlyakov. "Hyperbolic wavelet approximation," Constr. Approx. 14 (1998), 1-26. zdimension mismatchN)r@rA)rXrr^rrarrUr*rLr\rr)r<rTr)fswavedecn_resultr;rr^rrarcslr<r_rr@rXrs r3r#r#s^#))J$11L  ! !D  # #E ))H:, 4yC %%-.. C ;/CHH $C&/s45/I%J!/2D(BG MM#eCj/ *)+f6 &K Jr) symmetricNrp)rBrp)rBNrp)rBrC)rBNN)rBN)rN)rrJ)5r4rr+r itertoolsrnumpyr&_dwtrrr_extensions._dwtr _extensions._pywtr r _multidimr r rrr_utilsrrrr__all__r4rrrrr{rrrrrrrrrr!r rrrrr$r"r#rmrr3rMs  **+-<<OO N $<~@ FJZQ h-(Rj ; u p " ' +.\|#~Vr7t(V(VR1jHV=nnbnMbDr