teareduce 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

teareduce/cleanest/__init__.py

@@ -0,0 +1,10 @@
+#
+# Copyright 2023-2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+# License-Filename: LICENSE.txt
+#
+
+from .cleanest import cleanest

teareduce/cleanest/cleanest.py

@@ -0,0 +1,139 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Interpolate pixels identified in a mask."""
+
+from scipy import ndimage
+import numpy as np
+
+from .dilatemask import dilatemask
+from .interpolation_x import interpolation_x
+from .interpolation_y import interpolation_y
+from .interpolation_a import interpolation_a
+
+
+def cleanest(data, mask_crfound, dilation=0,
+             interp_method=None, npoints=None, degree=None,
+             debug=False):
+    """Interpolate pixels identified in a mask.
+
+    The original data and mask are not modified. A copy of both
+    arrays are created and returned with the interpolated pixels.
+
+    Parameters
+    ----------
+    data : 2D numpy.ndarray
+        The image data array to be processed.
+    mask_crfound : 2D numpy.ndarray of bool
+        A boolean mask array indicating which pixels are affected by
+        cosmic rays.
+    dilation : int, optional
+        The number of pixels to dilate the masked pixels before
+        interpolation.
+    interp_method : str, optional
+        The interpolation method to use. Options are:
+        'x' : Polynomial interpolation in the X direction.
+        'y' : Polynomial interpolation in the Y direction.
+        's' : Surface fit (degree 1) interpolation.
+        'd' : Median of border pixels interpolation.
+        'm' : Mean of border pixels interpolation.
+    npoints : int, optional
+        The number of points to use for interpolation. This
+        parameter is relevant for 'x', 'y', 's', 'd', and 'm' methods.
+    degree : int, optional
+        The degree of the polynomial to fit. This parameter is
+        relevant for 'x' and 'y' methods.
+    debug : bool, optional
+        If True, print debug information.
+
+    Returns
+    -------
+    cleaned_data : 2D numpy.ndarray
+        The image data array with cosmic rays cleaned.
+    mask_fixed : 2D numpy.ndarray of bool
+        The updated boolean mask array indicating which pixels
+        have been fixed.
+
+    Notes
+    -----
+    This function has been created to clean cosmic rays without
+    the need of a GUI interaction. It can be used in scripts
+    or batch processing of images.
+    """
+    if interp_method is None:
+        raise ValueError("interp_method must be specified.")
+    if interp_method not in ['x', 'y', 's', 'd', 'm']:
+        raise ValueError(f"Unknown interp_method: {interp_method}")
+    if npoints is None:
+        raise ValueError("npoints must be specified.")
+    if degree is None and interp_method in ['x', 'y']:
+        raise ValueError("degree must be specified for the chosen interp_method.")
+
+    # Apply dilation to the cosmic ray mask if needed
+    if dilation > 0:
+        updated_mask_crfound = dilatemask(mask_crfound, dilation)
+    else:
+        updated_mask_crfound = mask_crfound.copy()
+
+    # Create a mask to keep track of cleaned pixels
+    mask_fixed = np.zeros_like(mask_crfound, dtype=bool)
+
+    # Determine number of CR features
+    structure = [[1, 1, 1],
+                 [1, 1, 1],
+                 [1, 1, 1]]
+    cr_labels, num_features = ndimage.label(updated_mask_crfound, structure=structure)
+    if debug:
+        print(f"Number of cosmic ray pixels to be cleaned: {np.sum(updated_mask_crfound)}")
+        print(f"Number of cosmic rays (grouped pixels)...: {num_features}")
+
+    # Fix cosmic rays using the specified interpolation method
+    cleaned_data = data.copy()
+    num_cr_cleaned = 0
+    for cr_index in range(1, num_features + 1):
+        if interp_method in ['x', 'y']:
+            if 2 * npoints <= degree:
+                raise ValueError("2*npoints must be greater than degree for polynomial interpolation.")
+            if interp_method == 'x':
+                interp_func = interpolation_x
+            else:
+                interp_func = interpolation_y
+            interpolation_performed, _, _ = interp_func(
+                data=cleaned_data,
+                mask_fixed=mask_fixed,
+                cr_labels=cr_labels,
+                cr_index=cr_index,
+                npoints=npoints,
+                degree=degree)
+            if interpolation_performed:
+                num_cr_cleaned += 1
+        elif interp_method in ['s', 'd', 'm']:
+            if interp_method == 's':
+                method = 'surface'
+            elif interp_method == 'd':
+                method = 'median'
+            elif interp_method == 'm':
+                method = 'mean'
+            interpolation_performed, _, _ = interpolation_a(
+                data=cleaned_data,
+                mask_fixed=mask_fixed,
+                cr_labels=cr_labels,
+                cr_index=cr_index,
+                npoints=npoints,
+                method=method
+            )
+            if interpolation_performed:
+                num_cr_cleaned += 1
+        else:
+            raise ValueError(f"Unknown interpolation method: {interp_method}")
+
+    if debug:
+        print(f"Number of cosmic rays cleaned............: {num_cr_cleaned}")
+
+    return cleaned_data, mask_fixed

teareduce/cleanest/cosmicraycleanerapp.py

@@ -19,15 +19,17 @@ from ccdproc import cosmicray_lacosmic
 import matplotlib.pyplot as plt
 from matplotlib.backend_bases import key_press_handler
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
+from scipy import ndimage
 import numpy as np
 import os
 from rich import print
-from scipy import ndimage
+from tqdm import tqdm
 
 from .definitions import lacosmic_default_dict
 from .definitions import DEFAULT_NPOINTS_INTERP
 from .definitions import DEFAULT_DEGREE_INTERP
 from .definitions import MAX_PIXEL_DISTANCE_TO_CR
+from .dilatemask import dilatemask
 from .find_closest_true import find_closest_true
 from .interpolation_a import interpolation_a
 from .interpolation_x import interpolation_x
@@ -135,7 +137,7 @@ class CosmicRayCleanerApp(ImageDisplay):
         """
         self.root = root
         self.root.title("Cosmic Ray Cleaner")
-        self.root.geometry("800x700+50+0")
+        self.root.geometry("800x800+50+0")
         self.lacosmic_params = lacosmic_default_dict.copy()
         self.input_fits = input_fits
         self.extension = extension
@@ -357,41 +359,81 @@ class CosmicRayCleanerApp(ImageDisplay):
             self.last_xmax = updated_params['xmax']['value']
             self.last_ymin = updated_params['ymin']['value']
             self.last_ymax = updated_params['ymax']['value']
+            usefulregion = SliceRegion2D(f"[{self.last_xmin}:{self.last_xmax},{self.last_ymin}:{self.last_ymax}]",
+                                         mode="fits").python
+            usefulmask = np.zeros_like(self.data)
+            usefulmask[usefulregion] = 1.0
             # Update parameter dictionary with new values
             self.lacosmic_params = updated_params
             print("Parameters updated:")
             for key, info in self.lacosmic_params.items():
                 print(f"  {key}: {info['value']}")
