From f5881e914a7ec225b329fdb2900a3a1ebe0bbaa0 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Mon, 24 Jun 2024 11:36:23 +0200 Subject: [PATCH 01/35] new parameter frequency dependent window --- .../transfer_functions/transfer_functions.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index fa3a0ef..67868e3 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -1251,12 +1251,13 @@ def window_frequency_dependent( channel: int | None = None, frequency_range_hz: list | None = None, scaling: str | None = None, + end_window_value: float = 0.5, ): """A spectrum with frequency-dependent windowing defined by cycles is returned. To this end, a variable gaussian window is applied. A width of 5 cycles means that there are 5 periods of each frequency - before the window values hit 0.5, i.e., -6 dB. + before the window values hit `end_window_value`. This is computed only for real-valued signals (positive frequencies). @@ -1278,6 +1279,9 @@ def window_frequency_dependent( `"amplitude spectral density"`, `"fft"` or `None`. The first two take the window into account. `"fft"` scales the forward FFT by `1/N**0.5` and `None` leaves the spectrum completely unscaled. Default: `None`. + end_window_value : float, optional + This is the value that the gaussian window should have at its width. + Default: 0.5. Returns ------- @@ -1343,11 +1347,13 @@ def window_frequency_dependent( spec = np.zeros((len(f), td.shape[1]), dtype=np.complex128) + # Alpha such that window is exactly end_window_value after the number of + # required samples for each frequency half = (td.shape[0] - 1) / 2 - alpha_factor = np.log(4) ** 0.5 * half - ind_max = np.argmax(np.abs(td), axis=0) + alpha_factor = np.log(1 / (end_window_value) ** 2) ** 0.5 * half # Construct window vectors + ind_max = np.argmax(np.abs(td), axis=0) n = np.zeros_like(td) for ch in range(td.shape[1]): n[:, ch] = np.arange(-ind_max[ch], td.shape[0] - ind_max[ch]) @@ -1378,9 +1384,7 @@ def scaling_func(window: np.ndarray): def scaling_func(window: np.ndarray): return 1 - # Precompute window factors: - # Alpha such that window is exactly 0.5 after the number of - # required samples for each frequency + # Precompute some window factors n = -0.5 * (n / half) ** 2 alpha = (alpha_factor / cycles_per_freq_samples) ** 2 for ind, ind_f in enumerate(inds_f): From 535107ee7bf42798ce41ba2d33808a689109df66 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Wed, 3 Jul 2024 14:02:38 +0200 Subject: [PATCH 02/35] bug fix for single frequency in frequency dependent window --- dsptoolbox/transfer_functions/transfer_functions.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index 67868e3..252528c 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -1340,10 +1340,12 @@ def window_frequency_dependent( # Samples for each frequency according to number of cycles if f[0] == 0: - f[0] = f[1] + if len(f) > 1: + f[0] = f[1] cycles_per_freq_samples = np.round(fs / f * cycles).astype(int) - if f[0] == f[1]: - f[0] = 0 + if len(f) > 1: + if f[0] == f[1]: + f[0] = 0 spec = np.zeros((len(f), td.shape[1]), dtype=np.complex128) From 6b22800ea77c88d4ab9baa7ffce0a75ff2017c98 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Wed, 10 Jul 2024 16:24:11 +0200 Subject: [PATCH 03/35] added spectrum interpolation --- dsptoolbox/_general_helpers.py | 126 +++++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index e54ab31..f3a81e0 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -1406,3 +1406,129 @@ def _fractional_latency( xcor[:, i] = correlate(td2[:, i], td1[:, i]) inds = _get_fractional_impulse_peak_index(xcor, polynomial_points) return td1.shape[0] - inds - 1 + + +def _interpolate_fr( + f_interp: NDArray[np.float64], + fr_interp: NDArray[np.float64], + f_target: NDArray[np.float64], + mode: str | None = None, + interpolation_scheme: str = "linear", +) -> NDArray[np.float64]: + """Interpolate one frequency response to a new frequency vector. + + Parameters + ---------- + f_interp : NDArray[np.float64] + Frequency vector of the frequency response that should be interpolated. + fr_interp : NDArray[np.float64] + Frequency response to be interpolated. + f_target : NDArray[np.float64] + Target frequency vector. + mode : str, optional + Convert to amplitude or power representation from dB during + interpolation (or the other way around) using the modes `"db2power"` + (input in dB, interpolation in power spectrum, output in dB), + `"db2amplitude"`, `"amplitude2db"`, `"power2db"`. Pass `None` to avoid + any conversion. Default: `None`. + interpolation_scheme : str, optional + Type of interpolation to use. See `scipy.interpolation.interp1d` for + details. Choose from `"quadratic"` or `"cubic"` splines, or `"linear"`. + Default: `"linear"`. + + Returns + ------- + NDArray[np.float64] + New interpolated frequency response corresponding to `f_target` vector. + + Notes + ----- + - The input is always assumed to be already sorted. + - In case `f_target` has values outside the boundaries of `f_interp`, + the first and last values of `fr_interp` are used for extrapolation. This + also applies if interpolation is done in dB. If done in amplitude or + power units, the fill value outside the boundaries is 0. + - The interpolation is always done along the first (outer) axis or the + vector. + - Theoretical thoughts on interpolating an amplitude or power + frequency response: + - Using complex and dB values during interpolation are not very precise + when comparing the results in terms of the amplitude or power + spectrum. + - Interpolation can be done with amplitude or power representation with + similar precision. + - Changing the frequency resolution in a linear scale means zero- + padding or trimming the underlying time series. For an amplitude + representation , i.e. spectrum or spectral density, the values must + be scaled using the factor `old_length/new_length`. This ensures that + the RMS values (amplitude spectrum) are still correct, and that + integrating the new power spectral density still renders the total + signal's energy truthfully, i.e. parseval's theorem would still hold. + For the power representation, it also applies with the same squared + factor. + - A direct FFT-result which is not in physical units needs rescaling + depending on the normalization scheme used during the FFT -> IFFT (in + the complex/amplitude representation): + - Forward: scaling factor `old_length/new_length`. + - Backward: no rescaling. + - Orthogonal: scaling factor `(old_length/new_length)**0.5` + - Interpolating the (amplitude or power) spectrum to a logarithmic- + spaced frequency vector can be done without rescaling (the underlying + transformation in the time domain would be warping). Doing so for the + (amplitude or power) spectral density only retains its validity if + the new spectrum is weighted exponentially with increasing frequency + since each bin contains the energy of a larger “frequency band” + (this changes the physical units of the spectral density). Doing so + ensures that integrating the power spectral density over frequency + still retains the energy of the signal (parseval). + - Assuming a different time window in each frequency resolution would + require knowing the specific windows in order to rescale correctly. + Assuming the same time window while zero-padding in the time domain + would mean that no rescaling has to be applied. + + """ + + fill_value = (fr_interp[0], fr_interp[-1]) + + # Conversion if necessary + if mode is not None: + mode = mode.lower() + factor = 20 if "amplitude" in mode else 10 + if mode[:3] == "db2": + fr_interp = 10 ** (fr_interp / factor) + fill_value = (0.0, 0.0) + elif mode[-3:] == "2db": + fr_interp = factor * np.log10( + np.clip( + np.abs(fr_interp), + a_min=np.finfo(np.float64).smallest_normal, + a_max=None, + ) + ) + else: + raise ValueError(f"Unsupported interpolation mode: {mode}") + + interpolated = interp1d( + f_interp, + fr_interp, + kind=interpolation_scheme, + bounds_error=False, + assume_sorted=True, + fill_value=fill_value, + axis=0, + )(f_target) + + # Back conversion if activated + if mode is not None: + if mode[:3] == "db2": + interpolated = factor * np.log10( + np.clip( + np.abs(interpolated), + a_min=np.finfo(np.float64).smallest_normal, + a_max=None, + ) + ) + elif mode[-3:] == "2db": + interpolated = 10 ** (interpolated / factor) + + return interpolated From 5b18434510af931b736c3c88782849258617765c Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Wed, 10 Jul 2024 16:24:53 +0200 Subject: [PATCH 04/35] minor changes --- dsptoolbox/_general_helpers.py | 3 ++- dsptoolbox/room_acoustics/room_acoustics.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index f3a81e0..061175d 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -3,6 +3,7 @@ """ import numpy as np +from numpy.typing import NDArray from scipy.signal import ( windows, convolve as scipy_convolve, @@ -979,7 +980,7 @@ def _get_exact_gain_1khz(f: np.ndarray, sp_db: np.ndarray) -> float: + "given frequency vector" ) # Get nearest value just before - ind = _find_nearest(1e3, f) + ind = _find_nearest(1e3, f).squeeze() if f[ind] > 1e3: ind -= 1 return (sp_db[ind + 1] - sp_db[ind]) / (f[ind + 1] - f[ind]) * ( diff --git a/dsptoolbox/room_acoustics/room_acoustics.py b/dsptoolbox/room_acoustics/room_acoustics.py index a16ed1c..a9f59ea 100644 --- a/dsptoolbox/room_acoustics/room_acoustics.py +++ b/dsptoolbox/room_acoustics/room_acoustics.py @@ -195,7 +195,7 @@ def find_modes( id_cmif, _ = find_peaks( 10 * np.log10(cmif), distance=dist_samp, - width=dist_samp, + # width=dist_samp, # Is width here a good idea? prominence=prominence_db, ) f_modes = f[id_cmif] From 9bbf593219d7dc4f4e2993e2efc35e1df040c8ab Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 12 Jul 2024 15:38:31 +0200 Subject: [PATCH 05/35] added gain to some biquads --- dsptoolbox/classes/_filter.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/dsptoolbox/classes/_filter.py b/dsptoolbox/classes/_filter.py index d36de64..2509c9b 100644 --- a/dsptoolbox/classes/_filter.py +++ b/dsptoolbox/classes/_filter.py @@ -60,7 +60,7 @@ def _biquad_coefficients( eq_type: int | str = 0, fs_hz: int = 48000, frequency_hz: float | list | tuple | np.ndarray = 1000, - gain_db: float = 1, + gain_db: float = 0, q: float = 1, ): """Creates the filter coefficients for biquad filters. @@ -84,7 +84,7 @@ def _biquad_coefficients( + "not supported. A mean of passed frequencies was used for the " + "design but this might not give the intended result!" ) - A = np.sqrt(10 ** (gain_db / 20.0)) + A = 10 ** (gain_db / 40) if eq_type in (0, 7, 8) else 10 ** (gain_db / 20) Omega = 2.0 * np.pi * (frequency_hz / fs_hz) sn = np.sin(Omega) cs = np.cos(Omega) @@ -99,44 +99,44 @@ def _biquad_coefficients( a[1] = -2 * cs a[2] = 1 - alpha / A elif eq_type == 1: # Lowpass - b[0] = (1 - cs) / 2 - b[1] = 1 - cs + b[0] = (1 - cs) / 2 * A + b[1] = (1 - cs) * A b[2] = b[0] a[0] = 1 + alpha a[1] = -2 * cs a[2] = 1 - alpha elif eq_type == 2: # Highpass - b[0] = (1 + cs) / 2.0 - b[1] = -1 * (1 + cs) + b[0] = (1 + cs) / 2.0 * A + b[1] = -1 * (1 + cs) * A b[2] = b[0] a[0] = 1 + alpha a[1] = -2 * cs a[2] = 1 - alpha elif eq_type == 3: # Bandpass skirt - b[0] = sn / 2 + b[0] = sn / 2 * A b[1] = 0 b[2] = -b[0] a[0] = 1 + alpha a[1] = -2 * cs a[2] = 1 - alpha elif eq_type == 4: # Bandpass peak - b[0] = alpha + b[0] = alpha * A b[1] = 0 b[2] = -b[0] a[0] = 1 + alpha a[1] = -2 * cs a[2] = 1 - alpha elif eq_type == 5: # Notch - b[0] = 1 - b[1] = -2 * cs + b[0] = 1 * A + b[1] = -2 * cs * A b[2] = b[0] a[0] = 1 + alpha a[1] = -2 * cs a[2] = 1 - alpha elif eq_type == 6: # Allpass - b[0] = 1 - alpha - b[1] = -2 * cs - b[2] = 1 + alpha + b[0] = (1 - alpha) * A + b[1] = -2 * cs * A + b[2] = (1 + alpha) * A a[0] = 1 + alpha a[1] = -2 * cs a[2] = 1 - alpha From ea19abc6a51ff6604f522ca6a15bf97be28270f1 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 12 Jul 2024 15:42:30 +0200 Subject: [PATCH 06/35] added matched biquad filters --- dsptoolbox/filterbanks/__init__.py | 2 + dsptoolbox/filterbanks/_filterbank.py | 161 ++++++++++++++++++++++++++ dsptoolbox/filterbanks/filterbanks.py | 129 ++++++++++++++++++++- tests/test_filterbanks.py | 39 +++++++ 4 files changed, 330 insertions(+), 1 deletion(-) diff --git a/dsptoolbox/filterbanks/__init__.py b/dsptoolbox/filterbanks/__init__.py index 8bee361..fd4fcc9 100644 --- a/dsptoolbox/filterbanks/__init__.py +++ b/dsptoolbox/filterbanks/__init__.py @@ -44,6 +44,7 @@ complementary_fir_filter, convert_into_lattice_filter, pinking_filter, + matched_biquad, ) from ..classes._lattice_ladder_filter import LatticeLadderFilter @@ -63,4 +64,5 @@ "PhaseLinearizer", "StateVariableFilter", "pinking_filter", + "matched_biquad", ] diff --git a/dsptoolbox/filterbanks/_filterbank.py b/dsptoolbox/filterbanks/_filterbank.py index d84d141..866a0b6 100644 --- a/dsptoolbox/filterbanks/_filterbank.py +++ b/dsptoolbox/filterbanks/_filterbank.py @@ -1428,3 +1428,164 @@ def _get_2nd_order_linkwitz_riley( b, a = bilinear(b_s, a_s, warped) high_sos = tf2sos(b, a) return low_sos, high_sos + + +def _get_matched_peaking_eq(f, g_db, q, q_factor, fs): + """Analog-matched peaking eq coefficients.""" + if q_factor is None: + # Manually extracted approximation for gains between -20 and 20 + # at normalized frequency = 0.02 + q_factor = np.max([np.abs(0.0868 * g_db + 1.264), 0.55]) + assert q_factor > 0, "Q-factor should be greater than 0" + + omega0 = 2 * np.pi * f / fs + g = 10 ** (g_db / 20) + q *= q_factor + + a, A, phi = __get_matched_eq_helpers(omega0, q) + + R1 = g**2 * (A @ phi) + R2 = g**2 * (-A[0] + A[1] + 4 * (phi[0] - phi[1]) * A[2]) + B0 = A[0] + B2 = (R1 - R2 * phi[1] - B0) / (4 * phi[1] ** 2) + B1 = R2 + B0 + 4 * (phi[1] - phi[0]) * B2 + W = 0.5 * (B0**0.5 + B1**0.5) + + # b coefficients + b0 = 0.5 * (W + (W**2 + B2) ** 0.5) + b1 = 0.5 * (B0**0.5 - B1**0.5) + b2 = -B2 / (4 * b0) + return np.array([b0, b1, b2]), a + + +def _get_matched_lowpass_eq(f, g_db, q, fs): + """Analog-matched lowpass eq coefficents.""" + omega0 = 2 * np.pi * f / fs + Q = q + + a, A, phi = __get_matched_eq_helpers(omega0, q) + + R1 = Q**2 * (A @ phi) + B0 = A[0] + B1 = (R1 - B0 * phi[0]) / phi[1] + b0 = 0.5 * (np.sum(a) + B1**0.5) + b1 = np.sum(a) - b0 + b2 = 0 + + b = np.array([b0, b1, b2]) * 10 ** (g_db / 20) + return b, a + + +def _get_matched_highpass_eq(f, g_db, q, fs): + """Analog-matched highpass eq coefficents.""" + omega0 = 2 * np.pi * f / fs + Q = q + a, A, phi = __get_matched_eq_helpers(omega0, q) + + b0 = (A @ phi) ** 0.5 / 4 / phi[1] * Q * 10 ** (g_db / 20) + b1 = -2 * b0 + b2 = b0 + return np.array([b0, b1, b2]), a + + +def _get_matched_bandpass_eq(f, g_db, q, fs): + """Analog-matched bandpass eq coefficents.""" + omega0 = 2 * np.pi * f / fs + + a, A, phi = __get_matched_eq_helpers(omega0, q) + + R1 = A @ phi + R2 = -A[0] + A[1] + 4 * (phi[0] - phi[1]) * A[2] + B2 = (R1 - R2 * phi[1]) / 4 / phi[1] ** 2 + B1 = R2 + 4 * (phi[1] - phi[0]) * B2 + b1 = -0.5 * B1**0.5 + b0 = 0.5 * ((B2 + b1**2) ** 0.5 - b1) + b2 = -b0 - b1 + b = np.array([b0, b1, b2]) * 10 ** (g_db / 20) + return b, a + + +def _get_matched_shelving_eq(f, g_db, fs, lowshelf): + """Analog-matched low/highshelf eq coefficients with fixed + `q=np.sqrt(2)/2`. + + """ + fc = f / (fs / 2) + + G = 10 ** (g_db / 20) + + if lowshelf: + G = 1 / G + + if np.abs(1 - G) < 1e-6: + G = 1 + 1e-6 + + f1 = fc / (0.16 + 1.543 * fc**2) ** 0.5 + f2 = fc / (0.947 + 3.806 * fc**2) ** 0.5 + hny = (fc**4 + G) / (fc**4 + 1 / G) + + phi1 = np.sin(np.pi / 2 * f1) ** 2 + phi2 = np.sin(np.pi / 2 * f2) ** 2 + h1 = (fc**4 + f1**4 * G) / (fc**4 + f1**4 / G) + h2 = (fc**4 + f2**4 * G) / (fc**4 + f2**4 / G) + + d1 = (h1 - 1) * (1 - phi1) + c11 = -phi1 * d1 + c12 = (hny - h1) * phi1**2 + + d2 = (h2 - 1) * (1 - phi2) + c21 = -phi2 * d2 + c22 = (hny - h2) * phi2**2 + + alpha1 = (c22 * d1 - c12 * d2) / (c11 * c22 - c12 * c21) + alpha2 = (d1 - c11 * alpha1) / c12 + + beta1 = alpha1 + beta2 = hny * alpha2 + + A0 = 1 + A1 = alpha2 + A2 = 0.25 * (alpha1 - alpha2) + + B0 = 1 + B1 = beta2 + B2 = 0.25 * (beta1 - beta2) + + V = 0.5 * (A0**0.5 + A1**0.5) + a0 = 0.5 * (V + (V**2 + A2) ** 0.5) + a1 = 1 - V + a2 = -0.25 * A2 / a0 + + W = 0.5 * (B0**0.5 + B1**0.5) + b0 = 0.5 * (W + (W**2 + B2) ** 0.5) + b1 = 1 - W + b2 = -0.25 * B2 / b0 + return np.array([b0, b1, b2]) / (G if lowshelf else 1.0), np.array( + [a0, a1, a2] + ) + + +def __get_matched_eq_helpers(omega0, q): + """Return the some general helpers for matched biquad filters. The + normalized angular frequency and the quality factor (possibly scaled) are + needed. + + Returns + ------- + a, A, phi + + """ + q = 1 / (2 * q) + # a coefficients + if q <= 1: + a1 = -2 * np.exp(-q * omega0) * np.cos((1 - q**2) ** 0.5 * omega0) + else: + a1 = -2 * np.exp(-q * omega0) * np.cosh((q**2 - 1) ** 0.5 * omega0) + a2 = np.exp(-2 * q * omega0) + + # In-between factors + A = np.array([(1 + a1 + a2) ** 2, (1 - a1 + a2) ** 2, -4 * a2]).squeeze() + sin_omega = np.sin(omega0 / 2) ** 2 + phi = np.array([1 - sin_omega, sin_omega, 0]) + phi[2] = 4 * phi[0] * phi[1] + return np.array([1, a1, a2]), A, phi diff --git a/dsptoolbox/filterbanks/filterbanks.py b/dsptoolbox/filterbanks/filterbanks.py index 927a453..0b53734 100644 --- a/dsptoolbox/filterbanks/filterbanks.py +++ b/dsptoolbox/filterbanks/filterbanks.py @@ -18,7 +18,16 @@ _get_lattice_coefficients_fir, _get_lattice_ladder_coefficients_iir_sos, ) -from ._filterbank import LRFilterBank, GammaToneFilterBank, QMFCrossover +from ._filterbank import ( + LRFilterBank, + GammaToneFilterBank, + QMFCrossover, + _get_matched_peaking_eq, + _get_matched_lowpass_eq, + _get_matched_highpass_eq, + _get_matched_bandpass_eq, + _get_matched_shelving_eq, +) from .._standard import _kaiser_window_fractional @@ -570,3 +579,121 @@ def pinking_filter(frequency_0_db: float, sampling_rate_hz: int) -> Filter: return Filter( "other", {"zpk": [z, p, k]}, sampling_rate_hz=sampling_rate_hz ) + + +def matched_biquad( + eq_type: str, + freq_hz: float, + gain_db: float, + q: float, + sampling_rate_hz: int, + q_factor: float | None = None, +) -> Filter: + """This returns a biquad digital filter (EQ) that is matched to better + fit an analog prototype than the standard biquad implementation as defined + in [1]. This is due to the frequency warping that occurs when the frequency + approaches nyquist. See notes for details. + + Parameters + ---------- + eq_type : str + Type of biquad filter to create. Choose from "peaking", "lowpass", + "highpass", "bandpass", "lowshelf", "highshelf". + freq_hz : float + Characteristic frequency in Hz. + gain_db : float + Characteristic gain in dB. + q : float + Quality factor. The frequency response differs in its bandwidth from + the standard biquad implementation due to frequency warping. This + is specially clear for normalized frequencies higher than 0.2. + Beware that the implemented shelving filters do not support setting + a quality factor. Analyzing the resulting magnitude response carefully + is advised. + sampling_rate_hz : int + Sampling rate for the digital filter. + q_factor : float, None, optional + Factor by which to scale `q` for peaking filters. This is useful for + attempting to obtain similar bandwidths as the standard biquad + implementation in [1]. If None, an approximation formula is used, which + works well in the gain range [-20, 20] dB and normalized frequency + [0, 0.2]. With increasing frequency, the warping of the standard + implementation produces larger errors, so approximating the bandwidth + there would defeat the purpose of the matching biquad. It always should + be greater than 0. Default: None. + + Returns + ------- + `Filter` + Matched biquad filter. + + Notes + ----- + Frequency warping generates significant deformations of the frequency + response of a digital filter near nyquist when compared to the analog + prototype. These filters alleviate for this at the expense of a more + involved computation. Using matched biquads is only useful when + designing filters or filter banks that have normalized frequencies above + 0.15 or 0.2, e.g., above 7.2 kHz for 48 kHz sampling rate. + + The approach used here comes from [2], though there are others. See + references. + + For shelving filters, [5] is implemented. This implementation does not + support selecting a quality factor, i.e., q is fixed to `sqrt(2)/2`. + + References + ---------- + - [1]: R. Bristow-Johnson, Cookbook formulae for audio EQ biquad filter + coefficients. + - [2]: M. Vicanek. Matched Second Order Digital Filters. 2016. + - [3]: S. J. Orfanidis, Digital Parametric Equalizer Design With Prescribed + Nyquist-Frequency Gain. 1997. + - [4]: M. Massberg, Digital Low-Pass Filter Design with Analog-Matched + Magnitude Response. 2011. + - [5]: M. Vicanek. Matched Two-Pole Digital Shelving Filters. 2024. + + """ + eq_type = eq_type.lower() + assert eq_type in ( + "peaking", + "lowpass", + "highpass", + "lowshelf", + "highshelf", + "bandpass", + ), f"{eq_type} is not valid as eq type" + assert ( + freq_hz > 0 and freq_hz < sampling_rate_hz / 2 + ), f"{freq_hz} is not a valid frequency" + assert q > 0, "Quality factor must be greater than zero" + + match eq_type: + case "peaking": + ba = _get_matched_peaking_eq( + freq_hz, gain_db, q, q_factor, sampling_rate_hz + ) + case "lowpass": + ba = _get_matched_lowpass_eq(freq_hz, gain_db, q, sampling_rate_hz) + case "highpass": + ba = _get_matched_highpass_eq( + freq_hz, gain_db, q, sampling_rate_hz + ) + case "bandpass": + ba = _get_matched_bandpass_eq( + freq_hz, gain_db, q, sampling_rate_hz + ) + case "lowshelf": + ba = _get_matched_shelving_eq( + freq_hz, gain_db, sampling_rate_hz, True + ) + case "highshelf": + ba = _get_matched_shelving_eq( + freq_hz, gain_db, sampling_rate_hz, False + ) + + return Filter( + "other", + {"ba": ba}, + sampling_rate_hz, + ) diff --git a/tests/test_filterbanks.py b/tests/test_filterbanks.py index 9a219f6..898e118 100644 --- a/tests/test_filterbanks.py +++ b/tests/test_filterbanks.py @@ -280,3 +280,42 @@ def test_convert_lattice_filter(self): n1 = f.filter_signal(n).time_data.squeeze() n2 = new_f.filter_signal(n).time_data.squeeze() assert np.all(np.isclose(n1, n2)) + + def test_matched_biquads(self): + # Only functionality and plausibility + # Parameters + fs_hz = 48000 + freq = 10e3 + gain_db = -20 + q = 2**0.5 / 2 + + for eq_type in [ + "peaking", + "lowpass", + "highpass", + "lowshelf", + "highshelf", + "bandpass", + ]: + dsp.filterbanks.matched_biquad(eq_type, freq, gain_db, q, fs_hz) + + # For comparison with usual biquads + # f = dsp.filterbanks.matched_biquad( + # eq_type, freq, gain_db, q, fs_hz + # ) + # f2 = dsp.Filter( + # "biquad", + # { + # "eq_type": eq_type + # + ("_peak" if eq_type == "bandpass" else ""), + # "freqs": freq, + # "gain": gain_db, + # "q": q, + # }, + # fs_hz, + # ) + # fb = dsp.FilterBank([f, f2]) + # fig, ax = fb.plot_magnitude(length_samples=2**13) + # fig.suptitle(eq_type.capitalize()) + # ax.legend(["Matched", "Standard"]) + # dsp.plots.show() From d63a9db01cd4f12fb016e5da294400c6839ccb58 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 12 Jul 2024 15:42:59 +0200 Subject: [PATCH 07/35] minor change to edc computation (performance) --- dsptoolbox/room_acoustics/_room_acoustics.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/dsptoolbox/room_acoustics/_room_acoustics.py b/dsptoolbox/room_acoustics/_room_acoustics.py index 7aebd61..213ee50 100644 --- a/dsptoolbox/room_acoustics/_room_acoustics.py +++ b/dsptoolbox/room_acoustics/_room_acoustics.py @@ -1166,6 +1166,8 @@ def _compute_energy_decay_curve( fs_hz: int, ) -> np.ndarray: """Get the energy decay curve from an energy time curve.""" + # start_index might be the last index below -20 dB relative to peak value. + # If so, the normalization of the edc should be done with the beginning if trim_automatically: start_index, stopping_index, impulse_index = _trim_ir( time_data, @@ -1179,9 +1181,8 @@ def _compute_energy_decay_curve( signal_power = time_data[start_index:stopping_index] ** 2 edc = np.sum(signal_power) - np.cumsum(signal_power) epsilon = 1e-50 - edc = 10 * np.log10( - np.clip(edc / edc[impulse_index], a_min=epsilon, a_max=None) - ) + edc = 10 * np.log10(np.clip(edc, a_min=epsilon, a_max=None)) + edc -= edc[impulse_index] return edc From 718ffc7fb6e320bebedb739ff5ee6452c6f9ae58 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 16 Jul 2024 14:37:53 +0200 Subject: [PATCH 08/35] added time smoothing --- dsptoolbox/_general_helpers.py | 88 ++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index 061175d..9b504b2 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -9,6 +9,8 @@ convolve as scipy_convolve, hilbert, correlate, + lfilter, + lfilter_zi, ) from scipy.fft import fft, ifft from scipy.interpolate import interp1d @@ -1533,3 +1535,89 @@ def _interpolate_fr( interpolated = 10 ** (interpolated / factor) return interpolated + + +def _time_smoothing( + x: NDArray[np.float64], + sampling_rate_hz: int, + ascending_time_s: float, + descending_time_s: float | None = None, +) -> NDArray[np.float64]: + """Smoothing for a time series with independent ascending and descending + times. The smoothing is always applied along the longest axis. It works on + 1D and 2D arrays. + + If no descending time is provided, `ascending_time_s` is used for both + increasing and decreasing values. + + Parameters + ---------- + x : NDArray[np.float64] + Vector to apply smoothing to. + sampling_rate_hz : int + Sampling rate of the time series `x`. + ascending_time_s : float + Corresponds to the needed time for achieving a 95% accuracy of the + step response when the samples are increasing in value. + descending_time_s : float, None, optional + Analogous for descending values. If None, `ascending_time_s` is + applied. Default: None. + + Returns + ------- + NDArray[np.float64] + Smoothed time vector. + + """ + onedim = x.ndim == 1 + x = np.atleast_2d(x) + if x.shape[0] < x.shape[1]: + reverse_axis = True + x = x.T + else: + reverse_axis = False + + assert x.ndim < 3, "This function is only available for 2D arrays" + assert ascending_time_s > 0.0, "Attack time must be greater than 0" + ascending_factor = 1 - np.exp( + np.log(0.05) / ascending_time_s / sampling_rate_hz + ) + + if descending_time_s is None: + b, a = [ascending_factor], [1, -(1 - ascending_factor)] + zi = lfilter_zi(b, a) + y = lfilter( + b, + a, + x, + axis=0, + zi=np.asarray([zi * x[0, ch] for ch in range(x.shape[1])]).T, + )[0] + if reverse_axis: + y = y.T + if onedim: + return y.squeeze() + return y + + assert descending_time_s > 0.0, "Release time must be greater than 0" + + descending_factor = 1 - np.exp( + np.log(0.05) / descending_time_s / sampling_rate_hz + ) + + y = np.zeros_like(x) + y[0, :] = x[0, :] + for n in np.arange(1, x.shape[0]): + for ch in range(x.shape[1]): + val = ( + ascending_factor + if x[n, ch] > x[n - 1, ch] + else descending_factor + ) + y[n, ch] = val * x[n, ch] + (1.0 - val) * y[n - 1, ch] + + if reverse_axis: + y = y.T + if onedim: + return y.squeeze() + return y From 8cd29a1c1e60340edf13e809a575d5e5a8188ec4 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Wed, 17 Jul 2024 18:51:05 +0200 Subject: [PATCH 09/35] bug fix to interpolate fr --- dsptoolbox/_general_helpers.py | 1 + 1 file changed, 1 insertion(+) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index 9b504b2..93205e2 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -1508,6 +1508,7 @@ def _interpolate_fr( a_max=None, ) ) + fill_value = (fr_interp[0], fr_interp[-1]) else: raise ValueError(f"Unsupported interpolation mode: {mode}") From 74b20d8ef37b5f605a531854ca8b889b6d14fc7e Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 19 Jul 2024 10:29:09 +0200 Subject: [PATCH 10/35] added transfer function for filters and filter banks --- dsptoolbox/classes/filter_class.py | 44 +++++++++++++++++ dsptoolbox/classes/filterbank.py | 46 ++++++++++++++++++ tests/test_classes.py | 58 ++++++++++++++++++++++ tests/test_filterbanks.py | 78 +++++++++++++++--------------- 4 files changed, 187 insertions(+), 39 deletions(-) diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py index 020d7a5..50cbb55 100644 --- a/dsptoolbox/classes/filter_class.py +++ b/dsptoolbox/classes/filter_class.py @@ -568,6 +568,50 @@ def get_ir( ) return self.filter_signal(ir_filt, zero_phase=zero_phase) + def get_transfer_function(self, frequency_vector_hz: np.ndarray): + """Obtain the complex transfer function of the filter analytically + evaluated for a given frequency vector. + + Parameters + ---------- + frequency_vector_hz : `np.ndarray` + Frequency vector for which to compute the transfer function + + Returns + ------- + np.ndarray + Complex transfer function + + Notes + ----- + - This method uses scipy's freqz to compute the transfer function. In + the case of FIR filters, it might be significantly faster and more + precise to use a direct FFT approach. + + """ + assert ( + frequency_vector_hz.ndim == 1 + ), "Frequency vector can only have one dimension" + assert ( + frequency_vector_hz.max() <= self.sampling_rate_hz / 2 + ), "Queried frequency vector has values larger than nyquist" + if self.filter_type in ("iir", "biquad"): + if hasattr(self, "sos"): + return sig.sosfreqz( + self.sos, frequency_vector_hz, fs=self.sampling_rate_hz + )[1] + return sig.freqz( + self.ba[0], + self.ba[1], + frequency_vector_hz, + fs=self.sampling_rate_hz, + )[1] + + # FIR + return sig.freqz( + self.ba[0], [1], frequency_vector_hz, self.sampling_rate_hz + )[1] + def get_coefficients( self, mode: str = "sos" ) -> ( diff --git a/dsptoolbox/classes/filterbank.py b/dsptoolbox/classes/filterbank.py index 60561f0..01c3b4d 100644 --- a/dsptoolbox/classes/filterbank.py +++ b/dsptoolbox/classes/filterbank.py @@ -444,6 +444,52 @@ def get_ir( ) return ir + def get_transfer_function( + self, frequency_vector_hz: np.ndarray, mode: str = "parallel" + ): + """Compute the complex transfer function of the filter bank for + specified frequencies. The output is based on the filter bank filtering + mode. + + Parameters + ---------- + frequency_vector_hz : np.ndarray + Frequency vector to evaluate frequencies at. + mode : str, optional + Way of applying the filter bank. If `"parallel"`, the resulting + transfer function will have shape (frequency, filter). In the cases + of `"sequential"` and `"summed"`, it will have shape (frequency). + + Returns + ------- + np.ndarray + Complex transfer function of the filter bank. + + """ + mode = mode.lower() + assert mode in ( + "parallel", + "sequential", + "summed", + ), f"{mode} is not a valid mode. Use parallel, sequential or summed" + match mode: + case "parallel": + h = np.zeros( + (len(frequency_vector_hz), self.number_of_filters), + dtype=np.complex128, + ) + for ind, f in enumerate(self.filters): + h[:, ind] = f.get_transfer_function(frequency_vector_hz) + case "sequential": + h = np.ones(len(frequency_vector_hz), dtype=np.complex128) + for ind, f in enumerate(self.filters): + h *= f.get_transfer_function(frequency_vector_hz) + case "summed": + h = np.ones(len(frequency_vector_hz), dtype=np.complex128) + for ind, f in enumerate(self.filters): + h += f.get_transfer_function(frequency_vector_hz) + return h + # ======== Prints and plots =============================================== def show_info(self): """Show information about the filter bank.""" diff --git a/tests/test_classes.py b/tests/test_classes.py index 4a8522b..f3199c8 100644 --- a/tests/test_classes.py +++ b/tests/test_classes.py @@ -463,6 +463,42 @@ def test_other_functionalities(self): with pytest.raises(AssertionError): f.initialize_zi(0) + def test_get_transfer_function(self): + # Functionality + f = dsp.Filter( + "other", + filter_configuration=dict(sos=self.iir), + sampling_rate_hz=self.fs, + ) + freqs = np.linspace(1, 4e3, 200) + f.get_transfer_function(freqs) + + b = sig.firwin( + 1500, + (self.fs // 2 // 2), + pass_zero="lowpass", + fs=self.fs, + window="flattop", + ) + f = dsp.Filter( + "other", + filter_configuration=dict(ba=[b, 1]), + sampling_rate_hz=self.fs, + ) + f.get_transfer_function(freqs) + + f = dsp.Filter( + "biquad", + filter_configuration={ + "eq_type": "peaking", + "freqs": 200, + "gain": 3, + "q": 0.7, + }, + sampling_rate_hz=self.fs, + ) + f.get_transfer_function(freqs) + def test_filter_and_resampling_IIR(self): f = dsp.Filter( "other", @@ -848,6 +884,28 @@ def test_iterator(self): for n in fb: assert dsp.Filter == type(n) + def test_transfer_function(self): + # Create + fb = dsp.FilterBank() + config = dict( + order=5, + freqs=[1500, 2000], + type_of_pass="bandpass", + filter_design_method="bessel", + ) + fb.add_filter(dsp.Filter("iir", config, sampling_rate_hz=self.fs)) + config = dict(order=150, freqs=[1500, 2000], type_of_pass="bandpass") + fb.add_filter(dsp.Filter("fir", config, self.fs)) + + freqs = np.linspace(1, 2e3, 400) + fb.get_transfer_function(freqs, mode="parallel") + fb.get_transfer_function(freqs, mode="sequential") + fb.get_transfer_function(freqs, mode="summed") + + with pytest.raises(AssertionError): + freqs = np.linspace(1, self.fs, 40) + fb.get_transfer_function(freqs, mode="parallel") + class TestMultiBandSignal: fs = 44100 diff --git a/tests/test_filterbanks.py b/tests/test_filterbanks.py index 898e118..f66f7ea 100644 --- a/tests/test_filterbanks.py +++ b/tests/test_filterbanks.py @@ -206,6 +206,45 @@ def test_pinking_filter(self): ) n2 = dsp.merge_signals(n2, n) + def test_matched_biquads(self): + # Only functionality and plausibility + # Parameters + fs_hz = 48000 + freq = 10e3 + gain_db = -20 + q = 2**0.5 / 2 + + for eq_type in [ + "peaking", + "lowpass", + "highpass", + "lowshelf", + "highshelf", + "bandpass", + ]: + dsp.filterbanks.matched_biquad(eq_type, freq, gain_db, q, fs_hz) + + # For comparison with usual biquads + # f = dsp.filterbanks.matched_biquad( + # eq_type, freq, gain_db, q, fs_hz + # ) + # f2 = dsp.Filter( + # "biquad", + # { + # "eq_type": eq_type + # + ("_peak" if eq_type == "bandpass" else ""), + # "freqs": freq, + # "gain": gain_db, + # "q": q, + # }, + # fs_hz, + # ) + # fb = dsp.FilterBank([f, f2]) + # fig, ax = fb.plot_magnitude(length_samples=2**13) + # fig.suptitle(eq_type.capitalize()) + # ax.legend(["Matched", "Standard"]) + # dsp.plots.show() + class TestLatticeLadderFilter: b = np.array([1, 3, 3, 1]) @@ -280,42 +319,3 @@ def test_convert_lattice_filter(self): n1 = f.filter_signal(n).time_data.squeeze() n2 = new_f.filter_signal(n).time_data.squeeze() assert np.all(np.isclose(n1, n2)) - - def test_matched_biquads(self): - # Only functionality and plausibility - # Parameters - fs_hz = 48000 - freq = 10e3 - gain_db = -20 - q = 2**0.5 / 2 - - for eq_type in [ - "peaking", - "lowpass", - "highpass", - "lowshelf", - "highshelf", - "bandpass", - ]: - dsp.filterbanks.matched_biquad(eq_type, freq, gain_db, q, fs_hz) - - # For comparison with usual biquads - # f = dsp.filterbanks.matched_biquad( - # eq_type, freq, gain_db, q, fs_hz - # ) - # f2 = dsp.Filter( - # "biquad", - # { - # "eq_type": eq_type - # + ("_peak" if eq_type == "bandpass" else ""), - # "freqs": freq, - # "gain": gain_db, - # "q": q, - # }, - # fs_hz, - # ) - # fb = dsp.FilterBank([f, f2]) - # fig, ax = fb.plot_magnitude(length_samples=2**13) - # fig.suptitle(eq_type.capitalize()) - # ax.legend(["Matched", "Standard"]) - # dsp.plots.show() From 974db1b2d7e0012997a4ada5ebc92b368c29ac13 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 19 Jul 2024 10:29:26 +0200 Subject: [PATCH 11/35] added tools module --- docs/modules.rst | 1 + docs/modules/dsptoolbox.general_tools.rst | 7 + dsptoolbox/__init__.py | 2 + dsptoolbox/tools.py | 244 ++++++++++++++++++++++ tests/test_tools.py | 15 ++ 5 files changed, 269 insertions(+) create mode 100644 docs/modules/dsptoolbox.general_tools.rst create mode 100644 dsptoolbox/tools.py create mode 100644 tests/test_tools.py diff --git a/docs/modules.rst b/docs/modules.rst index 56969ff..e681c99 100644 --- a/docs/modules.rst +++ b/docs/modules.rst @@ -17,3 +17,4 @@ The modules and functions of dsptoolbox are listed down below. modules/dsptoolbox.standard_functions modules/dsptoolbox.transfer_functions modules/dsptoolbox.effects + modules/dsptoolbox.tools diff --git a/docs/modules/dsptoolbox.general_tools.rst b/docs/modules/dsptoolbox.general_tools.rst new file mode 100644 index 0000000..0414fff --- /dev/null +++ b/docs/modules/dsptoolbox.general_tools.rst @@ -0,0 +1,7 @@ +Tools (dsptoolbox.tools) +============================== + +.. automodule:: dsptoolbox.tools + :members: + :undoc-members: + :show-inheritance: diff --git a/dsptoolbox/__init__.py b/dsptoolbox/__init__.py index 459eb9e..450821e 100644 --- a/dsptoolbox/__init__.py +++ b/dsptoolbox/__init__.py @@ -34,6 +34,7 @@ from . import audio_io from . import beamforming from . import effects +from . import tools __all__ = [ # Basic classes @@ -71,6 +72,7 @@ "audio_io", "beamforming", "effects", + "tools", ] __version__ = "0.3.9" diff --git a/dsptoolbox/tools.py b/dsptoolbox/tools.py new file mode 100644 index 0000000..cb4bb02 --- /dev/null +++ b/dsptoolbox/tools.py @@ -0,0 +1,244 @@ +""" +This module contains general math and dsp utilities. These functions are solely +based on arrays and primitive data types. +""" + +import numpy as np +from numpy.typing import NDArray +from typing import Any +from scipy.interpolate import interp1d + +from ._general_helpers import ( + _fractional_octave_smoothing as fractional_octave_smoothing, + _wrap_phase as wrap_phase, + _get_smoothing_factor_ema as get_smoothing_factor_ema, + _interpolate_fr as interpolate_fr, + _time_smoothing as time_smoothing, +) + + +def log_frequency_vector( + frequency_range_hz: list[float], n_bins_per_octave: int +) -> NDArray[np.float64]: + """Obtain a logarithmically spaced frequency vector with a specified number + of frequency bins per octave. + + Parameters + ---------- + frequency_range_hz : list[float] + Frequency with length 2 for defining the frequency range. The lowest + frequency should be above 0. + n_bins_per_octave : int + Number of frequency bins in each octave. + + Returns + ------- + NDArray[np.float64] + Log-spaced frequency vector + + """ + assert frequency_range_hz[0] > 0, "The first frequency bin should not be 0" + + n_octave = np.log2(frequency_range_hz[1] / frequency_range_hz[0]) + return frequency_range_hz[0] * 2 ** ( + np.arange(0, n_octave, 1 / n_bins_per_octave) + ) + + +def to_db( + x: NDArray[np.float64], + amplitude_input: bool, + dynamic_range_db: float | None = None, + min_value: float | None = float(np.finfo(np.float64).smallest_normal), +) -> NDArray[np.float64]: + """Convert to dB from amplitude or power representation. Clipping small + values can be activated in order to avoid -inf dB outcomes. + + Parameters + ---------- + x : NDArray[np.float64] + Array to convert to dB. + amplitude_input : bool + Set to True if the values in x are in their linear form. False means + they have been already squared, i.e., in their power form. + dynamic_range_db : float, None, optional + If specified, a dynamic range in dB for the vector is applied by + finding its largest value and clipping to `max - dynamic_range_db`. + This will always overwrite `min_value` if specified. Pass None to + ignore. Default: None. + min_value : float, None, optional + Minimum value to clip `x` before converting into dB in order to avoid + `np.nan` or `-np.inf` in the output. Pass None to ignore. Default: + `np.finfo(np.float64).smallest_normal`. + + Returns + ------- + NDArray[np.float64] + New array or float in dB. + + """ + factor = 20.0 if amplitude_input else 10.0 + + if min_value is None and dynamic_range_db is None: + return factor * np.log10(np.abs(x)) + + x_abs = np.abs(x) + + if dynamic_range_db is not None: + min_value = np.max(x_abs) * 10.0 ** (-abs(dynamic_range_db) / factor) + + return factor * np.log10(np.clip(x_abs, a_min=min_value, a_max=None)) + + +def from_db(x: float | NDArray[np.float64], amplitude_output: bool): + """Get the values in their amplitude or power form from dB. + + Parameters + ---------- + x : float, NDArray[np.float64] + Values in dB. + amplitude_output : bool + When True, the values are returned in their linear form. Otherwise, + the squared (power) form is returned. + + Returns + ------- + float NDArray[np.float64] + Converted values + + """ + factor = 20.0 if amplitude_output else 10.0 + return 10 ** (x / factor) + + +def get_exact_value_at_frequency( + freqs_hz: NDArray[np.float64], y: NDArray[Any], f: float = 1e3 +): + """Return the exact value at 1 kHz extracted by using linear interpolation. + + Parameters + ---------- + freqs_hz : NDArray[np.float64] + Frequency vector in Hz. It is assumed to be in ascending order. + y : NDArray[np.float64] + Values to use for the interpolation. + f : float, optional + Frequency to query. Default: 1000. + + Returns + ------- + float + Queried value. + + """ + assert ( + freqs_hz[0] <= f and freqs_hz[-1] >= f + ), "Frequency vector does not contain 1 kHz" + assert freqs_hz.ndim == 1, "Frequency vector can only have one dimension" + assert len(freqs_hz) == len(y), "Lengths do not match" + + # Single value in vector or last value matches + if freqs_hz[-1] == f: + return y[-1] + + ind = np.searchsorted(freqs_hz, f) + if freqs_hz[ind] > f: + ind -= 1 + return (f - freqs_hz[ind]) * (y[ind + 1] - y[ind]) / ( + freqs_hz[ind + 1] - freqs_hz[ind] + ) + y[ind] + + +def log_mean(x: NDArray[np.float64], axis: int = 0): + """Get the mean value while using a logarithmic x-axis. It is assumed that + `x` is initially linearly-spaced. + + Parameters + ---------- + x : NDArray[np.float64] + Vector for which to obtain the mean. + axis : int, optional + Axis along which to compute the mean. + + Returns + ------- + float or NDArray[np.float64] + Logarithmic mean along the selected axis. + + """ + # Linear and logarithmic frequency vector + N = x.shape[axis] + l1 = np.arange(N) + k_log = (N) ** (l1 / (N - 1)) + # Interpolate to logarithmic scale + vec_log = interp1d( + l1 + 1, x, kind="linear", copy=False, assume_sorted=True, axis=axis + )(k_log) + return np.mean(vec_log, axis=axis) + + +def frequency_crossover( + crossover_region_hz: list[float], + logarithmic: bool = True, +): + """Return a callable that can be used to extract values from a crossover + to use on frequency data. This uses a hann window function to generate the + crossover. It is a "fade-in", i.e., the values are 0 before the low + frequency and rise up to 1 at the high frequency of the crossover. + + Parameters + ---------- + crossover_region_hz : list with length 2 + Frequency range for which to create the crossover. + logarithmic : bool, optional + When True, the crossover is defined logarithmically on the frequency + axis. Default: True. + + Returns + ------- + callable + Callable that produces values from the crossover function. The input + should always be in Hz. It can take float or NDArray[np.float64] and + returns the same type. + + """ + f = ( + log_frequency_vector(crossover_region_hz, 250) + if logarithmic + else np.linspace( + crossover_region_hz[0], + crossover_region_hz[1], + int(crossover_region_hz[1] - crossover_region_hz[0]), + ) + ) + length = len(f) + w = np.hanning(length * 2)[:length] + i = interp1d( + f, + w, + kind="cubic", + copy=False, + bounds_error=False, + fill_value=(0.0, 1.0), + assume_sorted=True, + ) + + def func(x: float | NDArray[np.float64]) -> float | NDArray[np.float64]: + return i(x) + + return func + + +__all__ = [ + "fractional_octave_smoothing", + "wrap_phase", + "get_smoothing_factor_ema", + "interpolate_fr", + "time_smoothing", + "log_frequency_vector", + "to_db", + "from_db", + "get_exact_value_at_frequency", + "log_mean", + "frequency_crossover", +] diff --git a/tests/test_tools.py b/tests/test_tools.py new file mode 100644 index 0000000..1bd82de --- /dev/null +++ b/tests/test_tools.py @@ -0,0 +1,15 @@ +import dsptoolbox as dsp +import numpy as np + + +class TestTools: + def test_functionality(self): + # Only assess basic functionality, not results + x = np.linspace(100, 150, 30) + dsp.tools.log_frequency_vector([20, 200], 50) + dsp.tools.frequency_crossover([100, 200], True)(x) + dsp.tools.log_mean(x) + dsp.tools.to_db(x, True, None, None) + dsp.tools.from_db(x, True) + dsp.tools.time_smoothing(x, 200, 0.1, None) + dsp.tools.time_smoothing(x, 200, 0.1, 0.2) From 120e6791a0a856b9857bc6e4e62a05439ac4922c Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 19 Jul 2024 10:29:42 +0200 Subject: [PATCH 12/35] updated time smoothing time smoothing fix corrected smoothing --- dsptoolbox/_general_helpers.py | 42 ++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 15 deletions(-) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index 93205e2..ea63837 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -1545,8 +1545,8 @@ def _time_smoothing( descending_time_s: float | None = None, ) -> NDArray[np.float64]: """Smoothing for a time series with independent ascending and descending - times. The smoothing is always applied along the longest axis. It works on - 1D and 2D arrays. + times using an exponential moving average. It works on 1D and 2D arrays. + The smoothing is always applied along the longest axis. If no descending time is provided, `ascending_time_s` is used for both increasing and decreasing values. @@ -1559,15 +1559,16 @@ def _time_smoothing( Sampling rate of the time series `x`. ascending_time_s : float Corresponds to the needed time for achieving a 95% accuracy of the - step response when the samples are increasing in value. + step response when the samples are increasing in value. Pass 0. in + order to avoid any smoothing for rising values. descending_time_s : float, None, optional - Analogous for descending values. If None, `ascending_time_s` is - applied. Default: None. + As `ascending_time_s` but for descending values. If None, + `ascending_time_s` is applied. Default: None. Returns ------- NDArray[np.float64] - Smoothed time vector. + Smoothed time series. """ onedim = x.ndim == 1 @@ -1579,9 +1580,11 @@ def _time_smoothing( reverse_axis = False assert x.ndim < 3, "This function is only available for 2D arrays" - assert ascending_time_s > 0.0, "Attack time must be greater than 0" - ascending_factor = 1 - np.exp( - np.log(0.05) / ascending_time_s / sampling_rate_hz + assert ascending_time_s >= 0.0, "Attack time must be at least 0" + ascending_factor = ( + _get_smoothing_factor_ema(ascending_time_s, sampling_rate_hz) + if ascending_time_s > 0.0 + else 1.0 ) if descending_time_s is None: @@ -1600,22 +1603,31 @@ def _time_smoothing( return y.squeeze() return y - assert descending_time_s > 0.0, "Release time must be greater than 0" + assert descending_time_s >= 0.0, "Release time must at least 0" + assert not ( + ascending_time_s == 0.0 and descending_time_s == ascending_time_s + ), "These times will not apply any smoothing" - descending_factor = 1 - np.exp( - np.log(0.05) / descending_time_s / sampling_rate_hz + descending_factor = ( + _get_smoothing_factor_ema(descending_time_s, sampling_rate_hz) + if descending_time_s > 0.0 + else 1.0 ) y = np.zeros_like(x) y[0, :] = x[0, :] + for n in np.arange(1, x.shape[0]): for ch in range(x.shape[1]): - val = ( + smoothing_factor = ( ascending_factor - if x[n, ch] > x[n - 1, ch] + if x[n, ch] > y[n - 1, ch] else descending_factor ) - y[n, ch] = val * x[n, ch] + (1.0 - val) * y[n - 1, ch] + y[n, ch] = ( + smoothing_factor * x[n, ch] + + (1.0 - smoothing_factor) * y[n - 1, ch] + ) if reverse_axis: y = y.T From 2a5505e3186e59a2d21d66bf46dfd424c783dc89 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Mon, 22 Jul 2024 20:47:33 +0200 Subject: [PATCH 13/35] added gaussian kernel to filterbanks --- dsptoolbox/filterbanks/__init__.py | 4 ++ dsptoolbox/filterbanks/filterbanks.py | 71 ++++++++++++++++++++++++++- tests/test_filterbanks.py | 20 ++++++++ 3 files changed, 94 insertions(+), 1 deletion(-) diff --git a/dsptoolbox/filterbanks/__init__.py b/dsptoolbox/filterbanks/__init__.py index fd4fcc9..2bcfac5 100644 --- a/dsptoolbox/filterbanks/__init__.py +++ b/dsptoolbox/filterbanks/__init__.py @@ -31,6 +31,8 @@ - `convert_into_lattice_filter()`: Turns a conventional filter into its lattice/ladder representation. - `pinking_filter()`: Get a -3 dB/octave filter. +- `matched_biquad()`: Analog-matched biquad filters. +- `gaussian_kernel()`: IIR first-order approximation of a gaussian window. """ @@ -45,6 +47,7 @@ convert_into_lattice_filter, pinking_filter, matched_biquad, + gaussian_kernel, ) from ..classes._lattice_ladder_filter import LatticeLadderFilter @@ -65,4 +68,5 @@ "StateVariableFilter", "pinking_filter", "matched_biquad", + "gaussian_kernel", ] diff --git a/dsptoolbox/filterbanks/filterbanks.py b/dsptoolbox/filterbanks/filterbanks.py index 0b53734..8fb36e5 100644 --- a/dsptoolbox/filterbanks/filterbanks.py +++ b/dsptoolbox/filterbanks/filterbanks.py @@ -4,7 +4,7 @@ """ import numpy as np -from scipy.signal import windows, bilinear_zpk, freqz_zpk +from scipy.signal import windows, bilinear_zpk, freqz_zpk, tf2sos import warnings from .. import ( Filter, @@ -697,3 +697,72 @@ def matched_biquad( {"ba": ba}, sampling_rate_hz, ) + + +def gaussian_kernel( + kernel_length_seconds: float, + kernel_boundary_value: float = 1e-2, + approximation_order: int = 12, + sampling_rate_hz: int = None, +): + """Approximate a gaussian FIR window with a first-order IIR approximation + kernel according to [1]. The resulting filter must be applied using + zero-phase filtering. + + Parameters + ---------- + kernel_length_seconds : float + Kernel length in seconds used to define the width of the gaussian + bell in relation to time. It corresponds to the time between `t=0` and + `t=t0` where `y(t0)=kernel_boundary_value`. + kernel_boundary_value : float, optional + Value that the gaussian window should reach after + `kernel_length_seconds`. Default: 1e-2. + approximation_order : int, optional + Order of the approximation. This corresponds to the number of times + that the filter will be applied (when using zero-phase filtering). The + higher this number, the better the approximation. This should be + an even number. Values around 10 will be sufficient in most cases. + Default: 12. + sampling_rate_hz : int + Sampling rate in Hz for the filter. + + Returns + ------- + Filter + IIR filter with the approximation kernel. It should always be applied + using zero-phase filtering! + + References + ---------- + - [1]: Alvarez, Mazorra, "Signal and Image Restoration using Shock Filters + and Anisotropic Diffusion," SIAM J. on Numerical Analysis, vol. 31, no. + 2, pp. 590-605, 1994. http://www.jstor.org/stable/2158018 + + """ + assert approximation_order % 2 == 0, "Approximation order must be even" + assert sampling_rate_hz is not None, "Sampling rate should not be None" + + K = approximation_order // 2 + + # Obtain sigma from kernel width definition in regards to time + kernel_length_samples = kernel_length_seconds * sampling_rate_hz + sigma = ( + kernel_length_samples + / (2.0 * np.log(1 / kernel_boundary_value)) ** 0.5 + ) + + # Before eq. (6) + lambdaa = sigma**2.0 / (2.0 * K) + + # Below eq. (9) + mu = (1.0 + 2.0 * lambdaa - (1.0 + 4.0 * lambdaa) ** 0.5) / (2.0 * lambdaa) + + # Eq. (7) + b = np.array([1.0]) * (mu / lambdaa) ** 0.5 + a = np.array([1.0, -mu]) + + sos = tf2sos(b, a) + sos = np.repeat(sos, K, axis=0) + + return Filter("other", {"sos": sos}, sampling_rate_hz) diff --git a/tests/test_filterbanks.py b/tests/test_filterbanks.py index f66f7ea..3bac314 100644 --- a/tests/test_filterbanks.py +++ b/tests/test_filterbanks.py @@ -245,6 +245,26 @@ def test_matched_biquads(self): # ax.legend(["Matched", "Standard"]) # dsp.plots.show() + def test_gaussian_kernel(self): + # Only functionality + fs_hz = 44100 + n = dsp.generators.noise(sampling_rate_hz=fs_hz) + + # Get kernel and apply filtering + f = dsp.filterbanks.gaussian_kernel(0.02, sampling_rate_hz=fs_hz) + n1 = f.filter_signal(n, zero_phase=True) + + # Compare to normal gaussian window + length = int(0.02 * fs_hz + 0.5) + sigma = length / (2.0 * np.log(1 / 1e-2)) ** 0.5 + w = sig.windows.gaussian(length, sigma, True) + w /= w.sum() + f = dsp.Filter("other", {"ba": [w, [1]]}, fs_hz) + n1 = dsp.merge_signals(n1, f.filter_signal(n, zero_phase=False)) + + # n1.plot_time() + # dsp.plots.show() + class TestLatticeLadderFilter: b = np.array([1, 3, 3, 1]) From 91af31fa532737a771986fe06461b1d3b056c61f Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Wed, 24 Jul 2024 19:31:39 +0200 Subject: [PATCH 14/35] added latency quality estimation --- dsptoolbox/_general_helpers.py | 51 +++++++++++++++++++ dsptoolbox/standard_functions.py | 36 +++++++++++-- .../transfer_functions/transfer_functions.py | 2 +- tests/test_standard.py | 30 ++++++----- 4 files changed, 99 insertions(+), 20 deletions(-) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index ea63837..86714bc 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -15,6 +15,7 @@ from scipy.fft import fft, ifft from scipy.interpolate import interp1d from scipy.linalg import toeplitz as toeplitz_scipy +from scipy.stats import pearsonr from os import sep from warnings import warn from scipy.fft import next_fast_len @@ -1634,3 +1635,53 @@ def _time_smoothing( if onedim: return y.squeeze() return y + + +def _get_correlation_of_latencies( + time_data: NDArray[np.float64], + other_time_data: NDArray[np.float64], + latencies: NDArray[np.int_], +) -> NDArray[np.float64]: + """Compute the pearson correlation coefficient of each channel between + `time_data` and `other_time_data` in order to obtain an estimation on the + quality of the latency computation. + + Parameters + ---------- + time_data : NDArray[np.float64] + Original time data. This is the "undelayed" version if the latency + is positive. It must have either one channel or a matching number + of channels with `other_time_data`. + other_time_data : NDArray[np.float64] + "Delayed" time data, when the latency is positive. + latencies : NDArray[np.int_] + Computed latencies for each channel. + + Returns + ------- + NDArray[np.float64] + Correlation coefficient for each channel. + + """ + one_channel = time_data.shape[1] == 1 + + correlations = np.zeros(len(latencies)) + + for ch in range(len(latencies)): + if latencies[ch] > 0: + undelayed = time_data[:, 0] if one_channel else time_data[:, ch] + delayed = other_time_data[:, ch] + else: + undelayed = other_time_data[:, ch] + delayed = time_data[:, 0] if one_channel else time_data[:, ch] + + # Remove delay samples + delayed = delayed[abs(latencies[ch]) :] + + # Get effective length + length_to_check = min(len(delayed), len(undelayed)) + + delayed = delayed[:length_to_check] + undelayed = undelayed[:length_to_check] + correlations[ch] = pearsonr(delayed, undelayed)[0] + return correlations diff --git a/dsptoolbox/standard_functions.py b/dsptoolbox/standard_functions.py index 6a8115c..fec9a18 100644 --- a/dsptoolbox/standard_functions.py +++ b/dsptoolbox/standard_functions.py @@ -36,6 +36,7 @@ _check_format_in_path, _get_smoothing_factor_ema, _fractional_latency, + _get_correlation_of_latencies, ) @@ -43,7 +44,7 @@ def latency( in1: Signal | MultiBandSignal, in2: Signal | MultiBandSignal | None = None, polynomial_points: int = 0, -) -> np.ndarray[int | float]: +) -> tuple[np.ndarray[int | float], np.ndarray[float]]: """Computes latency between two signals using the correlation method. If there is no second signal, the latency between the first and the other channels is computed. `in1` is to be understood as a delayed version @@ -58,6 +59,10 @@ def latency( returned for the respective channel. To avoid fractional latency, use `polynomial_points = 0`. + The quality of the estimation is assessed by computing the pearson + correlation coefficient between the two time series after compensating the + delay. See notes for details. + Parameters ---------- in1 : `Signal` or `MultiBandSignal` @@ -75,9 +80,17 @@ def latency( Returns ------- lags : `np.ndarray` - Delays. For `Signal`, the output shape is (channel). + Delays in samples. For `Signal`, the output shape is (channel). In case in2 is `None`, the length is `channels - 1`. In the case of `MultiBandSignal`, output shape is (band, channel). + correlations : `np.ndarray` + Correlation for computed delays with the same shape as lags. + + Notes + ----- + - The correlation coefficients have values between [-1, 1]. The closer the + absolute value is to 1, the better the latency estimation. This is always + computed using the integer latency for performance. References ---------- @@ -113,9 +126,15 @@ def latency( in1.number_of_channels > 1 ), "Signal must have at least 2 channels to compare" td2 = None - return latency_func( + latencies = latency_func( in1.time_data, td2, polynomial_points=polynomial_points ) + return latencies, _get_correlation_of_latencies( + td2 if td2 is not None else in1.time_data[:, 0][..., None], + in1.time_data if td2 is not None else in1.time_data[:, 1:], + np.round(latencies, 0).astype(np.int_), + ) + elif isinstance(in1, MultiBandSignal): if in2 is not None: assert isinstance( @@ -132,8 +151,11 @@ def latency( lags = np.zeros( (in1.number_of_bands, in1.number_of_channels), dtype=data_type ) + correlations = np.zeros( + (in1.number_of_bands, in1.number_of_channels), dtype=np.float64 + ) for band in range(in1.number_of_bands): - lags[band, :] = latency( + lags[band, :], correlations[band, :] = latency( in1.bands[band], in2.bands[band], polynomial_points=polynomial_points, @@ -143,8 +165,12 @@ def latency( (in1.number_of_bands, in1.number_of_channels - 1), dtype=data_type, ) + correlations = np.zeros( + (in1.number_of_bands, in1.number_of_channels - 1), + dtype=np.float64, + ) for band in range(in1.number_of_bands): - lags[band, :] = latency( + lags[band, :], correlations[band, :] = latency( in1.bands[band], None, polynomial_points=polynomial_points ) return lags diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index 252528c..62735ac 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -1486,7 +1486,7 @@ def find_ir_latency(ir: Signal) -> np.ndarray: """ assert ir.signal_type in ("rir", "ir"), "Only valid for rir or ir" min_ir = min_phase_ir(ir) - return latency(ir, min_ir, 1) + return latency(ir, min_ir, 1)[0] def harmonics_from_chirp_ir( diff --git a/tests/test_standard.py b/tests/test_standard.py index 195be51..57ed557 100644 --- a/tests/test_standard.py +++ b/tests/test_standard.py @@ -19,16 +19,18 @@ def test_latency(self): # Try latency s = dsp.Signal(None, td_del, self.fs) - vector = dsp.latency(self.audio_multi, s) + vector, corr = dsp.latency(self.audio_multi, s) + assert np.allclose(corr, 1.0) assert np.all(vector == -delay_samples) # Try latency the other way around - vector = dsp.latency(s, self.audio_multi) + vector, corr = dsp.latency(s, self.audio_multi) + assert np.allclose(corr, 1.0) assert np.all(vector == delay_samples) # Raise assertion when number of channels does not match with pytest.raises(AssertionError): - vector = dsp.latency(s.get_channels(0), self.audio_multi) + vector, corr = dsp.latency(s.get_channels(0), self.audio_multi) # Single channel td = s.time_data[:, :2] @@ -37,7 +39,8 @@ def test_latency(self): self.audio_multi.time_data[:, 0] ) s = dsp.Signal(None, td, self.fs) - value = dsp.latency(s) + value, corr = dsp.latency(s) + assert np.allclose(corr, 1.0) assert np.all(-value == delay_samples) # ===== Fractional delays @@ -46,18 +49,17 @@ def test_latency(self): "white", length_seconds=1, sampling_rate_hz=10_000 ) noi_del = dsp.fractional_delay(noi, delay) - assert ( - np.abs( - dsp.latency(noi_del, noi, 2)[0] - delay * noi.sampling_rate_hz - ) - < 0.9 - ) + lat, corr = dsp.latency(noi_del, noi, 2) + assert np.allclose(corr, 1.0, atol=1e-2) + assert np.abs(lat[0] - delay * noi.sampling_rate_hz) < 0.9 noi = dsp.merge_signals(noi_del, noi) - latencies = dsp.latency(noi, polynomial_points=1) + latencies, corr = dsp.latency(noi, polynomial_points=1) assert len(latencies) == noi.number_of_channels - 1 + assert np.allclose(corr, 1.0, atol=1e-2) assert np.abs(latencies[0] + delay * noi.sampling_rate_hz) < 0.5 - latencies = dsp.latency(noi, polynomial_points=5) + latencies, corr = dsp.latency(noi, polynomial_points=5) + assert np.allclose(corr, 1.0, atol=1e-2) assert np.abs(latencies[0] + delay * noi.sampling_rate_hz) < 0.5 def test_pad_trim(self): @@ -214,12 +216,12 @@ def test_fractional_delay(self): # All channels s = dsp.fractional_delay(self.audio_multi, delay_s) - lat = dsp.latency(s, self.audio_multi) + lat = dsp.latency(s, self.audio_multi)[0] assert np.all(np.isclose(np.abs(lat), 150)) # Selected channels only s = dsp.fractional_delay(self.audio_multi, delay_s, channels=0) - lat = dsp.latency(s, self.audio_multi) + lat = dsp.latency(s, self.audio_multi)[0] assert np.all(np.isclose(np.abs(lat), [150, 0, 0])) def test_activity_detector(self): From 2f27056f14330d415305d4f1e8be36de28e479b6 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 01:03:56 +0200 Subject: [PATCH 15/35] updated smoothing --- dsptoolbox/_general_helpers.py | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index 86714bc..ca60230 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -6,14 +6,14 @@ from numpy.typing import NDArray from scipy.signal import ( windows, - convolve as scipy_convolve, + oaconvolve, hilbert, correlate, lfilter, lfilter_zi, ) from scipy.fft import fft, ifft -from scipy.interpolate import interp1d +from scipy.interpolate import interp1d, PchipInterpolator from scipy.linalg import toeplitz as toeplitz_scipy from scipy.stats import pearsonr from os import sep @@ -532,8 +532,9 @@ def _fractional_octave_smoothing( ) # Linear and logarithmic frequency vector N = len(vector) - l1 = np.arange(N) + l1 = np.arange(N, dtype=np.float64) k_log = (N) ** (l1 / (N - 1)) + l1 += 1.0 beta = np.log2(k_log[1]) # Window length always odd, so that delay can be easily compensated @@ -566,20 +567,25 @@ def _fractional_octave_smoothing( window /= window.sum() # Interpolate to logarithmic scale - vec_int = interp1d( - l1 + 1, vector, kind="cubic", copy=False, assume_sorted=True, axis=0 - ) - vec_log = vec_int(k_log) + vec_log = PchipInterpolator(l1, vector, axis=0)(k_log) + # Smoothe by convolving with window (output is centered) - smoothed = scipy_convolve( - vec_log, window[..., None], mode="same", method="auto" - ) - # Interpolate back to linear scale - smoothed = interp1d( - k_log, smoothed, kind="cubic", copy=False, assume_sorted=True, axis=0 + n_window_half = n_window // 2 + smoothed = oaconvolve( + np.pad( + vec_log, + ((n_window_half, n_window_half - (1 - n_window % 2)), (0, 0)), + mode="edge", + ), + window[..., None], + mode="valid", + axes=0, ) - vec_final = smoothed(l1 + 1) + # Interpolate back to linear scale + vec_final = interp1d( + k_log, smoothed, kind="linear", copy=False, assume_sorted=True, axis=0 + )(l1) if one_dim: vec_final = vec_final.squeeze() From cd85dea79c926ed162aabebf3ba650a2758bcd89 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 01:04:12 +0200 Subject: [PATCH 16/35] correction to type annotations --- dsptoolbox/_general_helpers.py | 185 ++++++++++-------- dsptoolbox/_standard.py | 112 ++++++----- dsptoolbox/audio_io/_audio_io.py | 5 +- dsptoolbox/audio_io/audio_io.py | 4 +- dsptoolbox/beamforming/_beamforming.py | 39 ++-- dsptoolbox/beamforming/beamforming.py | 81 ++++---- dsptoolbox/classes/_filter.py | 33 ++-- dsptoolbox/classes/_lattice_ladder_filter.py | 81 ++++---- dsptoolbox/classes/_phaseLinearizer.py | 23 +-- dsptoolbox/classes/_svfilter.py | 5 +- dsptoolbox/classes/filter_class.py | 21 +- dsptoolbox/classes/filterbank.py | 11 +- dsptoolbox/classes/multibandsignal.py | 16 +- dsptoolbox/classes/signal_class.py | 57 +++--- dsptoolbox/distances/_distances.py | 49 ++--- dsptoolbox/distances/distances.py | 23 ++- dsptoolbox/effects/_effects.py | 35 ++-- dsptoolbox/effects/effects.py | 96 +++++---- dsptoolbox/filterbanks/_filterbank.py | 19 +- dsptoolbox/plots/plots.py | 6 +- dsptoolbox/room_acoustics/_room_acoustics.py | 115 ++++++----- dsptoolbox/room_acoustics/room_acoustics.py | 46 +++-- dsptoolbox/standard_functions.py | 33 ++-- .../transfer_functions/_transfer_functions.py | 27 +-- .../transfer_functions/transfer_functions.py | 69 +++---- dsptoolbox/transforms/_transforms.py | 44 +++-- dsptoolbox/transforms/transforms.py | 110 +++++++---- 27 files changed, 738 insertions(+), 607 deletions(-) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index ca60230..27695e0 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -21,7 +21,7 @@ from scipy.fft import next_fast_len -def _find_nearest(points, vector) -> np.ndarray: +def _find_nearest(points, vector) -> NDArray[np.int_]: """Gives back the indexes with the nearest points in vector Parameters @@ -33,14 +33,14 @@ def _find_nearest(points, vector) -> np.ndarray: Returns ------- - indexes : `np.ndarray` + indexes : `NDArray[np.int_]` Indexes of the points. """ points = np.array(points) if np.ndim(points) == 0: points = points[..., None] - indexes = np.zeros(len(points), dtype=int) + indexes = np.zeros(len(points), dtype=np.int_) for ind, p in enumerate(points): indexes[ind] = np.argmin(np.abs(p - vector)) return indexes @@ -52,7 +52,7 @@ def _calculate_window( window_type: str | tuple | list = "hann", at_start: bool = True, inverse=False, -) -> np.ndarray: +) -> NDArray[np.float64]: """Creates a custom window with given indexes Parameters @@ -74,7 +74,7 @@ def _calculate_window( Returns ------- - window_full: np.ndarray + window_full: NDArray[np.float64] Custom window. """ @@ -116,23 +116,26 @@ def _calculate_window( def _get_normalized_spectrum( f, - spectra: np.ndarray, + spectra: NDArray[np.float64], scaling: str = "amplitude", f_range_hz=[20, 20000], normalize: str | None = None, smoothe: int = 0, phase=False, calibrated_data: bool = False, -) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, np.ndarray]: +) -> ( + tuple[NDArray[np.float64], NDArray[np.float64]] + | tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] +): """This function gives a normalized magnitude spectrum in dB with frequency vector for a given range. It is also smoothed. Use `None` for the spectrum without f_range_hz. Parameters ---------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - spectra : `np.ndarray` + spectra : NDArray[np.float64] Spectrum matrix. scaling : str, optional Information about whether the spectrum is scaled as an amplitude or @@ -157,11 +160,11 @@ def _get_normalized_spectrum( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - mag_spectra : `np.ndarray` + mag_spectra : NDArray[np.float64] Magnitude spectrum matrix. - phase_spectra : `np.ndarray` + phase_spectra : NDArray[np.float64] Phase spectrum matrix, only returned when `phase=True`. Notes @@ -269,11 +272,11 @@ def _find_frequencies_above_threshold( def _pad_trim( - vector: np.ndarray, + vector: NDArray[np.float64], desired_length: int, axis: int = 0, in_the_end: bool = True, -) -> np.ndarray: +) -> NDArray[np.float64]: """Pads (with zeros) or trim (depending on size and desired length).""" throw_axis = False if vector.ndim < 2: @@ -348,12 +351,14 @@ def _compute_number_frames( return n_frames, padding_samples -def _normalize(s: np.ndarray, dbfs: float, mode="peak") -> np.ndarray: +def _normalize( + s: NDArray[np.float64], dbfs: float, mode="peak" +) -> NDArray[np.float64]: """Normalizes a signal. Parameters ---------- - s: `np.ndarray` + s: NDArray[np.float64] Signal to normalize. dbfs: float dbfs value to normalize to. @@ -363,7 +368,7 @@ def _normalize(s: np.ndarray, dbfs: float, mode="peak") -> np.ndarray: Returns ------- - s_out: `np.ndarray` + s_out: NDArray[np.float64] Normalized signal. """ @@ -380,28 +385,28 @@ def _normalize(s: np.ndarray, dbfs: float, mode="peak") -> np.ndarray: return s -def _rms(x: np.ndarray) -> np.ndarray: +def _rms(x: NDArray[np.float64]) -> NDArray[np.float64]: """Root mean square computation.""" return np.sqrt(np.sum(x**2) / len(x)) -def _amplify_db(s: np.ndarray, db: float) -> np.ndarray: +def _amplify_db(s: NDArray[np.float64], db: float) -> NDArray[np.float64]: """Amplify by dB.""" return s * 10 ** (db / 20) def _fade( - s: np.ndarray, + s: NDArray[np.float64], length_seconds: float = 0.1, mode: str = "exp", sampling_rate_hz: int = 48000, at_start: bool = True, -) -> np.ndarray: +) -> NDArray[np.float64]: """Create a fade in signal. Parameters ---------- - s : `np.ndarray` + s : NDArray[np.float64] np.array to be faded. length_seconds : float, optional Length of fade in seconds. Default: 0.1. @@ -416,7 +421,7 @@ def _fade( Returns ------- - s : `np.ndarray` + s : NDArray[np.float64] Faded vector. """ @@ -479,19 +484,19 @@ def _gaussian_window_sigma(window_length: int, alpha: float = 2.5) -> float: def _fractional_octave_smoothing( - vector: np.ndarray, + vector: NDArray[np.float64], num_fractions: int = 3, window_type="hann", - window_vec: np.ndarray | None = None, + window_vec: NDArray[np.float64] | None = None, clip_values: bool = False, -) -> np.ndarray: +) -> NDArray[np.float64]: """Smoothes a vector using interpolation to a logarithmic scale. Usually done for smoothing of frequency data. This implementation is taken from the pyfar package, see references. Parameters ---------- - vector : `np.ndarray` + vector : NDArray[np.float64] Vector to be smoothed. It is assumed that the first axis is to be smoothed. num_fractions : int, optional @@ -500,7 +505,7 @@ def _fractional_octave_smoothing( Type of window to be used. See `scipy.signal.windows.get_window` for valid types. If the window is `'gaussian'`, the parameter passed will be interpreted as alpha and not sigma. Default: `'hann'`. - window_vec : `np.ndarray`, optional + window_vec : NDArray[np.float64], optional Window vector to be used as a window. `window_type` should be set to `None` if this direct window is going to be used. Default: `None`. clip_values : bool, optional @@ -508,7 +513,7 @@ def _fractional_octave_smoothing( Returns ------- - vec_final : `np.ndarray` + vec_final : NDArray[np.float64] Vector after smoothing. References @@ -596,13 +601,13 @@ def _fractional_octave_smoothing( def _frequency_weightning( - f: np.ndarray, weightning_mode: str = "a", db_output: bool = True -) -> np.ndarray: + f: NDArray[np.float64], weightning_mode: str = "a", db_output: bool = True +) -> NDArray[np.float64]: """Returns the weights for frequency-weightning. Parameters ---------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. weightning_mode : str, optional Type of weightning. Choose from `'a'` or `'c'`. Default: `'a'`. @@ -611,7 +616,7 @@ def _frequency_weightning( Returns ------- - weights : `np.ndarray` + weights : NDArray[np.float64] Weightning values. References @@ -645,15 +650,17 @@ def _frequency_weightning( def _polyphase_decomposition( - in_sig: np.ndarray, number_polyphase_components: int, flip: bool = False -) -> tuple[np.ndarray, int]: + in_sig: NDArray[np.float64], + number_polyphase_components: int, + flip: bool = False, +) -> tuple[NDArray[np.float64], int]: """Converts input signal array with shape (time samples, channels) into its polyphase representation with shape (time samples, polyphase components, channels). Parameters ---------- - in_sig : `np.ndarray` + in_sig : NDArray[np.float64] Input signal array to be rearranged in polyphase representation. It should have the shape (time samples, channels). number_polyphase_components : int @@ -665,7 +672,7 @@ def _polyphase_decomposition( Returns ------- - poly : `np.ndarray` + poly : NDArray[np.float64] Rearranged vector with polyphase representation. New shape is (time samples, polyphase components, channels). padding : int @@ -696,7 +703,9 @@ def _polyphase_decomposition( return poly, padding -def _polyphase_reconstruction(poly: np.ndarray) -> np.ndarray: +def _polyphase_reconstruction( + poly: NDArray[np.float64], +) -> NDArray[np.float64]: """Returns the reconstructed input signal array from its polyphase representation, possibly with a different length if padded was needed for reconstruction. Polyphase representation shape is assumed to be @@ -704,13 +713,13 @@ def _polyphase_reconstruction(poly: np.ndarray) -> np.ndarray: Parameters ---------- - poly : `np.ndarray` + poly : NDArray[np.float64] Array with 3 dimensions (time samples, polyphase components, channels) as polyphase respresentation of signal. Returns ------- - in_sig : `np.ndarray` + in_sig : NDArray[np.float64] Rearranged vector with shape (time samples, channels). """ @@ -728,7 +737,7 @@ def _polyphase_reconstruction(poly: np.ndarray) -> np.ndarray: return in_sig -def _hz2mel(f: np.ndarray) -> np.ndarray: +def _hz2mel(f: NDArray[np.float64]) -> NDArray[np.float64]: """Convert frequency in Hz into mel. Parameters @@ -749,7 +758,7 @@ def _hz2mel(f: np.ndarray) -> np.ndarray: return 2595 * np.log10(1 + f / 700) -def _mel2hz(mel: np.ndarray) -> np.ndarray: +def _mel2hz(mel: NDArray[np.float64]) -> NDArray[np.float64]: """Convert frequency in mel into Hz. Parameters @@ -772,7 +781,7 @@ def _mel2hz(mel: np.ndarray) -> np.ndarray: def _get_fractional_octave_bandwidth( f_c: float, fraction: int = 1 -) -> np.ndarray: +) -> NDArray[np.float64]: """Returns an array with lower and upper bounds for a given center frequency with (1/fraction)-octave width. @@ -786,7 +795,7 @@ def _get_fractional_octave_bandwidth( Returns ------- - f_bounds : `np.ndarray` + f_bounds : NDArray[np.float64] Array of length 2 with lower and upper bounds. """ @@ -797,19 +806,21 @@ def _get_fractional_octave_bandwidth( ) -def _toeplitz(h: np.ndarray, length_of_input: int) -> np.ndarray: +def _toeplitz( + h: NDArray[np.float64], length_of_input: int +) -> NDArray[np.float64]: """Creates a toeplitz matrix from a system response given an input length. Parameters ---------- - h : `np.ndarray` + h : NDArray[np.float64] System's impulse response. length_of_input : int Input length needed for the shape of the toeplitz matrix. Returns ------- - `np.ndarray` + NDArray[np.float64] Toeplitz matrix with shape (len(h)+length_of_input-1, length_of_input). Convolution is done by using dot product from the right:: @@ -886,19 +897,19 @@ def _get_next_power_2(number, mode: str = "closest") -> int: return int(2**p) -def _euclidean_distance_matrix(x: np.ndarray, y: np.ndarray): +def _euclidean_distance_matrix(x: NDArray[np.float64], y: NDArray[np.float64]): """Compute the euclidean distance matrix between two vectors efficiently. Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] First vector or matrix with shape (Point x, Dimensions). - y : `np.ndarray` + y : NDArray[np.float64] Second vector or matrix with shape (Point y, Dimensions). Returns ------- - dist : `np.ndarray` + dist : NDArray[np.float64] Euclidean distance matrix with shape (Point x, Point y). """ @@ -950,32 +961,34 @@ def _get_smoothing_factor_ema( return 1 - np.exp(factor / relaxation_time_s / sampling_rate_hz) -def _wrap_phase(phase_vector: np.ndarray) -> np.ndarray: +def _wrap_phase(phase_vector: NDArray[np.float64]) -> NDArray[np.float64]: """Wraps phase between [-np.pi, np.pi[ after it has been unwrapped. This works for 1D and 2D arrays, more dimensions have not been tested. Parameters ---------- - phase_vector : `np.ndarray` + phase_vector : NDArray[np.float64] Phase vector for which to wrap the phase. Returns ------- - `np.ndarray` + NDArray[np.float64] Wrapped phase vector. """ return (phase_vector + np.pi) % (2 * np.pi) - np.pi -def _get_exact_gain_1khz(f: np.ndarray, sp_db: np.ndarray) -> float: +def _get_exact_gain_1khz( + f: NDArray[np.float64], sp_db: NDArray[np.float64] +) -> float: """Uses linear interpolation to get the exact gain value at 1 kHz. Parameters ---------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - sp : `np.ndarray` + sp : NDArray[np.float64] Spectrum. It can be in dB or not. Returns @@ -1017,7 +1030,7 @@ def gaussian_window( Returns ------- - w : `np.ndarray` + w : NDArray[np.float64] Gaussian window. References @@ -1063,7 +1076,7 @@ def _get_chirp_rate(range_hz: list, length_seconds: float) -> float: return np.log2(range_hz_array[1] / range_hz_array[0]) / length_seconds -def _correct_for_real_phase_spectrum(phase_spectrum: np.ndarray): +def _correct_for_real_phase_spectrum(phase_spectrum: NDArray[np.float64]): """This function takes in a wrapped phase spectrum and corrects it to be for a real signal (assuming the last frequency bin corresponds to nyquist, i.e., time data had an even length). This effectively adds a @@ -1072,13 +1085,13 @@ def _correct_for_real_phase_spectrum(phase_spectrum: np.ndarray): Parameters ---------- - phase_spectrum : np.ndarray + phase_spectrum : NDArray[np.float64] Wrapped phase to be corrected. It is assumed that its last element corresponds to the nyquist frequency. Returns ------- - np.ndarray + NDArray[np.float64] Phase spectrum that can correspond to a real signal. """ @@ -1094,18 +1107,18 @@ def _correct_for_real_phase_spectrum(phase_spectrum: np.ndarray): def _scale_spectrum( - spectrum: np.ndarray, + spectrum: NDArray[np.float64], mode: str | None, time_length_samples: int, sampling_rate_hz: int, - window: np.ndarray | None = None, -) -> np.ndarray: + window: NDArray[np.float64] | None = None, +) -> NDArray[np.float64]: """Scale the spectrum directly from the (unscaled) FFT. It is assumed that the time data was not windowed. Parameters ---------- - spectrum : `np.ndarray` + spectrum : NDArray[np.float64] Spectrum to scale. It is assumed that the frequency bins are along the first dimension. mode : str, None @@ -1119,7 +1132,7 @@ def _scale_spectrum( Returns ------- - `np.ndarray` + NDArray[np.float64] Scaled spectrum Notes @@ -1172,7 +1185,7 @@ def _scale_spectrum( def _get_fractional_impulse_peak_index( - time_data: np.ndarray, polynomial_points: int = 1 + time_data: NDArray[np.float64], polynomial_points: int = 1 ): """ Obtain the index for the peak in subsample precision using the root @@ -1180,7 +1193,7 @@ def _get_fractional_impulse_peak_index( Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time vector with shape (time samples, channels). polynomial_points : int, optional Number of points to take for the polynomial interpolation and root @@ -1188,7 +1201,7 @@ def _get_fractional_impulse_peak_index( Returns ------- - latency_samples : `np.ndarray` + latency_samples : NDArray[np.float64] Latency of impulses (in samples). It has shape (channels). """ @@ -1261,9 +1274,9 @@ def _get_fractional_impulse_peak_index( def _remove_ir_latency_from_phase( - freqs: np.ndarray, - phase: np.ndarray, - time_data: np.ndarray, + freqs: NDArray[np.float64], + phase: NDArray[np.float64], + time_data: NDArray[np.float64], sampling_rate_hz: int, padding_factor: int, ): @@ -1272,11 +1285,11 @@ def _remove_ir_latency_from_phase( Parameters ---------- - freqs : `np.ndarray` + freqs : NDArray[np.float64] Frequency vector. - phase : `np.ndarray` + phase : NDArray[np.float64] Phase vector. - time_data : `np.ndarray` + time_data : NDArray[np.float64] Corresponding time signal. sampling_rate_hz : int Sample rate. @@ -1285,7 +1298,7 @@ def _remove_ir_latency_from_phase( Returns ------- - new_phase : `np.ndarray` + new_phase : NDArray[np.float64] New phase response without impulse delay. """ @@ -1295,14 +1308,14 @@ def _remove_ir_latency_from_phase( def _min_phase_ir_from_real_cepstrum( - time_data: np.ndarray, padding_factor: int + time_data: NDArray[np.float64], padding_factor: int ): """Returns minimum-phase version of a time series using the real cepstrum method. Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time series to compute the minimum phase version from. It is assumed to have shape (time samples, channels). padding_factor : int, optional @@ -1312,7 +1325,7 @@ def _min_phase_ir_from_real_cepstrum( Returns ------- - min_phase_time_data : `np.ndarray` + min_phase_time_data : NDArray[np.float64] New time series. """ @@ -1327,14 +1340,14 @@ def _min_phase_ir_from_real_cepstrum( def _get_minimum_phase_spectrum_from_real_cepstrum( - time_data: np.ndarray, padding_factor: int + time_data: NDArray[np.float64], padding_factor: int ): """Returns minimum-phase version of a time series using the real cepstrum method. Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time series to compute the minimum phase version from. It is assumed to have shape (time samples, channels). padding_factor : int, optional @@ -1344,7 +1357,7 @@ def _get_minimum_phase_spectrum_from_real_cepstrum( Returns ------- - `np.ndarray` + NDArray[np.float64] New spectrum with minimum phase. """ @@ -1369,7 +1382,9 @@ def _get_minimum_phase_spectrum_from_real_cepstrum( def _fractional_latency( - td1: np.ndarray, td2: np.ndarray | None = None, polynomial_points: int = 1 + td1: NDArray[np.float64], + td2: NDArray[np.float64] | None = None, + polynomial_points: int = 1, ): """This function computes the sub-sample latency between two signals using Zero-Crossing of the analytic (hilbert transformed) correlation function. @@ -1381,7 +1396,7 @@ def _fractional_latency( ---------- td1 : `np.ndaray` Delayed version of the signal. - td2 : `np.ndarray`, optional + td2 : NDArray[np.float64], optional Original version of the signal. If `None` is passed, the latencies are computed between the first channel of td1 and every other. Default: `None`. @@ -1393,7 +1408,7 @@ def _fractional_latency( Returns ------- - lags : `np.ndarray` + lags : NDArray[np.float64] Fractional delays. It has shape (channel). In case td2 was `None`, its length is `channels - 1`. diff --git a/dsptoolbox/_standard.py b/dsptoolbox/_standard.py index 46b855b..2638868 100644 --- a/dsptoolbox/_standard.py +++ b/dsptoolbox/_standard.py @@ -11,10 +11,13 @@ _wrap_phase, ) from warnings import warn +from numpy.typing import NDArray def _latency( - in1: np.ndarray, in2: np.ndarray | None = None, polynomial_points: int = 0 + in1: NDArray[np.float64], + in2: NDArray[np.float64] | None = None, + polynomial_points: int = 0, ): """Computes the latency between two functions using the correlation method. The variable polynomial_points is only a dummy to share the same function @@ -35,8 +38,8 @@ def _latency( def _welch( - x: np.ndarray, - y: np.ndarray | None, + x: NDArray[np.float64], + y: NDArray[np.float64] | None, fs_hz: int, window_type: str = "hann", window_length_samples: int = 1024, @@ -44,14 +47,14 @@ def _welch( detrend: bool = True, average: str = "mean", scaling: str | None = "power spectral density", -) -> np.ndarray: +) -> NDArray[np.float64]: """Cross spectral density computation with Welch's method. Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] First signal with shape (time samples, channel). - y : `np.ndarray` or `None` + y : NDArray[np.float64] or `None` Second signal with shape (time samples, channel). If `None`, the auto- spectrum of `x` will be computed. fs_hz : int @@ -77,7 +80,7 @@ def _welch( Returns ------- - csd : `np.ndarray` + csd : NDArray[np.float64] Complex cross spectral density vector if x and y are different. Alternatively, the (real) autocorrelation power spectral density when x and y are the same. If density or spectrum depends on scaling. @@ -97,11 +100,11 @@ def _welch( """ autospectrum = y is None - if type(x) is not np.ndarray: + if type(x) is not NDArray[np.float64]: x = np.asarray(x).squeeze() if not autospectrum: - if type(y) is not np.ndarray: + if type(y) is not NDArray[np.float64]: y = np.asarray(y).squeeze() assert x.shape == y.shape, "Shapes of data do not match" # NOTE: Computing the spectrum in a vectorized manner for all channels @@ -229,12 +232,12 @@ def _welch( return csd -def _group_delay_direct(phase: np.ndarray, delta_f: float = 1): +def _group_delay_direct(phase: NDArray[np.float64], delta_f: float = 1): """Computes group delay by differentiation of the unwrapped phase. Parameters ---------- - phase : `np.ndarray` + phase : NDArray[np.float64] Complex spectrum or phase for the direct method delta_f : float, optional Frequency step for the phase. If it equals 1, group delay is computed @@ -242,7 +245,7 @@ def _group_delay_direct(phase: np.ndarray, delta_f: float = 1): Returns ------- - gd : `np.ndarray` + gd : NDArray[np.float64] Group delay vector either in s or in samples if no frequency step is given. @@ -257,16 +260,16 @@ def _group_delay_direct(phase: np.ndarray, delta_f: float = 1): def _minimum_phase( - magnitude: np.ndarray, + magnitude: NDArray[np.float64], whole_spectrum: bool = False, unwrapped: bool = True, odd_length: bool = False, -) -> np.ndarray: +) -> NDArray[np.float64]: """Computes minimum phase system from magnitude spectrum. Parameters ---------- - magnitude : `np.ndarray` + magnitude : NDArray[np.float64] Spectrum for which to compute the minimum phase. If real, it is assumed to be already the magnitude. whole_spectrum : bool, optional @@ -281,7 +284,7 @@ def _minimum_phase( Returns ------- - minimum_phase : `np.ndarray` + minimum_phase : NDArray[np.float64] Minimal phase of the system. """ @@ -310,7 +313,7 @@ def _minimum_phase( def _stft( - x: np.ndarray, + x: NDArray[np.float64], fs_hz: int, window_length_samples: int = 2048, window_type: str = "hann", @@ -324,7 +327,7 @@ def _stft( Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] First signal fs_hz : int Sampling rate in Hz. @@ -353,11 +356,11 @@ def _stft( Returns ------- - time_s : `np.ndarray` + time_s : NDArray[np.float64] Time vector in seconds for each frame. - freqs_hz : `np.ndarray` + freqs_hz : NDArray[np.float64] Frequency vector. - stft : `np.ndarray` + stft : NDArray[np.float64] STFT matrix with shape (frequency, time, channel). References @@ -445,7 +448,7 @@ def _stft( def _csm( - time_data: np.ndarray, + time_data: NDArray[np.float64], sampling_rate_hz: int, window_length_samples: int = 1024, window_type: str = "hann", @@ -459,7 +462,7 @@ def _csm( Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Signal sampling_rate_hz : int Sampling rate in Hz. @@ -484,9 +487,9 @@ def _csm( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector - csm : `np.ndarray` + csm : NDArray[np.float64] Cross spectral matrix with shape (frequency, channels, channels). References @@ -537,7 +540,7 @@ def _csm( def _center_frequencies_fractional_octaves_iec( nominal, num_fractions -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Returns the exact center frequencies for fractional octave bands according to the IEC 61260:1:2014 standard. octave ratio @@ -642,7 +645,7 @@ def _center_frequencies_fractional_octaves_iec( def _exact_center_frequencies_fractional_octaves( num_fractions, frequency_range -) -> np.ndarray: +) -> NDArray[np.float64]: """Calculate the center frequencies of arbitrary fractional octave bands. Parameters @@ -707,7 +710,7 @@ def _kaiser_window_beta(A): def _kaiser_window_fractional( length: int, side_lobe_suppression_db: float, fractional_delay: float -) -> np.ndarray: +) -> NDArray[np.float64]: """Create a kaiser window with a fractional offset. Parameters @@ -721,7 +724,7 @@ def _kaiser_window_fractional( Returns ------- - `np.ndarray` + NDArray[np.float64] Kaiser window. """ @@ -742,7 +745,7 @@ def _kaiser_window_fractional( def _indices_above_threshold_dbfs( - time_vec: np.ndarray, + time_vec: NDArray[np.float64], threshold_dbfs: float, attack_smoothing_coeff: int, release_smoothing_coeff: int, @@ -753,7 +756,7 @@ def _indices_above_threshold_dbfs( Parameters ---------- - time_vec : `np.ndarray` + time_vec : NDArray[np.float64] Time series for which to find indices above power threshold. Can only take one channel. threshold_dbfs : float @@ -768,7 +771,7 @@ def _indices_above_threshold_dbfs( Returns ------- - indices_above : `np.ndarray` + indices_above : NDArray[np.float64] Array of type boolean with length of time_vec indicating indices above threshold with `True` and below with `False`. @@ -801,12 +804,14 @@ def _indices_above_threshold_dbfs( return indices_above -def _detrend(time_data: np.ndarray, polynomial_order: int) -> np.ndarray: +def _detrend( + time_data: NDArray[np.float64], polynomial_order: int +) -> NDArray[np.float64]: """Compute and return detrended signal. Parameters ---------- - time_data : np.ndarray + time_data : NDArray[np.float64] Time data of the signal with shape (time samples, channels). polynomial_order : int Polynomial order of the fitted polynomial that will be removed @@ -814,7 +819,7 @@ def _detrend(time_data: np.ndarray, polynomial_order: int) -> np.ndarray: Returns ------- - new_time_data : np.ndarray + new_time_data : NDArray[np.float64] Detrended time data with shape (time samples, channels). """ @@ -825,18 +830,19 @@ def _detrend(time_data: np.ndarray, polynomial_order: int) -> np.ndarray: return time_data -def _rms(x: np.ndarray) -> float | np.ndarray: +def _rms(x: NDArray[np.float64]) -> float | NDArray[np.float64]: """Root mean squared value of a discrete time series. Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] Time series. Returns ------- - rms : float or `np.ndarray` - Root mean squared of a signal. Float or np.ndarray depending on input. + rms : float or NDArray[np.float64] + Root mean squared of a signal. Float or NDArray[np.float64] depending + on input. """ single_dim = False @@ -856,16 +862,16 @@ def _rms(x: np.ndarray) -> float | np.ndarray: def _get_framed_signal( - td: np.ndarray, + td: NDArray[np.float64], window_length_samples: int, step_size: int, keep_last_frames: bool = True, -) -> np.ndarray: +) -> NDArray[np.float64]: """This method computes a framed version of a signal and returns it. Parameters ---------- - td : `np.ndarray` + td : NDArray[np.float64] Signal with shape (time samples, channels). window_length_samples : int Window length in samples. @@ -877,7 +883,7 @@ def _get_framed_signal( Returns ------- - td_framed : `np.ndarray` + td_framed : NDArray[np.float64] Framed signal with shape (time samples, frames, channels). """ @@ -911,21 +917,21 @@ def _get_framed_signal( def _reconstruct_framed_signal( - td_framed: np.ndarray, + td_framed: NDArray[np.float64], step_size: int, - window: str | np.ndarray | None = None, + window: str | NDArray[np.float64] | None = None, original_signal_length: int | None = None, safety_threshold: float = 1e-4, -) -> np.ndarray: +) -> NDArray[np.float64]: """Gets and returns a framed signal into its vector representation. Parameters ---------- - td_framed : `np.ndarray` + td_framed : NDArray[np.float64] Framed signal with shape (time samples, frame, channel). step_size : int Step size in samples between frames (also known as hop length). - window : str, `np.ndarray`, optional + window : str, NDArray[np.float64], optional Window (if applies). Pass `None` to avoid using a window during reconstruction. Default: `None`. original_signal_length : int, optional @@ -940,7 +946,7 @@ def _reconstruct_framed_signal( Returns ------- - td : `np.ndarray` + td : NDArray[np.float64] Reconstructed signal. """ @@ -950,7 +956,7 @@ def _reconstruct_framed_signal( if window is not None: if type(window) is str: window = windows.get_window(window, td_framed.shape[0]) - elif type(window) is np.ndarray: + elif type(window) is NDArray[np.float64]: assert window.ndim == 1, "Window must be a 1D-array" assert ( window.shape[0] == td_framed.shape[0] @@ -983,7 +989,7 @@ def _reconstruct_framed_signal( def _get_window_envelope( - window: np.ndarray, + window: NDArray[np.float64], total_length_samples: int, step_size_samples: int, number_frames: int, @@ -1008,7 +1014,7 @@ def _fractional_delay_filter( delay_samples: float, filter_order: int, side_lobe_suppression_db: float, -) -> tuple[int, np.ndarray]: +) -> tuple[int, NDArray[np.float64]]: """This function delivers fractional delay filters according to specifications. Besides, additional integer delay, that might be necessary to compute the output, is returned as well. @@ -1033,7 +1039,7 @@ def _fractional_delay_filter( ------- integer_delay : int Additional integer delay necessary to achieve total desired delay. - h : `np.ndarray` + h : NDArray[np.float64] Filter's impulse response for fractional delay. References diff --git a/dsptoolbox/audio_io/_audio_io.py b/dsptoolbox/audio_io/_audio_io.py index 874a904..6426444 100644 --- a/dsptoolbox/audio_io/_audio_io.py +++ b/dsptoolbox/audio_io/_audio_io.py @@ -23,7 +23,8 @@ def standard_callback(signal: Signal): Function to be used as callback for the output stream. The signature must be valid for sounddevice's callback:: - call(outdata: np.ndarray, frames: int, time, status) -> None + call(outdata: NDArray[np.float64], frames: int, time, status)\ + -> None """ # Normalize @@ -36,7 +37,7 @@ def call(outdata: ndarray, frames: int, time, status) -> None: Parameters ---------- - outdata : `np.ndarray` + outdata : NDArray[np.float64] Samples as numpy array with shape (samples, channels). frames : int Block size in samples. diff --git a/dsptoolbox/audio_io/audio_io.py b/dsptoolbox/audio_io/audio_io.py index 02b4f69..7a07285 100644 --- a/dsptoolbox/audio_io/audio_io.py +++ b/dsptoolbox/audio_io/audio_io.py @@ -429,7 +429,7 @@ def play_through_stream( audio_callback(signal: Signal) -> callable - callback(outdata: np.ndarray, frames: int, + callback(outdata: NDArray[np.float64], frames: int, time: CData, status: CallbackFlags) -> None See `sounddevice`'s examples of callbacks for more general @@ -513,7 +513,7 @@ def output_stream( callback : callable Function that defines the audio callback:: - callback(outdata: np.ndarray, frames: int, + callback(outdata: NDArray[np.float64], frames: int, time: CData, status: CallbackFlags) -> None finished_callback : callable diff --git a/dsptoolbox/beamforming/_beamforming.py b/dsptoolbox/beamforming/_beamforming.py index 106dced..1b56884 100644 --- a/dsptoolbox/beamforming/_beamforming.py +++ b/dsptoolbox/beamforming/_beamforming.py @@ -3,9 +3,10 @@ """ import numpy as np -from .._general_helpers import _euclidean_distance_matrix import matplotlib.pyplot as plt from seaborn import set_style +from numpy.typing import NDArray +from .._general_helpers import _euclidean_distance_matrix set_style("whitegrid") @@ -56,7 +57,7 @@ def number_of_points(self): return self.coordinates.shape[0] @property - def coordinates(self) -> np.ndarray: + def coordinates(self) -> NDArray[np.float64]: return self._coordinates.copy() @coordinates.setter @@ -87,23 +88,25 @@ def extent(self): return extent # ======== distances ====================================================== - def get_distances_to_point(self, point: np.ndarray) -> np.ndarray: + def get_distances_to_point( + self, point: NDArray[np.float64] + ) -> NDArray[np.float64]: """Compute distances (euclidean) from given point to all points of the object efficiently. Parameters ---------- - point : `np.ndarray` + point : NDArray[np.float64] Point or points to which to compute the distances from all other points. Its shape should be (point, coordinate). Returns ------- - distances : `np.ndarray` + distances : NDArray[np.float64] Distances with shape (points, new_points). """ - if type(point) is not np.ndarray: + if type(point) is not NDArray[np.float64]: point = np.asarray(point) if point.ndim == 1: point = point[None, ...] @@ -164,7 +167,7 @@ def plot_points(self, projection: str | None = None): fig.tight_layout() return fig, ax - def find_nearest_point(self, point) -> tuple[int, np.ndarray]: + def find_nearest_point(self, point) -> tuple[int, NDArray[np.float64]]: """This method returns the coordinates and index of the nearest point to a given point using euclidean distance. @@ -177,7 +180,7 @@ def find_nearest_point(self, point) -> tuple[int, np.ndarray]: ------- index : int Index of the nearest point. - coord : `np.ndarray` + coord : NDArray[np.float64] Position vector with shape (x, y, z) of the nearest point. """ @@ -195,26 +198,26 @@ def find_nearest_point(self, point) -> tuple[int, np.ndarray]: def _clean_sc_deconvolve( - map: np.ndarray, - csm: np.ndarray, - h: np.ndarray, - h_H: np.ndarray, + map: NDArray[np.float64], + csm: NDArray[np.float64], + h: NDArray[np.float64], + h_H: NDArray[np.float64], maximum_iterations: int, remove_diagonal_csm: bool, safety_factor: float, -) -> np.ndarray: +) -> NDArray[np.float64]: """Computes and returns the degraded csm. Parameters ---------- - map : `np.ndarray` + map : NDArray[np.float64] Initial beamforming map to be deconvolved for a single frequency with shape (point). - csm : `np.ndarray` + csm : NDArray[np.float64] Cross-spectral matrix for a single frequency with shape (mic, mic). - h : `np.ndarray` + h : NDArray[np.float64] Steering vector for a single frequency with shape (mic, grid point). - h_H : `np.ndarray` + h_H : NDArray[np.float64] Steering vector (hermitian transposed) for a single frequency with shape (grid point, mic). maximum_iterations : int @@ -228,7 +231,7 @@ def _clean_sc_deconvolve( Returns ------- - `np.ndarray` + NDArray[np.float64] Deconvolved beamforming map. References diff --git a/dsptoolbox/beamforming/beamforming.py b/dsptoolbox/beamforming/beamforming.py index d73ffd1..08fbbd6 100644 --- a/dsptoolbox/beamforming/beamforming.py +++ b/dsptoolbox/beamforming/beamforming.py @@ -8,6 +8,7 @@ from scipy.integrate import simpson from matplotlib.figure import Figure from matplotlib.axes import Axes +from numpy.typing import NDArray from ..classes import Signal from .. import fractional_delay, merge_signals, pad_trim @@ -67,19 +68,21 @@ def __init__(self, positions: dict): """ super().__init__(positions) - def reconstruct_map_shape(self, map: np.ndarray) -> np.ndarray: + def reconstruct_map_shape( + self, map: NDArray[np.float64] + ) -> NDArray[np.float64]: """Placeholder for a user-defined map reconstruction. Here, it returns same given map. Use inheritance from the `Grid` class to overwrite this with an own implementation. Parameters ---------- - map : `np.ndarray` + map : NDArray[np.float64] Map to be reshaped. Returns ------- - map : `np.ndarray` + map : NDArray[np.float64] Reshaped map. Here with same passed shape as before. """ @@ -163,17 +166,19 @@ def __init__(self, line1, line2, dimensions, value3): } super().__init__(positions) - def reconstruct_map_shape(self, map_vector: np.ndarray) -> np.ndarray: + def reconstruct_map_shape( + self, map_vector: NDArray[np.float64] + ) -> NDArray[np.float64]: """Reshapes the map to be a matrix that fits the grid. Parameters ---------- - map_vector : `np.ndarray` + map_vector : NDArray[np.float64] Map (as a vector) to be reshaped. Returns ------- - map : `np.ndarray` + map : NDArray[np.float64] Reshaped map. """ @@ -186,13 +191,13 @@ def reconstruct_map_shape(self, map_vector: np.ndarray) -> np.ndarray: return map_vector.reshape(self.original_lengths) def plot_map( - self, map: np.ndarray, range_db: float = 20 + self, map: NDArray[np.float64], range_db: float = 20 ) -> tuple[Figure, Axes]: """Plot a map done with this type of grid. Parameters ---------- - map : `np.ndarray` + map : NDArray[np.float64] Beamformer map. range_db : float, optional Range in dB to plot. @@ -289,17 +294,19 @@ def __init__(self, line_x, line_y, line_z): } super().__init__(positions) - def reconstruct_map_shape(self, map_vector: np.ndarray) -> np.ndarray: + def reconstruct_map_shape( + self, map_vector: NDArray[np.float64] + ) -> NDArray[np.float64]: """Reshapes the map to be a matrix that fits the grid. Parameters ---------- - map_vector : `np.ndarray` + map_vector : NDArray[np.float64] Map (as a vector) to be reshaped. Returns ------- - map : `np.ndarray` + map : NDArray[np.float64] Reshaped map. """ @@ -313,7 +320,7 @@ def reconstruct_map_shape(self, map_vector: np.ndarray) -> np.ndarray: def plot_map( self, - map: np.ndarray, + map: NDArray[np.float64], third_dimension: str, value_third_dimension: float, range_db: float = 20, @@ -322,7 +329,7 @@ def plot_map( Parameters ---------- - map : `np.ndarray` + map : NDArray[np.float64] Beamformer map. third_dimension : str Choose the dimension that is normal to plane. Choose from `'x'`, @@ -544,12 +551,12 @@ def __compute_array_center(self): Parameters ---------- - coord : `np.ndarray` + coord : NDArray[np.float64] Coordinates of array with shape (points, xyz). Returns ------- - `np.ndarray` + NDArray[np.float64] Array with coordinates for mic closest to center with shape (x, y, z). ind : int @@ -859,7 +866,7 @@ def get_beamformer_map( center_frequency_hz: float, octave_fraction: int = 3, remove_csm_diagonal: bool = True, - ) -> np.ndarray: + ) -> NDArray[np.float64]: """Run delay-and-sum beamforming in the given frequency range. Parameters @@ -875,7 +882,7 @@ def get_beamformer_map( Returns ------- - map : `np.ndarray` + map : NDArray[np.float64] Beamforming map """ @@ -955,7 +962,7 @@ def get_beamformer_map( maximum_iterations: int | None = None, safety_factor: float = 0.5, remove_csm_diagonal: bool = False, - ) -> np.ndarray: + ) -> NDArray[np.float64]: """Returns a deconvolved beaforming map. Parameters @@ -980,7 +987,7 @@ def get_beamformer_map( Returns ------- - map : `np.ndarray` + map : NDArray[np.float64] Beamformer map. References @@ -1083,7 +1090,7 @@ def get_beamformer_map( center_frequency_hz: float, octave_fraction: int = 3, number_eigenvalues: int | None = None, - ) -> np.ndarray: + ) -> NDArray[np.float64]: """Returns a beaforming map created with orthogonal beamforming. Parameters @@ -1100,7 +1107,7 @@ def get_beamformer_map( Returns ------- - map : np.ndarray + map : NDArray[np.float64] Beamformer map. References @@ -1202,7 +1209,7 @@ def get_beamformer_map( center_frequency_hz: float, octave_fraction: int = 3, gamma: float = 10, - ) -> np.ndarray: + ) -> NDArray[np.float64]: """Returns a beaforming map created with functional beamforming. Parameters @@ -1217,7 +1224,7 @@ def get_beamformer_map( Returns ------- - map : np.ndarray + map : NDArray[np.float64] Beamformer map. References @@ -1303,7 +1310,7 @@ def get_beamformer_map( center_frequency_hz: float, octave_fraction: int = 3, gamma: float = 10, - ) -> np.ndarray: + ) -> NDArray[np.float64]: """Returns a beaforming map created with MVDR beamforming. Parameters @@ -1316,7 +1323,7 @@ def get_beamformer_map( Returns ------- - map : np.ndarray + map : NDArray[np.float64] Beamformer map. References @@ -1586,8 +1593,8 @@ def mix_sources_on_array( # ========== Steering vector formulations ===================================== def classic_steering( - wave_number: np.ndarray, grid: Grid, mic: MicArray -) -> np.ndarray: + wave_number: NDArray[np.float64], grid: Grid, mic: MicArray +) -> NDArray[np.float64]: """Classic formulation for steering vector (formulation 1 in reference paper). @@ -1602,7 +1609,7 @@ def classic_steering( Returns ------- - steering_vector : `np.ndarray` + steering_vector : NDArray[np.float64] Complex steering vector with shape (frequency, nmics, ngrid). References @@ -1636,8 +1643,8 @@ def classic_steering( def inverse_steering( - wave_number: np.ndarray, grid: Grid, mic: MicArray -) -> np.ndarray: + wave_number: NDArray[np.float64], grid: Grid, mic: MicArray +) -> NDArray[np.float64]: """Inverse formulation for steering vector (formulation 2 in reference paper). @@ -1652,7 +1659,7 @@ def inverse_steering( Returns ------- - steering_vector : `np.ndarray` + steering_vector : NDArray[np.float64] Complex steering vector with shape (frequency, nmics, ngrid). References @@ -1687,8 +1694,8 @@ def inverse_steering( def true_power_steering( - wave_number: np.ndarray, grid: Grid, mic: MicArray -) -> np.ndarray: + wave_number: NDArray[np.float64], grid: Grid, mic: MicArray +) -> NDArray[np.complex128]: """Formulation for true power steering vector (formulation 3 in reference paper). @@ -1703,7 +1710,7 @@ def true_power_steering( Returns ------- - steering_vector : `np.ndarray` + steering_vector : NDArray[np.complex128] Complex steering vector with shape (frequency, nmics, ngrid). References @@ -1740,8 +1747,8 @@ def true_power_steering( def true_location_steering( - wave_number: np.ndarray, grid: Grid, mic: MicArray -) -> np.ndarray: + wave_number: NDArray[np.float64], grid: Grid, mic: MicArray +) -> NDArray[np.float64]: """Formulation for true location steering vector (formulation 4 in reference paper). @@ -1756,7 +1763,7 @@ def true_location_steering( Returns ------- - steering_vector : `np.ndarray` + steering_vector : NDArray[np.float64] Complex steering vector with shape (frequency, ngrid, nmics). References diff --git a/dsptoolbox/classes/_filter.py b/dsptoolbox/classes/_filter.py index 2509c9b..0731373 100644 --- a/dsptoolbox/classes/_filter.py +++ b/dsptoolbox/classes/_filter.py @@ -6,6 +6,7 @@ from warnings import warn from enum import Enum import scipy.signal as sig +from numpy.typing import NDArray from .signal_class import Signal from .multibandsignal import MultiBandSignal from .._general_helpers import _polyphase_decomposition @@ -59,7 +60,7 @@ class biquad(Enum): def _biquad_coefficients( eq_type: int | str = 0, fs_hz: int = 48000, - frequency_hz: float | list | tuple | np.ndarray = 1000, + frequency_hz: float | list | tuple | NDArray[np.float64] = 1000, gain_db: float = 0, q: float = 1, ): @@ -171,7 +172,7 @@ def _impulse(length_samples: int = 512, delay_samples: int = 0): Returns ------- - imp : `np.ndarray` + imp : NDArray[np.float64] Impulse. """ @@ -196,9 +197,9 @@ def _group_delay_filter(ba, length_samples: int = 512, fs_hz: int = 48000): Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - gd : `np.ndarray` + gd : NDArray[np.float64] Group delay in seconds. """ @@ -321,7 +322,7 @@ def _filter_on_signal_ba( Signal to be filtered. ba : list List with ba coefficients of filter. Form ba=[b, a] where b and a - are of type `np.ndarray`. + are of type NDArray[np.float64]. channels : array-like, optional Channel or array of channels to be filtered. When `None`, all channels are filtered. Default: `None`. @@ -477,10 +478,10 @@ def _filterbank_on_signal( def _lfilter_fir( - b: np.ndarray, - a: np.ndarray, - x: np.ndarray, - zi: np.ndarray | None = None, + b: NDArray[np.float64], + a: NDArray[np.float64], + x: NDArray[np.float64], + zi: NDArray[np.float64] | None = None, axis: int = 0, ): """Variant to the `scipy.signal.lfilter` that uses `scipy.signal.convolve` @@ -529,11 +530,11 @@ def _lfilter_fir( def _filter_and_downsample( - time_data: np.ndarray, + time_data: NDArray[np.float64], down_factor: int, ba_coefficients: list, polyphase: bool, -) -> np.ndarray: +) -> NDArray[np.float64]: """Filters and downsamples time data. If polyphase is `True`, it is assumed that the filter is FIR and only b-coefficients are used. In that case, an efficient downsampling is done, otherwise standard filtering @@ -541,7 +542,7 @@ def _filter_and_downsample( Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time data to be filtered and resampled. Shape should be (time samples, channels). down_factor : int @@ -554,7 +555,7 @@ def _filter_and_downsample( Returns ------- - new_time_data : `np.ndarray` + new_time_data : NDArray[np.float64] New time data with downsampling. """ @@ -598,7 +599,7 @@ def _filter_and_downsample( def _filter_and_upsample( - time_data: np.ndarray, + time_data: NDArray[np.float64], up_factor: int, ba_coefficients: list, polyphase: bool, @@ -614,7 +615,7 @@ def _filter_and_upsample( Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time data to be filtered and resampled. Shape should be (time samples, channels). up_factor : int @@ -627,7 +628,7 @@ def _filter_and_upsample( Returns ------- - new_time_data : `np.ndarray` + new_time_data : NDArray[np.float64] New time data with downsampling. """ diff --git a/dsptoolbox/classes/_lattice_ladder_filter.py b/dsptoolbox/classes/_lattice_ladder_filter.py index 8fc552c..da52462 100644 --- a/dsptoolbox/classes/_lattice_ladder_filter.py +++ b/dsptoolbox/classes/_lattice_ladder_filter.py @@ -5,6 +5,7 @@ from .signal_class import Signal from warnings import warn import numpy as np +from numpy.typing import NDArray class LatticeLadderFilter: @@ -24,8 +25,8 @@ class LatticeLadderFilter: def __init__( self, - k_coefficients: np.ndarray, - c_coefficients: np.ndarray | None = None, + k_coefficients: NDArray[np.float64], + c_coefficients: NDArray[np.float64] | None = None, sampling_rate_hz: int | None = None, ): """Constructs a lattice or lattice/ladder filter. If `k_coefficients` @@ -38,10 +39,10 @@ def __init__( Parameters ---------- - k_coefficients : `np.ndarray` + k_coefficients : NDArray[np.float64] Reflection coefficients. It can be a 1d array or a 2d-array for second-order sections with shape (section, coefficients). - c_coefficients : `np.ndarray`, optional + c_coefficients : NDArray[np.float64], optional Feedforward coefficients. It can be a 1d-array or a 2d-array for second-order sections. Default: `None`. sampling_rate_hz : int @@ -95,7 +96,7 @@ def __init__( self.iir_filter = False self.k = k_coefficients self.c = c_coefficients - self.state: np.ndarray | None = None + self.state: NDArray[np.float64] | None = None self.sampling_rate_hz = sampling_rate_hz def initialize_zi(self, n_channels: int): @@ -118,7 +119,7 @@ def filter_signal( ---------- signal : `Signal` Signal to filter. - channels : `np.ndarray`, int, optional + channels : NDArray[np.float64], int, optional Channels to filter. If `None`, all channels of the signal are filtered. activate_zi : bool, optional @@ -177,11 +178,11 @@ def filter_signal( def _lattice_ladder_filtering_sos( - k: np.ndarray, - c: np.ndarray, - td: np.ndarray, - state: np.ndarray | None = None, -) -> tuple[np.ndarray, np.ndarray | None]: + k: NDArray[np.float64], + c: NDArray[np.float64], + td: NDArray[np.float64], + state: NDArray[np.float64] | None = None, +) -> tuple[NDArray[np.float64], NDArray[np.float64] | None]: """Filtering using a lattice/ladder structure of second-order sections. See `_lattice_ladder_filtering` for the parameter explanation. @@ -223,8 +224,10 @@ def _lattice_ladder_filtering_sos( def _lattice_filtering_fir( - k: np.ndarray, td: np.ndarray, state: np.ndarray | None = None -) -> tuple[np.ndarray, np.ndarray | None]: + k: NDArray[np.float64], + td: NDArray[np.float64], + state: NDArray[np.float64] | None = None, +) -> tuple[NDArray[np.float64], NDArray[np.float64] | None]: """Filtering using a lattice structure.""" passed_state = True if state is None: @@ -251,23 +254,23 @@ def _lattice_filtering_fir( def _lattice_ladder_filtering_iir( - k: np.ndarray, - c: np.ndarray, - td: np.ndarray, - state: np.ndarray | None = None, -) -> tuple[np.ndarray, np.ndarray | None]: + k: NDArray[np.float64], + c: NDArray[np.float64], + td: NDArray[np.float64], + state: NDArray[np.float64] | None = None, +) -> tuple[NDArray[np.float64], NDArray[np.float64] | None]: """Filtering using a lattice ladder structure (general IIR filter). The implementation follows [1]. Parameters ---------- - k : `np.ndarray` + k : NDArray[np.float64] Reflection coefficients. - c : `np.ndarray` + c : NDArray[np.float64] Feedforward coefficients. - td : `np.ndarray` + td : NDArray[np.float64] Time data assumed to have shape (time samples, channel). - state : `np.ndarray`, optional + state : NDArray[np.float64], optional Initial state for each channel as a 2D-matrix with shape (filter order, channel). State of the filter in the beginning. The last state corresponds to the last reflection coefficient (furthest to the @@ -275,9 +278,9 @@ def _lattice_ladder_filtering_iir( Returns ------- - new_td : `np.ndarray` + new_td : NDArray[np.float64] Filtered time data. - state : `np.ndarray` + state : NDArray[np.float64] Filter's state after filtering. It can be `None` if `None` was originally passed for `state`. @@ -312,24 +315,24 @@ def _lattice_ladder_filtering_iir( def _get_lattice_ladder_coefficients_iir( - b: np.ndarray, a: np.ndarray -) -> tuple[np.ndarray, np.ndarray]: + b: NDArray[np.float64], a: NDArray[np.float64] +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Compute reflection coefficients `k` and ladder coefficients `c` from feedforward `b` and feedbackward `a` coefficients according to the equations presented in [1]. Parameters ---------- - b : `np.ndarray` + b : NDArray[np.float64] Feedforward coefficients of a filter. - a : `np.ndarray` + a : NDArray[np.float64] Feedbackward coefficients. Returns ------- - k : `np.ndarray` + k : NDArray[np.float64] Reflection coefficients with the length of the order . - c : `np.ndarray` + c : NDArray[np.float64] Ladder coefficients. References @@ -361,20 +364,20 @@ def _get_lattice_ladder_coefficients_iir( def _get_lattice_ladder_coefficients_iir_sos( - sos: np.ndarray, -) -> tuple[np.ndarray, np.ndarray]: + sos: NDArray[np.float64], +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Compute the lattice/ladder coefficients for second-order IIR sections. Parameters ---------- - sos : `np.ndarray` + sos : NDArray[np.float64] Second-order sections with shape (..., 6) as used by `scipy.signal`. Returns ------- - k_sos : `np.ndarray` + k_sos : NDArray[np.float64] Reflection coefficients for second-order sections. - c_sos : `np.ndarray` + c_sos : NDArray[np.float64] Ladder coefficients for second-order sections. """ @@ -396,18 +399,20 @@ def _get_lattice_ladder_coefficients_iir_sos( return k, c -def _get_lattice_coefficients_fir(b: np.ndarray) -> np.ndarray: +def _get_lattice_coefficients_fir( + b: NDArray[np.float64], +) -> NDArray[np.float64]: """Compute reflection coefficients `k` for an FIR filter according to the equations presented in [1]. Parameters ---------- - b : `np.ndarray` + b : NDArray[np.float64] Feedforward coefficients of a filter. Returns ------- - k : `np.ndarray` + k : NDArray[np.float64] Reflection coefficients. References diff --git a/dsptoolbox/classes/_phaseLinearizer.py b/dsptoolbox/classes/_phaseLinearizer.py index 2774532..dffd93a 100644 --- a/dsptoolbox/classes/_phaseLinearizer.py +++ b/dsptoolbox/classes/_phaseLinearizer.py @@ -1,8 +1,9 @@ from .filter_class import Filter from .signal_class import Signal import numpy as np -from scipy.integrate import cumulative_simpson +from scipy.integrate import cumulative_trapezoid from scipy.interpolate import interp1d +from numpy.typing import NDArray from .._general_helpers import ( _correct_for_real_phase_spectrum, _pad_trim, @@ -19,10 +20,10 @@ class PhaseLinearizer: def __init__( self, - phase_response: np.ndarray, + phase_response: NDArray[np.float64], time_data_length_samples: int, sampling_rate_hz: int, - target_group_delay_samples: np.ndarray | None = None, + target_group_delay_samples: NDArray[np.float64] | None = None, ): """PhaseLinearizer creates an FIR filter that can linearize a phase response. Use the method `set_parameters` to define specific design @@ -30,16 +31,16 @@ def __init__( Parameters ---------- - phase_response : `np.ndarray` + phase_response : NDArray[np.float64] Wrapped phase response that should be linearized. It is expected to contain only the positive frequencies (including dc and eventually nyquist). - time_data_length_samples : `np.ndarray` + time_data_length_samples : NDArray[np.float64] Length of the time signal that gave the phase response. sampling_rate_hz : int Sampling rate corresponding to the passed phase response. It is also used for the designed FIR filter. - target_group_delay_samples : `np.ndarray` or `None`, optional + target_group_delay_samples : NDArray[np.float64] or `None`, optional If passed, this overwrites the phase response and becomes the target for the FIR filter. It must be given in samples for the whole spectrum (only positive frequencies). For producing @@ -62,12 +63,12 @@ def __init__( if target_group_delay_samples is not None: self._set_target_group_delay(target_group_delay_samples) - def _set_target_group_delay(self, target_group_delay: np.ndarray): + def _set_target_group_delay(self, target_group_delay: NDArray[np.float64]): """Set target group delay to use instead of phase response. Parameters ---------- - target_group_delay : `np.ndarray` + target_group_delay : NDArray[np.float64] Target group delay (in samples) to use. """ @@ -132,7 +133,7 @@ def get_filter_as_ir(self) -> Signal: None, self._design(), self.sampling_rate_hz, signal_type="ir" ) - def _design(self) -> np.ndarray: + def _design(self) -> NDArray[np.float64]: """Compute filter.""" if not hasattr(self, "target_group_delay"): gd = self._get_group_delay() @@ -189,7 +190,7 @@ def _design(self) -> np.ndarray: gd_time_length_samples = new_gd_time_length_samples # Get new phase using group target group delay - new_phase = -cumulative_simpson(target_gd, initial=0) + new_phase = -cumulative_trapezoid(target_gd, initial=0) # Correct if nyquist is given if gd_time_length_samples % 2 == 0: new_phase = _correct_for_real_phase_spectrum( @@ -207,7 +208,7 @@ def _design(self) -> np.ndarray: ir = _pad_trim(ir, trim_length) return ir - def _get_group_delay(self) -> np.ndarray: + def _get_group_delay(self) -> NDArray[np.float64]: """Return the unscaled group delay.""" return -np.gradient(np.unwrap(self.phase_response)) diff --git a/dsptoolbox/classes/_svfilter.py b/dsptoolbox/classes/_svfilter.py index 75dedba..f750e28 100644 --- a/dsptoolbox/classes/_svfilter.py +++ b/dsptoolbox/classes/_svfilter.py @@ -6,6 +6,7 @@ import numpy as np from matplotlib.figure import Figure from matplotlib.axes import Axes +from numpy.typing import NDArray from .signal_class import Signal from .multibandsignal import MultiBandSignal from ..generators import dirac @@ -101,7 +102,9 @@ def _process_sample( return yl, yh, yb, yl - self.resonance * yb + yh - def _process_vector(self, input: np.ndarray) -> np.ndarray: + def _process_vector( + self, input: NDArray[np.float64] + ) -> NDArray[np.float64]: """Process a whole multichannel array. The outputs are a 3d-array with shape (time sample, band, channel). There are 4 bands: lowpass, highpass, bandpass and allpass. They are returned in this order. diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py index 50cbb55..6ad31f4 100644 --- a/dsptoolbox/classes/filter_class.py +++ b/dsptoolbox/classes/filter_class.py @@ -10,6 +10,7 @@ from matplotlib.figure import Figure from matplotlib.axes import Axes import scipy.signal as sig +from numpy.typing import NDArray from .signal_class import Signal from ._filter import ( @@ -568,18 +569,20 @@ def get_ir( ) return self.filter_signal(ir_filt, zero_phase=zero_phase) - def get_transfer_function(self, frequency_vector_hz: np.ndarray): + def get_transfer_function( + self, frequency_vector_hz: NDArray[np.float64] + ) -> NDArray[np.complex128]: """Obtain the complex transfer function of the filter analytically evaluated for a given frequency vector. Parameters ---------- - frequency_vector_hz : `np.ndarray` + frequency_vector_hz : NDArray[np.float64] Frequency vector for which to compute the transfer function Returns ------- - np.ndarray + NDArray[np.complex128] Complex transfer function Notes @@ -615,9 +618,9 @@ def get_transfer_function(self, frequency_vector_hz: np.ndarray): def get_coefficients( self, mode: str = "sos" ) -> ( - list[np.ndarray] - | np.ndarray - | tuple[np.ndarray, np.ndarray, np.ndarray] + list[NDArray[np.float64]] + | NDArray[np.float64] + | tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] | None ): """Returns the filter coefficients. @@ -632,9 +635,9 @@ def get_coefficients( ------- coefficients : array-like Array with filter coefficients with shape depending on mode: - - `'ba'`: list(b, a) with b and a of type `np.ndarray`. - - `'sos'`: `np.ndarray` with shape (n_sections, 6). - - `'zpk'`: tuple(z, p, k) with z, p, k of type `np.ndarray` + - `'ba'`: list(b, a) with b and a of type NDArray[np.float64]. + - `'sos'`: NDArray[np.float64] with shape (n_sections, 6). + - `'zpk'`: tuple(z, p, k) with z, p, k of type NDArray[np.float64] - Return `None` if user decides that ba->sos is too costly. The threshold is for filters with order > 500. diff --git a/dsptoolbox/classes/filterbank.py b/dsptoolbox/classes/filterbank.py index 01c3b4d..55ef6fe 100644 --- a/dsptoolbox/classes/filterbank.py +++ b/dsptoolbox/classes/filterbank.py @@ -4,6 +4,7 @@ from warnings import warn from matplotlib.figure import Figure from matplotlib.axes import Axes +from numpy.typing import NDArray from .signal_class import Signal from .multibandsignal import MultiBandSignal @@ -86,7 +87,7 @@ def initialize_zi(self, number_of_channels: int = 1): f.initialize_zi(number_of_channels) @property - def sampling_rate_hz(self) -> int | np.ndarray: + def sampling_rate_hz(self) -> int | NDArray[np.int_]: return self.__sampling_rate_hz @sampling_rate_hz.setter @@ -445,15 +446,15 @@ def get_ir( return ir def get_transfer_function( - self, frequency_vector_hz: np.ndarray, mode: str = "parallel" - ): + self, frequency_vector_hz: NDArray[np.float64], mode: str = "parallel" + ) -> NDArray[np.complex128]: """Compute the complex transfer function of the filter bank for specified frequencies. The output is based on the filter bank filtering mode. Parameters ---------- - frequency_vector_hz : np.ndarray + frequency_vector_hz : NDArray[np.float64] Frequency vector to evaluate frequencies at. mode : str, optional Way of applying the filter bank. If `"parallel"`, the resulting @@ -462,7 +463,7 @@ def get_transfer_function( Returns ------- - np.ndarray + NDArray[np.complex128] Complex transfer function of the filter bank. """ diff --git a/dsptoolbox/classes/multibandsignal.py b/dsptoolbox/classes/multibandsignal.py index 92d90d1..49f0093 100644 --- a/dsptoolbox/classes/multibandsignal.py +++ b/dsptoolbox/classes/multibandsignal.py @@ -1,4 +1,6 @@ -from numpy import zeros, array, unique, atleast_1d, ndarray, complex128 +from numpy import zeros, array, unique, atleast_1d, complex128 +import numpy as np +from numpy.typing import NDArray from copy import deepcopy from pickle import dump, HIGHEST_PROTOCOL from warnings import warn @@ -292,7 +294,7 @@ def _get_metadata_str(self): # ======== Getters ======================================================== def get_all_bands( self, channel: int = 0 - ) -> Signal | tuple[list[ndarray], list[ndarray]]: + ) -> Signal | tuple[list[NDArray[np.float64]], list[NDArray[np.float64]]]: """Broadcasts and returns the `MultiBandSignal` as a `Signal` object with all bands as channels in the output. This is done only for a single channel of the original signal. @@ -304,7 +306,7 @@ def get_all_bands( Returns ------- - sig : `Signal` or list of `np.ndarray` and list of int + sig : `Signal` or list of NDArray[np.float64] and list of int Multichannel signal with all the bands. If the `MultiBandSignal` does not have the same sampling rate for all signals, a list with the time data vectors and a list containing their sampling @@ -357,7 +359,9 @@ def get_all_bands( def get_all_time_data( self, - ) -> tuple[ndarray, int] | list[tuple[ndarray, int]]: + ) -> ( + tuple[NDArray[np.float64], int] | list[tuple[NDArray[np.float64], int]] + ): """ Get all time data saved in the MultiBandSignal. If it has consistent sampling rate, a single array with shape (time samples, band, channel) @@ -367,12 +371,12 @@ def get_all_time_data( Returns ------- if `same_sampling_rate` : - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time samples. int Sampling rate in Hz else : - list[tuple[`np.ndarray`, int]] + list[tuple[NDArray[np.float64], int]] List with each band where time samples and sampling rate are contained. diff --git a/dsptoolbox/classes/signal_class.py b/dsptoolbox/classes/signal_class.py index a3b7ce2..9d1bc9d 100644 --- a/dsptoolbox/classes/signal_class.py +++ b/dsptoolbox/classes/signal_class.py @@ -10,6 +10,7 @@ from matplotlib.figure import Figure from matplotlib.axes import Axes from scipy.signal import convolve +from numpy.typing import NDArray from ..plots import general_plot, general_subplots_line, general_matrix_plot from ._plots import _csm_plot @@ -52,7 +53,7 @@ def __init__( path : str, optional A path to audio files. Reading is done with the soundfile library. Wave and Flac audio files are accepted. Default: `None`. - time_data : array-like, `np.ndarray`, optional + time_data : array-like, NDArray[np.float64], optional Time data of the signal. It is saved as a matrix with the form (time samples, channel number). Default: `None`. sampling_rate_hz : int, optional @@ -167,13 +168,13 @@ def _generate_time_vector(self): # ======== Properties and setters ========================================= @property - def time_data(self) -> np.ndarray: + def time_data(self) -> NDArray[np.float64]: return self.__time_data.copy() @time_data.setter def time_data(self, new_time_data): # Shape of Time Data array - if not type(new_time_data) is np.ndarray: + if not type(new_time_data) is NDArray[np.float64]: new_time_data = np.asarray(new_time_data) if new_time_data.ndim > 2: new_time_data = new_time_data.squeeze() @@ -263,13 +264,13 @@ def number_of_channels(self, new_number): self.__number_of_channels = new_number @property - def time_vector_s(self) -> np.ndarray: + def time_vector_s(self) -> NDArray[np.float64]: if self.__time_vector_update: self._generate_time_vector() return self.__time_vector_s @property - def time_data_imaginary(self) -> np.ndarray | None: + def time_data_imaginary(self) -> NDArray[np.float64] | None: if self.__time_data_imaginary is None: # warn('Imaginary part of time data was called, but there is ' + # 'None. None is returned.') @@ -277,7 +278,7 @@ def time_data_imaginary(self) -> np.ndarray | None: return self.__time_data_imaginary.copy() @time_data_imaginary.setter - def time_data_imaginary(self, new_imag: np.ndarray): + def time_data_imaginary(self, new_imag: NDArray[np.float64]): if new_imag is not None: assert ( new_imag.shape == self.__time_data.shape @@ -401,13 +402,13 @@ def set_spectrum_parameters( self._spectrum_parameters = _new_spectrum_parameters self.__spectrum_state_update = True - def set_window(self, window: np.ndarray): + def set_window(self, window: NDArray[np.float64]): """Sets the window used for the IR. It only works for `signal_type in ('ir', 'h1', 'h2', 'h3', 'rir')`. Parameters ---------- - window : `np.ndarray` + window : NDArray[np.float64] Window used for the IR. """ @@ -421,13 +422,13 @@ def set_window(self, window: np.ndarray): ), f"{window.shape} does not match shape {self.time_data.shape}" self.window = window - def set_coherence(self, coherence: np.ndarray): + def set_coherence(self, coherence: NDArray[np.float64]): """Sets the coherence measurements of the transfer function. It only works for `signal_type = ('ir', 'h1', 'h2', 'h3', 'rir')`. Parameters ---------- - coherence : `np.ndarray` + coherence : NDArray[np.float64] Coherence matrix. """ @@ -574,7 +575,7 @@ def set_spectrogram_parameters( def add_channel( self, path: str | None = None, - new_time_data: np.ndarray | None = None, + new_time_data: NDArray[np.float64] | None = None, sampling_rate_hz: int | None = None, padding_trimming: bool = True, ): @@ -584,7 +585,7 @@ def add_channel( ---------- path : str, optional Path to the file containing new channel information. - new_time_data : `np.ndarray`, optional + new_time_data : NDArray[np.float64], optional np.array with new channel data. sampling_rate_hz : int, optional Sampling rate for the new data @@ -607,7 +608,7 @@ def add_channel( f"{sampling_rate_hz} does not match {self.sampling_rate_hz} " + "as the sampling rate" ) - if not type(new_time_data) is np.ndarray: + if not type(new_time_data) is NDArray[np.float64]: new_time_data = np.array(new_time_data) if new_time_data.ndim > 2: new_time_data = new_time_data.squeeze() @@ -731,7 +732,7 @@ def get_channels(self, channels): # ======== Getters ======================================================== def get_spectrum( self, force_computation=False - ) -> tuple[np.ndarray, np.ndarray]: + ) -> tuple[NDArray[np.float64], NDArray[np.complex128]]: """Returns spectrum. Parameters @@ -741,9 +742,9 @@ def get_spectrum( Returns ------- - spectrum_freqs : `np.ndarray` + spectrum_freqs : NDArray[np.float64] Frequency vector. - spectrum : `np.ndarray` + spectrum : NDArray[np.complex128] Spectrum matrix for each channel. """ @@ -820,15 +821,15 @@ def get_spectrum( def get_csm( self, force_computation=False - ) -> tuple[np.ndarray, np.ndarray]: + ) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Get Cross spectral matrix for all channels with the shape (frequencies, channels, channels). Returns ------- - f_csm : `np.ndarray` + f_csm : NDArray[np.float64] Frequency vector. - csm : `np.ndarray` + csm : NDArray[np.float64] Cross spectral matrix with shape (frequency, channels, channels). """ @@ -851,7 +852,9 @@ def get_csm( def get_spectrogram( self, force_computation: bool = False - ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + ) -> tuple[ + NDArray[np.float64], NDArray[np.float64], NDArray[np.complex128] + ]: """Returns a matrix containing the STFT of a specific channel. Parameters @@ -861,11 +864,11 @@ def get_spectrogram( Returns ------- - t_s : `np.ndarray` + t_s : NDArray[np.float64] Time vector. - f_hz : `np.ndarray` + f_hz : NDArray[np.float64] Frequency vector. - spectrogram : `np.ndarray` + spectrogram : NDArray[np.complex128] Complex spectrogram with shape (frequency, time, channel). Notes @@ -899,14 +902,14 @@ def get_spectrogram( ) return t_s, f_hz, spectrogram - def get_coherence(self) -> tuple[np.ndarray, np.ndarray]: + def get_coherence(self) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Returns the coherence matrix. Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - coherence : `np.ndarray` + coherence : NDArray[np.float64] Coherence matrix. """ @@ -1585,7 +1588,7 @@ def stream_samples(self, blocksize_samples: int, signal_mode: bool = True): Returns ------- - sig : `np.ndarray` or `Signal` + sig : NDArray[np.float64] or `Signal` Numpy array with samples used for reproduction with shape (time_samples, channels) or `Signal` object. stop_flag : bool diff --git a/dsptoolbox/distances/_distances.py b/dsptoolbox/distances/_distances.py index ff429bd..4f95ca5 100644 --- a/dsptoolbox/distances/_distances.py +++ b/dsptoolbox/distances/_distances.py @@ -4,22 +4,23 @@ import numpy as np from scipy.integrate import simpson +from numpy.typing import NDArray from .._general_helpers import _compute_number_frames, _pad_trim from .._standard import _rms def _log_spectral_distance( - x: np.ndarray, y: np.ndarray, f: np.ndarray + x: NDArray[np.float64], y: NDArray[np.float64], f: NDArray[np.float64] ) -> float: """Computes log spectral distance between two signals. Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] First power spectrum. - y : `np.ndarray` + y : NDArray[np.float64] Second power spectrum. - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. Returns @@ -35,17 +36,17 @@ def _log_spectral_distance( def _itakura_saito_measure( - x: np.ndarray, y: np.ndarray, f: np.ndarray + x: NDArray[np.float64], y: NDArray[np.float64], f: NDArray[np.float64] ) -> float: """Computes log spectral distance between two signals. Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] First power spectrum. - y : `np.ndarray` + y : NDArray[np.float64] Second power spectrum. - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. Returns @@ -59,33 +60,35 @@ def _itakura_saito_measure( return ism -def _snr(s: np.ndarray, n: np.ndarray) -> float | np.ndarray: +def _snr( + s: NDArray[np.float64], n: NDArray[np.float64] +) -> float | NDArray[np.float64]: """Computes SNR from the passed numpy arrays. Parameters ---------- - s : `np.ndarray` + s : NDArray[np.float64] Signal - n : `np.ndarray` + n : NDArray[np.float64] Noise Returns ------- - snr : float or `np.ndarray` + snr : float or NDArray[np.float64] SNR between signals. It can be an array if signals are multichannel. """ return 20 * np.log10(_rms(s) / _rms(n)) -def _sisdr(s: np.ndarray, shat: np.ndarray) -> float: +def _sisdr(s: NDArray[np.float64], shat: NDArray[np.float64]) -> float: """Scale-invariant signal-to-distortion ratio Parameters ---------- - s : `np.ndarray` + s : NDArray[np.float64] Target signal. - shat : `np.ndarray` + shat : NDArray[np.float64] Modified or approximated signal. Returns @@ -102,11 +105,11 @@ def _sisdr(s: np.ndarray, shat: np.ndarray) -> float: def _fw_snr_seg_per_channel( - x: np.ndarray, - xhat: np.ndarray, - snr_range_db: np.ndarray, + x: NDArray[np.float64], + xhat: NDArray[np.float64], + snr_range_db: NDArray[np.float64], gamma: float, - time_window: np.ndarray, + time_window: NDArray[np.float64], step_samples: int, ) -> float: """This function gets an original signal x and a modified signal xhat @@ -117,15 +120,15 @@ def _fw_snr_seg_per_channel( Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] Original signal with shape (time_samples, bands). - xhat : `np.ndarray` + xhat : NDArray[np.float64] Modified signal with shape (time_samples, bands). - snr_range_db : `np.ndarray` with length 2 + snr_range_db : NDArray[np.float64] with length 2 SNR range in dB. gamma : float Gamma exponent for the weighting function. See reference for details. - time_window : `np.ndarray` + time_window : NDArray[np.float64] Time window to be used. step : int Hop length between each time frame. diff --git a/dsptoolbox/distances/distances.py b/dsptoolbox/distances/distances.py index 5456dcf..8ca5cf1 100644 --- a/dsptoolbox/distances/distances.py +++ b/dsptoolbox/distances/distances.py @@ -5,6 +5,7 @@ import numpy as np from scipy.signal import windows +from numpy.typing import NDArray from .. import Signal from ..filterbanks import auditory_filters_gammatone @@ -25,7 +26,7 @@ def log_spectral( f_range_hz=[20, 20000], energy_normalization: bool = True, spectrum_parameters: dict | None = None, -) -> np.ndarray: +) -> NDArray[np.float64]: """Computes log spectral distance between two signals. Parameters @@ -50,7 +51,7 @@ def log_spectral( Returns ------- - distances : `np.ndarray` + distances : NDArray[np.float64] Log spectral distance per channel for the given signals. References @@ -114,7 +115,7 @@ def itakura_saito( f_range_hz=[20, 20000], energy_normalization: bool = True, spectrum_parameters: dict | None = None, -) -> np.ndarray: +) -> NDArray[np.float64]: """Computes itakura-saito measure between two signals. Beware that this measure is not symmetric (x, y) != (y, x). @@ -140,7 +141,7 @@ def itakura_saito( Returns ------- - distances : `np.ndarray` + distances : NDArray[np.float64] Itakura-saito measure for the given signals. References @@ -197,7 +198,7 @@ def itakura_saito( return distances -def snr(signal: Signal, noise: Signal) -> np.ndarray: +def snr(signal: Signal, noise: Signal) -> NDArray[np.float64]: """Classical Signal-to-noise ratio. If noise only has one channel, it is assumed to be the noise for all channels of signal. @@ -210,7 +211,7 @@ def snr(signal: Signal, noise: Signal) -> np.ndarray: Returns ------- - snr_per_channel : `np.ndarray` + snr_per_channel : NDArray[np.float64] SNR value per channel References @@ -228,7 +229,9 @@ def snr(signal: Signal, noise: Signal) -> np.ndarray: return np.atleast_1d(_snr(signal.time_data, noise.time_data)) -def si_sdr(target_signal: Signal, modified_signal: Signal) -> np.ndarray: +def si_sdr( + target_signal: Signal, modified_signal: Signal +) -> NDArray[np.float64]: """Computes scale-invariant signal to distortion ratio from a target and a modified signal. If target signal only has one channel, it is assumed to be the target for all the channels in the modified signal. @@ -244,7 +247,7 @@ def si_sdr(target_signal: Signal, modified_signal: Signal) -> np.ndarray: Returns ------- - sdr : `np.ndarray` + sdr : NDArray[np.float64] SI-SDR per channel. References @@ -285,7 +288,7 @@ def fw_snr_seg( f_range_hz=[20, 10e3], snr_range_db=[-10, 35], gamma: float = 0.2, -) -> np.ndarray: +) -> NDArray[np.float64]: """Frequency-weighted segmental SNR (fwSNRseg) computation between two signals. @@ -319,7 +322,7 @@ def fw_snr_seg( Returns ------- - snr_per_channel : `np.ndarray` + snr_per_channel : NDArray[np.float64] Frequency-weighted, time-segmented SNR per channel. References diff --git a/dsptoolbox/effects/_effects.py b/dsptoolbox/effects/_effects.py index 33c98e4..f3b76cf 100644 --- a/dsptoolbox/effects/_effects.py +++ b/dsptoolbox/effects/_effects.py @@ -5,14 +5,15 @@ from .._general_helpers import _get_smoothing_factor_ema from ..plots import general_plot import numpy as np +from numpy.typing import NDArray # import matplotlib.pyplot as plt # ========= Distortion ======================================================== def _arctan_distortion( - inp: np.ndarray, distortion_level_db: float, offset_db: float -) -> np.ndarray: + inp: NDArray[np.float64], distortion_level_db: float, offset_db: float +) -> NDArray[np.float64]: """Applies arctan distortion.""" offset_linear = 10 ** (offset_db / 20) distortion_level_linear = 10 ** (distortion_level_db / 20) @@ -24,8 +25,8 @@ def _arctan_distortion( def _hard_clip_distortion( - inp: np.ndarray, distortion_level_db: float, offset_db: float -) -> np.ndarray: + inp: NDArray[np.float64], distortion_level_db: float, offset_db: float +) -> NDArray[np.float64]: """Applies hard clipping distortion.""" offset_linear = 10 ** (offset_db / 20) distortion_level_linear = 10 ** (distortion_level_db / 20) @@ -37,8 +38,8 @@ def _hard_clip_distortion( def _soft_clip_distortion( - inp: np.ndarray, distortion_level_db: float, offset_db: float -) -> np.ndarray: + inp: NDArray[np.float64], distortion_level_db: float, offset_db: float +) -> NDArray[np.float64]: """Applies non-linear cubic distortion.""" offset_linear = 10 ** (offset_db / 20) distortion_level_linear = 10 ** (distortion_level_db / 20) @@ -51,15 +52,15 @@ def _soft_clip_distortion( def _clean_signal( - inp: np.ndarray, distortion_level_db: float, offset_db: float -) -> np.ndarray: + inp: NDArray[np.float64], distortion_level_db: float, offset_db: float +) -> NDArray[np.float64]: """Returns the unchanged clean signal.""" return inp # ========= Compressor ======================================================== def _compressor( - x: np.ndarray, + x: NDArray[np.float64], threshold_db: float, ratio: float, knee_factor_db: float, @@ -67,12 +68,12 @@ def _compressor( release_samples: int, mix_compressed: float, downward_compression: bool, -) -> np.ndarray: +) -> NDArray[np.float64]: """Compresses the dynamic range of a signal. Parameters ---------- - x : `np.ndarray` + x : NDArray[np.float64] Signal to compress. threshold_db : float Threshold level. @@ -93,7 +94,7 @@ def _compressor( Returns ------- - x_ : `np.ndarray` + x_ : NDArray[np.float64] Compressed signal. """ @@ -167,7 +168,7 @@ def _get_knee_func( if downward_compression: - def compress_in_db(x: np.ndarray | float): + def compress_in_db(x: NDArray[np.float64] | float): if type(x) is float: if x - T < -W / 2: return x @@ -192,7 +193,7 @@ def compress_in_db(x: np.ndarray | float): else: - def compress_in_db(x: np.ndarray | float): + def compress_in_db(x: NDArray[np.float64] | float): if type(x) is float: if x - T < -W / 2: return T + (x - T) / R @@ -219,14 +220,14 @@ def compress_in_db(x: np.ndarray | float): def _find_attack_hold_release( - x: np.ndarray, + x: NDArray[np.float64], threshold_db: float, attack_samples: int, hold_samples: int, release_samples: int, - side_chain: np.ndarray, + side_chain: NDArray[np.float64], indices_above: bool, -) -> tuple[np.ndarray, np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: """This function finds the indices corresponding to attack, hold and release. It returns boolean arrays. It can only handle 1D-arrays as input! diff --git a/dsptoolbox/effects/effects.py b/dsptoolbox/effects/effects.py index c68e4f6..a800ef4 100644 --- a/dsptoolbox/effects/effects.py +++ b/dsptoolbox/effects/effects.py @@ -22,6 +22,7 @@ from scipy.signal.windows import get_window import numpy as np +from numpy.typing import NDArray from warnings import warn __all__ = [ @@ -82,20 +83,20 @@ def _apply_this_effect(self, signal: Signal) -> Signal: return signal def _add_gain_in_db( - self, time_data: np.ndarray, gain_db: float - ) -> np.ndarray: + self, time_data: NDArray[np.float64], gain_db: float + ) -> NDArray[np.float64]: """General gain stage. Parameters ---------- - time_data : `np.ndarray` + time_data : NDArray[np.float64] Time samples of the signal. gain_db : float Gain in dB. Returns ------- - new_time_data : `np.ndarray` + new_time_data : NDArray[np.float64] Time data with new gain. """ @@ -103,11 +104,13 @@ def _add_gain_in_db( return time_data return time_data * 10 ** (gain_db / 20) - def _save_peak_values(self, inp: np.ndarray): + def _save_peak_values(self, inp: NDArray[np.float64]): """Save the peak values of an input.""" self._peak_values = np.max(np.abs(inp), axis=0) - def _restore_peak_values(self, inp: np.ndarray) -> np.ndarray: + def _restore_peak_values( + self, inp: NDArray[np.float64] + ) -> NDArray[np.float64]: """Restore saved peak values of a signal.""" if not hasattr(self, "_peak_values"): return inp @@ -119,11 +122,13 @@ def _restore_peak_values(self, inp: np.ndarray) -> np.ndarray: return inp return inp * (self._peak_values / np.max(np.abs(inp), axis=0)) - def _save_rms_values(self, inp: np.ndarray): + def _save_rms_values(self, inp: NDArray[np.float64]): """Save the RMS values of a signal.""" self._rms_values = _rms(inp) - def _restore_rms_values(self, inp: np.ndarray) -> np.ndarray: + def _restore_rms_values( + self, inp: NDArray[np.float64] + ) -> NDArray[np.float64]: """Restore the RMS values of a signal.""" if not hasattr(self, "_rms_values"): return inp @@ -149,7 +154,7 @@ def __init__( adaptive_mode: bool = True, threshold_rms_dbfs: float = -40, block_length_s: float = 0.1, - spectrum_to_subtract: np.ndarray | bool = False, + spectrum_to_subtract: NDArray[np.float64] | bool = False, ): """Constructor for a spectral subtractor denoising effect. More parameters can be passed using the method `set_advanced_parameters`. @@ -173,7 +178,7 @@ def __init__( blocks of the signal. The real block length in samples is always clipped to the closest power of 2 for efficiency of the FFT. Default: 0.1. - spectrum_to_subtract : np.ndarray or `False`, optional + spectrum_to_subtract : NDArray[np.float64] or `False`, optional If a spectrum is passed, it is used as the one to subtract and all other parameters are ignored. This should be the result of the squared magnitude of the FFT without any scaling in order to avoid @@ -361,7 +366,7 @@ def set_parameters( adaptive_mode: bool | None = None, threshold_rms_dbfs: float | None = None, block_length_s: float | None = None, - spectrum_to_subtract: np.ndarray = False, + spectrum_to_subtract: NDArray[np.float64] = False, ): """Sets the audio effects parameters. Pass `None` to leave the previously selected value for each parameter unchanged. @@ -385,7 +390,7 @@ def set_parameters( blocks of the signal. The real block length in samples is always clipped to the closest power of 2 for efficiency of the FFT. Default: 0.1. - spectrum_to_subtract : np.ndarray, optional + spectrum_to_subtract : NDArray[np.float64], optional If a spectrum is passed, it is used as the one to subtract and all other parameters are ignored. This should be the result of the squared magnitude of the FFT without any scaling in order to avoid @@ -634,9 +639,9 @@ def __init__( def set_advanced_parameters( self, type_of_distortion="arctan", - distortion_levels_db: np.ndarray = 20, - mix_percent: np.ndarray = 100, - offset_db: np.ndarray = -np.inf, + distortion_levels_db: NDArray[np.float64] = 20, + mix_percent: NDArray[np.float64] = 100, + offset_db: NDArray[np.float64] = -np.inf, post_gain_db: float = 0, ): r"""This sets the parameters of the distortion. Multiple @@ -655,20 +660,21 @@ def set_advanced_parameters( (`'arctan'`, `'hard clip'`, `'soft clip'`, `'clean'`) or a callable containing a user-defined distortion. Its signature must be:: - func(time_data: np.ndarray, distortion_level_db: float, - offset_db: float) -> np.ndarray + func(time_data: NDArray[np.float64], + distortion_level_db: float, offset_db: float) \ + -> NDArray[np.float64] The output data is assumed to have shape (time samples, channels) as the input data. If a list is passed, `distortion_levels_db`, `mix_percent` and `offset_db` must have the same length as the list. Default: `'arctan'`. - distortion_levels : `np.ndarray`, optional + distortion_levels : NDArray[np.float64], optional This defines how strong the distortion effect is applied. It can vary according to the non-linear function. Usually, a range between 0 and 50 should be reasonable, though any value is possible. If multiple types of distortion are being used, this should be an array corresponding to each distortion. Default: 20. - mix_percent : `np.ndarray`, optional + mix_percent : NDArray[np.float64], optional This defines how much of each distortion is used in the final mix. If `type_of_distortion` is only one string or callable, mix_percent is its amount in the final mix with the clean signal. @@ -676,7 +682,7 @@ def set_advanced_parameters( 40 leads to 40% distorted, 60% clean. If multiple types of distortion are being used, this should be an array corresponding to each distortion and its sum must be 100. Default: 100. - offset_db : `np.ndarray`, optional + offset_db : NDArray[np.float64], optional This offset corresponds to the offset shown in [1]. It must be a value between -np.inf and 0. The bigger this value, the more even harmonics are caused by the distortion. Pass -np.inf to avoid any @@ -1083,7 +1089,9 @@ class Tremolo(AudioEffect): """ def __init__( - self, depth: float = 0.5, modulator: LFO | np.ndarray | None = None + self, + depth: float = 0.5, + modulator: LFO | NDArray[np.float64] | None = None, ): """Constructor for a tremolo effect. @@ -1092,7 +1100,7 @@ def __init__( depth : float, optional Depth of the amplitude variation. This must be a positive value. Default: 0.5. - modulator : `LFO` or `np.ndarray` + modulator : `LFO` or NDArray[np.float64] This is the modulator signal that modifies the amplitude of the carrier signal. It can either be a LFO or a numpy array. If the length of the numpy array is different to that of the carrier @@ -1106,14 +1114,16 @@ def __init__( modulator = LFO(1, "harmonic") self.__set_parameters(depth, modulator) - def __set_parameters(self, depth: float, modulator: LFO | np.ndarray): + def __set_parameters( + self, depth: float, modulator: LFO | NDArray[np.float64] + ): """Internal method to change parameters.""" if modulator is not None: assert type(modulator) in ( LFO, - np.ndarray, + NDArray[np.float64], ), "Unsupported modulator type. Use LFO or numpy.ndarray" - if type(modulator) is np.ndarray: + if type(modulator) is NDArray[np.float64]: modulator = modulator.squeeze() assert ( modulator.ndim == 1 @@ -1128,7 +1138,7 @@ def __set_parameters(self, depth: float, modulator: LFO | np.ndarray): def set_parameters( self, depth: float | None = None, - modulator: LFO | np.ndarray | None = None, + modulator: LFO | NDArray[np.float64] | None = None, ): """Set the parameters for the tremolo effect. Passing `None` in this function leaves them unchanged. @@ -1138,7 +1148,7 @@ def set_parameters( depth : float, optional Depth of the amplitude variation. This must be a positive value. Default: `None`. - modulator : `LFO` or `np.ndarray`, optional + modulator : `LFO` or NDArray[np.float64], optional This is the modulator signal that modifies the amplitude of the carrier signal. It can either be a LFO or a numpy array. If the length of the numpy array is different to that of the carrier @@ -1170,9 +1180,9 @@ class Chorus(AudioEffect): def __init__( self, - depths_ms: float | np.ndarray = 5, - base_delays_ms: float | np.ndarray = 15, - modulators: LFO | list | tuple | np.ndarray | None = None, + depths_ms: float | NDArray[np.float64] = 5, + base_delays_ms: float | NDArray[np.float64] = 15, + modulators: LFO | list | tuple | NDArray[np.float64] | None = None, mix_percent: float = 100, ): """Constructor for a chorus effect. Multiple voices with modulated @@ -1186,11 +1196,11 @@ def __init__( around the base delay. The bigger, the more dramatic the effect. Each voice can have a different depth. If a single value is passed, it is used for all voices. Default: 5. - base_delays_ms : `np.ndarray`, optional + base_delays_ms : NDArray[np.float64], optional Base delays for each voice. By default, 15 ms are used for all voices but different values can be passed per voice. Default: 15. - modulators : `LFO` or list or tuple or `np.ndarray`, optional + modulators : `LFO` or list or tuple or NDArray[np.float64], optional This is the modulators signal that modifies the delay of the carrier signal. It can either be an LFO, a list or tuple of LFOs or a numpy array with delay values in milliseconds. If the length of @@ -1221,9 +1231,9 @@ def __init__( def __set_parameters( self, - depths_ms: float | np.ndarray, - base_delays_ms: float | np.ndarray, - modulators: LFO | list | tuple | np.ndarray, + depths_ms: float | NDArray[np.float64], + base_delays_ms: float | NDArray[np.float64], + modulators: LFO | list | tuple | NDArray[np.float64], mix_percent: float, ): """Internal method to change parameters.""" @@ -1245,7 +1255,7 @@ def __set_parameters( if modulators is not None: if type(modulators) in (list, tuple): nv_mod = len(modulators) - elif type(modulators) is np.ndarray: + elif type(modulators) is NDArray[np.float64]: modulators = np.atleast_2d(modulators) nv_mod = modulators.shape[1] else: @@ -1274,9 +1284,9 @@ def __set_parameters( LFO, list, tuple, - np.ndarray, + NDArray[np.float64], ), "Unsupported modulators type. Use LFO or numpy.ndarray" - if type(modulators) is np.ndarray: + if type(modulators) is NDArray[np.float64]: modulators = np.atleast_2d(modulators) modulators.shape[1] == self.number_of_voices, ( "The modulators signal must " @@ -1322,9 +1332,9 @@ def __set_parameters( def set_parameters( self, - depths_ms: float | np.ndarray | None = None, - base_delays_ms: float | np.ndarray | None = None, - modulators: LFO | list | tuple | np.ndarray | None = None, + depths_ms: float | NDArray[np.float64] | None = None, + base_delays_ms: float | NDArray[np.float64] | None = None, + modulators: LFO | list | tuple | NDArray[np.float64] | None = None, mix_percent: float | None = None, ): """Sets the advanced parameters for the chorus effect. By passing @@ -1337,7 +1347,7 @@ def set_parameters( depths_ms : float, optional Depth of the delay variation in ms. This must be a positive value. Default: `None`. - modulators : LFO or list or tuple or `np.ndarray`, optional + modulators : LFO or list or tuple or NDArray[np.float64], optional This defines the modulators signal. It can be a single LFO object or a list containing an LFO for each voice. Alternatively, a numpy.ndarray with shape (time samples, voice) can be passed. If @@ -1361,7 +1371,7 @@ def _apply_this_effect(self, signal: Signal) -> Signal: le = len(signal) # Get valid modulation signals - if type(self.modulators) is not np.ndarray: + if type(self.modulators) is not NDArray[np.float64]: modulation = np.zeros((le, self.number_of_voices)) for ind, m in enumerate(self.modulators): modulation[:, ind] = ( diff --git a/dsptoolbox/filterbanks/_filterbank.py b/dsptoolbox/filterbanks/_filterbank.py index 866a0b6..8cc9c5b 100644 --- a/dsptoolbox/filterbanks/_filterbank.py +++ b/dsptoolbox/filterbanks/_filterbank.py @@ -7,6 +7,7 @@ from os import sep from pickle import dump, HIGHEST_PROTOCOL from copy import deepcopy +from numpy.typing import NDArray from scipy.signal import ( sosfilt, @@ -690,9 +691,9 @@ def __init__( self, filters: list, info: dict, - frequencies: np.ndarray, - coefficients: np.ndarray, - normalizations: np.ndarray, + frequencies: NDArray[np.float64], + coefficients: NDArray[np.float64], + normalizations: NDArray[np.float64], ): """Constructor for the Gamma Tone Filter Bank. It is only available as a constant sampling rate filter bank. @@ -703,11 +704,11 @@ def __init__( List with gamma tone filters. info : dict Dictionary containing basic information about the filter bank. - frequencies : `np.ndarray` + frequencies : NDArray[np.float64] Frequencies used for the filters. - coefficients : `np.ndarray` + coefficients : NDArray[np.float64] Filter coefficients. - normalizations : `np.ndarray` + normalizations : NDArray[np.float64] Normalizations. """ @@ -1391,7 +1392,7 @@ def _reconstruct_from_crossover_upsample( def _get_2nd_order_linkwitz_riley( f0: float, sampling_rate_hz: int -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Return filters (SOS representation) for a 2nd-order linkwitz-riley crossover. These are based on sallen-key filters (with Q=0.5). In order to obtain an allpass sum response, one band must be phase-inverted. Here, @@ -1406,9 +1407,9 @@ def _get_2nd_order_linkwitz_riley( Returns ------- - low_sos : `np.ndarray` + low_sos : NDArray[np.float64] SOS for low band. - high_sos : `np.ndarray` + high_sos : NDArray[np.float64] SOS for high band. """ diff --git a/dsptoolbox/plots/plots.py b/dsptoolbox/plots/plots.py index 1d69676..f5a241e 100644 --- a/dsptoolbox/plots/plots.py +++ b/dsptoolbox/plots/plots.py @@ -42,7 +42,7 @@ def general_plot( ---------- x : array-like Vector for x axis. Pass `None` to ignore. - matrix : `np.ndarray` + matrix : NDArray[np.float64] Matrix with data to plot. range_x : array-like, optional Range to show for x axis. Default: None. @@ -138,7 +138,7 @@ def general_subplots_line( ---------- x : array-like Vector for x axis. - matrix : `np.ndarray` + matrix : NDArray[np.float64] Matrix with data to plot. column : bool, optional When `True`, the subplots are organized in one column. Default: `True`. @@ -236,7 +236,7 @@ def general_matrix_plot( Parameters ---------- - matrix : `np.ndarray` + matrix : NDArray[np.float64] Matrix with data to plot. range_x : array-like, optional Range to show for x axis. Default: `None`. diff --git a/dsptoolbox/room_acoustics/_room_acoustics.py b/dsptoolbox/room_acoustics/_room_acoustics.py index 213ee50..23d3a7b 100644 --- a/dsptoolbox/room_acoustics/_room_acoustics.py +++ b/dsptoolbox/room_acoustics/_room_acoustics.py @@ -3,6 +3,7 @@ """ import numpy as np +from numpy.typing import NDArray from scipy.stats import pearsonr from warnings import warn from ..plots import general_plot @@ -10,7 +11,7 @@ def _reverb( - h, + h: NDArray[np.float64], fs_hz, mode, ir_start: int | None = None, @@ -21,7 +22,7 @@ def _reverb( Parameters ---------- - h : `np.ndarray` + h : NDArray[np.float64] Time series. fs_hz : int Sampling rate in Hz. @@ -87,12 +88,14 @@ def _reverb( return factor / np.abs(p[0]), corr -def _find_ir_start(ir, threshold_dbfs: float = -20) -> int: +def _find_ir_start( + ir: NDArray[np.float64], threshold_dbfs: float = -20 +) -> int: """Find start of an IR using a threshold. Done for 1D-arrays. Parameters ---------- - ir : `np.ndarray` + ir : NDArray[np.float64] IR as a 1D-array. threshold_dbfs : float, optional Threshold that should be surpassed at the start of the IR in dBFS. @@ -116,14 +119,14 @@ def _find_ir_start(ir, threshold_dbfs: float = -20) -> int: def _complex_mode_identification( - spectra: np.ndarray, maximum_singular_value: bool = True -) -> np.ndarray: + spectra: NDArray[np.complex128], maximum_singular_value: bool = True +) -> NDArray[np.float64]: """Complex transfer matrix and CMIF from: http://papers.vibetech.com/Paper17-CMIF.pdf Parameters ---------- - spectra : `np.ndarray` + spectra : NDArray[np.complex128] Matrix containing spectra of the necessary IR. maximum_singular_value : bool, optional When `True`, the maximum singular value at each frequency line is @@ -131,7 +134,7 @@ def _complex_mode_identification( Returns ------- - cmif : `np.ndarray` + cmif : NDArray[np.float64] Complex mode identificator function. References @@ -159,20 +162,22 @@ def _complex_mode_identification( return cmif -def _generate_rir(room_dim, alpha, s_pos, r_pos, rt, mo, sr) -> np.ndarray: +def _generate_rir( + room_dim, alpha, s_pos, r_pos, rt, mo, sr +) -> NDArray[np.float64]: """Generate RIR using image source model according to Brinkmann, et al. Parameters ---------- - room_dim : `np.ndarray` + room_dim : NDArray[np.float64] Room dimensions in meters. - alpha : float or `np.ndarray` + alpha : float or NDArray[np.float64] Mean absorption coefficient of the room or array with the absorption coefficient for each wall (length 6. Ordered as north, south, east, west, floor, ceiling). - s_pos : `np.ndarray` + s_pos : NDArray[np.float64] Source position. - r_pos : `np.ndarray` + r_pos : NDArray[np.float64] Receiver position. rt : float Desired reverberation time to achieve in RIR. @@ -183,7 +188,7 @@ def _generate_rir(room_dim, alpha, s_pos, r_pos, rt, mo, sr) -> np.ndarray: Returns ------- - rir : `np.ndarray` + rir : NDArray[np.float64] Time vector of the RIR. References @@ -363,21 +368,21 @@ def area(self, new_area): self.__area = new_area def modal_density( - self, f_hz: float | np.ndarray, c: float = 343 - ) -> float | np.ndarray: + self, f_hz: float | NDArray[np.float64], c: float = 343 + ) -> float | NDArray[np.float64]: """Compute and return the modal density for a given cut-off frequency and speed of sound. Parameters ---------- - f_hz : float or `np.ndarray` + f_hz : float or NDArray[np.float64] Frequency or array of frequencies. c : float, optional Speed of sound in m/s. Default: 343. Returns ------- - float or `np.ndarray` + float or NDArray[np.float64] Modal density. """ @@ -515,7 +520,9 @@ def get_mixing_time( self.mixing_time_s = mixing_time_s return self.mixing_time_s - def get_room_modes(self, max_order: int = 6, c: float = 343) -> np.ndarray: + def get_room_modes( + self, max_order: int = 6, c: float = 343.0 + ) -> NDArray[np.float64]: """Computes and returns room modes for a shoebox room assuming hard reflecting walls. @@ -531,7 +538,7 @@ def get_room_modes(self, max_order: int = 6, c: float = 343) -> np.ndarray: Returns ------- - modes : np.ndarray + modes : NDArray[np.float64] Array containing the frequencies of the room modes as well as their characteristics (orders in each room dimension. This is necessary to know if it is an axial, a tangential or oblique mode). @@ -580,7 +587,7 @@ def get_analytical_transfer_function( receiver_pos : array-like Receiver position in meters. It must be inside the room, otherwise an assertion error is raised. - freqs : `np.ndarray` + freqs : NDArray[np.float64] Frequency vector for which to compute the transfer function. max_mode_order : int, optional Maximum mode order to be regarded. It should be high enough to @@ -594,9 +601,9 @@ def get_analytical_transfer_function( Returns ------- - p : `np.ndarray` + p : NDArray[np.float64] Complex transfer function, non-normalized. - modes : `np.ndarray` + modes : NDArray[np.float64] Modes for which the transfer function was computed. It has shape (mode, frequency and order xyz) and it is sorted by frequency. @@ -859,13 +866,13 @@ def add_detailed_absorption(self, detailed_absorption: dict): def _add_reverberant_tail_noise( - rir: np.ndarray, mixing_time_s: int, t60: float, sr: int -) -> np.ndarray: + rir: NDArray[np.float64], mixing_time_s: int, t60: float, sr: int +) -> NDArray[np.float64]: """Adds a reverberant tail as noise to an IR. Parameters ---------- - rir : `np.ndarray` + rir : NDArray[np.float64] Impulse response as 1D-array. mixing_time_s : int Mixing time in samples. @@ -876,7 +883,7 @@ def _add_reverberant_tail_noise( Returns ------- - rir_late : `np.ndarray` + rir_late : NDArray[np.float64] RIR with added decaying noise as late reverberant tail. """ @@ -905,12 +912,14 @@ def _add_reverberant_tail_noise( return rir -def _d50_from_rir(td: np.ndarray, fs: int, automatic_trimming: bool) -> float: +def _d50_from_rir( + td: NDArray[np.float64], fs: int, automatic_trimming: bool +) -> float: """Compute definition D50 from a given RIR (1D-Array). Parameters ---------- - td : `np.ndarray` + td : NDArray[np.float64] IR. fs : int Sampling rate in Hz. @@ -940,12 +949,14 @@ def _d50_from_rir(td: np.ndarray, fs: int, automatic_trimming: bool) -> float: return np.sum(td[:window]) / np.sum(td[:stop]) -def _c80_from_rir(td: np.ndarray, fs: int, automatic_trimming: bool) -> float: +def _c80_from_rir( + td: NDArray[np.float64], fs: int, automatic_trimming: bool +) -> float: """Compute clarity C80 from a given RIR (1D-Array). Parameters ---------- - td : `np.ndarray` + td : NDArray[np.float64] IR. fs : int Sampling rate in Hz. @@ -977,12 +988,14 @@ def _c80_from_rir(td: np.ndarray, fs: int, automatic_trimming: bool) -> float: return 10 * np.log10(np.sum(td[:window]) / np.sum(td[window:stop])) -def _ts_from_rir(td: np.ndarray, fs: int, automatic_trimming: bool) -> float: +def _ts_from_rir( + td: NDArray[np.float64], fs: int, automatic_trimming: bool +) -> float: """Compute center time from a given RIR (1D-Array). Parameters ---------- - td : `np.ndarray` + td : NDArray[np.float64] IR. fs : int Sampling rate in Hz. @@ -1016,7 +1029,7 @@ def _ts_from_rir(td: np.ndarray, fs: int, automatic_trimming: bool) -> float: def _obtain_optimal_reverb_time( - time_vector: np.ndarray, edc: np.ndarray + time_vector: NDArray[np.float64], edc: NDArray[np.float64] ) -> tuple[float, float]: """Compute the optimal reverberation time by analyzing the best linear fit (with the smallest least-squares error) from T10 until T60. If EDT @@ -1025,9 +1038,9 @@ def _obtain_optimal_reverb_time( Parameters ---------- - time_vector : `np.ndarray` + time_vector : NDArray[np.float64] Time vector corresponding to the edc. - edc : `np.ndarray` + edc : NDArray[np.float64] Energy decay curve in dB and normalized so that 0 dB corresponds to the impulse. @@ -1061,7 +1074,7 @@ def _obtain_optimal_reverb_time( else: start = -5.0 - steps: np.ndarray = np.arange(start - 20, start - 60, -1) + steps: NDArray[np.float64] = np.arange(start - 20, start - 60, -1) end, r = _get_best_linear_fit_for_edc(time_vector, edc, start, steps) if r > -0.95: warn( @@ -1076,10 +1089,10 @@ def _obtain_optimal_reverb_time( def _get_best_linear_fit_for_edc( - time_vector: np.ndarray, - edc: np.ndarray, + time_vector: NDArray[np.float64], + edc: NDArray[np.float64], start_value: float, - steps: np.ndarray, + steps: NDArray[np.float64], ): """Obtain the best end value for a linear regression of the EDC based on the lowest pearson correlation coefficient, i.e., with the maximum of @@ -1087,13 +1100,13 @@ def _get_best_linear_fit_for_edc( Parameters ---------- - time_vector : `np.ndarray` + time_vector : NDArray[np.float64] Time vector. - edc : `np.ndarray` + edc : NDArray[np.float64] Energy decay curve. start_value : float Start value of the EDC in dB for the regression. - steps : `np.ndarray` + steps : NDArray[np.float64] Array of all ending values of the EDC in dB to take into account. Returns @@ -1117,20 +1130,20 @@ def _get_best_linear_fit_for_edc( def _get_polynomial_coeffs_from_edc( - time_vector: np.ndarray, - edc: np.ndarray, + time_vector: NDArray[np.float64], + edc: NDArray[np.float64], start_value: float, end_value: float, -) -> tuple[np.ndarray, float]: +) -> tuple[NDArray[np.float64], float]: """Return the polynomial coefficients from the energy decay curve for given starting and ending values. This can be used for all reverberation time computations. Parameters ---------- - time_vector : `np.ndarray` + time_vector : NDArray[np.float64] Time vector in seconds corresponding to the energy decay curve. - edc : `np.ndarray` + edc : NDArray[np.float64] Energy decay curve in dB normalized to 0 dB at the point of the impulse. start_value : float @@ -1140,7 +1153,7 @@ def _get_polynomial_coeffs_from_edc( Returns ------- - coeff : `np.ndarray` + coeff : NDArray[np.float64] Polynomial coefficients for x^1 and x^0, respectively. r_coefficient : float Pearson's correlation coefficient r. It takes values between [-1, 1] @@ -1160,11 +1173,11 @@ def _get_polynomial_coeffs_from_edc( def _compute_energy_decay_curve( - time_data: np.ndarray, + time_data: NDArray[np.float64], impulse_index: int, trim_automatically: bool, fs_hz: int, -) -> np.ndarray: +) -> NDArray[np.float64]: """Get the energy decay curve from an energy time curve.""" # start_index might be the last index below -20 dB relative to peak value. # If so, the normalization of the edc should be done with the beginning diff --git a/dsptoolbox/room_acoustics/room_acoustics.py b/dsptoolbox/room_acoustics/room_acoustics.py index a9f59ea..474411e 100644 --- a/dsptoolbox/room_acoustics/room_acoustics.py +++ b/dsptoolbox/room_acoustics/room_acoustics.py @@ -4,6 +4,7 @@ import numpy as np from scipy.signal import find_peaks, convolve +from numpy.typing import NDArray from ..classes import Signal, MultiBandSignal, Filter from ..filterbanks import fractional_octave_bands, linkwitz_riley_crossovers @@ -25,9 +26,9 @@ def reverb_time( signal: Signal | MultiBandSignal, mode: str = "T20", - ir_start: int | np.ndarray | None = None, + ir_start: int | NDArray[np.int_] | None = None, automatic_trimming: bool = True, -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Computes reverberation time. Topt, T20, T30, T60 and EDT. Parameters @@ -38,7 +39,7 @@ def reverb_time( mode : str, optional Reverberation time mode. Options are `'Topt'`, `'T20'`, `'T30'`, `'T60'` or `'EDT'`. Default: `'Topt'`. - ir_start : int or array-like, optional + ir_start : int or array-like, NDArray[np.int_], optional If it is an integer, it is assumed as the start of the IR for all channels (and all bands). For more specific cases, pass a 1d-array containing the start indices for each channel or a 2d-array with @@ -51,10 +52,10 @@ def reverb_time( Returns ------- - reverberation_times : `np.ndarray` + reverberation_times : NDArray[np.float64] Reverberation times for each channel. Shape is (band, channel) if `MultiBandSignal` object is passed. - correlation_coefficient : `np.ndarray` + correlation_coefficient : NDArray[np.float64] Pearson correlation coefficient to determine the accuracy of the reverberation time estimation. It has shape (channels) or (band, channels) if `MultiBandSignal` object is passed. See notes @@ -130,7 +131,7 @@ def find_modes( dist_hz: float = 5, prominence_db: float | None = None, antiresonances: bool = False, -) -> np.ndarray: +) -> NDArray[np.float64]: """Finds the room modes of a set of RIR using the peaks of the complex mode indicator function (CMIF). @@ -151,7 +152,7 @@ def find_modes( Returns ------- - f_modes : `np.ndarray` + f_modes : NDArray[np.float64] Vector containing frequencies where modes have been localized. References @@ -272,7 +273,9 @@ def convolve_rir_on_signal( return new_sig -def find_ir_start(signal: Signal, threshold_dbfs: float = -20) -> np.ndarray: +def find_ir_start( + signal: Signal, threshold_dbfs: float = -20 +) -> NDArray[np.int_]: """This function finds the start of an IR defined as the first sample before a certain threshold is surpassed. For room impulse responses, -20 dB relative to peak level is recommended according to [1]. @@ -286,7 +289,7 @@ def find_ir_start(signal: Signal, threshold_dbfs: float = -20) -> np.ndarray: Returns ------- - start_index : `np.ndarray` + start_index : NDArray[np.int_] Index of IR start for each channel. References @@ -299,7 +302,7 @@ def find_ir_start(signal: Signal, threshold_dbfs: float = -20) -> np.ndarray: start_index = np.empty(signal.number_of_channels, dtype=int) for n in range(signal.number_of_channels): start_index[n] = _find_ir_start(signal.time_data[:, n], threshold_dbfs) - return start_index.astype(int) + return start_index.astype(np.int_) def generate_synthetic_rir( @@ -500,7 +503,7 @@ def descriptors( Returns ------- - output_descriptor : `np.ndarray` + output_descriptor : NDArray[np.float64] Array containing the output descriptor. If RIR is a `Signal`, it has shape (channel). If RIR is a `MultiBandSignal`, the array has shape (band, channel). @@ -549,7 +552,7 @@ def descriptors( return desc -def _bass_ratio(rir: Signal) -> np.ndarray: +def _bass_ratio(rir: Signal) -> NDArray[np.float64]: """Core computation of bass ratio. Parameters @@ -559,7 +562,7 @@ def _bass_ratio(rir: Signal) -> np.ndarray: Returns ------- - br : `np.ndarray` + br : NDArray[np.float64] Bass ratio per channel. """ @@ -575,8 +578,9 @@ def _bass_ratio(rir: Signal) -> np.ndarray: def _check_ir_start_reverb( - sig: Signal | MultiBandSignal, ir_start: int | np.ndarray | list | tuple -) -> np.ndarray | list | None: + sig: Signal | MultiBandSignal, + ir_start: int | NDArray[np.int_] | list | tuple | None, +) -> NDArray[np.float64] | list | None: """This method checks `ir_start` and parses it into the necessary form if relevant. For a `Signal`, it is a vector with the same number of elements as channels of `sig`. For `MultiBandSignal`, it is a 2d-array @@ -588,8 +592,8 @@ def _check_ir_start_reverb( """ if ir_start is not None: - if type(ir_start) in (list, tuple, np.ndarray): - ir_start = np.atleast_1d(ir_start).astype(int) + if type(ir_start) in (list, tuple, NDArray[np.float64]): + ir_start = np.atleast_1d(ir_start).astype(np.int_) assert ( np.issubdtype(type(ir_start), np.integer) or type(ir_start) is np.ndarray @@ -597,7 +601,9 @@ def _check_ir_start_reverb( if type(sig) is Signal: if np.issubdtype(type(ir_start), np.integer): - ir_start = np.ones(sig.number_of_channels, dtype=int) * ir_start + ir_start = ( + np.ones(sig.number_of_channels, dtype=np.int_) * ir_start + ) elif ir_start is None: return [None] * sig.number_of_channels assert ( @@ -608,7 +614,7 @@ def _check_ir_start_reverb( ir_start = ( np.ones( (sig.number_of_bands, sig.number_of_channels), - dtype=int, + dtype=np.int_, ) * ir_start ) @@ -624,5 +630,5 @@ def _check_ir_start_reverb( sig.number_of_channels, ), "Shape of ir_start is not valid for the passed signal" if ir_start.dtype not in (int, np.intp): - ir_start = ir_start.astype(int) + ir_start = ir_start.astype(np.int_) return ir_start diff --git a/dsptoolbox/standard_functions.py b/dsptoolbox/standard_functions.py index fec9a18..3fdc6d4 100644 --- a/dsptoolbox/standard_functions.py +++ b/dsptoolbox/standard_functions.py @@ -7,6 +7,7 @@ """ import numpy as np +from numpy.typing import NDArray import pickle from scipy.signal import resample_poly, convolve, hilbert @@ -44,7 +45,7 @@ def latency( in1: Signal | MultiBandSignal, in2: Signal | MultiBandSignal | None = None, polynomial_points: int = 0, -) -> tuple[np.ndarray[int | float], np.ndarray[float]]: +) -> tuple[NDArray[np.float64] | NDArray[np.int_], NDArray[np.float64]]: """Computes latency between two signals using the correlation method. If there is no second signal, the latency between the first and the other channels is computed. `in1` is to be understood as a delayed version @@ -79,11 +80,11 @@ def latency( Returns ------- - lags : `np.ndarray` + lags : NDArray[np.float64] Delays in samples. For `Signal`, the output shape is (channel). In case in2 is `None`, the length is `channels - 1`. In the case of `MultiBandSignal`, output shape is (band, channel). - correlations : `np.ndarray` + correlations : NDArray[np.float64] Correlation for computed delays with the same shape as lags. Notes @@ -380,8 +381,12 @@ def resample(sig: Signal, desired_sampling_rate_hz: int) -> Signal: def fractional_octave_frequencies( num_fractions=1, frequency_range=(20, 20e3), return_cutoff=False ) -> ( - tuple[np.ndarray, np.ndarray, tuple[np.ndarray, np.ndarray]] - | tuple[np.ndarray, np.ndarray] + tuple[ + NDArray[np.float64], + NDArray[np.float64], + tuple[NDArray[np.float64], NDArray[np.float64]], + ] + | tuple[NDArray[np.float64], NDArray[np.float64]] ): """Return the octave center frequencies according to the IEC 61260:1:2014 standard. This implementation has been taken from the pyfar package. See @@ -591,7 +596,7 @@ def erb_frequencies( freq_range_hz=[20, 20000], resolution: float = 1, reference_frequency_hz: float = 1000, -) -> np.ndarray: +) -> NDArray[np.float64]: """Get frequencies that are linearly spaced on the ERB frequency scale. This implementation was taken and adapted from the pyfar package. See references. @@ -611,7 +616,7 @@ def erb_frequencies( Returns ------- - frequencies : `np.ndarray` + frequencies : NDArray[np.float64] The frequencies in Hz that are linearly distributed on the ERB scale with a spacing given by `resolution` ERB units. @@ -674,7 +679,7 @@ def erb_frequencies( def true_peak_level( signal: Signal | MultiBandSignal, -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Computes true-peak level of a signal using the standardized method by the Rec. ITU-R BS.1770-4. See references. @@ -685,10 +690,10 @@ def true_peak_level( Returns ------- - true_peak_levels : `np.ndarray` + true_peak_levels : NDArray[np.float64] True-peak levels (in dBTP) as an array with shape (channels) or (band, channels) in case that the input signal is `MultiBandSignal`. - peak_levels : `np.ndarray` + peak_levels : NDArray[np.float64] Peak levels (in dBFS) as an array with shape (channels) or (band, channels) in case that the input signal is `MultiBandSignal`. @@ -1021,7 +1026,9 @@ def detrend( raise TypeError("Pass either a Signal or a MultiBandSignal") -def rms(sig: Signal | MultiBandSignal, in_dbfs: bool = True) -> np.ndarray: +def rms( + sig: Signal | MultiBandSignal, in_dbfs: bool = True +) -> NDArray[np.float64]: """Returns Root Mean Squared (RMS) value for each channel. Parameters @@ -1034,7 +1041,7 @@ def rms(sig: Signal | MultiBandSignal, in_dbfs: bool = True) -> np.ndarray: Returns ------- - rms_values : `np.ndarray` + rms_values : NDArray[np.float64] Array with RMS values. If a `Signal` is passed, it has shape (channel). If a `MultiBandSignal` is passed, its shape is (bands, channel). @@ -1247,7 +1254,7 @@ def envelope( Returns ------- - `np.ndarray` + NDArray[np.float64] Signal envelope. It has the shape (time sample, channel) or (time sample, band, channel) in case of `MultiBandSignal`. diff --git a/dsptoolbox/transfer_functions/_transfer_functions.py b/dsptoolbox/transfer_functions/_transfer_functions.py index b700b2b..a54b53c 100644 --- a/dsptoolbox/transfer_functions/_transfer_functions.py +++ b/dsptoolbox/transfer_functions/_transfer_functions.py @@ -7,6 +7,7 @@ from scipy.fft import next_fast_len from scipy.stats import pearsonr from warnings import warn +from numpy.typing import NDArray from .._general_helpers import ( _find_nearest, _calculate_window, @@ -17,13 +18,13 @@ def _spectral_deconvolve( - num_fft: np.ndarray, - denum_fft: np.ndarray, + num_fft: NDArray[np.complex128], + denum_fft: NDArray[np.complex128], freqs_hz, time_signal_length: int, mode="regularized", start_stop_hz=None, -) -> np.ndarray: +) -> NDArray[np.complex128]: assert num_fft.shape == denum_fft.shape, "Shapes do not match" assert len(freqs_hz) == len(num_fft), "Frequency vector does not match" @@ -64,7 +65,7 @@ def _window_this_ir_tukey( offset_samples: int = 0, left_to_right_flank_ratio: float = 1.0, adaptive_window: bool = True, -) -> tuple[np.ndarray, np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64], int]: """This function finds the index of the impulse and trims or windows it accordingly. Window used and the start sample are returned. @@ -163,16 +164,16 @@ def _window_this_ir_tukey( def _window_this_ir( vec, total_length: int, window_type: str = "hann", window_parameter=None -) -> tuple[np.ndarray, np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64], int]: """This function windows an impulse response by placing the peak exactly in the middle of the window. It trims or pads at the end if needed. The windowed IR, window and the start sample are passed. Returns ------- - td : `np.ndarray` + td : NDArray[np.float64] Windowed vector. - w : `np.ndarray` + w : NDArray[np.float64] Generated window. ind_low_td : int Sample position of the start. @@ -231,19 +232,19 @@ def _window_this_ir( return td, w, ind_low_td -def _warp_time_series(td: np.ndarray, warping_factor: float): +def _warp_time_series(td: NDArray[np.float64], warping_factor: float): """Warp or unwarp a time series. Parameters ---------- - td : `np.ndarray` + td : NDArray[np.float64] Time series with shape (time samples, channels). warping_factor : float The warping factor to use. Returns ------- - warped_td : `np.ndarray` + warped_td : NDArray[np.float64] Time series in the (un)warped domain. """ @@ -277,7 +278,7 @@ def _get_harmonic_times( chirp_length_s: float, n_harmonics: int, time_offset_seconds: float = 0.0, -) -> np.ndarray: +) -> NDArray[np.float64]: """Get the time at which each harmonic IR occur relative to the fundamental IR in a measurement with an exponential chirp. This is computed according to [1]. If the fundamental happens at time `t=0`, all harmonics will be at @@ -296,7 +297,7 @@ def _get_harmonic_times( Returns ------- - np.ndarray + NDArray[np.float64] Array with the times for each harmonic in ascending order. The values are given in seconds. @@ -310,7 +311,7 @@ def _get_harmonic_times( def _trim_ir( - time_data: np.ndarray, + time_data: NDArray[np.float64], fs_hz: int, offset_start_s: float, ) -> tuple[int, int, int]: diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index 62735ac..bcdf78f 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -3,6 +3,7 @@ """ import numpy as np +from numpy.typing import NDArray from scipy.signal import minimum_phase as min_phase_scipy from scipy.fft import rfft as rfft_scipy, next_fast_len as next_fast_length_fft from scipy.interpolate import interp1d @@ -177,7 +178,7 @@ def window_ir( at_start: bool = True, offset_samples: int = 0, left_to_right_flank_length_ratio: float = 1.0, -) -> tuple[Signal, np.ndarray]: +) -> tuple[Signal, NDArray[np.float64]]: """Windows an IR with trimming and selection of constant valued length. This is equivalent to a tukey window whose flanks can be selected to be any type. The peak of the impulse response is aligned to correspond to @@ -220,7 +221,7 @@ def window_ir( ------- new_sig : `Signal` Windowed signal. The used window is also saved under `new_sig.window`. - start_positions_samples : `np.ndarray` + start_positions_samples : NDArray[np.float64] This array contains the position index of the start of the IR in each channel of the original IR (relative to the possibly padded windowed IR). @@ -285,7 +286,7 @@ def window_centered_ir( signal: Signal, total_length_samples: int, window_type: str | tuple = "hann", -) -> tuple[Signal, np.ndarray]: +) -> tuple[Signal, NDArray[np.float64]]: """This function windows an IR placing its peak in the middle. It trims it to the total length of the window or pads it to the desired length (padding in the end, window has `total_length`). @@ -307,7 +308,7 @@ def window_centered_ir( ------- new_sig : `Signal` Windowed signal. The used window is also saved under `new_sig.window`. - start_positions_samples : `np.ndarray` + start_positions_samples : NDArray[np.float64] This array contains the position index of the start of the IR in each channel of the original IR. @@ -348,7 +349,7 @@ def compute_transfer_function( mode="h2", window_length_samples: int = 1024, spectrum_parameters: dict | None = None, -) -> tuple[Signal, np.ndarray, np.ndarray]: +) -> tuple[Signal, NDArray[np.complex128], NDArray[np.float64]]: r"""Gets transfer function H1, H2 or H3 (for stochastic signals). H1: for noise in the output signal. `Gxy/Gxx`. H2: for noise in the input signal. `Gyy/Gyx`. @@ -378,10 +379,10 @@ def compute_transfer_function( tf_sig : `Signal` Transfer functions as `Signal` object. Coherences are also computed and saved in the `Signal` object. - tf : `np.ndarray` - Complex transfer function as type `np.ndarray` with shape (frequency, - channel). - coherence : `np.ndarray` + tf : NDArray[np.complex128] + Complex transfer function as type NDArray[np.complex128] with shape + (frequency, channel). + coherence : NDArray[np.float64] Coherence of the measurement with shape (frequency, channel). Notes @@ -566,7 +567,7 @@ def average_irs( def min_phase_from_mag( - spectrum: np.ndarray, + spectrum: NDArray[np.float64], sampling_rate_hz: int, original_length_time_data: int | None = None, signal_type: str = "ir", @@ -576,7 +577,7 @@ def min_phase_from_mag( Parameters ---------- - spectrum : `np.ndarray` + spectrum : NDArray[np.float64] Spectrum (no scaling) with only positive frequencies. sampling_rate_hz : int Signal's sampling rate in Hz. @@ -629,7 +630,7 @@ def min_phase_from_mag( def lin_phase_from_mag( - spectrum: np.ndarray, + spectrum: NDArray[np.float64], sampling_rate_hz: int, original_length_time_data: int | None = None, group_delay_ms: str | float = "minimum", @@ -647,7 +648,7 @@ def lin_phase_from_mag( Parameters ---------- - spectrum : `np.ndarray` + spectrum : NDArray[np.float64] Spectrum with only positive frequencies and 0. sampling_rate_hz : int Signal's sampling rate in Hz. @@ -811,7 +812,7 @@ def group_delay( method="matlab", smoothing: int = 0, remove_ir_latency: bool = False, -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Computes and returns group delay. Parameters @@ -833,9 +834,9 @@ def group_delay( Returns ------- - freqs : `np.ndarray` + freqs : NDArray[np.float64] Frequency vector in Hz. - group_delays : `np.ndarray` + group_delays : NDArray[np.float64] Matrix containing group delays in seconds with shape (gd, channel). """ @@ -893,7 +894,7 @@ def minimum_phase( signal: Signal, method: str = "real cepstrum", padding_factor: int = 8, -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Gives back a matrix containing the minimum phase signal for each channel. Two methods are available for computing the minimum phase of a system: `'real cepstrum'` (windowing in the cepstral domain) or @@ -913,9 +914,9 @@ def minimum_phase( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - min_phases : `np.ndarray` + min_phases : NDArray[np.float64] Minimum phases as matrix with shape (phase, channel). """ @@ -965,7 +966,7 @@ def minimum_group_delay( signal: Signal, smoothing: int = 0, padding_factor: int = 8, -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Computes minimum group delay of given IR using the real cepstrum method. Parameters @@ -982,9 +983,9 @@ def minimum_group_delay( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - min_gd : `np.ndarray` + min_gd : NDArray[np.float64] Minimum group delays in seconds as matrix with shape (gd, channel). References @@ -1006,7 +1007,7 @@ def excess_group_delay( signal: Signal, smoothing: int = 0, remove_ir_latency: bool = False, -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Computes excess group delay of an IR. Parameters @@ -1022,9 +1023,9 @@ def excess_group_delay( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - ex_gd : `np.ndarray` + ex_gd : NDArray[np.float64] Excess group delays in seconds with shape (excess_gd, channel). References @@ -1285,10 +1286,10 @@ def window_frequency_dependent( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - spec : `np.ndarray` - Spectrum with shape (frequency, channel). + spec : NDArray[np.complex128] + Complex spectrum with shape (frequency, channel). Notes ----- @@ -1363,12 +1364,12 @@ def window_frequency_dependent( # Scaling function if scaling == "amplitude spectrum": - def scaling_func(window: np.ndarray): + def scaling_func(window: NDArray[np.float64]): return 2**0.5 / np.sum(window, axis=0, keepdims=True) elif scaling == "amplitude spectral density": - def scaling_func(window: np.ndarray): + def scaling_func(window: NDArray[np.float64]): return ( 2 / np.sum(window**2, axis=0, keepdims=True) @@ -1378,12 +1379,12 @@ def scaling_func(window: np.ndarray): elif scaling == "fft": scaling_value = fast_length**-0.5 - def scaling_func(window: np.ndarray): + def scaling_func(window: NDArray[np.float64]): return scaling_value else: - def scaling_func(window: np.ndarray): + def scaling_func(window: NDArray[np.float64]): return 1 # Precompute some window factors @@ -1469,7 +1470,7 @@ def warp_ir( return f_unwarped, warped_ir -def find_ir_latency(ir: Signal) -> np.ndarray: +def find_ir_latency(ir: Signal) -> NDArray[np.float64]: """Find the subsample maximum of each channel of the IR using the its minimum phase equivalent. @@ -1480,7 +1481,7 @@ def find_ir_latency(ir: Signal) -> np.ndarray: Returns ------- - latency_samples : `np.ndarray` + latency_samples : NDArray[np.float64] Array with the position of each channel's maximum in samples. """ diff --git a/dsptoolbox/transforms/_transforms.py b/dsptoolbox/transforms/_transforms.py index 83c33cc..4a516df 100644 --- a/dsptoolbox/transforms/_transforms.py +++ b/dsptoolbox/transforms/_transforms.py @@ -3,6 +3,7 @@ """ import numpy as np +from numpy.typing import NDArray from scipy.signal import get_window @@ -17,7 +18,7 @@ def _pitch2frequency(tuning_a_hz: float = 440): Returns ------- - freqs : `np.ndarray` + freqs : NDArray[np.float64] Frequencies for each pitch. It always has length 128. """ @@ -60,19 +61,19 @@ def get_center_frequency(self): domain = x[-1] - x[0] return ind / domain - def get_scale_lengths(self, frequencies: np.ndarray, fs: int): + def get_scale_lengths(self, frequencies: NDArray[np.float64], fs: int): """Returns the lengths of the queried frequencies. Parameters ---------- - frequencies : `np.ndarray` + frequencies : NDArray[np.float64] Frequencies for which to scale the wavelet. fs : int Sampling rate in Hz. Returns ------- - `np.ndarray` + NDArray[np.float64] Lengths of wavelets in samples. """ @@ -143,11 +144,13 @@ def __init__( self.step = step self.interpolation = interpolation - def _get_x(self) -> np.ndarray: + def _get_x(self) -> NDArray[np.float64]: """Returns x vector for the mother wavelet.""" return np.arange(self.bounds[0], self.bounds[1] + self.step, self.step) - def get_base_wavelet(self) -> tuple[np.ndarray, np.ndarray]: + def get_base_wavelet( + self, + ) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Return complex morlet wavelet.""" x = self._get_x() return x, 1 / np.sqrt(np.pi * self.b) * np.exp( @@ -159,22 +162,22 @@ def get_center_frequency(self) -> float: return 1 / self.scale def get_wavelet( - self, f: float | np.ndarray, fs: int - ) -> np.ndarray | list[np.ndarray]: + self, f: float | NDArray[np.float64], fs: int + ) -> NDArray[np.float64] | list[NDArray[np.float64]]: """Return wavelet scaled for a specific frequency and sampling rate. The wavelet values can also be linearly interpolated for a higher accuracy at the expense of computation time. Parameters ---------- - f : float or `np.ndarray` + f : float or NDArray[np.float64] Queried frequency or array of frequencies. fs : int Sampling rate in Hz. Returns ------- - wave : `np.ndarray` or list of `np.ndarray` + wave : NDArray[np.float64] or list of NDArray[np.float64] Wavelet function. It is either a 1d-array for a single frequency or a list of arrays for multiple frequencies. @@ -200,7 +203,9 @@ def get_wavelet( wave.append(wavef) return wave - def _get_interpolated_wave(self, base: np.ndarray, inds: np.ndarray): + def _get_interpolated_wave( + self, base: NDArray[np.float64], inds: NDArray[np.float64] + ): """Return the wavelet function for a selection of index using linear interpolation. @@ -220,16 +225,19 @@ def _get_interpolated_wave(self, base: np.ndarray, inds: np.ndarray): def _squeeze_scalogram( - scalogram: np.ndarray, freqs: np.ndarray, fs: int, delta_w: float = 0.05 -) -> np.ndarray: + scalogram: NDArray[np.float64], + freqs: NDArray[np.float64], + fs: int, + delta_w: float = 0.05, +) -> NDArray[np.float64]: """Synchrosqueeze a scalogram. Parameters ---------- - scalogram : `np.ndarray` + scalogram : NDArray[np.float64] Complex scalogram from the CWT with shape (frequency, time sample, channel). - freqs : `np.ndarray` + freqs : NDArray[np.float64] Frequency vector. fs : int Sampling rate in Hz. @@ -240,7 +248,7 @@ def _squeeze_scalogram( Returns ------- - sync : `np.ndarray` + sync : NDArray[np.float64] Synchrosqueezed scalogram. References @@ -281,7 +289,7 @@ def _squeeze_scalogram( def _get_length_longest_wavelet( - wave: Wavelet | MorletWavelet, f: np.ndarray, fs: int + wave: Wavelet | MorletWavelet, f: NDArray[np.float64], fs: int ): """Get longest wavelet for a frequency vector. This is useful information for zero-padding to avoid boundary effects. @@ -290,7 +298,7 @@ def _get_length_longest_wavelet( ---------- wave : `Wavelet` or `MorletWavelet` Wavelet object. - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. fs : int Sampling rate in Hz. diff --git a/dsptoolbox/transforms/transforms.py b/dsptoolbox/transforms/transforms.py index 1278161..b31125a 100644 --- a/dsptoolbox/transforms/transforms.py +++ b/dsptoolbox/transforms/transforms.py @@ -16,6 +16,7 @@ ) import numpy as np +from numpy.typing import NDArray from scipy.signal.windows import get_window from scipy.fft import dct from scipy.signal import oaconvolve, resample_poly @@ -32,7 +33,9 @@ pass -def cepstrum(signal: Signal, mode="power") -> np.ndarray: +def cepstrum( + signal: Signal, mode="power" +) -> NDArray[np.float64] | NDArray[np.complex128]: """Returns the cepstrum of a given signal in the Quefrency domain. Parameters @@ -45,7 +48,7 @@ def cepstrum(signal: Signal, mode="power") -> np.ndarray: Returns ------- - ceps : `np.ndarray` + ceps : NDArray[np.float64] or NDArray[np.complex128] Cepstrum. References @@ -81,8 +84,14 @@ def log_mel_spectrogram( generate_plot: bool = True, stft_parameters: dict | None = None, ) -> ( - tuple[np.ndarray, np.ndarray, np.ndarray] - | tuple[np.ndarray, np.ndarray, np.ndarray, plt.Figure, plt.Axes] + tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] + | tuple[ + NDArray[np.float64], + NDArray[np.float64], + NDArray[np.float64], + plt.Figure, + plt.Axes, + ] ): """Returns the log mel spectrogram of the specific signal and channel. @@ -108,20 +117,20 @@ def log_mel_spectrogram( Returns ------- - time_s : `np.ndarray` + time_s : NDArray[np.float64] Time vector. - f_mel : `np.ndarray` + f_mel : NDArray[np.float64] Frequency vector in Mel. - log_mel_sp : `np.ndarray` + log_mel_sp : NDArray[np.float64] Log mel spectrogram with shape (frequency, time frame, channel). When `generate_plot=True`: - time_s : `np.ndarray` + time_s : NDArray[np.float64] Time vector. - f_mel : `np.ndarray` + f_mel : NDArray[np.float64] Frequency vector in Mel. - log_mel_sp : `np.ndarray` + log_mel_sp : NDArray[np.float64] Log mel spectrogram with shape (frequency, time frame, channel). fig : `matplotlib.figure.Figure` Figure. @@ -151,8 +160,11 @@ def log_mel_spectrogram( def mel_filterbank( - f_hz: np.ndarray, range_hz=None, n_bands: int = 40, normalize: bool = True -) -> tuple[np.ndarray, np.ndarray]: + f_hz: NDArray[np.float64], + range_hz=None, + n_bands: int = 40, + normalize: bool = True, +) -> tuple[NDArray[np.float64], NDArray[np.float64]]: """Creates equidistant mel triangle filters in a given range. The returned matrix can be used to convert Hz into Mel in a spectrogram. @@ -162,7 +174,7 @@ def mel_filterbank( Parameters ---------- - f_hz : `np.ndarray` + f_hz : NDArray[np.float64] Frequency vector. range_hz : array-like with length 2, optional Range (in Hz) in which to create the filters. If `None`, the whole @@ -175,9 +187,9 @@ def mel_filterbank( Returns ------- - mel_filters : `np.ndarray` + mel_filters : NDArray[np.float64] Mel filters matrix with shape (bands, frequency). - mel_center_freqs : `np.ndarray` + mel_center_freqs : NDArray[np.float64] Vector containing mel center frequencies. """ @@ -288,12 +300,18 @@ def plot_waterfall( def mfcc( signal: Signal, channel: int = 0, - mel_filters: np.ndarray | None = None, + mel_filters: NDArray[np.float64] | None = None, generate_plot: bool = True, stft_parameters: dict | None = None, ) -> ( - tuple[np.ndarray, np.ndarray, np.ndarray] - | tuple[np.ndarray, np.ndarray, np.ndarray, plt.Figure, plt.Axes] + tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] + | tuple[ + NDArray[np.float64], + NDArray[np.float64], + NDArray[np.float64], + plt.Figure, + plt.Axes, + ] ): """Mel-frequency cepstral coefficients for a windowed signal are computed and returned using the discrete cosine transform of type 2 (see @@ -307,7 +325,7 @@ def mfcc( channel : int, optional Channel of the signal for which to plot the MFCC when `generate_plot=True`. Default: 0. - mel_filters : `np.ndarray`, optional + mel_filters : NDArray[np.float64], optional Hz-to-Mel transformation matrix with shape (mel band, frequency Hz). It can be created using `mel_filterbank`. If `None` is passed, the filters are automatically computed regarding the whole @@ -324,23 +342,23 @@ def mfcc( Returns ------- - time_s : `np.ndarray` + time_s : NDArray[np.float64] Time vector. - f_mel : `np.ndarray` + f_mel : NDArray[np.float64] Frequency vector in mel. If `mel_filters` is passed, this is only a list with entries [0, n_mel_filters]. - mfcc : `np.ndarray` + mfcc : NDArray[np.float64] Mel-frequency cepstral coefficients with shape (cepstral coefficients, time frame, channel). When `generate_plot=True`: - time_s : `np.ndarray` + time_s : NDArray[np.float64] Time vector. - f_mel : `np.ndarray` + f_mel : NDArray[np.float64] Frequency vector in mel. If `mel_filters` is passed, this is only a list with entries [0, n_mel_filters]. - mfcc : `np.ndarray` + mfcc : NDArray[np.float64] Mel-frequency cepstral coefficients with shape (cepstral coefficients, time frame, channel). fig : `matplotlib.figure.Figure` @@ -390,7 +408,7 @@ def mfcc( def istft( - stft: np.ndarray, + stft: NDArray[np.complex128], original_signal: Signal | None = None, parameters: dict | None = None, sampling_rate_hz: int | None = None, @@ -411,7 +429,7 @@ def istft( Parameters ---------- - stft : `np.ndarray` + stft : NDArray[np.complex128] Complex STFT with shape (frequency, time frame, channel). It is assumed that only positive frequencies (including 0) are present. original_signal : `Signal`, optional @@ -538,8 +556,14 @@ def chroma_stft( compression: float = 0.5, plot_channel: int = -1, ) -> ( - tuple[np.ndarray, np.ndarray, np.ndarray] - | tuple[np.ndarray, np.ndarray, np.ndarray, plt.Figure, plt.Axes] + tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] + | tuple[ + NDArray[np.float64], + NDArray[np.float64], + NDArray[np.float64], + plt.Figure, + plt.Axes, + ] ): """This computes the Chroma Features and Pitch STFT. See [1] for details. @@ -558,12 +582,12 @@ def chroma_stft( Returns ------- - t : `np.ndarray` + t : NDArray[np.float64] Time vector corresponding to each time frame. - chroma_stft : `np.ndarray` + chroma_stft : NDArray[np.float64] Chroma Features with shape (note, time frame, channel). First index is C, second C#, etc. (Until B). - pitch_stft : `np.ndarray` + pitch_stft : NDArray[np.float64] Pitch log-STFT with shape (pitch, time frame, channel). First index is note 0 (MIDI), i.e., C0. When `plot_channel != -1`: @@ -628,23 +652,23 @@ def chroma_stft( def cwt( signal: Signal, - frequencies: np.ndarray, + frequencies: NDArray[np.float64], wavelet: Wavelet | MorletWavelet, - channel: np.ndarray | None = None, + channel: NDArray[np.float64] | None = None, synchrosqueezed: bool = False, -) -> np.ndarray: +) -> NDArray[np.complex128]: """Returns a scalogram by means of the continuous wavelet transform. Parameters ---------- signal : `Signal` Signal for which to compute the cwt. - frequencies : `np.ndarray` + frequencies : NDArray[np.float64] Frequencies to query with the wavelet. wavelet : `Wavelet` or `MorletWavelet` Type of wavelet to use. It must be a class inherited from the `Wavelet` class. - channel : `np.ndarray`, optional + channel : NDArray[np.float64], optional Channel for which to compute the cwt. If `None`, all channels are computed. Default: `None`. synchrosqueezed : bool, optional @@ -653,7 +677,7 @@ def cwt( Returns ------- - scalogram : `np.ndarray` + scalogram : NDArray[np.complex128] Complex scalogram scalogram with shape (frequency, time sample, channel). @@ -738,14 +762,14 @@ def hilbert(signal: Signal | MultiBandSignal) -> Signal | MultiBandSignal: def vqt( signal: Signal, - channel: np.ndarray | None = None, + channel: NDArray[np.int_] | None = None, q: float = 1, gamma: float = 50, octaves: list = [1, 5], bins_per_octave: int = 24, a4_tuning: int = 440, window: str | tuple = "hann", -) -> tuple[np.ndarray, np.ndarray]: +) -> tuple[NDArray[np.float64], NDArray[np.complex128]]: """Variable-Q Transform. This is a special case of the continuous wavelet transform with complex morlet wavelets for the time-frequency analysis. Constant-Q Transform can be obtained by setting `gamma = 0`. @@ -754,7 +778,7 @@ def vqt( ---------- signal : `Signal` Signal for which to compute the cqt coefficients. - channel : `np.ndarray` or int, optional + channel : NDArray[np.float64] or int, optional Channel(s) for which to compute the cqt coefficients. If `None`, all channels are computed. Default: `None`. q : float, optional @@ -781,9 +805,9 @@ def vqt( Returns ------- - f : `np.ndarray` + f : NDArray[np.float64] Frequency vector. - vqt : `np.ndarray` + vqt : NDArray[np.complex128] VQT coefficients with shape (frequency, time samples, channel). References From 42a3febd4ce7f5bf52b6bf397c97e8670eab7b1e Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 01:16:35 +0200 Subject: [PATCH 17/35] added assertion phase linearizer --- dsptoolbox/classes/_phaseLinearizer.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dsptoolbox/classes/_phaseLinearizer.py b/dsptoolbox/classes/_phaseLinearizer.py index dffd93a..0e3a8ab 100644 --- a/dsptoolbox/classes/_phaseLinearizer.py +++ b/dsptoolbox/classes/_phaseLinearizer.py @@ -57,6 +57,9 @@ def __init__( f"Phase response with length {len(phase_response)} and " + f"length {time_data_length_samples} do not match." ) + assert ( + phase_response.ndim == 1 + ), "Phase response should have only one dimension" self.phase_response = phase_response self.sampling_rate_hz = sampling_rate_hz self.set_parameters() From 2573bbd3ae60811efc13d37318ec1c45137b4500 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 01:38:15 +0200 Subject: [PATCH 18/35] moved some functions to tools --- dsptoolbox/__init__.py | 4 - dsptoolbox/filterbanks/filterbanks.py | 3 +- dsptoolbox/standard_functions.py | 168 ------------------------- dsptoolbox/tools.py | 173 ++++++++++++++++++++++++++ tests/test_standard.py | 8 -- tests/test_tools.py | 2 + 6 files changed, 176 insertions(+), 182 deletions(-) diff --git a/dsptoolbox/__init__.py b/dsptoolbox/__init__.py index 450821e..6e21d9d 100644 --- a/dsptoolbox/__init__.py +++ b/dsptoolbox/__init__.py @@ -4,14 +4,12 @@ merge_filterbanks, pad_trim, fractional_delay, - fractional_octave_frequencies, activity_detector, fade, normalize, true_peak_level, resample, load_pkl_object, - erb_frequencies, detrend, rms, CalibrationData, @@ -53,9 +51,7 @@ "normalize", "fractional_delay", "true_peak_level", - "erb_frequencies", "load_pkl_object", - "fractional_octave_frequencies", "detrend", "rms", "CalibrationData", diff --git a/dsptoolbox/filterbanks/filterbanks.py b/dsptoolbox/filterbanks/filterbanks.py index 8fb36e5..f37581e 100644 --- a/dsptoolbox/filterbanks/filterbanks.py +++ b/dsptoolbox/filterbanks/filterbanks.py @@ -9,9 +9,8 @@ from .. import ( Filter, FilterBank, - fractional_octave_frequencies, - erb_frequencies, ) +from ..tools import fractional_octave_frequencies, erb_frequencies from ..classes._lattice_ladder_filter import ( LatticeLadderFilter, _get_lattice_ladder_coefficients_iir, diff --git a/dsptoolbox/standard_functions.py b/dsptoolbox/standard_functions.py index 3fdc6d4..1b71882 100644 --- a/dsptoolbox/standard_functions.py +++ b/dsptoolbox/standard_functions.py @@ -23,8 +23,6 @@ ) from ._standard import ( _latency, - _center_frequencies_fractional_octaves_iec, - _exact_center_frequencies_fractional_octaves, _indices_above_threshold_dbfs, _detrend, _rms, @@ -378,87 +376,6 @@ def resample(sig: Signal, desired_sampling_rate_hz: int) -> Signal: return new_sig -def fractional_octave_frequencies( - num_fractions=1, frequency_range=(20, 20e3), return_cutoff=False -) -> ( - tuple[ - NDArray[np.float64], - NDArray[np.float64], - tuple[NDArray[np.float64], NDArray[np.float64]], - ] - | tuple[NDArray[np.float64], NDArray[np.float64]] -): - """Return the octave center frequencies according to the IEC 61260:1:2014 - standard. This implementation has been taken from the pyfar package. See - references. - - For numbers of fractions other than `1` and `3`, only the - exact center frequencies are returned, since nominal frequencies are not - specified by corresponding standards. - - Parameters - ---------- - num_fractions : int, optional - The number of bands an octave is divided into. Eg., ``1`` refers to - octave bands and ``3`` to third octave bands. The default is ``1``. - frequency_range : array, tuple - The lower and upper frequency limits, the default is - ``frequency_range=(20, 20e3)``. - - Returns - ------- - nominal : array, float - The nominal center frequencies in Hz specified in the standard. - Nominal frequencies are only returned for octave bands and third octave - bands. Otherwise, an empty array is returned. - exact : array, float - The exact center frequencies in Hz, resulting in a uniform distribution - of frequency bands over the frequency range. - cutoff_freq : tuple, array, float - The lower and upper critical frequencies in Hz of the bandpass filters - for each band as a tuple corresponding to `(f_lower, f_upper)`. - - References - ---------- - - The pyfar package: https://github.com/pyfar/pyfar - - """ - nominal = np.array([]) - - f_lims = np.asarray(frequency_range) - if f_lims.size != 2: - raise ValueError( - "You need to specify a lower and upper limit frequency." - ) - if f_lims[0] > f_lims[1]: - raise ValueError( - "The second frequency needs to be higher than the first." - ) - - if num_fractions in [1, 3]: - nominal, exact = _center_frequencies_fractional_octaves_iec( - nominal, num_fractions - ) - - mask = (nominal >= f_lims[0]) & (nominal <= f_lims[1]) - nominal = nominal[mask] - exact = exact[mask] - - else: - exact = _exact_center_frequencies_fractional_octaves( - num_fractions, f_lims - ) - - if return_cutoff: - octave_ratio = 10 ** (3 / 10) - freqs_upper = exact * octave_ratio ** (1 / 2 / num_fractions) - freqs_lower = exact * octave_ratio ** (-1 / 2 / num_fractions) - f_crit = (freqs_lower, freqs_upper) - return nominal, exact, f_crit - else: - return nominal, exact - - def normalize( sig: Signal | MultiBandSignal, peak_dbfs: float = -6, @@ -592,91 +509,6 @@ def fade( return new_sig -def erb_frequencies( - freq_range_hz=[20, 20000], - resolution: float = 1, - reference_frequency_hz: float = 1000, -) -> NDArray[np.float64]: - """Get frequencies that are linearly spaced on the ERB frequency scale. - This implementation was taken and adapted from the pyfar package. See - references. - - Parameters - ---------- - freq_range : array-like, optional - The upper and lower frequency limits in Hz between which the frequency - vector is computed. Default: [20, 20e3]. - resolution : float, optional - The frequency resolution in ERB units. 1 returns frequencies that are - spaced by 1 ERB unit, a value of 0.5 would return frequencies that are - spaced by 0.5 ERB units. Default: 1. - reference_frequency : float, optional - The reference frequency in Hz relative to which the frequency vector - is constructed. Default: 1000. - - Returns - ------- - frequencies : NDArray[np.float64] - The frequencies in Hz that are linearly distributed on the ERB scale - with a spacing given by `resolution` ERB units. - - References - ---------- - - The pyfar package: https://github.com/pyfar/pyfar - - B. C. J. Moore, An introduction to the psychology of hearing, - (Leiden, Boston, Brill, 2013), 6th ed. - - V. Hohmann, “Frequency analysis and synthesis using a gammatone - filterbank,” Acta Acust. united Ac. 88, 433-442 (2002). - - P. L. Søndergaard, and P. Majdak, “The auditory modeling toolbox,” - in The technology of binaural listening, edited by J. Blauert - (Heidelberg et al., Springer, 2013) pp. 33-56. - - """ - - # check input - if ( - not isinstance(freq_range_hz, (list, tuple, np.ndarray)) - or len(freq_range_hz) != 2 - ): - raise ValueError("freq_range must be an array like of length 2") - if freq_range_hz[0] > freq_range_hz[1]: - freq_range_hz = [freq_range_hz[1], freq_range_hz[0]] - if resolution <= 0: - raise ValueError("Resolution must be larger than zero") - - # convert the frequency range and reference to ERB scale - # (Hohmann 2002, Eq. 16) - erb_range = ( - 9.2645 - * np.sign(freq_range_hz) - * np.log(1 + np.abs(freq_range_hz) * 0.00437) - ) - erb_ref = ( - 9.2645 - * np.sign(reference_frequency_hz) - * np.log(1 + np.abs(reference_frequency_hz) * 0.00437) - ) - - # get the referenced range - erb_ref_range = np.array([erb_ref - erb_range[0], erb_range[1] - erb_ref]) - - # construct the frequencies on the ERB scale - n_points = np.floor(erb_ref_range / resolution).astype(int) - erb_points = ( - np.arange(-n_points[0], n_points[1] + 1) * resolution + erb_ref - ) - - # convert to frequencies in Hz - frequencies = ( - 1 - / 0.00437 - * np.sign(erb_points) - * (np.exp(np.abs(erb_points) / 9.2645) - 1) - ) - - return frequencies - - def true_peak_level( signal: Signal | MultiBandSignal, ) -> tuple[NDArray[np.float64], NDArray[np.float64]]: diff --git a/dsptoolbox/tools.py b/dsptoolbox/tools.py index cb4bb02..307d766 100644 --- a/dsptoolbox/tools.py +++ b/dsptoolbox/tools.py @@ -16,6 +16,11 @@ _time_smoothing as time_smoothing, ) +from ._standard import ( + _center_frequencies_fractional_octaves_iec, + _exact_center_frequencies_fractional_octaves, +) + def log_frequency_vector( frequency_range_hz: list[float], n_bins_per_octave: int @@ -229,6 +234,172 @@ def func(x: float | NDArray[np.float64]) -> float | NDArray[np.float64]: return func +def fractional_octave_frequencies( + num_fractions=1, frequency_range=(20, 20e3), return_cutoff=False +) -> ( + tuple[ + NDArray[np.float64], + NDArray[np.float64], + tuple[NDArray[np.float64], NDArray[np.float64]], + ] + | tuple[NDArray[np.float64], NDArray[np.float64]] +): + """Return the octave center frequencies according to the IEC 61260:1:2014 + standard. This implementation has been taken from the pyfar package. See + references. + + For numbers of fractions other than `1` and `3`, only the + exact center frequencies are returned, since nominal frequencies are not + specified by corresponding standards. + + Parameters + ---------- + num_fractions : int, optional + The number of bands an octave is divided into. Eg., ``1`` refers to + octave bands and ``3`` to third octave bands. The default is ``1``. + frequency_range : array, tuple + The lower and upper frequency limits, the default is + ``frequency_range=(20, 20e3)``. + + Returns + ------- + nominal : array, float + The nominal center frequencies in Hz specified in the standard. + Nominal frequencies are only returned for octave bands and third octave + bands. Otherwise, an empty array is returned. + exact : array, float + The exact center frequencies in Hz, resulting in a uniform distribution + of frequency bands over the frequency range. + cutoff_freq : tuple, array, float + The lower and upper critical frequencies in Hz of the bandpass filters + for each band as a tuple corresponding to `(f_lower, f_upper)`. + + References + ---------- + - The pyfar package: https://github.com/pyfar/pyfar + + """ + nominal = np.array([]) + + f_lims = np.asarray(frequency_range) + if f_lims.size != 2: + raise ValueError( + "You need to specify a lower and upper limit frequency." + ) + if f_lims[0] > f_lims[1]: + raise ValueError( + "The second frequency needs to be higher than the first." + ) + + if num_fractions in [1, 3]: + nominal, exact = _center_frequencies_fractional_octaves_iec( + nominal, num_fractions + ) + + mask = (nominal >= f_lims[0]) & (nominal <= f_lims[1]) + nominal = nominal[mask] + exact = exact[mask] + + else: + exact = _exact_center_frequencies_fractional_octaves( + num_fractions, f_lims + ) + + if return_cutoff: + octave_ratio = 10 ** (3 / 10) + freqs_upper = exact * octave_ratio ** (1 / 2 / num_fractions) + freqs_lower = exact * octave_ratio ** (-1 / 2 / num_fractions) + f_crit = (freqs_lower, freqs_upper) + return nominal, exact, f_crit + else: + return nominal, exact + + +def erb_frequencies( + freq_range_hz=[20, 20000], + resolution: float = 1, + reference_frequency_hz: float = 1000, +) -> NDArray[np.float64]: + """Get frequencies that are linearly spaced on the ERB frequency scale. + This implementation was taken and adapted from the pyfar package. See + references. + + Parameters + ---------- + freq_range : array-like, optional + The upper and lower frequency limits in Hz between which the frequency + vector is computed. Default: [20, 20e3]. + resolution : float, optional + The frequency resolution in ERB units. 1 returns frequencies that are + spaced by 1 ERB unit, a value of 0.5 would return frequencies that are + spaced by 0.5 ERB units. Default: 1. + reference_frequency : float, optional + The reference frequency in Hz relative to which the frequency vector + is constructed. Default: 1000. + + Returns + ------- + frequencies : NDArray[np.float64] + The frequencies in Hz that are linearly distributed on the ERB scale + with a spacing given by `resolution` ERB units. + + References + ---------- + - The pyfar package: https://github.com/pyfar/pyfar + - B. C. J. Moore, An introduction to the psychology of hearing, + (Leiden, Boston, Brill, 2013), 6th ed. + - V. Hohmann, “Frequency analysis and synthesis using a gammatone + filterbank,” Acta Acust. united Ac. 88, 433-442 (2002). + - P. L. Søndergaard, and P. Majdak, “The auditory modeling toolbox,” + in The technology of binaural listening, edited by J. Blauert + (Heidelberg et al., Springer, 2013) pp. 33-56. + + """ + + # check input + if ( + not isinstance(freq_range_hz, (list, tuple, np.ndarray)) + or len(freq_range_hz) != 2 + ): + raise ValueError("freq_range must be an array like of length 2") + if freq_range_hz[0] > freq_range_hz[1]: + freq_range_hz = [freq_range_hz[1], freq_range_hz[0]] + if resolution <= 0: + raise ValueError("Resolution must be larger than zero") + + # convert the frequency range and reference to ERB scale + # (Hohmann 2002, Eq. 16) + erb_range = ( + 9.2645 + * np.sign(freq_range_hz) + * np.log(1 + np.abs(freq_range_hz) * 0.00437) + ) + erb_ref = ( + 9.2645 + * np.sign(reference_frequency_hz) + * np.log(1 + np.abs(reference_frequency_hz) * 0.00437) + ) + + # get the referenced range + erb_ref_range = np.array([erb_ref - erb_range[0], erb_range[1] - erb_ref]) + + # construct the frequencies on the ERB scale + n_points = np.floor(erb_ref_range / resolution).astype(int) + erb_points = ( + np.arange(-n_points[0], n_points[1] + 1) * resolution + erb_ref + ) + + # convert to frequencies in Hz + frequencies = ( + 1 + / 0.00437 + * np.sign(erb_points) + * (np.exp(np.abs(erb_points) / 9.2645) - 1) + ) + + return frequencies + + __all__ = [ "fractional_octave_smoothing", "wrap_phase", @@ -241,4 +412,6 @@ def func(x: float | NDArray[np.float64]) -> float | NDArray[np.float64]: "get_exact_value_at_frequency", "log_mean", "frequency_crossover", + "erb_frequencies", + "fractional_octave_frequencies", ] diff --git a/tests/test_standard.py b/tests/test_standard.py index 57ed557..2af7d1e 100644 --- a/tests/test_standard.py +++ b/tests/test_standard.py @@ -156,10 +156,6 @@ def test_resample(self): # necessary to check... dsp.resample(self.audio_multi, desired_sampling_rate_hz=22050) - def test_fractional_octave_frequencies(self): - # Only functionality and not result is checked here - dsp.fractional_octave_frequencies() - def test_normalize(self): td = self.audio_multi.time_data n = dsp.normalize(self.audio_multi, peak_dbfs=-20) @@ -196,10 +192,6 @@ def test_fade(self): td[-fade_le:] *= np.linspace(1, 0, fade_le)[..., None] assert np.all(np.isclose(f_end.time_data, td)) - def test_erb_frequencies(self): - # Only functionality tested here - dsp.erb_frequencies() - def test_true_peak_level(self): # Only functionality is tested here dsp.true_peak_level(self.audio_multi) diff --git a/tests/test_tools.py b/tests/test_tools.py index 1bd82de..d52c187 100644 --- a/tests/test_tools.py +++ b/tests/test_tools.py @@ -13,3 +13,5 @@ def test_functionality(self): dsp.tools.from_db(x, True) dsp.tools.time_smoothing(x, 200, 0.1, None) dsp.tools.time_smoothing(x, 200, 0.1, 0.2) + dsp.tools.fractional_octave_frequencies() + dsp.tools.erb_frequencies() From 41417c12afbe46074a31bab55d40372ba3490692 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 23:00:05 +0200 Subject: [PATCH 19/35] made scale spectrum public in tools --- dsptoolbox/_general_helpers.py | 18 ++++++++++++------ dsptoolbox/tools.py | 2 ++ 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/dsptoolbox/_general_helpers.py b/dsptoolbox/_general_helpers.py index 27695e0..bbc029d 100644 --- a/dsptoolbox/_general_helpers.py +++ b/dsptoolbox/_general_helpers.py @@ -1107,32 +1107,38 @@ def _correct_for_real_phase_spectrum(phase_spectrum: NDArray[np.float64]): def _scale_spectrum( - spectrum: NDArray[np.float64], + spectrum: NDArray[np.float64] | NDArray[np.complex128], mode: str | None, time_length_samples: int, sampling_rate_hz: int, window: NDArray[np.float64] | None = None, ) -> NDArray[np.float64]: - """Scale the spectrum directly from the (unscaled) FFT. It is assumed that - the time data was not windowed. + """Scale the spectrum directly from the unscaled ("backward" normalization) + (R)FFT. If a window was applied, it is necessary to compute the right + scaling factor. Parameters ---------- - spectrum : NDArray[np.float64] + spectrum : NDArray[np.float64] | NDArray[np.complex128] Spectrum to scale. It is assumed that the frequency bins are along the first dimension. mode : str, None Type of scaling to use. `"power spectral density"`, `"power spectrum"`, `"amplitude spectral density"`, `"amplitude spectrum"`. Pass `None` - to avoid any scaling and return the same spectrum. + to avoid any scaling and return the same spectrum. Using a power + representation will returned the squared spectrum. time_length_samples : int Original length of the time data. sampling_rate_hz : int Sampling rate. + window : NDArray[np.float64], None, optional + Applied window when obtaining the spectrum. It is necessary to compute + the correct scaling factor. In case of None, "boxcar" window is + assumed. Default: None. Returns ------- - NDArray[np.float64] + NDArray[np.float64] | NDArray[np.complex128] Scaled spectrum Notes diff --git a/dsptoolbox/tools.py b/dsptoolbox/tools.py index 307d766..a11306d 100644 --- a/dsptoolbox/tools.py +++ b/dsptoolbox/tools.py @@ -14,6 +14,7 @@ _get_smoothing_factor_ema as get_smoothing_factor_ema, _interpolate_fr as interpolate_fr, _time_smoothing as time_smoothing, + _scale_spectrum as scale_spectrum, ) from ._standard import ( @@ -414,4 +415,5 @@ def erb_frequencies( "frequency_crossover", "erb_frequencies", "fractional_octave_frequencies", + "scale_spectrum", ] From 9344725ca5c5b8514db478d2b2c07273b4ec451c Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 23:00:25 +0200 Subject: [PATCH 20/35] made synchrosqueezing normalization optional --- dsptoolbox/transforms/_transforms.py | 18 +++++++++++++++--- dsptoolbox/transforms/transforms.py | 20 +++++++++++++++++++- 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/dsptoolbox/transforms/_transforms.py b/dsptoolbox/transforms/_transforms.py index 4a516df..2d03efc 100644 --- a/dsptoolbox/transforms/_transforms.py +++ b/dsptoolbox/transforms/_transforms.py @@ -229,6 +229,7 @@ def _squeeze_scalogram( freqs: NDArray[np.float64], fs: int, delta_w: float = 0.05, + apply_frequency_normalization: bool = False, ) -> NDArray[np.float64]: """Synchrosqueeze a scalogram. @@ -245,6 +246,10 @@ def _squeeze_scalogram( Maximum relative difference in frequency allowed in the phase transform for taking summing the result of the scalogram. If it's too small, it might lead to significant energy leaks. Default: 0.05. + apply_frequency_normalization : bool, optional + When `True`, each scale is scaled by taking into account the + normalization as shown in Eq. (2.4) of [1]. `False` does not apply + any normalization. Default: `False`. Returns ------- @@ -255,6 +260,8 @@ def _squeeze_scalogram( ---------- - https://dsp.stackexchange.com/questions/71398/synchrosqueezing-wavelet -transform-explanation + - [1]: Ingrid Daubechies, Jianfeng Lu, Hau-Tieng Wu. Synchrosqueezed + wavelet transforms: An empirical mode decomposition-like tool. 2011. """ scalpow = np.abs(scalogram) ** 2 @@ -270,8 +277,9 @@ def _squeeze_scalogram( ph *= fs # Scale to represent physical frequencies # Normalization factor - normalizations = 1 / (freqs / fs) # Scales - normalizations **= -3 / 2 + if apply_frequency_normalization: + normalizations = 1 / (freqs / fs) # Scales + normalizations **= -3 / 2 # Thresholds delta_f = delta_w * freqs @@ -284,7 +292,11 @@ def _squeeze_scalogram( ind = np.argmin(diff) if diff[ind] > delta_f[f]: continue - sync[ind, t, ch] += scalogram[f, t, ch] * normalizations[f] + if apply_frequency_normalization: + sync[ind, t, ch] += scalogram[f, t, ch] * normalizations[f] + continue + + sync[ind, t, ch] += scalogram[f, t, ch] return sync diff --git a/dsptoolbox/transforms/transforms.py b/dsptoolbox/transforms/transforms.py index b31125a..ef05aef 100644 --- a/dsptoolbox/transforms/transforms.py +++ b/dsptoolbox/transforms/transforms.py @@ -656,6 +656,7 @@ def cwt( wavelet: Wavelet | MorletWavelet, channel: NDArray[np.float64] | None = None, synchrosqueezed: bool = False, + apply_synchrosqueezed_normalization: bool = False, ) -> NDArray[np.complex128]: """Returns a scalogram by means of the continuous wavelet transform. @@ -674,6 +675,11 @@ def cwt( synchrosqueezed : bool, optional When `True`, the scalogram is synchrosqueezed using the phase transform. Default: `False`. + apply_synchrosqueezed_normalization : bool, optional + When `True`, each scale is scaled by taking into account the + normalization as shown in Eq. (2.4) of [1]. `False` does not apply + any normalization. This is only done for synchrosqueezed scalograms. + Default: `False`. Returns ------- @@ -685,6 +691,14 @@ def cwt( ----- - Zero-padding in the beginning is done for reducing boundary effects. + References + ---------- + - [1]: Ingrid Daubechies, Jianfeng Lu, Hau-Tieng Wu. Synchrosqueezed + wavelet transforms: An empirical mode decomposition-like tool. 2011. + - General information about synchrosqueezing: + https://dsp.stackexchange.com/questions/71398/synchrosqueezing-wavelet + -transform-explanation + """ if channel is None: channel = np.arange(signal.number_of_channels) @@ -697,6 +711,7 @@ def cwt( for ind_f, f in enumerate(frequencies): wv = np.array(wavelet.get_wavelet(f, signal.sampling_rate_hz)) + wv /= np.abs(wv).sum() scalogram[ind_f, ...] = oaconvolve( td, wv[..., None], axes=0, mode="same" @@ -704,7 +719,10 @@ def cwt( if synchrosqueezed: scalogram = _squeeze_scalogram( - scalogram, frequencies, signal.sampling_rate_hz + scalogram, + frequencies, + signal.sampling_rate_hz, + apply_frequency_normalization=apply_synchrosqueezed_normalization, ) return scalogram From 5b3e6ea3ea95260adc9b28fa491dcb8251598075 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 23:00:47 +0200 Subject: [PATCH 21/35] bug fix for plotting in signal --- dsptoolbox/classes/signal_class.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dsptoolbox/classes/signal_class.py b/dsptoolbox/classes/signal_class.py index 9d1bc9d..f053184 100644 --- a/dsptoolbox/classes/signal_class.py +++ b/dsptoolbox/classes/signal_class.py @@ -1314,6 +1314,7 @@ def plot_spectrogram( factor = 10 else: factor = 20 + zlabel = "dBFS" else: factor = 20 zlabel = "dBFS" @@ -1322,7 +1323,7 @@ def plot_spectrogram( if self.calibrated_signal: stft_db -= 20 * np.log10(2e-5) - zlabel = "dB" + zlabel = "dB(SPL)" stft_db = np.nan_to_num(stft_db, nan=np.min(stft_db)) fig, ax = general_matrix_plot( From 4adefca742b8c51fa6c562d5040e3d56b6aff33b Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 23:01:18 +0200 Subject: [PATCH 22/35] added constructors for filter --- dsptoolbox/classes/filter_class.py | 257 +++++++++++++++++++++++++---- 1 file changed, 222 insertions(+), 35 deletions(-) diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py index 6ad31f4..5d4c207 100644 --- a/dsptoolbox/classes/filter_class.py +++ b/dsptoolbox/classes/filter_class.py @@ -10,7 +10,7 @@ from matplotlib.figure import Figure from matplotlib.axes import Axes import scipy.signal as sig -from numpy.typing import NDArray +from numpy.typing import NDArray, ArrayLike from .signal_class import Signal from ._filter import ( @@ -51,13 +51,13 @@ def __init__( `scipy.signal.firwin` and `_biquad_coefficients`. See down below for the parameters needed for creating the filters. Alternatively, you can pass directly the filter coefficients while setting - `filter_type = 'other'`. + `filter_type = "other"`. Parameters ---------- filter_type : str, optional - String defining the filter type. Options are `'iir'`, `'fir'`, - `'biquad'` or `'other'`. Default: creates a dummy biquad bell + String defining the filter type. Options are `"iir"`, `"fir"`, + `"biquad"` or `"other"`. Default: creates a dummy biquad bell filter with no gain. filter_configuration : dict, optional Dictionary containing configuration for the filter. @@ -73,31 +73,31 @@ def __init__( filter_id (optional). - order (int): Filter order - - freqs (float, array-like): array with len 2 when 'bandpass' - or 'bandstop'. - - type_of_pass (str): 'bandpass', 'lowpass', 'highpass', - 'bandstop'. - - filter_design_method (str): Default: 'butter'. Supported methods - are: 'butter', 'bessel', 'ellip', 'cheby1', 'cheby2'. - - bandpass_ripple (float): maximum bandpass ripple in dB for - 'ellip' and 'cheby1'. + - freqs (float, array-like): array with len 2 when "bandpass" + or "bandstop". + - type_of_pass (str): "bandpass", "lowpass", "highpass", + "bandstop". + - filter_design_method (str): Default: "butter". Supported methods + are: "butter", "bessel", "ellip", "cheby1", "cheby2". + - passband_ripple (float): maximum bandpass ripple in dB for + "ellip" and "cheby1". - stopband_ripple (float): maximum stopband ripple in dB for - 'ellip' and 'cheby2'. + "ellip" and "cheby2". For `fir`: Keys: order, freqs, type_of_pass, filter_design_method (optional), - width (optional, necessary for 'kaiser'), filter_id (optional). + width (optional, necessary for "kaiser"), filter_id (optional). - order (int): Filter order, i.e., number of taps - 1. - - freqs (float, array-like): array with len 2 when 'bandpass' - or 'bandstop'. - - type_of_pass (str): 'bandpass', 'lowpass', 'highpass', - 'bandstop'. + - freqs (float, array-like): array with len 2 when "bandpass" + or "bandstop". + - type_of_pass (str): "bandpass", "lowpass", "highpass", + "bandstop". - filter_design_method (str): Window to be used. Default: - 'hamming'. Supported types are: 'boxcar', 'triang', - 'blackman', 'hamming', 'hann', 'bartlett', 'flattop', - 'parzen', 'bohman', 'blackmanharris', 'nuttall', 'barthann', - 'cosine', 'exponential', 'tukey', 'taylor'. + "hamming". Supported types are: "boxcar", "triang", + "blackman", "hamming", "hann", "bartlett", "flattop", + "parzen", "bohman", "blackmanharris", "nuttall", "barthann", + "cosine", "exponential", "tukey", "taylor". - width (float): estimated width of transition region in Hz for kaiser window. Default: `None`. @@ -137,6 +137,193 @@ def __init__( } self.set_filter_parameters(filter_type.lower(), filter_configuration) + @staticmethod + def iir_design( + order: int, + frequency_hz: float | ArrayLike[np.float64 | float], + type_of_pass: str, + filter_design_method: str, + passband_ripple_db: float | None = None, + stopband_ripple_db: float | None = None, + sampling_rate_hz: int | None = None, + ): + """Return an IIR filter using `scipy.signal.iirfilter`. IIR are + always implemented as SOS by default. + + Parameters + ---------- + order : int + Filter order. + frequency_hz : float | ArrayLike[np.float64 | float] + Frequency or frequencies of the filter in Hz. + type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} + Type of filter. + filter_design_method : str, {"butter", "bessel", "ellip", "cheby1",\ + "cheby2"} + Design method for the IIR filter. + passband_ripple_db : float, None, optional + Passband ripple in dB for "cheby1" and "ellip". Default: None. + stopband_ripple_db : float, None, optional + Passband ripple in dB for "cheby2" and "ellip". Default: None. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter( + "iir", + { + "order": order, + "freqs": frequency_hz, + "type_of_pass": type_of_pass, + "filter_design_method": filter_design_method, + "passband_ripple": passband_ripple_db, + "stopband_ripple": stopband_ripple_db, + }, + sampling_rate_hz, + ) + + @staticmethod + def biquad( + eq_type: str, + frequency_hz: float | ArrayLike[np.float64 | float], + gain_db: float, + q: float, + sampling_rate_hz: int, + ): + """Return a biquad filter according to [1]. + + Parameters + ---------- + eq_type : str, {"peaking", "lowpass", "highpass", "bandpass_skirt",\ + "bandpass_peak", "notch", "allpass", "lowshelf", "highshelf"} + EQ type. + frequency_hz : float + Frequency of the biquad in Hz. + gain_db : float + Gain of biquad in dB. + q : float + Quality factor. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + Reference + --------- + - [1]: https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq- + cookbook.html. + + """ + return Filter( + "biquad", + { + "eq_type": eq_type, + "freqs": frequency_hz, + "gain": gain_db, + "q": q, + }, + sampling_rate_hz, + ) + + @staticmethod + def fir_design( + order: int, + frequency_hz: float | ArrayLike[np.float64 | float], + type_of_pass: str, + filter_design_method: str, + width_hz: float | None = None, + sampling_rate_hz: int | None = None, + ): + """Design an FIR filter using `scipy.signal.firwin`. + + Parameters + ---------- + order : int + Filter order. It corresponds to the number of taps - 1. + frequency_hz : float | ArrayLike[np.float64 | float] + Frequency or frequencies of the filter in Hz. + type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} + Type of filter. + filter_design_method : str, {"boxcar", "triang",\ + "blackman", "hamming", "hann", "bartlett", "flattop",\ + "parzen", "bohman", "blackmanharris", "nuttall", "barthann",\ + "cosine", "exponential", "tukey", "taylor"} + Design method for the FIR filter. + width_hz : float, None, optional + estimated width of transition region in Hz for kaiser window. + Default: `None`. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter( + "fir", + { + "order": order, + "freqs": frequency_hz, + "type_of_pass": type_of_pass, + "filter_design_method": filter_design_method, + "width": width_hz, + }, + sampling_rate_hz, + ) + + @staticmethod + def from_ba( + b: ArrayLike[np.float64 | float], + a: ArrayLike[np.float64 | float], + sampling_rate_hz: int, + ): + """Create a filter from some b (numerator) and a (denominator) + coefficients. + + Parameters + ---------- + b : ArrayLike[np.float64 | float] + Numerator coefficients. + a : ArrayLike[np.float64 | float] + Denominator coefficients. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter("other", {"ba": [b, a]}, sampling_rate_hz) + + @staticmethod + def from_sos( + sos: NDArray[np.float64], + sampling_rate_hz: int, + ): + """Create a filter from second-order sections. + + Parameters + ---------- + sos : NDArray[np.float64] + Second-order sections. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter("other", {"sos": sos}, sampling_rate_hz) + def initialize_zi(self, number_of_channels: int = 1): """Initializes zi for steady-state filtering. The number of parallel zi's can be defined externally. @@ -388,8 +575,8 @@ def set_filter_parameters( if filter_type == "iir": if "filter_design_method" not in filter_configuration: filter_configuration["filter_design_method"] = "butter" - if "bandpass_ripple" not in filter_configuration: - filter_configuration["bandpass_ripple"] = None + if "passband_ripple" not in filter_configuration: + filter_configuration["passband_ripple"] = None if "stopband_ripple" not in filter_configuration: filter_configuration["stopband_ripple"] = None self.sos = sig.iirfilter( @@ -399,7 +586,7 @@ def set_filter_parameters( analog=False, fs=self.sampling_rate_hz, ftype=filter_configuration["filter_design_method"], - rp=filter_configuration["bandpass_ripple"], + rp=filter_configuration["passband_ripple"], rs=filter_configuration["stopband_ripple"], output="sos", ) @@ -516,7 +703,7 @@ def get_filter_metadata(self): def _get_metadata_string(self): """Helper for creating a string containing all filter info.""" - txt = f"""Filter – ID: {self.info['filter_id']}\n""" + txt = f"""Filter – ID: {self.info["filter_id"]}\n""" temp = "" for n in range(len(txt)): temp += "-" @@ -524,7 +711,7 @@ def _get_metadata_string(self): for k in self.info.keys(): if k == "ba": continue - txt += f"""{str(k).replace('_', ' '). + txt += f"""{str(k).replace("_", " "). capitalize()}: {self.info[k]}\n""" return txt @@ -628,16 +815,16 @@ def get_coefficients( Parameters ---------- mode : str, optional - Type of filter coefficients to be returned. Choose from `'sos'`, - `'ba'` or `'zpk'`. Default: `'sos'`. + Type of filter coefficients to be returned. Choose from `"sos"`, + `"ba"` or `"zpk"`. Default: `"sos"`. Returns ------- coefficients : array-like Array with filter coefficients with shape depending on mode: - - `'ba'`: list(b, a) with b and a of type NDArray[np.float64]. - - `'sos'`: NDArray[np.float64] with shape (n_sections, 6). - - `'zpk'`: tuple(z, p, k) with z, p, k of type NDArray[np.float64] + - `"ba"`: list(b, a) with b and a of type NDArray[np.float64]. + - `"sos"`: NDArray[np.float64] with shape (n_sections, 6). + - `"zpk"`: tuple(z, p, k) with z, p, k of type NDArray[np.float64] - Return `None` if user decides that ba->sos is too costly. The threshold is for filters with order > 500. @@ -714,8 +901,8 @@ def plot_magnitude( Range for which to plot the magnitude response. Default: [20, 20000]. normalize : str, optional - Mode for normalization, supported are `'1k'` for normalization - with value at frequency 1 kHz or `'max'` for normalization with + Mode for normalization, supported are `"1k"` for normalization + with value at frequency 1 kHz or `"max"` for normalization with maximal value. Use `None` for no normalization. Default: `None`. show_info_box : bool, optional Shows an information box on the plot. Default: `True`. @@ -934,7 +1121,7 @@ def save_filter(self, path: str = "filter"): path : str, optional Path for the filter to be saved. Use only folder1/folder2/name (it can be passed with .pkl at the end or without it). - Default: `'filter'` (local folder, object named filter). + Default: `"filter"` (local folder, object named filter). """ path = _check_format_in_path(path, "pkl") From 60f6c4197206079ab4577a308aa1389ae6d95fed Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Tue, 30 Jul 2024 23:54:20 +0200 Subject: [PATCH 23/35] documentation fixes --- dsptoolbox/classes/filter_class.py | 38 +++++++++++++-------------- dsptoolbox/classes/multibandsignal.py | 5 +++- 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py index 5d4c207..52ab759 100644 --- a/dsptoolbox/classes/filter_class.py +++ b/dsptoolbox/classes/filter_class.py @@ -79,10 +79,10 @@ def __init__( "bandstop". - filter_design_method (str): Default: "butter". Supported methods are: "butter", "bessel", "ellip", "cheby1", "cheby2". - - passband_ripple (float): maximum bandpass ripple in dB for + - passband_ripple (float): maximum passband ripple in dB for "ellip" and "cheby1". - - stopband_ripple (float): maximum stopband ripple in dB for - "ellip" and "cheby2". + - stopband_attenuation (float): minimum stopband attenuation in dB + for "ellip" and "cheby2". For `fir`: Keys: order, freqs, type_of_pass, filter_design_method (optional), @@ -140,21 +140,21 @@ def __init__( @staticmethod def iir_design( order: int, - frequency_hz: float | ArrayLike[np.float64 | float], + frequency_hz: float | ArrayLike, type_of_pass: str, filter_design_method: str, passband_ripple_db: float | None = None, - stopband_ripple_db: float | None = None, + stopband_attenuation_db: float | None = None, sampling_rate_hz: int | None = None, ): - """Return an IIR filter using `scipy.signal.iirfilter`. IIR are + """Return an IIR filter using `scipy.signal.iirfilter`. IIR filters are always implemented as SOS by default. Parameters ---------- order : int Filter order. - frequency_hz : float | ArrayLike[np.float64 | float] + frequency_hz : float | ArrayLike Frequency or frequencies of the filter in Hz. type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} Type of filter. @@ -163,7 +163,7 @@ def iir_design( Design method for the IIR filter. passband_ripple_db : float, None, optional Passband ripple in dB for "cheby1" and "ellip". Default: None. - stopband_ripple_db : float, None, optional + stopband_attenuation_db : float, None, optional Passband ripple in dB for "cheby2" and "ellip". Default: None. sampling_rate_hz : int Sampling rate in Hz. @@ -181,7 +181,7 @@ def iir_design( "type_of_pass": type_of_pass, "filter_design_method": filter_design_method, "passband_ripple": passband_ripple_db, - "stopband_ripple": stopband_ripple_db, + "stopband_attenuation": stopband_attenuation_db, }, sampling_rate_hz, ) @@ -189,7 +189,7 @@ def iir_design( @staticmethod def biquad( eq_type: str, - frequency_hz: float | ArrayLike[np.float64 | float], + frequency_hz: float | ArrayLike, gain_db: float, q: float, sampling_rate_hz: int, @@ -234,7 +234,7 @@ def biquad( @staticmethod def fir_design( order: int, - frequency_hz: float | ArrayLike[np.float64 | float], + frequency_hz: float | ArrayLike, type_of_pass: str, filter_design_method: str, width_hz: float | None = None, @@ -246,7 +246,7 @@ def fir_design( ---------- order : int Filter order. It corresponds to the number of taps - 1. - frequency_hz : float | ArrayLike[np.float64 | float] + frequency_hz : float | ArrayLike Frequency or frequencies of the filter in Hz. type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} Type of filter. @@ -280,8 +280,8 @@ def fir_design( @staticmethod def from_ba( - b: ArrayLike[np.float64 | float], - a: ArrayLike[np.float64 | float], + b: ArrayLike, + a: ArrayLike, sampling_rate_hz: int, ): """Create a filter from some b (numerator) and a (denominator) @@ -289,9 +289,9 @@ def from_ba( Parameters ---------- - b : ArrayLike[np.float64 | float] + b : ArrayLike Numerator coefficients. - a : ArrayLike[np.float64 | float] + a : ArrayLike Denominator coefficients. sampling_rate_hz : int Sampling rate in Hz. @@ -577,8 +577,8 @@ def set_filter_parameters( filter_configuration["filter_design_method"] = "butter" if "passband_ripple" not in filter_configuration: filter_configuration["passband_ripple"] = None - if "stopband_ripple" not in filter_configuration: - filter_configuration["stopband_ripple"] = None + if "stopband_attenuation" not in filter_configuration: + filter_configuration["stopband_attenuation"] = None self.sos = sig.iirfilter( N=filter_configuration["order"], Wn=filter_configuration["freqs"], @@ -587,7 +587,7 @@ def set_filter_parameters( fs=self.sampling_rate_hz, ftype=filter_configuration["filter_design_method"], rp=filter_configuration["passband_ripple"], - rs=filter_configuration["stopband_ripple"], + rs=filter_configuration["stopband_attenuation"], output="sos", ) self.filter_type = filter_type diff --git a/dsptoolbox/classes/multibandsignal.py b/dsptoolbox/classes/multibandsignal.py index 49f0093..96b030f 100644 --- a/dsptoolbox/classes/multibandsignal.py +++ b/dsptoolbox/classes/multibandsignal.py @@ -370,12 +370,15 @@ def get_all_time_data( Returns ------- - if `same_sampling_rate` : + if `self.same_sampling_rate=True` : + time_data : NDArray[np.float64] Time samples. int Sampling rate in Hz + else : + list[tuple[NDArray[np.float64], int]] List with each band where time samples and sampling rate are contained. From 11e65954883264b7d54c1ebb9598a47c29f6622f Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 01:24:04 +0200 Subject: [PATCH 24/35] got rid of signal ID --- dsptoolbox/classes/signal_class.py | 35 +++++++++---------- dsptoolbox/generators/generators.py | 6 +--- dsptoolbox/room_acoustics/room_acoustics.py | 9 +---- dsptoolbox/standard_functions.py | 2 -- .../transfer_functions/transfer_functions.py | 6 +--- examples/general.ipynb | 5 ++- tests/test_classes.py | 9 ----- 7 files changed, 21 insertions(+), 51 deletions(-) diff --git a/dsptoolbox/classes/signal_class.py b/dsptoolbox/classes/signal_class.py index f053184..9fb59ec 100644 --- a/dsptoolbox/classes/signal_class.py +++ b/dsptoolbox/classes/signal_class.py @@ -42,7 +42,6 @@ def __init__( time_data=None, sampling_rate_hz: int | None = None, signal_type: str = "general", - signal_id: str = "", constrain_amplitude: bool = True, ): """Signal class that saves time data, channel and sampling rate @@ -62,9 +61,6 @@ def __init__( A generic signal type. Some functionalities are only unlocked for signal types `'ir'`, `'h1'`, `'h2'`, `'h3'`, `'rir'`, `'chirp'`, `'noise'` or `'dirac'`. Default: `'general'`. - signal_id : str, optional - An even more generic signal id that can be set by the user. - Default: `''`. constrain_amplitude : bool, optional When `True`, audio is normalized to 0 dBFS peak level in case that there are amplitude values greater than 1. Otherwise, there is no @@ -92,7 +88,6 @@ def __init__( set_window, set_coherence, plot_group_delay, plot_coherence. """ - self.signal_id = signal_id self.signal_type = signal_type # Handling amplitude self.constrain_amplitude = constrain_amplitude @@ -132,6 +127,22 @@ def __init__( self.set_spectrogram_parameters() self._generate_metadata() + @staticmethod + def from_file(path: str): + """Create a signal from a path to a wav or flac audio file. + + Parameters + ---------- + path : str + Path to file. + + Returns + ------- + Signal + + """ + return Signal(path) + def __update_state(self): """Internal update of object state. If for instance time data gets added, new spectrum, csm or stft has to be computed. @@ -157,7 +168,6 @@ def _generate_metadata(self): self.time_data.shape[0] / self.sampling_rate_hz ) self.info["signal_type"] = self.signal_type - self.info["signal_id"] = self.signal_id def _generate_time_vector(self): """Internal method to generate a time vector on demand.""" @@ -241,15 +251,6 @@ def signal_type(self, new_signal_type): assert type(new_signal_type) is str, "Signal type must be a string" self.__signal_type = new_signal_type.lower() - @property - def signal_id(self) -> str: - return self.__signal_id - - @signal_id.setter - def signal_id(self, new_signal_id: str): - assert type(new_signal_id) is str, "Signal ID must be a string" - self.__signal_id = new_signal_id.lower() - @property def number_of_channels(self) -> int: return self.__number_of_channels @@ -1534,14 +1535,11 @@ def copy(self): def _get_metadata_string(self) -> str: """Helper for creating a string containing all signal info.""" - txt = f"""Signal – ID: {self.info['signal_id']}\n""" temp = "" for n in range(len(txt)): temp += "-" txt += temp + "\n" for k in self.info.keys(): - if k == "signal_id": - continue txt += f"""{str(k).replace('_', ' '). capitalize()}: {self.info[k]}\n""" return txt @@ -1613,7 +1611,6 @@ def stream_samples(self, blocksize_samples: int, signal_mode: bool = True): sig, self.sampling_rate_hz, self.signal_type, - self.signal_id, ) # In an audio stream, welch's method for acquiring a spectrum # is not very logical... diff --git a/dsptoolbox/generators/generators.py b/dsptoolbox/generators/generators.py index c7f76c3..c278bd9 100644 --- a/dsptoolbox/generators/generators.py +++ b/dsptoolbox/generators/generators.py @@ -126,10 +126,7 @@ def noise( ) time_data[:l_samples, :] = vec - id = type_of_noise.lower() + " noise" - noise_sig = Signal( - None, time_data, sampling_rate_hz, signal_type="noise", signal_id=id - ) + noise_sig = Signal(None, time_data, sampling_rate_hz, signal_type="noise") return noise_sig @@ -250,7 +247,6 @@ def chirp( chirp_n, sampling_rate_hz, signal_type="chirp", - signal_id=type_of_chirp, ) return chirp_sig diff --git a/dsptoolbox/room_acoustics/room_acoustics.py b/dsptoolbox/room_acoustics/room_acoustics.py index 474411e..e783ee5 100644 --- a/dsptoolbox/room_acoustics/room_acoustics.py +++ b/dsptoolbox/room_acoustics/room_acoustics.py @@ -269,7 +269,6 @@ def convolve_rir_on_signal( new_sig = signal.copy() new_sig.time_data = new_time_data - new_sig.signal_id += " (convolved with RIR)" return new_sig @@ -447,13 +446,7 @@ def generate_synthetic_rir( rir, room.mixing_time_s, room.t60_s, sr=sampling_rate_hz ) - rir_output = Signal( - None, - rir, - sampling_rate_hz, - signal_type="rir", - signal_id="Synthetized RIR using the image source method", - ) + rir_output = Signal(None, rir, sampling_rate_hz, signal_type="rir") # Bandpass signal in order to have a realistic audio signal representation if apply_bandpass: diff --git a/dsptoolbox/standard_functions.py b/dsptoolbox/standard_functions.py index 1b71882..373c806 100644 --- a/dsptoolbox/standard_functions.py +++ b/dsptoolbox/standard_functions.py @@ -1043,7 +1043,6 @@ def calibrate_signal( if isinstance(signal, Signal): calibrated_signal = signal.copy() - calibrated_signal.signal_id += " – Calibrated (time data in Pa)" calibrated_signal.constrain_amplitude = False calibrated_signal.time_data *= calibration_factors calibrated_signal.calibrated_signal = True @@ -1052,7 +1051,6 @@ def calibrate_signal( for b in calibrated_signal: b.constrain_amplitude = False b.time_data *= calibration_factors - b.signal_id += " – Calibrated (time data in Pa)" b.calibrated_signal = True else: raise TypeError( diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index bcdf78f..0f98fdf 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -1237,11 +1237,7 @@ def filter_to_ir(fir: Filter) -> Signal: ), "This is only valid is only available for FIR filters" b, _ = fir.get_coefficients(mode="ba") new_sig = Signal( - None, - b, - sampling_rate_hz=fir.sampling_rate_hz, - signal_type="ir", - signal_id="IR from FIR filter", + None, b, sampling_rate_hz=fir.sampling_rate_hz, signal_type="ir" ) return new_sig diff --git a/examples/general.ipynb b/examples/general.ipynb index 5a28516..f15ab10 100644 --- a/examples/general.ipynb +++ b/examples/general.ipynb @@ -59,7 +59,7 @@ " path=join('data', 'speech.flac'), time_data=None, sampling_rate_hz=None,\n", " # Optional parameters:\n", " signal_type='general', # Type of signal\n", - " signal_id='here is some random info or id about the signal')\n", + ")\n", "# If a path is given, time_data and sampling rate should be set to None\n", "\n", "# If you already have time data as vector, it can be passed to Signal \n", @@ -91,8 +91,7 @@ "Note:\n", "- The `time_data` attribute is a numpy vector with shape (time_samples, channels). Even when the passed data is trasposed, the constructor assumes that the longest dimension contains the time samples and inverts the array.\n", "- lists and tuples can also be passed, but every element should have the same length since it is a requirement to convert them into numpy arrays.\n", - "- `signal_type` is a marker (string) for the signal. Default types are `'ir'` (impulse response), `'h1'` (transfer function of type $H_1$), `'h2'`, `'h3'` or `'rir'` (room impulse response). Some functionalities like plotting group delay are only valid for these types. See documentation for details.\n", - "- `signal_id` is a placeholder for the user to save metadata about the object." + "- `signal_type` is a marker (string) for the signal. Default types are `'ir'` (impulse response), `'h1'` (transfer function of type $H_1$), `'h2'`, `'h3'` or `'rir'` (room impulse response). Some functionalities like plotting group delay are only valid for these types. See documentation for details." ] }, { diff --git a/tests/test_classes.py b/tests/test_classes.py index f3199c8..0d5c3ca 100644 --- a/tests/test_classes.py +++ b/tests/test_classes.py @@ -165,15 +165,6 @@ def test_setting_properties(self): with pytest.raises(AssertionError): s.signal_type = 15 - # Signal ID - typ = "test signal" - s.signal_id = typ - assert s.signal_id == typ - - # Setting a wrong signal id - with pytest.raises(AssertionError): - s.signal_id = True - # Number of channels is generated right assert s.number_of_channels == self.channels From 887c6ad9bef06c1c1c810c246eb77690afd69fa3 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 02:14:54 +0200 Subject: [PATCH 25/35] flake8 config --- tox.ini | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 tox.ini diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..7f34500 --- /dev/null +++ b/tox.ini @@ -0,0 +1,2 @@ +[flake8] +ignore = E203 From c647371b101ab1a6596e5855be72f64581b98226 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 02:15:20 +0200 Subject: [PATCH 26/35] renamed some files, first attempt impulse response --- dsptoolbox/__init__.py | 2 + dsptoolbox/classes/__init__.py | 6 +- dsptoolbox/classes/{_filter.py => filter.py} | 2 +- dsptoolbox/classes/filter_class.py | 6 +- dsptoolbox/classes/filterbank.py | 4 +- dsptoolbox/classes/impulse_response.py | 195 ++++++++++++++++++ ...der_filter.py => lattice_ladder_filter.py} | 2 +- dsptoolbox/classes/multibandsignal.py | 14 +- ...phaseLinearizer.py => phase_linearizer.py} | 8 +- dsptoolbox/classes/{_plots.py => plots.py} | 1 + .../classes/{signal_class.py => signal.py} | 186 +---------------- .../classes/{_svfilter.py => sv_filter.py} | 11 +- dsptoolbox/filterbanks/__init__.py | 6 +- dsptoolbox/filterbanks/_filterbank.py | 9 +- dsptoolbox/filterbanks/filterbanks.py | 2 +- dsptoolbox/generators/generators.py | 23 +-- dsptoolbox/room_acoustics/room_acoustics.py | 24 +-- dsptoolbox/standard_functions.py | 1 - .../transfer_functions/transfer_functions.py | 145 ++++++------- dsptoolbox/transforms/transforms.py | 2 +- examples/distances_module.ipynb | 2 +- examples/general.ipynb | 12 +- examples/room_acoustics_module.ipynb | 2 +- examples/transforms_module.ipynb | 2 +- tests/test_classes.py | 19 +- tests/test_filterbanks.py | 4 +- tests/test_room_acoustics.py | 2 +- tests/test_transfer_functions.py | 21 +- 28 files changed, 334 insertions(+), 379 deletions(-) rename dsptoolbox/classes/{_filter.py => filter.py} (99%) create mode 100644 dsptoolbox/classes/impulse_response.py rename dsptoolbox/classes/{_lattice_ladder_filter.py => lattice_ladder_filter.py} (99%) rename dsptoolbox/classes/{_phaseLinearizer.py => phase_linearizer.py} (97%) rename dsptoolbox/classes/{_plots.py => plots.py} (99%) rename dsptoolbox/classes/{signal_class.py => signal.py} (89%) rename dsptoolbox/classes/{_svfilter.py => sv_filter.py} (96%) diff --git a/dsptoolbox/__init__.py b/dsptoolbox/__init__.py index 6e21d9d..571b0c4 100644 --- a/dsptoolbox/__init__.py +++ b/dsptoolbox/__init__.py @@ -20,6 +20,7 @@ Filter, FilterBank, Signal, + ImpulseResponse, MultiBandSignal, ) from . import transfer_functions @@ -37,6 +38,7 @@ __all__ = [ # Basic classes "Signal", + "ImpulseResponse", "MultiBandSignal", "Filter", "FilterBank", diff --git a/dsptoolbox/classes/__init__.py b/dsptoolbox/classes/__init__.py index 60739ac..1413ddc 100644 --- a/dsptoolbox/classes/__init__.py +++ b/dsptoolbox/classes/__init__.py @@ -5,6 +5,8 @@ - `Signal` (core class for all computations, it is constructed from time data and a sampling rate) +- `ImpulseResponse` (class containing a signal that characterizes a system's + response) - `MultiBandSignal` (signal with multiple bands and multirate capabilities) - `Filter` (filter class with filtering methods) - `FilterBank` (class containing a group of `Filters` and their metadata) @@ -13,12 +15,14 @@ from .filter_class import Filter from .filterbank import FilterBank -from .signal_class import Signal +from .signal import Signal +from .impulse_response import ImpulseResponse from .multibandsignal import MultiBandSignal __all__ = [ "Filter", "FilterBank", "Signal", + "ImpulseResponse", "MultiBandSignal", ] diff --git a/dsptoolbox/classes/_filter.py b/dsptoolbox/classes/filter.py similarity index 99% rename from dsptoolbox/classes/_filter.py rename to dsptoolbox/classes/filter.py index 0731373..e1aae14 100644 --- a/dsptoolbox/classes/_filter.py +++ b/dsptoolbox/classes/filter.py @@ -7,7 +7,7 @@ from enum import Enum import scipy.signal as sig from numpy.typing import NDArray -from .signal_class import Signal +from .signal import Signal from .multibandsignal import MultiBandSignal from .._general_helpers import _polyphase_decomposition diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py index 52ab759..8d6c5f2 100644 --- a/dsptoolbox/classes/filter_class.py +++ b/dsptoolbox/classes/filter_class.py @@ -12,8 +12,8 @@ import scipy.signal as sig from numpy.typing import NDArray, ArrayLike -from .signal_class import Signal -from ._filter import ( +from .signal import Signal +from .filter import ( _biquad_coefficients, _impulse, _group_delay_filter, @@ -23,7 +23,7 @@ _filter_and_downsample, _filter_and_upsample, ) -from ._plots import _zp_plot +from .plots import _zp_plot from ..plots import general_plot from .._general_helpers import _check_format_in_path, _pad_trim diff --git a/dsptoolbox/classes/filterbank.py b/dsptoolbox/classes/filterbank.py index 55ef6fe..68da857 100644 --- a/dsptoolbox/classes/filterbank.py +++ b/dsptoolbox/classes/filterbank.py @@ -6,10 +6,10 @@ from matplotlib.axes import Axes from numpy.typing import NDArray -from .signal_class import Signal +from .signal import Signal from .multibandsignal import MultiBandSignal from .filter_class import Filter -from ._filter import _filterbank_on_signal +from .filter import _filterbank_on_signal from ..generators import dirac from ..plots import general_plot from .._general_helpers import _get_normalized_spectrum, _check_format_in_path diff --git a/dsptoolbox/classes/impulse_response.py b/dsptoolbox/classes/impulse_response.py new file mode 100644 index 0000000..ca3801c --- /dev/null +++ b/dsptoolbox/classes/impulse_response.py @@ -0,0 +1,195 @@ +import numpy as np +from numpy.typing import NDArray +from matplotlib.figure import Figure +from matplotlib.axes import Axes + +from .signal import Signal +from ..plots import general_subplots_line + + +class ImpulseResponse(Signal): + def __init__( + self, + path: str, + time_data: NDArray[np.float64], + sampling_rate_hz: int, + constrain_amplitude: bool = True, + ): + """Impulse response.""" + super().__init__( + path, + time_data, + sampling_rate_hz, + constrain_amplitude=constrain_amplitude, + ) + self.set_spectrum_parameters(method="standard") + + def set_window(self, window: NDArray[np.float64]): + """Sets the window used for the IR. + + Parameters + ---------- + window : NDArray[np.float64] + Window used for the IR. + + """ + assert ( + window.shape == self.time_data.shape + ), f"{window.shape} does not match shape {self.time_data.shape}" + self.window = window + + def set_coherence(self, coherence: NDArray[np.float64]): + """Sets the coherence measurements of the transfer function. + It only works for `signal_type = ('ir', 'h1', 'h2', 'h3', 'rir')`. + + Parameters + ---------- + coherence : NDArray[np.float64] + Coherence matrix. + + """ + assert coherence.shape[0] == ( + self.time_data.shape[0] // 2 + 1 + ), "Length of signals and given coherence do not match" + assert coherence.shape[1] == self.number_of_channels, ( + "Number of channels between given coherence and signal " + + "does not match" + ) + self.coherence = coherence + + def get_coherence(self) -> tuple[NDArray[np.float64], NDArray[np.float64]]: + """Returns the coherence matrix. + + Returns + ------- + f : NDArray[np.float64] + Frequency vector. + coherence : NDArray[np.float64] + Coherence matrix. + + """ + assert hasattr( + self, "coherence" + ), "There is no coherence data saved in the Signal object" + f, _ = self.get_spectrum() + return f, self.coherence + + def plot_spl( + self, + normalize_at_peak: bool = False, + range_db: float | None = 100.0, + window_length_s: float = 0.0, + ) -> tuple[Figure, list[Axes]]: + """Plots the momentary sound pressure level (dB or dBFS) of each + channel. If the signal is calibrated and not normalized at peak, the + values correspond to dB, otherwise they are dBFS. + + Parameters + ---------- + normalize_at_peak : bool, optional + When `True`, each channel gets normalize by its peak value. + Default: `False`. + range_db : float, optional + This is the range in dB used for plotting. Each plot will be in the + range [peak + 1 - range_db, peak + 1]. Pass `None` to avoid setting + any range. Default: 100. + window_length_s : float, optional + When different than 0, a moving average along the time axis is done + with the given length. Default: 0. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : list of `matplotlib.axes.Axes` + Axes. + + Notes + ----- + - All values are clipped to be at least -800 dBFS. + - If it is an analytic signal and normalization is applied, the peak + value of the real part is used as the normalization factor. + - If the time window is not 0, effects at the edges of the signal might + be present due to zero-padding. + + """ + fig, ax = super().plot_spl() + + peak_values = 10 * np.log10(np.max(self.time_data**2.0, axis=0)) + + add_to_peak = 1 # Add 1 dB for better plotting + max_values = ( + peak_values + add_to_peak + if not normalize_at_peak + else np.ones(self.number_of_channels) + ) + + for n in range(self.number_of_channels): + if hasattr(self, "window"): + ax[n].plot( + self.time_vector_s, + 20 + * np.log10( + np.clip( + np.abs(self.window[:, n] / 1.1), + a_min=1e-40, + a_max=None, + ) + ) + + max_values[n], + alpha=0.75, + ) + return fig, ax + + def plot_time(self) -> tuple[Figure, list[Axes]]: + """Plots time signals. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : list of `matplotlib.axes.Axes` + Axes. + + """ + fig, ax = super().plot_time() + if hasattr(self, "window"): + mx = np.max(np.abs(self.time_data), axis=0) * 1.1 + + for n in range(self.number_of_channels): + ax[n].plot( + self.time_vector_s, + self.window[:, n] * mx[n] / 1.1, + alpha=0.75, + ) + return fig, ax + + def plot_coherence(self) -> tuple[Figure, list[Axes]]: + """Plots coherence measurements if there are any. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : list of `matplotlib.axes.Axes` + Axes. + + """ + if not hasattr(self, "coherence"): + raise AttributeError("There is no coherence data saved") + f, coh = self.get_coherence() + fig, ax = general_subplots_line( + x=f, + matrix=coh, + column=True, + sharey=True, + log=True, + ylabels=[ + rf"$\gamma^2$ Coherence {n}" + for n in range(self.number_of_channels) + ], + xlabels="Frequency / Hz", + range_y=[-0.1, 1.1], + returns=True, + ) + return fig, ax diff --git a/dsptoolbox/classes/_lattice_ladder_filter.py b/dsptoolbox/classes/lattice_ladder_filter.py similarity index 99% rename from dsptoolbox/classes/_lattice_ladder_filter.py rename to dsptoolbox/classes/lattice_ladder_filter.py index da52462..b9f8453 100644 --- a/dsptoolbox/classes/_lattice_ladder_filter.py +++ b/dsptoolbox/classes/lattice_ladder_filter.py @@ -2,7 +2,7 @@ This file contains alternative filter implementations. """ -from .signal_class import Signal +from .signal import Signal from warnings import warn import numpy as np from numpy.typing import NDArray diff --git a/dsptoolbox/classes/multibandsignal.py b/dsptoolbox/classes/multibandsignal.py index 96b030f..f38be77 100644 --- a/dsptoolbox/classes/multibandsignal.py +++ b/dsptoolbox/classes/multibandsignal.py @@ -5,7 +5,7 @@ from pickle import dump, HIGHEST_PROTOCOL from warnings import warn -from .signal_class import Signal +from .signal import Signal from .._general_helpers import _check_format_in_path @@ -89,7 +89,6 @@ def bands(self, new_bands): if new_bands: # Check length and number of channels self.number_of_channels = new_bands[0].number_of_channels - self.signal_type = new_bands[0].signal_type sr = [] complex_data = new_bands[0].time_data_imaginary is not None for s in new_bands: @@ -101,9 +100,6 @@ def bands(self, new_bands): "Signals have different number of channels. This " + "behaviour is not supported" ) - assert ( - s.signal_type == self.signal_type - ), "Signal types do not match" assert (s.time_data_imaginary is not None) == complex_data, ( "Some bands have imaginary time data and others do " + "not. This behavior is not supported." @@ -164,7 +160,6 @@ def _generate_metadata(self): self.info["number_of_bands"] = self.number_of_bands if self.bands: self.info["same_sampling_rate"] = self.same_sampling_rate - self.info["signal_type"] = self.signal_type if self.same_sampling_rate: if hasattr(self, "sampling_rate_hz"): self.info["sampling_rate_hz"] = self.sampling_rate_hz @@ -333,12 +328,7 @@ def get_all_bands( self.bands[n].time_data[:, channel] + self.bands[n].time_data_imaginary[:, channel] * 1j ) - sig = Signal( - None, - new_time_data, - self.sampling_rate_hz, - signal_type=self.signal_type, - ) + sig = Signal(None, new_time_data, self.sampling_rate_hz) return sig else: new_time_data = [] diff --git a/dsptoolbox/classes/_phaseLinearizer.py b/dsptoolbox/classes/phase_linearizer.py similarity index 97% rename from dsptoolbox/classes/_phaseLinearizer.py rename to dsptoolbox/classes/phase_linearizer.py index 0e3a8ab..8e41db1 100644 --- a/dsptoolbox/classes/_phaseLinearizer.py +++ b/dsptoolbox/classes/phase_linearizer.py @@ -1,5 +1,5 @@ from .filter_class import Filter -from .signal_class import Signal +from .impulse_response import ImpulseResponse import numpy as np from scipy.integrate import cumulative_trapezoid from scipy.interpolate import interp1d @@ -131,10 +131,8 @@ def get_filter(self) -> Filter: sampling_rate_hz=self.sampling_rate_hz, ) - def get_filter_as_ir(self) -> Signal: - return Signal( - None, self._design(), self.sampling_rate_hz, signal_type="ir" - ) + def get_filter_as_ir(self) -> ImpulseResponse: + return ImpulseResponse(None, self._design(), self.sampling_rate_hz) def _design(self) -> NDArray[np.float64]: """Compute filter.""" diff --git a/dsptoolbox/classes/_plots.py b/dsptoolbox/classes/plots.py similarity index 99% rename from dsptoolbox/classes/_plots.py rename to dsptoolbox/classes/plots.py index 6c85c7f..54c5892 100644 --- a/dsptoolbox/classes/_plots.py +++ b/dsptoolbox/classes/plots.py @@ -1,6 +1,7 @@ """ Very specific plots which are harder to create from the general templates """ + import matplotlib.pyplot as plt from matplotlib.ticker import ScalarFormatter import numpy as np diff --git a/dsptoolbox/classes/signal_class.py b/dsptoolbox/classes/signal.py similarity index 89% rename from dsptoolbox/classes/signal_class.py rename to dsptoolbox/classes/signal.py index 9fb59ec..50c8240 100644 --- a/dsptoolbox/classes/signal_class.py +++ b/dsptoolbox/classes/signal.py @@ -9,11 +9,11 @@ import soundfile as sf from matplotlib.figure import Figure from matplotlib.axes import Axes -from scipy.signal import convolve +from scipy.signal import oaconvolve from numpy.typing import NDArray from ..plots import general_plot, general_subplots_line, general_matrix_plot -from ._plots import _csm_plot +from .plots import _csm_plot from .._general_helpers import ( _get_normalized_spectrum, _pad_trim, @@ -41,7 +41,6 @@ def __init__( path: str | None = None, time_data=None, sampling_rate_hz: int | None = None, - signal_type: str = "general", constrain_amplitude: bool = True, ): """Signal class that saves time data, channel and sampling rate @@ -57,10 +56,6 @@ def __init__( (time samples, channel number). Default: `None`. sampling_rate_hz : int, optional Sampling rate of the signal in Hz. Default: `None`. - signal_type : str, optional - A generic signal type. Some functionalities are only unlocked for - signal types `'ir'`, `'h1'`, `'h2'`, `'h3'`, `'rir'`, `'chirp'`, - `'noise'` or `'dirac'`. Default: `'general'`. constrain_amplitude : bool, optional When `True`, audio is normalized to 0 dBFS peak level in case that there are amplitude values greater than 1. Otherwise, there is no @@ -84,11 +79,8 @@ def __init__( plot_csm. General: save_signal, get_stream_samples. - Only for `signal_type in ('rir', 'ir', 'h1', 'h2', 'h3')`: - set_window, set_coherence, plot_group_delay, plot_coherence. """ - self.signal_type = signal_type # Handling amplitude self.constrain_amplitude = constrain_amplitude self.scale_factor = None @@ -119,10 +111,7 @@ def __init__( ), "A sampling rate should be passed!" self.sampling_rate_hz = sampling_rate_hz self.time_data = time_data - if signal_type in ("rir", "ir", "h1", "h2", "h3", "chirp", "dirac"): - self.set_spectrum_parameters(method="standard", scaling=None) - else: - self.set_spectrum_parameters() + self.set_spectrum_parameters() self.set_csm_parameters() self.set_spectrogram_parameters() self._generate_metadata() @@ -167,7 +156,6 @@ def _generate_metadata(self): self.info["signal_length_seconds"] = ( self.time_data.shape[0] / self.sampling_rate_hz ) - self.info["signal_type"] = self.signal_type def _generate_time_vector(self): """Internal method to generate a time vector on demand.""" @@ -242,15 +230,6 @@ def sampling_rate_hz(self, new_sampling_rate_hz): ), "Sampling rate can only be an integer" self.__sampling_rate_hz = new_sampling_rate_hz - @property - def signal_type(self) -> str: - return self.__signal_type - - @signal_type.setter - def signal_type(self, new_signal_type): - assert type(new_signal_type) is str, "Signal type must be a string" - self.__signal_type = new_signal_type.lower() - @property def number_of_channels(self) -> int: return self.__number_of_channels @@ -373,14 +352,6 @@ def set_spectrum_parameters( "welch", "standard", ), f"{method} is not a valid method. Use welch or standard" - if self.signal_type in ("h1", "h2", "h3", "rir", "ir"): - if method != "standard": - method = "standard" - warn( - f"For a signal of type {self.signal_type} " - + "the spectrum has to be the standard one and not welch." - + " This has been automatically changed." - ) _new_spectrum_parameters = dict( method=method, smoothe=smoothe, @@ -403,50 +374,6 @@ def set_spectrum_parameters( self._spectrum_parameters = _new_spectrum_parameters self.__spectrum_state_update = True - def set_window(self, window: NDArray[np.float64]): - """Sets the window used for the IR. It only works for - `signal_type in ('ir', 'h1', 'h2', 'h3', 'rir')`. - - Parameters - ---------- - window : NDArray[np.float64] - Window used for the IR. - - """ - valid_signal_types = ("ir", "h1", "h2", "h3", "rir") - assert self.signal_type in valid_signal_types, ( - f"{self.signal_type} is not valid. Please set it to ir or " - + "h1, h2, h3, rir" - ) - assert ( - window.shape == self.time_data.shape - ), f"{window.shape} does not match shape {self.time_data.shape}" - self.window = window - - def set_coherence(self, coherence: NDArray[np.float64]): - """Sets the coherence measurements of the transfer function. - It only works for `signal_type = ('ir', 'h1', 'h2', 'h3', 'rir')`. - - Parameters - ---------- - coherence : NDArray[np.float64] - Coherence matrix. - - """ - valid_signal_types = ("ir", "h1", "h2", "h3", "rir") - assert self.signal_type in valid_signal_types, ( - f"{self.signal_type} is not valid. Please set it to ir or " - + "h1, h2, h3, rir" - ) - assert coherence.shape[0] == ( - self.time_data.shape[0] // 2 + 1 - ), "Length of signals and given coherence do not match" - assert coherence.shape[1] == self.number_of_channels, ( - "Number of channels between given coherence and signal " - + "does not match" - ) - self.coherence = coherence - def set_csm_parameters( self, window_length_samples: int = 1024, @@ -903,23 +830,6 @@ def get_spectrogram( ) return t_s, f_hz, spectrogram - def get_coherence(self) -> tuple[NDArray[np.float64], NDArray[np.float64]]: - """Returns the coherence matrix. - - Returns - ------- - f : NDArray[np.float64] - Frequency vector. - coherence : NDArray[np.float64] - Coherence matrix. - - """ - assert hasattr( - self, "coherence" - ), "There is no coherence data saved in the Signal object" - f, _ = self.get_spectrum() - return f, self.coherence - # ======== Plots ========================================================== def plot_magnitude( self, @@ -1048,12 +958,6 @@ def plot_time(self) -> tuple[Figure, list[Axes]]: for n in range(self.number_of_channels): mx = np.max(np.abs(self.time_data[:, n])) * 1.1 - if hasattr(self, "window"): - ax[n].plot( - self.time_vector_s, - self.window[:, n] * mx / 1.1, - alpha=0.75, - ) if plot_complex: ax[n].plot( self.time_vector_s, @@ -1110,19 +1014,14 @@ def plot_spl( (int(window_length_s * self.sampling_rate_hz + 0.5), 1) ) window /= len(window) - td_squared = convolve( - td_squared, window, mode="same", method="auto" - ) + td_squared = oaconvolve(td_squared, window, mode="same", axes=0) complex_data = self.time_data_imaginary is not None if complex_data: td_squared_imaginary = self.time_data_imaginary**2.0 if window_length_s > 0: - td_squared_imaginary = convolve( - td_squared_imaginary, - window, - mode="same", - method="auto", + td_squared_imaginary = oaconvolve( + td_squared_imaginary, window, mode="same", axes=0 ) complex_etc = 10 * np.log10( np.clip( @@ -1170,20 +1069,6 @@ def plot_spl( ) for n in range(self.number_of_channels): - if hasattr(self, "window"): - ax[n].plot( - self.time_vector_s, - 20 - * np.log10( - np.clip( - np.abs(self.window[:, n] / 1.1), - a_min=1e-40, - a_max=None, - ) - ) - + max_values[n], - alpha=0.75, - ) if complex_data: ax[n].plot(self.time_vector_s, complex_etc[:, n], alpha=0.75) if range_db is not None: @@ -1199,8 +1084,6 @@ def plot_group_delay( smoothing: int = 0, ) -> tuple[Figure, Axes]: """Plots group delay of each channel. - Only works if `signal_type in ('ir', 'h1', 'h2', 'h3', 'rir', 'chirp', - 'noise', 'dirac')`. Parameters ---------- @@ -1223,21 +1106,6 @@ def plot_group_delay( Axes. """ - valid_signal_types = ( - "rir", - "ir", - "h1", - "h2", - "h3", - "chirp", - "noise", - "dirac", - ) - assert self.signal_type in valid_signal_types, ( - f"{self.signal_type} is not valid. Please set it to ir or " - + "h1, h2, h3, rir" - ) - # Handle spectrum parameters prior_spectrum_parameters = self._spectrum_parameters self.set_spectrum_parameters("standard", scaling=None, smoothe=0) @@ -1342,36 +1210,6 @@ def plot_spectrogram( ) return fig, ax - def plot_coherence(self) -> tuple[Figure, list[Axes]]: - """Plots coherence measurements if there are any. - - Returns - ------- - fig : `matplotlib.figure.Figure` - Figure. - ax : list of `matplotlib.axes.Axes` - Axes. - - """ - if not hasattr(self, "coherence"): - raise AttributeError("There is no coherence data saved") - f, coh = self.get_coherence() - fig, ax = general_subplots_line( - x=f, - matrix=coh, - column=True, - sharey=True, - log=True, - ylabels=[ - rf"$\gamma^2$ Coherence {n}" - for n in range(self.number_of_channels) - ], - xlabels="Frequency / Hz", - range_y=[-0.1, 1.1], - returns=True, - ) - return fig, ax - def plot_phase( self, range_hz=[20, 20e3], @@ -1421,10 +1259,6 @@ def plot_phase( self._spectrum_parameters["smoothe"] = prior_smoothing if remove_ir_latency: - assert self.signal_type in ( - "rir", - "ir", - ), f"{self.signal_type} is not valid, use rir or ir" ph = _remove_ir_latency_from_phase( f, ph, self.time_data, self.sampling_rate_hz, 8 ) @@ -1535,6 +1369,7 @@ def copy(self): def _get_metadata_string(self) -> str: """Helper for creating a string containing all signal info.""" + txt = "" temp = "" for n in range(len(txt)): temp += "-" @@ -1606,12 +1441,7 @@ def stream_samples(self, blocksize_samples: int, signal_mode: bool = True): self.streaming_position + blocksize_samples ) if signal_mode: - sig = Signal( - None, - sig, - self.sampling_rate_hz, - self.signal_type, - ) + sig = Signal(None, sig, self.sampling_rate_hz) # In an audio stream, welch's method for acquiring a spectrum # is not very logical... sig.set_spectrum_parameters(method="standard", scaling=None) diff --git a/dsptoolbox/classes/_svfilter.py b/dsptoolbox/classes/sv_filter.py similarity index 96% rename from dsptoolbox/classes/_svfilter.py rename to dsptoolbox/classes/sv_filter.py index f750e28..880d46a 100644 --- a/dsptoolbox/classes/_svfilter.py +++ b/dsptoolbox/classes/sv_filter.py @@ -7,7 +7,7 @@ from matplotlib.figure import Figure from matplotlib.axes import Axes from numpy.typing import NDArray -from .signal_class import Signal +from .signal import Signal from .multibandsignal import MultiBandSignal from ..generators import dirac @@ -146,10 +146,7 @@ def filter_signal(self, signal: Signal) -> MultiBandSignal: return MultiBandSignal( [ Signal( - None, - td[:, i, :], - sampling_rate_hz=self.sampling_rate_hz, - signal_type=signal.signal_type, + None, td[:, i, :], sampling_rate_hz=self.sampling_rate_hz ) for i in range(4) ] @@ -171,7 +168,6 @@ def get_ir(self, length_samples: int = 1024) -> MultiBandSignal: """ d = dirac(length_samples, sampling_rate_hz=self.sampling_rate_hz) - d.signal_type = "ir" self._reset_state() return self.filter_signal(d) @@ -200,7 +196,6 @@ def plot_magnitude( """ d = self.get_ir(length_samples).get_all_bands() - d.signal_type = "ir" d.set_spectrum_parameters(method="standard") fig, ax = d.plot_magnitude( range_hz=range_hz, @@ -232,7 +227,6 @@ def plot_group_delay( """ d = self.get_ir(length_samples).get_all_bands() - d.signal_type = "ir" d.set_spectrum_parameters(method="standard") fig, ax = d.plot_group_delay(range_hz=range_hz) ax.legend(["Lowpass", "Highpass", "Bandpass", "Allpass"]) @@ -262,7 +256,6 @@ def plot_phase( """ d = self.get_ir(length_samples).get_all_bands() - d.signal_type = "ir" d.set_spectrum_parameters(method="standard") fig, ax = d.plot_phase(range_hz=range_hz, unwrap=unwrap) ax.legend(["Lowpass", "Highpass", "Bandpass", "Allpass"]) diff --git a/dsptoolbox/filterbanks/__init__.py b/dsptoolbox/filterbanks/__init__.py index 2bcfac5..d4773c1 100644 --- a/dsptoolbox/filterbanks/__init__.py +++ b/dsptoolbox/filterbanks/__init__.py @@ -50,9 +50,9 @@ gaussian_kernel, ) -from ..classes._lattice_ladder_filter import LatticeLadderFilter -from ..classes._phaseLinearizer import PhaseLinearizer -from ..classes._svfilter import StateVariableFilter +from ..classes.lattice_ladder_filter import LatticeLadderFilter +from ..classes.phase_linearizer import PhaseLinearizer +from ..classes.sv_filter import StateVariableFilter __all__ = [ "linkwitz_riley_crossovers", diff --git a/dsptoolbox/filterbanks/_filterbank.py b/dsptoolbox/filterbanks/_filterbank.py index 8cc9c5b..e64fb9e 100644 --- a/dsptoolbox/filterbanks/_filterbank.py +++ b/dsptoolbox/filterbanks/_filterbank.py @@ -300,14 +300,7 @@ def filter_signal( b = [] for n in range(self.number_of_bands): - b.append( - Signal( - None, - new_time_data[:, :, n], - s.sampling_rate_hz, - signal_type=s.signal_type, - ) - ) + b.append(Signal(None, new_time_data[:, :, n], s.sampling_rate_hz)) d = dict( readme="MultiBandSignal made using Linkwitz-Riley filter bank", filterbank_freqs=self.freqs, diff --git a/dsptoolbox/filterbanks/filterbanks.py b/dsptoolbox/filterbanks/filterbanks.py index f37581e..ac978c5 100644 --- a/dsptoolbox/filterbanks/filterbanks.py +++ b/dsptoolbox/filterbanks/filterbanks.py @@ -11,7 +11,7 @@ FilterBank, ) from ..tools import fractional_octave_frequencies, erb_frequencies -from ..classes._lattice_ladder_filter import ( +from ..classes.lattice_ladder_filter import ( LatticeLadderFilter, _get_lattice_ladder_coefficients_iir, _get_lattice_coefficients_fir, diff --git a/dsptoolbox/generators/generators.py b/dsptoolbox/generators/generators.py index c278bd9..22e215a 100644 --- a/dsptoolbox/generators/generators.py +++ b/dsptoolbox/generators/generators.py @@ -5,14 +5,14 @@ """ import numpy as np -from ..classes.signal_class import Signal +from ..classes import Signal, ImpulseResponse from .._general_helpers import ( _normalize, _fade, _pad_trim, _frequency_weightning, ) -from ..classes._filter import _impulse +from ..classes.filter import _impulse def noise( @@ -126,7 +126,7 @@ def noise( ) time_data[:l_samples, :] = vec - noise_sig = Signal(None, time_data, sampling_rate_hz, signal_type="noise") + noise_sig = Signal(None, time_data, sampling_rate_hz) return noise_sig @@ -242,12 +242,7 @@ def chirp( if number_of_channels != 1: chirp_n = np.repeat(chirp_n, repeats=number_of_channels, axis=1) # Signal - chirp_sig = Signal( - None, - chirp_n, - sampling_rate_hz, - signal_type="chirp", - ) + chirp_sig = Signal(None, chirp_n, sampling_rate_hz) return chirp_sig @@ -256,7 +251,7 @@ def dirac( delay_samples: int = 0, number_of_channels: int = 1, sampling_rate_hz: int | None = None, -) -> Signal: +) -> ImpulseResponse: """Generates a dirac impulse Signal with the specified length and sampling rate. @@ -273,7 +268,7 @@ def dirac( Returns ------- - imp : `Signal` + imp : `ImpulseResponse` Signal with dirac impulse. """ @@ -294,7 +289,7 @@ def dirac( td[:, n] = _impulse( length_samples=length_samples, delay_samples=delay_samples ) - imp = Signal(None, td, sampling_rate_hz, signal_type="dirac") + imp = ImpulseResponse(None, td, sampling_rate_hz) return imp @@ -384,7 +379,7 @@ def harmonic( td = _pad_trim(td, l_samples + p_samples) # Signal - harmonic_sig = Signal(None, td, sampling_rate_hz, signal_type="general") + harmonic_sig = Signal(None, td, sampling_rate_hz) return harmonic_sig @@ -538,5 +533,5 @@ def oscillator( td = _pad_trim(td, l_samples + p_samples) # Signal - harmonic_sig = Signal(None, td, sampling_rate_hz, signal_type="general") + harmonic_sig = Signal(None, td, sampling_rate_hz) return harmonic_sig diff --git a/dsptoolbox/room_acoustics/room_acoustics.py b/dsptoolbox/room_acoustics/room_acoustics.py index e783ee5..1c03323 100644 --- a/dsptoolbox/room_acoustics/room_acoustics.py +++ b/dsptoolbox/room_acoustics/room_acoustics.py @@ -6,7 +6,7 @@ from scipy.signal import find_peaks, convolve from numpy.typing import NDArray -from ..classes import Signal, MultiBandSignal, Filter +from ..classes import Signal, MultiBandSignal, Filter, ImpulseResponse from ..filterbanks import fractional_octave_bands, linkwitz_riley_crossovers from ._room_acoustics import ( _reverb, @@ -79,10 +79,6 @@ def reverb_time( """ if type(signal) is Signal: ir_start = _check_ir_start_reverb(signal, ir_start) - assert signal.signal_type in ("ir", "rir"), ( - f"{signal.signal_type} is not a valid signal type for " - + "reverb_time. It should be ir or rir" - ) mode = mode.upper() valid_modes = ("TOPT", "T20", "T30", "T60", "EDT") assert mode in valid_modes, ( @@ -167,12 +163,11 @@ def find_modes( assert len(f_range_hz) == 2, ( "Range of frequencies must have a " + "minimum and a maximum value" ) - - assert signal.signal_type in ("rir", "ir"), ( - f"{signal.signal_type} is not a valid signal type. It should " - + "be either rir or ir" - ) + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" signal.set_spectrum_parameters("standard") + # Pad signal to have a resolution of around 1 Hz length = signal.sampling_rate_hz signal = pad_trim(signal, length) @@ -234,10 +229,9 @@ def convolve_rir_on_signal( Convolved signal with RIR. """ - assert rir.signal_type in ( - "rir", - "ir", - ), f"{rir.signal_type} is not a valid signal type. Set it to rir or ir." + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" assert ( signal.time_data.shape[0] > rir.time_data.shape[0] ), "The RIR is longer than the signal to convolve it with." @@ -446,7 +440,7 @@ def generate_synthetic_rir( rir, room.mixing_time_s, room.t60_s, sr=sampling_rate_hz ) - rir_output = Signal(None, rir, sampling_rate_hz, signal_type="rir") + rir_output = Signal(None, rir, sampling_rate_hz) # Bandpass signal in order to have a realistic audio signal representation if apply_bandpass: diff --git a/dsptoolbox/standard_functions.py b/dsptoolbox/standard_functions.py index 373c806..ff23fb5 100644 --- a/dsptoolbox/standard_functions.py +++ b/dsptoolbox/standard_functions.py @@ -11,7 +11,6 @@ import pickle from scipy.signal import resample_poly, convolve, hilbert -# from scipy.special import iv as bessel_first_mod from fractions import Fraction from warnings import warn diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index 0f98fdf..ea0f8a8 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -16,8 +16,8 @@ _get_harmonic_times, _trim_ir, ) -from ..classes import Signal, Filter -from ..classes._filter import _group_delay_filter +from ..classes import Signal, Filter, ImpulseResponse +from ..classes.filter import _group_delay_filter from .._general_helpers import ( _remove_ir_latency_from_phase, _min_phase_ir_from_real_cepstrum, @@ -160,9 +160,7 @@ def spectral_deconvolve( start_stop_hz=start_stop_hz, mode=mode, ) - new_sig = Signal( - None, new_time_data, num.sampling_rate_hz, signal_type="ir" - ) + new_sig = Signal(None, new_time_data, num.sampling_rate_hz) if padding: if keep_original_length: new_sig.time_data = _pad_trim(new_sig.time_data, original_length) @@ -240,10 +238,9 @@ def window_ir( parts of the window are set to 0 in order to make them visible. """ - assert signal.signal_type in ( - "rir", - "ir", - ), f"{signal.signal_type} is not a valid signal type. Use rir or ir." + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" assert ( constant_percentage < 1 and constant_percentage >= 0 ), "Constant percentage can not be larger than 1 or smaller than 0" @@ -319,10 +316,9 @@ def window_centered_ir( given length. """ - assert signal.signal_type in ( - "rir", - "ir", - ), f"{signal.signal_type} is not a valid signal type. Use rir or ir." + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" new_time_data = np.zeros((total_length_samples, signal.number_of_channels)) start_positions_samples = np.zeros(signal.number_of_channels, dtype=int) @@ -476,7 +472,6 @@ def compute_transfer_function( None, np.fft.irfft(tf, axis=0, n=window_length_samples), output.sampling_rate_hz, - signal_type=mode.lower(), ) tf_sig.set_coherence(coherence) return tf_sig, tf, coherence @@ -510,10 +505,9 @@ def average_irs( Averaged signal. """ - assert signal.signal_type in ("rir", "ir"), ( - "Averaging is valid for signal types rir or ir and not " - + f"{signal.signal_type}" - ) + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" mode = mode.lower() assert mode in ( "time", @@ -570,8 +564,7 @@ def min_phase_from_mag( spectrum: NDArray[np.float64], sampling_rate_hz: int, original_length_time_data: int | None = None, - signal_type: str = "ir", -): +) -> ImpulseResponse: """Returns a minimum-phase signal from a magnitude spectrum using the discrete hilbert transform. @@ -586,12 +579,10 @@ def min_phase_from_mag( necessary for reconstruction of the time data since the first half of the spectrum (only positive frequencies) is ambiguous. Pass `None` to assume an even length. Default: `None`. - signal_type : str, optional - Type of signal to be returned. Default: `'ir'`. Returns ------- - sig_min_phase : `Signal` + sig_min_phase : `ImpulseResponse` Signal with same magnitude spectrum but minimum phase. References @@ -620,11 +611,8 @@ def min_phase_from_mag( time_data = np.fft.irfft( spectrum * np.exp(1j * phase), axis=0, n=original_length_time_data ) - sig_min_phase = Signal( - None, - time_data=time_data, - sampling_rate_hz=sampling_rate_hz, - signal_type=signal_type, + sig_min_phase = ImpulseResponse( + None, time_data=time_data, sampling_rate_hz=sampling_rate_hz ) return sig_min_phase @@ -635,8 +623,7 @@ def lin_phase_from_mag( original_length_time_data: int | None = None, group_delay_ms: str | float = "minimum", check_causality: bool = True, - signal_type: str = "ir", -) -> Signal: +) -> ImpulseResponse: """Returns a linear phase signal from a magnitude spectrum. It is possible to return the smallest causal group delay by checking the minimum phase version of the signal and choosing a constant group delay that is never @@ -665,8 +652,6 @@ def lin_phase_from_mag( check_causality : bool, optional When `True`, it is assessed for each channel that the given group delay is not lower than the minimum group delay. Default: `True`. - signal_type : str, optional - Type of signal to be returned. Default: `'ir'`. Returns ------- @@ -734,11 +719,8 @@ def lin_phase_from_mag( phase = _correct_for_real_phase_spectrum(_wrap_phase(phase)) lin_spectrum[:, n] = spectrum[:, n] * np.exp(1j * phase) time_data = np.fft.irfft(lin_spectrum, axis=0, n=original_length_time_data) - sig_lin_phase = Signal( - None, - time_data=time_data, - sampling_rate_hz=sampling_rate_hz, - signal_type=signal_type, + sig_lin_phase = ImpulseResponse( + None, time_data=time_data, sampling_rate_hz=sampling_rate_hz ) return sig_lin_phase @@ -769,14 +751,13 @@ def min_phase_ir( Returns ------- - min_phase_sig : `Signal` + min_phase_sig : `ImpulseResponse` Minimum-phase IR as time signal. """ - assert sig.signal_type in ( - "rir", - "ir", - ), "Signal type must be either rir or ir" + assert ( + type(sig) is ImpulseResponse + ), "This is only valid for an impulse response" method = method.lower() assert method in ("real cepstrum", "equiripple"), ( f"{method} is not valid. Use either real cepstrum or " + "equiripple" @@ -862,13 +843,9 @@ def group_delay( signal._spectrum_parameters = spec_parameters if remove_ir_latency: - assert signal.signal_type in ( - "rir", - "ir", - ), ( - f"{signal.signal_type} is not a valid signal type. Use ir " - + "or rir" - ) + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" sp = _remove_ir_latency_from_phase( f, np.angle(sp), signal.time_data, signal.sampling_rate_hz, 1 ) @@ -920,13 +897,9 @@ def minimum_phase( Minimum phases as matrix with shape (phase, channel). """ - assert signal.signal_type in ( - "rir", - "ir", - "h1", - "h2", - "h3", - ), "Signal type must be rir or ir" + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" method = method.lower() assert method in ( "real cepstrum", @@ -993,7 +966,9 @@ def minimum_group_delay( - https://www.roomeqwizard.com/help/help_en-GB/html/minimumphase.html """ - assert signal.signal_type in ("rir", "ir"), "Only valid for rir or ir" + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" f, min_phases = minimum_phase(signal, padding_factor=padding_factor) min_gd = np.zeros_like(min_phases) for n in range(signal.number_of_channels): @@ -1033,7 +1008,9 @@ def excess_group_delay( - https://www.roomeqwizard.com/help/help_en-GB/html/minimumphase.html """ - assert signal.signal_type in ("rir", "ir"), "Only valid for rir or ir" + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" f, min_gd = minimum_group_delay( signal, smoothing=0, padding_factor=8 if remove_ir_latency else 1 ) @@ -1096,7 +1073,9 @@ def combine_ir_with_dirac( added dirac impulse has time to grow smoothly. """ - assert ir.signal_type in ("rir", "ir"), "Only valid for rir or ir" + assert ( + type(ir) is ImpulseResponse + ), "This is only valid for an impulse response" if normalization is not None: normalization = normalization.lower() assert normalization in ( @@ -1185,10 +1164,9 @@ def ir_to_filter( FIR filter object. """ - assert signal.signal_type in ("ir", "rir", "h1", "h2", "h3"), ( - f"{signal.signal_type} is not valid. Use one of " - + """('ir', 'rir', 'h1', 'h2', 'h3')""" - ) + assert ( + type(signal) is ImpulseResponse + ), "This is only valid for an impulse response" assert ( channel < signal.number_of_channels ), f"Signal does not have a channel {channel}" @@ -1217,7 +1195,7 @@ def ir_to_filter( return filt -def filter_to_ir(fir: Filter) -> Signal: +def filter_to_ir(fir: Filter) -> ImpulseResponse: """Takes in an FIR filter and converts it into an IR by taking its b coefficients. @@ -1236,9 +1214,7 @@ def filter_to_ir(fir: Filter) -> Signal: fir.filter_type == "fir" ), "This is only valid is only available for FIR filters" b, _ = fir.get_coefficients(mode="ba") - new_sig = Signal( - None, b, sampling_rate_hz=fir.sampling_rate_hz, signal_type="ir" - ) + new_sig = ImpulseResponse(None, b, sampling_rate_hz=fir.sampling_rate_hz) return new_sig @@ -1303,7 +1279,9 @@ def window_frequency_dependent( correct way to obtain the spectrum. """ - assert ir.signal_type in ("rir", "ir"), "Only valid for rir or ir" + assert ( + type(ir) is ImpulseResponse + ), "This is only valid for an impulse response" scaling = scaling if scaling is None else scaling.lower() assert scaling in ( "amplitude spectrum", @@ -1445,7 +1423,9 @@ def warp_ir( NY, USA, 2001, pp. 35-38, doi: 10.1109/ASPAA.2001.969536. """ - assert ir.signal_type in ("rir", "ir"), "Signal has to be an IR or a RIR" + assert ( + type(ir) is ImpulseResponse + ), "This is only valid for an impulse response" assert np.abs(warping_factor) < 1, "Warping factor has to be in ]-1; 1[" td = ir.time_data @@ -1466,13 +1446,13 @@ def warp_ir( return f_unwarped, warped_ir -def find_ir_latency(ir: Signal) -> NDArray[np.float64]: +def find_ir_latency(ir: ImpulseResponse) -> NDArray[np.float64]: """Find the subsample maximum of each channel of the IR using the its minimum phase equivalent. Parameters ---------- - ir : `Signal` + ir : `ImpulseResponse` Impulse response to find the maximum. Returns @@ -1481,24 +1461,26 @@ def find_ir_latency(ir: Signal) -> NDArray[np.float64]: Array with the position of each channel's maximum in samples. """ - assert ir.signal_type in ("rir", "ir"), "Only valid for rir or ir" + assert ( + type(ir) is ImpulseResponse + ), "This is only valid for an impulse response" min_ir = min_phase_ir(ir) return latency(ir, min_ir, 1)[0] def harmonics_from_chirp_ir( - ir: Signal, + ir: ImpulseResponse, chirp_range_hz: list, chirp_length_s: float, n_harmonics: int = 5, offset_percentage: float = 0.05, -) -> list[Signal]: +) -> list[ImpulseResponse]: """Get the individual harmonics (distortion) IRs of an IR computed with an exponential chirp. Parameters ---------- - ir : `Signal` + ir : `ImpulseResponse` Impulse response obtained through deconvolution with an exponential chirp. chirp_range_hz : list of length 2 @@ -1516,7 +1498,7 @@ def harmonics_from_chirp_ir( Returns ------- - harmonics : list[Signal] + harmonics : list[ImpulseResponse] List containing the IRs of each harmonic in ascending order. The fundamental is not in the list. @@ -1527,10 +1509,9 @@ def harmonics_from_chirp_ir( not be checked in this function. """ - assert ir.signal_type in ( - "ir", - "rir", - ), "Signal type has to be either ir or rir" + assert ( + type(ir) is ImpulseResponse + ), "This is only valid for an impulse response" assert ( offset_percentage < 1 and offset_percentage >= 0 ), "Offset must be smaller than one" @@ -1576,7 +1557,7 @@ def harmonics_from_chirp_ir( def harmonic_distortion_analysis( - ir: Signal | list[Signal], + ir: ImpulseResponse | list[ImpulseResponse], chirp_range_hz: list | None = None, chirp_length_s: float | None = None, n_harmonics: int | None = 8, @@ -1591,7 +1572,7 @@ def harmonic_distortion_analysis( Parameters ---------- - ir : `Signal` or list[`Signal`] + ir : `ImpulseResponse` or list[`ImpulseResponse`] Impulse response. It should only have one channel. Alternatively, a list containing the fundamental IR and all harmonics can be passed, in which case `chirp_range_hz`, `chirp_length_s` and `n_harmonics` diff --git a/dsptoolbox/transforms/transforms.py b/dsptoolbox/transforms/transforms.py index ef05aef..8a6809e 100644 --- a/dsptoolbox/transforms/transforms.py +++ b/dsptoolbox/transforms/transforms.py @@ -2,7 +2,7 @@ Here are methods considered as somewhat special or less common. """ -from ..classes.signal_class import Signal +from ..classes.signal import Signal from ..classes.multibandsignal import MultiBandSignal from ..plots import general_matrix_plot from .._standard import _reconstruct_framed_signal diff --git a/examples/distances_module.ipynb b/examples/distances_module.ipynb index 50f3935..9bf985d 100644 --- a/examples/distances_module.ipynb +++ b/examples/distances_module.ipynb @@ -41,7 +41,7 @@ "s1 = dsp.Signal(join('data', 'speech.flac'))\n", "\n", "# Get a \"distorted\" signal – here convolved with a RIR\n", - "rir = dsp.Signal(join('data', 'rir.wav'), signal_type='rir')\n", + "rir = dsp.ImpulseResponse(join('data', 'rir.wav'))\n", "s2 = dsp.Signal(join('data', 'speech.flac'))\n", "s2 = dsp.room_acoustics.convolve_rir_on_signal(s2, rir)" ] diff --git a/examples/general.ipynb b/examples/general.ipynb index f15ab10..f0d02e2 100644 --- a/examples/general.ipynb +++ b/examples/general.ipynb @@ -56,9 +56,7 @@ "# ========== Importing ========================================================\n", "# Give path to data directly, wav and flac are supported\n", "speech = dsp.Signal(\n", - " path=join('data', 'speech.flac'), time_data=None, sampling_rate_hz=None,\n", - " # Optional parameters:\n", - " signal_type='general', # Type of signal\n", + " path=join('data', 'speech.flac'), time_data=None, sampling_rate_hz=None\n", ")\n", "# If a path is given, time_data and sampling rate should be set to None\n", "\n", @@ -90,8 +88,7 @@ "source": [ "Note:\n", "- The `time_data` attribute is a numpy vector with shape (time_samples, channels). Even when the passed data is trasposed, the constructor assumes that the longest dimension contains the time samples and inverts the array.\n", - "- lists and tuples can also be passed, but every element should have the same length since it is a requirement to convert them into numpy arrays.\n", - "- `signal_type` is a marker (string) for the signal. Default types are `'ir'` (impulse response), `'h1'` (transfer function of type $H_1$), `'h2'`, `'h3'` or `'rir'` (room impulse response). Some functionalities like plotting group delay are only valid for these types. See documentation for details." + "- lists and tuples can also be passed, but every element should have the same length since it is a requirement to convert them into numpy arrays." ] }, { @@ -181,13 +178,12 @@ "# ========== Time vector ======================================================\n", "time_s = speech.time_vector_s\n", "\n", - "# Only available for signal_type in ('h1', 'h2', 'h3')\n", + "# Only available for impulse response\n", "# coherence_matrix = (())\n", "# speech.set_coherence(coherence_matrix)\n", "# frequency_hz, coherence_matrix = speech.get_coherence()\n", - "# NOTE: See later documentation regarding transfer functions\n", + "# NOTE: See documentation regarding transfer functions\n", "\n", - "# Only available for signal_type in ('ir', 'rir')\n", "# window = np.ones(100)\n", "# speech.set_window(window=window)" ] diff --git a/examples/room_acoustics_module.ipynb b/examples/room_acoustics_module.ipynb index e25c331..14557a0 100644 --- a/examples/room_acoustics_module.ipynb +++ b/examples/room_acoustics_module.ipynb @@ -36,7 +36,7 @@ "outputs": [], "source": [ "speech = dsp.Signal(join('data', 'speech.flac'))\n", - "rir = dsp.Signal(join('data', 'rir.wav'), signal_type='rir')\n", + "rir = dsp.ImpulseResponse(join('data', 'rir.wav'))\n", "\n", "speech_room = dsp.room_acoustics.convolve_rir_on_signal(\n", " speech, rir, keep_peak_level=True, keep_length=False)\n", diff --git a/examples/transforms_module.ipynb b/examples/transforms_module.ipynb index 5529f13..62e9088 100644 --- a/examples/transforms_module.ipynb +++ b/examples/transforms_module.ipynb @@ -58,7 +58,7 @@ } ], "source": [ - "rir = dsp.Signal(join('data', 'rir.wav'), signal_type='rir')\n", + "rir = dsp.ImpulseResponse(join('data', 'rir.wav'))\n", "rir.set_spectrogram_parameters(window_length_samples=256, overlap_percent=0,\n", " window_type='boxcar')\n", "dsp.transforms.plot_waterfall(rir, dynamic_range_db=30)" diff --git a/tests/test_classes.py b/tests/test_classes.py index 0d5c3ca..cef1f81 100644 --- a/tests/test_classes.py +++ b/tests/test_classes.py @@ -156,15 +156,6 @@ def test_setting_properties(self): with pytest.raises(AssertionError): s.sampling_rate_hz = 44100.5 - # Signal type - typ = "test signal" - s.signal_type = typ - assert s.signal_type == typ - - # Setting a wrong signal type - with pytest.raises(AssertionError): - s.signal_type = 15 - # Number of channels is generated right assert s.number_of_channels == self.channels @@ -173,7 +164,9 @@ def test_setting_properties(self): s.number_of_channels = 10 def test_plot_generation(self): - s = dsp.Signal(time_data=self.time_vec, sampling_rate_hz=self.fs) + s = dsp.ImpulseResponse( + time_data=self.time_vec, sampling_rate_hz=self.fs + ) # Test that all plots are generated without problems s.plot_magnitude() s.plot_magnitude(show_info_box=True) @@ -185,7 +178,6 @@ def test_plot_generation(self): s.plot_spl(True) # Plot phase and group delay - s.signal_type = "rir" s.set_spectrum_parameters(method="standard") s.plot_phase() s.plot_group_delay() @@ -193,10 +185,6 @@ def test_plot_generation(self): # Try to plot coherence with pytest.raises(AttributeError): s.plot_coherence() - # Try to plot group delay without having the correct signal type - with pytest.raises(AssertionError): - s.signal_type = "wrong type for group delay" - s.plot_group_delay() # Try to plot phase having welch's method for magnitude with pytest.raises(AssertionError): s.set_spectrum_parameters(method="welch", window_length_samples=32) @@ -204,7 +192,6 @@ def test_plot_generation(self): # Plot signal with window and imaginary time data d = dsp.generators.dirac(1024, 512, sampling_rate_hz=self.fs) - d.signal_type = "ir" d, _ = dsp.transfer_functions.window_centered_ir(d, len(d)) d = dsp.transforms.hilbert(d) d.plot_time() diff --git a/tests/test_filterbanks.py b/tests/test_filterbanks.py index 3bac314..d48bed8 100644 --- a/tests/test_filterbanks.py +++ b/tests/test_filterbanks.py @@ -274,7 +274,7 @@ def test_lattice_filter_coefficients(self): # Example values taken from Oppenheim, A. V., Schafer, R. W.,, # Buck, J. R. (1999). Discrete-Time Signal Processing. # Prentice-hall Englewood Cliffs. - from dsptoolbox.classes._lattice_ladder_filter import ( + from dsptoolbox.classes.lattice_ladder_filter import ( _get_lattice_ladder_coefficients_iir, ) @@ -290,7 +290,7 @@ def test_lattice_filter_filtering(self): n = dsp.generators.noise(sampling_rate_hz=200) expected = sig.lfilter(self.b / 10, self.a, n.time_data.squeeze()) - from dsptoolbox.classes._lattice_ladder_filter import ( + from dsptoolbox.classes.lattice_ladder_filter import ( _get_lattice_ladder_coefficients_iir, ) diff --git a/tests/test_room_acoustics.py b/tests/test_room_acoustics.py index 563da7c..8fdf222 100644 --- a/tests/test_room_acoustics.py +++ b/tests/test_room_acoustics.py @@ -5,7 +5,7 @@ class TestRoomAcousticsModule: - rir = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + rir = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) def test_reverb_time(self): # Only functionality diff --git a/tests/test_transfer_functions.py b/tests/test_transfer_functions.py index 29086fe..075c3f1 100644 --- a/tests/test_transfer_functions.py +++ b/tests/test_transfer_functions.py @@ -242,7 +242,6 @@ def test_window_centered_ir(self): # ============= Impulse in the middle, no changing lengths, even d = dsp.generators.dirac(1024, 512, sampling_rate_hz=self.fs) - d.signal_type = "rir" d2, _ = dsp.transfer_functions.window_centered_ir(d, len(d)) assert ( np.argmax(d.time_data[:, 0]) == np.argmax(d2.window[:, 0]) @@ -252,7 +251,6 @@ def test_window_centered_ir(self): # ============= Impulse in the middle, no changing lengths, odd d = dsp.generators.dirac(1025, 513, sampling_rate_hz=self.fs) - d.signal_type = "rir" d2, _ = dsp.transfer_functions.window_centered_ir(d, len(d)) assert ( np.argmax(d.time_data[:, 0]) == np.argmax(d2.window[:, 0]) @@ -262,7 +260,7 @@ def test_window_centered_ir(self): def test_ir_to_filter(self): s = self.audio_multi.time_data[:200, 0] - s = dsp.Signal(None, s, self.fs, signal_type="rir") + s = dsp.ImpulseResponse(None, s, self.fs) f = dsp.transfer_functions.ir_to_filter(s, channel=0) b, _ = f.get_coefficients(mode="ba") assert np.all(b == s.time_data[:, 0]) @@ -439,11 +437,11 @@ def test_excess_group_delay(self): def test_min_phase_ir(self): # Only functionality, computation is done using scipy's minimum phase - s = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + s = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) s = dsp.transfer_functions.min_phase_ir(s) def test_combine_ir(self): - s = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + s = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) dsp.transfer_functions.combine_ir_with_dirac( s, 1000, True, normalization=None ) @@ -456,7 +454,6 @@ def test_combine_ir(self): def test_find_ir_latency(self): ir = dsp.generators.dirac(self.fs, sampling_rate_hz=self.fs) - ir.signal_type = "ir" delay_seconds = 0.00133 # Some value to have a fractional delay delay_samples = self.fs * delay_seconds ir = dsp.fractional_delay(ir, delay_seconds) @@ -464,11 +461,11 @@ def test_find_ir_latency(self): assert np.isclose(delay_samples, output, atol=0.4) - ir = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + ir = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) assert dsp.transfer_functions.find_ir_latency(ir) > 0 def test_window_frequency_dependent(self): - s = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + s = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) f, sp = dsp.transfer_functions.window_frequency_dependent( s, 10, 0, [100, 1000] ) @@ -479,13 +476,13 @@ def test_window_frequency_dependent(self): def test_warp_ir(self): # Only functionality - s = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + s = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) dsp.transfer_functions.warp_ir(s, -0.6, True, 2**8) dsp.transfer_functions.warp_ir(s, 0.6, False, 2**8) def test_harmonics_from_chirp_ir(self): # Only functionality - ir = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + ir = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) dsp.transfer_functions.harmonics_from_chirp_ir( ir, chirp_range_hz=[20, 20e3], @@ -495,7 +492,7 @@ def test_harmonics_from_chirp_ir(self): def test_harmonic_distortion_analysis(self): # Only functionality - ir = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + ir = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) dsp.transfer_functions.harmonic_distortion_analysis( ir, chirp_range_hz=[20, 20e3], @@ -519,7 +516,7 @@ def test_harmonic_distortion_analysis(self): def test_trim_rir(self): # Only functionality - ir = dsp.Signal(join("examples", "data", "rir.wav"), signal_type="rir") + ir = dsp.ImpulseResponse(join("examples", "data", "rir.wav")) dsp.transfer_functions.trim_ir(ir) # Start offset way longer than rir (should be clipped to 0) assert ( From 698f5ceb98479bede77a7b555822fd17c00b1d34 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 17:12:30 +0200 Subject: [PATCH 27/35] fixed some types, added unit test placeholder --- dsptoolbox/beamforming/beamforming.py | 4 +- dsptoolbox/classes/filter_class.py | 12 +-- dsptoolbox/classes/impulse_response.py | 10 +- dsptoolbox/classes/multibandsignal.py | 2 +- dsptoolbox/classes/signal.py | 4 +- dsptoolbox/effects/effects.py | 2 +- dsptoolbox/filterbanks/_filterbank.py | 12 ++- dsptoolbox/generators/generators.py | 7 +- dsptoolbox/room_acoustics/room_acoustics.py | 17 +-- .../transfer_functions/transfer_functions.py | 102 +++++++++--------- dsptoolbox/transforms/transforms.py | 7 +- tests/test_classes.py | 9 ++ tox.ini | 2 +- 13 files changed, 106 insertions(+), 84 deletions(-) diff --git a/dsptoolbox/beamforming/beamforming.py b/dsptoolbox/beamforming/beamforming.py index 08fbbd6..caed06d 100644 --- a/dsptoolbox/beamforming/beamforming.py +++ b/dsptoolbox/beamforming/beamforming.py @@ -719,8 +719,8 @@ def __init__( object. """ - assert ( - type(multi_channel_signal) is Signal + assert isinstance( + multi_channel_signal, Signal ), "Multi-channel signal must be of type Signal" assert ( type(mic_array) is MicArray diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py index 8d6c5f2..b6608db 100644 --- a/dsptoolbox/classes/filter_class.py +++ b/dsptoolbox/classes/filter_class.py @@ -13,6 +13,7 @@ from numpy.typing import NDArray, ArrayLike from .signal import Signal +from .impulse_response import ImpulseResponse from .filter import ( _biquad_coefficients, _impulse, @@ -717,7 +718,7 @@ def _get_metadata_string(self): def get_ir( self, length_samples: int = 512, zero_phase: bool = False - ) -> Signal: + ) -> ImpulseResponse: """Gets an impulse response of the filter with given length. Parameters @@ -727,7 +728,7 @@ def get_ir( Returns ------- - ir_filt : `Signal` + ir_filt : `ImpulseResponse` Impulse response of the filter. """ @@ -741,17 +742,16 @@ def get_ir( ) length_samples = len(b) b = _pad_trim(b, length_samples) - return Signal( - None, b, self.sampling_rate_hz, "ir", constrain_amplitude=False + return ImpulseResponse( + None, b, self.sampling_rate_hz, constrain_amplitude=False ) # IIR or zero phase IR ir_filt = _impulse(length_samples) - ir_filt = Signal( + ir_filt = ImpulseResponse( None, ir_filt, self.sampling_rate_hz, - "ir", constrain_amplitude=False, ) return self.filter_signal(ir_filt, zero_phase=zero_phase) diff --git a/dsptoolbox/classes/impulse_response.py b/dsptoolbox/classes/impulse_response.py index ca3801c..ee3fe75 100644 --- a/dsptoolbox/classes/impulse_response.py +++ b/dsptoolbox/classes/impulse_response.py @@ -10,9 +10,9 @@ class ImpulseResponse(Signal): def __init__( self, - path: str, - time_data: NDArray[np.float64], - sampling_rate_hz: int, + path: str | None = None, + time_data: NDArray[np.float64] | None = None, + sampling_rate_hz: int | None = None, constrain_amplitude: bool = True, ): """Impulse response.""" @@ -113,7 +113,9 @@ def plot_spl( be present due to zero-padding. """ - fig, ax = super().plot_spl() + fig, ax = super().plot_spl( + normalize_at_peak, range_db, window_length_s + ) peak_values = 10 * np.log10(np.max(self.time_data**2.0, axis=0)) diff --git a/dsptoolbox/classes/multibandsignal.py b/dsptoolbox/classes/multibandsignal.py index f38be77..c4157e2 100644 --- a/dsptoolbox/classes/multibandsignal.py +++ b/dsptoolbox/classes/multibandsignal.py @@ -92,7 +92,7 @@ def bands(self, new_bands): sr = [] complex_data = new_bands[0].time_data_imaginary is not None for s in new_bands: - assert type(s) is Signal, ( + assert isinstance(s, Signal), ( f"{type(s)} is not a valid " + "band type. Use Signal objects" ) diff --git a/dsptoolbox/classes/signal.py b/dsptoolbox/classes/signal.py index 50c8240..41cc552 100644 --- a/dsptoolbox/classes/signal.py +++ b/dsptoolbox/classes/signal.py @@ -1232,8 +1232,8 @@ def plot_phase( 1/smoothing-octave band. This only applies smoothing to the plot data. Default: 0. remove_ir_latency : bool, optional - If the signal is of type `"rir"` or `"ir"`, the delay of the - impulse can be removed. Default: `False`. + If the signal is an impulse response, the delay of the impulse can + be removed. Default: `False`. Returns ------- diff --git a/dsptoolbox/effects/effects.py b/dsptoolbox/effects/effects.py index a800ef4..648d730 100644 --- a/dsptoolbox/effects/effects.py +++ b/dsptoolbox/effects/effects.py @@ -62,7 +62,7 @@ def apply( Modified signal. """ - if type(signal) is Signal: + if isinstance(signal, Signal): return self._apply_this_effect(signal) elif type(signal) is MultiBandSignal: new_mbs = signal.copy() diff --git a/dsptoolbox/filterbanks/_filterbank.py b/dsptoolbox/filterbanks/_filterbank.py index e64fb9e..f111d0f 100644 --- a/dsptoolbox/filterbanks/_filterbank.py +++ b/dsptoolbox/filterbanks/_filterbank.py @@ -17,7 +17,13 @@ bilinear, tf2sos, ) -from ..classes import Signal, MultiBandSignal, FilterBank, Filter +from ..classes import ( + Signal, + MultiBandSignal, + FilterBank, + Filter, + ImpulseResponse, +) from ..generators import dirac from ..plots import general_plot @@ -365,7 +371,7 @@ def get_ir( length_samples: int = 1024, mode: str = "parallel", zero_phase: bool = False, - ) -> Signal | MultiBandSignal: + ) -> ImpulseResponse | MultiBandSignal: """Returns impulse response from the filter bank. For this filter bank only `mode='parallel'` is valid and there is no zero phase filtering. @@ -383,7 +389,7 @@ def get_ir( Returns ------- - ir : `MultiBandSignal` or `Signal` + ir : `ImpulseResponse`, `MultiBandSignal` Impulse response of the filter bank. """ diff --git a/dsptoolbox/generators/generators.py b/dsptoolbox/generators/generators.py index 22e215a..db51010 100644 --- a/dsptoolbox/generators/generators.py +++ b/dsptoolbox/generators/generators.py @@ -5,7 +5,8 @@ """ import numpy as np -from ..classes import Signal, ImpulseResponse +from ..classes.signal import Signal +from ..classes.impulse_response import ImpulseResponse from .._general_helpers import ( _normalize, _fade, @@ -252,8 +253,8 @@ def dirac( number_of_channels: int = 1, sampling_rate_hz: int | None = None, ) -> ImpulseResponse: - """Generates a dirac impulse Signal with the specified length and - sampling rate. + """Generates a dirac impulse (ImpulseResponse) with the specified length + and sampling rate. Parameters ---------- diff --git a/dsptoolbox/room_acoustics/room_acoustics.py b/dsptoolbox/room_acoustics/room_acoustics.py index 1c03323..8e5d042 100644 --- a/dsptoolbox/room_acoustics/room_acoustics.py +++ b/dsptoolbox/room_acoustics/room_acoustics.py @@ -77,7 +77,7 @@ def reverb_time( by 6. """ - if type(signal) is Signal: + if type(signal) is ImpulseResponse: ir_start = _check_ir_start_reverb(signal, ir_start) mode = mode.upper() valid_modes = ("TOPT", "T20", "T30", "T60", "EDT") @@ -116,7 +116,8 @@ def reverb_time( ) else: raise TypeError( - "Passed signal should be of type Signal or MultiBandSignal" + f"Passed signal has type {type(signal)}. It should be of type" + + " ImpulseResponse or MultiBandSignal" ) return reverberation_times, correlation_coefficients @@ -201,7 +202,7 @@ def find_modes( def convolve_rir_on_signal( signal: Signal, - rir: Signal, + rir: ImpulseResponse, keep_peak_level: bool = True, keep_length: bool = True, ) -> Signal: @@ -214,7 +215,7 @@ def convolve_rir_on_signal( ---------- signal : Signal Signal to which the RIR is applied. All channels are affected. - rir : Signal + rir : ImpulseResponse Single-channel Signal object containing the RIR. keep_peak_level : bool, optional When `True`, output signal is normalized to the peak level of @@ -229,8 +230,8 @@ def convolve_rir_on_signal( Convolved signal with RIR. """ - assert ( - type(signal) is ImpulseResponse + assert isinstance( + rir, ImpulseResponse ), "This is only valid for an impulse response" assert ( signal.time_data.shape[0] > rir.time_data.shape[0] @@ -508,7 +509,7 @@ def descriptors( "br", "ts", ), "Given mode is not in the available descriptors" - if type(rir) is Signal: + if isinstance(rir, ImpulseResponse): if mode == "d50": func = _d50_from_rir elif mode == "c80": @@ -586,7 +587,7 @@ def _check_ir_start_reverb( or type(ir_start) is np.ndarray ), "Unsupported type for ir_start" - if type(sig) is Signal: + if isinstance(sig, ImpulseResponse): if np.issubdtype(type(ir_start), np.integer): ir_start = ( np.ones(sig.number_of_channels, dtype=np.int_) * ir_start diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index ea0f8a8..7c5b11e 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -52,7 +52,7 @@ def spectral_deconvolve( threshold_db=-30, padding: bool = False, keep_original_length: bool = False, -) -> Signal: +) -> ImpulseResponse: """Deconvolution by spectral division of two signals. If the denominator signal only has one channel, the deconvolution is done using that channel for all channels of the numerator. @@ -160,7 +160,7 @@ def spectral_deconvolve( start_stop_hz=start_stop_hz, mode=mode, ) - new_sig = Signal(None, new_time_data, num.sampling_rate_hz) + new_sig = ImpulseResponse(None, new_time_data, num.sampling_rate_hz) if padding: if keep_original_length: new_sig.time_data = _pad_trim(new_sig.time_data, original_length) @@ -168,7 +168,7 @@ def spectral_deconvolve( def window_ir( - signal: Signal, + signal: ImpulseResponse, total_length_samples: int, adaptive: bool = True, constant_percentage: float = 0.75, @@ -176,7 +176,7 @@ def window_ir( at_start: bool = True, offset_samples: int = 0, left_to_right_flank_length_ratio: float = 1.0, -) -> tuple[Signal, NDArray[np.float64]]: +) -> tuple[ImpulseResponse, NDArray[np.float64]]: """Windows an IR with trimming and selection of constant valued length. This is equivalent to a tukey window whose flanks can be selected to be any type. The peak of the impulse response is aligned to correspond to @@ -184,7 +184,7 @@ def window_ir( Parameters ---------- - signal : `Signal` + signal : `ImpulseResponse` Signal to window total_length_samples : int Total window length in samples. @@ -217,7 +217,7 @@ def window_ir( Returns ------- - new_sig : `Signal` + new_sig : `ImpulseResponse` Windowed signal. The used window is also saved under `new_sig.window`. start_positions_samples : NDArray[np.float64] This array contains the position index of the start of the IR in @@ -280,17 +280,17 @@ def window_ir( def window_centered_ir( - signal: Signal, + signal: ImpulseResponse, total_length_samples: int, window_type: str | tuple = "hann", -) -> tuple[Signal, NDArray[np.float64]]: +) -> tuple[ImpulseResponse, NDArray[np.float64]]: """This function windows an IR placing its peak in the middle. It trims it to the total length of the window or pads it to the desired length (padding in the end, window has `total_length`). Parameters ---------- - signal: `Signal` + signal: `ImpulseResponse` Signal to window total_length_samples: int Total window length in samples. @@ -303,7 +303,7 @@ def window_centered_ir( Returns ------- - new_sig : `Signal` + new_sig : `ImpulseResponse` Windowed signal. The used window is also saved under `new_sig.window`. start_positions_samples : NDArray[np.float64] This array contains the position index of the start of the IR in @@ -345,7 +345,7 @@ def compute_transfer_function( mode="h2", window_length_samples: int = 1024, spectrum_parameters: dict | None = None, -) -> tuple[Signal, NDArray[np.complex128], NDArray[np.float64]]: +) -> tuple[ImpulseResponse, NDArray[np.complex128], NDArray[np.float64]]: r"""Gets transfer function H1, H2 or H3 (for stochastic signals). H1: for noise in the output signal. `Gxy/Gxx`. H2: for noise in the input signal. `Gyy/Gyx`. @@ -372,9 +372,9 @@ def compute_transfer_function( Returns ------- - tf_sig : `Signal` - Transfer functions as `Signal` object. Coherences are also computed - and saved in the `Signal` object. + tf_sig : `ImpulseResponse` + Transfer functions as `ImpulseResponse` object. Coherences are also + computed and saved in the `ImpulseResponse` object. tf : NDArray[np.complex128] Complex transfer function as type NDArray[np.complex128] with shape (frequency, channel). @@ -468,7 +468,7 @@ def compute_transfer_function( elif mode == "h3".casefold(): tf[:, n] = G_xy / np.abs(G_xy) * (G_yy / G_xx) ** 0.5 coherence[:, n] = np.abs(G_xy) ** 2 / G_xx / G_yy - tf_sig = Signal( + tf_sig = ImpulseResponse( None, np.fft.irfft(tf, axis=0, n=window_length_samples), output.sampling_rate_hz, @@ -478,19 +478,19 @@ def compute_transfer_function( def average_irs( - signal: Signal, mode: str = "time", normalize_energy: bool = True -) -> Signal: + signal: ImpulseResponse, mode: str = "time", normalize_energy: bool = True +) -> ImpulseResponse: """Averages all channels of a given IR. It can either use a time domain average while time-aligning all channels to the one with the longest latency, or average directly their magnitude and phase responses. Parameters ---------- - signal : `Signal` + signal : `ImpulseResponse` Signal with channels to be averaged over. mode : str, optional It can be either `"time"` or `"spectral"`. When `"time"` is selected, - the IRs are time-aligned to the channel with the biggest latency + the IRs are time-aligned to the channel with the largest latency and then averaged in the time domain. `"spectral"` averages directly the magnitude and phase of each IR. Default: `"time"`. normalize_energy : bool, optional @@ -501,8 +501,8 @@ def average_irs( Returns ------- - avg_sig : `Signal` - Averaged signal. + avg_sig : `ImpulseResponse` + Averaged impulse response. """ assert ( @@ -726,8 +726,10 @@ def lin_phase_from_mag( def min_phase_ir( - sig: Signal, method: str = "real cepstrum", padding_factor: int = 8 -) -> Signal: + sig: ImpulseResponse, + method: str = "real cepstrum", + padding_factor: int = 8, +) -> ImpulseResponse: """Returns same IR with minimum phase. Three methods are available for computing the minimum phase version of the IR: `'real cepstrum'` (using filtering the real-cepstral domain) and `'equiripple'` (for @@ -738,7 +740,7 @@ def min_phase_ir( Parameters ---------- - sig : `Signal` + sig : `ImpulseResponse` IR for which to compute minimum phase IR. method : str, optional For general cases, `'real cepstrum'`. If the IR is symmetric (like a @@ -868,7 +870,7 @@ def group_delay( def minimum_phase( - signal: Signal, + signal: ImpulseResponse, method: str = "real cepstrum", padding_factor: int = 8, ) -> tuple[NDArray[np.float64], NDArray[np.float64]]: @@ -936,7 +938,7 @@ def minimum_phase( def minimum_group_delay( - signal: Signal, + signal: ImpulseResponse, smoothing: int = 0, padding_factor: int = 8, ) -> tuple[NDArray[np.float64], NDArray[np.float64]]: @@ -944,7 +946,7 @@ def minimum_group_delay( Parameters ---------- - signal : `Signal` + signal : `ImpulseResponse` IR for which to compute minimal group delay. smoothing : int, optional Octave fraction by which to apply smoothing. `0` avoids any smoothing @@ -979,7 +981,7 @@ def minimum_group_delay( def excess_group_delay( - signal: Signal, + signal: ImpulseResponse, smoothing: int = 0, remove_ir_latency: bool = False, ) -> tuple[NDArray[np.float64], NDArray[np.float64]]: @@ -987,7 +989,7 @@ def excess_group_delay( Parameters ---------- - signal : `Signal` + signal : `ImpulseResponse` IR for which to compute minimal group delay. smoothing : int, optional Octave fraction by which to apply smoothing. `0` avoids any smoothing @@ -1029,12 +1031,12 @@ def excess_group_delay( def combine_ir_with_dirac( - ir: Signal, + ir: ImpulseResponse, crossover_frequency: float, take_lower_band: bool, order: int = 8, normalization: str | None = None, -) -> Signal: +) -> ImpulseResponse: """Combine an IR with a perfect impulse at a given crossover frequency using a linkwitz-riley crossover. Forward-Backward filtering is done so that no phase distortion occurs. They can optionally be energy matched @@ -1141,10 +1143,10 @@ def combine_ir_with_dirac( def ir_to_filter( - signal: Signal, channel: int = 0, phase_mode: str = "direct" + signal: ImpulseResponse, channel: int = 0, phase_mode: str = "direct" ) -> Filter: - """This function takes in a signal with type `'ir'` or `'rir'` and turns - the selected channel into an FIR filter. With `phase_mode` it is possible + """This function takes in an impulse response and turns the selected + channel into an FIR filter. With `phase_mode` it is possible to use minimum phase or minimum linear phase. Parameters @@ -1219,7 +1221,7 @@ def filter_to_ir(fir: Filter) -> ImpulseResponse: def window_frequency_dependent( - ir: Signal, + ir: ImpulseResponse, cycles: int, channel: int | None = None, frequency_range_hz: list | None = None, @@ -1236,7 +1238,7 @@ def window_frequency_dependent( Parameters ---------- - ir : `Signal` + ir : `ImpulseResponse` Impulse response from which to extract the spectrum. cycles : int Number of cycles to include for each frequency bin. It defines @@ -1371,7 +1373,7 @@ def scaling_func(window: NDArray[np.float64]): def warp_ir( - ir: Signal, + ir: ImpulseResponse, warping_factor: float, shift_ir: bool = True, total_length: int | None = None, @@ -1383,7 +1385,7 @@ def warp_ir( Parameters ---------- - ir : `Signal` + ir : `ImpulseResponse` Impulse response to (un)warp. warping_factor : float Warping factor. It has to be in the range ]-1; 1[. @@ -1564,8 +1566,7 @@ def harmonic_distortion_analysis( smoothing: int = 12, generate_plot: bool = True, ) -> dict: - """ - Analyze non-linear distortion coming from an IR measured with an + """Analyze non-linear distortion coming from an IR measured with an exponential chirp. The range of the chirp and its length must be known. The distortion spectra of each harmonic, as well as THD+N and THD, are returned. Optionally, a plot can be generated. @@ -1620,7 +1621,7 @@ def harmonic_distortion_analysis( """ if type(ir) is list: for each_ir in ir: - assert type(each_ir) is Signal, "Unsupported type" + assert isinstance(each_ir, ImpulseResponse), "Unsupported type" assert ( each_ir.number_of_channels == 1 ), "Only single-channel IRs are supported" @@ -1634,7 +1635,7 @@ def harmonic_distortion_analysis( chirp_range_hz = [0, ir2.sampling_rate_hz // 2] passed_harmonics = True - elif type(ir) is Signal: + elif isinstance(ir, ImpulseResponse): assert ( chirp_length_s is not None and chirp_range_hz is not None @@ -1761,20 +1762,19 @@ def harmonic_distortion_analysis( def trim_ir( - ir: Signal, + ir: ImpulseResponse, channel: int = 0, start_offset_s: float = 20e-3, -) -> tuple[Signal, int, int]: - """ - Trim an IR in the beginning and end. This method acts only on one channel - and returns it trimmed. For defining the ending, a smooth envelope of the - energy time curve (ETC) is used, as well as the assumption that the energy - should decay monotonically after the impulse arrives. See notes for +) -> tuple[ImpulseResponse, int, int]: + """Trim an IR in the beginning and end. This method acts only on one + channel and returns it trimmed. For defining the ending, a smooth envelope + of the energy time curve (ETC) is used, as well as the assumption that the + energy should decay monotonically after the impulse arrives. See notes for details. Parameters ---------- - ir : `Signal` + ir : `ImpulseResponse` Impulse response to trim. channel : int, optional Channel to take from `rir`. Default: 0. @@ -1786,7 +1786,7 @@ def trim_ir( Returns ------- - trimmed_ir : `Signal` + trimmed_ir : `ImpulseResponse` IR with the new length. start : int Start index of the trimmed IR in the original vector. diff --git a/dsptoolbox/transforms/transforms.py b/dsptoolbox/transforms/transforms.py index 8a6809e..7f00e4d 100644 --- a/dsptoolbox/transforms/transforms.py +++ b/dsptoolbox/transforms/transforms.py @@ -3,6 +3,7 @@ """ from ..classes.signal import Signal +from ..classes.impulse_response import ImpulseResponse from ..classes.multibandsignal import MultiBandSignal from ..plots import general_matrix_plot from .._standard import _reconstruct_framed_signal @@ -728,7 +729,9 @@ def cwt( return scalogram -def hilbert(signal: Signal | MultiBandSignal) -> Signal | MultiBandSignal: +def hilbert( + signal: Signal | ImpulseResponse | MultiBandSignal, +) -> Signal | ImpulseResponse | MultiBandSignal: """Compute the analytic signal using the hilbert transform of the real signal. @@ -754,7 +757,7 @@ def hilbert(signal: Signal | MultiBandSignal) -> Signal | MultiBandSignal: complex_ts = Signal.time_data + Signal.time_data_imaginary*1j """ - if type(signal) is Signal: + if isinstance(signal, Signal): td = signal.time_data sp = np.fft.fft(td, axis=0) diff --git a/tests/test_classes.py b/tests/test_classes.py index cef1f81..445dd08 100644 --- a/tests/test_classes.py +++ b/tests/test_classes.py @@ -1064,3 +1064,12 @@ def test_iterator(self): ) for n in mbs: assert dsp.Signal == type(n) + + +class TestImpulseResponse: + fs_hz = 10_000 + seconds = 2 + d = dsp.generators.dirac(seconds * fs_hz, sampling_rate_hz=fs_hz) + + def test_different_things(self): + assert False diff --git a/tox.ini b/tox.ini index 7f34500..0081794 100644 --- a/tox.ini +++ b/tox.ini @@ -1,2 +1,2 @@ [flake8] -ignore = E203 +ignore = E203,W503 From e5ca46d7547f45028cb317993d1fdb98f2405208 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 17:15:13 +0200 Subject: [PATCH 28/35] room acoustics --- dsptoolbox/room_acoustics/room_acoustics.py | 37 ++++++++++----------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/dsptoolbox/room_acoustics/room_acoustics.py b/dsptoolbox/room_acoustics/room_acoustics.py index 8e5d042..81dd4d4 100644 --- a/dsptoolbox/room_acoustics/room_acoustics.py +++ b/dsptoolbox/room_acoustics/room_acoustics.py @@ -24,7 +24,7 @@ def reverb_time( - signal: Signal | MultiBandSignal, + signal: ImpulseResponse | MultiBandSignal, mode: str = "T20", ir_start: int | NDArray[np.int_] | None = None, automatic_trimming: bool = True, @@ -33,9 +33,8 @@ def reverb_time( Parameters ---------- - signal : `Signal` or `MultiBandSignal` - Signal for which to compute reverberation times. It must be type - `'ir'` or `'rir'`. + signal : `ImpulseResponse` or `MultiBandSignal` + IR for which to compute reverberation times. mode : str, optional Reverberation time mode. Options are `'Topt'`, `'T20'`, `'T30'`, `'T60'` or `'EDT'`. Default: `'Topt'`. @@ -123,7 +122,7 @@ def reverb_time( def find_modes( - signal: Signal, + signal: ImpulseResponse, f_range_hz=[50, 200], dist_hz: float = 5, prominence_db: float | None = None, @@ -134,7 +133,7 @@ def find_modes( Parameters ---------- - signal : `Signal` + signal : `ImpulseResponse` Signal containing the RIR'S from which to find the modes. f_range_hz : array-like, optional Vector setting range for mode search. Default: [50, 200]. @@ -216,7 +215,7 @@ def convolve_rir_on_signal( signal : Signal Signal to which the RIR is applied. All channels are affected. rir : ImpulseResponse - Single-channel Signal object containing the RIR. + Single-channel impulse response containing the RIR. keep_peak_level : bool, optional When `True`, output signal is normalized to the peak level of the original signal. Default: `True`. @@ -268,7 +267,7 @@ def convolve_rir_on_signal( def find_ir_start( - signal: Signal, threshold_dbfs: float = -20 + signal: ImpulseResponse, threshold_dbfs: float = -20 ) -> NDArray[np.int_]: """This function finds the start of an IR defined as the first sample before a certain threshold is surpassed. For room impulse responses, -20 @@ -276,8 +275,8 @@ def find_ir_start( Parameters ---------- - signal : `Signal` - IR signal. + signal : `ImpulseResponse` + IR. threshold_dbfs : float, optional Threshold that should be passed (in dBFS). Default: -20. @@ -309,7 +308,7 @@ def generate_synthetic_rir( apply_bandpass: bool = False, use_detailed_absorption: bool = False, max_order: int | None = None, -) -> Signal: +) -> ImpulseResponse: """This function returns a synthetized RIR in a shoebox-room using the image source model. The implementation is based on Brinkmann, et al. See References for limitations and advantages of this method. @@ -347,7 +346,7 @@ def generate_synthetic_rir( Returns ------- - rir : `Signal` + rir : `ImpulseResponse` Newly generated RIR. References @@ -427,7 +426,7 @@ def generate_synthetic_rir( rir_band = _pad_trim(rir_band, total_length_samples) # Prune possible nan values np.nan_to_num(rir_band, copy=False, nan=0) - rir0 = Signal(None, rir_band, sampling_rate_hz) + rir0 = ImpulseResponse(None, rir_band, sampling_rate_hz) rir_multi = fb.filter_signal(rir0, zero_phase=True) rir += rir_multi.bands[ind].time_data[:, 0] @@ -441,7 +440,7 @@ def generate_synthetic_rir( rir, room.mixing_time_s, room.t60_s, sr=sampling_rate_hz ) - rir_output = Signal(None, rir, sampling_rate_hz) + rir_output = ImpulseResponse(None, rir, sampling_rate_hz) # Bandpass signal in order to have a realistic audio signal representation if apply_bandpass: @@ -461,7 +460,7 @@ def generate_synthetic_rir( def descriptors( - rir: Signal | MultiBandSignal, + rir: ImpulseResponse | MultiBandSignal, mode: str = "d50", automatic_trimming_rir: bool = True, ): @@ -469,7 +468,7 @@ def descriptors( Parameters ---------- - rir : `Signal` or `MultiBandSignal` + rir : `ImpulseResponse` or `MultiBandSignal` Room impulse response. If it is a multi-channel signal, the descriptor given back has the shape (channel). If it is a `MultiBandSignal`, the descriptor has shape (band, channel). @@ -540,12 +539,12 @@ def descriptors( return desc -def _bass_ratio(rir: Signal) -> NDArray[np.float64]: +def _bass_ratio(rir: ImpulseResponse) -> NDArray[np.float64]: """Core computation of bass ratio. Parameters ---------- - rir : `Signal` + rir : `ImpulseResponse` RIR. Returns @@ -566,7 +565,7 @@ def _bass_ratio(rir: Signal) -> NDArray[np.float64]: def _check_ir_start_reverb( - sig: Signal | MultiBandSignal, + sig: ImpulseResponse | MultiBandSignal, ir_start: int | NDArray[np.int_] | list | tuple | None, ) -> NDArray[np.float64] | list | None: """This method checks `ir_start` and parses it into the necessary form From 9ca63266d7959bd5be62e94418538fdc12a79189 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 17:26:09 +0200 Subject: [PATCH 29/35] defined some more constructors for signal and ir --- dsptoolbox/classes/impulse_response.py | 99 +++++++++++++++++++++++++- dsptoolbox/classes/signal.py | 32 ++++++++- 2 files changed, 128 insertions(+), 3 deletions(-) diff --git a/dsptoolbox/classes/impulse_response.py b/dsptoolbox/classes/impulse_response.py index ee3fe75..68cfe89 100644 --- a/dsptoolbox/classes/impulse_response.py +++ b/dsptoolbox/classes/impulse_response.py @@ -15,7 +15,31 @@ def __init__( sampling_rate_hz: int | None = None, constrain_amplitude: bool = True, ): - """Impulse response.""" + """Instantiate impulse response. + + Parameters + ---------- + path : str, optional + A path to audio files. Reading is done with the soundfile library. + Wave and Flac audio files are accepted. Default: `None`. + time_data : array-like, NDArray[np.float64], optional + Time data of the signal. It is saved as a matrix with the form + (time samples, channel number). Default: `None`. + sampling_rate_hz : int, optional + Sampling rate of the signal in Hz. Default: `None`. + constrain_amplitude : bool, optional + When `True`, audio is normalized to 0 dBFS peak level in case that + there are amplitude values greater than 1. Otherwise, there is no + normalization and the audio data is not constrained to [-1, 1]. + A warning is always shown when audio gets normalized and the used + normalization factor is saved as `amplitude_scale_factor`. + Default: `True`. + + Returns + ------- + ImpulseResponse + + """ super().__init__( path, time_data, @@ -24,6 +48,79 @@ def __init__( ) self.set_spectrum_parameters(method="standard") + @staticmethod + def from_signal(signal: Signal): + """Create an impulse response from a signal. + + Parameters + ---------- + signal : `Signal` + + Returns + ------- + ImpulseResponse + + """ + ir = ImpulseResponse( + None, + signal.time_data, + signal.sampling_rate_hz, + signal.constrain_amplitude, + ) + ir.amplitude_scale_factor = signal.amplitude_scale_factor + ir.time_data_imaginary = signal.time_data_imaginary + return ir + + @staticmethod + def from_file(path: str): + """Create an impulse response from a path to a wav or flac audio file. + + Parameters + ---------- + path : str + Path to file. + + Returns + ------- + ImpulseResponse + + """ + s = Signal.from_file(path) + return ImpulseResponse.from_signal(s) + + @staticmethod + def from_time_data( + time_data: NDArray[np.float64], + sampling_rate_hz: int, + constrain_amplitude: bool = True, + ): + """Create an impulse response from an array of PCM samples. + + Parameters + ---------- + time_data : array-like, NDArray[np.float64], optional + Time data of the signal. It is saved as a matrix with the form + (time samples, channel number). Default: `None`. + sampling_rate_hz : int, optional + Sampling rate of the signal in Hz. Default: `None`. + constrain_amplitude : bool, optional + When `True`, audio is normalized to 0 dBFS peak level in case that + there are amplitude values greater than 1. Otherwise, there is no + normalization and the audio data is not constrained to [-1, 1]. + A warning is always shown when audio gets normalized and the used + normalization factor is saved as `amplitude_scale_factor`. + Default: `True`. + + Returns + ------- + ImpulseResponse + + """ + s = Signal.from_time_data( + time_data, sampling_rate_hz, constrain_amplitude + ) + return ImpulseResponse.from_signal(s) + def set_window(self, window: NDArray[np.float64]): """Sets the window used for the IR. diff --git a/dsptoolbox/classes/signal.py b/dsptoolbox/classes/signal.py index 41cc552..a84ced7 100644 --- a/dsptoolbox/classes/signal.py +++ b/dsptoolbox/classes/signal.py @@ -132,6 +132,36 @@ def from_file(path: str): """ return Signal(path) + @staticmethod + def from_time_data( + time_data: NDArray[np.float64], + sampling_rate_hz: int, + constrain_amplitude: bool = True, + ): + """Create a signal from an array of PCM samples. + + Parameters + ---------- + time_data : array-like, NDArray[np.float64], optional + Time data of the signal. It is saved as a matrix with the form + (time samples, channel number). Default: `None`. + sampling_rate_hz : int, optional + Sampling rate of the signal in Hz. Default: `None`. + constrain_amplitude : bool, optional + When `True`, audio is normalized to 0 dBFS peak level in case that + there are amplitude values greater than 1. Otherwise, there is no + normalization and the audio data is not constrained to [-1, 1]. + A warning is always shown when audio gets normalized and the used + normalization factor is saved as `amplitude_scale_factor`. + Default: `True`. + + Returns + ------- + Signal + + """ + return Signal(None, time_data, sampling_rate_hz, constrain_amplitude) + def __update_state(self): """Internal update of object state. If for instance time data gets added, new spectrum, csm or stft has to be computed. @@ -252,8 +282,6 @@ def time_vector_s(self) -> NDArray[np.float64]: @property def time_data_imaginary(self) -> NDArray[np.float64] | None: if self.__time_data_imaginary is None: - # warn('Imaginary part of time data was called, but there is ' + - # 'None. None is returned.') return None return self.__time_data_imaginary.copy() From 243f16a048dd334d481b61dbddddcd48d7aeff1e Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Thu, 1 Aug 2024 17:35:52 +0200 Subject: [PATCH 30/35] renamed files, added biquads --- dsptoolbox/classes/__init__.py | 2 +- dsptoolbox/classes/filter.py | 1746 +++++++++++------ dsptoolbox/classes/filter_class.py | 1140 ----------- dsptoolbox/classes/filter_helpers.py | 711 +++++++ dsptoolbox/classes/filterbank.py | 4 +- dsptoolbox/classes/phase_linearizer.py | 2 +- dsptoolbox/generators/generators.py | 2 +- .../transfer_functions/transfer_functions.py | 2 +- 8 files changed, 1821 insertions(+), 1788 deletions(-) delete mode 100644 dsptoolbox/classes/filter_class.py create mode 100644 dsptoolbox/classes/filter_helpers.py diff --git a/dsptoolbox/classes/__init__.py b/dsptoolbox/classes/__init__.py index 1413ddc..e9a3746 100644 --- a/dsptoolbox/classes/__init__.py +++ b/dsptoolbox/classes/__init__.py @@ -13,7 +13,7 @@ """ -from .filter_class import Filter +from .filter import Filter from .filterbank import FilterBank from .signal import Signal from .impulse_response import ImpulseResponse diff --git a/dsptoolbox/classes/filter.py b/dsptoolbox/classes/filter.py index e1aae14..2a5f07d 100644 --- a/dsptoolbox/classes/filter.py +++ b/dsptoolbox/classes/filter.py @@ -1,680 +1,1142 @@ """ -Backend for filter class and general filtering functions. +Contains Filter class """ -import numpy as np +from pickle import dump, HIGHEST_PROTOCOL from warnings import warn -from enum import Enum +from copy import deepcopy +import numpy as np +from fractions import Fraction +from matplotlib.figure import Figure +from matplotlib.axes import Axes import scipy.signal as sig -from numpy.typing import NDArray -from .signal import Signal -from .multibandsignal import MultiBandSignal -from .._general_helpers import _polyphase_decomposition - - -def _get_biquad_type(number: int | None = None, name: str | None = None): - """Helper method that handles string inputs for the biquad filters.""" - if name is not None: - name = name.lower() - valid_names = ( - "peaking", - "lowpass", - "highpass", - "bandpass_skirt", - "bandpass_peak", - "notch", - "allpass", - "lowshelf", - "highshelf", - ) - assert name in valid_names, ( - f"{name} is not a valid name. Please " - + """select from the ('peaking', 'lowpass', 'highpass', - 'bandpass_skirt', 'bandpass_peak', 'notch', 'allpass', 'lowshelf', - 'highshelf')""" - ) +from numpy.typing import NDArray, ArrayLike - class biquad(Enum): - peaking = 0 - lowpass = 1 - highpass = 2 - bandpass_skirt = 3 - bandpass_peak = 4 - notch = 5 - allpass = 6 - lowshelf = 7 - highshelf = 8 - - if number is None: - assert ( - name is not None - ), "Either number or name must be given, not both" - r = eval(f"biquad.{name}") - r = r.value - else: - assert name is None, "Either number or name must be given, not both" - r = biquad(number).name - return r - - -def _biquad_coefficients( - eq_type: int | str = 0, - fs_hz: int = 48000, - frequency_hz: float | list | tuple | NDArray[np.float64] = 1000, - gain_db: float = 0, - q: float = 1, -): - """Creates the filter coefficients for biquad filters. - eq_type: 0 PEAKING, 1 LOWPASS, 2 HIGHPASS, 3 BANDPASS_SKIRT, - 4 BANDPASS_PEAK, 5 NOTCH, 6 ALLPASS, 7 LOWSHELF, 8 HIGHSHELF. - - References - ---------- - - https://www.w3.org/TR/2021/NOTE-audio-eq-cookbook-20210608/ +from .signal import Signal +from .impulse_response import ImpulseResponse +from .filter_helpers import ( + _biquad_coefficients, + _impulse, + _group_delay_filter, + _get_biquad_type, + _filter_on_signal, + _filter_on_signal_ba, + _filter_and_downsample, + _filter_and_upsample, +) +from .plots import _zp_plot +from ..plots import general_plot +from .._general_helpers import _check_format_in_path, _pad_trim + + +class Filter: + """Class for creating and storing linear digital filters with all their + metadata. """ - # Asserts and input safety - if type(eq_type) is str: - eq_type = _get_biquad_type(None, eq_type) - # frequency_hz - frequency_hz = np.asarray(frequency_hz) - if frequency_hz.ndim > 0: - frequency_hz = np.mean(frequency_hz) - warn( - "More than one frequency was passed for biquad filter. This is " - + "not supported. A mean of passed frequencies was used for the " - + "design but this might not give the intended result!" + + # ======== Constructor and initializers =================================== + def __init__( + self, + filter_type: str = "biquad", + filter_configuration: dict | None = None, + sampling_rate_hz: int | None = None, + ): + """The Filter class contains all parameters and metadata needed for + using a digital filter. + + Constructor + ----------- + A dictionary containing the filter configuration parameters should + be passed. It is a wrapper around `scipy.signal.iirfilter`, + `scipy.signal.firwin` and `_biquad_coefficients`. See down below for + the parameters needed for creating the filters. Alternatively, you can + pass directly the filter coefficients while setting + `filter_type = "other"`. + + Parameters + ---------- + filter_type : str, optional + String defining the filter type. Options are `"iir"`, `"fir"`, + `"biquad"` or `"other"`. Default: creates a dummy biquad bell + filter with no gain. + filter_configuration : dict, optional + Dictionary containing configuration for the filter. + Default: some dummy parameters. + sampling_rate_hz : int, optional + Sampling rate in Hz for the digital filter. Default: `None`. + + Notes + ----- + For `iir`: + Keys: order, freqs, type_of_pass, filter_design_method (optional), + bandpass ripple (optional), stopband ripple (optional), + filter_id (optional). + + - order (int): Filter order + - freqs (float, array-like): array with len 2 when "bandpass" + or "bandstop". + - type_of_pass (str): "bandpass", "lowpass", "highpass", + "bandstop". + - filter_design_method (str): Default: "butter". Supported methods + are: "butter", "bessel", "ellip", "cheby1", "cheby2". + - passband_ripple (float): maximum passband ripple in dB for + "ellip" and "cheby1". + - stopband_attenuation (float): minimum stopband attenuation in dB + for "ellip" and "cheby2". + + For `fir`: + Keys: order, freqs, type_of_pass, filter_design_method (optional), + width (optional, necessary for "kaiser"), filter_id (optional). + + - order (int): Filter order, i.e., number of taps - 1. + - freqs (float, array-like): array with len 2 when "bandpass" + or "bandstop". + - type_of_pass (str): "bandpass", "lowpass", "highpass", + "bandstop". + - filter_design_method (str): Window to be used. Default: + "hamming". Supported types are: "boxcar", "triang", + "blackman", "hamming", "hann", "bartlett", "flattop", + "parzen", "bohman", "blackmanharris", "nuttall", "barthann", + "cosine", "exponential", "tukey", "taylor". + - width (float): estimated width of transition region in Hz for + kaiser window. Default: `None`. + + For `biquad`: + Keys: eq_type, freqs, gain, q, filter_id (optional). + + - eq_type (int or str): 0 = Peaking, 1 = Lowpass, 2 = Highpass, + 3 = Bandpass_skirt, 4 = Bandpass_peak, 5 = Notch, 6 = Allpass, + 7 = Lowshelf, 8 = Highshelf, 9 = Lowpass_first_order, + 10 = Highpass_first_order. + - freqs: float or array-like with length 2 (depending on eq_type). + - gain (float): in dB. + - q (float): Q-factor. + + For `other` or `general`: + Keys: ba or sos or zpk, filter_id (optional), freqs (optional). + + Methods + ------- + General + set_filter_parameters, get_filter_metadata, get_ir. + Plots or prints + show_filter_parameters, plot_magnitude, plot_group_delay, + plot_phase, plot_zp. + Filtering + filter_signal, filter_and_resample_signal. + + """ + self.warning_if_complex = True + self.sampling_rate_hz = sampling_rate_hz + if filter_configuration is None: + filter_configuration = { + "eq_type": 0, + "freqs": 1000, + "gain": 0, + "q": 1, + "filter_id": "dummy", + } + self.set_filter_parameters(filter_type.lower(), filter_configuration) + + @staticmethod + def iir_design( + order: int, + frequency_hz: float | ArrayLike, + type_of_pass: str, + filter_design_method: str, + passband_ripple_db: float | None = None, + stopband_attenuation_db: float | None = None, + sampling_rate_hz: int | None = None, + ): + """Return an IIR filter using `scipy.signal.iirfilter`. IIR filters are + always implemented as SOS by default. + + Parameters + ---------- + order : int + Filter order. + frequency_hz : float | ArrayLike + Frequency or frequencies of the filter in Hz. + type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} + Type of filter. + filter_design_method : str, {"butter", "bessel", "ellip", "cheby1",\ + "cheby2"} + Design method for the IIR filter. + passband_ripple_db : float, None, optional + Passband ripple in dB for "cheby1" and "ellip". Default: None. + stopband_attenuation_db : float, None, optional + Passband ripple in dB for "cheby2" and "ellip". Default: None. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter( + "iir", + { + "order": order, + "freqs": frequency_hz, + "type_of_pass": type_of_pass, + "filter_design_method": filter_design_method, + "passband_ripple": passband_ripple_db, + "stopband_attenuation": stopband_attenuation_db, + }, + sampling_rate_hz, ) - A = 10 ** (gain_db / 40) if eq_type in (0, 7, 8) else 10 ** (gain_db / 20) - Omega = 2.0 * np.pi * (frequency_hz / fs_hz) - sn = np.sin(Omega) - cs = np.cos(Omega) - alpha = sn / (2.0 * q) - a = np.ones(3) - b = np.ones(3) - if eq_type == 0: # Peaking - b[0] = 1 + alpha * A - b[1] = -2 * cs - b[2] = 1 - alpha * A - a[0] = 1 + alpha / A - a[1] = -2 * cs - a[2] = 1 - alpha / A - elif eq_type == 1: # Lowpass - b[0] = (1 - cs) / 2 * A - b[1] = (1 - cs) * A - b[2] = b[0] - a[0] = 1 + alpha - a[1] = -2 * cs - a[2] = 1 - alpha - elif eq_type == 2: # Highpass - b[0] = (1 + cs) / 2.0 * A - b[1] = -1 * (1 + cs) * A - b[2] = b[0] - a[0] = 1 + alpha - a[1] = -2 * cs - a[2] = 1 - alpha - elif eq_type == 3: # Bandpass skirt - b[0] = sn / 2 * A - b[1] = 0 - b[2] = -b[0] - a[0] = 1 + alpha - a[1] = -2 * cs - a[2] = 1 - alpha - elif eq_type == 4: # Bandpass peak - b[0] = alpha * A - b[1] = 0 - b[2] = -b[0] - a[0] = 1 + alpha - a[1] = -2 * cs - a[2] = 1 - alpha - elif eq_type == 5: # Notch - b[0] = 1 * A - b[1] = -2 * cs * A - b[2] = b[0] - a[0] = 1 + alpha - a[1] = -2 * cs - a[2] = 1 - alpha - elif eq_type == 6: # Allpass - b[0] = (1 - alpha) * A - b[1] = -2 * cs * A - b[2] = (1 + alpha) * A - a[0] = 1 + alpha - a[1] = -2 * cs - a[2] = 1 - alpha - elif eq_type == 7: # Lowshelf - b[0] = A * ((A + 1) - (A - 1) * cs + 2 * np.sqrt(A) * alpha) - b[1] = 2 * A * ((A - 1) - (A + 1) * cs) - b[2] = A * ((A + 1) - (A - 1) * cs - 2 * np.sqrt(A) * alpha) - a[0] = (A + 1) + (A - 1) * cs + 2 * np.sqrt(A) * alpha - a[1] = -2 * ((A - 1) + (A + 1) * cs) - a[2] = (A + 1) + (A - 1) * cs - 2 * np.sqrt(A) * alpha - elif eq_type == 8: # Highshelf - b[0] = A * ((A + 1) + (A - 1) * cs + 2 * np.sqrt(A) * alpha) - b[1] = -2 * A * ((A - 1) + (A + 1) * cs) - b[2] = A * ((A + 1) + (A - 1) * cs - 2 * np.sqrt(A) * alpha) - a[0] = (A + 1) - (A - 1) * cs + 2 * np.sqrt(A) * alpha - a[1] = 2 * ((A - 1) - (A + 1) * cs) - a[2] = (A + 1) - (A - 1) * cs - 2 * np.sqrt(A) * alpha - else: - raise Exception("eq_type not supported") - return b, a - - -def _impulse(length_samples: int = 512, delay_samples: int = 0): - """Creates an impulse with the given length - - Parameters - ---------- - length_samples : int, optional - Length for the impulse. Default: 512. - delay_samples : int, optional - Delay of the impulse. Default: 0. - - Returns - ------- - imp : NDArray[np.float64] - Impulse. - """ - imp = np.zeros(length_samples) - imp[delay_samples] = 1 - return imp - - -def _group_delay_filter(ba, length_samples: int = 512, fs_hz: int = 48000): - """Computes group delay using the method in - https://www.dsprelated.com/freebooks/filters/Phase_Group_Delay.html. - The implementation is mostly taken from `scipy.signal.group_delay` ! - - Parameters - ---------- - ba : array-like - Array containing b (numerator) and a (denominator) for filter. - length_samples : int, optional - Length for the final vector. Default: 512. - fs_hz : int, optional - Sampling frequency rate in Hz. Default: 48000. - - Returns - ------- - f : NDArray[np.float64] - Frequency vector. - gd : NDArray[np.float64] - Group delay in seconds. + @staticmethod + def biquad( + eq_type: str, + frequency_hz: float | ArrayLike, + gain_db: float, + q: float, + sampling_rate_hz: int, + ): + """Return a biquad filter according to [1]. + + Parameters + ---------- + eq_type : str, {"peaking", "lowpass", "highpass", "bandpass_skirt",\ + "bandpass_peak", "notch", "allpass", "lowshelf", "highshelf", \ + "lowpass_first_order", "highpass_first_order", "inverter"} + EQ type. + frequency_hz : float + Frequency of the biquad in Hz. + gain_db : float + Gain of biquad in dB. + q : float + Quality factor. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + Reference + --------- + - [1]: https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq- + cookbook.html. + + """ + return Filter( + "biquad", + { + "eq_type": eq_type, + "freqs": frequency_hz, + "gain": gain_db, + "q": q, + }, + sampling_rate_hz, + ) - """ - # Frequency vector at which to evaluate - omega = np.linspace(0, np.pi, length_samples) - # Turn always to FIR - c = np.convolve(ba[0], np.conjugate(ba[1][::-1])) - cr = c * np.arange(len(c)) # Ramped coefficients - # Evaluation - num = np.polyval(cr, np.exp(1j * omega)) - denum = np.polyval(c, np.exp(1j * omega)) - - # Group delay - gd = np.real(num / denum) - len(ba[1]) + 1 - - # Look for infinite values - gd[~np.isfinite(gd)] = 0 - f = omega / np.pi * (fs_hz / 2) - gd /= fs_hz - return f, gd - - -def _filter_on_signal( - signal: Signal, - sos, - channels=None, - zi=None, - zero_phase: bool = False, - warning_on_complex_output: bool = True, -): - """Takes in a `Signal` object and filters selected channels. Exports a new - `Signal` object. - - Parameters - ---------- - signal : `Signal` - Signal to be filtered. - sos : array-like - SOS coefficients of filter. - channels : int or array-like, optional - Channel or array of channels to be filtered. When `None`, all - channels are filtered. Default: `None`. - zi : array-like, optional - When not `None`, the filter state values are updated after filtering. - Default: `None`. - zero_phase : bool, optional - Uses zero-phase filtering on signal. Be aware that the filter - is doubled in this case. Default: `False`. - warning_on_complex_output: bool, optional - When `True`, there is a warning when the output is complex. Either way, - only the real part is regarded. Default: `True`. - - Returns - ------- - new_signal : `Signal` - New Signal object. - zi : list - None if passed zi was None. + @staticmethod + def fir_design( + order: int, + frequency_hz: float | ArrayLike, + type_of_pass: str, + filter_design_method: str, + width_hz: float | None = None, + sampling_rate_hz: int | None = None, + ): + """Design an FIR filter using `scipy.signal.firwin`. + + Parameters + ---------- + order : int + Filter order. It corresponds to the number of taps - 1. + frequency_hz : float | ArrayLike + Frequency or frequencies of the filter in Hz. + type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} + Type of filter. + filter_design_method : str, {"boxcar", "triang",\ + "blackman", "hamming", "hann", "bartlett", "flattop",\ + "parzen", "bohman", "blackmanharris", "nuttall", "barthann",\ + "cosine", "exponential", "tukey", "taylor"} + Design method for the FIR filter. + width_hz : float, None, optional + estimated width of transition region in Hz for kaiser window. + Default: `None`. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter( + "fir", + { + "order": order, + "freqs": frequency_hz, + "type_of_pass": type_of_pass, + "filter_design_method": filter_design_method, + "width": width_hz, + }, + sampling_rate_hz, + ) - """ - # Time Data - new_time_data = signal.time_data + @staticmethod + def from_ba( + b: ArrayLike, + a: ArrayLike, + sampling_rate_hz: int, + ): + """Create a filter from some b (numerator) and a (denominator) + coefficients. + + Parameters + ---------- + b : ArrayLike + Numerator coefficients. + a : ArrayLike + Denominator coefficients. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter("other", {"ba": [b, a]}, sampling_rate_hz) + + @staticmethod + def from_sos( + sos: NDArray[np.float64], + sampling_rate_hz: int, + ): + """Create a filter from second-order sections. + + Parameters + ---------- + sos : NDArray[np.float64] + Second-order sections. + sampling_rate_hz : int + Sampling rate in Hz. + + Returns + ------- + Filter + + """ + return Filter("other", {"sos": sos}, sampling_rate_hz) + + def initialize_zi(self, number_of_channels: int = 1): + """Initializes zi for steady-state filtering. The number of parallel + zi's can be defined externally. + + Parameters + ---------- + number_of_channels : int, optional + Number of channels is needed for the number of filter's zi's. + Default: 1. + + """ + assert ( + number_of_channels > 0 + ), """Zi's have to be initialized for at least one channel""" + self.zi = [] + if hasattr(self, "sos"): + for _ in range(number_of_channels): + self.zi.append(sig.sosfilt_zi(self.sos)) + else: + for _ in range(number_of_channels): + self.zi.append(sig.lfilter_zi(self.ba[0], self.ba[1])) - # zi unpacking - if zi is not None: - zi = np.moveaxis(np.asarray(zi), 0, -1) + @property + def sampling_rate_hz(self): + return self.__sampling_rate_hz + + @sampling_rate_hz.setter + def sampling_rate_hz(self, new_sampling_rate_hz): + assert ( + new_sampling_rate_hz is not None + ), "Sampling rate can not be None" + assert ( + type(new_sampling_rate_hz) is int + ), "Sampling rate can only be an integer" + self.__sampling_rate_hz = new_sampling_rate_hz - # Channels - if channels is None: - channels = np.arange(signal.number_of_channels) + @property + def warning_if_complex(self): + return self.__warning_if_complex - # Filtering - if zi is not None: - y, zi[:, :, channels] = sig.sosfilt( - sos, signal.time_data[:, channels], zi=zi[:, :, channels], axis=0 + @warning_if_complex.setter + def warning_if_complex(self, new_warning): + assert ( + type(new_warning) is bool + ), "This attribute must be of boolean type" + self.__warning_if_complex = new_warning + + @property + def filter_type(self): + return self.__filter_type + + @filter_type.setter + def filter_type(self, new_type: str): + assert type(new_type) is str, "Filter type must be a string" + self.__filter_type = new_type.lower() + + def __len__(self): + return self.info["order"] + 1 + + def __str__(self): + return self._get_metadata_string() + + # ======== Filtering ====================================================== + def filter_signal( + self, + signal: Signal, + channels=None, + activate_zi: bool = False, + zero_phase: bool = False, + ) -> Signal: + """Takes in a `Signal` object and filters selected channels. Exports a + new `Signal` object. + + Parameters + ---------- + signal : `Signal` + Signal to be filtered. + channels : int or array-like, optional + Channel or array of channels to be filtered. When `None`, all + channels are filtered. If only some channels are selected, these + will be filtered and the others will be bypassed (and returned). + Default: `None`. + activate_zi : int, optional + Gives the zi to update the filter values. Default: `False`. + zero_phase : bool, optional + Uses zero-phase filtering on signal. Be aware that the filter + is applied twice in this case. Default: `False`. + + Returns + ------- + new_signal : `Signal` + New Signal object. + + """ + # Check sampling rates + assert ( + self.sampling_rate_hz == signal.sampling_rate_hz + ), "Sampling rates do not match" + # Zero phase and zi + assert not (activate_zi and zero_phase), ( + "Filter initial and final values cannot be updated when " + + "filtering with zero-phase" ) - else: - if zero_phase: - y = sig.sosfiltfilt(sos, signal.time_data[:, channels], axis=0) + # Channels + if channels is None: + channels = np.arange(signal.number_of_channels) else: - y = sig.sosfilt(sos, signal.time_data[:, channels], axis=0) + channels = np.squeeze(channels) + channels = np.atleast_1d(channels) + assert ( + channels.ndim == 1 + ), "channels can be only a 1D-array or an int" + assert all(channels < signal.number_of_channels), ( + f"Selected channels ({channels}) are not valid for the " + + f"signal with {signal.number_of_channels} channels" + ) - # Check for complex output - if np.iscomplexobj(y): - if warning_on_complex_output: + # Zi – create always for all channels and selected channels will get + # updated while filtering + if activate_zi: + if not hasattr(self, "zi"): + self.initialize_zi(signal.number_of_channels) + if len(self.zi) != signal.number_of_channels: + warn( + "zi values of the filter have not been correctly " + + "intialized for the number of channels. They have now" + + " been corrected" + ) + self.initialize_zi(signal.number_of_channels) + zi_old = self.zi + else: + zi_old = None + + # Check filter length compared to signal + if self.info["order"] > signal.time_data.shape[0]: warn( - "Filter output is complex. Imaginary part is saved in " - + "Signal as time_data_imaginary" + "Filter is longer than signal, results might be " + + "meaningless!" ) - new_time_data = new_time_data.astype(np.complex128) - - # Create new signal - new_time_data[:, channels] = y - new_signal = signal.copy() - new_signal.time_data = new_time_data - - # zi packing - if zi is not None: - zi_new = [] - for n in range(signal.number_of_channels): - zi_new.append(zi[:, :, n]) - return new_signal, zi - - -def _filter_on_signal_ba( - signal: Signal, - ba, - channels=None, - zi: list | None = None, - zero_phase: bool = False, - filter_type: str = "iir", - warning_on_complex_output: bool = True, -): - """Takes in a `Signal` object and filters selected channels. Exports a new - `Signal` object. - - Parameters - ---------- - signal : `Signal` - Signal to be filtered. - ba : list - List with ba coefficients of filter. Form ba=[b, a] where b and a - are of type NDArray[np.float64]. - channels : array-like, optional - Channel or array of channels to be filtered. When `None`, all - channels are filtered. Default: `None`. - zi : list, optional - When not `None`, the filter state values are updated after filtering. - They should be passed as a list with the zi 1D-arrays. - Default: `None`. - zero_phase : bool, optional - Uses zero-phase filtering on signal. Be aware that the filter - is doubled in this case. Default: `False`. - filter_type : str, optional - Filter type. When FIR, an own implementation of lfilter is used, - otherwise scipy.signal.lfilter is used. Default: `'iir'`. - warning_on_complex_output: bool, optional - When `True`, there is a warning when the output is complex. Either way, - only the real part is regarded. Default: `True`. - - Returns - ------- - new_signal : `Signal` - New Signal object. - zi : list - None if passed zi was None. - """ - # Take lfilter function, might be a different one depending if filter is - # FIR or IIR - if filter_type == "fir": - lfilter = _lfilter_fir - elif filter_type in ("iir", "biquad"): - lfilter = sig.lfilter - else: - raise ValueError( - f"{filter_type} is not supported. Use either fir or iir" - ) - - # Time Data - new_time_data = signal.time_data - - # zi unpacking - if zi is not None: - zi = np.asarray(zi).T - - # Channels - if channels is None: - channels = np.arange(signal.number_of_channels) - - # Filtering - if zi is not None: - y, zi[:, channels] = lfilter( - ba[0], - a=ba[1], - x=signal.time_data[:, channels], - zi=zi[:, channels], - axis=0, - ) - else: - if zero_phase: - y = sig.filtfilt( - b=ba[0], a=ba[1], x=signal.time_data[:, channels], axis=0 + # Filter with SOS when possible + if hasattr(self, "sos"): + new_signal, zi_new = _filter_on_signal( + signal=signal, + sos=self.sos, + channels=channels, + zi=zi_old, + zero_phase=zero_phase, + warning_on_complex_output=self.warning_if_complex, ) else: - y = lfilter( - ba[0], a=ba[1], x=signal.time_data[:, channels], axis=0 + # Filter with ba + new_signal, zi_new = _filter_on_signal_ba( + signal=signal, + ba=self.ba, + channels=channels, + zi=zi_old, + zero_phase=zero_phase, + filter_type=self.filter_type, + warning_on_complex_output=self.warning_if_complex, ) + if activate_zi: + self.zi = zi_new + return new_signal + + def filter_and_resample_signal( + self, signal: Signal, new_sampling_rate_hz: int + ) -> Signal: + """Filters and resamples signal. This is only available for all + channels and sampling rates that are achievable by (only) down- or + upsampling. This method is for allowing specific filters to be + decimators/interpolators. If you just want to resample a signal, + use the function in the standard module. + + If this filter is iir, standard resampling is applied. If it is + fir, an efficient polyphase representation will be used. + + NOTE: Beware that no additional lowpass filter is used in the + resampling step which can lead to aliases or other effects if this + Filter is not adequate! + + Parameters + ---------- + signal : `Signal` + Signal to be filtered and resampled. + new_sampling_rate_hz : int + New sampling rate to resample to. + + Returns + ------- + new_sig : `Signal` + New down- or upsampled signal. + + """ + fraction = Fraction( + new_sampling_rate_hz, signal.sampling_rate_hz + ).as_integer_ratio() + assert fraction[0] == 1 or fraction[1] == 1, ( + f"{new_sampling_rate_hz} is not valid because it needs down- " + + f"AND upsampling (Up/Down: {fraction[0]}/{fraction[1]})" + ) - # Check for complex output - if np.iscomplexobj(y): - if warning_on_complex_output: - warn( - "Filter output is complex. Imaginary part is saved in " - + "Signal as time_data_imaginary" + # Check if standard or polyphase representation is to be used + if self.filter_type == "fir": + polyphase = True + elif self.filter_type in ("iir", "biquad"): + if not hasattr(self, "ba"): + self.ba: list = list(sig.sos2tf(self.sos)) + polyphase = False + else: + raise ValueError("Wrong filter type for filtering and resampling") + + # Check if down- or upsampling is required + if fraction[0] == 1: + assert ( + signal.sampling_rate_hz == self.sampling_rate_hz + ), "Sampling rates do not match" + new_time_data = _filter_and_downsample( + time_data=signal.time_data, + down_factor=fraction[1], + ba_coefficients=self.ba, + polyphase=polyphase, + ) + elif fraction[1] == 1: + assert ( + signal.sampling_rate_hz * fraction[0] == self.sampling_rate_hz + ), ( + "Sampling rates do not match. For the upsampler, the " + + """sampling rate of the filter should match the output's""" + ) + new_time_data = _filter_and_upsample( + time_data=signal.time_data, + up_factor=fraction[0], + ba_coefficients=self.ba, + polyphase=polyphase, ) - new_time_data = new_time_data.astype(np.complex128) - - # Create new signal - new_time_data[:, channels] = y - new_signal = signal.copy() - new_signal.time_data = new_time_data - - # zi packing - if zi is not None: - zi_new = [] - for n in range(zi.shape[1]): - zi_new.append(zi[:, n]) - return new_signal, zi - - -def _filterbank_on_signal( - signal: Signal, - filters, - activate_zi: bool = False, - mode: str = "parallel", - zero_phase: bool = False, - same_sampling_rate: bool = True, -): - """Applies filter bank on a given signal. - - Parameters - ---------- - signal : `Signal` - Signal to be filtered. - filters : list - List containing filters to be applied to signal. - activate_zi : bool, optional - When `True`, the filter initial values for each channel are updated - while filtering. Default: `None`. - mode : str, optional - Mode of filtering. Choose from `'parallel'`, `'sequential'` and - `'summed'`. Default: `'parallel'`. - zero_phase : bool, optional - Uses zero-phase filtering on signal. Be aware that the filter order - is doubled in this case. Default: `False`. - same_sampling_rate : bool, optional - When `True`, the output MultiBandSignal (parallel filtering) has - same sampling rate for all bands. Default: `True`. - - Returns - ------- - new_signal : `Signal` or `MultiBandSignal` - New Signal object. - """ - n_filt = len(filters) - if mode == "parallel": - ss = [] - for n in range(n_filt): - ss.append( - filters[n].filter_signal( - signal, activate_zi=activate_zi, zero_phase=zero_phase + new_sig = signal.copy() + if hasattr(new_sig, "window"): + del new_sig.window + new_sig.sampling_rate_hz = new_sampling_rate_hz + new_sig.time_data = new_time_data + return new_sig + + # ======== Setters ======================================================== + def set_filter_parameters( + self, filter_type: str, filter_configuration: dict + ): + if filter_type == "iir": + if "filter_design_method" not in filter_configuration: + filter_configuration["filter_design_method"] = "butter" + if "passband_ripple" not in filter_configuration: + filter_configuration["passband_ripple"] = None + if "stopband_attenuation" not in filter_configuration: + filter_configuration["stopband_attenuation"] = None + self.sos = sig.iirfilter( + N=filter_configuration["order"], + Wn=filter_configuration["freqs"], + btype=filter_configuration["type_of_pass"], + analog=False, + fs=self.sampling_rate_hz, + ftype=filter_configuration["filter_design_method"], + rp=filter_configuration["passband_ripple"], + rs=filter_configuration["stopband_attenuation"], + output="sos", + ) + self.filter_type = filter_type + elif filter_type == "fir": + # Preparing parameters + if "filter_design_method" not in filter_configuration: + filter_configuration["filter_design_method"] = "hamming" + if "width" not in filter_configuration: + filter_configuration["width"] = None + # Filter creation + self.ba = [ + sig.firwin( + numtaps=filter_configuration["order"] + 1, + cutoff=filter_configuration["freqs"], + window=filter_configuration["filter_design_method"], + width=filter_configuration["width"], + pass_zero=filter_configuration["type_of_pass"], + fs=self.sampling_rate_hz, + ), + np.asarray([1]), + ] + self.filter_type = filter_type + elif filter_type == "biquad": + # Preparing parameters + if type(filter_configuration["eq_type"]) is str: + filter_configuration["eq_type"] = _get_biquad_type( + None, filter_configuration["eq_type"] ) + # Filter creation + self.ba = _biquad_coefficients( + eq_type=filter_configuration["eq_type"], + fs_hz=self.sampling_rate_hz, + frequency_hz=filter_configuration["freqs"], + gain_db=filter_configuration["gain"], + q=filter_configuration["q"], ) - out_sig = MultiBandSignal(ss, same_sampling_rate=same_sampling_rate) - elif mode == "sequential": - out_sig = signal.copy() - for n in range(n_filt): - out_sig = filters[n].filter_signal( - out_sig, activate_zi=activate_zi, zero_phase=zero_phase + # Setting back + filter_configuration["eq_type"] = _get_biquad_type( + filter_configuration["eq_type"] + ).capitalize() + filter_configuration["order"] = ( + max(len(self.ba[0]), len(self.ba[1])) - 1 ) - else: - new_time_data = np.zeros( - (signal.time_data.shape[0], signal.number_of_channels, n_filt) - ) - for n in range(n_filt): - s = filters[n].filter_signal( - signal, activate_zi=activate_zi, zero_phase=zero_phase + self.filter_type = filter_type + else: + assert ( + ("ba" in filter_configuration) + ^ ("sos" in filter_configuration) + ^ ("zpk" in filter_configuration) + ), ( + "Only (and at least) one type of filter coefficients " + + "should be passed to create a filter" ) - new_time_data[:, :, n] = s.time_data - new_time_data = np.sum(new_time_data, axis=-1) - out_sig = signal.copy() - out_sig.time_data = new_time_data - return out_sig - - -def _lfilter_fir( - b: NDArray[np.float64], - a: NDArray[np.float64], - x: NDArray[np.float64], - zi: NDArray[np.float64] | None = None, - axis: int = 0, -): - """Variant to the `scipy.signal.lfilter` that uses `scipy.signal.convolve` - for filtering. The advantage of this is that the convolution will be - automatically made using fft or direct, depending on the inputs' sizes. - This is only used for FIR filters. - - The `axis` parameter is only there for compatibility with - `scipy.signal.lfilter`, but the first axis is always used. - - """ - assert ( - len(a) == 1 - ), f"{a} is not valid. It has to be 1 in order to be a valid FIR filter" - - # b dimensions handling - if b.ndim != 1: - b = np.squeeze(b) - assert b.ndim == 1, "FIR Filters for audio must be 1D-arrays" - - # Dimensions of zi and x must match - if zi is not None: - assert zi.ndim == x.ndim, ( - "Vector to filter and initial values should have the same " - + "number of dimensions!" - ) - if x.ndim < 2: - x = x[..., None] - if zi is not None: - zi = zi[..., None] - assert x.ndim == 2, "Filtering only works on 2D-arrays" - - # Convolving - y = sig.convolve(x, b[..., None], mode="full") - - # Use zi's and take zf's - if zi is not None: - y[: zi.shape[0], :] += zi - zf = y[-zi.shape[0] :, :] - - # Trim output - y = y[: x.shape[0], :] - if zi is None: - return y - return y, zf - - -def _filter_and_downsample( - time_data: NDArray[np.float64], - down_factor: int, - ba_coefficients: list, - polyphase: bool, -) -> NDArray[np.float64]: - """Filters and downsamples time data. If polyphase is `True`, it is - assumed that the filter is FIR and only b-coefficients are used. In - that case, an efficient downsampling is done, otherwise standard filtering - and downsampling is applied. - - Parameters - ---------- - time_data : NDArray[np.float64] - Time data to be filtered and resampled. Shape should be (time samples, - channels). - down_factor : int - Factor by which it will be downsampled. - ba_coefficients : list - List containing [b, a] coefficients. If polyphase is set to `True`, - only b coefficients are regarded. - polyphase : bool - Use polyphase representation or not. - - Returns - ------- - new_time_data : NDArray[np.float64] - New time data with downsampling. - - """ - if time_data.ndim == 1: - time_data = time_data[..., None] - assert ( - time_data.ndim == 2 - ), "Shape for time data should be (time samples, channels)" - - if polyphase: - poly, _ = _polyphase_decomposition(time_data, down_factor, flip=False) - # (time samples, polyphase components, channels) - # Polyphase representation of filter and filter length - b = ba_coefficients[0] - half_length = (len(b) - 1) // 2 - b_poly, _ = _polyphase_decomposition(b, down_factor, flip=True) - new_time_data = np.zeros( - (poly.shape[0] + b_poly.shape[0] - 1, poly.shape[2]) - ) - # Accumulator for each channel – it would be better to find a way - # to do it without loops, but using scipy.signal.convolve since it - # is advantageous compared to numpy.convolve - for ch in range(poly.shape[2]): - temp = np.zeros(new_time_data.shape[0]) - for n in range(poly.shape[1]): - temp += sig.convolve( - poly[:, n, ch], b_poly[:, n, 0], mode="full" + if "ba" in filter_configuration: + b, a = filter_configuration["ba"] + self.ba = [np.atleast_1d(b), np.atleast_1d(a)] + filter_configuration["order"] = ( + max(len(self.ba[0]), len(self.ba[1])) - 1 ) - new_time_data[:, ch] = temp - # Take correct values from vector - new_time_data = new_time_data[ - half_length // down_factor : -half_length // down_factor, : - ] - else: - new_time_data = sig.lfilter( - ba_coefficients[0], ba_coefficients[1], x=time_data, axis=0 - ) - new_time_data = new_time_data[::down_factor] - - return new_time_data - - -def _filter_and_upsample( - time_data: NDArray[np.float64], - up_factor: int, - ba_coefficients: list, - polyphase: bool, -): - """Filters and upsamples time data. If polyphase is `True`, it is - assumed that the filter is FIR and only b-coefficients are used. In - that case, an efficient polyphase upsampling is done, otherwise standard - upsampling and filtering is applied. - - NOTE: The polyphase implementation uses two loops: once for the polyphase - components and once for the channels. Hence, it might not be much faster - than usual filtering. - - Parameters - ---------- - time_data : NDArray[np.float64] - Time data to be filtered and resampled. Shape should be (time samples, - channels). - up_factor : int - Factor by which it will be upsampled. - ba_coefficients : list - List containing [b, a] coefficients. If polyphase is set to `True`, - only b coefficients are regarded. - polyphase : bool - Use polyphase representation or not. - - Returns - ------- - new_time_data : NDArray[np.float64] - New time data with downsampling. + if "zpk" in filter_configuration: + z, p, k = filter_configuration["zpk"] + self.sos = sig.zpk2sos(z, p, k, analog=False) + filter_configuration["order"] = len(self.sos) * 2 - 1 + if "sos" in filter_configuration: + self.sos = filter_configuration["sos"] + filter_configuration["order"] = len(self.sos) * 2 - 1 + # Change filter type to 'fir' or 'iir' depending on coefficients + self._check_and_update_filter_type() + + # Update Metadata about the Filter + self.info: dict = filter_configuration + self.info["sampling_rate_hz"] = self.sampling_rate_hz + self.info["filter_type"] = self.filter_type + if hasattr(self, "ba"): + self.info["preferred_method_of_filtering"] = "ba" + elif hasattr(self, "sos"): + self.info["preferred_method_of_filtering"] = "sos" + if "filter_id" not in self.info: + self.info["filter_id"] = None + + # ======== Check type ===================================================== + def _check_and_update_filter_type(self): + """Internal method to check filter type (if FIR or IIR) and update + its filter type. + + """ + # Get filter coefficients + if hasattr(self, "ba"): + b, a = self.ba[0], self.ba[1] + elif hasattr(self, "sos"): + b, a = sig.sos2tf(self.sos) + # Trim zeros for a + a = np.atleast_1d(np.trim_zeros(a)) + # Check length of a coefficients and decide filter type + if len(a) == 1: + b /= a[0] + a = a / a[0] + self.filter_type = "fir" + else: + self.filter_type = "iir" + + # ======== Getters ======================================================== + def get_filter_metadata(self): + """Returns filter metadata. + + Returns + ------- + info : dict + Dictionary containing all filter metadata. + + """ + return self.info + + def _get_metadata_string(self): + """Helper for creating a string containing all filter info.""" + txt = f"""Filter – ID: {self.info["filter_id"]}\n""" + temp = "" + for n in range(len(txt)): + temp += "-" + txt += temp + "\n" + for k in self.info.keys(): + if k == "ba": + continue + txt += f"""{str(k).replace("_", " "). + capitalize()}: {self.info[k]}\n""" + return txt + + def get_ir( + self, length_samples: int = 512, zero_phase: bool = False + ) -> ImpulseResponse: + """Gets an impulse response of the filter with given length. + + Parameters + ---------- + length_samples : int, optional + Length for the impulse response in samples. Default: 512. + + Returns + ------- + ir_filt : `ImpulseResponse` + Impulse response of the filter. + + """ + # FIR with no zero phase filtering + if self.filter_type == "fir" and not zero_phase: + b = self.ba[0].copy() + if length_samples < len(b): + warn( + f"{length_samples} is not enough for filter with " + + f"length {len(b)}. IR will have the latter length." + ) + length_samples = len(b) + b = _pad_trim(b, length_samples) + return ImpulseResponse( + None, b, self.sampling_rate_hz, constrain_amplitude=False + ) - """ - if time_data.ndim == 1: - time_data = time_data[..., None] - assert ( - time_data.ndim == 2 - ), "Shape for time data should be (time samples, channels)" - - if polyphase: - b = ba_coefficients[0] - half_length = (len(b) - 1) // 2 - - # Decompose filter - b_poly, padding = _polyphase_decomposition(b, up_factor) - b_poly *= up_factor - - # Accumulator – Length is not right! - new_time_data = np.zeros( - ( - (time_data.shape[0] + b_poly.shape[0] - 1) * up_factor, - time_data.shape[1], + # IIR or zero phase IR + ir_filt = _impulse(length_samples) + ir_filt = ImpulseResponse( + None, + ir_filt, + self.sampling_rate_hz, + constrain_amplitude=False, + ) + return self.filter_signal(ir_filt, zero_phase=zero_phase) + + def get_transfer_function( + self, frequency_vector_hz: NDArray[np.float64] + ) -> NDArray[np.complex128]: + """Obtain the complex transfer function of the filter analytically + evaluated for a given frequency vector. + + Parameters + ---------- + frequency_vector_hz : NDArray[np.float64] + Frequency vector for which to compute the transfer function + + Returns + ------- + NDArray[np.complex128] + Complex transfer function + + Notes + ----- + - This method uses scipy's freqz to compute the transfer function. In + the case of FIR filters, it might be significantly faster and more + precise to use a direct FFT approach. + + """ + assert ( + frequency_vector_hz.ndim == 1 + ), "Frequency vector can only have one dimension" + assert ( + frequency_vector_hz.max() <= self.sampling_rate_hz / 2 + ), "Queried frequency vector has values larger than nyquist" + if self.filter_type in ("iir", "biquad"): + if hasattr(self, "sos"): + return sig.sosfreqz( + self.sos, frequency_vector_hz, fs=self.sampling_rate_hz + )[1] + return sig.freqz( + self.ba[0], + self.ba[1], + frequency_vector_hz, + fs=self.sampling_rate_hz, + )[1] + + # FIR + return sig.freqz( + self.ba[0], [1], frequency_vector_hz, self.sampling_rate_hz + )[1] + + def get_coefficients( + self, mode: str = "sos" + ) -> ( + list[NDArray[np.float64]] + | NDArray[np.float64] + | tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] + | None + ): + """Returns the filter coefficients. + + Parameters + ---------- + mode : str, optional + Type of filter coefficients to be returned. Choose from `"sos"`, + `"ba"` or `"zpk"`. Default: `"sos"`. + + Returns + ------- + coefficients : array-like + Array with filter coefficients with shape depending on mode: + - `"ba"`: list(b, a) with b and a of type NDArray[np.float64]. + - `"sos"`: NDArray[np.float64] with shape (n_sections, 6). + - `"zpk"`: tuple(z, p, k) with z, p, k of type NDArray[np.float64] + - Return `None` if user decides that ba->sos is too costly. The + threshold is for filters with order > 500. + + """ + if mode == "sos": + if hasattr(self, "sos"): + coefficients = self.sos.copy() + else: + if self.info["order"] > 500: + inp = None + while inp not in ("y", "n"): + inp = input( + "This filter has a large order " + + f"""({self.info['order']}). Are you sure you """ + + "want to get sos? Computation might" + + " take long time. (y/n)" + ) + inp = inp.lower() + if inp == "y": + break + if inp == "n": + return None + coefficients = sig.tf2sos(self.ba[0], self.ba[1]) + elif mode == "ba": + if hasattr(self, "sos"): + coefficients = sig.sos2tf(self.sos) + else: + coefficients = deepcopy(self.ba) + elif mode == "zpk": + if hasattr(self, "sos"): + coefficients = sig.sos2zpk(self.sos) + else: + # Check if filter is too long + if self.info["order"] > 500: + inp = None + while inp not in ("y", "n"): + inp = input( + "This filter has a large order " + + f"""({self.info['order']}). Are you sure you """ + + "want to get zeros and poles? Computation might" + + " take long time. (y/n)" + ) + inp = inp.lower() + if inp == "y": + break + if inp == "n": + return None + coefficients = sig.tf2zpk(self.ba[0], self.ba[1]) + else: + raise ValueError(f"{mode} is not valid. Use sos, ba or zpk") + return coefficients + + # ======== Plots and prints =============================================== + def show_info(self): + """Prints all the filter parameters to the console.""" + print(self._get_metadata_string()) + + def plot_magnitude( + self, + length_samples: int = 512, + range_hz=[20, 20e3], + normalize: str | None = None, + show_info_box: bool = True, + zero_phase: bool = False, + ): + """Plots magnitude spectrum. + Change parameters of spectrum with set_spectrum_parameters. + + Parameters + ---------- + length_samples : int, optional + Length of ir for magnitude plot. Default: 512. + range_hz : array-like with length 2, optional + Range for which to plot the magnitude response. + Default: [20, 20000]. + normalize : str, optional + Mode for normalization, supported are `"1k"` for normalization + with value at frequency 1 kHz or `"max"` for normalization with + maximal value. Use `None` for no normalization. Default: `None`. + show_info_box : bool, optional + Shows an information box on the plot. Default: `True`. + zero_phase : bool, optional + Plots magnitude for zero phase filtering. Default: `False`. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : `matplotlib.axes.Axes` + Axes. + + """ + if self.info["order"] > length_samples: + length_samples = self.info["order"] + 100 + warn( + f"length_samples ({length_samples}) is shorter than the " + + f"""filter order {self.info['order']}. Length will be """ + + "automatically extended." + ) + ir = self.get_ir(length_samples=length_samples, zero_phase=zero_phase) + fig, ax = ir.plot_magnitude(range_hz, normalize, show_info_box=False) + if show_info_box: + txt = self._get_metadata_string() + ax.text( + 0.1, + 0.5, + txt, + transform=ax.transAxes, + verticalalignment="top", + bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), ) + return fig, ax + + def plot_group_delay( + self, + length_samples: int = 512, + range_hz=[20, 20e3], + show_info_box: bool = False, + ) -> tuple[Figure, Axes]: + """Plots group delay of the filter. Different methods are used for + FIR or IIR filters. + + Parameters + ---------- + length_samples : int, optional + Length of ir for magnitude plot. Default: 512. + range_hz : array-like with length 2, optional + Range for which to plot the magnitude response. + Default: [20, 20000]. + show_info_box : bool, optional + Shows an information box on the plot. Default: `False`. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : `matplotlib.axes.Axes` + Axes. + + """ + if self.info["order"] > length_samples: + length_samples = self.info["order"] + 100 + warn( + f"length_samples ({length_samples}) is shorter than the " + + f"""filter order {self.info['order']}. Length will be """ + + "automatically extended." + ) + if hasattr(self, "sos"): + ba = sig.sos2tf(self.sos) + else: + ba = self.ba + f, gd = _group_delay_filter(ba, length_samples, self.sampling_rate_hz) + gd *= 1e3 + ymax = None + ymin = None + if any(abs(gd) > 50): + ymin = -2 + ymax = 50 + fig, ax = general_plot( + x=f, + matrix=gd[..., None], + range_x=range_hz, + range_y=[ymin, ymax], + ylabel="Group delay / ms", + returns=True, ) - - # Interpolate per channel and per polyphase component – should be - # a better way to do it without the loops... - for ch in range(time_data.shape[1]): - for ind in range(up_factor): - new_time_data[ind::up_factor, ch] = sig.convolve( - time_data[:, ch], b_poly[:, ind, 0], mode="full" + if show_info_box: + txt = self._get_metadata_string() + ax.text( + 0.1, + 0.5, + txt, + transform=ax.transAxes, + verticalalignment="top", + bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), + ) + return fig, ax + + def plot_phase( + self, + length_samples: int = 512, + range_hz=[20, 20e3], + unwrap: bool = False, + show_info_box: bool = False, + ) -> tuple[Figure, Axes]: + """Plots phase spectrum. + + Parameters + ---------- + length_samples : int, optional + Length of ir for magnitude plot. Default: 512. + range_hz : array-like with length 2, optional + Range for which to plot the magnitude response. + Default: [20, 20000]. + unwrap : bool, optional + Unwraps the phase to show. Default: `False`. + show_info_box : bool, optional + Shows an information box on the plot. Default: `False`. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : `matplotlib.axes.Axes` + Axes. + + """ + if self.info["order"] > length_samples: + length_samples = self.info["order"] + 1 + warn( + f"length_samples ({length_samples}) is shorter than the " + + f"""filter order {self.info['order']}. Length will be """ + + "automatically extended." + ) + ir = self.get_ir(length_samples=length_samples) + fig, ax = ir.plot_phase(range_hz, unwrap) + if show_info_box: + txt = self._get_metadata_string() + ax.text( + 0.1, + 0.5, + txt, + transform=ax.transAxes, + verticalalignment="top", + bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), + ) + return fig, ax + + def plot_zp( + self, show_info_box: bool = False + ) -> tuple[Figure, Axes] | None: + """Plots zeros and poles with the unit circle. This returns `None` and + produces no plot if user decides that conversion ba->sos is too costly. + + Parameters + ---------- + show_info_box : bool, optional + Shows an information box on the plot. Default: `False`. + + Returns + ------- + fig : `matplotlib.figure.Figure` + Figure. + ax : `matplotlib.axes.Axes` + Axes. + + """ + # Ask explicitely if filter is very long + if self.info["order"] > 500: + inp = None + while inp not in ("y", "n"): + inp = input( + "This filter has a large order " + + f"""({self.info['order']}). Are you sure you want to""" + + " plot zeros and poles? Computation might take long " + + "time. (y/n)" ) - - # Take right samples from filtered signal - if padding == up_factor: - new_time_data = new_time_data[half_length:-half_length, :] + inp = inp.lower() + if inp == "y": + break + if inp == "n": + return None + # + if hasattr(self, "sos"): + z, p, k = sig.sos2zpk(self.sos) else: - new_time_data = new_time_data[ - half_length + padding : -half_length + padding, : - ] - else: - new_time_data = np.zeros( - (time_data.shape[0] * up_factor, time_data.shape[1]) + z, p, k = sig.tf2zpk(self.ba[0], self.ba[1]) + fig, ax = _zp_plot(z, p, returns=True) + ax.text( + 0.75, + 0.91, + rf"$k={k:.1e}$", + transform=ax.transAxes, + verticalalignment="top", ) - new_time_data[::up_factor] = time_data - new_time_data = sig.lfilter( - ba_coefficients[0], ba_coefficients[1], x=new_time_data, axis=0 - ) - return new_time_data + if show_info_box: + txt = self._get_metadata_string() + ax.text( + 0.1, + 0.5, + txt, + transform=ax.transAxes, + verticalalignment="top", + bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), + ) + return fig, ax + + # ======== Saving and export ============================================== + def save_filter(self, path: str = "filter"): + """Saves the Filter object as a pickle. + + Parameters + ---------- + path : str, optional + Path for the filter to be saved. Use only folder1/folder2/name + (it can be passed with .pkl at the end or without it). + Default: `"filter"` (local folder, object named filter). + + """ + path = _check_format_in_path(path, "pkl") + with open(path, "wb") as data_file: + dump(self, data_file, HIGHEST_PROTOCOL) + + def copy(self): + """Returns a copy of the object. + + Returns + ------- + new_sig : `Filter` + Copy of filter. + + """ + return deepcopy(self) diff --git a/dsptoolbox/classes/filter_class.py b/dsptoolbox/classes/filter_class.py deleted file mode 100644 index b6608db..0000000 --- a/dsptoolbox/classes/filter_class.py +++ /dev/null @@ -1,1140 +0,0 @@ -""" -Contains Filter class -""" - -from pickle import dump, HIGHEST_PROTOCOL -from warnings import warn -from copy import deepcopy -import numpy as np -from fractions import Fraction -from matplotlib.figure import Figure -from matplotlib.axes import Axes -import scipy.signal as sig -from numpy.typing import NDArray, ArrayLike - -from .signal import Signal -from .impulse_response import ImpulseResponse -from .filter import ( - _biquad_coefficients, - _impulse, - _group_delay_filter, - _get_biquad_type, - _filter_on_signal, - _filter_on_signal_ba, - _filter_and_downsample, - _filter_and_upsample, -) -from .plots import _zp_plot -from ..plots import general_plot -from .._general_helpers import _check_format_in_path, _pad_trim - - -class Filter: - """Class for creating and storing linear digital filters with all their - metadata. - - """ - - # ======== Constructor and initializers =================================== - def __init__( - self, - filter_type: str = "biquad", - filter_configuration: dict | None = None, - sampling_rate_hz: int | None = None, - ): - """The Filter class contains all parameters and metadata needed for - using a digital filter. - - Constructor - ----------- - A dictionary containing the filter configuration parameters should - be passed. It is a wrapper around `scipy.signal.iirfilter`, - `scipy.signal.firwin` and `_biquad_coefficients`. See down below for - the parameters needed for creating the filters. Alternatively, you can - pass directly the filter coefficients while setting - `filter_type = "other"`. - - Parameters - ---------- - filter_type : str, optional - String defining the filter type. Options are `"iir"`, `"fir"`, - `"biquad"` or `"other"`. Default: creates a dummy biquad bell - filter with no gain. - filter_configuration : dict, optional - Dictionary containing configuration for the filter. - Default: some dummy parameters. - sampling_rate_hz : int, optional - Sampling rate in Hz for the digital filter. Default: `None`. - - Notes - ----- - For `iir`: - Keys: order, freqs, type_of_pass, filter_design_method (optional), - bandpass ripple (optional), stopband ripple (optional), - filter_id (optional). - - - order (int): Filter order - - freqs (float, array-like): array with len 2 when "bandpass" - or "bandstop". - - type_of_pass (str): "bandpass", "lowpass", "highpass", - "bandstop". - - filter_design_method (str): Default: "butter". Supported methods - are: "butter", "bessel", "ellip", "cheby1", "cheby2". - - passband_ripple (float): maximum passband ripple in dB for - "ellip" and "cheby1". - - stopband_attenuation (float): minimum stopband attenuation in dB - for "ellip" and "cheby2". - - For `fir`: - Keys: order, freqs, type_of_pass, filter_design_method (optional), - width (optional, necessary for "kaiser"), filter_id (optional). - - - order (int): Filter order, i.e., number of taps - 1. - - freqs (float, array-like): array with len 2 when "bandpass" - or "bandstop". - - type_of_pass (str): "bandpass", "lowpass", "highpass", - "bandstop". - - filter_design_method (str): Window to be used. Default: - "hamming". Supported types are: "boxcar", "triang", - "blackman", "hamming", "hann", "bartlett", "flattop", - "parzen", "bohman", "blackmanharris", "nuttall", "barthann", - "cosine", "exponential", "tukey", "taylor". - - width (float): estimated width of transition region in Hz for - kaiser window. Default: `None`. - - For `biquad`: - Keys: eq_type, freqs, gain, q, filter_id (optional). - - - eq_type (int or str): 0 = Peaking, 1 = Lowpass, 2 = Highpass, - 3 = Bandpass_skirt, 4 = Bandpass_peak, 5 = Notch, 6 = Allpass, - 7 = Lowshelf, 8 = Highshelf. - - freqs: float or array-like with length 2 (depending on eq_type). - - gain (float): in dB. - - q (float): Q-factor. - - For `other` or `general`: - Keys: ba or sos or zpk, filter_id (optional), freqs (optional). - - Methods - ------- - General - set_filter_parameters, get_filter_metadata, get_ir. - Plots or prints - show_filter_parameters, plot_magnitude, plot_group_delay, - plot_phase, plot_zp. - Filtering - filter_signal, filter_and_resample_signal. - - """ - self.warning_if_complex = True - self.sampling_rate_hz = sampling_rate_hz - if filter_configuration is None: - filter_configuration = { - "eq_type": 0, - "freqs": 1000, - "gain": 0, - "q": 1, - "filter_id": "dummy", - } - self.set_filter_parameters(filter_type.lower(), filter_configuration) - - @staticmethod - def iir_design( - order: int, - frequency_hz: float | ArrayLike, - type_of_pass: str, - filter_design_method: str, - passband_ripple_db: float | None = None, - stopband_attenuation_db: float | None = None, - sampling_rate_hz: int | None = None, - ): - """Return an IIR filter using `scipy.signal.iirfilter`. IIR filters are - always implemented as SOS by default. - - Parameters - ---------- - order : int - Filter order. - frequency_hz : float | ArrayLike - Frequency or frequencies of the filter in Hz. - type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} - Type of filter. - filter_design_method : str, {"butter", "bessel", "ellip", "cheby1",\ - "cheby2"} - Design method for the IIR filter. - passband_ripple_db : float, None, optional - Passband ripple in dB for "cheby1" and "ellip". Default: None. - stopband_attenuation_db : float, None, optional - Passband ripple in dB for "cheby2" and "ellip". Default: None. - sampling_rate_hz : int - Sampling rate in Hz. - - Returns - ------- - Filter - - """ - return Filter( - "iir", - { - "order": order, - "freqs": frequency_hz, - "type_of_pass": type_of_pass, - "filter_design_method": filter_design_method, - "passband_ripple": passband_ripple_db, - "stopband_attenuation": stopband_attenuation_db, - }, - sampling_rate_hz, - ) - - @staticmethod - def biquad( - eq_type: str, - frequency_hz: float | ArrayLike, - gain_db: float, - q: float, - sampling_rate_hz: int, - ): - """Return a biquad filter according to [1]. - - Parameters - ---------- - eq_type : str, {"peaking", "lowpass", "highpass", "bandpass_skirt",\ - "bandpass_peak", "notch", "allpass", "lowshelf", "highshelf"} - EQ type. - frequency_hz : float - Frequency of the biquad in Hz. - gain_db : float - Gain of biquad in dB. - q : float - Quality factor. - sampling_rate_hz : int - Sampling rate in Hz. - - Returns - ------- - Filter - - Reference - --------- - - [1]: https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq- - cookbook.html. - - """ - return Filter( - "biquad", - { - "eq_type": eq_type, - "freqs": frequency_hz, - "gain": gain_db, - "q": q, - }, - sampling_rate_hz, - ) - - @staticmethod - def fir_design( - order: int, - frequency_hz: float | ArrayLike, - type_of_pass: str, - filter_design_method: str, - width_hz: float | None = None, - sampling_rate_hz: int | None = None, - ): - """Design an FIR filter using `scipy.signal.firwin`. - - Parameters - ---------- - order : int - Filter order. It corresponds to the number of taps - 1. - frequency_hz : float | ArrayLike - Frequency or frequencies of the filter in Hz. - type_of_pass : str, {"lowpass", "highpass", "bandpass", "bandstop"} - Type of filter. - filter_design_method : str, {"boxcar", "triang",\ - "blackman", "hamming", "hann", "bartlett", "flattop",\ - "parzen", "bohman", "blackmanharris", "nuttall", "barthann",\ - "cosine", "exponential", "tukey", "taylor"} - Design method for the FIR filter. - width_hz : float, None, optional - estimated width of transition region in Hz for kaiser window. - Default: `None`. - sampling_rate_hz : int - Sampling rate in Hz. - - Returns - ------- - Filter - - """ - return Filter( - "fir", - { - "order": order, - "freqs": frequency_hz, - "type_of_pass": type_of_pass, - "filter_design_method": filter_design_method, - "width": width_hz, - }, - sampling_rate_hz, - ) - - @staticmethod - def from_ba( - b: ArrayLike, - a: ArrayLike, - sampling_rate_hz: int, - ): - """Create a filter from some b (numerator) and a (denominator) - coefficients. - - Parameters - ---------- - b : ArrayLike - Numerator coefficients. - a : ArrayLike - Denominator coefficients. - sampling_rate_hz : int - Sampling rate in Hz. - - Returns - ------- - Filter - - """ - return Filter("other", {"ba": [b, a]}, sampling_rate_hz) - - @staticmethod - def from_sos( - sos: NDArray[np.float64], - sampling_rate_hz: int, - ): - """Create a filter from second-order sections. - - Parameters - ---------- - sos : NDArray[np.float64] - Second-order sections. - sampling_rate_hz : int - Sampling rate in Hz. - - Returns - ------- - Filter - - """ - return Filter("other", {"sos": sos}, sampling_rate_hz) - - def initialize_zi(self, number_of_channels: int = 1): - """Initializes zi for steady-state filtering. The number of parallel - zi's can be defined externally. - - Parameters - ---------- - number_of_channels : int, optional - Number of channels is needed for the number of filter's zi's. - Default: 1. - - """ - assert ( - number_of_channels > 0 - ), """Zi's have to be initialized for at least one channel""" - self.zi = [] - if hasattr(self, "sos"): - for _ in range(number_of_channels): - self.zi.append(sig.sosfilt_zi(self.sos)) - else: - for _ in range(number_of_channels): - self.zi.append(sig.lfilter_zi(self.ba[0], self.ba[1])) - - @property - def sampling_rate_hz(self): - return self.__sampling_rate_hz - - @sampling_rate_hz.setter - def sampling_rate_hz(self, new_sampling_rate_hz): - assert ( - new_sampling_rate_hz is not None - ), "Sampling rate can not be None" - assert ( - type(new_sampling_rate_hz) is int - ), "Sampling rate can only be an integer" - self.__sampling_rate_hz = new_sampling_rate_hz - - @property - def warning_if_complex(self): - return self.__warning_if_complex - - @warning_if_complex.setter - def warning_if_complex(self, new_warning): - assert ( - type(new_warning) is bool - ), "This attribute must be of boolean type" - self.__warning_if_complex = new_warning - - @property - def filter_type(self): - return self.__filter_type - - @filter_type.setter - def filter_type(self, new_type: str): - assert type(new_type) is str, "Filter type must be a string" - self.__filter_type = new_type.lower() - - def __len__(self): - return self.info["order"] + 1 - - def __str__(self): - return self._get_metadata_string() - - # ======== Filtering ====================================================== - def filter_signal( - self, - signal: Signal, - channels=None, - activate_zi: bool = False, - zero_phase: bool = False, - ) -> Signal: - """Takes in a `Signal` object and filters selected channels. Exports a - new `Signal` object. - - Parameters - ---------- - signal : `Signal` - Signal to be filtered. - channels : int or array-like, optional - Channel or array of channels to be filtered. When `None`, all - channels are filtered. If only some channels are selected, these - will be filtered and the others will be bypassed (and returned). - Default: `None`. - activate_zi : int, optional - Gives the zi to update the filter values. Default: `False`. - zero_phase : bool, optional - Uses zero-phase filtering on signal. Be aware that the filter - is applied twice in this case. Default: `False`. - - Returns - ------- - new_signal : `Signal` - New Signal object. - - """ - # Check sampling rates - assert ( - self.sampling_rate_hz == signal.sampling_rate_hz - ), "Sampling rates do not match" - # Zero phase and zi - assert not (activate_zi and zero_phase), ( - "Filter initial and final values cannot be updated when " - + "filtering with zero-phase" - ) - # Channels - if channels is None: - channels = np.arange(signal.number_of_channels) - else: - channels = np.squeeze(channels) - channels = np.atleast_1d(channels) - assert ( - channels.ndim == 1 - ), "channels can be only a 1D-array or an int" - assert all(channels < signal.number_of_channels), ( - f"Selected channels ({channels}) are not valid for the " - + f"signal with {signal.number_of_channels} channels" - ) - - # Zi – create always for all channels and selected channels will get - # updated while filtering - if activate_zi: - if not hasattr(self, "zi"): - self.initialize_zi(signal.number_of_channels) - if len(self.zi) != signal.number_of_channels: - warn( - "zi values of the filter have not been correctly " - + "intialized for the number of channels. They have now" - + " been corrected" - ) - self.initialize_zi(signal.number_of_channels) - zi_old = self.zi - else: - zi_old = None - - # Check filter length compared to signal - if self.info["order"] > signal.time_data.shape[0]: - warn( - "Filter is longer than signal, results might be " - + "meaningless!" - ) - - # Filter with SOS when possible - if hasattr(self, "sos"): - new_signal, zi_new = _filter_on_signal( - signal=signal, - sos=self.sos, - channels=channels, - zi=zi_old, - zero_phase=zero_phase, - warning_on_complex_output=self.warning_if_complex, - ) - else: - # Filter with ba - new_signal, zi_new = _filter_on_signal_ba( - signal=signal, - ba=self.ba, - channels=channels, - zi=zi_old, - zero_phase=zero_phase, - filter_type=self.filter_type, - warning_on_complex_output=self.warning_if_complex, - ) - if activate_zi: - self.zi = zi_new - return new_signal - - def filter_and_resample_signal( - self, signal: Signal, new_sampling_rate_hz: int - ) -> Signal: - """Filters and resamples signal. This is only available for all - channels and sampling rates that are achievable by (only) down- or - upsampling. This method is for allowing specific filters to be - decimators/interpolators. If you just want to resample a signal, - use the function in the standard module. - - If this filter is iir, standard resampling is applied. If it is - fir, an efficient polyphase representation will be used. - - NOTE: Beware that no additional lowpass filter is used in the - resampling step which can lead to aliases or other effects if this - Filter is not adequate! - - Parameters - ---------- - signal : `Signal` - Signal to be filtered and resampled. - new_sampling_rate_hz : int - New sampling rate to resample to. - - Returns - ------- - new_sig : `Signal` - New down- or upsampled signal. - - """ - fraction = Fraction( - new_sampling_rate_hz, signal.sampling_rate_hz - ).as_integer_ratio() - assert fraction[0] == 1 or fraction[1] == 1, ( - f"{new_sampling_rate_hz} is not valid because it needs down- " - + f"AND upsampling (Up/Down: {fraction[0]}/{fraction[1]})" - ) - - # Check if standard or polyphase representation is to be used - if self.filter_type == "fir": - polyphase = True - elif self.filter_type in ("iir", "biquad"): - if not hasattr(self, "ba"): - self.ba: list = list(sig.sos2tf(self.sos)) - polyphase = False - else: - raise ValueError("Wrong filter type for filtering and resampling") - - # Check if down- or upsampling is required - if fraction[0] == 1: - assert ( - signal.sampling_rate_hz == self.sampling_rate_hz - ), "Sampling rates do not match" - new_time_data = _filter_and_downsample( - time_data=signal.time_data, - down_factor=fraction[1], - ba_coefficients=self.ba, - polyphase=polyphase, - ) - elif fraction[1] == 1: - assert ( - signal.sampling_rate_hz * fraction[0] == self.sampling_rate_hz - ), ( - "Sampling rates do not match. For the upsampler, the " - + """sampling rate of the filter should match the output's""" - ) - new_time_data = _filter_and_upsample( - time_data=signal.time_data, - up_factor=fraction[0], - ba_coefficients=self.ba, - polyphase=polyphase, - ) - - new_sig = signal.copy() - if hasattr(new_sig, "window"): - del new_sig.window - new_sig.sampling_rate_hz = new_sampling_rate_hz - new_sig.time_data = new_time_data - return new_sig - - # ======== Setters ======================================================== - def set_filter_parameters( - self, filter_type: str, filter_configuration: dict - ): - if filter_type == "iir": - if "filter_design_method" not in filter_configuration: - filter_configuration["filter_design_method"] = "butter" - if "passband_ripple" not in filter_configuration: - filter_configuration["passband_ripple"] = None - if "stopband_attenuation" not in filter_configuration: - filter_configuration["stopband_attenuation"] = None - self.sos = sig.iirfilter( - N=filter_configuration["order"], - Wn=filter_configuration["freqs"], - btype=filter_configuration["type_of_pass"], - analog=False, - fs=self.sampling_rate_hz, - ftype=filter_configuration["filter_design_method"], - rp=filter_configuration["passband_ripple"], - rs=filter_configuration["stopband_attenuation"], - output="sos", - ) - self.filter_type = filter_type - elif filter_type == "fir": - # Preparing parameters - if "filter_design_method" not in filter_configuration: - filter_configuration["filter_design_method"] = "hamming" - if "width" not in filter_configuration: - filter_configuration["width"] = None - # Filter creation - self.ba = [ - sig.firwin( - numtaps=filter_configuration["order"] + 1, - cutoff=filter_configuration["freqs"], - window=filter_configuration["filter_design_method"], - width=filter_configuration["width"], - pass_zero=filter_configuration["type_of_pass"], - fs=self.sampling_rate_hz, - ), - np.asarray([1]), - ] - self.filter_type = filter_type - elif filter_type == "biquad": - # Preparing parameters - if type(filter_configuration["eq_type"]) is str: - filter_configuration["eq_type"] = _get_biquad_type( - None, filter_configuration["eq_type"] - ) - # Filter creation - self.ba = _biquad_coefficients( - eq_type=filter_configuration["eq_type"], - fs_hz=self.sampling_rate_hz, - frequency_hz=filter_configuration["freqs"], - gain_db=filter_configuration["gain"], - q=filter_configuration["q"], - ) - # Setting back - filter_configuration["eq_type"] = _get_biquad_type( - filter_configuration["eq_type"] - ).capitalize() - filter_configuration["order"] = ( - max(len(self.ba[0]), len(self.ba[1])) - 1 - ) - self.filter_type = filter_type - else: - assert ( - ("ba" in filter_configuration) - ^ ("sos" in filter_configuration) - ^ ("zpk" in filter_configuration) - ), ( - "Only (and at least) one type of filter coefficients " - + "should be passed to create a filter" - ) - if "ba" in filter_configuration: - b, a = filter_configuration["ba"] - self.ba = [np.atleast_1d(b), np.atleast_1d(a)] - filter_configuration["order"] = ( - max(len(self.ba[0]), len(self.ba[1])) - 1 - ) - if "zpk" in filter_configuration: - z, p, k = filter_configuration["zpk"] - self.sos = sig.zpk2sos(z, p, k, analog=False) - filter_configuration["order"] = len(self.sos) * 2 - 1 - if "sos" in filter_configuration: - self.sos = filter_configuration["sos"] - filter_configuration["order"] = len(self.sos) * 2 - 1 - # Change filter type to 'fir' or 'iir' depending on coefficients - self._check_and_update_filter_type() - - # Update Metadata about the Filter - self.info: dict = filter_configuration - self.info["sampling_rate_hz"] = self.sampling_rate_hz - self.info["filter_type"] = self.filter_type - if hasattr(self, "ba"): - self.info["preferred_method_of_filtering"] = "ba" - elif hasattr(self, "sos"): - self.info["preferred_method_of_filtering"] = "sos" - if "filter_id" not in self.info: - self.info["filter_id"] = None - - # ======== Check type ===================================================== - def _check_and_update_filter_type(self): - """Internal method to check filter type (if FIR or IIR) and update - its filter type. - - """ - # Get filter coefficients - if hasattr(self, "ba"): - b, a = self.ba[0], self.ba[1] - elif hasattr(self, "sos"): - b, a = sig.sos2tf(self.sos) - # Trim zeros for a - a = np.atleast_1d(np.trim_zeros(a)) - # Check length of a coefficients and decide filter type - if len(a) == 1: - b /= a[0] - a = a / a[0] - self.filter_type = "fir" - else: - self.filter_type = "iir" - - # ======== Getters ======================================================== - def get_filter_metadata(self): - """Returns filter metadata. - - Returns - ------- - info : dict - Dictionary containing all filter metadata. - - """ - return self.info - - def _get_metadata_string(self): - """Helper for creating a string containing all filter info.""" - txt = f"""Filter – ID: {self.info["filter_id"]}\n""" - temp = "" - for n in range(len(txt)): - temp += "-" - txt += temp + "\n" - for k in self.info.keys(): - if k == "ba": - continue - txt += f"""{str(k).replace("_", " "). - capitalize()}: {self.info[k]}\n""" - return txt - - def get_ir( - self, length_samples: int = 512, zero_phase: bool = False - ) -> ImpulseResponse: - """Gets an impulse response of the filter with given length. - - Parameters - ---------- - length_samples : int, optional - Length for the impulse response in samples. Default: 512. - - Returns - ------- - ir_filt : `ImpulseResponse` - Impulse response of the filter. - - """ - # FIR with no zero phase filtering - if self.filter_type == "fir" and not zero_phase: - b = self.ba[0].copy() - if length_samples < len(b): - warn( - f"{length_samples} is not enough for filter with " - + f"length {len(b)}. IR will have the latter length." - ) - length_samples = len(b) - b = _pad_trim(b, length_samples) - return ImpulseResponse( - None, b, self.sampling_rate_hz, constrain_amplitude=False - ) - - # IIR or zero phase IR - ir_filt = _impulse(length_samples) - ir_filt = ImpulseResponse( - None, - ir_filt, - self.sampling_rate_hz, - constrain_amplitude=False, - ) - return self.filter_signal(ir_filt, zero_phase=zero_phase) - - def get_transfer_function( - self, frequency_vector_hz: NDArray[np.float64] - ) -> NDArray[np.complex128]: - """Obtain the complex transfer function of the filter analytically - evaluated for a given frequency vector. - - Parameters - ---------- - frequency_vector_hz : NDArray[np.float64] - Frequency vector for which to compute the transfer function - - Returns - ------- - NDArray[np.complex128] - Complex transfer function - - Notes - ----- - - This method uses scipy's freqz to compute the transfer function. In - the case of FIR filters, it might be significantly faster and more - precise to use a direct FFT approach. - - """ - assert ( - frequency_vector_hz.ndim == 1 - ), "Frequency vector can only have one dimension" - assert ( - frequency_vector_hz.max() <= self.sampling_rate_hz / 2 - ), "Queried frequency vector has values larger than nyquist" - if self.filter_type in ("iir", "biquad"): - if hasattr(self, "sos"): - return sig.sosfreqz( - self.sos, frequency_vector_hz, fs=self.sampling_rate_hz - )[1] - return sig.freqz( - self.ba[0], - self.ba[1], - frequency_vector_hz, - fs=self.sampling_rate_hz, - )[1] - - # FIR - return sig.freqz( - self.ba[0], [1], frequency_vector_hz, self.sampling_rate_hz - )[1] - - def get_coefficients( - self, mode: str = "sos" - ) -> ( - list[NDArray[np.float64]] - | NDArray[np.float64] - | tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]] - | None - ): - """Returns the filter coefficients. - - Parameters - ---------- - mode : str, optional - Type of filter coefficients to be returned. Choose from `"sos"`, - `"ba"` or `"zpk"`. Default: `"sos"`. - - Returns - ------- - coefficients : array-like - Array with filter coefficients with shape depending on mode: - - `"ba"`: list(b, a) with b and a of type NDArray[np.float64]. - - `"sos"`: NDArray[np.float64] with shape (n_sections, 6). - - `"zpk"`: tuple(z, p, k) with z, p, k of type NDArray[np.float64] - - Return `None` if user decides that ba->sos is too costly. The - threshold is for filters with order > 500. - - """ - if mode == "sos": - if hasattr(self, "sos"): - coefficients = self.sos.copy() - else: - if self.info["order"] > 500: - inp = None - while inp not in ("y", "n"): - inp = input( - "This filter has a large order " - + f"""({self.info['order']}). Are you sure you """ - + "want to get sos? Computation might" - + " take long time. (y/n)" - ) - inp = inp.lower() - if inp == "y": - break - if inp == "n": - return None - coefficients = sig.tf2sos(self.ba[0], self.ba[1]) - elif mode == "ba": - if hasattr(self, "sos"): - coefficients = sig.sos2tf(self.sos) - else: - coefficients = deepcopy(self.ba) - elif mode == "zpk": - if hasattr(self, "sos"): - coefficients = sig.sos2zpk(self.sos) - else: - # Check if filter is too long - if self.info["order"] > 500: - inp = None - while inp not in ("y", "n"): - inp = input( - "This filter has a large order " - + f"""({self.info['order']}). Are you sure you """ - + "want to get zeros and poles? Computation might" - + " take long time. (y/n)" - ) - inp = inp.lower() - if inp == "y": - break - if inp == "n": - return None - coefficients = sig.tf2zpk(self.ba[0], self.ba[1]) - else: - raise ValueError(f"{mode} is not valid. Use sos, ba or zpk") - return coefficients - - # ======== Plots and prints =============================================== - def show_info(self): - """Prints all the filter parameters to the console.""" - print(self._get_metadata_string()) - - def plot_magnitude( - self, - length_samples: int = 512, - range_hz=[20, 20e3], - normalize: str | None = None, - show_info_box: bool = True, - zero_phase: bool = False, - ): - """Plots magnitude spectrum. - Change parameters of spectrum with set_spectrum_parameters. - - Parameters - ---------- - length_samples : int, optional - Length of ir for magnitude plot. Default: 512. - range_hz : array-like with length 2, optional - Range for which to plot the magnitude response. - Default: [20, 20000]. - normalize : str, optional - Mode for normalization, supported are `"1k"` for normalization - with value at frequency 1 kHz or `"max"` for normalization with - maximal value. Use `None` for no normalization. Default: `None`. - show_info_box : bool, optional - Shows an information box on the plot. Default: `True`. - zero_phase : bool, optional - Plots magnitude for zero phase filtering. Default: `False`. - - Returns - ------- - fig : `matplotlib.figure.Figure` - Figure. - ax : `matplotlib.axes.Axes` - Axes. - - """ - if self.info["order"] > length_samples: - length_samples = self.info["order"] + 100 - warn( - f"length_samples ({length_samples}) is shorter than the " - + f"""filter order {self.info['order']}. Length will be """ - + "automatically extended." - ) - ir = self.get_ir(length_samples=length_samples, zero_phase=zero_phase) - fig, ax = ir.plot_magnitude(range_hz, normalize, show_info_box=False) - if show_info_box: - txt = self._get_metadata_string() - ax.text( - 0.1, - 0.5, - txt, - transform=ax.transAxes, - verticalalignment="top", - bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), - ) - return fig, ax - - def plot_group_delay( - self, - length_samples: int = 512, - range_hz=[20, 20e3], - show_info_box: bool = False, - ) -> tuple[Figure, Axes]: - """Plots group delay of the filter. Different methods are used for - FIR or IIR filters. - - Parameters - ---------- - length_samples : int, optional - Length of ir for magnitude plot. Default: 512. - range_hz : array-like with length 2, optional - Range for which to plot the magnitude response. - Default: [20, 20000]. - show_info_box : bool, optional - Shows an information box on the plot. Default: `False`. - - Returns - ------- - fig : `matplotlib.figure.Figure` - Figure. - ax : `matplotlib.axes.Axes` - Axes. - - """ - if self.info["order"] > length_samples: - length_samples = self.info["order"] + 100 - warn( - f"length_samples ({length_samples}) is shorter than the " - + f"""filter order {self.info['order']}. Length will be """ - + "automatically extended." - ) - if hasattr(self, "sos"): - ba = sig.sos2tf(self.sos) - else: - ba = self.ba - f, gd = _group_delay_filter(ba, length_samples, self.sampling_rate_hz) - gd *= 1e3 - ymax = None - ymin = None - if any(abs(gd) > 50): - ymin = -2 - ymax = 50 - fig, ax = general_plot( - x=f, - matrix=gd[..., None], - range_x=range_hz, - range_y=[ymin, ymax], - ylabel="Group delay / ms", - returns=True, - ) - if show_info_box: - txt = self._get_metadata_string() - ax.text( - 0.1, - 0.5, - txt, - transform=ax.transAxes, - verticalalignment="top", - bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), - ) - return fig, ax - - def plot_phase( - self, - length_samples: int = 512, - range_hz=[20, 20e3], - unwrap: bool = False, - show_info_box: bool = False, - ) -> tuple[Figure, Axes]: - """Plots phase spectrum. - - Parameters - ---------- - length_samples : int, optional - Length of ir for magnitude plot. Default: 512. - range_hz : array-like with length 2, optional - Range for which to plot the magnitude response. - Default: [20, 20000]. - unwrap : bool, optional - Unwraps the phase to show. Default: `False`. - show_info_box : bool, optional - Shows an information box on the plot. Default: `False`. - - Returns - ------- - fig : `matplotlib.figure.Figure` - Figure. - ax : `matplotlib.axes.Axes` - Axes. - - """ - if self.info["order"] > length_samples: - length_samples = self.info["order"] + 1 - warn( - f"length_samples ({length_samples}) is shorter than the " - + f"""filter order {self.info['order']}. Length will be """ - + "automatically extended." - ) - ir = self.get_ir(length_samples=length_samples) - fig, ax = ir.plot_phase(range_hz, unwrap) - if show_info_box: - txt = self._get_metadata_string() - ax.text( - 0.1, - 0.5, - txt, - transform=ax.transAxes, - verticalalignment="top", - bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), - ) - return fig, ax - - def plot_zp( - self, show_info_box: bool = False - ) -> tuple[Figure, Axes] | None: - """Plots zeros and poles with the unit circle. This returns `None` and - produces no plot if user decides that conversion ba->sos is too costly. - - Parameters - ---------- - show_info_box : bool, optional - Shows an information box on the plot. Default: `False`. - - Returns - ------- - fig : `matplotlib.figure.Figure` - Figure. - ax : `matplotlib.axes.Axes` - Axes. - - """ - # Ask explicitely if filter is very long - if self.info["order"] > 500: - inp = None - while inp not in ("y", "n"): - inp = input( - "This filter has a large order " - + f"""({self.info['order']}). Are you sure you want to""" - + " plot zeros and poles? Computation might take long " - + "time. (y/n)" - ) - inp = inp.lower() - if inp == "y": - break - if inp == "n": - return None - # - if hasattr(self, "sos"): - z, p, k = sig.sos2zpk(self.sos) - else: - z, p, k = sig.tf2zpk(self.ba[0], self.ba[1]) - fig, ax = _zp_plot(z, p, returns=True) - ax.text( - 0.75, - 0.91, - rf"$k={k:.1e}$", - transform=ax.transAxes, - verticalalignment="top", - ) - if show_info_box: - txt = self._get_metadata_string() - ax.text( - 0.1, - 0.5, - txt, - transform=ax.transAxes, - verticalalignment="top", - bbox=dict(boxstyle="round", facecolor="grey", alpha=0.75), - ) - return fig, ax - - # ======== Saving and export ============================================== - def save_filter(self, path: str = "filter"): - """Saves the Filter object as a pickle. - - Parameters - ---------- - path : str, optional - Path for the filter to be saved. Use only folder1/folder2/name - (it can be passed with .pkl at the end or without it). - Default: `"filter"` (local folder, object named filter). - - """ - path = _check_format_in_path(path, "pkl") - with open(path, "wb") as data_file: - dump(self, data_file, HIGHEST_PROTOCOL) - - def copy(self): - """Returns a copy of the object. - - Returns - ------- - new_sig : `Filter` - Copy of filter. - - """ - return deepcopy(self) diff --git a/dsptoolbox/classes/filter_helpers.py b/dsptoolbox/classes/filter_helpers.py new file mode 100644 index 0000000..f6cfe49 --- /dev/null +++ b/dsptoolbox/classes/filter_helpers.py @@ -0,0 +1,711 @@ +""" +Backend for filter class and general filtering functions. +""" + +import numpy as np +from warnings import warn +from enum import Enum +import scipy.signal as sig +from numpy.typing import NDArray + +from .signal import Signal +from .multibandsignal import MultiBandSignal +from .._general_helpers import _polyphase_decomposition + + +def _get_biquad_type(number: int | None = None, name: str | None = None): + """Helper method that handles string inputs for the biquad filters.""" + if name is not None: + name = name.lower() + valid_names = ( + "peaking", + "lowpass", + "highpass", + "bandpass_skirt", + "bandpass_peak", + "notch", + "allpass", + "lowshelf", + "highshelf", + "lowpass_first_order", + "highpass_first_order", + "inverter", + ) + assert name in valid_names, ( + f"{name} is not a valid name. Please " + + """select from the ('peaking', 'lowpass', 'highpass', + 'bandpass_skirt', 'bandpass_peak', 'notch', 'allpass', 'lowshelf', + 'highshelf', 'lowpass_first_order', 'highpass_first_order', + 'inverter')""" + ) + + class biquad(Enum): + peaking = 0 + lowpass = 1 + highpass = 2 + bandpass_skirt = 3 + bandpass_peak = 4 + notch = 5 + allpass = 6 + lowshelf = 7 + highshelf = 8 + lowpass_first_order = 9 + highpass_first_order = 10 + inverter = 11 + + if number is None: + assert ( + name is not None + ), "Either number or name must be given, not both" + r = eval(f"biquad.{name}") + r = r.value + else: + assert name is None, "Either number or name must be given, not both" + r = biquad(number).name + return r + + +def _biquad_coefficients( + eq_type: int | str = 0, + fs_hz: int = 48000, + frequency_hz: float | list | tuple | NDArray[np.float64] = 1000, + gain_db: float = 0, + q: float = 1, +): + """Creates the filter coefficients for biquad filters. + eq_type: 0 PEAKING, 1 LOWPASS, 2 HIGHPASS, 3 BANDPASS_SKIRT, + 4 BANDPASS_PEAK, 5 NOTCH, 6 ALLPASS, 7 LOWSHELF, 8 HIGHSHELF. + + References + ---------- + - https://www.w3.org/TR/2021/NOTE-audio-eq-cookbook-20210608/ + + """ + # Asserts and input safety + if type(eq_type) is str: + eq_type = _get_biquad_type(None, eq_type) + # frequency_hz + frequency_hz = np.asarray(frequency_hz) + if frequency_hz.ndim > 0: + frequency_hz = np.mean(frequency_hz) + warn( + "More than one frequency was passed for biquad filter. This is " + + "not supported. A mean of passed frequencies was used for the " + + "design but this might not give the intended result!" + ) + A = 10 ** (gain_db / 40) if eq_type in (0, 7, 8) else 10 ** (gain_db / 20) + Omega = 2.0 * np.pi * (frequency_hz / fs_hz) + sn = np.sin(Omega) + cs = np.cos(Omega) + alpha = sn / (2.0 * q) + a = np.ones(3) + b = np.ones(3) + if eq_type == 0: # Peaking + b[0] = 1 + alpha * A + b[1] = -2 * cs + b[2] = 1 - alpha * A + a[0] = 1 + alpha / A + a[1] = -2 * cs + a[2] = 1 - alpha / A + elif eq_type == 1: # Lowpass + b[0] = (1 - cs) / 2 * A + b[1] = (1 - cs) * A + b[2] = b[0] + a[0] = 1 + alpha + a[1] = -2 * cs + a[2] = 1 - alpha + elif eq_type == 2: # Highpass + b[0] = (1 + cs) / 2.0 * A + b[1] = -1 * (1 + cs) * A + b[2] = b[0] + a[0] = 1 + alpha + a[1] = -2 * cs + a[2] = 1 - alpha + elif eq_type == 3: # Bandpass skirt + b[0] = sn / 2 * A + b[1] = 0 + b[2] = -b[0] + a[0] = 1 + alpha + a[1] = -2 * cs + a[2] = 1 - alpha + elif eq_type == 4: # Bandpass peak + b[0] = alpha * A + b[1] = 0 + b[2] = -b[0] + a[0] = 1 + alpha + a[1] = -2 * cs + a[2] = 1 - alpha + elif eq_type == 5: # Notch + b[0] = 1 * A + b[1] = -2 * cs * A + b[2] = b[0] + a[0] = 1 + alpha + a[1] = -2 * cs + a[2] = 1 - alpha + elif eq_type == 6: # Allpass + b[0] = (1 - alpha) * A + b[1] = -2 * cs * A + b[2] = (1 + alpha) * A + a[0] = 1 + alpha + a[1] = -2 * cs + a[2] = 1 - alpha + elif eq_type == 7: # Lowshelf + b[0] = A * ((A + 1) - (A - 1) * cs + 2 * np.sqrt(A) * alpha) + b[1] = 2 * A * ((A - 1) - (A + 1) * cs) + b[2] = A * ((A + 1) - (A - 1) * cs - 2 * np.sqrt(A) * alpha) + a[0] = (A + 1) + (A - 1) * cs + 2 * np.sqrt(A) * alpha + a[1] = -2 * ((A - 1) + (A + 1) * cs) + a[2] = (A + 1) + (A - 1) * cs - 2 * np.sqrt(A) * alpha + elif eq_type == 8: # Highshelf + b[0] = A * ((A + 1) + (A - 1) * cs + 2 * np.sqrt(A) * alpha) + b[1] = -2 * A * ((A - 1) + (A + 1) * cs) + b[2] = A * ((A + 1) + (A - 1) * cs - 2 * np.sqrt(A) * alpha) + a[0] = (A + 1) - (A - 1) * cs + 2 * np.sqrt(A) * alpha + a[1] = 2 * ((A - 1) - (A + 1) * cs) + a[2] = (A + 1) - (A - 1) * cs - 2 * np.sqrt(A) * alpha + elif eq_type == 9: # Lowpass first order + K = 1.0 / np.tan(Omega / 2.0) + b[0] = A + b[1] = A + b[2] = 0.0 + a[0] = 1.0 + K + a[1] = 1.0 - K + a[2] = 0.0 + elif eq_type == 10: # Highpass first order + K = 1.0 / np.tan(Omega / 2.0) + b[0] = K * A + b[1] = -K * A + b[2] = 0.0 + a[0] = 1.0 + K + a[1] = 1.0 - K + a[2] = 0.0 + elif eq_type == 11: # Inverter + b[0] = A + b[1] = 0.0 + b[2] = 0.0 + a[0] = 1.0 + a[1] = 0.0 + a[2] = 0.0 + else: + raise Exception("eq_type not supported") + return b, a + + +def _impulse(length_samples: int = 512, delay_samples: int = 0): + """Creates an impulse with the given length + + Parameters + ---------- + length_samples : int, optional + Length for the impulse. Default: 512. + delay_samples : int, optional + Delay of the impulse. Default: 0. + + Returns + ------- + imp : NDArray[np.float64] + Impulse. + + """ + imp = np.zeros(length_samples) + imp[delay_samples] = 1 + return imp + + +def _group_delay_filter(ba, length_samples: int = 512, fs_hz: int = 48000): + """Computes group delay using the method in + https://www.dsprelated.com/freebooks/filters/Phase_Group_Delay.html. + The implementation is mostly taken from `scipy.signal.group_delay` ! + + Parameters + ---------- + ba : array-like + Array containing b (numerator) and a (denominator) for filter. + length_samples : int, optional + Length for the final vector. Default: 512. + fs_hz : int, optional + Sampling frequency rate in Hz. Default: 48000. + + Returns + ------- + f : NDArray[np.float64] + Frequency vector. + gd : NDArray[np.float64] + Group delay in seconds. + + """ + # Frequency vector at which to evaluate + omega = np.linspace(0, np.pi, length_samples) + # Turn always to FIR + c = np.convolve(ba[0], np.conjugate(ba[1][::-1])) + cr = c * np.arange(len(c)) # Ramped coefficients + # Evaluation + num = np.polyval(cr, np.exp(1j * omega)) + denum = np.polyval(c, np.exp(1j * omega)) + + # Group delay + gd = np.real(num / denum) - len(ba[1]) + 1 + + # Look for infinite values + gd[~np.isfinite(gd)] = 0 + f = omega / np.pi * (fs_hz / 2) + gd /= fs_hz + return f, gd + + +def _filter_on_signal( + signal: Signal, + sos, + channels=None, + zi=None, + zero_phase: bool = False, + warning_on_complex_output: bool = True, +): + """Takes in a `Signal` object and filters selected channels. Exports a new + `Signal` object. + + Parameters + ---------- + signal : `Signal` + Signal to be filtered. + sos : array-like + SOS coefficients of filter. + channels : int or array-like, optional + Channel or array of channels to be filtered. When `None`, all + channels are filtered. Default: `None`. + zi : array-like, optional + When not `None`, the filter state values are updated after filtering. + Default: `None`. + zero_phase : bool, optional + Uses zero-phase filtering on signal. Be aware that the filter + is doubled in this case. Default: `False`. + warning_on_complex_output: bool, optional + When `True`, there is a warning when the output is complex. Either way, + only the real part is regarded. Default: `True`. + + Returns + ------- + new_signal : `Signal` + New Signal object. + zi : list + None if passed zi was None. + + """ + # Time Data + new_time_data = signal.time_data + + # zi unpacking + if zi is not None: + zi = np.moveaxis(np.asarray(zi), 0, -1) + + # Channels + if channels is None: + channels = np.arange(signal.number_of_channels) + + # Filtering + if zi is not None: + y, zi[:, :, channels] = sig.sosfilt( + sos, signal.time_data[:, channels], zi=zi[:, :, channels], axis=0 + ) + else: + if zero_phase: + y = sig.sosfiltfilt(sos, signal.time_data[:, channels], axis=0) + else: + y = sig.sosfilt(sos, signal.time_data[:, channels], axis=0) + + # Check for complex output + if np.iscomplexobj(y): + if warning_on_complex_output: + warn( + "Filter output is complex. Imaginary part is saved in " + + "Signal as time_data_imaginary" + ) + new_time_data = new_time_data.astype(np.complex128) + + # Create new signal + new_time_data[:, channels] = y + new_signal = signal.copy() + new_signal.time_data = new_time_data + + # zi packing + if zi is not None: + zi_new = [] + for n in range(signal.number_of_channels): + zi_new.append(zi[:, :, n]) + return new_signal, zi + + +def _filter_on_signal_ba( + signal: Signal, + ba, + channels=None, + zi: list | None = None, + zero_phase: bool = False, + filter_type: str = "iir", + warning_on_complex_output: bool = True, +): + """Takes in a `Signal` object and filters selected channels. Exports a new + `Signal` object. + + Parameters + ---------- + signal : `Signal` + Signal to be filtered. + ba : list + List with ba coefficients of filter. Form ba=[b, a] where b and a + are of type NDArray[np.float64]. + channels : array-like, optional + Channel or array of channels to be filtered. When `None`, all + channels are filtered. Default: `None`. + zi : list, optional + When not `None`, the filter state values are updated after filtering. + They should be passed as a list with the zi 1D-arrays. + Default: `None`. + zero_phase : bool, optional + Uses zero-phase filtering on signal. Be aware that the filter + is doubled in this case. Default: `False`. + filter_type : str, optional + Filter type. When FIR, an own implementation of lfilter is used, + otherwise scipy.signal.lfilter is used. Default: `'iir'`. + warning_on_complex_output: bool, optional + When `True`, there is a warning when the output is complex. Either way, + only the real part is regarded. Default: `True`. + + Returns + ------- + new_signal : `Signal` + New Signal object. + zi : list + None if passed zi was None. + + """ + # Take lfilter function, might be a different one depending if filter is + # FIR or IIR + if filter_type == "fir": + lfilter = _lfilter_fir + elif filter_type in ("iir", "biquad"): + lfilter = sig.lfilter + else: + raise ValueError( + f"{filter_type} is not supported. Use either fir or iir" + ) + + # Time Data + new_time_data = signal.time_data + + # zi unpacking + if zi is not None: + zi = np.asarray(zi).T + + # Channels + if channels is None: + channels = np.arange(signal.number_of_channels) + + # Filtering + if zi is not None: + y, zi[:, channels] = lfilter( + ba[0], + a=ba[1], + x=signal.time_data[:, channels], + zi=zi[:, channels], + axis=0, + ) + else: + if zero_phase: + y = sig.filtfilt( + b=ba[0], a=ba[1], x=signal.time_data[:, channels], axis=0 + ) + else: + y = lfilter( + ba[0], a=ba[1], x=signal.time_data[:, channels], axis=0 + ) + + # Check for complex output + if np.iscomplexobj(y): + if warning_on_complex_output: + warn( + "Filter output is complex. Imaginary part is saved in " + + "Signal as time_data_imaginary" + ) + new_time_data = new_time_data.astype(np.complex128) + + # Create new signal + new_time_data[:, channels] = y + new_signal = signal.copy() + new_signal.time_data = new_time_data + + # zi packing + if zi is not None: + zi_new = [] + for n in range(zi.shape[1]): + zi_new.append(zi[:, n]) + return new_signal, zi + + +def _filterbank_on_signal( + signal: Signal, + filters, + activate_zi: bool = False, + mode: str = "parallel", + zero_phase: bool = False, + same_sampling_rate: bool = True, +): + """Applies filter bank on a given signal. + + Parameters + ---------- + signal : `Signal` + Signal to be filtered. + filters : list + List containing filters to be applied to signal. + activate_zi : bool, optional + When `True`, the filter initial values for each channel are updated + while filtering. Default: `None`. + mode : str, optional + Mode of filtering. Choose from `'parallel'`, `'sequential'` and + `'summed'`. Default: `'parallel'`. + zero_phase : bool, optional + Uses zero-phase filtering on signal. Be aware that the filter order + is doubled in this case. Default: `False`. + same_sampling_rate : bool, optional + When `True`, the output MultiBandSignal (parallel filtering) has + same sampling rate for all bands. Default: `True`. + + Returns + ------- + new_signal : `Signal` or `MultiBandSignal` + New Signal object. + + """ + n_filt = len(filters) + if mode == "parallel": + ss = [] + for n in range(n_filt): + ss.append( + filters[n].filter_signal( + signal, activate_zi=activate_zi, zero_phase=zero_phase + ) + ) + out_sig = MultiBandSignal(ss, same_sampling_rate=same_sampling_rate) + elif mode == "sequential": + out_sig = signal.copy() + for n in range(n_filt): + out_sig = filters[n].filter_signal( + out_sig, activate_zi=activate_zi, zero_phase=zero_phase + ) + else: + new_time_data = np.zeros( + (signal.time_data.shape[0], signal.number_of_channels, n_filt) + ) + for n in range(n_filt): + s = filters[n].filter_signal( + signal, activate_zi=activate_zi, zero_phase=zero_phase + ) + new_time_data[:, :, n] = s.time_data + new_time_data = np.sum(new_time_data, axis=-1) + out_sig = signal.copy() + out_sig.time_data = new_time_data + return out_sig + + +def _lfilter_fir( + b: NDArray[np.float64], + a: NDArray[np.float64], + x: NDArray[np.float64], + zi: NDArray[np.float64] | None = None, + axis: int = 0, +): + """Variant to the `scipy.signal.lfilter` that uses `scipy.signal.convolve` + for filtering. The advantage of this is that the convolution will be + automatically made using fft or direct, depending on the inputs' sizes. + This is only used for FIR filters. + + The `axis` parameter is only there for compatibility with + `scipy.signal.lfilter`, but the first axis is always used. + + """ + assert ( + len(a) == 1 + ), f"{a} is not valid. It has to be 1 in order to be a valid FIR filter" + + # b dimensions handling + if b.ndim != 1: + b = np.squeeze(b) + assert b.ndim == 1, "FIR Filters for audio must be 1D-arrays" + + # Dimensions of zi and x must match + if zi is not None: + assert zi.ndim == x.ndim, ( + "Vector to filter and initial values should have the same " + + "number of dimensions!" + ) + if x.ndim < 2: + x = x[..., None] + if zi is not None: + zi = zi[..., None] + assert x.ndim == 2, "Filtering only works on 2D-arrays" + + # Convolving + y = sig.convolve(x, b[..., None], mode="full") + + # Use zi's and take zf's + if zi is not None: + y[: zi.shape[0], :] += zi + zf = y[-zi.shape[0] :, :] + + # Trim output + y = y[: x.shape[0], :] + if zi is None: + return y + return y, zf + + +def _filter_and_downsample( + time_data: NDArray[np.float64], + down_factor: int, + ba_coefficients: list, + polyphase: bool, +) -> NDArray[np.float64]: + """Filters and downsamples time data. If polyphase is `True`, it is + assumed that the filter is FIR and only b-coefficients are used. In + that case, an efficient downsampling is done, otherwise standard filtering + and downsampling is applied. + + Parameters + ---------- + time_data : NDArray[np.float64] + Time data to be filtered and resampled. Shape should be (time samples, + channels). + down_factor : int + Factor by which it will be downsampled. + ba_coefficients : list + List containing [b, a] coefficients. If polyphase is set to `True`, + only b coefficients are regarded. + polyphase : bool + Use polyphase representation or not. + + Returns + ------- + new_time_data : NDArray[np.float64] + New time data with downsampling. + + """ + if time_data.ndim == 1: + time_data = time_data[..., None] + assert ( + time_data.ndim == 2 + ), "Shape for time data should be (time samples, channels)" + + if polyphase: + poly, _ = _polyphase_decomposition(time_data, down_factor, flip=False) + # (time samples, polyphase components, channels) + # Polyphase representation of filter and filter length + b = ba_coefficients[0] + half_length = (len(b) - 1) // 2 + b_poly, _ = _polyphase_decomposition(b, down_factor, flip=True) + new_time_data = np.zeros( + (poly.shape[0] + b_poly.shape[0] - 1, poly.shape[2]) + ) + # Accumulator for each channel – it would be better to find a way + # to do it without loops, but using scipy.signal.convolve since it + # is advantageous compared to numpy.convolve + for ch in range(poly.shape[2]): + temp = np.zeros(new_time_data.shape[0]) + for n in range(poly.shape[1]): + temp += sig.convolve( + poly[:, n, ch], b_poly[:, n, 0], mode="full" + ) + new_time_data[:, ch] = temp + # Take correct values from vector + new_time_data = new_time_data[ + half_length // down_factor : -half_length // down_factor, : + ] + else: + new_time_data = sig.lfilter( + ba_coefficients[0], ba_coefficients[1], x=time_data, axis=0 + ) + new_time_data = new_time_data[::down_factor] + + return new_time_data + + +def _filter_and_upsample( + time_data: NDArray[np.float64], + up_factor: int, + ba_coefficients: list, + polyphase: bool, +): + """Filters and upsamples time data. If polyphase is `True`, it is + assumed that the filter is FIR and only b-coefficients are used. In + that case, an efficient polyphase upsampling is done, otherwise standard + upsampling and filtering is applied. + + NOTE: The polyphase implementation uses two loops: once for the polyphase + components and once for the channels. Hence, it might not be much faster + than usual filtering. + + Parameters + ---------- + time_data : NDArray[np.float64] + Time data to be filtered and resampled. Shape should be (time samples, + channels). + up_factor : int + Factor by which it will be upsampled. + ba_coefficients : list + List containing [b, a] coefficients. If polyphase is set to `True`, + only b coefficients are regarded. + polyphase : bool + Use polyphase representation or not. + + Returns + ------- + new_time_data : NDArray[np.float64] + New time data with downsampling. + + """ + if time_data.ndim == 1: + time_data = time_data[..., None] + assert ( + time_data.ndim == 2 + ), "Shape for time data should be (time samples, channels)" + + if polyphase: + b = ba_coefficients[0] + half_length = (len(b) - 1) // 2 + + # Decompose filter + b_poly, padding = _polyphase_decomposition(b, up_factor) + b_poly *= up_factor + + # Accumulator – Length is not right! + new_time_data = np.zeros( + ( + (time_data.shape[0] + b_poly.shape[0] - 1) * up_factor, + time_data.shape[1], + ) + ) + + # Interpolate per channel and per polyphase component – should be + # a better way to do it without the loops... + for ch in range(time_data.shape[1]): + for ind in range(up_factor): + new_time_data[ind::up_factor, ch] = sig.convolve( + time_data[:, ch], b_poly[:, ind, 0], mode="full" + ) + + # Take right samples from filtered signal + if padding == up_factor: + new_time_data = new_time_data[half_length:-half_length, :] + else: + new_time_data = new_time_data[ + half_length + padding : -half_length + padding, : + ] + else: + new_time_data = np.zeros( + (time_data.shape[0] * up_factor, time_data.shape[1]) + ) + new_time_data[::up_factor] = time_data + new_time_data = sig.lfilter( + ba_coefficients[0], ba_coefficients[1], x=new_time_data, axis=0 + ) + return new_time_data diff --git a/dsptoolbox/classes/filterbank.py b/dsptoolbox/classes/filterbank.py index 68da857..1ce4592 100644 --- a/dsptoolbox/classes/filterbank.py +++ b/dsptoolbox/classes/filterbank.py @@ -8,8 +8,8 @@ from .signal import Signal from .multibandsignal import MultiBandSignal -from .filter_class import Filter -from .filter import _filterbank_on_signal +from .filter import Filter +from .filter_helpers import _filterbank_on_signal from ..generators import dirac from ..plots import general_plot from .._general_helpers import _get_normalized_spectrum, _check_format_in_path diff --git a/dsptoolbox/classes/phase_linearizer.py b/dsptoolbox/classes/phase_linearizer.py index 8e41db1..4066cec 100644 --- a/dsptoolbox/classes/phase_linearizer.py +++ b/dsptoolbox/classes/phase_linearizer.py @@ -1,4 +1,4 @@ -from .filter_class import Filter +from .filter import Filter from .impulse_response import ImpulseResponse import numpy as np from scipy.integrate import cumulative_trapezoid diff --git a/dsptoolbox/generators/generators.py b/dsptoolbox/generators/generators.py index db51010..ee43818 100644 --- a/dsptoolbox/generators/generators.py +++ b/dsptoolbox/generators/generators.py @@ -13,7 +13,7 @@ _pad_trim, _frequency_weightning, ) -from ..classes.filter import _impulse +from ..classes.filter_helpers import _impulse def noise( diff --git a/dsptoolbox/transfer_functions/transfer_functions.py b/dsptoolbox/transfer_functions/transfer_functions.py index 7c5b11e..0135aaa 100644 --- a/dsptoolbox/transfer_functions/transfer_functions.py +++ b/dsptoolbox/transfer_functions/transfer_functions.py @@ -17,7 +17,7 @@ _trim_ir, ) from ..classes import Signal, Filter, ImpulseResponse -from ..classes.filter import _group_delay_filter +from ..classes.filter_helpers import _group_delay_filter from .._general_helpers import ( _remove_ir_latency_from_phase, _min_phase_ir_from_real_cepstrum, From 19ecec6911bf55e85a4187152ac766da6d645394 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Fri, 2 Aug 2024 10:52:27 +0200 Subject: [PATCH 31/35] bug fixes with instantiating signal instead of IR --- dsptoolbox/classes/multibandsignal.py | 9 +++++++-- dsptoolbox/classes/sv_filter.py | 2 +- dsptoolbox/filterbanks/_filterbank.py | 4 +++- 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/dsptoolbox/classes/multibandsignal.py b/dsptoolbox/classes/multibandsignal.py index c4157e2..d177a55 100644 --- a/dsptoolbox/classes/multibandsignal.py +++ b/dsptoolbox/classes/multibandsignal.py @@ -141,6 +141,10 @@ def same_sampling_rate(self, new_same): def number_of_bands(self) -> int: return len(self.bands) + def __get_type_of_signal_bands(self): + """Return type of saved bands (either Signal or ImpulseResponse).""" + return type(self.bands[0]) + def __len__(self): return len(self.bands) @@ -328,8 +332,9 @@ def get_all_bands( self.bands[n].time_data[:, channel] + self.bands[n].time_data_imaginary[:, channel] * 1j ) - sig = Signal(None, new_time_data, self.sampling_rate_hz) - return sig + return self.__get_type_of_signal_bands()( + None, new_time_data, self.sampling_rate_hz + ) else: new_time_data = [] sr = [] diff --git a/dsptoolbox/classes/sv_filter.py b/dsptoolbox/classes/sv_filter.py index 880d46a..8a4d69e 100644 --- a/dsptoolbox/classes/sv_filter.py +++ b/dsptoolbox/classes/sv_filter.py @@ -145,7 +145,7 @@ def filter_signal(self, signal: Signal) -> MultiBandSignal: td = self._process_vector(signal.time_data) return MultiBandSignal( [ - Signal( + type(signal)( None, td[:, i, :], sampling_rate_hz=self.sampling_rate_hz ) for i in range(4) diff --git a/dsptoolbox/filterbanks/_filterbank.py b/dsptoolbox/filterbanks/_filterbank.py index f111d0f..90f4590 100644 --- a/dsptoolbox/filterbanks/_filterbank.py +++ b/dsptoolbox/filterbanks/_filterbank.py @@ -306,7 +306,9 @@ def filter_signal( b = [] for n in range(self.number_of_bands): - b.append(Signal(None, new_time_data[:, :, n], s.sampling_rate_hz)) + # Extract if signal is ImpulseResponse or Signal and create + # accordingly + b.append(type(s)(None, new_time_data[:, :, n], s.sampling_rate_hz)) d = dict( readme="MultiBandSignal made using Linkwitz-Riley filter bank", filterbank_freqs=self.freqs, From ed83b10318a5f0d8871077d39be5d50230358d80 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Mon, 5 Aug 2024 11:46:31 +0200 Subject: [PATCH 32/35] delegated window handling to impulse response --- dsptoolbox/classes/impulse_response.py | 87 +++++++++++++++++++++++++- dsptoolbox/classes/signal.py | 6 -- 2 files changed, 85 insertions(+), 8 deletions(-) diff --git a/dsptoolbox/classes/impulse_response.py b/dsptoolbox/classes/impulse_response.py index 68cfe89..099cff8 100644 --- a/dsptoolbox/classes/impulse_response.py +++ b/dsptoolbox/classes/impulse_response.py @@ -121,6 +121,91 @@ def from_time_data( ) return ImpulseResponse.from_signal(s) + def add_channel( + self, + path: str | None = None, + new_time_data: NDArray[np.float64] | None = None, + sampling_rate_hz: int | None = None, + padding_trimming: bool = True, + ): + """Adds new channels to this signal object. + + Parameters + ---------- + path : str, optional + Path to the file containing new channel information. + new_time_data : NDArray[np.float64], optional + np.array with new channel data. + sampling_rate_hz : int, optional + Sampling rate for the new data + padding_trimming : bool, optional + Activates padding or trimming at the end of signal in case the + new data does not match previous data. Default: `True`. + + """ + super().add_channel( + path, new_time_data, sampling_rate_hz, padding_trimming + ) + if hasattr(self, "window"): + current_shape = self.time_data.shape + self.window = np.concatenate( + [ + self.window, + np.ones( + ( + current_shape[0], + current_shape[1] - self.window.shape[1], + ) + ), + ], + axis=1, + ) + + def remove_channel(self, channel_number: int = -1): + """Removes a channel. + + Parameters + ---------- + channel_number : int, optional + Channel number to be removed. Default: -1 (last). + + """ + super().remove_channel(channel_number) + if hasattr(self, "window"): + self.window = np.delete(self.window, channel_number, axis=1) + + def swap_channels(self, new_order): + """Rearranges the channels in the new given order. + + Parameters + ---------- + new_order : array-like + New rearrangement of channels. + + """ + super().swap_channels(new_order) + if hasattr(self, "window"): + self.window = self.window[:, np.asarray(new_order)] + + def get_channels(self, channels): + """Returns a signal object with the selected channels. Beware that + first channel index is 0! + + Parameters + ---------- + channels : array-like or int + Channels to be returned as a new Signal object. + + Returns + ------- + new_sig : `Signal` + New signal object with selected channels. + + """ + super().swap_channels(channels) + if hasattr(self, "window"): + self.window = self.window[:, np.asarray(channels)] + def set_window(self, window: NDArray[np.float64]): """Sets the window used for the IR. @@ -274,8 +359,6 @@ def plot_coherence(self) -> tuple[Figure, list[Axes]]: Axes. """ - if not hasattr(self, "coherence"): - raise AttributeError("There is no coherence data saved") f, coh = self.get_coherence() fig, ax = general_subplots_line( x=f, diff --git a/dsptoolbox/classes/signal.py b/dsptoolbox/classes/signal.py index a84ced7..e8b352f 100644 --- a/dsptoolbox/classes/signal.py +++ b/dsptoolbox/classes/signal.py @@ -601,10 +601,6 @@ def add_channel( self.time_data = np.concatenate( [self.time_data, new_time_data], axis=1 ) - if hasattr(self, "window"): - self.window = np.concatenate( - [self.window, np.ones(new_time_data.shape)], axis=1 - ) self.__update_state() def remove_channel(self, channel_number: int = -1): @@ -681,8 +677,6 @@ def get_channels(self, channels): ) new_sig = self.copy() new_sig.time_data = self.time_data[:, channels] - if hasattr(new_sig, "window"): - new_sig.window = new_sig.window[:, channels] return new_sig # ======== Getters ======================================================== From 36491b77c75d0fbce863ce62ed00ed1e77e3dc09 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Mon, 5 Aug 2024 11:46:44 +0200 Subject: [PATCH 33/35] updated unit tests channel handling --- tests/test_classes.py | 49 ++++++++++++++++++++++++++++++-- tests/test_transfer_functions.py | 2 ++ 2 files changed, 49 insertions(+), 2 deletions(-) diff --git a/tests/test_classes.py b/tests/test_classes.py index 445dd08..e77cdb3 100644 --- a/tests/test_classes.py +++ b/tests/test_classes.py @@ -1071,5 +1071,50 @@ class TestImpulseResponse: seconds = 2 d = dsp.generators.dirac(seconds * fs_hz, sampling_rate_hz=fs_hz) - def test_different_things(self): - assert False + path_rir = join("examples", "data", "rir.wav") + + def get_ir(self): + return dsp.ImpulseResponse.from_file(self.path_rir) + + def test_constructors(self): + rir = self.get_ir() + dsp.ImpulseResponse.from_time_data(rir.time_data, rir.sampling_rate_hz) + dsp.ImpulseResponse.from_signal(dsp.Signal.from_file(self.path_rir)) + + def test_channel_handling_with_window(self): + rir = self.get_ir() + rir = dsp.transfer_functions.window_centered_ir(rir, len(rir))[0] + + # Add channel + window_previous = rir.window[:, 0] + rir.add_channel(self.path_rir) + assert rir.window.shape == rir.time_data.shape + np.testing.assert_array_equal(rir.window[:, 0], window_previous) + np.testing.assert_array_equal(rir.window[:, 1], 1.0) + + # Remove channel + rir.remove_channel(1) + assert rir.window.shape == rir.time_data.shape + np.testing.assert_array_equal(rir.window[:, 0], window_previous) + + # Swap channels + rir.add_channel(self.path_rir) + rir.add_channel(self.path_rir) + rir.swap_channels([2, 1, 0]) + assert rir.window.shape == rir.time_data.shape + np.testing.assert_array_equal(rir.window[:, -1], window_previous) + + def test_plotting_with_window(self): + rir = self.get_ir() + rir = dsp.transfer_functions.window_centered_ir(rir, len(rir))[0] + rir.plot_time() + rir.plot_spl() + + # Expect no coherence saved + with pytest.raises(AssertionError): + rir.plot_coherence() + + rir.add_channel(self.path_rir) + rir.plot_time() + rir.plot_spl() + # dsp.plots.show() diff --git a/tests/test_transfer_functions.py b/tests/test_transfer_functions.py index 075c3f1..9104f01 100644 --- a/tests/test_transfer_functions.py +++ b/tests/test_transfer_functions.py @@ -303,6 +303,8 @@ def test_compute_transfer_function(self): ) # Check that coherence is saved h.get_coherence() + h.plot_coherence() + # dsp.plots.show() def test_average_irs(self): # Only functionality is tested From 2deb7acebacdc6d445419bd151c771a8012c1ede Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Mon, 5 Aug 2024 11:46:55 +0200 Subject: [PATCH 34/35] added example in general --- examples/general.ipynb | 37 ++++++++++++++++++++++++------------- 1 file changed, 24 insertions(+), 13 deletions(-) diff --git a/examples/general.ipynb b/examples/general.ipynb index f0d02e2..b32c580 100644 --- a/examples/general.ipynb +++ b/examples/general.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -101,20 +101,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Signal – ID: \n", - "--------------\n", + "\n", "Sampling rate hz: 48000\n", "Number of channels: 1\n", "Signal length samples: 189056\n", "Signal length seconds: 3.9386666666666668\n", - "Signal type: general\n", "\n" ] } @@ -153,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -198,12 +196,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAx0AAAGFCAYAAACYM56UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADtPUlEQVR4nOydd3gU5fbHv1uym947CQFCh0DoSJOmUlQUu6jX3tFrwZ9IUemi6LXgxa6IoCCgXrogSJEOKZQEAoSE9N6TzZbfH1N2Znc22U1ms0k4n+fJk92Z2Zl3353ynvec8z0Kk8lkAkEQBEEQBEEQhJNQuroBBEEQBEEQBEG0b8joIAiCIAiCIAjCqZDRQRAEQRAEQRCEUyGjgyAIgiAIgiAIp0JGB0EQBEEQBEEQToWMDoIgCIIgCIIgnAoZHQRBEARBEARBOBW1qxvQWjEajdDr9VAqlVAoFK5uDkEQBEEQBEG0OkwmE4xGI9RqNZRK2/4MMjpsoNfrkZyc7OpmEARBEARBEESrJy4uDhqNxuZ6MjpswFlqcXFxUKlULX58g8GA5ORklx2/PUF9KR+WfanTG/HNgStYuS/N7n38e2J3PDm6sxNb2Tag81IeqB/lg/pSPqgv5YP6Uh6c2Y/cvhvycgBkdNiEC6lSqVQuPcldffz2BPWlfKhUKvxzuRgPf3PM4c8u3ZGK3h38MLpbiBNa1vag81IeqB/lg/pSPqgv5YP6Uh6c2Y+NpSNQIjlBEA7zfxuTm2RwcDz8zTHU6Q0ytoggCIIgiNYMGR0EQThEUbUBv57KklwXH+0ver9wWh/+dVSAh2jdF39flr1tBEEQBEG0Tii8iiAIhziQWSt6f2T2BIT7udvc/uEbOpm3vVyE+788AgD48M8LeH5sLNQqmvsgCIIgiPYOPe0JgnCIH5Mq+Ndn372lQYPDkuFdgkTv04uqZGsXQRAEQRCtFzI6CIJoEh/fHw8vrePO0mNzJvCvl21PlbNJBEEQBEG0UsjoIAjCIdTsXWNwp8AmfT7Ux+wZ2X0+T44mEQRBEATRyiGjgyAIuymrqYfeyLz2boKXg+O1m7rzrw1GU3ObRRAEQRBEK4eMDoIg7GbBlvP86+YYHc+P68q//vbglWa1SW7q9AZ88fclJGSWuropBEEQBNFuIKODIAi7qazT869VyoaLADWE8LPLd6Y0q01ys3xHKpZuT8EdKw9h59lcVzeHIAiCINoFZHQQBGE3nHfj/yb1aPa+7hzQAQBQbzC1qhCrbwSel7VHM1zYEoIgCIJoP5DRQRCE3VTWMp4On2aEVnHc3j+Sf/3nudbhUaitF1dJ//tCAb4/dAV6g9FFLZKfq0VVuPH9vXi/lXmYnMUT3x9Hpze3YtrKQzh2pRjltfWubhJBEMR1CRUHJAjCbirY8Cpv9+bfOm7sHsK//mRPGib1jWj2PptLdmmN1bJ3/ncO7/zvHP++S7AXtr08Gu5uqpZsmixkFlfjxvf3AQBW7r2ElXsv8euiAjyw7eXR8HV3k/zcuA/2QS/hkRrWORCv3dwDQzs3Tc3MmZTX1mNPSj4AIDGzFPd+cRgAMOuWHnhBkFd0PfD9oSt453/nsPzufrh3cLSrm0MA0OmN+PSvi5jaLwI9w30BACVVOnhqVdCq2979hSAag4wOgiDswmA04eiVYgDyeDqUSgU8NSpU6ww4l1MOk8kEhaLpeSJykHStrNFtLhdWoee8HQCALiFeuG9wNJ4e08XlbW8Mo9GE0cv32lx/raQG/d7ZhZSFk0QGVWWdvsHPHb1SzA/mvTQqVOkMWPngQEzt53oj8tTVEsnl7+9Mhd5gwssTu7Vwi1xDWn4lbzi/8WsSRnYNRgd/Dxe3Sj5MJhPq9EZo1cpWfx1yGI0mdJ+7HQDw6V9pktv8e2I3TI2LQKdgL7ipKDCFaPuQ0UEQhF3sv1jAv+4YKM+A5YVxXfH+TqZAYHZZrcsHQhfzmWrroT5axEf7Y9e5huuIXC6owtLtKVi6nQlVWvvUMIyIDXZ6O5vClE8O2LVd3Ds7kbpwMpRssv///Zpk9zGqdEx42gtrT+GFtcyyLiFeeGJUZ9wzKBoadcsOnFJzK2yu+2j3BXQP88bkONcbR87mn0uFovcjl/2FY3Mm4J+0IpRU6xAd4Ak3tRLeGiUyyurRsUqHYB/3VjuAT75Whpd+Po16gxEGowk5ZbVW24T7uuOG2CDcOaADhnQKhIemdXkO0goqG93mP7sv4j+7L0quux69dUTbh4wOgiDsIlfwYO8S4i3LPp+7MZY3OkYu+wvpy6bKst+mkpjJeDoeG9kZT47ujP/svoB/LhXhdEapXZ9/8KujovcDOvrji4cHiQoiuooUwQB81UODcCGvAh/+ecFqu3qDCV8duIxnbozF1qQcbE3OadZxLxdUYc7mM5iz+Qx+e2Ek4qP9m7U/R7iYzwzsbu8fiT8Ss/HoiE74/p90fv1zP53CsTkT+N9n97k8eGpVGN45iDe62gPXSqzDBocu3mP7A7v+AsAYjO/d1Q9DmlgIVC6KKutQVWdAdKAH5v1+BmuONC7wkFtei82ns7D5dBYAYHS3YKx6aBC8ZPDSysFfbNhfU3l/Zyre35mK12/ujgm9wtArwlemlhGE82gdVx9BEK2e4iodAGB8J/m8Ea1tYHe1uAoAMLhTANxUSsy6pSe/Tqc3wk2lwKmMEjz5wwmUVDeekHw6oxRDF+/BnQM64KP74p3V7Ea5UljFv9aqlZjUNxyT+oZj5viuSM4qw/oTmaKB3NLtKXj4hhi88kuCaD9juodArVTgXHY5csutZ5cb446Vh+DjrsYTozrjsZGd4edhnT8iJ6XVzDl7Q2wQPnlgAADg9Vt6oO/bO/lthi7eg8T5N+P5tSdxKK3Iah+9Inwx79ZeGNY5qFky0bZoibDCM1mNhw1KcbmgCvesOoxgby3+eXN8i3uqACbPasSyv5q9nwMXCzF08W4kvH1zqwhVupjXuKfDHj7YdQEf7LqAB4ZGY8mdca3WO0UQQBs2OsrLy/Hee+9h7969MBqNGDt2LN566y34+rLJWCUlmD9/Pg4ePIiAgAC8/PLLmDZtmotbTRBtFy7UyEcr7wP7xyeG4uFvjgFgwkBcGZ5UWsUYEoFeGqt13IBrUEwgTs+/GQAzYPxy/2U+vMoWm09noU5vwOczBsncYvvYdOoa//rI7An8a4VCgX5R/ugX5Y9nb4zFqPfMuRu95+8U7ePzGQMxRSIUyWg0YfuZXMz7/Qw8NSp0CfHG/gsFVttxVNTq+bCRf94cj0gnhtSVs2prwuR4b60a3z06BI99f5xf1n/BLpv7OJ9Tznuwfnh8qEgAobm88Wsi1p8w/zZ3DYzCsrviZB0UG4wm/HOJMaY+nzEQH/15gfcA2UthZR26z92OX54ejmFdgmRrmz3IYXBwVOkM2JqUgztYuW5Xkl/BGO2L7+yLAdEB2Juaj4m9whAV4IE6vREH0wqx+p90nLCRl2TJumOZGBQTiLsHRTmz2QTRLFxv7jeRt99+GykpKfjyyy/xzTff4NKlS5g7dy6/fvbs2aioqMAvv/yC5557DnPnzkVSkv2xyQRBmDGZTLjMxiD7aOSdSRvW2TyI2X2ueSEHzcFkMvHqXD52qnMpFAo8c2MsLi+ZgkduiGlw223JuTjGJuK3NKUCr0yAhEEFAFEBnlh4R1/JdWqlApP6hEuuUyoVmNovAqfm3YSD/zceqx8fit9fGIlHR3TCYyM7NRj28cyPJx34Fo5TXsN8b18P8e85rmcoJvQMdXh///r2GI5ctvaGNIX/JWaLDA4A2HjqGhZvPS/L/jmEHqnxPUPxw+NDMdQiXKpXhC8GdvRH52BPRPnaPvfv+/IItjcz3M4RjA7U7xkcEwBPO/I2/v1LAvKb4KWTG85zHOnngd6RvnhhXFf0CPeBl1aNQC8Nbu8fiV+fG4HzCybh56eHY8mdcfj56eGYO7UXnr0xVnKfr29IxFOrT1hJfxNEa6FNejqqq6uxc+dOrFu3Dn37Mg/Jt956CzNmzEBdXR3y8vKwd+9e7NmzB1FRUejevTsSEhKwdu1a9OvXz8WtJ4i2R3mNHhXsrPE4GcOrAMaDMLVfBLYm5eDbQ1cw/7besu5fSG29ASYTJJNK6/TmWhyOyuEqlQosmNYXC6b1RWZxNQ5fLsLyHakorKwTbbds+3lsen5k0xrfDK4WVwMA3rsrrsHtHh4eg3m/nbFafnLuTQ6FwvWP9kd/Qe5GabUOUz4+gGyLhN/krDL8npCFafHOmXmukPB0cHz64AArb449vPJLAg4LvEVNZcWuVMnl3/+TjtHdgjGhV1izjwGYZaA7BnrC3U2FSH8PrH/2BsltDQYDEhISEB8fj+p6I2ZtSMKOs+IaOs/9dAq7X70RXUPlyetqiIZC+DY+dwOiAzyRX1GHjkGeVr+xTm9EdmkN9qTkY+GWc6J1/0vKwROjOjulzfZSVMkYHUHe0pMAHB4aFYZ3CcJw1sPE/Z91Sw8s3HJOlKMEAH+ey8Oqvy/h3xO7y99ogmgmbdLToVQqsWrVKvTq1Uu03GAwoKqqComJiYiIiEBUlNnNOGjQIJw+fbqlm0oQ7YIqHTN406gU8HeXXwWmT6R5Ntxkck518tp6AyZ/fABjP9hrZQxw6zk8mlGDIzrQE/cOjsaJuRNxbM4EBAk8C6cySp32/RriahGT09Ex0KvRbRPZ0DGOxXf2hZ9n83Iv/D01+Gf2BCyc1gcBFvtaffhqs/bdEGZPh3X7PTVqHH1LbDw8NrITdr0yBvcOjkKXEOm+yimrxb7U5nvk0ouqba775uCVZu+fo5L13ll6exrDx90Nqx4ehMOzxyPMVytaN/HDv1FW4/wii1fZPgry0sDdjRmuRPq548y7t2BQTCBCfd3Rt4OfpFGpUSvRKZhRTktbPFl0j1m45RxyyqyT61sKk8nEezqkQjntQaVU4J3b+yB92VR8/chg0br/7L6IhMzS5jaTIGSnTXo63N3dMWbMGNGy1atXo0ePHggMDERBQQFCQ8Wu86CgIOTlNSx/KYXB4Bo3JXdcVx2/PUF92XwqapgHJOchkLsv/zW8I5bvYGZ+z2aVSobkVNbpoVUrmxzv/tDXR/mE6v8lZFmFQ53LNifbKmGS5TsGebph+8ujMHSJOS597uZkLJjWp9nn5W8J2Sirqccjwzs2mDyqNxiRxaoXRflrGz2et1aJrTNHYuqnhwAAI7sEyvZ7Pzg0Gg8OjYZOb0Svt5k8ipNXS5BRWIkOAU3zoNnqR6PRhErWWPZ0U0h+h2AvN+x4eRTe+d85DI4JwHM3doG7mwpL7zSHmVXr9NiXWoiZPyfwyx797jguLZ7UpPYCTJ4Fx7ypPTGkUyASM0sx7w9mRj63rFa2Pq9mK7C7q1WN7lOqL0O9NTg4ayzm/H5WFA42aOGfSF14iyxttEV6IRPS2TvCB98/NgQnr5agU7AXPNTSv6ctFAB+f/4GdJ1r9mx9vPsCFtsIJ5SDhq7vwso66AyMZ9XfXd3s33pcj2DcOygK60+af587Vh7CgVk3OjVnqqWgZ7g8OLMf7d1nqzU6amtrbRoJISEh8PT05N+vWbMG27dvx9dffw0AqKmpgUYjnj3QaDTQ6XQOtyM5Odnhz8iJq4/fnqC+bDppxczAxQ3Mg9KZfXno9DnU5YklZu/aYA7xWD0tFF4axw0PYULm8ZSr6OchTtDcc9Gs8JSQkODw/hti5hA/fHqcMWouXstHQoJ5lrgpfVmlM+K135nZ9vSMa5jWw7YHI6Osnq8knnslBfl2qtssnxiEijojijIuoKhxhVKHeWmoHz45xvTJh/87gYf7+TRrf5b9WKUzgnMqXUk9h2sq29971iANgCqknJX+LSIBrLkzFA9tNns4mnOO7E03z7J3dytGfX4pemuBB/t6Y+2ZSlwurMKuQycR6tV8r2LKVeZY9bVVdrdZ6py8rzNQXOSB3VeY/emNJvR/Zye+nRYKlZMUk2ZvZq77mqpKJCQkQAUgswTIbOL+BkdocSKH8XL+fPwa4ryr0TO4aZ4Ge5Hqy9O5TBsivVVIPSfPvfTeziagxgvrz5nvY6Pf/xtzRwdgQLi2gU+2HegZLg+u7MdmGx0lJSXw9vaGm5u80oeJiYl45JFHJNetXLkSEydOBAD89NNPWLRoEWbPno1Ro0YBALRarZWBodPp4O7uuFZ+XFwcVKqWLypkMBiQnJzssuO3J6gvm0/t5SIARfDzZmbNnNGXk8+fxvYzedB5hiA+3pwoeSK9BIAgrjwoBvGxTVDQ2bCDf6nx9kd8vDi/a+2lZAAVmBoXjvj4eMf33wB944z4KmE3auuNcPPwRnx8fLPOy5+PZwJgBsDnytR4u4H2bv7jHAAm+XnggAF2H8P2HuUhtmc9PjnG1Irw9AtEfHyfJu3HVj9eK6kGkA93NyWGDLL/ezfExJRT2H2e6ffzuiA8MDS6Sfv5LfMcAMbgGjFkIL88skst1p7ZBwBYfLgSf79+Y7PaCwDndBkAyhAa6N/oed3YOflJHwN6v/Mn/76y3oR7f83DxYW3OEf+mr1mB3aNRHx8j2bvbmLFFZzIMefSnK/2xv3xTcshyy+vRX5FHRQKBboEe1nliTXUl3lncwGUIDzQR9Z7zYABQMSeNHwsqHC+6EAJts0ciR7hzTPqXQk9w+XBmf3I7bsx7DY6/vzzT6xfvx6LFi1CWFgYrl69ipdffhmpqanQaDSYMWMGZs2aJZtG9LBhw5CaKp1ox/HNN99g+fLleOONN/Cvf/2LXx4WFobCQnEF1sLCQoSEOC51qFKpXHqSu/r47Qnqy6ZTq2emjDl1GGf05YCOAdh+Jg/ncir4fZ/JKsO+i+Jr+ZFvjzepiKCbSoF6A/M9Kuv0Vu3nYqx7RfjK/t1UKhX+O2MQHvv+OMpq60X7b0pf/p5oVhA6cbUEe1MLMbG3dOJxLZsg3znYq1Wd//5eKsy/tTcWbDmHtccysbiZNQYs+7GslnH3+7i7yfa9//vQIHSbsx0AMPf3s3johk5N2g/nebpvcLSobeH+Zg9+pJ+HLO1mi8TDU6u2e3+2zklPlQq7Xx2DiR/uFy1/Z8t5LL6zYZGCpuDv6YbS6nrcHt9Blr54fFQX/J6Yg/M55QCANUczMO+23tCqG973oi3n8PXBK9j+8mhU6/R4/qdTyCsX54U9Maoz5t1qbcBI9SX3m3ho5L+P3tQnXGR0AMCUTw9hYq8w/Of+eHi3kuKITYGe4fLgyn60K0Zh69ateOWVVxAeHs6HLb3yyivIycnBl19+iR9++AEHDhzAt99+69TGCtm8eTOWL1+O2bNn44knnhCti4+PR1ZWFnJzzbOjJ0+elH32kiCuF6rZp6SnxnkPrB7hTB7H8fQSmEwmZBZX49ZPD+K/+y5ZbftXimP5WXqDkTc4AHP9BiE1bCJ5TFDjydZNwZ9NoC6pan4CrqXk55OrTyCrVDoxtprNa3h0RKdmH1duQnzMYR9/JGbLum8uf6ezjL+nZT5RU0UBymuY36RXhHj2WaFQ4IuHmVou9Uaj1eeaAieQ0BxxBCFdQ33w/t1iL+FPRzNwOsO+ehKOUFfP9IFUonhT0KiV2P7yaIwQeEpX7rW+vwg5nl6Mr9nE/skfH8Bd/z1sZXAAjiX/y/2bCOnbwQ+fPmDt2dt9Pg99396JjAYEDAjC2dhldHz//feYPXs2Fi5ciICAACQlJeHcuXN4/PHHMXr0aMTHx+PVV1/F+vXrnd1eAEBpaSkWLFiAO++8E1OnTkVBQQH/ZzAYEB0djVGjRmHWrFlISUnBhg0bsGXLFsyYMaNF2kcQ7QWTyYQT6cU4x84M2qOD31QGxQQAYJIsS6rrsWSbuF5B9zCzROfj359Apze38n+NUVUnTnLjvBpCatgBjjMGAgAQ4MlM2HBVspsDJ7cp5FkbNS8q2e/u1QpnOLnfHAD2pshboyWHledtaoK6Lb57bAj/mqvr4iilrDCDv6d1PgFXpb3Mjor39lDDThg4KgPdEPcMjsbOf4vFXPZfKLSxddPQG4z8RIC3nXVz7OXVm8xysgcv2i5kCQD3rDps9365vm4MzujQOulec1v/SOyfNU5y3Zj39+LVXxJQInEPJAhnY5fRcfHiRZFa1IEDB6BQKDBhgllusFu3bsjOlnemyhaHDh1CdXU1Nm/ejFGjRon+cnKYsIPly5fDy8sL9957L1atWoUlS5ZQjQ6CcJCVe9Nw96rDvLchxNt5CYneWjWCWc364+nF2H5GXB9gwzMjMKxzoNRH+VltW3AqRhwFFdYzlTXsNnIOzoSE+GihUDBVkaWOby+19QZ+sCusjp2cVYZz2eVW21ex23prW19YQqS/B1+kz9JnUFWnRyZbX+TI5SLewNx8+hrsgfvefhJyuc1hXA+zMuKHuy40aR+ct8tfQoqYWyaXJO2+C4wxp1XLq5DfI9wHx+dM5N8fuiSv0VEpMOjkDgka3CkQ49nz7lRGaZP2MWdKL1xZOgXpy6by960LeRV2fZYLeXRvJKyrOXQM8sTnMwZKrtt0OgsDFv6JX0/ady0RhFzYdRfSaDSoqzM/JA8dOoSIiAh07dqVX5afnw9fX9uVZ+Vk6tSpSE1NlfzjanMEBQVh1apVSEpKwp49e3Drrbe2SNsIoj3x9wXxLGB0oHPlF7uEMN6M/+y+yC97Y1IPXFk6BX6ebvjm0SGSn0tsRJOeG4Byua5lNfWo04tnJbmQiVBf5xhWXlo1urEF1Rqqaq3TG/kBtlRlYc5gcVMp8NBwseyvVMG5SjaUrDV6OgBg2gCmMODWJHOeSmZxNfq8vROjl+/FZ39dxP1fHuHXvfJLol37dcYMvyWWhdnswWQyIZutEREsYcT7ezAD2KIqnd2D2IY4k8UYooUS3rHmEuKjxRI2l+PYlWJcLqiUbd9HLhfzrzUyG0wA8LagCOkPEr/jj0euiryoh94cj2NzJuD0vJuQvmwqnhrThc9B6smGhqbkWhv9UnDXNVd7xFnc3DtMFEpmyesbEluk3gpBcNh1xg8fPhzr1q0DwKhKnT59GpMnTxZt880332DQoEHyt5AgCJdRahHiESVzqIolI2ODAYBP9ASAZ8fE8g93b60aKQut6yO8v7Nh0YkKtlaBULOem0UHmLwH7uHrTF37eLZK9+EGjI5pKw/xr6XyWc5kMapHXUN9MLFXKJbfZfbgBlgUGjOZTEhlB66tNYE0wo9RFdQbTfgfm9fx718S+PUfSHgT7Ak9qnFi3Pwd8ZH8a0fzOi4VVKG0uh4atVKyqneAl9n78dh3x5veSAtu7Rch276E3DHA3BdCw7G5/HdfWuMbNQNh7tY7/zsrWvf1gcuY99sZ0bIO/h4I9XG3usYAoCerDHU+xz4jsabe+QYxAKhVSqx9ajiOvTWBb6MlD3191KltIAghdhkdr7/+Ovbs2YNhw4ZhxowZiI2NxbPPPgsA2L59O6ZPn47jx4/j5ZdfdmpjCYJoWUpa2OgQ5m0AwHNjY62kON3dVEhfNhXpy6YiJohR+8kqrWlw8FdQwczyChOX0/LNs7JcjoRWrYSXE/NW4jr4sceTDq8yGk0ig0vK05HHJpF3DvaEQqHAvUOi8Q47a2sZLnGtxJxc3slJCfLNRdiuQ2lMiM7Jqw0nJfdfsKvR/XKeDo8m1HRpjGUCQ49LCrcXbjY8roOf5KBTq1bxVdvr9M1LJjcYTbzRJXduC4enRs0bNHLOmnPX6tBO0iGVcjDrFkaG1zL0bNFWcT7ZA0M7Nrifnmwx09Rc+4wOLkHe2Z4OjlBfd+z49xjMndrLal1yVpnEJwjCOdh1xnfs2BE7duzA0qVL8dlnn2HTpk3w8WGs5srKSgwcOBAbN25EbGxsI3siCKKtUFtvQHGVeHAcKDHLJyfdLWbjGsshWfWQ2bs6ZPEem9sVsIP8EG8tH38t9OKUsMndgV4a2WS/pfBhVXgsE9s5Ci2MkXyJ3I8iNgFUGJozWpDbsfucWdnrLFtlPTbES3KGtjUQ4qPFTazc74GLhbxXypKkd27mX/vYkVjsTE+Hu5uK7//0oobziSzhwvjCfW3Xjfrw3ngA0jkfjlBUWYeaegOUCkYy2Vn0YgfdJ2VUsOLqoTw1pots+7Tktn6Ml0anN/LhllKG05I7G65czk1+cGFzjcGHVzkxp0OKJ0d34Sds5kwxGyA/H3NC9U+CkMAuo8NoNMLd3R3jx4/H2LFjRdW+77nnHsydOxfR0U0rkkQQROvkckEVjBbOA2eH6MQEeoreN6Zaww12AGbAbsvbUcgO3oN9tLipdzgA4ECaOfGVU7NytlHF5VXYUj2yHPBsPp0Fg8WPwBkdAQLloy6CAeX/ksyCHtmljFekZ0TL5Ns1lbsHMbl4WaU1uJBn9kD98vRwvH1bb6QvmwpfdzfsfpUplldRq280rKnGyQpBYWzuz0PfOBaewoX1RTWQH+XHGhtp+ZVNluUFgFzWKxbq424l9ysnXJjY6YxSq1yppnBGMPvODeidAZejZjQBJ9MZg2nWBnPOEJco3thEBGdA5pbV2vV7ZbDngLPDqxriLvaaA4CV+9KgN8gj0UwQDWHXXahPnz4oKhLHIB88eFCUXE4QRPviYr51qIAzJXMBJgZ5vqDA1jRB7LwtfnxiKP/6YJq0gg7n6Qj21sJNxQwghLOMLWd0MMessmF0lEvM8g9ZvFv0njNMhLPgCoUCo7oy+TBCL0AR66kKbqVeDo4x3cyemrv++w//eliXIDw2sjP/XihkcC6n4aRdcwiLc87ZvpFMqFxFrR5GS+u8Abi6KQ3VnugeZvb4CUPkHIXzqoQ5SRyBY3zPUPiy550cikjC0McuTvTQKBQKRLI5RUu2MyFVCQJRCnu9nkGs97ROb0SVHbK5XAilU6q420mglwYPDGUmizOLa7DYQqKcIJyBXUaHlOX+0ksvIT9fXl11giBaD9xgRxh33BLhAI+P6syHADRWKRgARgsGrE98f8JqfZ3egLVHmfCBMF8tYlmFrGqBjG6xhPfAGXCeIltGB2dQcLkfwrZxlLPbWErBTuzFSID+cjyTX8YVdWytylUcHnYas8LzYeonBxvcljO4nJWjM3tKT/61I4ZBjR3GkNCjOHPd6Sa0joHzdIQ1EMolB24qJW7pw3gQU+xMpm4IrtDl9IEdoHaihwYAHmGLZp7JKofeYORDGjsG2u9h8dSo+TC+YgmVsAt5FbwiXX5FLZ8r15CyVEvwyA2d+NffHUrH505O3ieIJl/NzXH5EgTR+uHCeoRVyF05M9cQ/aOYQbpOIkTg4EWz96N7mA/vCTh2xSzJ2VKeDm4wWWnL08EmJft6qDF7snlQWy/4Xlw1dcuZcq6iu7DgnI5NRHaG5KjcfHx/vOj96zd3l97QTorZWhgRfs5JoBb28+lMJjRn0n/284PLap30b8zlrDSWa8LluRib8azNbyGjAwD6s8psnKHTHLJZoyPKiUpyHMIk8eFL/+Jff3hvf4f2w3k7CqusI0CeXWMu3Pn272alLFeLO3QL9RZNKi3f0bAKIEE0l9b/JCIIwiVwRoeUrGdr43VWhUaK7DLzIGhwTABUrOHkKSiWV1BRB4Wi5YyOqjrpnAQuvMrPww1PjjYn0G4+lcW/rmA9Hb4Wng7udyqoqONnijlPR1swOsYKiu4Btov67XntRv41d45eK9dj51lxMcnKOqaf7Ek6byqcd+nlnxOQkluOFIF60dJtKZKfSbrG5Cv0CG/4uvr3xG789k2Nt8/jjQ7nhlcB4AUaLD1zTYHLeXCW4pYQPw83aFhvilDIYbCDqlmcl7S02vr7Xy4wiw0Ia/TY6+FzFmqVEmfeuUWkSrhFkBNGEHJj15NIoVA4VdGFIIjWBzfD2ivcB5/PGIiNz41wcYtsI1TmsZSZLWUHQfcPiYZCoUAHidnT3PJamEyAWuXc+xwX5mQ0mROdhXChUz5aN944AoA3Nibxr7n8lEAv8aA8SGAwvcyG5Gw+zRgrOaXNn312NpZGxu3xHSS3E84Ox761DR/vuYiXdxbi+bUJ+PFwOgBAbzCilg1jcqb4weS+5toXk/5zQLTuxyNXrbav0xv4QXmX4IaNDuH61CYWCczlczqc7+kIYtW8Lhc0L/kdYBKyAaCDv/OSyIVYeki5goeOwOVYcdXmpdYB1jLkrkatUuLAG+N44/y7Q+mubRDRrrHrbmwymbBo0SJotebZkvr6erz//vvw8hK7B5cuXSpvCwmCcAncLLJSqcCUOGZwZTA0X5nGGQgNiXM55RjYMYB/zz3kuXAYbnArrK+Qww5y+kf5O7WdnhoVFArAZDJXChfCqVpxA4B7B0dh/QkmMbeith4qpQIV7OcsB5LC0LcTFnUunCmXKidbZo7CrZ8eRM9wH5ueDpVFiN8nf5kLKM77/SwevqGTSJLYmfksdwzogNc22FchHTDXg3FTKRqVw/UQnCtrjmRg6XTHB8ItGV7F5SGVVNdj34UCjLPwXDlCS4U7cvSO8BUJEzw4rOG6HFJw56ulAl29wWhVZBUwF8VsDSgUCmx+fiQmfvg3zmSVod5gdKraGXH9YtdZdeedd4oMDgC47bbbrAwOgiDaDwZ2tlLVBrycCoUCI7sySZlC5RvAHO7AFVzj6iuU1dRj3bEMmEwm/jPBjdQFkaOdXBiG1IwnZ4hwUsFv39aHX7fnfD4/A+ylUfE1P4S8MckcZiYMybFHBaw10LeDH9KXTcWOf49pcLuE+TfZXKfTG1HJ5lNo1EqnhpaplAqE+ojPmSOzJ/CvLXN3uCTlEG+tXdEDU1ljf19q00RbuPyK8BYY4Lq7qdCJlbcVhgM6itFo4uvmcHkSzmbby6P510316PLhVRZGRz7rbVJbGMs5Za3L+9gl2AsBnm6o0xtxqpHinATRVOyaAiLvBUFcf3AREq01edySmCAvHEorslIS4vIkuBwI4Qzz7E3JiGcTYIGGC7bJBRdCte9CAYZZlM/gBiycQeGlVUOjVkKnN+JgWiFvFIXZGETOGBrDJ4NygxqFwnZ+RFvF31OD9GVT0fWtbdAbTfDRKFChY07YC3kVfOhaY8Ul5WDxnXF4ajWjmvb7CyNFA/wrBVWIizIrkRVwRoePfe26a1AUtiTlIIet/+BImHNtvYGfYQ/zaZlZ9fE9w/DtoSu8clhTKKup5+sDOVtNTkj6sqnN+jx3X7HM6djPClkoFQpM7BWK3eeZ4p0/PTmsWceTG6VSgUExgdh9Pg8X8iowrItrlbWI9kmzpoCKi4vx008/Yc2aNcjOpuQjgmhP8OFVbcDTAZilUessciVqeYlS5nZnOXDLEVQR9mtmBWh74HJlPvnLWp6ygJ0VFc6eP87WqTh5tQQn2RlIW/VSfD3M80hr2SrD4b7uTpcddRVpS6bg0uJJ+H5aGLSsR+N/idk4yxaX6xLifG/8Tb3D8NmDA3BszgRewalPJGNNnrhaLNo2v4IxBO01Om4QDPy2JZsT5V/9JQGd3tzKqzxJkSwosCc8L5wJl1if24xZfC5nyddd3SYEEDg4w/5KobhC/eYExusT4qPFc2NjAQA3dg/BSLauTmsi0p8xTrPaQA4Y0Tax64qurq7Gu+++i2HDhmHYsGFYsmQJMjMzcdttt2HFihVYsWIFJk+ejOPHjzu7vQRBtBCc0dFWxqtcDQfLRHKuQrKwxgNX2RoAHmdre4ztEYKWgAuZ4owhIdygVGh0cAPYwso6fLT7AgDbcqtCg+q/+5hch6gWUABqDUxgB7z7UgtwmR34RTpJLteSW/tFIlTgTeA8ZkLVIgA4cpkxQuzNVRDW8tiazEzsZZfWYBMrEDBi2V+SnzubXYZ7Vh3m37eUEEwkm1uVXWpfZW4pslhPZYeAlkkilwvut7L0tJax3qYHh3XEwI7+2PrSKKycMbDF22cPPcKZopRNDecjiMawazixdOlSnDp1Cm+//TaWLl2KtLQ03HvvvRgxYgSOHj2K48ePY9q0afjkk0+c3V6CIFoIYxvK6QDMeRAVFnH0lp4OQFzZmqOxuglycdegKP51jcDwqDcYeXlfYYjOTb3DoBYkkAPAJIFqkiVDLaQ+LROv2yvT+jN5K6l5FVh9mFGOCvZxTSX229kcmh+PXBUNvv+XyBgO0Q4MqCf2Yup1cEnowroztnjqB+simS0Bd97W1BuarNJ0jfXedPBvPYnW9sAZkpZFH7k8nvE9Q6FQKNAn0s+pimrNYQxbaPVCXkWTZZoJoiHsMjr27NmDhQsXYsqUKRg/fjw++OADlJSU4KGHHoKbmxvUajUef/xxnDlzxtntJQiihRCqV7UFuGJ5mwRJrCaTiQ8z0ajMgwGpSuefPjDAyS1k8Naq4cMOOopqzA/2kmoddHojFArxoNTdTcXPQHI8ylZRluIjiyJ73Ox6e8dfIm9FWNm9Jbmxu9lrxoW5AWaVtdHd7feqPXsjU6/lEitFK1RZAsTCCfnltXh9Q6KoNs3PTw93rPHNwN1NxYcZHb5U1MjW0lxja3S0RPK7nHAVzM9b/D6c57Ut5FVF+ntArVTAaDIbSwQhJ3YZHcXFxQgPD+ffBwYGwsPDAwEBZllKb29v1NZSHCBBCNl1NhffHLxiFfLTFmhrno5gCaWbH/5J519zxeI4js0xqwz5uqtbNO+BG1AV1ZjPixq2kJ+XRm1l6AllOJ8bG9ug98KyH75/bEiz29sWcJOoseLn4RpPh7Ba+eKt5/nXXNFGRwoWconohZU6nM0uFxWXA4CMYnMI14NfH8WvJ6/x7/98ZQyGt3BCMFekcm8TQ3Q44YeWSn6XC6HynU7PTCYYTSboDMx9VNsG8lNUSgUfjnk8/fqYrCBaFruvApXKemaQCgYShG2uFFbh2TUnsXDLOXyy5yK/vKRK1yZc10a2iW3F0zG0szmsiFOQ+YMNZ+kS4oWbeoeLthfG4N/Wv2UlZaWMDq62hFSSuDD/42lBpXIpLL04rTFh1RlI5Um48hF1Sx8mLIqrCs/l6wDWITgNIfw9b/30IF/1nBsc/vAPE0qWkltuJRfdLUzsIWsJOHlmqWTyTm9u5f82nbpmtR4Ayi1ko9sKwqrv3G+tF9zmtS0UvtlcuBpHJ9JJNpeQH7uNjtOnT+P48eP8n8lkQlJSEv8+ISHBic0kiLbHwbRCXvqRG/y++7+zGLDwT9y16jCf4Nxa4ep0tBX1KuHscnoRE6JxKqMUALBwWl9J78C+18fipfFdMe/W3i3SRg5Ovai81jwq4Wo6SBWzO/DGOADAygcHIsDBgmnXS5Gv6EBPrLinP/p2MOsQx4Y0XPXbmTw9xmwcXiupxv4L5lyMMDvVqzikLsFurEfh7wsFyCuvxQc7U0Xrpw+UrujubLjkfe58Lq3W8YaGkFfXJyIxs9Tq81zuklQdmtaMQqHgc8U4uep6gzmfR9NGrsNQVgThxyNXXdwSoj1i91TCiy++aLXstddeE713lefj3XffRVpaGn788Ud+WWZmJubNm4eEhARERkbirbfewqhRo1zSPuL6JDXXHNt7raQG+y8U4LtD6QCAxMxS/HI8E4/c0Mk1jbMDYxtTrwKAQTEBOHm1BNmlNYiP9keApxtKquttVn/uFOyFV2/uIbnOmfAFCuvMRgcXQuUrEfvtoVE5VEdgQs9Q7EnJdyiMpz1w16AouKmVeGndaQD2S9M6g0ExZs/bqPf2YkgnZga5R5iPw6F8lxZPQZe3tomWzZzQDXtTCwAAw5bsQQ/WqxHg6YbT829uTtObBS/owIZJxS/40+a201Yesjqvq1hjxVvbNjwDQjr4eyCzuAZZJTUYGO0HvdFsdEiF/7VGJvQKxaq/GeW7ap0enprr6x7S2jGZTHhx3WlcK67GV48M5o3EtoJdZ1NKSoqz29FkTp06hXXr1mHIEHPcsslkwgsvvIDu3btj48aN2L17N1588UVs27YNkZFtozIv0faxlMv89tAV0fudZ3NbtdHR1jwdgDnEIY+txMyFJfm2slnTINZbcbnErEjFFQ2UI+F0yfQ4fPZXGh6+IabZ+2pr3BoXgcziagyxUPFyNcfZcJVR3RwPd1MqFUh652Z8fygdXUK8cGs/6+dYah4TdvXlI4Ob19BmwoUH1tYbJb25KQsnoee8Hfz7goo6kXHI1aJpix66Dv6eAIr53B2BzdFmwtGF183lgir0dZEYw/XA4UtF2HUuFy+M6yrKCWqIE1dLsDUpBwDww+F0zLqlpzObKDtt76oWoNPpMH/+fMTHx4uWHzlyBJmZmViwYAFiY2PxzDPPID4+Hhs3bnRNQ4nrEkv1j/0XmFnJqf0YudPka2VN1rJvCcx1OtrGwxIw52nkV9TBZDKhlqvR4da6bnWDYphZ78sl5gRx3tMhg3cizNcdC+/oi+4uiOl3NUqlAi+M6yrK8XEVH1soiQGwe3Bhia+7G16a0E1kcFxeMsVqOy7sylVw+So19QZczKuUXH9uwS38+yGLd0smnUspzLV2OrB5Nu/vTMUfidk4kdM2FaA4r9ylAuvfj7DNT0evYv3xTLu2NRpNeHHtKXx3KB2fSRSKtUXyNXPRz6YqxLkSu55uPXv2tNtKP3/+fOMbycSXX36JHj16oFOnTjh27Bi/PDExEb1794anp1l2ctCgQZR3QrQoBazRMaCjP05nlPKzXuN7hGJrUg7Ka/Uor9G3SBXspsCrV7Ulo0Pg6aio04Oz6Vqbp6NbKGMMVOtNqK03wEul4lV7pMKriLbJ7f0j8fLPCaJlDw7tKNv+lUoFVj8+FI98a37+uVqa1V1QpJOT9x0RG4S1T5mley1Ddh777jj+c188RnQ1K20Jc3PaCsJk8lfWJ6Gjb9sMTeoa6o3j6SW4lE9Gh70cu1KMOZuZshGxod78xJItzueWo6iKETw5lNZ47R2OFEHYdmpuBYxGU5sRewHsNDpWr17Nv05OTsZ3332H559/HnFxcXBzc8O5c+fw2Wef4ZFHHnFaQy25dOkS1q1bh99//x3r1q0TrSsoKEBoaKhoWVBQEHJzcx0+jsHgmmRf7riuOn5TqarT48cjGRjfM6TVzLK6oi/r9EZ+5noga3RwdAv1QqCXBsVVOmQUVaK3tnU+XDlPB0wmqz5sredlCCsXm19ei6oa5oauVABqhalVtdlLo4CbSoF6gwkF5TVwd1Pxilu+WlWramtrp7Wfk0dnj8Nnf11C70hfTB8QCbVKKWtbR8YG4rtHB6FGZ8S4HiEwGpuujCdHX7opmftGbb0B839nB2HBXlb7PP/uzej19i7+/b9/SRCt93STt59aggAP8ZAqo5wJn1x8R5829V06BTETtl8fvIL9Fwswe1JPDO7U8CDambSma/xqUTXm/HYGo7sF4xmBWMThS2bDYV9KHuKjGn6uX2TDIQHganE1dPV6uyb4Mtg6NgBQpTOgqLJWUrlPCmf2o737tMvoGDp0KP96/vz5eO+99zBy5Eh+Wc+ePdGhQwfMnj0bjz76qGMttUFtbS3y8vIk14WEhGD+/PmYOXMmgoOt42Nramqg0Yh/BI1GA51O53A7kpOTHf6MnNh7fKPJhJ2XqhHlq0ZcqOuSJ1cnVeD31Cr8eOgSPpsc3KriWFvyt8yvYi5ANyXgUy+WHizLSkOAxojiKuDA6XPITndDsGfrCyUoLikFAGRlXUNCgliz3dXXhS0q8hnv0sG0IhxNYAY8GqUCiYmJrmyWJL4aBYpqTDiaeB5FgW5IzyoFAFSWFCAhoca1jWuDtNZzEgDu6AgAhTiTbP+MpiP4sn/nzuTIsr/m9GVVPVejwpxTVVZS6HCkQXJS67tmG0NdIz3wijYVICGh7YTCGFj1rWqdAQmZZbjvq6PYeE94I59yPvael2W1BpwrrMfgCC2fwL/nSjVWJ1VgVLQHnhrY9Im+Dw6X4PC1Ohy+XIxIFCOa9WbtP2t+zh+/cA0JwVW2dgEAOHbe7EXS6Y3Yc/gUQr0aHwdczS8TvT9wIhExfo55N115r3TY95efn4+gIOtiQx4eHigvL5f4RNNITEy06Tl57bXXYDAYcN9990mu12q1KC0tFS3T6XRwd3c8yz8uLk6yRomzMRgMSE5Otvv4609cw9enz0CjVuLY7PFOUa25VlKNCD+PBq3xN/YdAADkVhngH90d4b7uKKnWIZKtxCsHJpPJLmPmh8NX8VdKPhbc1gsl19IQFxcHExT49/pE1OiM+M99/Zwmy5iQWQqgAKG+7rhxYG/85+hhAEwC8YghA9E59RQuleRj+T+lAIA3J/XAU6M7O3SM8pp6fLb3EkZ3C8ZoG8mpOr0R1Tq9SE7WXnySTgIoQKeOHREfHwXA8fOypQksrsaC/fsBAMmV3gAK4alVW+V9tQbCDx5CUU0F/MKiEd8nHOrkUwBq0bNLDOLjo13dvDZDaz8n2xJy9KVObwR+2yVa9tiE/ugXZZ2QHPPXflwtqrZavu2lkbwaV1vCaDQBW3aKlj05MgYjh/ZyUYuaRlTXOiz/Z69oWecefVwWuufoeXn7Z//gbE45nh3TGbNu6YF6gxFPbNmLSp0JOy5V4/XbB6FzsJfj7TCacOZ/e/j3R4s9cNuYPjCZTLiy9S9+eYnejX/mpBdVIdRHaxVS+PPlZABmwyMoqgviGwnJMplMKPmNUYPTqpWo0xsR1KEz4u2sxeTMeyW378ZweGQ6duxYvPXWW5g7dy569uwJk8mE5ORkLFq0CJMnT25SY6UYNmwYUlNTJdc9/PDDOHPmDAYOHAgAqK+vh8FgwIABA7B161aEhYUhLU2cmFNYWGgVcmUPKpXKpQ8ye4+/j01S1umNSM4ux+huIY1+JqOoGjvO5uC+IR0bvZn8dPQq5mw+g7sHReGDe/pLbmMymXh9cgC4kF+FF9cl4EJeBdY9NRzDmlkZd19qPv5vYxKq6gz47YUR6Bpq+6FUrdNjwRYmv+i7wxm4I5rpy13n8rH9DONB+/zvK3hrinMeBsXVjFs92Mcd3cPNsyp+Hm5QqVSI8BMbYR/suoB/jegMD4vCcP/ddwmH0gqx4t7+CLOQxlu5LxXfHErHT8cycHzORCsDymg04f6vDuNsdjk2PHsDfD3c8MJPp3Bz7zC7ZGJL2PAwtUppdQ66+rqwRecQ8znxDStPXFxd3yrbGh3oibM5Fcgqq4VKpUI5KxXq76Vple1t7bTWc7It0py+dFcqoVSIlZu6hftK7m/LzFH49mA69qTkIYlNkJ3YKwy9I/2bdGxXo1IB3z82BCm5FXhyZAz+OnwK44b3bHPnZZifp9WygYv2OCTbbS/fHbqCFbsuYOn0uEaLtNpzXl4rqcZZNpdo/cks/N/kXrhWVI3SGrNox/ncSnQN80VCZinWHLmK58bG2lXTJ7usmq8jAwAbTl7DzAndUFNvQHG1ef+FlTpmvHE2F0//eBJxHfzwx4sjRZOlhZXiyJt89jMNUVZdz3sP+0X54Xh6CQorHX++ufJe6bCky4IFC9C5c2c8/PDDGDRoEAYPHoynnnoK8fHxmDt3rjPaaMUHH3yArVu34rfffsNvv/2G+++/H3379sVvv/2G0NBQ9O/fH2fPnkVtrXkAfPLkSfTvLz1Ybg8kCIosXSls2K0HMAbCEz8cx5JtKfhUUC07Lb8Sd35+CBtPiqvFfr6X0e3+9eQ11NZLu5DLa/V89V0A+D0hCym5FTCagK3JzXP71+kNeG7NKeSV16GyTo+3/zhrtc2Ry0XYcCITRqNJpPAgzKdIFCz//lA6Ciudoy7C5XP4e7iJir1xr7mK1Bx6ownbLPqorLoe7+1IwcG0Qnx94LLVMfZfZAzN2nqj6DtyXC2uRuK1MuiNJmw4eQ1f/H0JKbkV+OSvNKTmVlhtLyS3rJbfp5xeqpbgoeHyJeo6k0h/5hzgDPVyXr2KEsmJtotCoYBGLR5aeEsUvASYAoAvT+zGS0gDwI3dHZcUbk2M7RGKZ2+MhUKhQJCnqk0l+TbGyr1peG7NSYdVF388nI4Vu1JxIr0YL649JXr+LNl2HpV1enywS3qS2VHOZZsjboqrdLhWUmPlTUvLr4TRaMJL607j15PXMHuTeYZ+S1I27vz8EI6ni0OKAabeFgB0DvbCoJgA6I0m7D6fh5OsHHaXEMZ7UlytQ73BiM2nswAAyVlluGwxLqtix0qcHZLLPgdW7ErF7Z8dxGUJ5bCccub4gV4adGCfy0VVbUshzWGjw9vbGytWrMDRo0exfv16rF+/HocPH8aiRYug1bZMLkFYWBhiYmL4Pz8/P7i7uyMmJgZqtRpDhw5FREQEZs+ejYsXL+LLL79EUlIS7r777hZpX0tTW29AXrn5xLPH6LhWUoOLrDLFn+fNuTOf7LmI0xmleG1DIvQGxqLWG4x83QPAuv4ER06ZOA79UJo5hjWlkUFuY+SW1aJGYOx0DBS7Rk9llOCBr45g1q9J2HQ6C2cFN570omr+JimUANQZjNhzXjpvqKmcvFqCj3dfRA6r084pEd0ziAlPenAYMyC29FoAwC8WUnunMs0xopZGhdFoQnqh+UZ6JpsxplJyy/mbbnap+fc4m1WGY1fMN1HuZmiLA6xB0zPcByNim+ehamkGdhS7qId3cb10qhRc5eZNp5jfQs46HQThSrjZWHsRemkDvVyXk0iYWf/MDXjkhhjsee1Gftn7O1Ox/Uwudp61X5SnrLoe834/i0//SsPdqw5jS1IOFmxhJg11eiNftf1qUTUTmtdMhInWAHA+p9xqWU5ZDc4Jlh+7UoyymnrU1hvwf78m4XRGKT7684LVvq+VMNtHBXhgfE8mcubo5WKcuMo8W2/qHQalAjCZGINHON5IyRGPgap1en5fAHP/v1RQiU//SkPStTJ8dUBc1wswGyahPloEsdLbRZWO5yq7kiaL13t7eyMuLg5xcXHw9natLrglKpUKn3/+OQoKCjB9+nT88ccfWLlyZbstDJhVKh7sCw0EWyRnmWf888vr+EE5N3gFwBsl2aW1osqq2aXSSa7C0CoAqKwzuyFtfcZehEYVAHRgZ4lNJhNMJhN2nMnl5VH/PJcrOl5lnR4VOmYlN3swmI2d3H9BnNj594UCjFz2F75gK7LaS0ZRNdLyK/Gvb4/ho90X8DHrPeJqLrw7rQ9+f2Ek7h/CxOpHCDwdDw7rCKUCOJZeLPotcwX9aXnTLKrSQWcw36CvFlbjWkk1bvv0IG799ADS8itE+7qQV8nP0gBA0rXSBr9PGttPw7sEtSoxAHvoF+Uveh/QhHyWlqBnBBMKxoXUNVSRnCDaM0JPeGpe8yaoCHkY2jkQC6b1RWyINwIsZN2/OWg9IAaYKvR/JGajTBBqlFZg/XseSiuCyWSyGqtklljn9ziKpVcjU+DpCGbVDXPKanFaEB0CAGeyyvD3hQLeAyE1Uco9Qzv4e6BPJBM2fSGvAidYT8fQToG8AV1WU490QVssa55U1THHifD14LcXShQnWLQPAB/a5efhhiD2u3yx/zLi3t6JM1llVtu3RlpXxawmMnPmTPz444+iZTExMVizZg2Sk5OxZcsWjBgxwkWtcz6WA/r8cmt3m8lkwrv/O4t7Vv2Dkiqd6DM19QaUVtfDaDSJBqZp7AWQXiT2bFgaORw5pbaNndyyWrMEayP8d98lzPj6iMi9qLeQgVx3LBO19QY8+cMJ3PTRfhy8aDYejl0pRq7FzSy/ygC9wcgP3u9iPQ+WD7h5v51BVmkNlm5PYZIC7SAtvxK3/Gc/Jn74N29ocUYaN4D01KjRP9qfH8ALw6sm9gpFrwjmBiYMCxMaHfkVdajTG/DryWv4+sBlq98gvagK+y8Uot5gYsLZknKtfmOh4XixEf117hyyDANrC1gmCFrmybQWwllvV3mtHnqDkX/YyVEckCBcyZaZo/jX79/dr9HtXxzXlX/90LC2ER55PfHJAwNE74+nl0hut2LXBby07jT+/ctpfplUgUiAGfhbTlTmlTU+YdoQBqOJf8ZzhlJGURUy2WXDOgfxx060GNSfzS4TeSOKq3RW4dcF7PswX3d0Y4UOLuZX4nJhFRQKYHBMIB9KeDGvUuS5OXalWPRMrmLHChH+5ucAV7cDAK4VWxtg3Ge8tWoECzyCFXV6rHJwotRVtAuj43okLb8Cj39/HFuSslHKziqo2dhRy0rYADNT/t2hdBxPL8Gm01miAS3AGBJ5FbWii2TmutOY99sZlFSL3XcFEvtnjsvss2e4dYK33mhCcZUOhy8V4W826V2K1NwKvLcjBYfSikQxnpbS81mlNbjt04PYk5KPtPxKvggVAJRU1yPRYia/oNqAzJIa1BtMcHdTYkx3JtE+vbCK/85FlXUij4Kl4WKLbck5otAvIbbi8zsFeWFAR390C/XGDV2CeaPjvOB7WM4C/ZNWhNc3JGLR1vP4fK9YKOFSQZVolujI5SJklVgbh5yed0FFnWg2yhLu/AiXCANr7aiUCpGal2crNTq4h1NlnV6UVEieDqKt07eDH96c3BNje4TgbnaCpyGeHxeLR0d0wmcPDkBoG7zntHdGdwvBjGEd4SW4l16T8EpsOsXkgu5NLeBzP21NcKXlV1qFZNv7zJVi8dZz6Pv2Tn58MbQzE1ZbUFmHPHZsMqCjP3OcslpksF4Ibryy6VQWVh9OF+3zgoW3o5i9Twd5axDu687L8TL78YWfpxuvHGo5oXkwrRDjPtjHezy4/FdOVKa8ph7FAqOjok5vlT/LTUx5atW8p4NDGFnSmrHL6EhISGhWwSFCfpZtT8FfKfl4dX0iX1SMs7zzymutEr2Errqjl4uQY3FxF1TUSQ5Sfzxy1crNxxkhRqMJJ68W89Z3eQ3z35YUXXJWKR765ij+9e0xnM2WdgUeEyRvCWdTLD0dgPTNLMSHsf4zi81uUIDxdHC5Lp2CvBDp5w6tWgm90YSM4ipcKqjkPTsc9oSpAdbuXCG+HtKz1iqlApufH4ldr4yBh0bFGx3CaqOWs0D7UvP517vOMbkojPcEKKysE7lXz+WUS3qkuoV684bEpULb3g5uhofrz7aGUJ7Tw611Gh1eWqZdJhOQVWo+h9xUNBdEtH2evTEW3z821K7wTK1ahXdu74Nb+7XPEOj2wOI745D8zi38+//svihaX28winJ5uMG1LaPjYn6l1TOuqUaH0WjCVweuiCb/uDDbokod77mP68A8Fyrr9LxRwClmpeRWiDwN3DIhnFEQ5KWFSqkQqVBy4VbcZFJafgW7rdk4qNMbsS0pByaTCVVsTgcXal1eW2+Vn1FeI54YNHs6VHxOB4fU+K01YtfTbcWKFRg5ciSeffZZ/PDDD7hwwTrBhmhZuAGyTm/kpQa7hjK5NXV6I8prxVavMGwqvagKBRYhWEVVOpEUnBBh6BIA3rPy3o4U3PXfw3j4m6MwmUwor2WWxwRJGx1bknL4EKu9KfmS2whnTwrYkCKAKX4IMLMS/p7SM8GhPlqMtEh65qqo5lcZePWI2BBvKBQKPnTo6R9PYsKKv/F/G5NEn7U3QYvz8EjRWFIw90COCWQkCoU3YUujJ+GataEW4q1BZ7a/Dwh+p7Kaej7OVEgHfw/EhjLbX7J4GGxPzsGsDYm4WlTFz5o4o95LS8AZcQDgoWmd38HDTcXfgDlRgLZYm4AgiOsDpVLBi6JUWowXLhdUifIMj10pRqc3t2I/63nQsJMpXJRBWn4lL7jCUVjRtKRoqQm23uwzoLCyjjcmOgV78eGrXA7d5L7WRQ85T/muc+KE+UJWKYqLGOCSwAHzZCunUHkhz5wXKeRSQSVq6418DipndJTV1FspUZVaGh2soeKlUYuMGYCJZnFUVcwV2GV0/Pjjj9i7dy8eeugh5Ofn480338SoUaPw2muvYcOGDbh27VrjOyFkpUykOc3Mjof5aPlBYoHFQFjoxrxWUsOfvFzcY3FVHT/QHN4lEOufuQFDOzHuSW6mgrtYS6p1MJlM2Miq7pzKKMXZ7HLeKu8QIC4g6O7GnGZJgkGzpfcku7QGv53OwhULZSxuhkLPKlx4aFQ4MnuCZJ9E+LmLBpuAWcnoQpEOS7cz4VqcrB2nIMWpcaVbeCyKq+y7AXLGwdS4CLx/dz/+ZgfYL3/KeRSE+TiccefD3sSuFlmrhnlp1XxCsiXcAyAmyKy5Huil4fXILwn6urbegNc3JGLDyWt4+4+z/LngZUPqsrUjlPltreFVjLQoc51woXHBPq0z6Z0gCAIAJscxg3TrXE/x8/PTv8QhwMfmTED6sqm4cwDjWbgk8HRwzyh75F+r6vR4+efTeHHtKT40+mK+2COhVir45/ulgioYjCYoFMzzT+idUCsViAnywtR+EeLv2Jd5f+RyMR9JAgg8Hd7WRkcndvLP253zdDDjpo5BnpgaZ95/Vql5/MXsi3n2V+sMVmOOspp6mEwmvLU5GQMW7MKfbISDp1aNUF+taAK2Tm+0GfremrDbj+/u7o5Ro0Zh1qxZ2LRpE7Zu3YpbbrkF586dw5NPPomJEye2WJ2O6x2D0SSygLnkJ18PN4SwJ7Bl4RlhDke1zsBf7NGB3MWu4wea3lo1hnYOxDALqdGoAGbbkup65JbXipKsdp7N5T0lvu5q0Qw5dzEKw5cSLWbtH/7mKP79SwIfNsS3mx3Qcx4StVLBz5hwaNRMMarnx3VF70jzgD/QS8MbGJdLzRd5T7ZYX2P5CoVVdfgjMdumV4aDU9b698RuuGdwtEiZyt74/FBf7ner4xPYOc8R9xuVSuRgeGrU6BUuNrT6djC/VyiYkCphezijIzVXKCtcxceLnskqEyWstUU6CIwOS+WV1oSGjQnmDNemVI4nCIJoKboEM8+P9KIqkdiKpZfCcgDN3du6sgVc0wrMRkdfNuypsLIOFbW2cw0B4NuDV/B7Qja2JOXg0CXGu38pX2wA6Y0mq5yHAE8N3FRKBHiZnwdhvu5QKRX45P4B+PLhQQCYMcY9g6P4McwHu1Ix//czeODLI/wzmPMyCKM6OMPJy2KSK8LPHStnDMTG524AwIRBcc9XT42KD/+trTdajdtKqxkZ3bVHM1BSXc9PkHprVdCqVfjl6Ruw8bkR6MJ6WYSeptZKk0cUfn5+uPnmm3HzzTcDAHJzc3HkyBHZGkaAd5WVVOmgUSv5WWfG02DejldKclcj2FuLy4VVVqoL2RbKUtwNISrAA0nXylBcqeMNFu44lqE10YEeOJdTjtJqnVXo0Wd70/g2+Xq4QSmI440K8LSKjSyoqIPeYIRapURFbb1o1h1gLny90YRC1nI3sDtXKRVQKhX8egD44qFB6B/tj0Avjeh7+7ireUOJY0RsECb2ZvS1w3wbzlfYfCoLF/MroVQAe14bK5mrUltv4L1OXAIkp0YB2K9EFMQqUeiNJpRU6+Dr4cYnmnUM9BQlygvx0qjQ08K78+DQGLy1mSl2ZDKJJWN93dWIj/YHAJy4WgKD0QSVUiGKBxXe+Nqq0REiiHdtzR5nNq2Dn6Ei5SqCIFozUQEecFMpUFtvRHZZDf+MLbBRaDfYW4N5t/bm33PhvcVVOt7A6Bvph61JOTiUVoS4d3ZhVNdgrHlymOT+hEI057LLMa5HqFV41dBOgVZS6dy91VtrNjq4yT6VUoGb+4Tj56eHI9LPA24qJd6+rQ9e35CINUcyRPtRKRVmA0owoceNDzwtwnlDfZjxAOd5KRRM8Hpp1XwkSF29AcWspyfIS4OiKh3KauqRmmudE8MdowebBP/ZgwORUVxlNd5pjciWsRgeHo477rhDrt1d91TU1mPW7iLEztmBAQv/xOSPD/CuRFthP55aNR+ecbmgis+HAGzL3Ebz3guxpwMQF2yy3JYLpYoN8cL0AR1EAztfdzcIUwe9tdLhLdz3kErE5pKyuBsZ56nhkmyFFW/D/dz5GMtgwWCzpErHV30GmPyKtU8Nh1bNtMcyEYuDmyXnwsqMJqbonxRcOJS7m5K/qYV4i49pDxq1kv8O+RV1ogQyoQvXEk+t2kot7N7BUfzMB+N1MrfBz9MNfSJ94a1Vo6JWzyefZ0tIFSoUrTc0qTGUSgXfL2N7hLq4NbbRsp4Ozuhoq0YeQRDXB2qVkh/ccoItALDLRsHAdU8Nx7T4Dvx7T42af8ZyhQG5iASOg2mFkkIueoNRlJjOKVBx45s74iMxsKM/nh8XC41ayYcmA+awJ+HEjuXzeXiXIHRkPRa39AmDVm09RA7w1PDh46O6BmNwTACeHNWZn6z1shjvcIYNZ6jo9EZ+7OOlUcGd9XTU1JvDq7johmqdXlIlzPI50TvSF5P6Rlht1xohmZRWyurDGbgiCAnKKK7mC7pZejE43N1U/Iz5h39eQI+5O7DjTC5KWIsZsB7Acu+LqnR8Yhh3Qlue2Ny2tfVGXpY3wFODNyb1FG3n56EWKZa421AP4mbULWNDAXMiMOfpOHKZqW7OJWUZBVZOpJ/4O/VnlYs6h3jzBgazT/Hg3DIRi8PyBghAVDNESEElc2MM8dHy31nYx46Ey4SyeR2TPz6Az1hJXG+tusEQLS+Nyuo3VauU+OpfgzEiNgifzxjE32wBxiBUq5R8otxHuy8wIgA11i5tL426zRUGFLL5+ZE49taEVl1rhAuv4h6ktgxhgiCI1gL3zBEOiC1Dpjn8JMJbYwUeAsAcgi3k94Qs1BuM+OV4Bo5cLsKPSRXoMX+XKJ/1ajEzduByVm/tF4lNz4/kJ5oCBSFWXqx3wLsBo0OIj7ubSAWRQ5jj4aVV49fnRmCuwJNj6engwri9NCq+rAFXr8NTo+bHR3qjiTfCOrD9W60zWCWTc8dtq5DR0Uo5mWE9s855BGx5OtzVStFMPwB8vOciX2W8Y6CnlQQqd3KXVOnMygha64sTYDwKnIXP1bPw9XBDuJ+76OL1dXeDcKxqaXRwbeCMJ0tPh49WzSd7XSupYeR82fAwLmdDKM1nKUv7+i09MLJrEJbfxRSlenh4RygAPD6ik2g7YcyncEaDy3kQYintx1FSxdwQAgXGxfieoQjz1eLOAR1ECfWNIfxtvjuUDoAJEbOUfBXu01MrbRjEhnhj7VPDMapbsOTMzmMjOwMA9qUW4EphFR9jKsRyxqat4aFRtXrNfy2bSM6F0lkKIRAEQbQ2eE+HICyXM0QetCju6O9hPfHWzcLoiA609uZvOpWFn49l4P82JmPGN8fxW6r15CQXacAVJhaGNgNmlSlAejK1sUiER27oBAC4e1AU+rNhyY1NYglzOvw93XijQ6FQ8Inf3HjGS6viw6uEn+fyEGt0BpGRJXWMtkbbNZfaOfcPicbfF8RStdmlNXjj10TsTZUuruehUVmp35zPKcf6E4y62ICO/iixSEbm4g2rdAY+EZwPr7Kwpn3c3eDv4YaiKp3Z6GAHtKE+Wv7i8HFnEtq5kBFLo6NLsBcKKup4oyOdlbJ9bmwsdHojxvYI4fe/6XQWNp3O4j8rlfxtOege3S0Eo7uF8O/nTe2FsSE1GNtLHGYTJKjo2S/Kj68LEivh6bDU7+YoZmc9AgQ3twAvDQ6/OQFKBwwOQDrpXBjzyREV4MEbatzNJ9zXHbnltZJywiKDkH09tHMg4jr4ITmrDKm5FTaMDro9OJucCnHxp8425KYJgiBaC5yB8cmei0jJKRcJwAzsGIC1R5k8CD8PN1EoNIcwF8JNpRB5B3qG++BCXgVScivw9cErksePCfLE1aJqFFbWobbewD+fhQIigHgy0EsibLwxo+O2/pEYERuEAE8N9qTkY8m281hyZ1yDn/EUPDdv6xcpGgf4ebihsFLH51B6adVwV4vHR4HeGr4/auptGB1t+Nlst6cjOTkZs2fPxuTJkzFgwAD07dsXgwcPxuTJkzF79mycOXPGme287ri5dxjGdBQPsP88n4f1J67xg3nLC8bdTSW6yLiZ8/8lZgMABkT7i5LDtWol/766Tm+lWGRpLHhr1byrlIul5AaxwkG3u5sS827tDY1aiffv7icaNHtpVOaCfRViT0fPcB/Mu7U3RncLESUCCwlrwsy1SqmAv7v1zIBwFoQrJAQAcYLXHEWVjJFkqYNdwt7sLJPWHDU4AIiS7zk83FRWv4MwnIy7+cy7tTfUSgXetAh1A8TnifA19zsUVNahQsroaKX1LdoTpXVitRGpGT+CIIjWhDCk11JxUigZbysnUGh0WIYjxXXw49WsbBXeHcNOKpbXmnMePNxUVmMi4TNeKoLDHkn7IG8tlEoFbuodhr2vj8UNFrXALBF+504W4jNcuDUnL+ylUUNpocgZ6KU153noDNKhz204CsEuo+OPP/7AjBkzoFKp8PTTT+Pjjz/G119/jQ8//BBPPfUUlEolHnroIWzbts3Z7b2ueKCvDyb2DMXIrsxJnmQRM2lp1Xu4icNJuCI+HFP7RYrccl5aNTzY99X1BnMiuTtndFi4/bRqfnBt9nS4if4DjOfhhtggpC6chHsGR4sGzVw4FgC+MBC3L2Fcp61K2Jzb8Ua2wBBXaKgpCMOr/D3csO6p4fjpyWGSOR1ns8sxeNFuzPlNbFxzniNLo6MpTOtvXY3XQyM2OizliDnDYGq/CKQumoz7h3a02ocwHEvoCeEMxaJKnaSnQyqJjpCXF4aYH9Azx3dt0zk0BEFcH1iGcQsRGhS2wpKFk4rcJOfcqb3QL8oPr9zUXbQPIdMHRKJflB+eubEL/1w7m80oO0b4uVvdP4U5HZygjVDYxl6hF0cQTtZFWIRicQYJl8/KvReOtYK9NPzyalvhVW3Y02FXyz/55BPMnz8fd999t+T66dOnIz4+Hh999BGmTJkiawOvZ0K9VPji4XisPX4Nh9KKrNZH+nuIpFTd3ZToHeGLlyd0Q1wHP1FexdR+EQjx0YoSqz01Kv4CMZnMFwJ3Qmst3H5eWhX82YuUq5/B5VP0ifTF7vPiGQ/uBuAuGLz6ebjxF+IPh69i9pRe/L46Bprl3mzd1Lh9/vD4UNTpDVZtdAThDItapeRnMITeDE66jmPt0QwsvqMv3w7O0xHo1fyb18TeYdg/axx+S8jCh39eAMAYksKcjgAvDW8oAoCn4AZqK39EKPUr7C8ukV6oXCbElgAAIR/jO3mic0wM9l8swqs3dXd1cwiCIBplUEyAzXVS4VSWCCfOuAH3k6O74MnRXQAAMYHSYabv390PKhXzXAr00qCgoo43OqSiIKTCq4RGgb11tBxB6OmwzP/gjs1Fq3gJokrK2fD2QC+NoHaHOexdtJ/2bnQUFxdjwIABDW7Tr18/FBRI5xoQzcOW5Kylla5Vq6BUKvAKO3gpEqhcjWPVHISz18LCNACQzw7+ueNpLTwdnm5qKzUmzsPxyA0x2JOShzsE0ngcwkGyr4eb6ObAqVJ5a9WiWXhbng7L79tcgr21KKys49WcAHGOSIiPFsUWdVEKKup4j1IJm9MhV1G3jkGeolA1y/Aqfw830U3NnhCoLiHe+OzBAVY3Zc71zBSGZHILhEaWpaeLcA53DuiAuwdbe6gIgiBaI8Jn0rePDkaojztu/fQgbmDVJYd1DsTRK8X4+enhkp8X5lVIlVGSev57uYkn1YJYoyOZjQCRSvCWTCS3U72qqQj7xpang/NecO+FY6Qgb605AkWn540OH62aD4P2bMMTgnYZHSNHjsTixYuxePFiRERYawHn5eVh8eLFGDFihOwNJKxjHjnGdA/GxlPX+PceFvGTQd5a3Nw7DGn5lbi5TxgAsSHhycYTempUqNYZ+IrUXPEcy0G9h0ZllajMzRQEeWuxZeZoyXYKL0JvrRp9Ophl6LhCP93CvK1kdnuG+yA1r8Kpxd22zByF3PJaPobUkuhA68KGKbkVCPV1R9K1Uj6eNdhbHqMDEOuIe2hU8NCYfzN/Tw083Mzr7a2jcWs/69At7rcsr6nnw6sCBUaHtg3f2AiCIAjnsfLBgcgpq8G4HqFQKBTYP2scX5Pil2duaPCzIm+IxPNdGPoc6KXBgtt7Q1ORJbnNYXbiMjrQujCecD9eTVCvagrC78YJ9XB4ai2jR1hPh2CsFext9nTU1Bv4Aoq+Hm680aFWtd0JQbuMjoULF+LNN9/EuHHjEBkZidDQULi5uaG+vh4FBQXIzs7GqFGjsGjRIme397rEsl7GuqeGo7bewBex4ZAKh/nykcEwmUz8gF5oSHDJSJ4aNS/ZKVxuOdPtplLwORUc9iRiCY/p4aYS5aJw0rBcMUAha54chopaPTafzsIney6KEtTkItzPXXKG5NWbuuOzv9Lw/NhY/GmRKHchrwKBXhrc/tkhfllTEtxtIXY9q0T9F+DpJjIcm+Nm5W64pzNK+fAqkSCADJ4kgiAIov0xtZ94AtpyPGIvUnOKwkk8f083TO4bjoQEcfHBQC+xN+T2/tYT4gES4VXCSdwgGScLOXqG++D5sbGICfK0Cnm2nEDmcmzdNUKjQyvwiOhRxxaF9vNws1nkuS1h14jF398fq1atQmZmJhITE1FQUICamhpotVqEhYWhf//+iI6OdnZbr1tEMfwaFYZ3CYRCobA6Ad1txFKKPQjmbbgZcx93tajgIGfkaCysaYVCAT/L8CqPxk8h4TE5w2hirzBRDsiAaOsY0WBvLYK9tXhhXCwi/dxxS5/wRo8lFzPHd8VLE7pJrjuVUYJFW8+LlvWwqAreHISuZw83lej3twzjao6KBefpEOZzCG/2FF5FEARBOBOjRCiDMKfTlkiLsLivl0YlWV9LKIvPhY0Lk9gDbRQIbg4KhcKqYDKHZc0tTl7XQ5hI7q0FZ6sUVJgT8e0Za7UFHPoW0dHRZFy4AGEITXSAp2SCtlJhn8tNytNh6UnhZgSklHT8PRz3dAg9MNxA9p7BUSKjo08H214MrVolqcrkTITffe1Tw/DT0QyMiA3CnM1nsC1ZPOPyn/vibYbANQVhn3pqVCLPh6+HG3R6s8yqpWHoCFKuZaE7mBLJCYIgCGciFT4tNDpsPeO6hZmNDH9PjeR4Rahexa3383TD2ieHwUOjglsLhylZThJyOZlCYyTYR4MaNvJEqHKlVraPScD28S3aOWL1IsEsuMAYsVdqU5xIbh3jqFUrG7wQLWcdpIrRNXRM7rtYyv12Dm69RdFGxAZj5YMDEddA3oec+FjkdAiNA5VCIVLXao7EqpRyR7CNKu0EQRAEITcGo7XVIQwb1huNVusBpko4h62wI+HYRlhYeETXYAzoaFuBy1l4WExOcjkewjFXkJfWKj/Xx12N4V0Cnd/AFqDNjipMJhM++eQTjBgxAkOHDsW8efNQV2cOEcrMzMSjjz6K+Ph4TJkyBQcPHnRha5uH8ATkkryBpsXcay0K9Vli6fWwRGhkqJQKhz0d3HcR6nBrVEpZlKicjb+HtCtW7oJuQmNAoRB7p1RKJrlMDqQ8HcKbInk6CIIgCGfSmFJlvUFaSUarVqFfFDMReGs/63wOjl+eHo6P749HLyfkhDqK5ZiLG28Jn+mBXhp4uonHYcHeWjw2sjNemdgdO/4tLdjTVmizRsdXX32FtWvXYsWKFfj6669x5MgRfPbZZwAYg+SFF15AcHAwNm7ciGnTpuHFF19Edna2i1vdNISeDuHsc1OqXouSktl4RmGtD1sDWm5CXWh0GIwmu9ogbDM3kHV3U+G1m7pjUp9wJL59s/1fwIX4W9Ti6BnugzlTelkpVDQX4Y3JwN5wfdib0+huIXjkhhgA4pmbpiA8Fzr4e+DzGQNFyhuU00EQBEE4g1UPDULfDr744J5+DW4n9PxL7ePREZ0arHE0rEsQpklI+bsCy0laLnReWJxXpVRYeTq6hnrDS6vGyxO7oWe4642n5tAmM1MMBgO+++47/N///R9uuIGRZps5cyZ+++03AMCRI0eQmZmJn3/+GZ6enoiNjcXhw4exceNGzJw504UtbxpCo8PWIF/KRdnYvrgkqgeGdsSqvy8BgEjFSoiKtTqaMsAWeToEr2faSNRurfho1VApFXxfz53aG6ME9T3kQhgyVc8ea8crY3C1qAr9o/0BAEdmT5BFeePREZ2QdK0U3z02FH4eblh/IpNfR54OgiAIwhlM6huOSX1ti8N88sAAfPTnBcyd2tvmNpH+Hnjn9j7OaJ5TCLCYuORyOiyL81oaHcJQsraOXUZHz5497Y4dP3/+fOMbNZOLFy+ipKQEEydO5JfdfvvtuP322wEAiYmJ6N27Nzw9zbH2gwYNQkJCgtPb5gyECeLqJng3hAgL43D5GS+Mi+WNDjeV9P6V7O+vUSsxqU84dpzNldxOCqGnw7LgYFtCoVDAz8MNxWwdC06T3JkY2HjWDv4eojwYKZnfpmB5wxZ5pdpAyBtBEATR/ri9fyRu78/UlzIY5AkpdjV+FiHanBcnws8DF/Iq+eXCydlIP3eM7hbSMg1sAewyOlavXu3sdjjEtWvX4Ofnh1OnTuGjjz5CSUkJbr75ZsyaNQsajQYFBQUIDQ0VfSYoKAi5ufYPlDlcdbJzx7U8vlJhu032tNVTMOgP8FDDYDDA002J1Y8NxnM/nca7t/eW3I+nRsUvf/f2XqitN2DGsGi7jinMR1aYTC3ep7b6simIpO283Jz2XW7sHoy/LxRiUu+wFu0voU3oprLuMzn78nqH+lIeqB/lg/pSPqgv5aO99KWvu0WCuJYZV903OAp/XyjAQonxV4CXRrbv7cx+tHefdhkdQ4cOtVpWWVmJjIwMdO3aFTqdDt7e1hrJzaG2thZ5eXmS6yoqKlBbW4sVK1Zg9uzZMBqNePvtt2E0GjFv3jzU1NRAoxFblBqNBjqdzuF2JCcnN6n9cmF5/LKSYpseG3s8OflVZjdeXuYlJJQyp4AXgNXTQgAUICGhgN/m9u6e+ONCNR7t5yna/8z+KqA2GwkJjefJCEO/Mq9lIsGtqNHPOAM5fsvcMrNu9uWUM81Sj2qIZ/qqcH/XYOjyLyMh3ymHkCQ71yzGkHMtAwkm6YO7+rpoT1BfygP1o3xQX8oH9aV8tPW+NFjoAycnJQIAwgD8eEcoPNRFSEgoFm1TV1Mje5SOK/vR4ZwOnU6HBQsWYNOmTQCAnTt34r333kNNTQ0+/PBD+PlJy4o6SmJiIh555BHJdR9++CFqa2sxd+5c3iB688038eqrr2LOnDnQarUoLS21are7u+MhKXFxcVCpWj7MxGAwIDk52Xz8DTsAABFhIYiPF8Q4ssujAjwQHx/f6H4r6/TAtt0AgDFD+osK0UnRq68RT+RVoE+kb/MG2BuZdnaK6Yj4+JaNT7Tqy+bsi+1vABgwYEBzm9bqqLtSDBw4BgDo2S0W8d3Fbl05+/J6h/pSHqgf5YP6Uj6oL+WjPfXlbRcS8b+kHCTMm9Dw+Isda/h4e9o1trMHZ/Yjt+/GcNjoWL58OdLS0rB582bcf//9AJgk7tmzZ2PRokV4//33HW+tBMOGDUNqaqrkumPHmEFRly5d+GWdO3dGXV0diouLERYWhrS0NNFnCgsLrUKu7EGlUrn0JOeOP7VfBLYm5eDlid1F7Xnvrjj838ZkvDWll13t9PNU4etHBkOlVMDfq3EjzFOlQv+O8ulDa9Su60+5f8u2fvOTwksgyeyldbP5HV19XbQnqC/lgfpRPqgv5YP6Uj7aQ19++uBAfPqg/durlErZv7Mr+9HhrN5du3Zhzpw56NGjB7+sR48eWLhwIfbv3y9r42zRu3dvuLm5ISUlhV926dIleHl5wd/fH/3798fZs2dRW2sOhTl58iT69+/fIu1zBisfHIj0ZVNFlToB4L4hHZG6aBKmxNnWqbZkYu8wjOvpuAEmBz3C2rbc2ycPMN6NxXf2dXFLnINQNcOrkZotBEEQBEE4j6aURmjNODyqqKqqgoeHdTE0o9HYYkk+3t7euPfee7Fw4UK89957MJlM+OCDD3DPPfdArVZj6NChiIiIwOzZs/H8889j7969SEpKwtKlS1ukfS1NWyist+2l0cgrr0XvyLZtdNzePxLje4Y2WkSxrSJUrCKjgyAIgiBch79EEd+2jMOejvHjx+Ojjz5CZaVZ3iszMxOLFi3CjTfeKGvjGuLNN9/EmDFj8PTTT+Ppp5/G6NGj8dprrwFgXEeff/45CgoKMH36dPzxxx9YuXIlIiMjW6x9hJjekb4u867ITXs1OABxQUBPiYr1BEEQBEE4lzlTeiHSz73BOiVtEYdHT/Pnz8dbb72FoUOHwmg04q677kJFRQVGjRqFefPmOaONkmg0GsyZMwdz5syRXB8TE4M1a9a0WHsIoj3gK5hVaagSLEEQBEEQzuGpMV3w1JgujW/YxnB4VOHj44NPP/0UGRkZuHz5MvR6PTp37ozY2FhntI8giBbE3U2FTc+PgFKhgKeGjA6CIAiCIOShyaMKDw8P9OjRAyZWdzg7m6nXQCFMBNG2GdgxwNVNIAiCIAiineGw0XHw4EHMnz8fOTk5ouUmkwkKhQLnz5+XrXEEQRAEQRAEQbR9HDY6Fi5ciH79+uG///2v7FXICYIgCIIgCIJofzhsdOTm5uLrr79GdHS0M9pDEARBEARBEEQ7w2HJ3MGDB+PkyZPOaAtBEARBEARBEO0Qhz0dQ4YMwbvvvot9+/YhJiYGbm7iwiUvvviibI0jCIIgCIIgCKLt47DRcejQIfTt2xdFRUUoKioSrVMo2le5doIgCIIgCIIgmo/DRsePP/7ojHYQBEEQBEEQBNFOaVKdjqtXr+LMmTOor6+3WnfHHXc0t00EQRAEQRAEQbQjHDY6vv76a3zwwQfw8/ODl5eXaJ1CoSCjgyAIgiAIgiAIEQ4bHd9++y1mzZqFJ554whntIQiCIAiCIAiineGwZG5dXR1uvvlmZ7SFIAiCIAiCIIh2iMNGx2233Ya1a9fCZDI5oz0EQRAEQRAEQbQzHA6vqqysxK+//ootW7YgKirKqk7H6tWrZWscQRAEQRAEQRBtH4eNjk6dOuHZZ591RlsIgiAIgiAIgmiHOGx0UMVxgiAIgiAIgiAcwWGjo6amBr/88gvS0tJgMBj45TqdDufOncP27dtlbSBBEARBEARBEG0bhxPJ586diy+++AI1NTX4448/UF9fj7S0NGzduhVTp051RhsJgiAIgiAIgmjDOOzp2L9/Pz7++GOMGDECFy9exKOPPoq+ffti2bJluHjxojPaSBAEQRAEQRBEG6ZJdTo6deoEAOjWrRvOnDkDALjvvvtw4sQJWRvXEGVlZXj99dcxdOhQjB49GitWrIDRaOTXZ2Zm4tFHH0V8fDymTJmCgwcPtljbCIIgCIIgCIIw47DRERsbi3/++QcAY3ScPHkSAFBRUYG6ujp5W9cA7777LvLz8/HTTz/h/fffx+bNm3m5XpPJhBdeeAHBwcHYuHEjpk2bhhdffBHZ2dkt1j6CIAiCIAiCIBiapF718ssvw2g0Ytq0aZg6dSqeffZZpKamYvTo0c5ooyR///03PvjgA3Tr1g3dunXDrbfeisOHD+PRRx/FkSNHkJmZiZ9//hmenp6IjY3F4cOHsXHjRsycObPF2kgQBEEQBEEQRBOMjgkTJmD79u0wGo2IiIjA2rVr8fvvv2PgwIF4+OGHndFGSfz9/fHHH39g+PDhKC8vx4EDB3DTTTcBABITE9G7d294enry2w8aNAgJCQkOH0eo0NWScMd11fHbE9SX8kF9KR/Ul/JA/Sgf1JfyQX0pH9SX8uDMfrR3nwqTyWSS/egtwP79+/HGG2+grKwMRqMRI0aMwFdffQW1Wo2FCxeiuLgYH330Eb/92rVr8dNPP2Hr1q127d9gMDTJSCEIgiAIgiCI6434+HioVCqb6x32dOTk5OCDDz5ASkoK6urqYGmz7Nmzx/FWSlBbW4u8vDzJdSEhIbhy5Qr69u2LF198EQUFBXj33Xfx1Vdf4bnnnkNNTQ00Go3oMxqNBjqdzuF2xMXFNdiBzsJgMCA5Odllx29PUF/KB/WlfFBfygP1o3xQX8oH9aV8UF/KgzP7kdt3YzhsdHDehfvuuw8+Pj5Napw9JCYm4pFHHpFcN2vWLHz44YfYt28fQkNDATBFC9955x089dRT0Gq1KC0tFX1Gp9PB3d3d4XaoVCqXnuSuPn57gvpSPqgv5YP6Uh6oH+WD+lI+qC/lg/pSHlzZjw4bHYmJidi4cSO6devmjPbwDBs2DKmpqZLrtm3bhoCAAN7gAIDevXujqqoKZWVlCAsLQ1pamugzhYWFou0JgiAIgiAIgmgZHJbMjYmJQVlZmTPaYjehoaEoKSlBUVERv+zy5cvw9PREYGAg+vfvj7Nnz6K2tpZff/LkSfTv398VzSUIgiAIgiCI6xq7PB3Hjx/nX0+ePBlvvPEGnnvuOURHR1u5aIYMGSJvCyWIj49HbGws3njjDbz55psoKSnB8uXL8dBDD0GhUGDo0KGIiIjA7Nmz8fzzz2Pv3r1ISkrC0qVLnd42giAIgiAIgiDE2GV0SEnhzps3z2qZQqHA+fPnm9+qRlCr1fjqq6+wePFizJgxA56ennwBQICJV/v8888xZ84cTJ8+HTExMVi5ciUiIyOd3jaCIAiCIAiCIMTYZXSkpKQ4ux0OEx4ejk8//dTm+piYGKxZs6YFW0QQBEEQBEEQhBQO5XRcvXoV9fX1omWHDx/G5cuXZW0UQRAEQRAEQRDtB7uMDpPJhEWLFmHy5Mk4ffq0aN2PP/6IqVOnYtmyZVY1OwiCIAiCIAiCIOwyOlavXo1t27Zh5cqVGDp0qGjd559/jpUrV2Lz5s1Yt26dUxpJEARBEARBEETbxS6jY/369Zg3bx7GjRsnuX78+PF4/fXXyeggCIIgCIIgCMIKu4yOrKws9OvXr8Fthg8fjszMTFkaRRAEQRAEQRBE+8EuoyMoKAhZWVkNbpObmwt/f3852kQQBEEQBEEQRDvCLqPjpptuwqeffmqlXMWh1+vx2WefYdSoUbI2jiAIgiAIgiCIto9ddTqef/553H333Zg+fToefvhh9O3bFz4+PigrK8PZs2exZs0aVFVVYfny5c5uL0EQBEEQBEEQbQy7jA5fX1+sX78eH3zwAZYtW4aamhoAjJSuj48PpkyZgpkzZyI4ONipjSUIgiAIgiAIou1hl9EBAP7+/li0aBHmz5+PzMxMlJeXw9/fHx07doRKpXJmGwmCIAiCIAiCaMPYbXRwaDQaxMbGOqMtBEEQBEEQBEG0Q+xKJCcIgiAIgiAIgmgqZHQQBEEQBEEQBOFUyOggCIIgCIIgCMKpkNFBEARBEARBEIRTIaODIAiCIAiCIAinQkYHQRAEQRAEQRBOhYwOgiAIgiAIgiCcChkdBEEQBEEQBEE4lVZvdJhMJjz++OPYtGmTaHlJSQlmzpyJAQMGYPz48fj9999F68+dO4d77rkH/fv3x1133YUzZ860ZLMJgiAIgiAIgmBp1UaH0WjEokWLcOjQIat1s2fPRkVFBX755Rc899xzmDt3LpKSkgAA1dXVePrppzF48GBs2rQJAwYMwDPPPIPq6uqW/goEQRAEQRAEcd2jdnUDbJGXl4fXX38d165dg6+vr2hdRkYG9u7diz179iAqKgrdu3dHQkIC1q5di379+mHbtm3QarV44403oFAoMGfOHOzfvx87duzA9OnTXfSNCIIgCIIgCOL6pNUaHWfPnkVERAQ+/vhj3H333aJ1iYmJiIiIQFRUFL9s0KBB+OKLL/j1gwYNgkKhAAAoFAoMHDgQCQkJDhsdBoOhmd+kaXDHddXx2xPUl/JBfSkf1JfyQP0oH9SX8kF9KR/Ul/LgzH60d5+t1ugYP348xo8fL7muoKAAoaGhomVBQUHIy8vj13ft2tVq/cWLFx1uR3JyssOfkRNXH789QX0pH9SX8kF9KQ/Uj/JBfSkf1JfyQX0pD67sR5cZHbW1tbyRYElISAg8PT1tframpgYajUa0TKPRQKfT2bXeEeLi4qBSqRz+XHMxGAxITk522fHbE9SX8kF9KR/Ul/JA/Sgf1JfyQX0pH9SX8uDMfuT23RguMzoSExPxyCOPSK5buXIlJk6caPOzWq3WyoDQ6XRwd3e3a70jqFQql57krj5+e4L6Uj6oL+WD+lIeqB/lg/pSPqgv5YP6Uh5c2Y8uMzqGDRuG1NTUJn02LCwMhYWFomWFhYUICQlpcL1lSBZBEARBEARBEM6nVUvm2iI+Ph5ZWVnIzc3ll508eRLx8fEAgP79++P06dMwmUwAmFofp06dQv/+/V3RXIIgCIIgCIK4rmmTRkd0dDRGjRqFWbNmISUlBRs2bMCWLVswY8YMAMCkSZNQXl6OxYsXIy0tDYsXL0ZNTQ0mT57s4pYTBEEQBEEQxPVHmzQ6AGD58uXw8vLCvffei1WrVmHJkiXo168fAMDb2xtffPEFTp48ienTpyMxMRFffvllg8npBEEQBEEQBEE4h1YrmSvkr7/+sloWFBSEVatW2fxMv379sHnz5iYfkwvNojodbR/qS/mgvpQP6kt5oH6UD+pL+aC+lA/qS3loiTod3NjZFgpTY1tcp+h0OtKEJgiCIAiCIAg7iIuLsypZIYSMDhsYjUbo9XoolUq+sjlBEARBEARBEGZMJhOMRiPUajWUStuZG2R0EARBEARBEAThVNpsIjlBEARBEARBEG0DMjoIgiAIgiAIgnAqZHQQBEEQBEEQBOFUyOggCIIgCIIgCMKpkNFBEARBEARBEIRTIaODIAiCIAiCIAinQkYHQRAEQRAEQRBOhYwOgiAIgiAIgiCcChkdBEEQBEEQBEE4FTI6CIIgCIIgCIJwKmR0EARBEARBEAThVNSubkBrxWg0Qq/XQ6lUQqFQuLo5BEEQBEEQBNHqMJlMMBqNUKvVUCpt+zPI6LCBXq9HcnKyq5tBEARBEARBEK2euLg4aDQam+vJ6LABZ6nFxcVBpVK1+PENBgOSk5Nddvz2BPWlfFj2ZWmVDg99exTphdV27+PWfuFYdld/J7aybUDnpTxQP8oH9aV8UF/KB/WlPDizH7l9N+TlAMjosAkXUqVSqVx6krv6+O0J6kv5UCqVWLX/Ct7fmerwZzecysHw2FDcNSjKCS1re9B5KQ/Uj/JBfSkf1JfyQX0pD87sx8bSEcjoIAjCYW75+CAuFVQ1+fOvbUjExN5h8PNwk7FVBEEQBEG0Vki9iiAIh8it1EsaHM+NjcWqhwYixEfLLzvwxjjc3j8S9wyKwop7xCFVH/15weltJQiCIAiidUCeDoIgHOL3VLHBkfj2zSKPxaS+EaL1nzwwgH89qlswhi3ZAwD4/p90zJ7SE1o1ucsJgiAIor1Dng6CIBxi1+Ua/vWlJVMcCpEK83VHjzAf/r0jCegEQRAEQbRdyOggCKJJrH58KFRKx2vYbHp+BP/6nlX/yNkkgiAIgiBaKWR0EARhNyaTCWrWzugW5t2kfXhpzVGd5bV6OZpFEARBEEQrh4wOgiDsJqO4BnoT89pb2/SUsM8eNOd51BuMzW0WQRAEQRCtHDI6CIKwmw92mRWnvDRNNzqmCJLN39ue0qw2yU1ptQ7P/3QSa49muLopBEEQBNFuIKODIAi7MZoYN4eHmwrKJuRzcAg/+/0/6c1tlqzM+e0MtiXn4q3Nyfj5GBkeBEEQBCEHZHQQBGE3WjVzy/j3xK7N3tfTY7oAAPRGE2p0hmbvTy62JuWYXyfnNLAl0Va4VlINPYXxEQRBuBQyOgiCsJsKNvHbpxn5HBzjeoTyr3edy232/uSgsk6c2H7gYiHu++IwLuZVuKhF8nMorRCd3tyKAQt2obRaB5PJBKPR1OjnTCYTymrqUV5b36YG8J3e3IpR7+1Fj3k78P2hKziUVujqJhEEQVyXUHFAgiDshhuUe7s3/9YxvEsg//rlnxMwLb5Ds/fZXHJKa6yWHb1SjJs+2i9admLuRAR7a622be0cTy/GjK+PAgBKqusRv+BP0fq/Z41FTJCX1eeSrpXi9s8O2dzvwml98OCwGACAAmhW6J2cFFbW8a8NRhPe+d85AEB0oAf2zxoHhaJ1tLMleOePs/j+n3TcOaADProv3tXNIcCcn49/fxzPj+2KSX3DUVKlw+XCKoT6aBHm6w6NmuaFifYFGR0EQdhFjc6AY+klAAAfGYwOywGfyWRy+SDwVAbz/TQqJXQNzOYPXrSbf90z3Aebnx8JD03rrqxeozPgnlWHG9zmxvf34dhbExDq684vy6+obdDgAIB5v5/FvN/P8u9fv7k7XhzfrXkNloFTV0skl2cW1+COlYfw+4ujWrhFriExs5TPndp8OgsP3xCDgR0DXNsoGams0yOntAY+7m7wdlc3S1mvpag3GPn7yLNrTkpuM7JrEO4dHI0x3ULg7+kGowlNqo1EEK2F1n9lEgTRKjhwsYB/3TWkaTU6LPny4UF4+kfmgXs6s9TlA6FLBVUAgEAvDZ4a0wULt5xr9DMpuRXoNX8HAGD6wA5Ycmcc3N1anwES985Ou7YbumQPLi6eDDeVEgajCXc0YnBI8cGuCyKls+kDO2D+rb3h76lxeF/NITXXdlhc4rUyrNybhhfGNT8/qbVzwsL4mv75P1jzxDD8ejITBZV16B7mA41aiQhfLcrya6AMLkO3cN9WOXjXG4z4PSEbr21IbHTbSD93PDC0I6b0i0CsTPcsuUjJaTxk81BaEQ6lFUmumxoXgUV39EWAV8teUwTRHFrfHYUgiFZJfgUTquKmBCL9PWTZ5029w/jX0z//B+nLpsqy36ZymvV0zJzQFQ8O7QhfdzUyi6vx/T/pdhUy3HQqC5tOZYmW/fL0cAzrEuSU9jqCXpC38dsLI1FSpcNj3x+X3PbtP85iyZ1xWH8iE9lltc0+Ntcvn88YiClxEY1/QCYuFzJG5BOjOuNQWiGeHN0FrwsGq+/vTMWorsHoH+0Pk8mElXvTUFpdjxfHd21xA8mZZEuEDT70zVH+teXA9qOjZo/YB/f0x92DopzXODu4kFeBokodBnT0x5jle/l7UWNkl9VixZ8XsOLPCwj00uDPV8YgqJWERe5JyWvW57cm52Brcg7G9QjB/UM74pY+4TK1jCCcBxkdBEHYRXGVDgBwY4w8BgfQ+kKsskuZAXavCF8oFArcMzgaAPDqzT34bUqqdHhlfQIyi6t5z0hD3PflEQDA5SVTXJbrcDa7jH8dH+2P+Gh/AED6sqmorNNj19lcvLrePBhfezQDL47ritmbkkX7eWNSD6gUCqTkVuBqURUyS2pQYOcAEACe/+kUAGB8z1AsmNYHUQGezfhWjVNWUw8A6BHmg3m39gYA3N4/Et3nbue3mbbyEP567UZM+eQAauuZkLqvD14Rt3tsLJ4e00V2Q8RkMqG4Suf0gXBzkudf35CI1zck4vDs8Yjwk+/at5czWWW49dODzd5PcZUOgxbtxrkFt8CzGTWG5OIKaxArFICpcR0Hm+xNLcDe1AKE+Ghx+M3xUKsoD4Rovbj+ymsi5eXleO+997B3714YjUaMHTsWb731Fnx9fQEAJSUlmD9/Pg4ePIiAgAC8/PLLmDZtmotbTRBtl02nrgEAfLTyPtQ2PHsDn2vwR2K2SxPKS6oZwyqwgcFlgJcG3z82lH//94UC/OvbY43ue/yKfdg3a1zzG9kE/kjI5l//+MRQ0TpvrRrTB0bhpt5hiHtnF798xLK/RNttfG4EBsVIh79dKazCkm3nAQAd/D0arb3yV0o+/krJx65XxqB7mI8jX8UhylmjQ5iDpFEr8ceLI0V5KuNX/N3gfj7fdwmf77uEZdPjcP/QjrK176aP9iMtv5J/r1IqcHr+TfB1d5PtGDq9ESlsmNn3jw3BplNZ+CMxu5FPWXPD0r8wd2ovPDm6i2xtswc5DA4hfyRky/obNhVO5OCDu/tjZNdgpOZVID7aH34ebtAbjLhaXI2NJ6/h832X7NpfQUUd3tuRgjlTezuz2QTRLNqs0fH2228jIyMDX375JRQKBd555x3MnTsXn3zyCQBg9uzZqK2txS+//ILExETMnTsXnTt3Rr9+/VzccoJoexiNJpRUMwM4P5mNjkGCPI4zWWUuMzqMRhOq2XohXg7Est/YPQTpy6Ziz/k8LN52HpdteD/Si6rxe0KWS75feS3z27m7KeFjY0Dr4+6G1Y8PxSMSBlT3MG8M7Ohvc/+dg73w1SOD+fdPju6Mk1dLoFAocDqjBN8dSpf83M0f7celJVOclhzLSTz7eoi/c78of/x7Yjf8Z/dFh/b35qZkeGhUsvyGK/emiQwOgFXY+uMsPrw3vtn758gpM4dWje4WgsGdAhEV4MEPZvtH+WFIp0Bo1EoUV9WhuKgISUUm5EqE1S3aeh5XCquw+M442drXEI5IM780vivOZJfjbHYZ8spte9/e3JSMYV2C0DnYWqWtJSmqZCY4gn20CPdzR7ifWbxBrVIiNsQbb0zqiVm39EBRlQ7phVXoGuqNc9nlKK+tx4pdF3DR4vz56sAVfHcoHSfn3gQ/T/kMV4KQizZpdFRXV2Pnzp1Yt24d+vbtCwB46623MGPGDNTV1SEvLw979+7Fnj17EBUVhe7duyMhIQFr164lo4MgmkBZTT0fqjKxi7whFkqlAg8N74g1RzLw1YErTp2pyymrgcFokgzrqdObBzhNUaKa0CsME3qFod5gREpOBdYeu4p1xzJF23z/T7pLjI6rRdUAgEV3NDxYHNOdUckpZQ1Mjt9eGOlQ2FtUgCffx7f3j8T8W3tj5rrT2JJkXWxx7dGrePiGTnbv2xE4Y0vKc/DiuK5YffgqHzZoL2//cVaW3/C301mSyzedysLwzkG4d0h0s48BADms8dAl2AsqpQLeWjXemNQTb0zqabWtwWBAQkIC4uPjYYIC3xy8gqXbU0Tb/HQ0A9PiO2Bo50Crz8sNF+5oiYebCrtfuxERvu6o1Onh6aaSDCuqrTfgbHYZZm9KxoU88wB997k8PDWmZT02lhSx511QI4ngCoUCwd5aXqJ7RNdgAMCkvhHYfS4PT64+IdpebzTh/V0pjV7rBOEK2qTRoVQqsWrVKvTq1Uu03GAwoKqqComJiYiIiEBUlDn5bdCgQfjiiy8cPpbB4JpKydxxXXX89gT1ZfOpqGEekBq1Eh5qpex92TXEPOtYX693Su5DeU09Jqz4GwoAW2aORMdAT4v15tlRN4Wpyd9RCaB3hDcWTeuDRdP64NHvT+DARSam/nRGKep09VCrlC16Xl4tYrwv0QHujR7v2Ozx6D7PrHT1+YPx0KoUzW7nx/f1x90DO+CXE5nYfsacRLv+RCYeHNr0AXZD/ciFV3lprM9ZBYC/Xh2N+IV7+GWzJ/fAtP6R+PN8HlJyKvDrqSyRMQoApdX1+O7gZTxyQ0yT2wzAapZayLrjGbhrYGSz9s9RyRpeXlpVo7+hsC9VKhWeHNUJ9w+JwusbkvDn+Xx+u3u/OIyDb4xFhGB23hlcKWTCwjoGeiDS3wNHLhdjfI8Q/HfGAKhVSphMRni5KQFIX69uSiA+yg/bXxqFd7ecw+rDGQCAxdvOY0y3IHQNdZ6iVUPnpdFoQglrdPh7qJt8bY3rEYxLiychOasMd3xuTv5fcyQD43uE4MbuIU3ab2uDnuHy4Mx+tHefbdLocHd3x5gxY0TLVq9ejR49eiAwMBAFBQUIDQ0VrQ8KCkJenuNqEcnJyY1v5ERcffz2BPVl08koYwYuWiWT8Sh3X/bWmDMpN+47jm6B1rN/p3Lq4K1RoHtQ05J5/72zkA+f+n73adzeXRxekZhnNjrOJCc16RhSPN1HiQOCKJ5Hv/wbr99gDilral/+eq4SeVUGPDfYF8oGvBD1BhM/Y1yRcxkJJY17cb6+NQRPbmEkkjUVWUhIkKdivA+AJ3sp8HjPMNzzK3M/Ts4qx2/7jqOTf/PCQSz70WA0oYr9vTPSUlCSKR0W+OXUEPyWWoV+YRoM9CpF1qUy9NYAvWOA6TGhMJpMyK00YPZfRajUMefpu1vOo5+HdA0Qe6gXKIktGheIKB81sir0mLO3GABwNb8cCQkJTd6/kJRrzG9vqKuxe5+WfflsXyW6evrivyfL+WWjlu/DhrvDGjz3msv+NMZYDtEaMWuQBkW9Q+CrUTbp+pwWBfzqpkB1PdP3r649igVjna8qJ3V951cZoDeaoABwLe088lTN78NnBvniC8Hv8/gPJ7FgbCB6B7u5vP6RXNAzXB5c2Y+t1uiora21aSSEhITA09M8S7lmzRps374dX3/9NQCgpqYGGo14YKLRaKDTOeZGB4C4uDioVC2vuW8wGJCcnOyy47cnqC+bjyKzFEARfD0ZF78z+lK5aQeMJsAvPAbxAildo9GEboKZ96OzxzWpGnjmhh38a73WH/HxfUTrj+6/DKAEPu5qxMfHO7z/hvg5pBj3f8XkSnj5+CE+Pr5Z52VBRR3WbdgLAOjeMRyzbulhc9tTGSUwgbmXjh020O4ByKHetais0zttNvhjVQ5e/oVRzEqu8sYdY3s18glpbPVjabUOYL/38MHxcGtA1WfCiMaPM2mk+Dxszjnyw+GrfNvuvHEQX9fFIzgbr25IQnGtEaqQzojr4NfkY3BcNmUBKEVwgF+jbW7onIyPB1S+F/HZXnNi8z2/5uHcOzdB66S6NHex12xIoL8s1+TIM6d4j83ZgnqUeHTAuB7O8QY01Jf7UgsAFKBbmDeGDBogy/Hi44GR/YvwyLdmGez5+4rx4T39MC1eHq+Zq6BnuDw4sx+5fTdGs42OkpISeHt7w81N3qSlxMREPPLII5LrVq5ciYkTJwIAfvrpJyxatAizZ8/GqFFMdVmtVmtlYOh0Ori7O+4KVqlULj3JXX389gT1ZdOp1TOzg5zUpDP68vb+kfgtIRvncyowOc78kNx/MV+03ZnsCkzo1Typ1Yo6g1X70/KZWdUx3UJk/27DugSjT6QvzmaXo1onPnZT+vK3RHNuxKr9V/DmFNt5MJtOm7dVq+2/5XcIdG6i7eS4SN7o0BtNze5zy36s0nHnrArumuY/n1Qq4PGRnfHtIUZOd+n2VMy9tWn5R1z9EA83FbzczRNkY3uaje1n15zGkbcmNKPFDHWCa9fePrZ1Tr5+S0+cyS5nB80Mvd/5EykLJzm1IGaPcF9Zrsmb+oSLwsT2pBRgYu+m1bc4dqUYn/51EQM7BuCh4TEI8ZGeCJHqS52B+U38PNxkvdeM6R6K127qjhV/mgtzvrohCRo3FabGRbR5jwc9w+XBlf1otwzNn3/+iaeeeor3Ply9ehV33HEHRowYgcGDB2P58uUwNUds2oJhw4YhNTVV8o8zOL755hssWLAAs2bNwr/+9S/+s2FhYSgsFOuSFxYWIiSkfcQ3EkRLw4WpeDhxYMHVjjibbQ4RWHPkKhZuFVcFf+KHE02612jU5ttdRW291fpiVi53SCf5q6IrFAo+cbek2vrYjrLzrDjcaePJaza3rdMzv90NraBAoRCNWol3b2e8TWuOZDikVGQPhVVMuJyc8rNzppq9MZa1PBzBwIZXPWyRFxIoSCqOCpBHsKG2nr12myCOIMXyu63FWMZ/sE+WfVsS7M30x6S+8hS+u3tgFB4cZpbLXXcsg/WINUynN7ei05tb8cM/6fju0BV0enMr7v3iMA5cLMTHey5iyOLduHfV4Ub3w1HLXpPOMNRul/BqvLj2NHrM3YH8iuYX+iSI5mCX0bF161a88sorCA8P58OWXnnlFeTk5ODLL7/EDz/8gAMHDuDbb791amOFbN68GcuXL8fs2bPxxBNPiNbFx8cjKysLubnmB/PJkydlD5kgiOuFah0jPeqpde5sJgCcuFoCk8mEs9llmPvbGUkJ2jVHrjq0b53eCJ0gIbhCorp4DWtYBduYsWwuAayEpT2DnMbgNP45XtuQiJTccsltq+uY7zUlrvVVLBbKhK49liHrvq+w502XEPk8NpbSvk2daCupYgzPaAnDgpMerpfJCOPOa3c3eaSuQ33c8e2jg0XLsstqceBigY1PNB3uOvV2QMK6IZRKBZbcGYf7BcpgK3ZdaOATwPZks6fw7T/O4t3/nZPc7lh6sd3t4IpQatXy309jgryw7aXRVst1BiOGLt6DpGulsh+TIOzFrrvQ999/j9mzZ2PhwoUICAhAUlISzp07h8cffxyjR49GfHw8Xn31Vaxfv97Z7QUAlJaWYsGCBbjzzjsxdepUFBQU8H8GgwHR0dEYNWoUZs2ahZSUFGzYsAFbtmzBjBkzWqR9BNFe0OmN+PXkNexhQxK8ZJotlWIAWweirKYeBZV1+OhP8WBgRKx5pn7e72f52cdOb25tdPBXVSc2MqRkUvkZYSd5c/w9mAmbkmpds73CnMa/kDtWHpLYEqhiDUZHao+0FIMFxQZPZ5TKuu/ccmZWV+4q2ltmjuJfW0oL20spqwbnJ1GE0p81TjmJ6uZSUy//rPr4nmE4PmeiaNnxK/YPuu1BpzfyymHC4o5y8NjIzvzr1LyKBrd97qdTDa4XGqLlEh5UKWrr5TUELekd6YvzCyZJrrv9s0MYuewvJGaWwmiULzqFIOzBrjP+4sWLIrWoAwcOQKFQYMIEc7xpt27dkJ3teJXTpnDo0CFUV1dj8+bNGDVqlOgvJ4eZlVi+fDm8vLxw7733YtWqVViyZAnV6CAIB1m6/Txe35DIVzAO83WeRKa7mwphvoyX4e/UAuw+L87l+PbRIZg+QLo+glCDX4pKC6OjoMK6eJizQ8hCfbVQKxWorTciW6Lwmr1U6/S8CtdkQdhJbb0R/6QVWm3PfffWaHQEeWvxODsA1FnM7CdkluL9nUyNiJ1nc3kDc+5v9imvcN45uQesfQXJ3S+ua3hAagvOWPH3sA794pZlFFc3ad+WcNeuMLxQDkJ8tDj77i18CNT2M/IonHEIr1m5PB0cPcJ98NKEbgCY3AxbkwANTQ7sfvVGpC+biktLpiCS9dil5jZswHA4wxC0xEOjwnePDZFcl1Vag2krD+HLA5eddnyCkMKuu5BGo0FdnfkhfejQIURERKBr1678svz8fPj6+srfQgmmTp1qM9+Dq80RFBSEVatWISkpCXv27MGtt97aIm0jiPZE0rUy0Xu54sxt0ZMNsfr0rzR+2c9PD0f6sqlwd1Nh2V3SEweJmaUN7peb7ecGXhV1ej7sBGAGF1wF5jAn1R5wd1OhVwTz/Q5JGAcchZV1/AC7qNLaOOLaqVUr8a8RnUTrvthvPYiolDlERW4Gszk0W5Ny+JnXs9lluGPlIazcewnP/ngSz/x4kt9+zZEMuzxFNTrGiJErl0GKQ2lFDn/GaDThWglTJVzKiOcqSRtNwP4LzQ9Z4o5VWNH8sD5LvLRqzGWLeV7Mr2z0OnSEXYK8JanCf83lwaHm3I4P/7QOsXr4m6PoPHsb/z5x/s24snQK0hZPRvqyqSJVt57sdZ1ip9HBhVc5y9PBMbZ7CB61uEcIWbY9BRlF8hi3BGEPdp3xw4cPx7p16wAwqlKnT5/G5MmTRdt88803GDRokPwtJAjCZZRY5B9ES1TylpNhXZgqx8JZ3uGCBGiNWonLS6bws6scb2xsWLe/vIYZeAuLmaUXmXNFKuv0/MxqpMzhOEK4ZPkTDcR/3/m5OUxKKln5DJto3yvCF8O7BOH3F0by6ywHMUajiS9C1xo9HYB44L3uOJPX8YIgpGXHWesZ9Kt2DJRqnBgu99zYWP61o6Fy53LKUVmnh7dWLZlvEiAIuZq57nTTG8niyRpd9w6OamTLpjG1XwT/es95x2th2WL1YcfythxFmE8knOQAgOfWnOQLenL4eTL1LqQMoB7hPgCAlBzpvCpL6jhPhxNyOoQoFAq8c3sfXFw8GQ/YKMD5xA/HJZcThDOwy+h4/fXXsWfPHgwbNgwzZsxAbGwsnn32WQDA9u3bMX36dBw/fhwvv/yyUxtLEETLYhmz7mxPR/dQH9H7meO7Wm2jVCpwYu5NSF82FX0izd5VTqVJCi7xOkRQ30NYEZpL7PXUqJw6M94zgvl+thSs6g1GZBbX8O8NEjHXXGgY91v0j/bHkjvjAAA7z+aJBsGcNCsAp1Zfbg5dQ8ztSmDzOtIbMSrG2qGW5MwcnX9P7AZOfVQqP6ghLhUw512fSF/J2iFuKiVGdwsGYBYfaCr1BiP0rDyrswQS3FRKzGAVoap19lUltodIf8YouMOJNSa468bPIszNMlTs/1jlOVv0ZI2OC43kh3DUtkB4lRA3lRJLp/fDN/8ajOHsxA7HxfxKWZVHCaIh7DI6OnbsiB07dmDp0qX47LPPsGnTJvj4MBdZZWUlBg4ciI0bNyI2NraRPREE0VaoqtNbDaj8mzkIagxuxpDDlvY9xxcPm72rPebusLkdN1AP8dHyeSPlgkTdIlZeNUAisVdOuBAny8R2DktVqjNZZVbbcCFXwgKJ43qa5cA3nDDL555nZ14HdPRvteFVfp5ufF7H3tR8yZAyAEhZaE6MtfR0ScGrNjnBiNSqVQhnPTRCj5k98GF8DeRHPTGK6Q/LXCRHKaiog85ghFqpQOcg59VdiQ5kPKAHGwgbdASj0cTndE2zkcclBzexRUjLaur58yVTIpdG6NmSIor1AGeX2per1VLhVZZM6BWGn5++AenLpuK/Mwbyy5fvTG3RdhDXL3ad8UajEe7u7hg/fjzGjh0rqvZ9zz33YO7cuYiOlnbdEQTRNknLt07OdnaITgd/sSfFvxEjIMoi3EvKMwCYB/PB3lrc0odJvhbGy3NhZEF2DGabQ2NGBxcGxvHPpSKrbfm2Cmo6CBWaDl0yD/zyWAWnmEDnhsU1l7FsVejCSp2oTsvxORPx2wsj+Zye/bPG8ds1przDJ+vKnEDNEcoaDXf91/76DACTxAsA0YG2vYac8VtY2TylM07BK8zXHUql8wrDcR7HlNwKWVS3TmaU8K87OdFYEk5q7GZDw/79SwK/LH3ZVKQvm9rofrhQrfyKWrt+rwv5jEekpTwdUoxivWkA8NX+yzbvSQQhJ3bdjfv06YOiInHC3MGDB0XJ5QRBtC+kpCSdKZkLMKFTO/9tVsq7NS6iga0Z/nrtRv61ZdE8DqGnQ8nGxfgIisZxErTO9nRwRluFjQe81ICtz9s7JbfxtQgJ4ZS9uKrxAFDEeqoCvJz7vZqLMG/nkW+P8a9DfLR8HgxgDrkBgFOCgakUzg5hGdjR3C5bxq4U3Ix6Qwa80OOXLOHtspd83uhwTmgVx8jYYF7BacOJzGbvT5iz0ynIuQYz57H6YBcz23/yasPnlRTcBEC9wYRyiRpAlnDy0EoXVgj3cXfD27cxIgB6ownPrjlJYVaE07HL6JA6EV966SXk5+dLbE0QRHuAG7AIDQ2tk2aNhfQI9+FnGO2Zne0iyAl4XkJTv6K2Hj8fZwZCYb5axLK5DZV15gE+5z0IdPLgvHFPB9Om/lF+kuuZbZjPWsahc3VO1gmK7HEDXE8nG4vNRaNWWuUL+UpI3QqTeO9upAJ0Aevdklsyl2P2ZHN1ci5PA2g8sdyeBHehoTR7k30SwVLklTN94Eypa4CZLBjXMxQAcEmimKejZLPeoPsGR0Ph5IH5G5N6AGBUvioEdTYGCWrINIa7m4q/tqVyfI5dKeYV6YQeZC68y1WM7mYOyzxwsRBv/3HWha0hrgeaPIIgi5gg2jdc2QThAMjZA4CmMrEX8/CW8sQIVWj6RPrBhx0c7Es1h1dxHoGWMzqkE2654mK+Hm747MEB/HJu1h4QejrEg+k+bP0I4Xfgal9oVK3b6ACAuVN7id4/N9ZaRAAQh5U1RBmbrB/uJAlkYd0LTiq205tb0Xn2NnR6c6tVfg4HZ+A2luDOqU01p36bMLzK2cSx5x83WdEcOKMj0t+5whUAMIX1phqMJsS9s4tfvnR6nEP74a47qZykp388wb9esMVc0TzUyR6oxogN8RIllq8+fJUKBhJOpWWzmAiCaDMY2ImFuAZm3VsLXOJtlYR6jnDw17eDH+89iRbkORRV6qBQON/o4EJqqnR6yYd7uSB0aqogtOwbgXQub5i4iz0dXKJwcZUO59i8iBx28CZ3YThnMLZHqOi9LdGC/wkqguvYitX7rtZg1d+XRWFOXBK2MxPoOcNg1q9J+CtFLBf73vYUyc8ks7VvhEUGpXhydBcAjBiA0Oh0hLwWNDr4QbeDal5ScOFVzlbLA2yH33UP85FcbgtOaUyqSr1wmTCXTOtkydzGUCgUWPfUcNzY3ezxWHPUuVLFxPWNXU8ihULRamc4CYJwDpw3MybQE7+/MBIH3hjn4hbZJlZQ78AydIkLd3iQlfXkBjLC4oAZxdUwmQA3lXPvc9wA2GQCqiUGklw8uK+7WnTPfZ9VlzGZTHx+SpC3eJZUOEifyVbK3st6czKKmx/y4mwsB393D5KuKxEuGEB3n7sdsXN24NNjZXh/1wX8ZzdT5E2nN6KONUh8tM5TXOM8bADw+PcnROs2nLxmuTlq6w38bxzdSHK/MIHa3krXluTz4VXOn1HnkrIv5lU4lOMiRV4FYyxF+DvfWAIAy+HNb4LaN/bCiV5Y1jYCnBfiJwcKhQI/PD6Ul9T++Vjzc3IIwhZ2XQkmkwmLFi2CVmu+cdXX1+P999+Hl5dYWWLp0qXytpAgCJfADRyUSgX6s8m8BoN8OvxyEurrjmBvLQor65CcVSZKTOZmGbmZSC4XolwQv80N5PtH+Tu1ne5uSqiUChiMJr5SuBBudp5Lcn9pQjd8suciAMZ4UqsUfC2EcIvZa6GRYhlXPyhGrM3fWjk97yYMWPgnHhgaLVnDAkCDeT6f/pWG127uITI8vbTOm02+mVVCsxfuPNOqlZI5K0I0aiUi/dyRXVaLj3ZfwPePDXW4fVx4leW54gw4z02VzoCNJ6/h3iFNV7TkJgqCvFom/Oi2fpH4IzGbfy8UL7AXzui3FIOoqzegQuJab4n8OEf47tEhGL18Ly7kVaC23uBSZS2i/WLXWX/nnXeKDA4AuO2226wMDoIg2g9ceJWqjXg5+3ZgZDsvWwy4uZlHfw9mJpKbka2o1ePR745BbzDiCltEz9mSuQqFglfIkko45QYnXqwC1YvjzHkNm09nIY+t8eDrrpYsYvjx/fH863ouKQfAxF6hVtu2RgK8NEhfNhVLp/drcLvLS6bYXFejM/DGm7ubUrKCtJzcIDBwAeDk3In86xKL3zhfoKJmT/TA0M6MsZhe2DRPFRdeFdoCRoebSsnLAP9zqen1OvQGIz9wd3a4I8cnD5jzp/a+PrZJ+/D3kA6vymav2dYe4hgV4IFwX3fojSYcuVzU+AcIognY5ekg7wVBXH9wOQcqJ+r7y0k0W7Mjp6xGtJzzKHAhDsJciH2pBTiXY64LEe7n/BhyLsdkc0IWploUWy5lDSQ/Nklco1byHpwLuRXowoaR2UqOniAI9+GKnKmUCpE8cHtAqVQgfdlUfLz7Ij7afQH39vbCxpRqGIwmJF4rhZE1mCNa4Pd8eWI3HP6SGaQd/L9xorC39KIqkVxxARs21FjRS45HR3bGbwnZSC+qhslkcijMubJOzxuxLRFeBQAPDO2I5TtSeQ9LUyitqQenU9PciuyOYE89jobwYycTSmvEhua2ZEbGW6c34oGh0VjHhi9tft7xEC5nolAoMKCjP7afycWVwiqM7eHqFhHtkWaZ3sXFxfjpp5+wZs0aZGdnN/4BgiDaDNxEuTOLiskJJwvLxfJz1OobrteQw85EBnppWqRqN1dN+7t/rBM2uZlw4cz0YyM7AWCqPe88wwxgbIXMC9W7Vuxi8hsi/d3bjOHoKC9P7IZLiyfhvj4+fDjgrrN5fCX3zsHO98YP7xKE5HduxpWlU/hilVw44tErxaJtuQTpUDuNDq7oHgD8eMR8vsQv2IVOb27F0QZmpA9fMq9rKaNzUEdGZparut4UuDyUQC+N071UcsJ5OpKzykXLD7O/UY8wHzw6ojNUSgXuGRSF3oLftrXACQ5kFtc0siVBNA27rujq6mq8++67GDZsGIYNG4YlS5YgMzMTt912G1asWIEVK1Zg8uTJOH78uLPbSxBEC8HNFreV8SoXI11joWBVV28UrQfEIRTP/HgSADCgCXHcTeHd2/sCABSwlh7Pr7Au5taTLRSXW17L1xuxFaMvnAnfmpwDAIjyb93VyOXiCdY4+/FIOl8LwZYCltz4uLuJ+j6C/X0uCWoyAOZCfw0VBhQizGvhDJi0/Eo+hOe+L49Ifu7AxQI8tfqE5DpnwkncZpfVNll6lavY3qEF5HLlRM2KUOgsJj247/PQDTHoEe6DU3Nvwnt3NRw+6Cr6sUqFe1OpBhvhHOwyOpYuXYpTp07h7bffxtKlS5GWloZ7770XI0aMwNGjR3H8+HFMmzYNn3zyibPbSxBEC2FsYzkd3GxupYV6lZSno6OEcpCz6jlYMp4tomY0AdX15oFZnd6AnFJWtUcQFjSmewi0aqVIEeiBoR1t7t9S9UmY29GeuYGtN1BvMGH9CUY5qoeDsqdyce8Q5jfYcPKa6HfbksQYgo4YuA8NZ35rrnaFZby9VM2sh785ZrWsJQj3c4dSwQy8Oa+do2SVMN6gyBZSrpILLrzT0tjicre43B8/T7dW6z0e1S0YABMWaGk8EYQc2GV07NmzBwsXLsSUKVMwfvx4fPDBBygpKcFDDz0ENzc3qNVqPP744zhz5oyz20sQRAshVK9qC3Czx5tPZ/HL9AYjzrDhDsLvIRVutOiOvk5uIYOHRsXPwBfVCIr+VddDbzRBqQAiBAaQm0opCrNRKRWYEmdbNen1m8XB2CeulsjV9FaNj4e1V6MlwqukEKqnffrXRf4156GKj7a/2vV9gxmjIy2/EkajCWezxeE7wvcX8irQ6c2tovV7XrvR/oY3EzeVkr8OD1wsaGRraa6VMMZVS+TjyAkXmpSaJ5Y35sI9namiJhch3lpo1EqYTGYjlyDkxC6jo7i4GOHh5odcYGAgPDw8EBBgvnF6e3ujtrb5lUgJoj3x7cErmP/7GSsVm7ZAW/N0cMo5Qji5WcB6Rvj8gkn8646Bni1ai4gbfBbVmGcTucKGXhq1VVuEErhzp/ZqsK3BFgpcWwTF9NozbhKGJFc7oaXx1JjDp774+zL/mkuw9nagbkOvCMZbU1Grx98XCvCbwKgGxPkTN3+0X7Tu+JyJiA3xtr/hMjAohhkXHLjYNAUrLvnd3mT71oKwujhXzNFgMqHewNx3XF0I0B4UCgViWC/w9TJZQbQsdmdpqVTWFwwVDCQI25zJKsOCLeew+vBVrPiTKe5mMJpwOqMEZRJVa1sbbc3TMaCjeRKEy434LYERuBjeJVBUdReASHL2jgEdWqCFZrhQLqGng6st4SkxI8oV7gIaDq0CYJV82yui9SWsOgOp8Di90XUhIo/cEAMAqGEHoJyaGMBI+dqL8Pd87Pvj/P66hzHnxJf7GaPmoMQg3xUD9yl9IwCYVdo4TCYTOr25lf97ls2lsqSijrk3toSog5wECVTKOKlivSC9rLXV5bDF4E7MfXT3uTwXt4Roj9h9VZ8+fRp+fn78e5PJhKSkJOTmMmoqZWVl8reOINowxwTKNTvP5mHhtL54ds1J/HkuD1EBHtj+8uhWLWXKpQK0FeUj4SAls7gaoT7ufIjAzPHdJCdJTs27CceuFOOm3mFW65xJCCurWl5rHhRzM7xSg61fnh6OtzYn4+kxsQ4X7Worv19zCfN1x89PD8fXBy5j93kmETaug18jn3IeDw2PwerDjOJUWn6FSMkqzMexfIWBHf1xKqNUtKxbqA8u5FXiWHoxEjJL8e2hK6L1827t3bSGN5NgH2bwzeVWnbxajLv+e9hqux1nc7HmyFU8NDxGtLzCQuK6raBQKNA52AtXCquQXVqLKH936AT5Ha29TgdHMHtv2nE218UtIWxhNJqgN5razDklxO6r+sUXX7Ra9tprr4neu8rz8e677yItLQ0//vgjvywzMxPz5s1DQkICIiMj8dZbb2HUqOsjzIBoHaTmmmN7Cyrq8EdiNv5kZ4+uldTgh3/S8eL4bq5qXqO0NfUqgCmmduxKMbJKazEohgljKa2utznjG+ilwaS+jlWVlgOulkNpndno4Cqk+0nkJqhVSiy/u7/d+79vcDR+OZHJz4ZfLwzvEoTaegNvdLjSqO8uSGKf+KE57KlvB1+HvYcbnxuBzrO38e+1aiVentiNVyi7Y+UhPmRvaOdArH/mhuY0vVl4a1lBB9Z4kDI4OOb+dsbK6OCMFWGIWluhg78HrhRWsYpV/qKkcnUbuZFO7huBT/9KA8Dck3xb8cTY9Ui9wYjpn/+DnLIarH/mBnRp4fDJ5mLXVZ2SkuLsdjSZU6dOYd26dRgyZAi/zGQy4YUXXkD37t2xceNG7N69Gy+++CK2bduGyMjIBvZGEPJxpUhcRfinoxmi939fKGgjRkfbeFgC5mTOfDa8gYut9nDQO+BsuDoNF4rMYXblbBVmXwmjw1Hm3NoL3cK8MbVfRLP31da4sXsIVj44ED0jXKNc1RjjejheHV6hUODSkinIr6iFt1YtaUxx+SLv3Nan2W1sDty1VlNvQLVOb7X+0pIpeHr1CexJYQzD5GtliIsye6ROsx6dthKOJIST+c1ik+H1gjSythKO3jvSF6E+WuRX1OFyQRXiW0hK/Hrk94Qs/JGQjXm39kYnO0Uvjlwu4qW3fzxyFW+7+Hp3lLZ3VQvQ6XSYP38+4uPjRcuPHDmCzMxMLFiwALGxsXjmmWcQHx+PjRs3uqahxHVJISsZqWFjsrlwq3sHM3KaZ7PLJeUuWwuGNlaRHDAP5vMr6mAwmlDL1ugQ5m+0BoZ2ZuRdM8vMg7IyzuiQYWbR190NT47u0uYUgORAoVBgar+IFk+glmLdU8Otlglj/x1BpVQgws9DZHCkL5tq5YmMkhBUaEm4fJXaegNScsVKTgM6+kOlVOC/Dw3il9322UF88fclq/20tmvWHjoEMH3/0e4LWLj1PA5ltE1xHS6HzLLODGEbo9GEpdvO4/2dKXbVqKk3GPHyzwnYk5KPz/am2X0coVrdifS2l+xvl6ejZ8+edlvp58+fb1aDHOHLL79Ejx490KlTJxw7ZtYlT0xMRO/eveHpadbiHzRoEBISElqsbQRRwBodg2IC+Kq0AFN3Yf2Ja6jWGVBcpeNDbVobvHpVGzI6uKJ6+eW1fHgHIM9AXk5igph7U63BhGqdHj4eKpSz7ZUKryLaJjfEBlktu78RIQBH+ePFUbj104P8ex8XJ2BzOUe19UacYwdIN3YPwQ+PD+W30aiV6BnuwxslS7enoLSmHrf1M0citEUBhABBMcrv/7nawJatm9gQb/xzqQgXyeiwm78vFuALVtRhWOcgjLEQLrHkTJY5D/qUA0phwrDtC3kVMBhNbeoZbdfdafXq1fzr5ORkfPfdd3j++ecRFxcHNzc3nDt3Dp999hkeeeQRpzXUkkuXLmHdunX4/fffsW7dOtG6goIChIaKXdhBQUF80rsjGAyGxjdyAtxxXXX8plJQUYcP/7yIW/tHYKTEA9cVuKIva3QGVLCxyQM6+omMji7Bnrz7OqOoCv4erTN2Wc9KPSpMJqs+bK3nZTA7i5xTVoPKWkamWKVUQKUwtao2e6gV0KqVqNMbkV9eC0+NGqXVjJHqrVW1qra2dlr7OZm64GakFVShrKYeQzsFQKGQt629wr2x69+joDea0CPMB8ZmKHbJ0Zecg6Km3oC5vzG1uzr4u1vt848XRqD7vJ38+//uu4T/7jN7PDzVilb7m9oixoaX6eP7+rep79IpiPkeq/6+hFV/X8LKB+JdkvvGIdc1XlZTD193a0lyR0i6VoYX1p3GmG7B/9/enYc3VeX/A3+nSZN0L13ZC5SlIKUtS0EsLlUZAVEGcBdkvm6gMs7PBUFARwVFEJ1RYEQR13FBQcQFB1EU0SJQaCl7CwhtoRvd27Rpk/v7I7k39yZpm0DSBd6v5/GRJjfJyclJ7v2c5XOw6ObLpOfaI0sU8VtOMa6IDWv2eY4X2YKH06W1qDM2wFfd8uSjvDJbFrz6RjOKKw0uZ6nz5m+lq8/p0tVOcrKth+KZZ57Byy+/jCuuuEK6LS4uDt26dcO8efMwY8YM90rahLq6OhQWOk/ZFhkZiWeeeQazZ89GRESEw/0GgwFarXIIW6vVwmh0f6+ErKwstx/jSa6+vtEk4L9ZVegV6otrerXd8Prq9ApsOWHA5qx8vHNTVLva46E1P8uCakvAoVUD/vWlivvKc3MQ4mtGEYCf9hzC/kM+GBSpbXdrJ8rKywEA+fl5yMhQvoe2/l40pbLIcuH+x8ky7Ei3lNHXB+1ylDNYCxQ3ArsyD6E8XItTZ8oBANVlxcjIqG3+weSgvbZJkQ5AZubpFo+7EBlnPfM8F1KXtQ2OQY9QW+b2d3D//szzLkNbaaxzfuEV2VCAjIyOk4K2oVw5LezhTzLwxdToNl+X4mq7zK1sxJ4zdRjbxx8BWsuF/LpD1fjsYDWSOmsxP6XTeb+XRb+W4ky5EZ/uzkNCUC36h1uuNX89ZDtHpmefQUZ085sr7j5kG0VqNAv4MW0vOge2fEl+qli5OeiO9P3oHere6Hhb/la63cVaVFSE8HDHHmw/Pz9UVlY6ecT5yczMbHLk5PHHH4fJZMJtt93m9H6dTody6wWTyGg0Qq93L00hAMTHxzvdo8TbTCYTsrKyXH79d3acxDfZlh+16dcPO+95w02Wxyxg58lSJPUIaTaryJEffwEAVBkFBHbpiyC9BnllBmkO+4USBAE1RpNLOdxf/O4IthwqxIo7EtBY/Cfi4+PRYAZuXf0Hahsa8d97k6WFx56WfqoMQAk6h/jhmuGX4ZW03wAA0UE6jByehD7H9iG7tBBv7LYMsf5tdAwWTBjo1mucKTfguW8OI3VAJG4b0cPpMaU1RpytqJN2tDabBZcz5wTtTwdQjJiePZGYaFmH4m67bG2dK+rwz19+BgCkl1uC7wCdr8O6r/agy++/o7i2EoFR3ZEY3xXq/ekA6jCwT08kJjr/PMlRe2+THYkn6rLBZAY2blHcdudVQzCoq+N0qesO7JUyjcntmZ+KTm20seOFEAQB+Pp/itsWjB+AkcN6t1GJzk9sXCOW/LZVcVtkrwHo3sm/iUecP7NZQGmtUUrV64w77VIQBPxj+Xbklhlg0nfCokmXob7BhK+/+gkAsK/ACL8ufRHX2f1EE8ZGMw5vtNXLr8Va3HptIkxmASc22W4vb9QgMTERgiBge3YJ+kUFomuosjP4o5z9AGyBR1i3Pkhs4TpJEASUb7B8t4L1GlTWNSKsay8ktjCVS+TN30rxuVvidtBx9dVX4+mnn8aCBQsQFxcHQRCQlZWFRYsWYdy4cedVWGdGjhyJo0ePOr1v2rRpOHDgAIYOHQoAaGhogMlkQlJSEr799ltER0cjJ0e5MKekpMRhypUr1Gp1m57IXH39347bouwDZyqRGtfyvgN7T5fhi/Q8zE7t2+KC0xXbsvHa1mO4sn8kPpDNzZUTBAGFlbYNoY4UVuOV/x3FmYo6vDVtGMZedmHDs5/sOo15GyyNet2DlzcbyFQYGvDOb38CAD76Ixe397HU5ddZZ3HwrCU4fnVrDl65xfU0pO4orbWMdIQH6hAbZftx89dpoFarHer73d9P4R/XDUCIv7LH4ukvs/BrdjHenZGs2CAOAFb9YtmPYOvhIvxlcBeHtSENJjMmrUpDfrkB7/1tBIL0vpj2zh8YOyga/7o9qcX3cMa607GvxrENtvX3oindwmwZQNal5wEAztUY22VZe4T5Y39+Jc5W1EOtVkvT8UIDdO2yvO1de22THdGF1KVarYbGR4VG2WLavtHBTp9v9bThyMgtw9Lvj0r7mNyR3BMRQR03AcJ3fx+DU+dqMHZQFPbt24ekpN4drl2GBjiW96pXtuPPJRM8/lpLtxzG6l9OYOGNg3BvSvPBmSvtMqeoGrnW7GGbMs9g8V/jcbq8BrVG2yjU0cJqXNYtFFsPFWL19uOYc0McRvRquWO0oKxOSk4CAN9lFeCx6w2obzShut72/CXWc85nu0/jqfVZ6BHmh1+euEbR4Vdao9wguKi65fPUuep6GE0CVCpgcLcQ/H78HEpqGtxuX235W+l29qrnn38evXv3xrRp0zBs2DAMHz4c999/PxITE7FgwQJvlNHBK6+8gm+//RYbN27Exo0bcfvtt2Pw4MHYuHEjoqKikJCQgIMHD6KuzjZEmJ6ejoQE71xgtgfyRUknimuaOdLCbBYw66N0fPzHaSz7ny24Sz9VhmEv/IAVP2Urjv9wp2VR3PZjxVIedXtltQ2ob7R9ITfszZcuXLcevrChZYPRhIXW+cEAsPR7xzTOX6TnYfmWo6hvNCEzt1y6fX+erW4OnbWNxq3fm6eYH+lJ4p4LoX6+is3cxIXOznZP3piRr/i7qLIOH/9xGrmlBrz3+0mH49OO29aJ2G8cBgCnzon54oGvM8/ivd//RK3RhI0ZZ7Dnz1KH4+VOltRIizxjI11L5dde3DnSswt1vUXs+RK/I2L2Ki4kp46u0S57T1OZqNQ+KgyLCUOAbOR6cLeOt4BcblDXYIyLt6SqbuvpSJ428sWt6DX3W8tolhsWf3sIsz/Zh68y8nHTih3YKVvjuPoXy+Jr+XqeC3Gs0LZWosZowomSapw6pzzPHy+uhrHRjEc/3Yfdf5Ypri3e2XESw174Ad8fcFwDLKZC7hcVKC0U//FwobQQXNyMtLy2AfWNJmw5aLnuyS01OGRyE9NJi9ktCyvrIAgCHv10HxKe24J9px0Xl5+1nisiAnXSNcS5aveXDbQlt4OOwMBALF++HH/88QfWrVuHdevWIS0tDYsWLYJO1zpZeKKjoxETEyP9FxISAr1ej5iYGGg0GiQnJ6NLly6YN28esrOz8dZbb2H//v2YOnVqq5SvtdXUN+Jcja3hnS5t+UL6REm1NCohT7v2n59zcK7GiFe2HJP2ODA2mlFaYxvBOFHsPKOFuPuzSP7DctyFQKg5+eUGxYkswS53+M9Hi/DE55l446ccfPzHaRyWBRenSmul1LTysgsCpM365AzG819k9V3WWTz2WQaOW19H3HPhvpTeUKmAGaMtPTmdnUzr+mTXaUUKXXmwlCX7N2CZ7ib25gCQssT8eLgQW6w7yebL5uUePFOhyJDxzf7mJ3//llMCwJJ5K6lnp2aPbW+uthtqvnqAa0PPra2r9aTxhXVEptJgOQm1t0xbRN4mD0rCOuC0qovR1seuxMIbB+HAc3+RbhOvGTbszXP5eUqq6/H2ryfxdeYZPPppBvbnVeC5rw8BsO2jJB4n//t82QcY2YXVOG1329mKOmTlV6DGeq4/UlCF4qp6VBga8MI3h3CuxojV2x2DILGTslsnP1xlPc/s/rMMe6zn1tS4KGkTyNIaI06U2K57souUQUeNdWRETLNcYWjAobOV+CrjDCoMDfggzTH7WVGV5ZweHayTpqMVVtZJt3cE571PR2BgIOLj4xEfH4/AwLbPhy6nVquxatUqFBcXY/Lkydi0aRNWrlx50W4MmG93sV9Y2XQDFC9q5bmeCyrrpLzSObIUeWKPQV5ZLeQdV/bBhfQ8FcrXlQcJTT3GVaU1ymhe7A2ubzShrsGEn48WS/dtO1os9QgAltSN4s7P4o9Aapxlqt1vObbACADWp+ch/p//wz83HXSrfLtOluKXY8V46L97sWFfvtR7I15Azp8wEOkLrpcygMjXksy8KhZajQ+OFFQpfqQKZJ9jXpmy/oqt+1CITpXWIKeoCve+vwcPfJiOjNxyRZ3nFFXjbIXt74NnlEGMvVPWjQ074sZQA+zm6vq303z/4jqbQGsbkfbpaKfZzIjOR7fQlqdKfSvrBDls1yNMbaNvVBDuTemNQJ3G4TNcuc35qMTZCgPe+DEbubKOz+xCx07KIwWVMJkFxXkagOJx58u+0/V0aS1OlVrOZ+L7KKiocxhJOJBfgZ+P2tYXnSiucdhHS7zW6hbqh4HW80x2URV2W6cGjugVhiC95fe7tMaoKIv9nifiSEcXa+dTpaFR8f6dnaOrrGnVg3S+0rrd937/E6Ne/FEx86E969CbA4pmz56NDz/8UHFbTEwMPvroI2RlZeGbb77B6NGj26h03md/QS9fVyEymwXc+95uJL/4I/LLDYoAwdhoxrkaIxpNZsXF7eGzls3rTtl9ifPLnQc14kWts3XKhZV1Lg3JCoKAeRv244olPyl+FBrt0kC++sMxFFfV4+YVv2HEoq1S7z5gyXltHwAV15hQ32iWvtQ3J1oCUHnvgyAIWPzdYTSaBbz3+59odHEIOTO3HLe/lYZ71u5yuE+8gFSpVAiTLe7vGmoLOq7sF4FB1pz0imBQ9h7O1RhhMJrw6pajWLjxgMNo06lztYoAavOBs9JQMGAJAOWB47HC6mY3JiywtqEuTqaBtXc9w5SLHf182+dFfHigpT1U1zXA2GiGwdrLx+lV1NHtmn+t9O9Ffx3c4vFLJsdL/37gyj5eKROdv3f/NkLxd1OzKV753zEs/+EYHvrvXum2nCLHIFIQLJ2Z8o4wQNnR5i6zWUBBRR1OWwMMcST5dGktckstrzPSug60oKJOMZMAsFzkywODCkODQ3nEvbeig/XSGstT52pxpqIOGh8VhsaEItAadIh7aIi+3n8W6ads05rFURZxmlRlXQNKZFOlcksNDudocV1KgE6jWMNpFizTwjqCiyLouBTt+bMUqct/xtvbT0g9pH7WtQPiF0Mup7gaPx4pQnFVPTbuy3foYcgvN+BsRZ1idOKp9Vm4593dKLMbZThX7fj8AFBs/cJc1jXE4T6zAJTVGPH5nlxpfYgz+3LL8cmuXOSXG/DvH23rSkxOdvhMefknHCmoQlV9ozQvHgCq6xux55RyzUJRjQmnSy0jNoE6DUbHWlItny6tlYZ0i6rqFSMqZ5oIruxtOVSApjYgbWqqTM8wf0xK7IrrBkZhRO8waSMs+bQw+x+8rYcL8fpPOfhw5ym8bl1zo9VYvsI5RdWKEa89f5Y5HV3qEqKHSmX5QT1X0/Rc0MIKcRi34wUdKpVK2vUdaL8jHWIGtup6E4pl3ylXMrMRtWdRQXqsnTEcc8fF4ZoBLSdwuXV4Dzw7cRDWPXg523871D86CEsmx+Ma2VRV+doJ0XdZlhGrrPwKae1nUxsM5hRV46zdOdb+usQdsz/Zh1Ev/Sh1vg2zLgwvqa6XZn8k9QwFAJypMCDXOlVqeIxl+vCbv5zA6z8pExAdtRt1E8+ZYQFaRAbpoNPYLqEHd7Nk9gzUWc75x+xGeE6W1GDqm2nSetMaa/10tSaVqTQ0KK4/DA0mxaJ1+WMCdGqp00pU39gx9oFxKejIyMi4oA2HyPNe2XIUJ4prsPi7w9JCon7Rlsi7uKreIUKWrwnY/Wepw0hASVW904vU7ceK8ccJ5QV8Wa0lyDEYTVifnic9V6U1+OkV4Xzh8c6TpXjyi/1YuPEA/jjhfChwv2wBuHwxuLOgQ75oXdTLutOz2GPQx7oIuqjGJC2w7xMZgIhALQK0agiCZXH5T0cKHX5giqtd+wHML2t66lhTvdYqlQr/uj0Ja+4ZAV+1DwZ1sQzVHpOVwf4z+jXbNoVsp/UzSegeAo2PChWGBsWajcNnKx2mZAGW997dOofUfrhX7px1DY/9D1tH0VmWHay9Bx0AkCfrOdS4sEEUUXuXGheNmVfFunSsj48Kf7uit8dSq5Pn3Z7cE2tn2EY83rC7QK9rMClmM5workZ9o8nhvCrKKap26FgrOs+RjkaTGd9mKdcpDrEu6i6tMaLE2qkz2HpbXYNZ6uC7cYhl0b88QY44W8O+7GJQEBGohUqlktZjAJA6DgN1lvONOK1MPjVNECydh2azII1adLHOeqiwCzoAoNyg/LtaCjo0iAhQrqF2dr5vj1w6uy1fvhxXXHEFZs6ciffffx/Hjh3zdrmoBfIL0sy8cgBA30hL0GE0mVFeq0zHJu8FP32uVrqoFJXWGKUG7eerljIqAMDOk8oAobzW8kVY+NUBPP55Ju54eycaTWYpY5N44W/vf7JsEDusC5Xtyb84ZbUN0qJuMeiI7xaCyUndnD62W6ifQ9o7sRejqNaEk9b1En0iAqBSqRBtHdacsXYX/u+9Pbj3/d2Kx5a4mBVCPp3NfmpZsItTZcT85/KeHvu1OfKpV6JQfy1irZ/7HlnQUWs0YZeTDFVdQvyk4+0X96/dcRK3rk5DRm651BY66qJmMYgDms6c09Z0Gh+pvYiLH8UTFxFRe6NSqTBjdC8AQK1dFsucomrFTIltR4oxYMH3UirkEb0s5+K/Ws/fOUXVDh2drp5z7dlPAfdRAXHWc0BxVb00QtG9k780zVkcRbjeSSr/6wZathxYb7dgXpzlEWa94JfvW9I7wvJvsTNJnLptH0ifLKmRptICsjUddY1ScCQSZ7GYzALKaoy26VVax5GOvLJap52z7Y1LQceHH36Ibdu24e6770ZRURHmzp2LlJQUPP744/j888+Rl+d6JgPyDHlEfOSspXFHBOkQat3nochuipV87mR+uUHKKS1mQDgnCzqSeobix8evwgRrD4B4QSR+WctqjTCbBWkdxcmSGmTklkvZdzqH6OGrtl19B1m/hPKFURmyUQwA2J9Xjn9vzVaktAVsF97ij5mvWoUXZfN/5bp38lNsQKVSQcq8lH62Hsu2WILlPtaLbjGDVKV1cVaDSfmFte91aEqhNXPEI9f0xX/vG4Uh3W3Ty1y9aI8MsnwO8mk25dYfnE7Wz9Q+Kwdg+fEZ2CXI4Xa5frL9PcICtLKgwzbSUVXXgOe/OYRdJ0vx4reHpcwaAR10qoN8I6aAZjazbEsqlQo66/dEzIoS0UFHlojo0nDtQMt0OfsLffsA4rWtys7pd/+WjD+XTJAen1NcLXWeiuco+4tuZ4qq6nDzyt9w04od0nQjZ4vVo4Is5/c/z9VCECzpmcMCtIopw1qND7oE6x3WEd1kXfNpP21ZPr0KgDRrAABiwi2zKsTEIOL5unsnPzx4le3588sNqLEuIlepLB2HgGXmiMNIR20DzGYBM97dhaGLfsBnu3MBWM7LkUE6dAv1k7JlNZiEC1oT01pcPhvr9XqkpKQgJSUFAFBRUYE//vgDaWlpeOedd9DY2IhRo0Zh0aJFXissWTSYzNKFMgActc6tDPHzRUSgDuW1DdaI3HYxKu9Br280S9M5eoT5oaS6HqU19dJUoACdBj3C/KWRE1H3Tn4orTGivLYB+eUGRRk27MuXRjpC/HwRoNNIoy0xEf44kF+JP2UXzVmyfUUEQcADH6Q7/cIUVNahV0SAlF1L4+OjGIUBLCMr5YYGPD52AMyyaWURgTrEWEddSg22YV8xD7yztLVyxVX1WPFTNkL8fDHt8l5NHldkHemYPLQb+kQGonOwHvtheX+uZiKKsgYd56otWanUPippulrPMH+U1VY43R/FX6exLJzOOCPdNjymkzTqofZRoU9kgDSvNlivkXppFGmFZZ/NsaIq6UcxQNc+RwlaIh/Sbs8Ls3VqFQyNtiwu7bmsRES9rdOnT52rQaPJLE0HbW6NIGAbARAXYOcUVUsjBfHdQpBdVI2zFXU4eKYCg7oEN7nHyTs7TkpTr3/NLsYNg7vgRIky6DALUCRuAYBO/lqofVRSJx5gGWXw8VHh6fEDcfuIHrjhX7+iT2QAxg/ugm6hR5BfbsAzGw+gwSwgu7BKyh4ldg71DrdNJe9l/XeA3ch6dLAed4+KwYT4LrhpxW/ILzOgVuzU02qktbj1jSaHPTfENLq/ZpdIf4t16av2wTezU1DXaML9H+zBgfxK+DrL4tPOnHcXYEhICMaOHYuxY8cCAAoKCrBz506PFYyA2gYzDEYT/iytRqi/r/QFtV/YLQrSaxARqEVOkbLHHIDDgi1x9+Menfyx73Q5ztUYERlka9Di88n16OSP/XkVKKs1oqxWWYaP/zgtK4cvfGQ/GN1C/XAgXzmCUV5rydij1figvNYxS4SfrxqGBpO0KF4c6fDxscz/9VWrpJGJRZPicUXfcKhUKulLCQB6Xx/06KSc6nVHck9c1d/S0xLVQtDxQdopqedlaEwnpwvkq+sbpWBAfD55L3uQiyMd4YE6+KgsP5bnauoRrPeV1qx0D/NHZp7zFLeBOo3DlJz7xvTBnlPpACzDsqF+th/fED9fDLNOOdt7ukz6DOS9OfKpeR11UafihNOOf4e11pEO8fvqanshImoLXUP8oPf1QV2DJduluIazxEkCGwC4sn8kHr7atrand0QAfFSW9K9ix9egrsHYsC8f6afKMOH1HdBpfHB00Tinz7dTlhr2aEE1bhjsOMoydlC0IrgALB1ugPKcFinLANUnMhBbH7sKIX6+8PFRYcGEgZj137348UiR4nl81SppBkPfaFvHrNjB6W83si6OrIizSspqbbNK/LVqafPgugazFLhFBelQVFWPCtkUcznxNTpZz3Nr7xmB4ur6Fq9p2gOPrVjs3LkzJk2a5Kmnu+QVVtbh0e9LMPi5H3DjGztw4xs7pLzOTfUo+PmqpYaddvyc9EUUBMFhLw+RODxYVmOUplw1FXRIx9Y2SBf3cZ2DMOtq5WLBYL1GsbbB/ksoEteV/HnOceNAcQ8D8aJfTNEnfkHlox1RwTqpV0TeU1xabVTs/B3m74uXJsdDbS1ceIDzqSy2xei2H1H7zflE4sK3QJ1Gqjf5FBlXN7qyDP1aPruTxTVSj4pKpRzCteevVUv5wkVjB0VjTD9Ldq4+kQGKzzHYzxf9ogIRFqBFXYMZ6dYREWd7u/iobBnROhqVSoVxgzsjIlCLvwxynLPbXmg1lrYojpYF6ztmkEdElwYfH5XUmSdfg/nJrtNOj3924iCM7BMu/a3TqB3SmsfazaqobzRLazBFJkHA6dJaxV5i4v4bYqbJ+1J6469J3TA7tR80ah/F9UCAdF1ju81+ZLlnuD9CrMHKNXFR0tRwuRA/LXys1xApfSMwZWh3PHfTZdK1if3sgOhgy3m9k/VaoMEkSJ2pgToN9L6WaxlDg0nqzBXrx9BgwpkKx2s3+9eICtY77RRtj5gmpZ16P+0USutsU4LKaxuQcbocQNNrDfSyoOPT3bkYveQnfLTzFIqr6lFd3wgflWURtZw4elJaY0R1nS0zAgAp9Zt0rPWLYGw0S4ung/W+eGCMcj6kZfG0LeoQv1T2xKFEZ2sV5IvAAMvmewBwZT9Lyj75+gv7vSTEC+7k3mHwlQUnQ+121m4qM5P9DyAAxaZ9cuLCN3mgIc/eZR+4NUecYnXbWzsx/8ssANZgppk1CQFajbQeROTjo8LyWxNwR3JPrLhjqOJHNtjaiyOmsXzxu8MwmQUpyFE8t07T5BB3R7DqrqFIm3etdBJpj8RzhzhFsiP0VBHRpU3sCBPTzgKQ0tZrNcrzfaiTKaN9o5Tn2J5Oks98uS8f1fWNWPr9EXyxNw+vppXjmuXbpf0tANtmgmIH6xX9IvDabYmIt66rlHcsihfq9p1wTdH7qpEU08nhdnlnpK/aB8tvTcA91sX1gGMnq9jxqff1kepG7AT216mh11jKZTIL0kJwMStWrdGECrukQED7XafoCgYd7dThs45p5sReheZHOpQX0m//ekKamtMnMtBhnqN89EJclCWmfAu0u2CODtJJC8TFkYdgPw06BWgVX+5gva9ipENv11subtojTikRRzrEx8R1DpLWWxw6W4n9eeXSQngxLbBRlprPfkrKUzfE4c6RPbH4r5YF50+M7Qc/jQr3j+mtOE5eF/IeDTHNrpx9+lqR2DPRSfZcqXFRGNGrE/6e2lfqEXFFVLAteNhyqBCApS7tsy/Jc4P769ROA4OoID1emhyPQV2DFZ+jOCwsLpzLyq9ATlG106Cjo06tEqlUKkXQ2R6J06vEk439qBURUXvTXRrpsAUdYofmDNkFuErlfJ1arF3Q4WzX+o378vFB2p9Y9fNxPLX+AHbmO07fEhPmiGviuoYon0d+jg/UOU6vamkN3QNj+iBIp8Hs1L642rpHSXy35kcU5CnaOwfrpSlcKpVKCsDEIMlfq3E4vwfpNVK5DMZGxZRxUUdN8AJcwJoO8q6/p/bF9mxlWtlTpTW4dXWa1OtvTz7SIT3mXC0+SPsTADC0Z6hDViuxt7/WaEK1UQw6HL+cgCUICfHToqS6HqetgYJ4ERsZpJOCoSC9Br0jAqTXsg86ekcG4ExFnTQHVBzpeOz6/gjx88WI3mHSQrGfjxbj56O2/Slc2axucLcQvPhXW4arWVfFYlRwJZJ6KXst5HU1pEeItKmQs5GOpkaXxPU18mlU/loNPp85usVy2nPWexGgU0NnV3/dOvlJe46Ij4nrHIQjBVXSIj85eU9TiHVh+4DOQdKC86OFVVLAqXxt/jx42+ES5Qmlj5O2R0TUnvQIs1zcr9x2HCu3HVfcN1h2Ud7JX+t03yF5khqt2kdxjZDYIxSHzlbidGktVv9ywunrD4gOwtHCKpyrNqJWdmHeNVR5fdDJSdDh6kgHAKT0i0DWc38BAGk38aduiGv2MfKgY2JCF0WnYKi/L4pke6IFaNWKTkTAMjojTms2NJicBh0duUOwfXcDXsKSeoZi0gDlBeTWQ0WKgMN+VEPvq5zDGGvtsRczHwzt2UkxKuDnq0aQdQpVrbHRYXqV/bSoIJ2vtDjLNtJh+TtUNoVF76vGsxMvQ7+oQLw7Y4Q0fGh5Dg26WHsjxKBEHOnoExmIaZf3QlznYIfgSXS+O2Q7Gw2Q94LEdwuV3kNCj1CHY0uq65F+qlTavVwkbpQY6uLajeY420/Cz1etWFfho1L25og/cM9OvAy9IwLw9PiBDs8h/2GV/1usy3PV9c4zY7XT/S0uZp1DOL2KiNq37p0cp0OJBskSm+g1zi8x5dOr7NcnJPUMlTb2c3bBDVjWWwCWRC7i2o8gncZh1oNyepVG8X/AvWyBw2LC8N7fklvcS0n+/Pb1FCKNdFhGZvytU5jlgUdYgFa6Fqg1Og86/DtoVknAxaDjzJkzLv9HnjNpQADuvaKXtF+GOO9b1NVuSFLvq5ZyRQPAzYnKTfQmDOkCf9kFbIBOLTXeWqMJVXXK7FU6jbJhB+jU0oW5FHToHRdnAZZsFD88dhWuiYtSBC/Bfr7S9Cox2hfnZcoXl9mvU5Aeb329+1IsU6XkQ7nukgcdAVo1NswajR8fv8phkRsAHCmowpT/pOHvn+xT3C5OrwoLuPB1A7eN6KHY3wSwfKby+rOkI5Z/hpb6uDw2HNueuBrXD4p2eF75DK9OsuCok7XMZbI9WhSvrem4P2wdxUupto2j1s4Y3oYlISJyjf00bTn5aPuZJqYlh8t20xbPYW/ckYQbh3TBo9f2czrbAAAeu64fJiZ0xYNX9pHOleKmudFOOmycTa9SjHR4IXGHYnqVXZnE9R7i1HJxvaZ8pCc8UKcY6RC3IpDryCMdLpX8lltuQWmppYddEASnvcbi7YcPH/ZsCS9hQTofPD0+Dp/uycO3+8863N81xA/7ZVmV9L5qxEYG4LXbEhAbGSht1gdYLs6D9L7QyS5g/bRqxZQe6Yugdz7SEaDTSD364gJqsed8ZO8w/GBdh2BP3oMf7OeLztae+v/+cRpPjx8oPZd8MVlTIx1i21tw4yAsuHGQ02NcJf+i+2p8pKktgmyvDzF1nWjLoULFd0CcXuWJkY4RvcJw+Pkb8PavJ/Hy90cAWOpOPtIR6q9VLFRzZQqUPKuFfI2DmC3rXI1Rml6l9lFJ6wt0TSQAIM/pH67Fl7Mux9HCaqTGOQaMRETtzYheYU3ep3ZhHaP8wl88D09M6IqJCZZN+ZwtLAeAh6+JhVptOT48QIeCyjocsgYdzvbdCnM20qE9v5EOV8nPyfZJbsSARJxaLnb66n19ICapCg/QSscZjCZpvaWYUl/+PB2RS0HHt99+i5kzZ6Kurg6vv/669KFT62gqqrXfeM5Pa1lU/Nek7gCgiJCHW9czyIfxArSWdG0qFSAItrSdAU2MdPhp1Q6ZKMQ1HXck98S+3HLccJljelJ5j3mInwadQ2wBhbheI9TfV7F7d1OZpTxtZO8w/HGyFBPiu0i3yYPq8EAdSqrrpS87YMk80d0uZWAnDwQdAKBR+yg+Vz9ftSI4CvVXLiy334jImc4henz50GiHwChctsO8ONIRFqCVMobZf/7kHUO6hyAppumTOBFReyIPLD6feTkiAnX4y2vbcdeongCAB6/sg9XbT2DrY1c6fbw8uYl8Q1+R/dRxABgQrrz2CAvQoqCyDvus6z+dTb12FnTIX9sbQYc8nb99ICR2GIr7pIkBkJ9ipEMrnfMNDSZp2nuQ3leaatWRs1e5VPLQ0FCsXr0aU6ZMwebNm/Hggw96u1wk09Q+F2MHdca6PXnS3/bzJ4P1vrgvpTeyi6px3UBLL6r8AtbfGqT4+6pRYzRJm9FJ06vserr9fNWKhVmALfAJ0Gmw8s6hTsspf54ArQZDuodKf/942DI60j9KmbVHp1FjZO8wHDpTKX1BveH9/0tGZV0DooKcz6WP6xyk2LkbAI4WVKF7J3/syC5B2gnL4vOmpoOdD/t1N/LPrJO/VjFFzt/FYdakno6p/8Qf3ApDgxR0hMuCjqZSHRMR0aXti5mXo7TGKI16HHz+L1BbO+zmjR+IeU7WF4oUWQUdYw7F9KuIQB3emT4UVWeUC9bFjkkx6YyzrJPKheTWrJyyc6YnZijYk4/i2M/YsB+hsI10qBWPEa/5amUjHcF+GinocCcrZnvjcrgUEhKCl19+GTt27PBmecgJ+4VWafNSoYJK2ixQZJ8lCoDDFCRFulWtLWCQ574Wv5T2c/p97TbbAaAYnWiKvFx6rTLD1oZ9+QAsvb32PrpvJOobzdiUcQZPf5mF8fGe3+RNb3dRL3p5SjzW/HoSD1/TF19ayyg6WlgFjdoH96zdJd3mbGj3fMl/tPy0yjUdoX6+8FWMVp3/aIS4f4WYtQtQjtg4qxciIqLhdlOszjc9uZOYAxGyTrxO/r4Y3C0EGcWOWZ7kJiUp17DaHyOOdMhnCjS3NuV89YkMxMtT4tE5xM8hOLBfAC5da9kFHX5ay3utqG2QtgcI9dMiF843ee5I3BqjGTZsGIYNG+atslAT5CMdQXoNOgfroVKppIXYIlcuEuVTZsSoO1CvUaxbEL+c9ouaAcdpRC2lnAOUQ4fiv++5PAbvp52Sbk/sGerwOF+1D3zVPrh9RA/0ivB32NzPm24b0RO3jbAMFUdYp1iJfs85h6XfH1UcP8CD+ysE2813tV/TIR+NbmoUzBXOhpbl09o40kFERN7kbHqVPFhoaupyuKzzMlivkRLUyDmbXtU5WA+t2gdGk1nKxulp4rWDPX9f5fnav4npVSrr5spFVbaF+O5sNNyeXRzv4iInb5A9OvlLaw7kt6t9VC4t4FJMdRKzOdhN0RF7z50lDAj1d3+kQz66Ipb5yv6RiqCjuTR0Pj4qjI6NaPF1vOWj+5KxKeMMBnUNxiMf78OOHOX+KavuGuqwC+uFkNepv1atCOyC9BrUNdpGpS7kdZ0FHfJpZsxeRURE3uQs6JBPV/Zp4hQnnx0hrme1J5+mJSaICdBp8P0/xsBX7eN0DxFvsp+1Il5ryUdfIgN10swTMSV/oE4DHyfvryNiV2YHIJ8HaL8fhsjV5qgIAGQjHdJtvupmv4j2C8lDXUgVKy+n+JrdOinT/cY4SVPbXsR1DsacG+LQK9xxzijgfDfVC6FY06FVK4IDtY/K+Xj0ebD/LAH7kQ4GHURE5D1ms+Nt8nNPo8n5CW/ikK7SvwsrHXcrB5QX8/I0vH0iA9GjDa457PfiEtdkyjuMwwN1Dms/gvUajLNOL/fk+tG20GGDDkEQ8Prrr2P06NFITk7GwoULUV9va3i5ubmYMWMGEhMTMX78+A69FkX+BZSnY7PfydIV8ulV4nzC+gbbt94+ErcnX3jlq1Y5jJI4fU3Z6Ir4XuQ/AEO6h7R6j8P5sB/lETnb1+NC2Gclk8+V1ahVnoo5nE6Nk4+enU/7IiIiclW/aOd7cogazM7PeD4+Kmlfqnsuj2ny8dueuBpfzLxcsYdZW7HPOhUgS40rCvXzVZyHAUugcevwHvjXbYn4+pEU7xfUizrsVcXbb7+Njz/+GMuXL8eaNWuwc+dOrFixAoAlIHn44YcRERGB9evX4+abb8YjjzzSYTcvlEfH8nRs8kVKzoYonZFfSIpzJXPLaqXbKuucZ4oSX0p+4d1gcr5ni+NrOq7p8FX7YPktCXjwyj7YMGu0S2Vva/aZLm64rDP+c9dQh4xeF0r+g2Oy9vKM6NUJvmoV/nJZZ2lDxFF9LizNqjyYSY2LwvpZoxXTtTjSQURE3vD5zMsxIb4LXpoc3+xxztZqiJbfmoB/ThyER1L7NXlM74gAh0XvbcV+SrPYiSzfnNfHR+UwItI/Ogi+ah9MSurmsOFgR9Mh13SYTCa8++67eOqpp3D55ZcDAGbPno2NGzcCAHbu3Inc3Fx8+umn8Pf3R2xsLNLS0rB+/XrMnj27DUt+fuzXbjjTRGeA43PJGrO4WOvukTFY/sMxAICx0clYJyDNJ3SWC7slesVIh+3fU4Z1d/u52lKAVg2NjwqN1sq+Z3QvXB4b7vHXkQdyYi/POzNGoKK2QRoSPvnSeI+81vzxA3H4bCVenBwPva8aJ4qrpfu4kJyIiLxhRK+wZjcZ/Pj+kXhr+wksbGYT4GC9L2Zc0dsbxfOKELvZEuI0qiq7XcftRzrusXY0XgxcCjri4uJc6tEG0Co7kmdnZ6OsrAzXXXeddNtNN92Em266CQCQmZmJQYMGwd/fNu1l2LBhyMjI8HrZvEEeaLiyWLw58gwIYg/9rKtjpaDD2aY8gC3oUPuocF9Kb6zZcdLl15SPdHhywXVrU6lUCPXXSpmsooK9P7ey0ZouL1iv3DzR1e9jS+6/so/ib/nno+NIBxERtYHRsRFSAhmTydTC0R2DfSauUD/L33Gdg3G8uEa6XR50xHUOwuBujlsKdFQuBR0ffPCBt8vhlry8PISEhGDv3r147bXXUFZWhrFjx+LJJ5+EVqtFcXExoqKiFI8JDw9HQUGB26/VVo1dfF371/dRNV0mV8rqp9jzQQ2TyQQVgE0Pj8ZT67Mw54b+Tp+nc4hOuv3Ra2NhNJnw18RuLr2mRmUbhlEJQqvXaVN1eT60GtmCL39fr72XqUO74fuDBbhjRPdWrS9fWVCrVascXtuTdXmpY116BuvRc1iXnsO69JyLpS6DdcpOV39fyzn2zuTu2HniHF64+TKH96j2cTwPny9v1qOrz+lS0JGcnOxwW3V1NU6fPo2+ffvCaDQiMLD5xUDuqqurQ2FhodP7qqqqUFdXh+XLl2PevHkwm8149tlnYTabsXDhQhgMBmi1yohSq9XCaDS6XY6srKzzKr+n2L9+WWlpkyM2rozkFNfaGkbh6ePIKLU1gUVjAoCafGRk2DbDuys+EP/Nqsb0y/SK57+5O2AuOYkMZfZYp0yyuV+5ebnI8D3XzNHe44nP8ky5LW92zuEsj4042Lu9j4CpvSJQ9OdRFHnlFZw7U2BLxnA29xQyzM6/g239vbiYsC49g/XoOaxLz2Fdek5Hr0v7tbf792cCAPQA3hofBjScRUbGWcUx9QaDx2fptGU9ur2mw2g04vnnn8eGDRsAAP/73//w8ssvw2Aw4NVXX0VIiGeGgTIzMzF9+nSn97366quoq6vDggULpIBo7ty5eOyxxzB//nzodDqUl5c7lFuvd389Qnx8PNTq1p9mYjKZkJWVZXv9z78HAPTr2RmJiQNsB1pvH9QlCImJiS0+r8Fogn7Lj6hrMOOq5MQWN5cbMkTAk5MaFWlcz8t6Szl7x8QgMdFx51BvcqjLC2GtbwBISkq6wJK1Pw1/lgK/WnZaj+sfi8R+kYr7PVqXlzjWpWewHj2Hdek5rEvPuZjq8v+VH8fvx8/hvRnDm59ubr3WCAr0d+nazhXerEfxuVvidtCxdOlS5OTk4Msvv8Ttt98OwLKIe968eVi0aBGWLVvmfmmdGDlyJI4ePer0vl27LBdFffrY5qP37t0b9fX1KC0tRXR0NHJychSPKSkpcZhy5Qq1Wt2mjVx8/Sf/MgDL/ncU/7hugKI8a6YPxzNfHcDCGy9zqZyBfmp8MXM0NGoVgvxaXpOgVgOhvp7LN6DVtF19euKzDA/Q4lyNUXq+i42/Tr4RobbJ99jW34uLCevSM1iPnsO69BzWpedcDHX56HX98eh1LR8n0qh9PP6e27Ie3V7Vu2XLFsyfPx8DBth62wcMGIAXXngB27dv92jhmjJo0CD4+vriyJEj0m3Hjx9HQEAAQkNDkZCQgIMHD6KuzjYVJj09HQkJCa1SPm94+Jq++HPJBIdUatcNisbv8651K4vS4G4hiOvc9A7g3iBG9Ek9Q1v1dT3tX7cnIiJQhzfvHtrWRfEK+QK2lkbBiIiIyHsulp3IRW5fVdTU1MDPz3EHZrPZ3GqLfAIDA3HrrbfihRdewMsvvwxBEPDKK6/glltugUajQXJyMrp06YJ58+bhoYcewrZt27B//3689NJLrVI+crTjqWtQXtvQLjbouRBj+kVizwI3uik6GOVGlB27R4mIiKgj69bJ8Xq7I3N7pCM1NRWvvfYaqqtt+fxzc3OxaNEiXHXVVR4tXHPmzp2LK6+8Eg888AAeeOABjBkzBo8//jgAy9DRqlWrUFxcjMmTJ2PTpk1YuXIlunbt2mrlI6WoID36Rwe1dTGoBfLd4+1H1YiIiMj7/n17Ikb1CcPT4we2dVE8yu2RjmeeeQZPP/00kpOTYTabMWXKFFRVVSElJQULFy70Rhmd0mq1mD9/PubPn+/0/piYGHz00UetVh6ii0GonxZBeg2q6hoV+4IQERFR67g5sRtubuWkO63B7aAjKCgIb7zxBk6fPo0TJ06gsbERvXv3RmxsrDfKR0StSKvxwff/uBKAcqoVERER0YU475Wifn5+GDBgAARr3uEzZ84AAKcwEXVw3UIvrjmkRERE1PbcDjp27NiBZ555BmfPKjcwEQQBKpUKhw8f9ljhiIiIiIio43M76HjhhRcwZMgQ/Oc///H4LuRERERERHTxcTvoKCgowJo1a9CjRw9vlIeIiIiIiC4ybqfMHT58ONLT071RFiIiIiIiugi5PdIxYsQIPPfcc/j5558RExMDX19lWs1HHnnEY4UjIiIiIqKOz+2g47fffsPgwYNx7tw5nDt3TnGf6iLbrp2IiIiIiC6c20HHhx9+6I1yEBERERHRReq89uk4deoUDhw4gIaGBof7Jk2adKFlIiIiIiKii4jbQceaNWvwyiuvICQkBAEBAYr7VCoVgw4iIiIiIlJwO+hYu3YtnnzySdx7773eKA8REREREV1k3E6ZW19fj7Fjx3qjLEREREREdBFyO+iYOHEiPv74YwiC4I3yEBERERHRRcbt6VXV1dX44osv8M0336B79+4O+3R88MEHHiscERERERF1fG4HHb169cLMmTO9URYiIiIiIroIuR10cMdxIiIiIiJyh9tBh8FgwGeffYacnByYTCbpdqPRiEOHDmHz5s0eLSAREREREXVsbi8kX7BgAVavXg2DwYBNmzahoaEBOTk5+PbbbzFhwgRvlJGIiIiIiDowt4OO7du3Y/ny5Vi+fDliY2MxY8YMfP7555gxYways7O9UUanKioq8MQTTyA5ORljxozB8uXLYTabpftzc3MxY8YMJCYmYvz48dixY0erlY2IiIiIiGzOa5+OXr16AQD69euHAwcOAABuu+027Nmzx6OFa85zzz2HoqIi/Pe//8WyZcvw5ZdfSpmzBEHAww8/jIiICKxfvx4333wzHnnkEZw5c6bVykdERERERBZuBx2xsbH4/fffAViCjvT0dABAVVUV6uvrPVu6Zvzyyy/429/+hn79+mHUqFG48cYbkZaWBgDYuXMncnNz8fzzzyM2NhYPPvggEhMTsX79+lYrHxERERERWZxX9qpHH30UZrMZN998MyZMmICZM2fi6NGjGDNmjDfK6FRoaCg2bdqEUaNGobKyEr/++iuuv/56AEBmZiYGDRoEf39/6fhhw4YhIyOj1cpHREREREQWbgcd1157LTZv3gyz2YwuXbrg448/xldffYWhQ4di2rRp3iijU88++yzmzJmDoUOHwmw2Y/To0VI63+LiYkRFRSmODw8PR0FBgduvI8/Q1ZrE122r17+YsC49h3XpOaxLz2A9eg7r0nNYl57DuvQMb9ajq8/pdtABAD169JD+HRcXh7i4uPN5mmbV1dWhsLDQ6X2RkZE4efIkBg8ejEceeQTFxcV47rnn8Pbbb2PWrFkwGAzQarWKx2i1WhiNRrfLkZWVdV7l95S2fv2LCevSc1iXnsO69AzWo+ewLj2Hdek5rEvPaMt6dDvoOHv2LF555RUcOXIE9fX1EARBcf+PP/7okYJlZmZi+vTpTu978skn8eqrr+Lnn3+WRjQMBgP++c9/4v7774dOp0N5ebniMUajEXq93u1yxMfHQ61Wu/24C2UymZCVldVmr38xYV16DuvSc1iXnsF69BzWpeewLj2HdekZ3qxH8blb4nbQMWfOHFRUVOC2225DUFDQeRXOFSNHjsTRo0ed3vfdd9+hU6dOiilUgwYNQk1NDSoqKhAdHY2cnBzFY0pKShymXLlCrVa3aSNv69e/mLAuPYd16TmsS89gPXoO69JzWJeew7r0jLasR7eDjszMTKxfvx79+vXzRnlcEhUVhbKyMpw7dw7h4eEAgBMnTsDf3x9hYWFISEjAW2+9hbq6Oml0Iz09HcOGDWuzMhMRERERXarcTpkbExODiooKb5TFZYmJiYiNjcWcOXOQnZ2NXbt2YenSpbj77ruhUqmQnJyMLl26YN68ecjOzsZbb72F/fv3Y+rUqW1abiIiIiKiS5FLIx27d++W/j1u3DjMmTMHs2bNQo8ePRyGaEaMGOHZEjqh0Wjw9ttvY/Hixbjrrrvg7+8vbQAIWIaOVq1ahfnz52Py5MmIiYnBypUr0bVrV6+XjYiIiIiIlFwKOpylwl24cKHDbSqVCocPH77wUrmgc+fOeOONN5q8PyYmBh999FGrlIWIiIiIiJrmUtBx5MgRb5eDiIiIiIguUm6t6Th16hQaGhoUt6WlpeHEiRMeLRQREREREV08XAo6BEHAokWLMG7cOOzbt09x34cffogJEyZgyZIlDnt2EBERERERuRR0fPDBB/juu++wcuVKJCcnK+5btWoVVq5ciS+//BKffPKJVwpJREREREQdl0tBx7p167Bw4UJcc801Tu9PTU3FE088waCDiIiIiIgcuBR05OfnY8iQIc0eM2rUKOTm5nqkUEREREREdPFwKegIDw9Hfn5+s8cUFBQgNDTUE2UiIiIiIqKLiEtBx/XXX4833njDIXOVqLGxEStWrEBKSopHC0dERERERB2fS/t0PPTQQ5g6dSomT56MadOmYfDgwQgKCkJFRQUOHjyIjz76CDU1NVi6dKm3y0tERERERB2MS0FHcHAw1q1bh1deeQVLliyBwWAAYEmlGxQUhPHjx2P27NmIiIjwamGJiIiIiKjjcSnoAIDQ0FAsWrQIzzzzDHJzc1FZWYnQ0FD07NkTarXam2UkIiIiIqIOzOWgQ6TVahEbG+uNshARERER0UXIpYXkRERERERE54tBBxEREREReRWDDiIiIiIi8ioGHURERERE5FUMOoiIiIiIyKsYdBARERERkVcx6CAiIiIiIq9i0EFERERERF7V7oMOQRDwf//3f9iwYYPi9rKyMsyePRtJSUlITU3FV199pbj/0KFDuOWWW5CQkIApU6bgwIEDrVlsIiIiIiKyatdBh9lsxqJFi/Dbb7853Ddv3jxUVVXhs88+w6xZs7BgwQLs378fAFBbW4sHHngAw4cPx4YNG5CUlIQHH3wQtbW1rf0WiIiIiIgueZq2LkBTCgsL8cQTTyAvLw/BwcGK+06fPo1t27bhxx9/RPfu3dG/f39kZGTg448/xpAhQ/Ddd99Bp9Nhzpw5UKlUmD9/PrZv347vv/8ekydPbqN3RERERER0aWq3QcfBgwfRpUsX/Pvf/8bUqVMV92VmZqJLly7o3r27dNuwYcOwevVq6f5hw4ZBpVIBAFQqFYYOHYqMjAy3gw6TyXSB7+T8iK/bVq9/MWFdeg7r0nNYl57BevQc1qXnsC49h3XpGd6sR1efs90GHampqUhNTXV6X3FxMaKiohS3hYeHo7CwULq/b9++DvdnZ2e7XY6srCy3H+NJbf36FxPWpeewLj2HdekZrEfPYV16DuvSc1iXntGW9dhmQUddXZ0UJNiLjIyEv79/k481GAzQarWK27RaLYxGo0v3uyM+Ph5qtdrtx10ok8mErKysNnv9iwnr0nNYl57DuvQM1qPnsC49h3XpOaxLz/BmPYrP3ZI2CzoyMzMxffp0p/etXLkS1113XZOP1el0DgGE0WiEXq936X53qNXqNm3kbf36FxPWpeewLj2HdekZrEfPYV16DuvSc1iXntGW9dhmQcfIkSNx9OjR83psdHQ0SkpKFLeVlJQgMjKy2fvtp2QREREREZH3teuUuU1JTExEfn4+CgoKpNvS09ORmJgIAEhISMC+ffsgCAIAy14fe/fuRUJCQlsUl4iIiIjoktYhg44ePXogJSUFTz75JI4cOYLPP/8c33zzDe666y4AwA033IDKykosXrwYOTk5WLx4MQwGA8aNG9fGJSciIiIiuvR0yKADAJYuXYqAgADceuutePPNN/Hiiy9iyJAhAIDAwECsXr0a6enpmDx5MjIzM/HWW281uzidiIiIiIi8o92mzJX76aefHG4LDw/Hm2++2eRjhgwZgi+//PK8X1OcmsV9Ojo+1qXnsC49h3XpGaxHz2Fdeg7r0nNYl57RGvt0iNfOTVEJLR1xiTIajcwJTURERETkgvj4eIctK+QYdDTBbDajsbERPj4+0s7mRERERERkIwgCzGYzNBoNfHyaXrnBoIOIiIiIiLyqwy4kJyIiIiKijoFBBxEREREReRWDDiIiIiIi8ioGHURERERE5FUMOoiIiIiIyKsYdBARERERkVcx6CAiIiIiIq9i0NGG6uvr8fTTT2P48OFISUnB2rVrmzz20KFDuOWWW5CQkIApU6bgwIEDrVjS9s+dupw1axYGDBig+G/btm2tWNqOwWg04sYbb8Qff/zR5DFsly1zpR7ZJptXWFiIv//970hOTsaYMWPw0ksvob6+3umxbJPNc6cu2S6bd+rUKdx7771ISkrC1VdfjTVr1jR5LNtl89ypS7ZL1zzwwAOYO3duk/f//vvvuPHGG5GQkIDp06cjNzfX+4USqM08//zzwsSJE4UDBw4IW7ZsEZKSkoTNmzc7HFdTUyNcccUVwpIlS4ScnBzhhRdeEEaPHi3U1NS0QanbJ1frUhAE4frrrxe++uoroaioSPqvvr6+lUvcvtXV1QkPP/yw0L9/f2Hnzp1Oj2G7bJkr9SgIbJPNMZvNwq233ircd999wrFjx4Tdu3cL119/vbBkyRKHY9kmm+dOXQoC22VzTCaTMHbsWOHxxx8XTp48Kfz888/C0KFDhU2bNjkcy3bZPHfqUhDYLl3xzTffCP379xeeeuopp/fn5+cLiYmJwjvvvCMcO3ZMePTRR4Ubb7xRMJvNXi0Xg442UlNTI8THxysuRFauXCncfffdDsd+/vnnQmpqqtQYzGazcP311wvr169vtfK2Z+7UZX19vTBw4EDhxIkTrVnEDiU7O1u46aabhIkTJzZ7scx22TxX65Ftsnk5OTlC//79heLiYum2r7/+WkhJSXE4lm2yee7UJdtl8woLC4VHH31UqKqqkm57+OGHhWeffdbhWLbL5rlTl2yXLSsrKxOuvPJKYcqUKU0GHf/6178U10i1tbVCUlJSs51jnsDpVW3kyJEjaGxsRFJSknTbsGHDkJmZCbPZrDg2MzMTw4YNg0qlAgCoVCoMHToUGRkZrVnkdsudujxx4gRUKhV69OjR2sXsMHbt2oWRI0fis88+a/Y4tsvmuVqPbJPNi4yMxJo1axAREaG4vbq62uFYtsnmuVOXbJfNi4qKwr/+9S8EBgZCEASkp6dj9+7dSE5OdjiW7bJ57tQl22XLXn75Zdx8883o27dvk8dkZmZi+PDh0t9+fn647LLLvN4mGXS0keLiYnTq1AlarVa6LSIiAvX19SgvL3c4NioqSnFbeHg4CgoKWqOo7Z47dXnixAkEBgZizpw5SElJwdSpU/HLL7+0conbtzvvvBNPP/00/Pz8mj2O7bJ5rtYj22TzgoODMWbMGOlvs9mMjz76CKNGjXI4lm2yee7UJdul61JTU3HnnXciKSkJf/nLXxzuZ7t0XUt1yXbZvLS0NOzZswcPPfRQs8e1VZtk0NFGDAaD4iIZgPS30Wh06Vj74y5V7tTliRMnUFdXh5SUFKxZswZXXXUVZs2ahaysrFYr78WC7dIz2Cbds2zZMhw6dAj/7//9P4f72Cbd01xdsl267vXXX8ebb76Jw4cP46WXXnK4n+3SdS3VJdtl0+rr6/Hss8/imWeegV6vb/bYtmqTGq8+OzVJp9M5fLji3/aNpaljW2pUlwp36vKhhx7CtGnTEBISAgCIi4vDwYMHsW7dOsTHx7dOgS8SbJeewTbpumXLluH999/Ha6+9hv79+zvczzbpupbqku3SdWJ91NfX44knnsCcOXMUF3Rsl65rqS7ZLpu2YsUKDB48WDGa2ZSm2mRwcLC3igeAIx1tJjo6GmVlZWhsbJRuKy4uhl6vd/jQo6OjUVJSoritpKTEYWjsUuVOXfr4+Eg/VqI+ffqgsLCwVcp6MWG79Ay2Sde88MILePfdd7Fs2TKn0y4AtklXuVKXbJfNKykpwdatWxW39e3bFw0NDQ5rZNgum+dOXbJdNu3bb7/F1q1bkZSUhKSkJHz99df4+uuvFetdRU21ycjISK+WkUFHGxk4cCA0Go1i0U56ejri4+Ph46P8WBISErBv3z4IggAAEAQBe/fuRUJCQmsWud1ypy7nzp2LefPmKW47cuQI+vTp0xpFvaiwXXoG22TLVqxYgU8//RSvvvoqJkyY0ORxbJMtc7Uu2S6bl5eXh0ceeURxsXvgwAGEhYUhLCxMcSzbZfPcqUu2y6Z9+OGH+Prrr7Fx40Zs3LgRqampSE1NxcaNGx2OTUhIQHp6uvS3wWDAoUOHvN4mGXS0ET8/P0yaNAn//Oc/sX//fmzduhVr167F9OnTAVh66uvq6gAAN9xwAyorK7F48WLk5ORg8eLFMBgMGDduXFu+hXbDnbpMTU2VvpSnTp3CihUrkJ6ejrvvvrst30KHwXbpGWyTrjt+/DhWrVqF+++/H8OGDUNxcbH0H8A26Q536pLtsnnx8fG47LLL8PTTTyMnJwe//PILli1bhpkzZwJgu3SHO3XJdtm0bt26ISYmRvovICAAAQEBiImJgclkQnFxsTSlasqUKdi7dy/eeustZGdnY968eejevTtGjhzp3UJ6NSEvNau2tlaYM2eOkJiYKKSkpAjvvvuudF///v0VObwzMzOFSZMmCfHx8cLUqVOFgwcPtkGJ2y936nLdunXC2LFjhcGDBwt//etfhV27drVBiTsG+/0l2C7PT0v1yDbZtNWrVwv9+/d3+p8gsE26w926ZLtsXkFBgfDwww8LQ4cOFa644grhP//5j7QXB9ule9ypS7ZL1zz11FPSPh25ubkO56Gff/5ZGDt2rDBkyBDhnnvuEU6fPu31MqkEwTreR0RERERE5AWcXkVERERERF7FoIOIiIiIiLyKQQcREREREXkVgw4iIiIiIvIqBh1ERERERORVDDqIiIiIiMirGHQQEREREZFXMeggIiIiIiKvYtBBREQeM3fuXAwYMKDJ/zZs2IABAwYgLy+vVcpTV1eHkSNHoqGhoVVej4iInOOO5ERE5DFVVVWoq6sDAHz33XdYu3YtvvjiC+n+kJAQVFRUICwsDGq12uvl+f3337F27VqsWbPG669FRERN07R1AYiI6OIRFBSEoKAg6d9qtRqRkZGKY+z/9qa0tDRcfvnlrfZ6RETkHKdXERFRq8nLy1NMrxowYAA2b96McePGISEhAY899hhyc3Mxffp0JCQk4M4770RhYaH0+B9++AHjx49HQkICpk6dil27djX7es0FHR988AGuueYaxMfHY/LkydizZ4/n3igRESkw6CAiojb1+uuvY8mSJVi9ejW2bNmCO+64A3fccQc+/fRTFBcX4+233wYAHDlyBE899RRmzZqFTZs24aabbsL999+PU6dOOX3eyspKnDlzBgMHDnS479ChQ1i6dCmeffZZbN68GcOHD8c//vEPmM1mr75XIqJLFadXERFRm5oxYwYSEhIAAAMHDkTv3r0xbtw4AMDYsWNx5MgRAMA777yDW2+9FRMnTgQATJ8+Hbt378Ynn3yCuXPnOjzvrl27MHz4cKhUKof78vPzoVKp0LVrV3Tv3h3/+Mc/cM0118BsNsPHh/1xRESexqCDiIjaVI8ePaR/6/V6dOvWTfG30WgEABw/fhybN2/GZ599Jt3f0NCAlJQUp8/b3NSqlJQU9O/fHxMnTsSgQYNw7bXX4pZbboFGw9MiEZE38NeViIjalH0Wq6ZGGkwmE+6//35MmjRJcbter3d6fFpaGqZNm+b0Pj8/P3z++efYtWsXtm3bhg0bNuCTTz7Bhg0bEB0d7f6bICKiZnEMmYiIOoTevXsjLy8PMTEx0n+fffYZtm/f7nBsUVERDAYDevXq5fS59u3bh9WrV2PUqFGYN28evv/+e9TX1yM9Pd3L74KI6NLEkQ4iIuoQZsyYgbvuugvx8fG4+uqr8dNPP+G9997D+++/73BsWloaRo0a1eRz6fV6rFy5EhEREbj88suxe/du1NbWYsCAAd58C0RElywGHURE1CEkJiZi6dKleOONN7B06VL07NkTy5cvx4gRIxyO3blzJ0aOHNnkcw0cOBCLFy/GqlWr8Pzzz6Nr165YtmwZYmNjvfkWiIguWdyRnIiIiIiIvIprOoiIiIiIyKsYdBARERERkVcx6CAiIiIiIq9i0EFERERERF7FoIOIiIiIiLyKQQcREREREXkVgw4iIiIiIvIqBh1ERERERORVDDqIiIiIiMirGHQQEREREZFXMeggIiIiIiKv+v8tEoaoux/tRgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -213,7 +221,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAHqCAYAAACZcdjsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACpI0lEQVR4nOzdd1zVZf/H8dc57L1FBUTEBS5QEcw0Z66stCxtaOtuabvb0rqru1Ibv3s07G7vslKz5R6ZpuJGUNwbFBUVkA3nnN8f5MkTqByGgL6fjwePON/vdV3fz/l6TpzPuZbBYrFYEBERERERqQZjXQcgIiIiIiINnxILERERERGpNiUWIiIiIiJSbUosRERERESk2pRYiIiIiIhItSmxEBERERGRalNiISIiIiIi1abEQkREREREqs2xrgOor8xmM6WlpRiNRgwGQ12HIyIiIiJy0VksFsxmM46OjhiN5++TUGJxDqWlpaSkpNR1GCIiIiIida5Dhw44Ozuft4wSi3M4k5FFR0df8CbWFZPJREpKCh06dMDBweGSuG5NtV3ddqpa39569pSvq3/vhqCh3Ju6iLMhvF9roq2q1K/NOg3lNVlXGsL90d/Y2mtHf2MbluLiYlJTUy/YWwFKLM7pzPAnBweHev8Cq6sYa/O6NdV2ddupan1769lTviG8JutKQ7k3dRFnQ3i/1kRbValfm3UaymuyrjSE+6O/sbXXjv7GNgxn7kdlpgZo8raIiIiIiFSbEgsREREREak2JRYiIiIiIlJtSixERERERKTalFiIiIiIiEi1KbEQEREREZFqU2IhIiIiIiLVpsRCRERERESqTYmFiIiIiIhUmxILERERERGpNiUWIiIiIiJSbUosRERERESk2pRYiIiIiIhItSmxEBERERGRalNiISIiIiIi1eZY1wGIiJzNbDKRdSKD7ONp5GamU3jqCKU5GRhyj2IsPo25UTsC2/WmeXQ3HJ2c6zpcERER+YMSCxG5KAoL8jh5NI2czDTyTxymJPsIlpwMjPnHcC44jkfJCXxKT+BnycbfYML/XA1lzYWdr5P7vRt73aLJC47Dq3VPSox+F/PpiIiIyF8osRCRKrOYzeScOs6pY4f+6F04TGlOBpw+imPBcdwKj+NZehI/80m8yaMp0PRCjRrK/nMKb7KM/uQ6+VPoGkSpexA4uuF+PIkWBVvwMhTQsXADHNgAB96l2OLArqWtORUYh1vLHkTE9sPHP6iW74CIiIicocRCRCrNVFpK8tJvMG76jOCCffhbTuFjKMWnkvWLLY6cMPiR4xhAvnMAxW5BmD2CcfBujLNvEzwCQvAOCsG/USh+zi6cqw/CVFrKnm3rydz6K45piTTL3UyQ4RRtS7bBkW1w5HPMyw3scwjnmH9nHJp3JyymH8GhkTV1K2rF7s0ryVk4FbfiE+S5NaXEKxQHv3Dcgprj2zSSoNCWuLp51HWYtSZzXxKblz6PwWLC7OCKycEVi6MbZic3cHLH4OSGZ4s42vcYdlHjKsg7zcmjBzGVltA0ot1FvbaISEOixEJELujU8SNsn/cOzfdOJ5bjf574o3chGw9OGf3JdQqg0CWQUrcg8GqMo3djXP2b4hUYim+jMLx9A2hiNNKkmvE4ODoS2SGByA4JAJSWlPDrkl9wzz+E4VAiTbI2EcZhIsz7icjcD5nfw3o4bGhEuncMlrDuBLfvTbPWMRiMdb+GxZEDO0if9Qxdcxb9ebAkFXKAdNuymfhywrExuW5NKPYMw+gXhmtQBL5NIglt2REHx5r73/qBHUlkLHqDyMylOGCmBEdKDE6UGpwpNThRanDC2WwkdaErZqMzxS7+BA18kuZRXe2+1vrZb9En5UWcDabzF9wDa4+9TLfhD1XxWZ2fqbSUtZ9PwjtjNV6lJ/AzncTLUEDIH+c3evSk5MqJtXJtEZGGTomFiJzTrk3LyVo2jY5ZS+huKAEgC0+2Nbkev87D8WkUhn9wGD6u7pXutagNBqMR76BmxMRci4PDwwBkZhziYNISiveuJPDEBiJK99KUYzTNXgjZC2HLPzmFN/vdO1AUEk9AdB8iO/bA6OBw0eLOPpXJtm+fI/bIdzT54/6u9+oHbQdTevIQhuxDuOal4VOUQSPTUdwNRQSSRWBpFpzeDqeBI3+2l4kve/174tLhOtp2H4qLq7vdMZlNJpKXzcC47n06Fm4g/K8FLH/8nK3oj/8WQPE3C1nd7C463/pipa5fWlLM+g/Gk3DsWzCUfXAvjeiLuTgfS0k+lBRgKCnAUFqAW146HQvXEZP0AttDo2gb19/u53chaz9+jO6HP//zwB/Jc4HFGSdK6Zy3gtRFRznVYjaBwaE1fn0RkYZMiYWI2CgqzCdl4Wd4JX9Cm9IdZQcNsNshkpPt76TjwDvp7u5Zt0FWQmDjMAIH3QHcAUBuzin2bfqV3F0r8D62jsii7fgZcvDLXwm7VsKuf3PsR3/2BfbBM/YG2sYPrNFv/89WVFhA8o//oe3Od0kgFwyw1bkjzoMn0zW2V4V1LGYzp04cJTN9N6cz9lB84gCGrIO45KXjXXiExqYjBBqyCDz5M/z2M7nL3NjinYC5zVBKfVtfMKbsU5lsm/sOYbu/JMZyFACzxcBmj+44dLsHr0bNKC0uxFRShKm4CFNJIaXFhRw9fIhAPx8wFeO0ay4xBYl0P/QB+1+bT+Gg/9C224DzXvPAezeRULgBgIV+t9D3wTdxdHKqsLzZZGLTv68lNu93AufczdEmS2t0eNv6X963JhWrI8bh1bI7XoFh+AWH4eXtR+rqeYQt+hvR5p2kvduftFtnEtqy/QXbLSkuYsuyGRRnHcacfxJDwSkcCk9R6htB59HPVykBFBGpj5RYiAgAGYd2s2/+W7RJ/56u5ABQbHEg2acPnr0epE3nPrSsB8OGqsrT248OV42Aq0YAZQnU9uSVZG1fjuuRtbTM30wjw0kaZc6CRbM4ucib3f5X4dpxOG27D8XZxbXaMVjMZo5tnk+TX0aT8MeH9/3GMLKvfJaOvW8677Asg9GIX1AT/IKaAD3LnS8uKiQlcS75yT/S4sRvBBlO0eX0r7D+V4otjmz5vTNFrYbQoseNBDYOs9Y7sG0DGYvfpEPmPBIMZV0POXiQGnwtYQMfIbZF1DljMplMJCUlERMTg4ODAxbzQ2yY/wnN1/6T5uZDmOeMZM3a4bQb8288vW1nzBzcmYRh+mg6Wg6Tb3FhW/yrBAR3PO89MDo40Pr+r9j3n6uIMO9n1yc34fPEb7jWQKK7e/PvtFv3DBhgdZMxdB87pVyZdj2Gss/vJ3K/u5lQyxFOfTmY7UM/uWDPyfpPn7TtBTkjG5L/u55WD/2Am4dXtZ+DiEhdu6QTi6KiIv75z3+ycOFCXF1dueuuu7jrrrvqOiyResNiNrN19RyKV71Hp9zfaWwoG+NyDH/2NL+ZVoPG0fWsD6GXEhdX97Jv0//4Rr2wII+kVT9TkvIDrbOW408O3U7+DMt+JmeZB5t9rsSp/fW0vfK6Kk2gTl09D8fFzzHYtBOA4/ixr8MjdL52HM1rYD8OZxdXa+JkNpnYvmkZpzZ8T2jGUsI4TKfCtZCyFnPyP9nmHE1WSC88jyTSoWhT2XAnA+w3NuNo1B10GHwPCZ72D24zGI10GXI32fHXsPaLR+mWNZf4zO85+u/f2NNrCp36jgIgedksmi8bjzf5ZBBI3g1fENMunqSkpAtew8PLF5fbv+XUZ/1pZdrN+nfH0uXRGXbHerYTx9LxnD0WN0Mxm13j6Hb3f85ZtlmbWFb2mkbeymdoZdqN2y+jSMp+i5j+oyssfyx9H7Hp08EAya5xFLo1wuTqB46uxBz8nI6F60n97yBCx/2Et29AtZ6HiEhdu6QTi9dee40tW7bw2WefcfjwYZ566imaNm3KoEGD6jo0kTqVm3OKrfPeJ3jHF7Q3Hyo7+MdwnKLOd9Ox3y00usw2n3N18yCm3yjoN4qS4qKyb/83z6bliWUEkE1c9gJYuYC83x9jg1cCRF9L25434OHle952D2zfyKmfJhGTvxqAPIsrm8PHEnPTM3Srwof3yjA6ONC2az/o2o/SkhIWz5+Fe2YSQWmLaGXaTVTJVti/FQCTxUCyZw+crrifdt2H0rwGeqV8AoLp9uh0Upb/iP+vfyfEcpTg5fexYdO3FAdG023vNBwMFrY7RRN493dENg7DZLrApO2zNI1oy9YB7+G58Ha65ixm9ZfP0+3WF6oUa2lpMZkfjyaaTA4ZmtL8vm8uOATOwyeI4IcWkvTeLcQUJNJyxWMcbtmZps3blCt78IcXaGIoYZtTOzpMWGjTI7N9zUBC5o4humQLu98agOn+OX/0SImINEyXbGKRn5/PjBkz+OCDD2jXrh3t2rVj165dfPXVV0os5LJ1cGcSRxa9Rbtjc4g3FACQb3EhJXAwjfqNp110XB1HWD84ObvQoddw6DUcU2kpqesWkbNxFhHHlxJsOEGX3GWwdhmFa55ik0ccprbX0qrnSHz8Aq1tZGYcZM93z9D1xM+EGyyUWoxsCLyW4na3cMVV/XG4SJPEDUYjfk1bETNkJA4Or5BxcBf7V36Hy6HfKfRpSfNB44kNL/+BuCZ06HUdBV36kvjFU8Qd+Zoup5fC6aVggLW+Q+h0/0dVnl/QrsdQ1qQ/TXzqZOL3vMXmpVHgb//zKFj+X+JLtnDa4oZ59HSbf8Pz8fDypf3jP7PttauIKknlwNd30/ip32wm/2cd3cdVJ+aAAQz9Xyg3zKtt/NXsdp1F6exRtDTt4cD/BmC6dy6BjZvZ/TxEROqDSzax2L59O6WlpcTGxlqPdenShXfffRez2YyxAY8VF7GHqbSUlF+/w2H9B3Qo2kgzAAMcMjQlvfVtRA++n3gNwTgnB0dHorsPhu6DsZjN7Exazol1MwjLWEwoGcTmr4KNqyje8Ayb3TpT1Goopqx0Oh38nHhDERhgk3sP/K+bQteWHSo13Kc2NW7WisbNnrlo13Pz8CLh/nfYlTQa488P06z0ABtaP0r86GervdRv/E0TWPPWVuJP/ECr3x9nTdxbEBNT6frrZv2H3nnzMVsM7On1X2LaVL4ugKOTM96jPyT/sz60K04h8ZvJJNz6nPW8R9JHOBrMJLl3Jyb+6grbaNmpBwdcfqTkmxsINx9i/VePEvjE93bFISJSX1yyicXx48fx8/PD2fnP4RyBgYEUFRWRlZWFv79/HUYnUvvO3nsi5o+9J86s8uMY/zfaXXkdYRdxadVLgcFopHXn3tC5NxazmT1b13J8zXc0PryQ5uZDdCpcBynr/igMOxzbYOr/IrEJZb2k9gz3udS0iumJpeMGck9nkeBTc///jb33Pbb+aw/tilNovf5ZTl/RB1//C/c6ZGYcImbrK2CANc0foHu/UVW6fkiLdqxp/xTxW18kduebHNg2lPCoLuxKWkFC8SrMFgM+Q/953jbC23Zm9/AvaDR7KF1PL2FPSqJ1jxYRkYbkkk0sCgoKbJIKwPq4uLi40u2YTKZ6+2HgTFwXO77avG5NtV3ddqpa39569pSvbNldSSvIWf4/Ov1174nG1xM24EE6Nm8LlG1FUF9f2/aqq/dC8+g4mkfHAa+zb2cSRxJnEJRWtsldducHibl6DAajsVx8FzPO+vZ+dff0qbB8VeN0cHSi0V3TOfJuH8LIYNWsl4m/618XrLfrx1fpbihhm7ElnUc/X633bJfrH2bznnl0KlxHycy/Ufjk75QsLEsm1vv0p0vbrhdsP6J9d9Yv6kPX3F85Pfc5TNHzKhVPQ1VX71l76G9s7bXTkP/GXo7suScGi8Xy162OLgnz5s3j5ZdfZuXKldZje/bsYciQIaxZswZfX9/z1j+zjKJIQ1BaXMTJ1MU0T/+JKPMu6/Gdhgh2h1yHf7urcXKu/nKpIvXVsS1LGLxvMnkWFzZe9QXuPufutSjMy6HjktF4GQqYF/kcjaJ7V/v6eVnH6Lj8HnwNuWxw7EyX0o0UWxxYecXHeAdWbmW17KMH6LXmbhwNZha2+xcBLWIvXElE5CI5s7T4+VyyPRbBwcGcOnWK0tJSHP9Y4eP48eO4urri7e1d6Xaio6PL9XzUFyaTiZSUFDp06HDRJoLW9nVrqu3qtlPV+vbWs6d8RWWPHtrN/kXv0Db9e/zP3nvCuw8ePR+gVexVRF4G84nq6r1gr7qIsyG8X2uirdJ27dj22rdEmXfjlPotMQ98cM6yaz9/Fi9DAfuMzQhs29Oua54vzk2F/6TruifoUroRgJVeg+jRZ4gdzyeG9bu+J/7Uz4Tu/ITW14+t9jyU+qohvGf1N7b22mkof2OlTHFxMampqZUqe8kmFlFRUTg6OpKUlETXrl0B2LBhAx06dLBr4raDg0O9f4HVVYy1ed2aaru67VS1vr317ClvNBjYljiX4lXv0zH3d5oazMDlsffEhTSE9yvUTZwN4f1a3bYOtL6HqO1P0/n4D2Qc+DshFWzuV5B3mrYHvgQgs9ODGI0OVbpmRXW6Dr2H9dvn0vX0EvItLjh2Hmt3281v+CdFH8wnumQLyb//SMc+N9oVV0PTEN6z+htbe+3Ux7+xDeE1ebHZcz8uza9CADc3N66//npeeOEFkpOTWbx4MR9//DFjxoyp69BEqiTvdBbH1s0kbWos7RfdRue85TgazGx17sTGhDfwf2YH3e94xWZXZZHLSVCrbiS7dMHZYOLID89WWGbzT2/hRw6HDcF0HHhHjcfQ6q73Wes7hNRuU847HOtcgkMj2dS4LJlw/30KZo33FpEG5JLtsQCYOHEiL7zwAmPHjsXT05OHHnqIq6+ueMk/kfrq4M4kDi96m3bHfmHwX/aeCO7/EO2iutZxhCL1h+vAF+CnYXTOLr+6UnFRIc13fATAoai/EVwLm0D6+AXS7dHp1Zqn1+bG58l9+wdamvawYf4ndBl6T80GKSJSSy7pxMLNzY1XX32VV199ta5DEbHLufaeOEATDre+jXZDHtDeEyIViOzUgw2/9qHL6V/JnfscdFhoPZc09326kUkmvnQa9mAdRnl+fkFNWB0+hu4H36P5uhfJjB1AYNPwug5LROSCLunEQqS+Ky0ppiA3iyP7t1OUl01hbhY5u1dXuPeEQ7e/UeQRSrfOXTT+U+Q8Gl33EqVf9KJTwRpSE+cTnTAIU2kpjVPeBWB35FgS3Dzq9bKSsaOeY+//LaCFeT+pn96K79+X4nhWD8veLWs4sehfOLW/npgBt9RqLEWF+eTlnMK/UUitXkdEGj4lFiJVVFxUSG72CfJzTlGQe4qi3FMUnT7FsfR9rN0xD4pOYyjMxlh8GseS0ziW5uJSmourOQ83cz6eljzcDUVceY72s/BkW5MRhA8cT2zzNloCWaSSwlp2YE3gMOJP/IhxyT+xdLuazYu+oLM5nRw8aH/dY3Ud4gW5unvidMuX5H4xgOjiFFZ/8gTd730LgJTlPxKx5D5aGApg5QI2bp5Os1verpVeDYvZzO5/D6JV0Va2XP0p7XsMq/FriMilQ4mFXHYsZjNFhfnk5pwkP+ckhblZFOWeoiQvi9L8bMyFOVgKsinIOsqGFaU4luTiXHoaF1MerqY83CxlSYGroQR/oMp7CBv+/LXA4kyewZ0Cgzs5TkHkRY2k48A76e7uWQPPWOTy0+KGFyl4bx5tS1JJWvIN3uvLPpRvDRtNd2+/Oo6ucsJadmBD/FS6rH2U7oc/J2lJD0pOnyBm0z9wMpg4YAwjxJRO59zl5LyfwNoOE4gb/kiNLlG7eck3xBRvBgMEL3qIk606q+dCRM5JiYU0KBazmfy8HPJyTlGQc5KC3FMU52ZRkl+WFFiKcrAU5mAoyqH0dCbJS4pxLs3FxZSHmzkXd0sBHpY8XA0mqrVd3FlJQZ7FlTyDO/lGD4qMHuThisXVF5OzF2ZnbywuXhhcfXBw88HR3QcnDx9cPf1w8/LDxcOHPfsP0bVrN9w0vEmkxgQ1bc7qkFF0P/w5zVf+HV9yybe4EHXd3+s6NLt0GXIna/b9TvzxmbRe/jDuhiIwwHqvfnQY9yUHdiVj/nE8rUp30S3lBRKLckm45R+VattUWkrSgk9xdPOmU9+bKjzvs/oVAEosDgQZTrH547H4/n0Bxgr+f5WTdYKdy7+j5FQanW9+BhdX9+o9eRFpcJRYXEBJcRFYzNbHlj9+t9mw/I/fzz5WUbmKfq/wvE3b526n1FRK/umTnDx+GKPBUL4dzmrH/Mf1qCgGc7ljts/LbHPIbDaRk3mII/tdMRodzqpzVrkKrnf2fSwtLqQwN4vivFOU5GVjKsjGXJANRacpyj7GpmUlOJbm4lyai6spFzdzHh7k42HJx8NgwYNq+ONWmS0Gcg1u5ONBgdGDQgcPih09KHH0wuTkyelSBzz8G2N08y1LCjx8cXb3weWPpMDD2x9Pbz88HB2t8ZwZrlSZ3SnPlHdMO1qdZyMi5xA98nmy35iFL7kAJDceTkJg4zqOyn6x90xj5+vJtC7dCcDqJmOIv+e/GB0ciOyQQGnbVaz+fCLdD31Ilx3/Ycf6HrTp2ve8be5YvxSHeU/SxbQHgD2BoUR2vMKmzKa5H9LVfIAcPEgb9BGR82+nU+E6Er95mYRbn7eWy8k6we4P76T96ZV0NZQCkPiNhYQ7ptTkbRCRBkCJxQW4/rc1DqX5dR3GOQUBLLv41w0FWH3xr3smKSi1GMk1uJNvODsp8MLk6IHJ2QuTsxeni8AnOAxHD1+c3H1x8fDFxdPXmhR4ePrg7eBARfuw25sgiEj94+MXSGKLu0nY+ybFFgcihk2o65CqxNnFFe+x09nw7ROYIvvRffjDNucdnZxJuPN1Nv57F51zf8Pnl3vJjliJT0BwubaKCvNJev8+4k/+ZHM8d97z0HGR9XFJcRFNNv0bgK0Rd9C9+2DWHHqK+NSX6bzzDQ7vu5mmEW3Lzn/7HN1zfwMDHMePIE4Ruf9riouew9nlz77h4qJCkqfdhtnRlTa3v1Fj90dE6g8lFpcos6XsE/hZ/QVYMNj81/a8oVy5s89bznG+cm2DxdqjUvbfUhysSUGRoycljp6UOv3RU1BiwDOgKQ7uvji4+eLs4YOzhy+uXv54ePnh7u2Lm7sXvkYjvud4/koMRAQgZuTTrPkoDUNILN1CI+s6nCprHNaSxk/+eM7zBqORVn/7lLT/XkGo5QhJH42l05Nzy8232Pj183T/I6lY5zMIzyvuotXcUXQqWMu2NQuIih9YVu6HN4m3HC1bmveGpwDoduMTbHn1F9oXJXFo7us0HfcRhQV5tD1SFtf6zq/QceCdHJsaRSNOsm7eR8RdP+7Pa896nYScsuRl31vJnI5/CYipqVskIvWAEosLyL53Iw5OThjOGmp05vcLHzOWO0aFdYwVHDt/OwaDwfrhObZz53IfnmtzS/Wa+tBe0aRnJQQiUpNc3TyIH/9JXYdxUXj5+HNs+McUzbqWmPzVJH71Agm3v2g9n753G50PfAIGWBc7lbjryvbyWLtmKN1O/oxl8YtY4gawZcUPdNr6KhhgT9v7iff0AcqSF0uPx2HpGDoc+5mszAx2/T6LOE6TQSAxg+/G0cmZPRG30Gjf2/infIDl2gcwGI1knzhK1M7/AWWLVUSYD+CzahxpzZsT3qbTxb9ZIlIravPz5yXB0zcAH79AvH0DrD9ePv54+ZSNrz/z4+Hli4eXL+6ePtYfNw8v3Dy8cHX3/PPHzcP64+LqjourO84urtYfJ2cXnJxdcHRytv44ODri4OiI0cHB+mMwGq0/IiIiAJEdryCp/dMAdNv9Jut+eNt67viMR3ExlLDFJYauw+63Hg8f8U+KLE5El2xhzfvjab30XlwNJWx2i6fziMdt2m9/5TD2OLTA3VDEtp//g/eWzwDY3/xm6z4b0dc8TL7FhUjTPrau+gWAbd89jw957DOGk3XX7+xxaIG/4TTHf3mhNm+HiFxk+lQqIiJyCel2w+OsCboRo8FCl03Psv7n90haPJ2YgkSKLQ54jXjD5kup4NBINjW+EYCEjK9wMZSwyeNKoh79CSdnF5u2DUYjp2LKkpKO+z+lTekOii0OtBz0gLWMT0AwKUFDAfBaOpHEd+6lc8Z3AJzu9TxNwttgubYs4YnN+ZW03Vtq72aIyEWlxEJEROQSYjAa6fbAB6wJuA6jwULs+qdo9nvZxPUNTW8lvE1MuTptbnyePEvZROuNnlfR/pHvbSZen63TwDvIIAgPQyEAyd69CWwcZlOm6aDHKbE4EG5OI+HYtzgbTCS7dqFj7xsAiGifwHqnLjgYLByeM7Wmnvolx1RaSuL/7mfNtLuxmM0XriDVdirzCKs/eYrMjIN1HUqDpMRCRETkEmMwGol78BPW+g7BwWDBnxyOEkDHW16qsLxfUBPSr/uWtR1eoOMjM8v1VJzNydmF/a3HWh97Xnl/uTJhLTuw//ofSGwzgcTgUaz1HULQ6P/ZlDnR5lYAYk7O42janqo8zXKKCvMvmQ/gFrOZ9f+7m4Sj04k/PpODO5PqOqR6Z+fG31jz7auYSktrrM3c9wbR/cC77P3mqRpr83KixEJEROQSZHRwoMv4L1jjfy15Flcyer2Ch5fvOcu37tybbjc8Zp0rcT7trxnPTsfWbPToRZu4/hWWaRXbi4TRz5DwwHt0e3Q6TcLb2JwPjIhhq3MHnA0mTn52O5sWfkne6SyKiwoxm0x2PVeA7euXUPhKS/ZO7sz+bevPWe7ksXRysk7Y3f7FYDGbOZ1dFlvq6jnEn/jBeu74rnV1FFXd2bd1Dev+c3OFiWdmxkGCfxpN/LYprPu2ZvZMKSkupLn5EABRp36tkTYvN1oVSkRE5BLl4OhI/MNfUFJcRKfz9ELYy9Pbj9bPVv+DruWqiZQsvJ2okq2walzZD5CFJydumEVkh4RKtZO+dxuNfrkDH/LwMe2j4JvBrI+bTNdr7rWWWffDNMKS/k1jMjmFF6fGrcMvqEm1n0NNOXJgB9lfjCWyZCfHwh6m2bHFNudL0zfXUWR1x/z9/cSZ9pL20WaKn07CwdHJem739y+TQB4A0bveJe/0w+dNnCsjN/PP4U9ehgLSdm8htGX7arV5uVGPhYiIyCXufEOb6lJUwiAOj15MYuNbyTxrZyJfcrH88CClJcUXbCN19TzMX4zAnxx2O0SS7NoVN0MxndY9zZYVZXts7Nz4GzGb/kFjMgHw4zQ7Fpdfhnj9L++z+dcZNfPk7FTw2U20Ld2Gk8HEwEP/pV1xCsUWR1aH/Q0Az1Nby9UpKsxn08IvObQ75WKHe1FElO4DINRyBOepwWx842YsZjOF+bl0OPrnvi7e5LFl7nsAFOSdJvmV/iR++HiFbZ5LQd5pwja+ZnMs9MseNq/BA9s2cPzw/io+m8uDeixERESkzoS37Ux423ewmM3k5eWQnZmB52d9aWnaQ+K3U0i47QWb8nu3rCH3l0l4FmdiMRiINpV9+DxKAD53f0+L4DDWv3ETXXMW02zJ/azJ2E3T1A9xMpjY6NmLokYxdN/7JoG7ZwKTrO2mLP+Rruv/TqnFyHZPP1p17nPR7kHm4QO0MO/HZDGw2aMHnfN/x2wxsCHyQQI7Xg2HPiC0aDcWs5kDOzaSsexDLA5OtDr8E7FkkbPKgwOjfiG8beeLFvPFcMwQSGOOWx/H5Sxi7cIsdi+x0MlQSAaB7G81loRd/8J31yws5r+z9dfpdC1cB2nrOJL+IGZz5YbVpXz3Et0te8sdX/f1P+k+djK7N/9Oy9llq52t9+5PwMAJRLSLB8qGsG3470i88g8R+sjCavecNGTqsRAREZE6ZzAa8fDypWlEW3Z0LJs422nXNOtytGaTicTP/0HojCF0LFxPC/N+Ik37KLUYWRNwPQ73/0ZQ0+YYHRxo/8DnbHOKxpt84re+SJjlMBkEEnnXx7Qd/GDZErmmPezbusbatttv/wTA0WDGa+6D5OZkXbTnnrZtNQCHHMJo/8j3zI9+nZMPbqH7mJcIa9OZEosDvuSybvYbNPlmEAlHp9P98OcEUhajN3kYvrvtnD08mRkHrd+0H9u2gt2bll+Mp1UtptJSAi3l58J0K1lHp8KyOTT7G/WlZb87MVsMtCndgeFFP7qu/7u1bJOPu+A39x6KiworvEbSkm9Y/d5DbFr4Jd3TPrQeT+n7KVudOwLQfd/brP78H7j+cI/1fNecxZi+f8C6UMC2tQvpmrOYNqU72PLpI5fMAgJVoR4LERERqVe6Xv8QW7fPol3xZoxfDSft1tkc+fklErLngwGS3Ltj7PY3TMUFNGrZhfgWUTb1Xd08aHr/DyTO+CduWTtxKc2FQZNp7B8EwEbPK+ict4Kjyz8hol08G+d+SFfTHnItbuQaPAmxHGXNF49h6D6OdbP+DcW5uAS1oFP/2zA6ONj1XJJ/nUlJfhahnfoQHBoJlCUyJSVFuLi6A1Cwv+yD8nGvKMIcHQmK7IJfYBPrc9nlGEEr025ikl/C2WDioDGETPdISsKuJLLnKBze70EzczrrF3xqM68EyuZuuH/SBzdLIXsdIxhs2k32bg9KO+2v1ET9qljz3etwfDuRN7xgsxTxnuRVmH96mJzOD0Lw+XdcP35kP40NZR/Q13v1w6XrbeRl7CJhW9lE7aMEEHXzy/gEBLPHMYJIU/neBoCWlgNsWvkjsQNusTl+YEcSMSvuK3tw5HPr8dWRj9G913A2lxbB8rLz3fe+Wb5d0x62rJ5DUXYmXdY+aj0ef+IH1s/tUe7f4XKhxEJERETqFYPRSOCYT0j7aCihliMUf9GLUIOJUouRDe2fodsNj9ts8lcRn4BgEu5/p8Jzxthb4fcVdM6YQeLnQbTb8wEYICXiDrxb9aTxoluIO/ET6xYdJaE4sazSbkjMPEDCrc9V+nmkJs6n4293A5C/1oXdI2YT2aE7O6f2ILg0nd0D3qVdj6G4ZyYDYGocU2E7J5oPpdWeN3A2mDBbDLjdM5fOTZtbz68Ov5XuB94lcONblA68A4PBiIOjIxazmRNf30sT8sAArUy7y+4NeezZvrHc5PjUxPnkZeym67UPXvD+nktmxiG6bp2Mg8HCng82cKjbY5hLS+gy9B6Kfv470aW7YO1jLIn7EPjz+RYXFZK+J4WI6DgsZjMn03fTGDhsCKbrE9+X3R+TiXmfleB/ejttb/8PPn8kiseDuhOZUXFiAVCcOhf+klgc37Ga8ArKdhpeNjejY++bWH1gE90PvGs9tzpiHEZXHwwZm+l2ag55G2cSm/kzGGzbcN7yHebBd18wCT3Ts1HVe10fXTrPRERERC4ZwaGRON8zj4PGEJwNJoosTqT0eIv4kU9W+4NYxz43sdGjJ86GUhL2vomXoYBU5w7E3vQs7XoMZb33AIwGC/F/JBVnhsVE73qXrMyM87adlZlh3VehYGXZh9IiixPuhiKK5zzFlt9/pG3pNvzIofXC20ldPY+Qgh0A+LbsVmGbLfqWDfcB2ObSgaCzkgqA6OueJAcPmpsP4jg5iANTulCQd5qkRV/QviiJIosTq5uMITHoRmudzO2/27Sx+uMJRM+/mbikZ1j/87tUhsVsZufGZWSfLJsHsSclkYNfjsPBYAEg0rSP2NUP02XdE2yY+wnRJX/ust5v3T1s+Llsb5OS4iJ2/as/Ed/1Z+2s/3LkpTZEz78ZgFNOjWyu2ajTYLqO/8yaVAC0vH4iGQSRb3Fhnc9AVje5zaZOk6yN5WIvzTtZ4XNycfMAyj7sd7/zVRJbPU6aoQmJjW8l4faXib/5KRxaDQDKeiecDX/O4djk3gOAjoXrODS54wWHRK1/YxTZL4ZxLH2f9djhfdtZ/fk/yMk6gdlkIjVxPoUFeedtpz5RYiEiIiL1UqOQCNzvnc/qJmPYd803xF5924UrVYLRwYEOj8xio+dVAGx17kDzh+fg6u4JQPNR/yLX4gbA6ia303bCr+w1NsebPHZ8+8w520357Xs834oi+d/DyDx8gA45ZXMZtvV8i0KLE9HFKXRYeoe1vJPBhPfCRwkki1KLkfDo+ArbbRQSwRa3rgDkRd1U7ryPfxDboh+zPm5h3k/SV8/QZHXZhoibwsbQ/b63iLv/fRb5ltU3pv+518f+bevpeuDPOQaeW76waX/Tgs/Y9NoQ6ypbAGaziS3/Hkrrn67j1Nt9WPP2XUTOGkjn3N8qfA5nhgudSZAAOm16gcyMQ+z8vwG0Ky5b2apbyvM0tRyzlsl3u/CSwIGNw/B8fB0lD6cQ99h3tL5+os35ZpZ0ThxNY++WNaz/5X3MJhOW/FMXbBcg4dbnCX1+Own3v2NNaMM69abEYtsbYbYY8Bv2ovVxuDmNY4f3UZHSkmIS/3cfcdkL8CWXk5/ewuZXB8ALPjT9LJ7ue9/E+78tWP/2GKLn38zef199znki9Y0SCxEREam3Ahs3o/t9b9H2HBvxVZWTswsxj81m9/A5tH5yCe6ePn9es2k4BwZ9yvzgB+hyx79wcHQkr3fZh8a4Y7PYMOdDVn/yFOt/+nM38cKCPPyXPY2jwUxs/ioKP7gaZ4OJHY5tiek/mk3hd9lcP3XgN+RbXAi1lPWAJHv2wM3D65zxht71GUk9/kfcdeMqPB93w+MkBo20Pu5++DMac5zDhmDa3/QP6/HSwGgAGuX8uUTtqV+ex8lgYqdja0otRqJKUm2WsA1MfIXY/JW0XzKGjEO7Sdu7hVMHtxJTUDb5vbn5EPGZswDIxJc1Adez76bFpBkal4tzY5epJLt0AcDFUELgu+1pV3zuPTpKvULPee5snt5++AQEAxAQHMox/G3O718/H+dZY+m6/u+s+XwShsIsoGz+xvqurwOw2vmKSl2rUUgEuwZ9ZX18Em9yH9tD86iubBv8nfW47wfxrPn21XL1N3z/HxKOfmN93LYklU4Fa8uV63bqFwCiS7aQ9L87ObB9Y72fGK7EQkRERC5LRgcHWna6ssJ9Ptp2G0BQt5E4OJZNR+3Q6zrWBFyP0WChy7on6H7gXbpufJqN88r2w9g0/Z+EWI6SbylrK9SSQYnFgaIeZasUxY+dypp2z3EMf9b6DSW6+2A2h90KQJqhMZF3l99X42z+jUKIGXDLOYeBGR0cSBj3IbmP77fuCbLTsTWO9yzA09vPWs6jadlE91BTOoUFeRzatZlOuSsBcLnhXXa4lG0Id3jjfKBsaFeY5bC1fuOPuhD+VS+uSv5z9aUz1sf9H4EvHCD+oc+IiI4jcMJG9t1ku9Ffm6tupt2ERSx3s00Uiy2OHLrtd9ZETWSdz8A/n5d31TYxdHhgBaubj2eVy5UAdFn3BKGWIwA0OTQHx6IsAEqDO9BlyD3suXERxj7/OFdz5UR3H0z2I3tIDBpJ1o0z8fYNACAqfiBr/YcBZYlT/LYpNntfbFuzgPht9u8U3i1rLuHf9GHNNzWzy3htUWIhIiIiUgmx977HdseyD+Znhkq1TXyKjfM/JfbAxwCkdpvM6vD7WedzNUduXUrHPmXzGowODsSPfIJGL+yj2yNfA9Dl9rJkw/GuOTZzBqrD09sP7l3OgdG/0WrSGhqFRNicd/cKIBsPHAwW0nenkPnDJIwGC0luCYRHdSGncXcAnA8sw2wycSBlRYXXcTGUAJDY6GbWBFzHgZuX0nXo32zKuLp5EBEdZ3PMy6esJyHPO9J6LMWlM6YJ+wlr2YH4m5+my8PTreeMLp5Vug8BwaF0u/1FclvfUO6cmzkfp5JsABzc/TEYjTSP6oKjnRtJ+vgFkjDuQ1q0tx3C5tnNdsjevjU/A7B21n+ImvfnULaDxhD2jJhnU3Z1s3tJbDPhnNdM2Pk6vODDoV31cyd2rQolIiIiUgnOLq6EPTKfpMS5tIwfzJZp19O+KInOiY+AAba4xNBl8N2Vnlzu7OJK/MgnajzOwKbhBFa45lHZpOTDTuH4lKRyYskbdMv7nVKLEZ9ryoZ6+UT1gYPvEZv3O6mvXkVBo7IJ5Tl44E35ScRN+t5/wY351nv3p2vOYtYE3sCZj+CGgJZwtOz3/JZDbYaBGR0cSGz5KO5pK2jf/3Y7n72tgOadON5jCyXv9bXO3QjmBMEFZXtkOHoGVKv9ikQnDCJx0yjrcCdT5h7MJhPdUl6wKRcyKRkHR0fWH3gNDAZCO/ahe7NW7ElJhB1lu4Cvafs05pwjdD/8mU3d4C/7svO673H19CE/O9M6VPDIgR34NQrF9Y9J6BebEgsRERGRSvLw8iXmj6VLwx+cTerbw4gu2UKxxQGv4f9pEEuH5nhFwslUumXNBWBD0HDi/9hFOjL2Ko4t8KcRJ4kuToG0srkWWyPuoO2+z8k3uHOw6VA6pX1FcvunSKjEbt9t7/mQ9cu+JebqMdZjXo1bQWrZ7826DStXJ+G2f1b3aVr5BzWl+MmNHD6WTvCnCdZVqwC8giPOU7PqEh54j8QvG5Ow+790T/8EXrId6rZv5EIi/hhm13XYfTbnIjsksOnINLyCI4jv1AOL2cz6X6IoyTps3VPD2VBK65+u/bPSHFjb4QVr8pI66FvadO1vHcp3sSixEBEREakCLx9/Ih6dz+pvX8Q1tBOxlfiQXR+YA9rAybLhOWaLgZBBj1vPubi64zRuFRs+f4Aup3+1Hg+KGQJDHsLT0Ylu3n5s2DiKuM5dK3U9T28/ul57v80xVw9vNsS/ARYTXcLb1MCzOj83Dy/cItrCWUkFQES7ilfiqgnekQmw2/ZYsmsXOj69lAulM2evgGYwGul67QMAmEqfJ+/lMLzJL1fn7B6R6Pk3UzzPgR2DviKkbRzHD26nZacrq/pUKq3+p9UiIiIi9ZSbhxfd73q9xpbCvRg8wjpYf9/k3ZvQlu1tzvsFNSF89Bs2x8Kj4vALaoKPXyAADsbqfzcdc/XtdBlyd7XbsUeyaxfr7+t8B9fqN/rR3QezIe5fNsd8hv+7Wm06ODqy54rXy616VRFngwmnJf/A878taTl7KNvXLqrWtStDPRYiIiIil5G28YNZvfMujD4hxAx7sMIygU3DKbA442YoBqhw5ayGKOKBmST++B88mnelU/zAC1eopi5D7yHFK4D8jF2EdbuO8ObV752Jvfo2uPo21s/5AK9NH5Dj0Zy47AUVlm1Vusu6M3jbuTeyZt8kOl7z4HmXNq4OJRYiIiIilxEHR0e63/OfC5Y7MOQrAuf9jX0xE4i7YOmGwcvHn4QxL13Ua3boNbxW2u069G/wx0pcptJScl6OwI+c89aJ3zaFjYd+p/OTP9dKTEosRERERKSctvFXQ/wBAus6ELkgB0dHnB5PZtPqn2h9xXV4/KviVcEAmuRuq7U4NMdCRERERKSB8/T2I3bgWDy8fDn2tyR2OLZhr7E5ULZsbea9yQAEWU6Qn5tNfm42B7ZtoCDvdI3FoB4LEREREZFLSKOQCBo9u9b6OB4wm0wUWxxwNphw/L9mAIQD252iiXhiCS6u7tW+rnosREREREQucUaHsqTir9qWpJL6Zvkdyqt0jRppRURERERE6rWzl9s9W2z+Ksym8kmHvZRYiIiIiIhcBlo99CP7jWEVnlvz0aPVbl+JhYiIiIjIZcDNw4vmz20hMXh0uXPdD3/O1lVzq9W+EgsRERERkctIpzGvsyboRjYmvMGagOutx52WPs/ulzqzcd4nVWpXq0KJiIiIiFxG3Dy8iB/3EQA5CcMo+s8cXAwltC7dWXZszSQsA8diMNrXB6EeCxERERGRy5S3bwCHRvxoe4x81rz3oN1tKbEQEREREbmMNY1sX+5YwtHpbHz9GkqKiyrdjhILEREREZHLmLunj/X3ZNc46++d81bg+t/WlW5HiYWIiIiIyGVurd81HDCGEn7v9Cq3ocnbIiIiIiKXuW6PfIXFbMZgNHLkzrU0+aSb3W2ox0JERERERKyrQDUJbwMvZLPrup/tqq8eCxERERERKadVbC+2FHxc6fLqsRARERERkQq17tqv0mWVWIiIiIiISLUpsRARERERkWpTYiEiIiIiItXWYBOL1NRU2rRpY/MzYsQI6/lDhw5xxx13EBMTw5AhQ/j999/rMFoRERERkUtbg10Vavfu3URFRfHBBx9Yjzk6lj0di8XCuHHjaN26NbNmzWLx4sWMHz+euXPn0rRp07oKWURERETkktVgE4s9e/YQGRlJUFBQuXOJiYkcOnSIb775Bnd3dyIjI1m9ejWzZs3ioYceqoNoRUREREQubQ12KNSePXto3rx5hec2b95MdHQ07u7u1mNdunQhKSnp4gQnIiIiInKZadA9FmazmWHDhnH69Gl69erFhAkT8PT05Pjx4zRq1MimfEBAABkZGXZfx2QyYTKZairsGnUmrosdX21et6barm47Va1vbz17ytfVv3dD0FDuTV3E2RDerzXRVlXq12adhvKarCsN4f7ob2zttaO/sQ2LPffEYLFYLLUYS5UVFhZy9OjRCs/5+/vTvXt3unfvzsMPP0xOTg5Tp04lLCyM//3vf0yaNAmTycSrr75qrTNz5kzee+89Fi1aVKnrm0wm9XCIiIiIiAAxMTE4ODict0y97bHYvHkzY8aMqfDctGnTSExMxMXFBScnJwBeeeUVbrjhBo4ePYqLiwtZWVk2dYqLi3F1dbU7jujoaJydne2udzGYTCZSUlLo0KHDBf+hG8p1a6rt6rZT1fr21rOnfF39ezcEDeXe1EWcDeH9WhNtVaV+bdZpKK/JutIQ7o/+xtZeO/ob27AUFxeTmppaqbL1NrGIj49nx44dlS4fGRkJwNGjRwkODmb37t025zMzM8sNj6oMBweHev8Cq6sYa/O6NdV2ddupan1769lTviG8JutKQ7k3dRFnQ3i/1kRbValfm3UaymuyrjSE+6O/sbXXjv7GNgz23I8GOXl79+7dxMbGcujQIeuxbdu24ejoSHh4OJ06dWLr1q0UFhZaz2/YsIFOnTrVRbgiIiIiIpe8BplYtGjRgvDwcP7xj3+wc+dO1q9fzz/+8Q9GjhyJj48P3bp1o0mTJkycOJFdu3bx/vvvk5yczI033ljXoYuIiIiIXJKqNBRq586dpKamcuLECYxGI4GBgURHR1uHI9U2o9HI//73PyZPnsytt96K0Whk2LBhTJgwASjrsnnnnXd45plnGDFiBOHh4UybNk2b44mIiIiI1JJKJxbZ2dl89dVXfPvtt2RmZhIaGoqfnx9ms5lTp06Rnp5O48aNuemmmxg9ejQ+Pj61GTdNmjTh7bffPuf58PBwvvzyy1qNQUREREREylQqsZgxYwbvvfcePXv25KWXXiIhIaHcSkl5eXls3LiRuXPnct111/HAAw9w880310rQIiIiIiJSv1QqsUhLS2P27Nl4eXmds4yHhwc9e/akZ8+enDp1ik8++aTGghQRERERkfqtUpO3H3vssfMmFQBms5nDhw8D4Ofnx+OPP1796EREREREpEGwe1Wo/v378/XXX5c7fvLkSfr161cjQYmIiIiISMNid2KRlpbGG2+8wRNPPEF+fr7NOYvFUmOBiYiIiIhIw2F3YmEwGPj00085cuQIN9xwA7t27bI5JyIiIiIilx+7EwuLxUKjRo344osv6NWrFzfddBPff/+9tj8XEREREbmM2b1B3pleCQcHByZOnEhMTAzPPPMMiYmJNR6ciIiIiIg0DFXqsTjb4MGDmTFjBlu2bKmxoEREREREpGGxu8di+/bt5Y5FRkYyc+ZMJRciIiIiIpepSiUWP/zwQy2HISIiIiIiDVmlEos333yz3LGMjAyCgoJsJm0bDAauv/76GgtOREREREQahkolFkuXLi13LDY2li+//JKwsLAaD0pERERERBoWuydvi4iIiIiI/JUSCxERERERqTYlFiIiIiIiUm1VTizObJQnIiIiIiJSqcnbffv2LZdIFBQUcPvtt9usCgWwZMmSmotOREREREQahEolFg899FBtxyEiIiIiIg1YpRKL4cOHW38vLS3F0bHialu3bq2ZqEREREREpEGxe47FfffdR1FRkc2xnJwcnn/+eW666aYaC0xERERERBoOuxOL/Px8xo4dy+nTpwGYOXMmAwcOJDExkXfeeafGAxQRERERkfqvUkOhzvbZZ5/x2GOPccstt+Dh4cGuXbt44IEHGDt2LE5OTrURo4iIiIiI1HN291g4Ozvz9ttvExcXR3JyMu+99x733HOPkgoRERERkctYpXosbr/99nLLzVosFhwcHHjooYdo1aqV9fjnn39esxGKiIiIiEi9V6nEIj4+3q7jIiIiIiJyealUYjF+/PjajkNERERERBowu+dYiIiIiIiI/JUSCxERERERqTYlFiIiIiIiUm1KLEREREREpNqUWIiIiIiISLVValWodevWVbrBuLi4KgcjIiIiIiINU6USixdffJHdu3cDZRvjnYvBYGDbtm01E5mIiIiIiDQYlUosZs2axeOPP05aWhrffvstLi4utR2XiIiIiIg0IJWaY+Hs7My///1vAP773//WZjwiIiIiItIAVXrytrOzM//6179o1qxZbcYjIiIiIiINUKWGQp0RGRlJZGRkbcUiIiIiIiINlJabFRERERGRalNiISIiIiIi1abEQkREREREqk2JhYiIiIiIVFuVEovMzEySk5PZuXMnJpPJevzkyZPs3LmzxoITEREREZGGwa5VoVatWsW///1v0tPTCQsLIzc3l8zMTEaNGsW4ceMoKSnh9ttv5+233yYuLq62YhYRERERkXqm0j0Wn332GU8++ST33HMPK1eu5LvvvmPu3Ll8//33pKWlMWrUKFxdXXn55Zd59NFHycnJqc24RURERESkHqlUYrFlyxbefPNNPvnkEwIDA8nPz7eeCw0N5d///jetWrVi6tSpDBgwgI4dO/Lll1/WWtAiIiIiIlK/VCqx+OKLLxg5ciRt2rThgQceoFu3bgwYMICHH36Y//3vfyxbtozo6GgWLlwIwLBhw1i2bFltxi0iIiIiIvVIpRKLdevWcfXVVwPwv//9j8aNG3PVVVfRunVrNm/ezAMPPMCrr75Ky5YtAWjVqhX79++vtaBFRERERKR+qdTk7ePHj9O4cWMAnnnmGSZPnkz37t2t57dt28b48eN57rnnAPDy8rIZLiUiIiIiIpe2SvVYeHh4cOLECQCys7Nxc3OzOR8VFcVjjz3GxIkTgbJlZ729vWs4VBERERERqa8qlVi0a9eOdevWATB69GieeeYZkpOTbcocP36cY8eOAWWTvc8Mi6oui8XCXXfdxffff29z/NSpUzz00EPExsbSt29ffvzxR5vzqampjBw5kk6dOnHDDTewZcuWGolHRERERETKq1RiMXz4cL788ksKCgp4+OGH6dWrF6NHj2bYsGE8+uij3H777bz22mvcf//9APz444/07du32sGZzWZefvllVq5cWe7cxIkTOX36NN9++y0PPPAAzz77rDXZyc/P595776Vr1658//33xMbGct9992l4loiIiIhILalUYnHNNdcQHR3NY489RklJCU899RQLFixg+PDh+Pr6EhMTw/Tp07nzzjv5+uuvOXz4MDfddFO1Ajt69Chjx45l6dKl5YZVHTx4kF9//ZWXX36Z1q1bM3LkSK699lq+/vprAObOnYuLiwsTJkwgMjKSZ555Bg8PD+bPn1+tmEREREREpGKV3iDvP//5Dx4eHgwbNoy5c+cSFBTEXXfdxQsvvMATTzxBo0aNePnll3n77bd5++23cXd3r1ZgW7dupUmTJsyaNQsvLy+bc5s3b6ZJkyaEhoZaj3Xp0oVNmzZZz3fp0gWDwQCAwWCgc+fOJCUlVSsmERERERGpWKVWhQJwcnLiX//6F2vWrOHjjz/mhRdeICgoCC8vL44fP05ubi79+/dn9uzZBAcHVzuwvn37nnM41fHjx2nUqJHNsYCAAI4ePWo9/9c5HgEBAezatcvuOEwmEyaTye56F8OZuC52fLV53Zpqu7rtVLW+vfXsKV9X/94NQUO5N3URZ0N4v9ZEW1WpX5t1Gsprsq40hPujv7G1147+xjYs9twTg8VisVTlIkVFRaSnp5OdnY2vry9hYWE4OlY6T6GwsNCaCPxVUFCQTY9H3759GT9+PCNGjABg2rRprF692mZ379WrV3P33XeTmprK2LFj6dKlCw8//LD1/BtvvMGmTZv49NNPKxWfyWRSD4eIiIiICBATE4ODg8N5y1Q+E/gLFxcXWrRoUdXqbN68mTFjxlR4btq0afTv3/+81y4uLrY5VlxcjKura6XO2yM6OhpnZ2e7610MJpOJlJQUOnTocMF/6IZy3Zpqu7rtVLW+vfXsKV9X/94NQUO5N3URZ0N4v9ZEW1WpX5t1Gsprsq40hPujv7G1147+xjYsxcXFpKamVqpslROL6oqPj2fHjh1VqhscHExmZqbNsczMTIKCgs57/q/DpyrDwcGh3r/A6irG2rxuTbVd3XaqWt/eevaUbwivybrSUO5NXcTZEN6vNdFWVerXZp2G8pqsKw3h/uhvbO21o7+xDYM996PSk7frk5iYGNLT08nIyLAe27BhAzExMQB06tSJTZs2cWaUl8ViYePGjXTq1KkuwhURERERueQ1yMQiLCyMK6+8kr///e9s376dGTNm8Msvv3DrrbcCMGjQIHJycpg8eTK7d+9m8uTJFBQUMHjw4DqOXERERETk0lSpoVCHDx+udINNmzatcjD2eO2113jmmWe46aabCAoKYsqUKXTs2BEAT09P3nvvPZ5//nm+++472rRpw/vvv1/tJXBFRERERKRilUos+vbta90T4mxnhhqdfW7btm01FNqfli5dWu5YQEAA77777jnrdOzYkdmzZ9d4LCIiIiIiUl6lEoslS5ZYf1+2bBlffPEFEydOpEOHDjg7O7N161ZeeeWVau+2LSIiIiIiDVOlEouQkBDr7x988AFvvPGGzUTo+Ph4XnzxRR544AFGjx5d81GKiIiIiEi9Zvfk7by8PEpLS8sdz83NpaSkpEaCEhERERGRhsXufSyuvfZaJkyYwKOPPkrbtm2xWCykpKTw5ptvMmrUqNqIUURERERE6jm7E4uJEyfi4eHB1KlTOXnyJACBgYHceuut3H///TUeoIiIiIiI1H92JxaOjo48/vjjPP7449bEwt/fv8YDExERERGRhqNKG+QdOnSIV199lWeffZbS0lJmzpzJhg0bajo2ERERERFpIOxOLNatW8e1115Leno6K1asoKioiL179zJ27FgWLlxYGzGKiIiIiEg9Z3di8frrr/PEE0/w5ptv4uhYNpJqwoQJPPnkk7z55ps1HqCIiIiIiNR/dicWO3fu5Kqrrip3vF+/fhw8eLBGghIRERERkYbF7sQiJCSElJSUcseXLVtms5GeiIiIiIhcPuxeFerRRx/l6aefJiUlBZPJxA8//EBaWhpz5szhtddeq40YRURERESknrO7x2LAgAF89dVXnDhxglatWrFkyRKKi4v56quvGDJkSG3EKCIiIiIi9ZzdPRZHjhyhbdu25XonioqK+OGHH7j++utrKjYREREREWkg7O6x6Nu3L4899hj5+fk2x0+fPs3EiRNrLDAREREREWk47E4sLBYLhw4dYvjw4ezYsaM2YhIRERERkQbG7sTCYDDwzjvvMGDAAEaNGsXMmTOtx0VERERE5PJk9xwLi8WCg4MDTz75JDExMUycOJH169fz2GOP1UZ8IiIiIiLSANjdY3G2/v37M3PmTFJTU7n77rtrKiYREREREWlg7E4s4uLicHJysj4ODw/nu+++IyoqCovFUqPBiYiIiIhIw2B3YvHFF1/g7e1tc8zV1ZXXX3+d7du311hgIiIiIiLScFRqjsWYMWN4++238fb2ZsyYMecsZzAY+Oyzz2osOBERERERaRgqlVh069bNOvwpLi5OK0CJiIiIiIiNSiUW48ePt/7+0EMP1VowIiIiIiLSMFUqsbBnR+2pU6dWORgREREREWmYqrXcrIiIiIiICFSyx0K9ECIiIiIicj5V2nl7yZIl7Nq1C5PJZD1eXFxMamoqH374YY0GKCIiIiIi9Z/dicVLL73EzJkziY6OJjk5mdjYWA4ePEhmZiajR4+ujRhFRERERKSes3uOxdy5c/m///s/vvnmG5o1a8YLL7zAr7/+ytChQykpKamNGEVEREREpJ6zO7HIzc2lffv2ALRu3Zrk5GQcHR257777+O2332o8QBERERERqf/sTizCwsJITU0FoFWrViQnJwNlcy9Onz5ds9GJiIiIiEiDYPcci7vuuou///3vTJ48mSFDhjBixAgcHR3ZtGkTXbp0qY0YRURERESknrM7sRg5ciTNmzfH3d2dyMhI3n77bWbMmEH79u21K7eIiIiIyGXK7sQCIC4uzvp7z5496dmzZ40FJCIiIiIiDY/dicWePXv497//zd69eykuLi53fsmSJTUSmIiIiIiINBx2JxZPPPEErq6ujBkzBldX19qISUREREREGhi7E4v9+/cza9YsIiMjayMeERERERFpgOxebrZXr15s2LChNmIREREREZEGyu4ei6effprhw4fz888/ExISgsFgsDk/derUGgtOREREREQaBrt7LP7xj39gNBoJDAwsl1SIiIiIiMjlye4ei/Xr1zN9+nSio6NrIx4REREREWmA7O6xaNWqFTk5ObURi4iIiIiINFB291iMHj2aCRMmMGLECEJDQ3F0tG3i+uuvr6nYRERERESkgbA7sZg2bRqOjo789NNP5c4ZDAYlFiIiIiIilyG7E4tXX32Vjh074uLiUhvxiIiIiIhIA2T3HIvx48ezb9++2ohFGgiDwUBAQECtrApWU21Xt52q1re3nj3la/O+i4iIiFSX3T0WrVq1Ijk5mbZt29ZGPFJPWSwWCgsLKSgooKioCIvFQkZGRq1dqybarm47Va1vbz17ytfmfa8KBwcH3NzccHV1xdnZua7DERERkTpkd2Lh4+PD888/z5tvvkloaGi5DxOff/55jQUn9YPFYiErK4ukpCQOHz5MSUkJubm5eHp61vi35xaLpUbarm47Va1vbz17ytfUvalpnp6eREVFERkZqSGSIiIilzG7E4uoqCiioqJqI5YKWSwW7r77bq655hpGjBhhPf7pp5+W2+X7rrvu4qmnngJg1apVTJkyhUOHDtGpUycmT55MWFjYRYv7UlJcXMy2bds4ePBgXYci9VBubi4bNmwgMDCQRo0a1XU4IiIiUkfsTizGjx9v/T03NxeTyYSPj0+NBnWG2Wxm8uTJrFy5kmuuucbm3O7du7nlllt48MEHrcfc3NwAOHz4MOPGjeOhhx6iZ8+eTJs2jQcffJCffvqpXn3T21AUFxdz9OjRug5D6jGz2czhw4cJCAjAwcGhrsMRERGROmB3YgHw2Wef8eGHH5KZmQmAv78/o0ePtkk6quvo0aM8+eSTpKWl4e3tXe78nj17uP766wkKCip3bsaMGbRv35677roLgKlTp9KjRw/Wrl1LfHx8jcV4ubBYLBQXF5c7/tVXX9GsWTN69ep13vqlpaX88MMP7N27l6ZNm3LbbbfVVqhSh4qKijCbzUosRERELlNV2sfiyy+/5JFHHiE2Nhaz2czGjRt5++23cXZ25t57762RwLZu3UqTJk144403uPHGG8ud37t3L82bN6+w7ubNm+natav1sZubG+3atSMpKUmJRRVYLJZq1d+zZw979uxhzJgxeHl51VBUIiIiIlKf2J1YfPfdd0yePJm+fftaj0VFRREcHMzkyZNrLLHo27evzTXOlpmZSVZWFrNnz2bixIm4uLhw4403ctddd2EwGDh+/Hi5sd4BAQH1ajWdy0lRUREeHh40adKkrkMRERERkVpid2KRm5tbYU9BREQEJ0+erHQ7hYWF5xy3HxQUhLu7+znr7t27FyhLFv73v/+xbds2Xn75ZRwcHLjjjjsoKCgot1qVs7NzhcN5LsRkMmEymeyudzGcietixGexWKw9F3/97+bNm0lJSSEsLIyNGzdiNpvp2LEj/fr1IyUlhTlz5gAwZcoUhg4dSseOHUlOTiYxMZHs7GwCAwPp168fzZo1K9d2deKtTjtVrW9vPXvK19S9qS0WiwWz2Vwn75eL+V6ojrqIszavWZNtV7etqtSvzToN5TVZVxrC/amrGBvCe7Yu3q9VqWdP+Ybwmqwr9twTuxOL2NhYPv74Y1588UWMRqP1gh9//DEdO3asdDubN29mzJgxFZ6bNm0a/fv3P2fdbt26kZiYiJ+fHwBt2rTh5MmTTJ8+nTvuuAMXF5dySURxcXGFczUuJDU11e46F1tKSkqtte3u7k5AQAB5eXkUFBTYnDObzRQXF1NUVERaWhouLi7ccMMNHD16lMWLF9O0aVOaNWtGz5492bRpEzfddBMuLi6sW7eO3377jauuuorGjRuTmprKd999x2233YanpycAeXl5NRJ/ddupan1769lTvqbuTU0rLi4mKyuLtLS0OouhNt8LNaku4qzNa9Zk29Vtqyr1a7NOQ3lN1pWGcH/qKsaG8J6ti/drVerZU74hvCbrM7sTi4kTJ3LrrbeyatUq2rVrB5TNhyguLubDDz+sdDvx8fHs2LHD3stbnUkqzoiMjLT2gAQHB1snlp+RmZlZpWVyo6Oj6+3GXyaTiZSUFDp06FCrE2Zzc3Px8PCwXsNisZCXl4fRaMTZ2RkXFxcsFgvDhg3DxcWFsLAwkpOTycrKIjo6Gm9vbxwcHAgODgbK3rRdu3YlLi4OgLCwMDIyMti+fTtXXXUVeXl5eHh4VHsfi+q0U9X69tazp3x1n1Ntc3Z2xtfXl8DAwIt+7Yv1XqiuuoizNq9Zk21Xt62q1K/NOg3lNVlXGsL9qasYG8J7ti7er1WpZ0/5hvCarCvFxcWV/qLd7sQiMjKSefPm8fPPP7N3715cXFzo0aMHw4YNw8PDw+5gq2LGjBl8+OGHzJ8/3/oBa9u2bbRo0QKATp06sWHDBmv5goICUlNTq7RqlYODQ71/gV2MGA0GQ7kPs2ceGwwGPDw8cHV1tZ5zcXHBbDbb1Dvz3xMnTtCzZ0+b9kJDQzlx4oRN2Zr48Fzddqpa39569pSvqXtT0wwGA0ajsU7fLw3h/Qp1E2dtXrMm265uW1WpX5t1Gsprsq40hPtTVzE2hPdsXbxfq1LPnvIN4TV5sdlzP6q03Kyfn985hzFdDFdccQVTp07l1VdfZfTo0WzZsoUPPviAl156CYAbbriBjz76iPfff58+ffowbdo0QkNDtSJULaroRXeuuQCOjuVfdmazGbPZXONxiYiIiMjFYXdikZ6ezn//+19SUlIoLS0t9+FxyZIlNRbcuYSEhPD+++/z+uuvM336dAICAnjyyScZMmQIUPbt91tvvcWUKVOYNm0asbGxTJs2rV5+y3s58vf3Jz09ndatW1uPHT58WDuji4iIiDRgdicWEyZM4NSpU9x6663Wiba1benSpeWOde3alW+//facda666iquuuqq2gxLqqhbt27MmTOHwMBAmjZtSnJyMkePHi23u7qIiIiINBx2JxbJycnMnj2bli1b1kY8chmIjo4mLy+P5cuXk5ubS3BwMKNHjyYwMLDeLqUqIiIiIudnd2LRvHlzu/arkEvXrbfeah1e9telhm+77Tbr7x07dix3Pi4uzroqlIiIiIg0fHYnFn/729949tlnufPOOwkPD8fJycnmvD4sioiIiIhcfqo0xwLgn//8Z7lzBoOBbdu2VT8qERERERFpUOxOLLZv314bcYiIiIiISANmrEyhmTNn2rXHgMlkYsaMGVUOSkREREREGpZKJRaHDh1i2LBhfPDBB+zbt++c5Q4cOMA777zDkCFDOHjwYI0FKSIiIiIi9VulhkI99thjXHfddXz44YcMHz4cPz8/WrRogZ+fH2azmaysLHbu3ElOTg5Dhw7lnXfeITIysrZjlzo2depUAMaNG4ePj4/NuY0bNzJ//nyuvPJKevXqZXfbBw4c4Ouvv2bSpEk1EmtNmDZtGj179iy3wtVfffrpp/Tq1YtOnTpdpMhERERE6l6l51i0aNGCKVOmMHHiRNauXUtqaionT57EYDAQGRnJ7bffTnx8PO7u7rUZr9QzRqORXbt20bVrV5vjO3bsqKOIRERERKQu2D1528vLi379+tGvX7/aiEcamGbNmpVLLIqKikhPT6dx48Z1GJmIiIiIXEx2JxYiZ2vVqhVLly6lqKgIFxcXAHbv3k1YWBglJSU2ZZOTk1m9ejXZ2dkEBgbSv39/mjVrBpQlI/PmzWP37t24u7sTGxtrUzcnJ4cFCxawb98+PDw86NixIz169MBoLJsmNGXKFK655ppyw5R27NjB/PnzeeSRRzAYDBw6dIgvvviCW265hebNmwPw5ptvMmzYMCIiIti4cSOrV68mPz+fRo0aMWjQIIKDg8s9b7PZzPLly9m8eTOlpaVEREQwaNAg3NzcAMjMzOSzzz4jIyODwMBArrnmmgrbEREREblUVGrytsi5NGrUCC8vL/bs2WM9tmPHDlq3bm1TLjk5mQULFnDFFVdw9913ExERwbfffsvp06cBmDdvHidOnODWW2+lV69erF271lrXYrEwa9Ys3N3dufvuu7nmmmvYunUrq1atspZ5+OGHiYqKKhdf8+bNKSws5Pjx4wDWRQXS0tIAOH78OEVFRYSFhbFr1y5WrFjB1VdfzV133UXTpk35+uuvKSgoKNfub7/9RnJyMtdccw1jxowhLy+PefPmWc9v3ryZ7t27c8899+Dq6mpzTkRERORSpMRCqq1Vq1bs2rULgNLSUvbt21cusVi3bh1xcXF06NCBgIAA+vTpQ6NGjVi/fj2FhYVs27aNAQMG0LhxY8LDw+nRo4e17v79+8nOzmbIkCEEBAQQHh5Ov379WLdunbWMp6dnuV3gAVxcXGjatKk1oTh06BCRkZHWxGLfvn2Eh4fj6OjI6tWrueKKK2jVqhX+/v4kJCTg4+PDli1bbNq0WCwkJSXRu3dvIiMjCQoKYtCgQQQFBVnLxMbG0rp1awICAoiLi+PYsWPVvMsiIiIi9ZuGQkm1tW7dmu+//x6z2cz+/fsJCgrCw8PDpsyJEyfo2bOnzbGQkBBOnDjByZMnsVgsNkOFmjRpYlO3oKCA//u//7Mes1gslJaWkp+ff8EFA1q0aMGBAwfo3Lkz6enp3HDDDcyaNQuLxcL+/ftp0aKF9Tq//vory5Yts9YtLS0lJCTEpr38/HwKCgps5pAEBQURFBSExWIBwM/Pz3rOxcWF0tLS88YoIiIi0tBVOrEoKCggMTERgISEBNzc3Pjhhx/48ssvMZvNDB48mHvuuQeDwVBrwUr9FBYWBpT1BuzcuZM2bdqUK+PoWP6lZjabz7nxooODg025gIAAbrzxxnLlXF1dLxhfREQE69atIyMjA09PT8LDwzEYDGRkZHDw4EH69+9vvU7//v1p3rw5FovFmrT89Rpnx3Yueh+IiIjI5aZSQ6FSUlLo168fTzzxBBMnTmTgwIF89tlnPP/880RHR9O+fXveeecdPvjgg9qOV+oho9FIZGQku3btYteuXRUmFv7+/qSnp9scO3z4MAEBAQQEBGA0Gjl8+LD13NGjR62/BwQEkJOTg7u7O/7+/vj7+5Odnc2KFSsqFV/Tpk0BSEpKIiwsDIPBQGhoKGvWrMHDwwN/f3/rdU6fPm29hq+vL6tWrSoXt6urK25ubjbDm44ePcpbb71VbsK6iIiIyOWiUonFlClTuPbaa1m3bh2JiYncd999vPLKK0yaNIkXX3yRF198kcmTJzNjxozajlfqqdatW5OUlISHhwe+vr7lznfr1o3169eTkpJiHXJ09OhROnXqhIuLCx06dGDhwoWkp6eTlpbG77//bq0bERGBt7c3P/30E8eOHePgwYPMnTsXJycn66pQubm55/xQbzAYCA8PJyUlxdq7EhYWRmpqqnUY1JkY161bR0pKCqdOnWLlypVs376dwMDAcm3GxcXx22+/sX//fo4fP87ChQsJCQmpcJ6HiIiIyOWgUkOhtm3bxtSpU61DQEaNGsWUKVPo0qWLtUyXLl04cuRI7UQp9V6LFi0wm83lJm2fER0dTV5eHsuXLyc3N5fg4GBGjx5t/dB+9dVXs3DhQr755htcXFyIi4tj6dKlQFmPyMiRI1m4cCGffvopzs7OtG3b1mYvlTfffLPC5WbPjm/79u2EhoYCfw7fOjuxODvGvLw8/P39ufHGG609Gmfr3r07hYWFzJ49G7PZTMuWLbn66qurcOdERERELg2VSiwKCwvx8vKyPnZwcMDZ2dm6b8GZYyaTqeYjlHpr4sSJ1rkEzs7OTJgwweb8bbfdZvM4Li6OuLi4CttycnJi6NChDBkyhNzcXDw9PUlISLCe9/Pz4+abbz5nLJMmTTpvrDExMcTExFgfh4aGVljnTIwWi8Uaxxnjxo2z/u7g4ED//v2t8zPOsFgs3HHHHTb1wsPDLxifiIiISENXqaFQBoNBk1FFREREROScKtVjYbFYePnll216KEpKSnj99dety4oWFRXVToQiIiIiIlLvVSqxuP7668v1WAwbNszmsYuLC9dff32NBSYiIiIiIg1HpRKLV155pbbjEBERERGRBqxSicUPP/xQ6QbVa3H5eOedd8jOzrY55urqSlhYGAMHDsTb27uOIqucrKws3nnnHQBiY2MZPHgwmZmZLFq0iPT0dFxdXYmNjeWKK66w9thlZGQwf/58jh07RlBQEIMGDbLZJfx8CgsLWbJkCbt27cJisdCyZUubyd/5+fnMmzePffv24ebmxlVXXUX79u2t5zMyMpg7dy4nTpyo8Npbt27lt99+Izc3lxYtWjBkyBDrruQWi4Vly5aRlJSExWIhJiaGPn36nHPuVFZWFnPnziU9PR1vb28GDBhAixYtSE9P57PPPgPgyiuvpFevXnbccREREbmUVSqxePPNN20eHzlyBGdnZ8LCwnBycuLAgQMUFRXRtm1bJRaXmf79+xMdHQ2UfXjNzMxk3rx5/Pzzz9x66611HF3l3HHHHQQEBFBSUsJ3331Hs2bNuOOOOzhy5AhLlizBxcWFrl27UlxczLfffkv79u255ppr2LhxI9999x0PPPAAzs7OF7zOvHnzyMrK4uabb8ZgMDB//nzmzZvHgAEDAPjll18oLS1lzJgxHD58mDlz5uDv70/Tpk0pLi7mu+++o3Xr1lx77bVs2rTJ5tpnyg8ePJjg4GAWLlzIL7/8wk033QTA2rVr2bp1KzfeeCMmk4mffvoJd3d3m5W3zrBYLMycOZOgoCDuvPNOdu7cyaxZs7j33ntp3LgxDz/8MLNmzarZfwQRERFp8Cq1KtTSpUutPyNHjqRPnz789ttv/PLLL8yePZvly5czcOBAm30t5PLg6uqKp6cnnp6eeHl5ERERQa9evThw4ACFhYV1HV6luLu74+LiwsGDBykoKGDQoEEEBATQvHlz4uLiSE1NBcr2c3FycqJv374EBgYyYMAAnJ2d2b59+wWvUVxczPbt27n66qtp0qQJjRs3pn///uzYsYPS0lJOnTrF7t27GTJkCI0aNSImJob27duzYcMGm2v36NGjwmuvX7+eqKgoOnToQKNGjbj22mvZvXs3WVlZAKxbt45evXoRFhZG8+bN6du3r7Xtvzpw4ACnTp1i8ODBBAYGcsUVVxASEsLmzZtxcHDA09PTuqeNiIiIyBmV6rE420cffcS3335rs7uyp6cn48eP58Ybb9R6/WL90HlmV+zjx4+zePFi0tPTMZlMNGnShCFDhhAYGMiBAwf45ZdfSEhIYOXKlRQVFdGiRQuuvfZa6y7WW7ZssW6sd2YDPn9/f3r16oXFYmHlypVs3LiRkpKScsOwfvnlF7Kzs8vtqVGR4OBgbrzxRhwdHbFYLNbjZxKk9PR0QkNDrcOHDAYDoaGhpKWlnXNjvjMMBgM33XQTwcHBNsctFgslJSUcO3YMb29vm/dVWFgYq1atqtS1Dx8+TPfu3a11vb298fHxIT09HQcHB3JycqybAkLZPh7Z2dnl9uo4c63GjRvb9MKEhoaSnp5+wXsoIiIil69K9ViczcvLy/oN7tk2bNhQ4Q7Fcnk5deoUq1evpkWLFjg7O2OxWJgxYwa+vr7cfffdjB07FovFwq+//mqtc/r0abZv386oUaMYMWIEe/bsYcuWLQAcOnSIOXPmkJCQwF133YWzs7PN62/9+vVs2bKF6667jrFjx+Lh4cH06dOtmzX279+fG264oVKxe3p6Eh4ebn1cWlrK5s2bad68OQC5ubk2G0UCeHh4cPr06Qu27eTkRGRkJI6Of+by69ato1GjRri5uVX4Af/stqtzPjc3F8Am9jPLROfk5JSL9ULXEhEREamI3T0W9913H8888wxr1qwhKioKi8VCSkoK8+bNY+rUqbURo9Rj8+bNY8GCBQCYzWYcHBxo3bq1dVJySUkJnTt3pnPnztZvwDt06EBiYqK1DbPZzNVXX01QUBBBQUE0a9aMI0eOEBsby4YNG4iKiqJz584ADBo0iL1791rrJiYmMmjQIGtCMHjwYN5880327t1LkyZNcHV1rdLmjhaLhUWLFlFUVMQVV1xhfS5/HQJU1R3n169fz7Zt26y7iZ+r7dLS0kpd+3z1S0pKrI/POJPgVBR7aWmpTQJ0pnxVnqeIiIhcPuxOLEaNGkVISAgzZ85k+vTpALRq1YqPP/6Yrl271niAUr/16tWLNm3aUFxczIoVK8jOzqZ3797W1YicnZ3p3LkzKSkpZGRkcOLECTIyMqzfmJ9xdm+Xs7Oz9UPssWPHiI2NtZ4zGo00btwYKJu3cPr0aWbPnm2TPJSWlnLy5MlKr9b0V2azmZ9++on9+/czevRo67f3FX24NplM1iFblbVhwwYWLlxI//79adGiBbm5uRdsuzrnz04izvx+JmGpKHYHBweKi4ttjlWUbIiIiIicrUqfFHr27EnPnj1rOhZpgDw8PKxJwYgRI/jkk0+YOXMmY8eOtX5A/eSTT3Bzc6N169ZER0dz4sQJ1qxZY9POuSYDn5mnURGz2Wy97l+H4bm6ulbpG3aTycTs2bPZt28f1157LaGhodZzXl5e1mFFZ+Tl5ZVLks4nMTGRpUuX0rdvX7p162ady+Hl5UVeXp5N2bOHJFV0/uxrn6/+mSFQubm51jkcZ8r+dcjTmbYyMzPLXauisiIiIiJn2D3HQuRcHBwcGDJkCEePHmXt2rVA2QpDubm53HbbbSQkJBAREUFOTo7N5OjzCQoKIiMjw/rYbDZz9OhRoCx5cHd3Jzc3F39/f/z9/fHx8WHp0qWcOHGiSs9h3rx57N+/n5tvvpmQkBCbcyEhIaSnp1tjt1gspKWllSt3LsnJySxdupT+/fuXW+a1adOmZGdn28x5OLvtkJAQ0tLSznntpk2bcujQIWvdnJwccnJyCAkJwcvLC29vb9LS0qznDx06hLe3d4XJQkhICBkZGdYhVGfKV/Z5ioiIyOVJiYXUqKZNm9KpUydWrlzJ6dOncXNzo7i4mB07dpCVlUVSUhLr16+vdG9Cly5dSE1NJSkpiRMnTrBo0SKys7OtQ5/i4+P57bff2LVrFydPnmTOnDmkpaUREBAAlK3oVFBQUKlr7du3j+TkZPr164efnx95eXnk5uZav91v27YthYWFLFq0iOPHj7No0SKKi4uJiooCyuY5/LVH44yCggIWLlxIhw4diI6OJjc31/pjNpvx8/OjRYsW/PTTTxw7doykpCS2bt1qXcK5bdu2FBUVsWLFCusmfmdfu3PnzmzZsoWkpCSOHTvGTz/9RKtWraw9FJ07d2bp0qUcOHCAAwcO8OuvvxIXF2eNLy8vzzr8qVmzZnh7e/PLL79w/PhxVq1axZEjR+jUqVOl7qOIiIhcnjRoWmpc79692b59O0uXLuW6667jyiuvZMGCBZSWltKoUSMGDhzInDlzKrXKUGhoKAMHDuT3338nPz+fqKgoQkJCrEOn4uPjKSoqYu7cuRQXF9O4cWNGjx5tXWlp8eLFlV5u9syeEPPmzbM57uPjw7hx43BxceGmm25i3rx5JCUl0ahRI26++WbrpPRt27bxyy+/8NBDD5Vre+/evRQXF5OSkkJKSorNubFjx+Lt7c2wYcOYO3cun376KZ6engwdOpSmTZsC4OLiwsiRI5k7dy6ffPJJuWuHhoYyePBgli9fTkFBAREREQwZMsR6jYSEBPLz85k1axYGg4GYmBi6detmPf/pp5/SoUMHevXqhdFo5MYbb2TOnDl8/PHH+Pn5ccMNN+Dj43PBeygiIiKXr0olFs899xzdu3cnISEBPz+/2o5JGogHH3ywwhWX3N3defzxx62PK5qTc+bbby8vr3J7nwwYMMA6ROfw4cOEhYUxfvx46/n333/fet5oNNK7d2969+5t08aZIUPXXHNNpVeFGjx4MIMHD7bWPzNH4ez6TZs25e67766wfseOHa3L5P5Vu3btaNeuXbnjZ64DZfNVRo4cec74mjZtyqhRo8rFdPb1z7WfhtFopH///tbVuv5q3LhxNo/9/f25/fbbzxmLiIiIyF9VKrGIiYlh6dKlTJ06FX9/f2uSERcXZ139R6Q2pKWlsWHDBoYNG4anpydbt24lJyeHFi1a1Ng18vPzcXNzw8XFpVrtHDx40Lox36XKZDJRUFCgpWdFRESknEolFiNGjGDEiBEA7Nmzh9WrV/Pdd9/x9NNPExERQffu3enevTsxMTFaklJqVNeuXcnOzmbWrFkUFRURHBzMzTffXKMrFH366afExsZaeyuqKjQ0lNDQ0HKrM11KMjIy+OyzzwCIiIio42hERESkPrE7C4iMjCQyMpLbbrsNs9nMli1bSExMZNq0aWzbts1m4zOR6jIajQwYMIABAwbUeNu+vr7lhmFVh9ForPRqVw1VSEhIjd4zERERuXRUq3vBaDRax3Xfe++95TbVEhERERGRy0ONLjd7ZoUauTxMnTqVH374odzx5ORkpk2bdvEDqsCKFSv48ssvgdqNa8qUKRw4cMCuOqWlpXzwwQc2+0vUp3snIiIiYg9NiJBqSU1NJSYmhubNm9d1KBcUFRVFZGRkXYcBlCUVP/zwQ7kdrkVEREQaKm2QJ9Xi4+PDggULGsQqQU5OTnh4eNR1GBw/fpxPP/2UrKysug5FREREpMZUucdi165d7N+/nx49enDixAlCQ0MrvV+AXDquuuoq5s+fT2JiIj169KiwTE5ODosXL2b//v0YDAbatWtH3759cXR0JDk5maSkJNzd3Tlw4ABXX301GzdupE2bNuzdu5e0tDSCgoK47rrrSExMZOvWrXh6ejJkyBDCw8MB2Llzp3VHakdHRyIjIytc4Sk5OZkVK1Ywbtw4fv7553Ib1QHceuuthIeHc+jQIRYuXMjJkyfx8/OjZ8+etG3b1lpuxYoVbNiwAYvFQp8+fWzaWLNmDTt27Ci3N8QZBw8eJDw8nN69e/P666+f895aLBZmz57NyZMnue2226q9HK6IiIhIbbI7scjOzuaRRx5h7dq1ACxYsIDJkydz6NAh3n//fUJCQmo8SKm/vLy86NWrF8uWLaNdu3b4+vranDeZTHz99df4+flx2223kZ+fz9y5cwG4+uqrgbK9Kq644gp69+6Nm5sbGzdu5Pfff2fo0KEMGDCAWbNm8emnn9KlSxfuvPNOli1bxqJFi7jnnns4deoU33//PQMHDiQiIoKTJ0/y448/kpSURHR09DnjHjBggE1CMG/ePPLz8wkNDSU3N5cZM2YQHx9PVFQUR44c4ZdffsHd3Z1mzZqxadMm1q1bx7Bhw/D29mb+/Pk2bcfGxtK9e/dzXrtLly6VureLFi3i6NGj3H777bi6ul7yK06JiIhIw2b3UKiXX34ZNzc3EhMTrd+gTpkyhcaNG/Pyyy/XeIBS/3Xt2hV/f38WLlxY7tyePXs4ffo01157LY0aNaJ58+YMHDiQjRs32qwi1qNHDwIDA60bLrZs2ZKoqCiCgoJo3bo1zs7O9OrVi8DAQGJjYzlx4gRQ9q3+1VdfTWxsLL6+vrRo0YKIiAiOHz9+3phdXV3x9PTE09OTnTt3kpaWxvDhw3FwcGDDhg00b96cTp064e/vT/v27YmJiWHdunUAJCUl0a1bN1q1akVwcDBDhgyxadvZ2bnaG0euXr2a7du3M3r06Brds0NERESkttjdY7FixQq++OILmx2G/f39mThxIqNGjarR4KRhMBqNDBo0iM8//5wdO3bYnDtx4gT+/v64ublZj4WGhmI2mzl16hQAHh4eODk52dQ7u+fD0dERHx8f61A7R0dH65wOf39/HBwcWLlyJcePH+f48eNkZmbSvn37SsV++PBhFi9ezA033GB9TWdmZrJr1y727t1rLWc2m/H397eev/LKK63ngoKCysVfHadPn2bZsmV4e3vXizkhIiIiIpVRpTkWRUVF5Y6dPHlSu25fxkJDQ+nUqROLFi0iISHBetzBwaFcWbPZbPPfil43RqNtZ9q55u8cPXqUL774glatWhEWFka3bt2sPQsXkp+fz/fff0+3bt1sVouyWCy0b9+eTp064e7ubr322c/lr8OSKnqeVWUwGLj55puZM2cOK1eupHfv3jXWtoiIiEhtsXso1DXXXMPkyZPZtWsXBoOB/Px8EhMT+cc//lFuSIhcXvr06UNJSQlr1qyxHgsICODkyZMUFBRYj6Wnp2M0GvHz86v2Nbds2UJYWBjXXXcdXbp0oWnTppw8efKC8xEsFgs//vgjvr6+9OrVy+acv78/J0+exNfXF39/f/z9/dm1axdbtmwBynoojhw5Yi2flZVFYWFhtZ/LGZ6enkRERNC3b1/WrFnDyZMna6xtERERkdpid2IxYcIEOnXqxIgRI8jPz+e6667j7rvvpnv37kyYMKE2YpQGwt3dnT59+pCdnW09FhERga+vLz/99BPHjh1j//79LFy4kHbt2uHq6lrta7q5uXHs2DEOHz7MiRMnWLx4MUeOHLng8rfLly/n2LFjDBo0iPz8fHJzc8nNzaW4uJguXbqQkZHB6tWrOXnyJFu3bmXZsmX4+PgAZXNK1q1bx/bt2zl27Bhz5syx6VEpLi4mPz+/2s8tOjqakJCQCueuiIiIiNQ3do9dcnZ25umnn+bRRx/l0KFDmEwmwsLCNBZcAOjUqRPJycmcPn0aKBvSNHLkSBYsWMCnn36Ks7Mz7du3r7HhPV27diUjI4Ovv/4aR0dHwsLCuPLKK0lNTT1vvS1btpCXl8f7779vc/zKK6+kV69e3HjjjSxZsoRNmzbh5eVFv379rPM22rdvT35+PgsXLqSkpIQrrriCY8eOWdvYtGnTeZebtcfVV1/NRx99xPbt22nTpk212xMRERGpLZVKLC40Zv3sD3FxcXHVi+gPOTk5vPrqq/z666+YzWZ69+7NpEmTrBNsT506xXPPPcfvv/+On58fjzzyCNddd51NTM8//zw7d+6kZcuW/POf/6z0hF6pnIkTJ5ab+2AwGBgzZozNMV9fX26++eYK2+jYsSMdO3a0OTZixAiblZD+OlQpPDycSZMmAWWJ7ogRI8q127NnT3Jzc+nZs6c1xrOvdaEP/REREYwaNQpPT88K53d069aNbt26WR+fWV7WYrEQHx9Pv379ztv+GRMnTiQ3N9f6+K/3o1GjRkycONHatoiIiEh9VanE4vbbb7d5bDAYsFgsuLm54eTkRE5ODg4ODnh7e7N69eoaCez555/n4MGDvP/++xgMBl544QWeffZZ3nzzTaDsA1lhYSHffvstmzdv5tlnnyUiIoKOHTuSn5/Pvffey7Bhw3jllVeYPn069913H4sWLar2MqAiIiIiIlJepRKL7du3W3+fOXMmM2fOZPLkydaVdNLS0nj22WdtluCsjvz8fBYsWMD06dOtvQyTJk3i1ltvpaioiKNHj/Lrr7+yZMkSQkNDad26NUlJSXz99dd07NiRuXPn4uLiwoQJEzAYDDzzzDMsX76c+fPnV/jttoiIiIiIVI/dk7f/9a9/8cILL9gszxkaGsqkSZPKjVevclBGI++++y5RUVE2x00mE3l5eWzevJkmTZoQGhpqPdelSxc2bdoEwObNm+nSpYt1CIvBYKBz584kJSXVSHwiIiIiImLL7snbBoOBo0eP0rZtW5vj+/fvt+7EXV2urq7lxtV//vnntGnTBn9/f44fP06jRo1szgcEBHD06FEAjh8/TsuWLcud37Vrl92xmEymC64wVFfOxHUx4rNYLNYx/n/9b01fpybarm47Va1vbz17ytfmfa8JFosFs9lcJ++Xi/leqI66iLM2r1mTbVe3rarUr806DeU1WVcawv2pqxgbwnu2Lt6vValnT/mG8JqsK/bcE7sTi1tuuYUJEyZw55130rZtWywWCykpKXz++ec89NBDlW6nsLDQmgj8VVBQkM1ciC+//JJ58+bx4YcfAlBQUICzs7NNHWdnZ4qLiyt13h4XWl2oPkhJSam1tt3d3QkICCAvL89mLwoom2C/fv16tm/fTm5uLu7u7rRs2ZL4+Phy999eeXl5dtfJz88nPT2dVq1aAfDWW28xfPhwm56tM9LS0pg9e/YFX7NViaOieklJSWzcuJHi4mJatWpFr169bHbrtuc6VY2pthUXF5OVlUVaWlqdxVCb74WaVBdx1uY1a7Lt6rZVlfq1WaehvCbrSkO4P3UVY0N4z9bF+7Uq9ewp3xBek/WZ3YnF+PHjCQoKYsaMGbz33nsAtGrViueee45rr7220u1s3ry53OpBZ0ybNo3+/fsD8NVXX/Hyyy8zceJE6xwOFxeXcklCcXGxdV+EC523R3R0dLU/JNcWk8lESkoKHTp0qNGdn/8qNzcXDw8P6zUsFgt5eXmsW7eO/fv3M3ToUHx9fcnKymLRokXk5uYycuTIKl3rTNseHh7n3G37XJYtWwZAbGys9Vt9V1dXmxWmzmjVqhUPPfRQheeqE0dF9bZv387atWsZNmwYHh4ezJkzh7Vr1zJw4EC7rlOde3MxODs74+vrS2Bg4EW/9sV6L1RXXcRZm9esybar21ZV6tdmnYbymqwrDeH+1FWMDeE9Wxfv16rUs6d8Q3hN1pXi4uJKf9Fud2IBcPPNN59z+dDKio+PZ8eOHect89FHH/Haa68xYcIExo4daz0eHBxMZmamTdnMzEyCgoLOe/6vw6cqw8HBod6/wC5GjAaDodyH2ZSUFIYOHUpERAQAfn5+DB48mC+++IK8vLxzfmiv6vXsqXuhdhwdHfHy8qq1OM6ut379euLi4mjdujUAgwcPZvr06fTr1w9HR0e7r1Ode1ObDAYDRqOxTt8vDeH9CnUTZ21esybbrm5bValfm3UaymuyrjSE+1NXMTaE92xdvF+rUs+e8g3hNXmx2XM/7E4s3n777fOeHz9+vL1NVmj27Nm89tprTJw4kTvuuMPmXExMDOnp6WRkZNC4cWMANmzYQExMDFC2SdsHH3yAxWKxLo27ceNG7r///hqJTcoYDAYOHDhA69atrR90Q0JC+Nvf/oabmxtQ1vt05ZVXsnHjRo4fP05YWBhDhgxh8eLF7NmzB39/f6677jprUpiWlsbixYvJzMzE3d2d7t2707lzZ+s1k5OTWb16NdnZ2QQGBtK/f3+aNWvG8uXLrd2XBw8e5MEHHwTg0KFDLFq0iJMnT9K0aVOuvfZafHx8OHDgAF999RWTJk0iKyuLd955hxEjRrB06VJOnz5N8+bN6du3rzU52rt3L0uWLOHUqVM0a9YMPz8/iouLGTZsmLWtBx980Lo79xlms5kjR47Qs2dP67GQkBBMJhNHjx4lJCSklv51RERERC4uuxOLNWvW2Dw2mUykpaWRk5PDwIEDaySorKwsXnzxRYYPH87QoUM5fvy49Zy/v791d+W///3vPPPMM6SkpPDLL7/w5ZdfAjBo0CD+9a9/MXnyZEaNGsU333xDQUEBgwcPrpH4pEzXrl1ZsWIFO3fuJDIykoiICFq0aGFNEs747bffGDZsGK6urnzzzTd89NFH9O7dm169ejF37lyWLVvGyJEjyczMZPr06XTq1Ilhw4Zx+PBhFixYgIeHB23atCE5OZkFCxYwaNAgmjZtSnJyMt9++y33338/CQkJnDhxAijbrfqMzZs3M2zYMNzc3Pjxxx9ZunQpw4cPr/D5rFq1iuuvvx6LxcKMGTPYtGkTAwYM4NSpU8yYMYMePXoQFRXFli1bWLlyJR06dADKVkV7+OGHK9wjpbCwkNLSUpveG6PRiJubm3V3chEREZFLgd2JxRdffFHh8SlTptTY8IyVK1eSn5/P7NmzmT17ts25M3tXvPbaazzzzDPcdNNNBAUFMWXKFOuOxZ6enrz33ns8//zzfPfdd7Rp04b3339fm+PVsCuvvBI/Pz82btxIUlISmzZtwtnZmQEDBtCpUydruY4dO1qHSzVv3pzc3FxrL0T79u2tO7snJSURHBzMFVdcgaenJ4GBgZw4cYLExETatGnDunXriIuLs36g79OnDwcPHmT9+vX06dPHOqzIw8PDOsfiiiuuIDw8HCjryTqzJHFFevXqRdOmTQFo164dGRkZQFly0rRpU+scn6uuuor9+/db6zk4OFgTh7+u2FRaWgpgje0MR0dHrTwhIiIil5QqzbGoyO23386IESOYOHFitdsaOnQoQ4cOPW+ZgIAA3n333XOe79ixY7mkRGpe+/btad++Pfn5+ezbt4/169czZ84cGjVqRJMmTQDw9fW1lnd0dLQZLuTk5GT9gJ2ZmWn9YH9GSEgIGzduBODEiRM2Q4rOnD/TU1ERPz8/6++urq7WD/oXKuvi4oLZbAbg2LFj1udy9nX/ukpWRc6MS/zrdUtLS8slGyIiIiINmd0b5J3Lb7/9VmP7WEj9l5mZyZIlS6yP3d3dadeuHbfddhve3t4cOHDAes5otH2Znatnq6IP2mfvn1HRebPZbE0AKmJPL9q5Jif9Nf4zcVWGu7s7jo6ONkvEms1mCgoKqjW5XURERKS+sfsr0759+5b7sJaXl0d2djZPPfVUjQUm9ZvZbGbt2rW0b9/eOoEeyj6cOzo6VmnYWUBAgE1CApCeno6/vz9QNr8mPT3duroSwOHDhwkLCwOwTtSvaYGBgRw6dMjmWEZGhk1PzLkYDAaaNGnCoUOHrEOy0tLScHBwIDg4uMZjFREREakrdicWf91QzGAw4OTkRPv27a0fnOTS16hRIyIjI5k5cyZ9+vQhJCSEvLw8kpOTMZlMtGnTxu42O3fuzLp161i1ahVdunTh8OHDbNiwwToZu1u3bsyZM4fAwEDr5O2jR49yzTXXAGXDqo4fP87p06drtDcgNjaWNWvWsHr1alq3bs327ds5dOiQdeiUyWSioKAAd3f3CntIOnfuzPz58wkKCsLLy4v58+cTExODk5NTvd1FW0RERMRedicW6enp3H333dblRM/Izc3llVde4emnn66x4KR+Gz58OKtWrWLFihVkZ2fj7OxMREQEt912W5WGxfn4+DBy5EgWL15MUlIS3t7e9OvXzzoRPDo6mry8PJYvX05ubi7BwcGMHj3auiFb+/btmTlzJh9++CGPPPJIjT1PHx8fRowYwZIlS1i+fDkRERG0bt3aOkQqLS3tnMvNQtlE8OzsbObNm4fJZKJt27b07du3xuITERERqQ8qlVjs3bvXOkF22rRptG3bttwHqJ07d/LNN98osbiMODk50bt3b3r37n3OMuPGjbN5PGzYMJvHHTt2tK7mBWWrRo0aNQpPT88Kv/2Pi4sjLi6uwmuFhIRYEwqLxVJuZ+2zrxUeHs6kSZOAssnlZ34/o2fPnsTGxgJlk7e9vLxs9kH59ttvrW2f3da5eiCuuOIKrrjiigrPiYiIiFwKKpVYHDt2zGaTuoo2wXNzc7PZHVvkUpGVlcWcOXO4/vrr8ff3Z9++fezfv58+ffrUdWgiIiIi9UalEouEhAS2b98OlE3enjlzpnVCrcilrnXr1hw/fpw5c+aQl5dHQEAAw4cPp1GjRnUdmoiIiEi9Yfcci6VLl9ZGHFKPGQyGCpdcvZz06NGDHj161HUY9ZrRaKyxTTJFRESk4alUYtGvXz9mzpyJn59fhcvNnu3svQ3k0uDo6Ii3tzf5+fl1HYrUY76+vufcC0REREQufZVKLMaPH4+HhwdQfrlZufS5uLgQERHBsWPHzrsZnVy+AgICaNSokXosRERELmOVSiyGDx9e4e9yeXBwcCA8PBwXFxfS09PJy8sjPz8fNze3Gv8gabFYKCgoqHbb1W2nqvXtrWdP+Zq6NzXJwcEBf39/wsPD8fLyqutwREREpA7ZPcciJyeHjz/+mJSUFEpLS8str/n555/XWHBSf7i4uNCsWTMaN26M2Wy2fsCtDTXVdnXbqWp9e+vZU74277u9ziQ3jo6OODra/b8SERERucTY/WlgwoQJpKSkMGzYsBrd3VjqP4PBgIuLCyaTidTUVGJiYmp8TH1NtV3ddqpa39569pSvzfsuIiIiUl12JxarVq3iyy+/tNnUTERERERELm92ryEaHBx82S89KiIiIiIitqo0FOqFF17g4YcfJjw8HCcnJ5vzTZs2rbHgRERERESkYbA7sTiz3Oy9994L/DmB02KxYDAY2LZtWw2GJyIiIiIiDYHdiYU2wBMRERERkb+yO7E41/r5BoMBJycnTCaTVqwREREREbnM2J1YDBgwwLr78pk9LM5ONhwdHenfvz8vvfSSlqMVEREREblM2L280z//+U/Cw8P54IMPWL9+PevXr+fjjz+mZcuWPPbYY3z11VdkZmbyyiuv1Ea8IiIiIiJSD9mdWLz11ltMmTKFK6+8Ek9PTzw9PenevTsvvfQSX331FR07dmTixIksXry4NuIVEREREZF6yO7EIi8vD0fH8iOojEYjp0+fBsDT05OSkpLqRyciIiIiIg2C3YnFwIEDmTRpEmvXriU/P5+8vDzWrl3Ls88+S//+/SkoKOD999/XztwiIiIiIpcRuydvP/fcc7z00kvcfffdlJaWljXi6MiIESN46qmnWLlyJVu3buX//u//ajxYERERERGpn+xOLFxcXHj55ZeZNGkSe/fuxdHRkWbNmuHu7g5A//796d+/f40HKiIiIiIi9ZfdiQXAyZMn2bdvn3XZ2S1btlBcXExqaqp1R24REREREbl82J1YfPfdd7z44ouUlpZiMBhs9rLo2LGjEgsRERERkcuQ3ZO33333Xe6//36Sk5MJCAjg119/5ZdffiEqKooBAwbURowiIiIiIlLP2Z1YHDt2jOuvvx5nZ2fatWtHUlISLVu2ZNKkScyYMaM2YhQRERERkXrO7sTC39+fkydPAtCiRQu2bdsGQHBwMEePHq3Z6EREREREpEGwO7EYPHgwTz31FBs3bqRnz558//33LFiwgGnTphEeHl4bMYqIiIiISD1n9+TtJ598Ei8vL06dOkW/fv244YYbeP755/H19WXKlCm1EaOIiIiIiNRzdicWTk5OjB8/3vr4scce47HHHqvRoEREREREpGGpVGLx9ttvV7rBs5MOERERERG5PFQ6sTAajURFReHh4WHdu+KvDAZDjQYnIiIiIiINQ6USi+eff57FixeTlJREXFwc/fr1o1+/fvj7+9d2fCIiIiIi0gBUKrEYPXo0o0ePJjc3l99++41Fixbx+uuv07p1a/r378+AAQMICQmp7VhFRERERKSesmvytqenJ0OHDmXo0KEUFxezevVqlixZwqhRowgMDKR///6MGzeutmIVEREREZF6yu59LM5wdnamZ8+eDBs2jKFDh3Lw4EE++OCDmoxNREREREQaCLuXm83Ly2PFihUsXbqU5cuXA9C7d2+mTp3KlVdeWeMBioiIiIhI/VepxCIjI4MlS5awdOlS1q1bR3BwMH379uXNN9+kS5cuODg41HacIiIiIiJSj1UqsejTpw+Ojo7ExcXx1FNP0bp1a+u5jRs32pSNi4ur2QhFRERERKTeq1RiYbFYKCkpYdWqVaxateqc5QwGA9u2baux4EREREREpGGoVGKxffv22o5DREREREQasCqvCiUiIiIiInKGEgsREREREak2JRYiIiIiIlJtSixERERERKTalFiIiIiIiEi11dvEIicnh2eeeYYrrriChIQEnn76aXJycqznP/30U9q0aWPz8+qrr1rPr1q1imuuuYZOnToxZswYDh06VBdPQ0RERETkslBvE4vnn3+e7du38/777/PRRx+xZ88enn32Wev53bt3c8stt/D7779bf8aNGwfA4cOHGTduHCNGjGDmzJn4+/vz4IMPYrFY6urpiIiIiIhc0iq1j8XFlp+fz4IFC5g+fTrt27cHYNKkSdx6660UFRXh4uLCnj17uP766wkKCipXf8aMGbRv35677roLgKlTp9KjRw/Wrl1LfHz8RX0uIiIiIiKXg3rZY2E0Gnn33XeJioqyOW4ymcjLywNg7969NG/evML6mzdvpmvXrtbHbm5u/H979x4WVbX/D/w9MDCA4MEI0UTR9Eg3bqLgBQ5lFibeKvJIimn6VOSRLuKFwGMJokGWJ7LwUlmZZWQcn7SjeaROVkqpOQdEEDyKd4USbzMwMLN+f/hl/xwBBfbMbEber+eZ5xn22mvtz17Mcvyw19r73nvvxf79+60VMhERERFRh9Yur1i4uLjgL3/5i9m2jz/+GP7+/rjttttQVVWF6upq5OXlITk5GRqNBrGxsXj66aehUqlQWVmJrl27mtX38vLCmTNnWh2L0WiE0WiUdT7W0hCXreOz5nEt1bbcdtpav7X1WrO/Ur9ve2AvfaNEnPYwXi3RVlvqW7OOvXwmlWIP/cPvWOu1w+9Y+9KaPlEJhRYe1NTU4OzZs02WeXt7w83NTfp53bp1SE9Px5o1axAREYFffvkF8fHxmDFjBsaOHYuDBw8iPT0df/vb3zB16lSMGDECCQkJePzxx6U25s6dCycnJyxevLhF8RmNRl7hICIiIiICEBwcDEdHxxvuo9gVC61WiylTpjRZtmLFCowYMQIA8OmnnyI9PR3JycmIiIgAAISFhWH37t3o0qULAMDf3x9//PEHPvvsM0ydOhUajQYGg8GsTYPBgM6dO7c6znvuuQfOzs6trmcLRqMRhYWFCAgIuOkv2l6Oa6m25bbT1vqtrdea/ZX6fdsDe+kbJeK0h/FqibbaUt+adezlM6kUe+gffsdarx1+x9oXg8GA4uLiFu2rWGIRHh6O0tLSG+7z/vvvIzMzE3PnzsVTTz1lVtaQVDTo27evdAXEx8cHVVVVZuVVVVWN1my0hKOjY7v/gCkVozWPa6m25bbT1vqtrdea/e3hM6kUe+kbJeK0h/FqibbaUt+adezlM6kUe+gffsdarx1+x9qH1vRHu1y8DQB5eXnIzMxEcnIypk+fblaWm5uL6Ohos9vHHjx4EHfeeScAICgoCHv37pXK9Ho9iouLERQUZJvgiYiIiIg6mHaZWFRXV2PRokV49NFHERMTg8rKSullNBoxdOhQVFZW4vXXX0dFRQW2bNmC1atXY8aMGQCAxx9/HPv27cOqVatQVlaG5ORk+Pr68lazRERERERW0i7vCvXTTz9Bp9MhLy8PeXl5ZmU7duyAr68vVq1ahaysLHz22Wfw8vJCUlISRo0aBQDw9fVFdnY2MjIysGLFCoSEhGDFihVQqVRKnA4RERER0S2vXSYWMTExiImJueE+AwcOxIYNG5otj4qKQlRUlKVDIyIiIiKiJrTLqVBERERERGRfmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAiIiIiItmYWBARERERkWxMLIiIiIiISDYmFkREREREJBsTCyIiIiIiko2JBRERERERycbEgoiIiIiIZGNiQUREREREsjGxICIiIiIi2ZhYEBERERGRbEwsiIiIiIhINiYWREREREQkGxMLIiIiIiKSjYkFERERERHJxsSCiIiIiIhkY2JBRERERESyMbEgIiIiIiLZmFgQEREREZFsaqUDsGcmkwkGg0Gx4xuNRgBATU0NHB0db4njWqrtG7Xj5ORk0/4iIiIi6giYWLSRwWDAkSNHYDKZFItBCAG1Wo2KigqoVKpb4riWavtm7Xh6eqJbt2427TciIiKiWxkTizYQQuD06dNwdHREz5494eCgzIwyIQT0ej1cXV1tnlhY67iWaru5doQQ0Ol0OHfuHACge/fusmMmIiIiIiYWbVJfXw+dToc77rgDbm5uisUhhIDJZIKLi4vNEwtrHddSbd+oHVdXVwDAuXPn0LVrV06LIiIiIrIALt5ug4b5+87OzgpHQm3VkBDW1dUpHAkRERHRrYGJhQycn2+/+LsjIiIisiwmFh3MhQsXsHTpUgwfPhxBQUF45JFHsHbtWrNF6P7+/igoKFAwyqYVFBTA39+/2fLz589j1qxZCAkJwYMPPogtW7bYMDoiIiKijo1rLDqQ8+fP469//Su6du2KxYsXw9fXF4WFhUhLS8Px48exYMECpUOUJTk5GTU1NdiwYQO0Wi0WLVoEf39/BAUFKR0aERER0S2PiUUHsmzZMjg7O+P999+HRqMBAPTs2RMuLi54/vnnMXnyZPTp00fhKNvm2LFj+O6777Bjxw74+vriz3/+M/bs2YP169czsSAiIiKyAU6F6iAMBgO2bNmCSZMmSUlFgwceeABr165Fjx49pG179uzBmDFjEBAQgMmTJ+PkyZNSWX5+PuLi4hAYGIiBAwfi5ZdfxpUrVwAA2dnZmD17NhYuXIgBAwZgyJAhWL16tVQ3Pj4e7733HqZPn47AwEBER0dj586dUvnFixeRmpqK0NBQREREIC0tDTU1NTc9P61Wi+7du8PX11faFhwcjP3797e6r4iIiIio9ZhYWIgQAjpDvU1fQogWx3fs2DHodDoEBAQ0KlOpVBg8eLDZXa5yc3ORmpqKL7/8EhcuXMAbb7whtfPCCy/giSeewDfffIPly5fj559/xhdffCHV3bZtGzQaDfLy8jB9+nS88cYbOHLkiFSek5ODmJgYbN68GXfddRcWLFggrfFISUnB5cuXsX79erz77rsoLCzEokWLbnp+lZWV6Nq1q9k2Ly8vnD17tsV9RERERERtx6lQFiCEQGzOLuytOG/T4w7064K18YEt2vfixYsAAA8Pjxbtn5CQgPDwcABAbGwsPv/8cwCAyWRCSkoKxo4dCzc3N/Ts2RNDhw5FWVmZVNfT0xPz5s2Do6MjZsyYgdWrV6OoqEiaZhUVFYXHHntMOs64ceNQWVmJ2tpa7NixA9999x18fHygUqmQlpaG8ePHIzk5+Ybx6vX6Rrf/dXJygsFgaNH5EhEREZE8TCwspL3fvNTT0xPA1btCtUSvXr2k9x4eHqitrQUA9O7dG05OTlizZg2OHj2K8vJylJeXY9y4cdL+vr6+Zg+d69SpE+rr66Wfe/fuLb13d3cHcPWhg4cPH4bJZMLIkSPNbgdrMplQUVFxw3g1Gk2jJKKurg4uLi4tOl8iIiIikoeJhQWoVCrkPjcE+jqjTY/ronaAXq9v0b69evWCh4cHDhw4gMDAxlc5EhISEB8fj6FDhwIAHByaniVXUlKCuLg4REVFISwsDNOmTcNHH31kto+Tk1OjetdO22qu3Gg0wsPDA5988glcXV3NkgsfHx9otdpmz8/HxwdVVVVm26qqquDt7d1sHSIiIiKyHK6xsBCVSgU3Z7VNX615yJtarcaoUaPw6aefNvrLfn5+PvLz8xutUWjKpk2bMGjQICxevFhawF1RUdGq9R7N6dOnDy5dugSVSgU/Pz/4+fmhpqYGmZmZN53SFBwcjJMnT+LMmTPStv379/OOUEREREQ2wsSiA5k1axYuX76M6dOn45dffsGxY8eQm5uL+fPnY8qUKejXr99N2/D09ERpaSmKiopw5MgRLF26FIWFhRZZy9C3b19ERkYiJSUFhYWFOHDgAJKTk6HT6dC5c+cb1u3ZsyciIiIwZ84clJSU4Msvv8TWrVsxadIk2XERERER0c1xKlQH4u3tjc8++wzZ2dlISkpCdXU1evXqhcTERMTFxbWojfj4eBQXFyMhIQEajQaDBg3CzJkzLfaU68zMTLz66quYOnUq1Go1IiMjkZqa2uK6KSkpmDBhAry9vbFw4cImp30RERERkeUxsehgunfvjoyMjBvuU1paavbzY489Jt3Fyc3NDcuXL4dOp4Obm5s0HSsxMRHA1asi18vPz5fef/LJJ2Zlvr6+Zsfr0qULlixZYtZ2g/Dw8EaxXcvLyws5OTkA/u/2vzrdDc+TiIiIiCyHU6GIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRrt4nF77//jsTERISGhmLYsGHIyspCfX29VH7+/HnMmjULISEhGD58ODZt2mRWv7i4GE888QSCgoLw+OOPo6ioyNanQERERETUYbTbxCIpKQmXL1/Ghg0b8I9//ANbtmzBmjVrpPLk5GRcunQJGzZsQEJCAlJTU/Hf//4XAKDT6fDMM89g4MCB+OqrrxASEoJnn32Wtx8lIiIiIrKSdvkcC4PBAC8vL8yaNQt+fn4AgOjoaOzduxcAcOzYMXz33XfYsWMHfH190b9/f+zfvx/r169HYGAgvvnmG2g0GsydOxcqlQopKSn44YcfsHXrVul5DEREREREZDnt8oqFs7Mz3njjDSmpKCsrQ35+PsLCwgAAWq0W3bt3h6+vr1QnNDQUv/32m1QeGhoqPWBNpVJhwIAB2L9/v21PhIiIiIiog2iXicW1Jk+ejNGjR8PDwwOTJk0CAFRWVqJr165m+3l5eeHs2bM3LD9z5oxtgm7HLly4gKVLl2L48OEICgrCI488grVr18JkMkn7+Pv7o6CgQMEom1ZQUAB/f/+b7lddXY1hw4bh1KlTNoiKiIiIiAAFp0LV1NRIicD1vL294ebmBgBITU3FhQsXkJ6ejpdffhk5OTnQ6/VwdnY2q+Ps7AyDwQAANy1vDaPRCKPR2GibEEJ6KaXh2C2N4fz585g4cSK8vb2xePFi+Pr64r///S/S09Nx7NgxLFiwwKzt5tpt7XFb40Ztt+S4Fy5cwHPPPYfff//9hvs2nF9Tv18A0ramym6ktfVas39bY+oI7KVvlIjTmse0ZNty22pLfWvWsZfPpFLsoX+UitEexqwS47Ut9fgdaxmt6RPFEgutVospU6Y0WbZixQqMGDECAHDXXXcBADIyMhAbG4sTJ05Ao9E0ShIMBgNcXFwA4KblrVFcXNzkdrVaDb1eb/aXfqXo9foW7ZeZmQm1Wo3s7GxoNBoAwP333w+VSoWXX34ZsbGx0vSz2tramy52b+lx26KptmtrawGg2bh+++03/P3vf5eS0ubaaWirrq4OJSUlN4yjsLCwpSHLqtea/dsaU0dgL32jRJzWPKYl25bbVlvqW7OOvXwmlWIP/aNUjPYwZpUYr22px+9Y21EssQgPD0dpaWmTZZcvX8Y333yDkSNHwsHh6mytfv36Abj6V3cfHx9UVVWZ1amqqoK3tzcANFt+/fSolrjnnnsaXf2oqalBRUUFXF1d25SsWIoQAnq9Hq6urtJ6kuYYDAZs27YNc+fORZcuXczKRo4ciS5duqBv377SuRYVFSErKwsVFRUIDAzE66+/jh49egAAduzYgbfffhtHjhyBRqNBZGQk0tLS0KlTJ2RnZ6OiogLu7u74+uuvodFo8PTTT2PGjBkAgPj4eAwbNgy//vor9uzZg27duiE1NRWRkZEArl5xeO211/Cf//wHbm5uePjhhzFnzhy4uLhIydC1icO19uzZg9jYWIwaNQrR0dEA0GzfODg4wMnJCf369Wvyd2g0GlFYWIiAgAA4OjresG/l1GvN/m2NqSOwl75RIk5rHtOSbcttqy31rVnHXj6TSrGH/lEqRnsYs0qM17bU43esZRgMhmb/0H69dnlXKL1ej5deegndu3dHSEgIAODAgQNwdHREnz594OnpiZMnT+LMmTPo1q0bAGDv3r0IDg4GAAQFBWH16tUQQkClUkEIgX379uG5555rdSyOjo6NPmCOjo5QqVTSCwAgBFBn49vZql0BwDyOZhw/fhw6nQ4BAQGN9lWpVBgyZIjZttzcXLz++uvw9PREUlISli1bhrfeegvHjh3Diy++iHnz5uH+++9HRUUFkpKSkJubi2nTpkGlUmHbtm148sknkZeXh+3btyMrKwsjRoxAnz59oFKpkJOTg4ULF+LVV1/FsmXL8Pe//x35+flwcHBAamoqamtrsX79ehgMBqSnpyMtLQ0ZGRlmi/Gb8uKLLwIATpw4YXZuTe3fsL2p3++1blZuqXqt2b+tMXUE9tI3SsRpzWNasm25bbWlvjXr2MtnUin20D9KxWgPY1aJ8dqWevyOlac1/dEuEwtvb288/PDDSEtLQ3p6OnQ6HVJSUjB58mS4u7vD3d0dERERmDNnDlJSUlBYWIjNmzdj3bp1AK7+BX7ZsmVYvHgxJk6ciM8//xx6vR6PPPKIdQIWAvggGjhu4wXPPQcDf93Yol0vXrwIAPDw8GjR/gkJCQgPDwcAxMbG4vPPPwcAmEwmpKSkYOzYsXBzc0PPnj0xdOhQlJWVSXU9PT0xb948ODo6YsaMGVi9ejWKiorQp08fAEBUVJR029+EhASMGzcOlZWVqK2txY4dO/Ddd9/Bx8cHKpUKaWlpGD9+PJKTk1vWJ0RERESkiHaZWABX11RkZGRg2rRpAIDx48dj9uzZUnlmZiZSUlIwYcIEeHt7IyMjA4GBgQAAd3d3rFy5EgsXLsQXX3wBf39/rFq1qtkpNJZx4ysGSvP09ARwdapRS/Tq1Ut67+HhIa1v6N27N5ycnLBmzRocPXoU5eXlKC8vx7hx46T9fX19zbLbTp06mT01vXfv3tJ7d3d3AEB9fT0OHz4Mk8mEkSNHml1lMJlMqKioaPnJEhEREZHNtdvEwsPDA0uWLGm23MvLCzk5Oc2WBwYGIi8vzxqhNaZSAU9vVWYqVAsXUPfq1QseHh44cOCAlIBdKyEhAfHx8Rg6dCgASGtbrldSUoK4uDhERUUhLCwM06ZNw0cffWS2j5OTU6N6196dqblyo9EIDw8PfPLJJ43WRvj4+ECr1bboXImIiIjI9tr9cyzshkoFOHey7esm6yqupVarMWrUKHz66aeN7piVn5+P/Pz8Fi1u37RpEwYNGoTFixcjLi4OgYGBqKiosMitZ/v06YNLly5BpVLBz88Pfn5+qKmpQWZmZptuFUxEREREtsPEogOZNWsWLl++jOnTp+OXX37BsWPHkJubi/nz52PKlCnSnbduxNPTE6WlpSgqKsKRI0ewdOlSFBYWWuQ//n379kVkZKS0bubAgQNITk6GTqdD586dZbdPRERERNbTbqdCkeV5e3vjs88+Q3Z2NpKSklBdXY1evXohMTERcXFxLWojPj4excXFSEhIgEajwaBBgzBz5kxs2bLFIjFmZmbi1VdfxdSpU6FWqxEZGYnU1FSLtE1ERERE1sPEooPp3r07MjIybrjP9c8Xeeyxx6S7OLm5uWH58uXQ6XRwc3OT1kEkJiYCuHpV5Hr5+fnS+08++cSszNfX1+x4Xbp0wZIlS8zabnCjZ59c32ZJSclNH/BHRERERJbDqVBERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsZDBEg+FI2Xwd0dERERkWUws2sDR0REA+DRoO9ZwK1onJyeFIyEiIiK6NfA5Fm2gVqvh5uaGyspKODk5wcFBmfxMCIHa2lo4ODg0euaDvR7XUm03144QAjqdDufOnYOnp6eUJBIRERGRPEws2kClUqF79+44cuQIKioqFItDCIG6ujo4OTnZPLGw1nEt1fbN2vH09ES3bt3khEpERERE12Bi0UbOzs7485//rOh0KKPRiJKSEvTr18+mf3m35nEt1faN2nFycuKVCiIiIiILY2Ihg4ODA1xcXBQ7vtFoBAC4uLjYPLGw1nEt1bZSfUNERETUUXHxNhERERERycbEgoiIiIiIZGNiQUREREREsnGNRTMaHqBmNBql+frtTUNcto7Pmse1VNty22lr/dbWa83+Sv2+7YG99I0ScdrDeLVEW22pb8069vKZVIo99A+/Y63XDr9j7UtDn7Tk4cIqwUcQN8lgMKCwsFDpMIiIiIiIFBcQEABnZ+cb7sPEohkmkwn19fU2f/gcEREREVF7IYSAyWSCWq2+6UOhmVgQEREREZFsXLxNRERERESyMbEgIiIiIiLZmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUpZvv27fD39zd7JSYmAgCKi4vxxBNPICgoCI8//jiKiooUjtY2DAYDRo8ejYKCAmnb8ePHMXXqVAQHB2PUqFH48ccfzer8/PPPGD16NIKCgjBlyhQcP37c1mFb1dmzZ5GYmIiwsDBERkZiyZIlqK2tBcC+sSY543Pz5s0YMWIEgoKCMHPmTPzxxx9KnILFWWN8rl27FpGRkQgJCcErr7wCvV5vk3OxFGuOT3vvG2uz1hgVQuCNN97A4MGDERYWhszMTJhMJpueW1vZeozW1tbilVdewcCBAxEREYEPPvjAuidoDwSRQt59913x7LPPinPnzkmvCxcuiCtXrohhw4aJpUuXivLycpGWliaGDh0qrly5onTIVlVTUyNmzpwp+vfvL3bv3i2EEMJkMokxY8aI2bNni/LycpGTkyOCgoLEyZMnhRBCnDx5UgQHB4v3339fHDp0SLzwwgti9OjRwmQyKXkqFmMymcSECRPEjBkzxKFDh8Svv/4qHnroIbF06dIO3zfW1tbxqdVqRWBgoMjLyxMHDx4UkydPFs8884zCZyOfNcbn1q1bRWhoqMjPzxdarVaMGjVKvPbaa4qdY2tZc3zae9/YgrXG6Pvvvy+ioqLEr7/+Knbt2iUiIiLEmjVrlDrNFlNijC5atEiMGTNGFBUViW+//VaEhISIf/3rX7Y/+XaEiQUpZvbs2WLZsmWNtufm5orhw4dLA9tkMomHHnpIbNy40dYh2kxZWZkYO3asGDNmjNk/ij///LMIDg42S6qeeuop8fbbbwshhFi+fLmYPHmyVKbT6URISIhU396Vl5eL/v37i8rKSmnb119/LSIiIjp831hbW8fnnDlzxLx586T9T506Jfz9/cWxY8dsE7gVWGt8Pvnkk9K+Qgjx66+/isDAQKHT6WxxWrJZc3zae9/YgrXGaFRUlNn37T//+U/xwAMPWPNUZFNijF65ckUEBASYfaesWLHCrL2OiFOhSDGHDx9G7969G23XarUIDQ2FSqUCAKhUKgwYMAD79++3bYA29MsvvyA8PBwbNmww267VanHPPffAzc1N2hYaGir1hVarxcCBA6UyV1dX3HvvvbdMX3l7e2PNmjW4/fbbzbZfvny5w/eNtbV1fF7f7927d8cdd9wBrVZri7Ctwhrj02g0orCw0Kw8ODgYdXV1KCkpse4JWYi1xuet0De2YI0xevbsWZw+fRqDBg2SykNDQ3Hy5EmcO3fOqucjhxJjtKSkBPX19QgJCTFrW6vV2s3UMWtQKx0AdUxCCBw5cgQ//vgjVq5cCaPRiJEjRyIxMRGVlZXo16+f2f5eXl4oKytTKFrre/LJJ5vcXllZia5du5pt8/LywpkzZ1pUbu86d+6MyMhI6WeTyYR169Zh8ODBHb5vrEnO+Dx37twt1+/WGJ8XL15EbW2tWblarYanp6fd9JW1xuet0DfWZq0xWllZCQBm5Q2J45kzZxrVay+UGKMODg7o0qULnJ2dpfLbb78dtbW1qK6uxm233Wap07MrTCxIEadOnYJer4ezszOWL1+OEydOID09HTU1NdL2azk7O8NgMCgUrXJu1hcdra+ysrJQXFyML7/8EmvXrmXfWImc8VlTU9Nh+l3O+KypqZF+bq6+vbHU+LwV+8bSrDVGm+r7hvf22PfWHKNCiCbLAPvsK0thYkGK6NGjBwoKCvCnP/0JKpUKd999N0wmE+bMmYOwsLBGg9JgMMDFxUWhaJWj0WhQXV1ttu3avtBoNE32VefOnW0Vos1kZWXho48+wltvvYX+/fuzb6xIzvhsrt9dXV1tFr+tyPkMajQa6efry+2xryw5Pm+1vrEGa43Ra/9jfP3vwR773pqfQ6PR2GQZgA75/5UGXGNBivH09JTmgAJA3759UVtbC29vb1RVVZntW1VV1W4vwVqTj4/PDfuiuXJvb2+bxWgLaWlp+PDDD5GVlYXo6GgA7Btra+v47Ej9Lucz6OnpCY1GY1ZeX1+P6upqu+srS4/PW6lvrMkaY9THxwcApClR1763x7635ufQx8cH58+fR319vVReWVkJFxeXDv0HLCYWpIidO3ciPDzc7H7QBw8ehKenJ0JDQ/Hbb79BCAHg6lzSffv2ISgoSKlwFRMUFIQDBw5Il2QBYO/evVJfBAUFYe/evVKZXq9HcXHxLdVX77zzDj7//HO8+eabiImJkbazb6xHzvi8vt9Pnz6N06dP35L9Lucz6ODggICAALPy/fv3Q61W46677rLdSchkjfF5q/SNNVlrjPr4+OCOO+4wK9+7dy/uuOMOu/zjnjU/h3fffTfUarXZDUH27t2LgIAAODh04P9eK3U7KurYLl26JCIjI8XLL78sDh8+LL7//nsREREhVq1aJS5duiQGDx4s0tLSRFlZmUhLSxPDhg275Z9j0eDaW+XV19eLUaNGiRdffFEcOnRIrFy5UgQHB0v34D5+/LgICAgQK1eulO7BPWbMmFvmWQ3l5eXi7rvvFm+99ZbZvdrPnTvX4fvGmuSMz3379ol7771XfPHFF9I98p999lmFz8hyLDk+N2/eLAYMGCC2b98utFqtiImJEWlpaYqdW2tZc3zae99YmzXH6MqVK0VERITYvXu32L17t4iIiBAffPCBUqfaarYcowsWLBAxMTFCq9WK7du3iwEDBoht27bZ/qTbESYWpJhDhw6JqVOniuDgYDFs2DCRnZ0tDWatVivGjx8vAgICRGxsrDhw4IDC0drOtf8oCiHE0aNHxaRJk8R9990nYmJixE8//WS2//fffy8efvhhERgYKJ566im7fl7A9VauXCn69+/f5EuIjt031iZnfG7cuFFERUWJ4OBgMXPmTPHHH38ocQpWYenxuXLlSjFkyBARGhoqkpOTRU1NjU3OwxKsPT7tuW9swVpjtL6+XmRkZIiBAweK8PBwkZWVZVd/kLHlGNXpdGLu3LkiODhYREREiA8//NCq52YPVEL837UyIiIiIiKiNurAk8CIiIiIiMhSmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGRjYkFERERERLIxsSAi6gCGDx8Of3//Rq+4uDilQ1Pc5MmTsW/fvkbb58+fj/nz5zfafuLECfj7++PEiRO2CI+IyG6olQ6AiIhs45VXXsGoUaPMtjk5OSkUTfug1+tRVlaGwMBApUMhIrJ7TCyIiDoIDw8PeHt7Kx1Gu7Jnzx4EBwdDrebXIRGRXJwKRUREiI+PR1paGh588EHcf//9uHz5Mk6fPo3nnnsOQUFBGD58ON555x0YjUapzvbt2xEdHY3g4GC88sorSEpKQnZ2NoCmpxH5+/ujoKAAAGAwGJCeno7w8HCEh4cjKSkJ1dXVAP7/VKNvv/0WI0aMQEBAAJ599lmpHAB++OEHPProowgKCsLYsWOxa9cu1NTUYMCAAfj222+l/erq6hAeHo5du3Y1ed67du3CkCFD2txvBQUFTU4xS05ObnObRET2iokFEREBAL766itkZWXhnXfeQadOnfC3v/0NXl5eyMvLw5IlS/D1118jJycHAFBaWooXXngBEydOxMaNGyGEwNatW1t8rDfffBNFRUVYvXo1Pv74Y1y+fBkvvPCC2T45OTl48803sW7dOhQWFuLDDz8EAJSVlSEhIQEPPfQQNm3ahNGjR+P555/HpUuXMGLECGzbtk1q4+eff4ZarUZYWFiTcezevRuDBw9ubVdJQkJC8OOPP0qvrKwsODs7Y9KkSW1uk4jIXvHaLxFRB7Fw4UKkpaWZbfvpp5/g5uYGALj//vsxYMAAAFf/kn/q1Cnk5ubCwcEBd955J+bNm4fk5GTMnDkTX331FQYNGoRp06YBAF577TXs3LmzRXHo9XqsW7cOGzduhL+/PwAgMzMT4eHhKC0tRadOnQAAiYmJ0tqHMWPGoLCwEADw5ZdfYsCAAXj++ecBAM888wx0Oh0uXryImJgYvPTSS6itrYVGo8HWrVsxcuRIODo6NoqjuroaZ8+elWJoytdff22WqACAEEJ67+zsLE0vO3PmDDIyMjB//nzcd999LeoLIqJbCRMLIqIOIjExEQ8//LDZNldXV+l9jx49pPeHDx9GdXU1QkNDpW0mkwk1NTU4f/48/ve//+Huu++WypydnVv8n+njx4+jrq4OEydONNtuMplw9OhR3HvvvQAAPz8/qczd3R11dXUAgCNHjkj7NHjxxRelOs7Ozti5cyeioqLw73//W7rKcr2CggKEhYVBpVI1G+vw4cORlJRktu3s2bOIj48322YwGJCYmIihQ4fyagURdVhMLIiIOggvLy+z/6xfT6PRSO/r6+tx55134t133220n4eHB1xdXc3+cg9cTS4aqFQqs/L6+nrpfcM6jfXr10tXS66NsWEtRXN3rLrRQmu1Wo3o6Ghs27YNTk5OcHd3l67CXK8l6ys6derUqM+auvqxZMkSXLx4sdEVISKijoRrLIiIqJE+ffrg1KlTuO222+Dn5wc/Pz+cOHECb7/9NlQqFfr27StNTQKuTg8qLS2VfnZycsKVK1ekn48fPy6979mzJxwdHVFdXS217e7ujiVLluD333+/aWx+fn4oKSkx2zZx4kRs2bIFwNVpUz/88APy8/MxcuTIZq9IyF243WDTpk346quv8I9//EOaxkVE1BExsSAiokYiIiLQo0cPzJkzB6WlpdizZw8WLFgAV1dXODo6Ii4uDgcPHsS7776L//3vf8jMzMTRo0el+gEBAfjpp5+wa9cuHDp0CIsWLZKuQLi7u+OJJ57Aq6++ioKCApSXl2Pu3LmoqKiAr6/vTWOLi4vDnj178OGHH6KiogIrV65EWVkZBg4cCAAIDQ2Fq6sr8vLyEBMT02QbZ86cQV1dHXr27Cmrn0pLS7Fw4ULMmzcPt99+OyorK1FZWYk//vhDVrtERPaIiQURETXi6OiI9957DyaTCRMmTMCsWbMQFRWF1NRUAEDXrl3x3nvv4ZtvvsH48eNRXV2NkJAQqf64ceMQHR2N559/HjNmzMDo0aPRtWtXqXz+/PkYMmQIEhMTMWHCBKjVaqxatarJaUbX69WrF7Kzs7Fx40aMHj0a27ZtQ05ODnx8fABcnYY1cuRIdOvWrdl1H7t27ZJ1N6gG3377LfR6PV577TUMHToUERERiIiIQGxsrOy2iYjsjUpcP0mWiIioDeLj4xEWFoZZs2YpHQpmz54NPz8/JCYmKh0KEVGHwcXbRER0y9i/fz8OHDiAHTt2YPPmzUqHQ0TUoTCxICKiW8bOnTvxwQcf4KWXXmrReg0iIrIcToUiIiIiIiLZuHibiIiIiIhkY2JBRERERESyMbEgIiIiIiLZmFgQEREREZFsTCyIiIiIiEg2JhZERERERCQbEwsiIiIiIpKNiQUREREREcnGxIKIiIiIiGT7f2ZchR0KQsujAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -223,7 +231,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -233,7 +241,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -246,6 +254,9 @@ "# ========== Time signal ======================================================\n", "fig, ax = speech.plot_time()\n", "\n", + "# ========== Time signal dBSPL ================================================\n", + "fig, ax = speech.plot_spl(window_length_s=10e-3)\n", + "\n", "# ========== Magnitude spectrum ===============================================\n", "speech.plot_magnitude(\n", " range_hz=[20, 20e3],\n", From 62ada031cead3421425886ca257f3caf094034e2 Mon Sep 17 00:00:00 2001 From: nico-franco-gomez <80042895+nico-franco-gomez@users.noreply.github.com> Date: Mon, 5 Aug 2024 11:58:40 +0200 Subject: [PATCH 35/35] changelog and version number --- CHANGELOG.rst | 31 +++++++++++++++++++++++++++++++ dsptoolbox/__init__.py | 2 +- 2 files changed, 32 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 8acd2e2..a4da04d 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -14,6 +14,37 @@ adheres to `Semantic Versioning `_. - Validation for results from tests in every module (so far many tests are only regarding functionality) +`0.4.0 `_ - +--------------------- +Added +~~~~~~ +- `ImpulseResponse` as a subclass of `Signal`. It handles time windows, coherence + and plotting of those windows. Assertions for expected `ImpulseResponse` instead + of `Signal` were added as well +- new module ``tools`` for computations with primitive data types, added time + smoothing, interpolation of frequency response +- `get_transfer_function` in Filter and FilterBank +- analog-matched biquads in ``filterbanks`` +- `gaussian_kernel` approximation in ``filterbanks`` +- gain parameter functionality for some biquads +- new biquad types (lowpass and highpass first order, inverter) +- new explicit constructors for signal and filter +- pearson correlation as part quality estimator for latency computation +- new scaling parameter in synchrosqueezing of `cwt` +- new parameter in `window_frequency_dependent` + +Bugfix +~~~~~~ +- bugfix in `window_frequency_dependent` when querying a single frequency bin +- corrected plotting of spl when calibrated signal is passed + +Misc +~~~~~~~ +- got rid of signal type attribute. Use now `ImpulseResponse` +- general doc additions and fixes, type annotations +- `fractional_octave_smoothing` performance improved +- renamed some files of code base for consistency + `0.3.9 `_ - --------------------- Added diff --git a/dsptoolbox/__init__.py b/dsptoolbox/__init__.py index 571b0c4..7a2a848 100644 --- a/dsptoolbox/__init__.py +++ b/dsptoolbox/__init__.py @@ -73,4 +73,4 @@ "tools", ] -__version__ = "0.3.9" +__version__ = "0.4.0"