}Kg dZddlmZddlZddlZddlZddlZddlZddl Zddl m Z ddl m Z ddlmZddlmZd d lmZd d l mZd d lmZd d lmZmZd dlmZddlmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$ddl%m&Z&d dl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.gdZ/edddddddddd d`dZ0edddddddddd dadZ1e ddd Z2 db dcd"Z3 db dcd#Z4d!ddddddddd$d%dddd& ddd'Z5dd(ded)Z6ddd* dfd+Z7edd!dddd,dd-d.d/ dgd0Z8e$d1d1d1d2 dhd3Z9e$d1d1d1d2 did4Z9e$d1d1d1d2 djd5Z9edd6d7d8d2 djd9Z9e$d1d: dkd;Z:e$d1d: dld<Z:e$d1d: dmd=Z:edd6d:dmd>Z:e$d1d1d1d2 dhd?Z;e$d1d1d1d2 did@Z;e$d1d1d1d2 djdAZ;edd6dBd8d2 djdCZ;e$d1d: dkdDZe$d1d1d1d1d1d1d1d1d1d1d1d1d1d1dP dpdQZ?e$d1d1d1d1d1d1d1d1d1d1d1d1d1dR dqdSZ?e$d1d1d1d1d1d1d1d1d1d1d1d1d1d1dP drdTZ?edd!dUdVd dKdWd$ddddMddd%dP drdXZ?dYdddddddddZd[dd\ dsd]Z@ddddUdddddd^ dtd_ZAy)uz!Utilities for spectral processing) annotationsN)jit)convert) get_fftlib)resample)cache)util)ParameterError) get_windowsemitone_filterbank)window_sumsquare) DTypeLike)AnyCallableOptionalTupleListUnionoverload)Literal) _WindowSpec_PadMode _PadModeSTFT _SequenceLike_ScalarOrSequence_ComplexLike_co _FloatLike_co)stftistftmagphaseiirtreassigned_spectrogram phase_vocoderperceptual_weighting power_to_db db_to_poweramplitude_to_dbdb_to_amplitudefmtpcen griffinlim)levelhannTconstant)n_fft hop_length win_lengthwindowcenterdtypepad_modeoutc ||}|t|dz}n$tj|std|dtj|dt ||d} tj | | } tj| d |jzd } |r |d vrtd|d||jdkDr(tjd|d|jdt|jD cgc]} d} } ttj|dz|z } |jd|dzz|z |zd z} | | kr+d}d}|dz|dzf| d<tj|| |}n]| |z|dzz }|dzdf| d<tj|dd| d z |z|dzz |zd zf| |}tj |||}|dd| f}|jd}| |z|dzz |z|jd|dzzkr]d|dzf| d<tj|d| |z|dzz df| |}tj |||}||jdz }nft#|j}d|d<tj$||}n4||jdkDrtd|d|jdd}d}t'}|tj(|j*}tj |d|df||}t#|j}d |dzz|d <|dxx|z cc<|tj,||d}ntj.|jdd|ddr|jd|dk\std|jd|tj0|std|j*d tj.||jr|}n |dd|df}|rd|dkDr_jd}|j3| |zd !|dd|f<jd}|dkDr!|j3| |zd !|d| df<nd}ttj4tj6|jdd|j8zz}t;|d }td|jd|D]H}t=||z|jd}|j3| |d||fzd !|d||z||zf<J|Scc} w)"aShort-time Fourier transform (STFT). The STFT represents a signal in the time-frequency domain by computing discrete Fourier transforms (DFT) over short overlapping windows. This function returns a complex-valued matrix D such that - ``np.abs(D[..., f, t])`` is the magnitude of frequency bin ``f`` at frame ``t``, and - ``np.angle(D[..., f, t])`` is the phase of frequency bin ``f`` at frame ``t``. The integers ``t`` and ``f`` can be converted to physical units by means of the utility functions `frames_to_samples` and `fft_frequencies`. Parameters ---------- y : np.ndarray [shape=(..., n)], real-valued input signal. Multi-channel is supported. n_fft : int > 0 [scalar] length of the windowed signal after padding with zeros. The number of rows in the STFT matrix ``D`` is ``(1 + n_fft/2)``. The default value, ``n_fft=2048`` samples, corresponds to a physical duration of 93 milliseconds at a sample rate of 22050 Hz, i.e. the default sample rate in librosa. This value is well adapted for music signals. However, in speech processing, the recommended value is 512, corresponding to 23 milliseconds at a sample rate of 22050 Hz. In any case, we recommend setting ``n_fft`` to a power of two for optimizing the speed of the fast Fourier transform (FFT) algorithm. hop_length : int > 0 [scalar] number of audio samples between adjacent STFT columns. Smaller values increase the number of columns in ``D`` without affecting the frequency resolution of the STFT. If unspecified, defaults to ``win_length // 4`` (see below). win_length : int <= n_fft [scalar] Each frame of audio is windowed by ``window`` of length ``win_length`` and then padded with zeros to match ``n_fft``. Padding is added on both the left- and the right-side of the window so that the window is centered within the frame. Smaller values improve the temporal resolution of the STFT (i.e. the ability to discriminate impulses that are closely spaced in time) at the expense of frequency resolution (i.e. the ability to discriminate pure tones that are closely spaced in frequency). This effect is known as the time-frequency localization trade-off and needs to be adjusted according to the properties of the input signal ``y``. If unspecified, defaults to ``win_length = n_fft``. window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)] Either: - a window specification (string, tuple, or number); see `scipy.signal.get_window` - a window function, such as `scipy.signal.windows.hann` - a vector or array of length ``n_fft`` Defaults to a raised cosine window (`'hann'`), which is adequate for most applications in audio signal processing. .. see also:: `filters.get_window` center : boolean If ``True``, the signal ``y`` is padded so that frame ``D[:, t]`` is centered at ``y[t * hop_length]``. If ``False``, then ``D[:, t]`` begins at ``y[t * hop_length]``. Defaults to ``True``, which simplifies the alignment of ``D`` onto a time grid by means of `librosa.frames_to_samples`. Note, however, that ``center`` must be set to `False` when analyzing signals with `librosa.stream`. .. see also:: `librosa.stream` dtype : np.dtype, optional Complex numeric type for ``D``. Default is inferred to match the precision of the input signal. pad_mode : string or function If ``center=True``, this argument is passed to `np.pad` for padding the edges of the signal ``y``. By default (``pad_mode="constant"``), ``y`` is padded on both sides with zeros. .. note:: Not all padding modes supported by `numpy.pad` are supported here. `wrap`, `mean`, `maximum`, `median`, and `minimum` are not supported. Other modes that depend at most on input values at the edges of the signal (e.g., `constant`, `edge`, `linear_ramp`) are supported. If ``center=False``, this argument is ignored. .. see also:: `numpy.pad` out : np.ndarray or None A pre-allocated, complex-valued array to store the STFT results. This must be of compatible shape and dtype for the given input parameters. If `out` is larger than necessary for the provided input signal, then only a prefix slice of `out` will be used. If not provided, a new array is allocated and returned. Returns ------- D : np.ndarray [shape=(..., 1 + n_fft/2, n_frames), dtype=dtype] Complex-valued matrix of short-term Fourier transform coefficients. If a pre-allocated `out` array is provided, then `D` will be a reference to `out`. If `out` is larger than necessary, then `D` will be a sliced view: `D = out[..., :n_frames]`. See Also -------- istft : Inverse STFT reassigned_spectrogram : Time-frequency reassigned spectrogram Notes ----- This function caches at level 20. Examples -------- >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> S = np.abs(librosa.stft(y)) >>> S array([[5.395e-03, 3.332e-03, ..., 9.862e-07, 1.201e-05], [3.244e-03, 2.690e-03, ..., 9.536e-07, 1.201e-05], ..., [7.523e-05, 3.722e-05, ..., 1.188e-04, 1.031e-03], [7.640e-05, 3.944e-05, ..., 5.180e-04, 1.346e-03]], dtype=float32) Use left-aligned frames, instead of centered frames >>> S_left = librosa.stft(y, center=False) Use a shorter hop length >>> D_short = librosa.stft(y, hop_length=64) Display a spectrogram >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> img = librosa.display.specshow(librosa.amplitude_to_db(S, ... ref=np.max), ... y_axis='log', x_axis='time', ax=ax) >>> ax.set_title('Power spectrogram') >>> fig.colorbar(img, ax=ax, format="%+2.0f dB") Nz hop_length= must be a positive integerFmonoTfftbinssizerndimaxes)wrapmaximummeanmedianminimumz pad_mode='z"' is not supported by librosa.stftzn_fft=z) is too large for input signal of length=rrr rmode.) frame_lengthr4shapez@ is too large for uncentered analysis of input signal of length=F)r8order3Shape mismatch for provided output array out.shape=z and target shape=zoutput with dtype=z is not of complex typeaxis)intr is_positive_intr valid_audior pad_center expand_torFrSwarningswarnrangenpceilpadframelist empty_liker dtype_r2cr8zerosallclose iscomplexobjrfft MAX_MEM_BLOCKproditemsizemaxmin)yr3r4r5r6r7r8r9r: fft_window_paddingstart_ktail_kstartextray_pre y_frames_prey_post y_frames_post post_shapeffty_framesrS stft_matrix off_startoff_end n_columnsbl_sbl_ts Y/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/librosa/core/spectrum.pyr r 6s^ q)  ! !* -{:,6QRSS QU#FJ=J%8J QVV"EJ G G!XJ&HI  1772;  MMHQS V  $)=1=a6=1bggeqj:567''"+ *U2zAAE W EE A:uz2GBKq'1A j(5A:5E A:q/GBKFF#L'A+3eqj@5H1LLLME  ::e%JWL'XgX 6L!&&r*E "UaZ/%71772;RS;SS %1*o cFj05A:=??@'PX!% :! ,,R00 ","4"45 !" 2 " l* M 1772;  _`a`g`ghj`k_lm   ,C }qww'zz!CK.uTH  EEQJE"I "II {hhuE= kk#))CR.%*5#))B-5QS9:TA#))L^_d^e f  __S !1#))O>OOPIIq!Ia+Y74)#X^^B%78@C #tDy.1 1AIA C )D9,<<<=8 o2s Ur4r5r3r6r7r8lengthr:c h|d|jddz z}||}|t|dz}t||d} tj| |} tj | |j d } |rI|r |d|dzzz} n|} t|jd ttj| |z } n|jd } |tj|j}t|jdd} ||| dz zz} |r|} n |r | d|dzzz} | j| |tj| | }nNtj|j| st!d |jd | |}|j#dt%}|rttj|dz|z }| |j'|dd|f|dz}|||dz zz| d <tj| | }t)||||jd | d |dzz kr'|d|dz|jd |dzzf|dddf<n|d|dzdf|dd| d |dzz f<||z|dzz }nd}d}ttj*tj,|jdd |j.zz}t1|d}d}t3|| |D]Q}t||z| }| |j'|d||f|dz}t)|d||z|zdf|||||z z }St5|| ||||}|r|dz}nd}tj6|d|df|jd }|tj8|kD}|d|fxx||zcc<|S)u  Inverse short-time Fourier transform (ISTFT). Converts a complex-valued spectrogram ``stft_matrix`` to time-series ``y`` by minimizing the mean squared error between ``stft_matrix`` and STFT of ``y`` as described in [#]_ up to Section 2 (reconstruction from MSTFT). In general, window function, hop length and other parameters should be same as in stft, which mostly leads to perfect reconstruction of a signal from unmodified ``stft_matrix``. .. [#] D. W. Griffin and J. S. Lim, "Signal estimation from modified short-time Fourier transform," IEEE Trans. ASSP, vol.32, no.2, pp.236–243, Apr. 1984. Parameters ---------- stft_matrix : np.ndarray [shape=(..., 1 + n_fft//2, t)] STFT matrix from ``stft`` hop_length : int > 0 [scalar] Number of frames between STFT columns. If unspecified, defaults to ``win_length // 4``. win_length : int <= n_fft = 2 * (stft_matrix.shape[0] - 1) When reconstructing the time series, each frame is windowed and each sample is normalized by the sum of squared window according to the ``window`` function (see below). If unspecified, defaults to ``n_fft``. n_fft : int > 0 or None The number of samples per frame in the input spectrogram. By default, this will be inferred from the shape of ``stft_matrix``. However, if an odd frame length was used, you can specify the correct length by setting ``n_fft``. window : string, tuple, number, function, np.ndarray [shape=(n_fft,)] - a window specification (string, tuple, or number); see `scipy.signal.get_window` - a window function, such as `scipy.signal.windows.hann` - a user-specified window vector of length ``n_fft`` .. see also:: `filters.get_window` center : boolean - If ``True``, ``D`` is assumed to have centered frames. - If ``False``, ``D`` is assumed to have left-aligned frames. dtype : numeric type Real numeric type for ``y``. Default is to match the numerical precision of the input spectrogram. length : int > 0, optional If provided, the output ``y`` is zero-padded or clipped to exactly ``length`` samples. out : np.ndarray or None A pre-allocated, complex-valued array to store the reconstructed signal ``y``. This must be of the correct shape for the given input parameters. If not provided, a new array is allocated and returned. Returns ------- y : np.ndarray [shape=(..., n)] time domain signal reconstructed from ``stft_matrix``. If ``stft_matrix`` contains more than two axes (e.g., from a stereo input signal), then ``y`` will match shape on the leading dimensions. See Also -------- stft : Short-time Fourier Transform Notes ----- This function caches at level 30. Examples -------- >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> D = librosa.stft(y) >>> y_hat = librosa.istft(D) >>> y_hat array([-1.407e-03, -4.461e-04, ..., 5.131e-06, -1.417e-05], dtype=float32) Exactly preserving length of the input signal requires explicit padding. Otherwise, a partial frame at the end of ``y`` will not be represented. >>> n = len(y) >>> n_fft = 2048 >>> y_pad = librosa.util.fix_length(y, size=n + n_fft // 2) >>> D = librosa.stft(y_pad, n_fft=n_fft) >>> y_out = librosa.istft(D, length=n) >>> np.max(np.abs(y - y_out)) 8.940697e-08 Nr rDrr<Tr@rBrErMr8rVz != .)nrXr)r6n_framesr5r3r4r8)rSrYr r r\r]rFrprarb dtype_c2rr8reappendrhrir fillrirfft __overlap_addrlrmrnror`r fix_lengthtiny)rr4r5r3r6r7r8rr: ifft_window padded_lengthrrSexpected_signal_lenrqr~ start_frameytmp head_bufferoffsetrrdrrifft_window_sumrwapprox_nonzero_indicess rr!r!s&^ }[&&r*Q./ q) VZ>K//+E:K..;3C3C"MK "Q%1*%55M"M{((,c"''-*:T2U.VW$$R( }{001 ""3B' (E*1 "== $ qEQJ// LL$% { HHU% ( [[E *A#))DQVPW X    s ,C "''5A:";<= SYY{3  3D'EUWYXXJ+/::b hhuE2 k44 772;rUaZ/ /#C!aggbkEQJ6N)N$NOAc1fI0;3 ;L/MAc+U2Y!+++ ,z)EQJ6  rww{'8'8"'=>AUAUUVIIq!I Ek8Y74)#X.SYY{3T >'BeRTYUU aUZ/&8::;T:N 8' O oooc56k&BQSUO,tyy/IIc !!"o6L&MM" H)nopythonr c|jd}|}t|jdD]J}||z}||jd|z kDr|jd|z }|d|||zfxx|dd||fz cc<Ly)NrDrM.)rSr`)rqrr4r3Nrdsamples rrrus JJrNE Atzz"~&# qwwr{V# # f$A #v!$ $%c2A2un)==% 'r"Vc d||}t||d}tj||}|4|tj|j}t ||||||| } n| |j}|} tj |} t |||| ||| } tjd5tj| | z  } dddtj||}tj| jd | d |ztjz zz}|| fS#1swY`xYw) ad Instantaneous frequencies based on a spectrogram representation. The reassignment vector is calculated using equation 5.20 in Flandrin, Auger, & Chassande-Mottin 2002:: omega_reassigned = omega - np.imag(S_dh/S_h) where ``S_h`` is the complex STFT calculated using the original window, and ``S_dh`` is the complex STFT calculated using the derivative of the original window. See `reassigned_spectrogram` for references. It is recommended to use ``pad_mode="wrap"`` or else ``center=False``, rather than the defaults. Frequency reassignment assumes that the energy in each FFT bin is associated with exactly one signal component. Reflection padding at the edges of the signal may invalidate the reassigned estimates in the boundary frames. Parameters ---------- y : np.ndarray [shape=(..., n,)], real-valued audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` S : np.ndarray [shape=(..., d, t)] or None (optional) complex STFT calculated using the other arguments provided to `__reassign_frequencies` n_fft : int > 0 [scalar] FFT window size. Defaults to 2048. hop_length : int > 0 [scalar] hop length, number samples between subsequent frames. If not supplied, defaults to ``win_length // 4``. win_length : int > 0, <= n_fft Window length. Defaults to ``n_fft``. See ``stft`` for details. window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)] - a window specification (string, tuple, number); see `scipy.signal.get_window` - a window function, such as `scipy.signal.windows.hann` - a user-specified window vector of length ``n_fft`` See `stft` for details. .. see also:: `filters.get_window` center : boolean - If ``True``, the signal ``y`` is padded so that frame ``S[:, t]`` is centered at ``y[t * hop_length]``. - If ``False``, then ``S[:, t]`` begins at ``y[t * hop_length]``. dtype : numeric type Complex numeric type for ``S``. Default is inferred to match the numerical precision of the input signal. pad_mode : string If ``center=True``, the padding mode to use at the edges of the signal. By default, STFT uses zero padding. Returns ------- freqs : np.ndarray [shape=(..., 1 + n_fft/2, t), dtype=real] Instantaneous frequencies: ``freqs[f, t]`` is the frequency for bin ``f``, frame ``t``. S : np.ndarray [shape=(..., 1 + n_fft/2, t), dtype=complex] Short-time Fourier transform Warns ----- RuntimeWarning Frequencies with zero support will produce a divide-by-zero warning and will be returned as `np.nan`. See Also -------- stft : Short-time Fourier Transform reassigned_spectrogram : Time-frequency reassigned spectrogram Examples -------- >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> frequencies, S = librosa.core.spectrum.__reassign_frequencies(y, sr=sr) >>> frequencies array([[0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], [3.628e+00, 4.698e+00, ..., 1.239e+01, 1.072e+01], ..., [1.101e+04, 1.102e+04, ..., 1.105e+04, 1.102e+04], [1.102e+04, 1.102e+04, ..., 1.102e+04, 1.102e+04]]) NTr@rBrqr3r4r6r7r8r9ignoreinvalidsrr3rDrE?)r r r\rgr8r cyclic_gradientraerrstateimagrfft_frequenciesr]rFpi)rqrSr3r4r5r6r7r8r9S_hwindow_derivativeS_dh correctionfreqss r__reassign_frequenciesrs4Z  D 9F __V% 0Fy =NN177+E!  =GGE,,V4    D X &ggdSj))  '  # #r 7E NN5zR @: b255D E #: ' &s -D&&D/c ||}t||d}tj||}|t|dz}|4|tj|j }t ||||||| } n| |j }|} |dz} |dzrtj| | dz} ntjd | z | } || z} t |||| ||| }tjd 5tj|| z }ddd|rd}n|}tjtj| jd ||| }tj|jd ||z z}|| fS#1swYuxYw)ad Time reassignments based on a spectrogram representation. The reassignment vector is calculated using equation 5.23 in Flandrin, Auger, & Chassande-Mottin 2002:: t_reassigned = t + np.real(S_th/S_h) where ``S_h`` is the complex STFT calculated using the original window, and ``S_th`` is the complex STFT calculated using the original window multiplied by the time offset from the window center. See `reassigned_spectrogram` for references. It is recommended to use ``pad_mode="constant"`` (zero padding) or else ``center=False``, rather than the defaults. Time reassignment assumes that the energy in each FFT bin is associated with exactly one impulse event. Reflection padding at the edges of the signal may invalidate the reassigned estimates in the boundary frames. Parameters ---------- y : np.ndarray [shape=(..., n,)], real-valued audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` S : np.ndarray [shape=(..., d, t)] or None (optional) complex STFT calculated using the other arguments provided to `__reassign_times` n_fft : int > 0 [scalar] FFT window size. Defaults to 2048. hop_length : int > 0 [scalar] hop length, number samples between subsequent frames. If not supplied, defaults to ``win_length // 4``. win_length : int > 0, <= n_fft Window length. Defaults to ``n_fft``. See `stft` for details. window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)] - a window specification (string, tuple, number); see `scipy.signal.get_window` - a window function, such as `scipy.signal.windows.hann` - a user-specified window vector of length ``n_fft`` See `stft` for details. .. see also:: `filters.get_window` center : boolean - If ``True``, the signal ``y`` is padded so that frame ``S[:, t]`` is centered at ``y[t * hop_length]``. - If ``False``, then ``S[:, t]`` begins at ``y[t * hop_length]``. dtype : numeric type Complex numeric type for ``S``. Default is inferred to match the precision of the input signal. pad_mode : string If ``center=True``, the padding mode to use at the edges of the signal. By default, STFT uses zero padding. Returns ------- times : np.ndarray [shape=(..., 1 + n_fft/2, t), dtype=real] Reassigned times: ``times[f, t]`` is the time for bin ``f``, frame ``t``. S : np.ndarray [shape=(..., 1 + n_fft/2, t), dtype=complex] Short-time Fourier transform Warns ----- RuntimeWarning Time estimates with zero support will produce a divide-by-zero warning and will be returned as `np.nan`. See Also -------- stft : Short-time Fourier Transform reassigned_spectrogram : Time-frequency reassigned spectrogram Examples -------- >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> times, S = librosa.core.spectrum.__reassign_times(y, sr=sr) >>> times array([[ 2.268e-05, 1.144e-02, ..., 5.332e+00, 5.333e+00], [ 2.268e-05, 1.451e-02, ..., 5.334e+00, 5.333e+00], ..., [ 2.268e-05, -6.177e-04, ..., 5.368e+00, 5.327e+00], [ 2.268e-05, 1.420e-03, ..., 5.307e+00, 5.328e+00]]) NTr@rBr<rr rrrrrM)rr4r3rE)r r r\rYrgr8r raarangerrealrframes_to_timerSr]rF)rqrrr3r4r5r6r7r8r9r half_width window_timeswindow_time_weightedS_thr pad_lengthtimess r__reassign_timesr)sZ  D 9F __V% 0Fq) y =NN177+E!  =GGE!J qyyy*j1n= yyz!1:> !L0  # D X &WWTCZ(  '   " " #))B- RJj E NN5zR @:PR? RE #:! ' &s +E88Fgư>F)rrr3r4r5r6r7reassign_frequenciesreassign_times ref_powerfill_nanclipr8r9c Tt| s| dkr td|s | s td||}|t|dz}|rt||||||||| | \}}| rt ||||||||| | \}}|Jt j |}| s|r| sW|rd}n|}tj||}tjt j|jd||| }t| r | |d z}n| }t j||d zt j| }|rx|dkDrt j|<| r?t jt jddt j f|}| rRt j"d|d z |n5t j$ddt j f|j}| r|dkDrt j|<| r?t jt jt j ddf|}| rht j"d|jdt'|z |n5t j$t j ddf|j}|fS)aTime-frequency reassigned spectrogram. The reassignment vectors are calculated using equations 5.20 and 5.23 in [#]_:: t_reassigned = t + np.real(S_th/S_h) omega_reassigned = omega - np.imag(S_dh/S_h) where ``S_h`` is the complex STFT calculated using the original window, ``S_dh`` is the complex STFT calculated using the derivative of the original window, and ``S_th`` is the complex STFT calculated using the original window multiplied by the time offset from the window center. See [#]_ for additional algorithms, and [#]_ and [#]_ for history and discussion of the method. .. [#] Flandrin, P., Auger, F., & Chassande-Mottin, E. (2002). Time-Frequency reassignment: From principles to algorithms. In Applications in Time-Frequency Signal Processing (Vol. 10, pp. 179-204). CRC Press. .. [#] Fulop, S. A., & Fitz, K. (2006). Algorithms for computing the time-corrected instantaneous frequency (reassigned) spectrogram, with applications. The Journal of the Acoustical Society of America, 119(1), 360. doi:10.1121/1.2133000 .. [#] Auger, F., Flandrin, P., Lin, Y.-T., McLaughlin, S., Meignen, S., Oberlin, T., & Wu, H.-T. (2013). Time-Frequency Reassignment and Synchrosqueezing: An Overview. IEEE Signal Processing Magazine, 30(6), 32-41. doi:10.1109/MSP.2013.2265316 .. [#] Hainsworth, S., Macleod, M. (2003). Time-frequency reassignment: a review and analysis. Tech. Rep. CUED/FINFENG/TR.459, Cambridge University Engineering Department Parameters ---------- y : np.ndarray [shape=(..., n)], real-valued audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` S : np.ndarray [shape=(..., d, t)] or None (optional) complex STFT calculated using the other arguments provided to ``reassigned_spectrogram`` n_fft : int > 0 [scalar] FFT window size. Defaults to 2048. hop_length : int > 0 [scalar] hop length, number samples between subsequent frames. If not supplied, defaults to ``win_length // 4``. win_length : int > 0, <= n_fft Window length. Defaults to ``n_fft``. See `stft` for details. window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)] - a window specification (string, tuple, number); see `scipy.signal.get_window` - a window function, such as `scipy.signal.windows.hann` - a user-specified window vector of length ``n_fft`` See `stft` for details. .. see also:: `filters.get_window` center : boolean - If ``True`` (default), the signal ``y`` is padded so that frame ``S[:, t]`` is centered at ``y[t * hop_length]``. See `Notes` for recommended usage in this function. - If ``False``, then ``S[:, t]`` begins at ``y[t * hop_length]``. reassign_frequencies : boolean - If ``True`` (default), the returned frequencies will be instantaneous frequency estimates. - If ``False``, the returned frequencies will be a read-only view of the STFT bin frequencies for all frames. reassign_times : boolean - If ``True`` (default), the returned times will be corrected (reassigned) time estimates for each bin. - If ``False``, the returned times will be a read-only view of the STFT frame times for all bins. ref_power : float >= 0 or callable Minimum power threshold for estimating time-frequency reassignments. Any bin with ``np.abs(S[f, t])**2 < ref_power`` will be returned as `np.nan` in both frequency and time, unless ``fill_nan`` is ``True``. If 0 is provided, then only bins with zero power will be returned as `np.nan` (unless ``fill_nan=True``). fill_nan : boolean - If ``False`` (default), the frequency and time reassignments for bins below the power threshold provided in ``ref_power`` will be returned as `np.nan`. - If ``True``, the frequency and time reassignments for these bins will be returned as the bin center frequencies and frame times. clip : boolean - If ``True`` (default), estimated frequencies outside the range `[0, 0.5 * sr]` or times outside the range `[0, len(y) / sr]` will be clipped to those ranges. - If ``False``, estimated frequencies and times beyond the bounds of the spectrogram may be returned. dtype : numeric type Complex numeric type for STFT calculation. Default is inferred to match the precision of the input signal. pad_mode : string If ``center=True``, the padding mode to use at the edges of the signal. By default, STFT uses zero padding. Returns ------- freqs, times, mags : np.ndarray [shape=(..., 1 + n_fft/2, t), dtype=real] Instantaneous frequencies: ``freqs[..., f, t]`` is the frequency for bin ``f``, frame ``t``. If ``reassign_frequencies=False``, this will instead be a read-only array of the same shape containing the bin center frequencies for all frames. Reassigned times: ``times[..., f, t]`` is the time for bin ``f``, frame ``t``. If ``reassign_times=False``, this will instead be a read-only array of the same shape containing the frame times for all bins. Magnitudes from short-time Fourier transform: ``mags[..., f, t]`` is the magnitude for bin ``f``, frame ``t``. Warns ----- RuntimeWarning Frequency or time estimates with zero support will produce a divide-by-zero warning, and will be returned as `np.nan` unless ``fill_nan=True``. See Also -------- stft : Short-time Fourier Transform Notes ----- It is recommended to use ``center=False`` with this function rather than the librosa default ``True``. Unlike ``stft``, reassigned times are not aligned to the left or center of each frame, so padding the signal does not affect the meaning of the reassigned times. However, reassignment assumes that the energy in each FFT bin is associated with exactly one signal component and impulse event. If ``reassign_times`` is ``False``, the frame times that are returned will be aligned to the left or center of the frame, depending on the value of ``center``. In this case, if ``center`` is ``True``, then ``pad_mode="wrap"`` is recommended for valid estimation of the instantaneous frequencies in the boundary frames. Examples -------- >>> import matplotlib.pyplot as plt >>> amin = 1e-10 >>> n_fft = 64 >>> sr = 4000 >>> y = 1e-3 * librosa.clicks(times=[0.3], sr=sr, click_duration=1.0, ... click_freq=1200.0, length=8000) +\ ... 1e-3 * librosa.clicks(times=[1.5], sr=sr, click_duration=0.5, ... click_freq=400.0, length=8000) +\ ... 1e-3 * librosa.chirp(fmin=200, fmax=1600, sr=sr, duration=2.0) +\ ... 1e-6 * np.random.randn(2*sr) >>> freqs, times, mags = librosa.reassigned_spectrogram(y=y, sr=sr, ... n_fft=n_fft) >>> mags_db = librosa.amplitude_to_db(mags, ref=np.max) >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> img = librosa.display.specshow(mags_db, x_axis="s", y_axis="linear", sr=sr, ... hop_length=n_fft//4, ax=ax[0]) >>> ax[0].set(title="Spectrogram", xlabel=None) >>> ax[0].label_outer() >>> ax[1].scatter(times, freqs, c=mags_db, cmap="magma", alpha=0.1, s=5) >>> ax[1].set_title("Reassigned spectrogram") >>> fig.colorbar(img, ax=ax, format="%+2.f dB") rz+ref_power must be non-negative or callable.z4reassign_frequencies or reassign_times must be True.Nr<) rqrrr3r4r5r6r7r8r9rrM)framesrr4r3r r)where@r:)callabler rYrrraabsrrrrrSlessisnannanrnewaxisr broadcast_tofloat)rqrrr3r4r5r6r7rrrrrr8r9rrmagsr bin_freqs frame_timesref_pmags_lows rr$r$suN I 9q=JKK STT q) )!!  q#!!  q ==vvayD +> JJ++r? ,,99QWWR[)!   $'"wwtUCZ?H  19 ffE(O HHRXXe_i2:: .FNE  GGE1b3hE 2  !RZZ- 8!''B 19 ffE(O HHRXXe_k"**a-.H%PE  GGE1aggbkE"I55 A BJJM :AGGD % r)powerctj|}|dk(}||z}tj|tj|j }|j |z |z|_|j|z |_||z}||fS)aySeparate a complex-valued spectrogram D into its magnitude (S) and phase (P) components, so that ``D = S * P``. Parameters ---------- D : np.ndarray [shape=(..., d, t), dtype=complex] complex-valued spectrogram power : float > 0 Exponent for the magnitude spectrogram, e.g., 1 for energy, 2 for power, etc. Returns ------- D_mag : np.ndarray [shape=(..., d, t), dtype=real] magnitude of ``D``, raised to ``power`` D_phase : np.ndarray [shape=(..., d, t), dtype=complex] ``exp(1.j * phi)`` where ``phi`` is the phase of ``D`` Examples -------- >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> D = librosa.stft(y) >>> magnitude, phase = librosa.magphase(D) >>> magnitude array([[5.395e-03, 3.332e-03, ..., 9.862e-07, 1.201e-05], [3.244e-03, 2.690e-03, ..., 9.536e-07, 1.201e-05], ..., [7.523e-05, 3.722e-05, ..., 1.188e-04, 1.031e-03], [7.640e-05, 3.944e-05, ..., 5.180e-04, 1.346e-03]], dtype=float32) >>> phase array([[ 1. +0.000e+00j, 1. +0.000e+00j, ..., -1. -8.742e-08j, -1. -8.742e-08j], [-1. -8.742e-08j, -0.775-6.317e-01j, ..., -0.885-4.648e-01j, 0.472-8.815e-01j], ..., [ 1. -4.342e-12j, 0.028-9.996e-01j, ..., -0.222-9.751e-01j, -0.75 -6.610e-01j], [-1. -8.742e-08j, -1. -8.742e-08j, ..., 1. +0.000e+00j, 1. +0.000e+00j]], dtype=complex64) Or get the phase angle (in radians) >>> np.angle(phase) array([[ 0.000e+00, 0.000e+00, ..., -3.142e+00, -3.142e+00], [-3.142e+00, -2.458e+00, ..., -2.658e+00, -1.079e+00], ..., [-4.342e-12, -1.543e+00, ..., -1.794e+00, -2.419e+00], [-3.142e+00, -3.142e+00, ..., 0.000e+00, 0.000e+00]], dtype=float32) rr)rarrfr rgr8rr)Drmag zeros_to_ones mag_nonzerophases rr"r"s~h &&)C1HM %K MM!4>>!''#: ;E+% 5EJ+%EJEMC :r)r4r3cb|d|jddz z}|t|dz}tjd|jd|tj}t |j}t ||d<tj||}|tjdtjz| z}tj|d }|jD cgc]} d } } d | d<tj|| d }t|D] \} } |dt| t| dzf} tj| d}d|z tj| d z|tj| dzz}t!j"|||d| f<tj| dtj| d z |z }|dtjztj$|dtjzz zz }|||zz }|Scc} w)aPhase vocoder. Given an STFT matrix D, speed up by a factor of ``rate`` Based on the implementation provided by [#]_. This is a simplified implementation, intended primarily for reference and pedagogical purposes. It makes no attempt to handle transients, and is likely to produce many audible artifacts. For a higher quality implementation, we recommend the RubberBand library [#]_ and its Python wrapper `pyrubberband`. .. [#] Ellis, D. P. W. "A phase vocoder in Matlab." Columbia University, 2002. https://www.ee.columbia.edu/~dpwe/resources/matlab/pvoc/ .. [#] https://breakfastquay.com/rubberband/ Examples -------- >>> # Play at double speed >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> D = librosa.stft(y, n_fft=2048, hop_length=512) >>> D_fast = librosa.phase_vocoder(D, rate=2.0, hop_length=512) >>> y_fast = librosa.istft(D_fast, hop_length=512) >>> # Or play at 1/3 speed >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> D = librosa.stft(y, n_fft=2048, hop_length=512) >>> D_slow = librosa.phase_vocoder(D, rate=1./3, hop_length=512) >>> y_slow = librosa.istft(D_slow, hop_length=512) Parameters ---------- D : np.ndarray [shape=(..., d, t), dtype=complex] STFT matrix rate : float > 0 [scalar] Speed-up factor: ``rate > 1`` is faster, ``rate < 1`` is slower. hop_length : int > 0 [scalar] or None The number of samples between successive columns of ``D``. If None, defaults to ``n_fft//4 = (D.shape[0]-1)//2`` n_fft : int > 0 or None The number of samples per frame in D. By default (None), this will be inferred from the shape of D. However, if D was constructed using an odd-length window, the correct frame length can be specified here. Returns ------- D_stretched : np.ndarray [shape=(..., d, t / rate), dtype=complex] time-stretched STFT See Also -------- pyrubberband r rDrr<rrMrrRr).rrN)rr r2rO.?).r)rr)rSrYrarfloat64relen zeros_likerrranglerc enumeratemodrr phasorround)rrater4r3 time_stepsrS d_stretch phi_advance phase_accrsrttstepcolumnsalphardphases rr%r%UsB }QWWR[1_%!_ 1aggbk4rzzBJ MEJE"I au-Iw66!bee)5QQK6#I !ww'w!vwG'GBK q' +AZ(4CTS]223tS!U{bffWV_55wv@W8WW!KK s; #q&'&/*RXXgfo-FFT#+3;1G(HHH [6)) #)& /(s' H,rsossoxr_hq)rr5r4r7tuningr9flayoutres_typec v|dvrtd|tj|d||dz}|r>|jD cgc]} d} } |dz|dzf| d <t j || | }t d||d | \} } g}t j| }|D] }|jt|||| "td |jd |z |zz}t|j}||d <|jd t| t j||}|jD cgc] } td}} t!t#| | D]\}\}}||d<t j$||k(d}|dk(r-t&j(j+|d|d ||d }n*|dk(r%t&j(j-|||d }||z }||z }tt/||z }t j0djd |z |}t||krbtt j2||z|z}tj4||}t j0d|jd |z |}t j.|j7td|}tj8j;|t j0|}|t j<|d|fdzd z|t?|<|Scc} wcc} w)uTime-frequency representation using IIR filters This function will return a time-frequency representation using a multirate filter bank consisting of IIR filters. [#]_ First, ``y`` is resampled as needed according to the provided ``sample_rates``. Then, a filterbank with with ``n`` band-pass filters is designed. The resampled input signals are processed by the filterbank as a whole. (`scipy.signal.filtfilt` resp. `sosfiltfilt` is used to make the phase linear.) The output of the filterbank is cut into frames. For each band, the short-time mean-square power (STMSP) is calculated by summing ``win_length`` subsequent filtered time samples. When called with the default set of parameters, it will generate the TF-representation (pitch filterbank): * 85 filters with MIDI pitches [24, 108] as ``center_freqs``. * each filter having a bandwidth of one semitone. .. [#] Müller, Meinard. "Information Retrieval for Music and Motion." Springer Verlag. 2007. Parameters ---------- y : np.ndarray [shape=(..., n)] audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` win_length : int > 0, <= n_fft Window length. hop_length : int > 0 [scalar] Hop length, number samples between subsequent frames. If not supplied, defaults to ``win_length // 4``. center : boolean - If ``True``, the signal ``y`` is padded so that frame ``D[..., :, t]`` is centered at ``y[t * hop_length]``. - If ``False``, then `D[..., :, t]`` begins at ``y[t * hop_length]`` tuning : float [scalar] Tuning deviation from A440 in fractions of a bin. pad_mode : string If ``center=True``, the padding mode to use at the edges of the signal. By default, this function uses zero padding. flayout : string - If `sos` (default), a series of second-order filters is used for filtering with `scipy.signal.sosfiltfilt`. Minimizes numerical precision errors for high-order filters, but is slower. - If `ba`, the standard difference equation is used for filtering with `scipy.signal.filtfilt`. Can be unstable for high-order filters. res_type : string The resampling mode. See `librosa.resample` for details. **kwargs : additional keyword arguments Additional arguments for `librosa.filters.semitone_filterbank` (e.g., could be used to provide another set of ``center_freqs`` and ``sample_rates``). Returns ------- bands_power : np.ndarray [shape=(..., n, t), dtype=dtype] Short-time mean-square power for the input signal. Raises ------ ParameterError If ``flayout`` is not None, `ba`, or `sos`. See Also -------- librosa.filters.semitone_filterbank librosa.filters.mr_frequencies librosa.cqt scipy.signal.filtfilt scipy.signal.sosfiltfilt Examples -------- >>> import matplotlib.pyplot as plt >>> y, sr = librosa.load(librosa.ex('trumpet'), duration=3) >>> D = np.abs(librosa.iirt(y, sr=sr)) >>> C = np.abs(librosa.cqt(y=y, sr=sr)) >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> img = librosa.display.specshow(librosa.amplitude_to_db(C, ref=np.max), ... y_axis='cqt_hz', x_axis='time', ax=ax[0]) >>> ax[0].set(title='Constant-Q transform') >>> ax[0].label_outer() >>> img = librosa.display.specshow(librosa.amplitude_to_db(D, ref=np.max), ... y_axis='cqt_hz', x_axis='time', ax=ax[1]) >>> ax[1].set_title('Semitone spectrogram (iirt)') >>> fig.colorbar(img, ax=ax, format="%+2.0f dB") )barzUnsupported flayout=Fr>Nr<rNr rMrO)rr)orig_sr target_srrrrRrDrrrWrrB.) r r r[rSrarcruniquerrrYreinsertrrfslicerzip flatnonzeroscipysignalfiltfilt sosfiltfiltrrrbrastypeaddoutersumtuple)rqrr5r4r7rr9rrkwargsrsrt filterbank_ct sample_rates y_resampledy_srscur_srrrS bands_powerslicesi cur_filter cur_sr_idxcur_filter_outputfactorhop_length_STMSPwin_length_STMSP_round start_idx min_lengthidxs rr#r#sSPm#3G9=>> QU#1_ #$77+7a67+!Q a8 FF1gH -#6#w#*0#M< K IIl #E8ArVhWX1 j0Z??@H MEE"I LLS'(--/K%?!@II  &&r*-CCEU  y>H $BGGH'7789 ffll9bii0F&GH%+bff c3h '1 ,2/ & E&M"M$OT Q,:'Os  L19L6.refamintop_dbcyNrrr!r"r#s rr'r'rcyr%rr&s rr'r'r'rcyr%rr&s rr'r'r'rrg|=gT@ctj|}|dkr tdtj|jtj r-t jddtj|}n|}t|r ||}ntj|}dtjtj||z}|dtjtj||zz}|7|dkr tdtj||j|z }|S)a Convert a power spectrogram (amplitude squared) to decibel (dB) units This computes the scaling ``10 * log10(S / ref)`` in a numerically stable way. Parameters ---------- S : np.ndarray input power ref : scalar or callable If scalar, the amplitude ``abs(S)`` is scaled relative to ``ref``:: 10 * log10(S / ref) Zeros in the output correspond to positions where ``S == ref``. If callable, the reference value is computed as ``ref(S)``. amin : float > 0 [scalar] minimum threshold for ``abs(S)`` and ``ref`` top_db : float >= 0 [scalar] threshold the output at ``top_db`` below the peak: ``max(10 * log10(S/ref)) - top_db`` Returns ------- S_db : np.ndarray ``S_db ~= 10 * log10(S) - 10 * log10(ref)`` See Also -------- perceptual_weighting db_to_power amplitude_to_db db_to_amplitude Notes ----- This function caches at level 30. Examples -------- Get a power spectrogram from a waveform ``y`` >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> S = np.abs(librosa.stft(y)) >>> librosa.power_to_db(S**2) array([[-41.809, -41.809, ..., -41.809, -41.809], [-41.809, -41.809, ..., -41.809, -41.809], ..., [-41.809, -41.809, ..., -41.809, -41.809], [-41.809, -41.809, ..., -41.809, -41.809]], dtype=float32) Compute dB relative to peak power >>> librosa.power_to_db(S**2, ref=np.max) array([[-80., -80., ..., -80., -80.], [-80., -80., ..., -80., -80.], ..., [-80., -80., ..., -80., -80.], [-80., -80., ..., -80., -80.]], dtype=float32) Or compare to median power >>> librosa.power_to_db(S**2, ref=np.median) array([[16.578, 16.578, ..., 16.578, 16.578], [16.578, 16.578, ..., 16.578, 16.578], ..., [16.578, 16.578, ..., 16.578, 16.578], [16.578, 16.578, ..., 16.578, 16.578]], dtype=float32) And plot the results >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> imgpow = librosa.display.specshow(S**2, sr=sr, y_axis='log', x_axis='time', ... ax=ax[0]) >>> ax[0].set(title='Power spectrogram') >>> ax[0].label_outer() >>> imgdb = librosa.display.specshow(librosa.power_to_db(S**2, ref=np.max), ... sr=sr, y_axis='log', x_axis='time', ax=ax[1]) >>> ax[1].set(title='Log-Power spectrogram') >>> fig.colorbar(imgpow, ax=ax[0]) >>> fig.colorbar(imgdb, ax=ax[1], format="%+2.0f dB") rzamin must be strictly positivezpower_to_db was called on complex input so phase information will be discarded. To suppress this warning, call power_to_db(np.abs(D)**2) instead.r  stacklevel$@ztop_db must be non-negative) raasarrayr issubdtyper8complexfloatingr^r_rrlog10rIro)rr!r"r# magnitude ref_valuelog_specs rr'r's~ 1 A qy=>> }}QWWb001  6  FF1I  } N FF3K "((2::dI+F"GGH rxx 4 ;<<? ?::h (?@ Orr!cyr%rS_dbr!s rr(r(! rcyr%rr7s rr(r()r9rcyr%rr7s rr(r(1r9rc:|tjd|dzzS)aConvert dB-scale values to a power values. This effectively inverts ``power_to_db``:: db_to_power(S_db) ~= ref * 10.0**(S_db / 10) Parameters ---------- S_db : np.ndarray dB-scaled values ref : number > 0 Reference power: output will be scaled by this value Returns ------- S : np.ndarray Power values Notes ----- This function caches at level 30. r-g?)rarr7s rr(r(9s0 $s + ++rcyr%rr&s rr)r)Tr'rcyr%rr&s rr)r)^r'rcyr%rr&s rr)r)hr'rgh㈵>ctj|}tj|jtjrt j ddtj|}t|r ||}ntj|}t|tjr|nd}tj||}t||dz|dz|}|S)aConvert an amplitude spectrogram to dB-scaled spectrogram. This is equivalent to ``power_to_db(S**2, ref=ref**2, amin=amin**2, top_db=top_db)``, but is provided for convenience. Parameters ---------- S : np.ndarray input amplitude ref : scalar or callable If scalar, the amplitude ``abs(S)`` is scaled relative to ``ref``: ``20 * log10(S / ref)``. Zeros in the output correspond to positions where ``S == ref``. If callable, the reference value is computed as ``ref(S)``. amin : float > 0 [scalar] minimum threshold for ``S`` and ``ref`` top_db : float >= 0 [scalar] threshold the output at ``top_db`` below the peak: ``max(20 * log10(S/ref)) - top_db`` Returns ------- S_db : np.ndarray ``S`` measured in dB See Also -------- power_to_db, db_to_amplitude Notes ----- This function caches at level 30. zamplitude_to_db was called on complex input so phase information will be discarded. To suppress this warning, call amplitude_to_db(np.abs(S)) instead.r r+Nrr ) rar.r/r8r0r^r_rr isinstancendarraysquarer') rr!r"r#r2r3 out_arrayrdbs rr)r)rsZ 1 A }}QWWb001  7  q I} N FF3K ' 2::> DI IIiY /E IqLtQwvVB Ircyr%rr7s rr*r*r9rcyr%rr7s rr*r*r9rcyr%rr7s rr*r*r9rc(t||dzdzS)aConvert a dB-scaled spectrogram to an amplitude spectrogram. This effectively inverts `amplitude_to_db`:: db_to_amplitude(S_db) ~= 10.0**(0.5 * S_db/10 + log10(ref)) Parameters ---------- S_db : np.ndarray dB-scaled values ref : number > 0 Optional reference amplitude. Returns ------- S : np.ndarray Linear magnitude values Notes ----- This function caches at level 30. r r5r)r(r7s rr*r*s0 ta (C //rAkindc ptj||jd}|t|fi|z}|S)a Perceptual weighting of a power spectrogram:: S_p[..., f, :] = frequency_weighting(f, 'A') + 10*log(S[..., f, :] / ref) Parameters ---------- S : np.ndarray [shape=(..., d, t)] Power spectrogram frequencies : np.ndarray [shape=(d,)] Center frequency for each row of` `S`` kind : str The frequency weighting curve to use. e.g. `'A'`, `'B'`, `'C'`, `'D'`, `None or 'Z'` **kwargs : additional keyword arguments Additional keyword arguments to `power_to_db`. Returns ------- S_p : np.ndarray [shape=(..., d, t)] perceptually weighted version of ``S`` See Also -------- power_to_db Notes ----- This function caches at level 30. Examples -------- Re-weight a CQT power spectrum, using peak power as reference >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> C = np.abs(librosa.cqt(y, sr=sr, fmin=librosa.note_to_hz('A1'))) >>> freqs = librosa.cqt_frequencies(C.shape[0], ... fmin=librosa.note_to_hz('A1')) >>> perceptual_CQT = librosa.perceptual_weighting(C**2, ... freqs, ... ref=np.max) >>> perceptual_CQT array([[ -96.528, -97.101, ..., -108.561, -108.561], [ -95.88 , -96.479, ..., -107.551, -107.551], ..., [ -65.142, -53.256, ..., -80.098, -80.098], [ -71.542, -53.197, ..., -80.311, -80.311]]) >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> img = librosa.display.specshow(librosa.amplitude_to_db(C, ... ref=np.max), ... fmin=librosa.note_to_hz('A1'), ... y_axis='cqt_hz', x_axis='time', ... ax=ax[0]) >>> ax[0].set(title='Log CQT power') >>> ax[0].label_outer() >>> imgp = librosa.display.specshow(perceptual_CQT, y_axis='cqt_hz', ... fmin=librosa.note_to_hz('A1'), ... x_axis='time', ax=ax[1]) >>> ax[1].set(title='Perceptually weighted log CQT') >>> fig.colorbar(img, ax=ax[0], format="%+2.0f dB") >>> fig.colorbar(imgp, ax=ax[1], format="%+2.0f dB") rK)rMr)rfrequency_weightingreshaper')r frequenciesrLrrresults rr&r&s;F ( (4 @ H H QF+a":6"::F MrrcubicrM)t_minn_fmtrLbeta over_samplerXc |j|}|dkrtd|d|d|dkrtd|d||d krtd |d tj|d z tj|d z z }t tj |tj|d z tj|z z|z }nH|dkrtd |dtj|d z tj|d z z |z }tj tj|s tdtj|} tjdd |d} tjj| |||} t tj |} tjtj|tj|z |z d|| zd| d| } | d|ks| dt|dz |z kDr&tj| t||z | d} t!tj"| t!| k7r td| | }d g|j$z}d||<t'}|j)|| |zj+|tj,|z|z z|}|S)arFast Mellin transform (FMT) The Mellin of a signal `y` is performed by interpolating `y` on an exponential time axis, applying a polynomial window, and then taking the discrete Fourier transform. When the Mellin parameter (beta) is 1/2, it is also known as the scale transform. [#]_ The scale transform can be useful for audio analysis because its magnitude is invariant to scaling of the domain (e.g., time stretching or compression). This is analogous to the magnitude of the Fourier transform being invariant to shifts in the input domain. .. [#] De Sena, Antonio, and Davide Rocchesso. "A fast Mellin and scale transform." EURASIP Journal on Applied Signal Processing 2007.1 (2007): 75-75. .. [#] Cohen, L. "The scale representation." IEEE Transactions on Signal Processing 41, no. 12 (1993): 3275-3292. Parameters ---------- y : np.ndarray, real-valued The input signal(s). Can be multidimensional. The target axis must contain at least 3 samples. t_min : float > 0 The minimum time spacing (in samples). This value should generally be less than 1 to preserve as much information as possible. n_fmt : int > 2 or None The number of scale transform bins to use. If None, then ``n_bins = over_sample * ceil(n * log((n-1)/t_min))`` is taken, where ``n = y.shape[axis]`` kind : str The type of interpolation to use when re-sampling the input. See `scipy.interpolate.interp1d` for possible values. Note that the default is to use high-precision (cubic) interpolation. This can be slow in practice; if speed is preferred over accuracy, then consider using ``kind='linear'``. beta : float The Mellin parameter. ``beta=0.5`` provides the scale transform. over_sample : float >= 1 Over-sampling factor for exponential resampling. axis : int The axis along which to transform ``y`` Returns ------- x_scale : np.ndarray [dtype=complex] The scale transform of ``y`` along the ``axis`` dimension. Raises ------ ParameterError if ``n_fmt < 2`` or ``t_min <= 0`` or if ``y`` is not finite or if ``y.shape[axis] < 3``. Notes ----- This function caches at level 30. Examples -------- >>> # Generate a signal and time-stretch it (with energy normalization) >>> scale = 1.25 >>> freq = 3.0 >>> x1 = np.linspace(0, 1, num=1024, endpoint=False) >>> x2 = np.linspace(0, 1, num=int(scale * len(x1)), endpoint=False) >>> y1 = np.sin(2 * np.pi * freq * x1) >>> y2 = np.sin(2 * np.pi * freq * x2) / np.sqrt(scale) >>> # Verify that the two signals have the same energy >>> np.sum(np.abs(y1)**2), np.sum(np.abs(y2)**2) (255.99999999999997, 255.99999999999969) >>> scale1 = librosa.fmt(y1, n_fmt=512) >>> scale2 = librosa.fmt(y2, n_fmt=512) >>> # And plot the results >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=2) >>> ax[0].plot(y1, label='Original') >>> ax[0].plot(y2, linestyle='--', label='Stretched') >>> ax[0].set(xlabel='time (samples)', title='Input signals') >>> ax[0].legend() >>> ax[1].semilogy(np.abs(scale1), label='Original') >>> ax[1].semilogy(np.abs(scale2), linestyle='--', label='Stretched') >>> ax[1].set(xlabel='scale coefficients', title='Scale transform magnitude') >>> ax[1].legend() >>> # Plot the scale transform of an onset strength autocorrelation >>> y, sr = librosa.load(librosa.ex('choice')) >>> odf = librosa.onset.onset_strength(y=y, sr=sr) >>> # Auto-correlate with up to 10 seconds lag >>> odf_ac = librosa.autocorrelate(odf, max_size=10 * sr // 512) >>> # Normalize >>> odf_ac = librosa.util.normalize(odf_ac, norm=np.inf) >>> # Compute the scale transform >>> odf_ac_scale = librosa.fmt(librosa.util.normalize(odf_ac), n_fmt=512) >>> # Plot the results >>> fig, ax = plt.subplots(nrows=3) >>> ax[0].plot(odf, label='Onset strength') >>> ax[0].set(xlabel='Time (frames)', title='Onset strength') >>> ax[1].plot(odf_ac, label='Onset autocorrelation') >>> ax[1].set(xlabel='Lag (frames)', title='Onset autocorrelation') >>> ax[2].semilogy(np.abs(odf_ac_scale), label='Scale transform magnitude') >>> ax[2].set(xlabel='scale coefficients') zy.shape[z]==z < 3rzt_min=z must be a positive numberNrz over_sample=z must be >= 1r zn_fmt==zy must be finite everywhereF)numendpoint)rLrX)rYrZbaserMrz.Redundant sample positions in Mellin transformrW)rSr ralogrYrballisfiniteexplinspacer interpolateinterp1dlogspacerrrrrFrrkrOsqrt)rqrSrTrLrUrVrXrlog_baser[xf_interpn_overx_expy_resrSr~rQs rr+r+4sv  A1uxvS4899 zveW,FGHH } ? < }M!JK K 66!a%=266!a%=0BGGK266!a%=266%=+HIHTUV wugT233FF519%uqy(99[H 66"++a. !:;; 66( D Aqa%0A  ))!QT)EH% &F KK  "h. FN    w  E Qx%59uQW~'99uU|a/27 299U E *MNN UOEC%** EE$K ,C %+&&u- :UBC$"F Mr)rr4gainbiasr time_constantepsbmax_sizer!rXmax_axiszi return_zfcyr%rrrr4rkrlrrmrnrorpr!rXrqrrrss rr,r,&r) rr4rkrlrrmrnrorpr!rXrqrrcyr%rrus rr,r, rvrcyr%rrus rr,r,' rvrig\(\?g?cp|dkrtd|d|dkrtd|d|dkrtd|d|dkrtd|d|dkrtd |dtj| std | d |;||zt|z }t j d d|dzzzd z d|dzzz }d|cxkrd ksntd|dt j |jtjr,tjddt j|}| | d k(r|} n|jd k(r td| B|jdk7rtd|jddt jd | z d} tjj!|| | } | Zt#d g| jz}t j$|} tj&j)|gd |d z gd d | d d tj&j+|gd |d z g| | | \}}t j,| t j.|t j0||z zz}|dk(rt j0||z}n~|dk(rBt j,|t j.|t j.|zz}n7||zt j2|t j0||z|z zz}|r||fS|S)aPer-channel energy normalization (PCEN) This function normalizes a time-frequency representation ``S`` by performing automatic gain control, followed by nonlinear compression [#]_ :: P[f, t] = (S / (eps + M[f, t])**gain + bias)**power - bias**power IMPORTANT: the default values of eps, gain, bias, and power match the original publication, in which ``S`` is a 40-band mel-frequency spectrogram with 25 ms windowing, 10 ms frame shift, and raw audio values in the interval [-2**31; 2**31-1[. If you use these default values, we recommend to make sure that the raw audio is properly scaled to this interval, and not to [-1, 1[ as is most often the case. The matrix ``M`` is the result of applying a low-pass, temporal IIR filter to ``S``:: M[f, t] = (1 - b) * M[f, t - 1] + b * S[f, t] If ``b`` is not provided, it is calculated as:: b = (sqrt(1 + 4* T**2) - 1) / (2 * T**2) where ``T = time_constant * sr / hop_length``. [#]_ This normalization is designed to suppress background noise and emphasize foreground signals, and can be used as an alternative to decibel scaling (`amplitude_to_db`). This implementation also supports smoothing across frequency bins by specifying ``max_size > 1``. If this option is used, the filtered spectrogram ``M`` is computed as:: M[f, t] = (1 - b) * M[f, t - 1] + b * R[f, t] where ``R`` has been max-filtered along the frequency axis, similar to the SuperFlux algorithm implemented in `onset.onset_strength`:: R[f, t] = max(S[f - max_size//2: f + max_size//2, t]) This can be used to perform automatic gain control on signals that cross or span multiple frequency bans, which may be desirable for spectrograms with high frequency resolution. .. [#] Wang, Y., Getreuer, P., Hughes, T., Lyon, R. F., & Saurous, R. A. (2017, March). Trainable frontend for robust and far-field keyword spotting. In Acoustics, Speech and Signal Processing (ICASSP), 2017 IEEE International Conference on (pp. 5670-5674). IEEE. .. [#] Lostanlen, V., Salamon, J., McFee, B., Cartwright, M., Farnsworth, A., Kelling, S., and Bello, J. P. Per-Channel Energy Normalization: Why and How. IEEE Signal Processing Letters, 26(1), 39-43. Parameters ---------- S : np.ndarray (non-negative) The input (magnitude) spectrogram sr : number > 0 [scalar] The audio sampling rate hop_length : int > 0 [scalar] The hop length of ``S``, expressed in samples gain : number >= 0 [scalar] The gain factor. Typical values should be slightly less than 1. bias : number >= 0 [scalar] The bias point of the nonlinear compression (default: 2) power : number >= 0 [scalar] The compression exponent. Typical values should be between 0 and 0.5. Smaller values of ``power`` result in stronger compression. At the limit ``power=0``, polynomial compression becomes logarithmic. time_constant : number > 0 [scalar] The time constant for IIR filtering, measured in seconds. eps : number > 0 [scalar] A small constant used to ensure numerical stability of the filter. b : number in [0, 1] [scalar] The filter coefficient for the low-pass filter. If not provided, it will be inferred from ``time_constant``. max_size : int > 0 [scalar] The width of the max filter applied to the frequency axis. If left as `1`, no filtering is performed. ref : None or np.ndarray (shape=S.shape) An optional pre-computed reference spectrum (``R`` in the above). If not provided it will be computed from ``S``. axis : int [scalar] The (time) axis of the input spectrogram. max_axis : None or int [scalar] The frequency axis of the input spectrogram. If `None`, and ``S`` is two-dimensional, it will be inferred as the opposite from ``axis``. If ``S`` is not two-dimensional, and ``max_size > 1``, an error will be raised. zi : np.ndarray The initial filter delay values. This may be the ``zf`` (final delay values) of a previous call to ``pcen``, or computed by `scipy.signal.lfilter_zi`. return_zf : bool If ``True``, return the final filter delay values along with the PCEN output ``P``. This is primarily useful in streaming contexts, where the final state of one block of processing should be used to initialize the next block. If ``False`` (default) only the PCEN values ``P`` are returned. Returns ------- P : np.ndarray, non-negative [shape=(n, m)] The per-channel energy normalized version of ``S``. zf : np.ndarray (optional) The final filter delay values. Only returned if ``return_zf=True``. See Also -------- amplitude_to_db librosa.onset.onset_strength Examples -------- Compare PCEN to log amplitude (dB) scaling on Mel spectra >>> import matplotlib.pyplot as plt >>> y, sr = librosa.load(librosa.ex('robin')) >>> # We recommend scaling y to the range [-2**31, 2**31[ before applying >>> # PCEN's default parameters. Furthermore, we use power=1 to get a >>> # magnitude spectrum instead of a power spectrum. >>> S = librosa.feature.melspectrogram(y=y, sr=sr, power=1) >>> log_S = librosa.amplitude_to_db(S, ref=np.max) >>> pcen_S = librosa.pcen(S * (2**31)) >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> img = librosa.display.specshow(log_S, x_axis='time', y_axis='mel', ax=ax[0]) >>> ax[0].set(title='log amplitude (dB)', xlabel=None) >>> ax[0].label_outer() >>> imgpcen = librosa.display.specshow(pcen_S, x_axis='time', y_axis='mel', ax=ax[1]) >>> ax[1].set(title='Per-channel energy normalization') >>> fig.colorbar(img, ax=ax[0], format="%+2.0f dB") >>> fig.colorbar(imgpcen, ax=ax[1]) Compare PCEN with and without max-filtering >>> pcen_max = librosa.pcen(S * (2**31), max_size=3) >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> librosa.display.specshow(pcen_S, x_axis='time', y_axis='mel', ax=ax[0]) >>> ax[0].set(title='Per-channel energy normalization (no max-filter)') >>> ax[0].label_outer() >>> img = librosa.display.specshow(pcen_max, x_axis='time', y_axis='mel', ax=ax[1]) >>> ax[1].set(title='Per-channel energy normalization (max_size=3)') >>> fig.colorbar(img, ax=ax) rzpower=z must be nonnegativezgain=z must be non-negativezbias=zeps=z must be strictly positiveztime_constant=z max_size=r=Nrr<r zb=z must be between 0 and 1zpcen was called on complex input so phase information will be discarded. To suppress this warning, call pcen(np.abs(D)) instead.r+z6Max-filtering cannot be applied to 1-dimensional inputzMax-filtering a dz9-dimensional spectrogram requires you to specify max_axisrW)rrrX)r r rZrrardr/r8r0r^r_rrFrrndimagemaximum_filter1dr emptyr lfilter_zilfilterr_r\log1pexpm1)rrr4rkrlrrmrnrorpr!rXrqrrrst_framesrSS_smoothzfsmoothS_outs rr,r,= s'h qyveW,@ABB axuTF*?@AA axuTF*?@AA axtC5(BCDD~m_> }}QWWb001  ,  FF1I { q=C VVq[ H 66Q;(*166!*5;; 66!d(A.--00H80LC zqcCHHn% XXe_ ''aQZ8;1 <<''aQZ$'OLHbVVTERVVC[288HsN+CCD EF zV$ uq BFF6N :;<u!f*t:K1L)L MMby r gGz?random) n_iterr4r5r3r6r7r8rr9momentuminit random_statec f| tjj} nt| tr!tjj | } nOt| tjj tjj fr| } ntd| | dkDrtjd| ddn| d krtd | d |d|jd dz z}tj|jtj|j }tj|}| dk(rGtj dtj"z| j|jz|ddn| d|ddntd| dd}d}d}||z}t%|D]b}t'||||||||| }t)||||||| |}||dd||| d| zz |zz}|tj*||zz}||z}||}}dt'||||||||| S)uApproximate magnitude spectrogram inversion using the "fast" Griffin-Lim algorithm. Given a short-time Fourier transform magnitude matrix (``S``), the algorithm randomly initializes phase estimates, and then alternates forward- and inverse-STFT operations. [#]_ Note that this assumes reconstruction of a real-valued time-domain signal, and that ``S`` contains only the non-negative frequencies (as computed by `stft`). The "fast" GL method [#]_ uses a momentum parameter to accelerate convergence. .. [#] D. W. Griffin and J. S. Lim, "Signal estimation from modified short-time Fourier transform," IEEE Trans. ASSP, vol.32, no.2, pp.236–243, Apr. 1984. .. [#] Perraudin, N., Balazs, P., & Søndergaard, P. L. "A fast Griffin-Lim algorithm," IEEE Workshop on Applications of Signal Processing to Audio and Acoustics (pp. 1-4), Oct. 2013. Parameters ---------- S : np.ndarray [shape=(..., n_fft // 2 + 1, t), non-negative] An array of short-time Fourier transform magnitudes as produced by `stft`. n_iter : int > 0 The number of iterations to run hop_length : None or int > 0 The hop length of the STFT. If not provided, it will default to ``n_fft // 4`` win_length : None or int > 0 The window length of the STFT. By default, it will equal ``n_fft`` n_fft : None or int > 0 The number of samples per frame. By default, this will be inferred from the shape of ``S`` as an even number. However, if an odd frame length was used, you can explicitly set ``n_fft``. window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)] A window specification as supported by `stft` or `istft` center : boolean If ``True``, the STFT is assumed to use centered frames. If ``False``, the STFT is assumed to use left-aligned frames. dtype : np.dtype Real numeric type for the time-domain signal. Default is inferred to match the precision of the input spectrogram. length : None or int > 0 If provided, the output ``y`` is zero-padded or clipped to exactly ``length`` samples. pad_mode : string If ``center=True``, the padding mode to use at the edges of the signal. By default, STFT uses zero padding. momentum : number >= 0 The momentum parameter for fast Griffin-Lim. Setting this to 0 recovers the original Griffin-Lim method [1]_. Values near 1 can lead to faster convergence, but above 1 may not converge. init : None or 'random' [default] If 'random' (the default), then phase values are initialized randomly according to ``random_state``. This is recommended when the input ``S`` is a magnitude spectrogram with no initial phase estimates. If `None`, then the phase is initialized from ``S``. This is useful when an initial guess for phase can be provided, or when you want to resume Griffin-Lim from a previous output. random_state : None, int, np.random.RandomState, or np.random.Generator If int, random_state is the seed used by the random number generator for phase initialization. If `np.random.RandomState` or `np.random.Generator` instance, the random number generator itself. If `None`, defaults to the `np.random.default_rng()` object. Returns ------- y : np.ndarray [shape=(..., n)] time-domain signal reconstructed from ``S`` See Also -------- stft istft magphase filters.get_window Examples -------- A basic STFT inverse example >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> # Get the magnitude spectrogram >>> S = np.abs(librosa.stft(y)) >>> # Invert using Griffin-Lim >>> y_inv = librosa.griffinlim(S) >>> # Invert without estimating phase >>> y_istft = librosa.istft(S) Wave-plot the results >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=3, sharex=True, sharey=True) >>> librosa.display.waveshow(y, sr=sr, color='b', ax=ax[0]) >>> ax[0].set(title='Original', xlabel=None) >>> ax[0].label_outer() >>> librosa.display.waveshow(y_inv, sr=sr, color='g', ax=ax[1]) >>> ax[1].set(title='Griffin-Lim reconstruction', xlabel=None) >>> ax[1].label_outer() >>> librosa.display.waveshow(y_istft, sr=sr, color='r', ax=ax[2]) >>> ax[2].set_title('Magnitude-only istft reconstruction') N)seedzUnsupported random_state=rzGriffin-Lim with momentum=z+ > 1 can be unstable. Proceed with caution!r r+rz"griffinlim() called with momentum=z < 0rDrrrBrzinit=z must either None or 'random'r)r3r4r5r6r7r9r:)rar default_rngrArY RandomState Generatorr r^r_rSr}r rgr8rrrr`r!r r)rrr4r5r3r6r7r8rr9rrrrnganglesrnrebuilttprevinverserss rr-r-J sWTii##% L# &ii###6 L299#8#8")):M:M"N O88HIJJ!| ( 3$ $ AA(4PQQ }QWWR[1_%XXaggT^^AGG%< =F ))F C xKKRUUSZZQWWZ-E!EGq q uTF*GHIIG EG aKF 6] !!   !!  q   x1x<0E9 9F"&&.3&&! CH    r rqrr3r4rr5r6r7r9c |3||dzdz|jdk7rd|jddz z}||fS|td|| tdtjt ||||||||z}||fS)a Retrieve a magnitude spectrogram. This is primarily used in feature extraction functions that can operate on either audio time-series or spectrogram input. Parameters ---------- y : None or np.ndarray If provided, an audio time series S : None or np.ndarray Spectrogram input, optional n_fft : int > 0 STFT window size hop_length : int > 0 STFT hop length power : float > 0 Exponent for the magnitude spectrogram, e.g., 1 for energy, 2 for power, etc. win_length : int <= n_fft [scalar] Each frame of audio is windowed by ``window``. The window will be of length ``win_length`` and then padded with zeros to match ``n_fft``. If unspecified, defaults to ``win_length = n_fft``. window : string, tuple, number, function, or np.ndarray [shape=(n_fft,)] - a window specification (string, tuple, or number); see `scipy.signal.get_window` - a window function, such as `scipy.signal.windows.hann` - a vector or array of length ``n_fft`` .. see also:: `filters.get_window` center : boolean - If ``True``, the signal ``y`` is padded so that frame ``t`` is centered at ``y[t * hop_length]``. - If ``False``, then frame ``t`` begins at ``y[t * hop_length]`` pad_mode : string If ``center=True``, the padding mode to use at the edges of the signal. By default, STFT uses zero padding. Returns ------- S_out : np.ndarray [dtype=np.float] - If ``S`` is provided as input, then ``S_out == S`` - Else, ``S_out = |stft(y, ...)|**power`` n_fft : int > 0 - If ``S`` is provided, then ``n_fft`` is inferred from ``S`` - Else, copied from input r rrDz)Unable to compute spectrogram with n_fft=z6Input signal must be provided to compute a spectrogram)r3r4r5r7r6r9)rSr rarr rs r _spectrogramr/ sH } =EQJNaggbk9q)E0 e8O+ = #LUG!TU U 9 H  FF))!!%    e8Or)rq np.ndarrayr3rYr4 Optional[int]r5rr6rr7boolr8Optional[DTypeLike]r9rr:Optional[np.ndarray]returnr)rrr4rr5rr3rr6rr7rr8rrrr:rrr) rNr0NNr1TNr2)rqrrrrrr3rYr4rr5rr6rr7rr8rr9rrTuple[np.ndarray, np.ndarray]) rqrrrrrr3rYr4rr5rr6rr7rrrrrrUnion[float, Callable]rrrrr8rr9rrz)Tuple[np.ndarray, np.ndarray, np.ndarray])rrrrrr) rrrrr4rr3rrr)rqrrrr5rYr4rr7rrrr9rrstrrrrrrr) rrr!rr"rr#Optional[float]rnp.floating[Any]) rz_SequenceLike[_ComplexLike_co]r!rr"rr#rrr) rz"_ScalarOrSequence[_ComplexLike_co]r!rr"rr#rr#Union[np.floating[Any], np.ndarray])r8rr!rrr)r8rr!rrr)r8z Union[_FloatLike_co, np.ndarray]r!rrr) rrrPrrLrrrrr)rqrrSrrTrrLrrUrrVrrXrYrr) rrrrr4rYrkrrlrrrrmrrnrrorrprYr!rrXrYrqrrrrrszLiteral[False]rr) rrrrr4rYrkrrlrrrrmrrnrrorrprYr!rrXrYrqrrrrrsz Literal[True]rr) rrrrr4rYrkrrlrrrrmrrnrrorrprYr!rrXrYrqrrrrrsrrz0Union[np.ndarray, Tuple[np.ndarray, np.ndarray]])rrrrYr4rr5rr3rr6rr7rr8rrrr9rrrrz Optional[str]rz@Optional[Union[int, np.random.RandomState, np.random.Generator]]rr)rqrrrr3rr4rrrr5rr6rr7rr9rrzTuple[np.ndarray, int])B__doc__ __future__rr^numpyrar scipy.ndimage scipy.signalscipy.interpolatenumbarrr~raudior_cacher r util.exceptionsr filtersr rr numpy.typingrtypingrrrrrrrtyping_extensionsr_typingrrrrrrr__all__r r!rrrr$r"r%r#r'r(r)r*r&r+r,r-rrrrrs(" ,5&"HHH% $R $ $ !%' $OO O O  O  O O OO OOOd R!% $ !% $h h h  h  h  h  h  h  h  h h h Vd$ >  >$" $ $ !%'`` ``  `  `  ` ` ` ``#`J" $ $ !%'rr rr  r  r  r r r rr#rp" $ $ !%(,!%'!oo o o  o  oo o ooo&oo o o !o"/#od /0BR!% ll l l  l  l^R $#{{ { {  {  { {{{{{{{| #&!          #&! %         #&! )      )  R#&" |)| |  |  | ) ||~           * )  RHK,,4 #&!          #&! %         #&! )      )  R#&" B)B B  B  B ) BBJ            * )  RLO004R;>EE *E58EJMEEEPRCC C  C  C  CC CCCL  #!" #!            !"# *  #!"            !"## *  #!"!            !"6# *R  $"#!II I I  I  I II III I II I !I"6#II^ $ $ !% '" !bb b b  b  b b b b bbb bb"#bN#" # $ '___  _  _  __ _ ___r