+            if self.lacosmic_params['nruns']['value'] not in [1, 2]:
+                raise ValueError("nruns must be 1 or 2")
             # Execute L.A.Cosmic with updated parameters
             cleandata_lacosmic, mask_crfound = cosmicray_lacosmic(
                 self.data,
-                gain=self.lacosmic_params['gain']['value'],
-                readnoise=self.lacosmic_params['readnoise']['value'],
-                sigclip=self.lacosmic_params['sigclip']['value'],
-                sigfrac=self.lacosmic_params['sigfrac']['value'],
-                objlim=self.lacosmic_params['objlim']['value'],
-                niter=self.lacosmic_params['niter']['value'],
-                verbose=self.lacosmic_params['verbose']['value']
+                gain=self.lacosmic_params['run1_gain']['value'],
+                readnoise=self.lacosmic_params['run1_readnoise']['value'],
+                sigclip=self.lacosmic_params['run1_sigclip']['value'],
+                sigfrac=self.lacosmic_params['run1_sigfrac']['value'],
+                objlim=self.lacosmic_params['run1_objlim']['value'],
+                niter=self.lacosmic_params['run1_niter']['value'],
+                verbose=self.lacosmic_params['run1_verbose']['value']
             )
+            # Apply usefulmask to consider only selected region
+            cleandata_lacosmic *= usefulmask
+            mask_crfound = mask_crfound & (usefulmask.astype(bool))
+            # Second execution if nruns == 2
+            if self.lacosmic_params['nruns']['value'] == 2:
+                cleandata_lacosmic2, mask_crfound2 = cosmicray_lacosmic(
+                    self.data,
+                    gain=self.lacosmic_params['run2_gain']['value'],
+                    readnoise=self.lacosmic_params['run2_readnoise']['value'],
+                    sigclip=self.lacosmic_params['run2_sigclip']['value'],
+                    sigfrac=self.lacosmic_params['run2_sigfrac']['value'],
+                    objlim=self.lacosmic_params['run2_objlim']['value'],
+                    niter=self.lacosmic_params['run2_niter']['value'],
+                    verbose=self.lacosmic_params['run2_verbose']['value']
+                )
+                # Apply usefulmask to consider only selected region
+                cleandata_lacosmic2 *= usefulmask
+                mask_crfound2 = mask_crfound2 & (usefulmask.astype(bool))
+                # Combine results from both runs
+                if np.any(mask_crfound):
+                    print(f"Number of cosmic ray pixels (run1).......: {np.sum(mask_crfound)}")
+                    print(f"Number of cosmic ray pixels (run2).......: {np.sum(mask_crfound2)}")
+                    # find features in second run
+                    structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+                    cr_labels2, num_features2 = ndimage.label(mask_crfound2, structure=structure)
+                    # generate mask of ones at CR pixels found in first run
+                    mask_peaks = np.zeros(mask_crfound.shape, dtype=float)
+                    mask_peaks[mask_crfound] = 1.0
+                    # preserve only those CR pixels in second run that are in the first run
+                    cr_labels2_preserved = mask_peaks * cr_labels2
+                    # generate new mask with preserved CR pixels from second run
+                    mask_crfound = np.zeros_like(mask_crfound, dtype=bool)
+                    for icr in np.unique(cr_labels2_preserved):
+                        if icr > 0:
+                            mask_crfound[cr_labels2 == icr] = True
+                    print(f'Number of cosmic ray pixels (run1 & run2): {np.sum(mask_crfound)}')
+                # Use the cleandata from the second run
+                cleandata_lacosmic = cleandata_lacosmic2
             # Select the image region to process
-            fits_region = f"[{updated_params['xmin']['value']}:{updated_params['xmax']['value']}"
-            fits_region += f",{updated_params['ymin']['value']}:{updated_params['ymax']['value']}]"
-            region = SliceRegion2D(fits_region, mode="fits").python
             self.cleandata_lacosmic = self.data.copy()
-            self.cleandata_lacosmic[region] = cleandata_lacosmic[region]
+            self.cleandata_lacosmic[usefulregion] = cleandata_lacosmic[usefulregion]
             self.mask_crfound = np.zeros_like(self.data, dtype=bool)
-            self.mask_crfound[region] = mask_crfound[region]
+            self.mask_crfound[usefulregion] = mask_crfound[usefulregion]
             # Process the mask: dilation and labeling
             if np.any(self.mask_crfound):
                 num_cr_pixels_before_dilation = np.sum(self.mask_crfound)
                 dilation = self.lacosmic_params['dilation']['value']
                 if dilation > 0:
                     # Dilate the mask by the specified number of pixels
