From c390760d3857a3d4c9d8ada2b55706984abd9576 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Fri, 27 Sep 2024 17:53:47 +0100 Subject: [PATCH 01/15] Added flag for mag corr when starting fitting --- ukat/mapping/t1.py | 96 +++++++++++++++++++++++------------ ukat/mapping/tests/test_t1.py | 59 ++++++++++++++------- 2 files changed, 104 insertions(+), 51 deletions(-) diff --git a/ukat/mapping/t1.py b/ukat/mapping/t1.py index 0fb63f4..4455da1 100644 --- a/ukat/mapping/t1.py +++ b/ukat/mapping/t1.py @@ -8,7 +8,7 @@ class T1Model(fitting.Model): def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, - tss_axis=-2, multithread=True): + tss_axis=-2, mag_corr=False, multithread=True): """ A class containing the T1 fitting model @@ -43,6 +43,15 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, would be along the TI axis and would be meaningless. If `pixel_array` is single slice (dimensions [x, y, TI]), then this should be set to None. + mag_corr : {True, False, 'auto'}, optional + Default False + If True, the data is assumed to have been magnitude corrected + using the complex component of the signal and thus negative + values represent inverted signal. If False, the data will be + fit to the modulus of the expected signal, negative values are + simply considered part of the noise in the data. If 'auto', + the data will be assumed to have been magnitude corrected if 5% + of the initial inversion time data is negative. multithread : bool, optional Default True If True, the fitting will be performed in parallel using all @@ -52,36 +61,46 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, self.tss = tss self.tss_axis = tss_axis - # Assume the data has been magnitude corrected if the first - # percentile of the first inversion time is negative. - if np.percentile(pixel_array[..., 0], 1) < 0: - self.mag_corr = True - neg_percent = (np.sum(pixel_array[..., 0] < 0) - / pixel_array[..., 0].size) - if neg_percent < 0.05: - warnings.warn('Fitting data to a magnitude corrected ' - 'inversion recovery curve however, less than 5% ' - 'of the data from the first inversion is ' - 'negative. If you have performed magnitude ' - 'correction ignore this warning, otherwise the ' - 'negative values could be due to noise or ' - 'preprocessing steps such as EPI distortion ' - 'correction and registration.\n' - f'Percentage of first inversion data that is ' - f'negative = {neg_percent:.2%}') + if mag_corr == 'auto': + # Find a very rough estimate of the fully recovered signal + recovered_signal = np.percentile(pixel_array[..., -1], 95) + + # If the fifth percentile of the first inversion time is + # less than the negative of 5% of the recovered signal + # then assume the data has been magnitude corrected + if np.percentile(pixel_array[..., 0], 5) < -recovered_signal * 0.05: + self.mag_corr = True + neg_percent = (np.sum(pixel_array[..., 0] < 0) + / pixel_array[..., 0].size) + if neg_percent < 0.05: + warnings.warn('Fitting data to a magnitude corrected ' + 'inversion recovery curve however, less ' + 'than 5% of the data from the first ' + 'inversion is negative. If you have ' + 'performed magnitude correction ignore ' + 'this warning, otherwise the negative ' + 'values could be due to noise or ' + 'preprocessing steps such as EPI ' + 'distortion correction and registration.\n' + f'Percentage of first inversion data that ' + f'is negative = {neg_percent:.2%}') + else: + self.mag_corr = False + if np.nanmin(pixel_array) < 0: + warnings.warn('Negative values found in data from the ' + 'first inversion but as the first ' + 'percentile is not negative, it is assumed ' + 'these are negative due to noise or ' + 'preprocessing steps such as EPI ' + 'distortion correction and registration. ' + 'As such the data will be fit to the ' + 'modulus of the recovery curve.\n' + f'Min value = ' + f'{np.nanmin(pixel_array[..., 0])}\n' + '5th percentile = ' + f'{np.percentile(pixel_array[..., 0], 5)}') else: - self.mag_corr = False - if np.nanmin(pixel_array) < 0: - warnings.warn('Negative values found in data from the first ' - 'inversion but as the first percentile is not ' - 'negative, it is assumed these are negative ' - 'due to noise or preprocessing steps such as ' - 'EPI distortion correction and registration. ' - 'As such the data will be fit to the modulus of ' - 'the recovery curve.\n' - f'Min value = {np.nanmin(pixel_array[..., 0])}\n' - '1st percentile = ' - f'{np.percentile(pixel_array[..., 0], 1)}') + self.mag_corr = mag_corr if self.parameters == 2: if self.mag_corr: @@ -149,7 +168,8 @@ class T1: """ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, - mask=None, parameters=2, molli=False, multithread=True): + mask=None, parameters=2, mag_corr=False, molli=False, + multithread=True): """Initialise a T1 class instance. Parameters @@ -186,6 +206,15 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, The number of parameters to fit the data to. A two parameter fit will estimate S0 and T1 while a three parameter fit will also estimate the inversion efficiency. + mag_corr : {True, False, 'auto'}, optional + Default False + If True, the data is assumed to have been magnitude corrected + using the complex component of the signal and thus negative + values represent inverted signal. If False, the data will be + fit to the modulus of the expected signal, negative values are + simply considered part of the noise in the data. If 'auto', + the data will be assumed to have been magnitude corrected if 5% + of the initial inversion time data is negative. molli : bool, optional Default False. Apply MOLLI corrections to T1. @@ -229,6 +258,7 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, self.tss_axis = None self.tss = 0 self.parameters = parameters + self.mag_corr = mag_corr self.molli = molli if multithread == 'auto': if self.n_vox > 20: @@ -256,7 +286,9 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, # Fit Data self.fitting_model = T1Model(self.pixel_array, self.inversion_list, self.parameters, self.mask, self.tss, - self.tss_axis, self.multithread) + self.tss_axis, self.mag_corr, + self.multithread) + self.mag_corr = self.fitting_model.mag_corr popt, error, r2 = fitting.fit_image(self.fitting_model) self.t1_map = popt[0] self.m0_map = popt[1] diff --git a/ukat/mapping/tests/test_t1.py b/ukat/mapping/tests/test_t1.py index 4b8c9a3..dc52a06 100644 --- a/ukat/mapping/tests/test_t1.py +++ b/ukat/mapping/tests/test_t1.py @@ -94,7 +94,8 @@ def test_two_param_fit(self): signal_array = np.tile(self.correct_signal_two_param, (10, 10, 3, 1)) # Multithread - mapper = T1(signal_array, self.t, self.affine, multithread=True) + mapper = T1(signal_array, self.t, self.affine, + mag_corr=True, multithread=True) assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) @@ -102,7 +103,8 @@ def test_two_param_fit(self): npt.assert_almost_equal(mapper.r2.mean(), 1) # Single Threaded - mapper = T1(signal_array, self.t, self.affine, multithread=False) + mapper = T1(signal_array, self.t, self.affine, mag_corr=True, + multithread=False) assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) @@ -110,7 +112,8 @@ def test_two_param_fit(self): npt.assert_almost_equal(mapper.r2.mean(), 1) # Auto Threaded - mapper = T1(signal_array, self.t, self.affine, multithread='auto') + mapper = T1(signal_array, self.t, self.affine, mag_corr=True, + multithread='auto') assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) @@ -123,7 +126,7 @@ def test_three_param_fit(self): # Multithread mapper = T1(signal_array, self.t, self.affine, parameters=3, - multithread=True) + mag_corr=True, multithread=True) assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) @@ -133,7 +136,7 @@ def test_three_param_fit(self): # Single Threaded mapper = T1(signal_array, self.t, self.affine, parameters=3, - multithread=False) + mag_corr=True, multithread=False) assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) @@ -144,7 +147,7 @@ def test_three_param_fit(self): def test_tss(self): mapper = T1(self.correct_signal_two_param_tss, self.t, self.affine, - tss=10) + tss=10, mag_corr=True) assert mapper.shape == self.correct_signal_two_param_tss.shape[:-1] npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) @@ -153,7 +156,8 @@ def test_tss(self): def test_tss_axis(self): signal_array = np.swapaxes(self.correct_signal_two_param_tss, 0, 1) - mapper = T1(signal_array, self.t, self.affine, tss=10, tss_axis=0) + mapper = T1(signal_array, self.t, self.affine, tss=10, tss_axis=0, + mag_corr=True) npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) npt.assert_almost_equal(mapper.r1_map().mean(), 1 / self.t1) @@ -165,7 +169,7 @@ def test_failed_fit(self): # Fail to fit using the 2 parameter equation mapper_two_param = T1(signal_array, self.t, self.affine, - parameters=2, multithread=True) + parameters=2, mag_corr=True, multithread=True) assert mapper_two_param.shape == signal_array.shape[:-1] # Voxels that fail to fit are set to zero npt.assert_equal(mapper_two_param.t1_map.mean(), 0) @@ -176,7 +180,7 @@ def test_failed_fit(self): # Fail to fit using the 3 parameter equation mapper_three_param = T1(signal_array, self.t, self.affine, - parameters=3, multithread=True) + parameters=3, mag_corr=True, multithread=True) assert mapper_three_param.shape == signal_array.shape[:-1] # Voxels that fail to fit are set to zero npt.assert_equal(mapper_three_param.t1_map.mean(), 0) @@ -191,7 +195,8 @@ def test_mask(self): # Bool mask mask = np.ones(signal_array.shape[:-1], dtype=bool) mask[:5, ...] = False - mapper = T1(signal_array, self.t, self.affine, mask=mask) + mapper = T1(signal_array, self.t, self.affine, mask=mask, + mag_corr=True) assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map[5:, ...].mean(), self.t1) npt.assert_equal(mapper.t1_map[:5, ...].mean(), 0) @@ -199,7 +204,8 @@ def test_mask(self): # Int mask mask = np.ones(signal_array.shape[:-1]) mask[:5, ...] = 0 - mapper = T1(signal_array, self.t, self.affine, mask=mask) + mapper = T1(signal_array, self.t, self.affine, mask=mask, + mag_corr=True) assert mapper.shape == signal_array.shape[:-1] npt.assert_almost_equal(mapper.t1_map[5:, ...].mean(), self.t1) npt.assert_equal(mapper.t1_map[:5, ...].mean(), 0) @@ -262,7 +268,7 @@ def test_tss_valid_axis(self): inversion_list=np.linspace(0, 2000, 10), affine=self.affine, tss=1, tss_axis=2) - def test_mag_corr_warning(self): + def test_auto_mag_corr(self): # Test warning for small number of negative values thus assuming no # magnitude correction has been performed @@ -270,10 +276,11 @@ def test_mag_corr_warning(self): signal_array = np.tile(np.abs(self.correct_signal_two_param), (10, 10, 3, 1)) # Add a single negative value to the signal - signal_array[0, 0, 0, 0] = -1 + signal_array[0, 0, 0, 0] = -1000 with pytest.warns(UserWarning): - mapper = T1(signal_array, self.t, self.affine, multithread=False) + mapper = T1(signal_array, self.t, self.affine, + mag_corr='auto', multithread=False) # Test warning for enough negative values to assume magnitude # correction has been performed but still not that many negative values @@ -286,7 +293,22 @@ def test_mag_corr_warning(self): signal_array[:, 0, 0, :] = self.correct_signal_two_param with pytest.warns(UserWarning): - mapper = T1(signal_array, self.t, self.affine, multithread=False) + mapper = T1(signal_array, self.t, self.affine, + mag_corr='auto', multithread=False) + + # Test that giving abs data leads to mag_corr = False + signal_array = np.tile(np.abs(self.correct_signal_two_param), + (10, 10, 3, 1)) + mapper = T1(signal_array, self.t, self.affine, mag_corr='auto', + multithread=False) + assert mapper.mag_corr is False + + # Test that giving mag corrected data leads to mag_corr = True + signal_array = np.tile(self.correct_signal_two_param, + (10, 10, 3, 1)) + mapper = T1(signal_array, self.t, self.affine, mag_corr='auto', + multithread=False) + assert mapper.mag_corr is True def test_molli_2p_warning(self): @@ -404,7 +426,8 @@ def test_get_fit_signal(self): # Two parameter fit signal_array = np.tile(self.correct_signal_two_param, (10, 10, 3, 1)) - mapper = T1(signal_array, self.t, self.affine, multithread=False) + mapper = T1(signal_array, self.t, self.affine, mag_corr=True, + multithread=False) fit_signal = mapper.get_fit_signal() npt.assert_array_almost_equal(fit_signal, signal_array) @@ -412,7 +435,7 @@ def test_get_fit_signal(self): signal_array = np.tile(self.correct_signal_three_param, (10, 10, 3, 1)) mapper = T1(signal_array, self.t, self.affine, - parameters=3, multithread=False) + parameters=3, mag_corr=True, multithread=False) fit_signal = mapper.get_fit_signal() npt.assert_array_almost_equal(fit_signal, signal_array) @@ -421,8 +444,6 @@ def test_get_fit_signal(self): image_molli = image_molli[70:90, 100:120, :2, :] ti_molli *= 1000 - signal_array = np.tile(self.correct_signal_three_param, (10, 10, 3, 1)) - mapper = T1(image_molli, ti_molli, affine_molli, parameters=3, molli=True, multithread=False) fit_signal = mapper.get_fit_signal() From 1d0e5ed7b66a8986309d40de23d55b2f445d5c6f Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Mon, 30 Sep 2024 13:33:51 +0100 Subject: [PATCH 02/15] Improved tests and error handling --- ukat/mapping/t1.py | 13 ++++++++----- ukat/mapping/tests/test_t1.py | 28 ++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 5 deletions(-) diff --git a/ukat/mapping/t1.py b/ukat/mapping/t1.py index 4455da1..a95748e 100644 --- a/ukat/mapping/t1.py +++ b/ukat/mapping/t1.py @@ -231,11 +231,14 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, 'auto' attempts to apply multithreading where appropriate based on the number of voxels being fit. """ - assert multithread is True \ - or multithread is False \ - or multithread == 'auto', f'multithreaded must be True,' \ - f'False or auto. You entered ' \ - f'{multithread}' + assert multithread in [True, False, + 'auto'], \ + (f'multithreaded must be True, False or auto. ' + f'You entered {multithread}') + assert mag_corr in [True, False, + 'auto'], \ + (f'mag_corr must be True, False or auto. ' + f'You entered {mag_corr}') self.pixel_array = pixel_array self.shape = pixel_array.shape[:-1] diff --git a/ukat/mapping/tests/test_t1.py b/ukat/mapping/tests/test_t1.py index dc52a06..9ffc4a5 100644 --- a/ukat/mapping/tests/test_t1.py +++ b/ukat/mapping/tests/test_t1.py @@ -268,6 +268,34 @@ def test_tss_valid_axis(self): inversion_list=np.linspace(0, 2000, 10), affine=self.affine, tss=1, tss_axis=2) + def test_mag_corr_options(self): + # Test that the mag_corr option can be set to True, False, auto is + # checked more thoroughly in the next test + signal_array = np.tile(self.correct_signal_two_param, (10, 10, 3, 1)) + + # Test that mag_corr = True + mapper = T1(signal_array, self.t, self.affine, mag_corr=True, + multithread=False) + npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) + npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) + npt.assert_almost_equal(mapper.r1_map().mean(), 1 / self.t1) + npt.assert_almost_equal(mapper.r2.mean(), 1) + + # Test that mag_corr = False + mapper = T1(np.abs(signal_array), self.t, self.affine, mag_corr=False, + multithread=False) + npt.assert_almost_equal(mapper.t1_map.mean(), self.t1) + npt.assert_almost_equal(mapper.m0_map.mean(), self.m0) + npt.assert_almost_equal(mapper.r1_map().mean(), 1 / self.t1) + npt.assert_almost_equal(mapper.r2.mean(), 1) + + # Test with mag_corr not recognised input + with pytest.raises(AssertionError): + mapper = T1(signal_array, self.t, self.affine, + mag_corr='yes please', + multithread=False) + + def test_auto_mag_corr(self): # Test warning for small number of negative values thus assuming no # magnitude correction has been performed From eddb1e4849d9960449505f20fe7d43f4c7f1b76d Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Mon, 30 Sep 2024 13:34:07 +0100 Subject: [PATCH 03/15] Added mag_corr flag to notebook --- tutorials/t1_calculation.ipynb | 209 ++++++++++++++++++--------------- 1 file changed, 116 insertions(+), 93 deletions(-) diff --git a/tutorials/t1_calculation.ipynb b/tutorials/t1_calculation.ipynb index 4661d84..be03d4c 100644 --- a/tutorials/t1_calculation.ipynb +++ b/tutorials/t1_calculation.ipynb @@ -21,13 +21,15 @@ }, { "cell_type": "code", - "execution_count": 1, "metadata": { "pycharm": { "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:21:37.375947Z", + "start_time": "2024-09-30T12:21:37.359957Z" } }, - "outputs": [], "source": [ "import os\n", "import numpy as np\n", @@ -39,7 +41,9 @@ "\n", "# Ensure figures are rendered in the notebook\n", "%matplotlib inline" - ] + ], + "outputs": [], + "execution_count": 3 }, { "cell_type": "markdown", @@ -49,16 +53,21 @@ ] }, { + "metadata": { + "ExecuteTime": { + "end_time": "2024-09-30T12:21:37.406020Z", + "start_time": "2024-09-30T12:21:37.393938Z" + } + }, "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], "source": [ "# Initialise output path for T1 maps\n", "directory = 't1_calculation_output'\n", "os.makedirs(directory, exist_ok=True)\n", "OUTPUT_DIR = os.path.join(os.getcwd(), directory)" - ] + ], + "outputs": [], + "execution_count": 4 }, { "cell_type": "markdown", @@ -77,13 +86,15 @@ }, { "cell_type": "code", - "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:21:38.066183Z", + "start_time": "2024-09-30T12:21:37.500131Z" } }, - "outputs": [], "source": [ "# Fetch test data\n", "magnitude, phase, affine, ti, tss = fetch.t1_philips(2)\n", @@ -92,7 +103,9 @@ "complex_data = magnitude * (np.cos(phase) + 1j * np.sin(phase)) # convert magnitude and phase into complex data\n", "ti = np.array(ti) * 1000 # convert TIs to ms\n", "tss *= 1000 # convert tss into ms" - ] + ], + "outputs": [], + "execution_count": 5 }, { "cell_type": "markdown", @@ -108,56 +121,61 @@ }, { "cell_type": "code", - "execution_count": 4, "metadata": { "pycharm": { "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:21:39.640913Z", + "start_time": "2024-09-30T12:21:38.144139Z" } }, + "source": [ + "raw_signal = magnitude[55, 40, 2, :]\n", + "magnitude_corrected = magnitude_correct(complex_data)\n", + "magnitude_corrected_signal = magnitude_corrected[55, 40, 2, :]\n", + "\n", + "plt.plot(ti, raw_signal, label='Raw Signal')\n", + "plt.plot(ti, magnitude_corrected_signal, label='Magnitude Corrected')\n", + "plt.xlabel('Inversion Time (ms)')\n", + "plt.ylabel('Signal (AU)')\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ], "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:483: RuntimeWarning: invalid value encountered in true_divide\n", - " / np.abs(pixel_array[..., -1])\n", - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:485: RuntimeWarning: invalid value encountered in true_divide\n", + "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:585: RuntimeWarning: invalid value encountered in divide\n", + " pixel_array_prime[..., ti] = (pixel_array[..., ti] *\n", + "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:589: RuntimeWarning: invalid value encountered in divide\n", " phase_factor = np.imag(np.log(pixel_array_prime / np.abs(pixel_array)))\n", - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:485: RuntimeWarning: invalid value encountered in log\n", + "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:589: RuntimeWarning: invalid value encountered in log\n", " phase_factor = np.imag(np.log(pixel_array_prime / np.abs(pixel_array)))\n" ] }, { "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" + "text/plain": [ + "
" + ], + "image/png": "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" }, + "metadata": {}, "output_type": "display_data" } ], - "source": [ - "raw_signal = magnitude[55, 40, 2, :]\n", - "magnitude_corrected = magnitude_correct(complex_data)\n", - "magnitude_corrected_signal = magnitude_corrected[55, 40, 2, :]\n", - "\n", - "plt.plot(ti, raw_signal, label='Raw Signal')\n", - "plt.plot(ti, magnitude_corrected_signal, label='Magnitude Corrected')\n", - "plt.xlabel('Inversion Time (ms)')\n", - "plt.ylabel('Signal (AU)')\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.show()" - ] + "execution_count": 6 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The dynamic range of this voxel has been doubled by magnitude correcting the data. This can be used to increase the accuracy\n", - " of our T1 maps and simplifies the equation the data is fit to by removing the absolute term.\n", + " of our T1 maps and simplifies the equation the data is fit to by removing the absolute term. If the data has been magnitude\n", + " corrected, don't forget to set `mag_corr=True` when creating the `T1` object.\n", " \n", "Now compute the T1 maps using the `T1` class implemented in `mapping`. By default this is executed over all available CPU cores\n", "however this can be run single-threaded by setting `multithread=False` although will obviously take much longer.\n", @@ -167,29 +185,23 @@ }, { "cell_type": "code", - "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:24:36.773680Z", + "start_time": "2024-09-30T12:21:39.720869Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 20455/20455 [01:52<00:00, 181.09it/s]\n", - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:294: RuntimeWarning: divide by zero encountered in reciprocal\n", - " return np.nan_to_num(np.reciprocal(self.t1_map), posinf=0, neginf=0)\n" - ] - } - ], "source": [ - "mapper = T1(magnitude_corrected[32:-32, 32:-32, :, :], ti, affine=affine, parameters=2, tss=tss)\n", + "mapper = T1(magnitude_corrected[32:-32, 32:-32, :, :], ti, affine=affine, parameters=2, tss=tss, mag_corr=True)\n", "\n", "# Save output maps to Nifti\n", "mapper.to_nifti(output_directory=OUTPUT_DIR, base_file_name='Philips2', maps='all')" - ] + ], + "outputs": [], + "execution_count": 7 }, { "cell_type": "markdown", @@ -200,24 +212,15 @@ }, { "cell_type": "code", - "execution_count": 6, "metadata": { "pycharm": { "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:24:37.774711Z", + "start_time": "2024-09-30T12:24:36.868686Z" } }, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "fig, ax1 = plt.subplots()\n", "\n", @@ -228,7 +231,20 @@ "ax1.axis('off')\n", "\n", "plt.show()" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfUAAAGTCAYAAAAx5YtWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABx4ElEQVR4nO29eZxU1Z3+/1TX2mv1Rm/QbIqKNqKAsmgENxZFRolBgyE6cdCJW/yqk8kyGZiZjM5kUWdkkvFnjBrBMTOJ20TTClFBBkEEWwWRRbYGeoFeqrfqrvX3B7FJ5zxHu7qvNLbPO696RZ769Lm37lKn7rnPea4rmUwmIYQQQojPPWkDvQJCCCGEcAZ16kIIIcQgQZ26EEIIMUhQpy6EEEIMEtSpCyGEEIMEdepCCCHEIEGduhBCCDFIUKcuhBBCDBLUqQshhBCDBHXqQgghxCBBnboQQojPNffddx/OOeccZGdno6ioCFdeeSW2b9/e/X40GsXf/u3fYty4ccjMzERZWRm+/vWv49ChQz3amTFjBlwuV4/Xtdde26OmqakJixYtQjAYRDAYxKJFi9Dc3Hw8PmavUKcuhBDic83q1atx6623Yv369Vi5ciVisRhmzpyJ9vZ2AEBHRwc2b96MH/zgB9i8eTOeeeYZ7NixA/PmzTPaWrx4MWpqarpfDz/8cI/3Fy5ciKqqKlRWVqKyshJVVVVYtGjRcfmcvcGlB7oIIYQYTBw+fBhFRUVYvXo1LrjgAlqzceNGnHvuudi3bx+GDx8O4OiV+llnnYUHH3yQ/s22bdtw+umnY/369Zg8eTIAYP369Zg6dSo+/PBDnHrqqZ/J50kFz0CvgBBCiMFBZ2cnIpGII20lk0m4XK4emt/vh9/v/9S/DYVCAID8/PxPrHG5XMjNze2hr1ixAsuXL0dxcTHmzJmDJUuWIDs7GwDw5ptvIhgMdnfoADBlyhQEg0GsW7fu89WpfzXvDqpneFxUZ2q+nw8KNHbxNrK9fF0SKYwtBNy8uCnCl9ka5fWdcVP3p/E2fG6uB9xUprRE+Hq4LTdMvC6+TFs9qy6w7J8Cf4zqQ/z85D19SC3Vc7LaDG3rgeG0NkHXEHC7ElSPJ80P2tAZoLWbGrnutWyr/6z/D/5GCsQST1D9tOz/pvpVuSMMrSTA90PAHad6pofXt8f4aZ/jjZptePk+bo/6qB5P8v22uy3D0Ar85vIAIEjWAwCGpLdTPcvfRXUP2S5Jy/rZSFjq01y9/xKytRG17Afbtq1uyzY02z4emt1C9UvW/w/VnaCzsxOjRpWgtjbkSHtZWVloa+v5nbFkyRIsXbr0E/8umUzirrvuwvnnn4+Kigrrun7nO9/BwoULkZOT061fd911GDVqFEpKSrBlyxZ897vfxbvvvouVK1cCAGpra1FUVGS0V1RUhNpa/r13vNGVuhBCiH4TiURQWxvC7n0PICcnvV9ttbSEMXrE/0N1dXWPTrc3V+m33XYb3nvvPaxdu5a+H41Gce211yKRSOBnP/tZj/cWL17c/d8VFRUYM2YMJk2ahM2bN2PChAkAYIweAHxUYaBQpy6EEMIxcnLS+92pH2srp0en/mncfvvteOGFF7BmzRoMGzbMeD8ajWLBggXYs2cPXn311U9te8KECfB6vdi5cycmTJiAkpIS1NXVGXWHDx9GcXFxr9fzs0TudyGEEI6RTMYceaW2zCRuu+02PPPMM3j11VcxatQoo+bjDn3nzp1YtWoVCgoKPrXdrVu3IhqNorS0FAAwdepUhEIhvPXWW901GzZsQCgUwrRp01Ja588KXakLIYRwjGQyjmSS+zxSaSMVbr31Vjz11FN4/vnnkZ2d3X1/OxgMIj09HbFYDFdffTU2b96M3/3ud4jH4901+fn58Pl8+Oijj7BixQpcdtllKCwsxAcffIC7774bZ599Ns477zwAwNixYzF79mwsXry4e6rbTTfdhLlz554QJjkghSltNxR8i+oey7W+n5jCAml8UTGLkWRIgO/Y5oi50GaL8a0snRurWmN8xWvDfB2JTw45Xr7MNovZzmagyyGGwP3t/LOnWe7b5NhcXhZYtc9i5BuWwddlTLZpfAOALB83VwWIqWd7E3entsf4yrD9AADDM8OkDf6btbaTG5H+bs9UqnvSrucLdYBbim+leqHfPG79afxYZp8dAAJufrVT38mHRqMJ86gosJjQ+JoAkTjfb61kXwzN6KC1+elc93u4gc5mfuuKmSeWy2Jw86TxY9xt2eZWnRg5bctMEHPnUZ1/ngjZhvXtpnkOAJoj/Bi/adsjVHeClpYWBINB1Df8myP31IsKvoVQKNSr4Xfb/ezHHnsMN9xwA/bu3Uuv3gHgtddew4wZM1BdXY2vfe1r2LJlC9ra2lBeXo7LL78cS5Ys6eGib2xsxB133IEXXngBADBv3jwsW7bMcNEPFLpSF0II4RiJZAyJFIfPWRup8GnXpiNHjvzUmvLycqxevfpTl5Wfn4/ly5entH7HE3XqQgghHKMv98RZG6JvyCgnhBBCDBJ0pS6EEMIxjhrl+nul3j+j3RcZdepCCCEcI5mIIZnoZ6fez7//ItPrTt3mdrVZD1iUq83lXmyJv8z08KWGiXO9M8UfdraoWRYHCwABi3Od4bHEx9razvOZ9WOy+Z2Rj9p4GxFL2+mWGF9WHrFsw4Yu7mg+Pcj3z4jCeqrvqC0ztOoO7tK1HVe2GRTMuV1ncbnfvfow1T9Ll7uNw5388wzLMLdtrpefJ7Zzs524vwGgi2wrgLvIPRaXt21mgdvi9GZO90JL7Gumv5PqkThfZtzyeZijPdU2bC53n2VmQZrH/Pwuy9Fs023b0EdmjwwLNtHaoGWGw3EhGTv66m8bok/onroQQggxSNDwuxBCCMeQ+31gUacuhBDCORIxIMGDglJqQ/QJDb8LIYQQg4ReX6mn2vszI5bN/FTbyVejy2LcYj60sgzeekk6jyzd286fqW1bxzD5QBY/nJWoxZ3HDIRn5PLoT4AbYBosz6T3WXZcW8xcF5vXsCXK297ZyiMqCzKCVM9NNz/TOZZnKmRb4kk3Hh5C9T1t5nb59td+w9seyY1yA0FpuiUSNNH7g6s2zI/liMX8VRvmxscDHaYp7ORsHtF5Sg4/PjMtz0L3kWebJ9D7eNdP0uOWbcWSQ221Scu62IhYvjqpsc5yDtriYFnULMCNf7aI3KAlavd4cHT43ZI5nUIbom9o+F0IIYRzJGJAon+duobf+46G34UQQohBgq7UhRBCOIeu1AcUdepCCCEcJO5AeIxiYvuKht+FEEKIQUKvr9Q9lu4/YBllYamqliRTHLFEZRKD9h/bMd84KYv/srN5Wlui3GGaZ7GLN0fMelvsq8uyVFvUbAP5/NtCGbT2jCB3tbZaYjs/auVRqXHy8Zlb+JOIW5y38WTvYzvHlh2gtS5LVOaIolqqj/nfm4g6hdbivuMfB2vjkjLuxF9XX2hoO1q5y73IErO8v52fnC0Rvm1Pzjb350etvHZ/O5+FcWEx3/e5pJmAmzvl4wl+zNoiW+1nuYnXzduwOdHTLMehzXUejprrbouUTTWa1kNmENic8rYI2uOBKxGDy/LZUmlD9A0NvwshhHCORAzoZ6eue+p9R526EEII51CnPqDonroQQggxSNCVuhBCCMdwJWNwWXw1qbQh+oY6dSGEEM6RSACJfk5JS9hMkeLT6HWnbnO5B9w2d6ipdca5Y9RjCVF3WxycHeRH3JZmngud4+N6MTcSI8vDl5njNX951oV5rc3l3hrjB2oHsaJ3tvFfupkevuJRS6Z1k8XpzJzulgkB1sx62/60OYOHDqk3tNa2LFrb1snd1QU5Iap70k4cR3sqXPb25VQPjfuDoQ3N5p/dtk3CnfxYae3i27a6xczsz/XxNmrD/Ph884jt+PQb2jdP5+ttc6K3R8w2ALsD3O/p/ZPCbMesTbfBZm3E4vzL05Z9n7ScV6ztNMv370C638XAoit1IYQQjnF0SluK82NJG6JvqFMXQgjhHIm4A+53Jcr1FbnfhRBCiEGCrtSFEEI4RyIG9HP4XfPU+446dSGEEI7hSsQdiInV8Htf6XWnHvTaXOF84x8Mm013WfZTzOKutrnIs72m3mYJio9aTKCWRVrzzFm5zbU/qaCL6u80cfduqds8Afa38421q4WfLOkei2PY4rhnm9ZtCX+3bavDnXxdjnTw3PqyiJmLXU8c1wCwpbGAr0ttKdVb/ma7ofkKWmht4Dthqts4cvNJVA+HTOd+ZmEzrc1fto/qNtf+B5edb2iRKJ/JkbA85jIjnX/OoiFHqB7aZTrXm8g+AwC3iy+zJJ0fLOSUxesHh9LasnR+/uT6uO6x5Ln7SFa638sd8VGLQ93mfrc519PIx7c9C8FG1FKfiJnLtGXTey1582Lwoyt1IYQQzpF0wCiX1JV6X1GnLoQQwjFciUS/h89dCp/pM+rUhRBCOEci7oBRTlfqfUVT2oQQQohBQq+v1ENRS5Sri/8usJniUiGT+4JQ6DeHZrY2W6JZLdmnUwq5waQ9xg0zaxtMk86YTB6Jua2FG+JshrOz89sNrb6Tm80sXjYrFq8hhcXVAkAgje/jD9s6qR705VA93VtmaGvr8mntrla+sfbFm6k+850KQzv5hYtpLb7zPSp3/d9Yqv/w2hlU/1JpnaGdP3YVX6aFUN1iqrf+vw2GduQwNw8G/Hw/vFc9kureNH5yhmPmCdcY4efDmXnmMQsAw7O5OdFDlmkzkLVZ4mB9aamZv5iZzWaIS6R4DzjNEsPKPhOLd/2kNlI5Z+OW9baZeI8HR93v/U2U05V6X9HwuxBCCOfQ8PuAouF3IYQQYpCgTl0IIYRjHB1+7/8rFe677z6cc845yM7ORlFREa688kps394zuyKZTGLp0qUoKytDeno6ZsyYga1bt/ao6erqwu23347CwkJkZmZi3rx5OHDgQI+apqYmLFq0CMFgEMFgEIsWLUJzc3OfttVngTp1IYQQzpGIO/NKgdWrV+PWW2/F+vXrsXLlSsRiMcycORPt7ce8Hz/60Y9w//33Y9myZdi4cSNKSkpw6aWXorW1tbvmzjvvxLPPPounn34aa9euRVtbG+bOnYt4/Nj6LFy4EFVVVaisrERlZSWqqqqwaNGi/m83h9A9dSGEEJ9rKisre/z7scceQ1FRETZt2oQLLrgAyWQSDz74IL7//e9j/vz5AIAnnngCxcXFeOqpp3DzzTcjFArh0UcfxZNPPolLLrkEALB8+XKUl5dj1apVmDVrFrZt24bKykqsX78ekydPBgA88sgjmDp1KrZv345TTz31+H5wQq87dZuZsiPO32CprZYkVysW4zrKM0y3b4Gfu1pfPMgHI84vq6F6dUsu1auaTDe6zaXa0Mk/aKfF/v5eU6ahRSzhC7EkbyNpcRLHrTG55hu2YRtLAi2KfdylvLmJR3E2dpnu7fpO/ovcFln7/ZO5PubcKkMLBL5Oa21s+QGPLR2WaXH5p5sO8F3rzra0vpqqafc/z/W0IYZWH8qjtRGLo3tHSzbVbcfEEL+5387M4272osxWqmcHeDStzxcxtKgl9tZniTitb+Ofh8XBAoAPph6zROoydz5gj4m1OffdLvO89XpSc+270z7fwSuuRLLf4TGuP35XtrT0PP78fj/8fv6986eEQiEAQH7+0dk1e/bsQW1tLWbOnNmjrenTp2PdunW4+eabsWnTJkSj0R41ZWVlqKiowLp16zBr1iy8+eabCAaD3R06AEyZMgXBYBDr1q07ITp1Db8LIYRwDgeH38vLy7vvXQeDQdx3332fuvhkMom77roL559/Pioqjk51ra2tBQAUFxf3qC0uLu5+r7a2Fj6fD3l5eZ9YU1RUZCyzqKiou2ag0fC7EEKIE5Lq6mrk5BzLvejNVfptt92G9957D2vXrjXec/3ZCGAymTS0P+fPa1h9b9o5XuhKXQghhHMkHbhK/+MDXXJycnq8Pq1Tv/322/HCCy/gtddew7Bhw7r1kpISADCupuvr67uv3ktKShCJRNDU1PSJNXV1ZujU4cOHjVGAgUKduhBCCMdwJROOvFIhmUzitttuwzPPPINXX30Vo0aN6vH+qFGjUFJSgpUrV3ZrkUgEq1evxrRp0wAAEydOhNfr7VFTU1ODLVu2dNdMnToVoVAIb731VnfNhg0bEAqFumsGGg2/CyGEcI5EHOiv1y/FKW233nornnrqKTz//PPIzs7uviIPBoNIT0+Hy+XCnXfeiXvvvRdjxozBmDFjcO+99yIjIwMLFy7srr3xxhtx9913o6CgAPn5+bjnnnswbty4bjf82LFjMXv2bCxevBgPP/wwAOCmm27C3LlzTwiTHJBCp95hMXC6LNZoJndYnNs2V7wtK52RYXHAZri5w/bZPcOpHrEcjF7iSLW5iIM+vk0SpgEYALCj1dy4tiGUHC9379pmJ3gs7l2WDX3ZsDZaG7Bs2zV1uVQvz+Db/Mw83j6DzQgAgC6LezlJHOCetOt7vTwAOO38TVTPeZc7vT1ec7+N+g1vw8YV/34F1Z/8i7cNbX8rz9R/p5Fvq73tfL89Mn8Nb2fr6YaWZsktT/fygzkzo4Pq/oD57IS45TkL2Vn8OLFlqNe0BqmeiJjHeJbPXA8A6CK59wAQTzHuNDtgzpTwe/hsEJsT37bNmUPftk1srv3Bys9//nMAwIwZM3rojz32GG644QYAwLe//W2Ew2HccsstaGpqwuTJk/HKK68gO/vYrIoHHngAHo8HCxYsQDgcxsUXX4zHH38cbvexfbVixQrccccd3S75efPmYdmyZZ/tB0wBXakLIYRwjkTCgez31IffPw2Xy4WlS5di6dKl1ppAIICHHnoIDz30kLUmPz8fy5cvT2n9jifq1IUQQjjHAHTq4hgyygkhhBCDBF2pCyGEcAxXIgESrJdyG6JvqFMXQgjhHImEA+53dep9pd+densKscY2t7gtz7yNm0bxDslhP9jBDwKWcQ4A+9t5vW0d2R2iligvzrSFpVsIpJl3QQKWYHmvxeZ+qJO7kRvAncSjPbmGtr/d3K4AsKmBL7OMl+PkbO4wLs4w12WHJc98WCbf+TZXb+2Howyt/e95G5n/2ER1/9IHqT7yuTuo7rry303R4riPJZ6gus2hv+/A5YYWivhorT+NH4fbk9VUzxvD9XFdZvsf7eezRGz55GmWdUnPMnPy20M8y71wOH8uw9CztlN9/cvTqX4kbM4KaIvw8JKAmx8rbsvnsTnU2XZJWHLibbhgmSVE3PJeS05+RjrP4BeDH12pCyGEcA5dqQ8o6tSFEEI4hzr1AUXudyGEEGKQoCt1IYQQzpGMpxYHStvQlXpfUacuhBDCMTSlbWDpdaduyxZvtwS3d6WQx29zqDdFeSNNxKia+u/C1O48BNxmfcTya7Szix+QUcvnLPCZu2F0Fm/DNttgVBbflfWd+VTvJJt2yf5f0dpEgmeffzvnFqq3RPm6/P5ASa/WAwDOK+LLtFFdZ7ZddOuZvPgfH6GyzYmeqnM9Fc5P/wbVG9pNt3iXJaVr6pBmqkeTI6m++RV+HAZInrst492WWx6z5Lm7iIs8YnHz+/L4vvedwnPlx+7dQfV3PxhraDb3u8fHzze3pXfyWJ6HwOpt+ey271Sbsz6RQp57jDwL4bihe+oDiu6pCyGEEIMEDb8LIYRwDl2pDyjq1IUQQjhHItn/Trm/RrsvMBp+F0IIIQYJvb5Sz/HyX06HOy1xia7emzrSLLW232p1CBnaEOTQ2hI/N+OE4xYzm+UXIjPFtcQsObYWxgW5Sefi0iOGZjPX2Iw7XrctJrf3++Ga5Eyqs7hNANjdxpeZ7eVuvqkkKjTXz+MsbYfPzmYeK9veVGBo529ZyRtJEScMcYk3fkj1NFzA60kw8ZFObn4aw9NWcUaQb9uWcDrV4wnzN35OhrnPACA3r5m3EeNfKaEjpmHTFvnrzuLrnSwtpXp6kEch55Co1Eicr1+zZZsUZ7dQ3WsxyrH2fZYoV9s5bj/3Td1WG7Psh+NCIunA8Luu1PuKht+FEEI4hyPPU1en3lc0/C6EEEIMEnSlLoQQwjl0pT6gqFMXQgjhHLqnPqBo+F0IIYQYJPT6Sv2C4gaq720zXceAPQKR0WVxovvS+G+O24dlGFpLlC9wOzevWuNWbbTFzT+wufYXDOeND8usozpzrrPITsAe28mcy58Ec83a4inzLA7oTG8u1Tstztvzz3jf0ALZvO23Np9F9ZODTVRnDv1pc8+ntcBei/7ZEV3Jz5/RGQGq14fNY6LZcow32qJP0/h55ffw45Ptf5+Xz/Aou/A9qidCfLbJ7jUTDc12zCaj3OWfzMiietbZH1K9vN503HfuHUlro5bY2w7Ltg2m88ha5uiPJ/nndKd4Oesm3xMuy2yY+EDGxCYTQAqzbngbulLvKxp+F0II4RxJB4bf1an3GXXqQgghnEP31AcU3VMXQgghBgm6UhdCCOEculIfUNSpCyGEcIxk4uirv22IvtHrTn1vGw+YjlsMDV5if2f56QDgt7jcPRZ3eUVRraG9XTOU1taEeUZzl+UpQh1J7gwu9pou5QUjzQx6ACjKbKW6jRzipD11yju0Nt7J3bgfbhrH287iudi5hY2G1kzyuQGgvcOcbQAA6R7ujG7o7H22eEsDz3L/1oc8//uF6XybF5J1fHvrK7R2IIi28W1ybkEn1fe3m8dbaTo/Zg+QWgAYG+THoS1zne0ff6CL1uKUciq72/gyC3eZMz+OHCrm6xfjzu3okJFU9zcepnrRWTsMrbGRH2/1Ia7bZnJELLqfnBNJkuMP2HPbbfsnFRIpzoYRgwddqQshhHAODb8PKOrUhRBCOEcCDnTqTqzIFxON0QghhBCDBF2pCyGEcA5dqQ8o6tSFEEI4R/KPr/62IfpErzv1dxq567qAywjHe79XEhYHfcSi/6RqlKHFLLXxFOdGMJc7AFw7stnQMiw57F0xL9VL83j+9ynTNxpa7KuX0NrAcy/xZW7gyxw1fRPV3WcEDS2+grfREebO7USKLt2NH441tOoOM7MdAMotRpmdNTz/u9mS0Z0KscQTVP/wskepftJ55gyFMf9qZpwDQFu9OdsAANyWfPYCvzkLYyKZ9QEAv9vHneg2PG4+I4Ttz0yLgz6ez53raT5LVvrpuw2to4XvS28Jfx6A9+TfUd2239wNf2VoZ3z1DVqb+Tzfbx8dGkb1RvKsAQAYnnfEXD9LDrtt39tc8QnyOFOPR72f6Imu1IUQQjhGMuFCsp/PU9c89b4jo5wQQgjnSDj0SoE1a9bgiiuuQFlZGVwuF5577rke77tcLvr68Y9/3F0zY8YM4/1rr722RztNTU1YtGgRgsEggsEgFi1ahObm5tRW9jNGnboQQgjnSLqARD9fKd7aa29vx/jx47Fs2TL6fk1NTY/XL3/5S7hcLnz5y1/uUbd48eIedQ8//HCP9xcuXIiqqipUVlaisrISVVVVWLRoUWrb5zNGw+9CCCE+18yZMwdz5syxvl9SUtLj388//zwuvPBCjB49uoeekZFh1H7Mtm3bUFlZifXr12Py5MkAgEceeQRTp07F9u3bceqpp/bzUziDrtSFEEI4xsf31Pv7AoCWlpYer64uS2xxCtTV1eHFF1/EjTfeaLy3YsUKFBYW4owzzsA999yD1tZjRtE333wTwWCwu0MHgClTpiAYDGLdunX9Xi+n6PWVeoAbOEEi3gEA7TxCnVLg542XZ/AbK5ubTN2WQW/Nprfkyl9/suleBYCAx/xAnjTuIi4MNlN97DX/R/XkqOGGFi89j9Z2HXqL6sX53F3dddMdVPce3GBovoxDtLYz6qO6DdvtsK6EuZ874/x3ZVmAH5ovHuDu6qZI/13A3yzm2/aRw2uo/i/bbza0rwb5sbxlp5l9DgBHOvm29aWZn+cPB7gTu5A45QHATdo4qvM9lCAu7XArd3kXbH+f6uG536F6csweQ/O/u57WtrzL3fyxxD9QvePQy1QPhMzP2bGrlNZGInw/eC3neMRlyacnmfAFeU209kgTf9aC1937L8+YJYPe5qA/Lnw8hN6vNo7+X3l5z2NhyZIlWLp0ab+afuKJJ5CdnY358+f30K+77jqMGjUKJSUl2LJlC7773e/i3XffxcqVKwEAtbW1KCoqMtorKipCbS2fmTIQaPhdCCHECUl1dTVycnK6/+3393/q6i9/+Utcd911CAR6Tl9evHhx939XVFRgzJgxmDRpEjZv3owJEyYAOGq4+3OSySTVBwp16kIIIZwjmbrRzWzj6P/l5OT06NT7yxtvvIHt27fj17/+9afWTpgwAV6vFzt37sSECRNQUlKCujpzxO3w4cMoLua5DQOB7qkLIYRwDCfvqTvNo48+iokTJ2L8+PGfWrt161ZEo1GUlh69ZTN16lSEQiG89dax23QbNmxAKBTCtGnTPpP17Qu6UhdCCPG5pq2tDbt27er+9549e1BVVYX8/HwMH37Us9TS0oL/+Z//wU9/+lPj7z/66COsWLECl112GQoLC/HBBx/g7rvvxtlnn43zzjvqbxo7dixmz56NxYsXd091u+mmmzB37twTxvkOpNCpZ3u58aKhi/+iYimxeT4+MHDtSdygtTuUS/WqJvO+SkeCG1qK/dwAc9XwENWLslqoHk+a6z4kj5vTRl78NtWj50yhurut2Vxey06+HhZj1ei5pvENACKBq6nu3bXF0GIRPoQUsZhxvG5uuLIN//iJ6egnddws1Rnn+6fMcwbVm5LmMeSyHN5/WWga3ACgNJ1/nuvybqX61NL9hvb/bTNNjwDwygG+bW0G1E5idPqojZ9rZ+fxNtI9UarbDJ5RYpTLLT3MG0/wbZWRMYIvM+vvDa3rQR5L3GrZhtUL/p3qew8OpXp24CKz7U4eeWwjAb7NbQa69i4zZjqjk0dPp7n4NrTFTAdILHWaxQwZiw3gIGwizQGjXGpGv7fffhsXXnhh97/vuusuAMD111+Pxx9/HADw9NNPI5lM4qtf/arx9z6fD3/4wx/wb//2b2hra0N5eTkuv/xyLFmyBG73sfNixYoVuOOOOzBz5kwAwLx586xz4wcKXakLIYRwDgfd771lxowZSFpmOn3MTTfdhJtuuom+V15ejtWrV3/qcvLz87F8+fLUVu44o3vqQgghxCBBV+pCCCEcI5l0IdlP9/unXHSLT0CduhBCCOcYgHvq4hjq1IUQQjhGMgEHHr2qTr2v9LpTj1p2UtRiaIiSnTI6iztGbUM1mxoyqM5co/le7gq/pLSD6qPzuavXFq/oIp/HGtFYwC3NSR933kaKCwwtrYu7v9PHHqB64syxVHdvfYrX7zFd/k2HT6e1aZZt4ra4d9NJpC4ApHtNN/a/Dp9Aa2s7eXLUmnq+zOroO4aWBF+P99r5tv3e+TuoXnbWdqrHw+Y63hDnx8SaQ/whEauPmI5mAMjzmMfzqZYMjqL0TqpnErc0wGdyAHw/uyyRsvBxh3ZH7Sqq3112i6G575hMKoG0O0ynPAB4fdzN77Mcb+x7xfZdk5/NZ72Un7SP6h9uPY3qzR3md9ahxkJae1IZP5ebQ0GqJxLmfvP7+L6PW+KXxeBHV+pCCCGcI+mA+72/iXRfYNSpCyGEcAxnjHLq1PuKxmiEEEKIQYKu1IUQQjhHIu3oq19tOLMqX0TUqQshhHAMJx7I8lk90OWLQK87dZbl/klkeMyd0hrjrvDKau4MDnOzPGViAS8eldNM9YTlno3b4vRm93j2H+Z53ln/y53oJeV7qd51zl+ay0twR69r9BtUjwcyqe756AOqN20ZaWhhS0a12+KAjlt+jbOMdwBojZhu8cL0MG/bsn/OyuPrGAjNM7TK5G9p7dvh/6L6yc/x9f7Bpm9S/fqJmwztDwdLaW1zxOK6Ji53AKiLmbM2CruyaG3YMgsjzbLfbFn+6cQtH49aviJifFv5nuDb/J/vMM+r9mY+w8Ftcbm3hrKpbvs87PjMy2qjtaecb+5LAPBMy6V6cC9vp6nDPA/dlvPhxa1nUv0rk/nzEA7Xmy562z4O+LuoLgY/ulIXQgjhGDLKDSzq1IUQQjiH7qkPKHK/CyGEEIMEXakLIYRwDBnlBhZ16kIIIRxD99QHll536rZ8fdv4fTpxvzfzKGq0crMr2mL8xkqez1zqSZbs5miCO+6HFDZQvXymmSEOANFa09W69bUptLaxMY/qnkf5BhjS8oChea/g2fShusVU9+9/m+rNL3OHflPdEENzuy0u9y6+l7ssruPaMM/s97lNF/Bdu/fQ2u+U8RkEgTR+IJ6VZx5vZ+JqWmtz1le3c/28klqqF444ZGiXHd5Pa1cfHEb1fHIsA0BGu3m8laWndqMx1S/G9ICZI549tpoX5/EZK67aeqqH9xYZWlbuWbQ2XvYfVM9v5u732kbz2QkAz7Ifc24VrXVfMpTqrsYjVM/I5M+UyCBfcrbz5MxCvq1+/OoFVP/LcVsNLdTGt4nH4rg/Luie+oCie+pCCCHEIEHD70IIIRxD99QHFnXqQgghHEP31AcWDb8LIYQQg4TPLCY2lfJOS+MdcW72uCTfdNblBXjcaF4Gj3Msv+p9qseueYjq0Waz/szsX9DaDyvPo/qePSOp3vVEOlG5US5Y/AjVOzfwyEnbL96CsjpDi1fziNN4G48ntZkQbVG7p+SZ5sS/iZ3Ol2k5gFyWH/ARMlxnW48dLVy3eNbwf7WmyQsAzqgzDVrBTH682dbF5gcaTlJ/Mz28emROiC/TEiHqIYZFABg22jT5JaN8o4Rf5p/H5c6nehpZd0/a9bT2hQkLqD7nmzyCtqiG758oMaj5Lg3S2s4RZ1Pdm/ER1YddwGNl639rRrm2kXhkAGgP84jgqUOaqV481DRs7v1oJK3tinmpflxIOmCUS7G/EcfQ8LsQQgjH0D31gUXD70IIIcQgQVfqQgghHCOZ7L/RLanh9z6jTl0IIYRzODD8Dg2/9xkNvwshhBCDhH7HxNrcu80R8w/clh9fMctYy0lZ3ME5LMt0UWf6zYhLABj/lT9Q3bXwl1SPtG2nuueIqSe/VEFrT5rH3eKbvs43wLB57xla27/MpbVpw2dSHQ9+m8rpBTlU95c1GlpjjRkd+0kEPDGuW9zVOelmtOasMR/S2uc/5K54GxGySJ/lgHsr8QHVL3DzZTZE+G/f771yvqFlWs6obK/FLc7LcVaeGXvcGeeNR+J8FkJ2gO+H3KxWqvuCpnO/YfMptLbZEoXcZXF6n/Fd4iL/CS3FvM3/TfUJdyyk+n9dspfqLMrVd+FuvlBwveUAX6b7TD47ZdgGMzq4YTv/PgjHAlRP9/Dc7F++Pt3QvjFjNa3dt3sE1Y8HyWQaksn+XS8mNf7eZzT8LoQQwjkSrv4Pn2v4vc+oUxdCCOEYSpQbWHRPXQghhBgk6EpdCCGEYyh8ZmBRpy6EEMIxZJQbWPrdqXst+y5B7olELBb6Qj9v5IIinmntTTNdvRXnVNHatG9yl3t709tU99Rvpbpvx7uGFht+Mq0NjP4K1aev41nX4Z9PNdte9g6tBbjedOAMqg+73szzBoBk1nBDc6/mbmnb/S2/xaVrmxFREzId060Wt3R5Bs/yr+5gOflAU8Q8lO8/8B+0Nt1nfnYACOE0qrOZHABwRq7pOm/s4tvKNvPDRmGG6dzO8HXR2uZwRkptuyw59PveNT9/ZxffP4VDjlB92IidVPddbD5rIFVGeXOpnka+DwDARbLv27ddRGv9p/Jzs72Ffx8gwY/ynKHm58zay53oHVGe/d5iOScOdJjHeMG1fCZD3U/5sSIGP7pSF0II4Rgafh9Y1KkLIYRwDLnfBxa534UQQnyuWbNmDa644gqUlZXB5XLhueee6/H+DTfcAJfL1eM1ZcqUHjVdXV24/fbbUVhYiMzMTMybNw8HDhzoUdPU1IRFixYhGAwiGAxi0aJFaG5u/ow/XWqoUxdCCOEYH1+p9/eVCu3t7Rg/fjyWLVtmrZk9ezZqamq6Xy+99FKP9++88048++yzePrpp7F27Vq0tbVh7ty5iMePeTYWLlyIqqoqVFZWorKyElVVVVi0aFFqG+gzRsPvQgghHCOZdOCeeoqd+pw5czBnzpxPrPH7/SgpKaHvhUIhPProo3jyySdxySWXAACWL1+O8vJyrFq1CrNmzcK2bdtQWVmJ9evXY/LkyQCARx55BFOnTsX27dtx6qmnprTOnxW97tSbLA7gPB/f+B7Ssteyo3N9vO0cP3dwZpOcd3+JmWUOALGNP6V64P+2Ub2rJp/qLa1BQ3P7D9LatFF/RfXocu5qxTbTWR9Jy6WlrbWFVM/MNbPCAaDrtIlUT7rNdckp4E7fxMFhVHcTdzEAFJGMdwAIR80s/y3N2byNAHfWB708b35byDzgMv0n0dqR7rOo/mrkJap/I+8Kqs8cZuZ8v1HDvzTaY/zYL0vnn8dDHN3v1JXS2sIAf+4BO08AoKmVPw+AfZGy9QAAX4Cfm4G5vG38uPfu99BdZVTvbObPcdi9azTV4wlzILLlTjPfHgBygg9SfejF5nMZACB27iSqe7LM7xXbcyk84Uyqpyf5MTEi0zwnDj5aRGtHn82fb/B5o6Wl5/ea3++H32/5Hv0UXn/9dRQVFSE3NxfTp0/HP//zP6Oo6Oj227RpE6LRKGbOPPZsjbKyMlRUVGDdunWYNWsW3nzzTQSDwe4OHQCmTJmCYDCIdevWnTCduobfhRBCOMbH89T7+wKA8vLy7vvXwWAQ9913X5/Wac6cOVixYgVeffVV/PSnP8XGjRtx0UUXoavr6I/T2tpa+Hw+5OX1nHZbXFyM2tra7pqPfwT8KUVFRd01JwIafhdCCOEYTk5pq66uRk7OsdGfvl6lX3PNNd3/XVFRgUmTJmHEiBF48cUXMX/+fPt6JJNwuY59lj/9b1vNQKMrdSGEEI7hpFEuJyenx6uvnfqfU1paihEjRmDnzqNhSSUlJYhEImhqaupRV19fj+Li4u6aujrzNtLhw4e7a04E1KkLIYT4QtHQ0IDq6mqUlh71qUycOBFerxcrV67srqmpqcGWLVswbdo0AMDUqVMRCoXw1ltvddds2LABoVCou+ZEQMPvQgghHGMgwmfa2tqwa9eu7n/v2bMHVVVVyM/PR35+PpYuXYovf/nLKC0txd69e/G9730PhYWFuOqqqwAAwWAQN954I+6++24UFBQgPz8f99xzD8aNG9fthh87dixmz56NxYsX4+GHHwYA3HTTTZg7d+4JY5IDUujUMyzh1X4z/hoA0EEMnLaM/jTL/nOB/wFzXbfu5A7tQAM3MHQ28jzmpjruLq+uM13NNlfr8CbuAD5SN4TqoyduMTRvkLt03Q2mCx8AYp08R9p3YAfVw+P/wtAChetoLXMRA0BrZ4DqHzSZGe8AUEQc02Mtn7Mzzg8sr8Vxf1qOeSj7O7No7daO31J9dCafEtPGjfj4332mS/vMvHZa20Kc/wBwoJ3rHbWm031biO+HVyL8eQDT3ZOpPq+cb3O2n7/6tf+htSt/eznVL/sS1wGerc7Y8z7/gszO5ut9oJkfb0EyKyDdkp8faubnVcfz5nMZAGB00yaqtx0YSnVGmuX7LW571kKaWf9S1QTeuEX/5r/0bt36QzLR/5jXpO0BEhbefvttXHjhhd3/vuuuuwAA119/PX7+85/j/fffx69+9Ss0NzejtLQUF154IX79618jO/vY7JsHHngAHo8HCxYsQDgcxsUXX4zHH38cbvex76IVK1bgjjvu6HbJz5s37xPnxg8EulIXQgjxuWbGjBmf+GS3l19++VPbCAQCeOihh/DQQw9Za/Lz87F8+fI+rePxQp26EEIIx1D2+8CiTl0IIYRjOPM8dXm4+4q2nBBCCDFI6PWVutvS/Qfc/D5GB4nFtM3Pt3jwrHQR09Gu7WNobW42j09N2Mxf7Ty6MRwzl5lhibH1+LizKt0S59nVaJp00kuP0Nr6Gj4fMmoxYuVvfIPqGG9KaZYIVhvNXelU39HKD6tMjxk5ajMF1VuMf4e7eNtD/Oa6/78ibnLypXEDWYabu3O8aWGqJ1IYIsz18mMins7baIqYn7MxwiNbz07yKGAbbZZj5YqzTfNX07aRtPZIOIPqnjRuiIslnjC0moX309rWFr6t8ofyqNlT2vg529BinlceDz/GA/4I1Q9bTJ8dL59PdUY0zo9Zl4t/d9oMdG5SXxPm50l0AIevE0lXSueGrQ3RNzT8LoQQwjkcSJRDf//+C4w6dSGEEI4ho9zAonvqQgghxCBBV+pCCCEcQ1fqA4s6dSGEEI6hTn1g6XWnnm6Jg/Vatj2LfrW53C8bsZ/q7V29fyJPyOLG7bC04XFzJ3EXcbkDgN/immUcPmhGygKAz8cdtl0dZtxquuWgDluiWVstTvSGd/msgLyDGw3NZXEA24Kacv3cFf7LIzxx6Zz2RYY20pdNKoFsy4E1Noc7o7OJcz9o2d4j8xqobovDLS2qp3pukdnO/l2jaO2b+0dSPYPMCAC4e7k8g5+uB1kmM4DV8Q1U/8mZVEZwqPk5vTk89vbrv/o213Eh1UO3/IOhdYZ5bLJtZko0zM/lISV8/xQPNSOi87/Oj4lYUTnVR/5+JdXrNp5O9XCH+T3U2cUd6l5SmyqNEb6t9rSlNpNFDB50pS6EEMIxEsk0JPoZHtPfv/8io05dCCGEYyST/Z/SpuH3vqOfQ0IIIcQgQVfqQgghHENGuYFFnboQQgjHUKc+sPQ++92yjbssD7MPELe8bTdN/X+rqf7KfbOozjKTswPciR2Lc9t+s8Utn7CsZZbPzHl3WTKavZac77LxO6jetMt03sba+PoNH15N9Xc/PI3qe/YNp3rRR+sMLZnFs+xtzv+uGD98rsz+JtXfiK83246cTWszPdzNX5TO8/MLAx2GNjSfu9x9lv3TbnEjHz5SQPUIcTUXl5iOawAYb5mFcf+7I6nuJTfG8i2TQV5qf5jqJ2deTvWJLx2g+r5vmdslY2mIL3Rp7zPeASD9dvMYLx4+ndYeuOZVqrc25lL9nY9OpvrMmWY70TJu/fdteJ3q0XZ+HOaUHqZ6ZsScPVO3dxittT0LI24xibXGzO+yZm7mhzdNd1ZPZKLRKGpra9HR0YEhQ4YgPz/fsba154UQQjjGxw906e9rsNHW1oaHH34YM2bMQDAYxMiRI3H66adjyJAhGDFiBBYvXoyNG82pxqmiTl0IIYRjfDz83t/XYOKBBx7AyJEj8cgjj+Ciiy7CM888g6qqKmzfvh1vvvkmlixZglgshksvvRSzZ8/Gzp07+7ws3VMXQgjhGLqnbrJu3Tq89tprGDduHH3/3HPPxTe+8Q3853/+Jx599FGsXr0aY8bw4LBPQ526EEII8RnyP//zP72q8/v9uOWWW/q1LHXqQgghHMOJe+KD8Z76x4TDYSSTSWRkHDXm7tu3D88++yzGjh2LWbO4OTwVet2pt1ujhPnGHxIwneG5Xp5zHaniees23Gmm5T7Dz53bw0/eQ/XWxiDVd+/nbvGOqOl0zsvgnyc9gzvxPfltVK8+MNTQJpy7jdbm/KSG6sBWqr5y7nyq1/03z7pm2IbCdoXyqH5WPp8VcFp8aq+XaXP17mrJpLqbzIg4OcCPiYxMnmeek9tC9awhjVT3ZJr7uaOeu1hbwtxFzVzuANAZZ+cPr71pyK1U/+rJfKbEawenUT37vp/zBaRAe9t2qgfPMGe4xBLfoLXl4/6T6vve5TM8Mr38YNm5yRzqHN7Mvw9QzJ9B8OG6CVRPS+PHeHZWq6E1tvDvGtszFdjsHhuRBK/N8w2cXSqZ7P/wuW3bDAb+4i/+AvPnz8df//Vfo7m5GZMnT4bX68WRI0dw//3345vf5LOHeouMckIIIcRxYvPmzfjSl74EAPjNb36D4uJi7Nu3D7/61a/w7//+7/1uX8PvQgghHENGuU+mo6MD2dlHR4ZeeeUVzJ8/H2lpaZgyZQr27dvX7/Z1pS6EEMIxkg7MUR/MnfrJJ5+M5557DtXV1Xj55Zcxc+ZMAEB9fT1ycnL63b46dSGEEOI48fd///e45557MHLkSEyePBlTpx71Gr3yyis4+2yesJkKvR5+txl6WBwsAHiJ2eOmyytpbeYPuRHpdxP5rzVmlHO7uZPPk8FjRYdewmMeAy9yk9u+3SMM7eTxH/D1S+fGnY6PSqk++uTdhha/eDKtBdZadE7EEpN78KC5Lmy7AvbYyo4413MshsjWqFl/Wg7f3sz4dnRd+DHRFjVdZKu2j6W1jSTKEwA647zt03K4sW78MHOo7FBjIa2taedGrLoufqwEPeY6+tx8/4zJ5vqWI0VUn17KzZYtC8xjom4nN46OeX4D1YM59/K27zHb3jr7MVobaj+X6jbyM7kB9cyvvW5oiTEn0VpXZxbVS/bUUf0QOX8AoKHJNI92kWMTACJx/vVru0od4jePlboIPwfdkYG70tXw+ydz9dVX4/zzz0dNTQ3Gjx/frV988cW46qqr+t2+7qkLIYRwDHXqn05JSQlKSkp6aOeem9qPWRvq1IUQQojjSGdnJ9577z3U19cjkeg50jZv3rx+ta1OXQghhGMofOaTqaysxNe//nUcOXLEeM/lciEe57cve4uMckIIIRxDD3T5ZG677TZ85StfQU1NDRKJRI9Xfzt0QFfqQgghHERX6p9MfX097rrrLhQXF38m7fe7U49w4y3SPeYb+ctSm1hv27EsRtHvi9LapMWhjQivL5i1n+o5H5qO4ebdZrwrAHgs65I1rJ7qbhJn6t30Ea21EWr+NtVbb+EzDjzESZtR2ERrN67h8a62X9P5Ph7POrXsgKHtaSygtU0RP9WDPu4W96eZv3A9Frd4UYAfE82WZR7u4vqrH51iaLaIz3KLQ/vaETw+dkuzuUwX+K/4HMvxluHm9RdveI7qIIb2u0q5G/fNC3gcbkM7d5E//3vzcxam81kFhSRqFQDSA3wmiy2WOdFMjs80vu9jZaOonlnIz0NvPZ/lEO4KGFo0wWegeMgxCwDDcpqpvqfZ3OYd4OdaY1oD1cXAc/XVV+P111/HSSfxmRj9RVfqQgghHCMJF5KWZ4Kk0sZgZdmyZfjKV76CN954A+PGjYPX23PK4x133NGv9tWpCyGEcAxNaftknnrqKbz88stIT0/H66+/Dpfr2Gd1uVz97tRllBNCCPG5Zs2aNbjiiitQVlYGl8uF5557rvu9aDSKv/3bv8W4ceOQmZmJsrIyfP3rX8ehQ4d6tDFjxgy4XK4er2uvvbZHTVNTExYtWoRgMIhgMIhFixahubk5pXX9u7/7O/zjP/4jQqEQ9u7diz179nS/du82g8hSRZ26EEIIx+hv7ntfjHbt7e0YP348li1bZrzX0dGBzZs34wc/+AE2b96MZ555Bjt27KDzwRcvXoyampru18MPP9zj/YULF6KqqgqVlZWorKxEVVUVFi1alNK6RiIRXHPNNUiz+Dv6i4bfhRBCOMZADL/PmTMHc+bMoe8Fg0GsXLmyh/bQQw/h3HPPxf79+zF8+LEo5IyMDCPp7WO2bduGyspKrF+/HpMnH43xfuSRRzB16lRs374dp556aq/W9frrr8evf/1rfO973+tVfar0u1OPWdzv0UTvd0os8QTVX5jwe6rHE+YvnLxinuXu+h7f0a4h51M9EgtRPdpZa2hFWb3biR/TcsffU53NCnhv1nRLK6upGsz9EdVr//I0qvsyTcewK407t2255V5Lve1XdiicYS7Tcpj4Lc7tTkuWPcuKj8X4L+FQxEf1LnJcAYDfkolflmm6t5N8k6Chk7vcbaS7zYZsufcH2k3HNQDUdfb/SmBoBn+mQhtxeQNAcTY/f4YXmjM/ykaasyEAIDj9INXb3+IzJd59awLVG1+40NB8lZas/Vy+3rW1FVTvsMyU8HnM7WV7pkJuOnft17UGqf5hi3n+uMFnVYTRQvXPGy0tPT+H3++H38+3fSqEQiG4XC7k5ub20FesWIHly5ejuLgYc+bMwZIlS7ofk/rmm28iGAx2d+gAMGXKFASDQaxbt67XnXo8HsePfvQjvPzyyzjzzDMNo9z999/fr8+mK3UhhBCOkYAD89T/6H4vLy/voS9ZsgRLly7tV9udnZ34zne+g4ULF/Z41Ol1112HUaNGoaSkBFu2bMF3v/tdvPvuu91X+bW1tSgqMh+SVFRUhNpa86LPxvvvv9/9NLYtW7b0eM9lu8pJAXXqQgghHMPJ4ffq6uoeHW9/r9Kj0SiuvfZaJBIJ/OxnP+vx3uLFi7v/u6KiAmPGjMGkSZOwefNmTJhwdDSIdbrJZDKlzvi1117r49r3DhnlhBBCnJDk5OT0ePWnU49Go1iwYAH27NmDlStX9vixwJgwYQK8Xi927twJ4OiT1erqzEfxHj58+FPT4fbv56FmNg4e5LegeoM6dSGEEI6RgMuRl5N83KHv3LkTq1atQkEB92f8KVu3bkU0GkVpaSkAYOrUqQiFQnjrrbe6azZs2IBQKIRp06Z9YlvnnHMOFi9e3ONv/5xQKIRHHnkEFRUVeOaZZ3r5yUw0/C6EEMI5nHggS4p/39bWhl27dnX/e8+ePaiqqkJ+fj7Kyspw9dVXY/Pmzfjd736HeDzefQ88Pz8fPp8PH330EVasWIHLLrsMhYWF+OCDD3D33Xfj7LPPxnnnnQcAGDt2LGbPno3Fixd3T3W76aabMHfu3E81yW3btg333nsvZs+eDa/Xi0mTJqGsrAyBQABNTU344IMPsHXrVkyaNAk//vGPrU7+3tDrTj1hcfUW+vkbI7M6er8SaddT/Tfjv0r1zqjpXo51ckezP41/xPa27VTP+K9/pTrOJ275sXxHhm5bQvVdW7kT/Z1LTja013bzLOrwP22muqecO2n3PJNL9SySif/G/02htTa3eIclV3+4lzuMC7NMR27M4jhPs2So29zvxZlmXngkzvd9jo9niNuW2RLhTu9w1Gw/3cvd4l6LA7rBkitf4DfbaY/xz35yDs9Q//8ad1A9FcYVmI+HBICuGN+2xcX8+QYlf23u+0j56bS2M407zjMjL1I9uJU7wFs6Mg3N5tpvaOGOcxs2R3uUHJ/plvPBxjP7eK68h5wqU3P5zJRDrf13iPeVgXigy9tvv40LLzw22+Guu+4CcHT62NKlS/HCCy8AAM4666wef/faa69hxowZ8Pl8+MMf/oB/+7d/Q1tbG8rLy3H55ZdjyZIlcLuP7dMVK1bgjjvuwMyZMwEcffY5mxv/5+Tn5+MnP/kJfvjDH+Kll17CG2+8gb179yIcDqOwsBDXXXcdZs2ahYoKfuyngq7UhRBCfK6ZMWMGkrb5pMAnvgccddmvXs2nC/8p+fn5WL58ecrr9zGBQADz58/H/Pnz+9zGp6FOXQghhGMo+31gUacuhBDCMRJ/fPW3DdE35H4XQgghBgm6UhdCCOEYGn4fWPrdqad7LC5Qi6uZ0bnhTKqvub2L6i7iUq6vM+P7AGDMv/2a6uHDeVTfdYA7wPPWm6EDu3b+N61t7DiX6hPHbqN6e6vp0p1SVk1r3bl8VkHyz+IUPyZmcSnv3zvc0L6zg7t0/7qMn2AZbr7vuxLcpX241Qx7aCczGQCgNeqleoabu8s7SDvNNqezxXFuy3gv8HO3fF6GOeMgapkRMK6Eu8jLR5u5/wDwmzUXGFqnpe1MT5Tqde3rqW7jqYqvGdrbh81jEwDOtrji29t4vWv3+4bm7+CufXTx7W2jZFgN1fM7zP0f7jDz0wGgpTWL6jYXti37vYE47kcV8OdSpAf452y1PFDj3AJTH5ffQGt//yF3xR8PEsnU3eusDdE3NPwuhBBCnEBs2rSpz3+rTl0IIYRjJOFy5PVF5qqrrurz3+qeuhBCCMcYiPCZzyMLFiygejKZRGNjY5/bVacuhBBCHGdWrVqFJ598EllZPf0cyWQSa9as6XO7ve7U0yw/nHIssZh/te3xXq9ErMA0bQFAAYkVBYDGdtME0tTGjSFrKi+kepvF6MJMeABwCjGcja3gxrfMEfzZurHWdKpndZrrEmzmn6dly0iqpx/mv+xGTuZ65bOXGdq1hbm0Np6MUz3g5nrEEuX6QZP5EIVMDz9+PBbTWpaPm/nixJjZbjEJlqVzs6HP8nnaLaa9I8R0FU2mFnvrP1BK9YYIXyaj2XIs23jktL+k+pnDPjK0jz7kUa42g+PeuhKqdz1tGv8KCvixmWYxYMYtMbmNjdz0GiX7zeOxHbP8WGlo5wa6dC83J7LjM5jDv8dsnzNqcYk1RszPn2E5H742pIzqx4OjRrn+tzHYePnll3HppZciLe3od8SMGTOQlZWF6dOnG7UfP2+9L+hKXQghhGM4cU98MN5Tv+yyy1BTU4OioqMztT7pSWyVlZV9Xo46dSGEEI6he+qcT8ufdwq534UQQohBgjp1IYQQjpFMOvMajCxbtgwvv/wyjhzh4U1OoOF3IYQQjpGECwndU6f8/Oc/xw9/+EO4XC4MHToUEyZMwMSJEzFhwgRMmDABpaXcOJsKve7UMz38p9PNN66g+re+Y2r/MupmWutf+yjVE4mLqM6czm4Xd5LmpJtRngCQbYlojFqc21lZZqSlLZ+4szaf6rA4oJNkmfEI3zXVe/hMgZPT+efJOIk78d9pMB3DeX7uRHdb1jvd4haPW7ZLkDh1bbW2bdvYyWcQMKd7s2UbNnVx57bP4kaOWOJZCwNmjLEtanZ3Sy7Va8hMDgAIkHZsM1CGBPgxbnO522YtbKoeaWhjgyFaG7e4/MMx7tqvD5nHWwuJVAUAr2X9PGlct91/jRJHuy3e1eZ+j1nirm3rEiPHymsfnkFrP2zhx/IkEgcLAEMzzFkbuZk8andSIY+mFQPL1q1bEYvF8M4772Dz5s3YvHkzfvGLX6C6uhoulwvFxcU4dOhQv5ahK3UhhBCOoQe6cFyuo5+prKwMZWVluPzyy7vfa2xsxNtvv42qqqp+L0eduhBCCMeQ+53zSe73/Px8zJw5EzNnzuz3cmSUE0IIIT5jfv/73yMYDH7my9GVuhBCCMdI/vHV3zYGG7NmzTouy1GnLoQQwjE0/D6w9LpTz/VxR+Zvll/N9fGmkzrLx+fm7XlmEtX3kaxwAAiQvHAfN61jSB7Ply45ZR/V3RncRe47jTiMbQHF7dxF3v4Bn66we+sphhazuPDfqR1K9fELX+XrMpxncXcmzJNmiN90cwPA3nYz4xwAHqip5uviGk31HK95t+fkbO4ivmT4fqrb9mfS4sZmxCwZ4m0kyx0Amjp4/vf7DebxGbA46IdmtlG92pItzlqxfcILzn+T6hkn1VD9yYevozqbiXBqQT2ttWWit0QCVM92mceWzYnutswgYLNeACBoyfIPk3x6Wxu2bH7bswbKCvl32aEjhYZmewbBGUG+3gG3ZRZKmrmOyz84ldaubeLH22yqisGErtSFEEI4RgL8R2mqbYi+oU5dCCGEY2hK28CiTl0IIYRj6J76wKIpbUIIIcQgQVfqQgghHENT2gaWXnfqnXE+HPJBM8+u9hCnZrnFWd5kyfPusjjAM72mIzUc5ZnTrW3cpTssiztP0+aMoHp4aIWhpa97ntba3O/RDu4MdpOs66jFMVvg59swyU26cB2so3qu11ymzZwSJU55ADglwbfVNtcBqs/ymbn1kywu4gDZxwDQ2JxL9VjCPFZCYX5cMRcxAGT4uPt/SDbPP59A8r831hfT2veacqneHuODZWz/RCwPufDfxJ8HkHyR53+XZPC88FziIm+y5LOz7Q0Ao/L4/kwnz1rYWcdng0Qs573LMiIbtxyfzIlve9ZApjdK9aZOfs7mZ7ZSnbnoh2fxWpsTP2rRt4XM79qXQnyGQ6u7ierHAw2/DywafhdCCCEGCRp+F0II4Ria0jawqFMXQgjhGJrSNrBo+F0IIYQYJPT6Sr0pwvv/du4vweEu0+izr43HcAbNNEcAQJaHG5ryA2Zkq5eYlgAgEuMGOlhiIeM5ZswjAKSvecbQWtaU0VqPxRCYfdJBqp8xaY+hHVlnRscCQNNWblxqfodHs7785lSqp3vMAa5Oi0HJFn3qT+PHxGXZ3LhV1Wxul4tK+SHY3sUNSukWA11Whmny8lriNm0mr84IPxAPdPC44jxiOBuVzeM579vFt+GEjHyqp7vNbZth2Q/xbG7OO/IOjxC1mZByiaHrcDs3wta08+MwYTHzxUOmbjPE+YhxFADaSOwrAIQt57jHZW6vbB//wsq0mCRzA9xQe6Qth+rseyiXfF8BQCTOj/0ui0mWbVl/kp8nIfBteDxIov/D53K/9x0NvwshhHCMJBwYfrf8OBSfjobfhRBCiEGCOnUhhBCOkUg680qFNWvW4IorrkBZWRlcLheee+65Hu8nk0ksXboUZWVlSE9Px4wZM7B169YeNV1dXbj99ttRWFiIzMxMzJs3DwcO9MzcaGpqwqJFixAMBhEMBrFo0SI0Nzf3YSt9dqhTF0II4RhJh16p0N7ejvHjx2PZsmX0/R/96Ee4//77sWzZMmzcuBElJSW49NJL0dp6zEdy55134tlnn8XTTz+NtWvXoq2tDXPnzkU8fsyfsHDhQlRVVaGyshKVlZWoqqrCokWLUlzbzxbdUxdCCOEYA5EoN2fOHMyZM4e+l0wm8eCDD+L73/8+5s+fDwB44oknUFxcjKeeego333wzQqEQHn30UTz55JO45JJLAADLly9HeXk5Vq1ahVmzZmHbtm2orKzE+vXrMXnyZADAI488gqlTp2L79u049VRuTD3e9LpT/6CFO7q9Lu5g9ZJMx8Nd3I3cHOUDBkdifJmn5Jjxn8UZ3HVsOzg6D+dRPefU66mefHONoe3dwR3nI0/bRfX0yTwWM1pouuhbX+TbKp7k26qhpojqzRZHNzOy2NzINs4v4h7XoMWhfhoxDO8IcRdxsjlI9dIM7iQuI87tEcU8QjPd0obN3BO3bJdIl9/QtjUMobUj3dylbBtm9JIo23QPdzR7/+v3VN+171Kq244hn8/cbxXDzZkZAJBricNttcxaiCXNr5rmiLn9ALv73YbNFc++EyacuYXWNh/mMxyq9o2iups46wEeYW2Lt7XFYwc8/Nz3k2NijJd/j6VbzvvPGy0tLT3+7ff74ffz48bGnj17UFtbi5kzZ/ZoZ/r06Vi3bh1uvvlmbNq0CdFotEdNWVkZKioqsG7dOsyaNQtvvvkmgsFgd4cOAFOmTEEwGMS6detOmE5dw+9CCCEcI+HQCwDKy8u7718Hg0Hcd999Ka9PbW0tAKC4uOcP0eLi4u73amtr4fP5kJeX94k1RUXmxVNRUVF3zYmAht+FEEI4hpOJctXV1cjJOTaal+pV+p/i+rMhk2QyaWjmevSsYfW9aed4oit1IYQQJyQ5OTk9Xn3p1EtKSgDAuJqur6/vvnovKSlBJBJBU1PTJ9bU1ZlPvTx8+LAxCjCQqFMXQgjhGE4OvzvBqFGjUFJSgpUrV3ZrkUgEq1evxrRp0wAAEydOhNfr7VFTU1ODLVu2dNdMnToVoVAIb731VnfNhg0bEAqFumtOBDT8LoQQwjGSyaOv/raRCm1tbdi165hBec+ePaiqqkJ+fj6GDx+OO++8E/feey/GjBmDMWPG4N5770VGRgYWLlwIAAgGg7jxxhtx9913o6CgAPn5+bjnnnswbty4bjf82LFjMXv2bCxevBgPP/wwAOCmm27C3LlzTxiTHJBCp/7lYfyewc5WnrvcQKKUD3XyfOUAybkGgOkF3B3aETPbsd3S8Ht41nObxf2e9dCNVK/fcLqhtYR5ln2gMET1RNZIqnu3v2to4c6JtNbmDG5s4W5x2y/edNJOe8w2k4GfYbZM+GiC78+idNN1Xkwy2wGgPsz3/cEOrm8LZRla2kE+2yBm+cIIuPkbtsz1HK/pUs6wOJerkrupPtt9MtWjCfOA9qfx9WjcNpLqNid6nLQNANGoeS6nWZaZm2nm3gNAu8XR7iLHUMByLKdZjrcOSya6x7LNmbt870cjaW0mOTYBIMfHZ+AU5fBznK1LawfPyc+zzNhps7ji22Pmd1Yoyj/7zjTu8h+svP3227jwwgu7/33XXXcBAK6//no8/vjj+Pa3v41wOIxbbrkFTU1NmDx5Ml555RVkZx97tsEDDzwAj8eDBQsWIBwO4+KLL8bjjz8Ot/vY9+KKFStwxx13dLvk582bZ50bP1DoSl0IIYRjJOCyPtgnlTZSYcaMGUh+wuW9y+XC0qVLsXTpUmtNIBDAQw89hIceeshak5+fj+XLl6e0bscbdepCCCEcoy8xr6wN0TdklBNCCCEGCbpSF0II4RwOGOX0QPW+o05dCCGEYwzEPXVxjF536qfmNVK9wM8d4O81m5neaS7ujG2NcoftiCzuSK3vNNsZY3HpsjxrAAh38PXe9Fuel13barrLWc4zALjTucs/OoRnxbv+z3SqdlgcsJ407hg+0pZNdRuZXnNWQG0nz4se4uczCM62ZKsfbufrEiJZ6e3EcQ3Yc9iHZ3K3fBr5aR+1ZJzb6LRkvNtaYTMRbLV3l5ZTPQF+rLREzVPT9hyDukPc5e+2nBMNlmNr/2EzAjOa4NvENgsjbpn5wOrTLa71uOVz2pYZs9S7yf63Ocu7Yvw4HD6knuonTX+b6oerTjG0Zsu5edJJ+6m+ecsZVGfbZXIB3z/F7VOofjwYiClt4hi6py6EEEIMEjT8LoQQwjGcSIRzMlHui4Y6dSGEEI6hKW0Di4bfhRBCiEGCrtSFEEI4RhL9n5GmC/W+0+tOfdXBEqp70/jmZ8MnQzN47chM7gDOtTjXzywyH0jfanOLWxyzYeKgB4A2S152aXazofl93BUeaeRu18D/Pkf16jUTDK3T4gqPWxzd9ZYc+pjFjdwcMZ3uxQG+vf2WbZiTybOrI5aM7gNtZj671+LQ7rA40T2WeuYMzrbk/rdEucuf5ZMDgNuiR8g62hzdLPceAGotGfc+8jlbLdn8bx0YTvXRwWaq5/p5nnlzF18XRjDAs899bv752bYNWc41t4vv4yEBvg0zLN8TuelmPr1tH3dajon6Zv6MiIb/vZjqHST73pa139Fqng8AELPMODg1aJ5v7Bg8Ct+2x4Ojw+/9nNKmXr3PaPhdCCGEGCRo+F0IIYRjaJ76wKJOXQghhGNoStvAouF3IYQQYpDQ6yv13zTvoXobGqiegyGGNtEzgtaeks1/l43MO0L1rAwzKvQXH/AI1r8bvo/q4UZuJLHFsLIYyaQln7hux0iqJ7ePovrhpnxD81kMV/UhbsKz/bK1mbzCxHRlayPf0oaNOktMbGfc/A1pW2apxVhmI42soy1WNN1riSe1GJraLRGiUWJSOrt8L60Nd/Ljrf4APyf8xIBq21Z+i3nw0g3PUv2FCQuonhtoNTSbscwWq2ozuTHSLUZGq06ijQEgmGEa4gAeNWyLsbUZZG3Gv3YSeQwAYbJdzhy5m9ZmZHOjqS0mtzZsruP+dr4fasMDN36t4feBRcPvQgghHEPD7wOLOnUhhBCOkXQgUU5X6n1H99SFEEKIQYKu1IUQQjiGEuUGFnXqQgghHEMPdBlYet2pJyyu1vq2jVRv8Q01tPQkjzK9ws2dp43tPEaRud+/PfUdWsscsACQm8tjLtstLthmEsPKHNcA0GFxxtrwEqf7yGEHaO27daVUt50DNidtp8XpzQhYXOTvHeTxpPvb+X7OJa7zpgg/BDvjvI0wcdADQEfM1If4uXM52+J+t0W8hi2xt+VZLYY2/MzttPb5F2dR3QZzndsCQW0xvi9OvJrqpwzjM0LSM80ZB62W2RY+P49mtbnloySWOLOFt207Z22O+xZLRHIHi0LO4ed9tiWCNmaJYS2ytNNIZn60tvHP2dScS/WdLTlUZ7NHlre8Rmunpn2J6mLwoyt1IYQQjqEpbQOLOnUhhBCOoSltA4vc70IIIcQgQVfqQgghHENGuYFFnboQQgjH0JS2gaXXnXp2gjsyPe5cqnvT0g3tr4fxNk4bsp/q2+q507t+v5mhXmBxr55Wzp2+tUfMbHoAyPR3Ur2hw3Tih7pMdy0AhN3cpWvLIh+V22Rou/bxTPDSTJ5zXdOeSXWPJRc8k5h6vSRv/JPaiFlytEsCXVTPJdt2RDZ3nMcS3HXcHuXbNmHJ4We0Wdqwtd0Q4brLZbqad2w8k9baMvhtsxNsLnJGu8Wdf+4YfuyXX7yZ6skuc38WF1oWWlzE9f21VI7Vmg71ggO8jea6AqrbztkMS1Z8NG5uF5uDPsPPj9lDTXlUt2XIM33d/pG09mAHnyWzl5/iGEpM/udZXO5NCf49JgY/ulIXQgjhGBp+H1jUqQshhHAMTWkbWNSpCyGEcAxNaRtYNKVNCCGEGCToSl0IIYRjJODAPXVH1uSLSb879el+ni/dkjTdl10Wx+jB5nyq14Z5DnuOz3S71ndw97fv0DCqb2/iy7x95y+o/q+jbzK0iOXzDE3nztOTs49Q/cyXVxvaCxMW0NqQJVe+KN3Mwwfsjvt6kpddY9ne7W08W7sowPO/bRnqbJmdlmxtJ05qv8W1b8tKz7Ssd7aXu6uZQ/0NMjMDAHyWdbG536Mk57vQMqsgw83XO6fAnFUBAK4gP+1dPlP3LrBYsXGQquF3JlPdvfZtQ0vv4uuXUXaY6icvecuyLpzdX55kaE1NubS2upE77ttIfjwA1JDZMABQEDDP/fFFfEZAV20Z1Tvj3KHvJYdKRS4/fzY28jaOB5rSNrBo+F0IIYQYJKhTF0II4RjJ5LFpbX19pep+HzlyJFwul/G69dZbAQA33HCD8d6UKVN6tNHV1YXbb78dhYWFyMzMxLx583DgAH9a5omMOnUhhBCO8fGUtv6+UmHjxo2oqanpfq1cuRIA8JWvfKW7Zvbs2T1qXnrppR5t3HnnnXj22Wfx9NNPY+3atWhra8PcuXMRj/PbdScqMsoJIYT4XDNkSM+0wX/5l3/BSSedhOnTp3drfr8fJSUl9O9DoRAeffRRPPnkk7jkkksAAMuXL0d5eTlWrVqFWbNmfXYr7zC6UhdCCOEYCYdeANDS0tLj1dXFzaJ/SiQSwfLly/GNb3wDLtcxd+Hrr7+OoqIinHLKKVi8eDHq6+u739u0aROi0ShmzpzZrZWVlaGiogLr1q3r66YYEHp9pf5h5HWqV3uLqX42phjau43cSfrbg9xdfVYOd3DWN5irfVoOH6/xWlzHNle4zXX+8kFzXUZmWjKnLY7m0kLu6u34BzMT//nf8G1lc25n+bgT3ZbPHvSa9W8e5jMIzsjlbW8N8f02Jpu7/yeUHDI0r8W5HcxpobqN9g5zXQ408uDyfa38GQQ297sthz1J9nOeJUM8bMlnty2TzRSx/QJv6OKzFtK8vG1kc+d21xlTDa19m2VWxe6tVI+MvYbqSY95/rh/bzriASDNdl49x3PYvVdyF/3o35rtH158Mq2t3ZxL9ZYoPw9HB5u5Xmbegx16Dt9W4xqCVO9q4edh9W7zeRC7jvDv33A8l+rHg0QSSPTTv/7xlLjy8vIe+pIlS7B06dJP/NvnnnsOzc3NuOGGG7q1OXPm4Ctf+QpGjBiBPXv24Ac/+AEuuugibNq0CX6/H7W1tfD5fMjL63mMFRcXo7aWz144UdHwuxBCiBOS6upq5OQc+xHu9/MpvX/Ko48+ijlz5qCs7NiUwWuuOfZjs6KiApMmTcKIESPw4osvYv78+da2kslkj6v9zwPq1IUQQjiGk/PUc3JyenTqn8a+ffuwatUqPPPMM59YV1paihEjRmDnzp0AgJKSEkQiETQ1NfW4Wq+vr8e0adNSXv+BRPfUhRBCOEZ/p7P15ylvjz32GIqKinD55Zd/Yl1DQwOqq6tRWnr08d4TJ06E1+vtds0DQE1NDbZs2fK569R1pS6EEMIxkn/8X3/bSJVEIoHHHnsM119/PTyeY11bW1sbli5dii9/+csoLS3F3r178b3vfQ+FhYW46qqrAADBYBA33ngj7r77bhQUFCA/Px/33HMPxo0b1+2G/7zQ6059iP80qjdG91C9LNO893H9KXwi/6Z6bvb4m93/QfXswBhD29lgRkICwJeiPA52WAY341QMaaP6olNN49a79aW01msxVg07dwvVm7abBpjhuY20dr8lUrepM53qNrJ9pqGrKcJNhatq+IDOmXn8c5ZntVK9qNCMyY1FuRky3MnNX8ycBgBxEjc7vLCeVAKlQW6s2nGYT3fZ384NgZGEuS7ZHr4NgxYjo22ozGbOY9jMoPt3nET1ke6dVM868ntDix3in/3ILh6/XOB7kOqMznpufAuM4vstPnSkpSW+Pw99/XRzma38eJsymZv2xjfzod/sEh75nD7CXHfft7hh8d2Z51D99T3czMe+VzY18vPkSNcXLz191apV2L9/P77xjW/00N1uN95//3386le/QnNzM0pLS3HhhRfi17/+NbKzs7vrHnjgAXg8HixYsADhcBgXX3wxHn/8cbjdPIr3REVX6kIIIRzjqPu9/22kysyZM5EkqTXp6el4+eWXP/XvA4EAHnroITz00EOpL/wEQp26EEIIx9Dz1AcWGeWEEEKIQYKu1IUQQjhGMumAUS7V8HfRjTp1IYQQjqHh94Gl1516R4I7TAPuXKp7ycC+38sd59eeu4HqE4ZcSfUbtppOdA9xPwPAO6Ew1ScVcEdqzNJOR9x08wcska15fh6Tmv79dqqflTHe0P7xNN42c60DQDTB1zsc5buY1b+V2EZrr845g+peFz/1vGl83f0Bc93dlpjUllYeZZqwuN8TSfOAawlz53ZJfgPVzxrOZ3L4D5ZT/YXqAkPL8fL9MLeAu6U/aDTbAPiXWobleLPx0eEiqqdZ9s8I4qJ3/cNCWjvEckx0dtVR3fv2o0Tl3weI8X0cHTKa6i2tV1C99a+fNTS3jy8z65SDXAfXbb3OVd//K0P7p5G8dvwr/0l1j/t9qg8JmDOQajs20tqijAl8oWLQoyt1IYQQjqHh94FFnboQQgjHSKL/w+fq0vuO3O9CCCHEIEFX6kIIIRwjkUw68OhVXav3FXXqQgghHGOgst/FUXrdqbtdPDM5K427d7d3mBnq245wN67H4sb1WNy+d5eYmdb/e4iW4g8dj1D9lLpbqR5P8DsSB8NmxnI4xmunFXPHvY2bhpku7YCHzzaw4bHkf0csbv44yS3ffd8btPapn5vZ9J9EXQd3rnduM7O4S7ObaW15OXcdd3Xy5yl7iIs+3MHd7y6La99H3PkA4Hdzhz4j6OVt17XzbWKD7Z/WhGUmg2VGwMyK96ju8/Mc+vQF2YbmtrjcuyJ8BoHPx78PYrlDzOWdy58FUfeceZwAQNHp3OmdNnwe1fGfVxlS+Fu/5m0U8nPZ+zV+TLR+1/w8AHDDaHNmziHLLIwL0m+k+powmykA1LT/n6GdlfFVWlvV/l9UPx5oStvAonvqQgghxCBBw+9CCCEcIwEH7qlr+L3PqFMXQgjhGDLKDSwafhdCCCEGCbpSF0II4Rhyvw8sve7UxyV5lvDhRDPVm9NMF+jyvfm0dkbHKKrn+bjr+KVDptu3KWm67QHgssybqV6Ryx3AuZbc9vaYuakmFzXS2plvPUP16/K4474lan7O9qiP1tpGpWzZ750W93t5trm9Fi/5a1p72bBmqucFuMvf5rg/QlzA9eFSWvtuPdfdLr4BbDn8qbTRFuUzPGzbMEDkAj8/ZtnxAwBey6yFBBlEsw2r5Xn5sbzvUBnVKyo+oHrnKZcaWvrqf6C13hj/nJGR3LnubWs2tOgZk2ht3nh+7PtO5W5+4HqqxhJPGFoimz9/weZyt9F5JEj1c04zn5+wbTfPrF/kzqH6A2WXUP2eN0ca2uvh5ZY1HDh0T31g0fC7EEIIMUjQ8LsQQgjH0JX6wKJOXQghhGPonvrAouF3IYQQYpDQ6yv10ZlmTCoABLt49GumxzSznZxt+/XF9e0tPBL0SNKMUD0tkEtrS9P5EodnmkY+AMjycdPRlNz9hlY2tIbW5r5fQfUzcrm5KOA2zVIsJhQAmiN8m5RkcAOQ28V3cZiYwn7y5Zdp7Qdbx1L9w8ZCqttMa+kkyjXHEhHcaTGWZXqjVG8nn6fFYjYMWvaxbb0L07khcFROyNAOtJlRqwDQYTHbReL8d3UriSDO8fL1S1gMfi2d/OCvP8BNiPn3vG5o3lE8DtY70mI4y8ikeqxwmFl7YCetdR2up7oNZoiz4S809xkAjMji5rR9bauoHm7hsb8j//sdQ/vDZB6zfGrBYaoHc/h304Q883i+p3Qurb1802+ofjxIOjD8riv1vqPhdyGEEI6RcCWsz1fodRtKf+8z6tSFEEI4RgJJuGSUGzB0T10IIYQYJOhKXQghhGMk/ziprb9tiL6hTl0IIYRjJAAHht9FX+l3p37+EO7IHZtnOtSzLRGs/1hVQvVdabuoPgRmfa6Pu8VruXEZO1p4RGNZOl9HF4kWPWfF+7R2zXnckbr6IF/HUNR0Ro/xcJd3MsnbONjO3bgl6R1UHzHEdBj7snmtx+IKjyf43Zu4JYa12eIAZ2RYlhm1LNOdZi7T5maPWNqw3YvypfFZC0PzTWf4/lZ+XNmiaW16LnG6t5DjBAAyPfwrsKmLz1i5f+OZVL+guNXQzm81Y08BIO8Id6hnR3dQPXOx2U70l/zrp3HtSVTfMS+P6vH7F1M9bbTp/veU8y+ED+7aRPXmj8ZRfcPW06j+49HnGtq7DXwff2nYPqq/s/tkqpdnmN8Jz+0vprUXpN9IdTH40ZW6EEIIx5D7fWBRpy6EEMIxEkjA1c9OWZ1635H7XQghhBgk6EpdCCGEY+hKfWBRpy6EEMIxNKVtYOl1pz61kDujbbnYhZmmk9adxnfUP0w4RPWX9p5C9baY6QAfkcnd4rWd/CMO8fP8b5ZPDgCN4QxD+5dRN9PaZ3bzZWZbXMozyswMeb8l47wtyrPfbU50G7n5zYYWbedZ4W6L6aU005Y3z+trOsxc8M4UHPGAfapLMcm+T/fwtkMWV3hzhGfFTxyxm+olo6sNbWcdz1U/RI6fT8JL3PxFAX5MFFnOQa8lV//qkW1Ur+swZ1BMf4VnuQcTk6h+Q8ksqm+Z/aGhxWq44zx7BH+mgifQRfVIQ5Dq7nazPtZWQGsb95VR/fENk6n+YP1aqv/90KmGdt5Q87kRADB02EGqV1z8JtU9I8yZOb+892u0FkjteBODB12pCyGEcAy53wcWGeWEEEI4RhKJfv8v1eH3pUuXwuVy9XiVlBzLM0kmk1i6dCnKysqQnp6OGTNmYOvWrT3a6Orqwu23347CwkJkZmZi3rx5OHDggCPb5HiiTl0IIYRjJBF35JUqZ5xxBmpqarpf779/LBzsRz/6Ee6//34sW7YMGzduRElJCS699FK0th67TXznnXfi2WefxdNPP421a9eira0Nc+fORTye+roMJBp+F0II8bnH4/H0uDr/mGQyiQcffBDf//73MX/+fADAE088geLiYjz11FO4+eabEQqF8Oijj+LJJ5/EJZdcAgBYvnw5ysvLsWrVKsyaxb0iJyK6UhdCCOEY/R98T3TfU29paenx6uriZkkA2LlzJ8rKyjBq1Chce+212L37qMF1z549qK2txcyZM7tr/X4/pk+fjnXr1gEANm3ahGg02qOmrKwMFRUV3TWfF3p9pV7VxN2UIyNeqmd6TXd5QVYLra1p4e5Vn5vfVzkp3XSoTx/5Ea0NW5zOuxqGUD3g5u73sqCZZb8tlE1rO3gTCLh5bnt71HRdt0T4eics2e+ZFrd8Arx+X/UwQ7M56Fs7+bokLc9saLE49P1k9kO2JePe9nkiFrc8W5c0S666z5IJXxjguf+5+ea+B4Caj4Yb2u42nsGf7bEM4VmOcboePj5jw8aI/CNU91vaefODIkObFTiD1v7DzDeoXjzv93xl8szc9uSH/AvalcH3m3c83/fxD/l+aye56A0H+HMmtlaPpPrL9XxmQWuXOfMBAC4eXWhoeXnNtHbIfH6/NjzlSqp7Vj1taFdf9BqtPeM9vt+OB0efhd5fo9zRY6C8vLyHvmTJEixdutSonzx5Mn71q1/hlFNOQV1dHX74wx9i2rRp2Lp1K2prawEAxcU9j4fi4mLs23c0f7+2thY+nw95f3acFhcXd//95wUNvwshhDghqa6uRk7OsYck+f38gmHOnDnd/z1u3DhMnToVJ510Ep544glMmTIFAOBy9bzASSaThvbn9KbmREPD70IIIRzDSaNcTk5Oj5etU/9zMjMzMW7cOOzcubP7PvufX3HX19d3X72XlJQgEomgqanJWvN5QZ26EEIIx3Dynnpf6erqwrZt21BaWopRo0ahpKQEK1eu7H4/Eolg9erVmDZtGgBg4sSJ8Hq9PWpqamqwZcuW7prPCxp+F0II8bnmnnvuwRVXXIHhw4ejvr4eP/zhD9HS0oLrr78eLpcLd955J+69916MGTMGY8aMwb333ouMjAwsXLgQABAMBnHjjTfi7rvvRkFBAfLz83HPPfdg3Lhx3W74zwvq1IUQQjjGQGS/HzhwAF/96ldx5MgRDBkyBFOmTMH69esxYsQIAMC3v/1thMNh3HLLLWhqasLkyZPxyiuvIDv7mNn5gQcegMfjwYIFCxAOh3HxxRfj8ccfh9udWpT1QONKJm0e5p6UZU2nemGSZyZfmGM6ab8+dgetrW3JpXpLF79/MjQnZGg5GTybvjXM88x3NJouVQC47Jy3qF70+N8a2j+OXE9rIwlurLDd68gkzuiAm++WYkvOd4bFRd4V7/3vtkMdfIZD0OKWjlnc8i6L65xVp1IL2B3tLLM/HOOfvcOi21zxtmMi1mXOWlj+Fs8K95MsdwAIWJbJjqAxeY20dnhRHdXjcb4Vm1pzqH7P2+aMkEcv5LNKxlzF88nDc66hurdhj6F53t9MaxHj2yQ5ahTVXXvMtgFg92/PNTS3ZXZL1Z6TqH7nRzyH/kDb61Tfc/VEQxu2wMy9BwDvAv7sBBtdb1YYWvKNXbS24d0xVC9b/k5Ky0yFlpYWBINBFGdOQ5qrf9eLiWQMde3rEAqFehjlxKeje+pCCCHEIEHD70IIIRxDj14dWNSpCyGEcIxEMg5+AynVNkRfUKcuhBDCMXSlPrD0ulM/KXEq1Qs83Mw2Ib/N0Notka1DLQagMwsaqN7UlGtoO2q5Yc9jieG0mbzKfvUB1XeGfmZo2Z7xtNZGgZ8bzlgkqs3kZYtJtcXbetP4L17WzugcHuMbtxj/bOvitpjComSbp4HX2tqwweJzW6M8wthmiItbIng/3MFNRyeP2GdoZ+Q209odIR6FzLYJwA2EHzQW0NpDbTyu2Ea7ZbvcMMI8V7oi/PyO1fNzObCTm0ddnabBMxnix2wyyreJf/pOqtuo+4b5/RFu42ZQFmsNAHkJHid92ZBbqZ5MbjBFn2moBIDWvbOp7t/3HtWj+aWG5pnKDbJDv/0+1ZPLqSwGEbpSF0II4RhHr9T7N3yuK/W+o05dCCGEYySTCeuDpFJpQ/QNTWkTQgghBgm6UhdCCOEYR4fO+3mlruH3PqNOXQghhGMkHZiO5kQbX1R63akvLOe/vDI8PJ41z99paNPX/W9vFwcAOHjdOKp7SSTowY5MWvtGPXf6/rbFdLMDwM6/4DGfr2wzIxpbY9z9XeDnjtQGEisKALWdpsM46OXO4KIAj4m1uXcDxFkPAAniuq5p5y7qNotbusvi3LbOLCBRvl0WB316Gv/8NpjLv4AcgwDQaYnOdafxq4P3jpiRxwCwn8Qbeyxt2Jz1HTanN3H/d1pmIexp4w71U7L5568YwmNls0kEcYYlljgxn58nkaIzqJ6x/r8NretAPq11uWxXaXw2jI2CX3zP0Dxp19ParXOyqP6j0/m+b+jkM0VKz9puih38HAy8v4bqyZxcqie8pnM/rZnPHPrF2BuoLgY/ulIXQgjhGEdtchp+HyjUqQshhHCMo851ud8HCrnfhRBCiEGCrtSFEEI4Rn+DZ5xq44uKOnUhhBCOkUwmgf5mvydTi4kWx+h1p16S0U71DIu7em8Lz7pm7Jg3herPb+RO2omlBwytwN9Fa+8af5Dqj4wfQfW167jeGjU3Vb6PO7RtTudsi6M9QLLIMz18uwYD3NEcTOf7J2DZLlUHhxvaR618BkEaySEHgOp27ly3nY4HO3IMLWpzhVvM78Mz+S/40Vmms96Whz8kM8SXGeGzE4os29ZPZmFUWZzyNgotMyVYln2OZT9kWp5vcEZhPdVPGmlm1gNAkiyz6LyttDbt1F9SnfvwgUTGi+byYny7JpOW5x68Nprqvgt3W5ZqEn2EH7PexW9Qvel28zwBgPSyI1RPzJ1gaF0B7qx3d/DjMK2tmeq+uo9MsaGJ1o4rqqH68cAJk5uMcn1H99SFEEKIQYKG34UQQjjG0eCY/g2fy/3ed9SpCyGEcAwnOmR16n1Hw+9CCCHEIEFX6kIIIRxDRrmBpdedemuUO4PjlpzvQktGOeOf106kenOU79hzh5r6JZM20tqcEbVUjzTxnPOyIHeT1ofN3GVbbrktS8llcy8Tp7utNhrn29vmUG+wzEJo6DJ9ym1RvubplqPktBzu3C5K5w79woDpULetd7vleLNl/O9vTze0TA8/fna08H1f18k/6EnZfAYBm7XgtnyeHMvMBx9pAwA8pJ2o5VxLc/HjMGLJuGcudwDIGmLmiLuGBGhtZxfPj0/E2qjuLjvJ0DL+9Wu01oYtt91G8n/vMrTEaSfT2pa266juatzCG3/6BSp79+801yODH7OuEP+uQXMrlRON5n6Lhfl8g1Fjej8jwGk0/D6waPhdCCGEGCRo+F0IIYRjaPh9YFGnLoQQwjE0pW1g0fC7EEIIMUjo9ZX6/9Vzc9GlpdzsEU2Y5p0bC2+ltX8x/DDVP2jKo3pOtmkkySjgkYueHB5FGdpbSvW9jYVU96b1/pejLSa2JeKler7PNGK1RLgBxmZy8vkiVHdb2skkEaeTCri5scnSRl0nN7Mlwtxc1RY1P7/NWGbTMyzGMrbND3fxw7smzH/LHu7kbX+pyDT4Adzk1hHj+zhiMbm1k20CADHL52cELfveRt5oM2YZAHwntxCV73vf+v+kuquBn8uxk043tFSNb6kSPucyQ8spe9JS/fdU7Xj/fKp31eZTPWMYMRvW8kjZeD3ftoHvclNl87eGGVrSclzZ9OND/7Pf+3ul/0VGw+9CCCEcw5nnqatT7yvq1IUQQjjGUZNbPzt1Xan3Gd1TF0IIIQYJulIXQgjhIP2/Utc99b6jTl0IIYRzOHBPHbqn3md63alPKeQu8jOG7ad6e4cZq7p8TxatHV3Eo1y3NedSPZk07xokLfGp4eoiqu/cZcZWAkA6iWwFgKYu09HdbHGzu9MsUaE+3naIRKJGLBG0OT5L2zk8WnLoqGqq+7eNMbQDIT7boMgS+euzzAiwzRRoJU7vve3cARxN8C+FkZnc6R0h+99r2Q/NkdScuTFyvAFAe5f5efwWd77tPpfNFd9JPk+JJX7XFh+7zxIRfG4Hn53gyyPbvLaZ1rqa9lE9UXEK1b3jbyHqBlqbKrHEE1SPJ8xZJbHEJbTW5sR3/4Gv484t51H9lefMz/+tR1fR2q6tfH/WXD+C6r78g4bmHca/l8Pb+PeeGPzoSl0IIYRjyCg3sKhTF0II4SC6pz6QyP0uhBDic819992Hc845B9nZ2SgqKsKVV16J7du396i54YYb4HK5erymTJnSo6arqwu33347CgsLkZmZiXnz5uHAAR7WdKKiTl0IIYSDJI8a3frzSvFKffXq1bj11luxfv16rFy5ErFYDDNnzkR7e0/PwezZs1FTU9P9eumll3q8f+edd+LZZ5/F008/jbVr16KtrQ1z585FPM69MiciGn4XQgjhIE7cEU+thcrKyh7/fuyxx1BUVIRNmzbhggsu6Nb9fj9KSkpoG6FQCI8++iiefPJJXHLJUUPl8uXLUV5ejlWrVmHWrFkpfoaBoded+l9+8It+L+x3Kdaf0e8l2rng00sGNQVEm3zc10J8kUkmr/tM23fzCSSUVNflzG9Z9BTa8M7gek5Ka8LhT+o4njhzT7ylpefzCPx+P/x+PmPmTwmFjj4LJD+/Z0b/66+/jqKiIuTm5mL69On453/+ZxQVHZ0psGnTJkSjUcycObO7vqysDBUVFVi3bt3nplPX8LsQQoh+4/P5/ngVHHfklZWVhfLycgSDwe7Xfffd96nrkUwmcdddd+H8889HRUVFtz5nzhysWLECr776Kn76059i48aNuOiii9DVdXTqY21tLXw+H/Lyek7tLS4uRm0tn3Z9IqLhdyGEEP0mEAhgz549iERSe2qgjWQyCZerp4u+N1fpt912G9577z2sXbu2h37NNdd0/3dFRQUmTZqEESNG4MUXX8T8+fNTWo8TGXXqQgghHCEQCCAQ4OFGx4Pbb78dL7zwAtasWYNhw8xH1f4ppaWlGDFiBHbu3AkAKCkpQSQSQVNTU4+r9fr6ekybNu0zXW8n0fC7EEKIzzXJZBK33XYbnnnmGbz66qsYNWrUp/5NQ0MDqqurUVpaCgCYOHEivF4vVq5c2V1TU1ODLVu2fK46dVdSD64VQgjxOeaWW27BU089heeffx6nnnpqtx4MBpGeno62tjYsXboUX/7yl1FaWoq9e/fie9/7Hvbv349t27YhO/uotfCb3/wmfve73+Hxxx9Hfn4+7rnnHjQ0NGDTpk1wp+K8HEDUqQshhPhcY7vn/dhjj+GGG25AOBzGlVdeiXfeeQfNzc0oLS3FhRdeiH/6p39CeXl5d31nZyf+5m/+Bk899RTC4TAuvvhi/OxnP+tRc6KjTl0IIYQYJOieuhBCCDFIUKcuhBBCDBLUqQshhBCDBHXqQgghxCBBnboQQggxSFCnLoQQQgwS1KkLIYQQgwR16kIIIcQgQZ26EEIIMUhQpy6EEEIMEtSpCyGEEIOE/x/RllGn7oJZxwAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 8 }, { "cell_type": "markdown", @@ -244,49 +260,39 @@ }, { "cell_type": "code", - "execution_count": 15, + "source": [ + "image, affine, inversion_times = fetch.t1_molli_philips()\n", + "mapper = T1(image[32:-32, 32:-32, :2, :], inversion_times * 1000, affine=affine, multithread=True, molli=True)\n", + "mapper.to_nifti(output_directory=OUTPUT_DIR, base_file_name='Philips_MOLLI', maps='all')" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:29:20.751416Z", + "start_time": "2024-09-30T12:26:24.268676Z" + } + }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:122: UserWarning: MOLLI requires a three parameter fit, using parameters=3.\n", + "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:286: UserWarning: MOLLI requires a three parameter fit, using parameters=3.\n", " warnings.warn('MOLLI requires a three parameter fit, '\n", - "100%|██████████| 184320/184320 [20:08<00:00, 152.58it/s]\n", - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:145: RuntimeWarning: invalid value encountered in true_divide\n", + "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:325: RuntimeWarning: invalid value encountered in divide\n", " correction_factor = (self.m0_map * self.eff_map) / self.m0_map - 1\n", - "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:146: RuntimeWarning: invalid value encountered in true_divide\n", + "D:\\ppzajd\\NextCloud\\University\\Renal Imaging\\ukat\\ukat\\mapping\\t1.py:326: RuntimeWarning: invalid value encountered in divide\n", " percentage_error = self.t1_err / self.t1_map\n" ] } ], - "source": [ - "image, affine, inversion_times = fetch.t1_molli_philips()\n", - "mapper = T1(image[32:-32, 32:-32, :, :], inversion_times * 1000, affine=affine, multithread=False, molli=True)\n", - "mapper.to_nifti(output_directory=OUTPUT_DIR, base_file_name='Philips_MOLLI', maps='all')" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + "execution_count": 10 }, { "cell_type": "code", - "execution_count": 16, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "fig, ax1 = plt.subplots()\n", "im = ax1.imshow(mapper.t1_map[:, :, 1].T, origin='lower', cmap='inferno', clim=(250, 2250))\n", @@ -300,8 +306,25 @@ "collapsed": false, "pycharm": { "name": "#%%\n" + }, + "ExecuteTime": { + "end_time": "2024-09-30T12:29:42.441042Z", + "start_time": "2024-09-30T12:29:42.126351Z" } - } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 11 } ], "metadata": { @@ -325,4 +348,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} \ No newline at end of file +} From dd62929730308a7edfa5d7caec0c0c0a8b4dc3ca Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Mon, 30 Sep 2024 13:56:25 +0100 Subject: [PATCH 04/15] Fix some pep8 issues --- ukat/mapping/t1.py | 20 +++++++++++--------- ukat/mapping/tests/test_t1.py | 1 - 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/ukat/mapping/t1.py b/ukat/mapping/t1.py index a95748e..11a8e4c 100644 --- a/ukat/mapping/t1.py +++ b/ukat/mapping/t1.py @@ -68,7 +68,8 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, # If the fifth percentile of the first inversion time is # less than the negative of 5% of the recovered signal # then assume the data has been magnitude corrected - if np.percentile(pixel_array[..., 0], 5) < -recovered_signal * 0.05: + if (np.percentile(pixel_array[..., 0], 5) + < -recovered_signal * 0.05): self.mag_corr = True neg_percent = (np.sum(pixel_array[..., 0] < 0) / pixel_array[..., 0].size) @@ -231,14 +232,15 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, 'auto' attempts to apply multithreading where appropriate based on the number of voxels being fit. """ - assert multithread in [True, False, - 'auto'], \ - (f'multithreaded must be True, False or auto. ' - f'You entered {multithread}') - assert mag_corr in [True, False, - 'auto'], \ - (f'mag_corr must be True, False or auto. ' - f'You entered {mag_corr}') + assert multithread in [True, + False, + 'auto'], (f'multithreaded must ' + f'be True, False or auto. You ' + f'entered { multithread}.') + assert mag_corr in [True, + False, + 'auto'], (f'mag_corr must be True, False or auto. ' + f'You entered {mag_corr}.') self.pixel_array = pixel_array self.shape = pixel_array.shape[:-1] diff --git a/ukat/mapping/tests/test_t1.py b/ukat/mapping/tests/test_t1.py index 9ffc4a5..45933dc 100644 --- a/ukat/mapping/tests/test_t1.py +++ b/ukat/mapping/tests/test_t1.py @@ -295,7 +295,6 @@ def test_mag_corr_options(self): mag_corr='yes please', multithread=False) - def test_auto_mag_corr(self): # Test warning for small number of negative values thus assuming no # magnitude correction has been performed From e11d70e0736a1cd6b28655036d68a6768c069052 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Mon, 30 Sep 2024 13:56:54 +0100 Subject: [PATCH 05/15] Upgrade to codecov v4 Because codecov isn't working... again... --- .github/workflows/python_CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 5b722cd..8d126db 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -44,7 +44,7 @@ jobs: run: | pytest --cov-report=xml --cov=ukat - name: Upload coverage to Codecov - uses: codecov/codecov-action@v3 + uses: codecov/codecov-action@v4 with: env_vars: OS,PYTHON fail_ci_if_error: true From 4928e22beae81e57608e4b6d6a7aaa10f54faf6f Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Mon, 30 Sep 2024 14:06:59 +0100 Subject: [PATCH 06/15] More pep8 fixes --- ukat/mapping/t1.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ukat/mapping/t1.py b/ukat/mapping/t1.py index 11a8e4c..017d064 100644 --- a/ukat/mapping/t1.py +++ b/ukat/mapping/t1.py @@ -69,7 +69,7 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, # less than the negative of 5% of the recovered signal # then assume the data has been magnitude corrected if (np.percentile(pixel_array[..., 0], 5) - < -recovered_signal * 0.05): + < -recovered_signal * 0.05): self.mag_corr = True neg_percent = (np.sum(pixel_array[..., 0] < 0) / pixel_array[..., 0].size) From 3ace838d19f49c5dd79f0f00ee686a4422d7b777 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Wed, 13 Nov 2024 16:53:32 +0000 Subject: [PATCH 07/15] Removed automatic model selection entirely Was more trouble than it was worth implementing it! --- ukat/mapping/t1.py | 67 ++++++++--------------------------- ukat/mapping/tests/test_t1.py | 48 ++++--------------------- 2 files changed, 21 insertions(+), 94 deletions(-) diff --git a/ukat/mapping/t1.py b/ukat/mapping/t1.py index 017d064..f3f1aab 100644 --- a/ukat/mapping/t1.py +++ b/ukat/mapping/t1.py @@ -43,15 +43,13 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, would be along the TI axis and would be meaningless. If `pixel_array` is single slice (dimensions [x, y, TI]), then this should be set to None. - mag_corr : {True, False, 'auto'}, optional + mag_corr : bool, optional Default False If True, the data is assumed to have been magnitude corrected using the complex component of the signal and thus negative values represent inverted signal. If False, the data will be fit to the modulus of the expected signal, negative values are - simply considered part of the noise in the data. If 'auto', - the data will be assumed to have been magnitude corrected if 5% - of the initial inversion time data is negative. + simply considered part of the noise in the data. multithread : bool, optional Default True If True, the fitting will be performed in parallel using all @@ -61,47 +59,15 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, self.tss = tss self.tss_axis = tss_axis - if mag_corr == 'auto': - # Find a very rough estimate of the fully recovered signal - recovered_signal = np.percentile(pixel_array[..., -1], 95) - - # If the fifth percentile of the first inversion time is - # less than the negative of 5% of the recovered signal - # then assume the data has been magnitude corrected - if (np.percentile(pixel_array[..., 0], 5) - < -recovered_signal * 0.05): - self.mag_corr = True - neg_percent = (np.sum(pixel_array[..., 0] < 0) - / pixel_array[..., 0].size) - if neg_percent < 0.05: - warnings.warn('Fitting data to a magnitude corrected ' - 'inversion recovery curve however, less ' - 'than 5% of the data from the first ' - 'inversion is negative. If you have ' - 'performed magnitude correction ignore ' - 'this warning, otherwise the negative ' - 'values could be due to noise or ' - 'preprocessing steps such as EPI ' - 'distortion correction and registration.\n' - f'Percentage of first inversion data that ' - f'is negative = {neg_percent:.2%}') - else: - self.mag_corr = False - if np.nanmin(pixel_array) < 0: - warnings.warn('Negative values found in data from the ' - 'first inversion but as the first ' - 'percentile is not negative, it is assumed ' - 'these are negative due to noise or ' - 'preprocessing steps such as EPI ' - 'distortion correction and registration. ' - 'As such the data will be fit to the ' - 'modulus of the recovery curve.\n' - f'Min value = ' - f'{np.nanmin(pixel_array[..., 0])}\n' - '5th percentile = ' - f'{np.percentile(pixel_array[..., 0], 5)}') - else: - self.mag_corr = mag_corr + if (mag_corr == False) & (np.nanmin(pixel_array) < 0): + warnings.warn('Negative values found in data, this could be due ' + 'to noise or preprocessing steps, however if you ' + 'have magnitude corrected your data, remember to ' + 'set mag_corr=True\n' + f'Min value = ' + f'{np.nanmin(pixel_array[..., 0])}\n') + + self.mag_corr = mag_corr if self.parameters == 2: if self.mag_corr: @@ -207,15 +173,13 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, The number of parameters to fit the data to. A two parameter fit will estimate S0 and T1 while a three parameter fit will also estimate the inversion efficiency. - mag_corr : {True, False, 'auto'}, optional + mag_corr : bool, optional Default False If True, the data is assumed to have been magnitude corrected using the complex component of the signal and thus negative values represent inverted signal. If False, the data will be fit to the modulus of the expected signal, negative values are - simply considered part of the noise in the data. If 'auto', - the data will be assumed to have been magnitude corrected if 5% - of the initial inversion time data is negative. + simply considered part of the noise in the data. molli : bool, optional Default False. Apply MOLLI corrections to T1. @@ -238,9 +202,8 @@ def __init__(self, pixel_array, inversion_list, affine, tss=0, tss_axis=-2, f'be True, False or auto. You ' f'entered { multithread}.') assert mag_corr in [True, - False, - 'auto'], (f'mag_corr must be True, False or auto. ' - f'You entered {mag_corr}.') + False], (f'mag_corr must be True or False. ' + f'You entered {mag_corr}.') self.pixel_array = pixel_array self.shape = pixel_array.shape[:-1] diff --git a/ukat/mapping/tests/test_t1.py b/ukat/mapping/tests/test_t1.py index 45933dc..8daf72a 100644 --- a/ukat/mapping/tests/test_t1.py +++ b/ukat/mapping/tests/test_t1.py @@ -289,54 +289,18 @@ def test_mag_corr_options(self): npt.assert_almost_equal(mapper.r1_map().mean(), 1 / self.t1) npt.assert_almost_equal(mapper.r2.mean(), 1) + # Test negative values warning when mag_corr is False + with pytest.warns(UserWarning): + signal_array[0, 0, 0, 0] = -1000 + mapper = T1(signal_array, self.t, self.affine, mag_corr=False, + multithread=False) + # Test with mag_corr not recognised input with pytest.raises(AssertionError): mapper = T1(signal_array, self.t, self.affine, mag_corr='yes please', multithread=False) - def test_auto_mag_corr(self): - # Test warning for small number of negative values thus assuming no - # magnitude correction has been performed - - # Make the absolute of the signal into a 4D array - signal_array = np.tile(np.abs(self.correct_signal_two_param), - (10, 10, 3, 1)) - # Add a single negative value to the signal - signal_array[0, 0, 0, 0] = -1000 - - with pytest.warns(UserWarning): - mapper = T1(signal_array, self.t, self.affine, - mag_corr='auto', multithread=False) - - # Test warning for enough negative values to assume magnitude - # correction has been performed but still not that many negative values - - # Make the of the signal into a 4D array - signal_array = np.tile(np.abs(self.correct_signal_two_param), - (10, 10, 3, 1)) - # Add a row of signals with negative values to the image - # 3.3% of first inversion is negative but 1st percentile is negative. - signal_array[:, 0, 0, :] = self.correct_signal_two_param - - with pytest.warns(UserWarning): - mapper = T1(signal_array, self.t, self.affine, - mag_corr='auto', multithread=False) - - # Test that giving abs data leads to mag_corr = False - signal_array = np.tile(np.abs(self.correct_signal_two_param), - (10, 10, 3, 1)) - mapper = T1(signal_array, self.t, self.affine, mag_corr='auto', - multithread=False) - assert mapper.mag_corr is False - - # Test that giving mag corrected data leads to mag_corr = True - signal_array = np.tile(self.correct_signal_two_param, - (10, 10, 3, 1)) - mapper = T1(signal_array, self.t, self.affine, mag_corr='auto', - multithread=False) - assert mapper.mag_corr is True - def test_molli_2p_warning(self): signal_array = np.tile(self.correct_signal_three_param, (10, 10, 3, 1)) From 23b5dd4788666685246ed3850294d243e11ea22d Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Wed, 13 Nov 2024 17:09:56 +0000 Subject: [PATCH 08/15] Bug when merging --- ukat/mapping/tests/test_t1.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ukat/mapping/tests/test_t1.py b/ukat/mapping/tests/test_t1.py index 9d5de24..bca7e45 100644 --- a/ukat/mapping/tests/test_t1.py +++ b/ukat/mapping/tests/test_t1.py @@ -168,7 +168,7 @@ def test_failed_fit(self): signal_array = np.tile(self.signal_fail_fit, (10, 10, 3, 1)) # Fail to fit using the 2 parameter equation - mapper_two_param = T1(signal_array[..., 2], self.t[:2], self.affine, + mapper_two_param = T1(signal_array[..., :2], self.t[:2], self.affine, parameters=2, mag_corr=True, multithread=True) assert mapper_two_param.shape == signal_array.shape[:-1] # Voxels that fail to fit are set to zero From cfa43238742f80f729c7b02a5b307468d57571a4 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 14:39:23 +0000 Subject: [PATCH 09/15] More issues with merge fixed --- ukat/mapping/tests/test_t1.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ukat/mapping/tests/test_t1.py b/ukat/mapping/tests/test_t1.py index bca7e45..83750d7 100644 --- a/ukat/mapping/tests/test_t1.py +++ b/ukat/mapping/tests/test_t1.py @@ -169,7 +169,7 @@ def test_failed_fit(self): # Fail to fit using the 2 parameter equation mapper_two_param = T1(signal_array[..., :2], self.t[:2], self.affine, - parameters=2, mag_corr=True, multithread=True) + parameters=2, mag_corr=False, multithread=True) assert mapper_two_param.shape == signal_array.shape[:-1] # Voxels that fail to fit are set to zero npt.assert_equal(mapper_two_param.t1_map.mean(), 0) @@ -180,7 +180,7 @@ def test_failed_fit(self): # Fail to fit using the 3 parameter equation mapper_three_param = T1(signal_array[..., :2], self.t[:2], self.affine, - parameters=3, mag_corr=True, multithread=True) + parameters=3, mag_corr=False, multithread=True) assert mapper_three_param.shape == signal_array.shape[:-1] # Voxels that fail to fit are set to zero npt.assert_equal(mapper_three_param.t1_map.mean(), 0) From ee45e6f8a4c138ab69a97d931be36ccf346c3161 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 15:03:21 +0000 Subject: [PATCH 10/15] More issues with codecov. Trying v5 --- .github/workflows/python_CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 8d126db..2f0e8bc 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -44,7 +44,7 @@ jobs: run: | pytest --cov-report=xml --cov=ukat - name: Upload coverage to Codecov - uses: codecov/codecov-action@v4 + uses: codecov/codecov-action@v5 with: env_vars: OS,PYTHON fail_ci_if_error: true From 17d73ebce5627c43361490385b867d5eded07481 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 15:04:21 +0000 Subject: [PATCH 11/15] Pep8 fix --- ukat/mapping/t1.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ukat/mapping/t1.py b/ukat/mapping/t1.py index 79902fe..53f16f7 100644 --- a/ukat/mapping/t1.py +++ b/ukat/mapping/t1.py @@ -60,7 +60,7 @@ def __init__(self, pixel_array, ti, parameters=2, mask=None, tss=0, self.tss_axis = tss_axis self.molli = molli - if (mag_corr == False) & (np.nanmin(pixel_array) < 0): + if (mag_corr is False) & (np.nanmin(pixel_array) < 0): warnings.warn('Negative values found in data, this could be due ' 'to noise or preprocessing steps, however if you ' 'have magnitude corrected your data, remember to ' From 7266336dd100188f0b8acbe918901391fb1bd807 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 15:05:24 +0000 Subject: [PATCH 12/15] Codecov v5 isn't actually released yet --- .github/workflows/python_CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 2f0e8bc..8d126db 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -44,7 +44,7 @@ jobs: run: | pytest --cov-report=xml --cov=ukat - name: Upload coverage to Codecov - uses: codecov/codecov-action@v5 + uses: codecov/codecov-action@v4 with: env_vars: OS,PYTHON fail_ci_if_error: true From c5fa673c914a7c6d66c35223421d9c474ffac123 Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 16:07:02 +0000 Subject: [PATCH 13/15] Changed how codecov gets its token --- .github/workflows/python_CI.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 8d126db..0339274 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -49,5 +49,6 @@ jobs: env_vars: OS,PYTHON fail_ci_if_error: true verbose: false - env: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + token: ${{ secrets.CODECOV_TOKEN }} +# env: +# CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} From 96caf2461f003c51b6cedc553fddd4db103d8c6c Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 16:21:56 +0000 Subject: [PATCH 14/15] Changed codecov to verbose and specified coverage xml files --- .github/workflows/python_CI.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 0339274..9d421b4 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -48,7 +48,6 @@ jobs: with: env_vars: OS,PYTHON fail_ci_if_error: true - verbose: false + files: ./coverage1.xml,./coverage2.xml,!./cache + verbose: true token: ${{ secrets.CODECOV_TOKEN }} -# env: -# CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} From 2d31d08b6c27ca2fbad7167d804f39450b1d88ee Mon Sep 17 00:00:00 2001 From: Alex Daniel Date: Thu, 14 Nov 2024 16:49:34 +0000 Subject: [PATCH 15/15] Removed coverage files --- .github/workflows/python_CI.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 9d421b4..2de58d4 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -48,6 +48,5 @@ jobs: with: env_vars: OS,PYTHON fail_ci_if_error: true - files: ./coverage1.xml,./coverage2.xml,!./cache verbose: true token: ${{ secrets.CODECOV_TOKEN }}