teareduce 0.5.4__py3-none-any.whl → 0.5.7__py3-none-any.whl

teareduce/cleanest/definitions.py

@@ -15,42 +15,35 @@
 # when reading user input.
 lacosmic_default_dict = {
     # 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},
+    "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": True, "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},
+    "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": True, "type": bool},
     # Dilation of the mask
-    'dilation': {'value': 0, 'type': int, 'positive': True},
+    "dilation": {"value": 0, "type": int, "positive": True},
+    "borderpadd": {"value": 10, "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},
+    "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},
     # Number of runs to execute L.A.Cosmic
-    'nruns': {'value': 1, 'type': int, 'positive': True}
+    "nruns": {"value": 1, "type": int, "positive": True},
 }
 
 # Default parameters for cleaning methods
-VALID_CLEANING_METHODS = [
-    'x interp.',
-    'y interp.',
-    'surface interp.',
-    'median',
-    'mean',
-    'lacosmic',
-    'auxdata'
-]
+VALID_CLEANING_METHODS = ["x interp.", "y interp.", "surface interp.", "median", "mean", "lacosmic", "auxdata"]
 
 # Maximum pixel distance to consider when finding closest CR pixel
 MAX_PIXEL_DISTANCE_TO_CR = 15
@@ -60,3 +53,11 @@ DEFAULT_NPOINTS_INTERP = 2
 
 # Default degree for interpolation
 DEFAULT_DEGREE_INTERP = 1
+
+# Default Tk window size
+DEFAULT_TK_WINDOW_SIZE_X = 800
+DEFAULT_TK_WINDOW_SIZE_Y = 700
+
+# Default font settings
+DEFAULT_FONT_FAMILY = "Helvetica"
+DEFAULT_FONT_SIZE = 14

teareduce/cleanest/imagedisplay.py

@@ -60,6 +60,7 @@ class ImageDisplay:
     the displayed region can be determined from either the axes limits or a
     predefined region attribute.
     """
+
     def set_vmin(self):
         """Prompt user to set a new minimum display value (vmin)."""
         old_vmin = self.get_vmin()
@@ -72,7 +73,7 @@ class ImageDisplay:
             return
         self.vmin_button.config(text=f"vmin: {new_vmin:.2f}")
         self.image.set_clim(vmin=new_vmin)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmin=new_vmin)
         self.canvas.draw_idle()
 
@@ -88,7 +89,7 @@ class ImageDisplay:
             return
         self.vmax_button.config(text=f"vmax: {new_vmax:.2f}")
         self.image.set_clim(vmax=new_vmax)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmax=new_vmax)
         self.canvas.draw_idle()
 
@@ -102,7 +103,7 @@ class ImageDisplay:
 
     def get_displayed_region(self):
         """Get the currently displayed region of the image."""
-        if hasattr(self, 'ax'):
+        if hasattr(self, "ax"):
             xmin, xmax = self.ax.get_xlim()
             xmin = int(xmin + 0.5)
             if xmin < 1:
@@ -118,10 +119,8 @@ class ImageDisplay:
             if ymax > self.data.shape[0]:
                 ymax = self.data.shape[0]
             print(f"Setting min/max using axis limits: x=({xmin:.2f}, {xmax:.2f}), y=({ymin:.2f}, {ymax:.2f})")
-            region = self.region = SliceRegion2D(
-                f'[{xmin}:{xmax}, {ymin}:{ymax}]', mode='fits'
-            ).python
-        elif hasattr(self, 'region'):
+            region = self.region = SliceRegion2D(f"[{xmin}:{xmax}, {ymin}:{ymax}]", mode="fits").python
+        elif hasattr(self, "region"):
             region = self.region
         else:
             raise AttributeError("No axis or region defined for set_minmax.")
@@ -136,7 +135,7 @@ class ImageDisplay:
         self.vmax_button.config(text=f"vmax: {vmax_new:.2f}")
         self.image.set_clim(vmin=vmin_new)
         self.image.set_clim(vmax=vmax_new)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmin=vmin_new)
             self.image_aux.set_clim(vmax=vmax_new)
         self.canvas.draw_idle()
@@ -149,7 +148,7 @@ class ImageDisplay:
         self.vmax_button.config(text=f"vmax: {vmax_new:.2f}")
         self.image.set_clim(vmin=vmin_new)
         self.image.set_clim(vmax=vmax_new)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmin=vmin_new)
             self.image_aux.set_clim(vmax=vmax_new)
         self.canvas.draw_idle()

teareduce/cleanest/{cleanest.py → interpolate.py}

@@ -11,6 +11,7 @@
 
 from scipy import ndimage
 import numpy as np
+from tqdm import tqdm
 
 from .dilatemask import dilatemask
 from .interpolation_x import interpolation_x
@@ -18,9 +19,7 @@ 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):
+def interpolate(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
@@ -31,8 +30,8 @@ def cleanest(data, mask_crfound, dilation=0,
     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.
+        A boolean mask array indicating which pixels are flagged
+        and need to be interpolated (True = pixel to be fixed).
     dilation : int, optional
         The number of pixels to dilate the masked pixels before
         interpolation.
@@ -50,7 +49,7 @@ def cleanest(data, mask_crfound, dilation=0,
         The degree of the polynomial to fit. This parameter is
         relevant for 'x' and 'y' methods.
     debug : bool, optional
-        If True, print debug information.
+        If True, print debug information and enable tqdm progress bar.
 
     Returns
     -------
@@ -68,11 +67,11 @@ def cleanest(data, mask_crfound, dilation=0,
     """
     if interp_method is None:
         raise ValueError("interp_method must be specified.")