-                    structure = ndimage.generate_binary_structure(2, 2)  # 8-connectivity
-                    self.mask_crfound = ndimage.binary_dilation(
-                        self.mask_crfound,
-                        structure=structure,
-                        iterations=self.lacosmic_params['dilation']['value']
+                    self.mask_crfound = dilatemask(
+                        mask=self.mask_crfound,
+                        iterations=self.lacosmic_params['dilation']['value'],
+                        connectivity=1
                     )
                     num_cr_pixels_after_dilation = np.sum(self.mask_crfound)
                     sdum = str(num_cr_pixels_after_dilation)
@@ -407,7 +449,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 # diagonal connections too, so we define a 3x3 square.
                 structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
                 self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
-                print(f"Number of cosmic rays features (grouped pixels)...: {self.num_features:{len(sdum)}}")
+                print(f"Number of cosmic rays features (grouped pixels)...: {self.num_features:>{len(sdum)}}")
                 self.apply_lacosmic_button.config(state=tk.NORMAL)
                 self.examine_detected_cr_button.config(state=tk.NORMAL)
                 self.update_cr_overlay()
@@ -452,10 +494,13 @@ class CosmicRayCleanerApp(ImageDisplay):
         """Apply the selected cleaning method to the detected cosmic rays."""
         if np.any(self.mask_crfound):
             # recalculate labels and number of features
-            structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+            structure = [[1, 1, 1],
+                         [1, 1, 1],
+                         [1, 1, 1]]
             self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
-            print(f"Number of cosmic ray pixels detected by L.A.Cosmic...........: {np.sum(self.mask_crfound)}")
-            print(f"Number of cosmic rays (grouped pixels) detected by L.A.Cosmic: {self.num_features}")
+            sdum = str(np.sum(self.mask_crfound))
+            print(f"Number of cosmic ray pixels detected by L.A.Cosmic...........: {sdum}")
+            print(f"Number of cosmic rays (grouped pixels) detected by L.A.Cosmic: {self.num_features:>{len(sdum)}}")
             # Define parameters for L.A.Cosmic from default dictionary
             editor_window = tk.Toplevel(self.root)
             editor = InterpolationEditor(
@@ -463,7 +508,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 last_dilation=self.lacosmic_params['dilation']['value'],
                 last_npoints=self.last_npoints,
                 last_degree=self.last_degree,
-                auxdata=self.auxdata
+                auxdata=self.auxdata,
             )
             # Make it modal (blocks interaction with main window)
             editor_window.transient(self.root)
@@ -498,7 +543,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 self.mask_crfound[self.mask_crfound] = False
                 num_cr_cleaned = self.num_features
             else:
-                for i in range(1, self.num_features + 1):
+                for i in tqdm(range(1, self.num_features + 1)):
                     tmp_mask_fixed = np.zeros_like(self.data, dtype=bool)
                     if cleaning_method == 'x':
                         interpolation_performed, _, _ = interpolation_x(
@@ -536,6 +581,15 @@ class CosmicRayCleanerApp(ImageDisplay):
                             npoints=editor.npoints,
                             method='median'
                         )
+                    elif cleaning_method == 'a-mean':
+                        interpolation_performed, _, _ = interpolation_a(
+                            data=self.data,
+                            mask_fixed=tmp_mask_fixed,
+                            cr_labels=self.cr_labels,
+                            cr_index=i,
+                            npoints=editor.npoints,
+                            method='mean'
+                        )
                     else:
                         raise ValueError(f"Unknown cleaning method: {cleaning_method}")
                     if interpolation_performed:
@@ -548,8 +602,9 @@ class CosmicRayCleanerApp(ImageDisplay):
             # recalculate labels and number of features
             structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
             self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
-            print(f"Remaining number of cosmic ray pixels...........: {np.sum(self.mask_crfound)}")
-            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features}")
+            sdum = str(np.sum(self.mask_crfound))
+            print(f"Remaining number of cosmic ray pixels...........: {sdum}")
+            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features:>{len(sdum)}}")
             # redraw image to show the changes
             self.image.set_data(self.data)
             self.canvas.draw_idle()
@@ -612,8 +667,9 @@ class CosmicRayCleanerApp(ImageDisplay):
             # recalculate labels and number of features
             structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
             self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
-            print(f"Remaining number of cosmic ray pixels...........: {np.sum(self.mask_crfound)}")
-            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features}")
+            sdum = str(np.sum(self.mask_crfound))
+            print(f"Remaining number of cosmic ray pixels...........: {sdum}")
+            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features:>{len(sdum)}}")
             # redraw image to show the changes
             self.image.set_data(self.data)
             self.canvas.draw_idle()

teareduce/cleanest/definitions.py

@@ -14,21 +14,31 @@
 # using the intrinsic Python types, so that they can be easily cast
 # when reading user input.
 lacosmic_default_dict = {
-    # L.A.Cosmic parameters
-    'gain': {'value': 1.0, 'type': float, 'positive': True},
-    'readnoise': {'value': 6.5, 'type': float, 'positive': True},
-    'sigclip': {'value': 4.5, 'type': float, 'positive': True},
-    'sigfrac': {'value': 0.3, 'type': float, 'positive': True},
-    'objlim': {'value': 5.0, 'type': float, 'positive': True},
-    'niter': {'value': 4, 'type': int, 'positive': True},
-    'verbose': {'value': False, 'type': bool},
+    # L.A.Cosmic parameters for run 1
+    'run1_gain': {'value': 1.0, 'type': float, 'positive': True},
+    'run1_readnoise': {'value': 6.5, 'type': float, 'positive': True},
+    'run1_sigclip': {'value': 5.0, 'type': float, 'positive': True},
+    'run1_sigfrac': {'value': 0.3, 'type': float, 'positive': True},
+    'run1_objlim': {'value': 5.0, 'type': float, 'positive': True},
+    'run1_niter': {'value': 4, 'type': int, 'positive': True},
+    'run1_verbose': {'value': False, 'type': bool},
+    # L.A.Cosmic parameters for run 2
+    'run2_gain': {'value': 1.0, 'type': float, 'positive': True},
+    'run2_readnoise': {'value': 6.5, 'type': float, 'positive': True},
+    'run2_sigclip': {'value': 3.0, 'type': float, 'positive': True},
+    'run2_sigfrac': {'value': 0.3, 'type': float, 'positive': True},
+    'run2_objlim': {'value': 5.0, 'type': float, 'positive': True},
+    'run2_niter': {'value': 4, 'type': int, 'positive': True},
+    'run2_verbose': {'value': False, 'type': bool},
     # Dilation of the mask
     'dilation': {'value': 0, 'type': int, 'positive': True},
     # Limits for the image section to process (pixels start at 1)
     'xmin': {'value': 1, 'type': int, 'positive': True},
     'xmax': {'value': None, 'type': int, 'positive': True},
     'ymin': {'value': 1, 'type': int, 'positive': True},
-    'ymax': {'value': None, 'type': int, 'positive': True}
+    'ymax': {'value': None, 'type': int, 'positive': True},
+    # Number of runs to execute L.A.Cosmic
+    'nruns': {'value': 1, 'type': int, 'positive': True}
 }
 
 # Default parameters for cleaning methods
@@ -37,6 +47,7 @@ VALID_CLEANING_METHODS = [
     'y interp.',
     'surface interp.',
     'median',
+    'mean',
     'lacosmic',
     'auxdata'
 ]

teareduce/cleanest/dilatemask.py

@@ -0,0 +1,41 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Dilate cosmic ray mask"""
+
+from scipy import ndimage
+
+
+def dilatemask(mask, iterations, rank=None, connectivity=1):
+    """Dilate mask by a given number of points.
+
+    Parameters
+    ----------
+    mask : numpy.ndarray of bool
+        A boolean mask array indicating cosmic ray affected pixels.
+    iterations : int
+        The number of dilation iterations to perform. Each iteration
+        expands the mask by one pixel in the specified connectivity.
+    rank : int, optional
+        The rank of the array. If None, it is inferred from crmask.
+        See scipy.ndimage.generate_binary_structure for details.
+    connectivity : int, optional
+        The connectivity for the structuring element. Default is 1.
+        See scipy.ndimage.generate_binary_structure for details.
+
+    Returns
+    -------
+    dilated_mask : numpy.ndarray of bool
+        The dilated mask.
+    """
+    if rank is None:
+        rank = mask.ndim
+    structure = ndimage.generate_binary_structure(rank, connectivity)
+    dilated_mask = ndimage.binary_dilation(mask, structure=structure, iterations=iterations)
+    return dilated_mask

teareduce/cleanest/interpolation_a.py

@@ -10,11 +10,12 @@
 """Surface interpolation (plane fit) or median interpolation"""
 
 import numpy as np
-from scipy.ndimage import binary_dilation
+
+from .dilatemask import dilatemask
 
 
 def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
-    """Interpolate cosmic ray pixels using surface fit or median of border pixels.
+    """Fix cosmic ray pixels using surface fit, median or mean.
 
     Parameters
     ----------
@@ -29,7 +30,7 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
     npoints : int
         The number of points to use for interpolation.
     method : str
-        The interpolation method to use ('surface' or 'median').
+        The interpolation method to use ('surface', 'median' or 'mean').
 
     Returns
     -------
@@ -39,11 +40,27 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
         X-coordinates of border pixels used for interpolation.
     yfit_all : list
         Y-coordinates of border pixels used for interpolation.
+
+    Notes
+    -----
+    The `data` array is modified in place with interpolated values for the
+    cosmic ray pixels. This function also returns an updated `mask_fixed`
+    array with interpolated pixels marked as fixed.
+
+    It is important to highlight that contrary to what is performed when
+    using the X- and Y-interpolation, this function does not fill the gaps
+    between the marked pixels. Only the pixels explicitly marked as affected
+    by cosmic rays are interpolated.
     """
     # Mask of CR pixels
     mask = (cr_labels == cr_index)
     # Dilate the mask to find border pixels
