nabu 2024.2.14__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/pipeline/helical/gridded_accumulator.py

@@ -29,8 +29,7 @@ class GriddedAccumulator:
         This class creates, for a selected volume slab, a standard set of radios from an helical dataset.
 
         Parameters
-        ==========
-
+        ----------
         gridded_radios : 3D np.array
            this is the stack of new radios which will be resynthetised, by this class,
            for a selected slab.
@@ -97,7 +96,7 @@ class GriddedAccumulator:
         self.flats_srcurrent = flats_srcurrent
 
         self.flat_indexes = flat_indexes
-        self.flat_indexes_reverse_map = dict(
+        self.flat_indexes_reverse_map = dict(  # noqa: C404
             [(global_index, local_index) for (local_index, global_index) in enumerate(flat_indexes)]
         )
         self.flats = flats
@@ -121,7 +120,7 @@ class GriddedAccumulator:
         the accumulators are ready.
 
         Parameters
-        ==========
+        ----------
         subchunk_slice: an object of the python class "slice"
           this slice slices the angular domain which corresponds to the useful
           projections  which are useful for the chunk, and whose informations
@@ -278,7 +277,7 @@ class GriddedAccumulator:
                 i_diag_list = [(i0 - 1) // 2, (i0 - 1) // 2 + len(self.diagnostic_searched_angles_rad_clipped)]
                 for i_redundancy, i_diag in enumerate(i_diag_list):
                     # print("IRED ", i_redundancy)
-                    if i_redundancy:
+                    if i_redundancy:  # noqa: SIM102
                         # to avoid, in z_stages with >360 range for one single stage, to fill the second items which should instead be filled by another stage.
                         if abs(original_zpix_transl - self.diagnostic_zpix_transl[i_diag_list[0]]) < 2.0:
                             # print( " >>>>>> stesso z" , i_redundancy )
@@ -306,7 +305,7 @@ class GriddedAccumulator:
                         self.diagnostic_radios[i_diag] += data_token * factor
                         self.diagnostic_weights[i_diag] += weight * factor
                         break
-                    else:
+                    else:  # noqa: RET508
                         pass
 
     class _ReframingInfos:
@@ -483,8 +482,8 @@ def overlap_logic(subr_start_z, subr_end_z, dtasrc_start_z, dtasrc_end_z):
 
 def padding_logic(subr_start_z, subr_end_z, dtasrc_start_z, dtasrc_end_z):
     """.......... and the missing ranges which possibly could be obtained by extension padding"""
-    t_h = subr_end_z - subr_start_z
-    s_h = dtasrc_end_z - dtasrc_start_z
+    # t_h = subr_end_z - subr_start_z
+    # s_h = dtasrc_end_z - dtasrc_start_z
 
     if dtasrc_start_z <= subr_start_z:
         target_lower_padding = None
@@ -503,9 +502,9 @@ def get_reconstruction_space(span_info, min_scanwise_z, end_scanwise_z, phase_ma
     """Utility function, so far used only by the unit test, which, given the span_info object, creates the auxiliary collection arrays
     and initialises the  my_z_min, my_z_end variable keeping into account the scan direction
     and the min_scanwise_z, end_scanwise_z input arguments
-    Parameters
-    ==========
 
+    Parameters
+    ----------
     span_info: SpanStrategy
 
     min_scanwise_z: int
@@ -533,7 +532,7 @@ def get_reconstruction_space(span_info, min_scanwise_z, end_scanwise_z, phase_ma
     # regridded dataset, estimating a meaningul angular step representative
     # of the raw data
     my_angle_step = abs(np.diff(span_info.projection_angles_deg).mean())
-    n_gridded_angles = int(round(360.0 / my_angle_step))
+    n_gridded_angles = round(360.0 / my_angle_step)
 
     radios_h = phase_margin_pix + (my_z_end - my_z_min) + phase_margin_pix
 

nabu/pipeline/helical/helical_chunked_regridded.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 # pylint: skip-file
 
 from os import path

nabu/pipeline/helical/helical_reconstruction.py

@@ -3,6 +3,8 @@ from math import ceil
 from time import time
 import numpy as np
 import copy
+
+from nabu.utils import first_generator_item
 from ...resources.logger import LoggerOrPrint
 from ...io.writer import merge_hdf5_files
 from ...cuda.utils import collect_cuda_gpus
@@ -18,7 +20,7 @@ except:
 
 from .helical_chunked_regridded_cuda import CudaHelicalChunkedRegriddedPipeline
 
-from ..fullfield.reconstruction import collect_cuda_gpus, FullFieldReconstructor
+from ..fullfield.reconstruction import FullFieldReconstructor
 
 avail_gpus = collect_cuda_gpus() or {}
 
@@ -53,7 +55,8 @@ class HelicalReconstructorRegridded:
             Dictionary with advanced options. Please see 'Other parameters' below
         cuda_options: dict, optional
             Dictionary with cuda options passed to `nabu.cuda.processing.CudaProcessing`
-        Other parameters
+
+        Other Parameters
         -----------------
         Advanced options can be passed in the 'extra_options' dictionary. These can be:
 
@@ -165,8 +168,8 @@ class HelicalReconstructorRegridded:
 
             # the meaming of z_min and z_max is: position in slices units from the
             # first available slice and in the direction of the scan
-            self.z_min = int(round(z_start * (0 - z_fract_min) + z_max * z_fract_min))
-            self.z_max = int(round(z_start * (0 - z_fract_max) + z_max * z_fract_max)) + 1
+            self.z_min = round(z_start * (0 - z_fract_min) + z_max * z_fract_min)
+            self.z_max = round(z_start * (0 - z_fract_max) + z_max * z_fract_max) + 1
 
     def _compute_translations_margin(self):
         return 0, 0
@@ -242,9 +245,9 @@ class HelicalReconstructorRegridded:
             "reconstruction" in process_config.processing_steps
             and process_config.processing_options["reconstruction"]["enable_halftomo"]
         ):
-            radios_and_sinos = True
+            radios_and_sinos = True  # noqa: F841
 
-        max_dz = process_config.dataset_info.radio_dims[1]
+        # max_dz = process_config.dataset_info.radio_dims[1]
         chunk_size = chunk_step
         last_good_chunk_size = chunk_size
         while True:
@@ -431,7 +434,7 @@ class HelicalReconstructorRegridded:
         angles_deg = np.rad2deg(angles_rad)
 
         redundancy_angle_deg = self.process_config.nabu_config["reconstruction"]["redundancy_angle_deg"]
-        do_helical_half_tomo = self.process_config.nabu_config["reconstruction"]["helical_halftomo"]
+        # do_helical_half_tomo = self.process_config.nabu_config["reconstruction"]["helical_halftomo"]
 
         self.logger.info("Creating SpanStrategy object for helical ")
         t0 = time()
@@ -460,7 +463,7 @@ class HelicalReconstructorRegridded:
         self.logger.debug("Creating a new pipeline object")
         args = [self.process_config, task["sub_region"]]
 
-        dz = self._get_delta_z(task)
+        # dz = self._get_delta_z(task)
 
         pipeline = self._pipeline_cls(
             *args,
@@ -542,7 +545,7 @@ class HelicalReconstructorRegridded:
         # Prevent issue when out_dir is empty, which happens only if dataset/location is a relative path.
         # TODO this should be prevented earlier
         if out_dir is None or len(out_dir.strip()) == 0:
-            out_dir = dirname(dirname(self.results[list(self.results.keys())[0]]))
+            out_dir = dirname(dirname(self.results[first_generator_item(self.results.keys())]))
         #
         if output_file is None:
             output_file = join(out_dir, prefix + out_cfg["file_prefix"]) + ".hdf5"

nabu/pipeline/helical/helical_utils.py

@@ -9,9 +9,8 @@ def find_mirror_indexes(angles_deg, tolerance_factor=1.0):
     contains the index of the angles_deg array element which has the value the closest
     to angles_deg[i] + 180. It is used for padding in halftomo.
 
-    Parameters:
+    Parameters
     -----------
-
     angles_deg: a nd.array of floats
 
     tolerance: float

nabu/pipeline/helical/nabu_config.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 from ..fullfield.nabu_config import *
 import copy
 
@@ -42,7 +43,7 @@ nabu_config["preproc"]["processes_file"] = {
     "validator": optional_file_location_validator,
     "type": "required",
 }
-nabu_config["preproc"]["double_flatfield_enabled"]["default"] = 1
+nabu_config["preproc"]["double_flatfield"]["default"] = 1
 
 
 nabu_config["reconstruction"].update(

nabu/pipeline/helical/span_strategy.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 import math
 import numpy as np
 from ...resources.logger import LoggerOrPrint

nabu/pipeline/helical/weight_balancer.py

@@ -12,8 +12,7 @@ class WeightBalancer:
         to Nabu, we create this class and follow the scheme initialisation + application.
 
         Parameters
-        ==========
-
+        ----------
         rot_center : float
                     the center of rotation in pixel units
         angles_rad :
@@ -84,7 +83,7 @@ def shift(arr, shift, fill_value=0.0):
     """
     result = np.zeros_like(arr)
 
-    num1 = int(math.floor(shift))
+    num1 = math.floor(shift)
     num2 = num1 + 1
     partition = shift - num1
 

nabu/pipeline/params.py

@@ -3,6 +3,17 @@ flatfield_modes = {
     "1": True,
     "false": False,
     "0": False,
+    # These three should be removed after a while (moved to 'flatfield_loading_mode')
+    "forced": "force-load",
+    "force-load": "force-load",
+    "force-compute": "force-compute",
+    #
+    "pca": "pca",
+}
+
+flatfield_loading_mode = {
+    "": "load_if_present",
+    "load_if_present": "load_if_present",
     "forced": "force-load",
     "force-load": "force-load",
     "force-compute": "force-compute",
@@ -25,12 +36,17 @@ unsharp_methods = {
     "": None,
 }
 
+# see PaddingBase.supported_modes
 padding_modes = {
-    "edges": "edge",
-    "edge": "edge",
-    "mirror": "mirror",
     "zeros": "zeros",
     "zero": "zeros",
+    "constant": "zeros",
+    "edges": "edge",
+    "edge": "edge",
+    "mirror": "reflect",
+    "reflect": "reflect",
+    "symmetric": "symmetric",
+    "wrap": "wrap",
 }
 
 reconstruction_methods = {
@@ -72,6 +88,7 @@ iterative_methods = {
 optim_algorithms = {
     "chambolle": "chambolle-pock",
     "chambollepock": "chambolle-pock",
+    "chambolle-pock": "chambolle-pock",
     "fista": "fista",
 }
 

nabu/pipeline/tests/test_estimators.py

@@ -1,14 +1,23 @@
 import os
+from tempfile import TemporaryDirectory
 import pytest
 import numpy as np
-from nabu.testutils import utilstest, __do_long_tests__
-from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer, analyze_dataset
+from pint import get_application_registry
+from nxtomo import NXtomo
+from nabu.testutils import utilstest, __do_long_tests__, get_data
+from nabu.resources.dataset_analyzer import HDF5DatasetAnalyzer, analyze_dataset, ImageKey
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from nabu.resources.utils import extract_parameters
-from nabu.pipeline.estimators import CompositeCOREstimator
+from nabu.pipeline.estimators import CompositeCOREstimator, TranslationsEstimator
 from nabu.pipeline.config import parse_nabu_config_file
 from nabu.pipeline.estimators import SinoCORFinder, CORFinder
 
+from nabu.estimation.tests.test_motion_estimation import (
+    check_motion_estimation,
+    project_volume,
+    _create_translations_vector,
+)
+
 
 #
 # Test CoR estimation with "composite-coarse-to-fine" (aka "near" in the legacy system vocable)
@@ -119,3 +128,231 @@ class TestCorNearPos:
             cor = finder.find_cor()
             message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
             assert np.isclose(self.true_cor + 0.5, cor, atol=self.abs_tol), message
+
+
+def _add_fake_flats_and_dark_to_data(data, n_darks=10, n_flats=21, dark_val=1, flat_val=3):
+    img_shape = data.shape[1:]
+    # Use constant darks/flats, to avoid "reduction" (mean/median) issues
+    fake_darks = np.ones((n_darks,) + img_shape, dtype=np.uint16) * dark_val
+    fake_flats = np.ones((n_flats,) + img_shape, dtype=np.uint16) * flat_val
+    return data * (fake_flats[0, 0, 0] - fake_darks[0, 0, 0]) + fake_darks[0, 0, 0], fake_darks, fake_flats
+
+
+def _generate_nx_for_180_dataset(volume, output_file_path, n_darks=10, n_flats=21):
+
+    n_angles = 250
+    cor = -10
+
+    alpha_x = 4
+    beta_x = 3
+    alpha_y = -5
+    beta_y = 10
+    beta_z = 0
+    orig_det_dist = 0
+
+    angles0 = np.linspace(0, np.pi, n_angles, False)
+    return_angles = np.deg2rad([180.0, 135.0, 90.0, 45.0, 0.0])
+    angles = np.hstack([angles0, return_angles]).ravel()
+    a = np.arange(angles0.size + return_angles.size) / angles0.size
+
+    tx = _create_translations_vector(a, alpha_x, beta_x)
+    ty = _create_translations_vector(a, alpha_y, beta_y)
+    tz = _create_translations_vector(a, 0, beta_z)
+
+    sinos = project_volume(volume, angles, -tx, -ty, -tz, cor=-cor, orig_det_dist=orig_det_dist)
+    data = np.moveaxis(sinos, 1, 0)
+
+    sample_motion_xy = np.stack([-tx, ty], axis=1)
+    sample_motion_z = -tz
+    angles_deg = np.degrees(angles0)
+    return_angles_deg = np.degrees(return_angles)
+    n_return_radios = len(return_angles_deg)
+    n_radios = data.shape[0] - n_return_radios
+
+    ureg = get_application_registry()
+    fake_raw_data, darks, flats = _add_fake_flats_and_dark_to_data(data, n_darks=n_darks, n_flats=n_flats)
+
+    nxtomo = NXtomo()
+    nxtomo.instrument.detector.data = np.concatenate(
+        [
+            darks,
+            flats,
+            fake_raw_data,  # radios + return radios (in float32 !)
+        ]
+    )
+    image_key_control = np.concatenate(
+        [
+            [ImageKey.DARK_FIELD.value] * n_darks,
+            [ImageKey.FLAT_FIELD.value] * n_flats,
+            [ImageKey.PROJECTION.value] * n_radios,
+            [ImageKey.ALIGNMENT.value] * n_return_radios,
+        ]
+    )
+    nxtomo.instrument.detector.image_key_control = image_key_control
+
+    rotation_angle = np.concatenate(
+        [np.zeros(n_darks, dtype="f"), np.zeros(n_flats, dtype="f"), angles_deg, return_angles_deg]
+    )
+    nxtomo.sample.rotation_angle = rotation_angle * ureg.degree
+    nxtomo.instrument.detector.field_of_view = "Full"
+    nxtomo.instrument.detector.x_pixel_size = nxtomo.instrument.detector.y_pixel_size = 1 * ureg.micrometer
+    nxtomo.save(file_path=output_file_path, data_path="entry", overwrite=True)
+
+    return sample_motion_xy, sample_motion_z, cor
+
+
+def _generate_nx_for_360_dataset(volume, output_file_path, n_darks=10, n_flats=21):
+
+    n_angles = 250
+    cor = -5.5
+
+    alpha_x = -2
+    beta_x = 7.0
+    alpha_y = -2
+    beta_y = 3
+    beta_z = 100
+    orig_det_dist = 0
+
+    angles = np.linspace(0, 2 * np.pi, n_angles, False)
+    a = np.linspace(0, 1, angles.size, endpoint=False)  # theta/theta_max
+
+    tx = _create_translations_vector(a, alpha_x, beta_x)
+    ty = _create_translations_vector(a, alpha_y, beta_y)
+    tz = _create_translations_vector(a, 0, beta_z)
+
+    sinos = project_volume(volume, angles, -tx, -ty, -tz, cor=-cor, orig_det_dist=orig_det_dist)
+    data = np.moveaxis(sinos, 1, 0)
+
+    sample_motion_xy = np.stack([-tx, ty], axis=1)
+    sample_motion_z = -tz
+    angles_deg = np.degrees(angles)
+
+    ureg = get_application_registry()
+
+    fake_raw_data, darks, flats = _add_fake_flats_and_dark_to_data(data, n_darks=n_darks, n_flats=n_flats)
+
+    nxtomo = NXtomo()
+    nxtomo.instrument.detector.data = np.concatenate([darks, flats, fake_raw_data])  # in float32 !
+
+    image_key_control = np.concatenate(
+        [
+            [ImageKey.DARK_FIELD.value] * n_darks,
+            [ImageKey.FLAT_FIELD.value] * n_flats,
+            [ImageKey.PROJECTION.value] * data.shape[0],
+        ]
+    )
+    nxtomo.instrument.detector.image_key_control = image_key_control
+
+    rotation_angle = np.concatenate(
+        [
+            np.zeros(n_darks, dtype="f"),
+            np.zeros(n_flats, dtype="f"),
+            angles_deg,
+        ]
+    )
+    nxtomo.sample.rotation_angle = rotation_angle * ureg.degree
+    nxtomo.instrument.detector.field_of_view = "Full"
+    nxtomo.instrument.detector.x_pixel_size = nxtomo.instrument.detector.y_pixel_size = 1 * ureg.micrometer
+    nxtomo.save(file_path=output_file_path, data_path="entry", overwrite=True)
+
+    return sample_motion_xy, sample_motion_z, cor
+
+
+@pytest.fixture(scope="class")
+def setup_test_motion_estimator(request):
+    cls = request.cls
+    cls.volume = get_data("motion/mri_volume_subsampled.npy")
+
+
+@pytest.mark.skipif(not (__do_long_tests__), reason="need environment variable NABU_LONG_TESTS=1")
+@pytest.mark.usefixtures("setup_test_motion_estimator")
+class TestMotionEstimator:
+
+    def _setup(self, tmpdir):
+        # pytest uses some weird data structure for "tmpdir"
+        if not (isinstance(tmpdir, str)):
+            tmpdir = str(tmpdir)
+        #
+        if getattr(self, "volume", None) is None:
+            self.volume = get_data("motion/mri_volume_subsampled.npy")
+
+    def test_estimate_motion_360_dataset(self, tmpdir, verbose=False):
+        self._setup(tmpdir)
+        nx_file_path = os.path.join(tmpdir, "mri_projected_360_motion.nx")
+        sample_motion_xy, sample_motion_z, cor = _generate_nx_for_360_dataset(self.volume, nx_file_path)
+
+        dataset_info = analyze_dataset(nx_file_path)
+
+        translations_estimator = TranslationsEstimator(
+            dataset_info, do_flatfield=True, rot_center=cor, angular_subsampling=5, deg_xy=2, deg_z=2
+        )
+        estimated_shifts_h, estimated_shifts_v, estimated_cor = translations_estimator.estimate_motion()
+
+        s = translations_estimator.angular_subsampling
+        if verbose:
+            translations_estimator.motion_estimator.plot_detector_shifts(cor=cor)
+            translations_estimator.motion_estimator.plot_movements(
+                cor=cor,
+                angles_rad=dataset_info.rotation_angles[::s],
+                gt_xy=sample_motion_xy[::s, :],
+                gt_z=sample_motion_z[::s],
+            )
+        check_motion_estimation(
+            translations_estimator.motion_estimator,
+            dataset_info.rotation_angles[::s],
+            cor,
+            sample_motion_xy[::s, :],
+            sample_motion_z[::s],
+            fit_error_shifts_tol_vu=(0.2, 0.2),
+            fit_error_det_tol_vu=(1e-5, 5e-2),
+            fit_error_tol_xyz=(0.05, 0.05, 0.05),
+            fit_error_det_all_angles_tol_vu=(1e-5, 0.05),
+        )
+
+    def test_estimate_motion_180_dataset(self, tmpdir, verbose=False):
+        self._setup(tmpdir)
+        nx_file_path = os.path.join(tmpdir, "mri_projected_180_motion.nx")
+
+        sample_motion_xy, sample_motion_z, cor = _generate_nx_for_180_dataset(self.volume, nx_file_path)
+
+        dataset_info = analyze_dataset(nx_file_path)
+
+        translations_estimator = TranslationsEstimator(
+            dataset_info,
+            do_flatfield=True,
+            rot_center=cor,
+            angular_subsampling=2,
+            deg_xy=2,
+            deg_z=2,
+            shifts_estimator="DetectorTranslationAlongBeam",
+        )
+        estimated_shifts_h, estimated_shifts_v, estimated_cor = translations_estimator.estimate_motion()
+
+        if verbose:
+            translations_estimator.motion_estimator.plot_detector_shifts(cor=cor)
+            translations_estimator.motion_estimator.plot_movements(
+                cor=cor,
+                angles_rad=dataset_info.rotation_angles,
+                gt_xy=sample_motion_xy[: dataset_info.n_angles],
+                gt_z=sample_motion_z[: dataset_info.n_angles],
+            )
+
+        check_motion_estimation(
+            translations_estimator.motion_estimator,
+            dataset_info.rotation_angles,
+            cor,
+            sample_motion_xy,
+            sample_motion_z,
+            fit_error_shifts_tol_vu=(0.02, 0.1),
+            fit_error_det_tol_vu=(1e-2, 0.5),
+            fit_error_tol_xyz=(0.5, 2, 1e-2),
+            fit_error_det_all_angles_tol_vu=(1e-2, 2),
+        )
+
+
+if __name__ == "__main__":
+
+    T = TestMotionEstimator()
+    with TemporaryDirectory(suffix="_motion", prefix="nabu_testdata") as tmpdir:
+        T.test_estimate_motion_360_dataset(tmpdir, verbose=True)
+        T.test_estimate_motion_180_dataset(tmpdir, verbose=True)

nabu/pipeline/utils.py

@@ -72,7 +72,7 @@ def get_subregion(sub_region, ndim=3):
     if sub_region is None:
         res = ((None, None),)
     elif hasattr(sub_region[0], "__iter__"):
-        if set(map(len, sub_region)) != set([2]):
+        if set(map(len, sub_region)) != {2}:
             raise ValueError("Expected each tuple to be in the form (start, end)")
         res = sub_region
     else:

nabu/pipeline/writer.py

@@ -163,7 +163,7 @@ class WriterManager:
     def _init_histogram_writer(self):
         if not self.histogram:
             return
-        separate_histogram_file = not (self.file_format == "hdf5")
+        separate_histogram_file = self.file_format != "hdf5"
         if separate_histogram_file:
             fmode = "w"
             hist_fname = path.join(self.output_dir, "histogram_%05d.hdf5" % self.start_index)

nabu/preproc/alignment.py

@@ -1,11 +1 @@
 # Backward compat.
-from ..estimation.alignment import AlignmentBase
-from ..estimation.cor import (
-    CenterOfRotation,
-    CenterOfRotationAdaptiveSearch,
-    CenterOfRotationGrowingWindow,
-    CenterOfRotationSlidingWindow,
-)
-from ..estimation.translation import DetectorTranslationAlongBeam
-from ..estimation.focus import CameraFocus
-from ..estimation.tilt import CameraTilt

nabu/preproc/ccd.py

@@ -1,5 +1,6 @@
 import numpy as np
 from ..utils import check_supported
+from scipy.ndimage import binary_dilation
 from silx.math.medianfilter import medfilt2d
 
 
@@ -13,6 +14,7 @@ class CCDFilter:
     def __init__(
         self,
         radios_shape: tuple,
+        kernel_size: int = 3,
         correction_type: str = "median_clip",
         median_clip_thresh: float = 0.1,
         abs_diff=False,
@@ -26,6 +28,9 @@ class CCDFilter:
         radios_shape: tuple
             A tuple describing the shape of the radios stack, in the form
             `(n_radios, n_z, n_x)`.
+        kernel_size: int
+            Size of the kernel for the median filter.
+            Default is 3.
         correction_type: str
             Correction type for radios ("median_clip", "sigma_clip", ...)
         median_clip_thresh: float, optional
@@ -48,6 +53,7 @@ class CCDFilter:
              then this pixel value is set to the median value.
         """
         self._set_radios_shape(radios_shape)
+        self.kernel_size = kernel_size
         check_supported(correction_type, self._supported_ccd_corrections, "CCD correction mode")
         self.correction_type = correction_type
         self.median_clip_thresh = median_clip_thresh
@@ -67,11 +73,11 @@ class CCDFilter:
         self.shape = (n_z, n_x)
 
     @staticmethod
-    def median_filter(img):
+    def median_filter(img, kernel_size=3):
         """
         Perform a median filtering on an image.
         """
-        return medfilt2d(img, (3, 3), mode="reflect")
+        return medfilt2d(img, (kernel_size, kernel_size), mode="reflect")
 
     def median_clip_mask(self, img, return_medians=False):
         """
@@ -85,7 +91,7 @@ class CCDFilter:
         return_medians: bool, optional
             Whether to return the median values additionally to the mask.
         """
-        median_values = self.median_filter(img)
+        median_values = self.median_filter(img, kernel_size=self.kernel_size)
         if not self.abs_diff:
             invalid_mask = img >= median_values + self.median_clip_thresh
         else:
@@ -124,6 +130,50 @@ class CCDFilter:
 
         return output
 
+    def dezinger_correction(self, radios, dark=None, nsigma=5, output=None):
+        """
+        Compute the median clip correction on a radios stack, and propagates the invalid pixels into vert and horiz directions.
+
+        Parameters
+        ----------
+        radios: numpy.ndarray
+            A radios stack.
+        dark: numpy.ndarray, optional
+            A dark image. Default is None. If not None, it is subtracted from the radios.
+        nsigma: float, optional
+            Number of standard deviations to use for the zinger detection.
+            Default is 5.
+        output: numpy.ndarray, optional
+            Output array
+        """
+        if radios.shape[1:] != self.radios_shape[1:]:
+            raise ValueError(f"Expected radios shape {self.radios_shape}, got {radios.shape}")
+
+        if output is None:
+            output = np.copy(radios)
+        else:
+            output[:] = radios[:]
+
+        n_radios = radios.shape[0]
+        for i in range(n_radios):
+            if dark is None:
+                dimg = radios[i]
+            elif dark.shape == radios.shape[1:]:
+                dimg = radios[i] - dark
+            else:
+                raise ValueError("Dark image shape does not match radios shape.")
+
+            dimg = radios[i] - dark
+            med = self.median_filter(dimg, self.kernel_size)
+            err = dimg - med
+            ds0 = err.std()
+            msk = err > (ds0 * nsigma)
+            gromsk = binary_dilation(msk)
+
+            output[i] = np.where(gromsk, med, radios[i])
+
+        return output
+
 
 class Log:
     """