From ad11a9d3ea5c1064d394152bea84f4f77e4233da Mon Sep 17 00:00:00 2001 From: algol Date: Thu, 2 Apr 2026 14:04:08 +0100 Subject: [PATCH 1/2] changes for dark field correction --- httomolibgpu/misc/rescale.py | 1 - httomolibgpu/prep/normalize.py | 82 ++++++++++++++++++++++++++---- tests/test_prep/test_normalize.py | 60 ++++++++++++++++++++++ tests/test_prep/test_stripe.py | 10 ++-- tests/test_recon/test_algorithm.py | 38 +++++++------- 5 files changed, 155 insertions(+), 36 deletions(-) diff --git a/httomolibgpu/misc/rescale.py b/httomolibgpu/misc/rescale.py index 2510a7fe..845e31bb 100644 --- a/httomolibgpu/misc/rescale.py +++ b/httomolibgpu/misc/rescale.py @@ -33,7 +33,6 @@ from httomolibgpu.misc.utils import ( __check_variable_type, - __check_if_data_3D_array, __check_if_data_correct_type, ) diff --git a/httomolibgpu/prep/normalize.py b/httomolibgpu/prep/normalize.py index e805a241..a6224946 100644 --- a/httomolibgpu/prep/normalize.py +++ b/httomolibgpu/prep/normalize.py @@ -21,6 +21,7 @@ """Modules for raw projection data normalization""" from httomolibgpu import cupywrapper +import numpy as np cp = cupywrapper.cp cupy_run = cupywrapper.cupy_run @@ -32,8 +33,8 @@ else: mean = Mock() -from typing import Union -from numpy import float32 +from typing import Union, Optional +from numpy import float32, int64 from httomolibgpu.misc.utils import ( __check_variable_type, __check_if_data_3D_array, @@ -49,7 +50,8 @@ def dark_flat_field_correction( darks: cp.ndarray, flats_multiplier: Union[float, int] = 1.0, darks_multiplier: Union[float, int] = 1.0, - cutoff: Union[float, int] = 10.0, + upper_bound: Optional[Union[float, int]] = None, + lower_bound: Optional[Union[float, int]] = None, ) -> cp.ndarray: """ Perform dark/flat field correction of raw projection data. @@ -66,8 +68,10 @@ def dark_flat_field_correction( A multiplier to apply to flats, can work as an intensity compensation constant. darks_multiplier: float,int A multiplier to apply to darks, can work as an intensity compensation constant. - cutoff : float,int - Permitted maximum value for the normalised data. + upper_bound : Optional[float, int] + All values above the upper bound are set to the provided value. Default None. + lower_bound : Optional[float, int] + All values bellow the lower bound are set to the provided value. Default None. Returns ------- @@ -92,10 +96,21 @@ def dark_flat_field_correction( __check_variable_type( darks_multiplier, [int, float], "darks_multiplier", [], methods_name ) - __check_variable_type(cutoff, [int, float], "cutoff", [], methods_name) - ################################### + __check_variable_type( + upper_bound, [int, float, type(None)], "upper_bound", [], methods_name + ) + __check_variable_type( + lower_bound, [int, float, type(None)], "lower_bound", [], methods_name + ) _check_valid_input_flats_darks(flats, darks) + ################################### + + data_elements_num = int(np.prod(data.shape)) + if upper_bound is None: + upper_bound = 1e12 + if lower_bound is None: + lower_bound = -1e12 dark0 = cp.empty(darks.shape[1:], dtype=float32) flat0 = cp.empty(flats.shape[1:], dtype=float32) @@ -114,12 +129,12 @@ def dark_flat_field_correction( } float v = (float(data) - float(darks))/denom; """ - kernel += "if (v > cutoff) v = cutoff;\n" - kernel += "if (v < -cutoff) v = cutoff;\n" + kernel += "if (v > upper_bound) v = upper_bound;\n" + kernel += "if (v <= lower_bound) v = lower_bound;\n" kernel += "out = v;\n" normalisation_kernel = cp.ElementwiseKernel( - "T data, U flats, U darks, raw float32 cutoff", + "T data, U flats, U darks, raw float32 upper_bound, raw float32 lower_bound", "float32 out", kernel, kernel_name, @@ -128,7 +143,52 @@ def dark_flat_field_correction( no_return=True, ) - normalisation_kernel(data, flat0, dark0, float32(cutoff), out) + count_greater_kernel = cp.ReductionKernel( + in_params="T data, raw float32 upper_bound", + out_params="int32 out", + map_expr="data >= upper_bound ? 1 : 0", # map each element → 1 or 0 + reduce_expr="a + b", # sum them + post_map_expr="out = a", # final result + identity="0", + name="count_greater", + ) + + count_smaller_kernel = cp.ReductionKernel( + in_params="T data, raw float32 lower_bound", + out_params="int32 out", + map_expr="data <= lower_bound ? 1 : 0", # map each element → 1 or 0 + reduce_expr="a + b", # sum them + post_map_expr="out = a", # final result + identity="0", + name="count_smaller", + ) + + normalisation_kernel(data, flat0, dark0, upper_bound, lower_bound, out) + + # Count the amount of clipping and raise warnings if required + clipped_percentage_warning = ( + 50.0 # warning if more clipped values than given percentage + ) + + clipped_total_up = int(count_greater_kernel(out, float32(upper_bound))) + clipped_up_percent = clipped_total_up / data_elements_num * 100 + + if clipped_up_percent >= clipped_percentage_warning: + print( + "Warning! The output data of 'dark_flat_field_correction' method contains \033[31m{}\033[0m percent of 'upper_bound' clipped data.".format( + int(clipped_up_percent) + ) + ) + + clipped_total_lower = int(count_smaller_kernel(out, float32(lower_bound))) + clipped_down_percent = clipped_total_lower / data_elements_num * 100 + + if clipped_down_percent >= clipped_percentage_warning: + print( + "Warning! The output data of 'dark_flat_field_correction' method contains \033[31m{}\033[0m percent of 'lower_bound' clipped data.".format( + int(clipped_down_percent) + ) + ) return out diff --git a/tests/test_prep/test_normalize.py b/tests/test_prep/test_normalize.py index 9001500b..b1b3c01e 100644 --- a/tests/test_prep/test_normalize.py +++ b/tests/test_prep/test_normalize.py @@ -22,6 +22,66 @@ def test_dark_flat_field_correction_1D_raises(data, flats, darks, ensure_clean_m dark_flat_field_correction(data, _data_1d, darks) +def test_dark_flat_field_upper_bound(data, flats, darks, ensure_clean_memory): + # --- testing dark_flat_field_correction with minus_log ---# + data_normalize = cp.asnumpy( + dark_flat_field_correction( + cp.copy(data), + flats, + darks, + flats_multiplier=1, + darks_multiplier=1, + upper_bound=0.8, + lower_bound=None, + ) + ) + + assert data_normalize.dtype == np.float32 + assert_allclose(np.mean(data_normalize), 0.6904512, rtol=1e-06) + assert_allclose(np.mean(data_normalize, axis=(1, 2)).sum(), 124.28119, rtol=1e-06) + assert data_normalize.flags.c_contiguous + + +def test_dark_flat_field_lower_bound(data, flats, darks, ensure_clean_memory): + # --- testing dark_flat_field_correction with minus_log ---# + data_normalize = cp.asnumpy( + dark_flat_field_correction( + cp.copy(data), + flats, + darks, + flats_multiplier=1, + darks_multiplier=1, + upper_bound=None, + lower_bound=0.1, + ) + ) + + assert data_normalize.dtype == np.float32 + assert_allclose(np.mean(data_normalize), 0.8285064, rtol=1e-06) + assert_allclose(np.mean(data_normalize, axis=(1, 2)).sum(), 149.13116, rtol=1e-06) + assert data_normalize.flags.c_contiguous + + +def test_dark_flat_field_upper_and_lower_bound(data, flats, darks, ensure_clean_memory): + # --- testing dark_flat_field_correction with minus_log ---# + data_normalize = cp.asnumpy( + dark_flat_field_correction( + cp.copy(data), + flats, + darks, + flats_multiplier=1, + darks_multiplier=1, + upper_bound=0.7, + lower_bound=0.2, + ) + ) + + assert data_normalize.dtype == np.float32 + assert_allclose(np.mean(data_normalize), 0.6218485, rtol=1e-06) + assert_allclose(np.mean(data_normalize, axis=(1, 2)).sum(), 111.93274, rtol=1e-06) + assert data_normalize.flags.c_contiguous + + def test_dark_flat_field_minus_log_correction(data, flats, darks, ensure_clean_memory): # --- testing dark_flat_field_correction with minus_log ---# data_normalize = dark_flat_field_correction(cp.copy(data), flats, darks) diff --git a/tests/test_prep/test_stripe.py b/tests/test_prep/test_stripe.py index aa21b44f..e98af7cd 100644 --- a/tests/test_prep/test_stripe.py +++ b/tests/test_prep/test_stripe.py @@ -17,7 +17,7 @@ def test_remove_stripe_ti_on_data(data, flats, darks): # --- testing the CuPy implementation from TomoCupy ---# - data_norm = dark_flat_field_correction(cp.copy(data), flats, darks, cutoff=10) + data_norm = dark_flat_field_correction(cp.copy(data), flats, darks) data_norm = minus_log(data_norm) data_after_stripe_removal = cp.asnumpy(remove_stripe_ti(data_norm)) @@ -54,7 +54,7 @@ def free_postprocess( def test_remove_stripe_fw_on_data(data, flats, darks): # --- testing the CuPy implementation from TomoCupy ---# - data_norm = dark_flat_field_correction(data, flats, darks, cutoff=10) + data_norm = dark_flat_field_correction(data, flats, darks) data_norm = minus_log(data_norm) data_after_stripe_removal = remove_stripe_fw( @@ -183,7 +183,7 @@ def test_remove_stripe_ti_dims_change(angles, det_y, det_x): def test_stripe_removal_sorting_cupy(data, flats, darks): # --- testing the CuPy port of TomoPy's implementation ---# - data_norm = dark_flat_field_correction(cp.copy(data), flats, darks, cutoff=10) + data_norm = dark_flat_field_correction(cp.copy(data), flats, darks) data_norm = minus_log(data_norm) corrected_data = cp.asnumpy(remove_stripe_based_sorting(data_norm)) @@ -199,7 +199,7 @@ def test_stripe_removal_sorting_cupy(data, flats, darks): def test_stripe_raven_cupy(data, flats, darks): - data_norm = dark_flat_field_correction(cp.copy(data), flats, darks, cutoff=10) + data_norm = dark_flat_field_correction(cp.copy(data), flats, darks) data_norm = minus_log(data_norm) data_after_raven_gpu = cp.asnumpy(raven_filter(data_norm)) @@ -289,7 +289,7 @@ def test_raven_filter_performance(ensure_clean_memory): def test_remove_all_stripe_on_data(data, flats, darks): # --- testing the CuPy implementation from TomoCupy ---# - data_norm = dark_flat_field_correction(cp.copy(data), flats, darks, cutoff=10) + data_norm = dark_flat_field_correction(cp.copy(data), flats, darks) data_norm = minus_log(data_norm) data_after_stripe_removal = cp.asnumpy(remove_all_stripe(data_norm)) diff --git a/tests/test_recon/test_algorithm.py b/tests/test_recon/test_algorithm.py index 2e0045ab..1b1c4306 100644 --- a/tests/test_recon/test_algorithm.py +++ b/tests/test_recon/test_algorithm.py @@ -18,7 +18,7 @@ def test_reconstruct_FBP_2d_astra(data, flats, darks, ensure_clean_memory): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_size = 150 @@ -41,7 +41,7 @@ def test_reconstruct_FBP_2d_astra(data, flats, darks, ensure_clean_memory): def test_reconstruct_FBP_2d_astra_pad(data, flats, darks, ensure_clean_memory): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_size = 150 @@ -64,7 +64,7 @@ def test_reconstruct_FBP_2d_astra_pad(data, flats, darks, ensure_clean_memory): def test_reconstruct_FBP3d_tomobar_1(data, flats, darks, ensure_clean_memory): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = FBP3d_tomobar( @@ -85,7 +85,7 @@ def test_reconstruct_FBP3d_tomobar_1(data, flats, darks, ensure_clean_memory): def test_reconstruct_FBP3d_tomobar_2(data, flats, darks, ensure_clean_memory): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = FBP3d_tomobar( @@ -108,7 +108,7 @@ def test_reconstruct_FBP3d_tomobar_2(data, flats, darks, ensure_clean_memory): def test_reconstruct_FBP3d_tomobar_3_detpad_true( data, flats, darks, ensure_clean_memory ): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = FBP3d_tomobar( @@ -131,7 +131,7 @@ def test_reconstruct_FBP3d_tomobar_3_detpad_true( def test_reconstruct_LPRec3d_tomobar_1(data, flats, darks, ensure_clean_memory): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = LPRec3d_tomobar( @@ -150,7 +150,7 @@ def test_reconstruct_LPRec3d_tomobar_1(data, flats, darks, ensure_clean_memory): def test_reconstruct_LPRec3d_tomobar_1_pad(data, flats, darks, ensure_clean_memory): - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = LPRec3d_tomobar( @@ -170,7 +170,7 @@ def test_reconstruct_LPRec3d_tomobar_1_pad(data, flats, darks, ensure_clean_memo def test_reconstruct_SIRT3d_tomobar(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = SIRT3d_tomobar( @@ -190,7 +190,7 @@ def test_reconstruct_SIRT3d_tomobar(data, flats, darks, ensure_clean_memory): def test_reconstruct_CGLS3d_tomobar(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = CGLS3d_tomobar( @@ -212,7 +212,7 @@ def test_reconstruct_CGLS3d_tomobar_detpad_true( data, flats, darks, ensure_clean_memory ): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = CGLS3d_tomobar( @@ -233,7 +233,7 @@ def test_reconstruct_CGLS3d_tomobar_detpad_true( def test_reconstruct_FISTA3d_tomobar_pd_tv(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = FISTA3d_tomobar( @@ -261,7 +261,7 @@ def test_reconstruct_FISTA3d_tomobar_pd_tv_detpad_true( data, flats, darks, ensure_clean_memory ): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = FISTA3d_tomobar( @@ -288,7 +288,7 @@ def test_reconstruct_FISTA3d_tomobar_pd_tv_detpad_true( def test_reconstruct_FISTA3d_tomobar_rof_tv(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = FISTA3d_tomobar( @@ -313,7 +313,7 @@ def test_reconstruct_FISTA3d_tomobar_rof_tv(data, flats, darks, ensure_clean_mem def test_reconstruct_ADMM3d_tomobar_pd_tv(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = ADMM3d_tomobar( @@ -341,7 +341,7 @@ def test_reconstruct_ADMM3d_tomobar_pd_tv(data, flats, darks, ensure_clean_memor def test_reconstruct_ADMM3d_warm_tomobar_pd_tv(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = ADMM3d_tomobar( @@ -371,7 +371,7 @@ def test_reconstruct_ADMM3d_warm2_tomobar_pd_tv( data, flats, darks, ensure_clean_memory ): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = ADMM3d_tomobar( @@ -401,7 +401,7 @@ def test_reconstruct_ADMM3d_tomobar_pd_tv_detpad_true( data, flats, darks, ensure_clean_memory ): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = ADMM3d_tomobar( @@ -432,7 +432,7 @@ def test_reconstruct_ADMM3d_warm_tomobar_pd_tv_detpad_true( data, flats, darks, ensure_clean_memory ): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = ADMM3d_tomobar( @@ -461,7 +461,7 @@ def test_reconstruct_ADMM3d_warm_tomobar_pd_tv_detpad_true( def test_reconstruct_ADMM3d_tomobar_rof_tv(data, flats, darks, ensure_clean_memory): objrecon_size = data.shape[2] - normalised_data = dark_flat_field_correction(data, flats, darks, cutoff=10) + normalised_data = dark_flat_field_correction(data, flats, darks) normalised_data = minus_log(normalised_data) recon_data = ADMM3d_tomobar( From 0bcb4817049b59229f7789a32c60f3f362483158 Mon Sep 17 00:00:00 2001 From: algol Date: Wed, 8 Apr 2026 11:38:36 +0100 Subject: [PATCH 2/2] updating all zenodo tests --- zenodo-tests/test_misc/test_morph.py | 6 +-- zenodo-tests/test_prep/test_stripe.py | 13 ++---- zenodo-tests/test_recon/test_algorithm.py | 54 ++++++++++++----------- zenodo-tests/test_recon/test_rotation.py | 22 ++++----- 4 files changed, 46 insertions(+), 49 deletions(-) diff --git a/zenodo-tests/test_misc/test_morph.py b/zenodo-tests/test_misc/test_morph.py index 4b5e7366..560f5f47 100644 --- a/zenodo-tests/test_misc/test_morph.py +++ b/zenodo-tests/test_misc/test_morph.py @@ -11,7 +11,7 @@ def test_sino_360_to_180_i13_dataset1(i13_dataset1): darks = i13_dataset1[3] del i13_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata force_clean_gpu_memory() @@ -32,7 +32,7 @@ def test_sino_360_to_180_i13_dataset3(i13_dataset3): darks = i13_dataset3[3] del i13_dataset3 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata force_clean_gpu_memory() @@ -52,7 +52,7 @@ def test_sino_360_to_180_i12_dataset5(i12_dataset5): darks = i12_dataset5[3] del i12_dataset5 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata force_clean_gpu_memory() diff --git a/zenodo-tests/test_prep/test_stripe.py b/zenodo-tests/test_prep/test_stripe.py index c22e5b3e..722fd13b 100644 --- a/zenodo-tests/test_prep/test_stripe.py +++ b/zenodo-tests/test_prep/test_stripe.py @@ -40,9 +40,7 @@ def test_remove_stripe_based_sorting_i12_dataset4( request, dataset_fixture, size_filt, norm_res_expected ): dataset = request.getfixturevalue(dataset_fixture) - data_normalised = dark_flat_field_correction( - dataset[0], dataset[2], dataset[3], cutoff=10 - ) + data_normalised = dark_flat_field_correction(dataset[0], dataset[2], dataset[3]) data_normalised = minus_log(data_normalised) del dataset @@ -86,9 +84,7 @@ def test_remove_stripe_ti_i12_dataset4( request, dataset_fixture, beta_val, norm_res_expected ): dataset = request.getfixturevalue(dataset_fixture) - data_normalised = dark_flat_field_correction( - dataset[0], dataset[2], dataset[3], cutoff=10 - ) + data_normalised = dark_flat_field_correction(dataset[0], dataset[2], dataset[3]) data_normalised = minus_log(data_normalised) del dataset @@ -164,9 +160,7 @@ def test_remove_all_stripe_i12_dataset4( request, dataset_fixture, snr_val, la_size_val, sm_size_val, norm_res_expected ): dataset = request.getfixturevalue(dataset_fixture) - data_normalised = dark_flat_field_correction( - dataset[0], dataset[2], dataset[3], cutoff=10 - ) + data_normalised = dark_flat_field_correction(dataset[0], dataset[2], dataset[3]) data_normalised = minus_log(data_normalised) del dataset @@ -206,7 +200,6 @@ def test_raven_filter_i12_dataset4( dataset[0][:, 10:20, :], dataset[2][:, 10:20, :], dataset[3][:, 10:20, :], - cutoff=10, ) data_normalised = minus_log(data_normalised) diff --git a/zenodo-tests/test_recon/test_algorithm.py b/zenodo-tests/test_recon/test_algorithm.py index 7523edd4..766dfcc8 100644 --- a/zenodo-tests/test_recon/test_algorithm.py +++ b/zenodo-tests/test_recon/test_algorithm.py @@ -31,7 +31,9 @@ def test_reconstruct_FBP2d_astra_i12_dataset1(i12_dataset1: tuple): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction( + projdata, flats, darks, upper_bound=10.0 + ) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -48,7 +50,7 @@ def test_reconstruct_FBP2d_astra_i12_dataset1(i12_dataset1: tuple): recon_mask_radius=0.9, ) assert recon_data.flags.c_contiguous - assert_allclose(np.sum(recon_data), 84672.84, atol=1e-2) + assert_allclose(np.sum(recon_data), 84673.39, atol=1e-2) assert recon_data.dtype == np.float32 assert recon_data.shape == (2560, 50, 2560) @@ -61,7 +63,9 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset1(i12_dataset1: tuple): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction( + projdata, flats, darks, upper_bound=5.0, lower_bound=0 + ) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -76,7 +80,7 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset1(i12_dataset1: tuple): ) assert recon_data.flags.c_contiguous recon_data = cp.asnumpy(recon_data) - assert_allclose(np.sum(recon_data), 46569.39, rtol=1e-07, atol=1e-6) + assert_allclose(np.sum(recon_data), 46569.46, rtol=1e-07, atol=1e-6) assert recon_data.dtype == np.float32 assert recon_data.shape == (2560, 50, 2560) @@ -89,7 +93,7 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset1_pad(i12_dataset1: tuple): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -105,7 +109,7 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset1_pad(i12_dataset1: tuple): ) assert recon_data.flags.c_contiguous recon_data = cp.asnumpy(recon_data) - assert_allclose(np.sum(recon_data), 9864.915, rtol=1e-07, atol=1e-6) + assert_allclose(np.sum(recon_data), 9864.938, rtol=1e-07, atol=1e-6) assert recon_data.dtype == np.float32 assert recon_data.shape == (2560, 10, 2560) @@ -118,7 +122,7 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset1_autopad(i12_dataset1: tuple): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -134,7 +138,7 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset1_autopad(i12_dataset1: tuple): ) assert recon_data.flags.c_contiguous recon_data = cp.asnumpy(recon_data) - assert_allclose(np.sum(recon_data), 7208.2295, rtol=1e-07, atol=1e-6) + assert_allclose(np.sum(recon_data), 7208.2275, rtol=1e-07, atol=1e-6) assert recon_data.dtype == np.float32 assert recon_data.shape == (2560, 5, 2560) @@ -147,7 +151,7 @@ def test_reconstruct_LPRec3d_tomobar_i12_dataset1(i12_dataset1: tuple): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) data_normalised_cut = data_normalised[:, 5:8, :] @@ -165,7 +169,7 @@ def test_reconstruct_LPRec3d_tomobar_i12_dataset1(i12_dataset1: tuple): ) assert recon_data.flags.c_contiguous recon_data = cp.asnumpy(recon_data) - assert isclose(np.sum(recon_data), 9628.818, abs_tol=10**-3) + assert isclose(np.sum(recon_data), 9628.824, abs_tol=10**-3) assert pytest.approx(np.max(recon_data), rel=1e-3) == 0.006367563270032406 assert pytest.approx(np.min(recon_data), rel=1e-3) == -0.0062076798 assert recon_data.dtype == np.float32 @@ -180,7 +184,7 @@ def test_reconstruct_LPRec3d_tomobar_i12_dataset1_autopad(i12_dataset1: tuple): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) data_normalised_cut = data_normalised[:, 5:8, :] @@ -213,7 +217,7 @@ def test_reconstruct_LPRec_tomobar_i13_dataset1(i13_dataset1: tuple): darks = i13_dataset1[3] del i13_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -252,7 +256,7 @@ def test_FBP3d_tomobar_performance_i13_dataset2(i13_dataset2: tuple): darks = i13_dataset2[3] del i13_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -293,7 +297,7 @@ def test_reconstruct_LPRec3d_tomobar_i13_dataset2(i13_dataset2: tuple): darks = i13_dataset2[3] del i13_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -326,7 +330,7 @@ def test_LPRec3d_tomobar_performance_i13_dataset2(i13_dataset2: tuple): darks = i13_dataset2[3] del i13_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -365,7 +369,7 @@ def test_reconstruct_FBP3d_tomobar_i13_dataset3(i13_dataset3: tuple): darks = i13_dataset3[3] del i13_dataset3 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -402,7 +406,7 @@ def test_reconstruct_FBP3d_tomobar_i12_dataset5(i12_dataset5: tuple): darks = i12_dataset5[3] del i12_dataset5 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -436,7 +440,7 @@ def test_reconstruct_LPRec3d_tomobar_k11_dataset2(k11_dataset2: tuple): darks = k11_dataset2[3] del k11_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -453,7 +457,7 @@ def test_reconstruct_LPRec3d_tomobar_k11_dataset2(k11_dataset2: tuple): ) assert recon_data.flags.c_contiguous recon_data = recon_data.get() - assert isclose(np.sum(recon_data), 10865.34, abs_tol=10**-2) + assert isclose(np.sum(recon_data), 10865.37, abs_tol=10**-2) assert recon_data.dtype == np.float32 assert recon_data.shape == (2560, 25, 2560) @@ -466,7 +470,7 @@ def test_reconstruct_CGLS3d_tomobar_k11_dataset2(k11_dataset2: tuple): darks = k11_dataset2[3] del k11_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -495,7 +499,7 @@ def test_reconstruct_SIRT3d_tomobar_k11_dataset2(k11_dataset2: tuple): darks = k11_dataset2[3] del k11_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -524,7 +528,7 @@ def test_reconstruct_FISTA3d_tomobar_autopad_k11_dataset2(k11_dataset2: tuple): darks = k11_dataset2[3] del k11_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -541,7 +545,7 @@ def test_reconstruct_FISTA3d_tomobar_autopad_k11_dataset2(k11_dataset2: tuple): ) assert recon_data.flags.c_contiguous recon_data = cp.asnumpy(recon_data) - assert isclose(np.sum(recon_data), 1355.4624, abs_tol=10**-3) + assert isclose(np.sum(recon_data), 1355.4636, abs_tol=10**-3) assert recon_data.dtype == np.float32 assert recon_data.shape == (2560, 5, 2560) @@ -554,7 +558,7 @@ def test_reconstruct_ADMM3d_tomobar_autopad_k11_dataset2(k11_dataset2: tuple): darks = k11_dataset2[3] del k11_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) del flats, darks, projdata @@ -574,6 +578,6 @@ def test_reconstruct_ADMM3d_tomobar_autopad_k11_dataset2(k11_dataset2: tuple): assert recon_data.flags.c_contiguous recon_data = cp.asnumpy(recon_data) - assert isclose(np.sum(recon_data), 2275.893, abs_tol=10**-3) + assert isclose(np.sum(recon_data), 2275.8916, abs_tol=10**-3) assert recon_data.dtype == np.float32 assert recon_data.shape == (4150, 3, 4150) diff --git a/zenodo-tests/test_recon/test_rotation.py b/zenodo-tests/test_recon/test_rotation.py index d6c74959..6829c776 100644 --- a/zenodo-tests/test_recon/test_rotation.py +++ b/zenodo-tests/test_recon/test_rotation.py @@ -18,7 +18,7 @@ def test_center_vo_i12_dataset1(i12_dataset1): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata force_clean_gpu_memory() @@ -41,7 +41,7 @@ def test_center_vo_i12_dataset1_performance(i12_dataset1, ensure_clean_memory): darks = i12_dataset1[3] del i12_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata ensure_clean_memory @@ -69,7 +69,7 @@ def test_center_vo_i12_dataset2(i12_dataset2, ensure_clean_memory): darks = i12_dataset2[3] del i12_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata ensure_clean_memory @@ -89,7 +89,7 @@ def test_center_vo_average_i12_dataset2(i12_dataset2, ensure_clean_memory): darks = i12_dataset2[3] del i12_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata ensure_clean_memory @@ -115,7 +115,7 @@ def test_center_pc_i12_dataset3(i12_dataset3, ensure_clean_memory): projdata[0, :, :] = proj1 projdata[1, :, :] = proj2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) data_normalised = minus_log(data_normalised) proj1 = data_normalised[0, :, :] @@ -138,7 +138,7 @@ def test_center_vo_i13_dataset2(i13_dataset2, ensure_clean_memory): darks = i13_dataset2[3] del i13_dataset2 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata @@ -160,7 +160,7 @@ def test_center_vo_geant4_dataset1(geant4_dataset1, ensure_clean_memory): darks = geant4_dataset1[3] del geant4_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata mid_slice = data_normalised.shape[1] // 2 @@ -179,7 +179,7 @@ def test_center_vo_k11_dataset1(k11_dataset1, ensure_clean_memory): darks = k11_dataset1[3] del k11_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata @@ -202,7 +202,7 @@ def test_center_360_i12_dataset5(i12_dataset5, ensure_clean_memory): darks = i12_dataset5[3] del i12_dataset5 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata @@ -223,7 +223,7 @@ def test_center_360_i13_dataset1(i13_dataset1, ensure_clean_memory): darks = i13_dataset1[3] del i13_dataset1 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata ensure_clean_memory @@ -243,7 +243,7 @@ def test_center_360_i13_dataset3(i13_dataset3, ensure_clean_memory): darks = i13_dataset3[3] del i13_dataset3 - data_normalised = dark_flat_field_correction(projdata, flats, darks, cutoff=10) + data_normalised = dark_flat_field_correction(projdata, flats, darks) del flats, darks, projdata ensure_clean_memory