-    dilated_mask = binary_dilation(mask, structure=np.ones((3, 3)), iterations=npoints)
+    # dilated_mask = binary_dilation(mask, structure=np.ones((3, 3)), iterations=npoints)
+    dilated_mask = dilatemask(
+        mask=mask,
+        iterations=npoints,
+        connectivity=1
+    )
     # Border pixels are those in the dilated mask but not in the original mask
     border_mask = dilated_mask & (~mask)
     # Get coordinates of border pixels
@@ -67,16 +84,21 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
             interpolation_performed = True
         else:
             print("Not enough points to fit a plane")
-    elif method == 'median':
+    elif method in ['median', 'mean']:
         # Compute median of all surrounding points
         if len(zfit_all) > 0:
-            zmed = np.median(zfit_all)
+            if method == 'median':
+                zval = np.median(zfit_all)
+            else:
+                zval = np.mean(zfit_all)
             # recompute all CR pixels to take into account "holes" between marked pixels
             ycr_list, xcr_list = np.where(cr_labels == cr_index)
             for iy, ix in zip(ycr_list, xcr_list):
-                data[iy, ix] = zmed
+                data[iy, ix] = zval
                 mask_fixed[iy, ix] = True
             interpolation_performed = True
+        else:
+            print("No surrounding points found for median interpolation")
     else:
         print(f"Unknown interpolation method: {method}")
 

teareduce/cleanest/interpolation_x.py

@@ -37,6 +37,24 @@ def interpolation_x(data, mask_fixed, cr_labels, cr_index, npoints, degree):
         X-coordinates of border pixels used for interpolation.
     yfit_all : list
         Y-coordinates of border pixels used for interpolation.
+
+    Notes
+    -----
+    The `data` array is modified in place with interpolated values for the
+    cosmic ray pixels. This function also returns an updated `mask_fixed`
+    array with interpolated pixels marked as fixed.
+
+    It is important to highlight that this function assumes that at
+    every y-coordinate where cosmic ray pixels are found, the pixels
+    form a contiguous horizontal segment. In this sense, gaps in the
+    x-direction are assumed to be also part of the same cosmic ray
+    feature, and the `cr_labels` array is updated accordingly. In other
+    words, all the pixels between the minimum and maximum x-coordinates
+    of the cosmic ray pixels at a given y-coordinate are treated as
+    affected by the cosmic ray. This simplyfies the interactive marking
+    of cosmic rays, as the user does not need to ensure that all pixels
+    in a horizontal segment are marked; marking just the extreme pixels
+    is sufficient.
     """
     ycr_list, xcr_list = np.where(cr_labels == cr_index)
     ycr_min = np.min(ycr_list)

teareduce/cleanest/interpolation_y.py

@@ -37,6 +37,24 @@ def interpolation_y(data, mask_fixed, cr_labels, cr_index, npoints, degree):
         X-coordinates of border pixels used for interpolation.
     yfit_all : list
         Y-coordinates of border pixels used for interpolation.
+
+    Notes
+    -----
+    The `data` array is modified in place with interpolated values for the
+    cosmic ray pixels. This function also returns an updated `mask_fixed`
+    array with interpolated pixels marked as fixed.
+
+    It is important to highlight that this function assumes that at
+    every x-coordinate where cosmic ray pixels are found, the pixels
+    form a contiguous vertical segment. In this sense, gaps in the
+    y-direction are assumed to be also part of the same cosmic ray
+    feature, and the `cr_labels` array is updated accordingly. In other
+    words, all the pixels between the minimum and maximum y-coordinates
+    of the cosmic ray pixels at a given x-coordinate are treated as
+    affected by the cosmic ray. This simplyfies the interactive marking
+    of cosmic rays, as the user does not need to ensure that all pixels
+    in a vertical segment are marked; marking just the extreme pixels
+    is sufficient.
     """
     ycr_list, xcr_list = np.where(cr_labels == cr_index)
     xcr_min = np.min(xcr_list)

teareduce/cleanest/interpolationeditor.py

@@ -72,6 +72,7 @@ class InterpolationEditor:
             "y interp.": "y",
             "surface interp.": "a-plane",
             "median": "a-median",
+            "mean": "a-mean",
             "lacosmic": "lacosmic",
             "auxdata": "auxdata"
         }
@@ -190,6 +191,9 @@ class InterpolationEditor:
         elif selected_method == 'median':
             self.entry_npoints.config(state='normal')
             self.entry_degree.config(state='disabled')
+        elif selected_method == 'mean':
+            self.entry_npoints.config(state='normal')
+            self.entry_degree.config(state='disabled')
         elif selected_method == 'lacosmic':
             self.entry_npoints.config(state='disabled')
             self.entry_degree.config(state='disabled')

teareduce/cleanest/parametereditor.py

@@ -75,7 +75,7 @@ class ParameterEditor:
         self.param_dict['ymin']['value'] = ymin
         self.param_dict['ymax']['value'] = ymax
         self.imgshape = imgshape
-        self.entries = {}  # dictionary to hold entry widgets
+        self.entries = {'run1': {}, 'run2': {}}  # dictionary to hold entry widgets
         self.result_dict = None
 
         # Create the form
@@ -91,33 +91,48 @@ class ParameterEditor:
 
         # Subtitle for L.A.Cosmic parameters
         subtitle_label = tk.Label(main_frame, text="L.A.Cosmic Parameters", font=("Arial", 14, "bold"))
-        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
         row += 1
 