-    if interp_method not in ['x', 'y', 's', 'd', 'm']:
+    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']:
+    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
@@ -85,22 +84,21 @@ def cleanest(data, mask_crfound, dilation=0,
     mask_fixed = np.zeros_like(mask_crfound, dtype=bool)
 
     # Determine number of CR features
-    structure = [[1, 1, 1],
-                 [1, 1, 1],
-                 [1, 1, 1]]
+    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}")
+        sdum = str(np.sum(updated_mask_crfound))
+        print(f"Number of cosmic ray pixels to be cleaned: {sdum}")
+        print(f"Number of cosmic rays (grouped pixels)...: {num_features:>{len(sdum)}}")
 
     # 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']:
+    for cr_index in tqdm(range(1, num_features + 1), disable=not debug):
+        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':
+            if interp_method == "x":
                 interp_func = interpolation_x
             else:
                 interp_func = interpolation_y
@@ -110,23 +108,24 @@ def cleanest(data, mask_crfound, dilation=0,
                 cr_labels=cr_labels,
                 cr_index=cr_index,
                 npoints=npoints,
-                degree=degree)
+                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'
+        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
+                method=method,
             )
             if interpolation_performed:
                 num_cr_cleaned += 1
@@ -134,6 +133,6 @@ def cleanest(data, mask_crfound, dilation=0,
             raise ValueError(f"Unknown interpolation method: {interp_method}")
 
     if debug:
-        print(f"Number of cosmic rays cleaned............: {num_cr_cleaned}")
+        print(f"Number of cosmic rays cleaned............: {num_cr_cleaned:>{len(sdum)}}")
 
     return cleaned_data, mask_fixed

teareduce/cleanest/interpolation_a.py

@@ -53,14 +53,10 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
     by cosmic rays are interpolated.
     """
     # Mask of CR pixels
-    mask = (cr_labels == cr_index)
+    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 = dilatemask(
-        mask=mask,
-        iterations=npoints,
-        connectivity=1
-    )
+    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
@@ -68,7 +64,7 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
     zfit_all = data[yfit_all, xfit_all].tolist()
     # Perform interpolation
     interpolation_performed = False
-    if method == 'surface':
+    if method == "surface":
         if len(xfit_all) > 3:
             # Construct the design matrix for a 2D polynomial fit to a plane,
             # where each row corresponds to a point (x, y, z) and the model
@@ -84,10 +80,10 @@ 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 in ['median', 'mean']:
+    elif method in ["median", "mean"]:
         # Compute median of all surrounding points
         if len(zfit_all) > 0:
-            if method == 'median':
+            if method == "median":
                 zval = np.median(zfit_all)
             else:
                 zval = np.mean(zfit_all)

teareduce/cleanest/interpolationeditor.py

@@ -11,13 +11,16 @@
 
 import tkinter as tk
 from tkinter import messagebox
+from tkinter import ttk
 
+from .centerchildparent import center_on_parent
 from .definitions import VALID_CLEANING_METHODS
 
 
 class InterpolationEditor:
     """Dialog to select interpolation cleaning parameters."""
-    def __init__(self, root, last_dilation, last_npoints, last_degree, auxdata):
+
+    def __init__(self, root, last_dilation, last_npoints, last_degree, auxdata, xmin, xmax, ymin, ymax, imgshape):
         """Initialize the interpolation editor dialog.
 
         Parameters
@@ -32,6 +35,16 @@ class InterpolationEditor:
             The last used degree for interpolation.
         auxdata : array-like or None
             Auxiliary data for cleaning, if available.
+        xmin : float
+            Minimum x value of the data. From 1 to NAXIS1.
+        xmax : float
+            Maximum x value of the data. From 1 to NAXIS1.
+        ymin : float
+            Minimum y value of the data. From 1 to NAXIS2.
+        ymax : float
+            Maximum y value of the data. From 1 to NAXIS2.
+        imgshape : tuple
+            Shape of the image data (height, width).
 
         Methods
         -------
@@ -62,6 +75,16 @@ class InterpolationEditor:
             The number of points for interpolation.
         degree : int
             The degree for interpolation.
+        xmin : float
+            Minimum x value of the data. From 1 to NAXIS1.
+        xmax : float
+            Maximum x value of the data. From 1 to NAXIS1.
+        ymin : float
+            Minimum y value of the data. From 1 to NAXIS2.
+        ymax : float
+            Maximum y value of the data. From 1 to NAXIS2.
+        imgshape : tuple
+            Shape of the image data (height, width).
         """
         self.root = root
         self.root.title("Cleaning Parameters")
@@ -74,15 +97,23 @@ class InterpolationEditor:
             "median": "a-median",
             "mean": "a-mean",
             "lacosmic": "lacosmic",
-            "auxdata": "auxdata"
+            "auxdata": "auxdata",
         }
         self.check_interp_methods()
         # Initialize parameters
         self.cleaning_method = None
         self.npoints = last_npoints
         self.degree = last_degree
+        self.xmin = xmin
+        self.xmax = xmax
+        self.ymin = ymin
+        self.ymax = ymax
+        self.imgshape = imgshape
+        # Dictionary to hold entry widgets for region parameters
+        self.entries = {}
         # Create the form
         self.create_widgets()
+        center_on_parent(child=self.root, parent=self.root.master)
 
     def create_widgets(self):
         """Create the widgets for the dialog."""
@@ -90,9 +121,15 @@ class InterpolationEditor:
         main_frame = tk.Frame(self.root, padx=10, pady=10)
         main_frame.pack()
 
-        # Title
-        title_label = tk.Label(main_frame, text="Select Cleaning Method", font=("Arial", 14, "bold"))
-        title_label.grid(row=0, column=0, columnspan=2, pady=(0, 15))
+        row = 0
+
+        # Subtitle for cleaning method selection
+        default_font = tk.font.nametofont("TkDefaultFont")
+        bold_font = default_font.copy()
+        bold_font.configure(weight="bold", size=default_font.cget("size") + 2)
+        subtitle_label = tk.Label(main_frame, text="Select Cleaning Method", font=bold_font)
+        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        row += 1
 
         # Create labels and entry fields for each cleaning method
         row = 1
@@ -111,35 +148,80 @@ class InterpolationEditor:
                     text=interp_method,
                     variable=self.cleaning_method_var,
                     value=interp_method,
-                    command=self.action_on_method_change
-                ).grid(row=row, column=0, sticky='w')
+                    command=self.action_on_method_change,
+                ).grid(row=row, column=1, sticky="w")
                 row += 1
 
+        # Separator
+        separator1 = ttk.Separator(main_frame, orient="horizontal")
+        separator1.grid(row=row, column=0, columnspan=3, sticky="ew", pady=(10, 10))
+        row += 1
+
+        # Subtitle for additional parameters
+        subtitle_label = tk.Label(main_frame, text="Additional Parameters", font=bold_font)
+        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        row += 1
+
         # Create labels and entry fields for each additional parameter
-        label = tk.Label(main_frame, text='Npoints:')
-        label.grid(row=row, column=0, sticky='e', padx=(0, 10))
+        label = tk.Label(main_frame, text="Npoints:")
+        label.grid(row=row, column=0, sticky="e", padx=(0, 10))
         self.entry_npoints = tk.Entry(main_frame, width=10)
         self.entry_npoints.insert(0, self.npoints)
-        self.entry_npoints.grid(row=row, column=1, sticky='w')
+        self.entry_npoints.grid(row=row, column=1, sticky="w")
         row += 1
-        label = tk.Label(main_frame, text='Degree:')
-        label.grid(row=row, column=0, sticky='e', padx=(0, 10))
+        label = tk.Label(main_frame, text="Degree:")
+        label.grid(row=row, column=0, sticky="e", padx=(0, 10))
         self.entry_degree = tk.Entry(main_frame, width=10)
         self.entry_degree.insert(0, self.degree)
-        self.entry_degree.grid(row=row, column=1, sticky='w')
+        self.entry_degree.grid(row=row, column=1, sticky="w")
+        row += 1
+
+        # Separator
+        separator2 = ttk.Separator(main_frame, orient="horizontal")
+        separator2.grid(row=row, column=0, columnspan=3, 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=bold_font)
+        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        row += 1
+
+        # Region to be examined label and entries
+        for key in ["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(self.__dict__[key]))
+            entry.grid(row=row, column=1, padx=10, pady=5)
+            self.entries[key] = entry  # dictionary to hold entry widgets
+            # Type label
+            dumtext = "(int)"
+            if key in ["xmin", "xmax"]:
+                dumtext += f" --> [1, {self.imgshape[1]}]"
+            else:
+                dumtext += f" --> [1, {self.imgshape[0]}]"
+            type_label = tk.Label(main_frame, text=dumtext, fg="gray", anchor="w", width=15)
+            type_label.grid(row=row, column=2, sticky="w", pady=5)
+            row += 1
+
+        # Separator
+        separator3 = ttk.Separator(main_frame, orient="horizontal")
+        separator3.grid(row=row, column=0, columnspan=3, sticky="ew", pady=(10, 10))
         row += 1
 
         # Button frame
         self.button_frame = tk.Frame(main_frame)
-        self.button_frame.grid(row=row, column=0, columnspan=2, pady=(15, 0))
+        self.button_frame.grid(row=row, column=0, columnspan=3, pady=(15, 0))
 
         # OK button
         self.ok_button = tk.Button(self.button_frame, text="OK", width=5, command=self.on_ok)
-        self.ok_button.pack(side='left', padx=5)
+        self.ok_button.pack(side="left", padx=5)
 
         # Cancel button
         self.cancel_button = tk.Button(self.button_frame, text="Cancel", width=5, command=self.on_cancel)
-        self.cancel_button.pack(side='left', padx=5)
+        self.cancel_button.pack(side="left", padx=5)
 
         # Initial action depending on the default method
         self.action_on_method_change()
@@ -165,10 +247,49 @@ class InterpolationEditor:
             messagebox.showerror("Input Error", "Degree must be non-negative.")
             return
 
-        if self.cleaning_method in ['x', 'y'] and 2 * self.npoints <= self.degree:
+        if self.cleaning_method in ["x", "y"] and 2 * self.npoints <= self.degree:
             messagebox.showerror("Input Error", "2*Npoints must be greater than Degree for x and y interpolation.")
             return
 
+        # Retrieve and validate region parameters
+        try:
+            xmin = int(self.entries["xmin"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "xmin must be an integer.")
+            return
+        try:
+            xmax = int(self.entries["xmax"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "xmax must be an integer.")
+            return
+        if xmin >= xmax:
+            messagebox.showerror("Input Error", "xmin must be less than xmax.")
+            return
+        try:
+            ymin = int(self.entries["ymin"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "ymin must be an integer.")
+            return
+        try:
+            ymax = int(self.entries["ymax"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "ymax must be an integer.")
+            return
+        if ymin >= ymax:
+            messagebox.showerror("Input Error", "ymin must be less than ymax.")
+            return
+        for key, entry in self.entries.items():
+            value = int(entry.get())
+            if key in ["xmin", "xmax"]:
+                if not (1 <= value <= self.imgshape[1]):
+                    messagebox.showerror("Input Error", f"{key} must be in the range [1, {self.imgshape[1]}].")
+                    return
+            else:
+                if not (1 <= value <= self.imgshape[0]):
+                    messagebox.showerror("Input Error", f"{key} must be in the range [1, {self.imgshape[0]}].")
+                    return
+            self.__dict__[key] = value
+
         self.root.destroy()
 
     def on_cancel(self):
@@ -182,24 +303,24 @@ class InterpolationEditor:
         """Handle changes in the selected cleaning method."""
         selected_method = self.cleaning_method_var.get()
         print(f"Selected cleaning method: {selected_method}")
-        if selected_method in ['x interp.', 'y interp.']:
-            self.entry_npoints.config(state='normal')
-            self.entry_degree.config(state='normal')
-        elif selected_method == 'surface interp.':
-            self.entry_npoints.config(state='normal')
-            self.entry_degree.config(state='disabled')
-        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')
-        elif selected_method == 'auxdata':
-            self.entry_npoints.config(state='disabled')
-            self.entry_degree.config(state='disabled')
+        if selected_method in ["x interp.", "y interp."]:
+            self.entry_npoints.config(state="normal")
+            self.entry_degree.config(state="normal")
+        elif selected_method == "surface interp.":
+            self.entry_npoints.config(state="normal")
+            self.entry_degree.config(state="disabled")
+        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")
+        elif selected_method == "auxdata":
+            self.entry_npoints.config(state="disabled")
+            self.entry_degree.config(state="disabled")
 
     def check_interp_methods(self):
         """Check that all interpolation methods are valid."""

teareduce/cleanest/lacosmicpad.py

@@ -0,0 +1,57 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Execute LACosmic algorithm on a padded image."""
+
+from ccdproc import cosmicray_lacosmic
+import numpy as np
+
+
+def lacosmicpad(pad_width, **kwargs):
+    """Execute LACosmic algorithm on a padded array.
+
+    This function pads the input image array before applying the LACosmic
+    cosmic ray cleaning algorithm. After processing, the padding is removed
+    to return an array of the original size.
+
+    The padding helps to mitigate edge effects that can occur during the
+    cosmic ray detection and cleaning process.
+
+    Apart from the `pad_width` parameter, all other keyword arguments
+    are passed directly to the `cosmicray_lacosmic` function from the
+    `ccdproc` package.
+
+    Parameters
+    ----------
+    pad_width : int
+        Width of the padding to be applied to the image before executing
+        the LACosmic algorithm.
+    **kwargs : dict
+        Keyword arguments to be passed to the `cosmicray_lacosmic` function.
+
+    Returns
+    -------
+    clean_array : 2D numpy.ndarray
+        The cleaned image array after applying the LACosmic algorithm with padding.
+    mask_array : 2D numpy.ndarray of bool
+        The mask array indicating detected cosmic rays.
+    """
+    if "ccd" not in kwargs:
+        raise ValueError("The 'ccd' keyword argument must be provided.")
+    array = kwargs.pop("ccd")
+    if not isinstance(array, np.ndarray):
+        raise TypeError("The 'ccd' keyword argument must be a numpy ndarray.")
+    # Pad the array
+    padded_array = np.pad(array, pad_width, mode="reflect")
+    # Apply LACosmic algorithm to the padded array
+    cleaned_padded_array, mask_padded_array = cosmicray_lacosmic(ccd=padded_array, **kwargs)
+    # Remove padding
+    cleaned_array = cleaned_padded_array[pad_width:-pad_width, pad_width:-pad_width]
+    mask_array = mask_padded_array[pad_width:-pad_width, pad_width:-pad_width]
+    return cleaned_array, mask_array