-        # Create labels and entry fields for each parameter
+        # Create labels and entry fields for each parameter.
+        # Note: here we are using entry_vars to trace changes in the entries
+        # so that we can update the color of run2 entries if they differ from run1.
+        self.entry_vars = {}
         for key, info in self.param_dict.items():
-            if key.lower() not in ['dilation', 'xmin', 'xmax', 'ymin', 'ymax']:
-                # Parameter name label
-                label = tk.Label(main_frame, text=f"{key}:", anchor='e', width=15)
-                label.grid(row=row, column=0, sticky='w', pady=5)
-                # Entry field
-                entry = tk.Entry(main_frame, width=10)
-                entry.insert(0, str(info['value']))
-                entry.grid(row=row, column=1, padx=10, pady=5)
-                self.entries[key] = entry  # dictionary to hold entry widgets
-                # Type label
-                type_label = tk.Label(main_frame, text=f"({info['type'].__name__})", fg='gray', anchor='w', width=10)
-                type_label.grid(row=row, column=2, sticky='w', pady=5)
-                row += 1
+            if not key.startswith('run1_'):
+                continue
+            # Parameter name label
+            label = tk.Label(main_frame, text=f"{key[5:]}:", anchor='e', width=15)
+            label.grid(row=row, column=0, sticky='w', pady=5)
+            # Entry field for run1
+            self.entry_vars[key] = tk.StringVar()
+            self.entry_vars[key].trace_add('write', lambda *args: self.update_colour_param_run1_run2())
+            entry = tk.Entry(main_frame, textvariable=self.entry_vars[key], width=10)
+            entry.insert(0, str(info['value']))
+            entry.grid(row=row, column=1, padx=10, pady=5)
+            self.entries[key] = entry  # dictionary to hold entry widgets
+            # Entry field for run2
+            key2 = 'run2_' + key[5:]
+            self.entry_vars[key2] = tk.StringVar()
+            self.entry_vars[key2].trace_add('write', lambda *args: self.update_colour_param_run1_run2())
+            entry = tk.Entry(main_frame, textvariable=self.entry_vars[key2], width=10)
+            entry.insert(0, str(self.param_dict[key2]['value']))
+            entry.grid(row=row, column=2, padx=10, pady=5)
+            self.entries['run2_'+key[5:]] = entry  # dictionary to hold entry widgets
+            # Type label
+            type_label = tk.Label(main_frame, text=f"({info['type'].__name__})", fg='gray', anchor='w', width=10)
+            type_label.grid(row=row, column=3, sticky='w', pady=5)
+            row += 1
+        # self.update_colour_param_run1_run2()
 
         # Separator
         separator1 = ttk.Separator(main_frame, orient='horizontal')
-        separator1.grid(row=row, column=0, columnspan=3, sticky='ew', pady=(10, 10))
+        separator1.grid(row=row, column=0, columnspan=4, sticky='ew', pady=(10, 10))
         row += 1
 
         # Subtitle for additional parameters
         subtitle_label = tk.Label(main_frame, text="Additional Parameters", font=("Arial", 14, "bold"))
-        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
         row += 1
 
         # Dilation label and entry
@@ -134,12 +149,12 @@ class ParameterEditor:
 
         # Separator
         separator2 = ttk.Separator(main_frame, orient='horizontal')
-        separator2.grid(row=row, column=0, columnspan=3, sticky='ew', pady=(10, 10))
+        separator2.grid(row=row, column=0, columnspan=4, sticky='ew', pady=(10, 10))
         row += 1
 
         # Subtitle for region to be examined
         subtitle_label = tk.Label(main_frame, text="Region to be Examined", font=("Arial", 14, "bold"))
-        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
         row += 1
 
         # Region to be examined label and entries
@@ -165,12 +180,12 @@ class ParameterEditor:
 
         # Separator
         separator3 = ttk.Separator(main_frame, orient='horizontal')
-        separator3.grid(row=row, column=0, columnspan=3, sticky='ew', pady=(10, 10))
+        separator3.grid(row=row, column=0, columnspan=4, sticky='ew', pady=(10, 10))
         row += 1
 
         # Button frame
         button_frame = tk.Frame(main_frame)
-        button_frame.grid(row=row, column=0, columnspan=3, pady=(5, 0))
+        button_frame.grid(row=row, column=0, columnspan=4, pady=(5, 0))
 
         # OK button
         ok_button = tk.Button(button_frame, text="OK", width=5, command=self.on_ok)
@@ -190,6 +205,8 @@ class ParameterEditor:
             updated_dict = {}
 
             for key, info in self.param_dict.items():
+                if key == 'nruns':
+                    continue
                 entry_value = self.entries[key].get()
                 value_type = info['type']
 
@@ -212,6 +229,17 @@ class ParameterEditor:
                     'type': value_type
                 }
 
+            # Check whether any run1 and run2 parameters differ
+            nruns = 1
+            for key in self.param_dict.keys():
+                if key.startswith('run1_'):
+                    parname = key[5:]
+                    key2 = 'run2_' + parname
+                    if updated_dict[key]['value'] != updated_dict[key2]['value']:
+                        nruns = 2
+                        print(f"Parameter '{parname}' differs between run1 and run2: "
+                              f"{updated_dict[key]['value']} (run1) vs {updated_dict[key2]['value']} (run2)")
+
             # Additional validation for region limits
             try:
                 if updated_dict['xmax']['value'] <= updated_dict['xmin']['value']:
@@ -219,6 +247,9 @@ class ParameterEditor:
                 if updated_dict['ymax']['value'] <= updated_dict['ymin']['value']:
                     raise ValueError("ymax must be greater than ymin")
                 self.result_dict = updated_dict
+                self.result_dict['nruns'] = {'value': nruns, 'type': int, 'positive': True}
+                if nruns not in [1, 2]:
+                    raise ValueError("nruns must be 1 or 2")
                 self.root.destroy()
             except ValueError as e:
                 messagebox.showerror("Invalid Inputs",
@@ -243,9 +274,23 @@ class ParameterEditor:
         self.param_dict['ymin']['value'] = 1
         self.param_dict['ymax']['value'] = self.imgshape[0]
         for key, info in self.param_dict.items():
+            if key == 'nruns':
+                continue
             self.entries[key].delete(0, tk.END)
             self.entries[key].insert(0, str(info['value']))
 
     def get_result(self):
         """Return the updated dictionary"""
         return self.result_dict
+
+    def update_colour_param_run1_run2(self):
+        """Update the foreground color of run1 and run2 entries."""
+        # Highlight run2 parameter if different from run1
+        for key in self.param_dict.keys():
+            if key.startswith('run1_'):
+                parname = key[5:]
+                if key in self.entries and 'run2_'+parname in self.entries:
+                    if self.entries[key].get() != self.entries['run2_'+parname].get():
+                        self.entries['run2_'+parname].config(fg='red')
+                    else:
+                        self.entries['run2_'+parname].config(fg='black')

teareduce/cleanest/reviewcosmicray.py

@@ -193,8 +193,11 @@ class ReviewCosmicRay(ImageDisplay):
         self.interp_s_button = tk.Button(self.button_frame2, text="[s]urface interp.",
                                          command=lambda: self.interp_a('surface'))
         self.interp_s_button.pack(side=tk.LEFT, padx=5)
-        self.interp_m_button = tk.Button(self.button_frame2, text="[m]edian",
+        self.interp_d_button = tk.Button(self.button_frame2, text="me[d]ian",
                                          command=lambda: self.interp_a('median'))
+        self.interp_d_button.pack(side=tk.LEFT, padx=5)
+        self.interp_m_button = tk.Button(self.button_frame2, text="[m]ean",
+                                         command=lambda: self.interp_a('mean'))
         self.interp_m_button.pack(side=tk.LEFT, padx=5)
         self.interp_l_button = tk.Button(self.button_frame2, text="[l]acosmic", command=self.use_lacosmic)
         self.interp_l_button.pack(side=tk.LEFT, padx=5)
@@ -262,20 +265,24 @@ class ReviewCosmicRay(ImageDisplay):
         # to avoid image shifts when some pixels are unmarked or new ones are marked
         i0 = int(np.mean(ycr_list_original) + 0.5)
         j0 = int(np.mean(xcr_list_original) + 0.5)
-        semiwidth = MAX_PIXEL_DISTANCE_TO_CR
+        max_distance_from_center = np.max(
+            [np.max(np.abs(ycr_list_original - i0)),
+             np.max(np.abs(xcr_list_original - j0))]
+        )
+        semiwidth = int(np.max([max_distance_from_center, MAX_PIXEL_DISTANCE_TO_CR]))
         jmin = j0 - semiwidth if j0 - semiwidth >= 0 else 0
         jmax = j0 + semiwidth if j0 + semiwidth < self.data.shape[1] else self.data.shape[1] - 1
         imin = i0 - semiwidth if i0 - semiwidth >= 0 else 0
         imax = i0 + semiwidth if i0 + semiwidth < self.data.shape[0] else self.data.shape[0] - 1
         # Force the region to be of size (2*semiwidth + 1) x (2*semiwidth + 1)
         if jmin == 0:
-            jmax = 2 * semiwidth
+            jmax = np.min([2 * semiwidth, self.data.shape[1] - 1])
         elif jmax == self.data.shape[1] - 1:
-            jmin = self.data.shape[1] - 1 - 2 * semiwidth
+            jmin = np.max([0, self.data.shape[1] - 1 - 2 * semiwidth])
         if imin == 0:
-            imax = 2 * semiwidth
+            imax = np.min([2 * semiwidth, self.data.shape[0] - 1])
         elif imax == self.data.shape[0] - 1:
-            imin = self.data.shape[0] - 1 - 2 * semiwidth
+            imin = np.max([0, self.data.shape[0] - 1 - 2 * semiwidth])
         self.region = SliceRegion2D(f'[{jmin+1}:{jmax+1}, {imin+1}:{imax+1}]', mode='fits').python
         self.ax.clear()
         vmin = self.get_vmin()
@@ -333,6 +340,7 @@ class ReviewCosmicRay(ImageDisplay):
         self.interp_x_button.config(state=tk.DISABLED)
         self.interp_y_button.config(state=tk.DISABLED)
         self.interp_s_button.config(state=tk.DISABLED)
+        self.interp_d_button.config(state=tk.DISABLED)
         self.interp_m_button.config(state=tk.DISABLED)
         self.interp_l_button.config(state=tk.DISABLED)
         self.interp_aux_button.config(state=tk.DISABLED)
@@ -387,7 +395,7 @@ class ReviewCosmicRay(ImageDisplay):
         Parameters
         ----------
         method : str
-            The interpolation method to use ('surface' or 'median').
+            The interpolation method to use ('surface', 'median' or 'mean').
         """
         print(f"{method} interpolation of cosmic ray {self.cr_index}")
         interpolation_performed, xfit_all, yfit_all = interpolation_a(
@@ -444,6 +452,7 @@ class ReviewCosmicRay(ImageDisplay):
         self.interp_x_button.config(state=tk.DISABLED)
         self.interp_y_button.config(state=tk.DISABLED)
         self.interp_s_button.config(state=tk.DISABLED)
+        self.interp_d_button.config(state=tk.DISABLED)
         self.interp_m_button.config(state=tk.DISABLED)
         self.interp_l_button.config(state=tk.DISABLED)
         self.interp_aux_button.config(state=tk.DISABLED)
@@ -458,6 +467,7 @@ class ReviewCosmicRay(ImageDisplay):
             self.interp_x_button.config(state=tk.NORMAL)
             self.interp_y_button.config(state=tk.NORMAL)
             self.interp_s_button.config(state=tk.NORMAL)
+            self.interp_d_button.config(state=tk.NORMAL)
             self.interp_m_button.config(state=tk.NORMAL)
             if self.cleandata_lacosmic is not None:
                 if self.last_dilation is None or self.last_dilation == 0:
@@ -484,6 +494,7 @@ class ReviewCosmicRay(ImageDisplay):
         self.interp_x_button.config(state=tk.NORMAL)
         self.interp_y_button.config(state=tk.NORMAL)
         self.interp_s_button.config(state=tk.NORMAL)
+        self.interp_d_button.config(state=tk.NORMAL)
         self.interp_m_button.config(state=tk.NORMAL)
         if self.cleandata_lacosmic is not None:
             if self.last_dilation is None or self.last_dilation == 0:
@@ -513,9 +524,12 @@ class ReviewCosmicRay(ImageDisplay):
         elif event.key == 's':
             if self.interp_s_button.cget("state") != "disabled":
                 self.interp_a('surface')
+        elif event.key == 'd':
+            if self.interp_d_button.cget("state") != "disabled":
+                self.interp_a('median')
         elif event.key == 'm':
             if self.interp_m_button.cget("state") != "disabled":
-                self.interp_a('median')
+                self.interp_a('mean')
         elif event.key == 'l':
             if self.interp_l_button.cget("state") != "disabled":
                 self.use_lacosmic()
@@ -551,6 +565,7 @@ class ReviewCosmicRay(ImageDisplay):
                 self.interp_x_button.config(state=tk.DISABLED)
                 self.interp_y_button.config(state=tk.DISABLED)
                 self.interp_s_button.config(state=tk.DISABLED)
+                self.interp_d_button.config(state=tk.DISABLED)
                 self.interp_m_button.config(state=tk.DISABLED)
                 self.interp_l_button.config(state=tk.DISABLED)
                 self.interp_aux_button.config(state=tk.DISABLED)
@@ -559,6 +574,7 @@ class ReviewCosmicRay(ImageDisplay):
                 self.interp_x_button.config(state=tk.NORMAL)
                 self.interp_y_button.config(state=tk.NORMAL)
                 self.interp_s_button.config(state=tk.NORMAL)
+                self.interp_d_button.config(state=tk.NORMAL)
                 self.interp_m_button.config(state=tk.NORMAL)
                 if self.cleandata_lacosmic is not None:
                     if self.last_dilation is None or self.last_dilation == 0:

teareduce/tests/test_cleanest.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+# License-Filename: LICENSE.txt
+#
+"""Tests for the cleanest module."""
+
+import numpy as np
+
+
+from ..cleanest.cleanest import cleanest
+
+
+def test_cleanest_no_cr():
+    """Test cleanest function with no cosmic rays."""
+    data = np.array([[1, 2, 3],
+                     [4, 5, 6],
+                     [7, 8, 9]], dtype=float)
+    mask_crfound = np.zeros_like(data, dtype=bool)
+
+    for interp_method in ['x', 'y', 's', 'd', 'm']:
+        cleaned_data, mask_fixed = cleanest(data, mask_crfound, interp_method=interp_method, npoints=2, degree=1)
+
+        assert np.array_equal(cleaned_data, data), "Data should remain unchanged when no cosmic rays are present."
+        assert np.array_equal(mask_fixed, mask_crfound), "Mask should remain unchanged when no cosmic rays are present."
+
+
+def test_cleanest_interpolation_x():
+    """Test cleanest function with interpolation in X direction."""
+    data = np.array([[1, 1, 2, 1, 1],
+                     [2, 2, 3, 2, 2],
+                     [3, 3, 4, 3, 3]], dtype=float)
+    mask_crfound = np.array([[False, False, True, False, False],
+                             [False, False, True, False, False],
+                             [False, False, True, False, False]], dtype=bool)
+
+    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
+                                        interp_method='x', npoints=2, degree=1)
+
+    expected_data = np.array([[1, 1, 1, 1, 1],
+                              [2, 2, 2, 2, 2],
+                              [3, 3, 3, 3, 3]], dtype=float)
+
+    assert np.allclose(cleaned_data, expected_data), "Interpolation in X direction failed."
+    assert np.array_equal(mask_fixed, mask_crfound), "Mask should remain unchanged after interpolation."
+
+
+def test_cleanest_interpolation_y():
+    """Test cleanest function with interpolation in Y direction."""
+    data = np.array([[1, 2, 3],
+                     [1, 2, 3],
+                     [2, 3, 4],
+                     [1, 2, 3],
+                     [1, 2, 3]], dtype=float)
+    mask_crfound = np.array([[False, False, False],
+                             [False, False, False],
+                             [True, True, True],
+                             [False, False, False],
+                             [False, False, False]], dtype=bool)
+
+    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
+                                        interp_method='y', npoints=2, degree=1)
+
+    expected_data = np.array([[1, 2, 3],
+                              [1, 2, 3],
+                              [1, 2, 3],
+                              [1, 2, 3],
+                              [1, 2, 3]], dtype=float)
+    assert np.allclose(cleaned_data, expected_data), "Interpolation in Y direction failed."
+    assert np.array_equal(mask_fixed, mask_crfound), "Mask should remain unchanged after interpolation."
+
+
+def test_cleanest_interpolation_surface():
+    """Test cleanest function with surface interpolation."""
+    data = np.array([[1, 2, 3],
+                     [4, 100, 6],
+                     [7, 8, 9]], dtype=float)
+    mask_crfound = np.array([[False, False, False],
+                             [False, True, False],
+                             [False, False, False]], dtype=bool)
+
+    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
+                                        interp_method='s', npoints=1)
+
+    expected_data = np.array([[1, 2, 3],
+                              [4, 5, 6],
+                              [7, 8, 9]], dtype=float)
+    assert np.allclose(cleaned_data, expected_data), "Surface interpolation failed."
+    assert np.array_equal(mask_fixed, mask_crfound), "Mask should remain unchanged after interpolation."
+
+
+def test_cleanest_interpolation_median():
+    """Test cleanest function with median border pixel interpolation."""
+    data = np.array([[1, 2, 3],
+                     [4, 100, 6],
+                     [7, 8, 9]], dtype=float)
+    mask_crfound = np.array([[False, False, False],
+                             [False, True, False],
+                             [False, False, False]], dtype=bool)
+
+    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
+                                        interp_method='d', npoints=1)
+
+    expected_data = np.array([[1, 2, 3],
+                              [4, 5, 6],
+                              [7, 8, 9]], dtype=float)
+    assert np.allclose(cleaned_data, expected_data), "Median border pixel interpolation failed."
+    assert np.array_equal(mask_fixed, mask_crfound), "Mask should remain unchanged after interpolation."
+
+
+def test_cleanest_interpolation_mean():
+    """Test cleanest function with mean border pixel interpolation."""
+    data = np.array([[1, 2, 3],
+                     [4, 100, 6],
+                     [7, 8, 9]], dtype=float)
+    mask_crfound = np.array([[False, False, False],
+                             [False, True, False],
+                             [False, False, False]], dtype=bool)
+
+    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
+                                        interp_method='m', npoints=1)
+
+    expected_data = np.array([[1, 2, 3],
+                              [4, 5, 6],
+                              [7, 8, 9]], dtype=float)
+    assert np.allclose(cleaned_data, expected_data), "Mean border pixel interpolation failed."
+    assert np.array_equal(mask_fixed, mask_crfound), "Mask should remain unchanged after interpolation."

teareduce/version.py

@@ -9,7 +9,7 @@
 #
 """Module to define the version of the teareduce package."""
 
-VERSION = '0.5.1'
+VERSION = '0.5.3'
 
 
 def main():

{teareduce-0.5.1.dist-info → teareduce-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: teareduce
-Version: 0.5.1
+Version: 0.5.3
 Summary: Utilities for astronomical data reduction
 Author-email: Nicolás Cardiel <cardiel@ucm.es>
 License: GPL-3.0-or-later
@@ -20,6 +20,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: astropy
+Requires-Dist: ccdproc
 Requires-Dist: lmfit
 Requires-Dist: matplotlib
 Requires-Dist: numpy>=1.22

{teareduce-0.5.1.dist-info → teareduce-0.5.3.dist-info}/RECORD

@@ -15,30 +15,33 @@ teareduce/sdistortion.py,sha256=5ZsZn4vD5Sw2aoqO8-NIOH7H89Zmh7ZDkow6YbAotHU,5916
 teareduce/simulateccdexposure.py,sha256=cdbpca6GVuM3d7R1LGzlIZZvjTq_jzrlkk_Cli7aouQ,24636
 teareduce/sliceregion.py,sha256=Jdf8XvmGaY_vaY1cneTaRtSOYPxpUsJm9cXJDDMa0YM,18626
 teareduce/statsummary.py,sha256=VTNAnBV8z6suqiyB2Lhw3YjUUOjlmwUPX3enkOKRF54,5422
-teareduce/version.py,sha256=xLqN-tdfVT9Wo_JlWBg7gTYouoD8dFGklalXALgLTAU,419
+teareduce/version.py,sha256=PhV5vwOfjd2-SjStecfYtye4EUgepCl7-M0rx5QAJA0,419
 teareduce/wavecal.py,sha256=2MewWz5Y3ms41c305UtWOM_LaLNdk1mugDXCtzf-fSw,68586
 teareduce/write_array_to_fits.py,sha256=kWDrEH9coJ1yIu56oQJpWtDqJL4c8HGmssE9jle4e94,617
 teareduce/zscale.py,sha256=SDgmcDD2N5GvDn46JADCgTQJPBF_N_jSKMHoeTz9Nsw,1152
-teareduce/cleanest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+teareduce/cleanest/__init__.py,sha256=3O-eptEAQareN504tLALMrJVQPGCuBx7YTfQGqMKjmc,205
 teareduce/cleanest/__main__.py,sha256=mobw6PW6JauOBKt-0eNvUH0UCC_D-AjrbTlzfAu7joY,1732
-teareduce/cleanest/cosmicraycleanerapp.py,sha256=k0E72E4lOwYmQ8IKRhtyuQIHsKxHjVA2V5hJEFKnQDo,33141
-teareduce/cleanest/definitions.py,sha256=zTF3O0dC1VeU43MZqYA6WLk8NRsNL07IHW9NvWXHyJM,1689
+teareduce/cleanest/cleanest.py,sha256=tf1RdKRZfSXkGXbMVkN-Y0eudFb_XUfCl8Va2mJ0kK8,5070
+teareduce/cleanest/cosmicraycleanerapp.py,sha256=gYP9KaueOPaUX2iLnHZc5rWBeiAm8u-2Lxl3t83KBls,36409
+teareduce/cleanest/definitions.py,sha256=pcq0gk_EnDVkRfatWseQvRIyF445jIarICkuWIW3oqE,2343
+teareduce/cleanest/dilatemask.py,sha256=I5tHAv5VEO6V0Wed8Ar20uLt4F9P-tgjmLL5BAaFvgM,1276
 teareduce/cleanest/find_closest_true.py,sha256=mWdIvhipzAXDRKfePDrP7f0lP4U48cckpHiKwiB4jHI,1320
 teareduce/cleanest/imagedisplay.py,sha256=4FhoRcyskj_F6gaza4U37sLODpe-Sud3sunM8_-p5iY,5877
-teareduce/cleanest/interpolation_a.py,sha256=MpZ41WV3ck5Q2DDmgkeMhIqG-VNVD97lN9SU1tUJJmA,3266
-teareduce/cleanest/interpolation_x.py,sha256=qp1JU5_w8xrsyo33cK2U1gYf4Y49LewDJ8-s1pxh93s,2801
-teareduce/cleanest/interpolation_y.py,sha256=ra6rdvUcwG5hVqF7id5rLtSE8amgvjSYFSrgjhwSgIQ,2820
-teareduce/cleanest/interpolationeditor.py,sha256=RjAmfgpNOFivot9nz9d87Xno-hxmtDdNH29oIvn5xeY,8000
-teareduce/cleanest/parametereditor.py,sha256=XxGRLqm8Rcy7vkCSMVPrBxLeqFWFFWNaIklr7bmS7eU,10058
-teareduce/cleanest/reviewcosmicray.py,sha256=U2jpYsNSNFA8bbqeQ8wZDvVWTwdgLPZfvtIzzcy23aA,26783
+teareduce/cleanest/interpolation_a.py,sha256=upbfZBU0i7YyXR4EJj-WdnMkWbajgDbnUDvJaoLAeEg,4039
+teareduce/cleanest/interpolation_x.py,sha256=D5hKbobT6lJk18XktP3PXhzEN12zqed6U18yfQ-reLQ,3744
+teareduce/cleanest/interpolation_y.py,sha256=O6yw5nKKlTdV6qsP1Ku6CwGhXB6o3j0_YQirXyILi8c,3759
+teareduce/cleanest/interpolationeditor.py,sha256=F5_FyOLHgtvoan22Lfaoa9j-kdKrygaQARi1SYsDfPA,8179
+teareduce/cleanest/parametereditor.py,sha256=wfl1Zem_FI02YAVawq8r1FLGz5dXB5-S8RF1d_v6ZEQ,12495
+teareduce/cleanest/reviewcosmicray.py,sha256=tL1iutMrWlp0Ep5eDnuXlBPaIsFgYzy_c7BGU8_Gcd0,27775
 teareduce/cookbook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 teareduce/cookbook/get_cookbook_file.py,sha256=vde-iNii2lm1QII8GmLRsFsKNxkdsd7njCBE-8Z7io0,1088
 teareduce/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+teareduce/tests/test_cleanest.py,sha256=0uiun1Uloh3rt5ppkv1aG04KUbOJvYZ9C5BvqNizLuI,5562
 teareduce/tests/test_sliceregion.py,sha256=S7Zoh2eEBFIEbfsXgWBEMCf7pottjw2oLhqlZJQkAwg,3785
 teareduce/tests/test_version.py,sha256=mKLnbXyvVNc1pATq5PxR8qeoFMPAFL_GilFV6IHLOi0,172
-teareduce-0.5.1.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-teareduce-0.5.1.dist-info/METADATA,sha256=e5_qPcfh2VS2v0o9mhF5wpasxq0Bp5oWHs0fIqkqjeo,3090
-teareduce-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-teareduce-0.5.1.dist-info/entry_points.txt,sha256=6yBvig5jTL2ugqz5SF767AiszzrHKGRASsX1II84kqA,66
-teareduce-0.5.1.dist-info/top_level.txt,sha256=7OkwtX9zNRkGJ7ACgjk4ESgC74qUYcS5O2qcO0v-Si4,10
-teareduce-0.5.1.dist-info/RECORD,,
+teareduce-0.5.3.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+teareduce-0.5.3.dist-info/METADATA,sha256=4CHBLx7SPJxE9Yh6gaxL5dpfxPkqH-g5DFcucCNzn9k,3113
+teareduce-0.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+teareduce-0.5.3.dist-info/entry_points.txt,sha256=6yBvig5jTL2ugqz5SF767AiszzrHKGRASsX1II84kqA,66
+teareduce-0.5.3.dist-info/top_level.txt,sha256=7OkwtX9zNRkGJ7ACgjk4ESgC74qUYcS5O2qcO0v-Si4,10
+teareduce-0.5.3.dist-info/RECORD,,