teareduce 0.5.5__py3-none-any.whl → 0.5.8__py3-none-any.whl

teareduce/cleanest/__init__.py

@@ -7,4 +7,6 @@
 # License-Filename: LICENSE.txt
 #
 
-from .cleanest import cleanest
+from .interpolate import interpolate
+from .lacosmicpad import lacosmicpad
+from .mergemasks import merge_peak_tail_masks

teareduce/cleanest/__main__.py

@@ -10,8 +10,12 @@
 """Interactive Cosmic Ray cleaning tool."""
 
 import argparse
+from ast import arg
 import tkinter as tk
+from tkinter import filedialog
+from tkinter import simpledialog
 import os
+from pathlib import Path
 import platform
 from rich import print
 from rich_argparse import RichHelpFormatter
@@ -21,6 +25,7 @@ from .definitions import DEFAULT_FONT_SIZE
 from .definitions import DEFAULT_TK_WINDOW_SIZE_X
 from .definitions import DEFAULT_TK_WINDOW_SIZE_Y
 from .cosmicraycleanerapp import CosmicRayCleanerApp
+from ..version import VERSION
 
 import matplotlib
 
@@ -32,13 +37,13 @@ def main():
         description="Interactive cosmic ray cleaner for FITS images.",
         formatter_class=RichHelpFormatter,
     )
-    parser.add_argument("input_fits", help="Path to the FITS file to be cleaned.")
-    parser.add_argument("--extension", type=int, default=0, help="FITS extension to use (default: 0).")
+    parser.add_argument("input_fits", nargs="?", default=None, help="Path to the FITS file to be cleaned.")
+    parser.add_argument("--extension", type=str, default="0", help="FITS extension to use (default: 0).")
     parser.add_argument("--auxfile", type=str, default=None, help="Auxiliary FITS file")
     parser.add_argument(
         "--extension_auxfile",
-        type=int,
-        default=0,
+        type=str,
+        default="0",
         help="FITS extension for auxiliary file (default: 0).",
     )
     parser.add_argument(
@@ -65,14 +70,67 @@ def main():
         default=DEFAULT_TK_WINDOW_SIZE_Y,
         help=f"Height of the GUI window in pixels (default: {DEFAULT_TK_WINDOW_SIZE_Y}).",
     )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {VERSION}")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose output.")
     args = parser.parse_args()
 
+    # Welcome message
+    print("[bold green]Cosmic Ray Cleaner[/bold green]")
+    print("Interactive tool to clean cosmic rays from FITS images.")
+    print("teareduce version: " + VERSION)
+    print(f"https://nicocardiel.github.io/teareduce-cookbook/docs/cleanest/cleanest.html\n")
+
+    # If input_file is not provided, ask for it using a file dialog
+    if args.input_fits is None:
+        root = tk.Tk()
+        root.withdraw()  # Hide the root window
+        args.input_fits = filedialog.askopenfilename(
+            title="Select FITS file to be cleaned",
+            filetypes=[("FITS files", "*.fits *.fit *.fts"), ("All files", "*.*")],
+        )
+        if not args.input_fits:
+            print("No input FITS file selected. Exiting.")
+            exit(1)
+        print(f"Selected input FITS file: {args.input_fits}")
+        args.extension = simpledialog.askstring(
+                "Select Extension",
+                f"\nEnter extension number or name for file:\n{Path(args.input_fits).name}",
+                initialvalue=args.extension,
+            )
+        # Ask for auxiliary file if not provided
+        if args.auxfile is None:
+            use_auxfile = tk.messagebox.askyesno(
+                "Auxiliary File",
+                "Do you want to use an auxiliary FITS file?",
+                default=tk.messagebox.NO,
+            )
+            if use_auxfile:
+                args.auxfile = filedialog.askopenfilename(
+                    title="Select Auxiliary FITS file",
+                    filetypes=[("FITS files", "*.fits *.fit *.fts"), ("All files", "*.*")],
+                    initialfile=args.auxfile,
+                )
+                if not args.auxfile:
+                    print("No auxiliary FITS file selected. Exiting.")
+                    exit(1)
+        else:
+            use_auxfile = True
+        if use_auxfile:
+            print(f"Selected auxiliary FITS file: {args.auxfile}")
+            args.extension_auxfile = simpledialog.askstring(
+                "Select Extension for Auxiliary File",
+                f"\nEnter extension number or name for auxiliary file:\n{Path(args.auxfile).name}",
+                initialvalue=args.extension_auxfile,
+            )
+        root.destroy()
+
+    # Check that input files, and the corresponding extensions, exist
     if not os.path.isfile(args.input_fits):
         print(f"Error: File '{args.input_fits}' does not exist.")
-        return
+        exit(1)
     if args.auxfile is not None and not os.path.isfile(args.auxfile):
         print(f"Error: Auxiliary file '{args.auxfile}' does not exist.")
-        return
+        exit(1)
 
     # Initialize Tkinter root
     root = tk.Tk()
@@ -100,6 +158,7 @@ def main():
         fontsize=args.fontsize,
         width=args.width,
         height=args.height,
+        verbose=args.verbose,
     )
 
     # Execute

teareduce/cleanest/cosmicraycleanerapp.py

@@ -13,16 +13,18 @@ import tkinter as tk
 from tkinter import filedialog
 from tkinter import font as tkfont
 from tkinter import messagebox
+from tkinter import simpledialog
 import sys
 
 from astropy.io import fits
-from ccdproc import cosmicray_lacosmic
+from maskfill import maskfill
 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 pathlib import Path
 from rich import print
 
 from .centerchildparent import center_on_parent
@@ -41,6 +43,8 @@ from .interpolation_x import interpolation_x
 from .interpolation_y import interpolation_y
 from .interpolationeditor import InterpolationEditor
 from .imagedisplay import ImageDisplay
+from .lacosmicpad import lacosmicpad
+from .mergemasks import merge_peak_tail_masks
 from .parametereditor import ParameterEditor
 from .reviewcosmicray import ReviewCosmicRay
 from .modalprogressbar import ModalProgressBar
@@ -61,13 +65,14 @@ class CosmicRayCleanerApp(ImageDisplay):
         self,
         root,
         input_fits,
-        extension=0,
+        extension="0",
         auxfile=None,
-        extension_auxfile=0,
+        extension_auxfile="0",
         fontfamily=DEFAULT_FONT_FAMILY,
         fontsize=DEFAULT_FONT_SIZE,
         width=DEFAULT_TK_WINDOW_SIZE_X,
         height=DEFAULT_TK_WINDOW_SIZE_Y,
+        verbose=False,
     ):
         """
         Initialize the application.
@@ -78,19 +83,29 @@ class CosmicRayCleanerApp(ImageDisplay):
             The main Tkinter window.
         input_fits : str
             Path to the FITS file to be cleaned.
-        extension : int, optional
-            FITS extension to use (default is 0).
+        extension : str, optional
+            FITS extension to use (default is "0").
         auxfile : str, optional
             Path to an auxiliary FITS file (default is None).
-        extension_auxfile : int, optional
-            FITS extension for auxiliary file (default is 0).
+        extension_auxfile : str, optional
+            FITS extension for auxiliary file (default is "0").
         fontfamily : str, optional
             Font family for the GUI (default is "Helvetica").
         fontsize : int, optional
             Font size for the GUI (default is 14).
+        width : int, optional
+            Width of the GUI window in pixels (default is 800).
+        height : int, optional
+            Height of the GUI window in pixels (default is 600).
+        verbose : bool, optional
+            Enable verbose output (default is False).
 
         Methods
         -------
+        process_detected_cr(dilation)
+            Process the detected cosmic ray mask.
+        load_detected_cr_from_file()
+            Load detected cosmic ray mask from a FITS file.
         load_fits_file()
             Load the FITS file and auxiliary file (if provided).
         save_fits_file()
@@ -124,6 +139,12 @@ class CosmicRayCleanerApp(ImageDisplay):
             Font size for the GUI.
         default_font : tkfont.Font
             The default font used in the GUI.
+        width : int
+            Width of the GUI window in pixels.
+        height : int
+            Height of the GUI window in pixels.
+        verbose : bool
+            Enable verbose output.
         lacosmic_params : dict
             Dictionary of L.A.Cosmic parameters.
         input_fits : str
@@ -171,6 +192,7 @@ class CosmicRayCleanerApp(ImageDisplay):
         # self.root.geometry("800x800+50+0")  # This does not work in Fedora
         self.width = width
         self.height = height
+        self.verbose = verbose
         self.root.minsize(self.width, self.height)
         self.root.update_idletasks()
         self.root.title("Cosmic Ray Cleaner")
@@ -181,6 +203,8 @@ class CosmicRayCleanerApp(ImageDisplay):
             family=fontfamily, size=fontsize, weight="normal", slant="roman", underline=0, overstrike=0
         )
         self.lacosmic_params = lacosmic_default_dict.copy()
+        self.lacosmic_params["run1_verbose"]["value"] = self.verbose
+        self.lacosmic_params["run2_verbose"]["value"] = self.verbose
         self.input_fits = input_fits
         self.extension = extension
         self.data = None
@@ -202,6 +226,93 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.num_features = 0
         self.working_in_review_window = False
 
+    def process_detected_cr(self, dilation):
+        """Process the detected cosmic ray mask.
+        
+        Parameters
+        ----------
+        dilation : int
+            Number of pixels to dilate the cosmic ray mask.
+        """
+        # Process the mask: dilation and labeling
+        if np.any(self.mask_crfound):
+            num_cr_pixels_before_dilation = np.sum(self.mask_crfound)
+            if dilation > 0:
+                # Dilate the mask by the specified number of pixels
+                self.mask_crfound = dilatemask(
+                    mask=self.mask_crfound, iterations=dilation, connectivity=1
+                )
+                num_cr_pixels_after_dilation = np.sum(self.mask_crfound)
+                sdum = str(num_cr_pixels_after_dilation)
+            else:
+                sdum = str(num_cr_pixels_before_dilation)
+            print(
+                "Number of cosmic ray pixels detected..........: "
+                f"{num_cr_pixels_before_dilation:>{len(sdum)}}"
+            )
+            if dilation > 0:
+                print(
+                    f"Number of cosmic ray pixels after dilation....: "
+                    f"{num_cr_pixels_after_dilation:>{len(sdum)}}"
+                )
+            # Label connected components in the mask; note that by default,
+            # structure is a cross [0,1,0;1,1,1;0,1,0], but we want to consider
+            # 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 ray features (grouped pixels): {self.num_features:>{len(sdum)}}")
+            self.replace_detected_cr_button.config(state=tk.NORMAL)
+            self.examine_detected_cr_button.config(state=tk.NORMAL)
+            self.update_cr_overlay()
+            self.use_cursor = True
+            self.use_cursor_button.config(text="[c]ursor: ON ")
+        else:
+            print("No cosmic ray pixels detected!")
+            self.cr_labels = None
+            self.num_features = 0
+            self.replace_detected_cr_button.config(state=tk.DISABLED)
+            self.examine_detected_cr_button.config(state=tk.DISABLED)
+
+    def load_detected_cr_from_file(self):
+        """Load detected cosmic ray mask from a FITS file."""
+        crmask_file = filedialog.askopenfilename(
+            initialdir=os.getcwd(),
+            title="Select FITS file with cosmic ray mask",
+            filetypes=[("FITS files", "*.fits"), ("All files", "*.*")],
+        )
+        if crmask_file:
+            print(f"Selected input FITS file: {crmask_file}")
+            extension = simpledialog.askstring(
+                "Select Extension",
+                f"\nEnter extension number or name for file:\n{Path(crmask_file).name}",
+                initialvalue=None,
+            )
+            try:
+                extension = int(extension)
+            except ValueError:
+                pass  # Keep as string
+            dilation = simpledialog.askinteger(
+                "Dilation", "Enter Dilation (min=0):", initialvalue=0, minvalue=0
+            )
+            try:
+                with fits.open(crmask_file, mode="readonly") as hdul:
+                    if isinstance(extension, int):
+                        if extension < 0 or extension >= len(hdul):
+                            raise IndexError(f"Extension index {extension} out of range.")
+                    else:
+                        if extension not in hdul:
+                            raise KeyError(f"Extension name '{extension}' not found.")
+                    mask_crfound_loaded = hdul[extension].data.astype(bool)
+                    if mask_crfound_loaded.shape != self.data.shape:
+                        print(f"data shape...: {self.data.shape}")
+                        print(f"mask shape...: {mask_crfound_loaded.shape}")
+                        raise ValueError("Cosmic ray mask has different shape.")
+                    self.mask_crfound = mask_crfound_loaded
+                    print(f"Loaded cosmic ray mask from {crmask_file}")
+                    self.process_detected_cr(dilation=dilation)
+            except Exception as e:
+                print(f"Error loading cosmic ray mask: {e}")
+
     def load_fits_file(self):
         """Load the FITS file and auxiliary file (if provided).
 
@@ -216,8 +327,22 @@ class CosmicRayCleanerApp(ImageDisplay):
         provided, it also loads the auxiliary data from the specified extension.
         The loaded data is stored in `self.data` and `self.auxdata` attributes.
         """
+        # check if extension is compatible with an integer
+        try:
+            extnum = int(self.extension)
+            self.extension = extnum
+        except ValueError:
+            # Keep as string (delaying checking until opening the file)
+            self.extension = self.extension.upper()  # Convert to uppercase
         try:
             with fits.open(self.input_fits, mode="readonly") as hdul:
+                if isinstance(self.extension, int):
+                    if self.extension < 0 or self.extension >= len(hdul):
+                        raise IndexError(f"Extension index {self.extension} out of range.")
+                else:
+                    if self.extension not in hdul:
+                        raise KeyError(f"Extension name '{self.extension}' not found.")
+                print(f"Reading file [bold green]{self.input_fits}[/bold green], extension {self.extension}")
                 self.data = hdul[self.extension].data
                 if "CRMASK" in hdul:
                     self.mask_fixed = hdul["CRMASK"].data.astype(bool)
@@ -225,13 +350,28 @@ class CosmicRayCleanerApp(ImageDisplay):
                     self.mask_fixed = np.zeros(self.data.shape, dtype=bool)
         except Exception as e:
             print(f"Error loading FITS file: {e}")
+            sys.exit(1)
         self.mask_crfound = np.zeros(self.data.shape, dtype=bool)
         naxis2, naxis1 = self.data.shape
         self.region = SliceRegion2D(f"[1:{naxis1}, 1:{naxis2}]", mode="fits").python
         # Read auxiliary file if provided
         if self.auxfile is not None:
+            # check if extension_auxfile is compatible with an integer
+            try:
+                extnum_aux = int(self.extension_auxfile)
+                self.extension_auxfile = extnum_aux
+            except ValueError:
+                # Keep as string (delaying checking until opening the file)
+                self.extension_auxfile = self.extension_auxfile.upper()  # Convert to uppercase
             try:
                 with fits.open(self.auxfile, mode="readonly") as hdul_aux:
+                    if isinstance(self.extension_auxfile, int):
+                        if self.extension_auxfile < 0 or self.extension_auxfile >= len(hdul_aux):
+                            raise IndexError(f"Extension index {self.extension_auxfile} out of range.")
+                    else:
+                        if self.extension_auxfile not in hdul_aux:
+                            raise KeyError(f"Extension name '{self.extension_auxfile}' not found.")
+                    print(f"Reading auxiliary file [bold green]{self.auxfile}[/bold green], extension {self.extension_auxfile}")
                     self.auxdata = hdul_aux[self.extension_auxfile].data
                     if self.auxdata.shape != self.data.shape:
                         print(f"data shape...: {self.data.shape}")
@@ -308,20 +448,15 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.button_frame1.pack(pady=5)
         self.run_lacosmic_button = tk.Button(self.button_frame1, text="Run L.A.Cosmic", command=self.run_lacosmic)
         self.run_lacosmic_button.pack(side=tk.LEFT, padx=5)
-        if self.overplot_cr_pixels:
-            self.overplot_cr_button = tk.Button(
-                self.button_frame1, text="CR overlay: On", command=self.toggle_cr_overlay
-            )
-        else:
-            self.overplot_cr_button = tk.Button(
-                self.button_frame1, text="CR overlay: Off", command=self.toggle_cr_overlay
-            )
-        self.overplot_cr_button.pack(side=tk.LEFT, padx=5)
-        self.apply_lacosmic_button = tk.Button(
+        self.load_detected_cr_button = tk.Button(
+            self.button_frame1, text="Load detected CRs", command=self.load_detected_cr_from_file
+        )
+        self.load_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        self.replace_detected_cr_button = tk.Button(
             self.button_frame1, text="Replace detected CRs", command=self.apply_lacosmic
         )
-        self.apply_lacosmic_button.pack(side=tk.LEFT, padx=5)
-        self.apply_lacosmic_button.config(state=tk.DISABLED)  # Initially disabled
+        self.replace_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        self.replace_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
         self.examine_detected_cr_button = tk.Button(
             self.button_frame1, text="Examine detected CRs", command=lambda: self.examine_detected_cr(1)
         )
@@ -331,6 +466,17 @@ class CosmicRayCleanerApp(ImageDisplay):
         # Row 2 of buttons
         self.button_frame2 = tk.Frame(self.root)
         self.button_frame2.pack(pady=5)
+        self.toggle_auxdata_button = tk.Button(self.button_frame2, text="[t]oggle data", command=self.toggle_auxdata)
+        self.toggle_auxdata_button.pack(side=tk.LEFT, padx=5)
+        if self.auxdata is None:
+            self.toggle_auxdata_button.config(state=tk.DISABLED)
+        else:
+            self.toggle_auxdata_button.config(state=tk.NORMAL)
+        self.image_aspect = "equal"
+        self.toggle_aspect_button = tk.Button(
+            self.button_frame2, text=f"[a]spect: {self.image_aspect}", command=self.toggle_aspect
+        )
+        self.toggle_aspect_button.pack(side=tk.LEFT, padx=5)
         self.save_button = tk.Button(self.button_frame2, text="Save cleaned FITS", command=self.save_fits_file)
         self.save_button.pack(side=tk.LEFT, padx=5)
         self.save_button.config(state=tk.DISABLED)  # Initially disabled
@@ -340,6 +486,9 @@ class CosmicRayCleanerApp(ImageDisplay):
         # Row 3 of buttons
         self.button_frame3 = tk.Frame(self.root)
         self.button_frame3.pack(pady=5)
+        self.use_cursor = False
+        self.use_cursor_button = tk.Button(self.button_frame3, text="[c]ursor: OFF", command=self.set_cursor_onoff)
+        self.use_cursor_button.pack(side=tk.LEFT, padx=5)
         vmin, vmax = zscale(self.data)
         self.vmin_button = tk.Button(self.button_frame3, text=f"vmin: {vmin:.2f}", command=self.set_vmin)
         self.vmin_button.pack(side=tk.LEFT, padx=5)
@@ -349,6 +498,19 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.set_minmax_button.pack(side=tk.LEFT, padx=5)
         self.set_zscale_button = tk.Button(self.button_frame3, text="zscale [/]", command=self.set_zscale)
         self.set_zscale_button.pack(side=tk.LEFT, padx=5)
+        if self.overplot_cr_pixels:
+            self.overplot_cr_button = tk.Button(
+                self.button_frame3,
+                text="CR overlay: ON ",
+                command=self.toggle_cr_overlay,
+            )
+        else:
+            self.overplot_cr_button = tk.Button(
+                self.button_frame3,
+                text="CR overlay: OFF",
+                command=self.toggle_cr_overlay,
+            )
+        self.overplot_cr_button.pack(side=tk.LEFT, padx=5)
 
         # Figure
         self.plot_frame = tk.Frame(self.root)
@@ -378,19 +540,63 @@ class CosmicRayCleanerApp(ImageDisplay):
         xlabel = "X pixel (from 1 to NAXIS1)"
         ylabel = "Y pixel (from 1 to NAXIS2)"
         extent = [0.5, self.data.shape[1] + 0.5, 0.5, self.data.shape[0] + 0.5]
+        self.image_aspect = "equal"
+        self.displaying_auxdata = False
         self.image, _, _ = imshow(
-            self.fig,
-            self.ax,
-            self.data,
+            fig=self.fig,
+            ax=self.ax,
+            data=self.data,
             vmin=vmin,
             vmax=vmax,
-            title=os.path.basename(self.input_fits),
+            title=f"data: {os.path.basename(self.input_fits)}",
             xlabel=xlabel,
             ylabel=ylabel,
             extent=extent,
+            aspect=self.image_aspect,
         )
         self.fig.tight_layout()
 
+    def set_cursor_onoff(self):
+        """Toggle cursor selection mode on or off."""
+        if not self.use_cursor:
+            self.use_cursor = True
+            self.use_cursor_button.config(text="[c]ursor: ON ")
+        else:
+            self.use_cursor = False
+            self.use_cursor_button.config(text="[c]ursor: OFF")
+
+    def toggle_auxdata(self):
+        """Toggle between main data and auxiliary data for display."""
+        if self.displaying_auxdata:
+            # Switch to main data
+            vmin = self.get_vmin()
+            vmax = self.get_vmax()
+            self.image.set_data(self.data)
+            self.image.set_clim(vmin=vmin, vmax=vmax)
+            self.displaying_auxdata = False
+            self.ax.set_title(f"data: {os.path.basename(self.input_fits)}")
+        else:
+            # Switch to auxiliary data
+            vmin = self.get_vmin()
+            vmax = self.get_vmax()
+            self.image.set_data(self.auxdata)
+            self.image.set_clim(vmin=vmin, vmax=vmax)
+            self.displaying_auxdata = True
+            self.ax.set_title(f"auxdata: {os.path.basename(self.auxfile)}")
+        self.canvas.draw_idle()
+
+    def toggle_aspect(self):
+        """Toggle the aspect ratio of the image display."""
+        if self.image_aspect == "equal":
+            self.image_aspect = "auto"
+        else:
+            self.image_aspect = "equal"
+        print(f"Setting image aspect to: {self.image_aspect}")
+        self.toggle_aspect_button.config(text=f"[a]spect: {self.image_aspect}")
+        self.ax.set_aspect(self.image_aspect)
+        self.fig.tight_layout()
+        self.canvas.draw_idle()
+
     def run_lacosmic(self):
         """Run L.A.Cosmic to detect cosmic rays."""
         self.run_lacosmic_button.config(state=tk.DISABLED)
@@ -427,17 +633,18 @@ class CosmicRayCleanerApp(ImageDisplay):
             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.verbose:
+                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
             print("[bold green]Executing L.A.Cosmic (run 1)...[/bold green]")
             borderpadd = updated_params["borderpadd"]["value"]
-            data_reflection_padded = np.pad(self.data, pad_width=borderpadd, mode="reflect")
-            cleandata_lacosmic, mask_crfound = cosmicray_lacosmic(
-                ccd=data_reflection_padded,
+            cleandata_lacosmic, mask_crfound = lacosmicpad(
+                pad_width=borderpadd,
+                ccd=self.data,
                 gain=self.lacosmic_params["run1_gain"]["value"],
                 readnoise=self.lacosmic_params["run1_readnoise"]["value"],
                 sigclip=self.lacosmic_params["run1_sigclip"]["value"],
@@ -446,16 +653,15 @@ class CosmicRayCleanerApp(ImageDisplay):
                 niter=self.lacosmic_params["run1_niter"]["value"],
                 verbose=self.lacosmic_params["run1_verbose"]["value"],
             )
-            cleandata_lacosmic = cleandata_lacosmic[borderpadd:-borderpadd, borderpadd:-borderpadd]
-            mask_crfound = mask_crfound[borderpadd:-borderpadd, borderpadd:-borderpadd]
             # 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:
                 print("[bold green]Executing L.A.Cosmic (run 2)...[/bold green]")
-                cleandata_lacosmic2, mask_crfound2 = cosmicray_lacosmic(
-                    ccd=data_reflection_padded,
+                cleandata_lacosmic2, mask_crfound2 = lacosmicpad(
+                    pad_width=borderpadd,
+                    ccd=self.data,
                     gain=self.lacosmic_params["run2_gain"]["value"],
                     readnoise=self.lacosmic_params["run2_readnoise"]["value"],
                     sigclip=self.lacosmic_params["run2_sigclip"]["value"],
@@ -464,8 +670,6 @@ class CosmicRayCleanerApp(ImageDisplay):
                     niter=self.lacosmic_params["run2_niter"]["value"],
                     verbose=self.lacosmic_params["run2_verbose"]["value"],
                 )
-                cleandata_lacosmic2 = cleandata_lacosmic2[borderpadd:-borderpadd, borderpadd:-borderpadd]
-                mask_crfound2 = mask_crfound2[borderpadd:-borderpadd, borderpadd:-borderpadd]
                 # Apply usefulmask to consider only selected region
                 cleandata_lacosmic2 *= usefulmask
                 mask_crfound2 = mask_crfound2 & (usefulmask.astype(bool))
@@ -473,19 +677,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 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
+                    mask_crfound = merge_peak_tail_masks(mask_crfound, mask_crfound2)
                     print(f"Number of cosmic ray pixels (run1 & run2): {np.sum(mask_crfound)}")
                 # Use the cleandata from the second run
                 cleandata_lacosmic = cleandata_lacosmic2
@@ -495,42 +687,7 @@ class CosmicRayCleanerApp(ImageDisplay):
             self.mask_crfound = np.zeros_like(self.data, dtype=bool)
             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
-                    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)
-                else:
-                    sdum = str(num_cr_pixels_before_dilation)
-                print(
-                    "Number of cosmic ray pixels detected by L.A.Cosmic: "
-                    f"{num_cr_pixels_before_dilation:>{len(sdum)}}"
-                )
-                if dilation > 0:
-                    print(
-                        f"Number of cosmic ray pixels after dilation........: "
-                        f"{num_cr_pixels_after_dilation:>{len(sdum)}}"
-                    )
-                # Label connected components in the mask; note that by default,
-                # structure is a cross [0,1,0;1,1,1;0,1,0], but we want to consider
-                # 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 ray 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()
-            else:
-                print("No cosmic ray pixels detected by L.A.Cosmic.")
-                self.cr_labels = None
-                self.num_features = 0
-                self.apply_lacosmic_button.config(state=tk.DISABLED)
-                self.examine_detected_cr_button.config(state=tk.DISABLED)
+            self.process_detected_cr(dilation=self.lacosmic_params["dilation"]["value"])
         else:
             print("Parameter editing cancelled. L.A.Cosmic detection skipped!")
         self.run_lacosmic_button.config(state=tk.NORMAL)
@@ -539,9 +696,9 @@ class CosmicRayCleanerApp(ImageDisplay):
         """Toggle the overlay of cosmic ray pixels on the image."""
         self.overplot_cr_pixels = not self.overplot_cr_pixels
         if self.overplot_cr_pixels:
-            self.overplot_cr_button.config(text="CR overlay: On")
+            self.overplot_cr_button.config(text="CR overlay: ON ")
         else:
-            self.overplot_cr_button.config(text="CR overlay: Off")
+            self.overplot_cr_button.config(text="CR overlay: OFF")
         self.update_cr_overlay()
 
     def update_cr_overlay(self):
@@ -617,6 +774,21 @@ class CosmicRayCleanerApp(ImageDisplay):
                     # upate mask_crfound by eliminating the cleaned pixels
                     self.mask_crfound[mask_crfound_region] = False
                     data_has_been_modified = True
+                elif cleaning_method == "maskfill":
+                    # Replace detected CR pixels with local median values
+                    smoothed_output, _ = maskfill(
+                        input_image=self.data,
+                        mask=mask_crfound_region,
+                        size=3,
+                        operator="median",
+                        smooth=True,
+                    )
+                    self.data[mask_crfound_region] = smoothed_output[mask_crfound_region]
+                    # update mask_fixed to include the newly fixed pixels
+                    self.mask_fixed[mask_crfound_region] = True
+                    # upate mask_crfound by eliminating the cleaned pixels
+                    self.mask_crfound[mask_crfound_region] = False
+                    data_has_been_modified = True
                 elif cleaning_method == "auxdata":
                     if self.auxdata is None:
                         print("No auxiliary data available. Cleaning skipped!")
@@ -699,9 +871,13 @@ 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)
-            sdum = str(np.sum(self.mask_crfound))
+            num_cr_remaining = np.sum(self.mask_crfound)
+            sdum = str(num_cr_remaining)
             print(f"Remaining number of cosmic ray pixels...................: {sdum}")
             print(f"Remaining number of cosmic ray features (grouped pixels): {self.num_features:>{len(sdum)}}")
+            if num_cr_remaining == 0:
+                self.use_cursor = False
+                self.use_cursor_button.config(text="[c]ursor: OFF")
             # redraw image to show the changes
             self.image.set_data(self.data)
             self.canvas.draw_idle()
@@ -709,7 +885,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 self.save_button.config(state=tk.NORMAL)
             if self.num_features == 0:
                 self.examine_detected_cr_button.config(state=tk.DISABLED)
-                self.apply_lacosmic_button.config(state=tk.DISABLED)
+                self.replace_detected_cr_button.config(state=tk.DISABLED)
             self.update_cr_overlay()
 
     def examine_detected_cr(self, first_cr_index=1, single_cr=False, ixpix=None, iypix=None):
@@ -765,9 +941,13 @@ 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)
-            sdum = str(np.sum(self.mask_crfound))
+            num_remaining = np.sum(self.mask_crfound)
+            sdum = str(num_remaining)
             print(f"Remaining number of cosmic ray pixels...................: {sdum}")
             print(f"Remaining number of cosmic ray features (grouped pixels): {self.num_features:>{len(sdum)}}")
+            if num_remaining == 0:
+                self.use_cursor = False
+                self.use_cursor_button.config(text="[c]ursor: OFF")
             # redraw image to show the changes
             self.image.set_data(self.data)
             self.canvas.draw_idle()
@@ -775,7 +955,7 @@ class CosmicRayCleanerApp(ImageDisplay):
             self.save_button.config(state=tk.NORMAL)
         if self.num_features == 0:
             self.examine_detected_cr_button.config(state=tk.DISABLED)
-            self.apply_lacosmic_button.config(state=tk.DISABLED)
+            self.replace_detected_cr_button.config(state=tk.DISABLED)
         self.update_cr_overlay()
 
     def stop_app(self):
@@ -792,14 +972,39 @@ class CosmicRayCleanerApp(ImageDisplay):
 
     def on_key(self, event):
         """Handle key press events."""
-        if event.key == "q":
-            pass  # Ignore the "q" key to prevent closing the window
+        if event.key == "c":
+            self.set_cursor_onoff()
+        elif event.key == "a":
+            self.toggle_aspect()
+        elif event.key == "t" and self.auxdata is not None:
+            self.toggle_auxdata()
         elif event.key == ",":
             self.set_minmax()
         elif event.key == "/":
             self.set_zscale()
-        else:
-            print(f"Key pressed: {event.key}")
+        elif event.key == "o":
+            self.toolbar.zoom()
+        elif event.key == "h":
+            self.toolbar.home()
+        elif event.key == "p":
+            self.toolbar.pan()
+        elif event.key == "s":
+            self.toolbar.save_figure()
+        elif event.key == "?":
+            # Display list of keyboard shortcuts
+            print("[bold blue]Keyboard Shortcuts:[/bold blue]")
+            print("[red]  c [/red]: Toggle cursor selection mode on/off")
+            print("[red]  t [/red]: Toggle between main data and auxiliary data")
+            print("[red]  a [/red]: Toggle image aspect ratio equal/auto")
+            print("[red]  , [/red]: Set vmin and vmax to minmax")
+            print("[red]  / [/red]: Set vmin and vmax using zscale")
+            print("[red]  h [/red]: Go to home view \\[toolbar]")
+            print("[red]  o [/red]: Activate zoom mode \\[toolbar]")
+            print("[red]  p [/red]: Activate pan mode \\[toolbar]")
+            print("[red]  s [/red]: Save the current figure \\[toolbar]")
+            print("[red]  q [/red]: (ignored) prevent closing the window")
+        elif event.key == "q":
+            pass  # Ignore the "q" key to prevent closing the window
 
     def on_click(self, event):
         """Handle mouse click events on the image."""
@@ -814,6 +1019,10 @@ class CosmicRayCleanerApp(ImageDisplay):
             print(f"Toolbar mode '{toolbar.mode}' active; click ignored.")
             return
 
+        # proceed only if cursor selection mode is on
+        if not self.use_cursor:
+            return
+
         # ignore clicks outside the expected axes
         # (note that the color bar is a different axes)
         if event.inaxes == self.ax:

teareduce/cleanest/definitions.py

@@ -43,7 +43,7 @@ lacosmic_default_dict = {
 }
 
 # 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", "maskfill", "auxdata"]
 
 # Maximum pixel distance to consider when finding closest CR pixel
 MAX_PIXEL_DISTANCE_TO_CR = 15

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,7 +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
@@ -29,8 +30,8 @@ def cleanest(data, mask_crfound, dilation=0, interp_method=None, npoints=None, d
     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.
@@ -48,7 +49,7 @@ def cleanest(data, mask_crfound, dilation=0, interp_method=None, npoints=None, d
         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
     -------
@@ -86,13 +87,14 @@ def cleanest(data, mask_crfound, dilation=0, interp_method=None, npoints=None, d
     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):
+    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.")
@@ -131,6 +133,6 @@ def cleanest(data, mask_crfound, dilation=0, interp_method=None, npoints=None, d
             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/interpolationeditor.py

@@ -97,6 +97,7 @@ class InterpolationEditor:
             "median": "a-median",
             "mean": "a-mean",
             "lacosmic": "lacosmic",
+            "maskfill": "maskfill",
             "auxdata": "auxdata",
         }
         self.check_interp_methods()

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

teareduce/cleanest/mergemasks.py

@@ -0,0 +1,58 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Merge peak and tail masks for cosmic ray cleaning."""
+
+import numpy as np
+from scipy import ndimage
+
+
+def merge_peak_tail_masks(mask_peaks, mask_tails):
+    """Merge peak and tail masks for cosmic ray cleaning.
+
+    Tail pixels are preserved only if they correspond to CR features
+    that are also present in the peak mask.
+
+    Parameters
+    ----------
+    mask_peaks : ndarray
+        Boolean array indicating the pixels identified as cosmic ray peaks.
+    mask_tails : ndarray
+        Boolean array indicating the pixels identified as cosmic ray tails.
+
+    Returns
+    -------
+    merged_mask : ndarray
+        Boolean array indicating the merged cosmic ray mask.
+    """
+    # check that input masks are numpy arrays
+    if not isinstance(mask_peaks, np.ndarray) or not isinstance(mask_tails, np.ndarray):
+        raise TypeError("Input masks must be numpy arrays.")
+    # check that input masks have the same shape
+    if mask_peaks.shape != mask_tails.shape:
+        raise ValueError("Input masks must have the same shape.")
+    # check that input masks are boolean arrays
+    if mask_peaks.dtype != bool or mask_tails.dtype != bool:
+        raise TypeError("Input masks must be boolean arrays.")
+
+    # find structures in tail mask
+    structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+    cr_labels_tails, num_crs_tails = ndimage.label(mask_tails, structure=structure)
+    # generate mask of ones at peak pixels
+    mask_peaks_ones = np.zeros(mask_peaks.shape, dtype=float)
+    mask_peaks_ones[mask_peaks] = 1.0
+    # preserve only those tail pixels that are flagged as peaks
+    cr_labels_tails_preserved = mask_peaks_ones * cr_labels_tails
+    # generate new mask with preserved tail pixels
+    merged_mask = np.zeros_like(mask_peaks, dtype=bool)
+    for icr in np.unique(cr_labels_tails_preserved):
+        if icr > 0:
+            merged_mask[cr_labels_tails == icr] = True
+
+    return merged_mask

teareduce/cleanest/modalprogressbar.py

@@ -116,11 +116,11 @@ class ModalProgressBar:
 
             elapsed_str = self._format_time(elapsed)
             eta_str = self._format_time(eta_seconds)
+            total_str = self._format_time(elapsed + eta_seconds)
             rate_str = f"{rate:.2f} CR/s" if rate >= 1 else f"{1/rate:.2f} s/CR"
 
             self.status_label.config(text=f"{self.current}/{self.total} ({percentage:.1f}%) | {rate_str}")
-            self.time_label.config(text=f"Elapsed: {elapsed_str} | ETA: {eta_str}")
-
+            self.time_label.config(text=f"Expected Total: {total_str} | Elapsed: {elapsed_str} | ETA: {eta_str}")
         self.window.update_idletasks()
         self.window.update()
 

teareduce/cleanest/parametereditor.py

@@ -101,10 +101,21 @@ class ParameterEditor:
         bold_font = default_font.copy()
         bold_font.configure(weight="bold", size=default_font.cget("size") + 2)
         subtitle_label = tk.Label(main_frame, text="L.A.Cosmic Parameters", font=bold_font)
-        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 10))
         row += 1
 
         # Create labels and entry fields for each parameter.
+        bold_font_subheader = default_font.copy()
+        bold_font_subheader.configure(weight="bold", size=default_font.cget("size") + 1)
+        label = tk.Label(main_frame, text="Parameter", font=bold_font_subheader, anchor="w", fg="gray")
+        label.grid(row=row, column=0, sticky="e", pady=0)
+        label = tk.Label(main_frame, text="Run 1", font=bold_font_subheader, anchor="w", fg="gray", width=10)
+        label.grid(row=row, column=1, sticky="w", padx=10, pady=0)
+        label = tk.Label(main_frame, text="Run 2", font=bold_font_subheader, anchor="w", fg="gray", width=10)
+        label.grid(row=row, column=2, sticky="w", padx=10, pady=0)
+        label = tk.Label(main_frame, text="Type", font=bold_font_subheader, anchor="w", fg="gray", width=10)
+        label.grid(row=row, column=3, sticky="w", pady=0)
+        row += 1
         # 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 = {}
@@ -142,7 +153,7 @@ class ParameterEditor:
 
         # Subtitle for additional parameters
         subtitle_label = tk.Label(main_frame, text="Additional Parameters", font=bold_font)
-        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 10))
         row += 1
 
         # Dilation label and entry
@@ -177,7 +188,7 @@ class ParameterEditor:
 
         # 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=4, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 10))
         row += 1
 
         # Region to be examined label and entries

teareduce/cleanest/reviewcosmicray.py

@@ -13,6 +13,7 @@ import tkinter as tk
 from tkinter import messagebox
 from tkinter import simpledialog
 
+from maskfill import maskfill
 import matplotlib.pyplot as plt
 from matplotlib.backend_bases import key_press_handler
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
@@ -150,7 +151,7 @@ class ReviewCosmicRay(ImageDisplay):
             self.root.minsize(1000, 700)
         else:
             # self.root.geometry("800x700+100+100")  # This does not work in Fedora
-            self.root.minsize(800, 700)
+            self.root.minsize(900, 700)
         self.root.update_idletasks()
         self.root.geometry("+100+100")
         self.data = data
@@ -224,6 +225,8 @@ class ReviewCosmicRay(ImageDisplay):
             self.interp_l_button.config(state=tk.DISABLED)
         if self.cleandata_lacosmic is None:
             self.interp_l_button.config(state=tk.DISABLED)
+        self.interp_maskfill_button = tk.Button(self.button_frame2, text="mas[k]fill", command=self.use_maskfill)
+        self.interp_maskfill_button.pack(side=tk.LEFT, padx=5)
         self.interp_aux_button = tk.Button(self.button_frame2, text="[a]ux. data", command=self.use_auxdata)
         self.interp_aux_button.pack(side=tk.LEFT, padx=5)
         if self.auxdata is None:
@@ -246,7 +249,7 @@ class ReviewCosmicRay(ImageDisplay):
         if self.auxdata is not None:
             self.fig, (self.ax_aux, self.ax) = plt.subplots(ncols=2, figsize=(11, 5.5), constrained_layout=True)
         else:
-            self.fig, self.ax = plt.subplots(figsize=(8, 5.5), constrained_layout=True)
+            self.fig, self.ax = plt.subplots(figsize=(9, 5.5), constrained_layout=True)
         self.canvas = FigureCanvasTkAgg(self.fig, master=self.root)
         self.canvas.get_tk_widget().pack(padx=5, pady=5)
         # The next two instructions prevent a segmentation fault when pressing "q"
@@ -376,6 +379,7 @@ class ReviewCosmicRay(ImageDisplay):
         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_maskfill_button.config(state=tk.DISABLED)
         self.interp_aux_button.config(state=tk.DISABLED)
 
     def interp_x(self):
@@ -461,6 +465,27 @@ class ReviewCosmicRay(ImageDisplay):
         self.set_buttons_after_cleaning_cr()
         self.update_display(cleaned=True)
 
+    def use_maskfill(self):
+        """Use maskfill cleaned data to clean a cosmic ray."""
+        print(f"Maskfill interpolation of cosmic ray {self.cr_index}")
+        ycr_list, xcr_list = np.where(self.cr_labels == self.cr_index)
+        mask = np.zeros(self.data.shape, dtype=bool)
+        for iy, ix in zip(ycr_list, xcr_list):
+            mask[iy, ix] = True
+        smoothed_output, _ = maskfill(
+            input_image=self.data,
+            mask=mask,
+            size=3,
+            operator="median",
+            smooth=True,
+        )
+        for iy, ix in zip(ycr_list, xcr_list):
+            self.data[iy, ix] = smoothed_output[iy, ix]
+            self.mask_fixed[iy, ix] = True
+        self.num_cr_cleaned += 1
+        self.set_buttons_after_cleaning_cr()
+        self.update_display(cleaned=True)
+
     def use_auxdata(self):
         """Use auxiliary data to clean a cosmic ray."""
         if self.auxdata is None:
@@ -505,6 +530,7 @@ class ReviewCosmicRay(ImageDisplay):
             if self.cleandata_lacosmic is not None:
                 if self.last_dilation is None or self.last_dilation == 0:
                     self.interp_l_button.config(state=tk.NORMAL)
+            self.interp_maskfill_button.config(state=tk.NORMAL)
             if self.auxdata is not None:
                 self.interp_aux_button.config(state=tk.NORMAL)
         print(f"Restored all pixels of cosmic ray {self.cr_index}")
@@ -566,6 +592,9 @@ class ReviewCosmicRay(ImageDisplay):
         elif event.key == "l":
             if self.interp_l_button.cget("state") != "disabled":
                 self.use_lacosmic()
+        elif event.key == "k":
+            if self.interp_maskfill_button.cget("state") != "disabled":
+                self.use_maskfill()
         elif event.key == "a":
             if self.interp_aux_button.cget("state") != "disabled":
                 self.use_auxdata()

teareduce/tests/test_cleanest.py

@@ -12,7 +12,7 @@
 import numpy as np
 
 
-from ..cleanest.cleanest import cleanest
+from ..cleanest.interpolate import interpolate
 
 
 def test_cleanest_no_cr():
@@ -23,7 +23,7 @@ def test_cleanest_no_cr():
     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)
+        cleaned_data, mask_fixed = interpolate(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."
@@ -38,7 +38,7 @@ def test_cleanest_interpolation_x():
                              [False, False, True, False, False],
                              [False, False, True, False, False]], dtype=bool)
 
-    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
+    cleaned_data, mask_fixed = interpolate(data, mask_crfound,
                                         interp_method='x', npoints=2, degree=1)
 
     expected_data = np.array([[1, 1, 1, 1, 1],
@@ -62,8 +62,8 @@ def test_cleanest_interpolation_y():
                              [False, False, False],
                              [False, False, False]], dtype=bool)
 
-    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
-                                        interp_method='y', npoints=2, degree=1)
+    cleaned_data, mask_fixed = interpolate(data, mask_crfound,
+                                           interp_method='y', npoints=2, degree=1)
 
     expected_data = np.array([[1, 2, 3],
                               [1, 2, 3],
@@ -83,8 +83,8 @@ def test_cleanest_interpolation_surface():
                              [False, True, False],
                              [False, False, False]], dtype=bool)
 
-    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
-                                        interp_method='s', npoints=1)
+    cleaned_data, mask_fixed = interpolate(data, mask_crfound,
+                                           interp_method='s', npoints=1)
 
     expected_data = np.array([[1, 2, 3],
                               [4, 5, 6],
@@ -102,8 +102,8 @@ def test_cleanest_interpolation_median():
                              [False, True, False],
                              [False, False, False]], dtype=bool)
 
-    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
-                                        interp_method='d', npoints=1)
+    cleaned_data, mask_fixed = interpolate(data, mask_crfound,
+                                           interp_method='d', npoints=1)
 
     expected_data = np.array([[1, 2, 3],
                               [4, 5, 6],
@@ -121,8 +121,8 @@ def test_cleanest_interpolation_mean():
                              [False, True, False],
                              [False, False, False]], dtype=bool)
 
-    cleaned_data, mask_fixed = cleanest(data, mask_crfound,
-                                        interp_method='m', npoints=1)
+    cleaned_data, mask_fixed = interpolate(data, mask_crfound,
+                                           interp_method='m', npoints=1)
 
     expected_data = np.array([[1, 2, 3],
                               [4, 5, 6],

teareduce/version.py

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

{teareduce-0.5.5.dist-info → teareduce-0.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: teareduce
-Version: 0.5.5
+Version: 0.5.8
 Summary: Utilities for astronomical data reduction
 Author-email: Nicolás Cardiel <cardiel@ucm.es>
 License: GPL-3.0-or-later
@@ -23,6 +23,7 @@ Requires-Dist: astropy
 Requires-Dist: ccdproc
 Requires-Dist: lmfit
 Requires-Dist: matplotlib
+Requires-Dist: maskfill
 Requires-Dist: numpy>=1.22
 Requires-Dist: requests
 Requires-Dist: rich

{teareduce-0.5.5.dist-info → teareduce-0.5.8.dist-info}/RECORD

@@ -15,35 +15,37 @@ 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=x8qFVHj0LWtGzf-qBtcwzyAnbALRdsIJ4c4C_GQISJc,419
+teareduce/version.py,sha256=G40b1Oo_cwqV4sHca8L26xY3VpGjlKvOFDTnZdytrtg,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=3O-eptEAQareN504tLALMrJVQPGCuBx7YTfQGqMKjmc,205
-teareduce/cleanest/__main__.py,sha256=_wXGgwq62ete5-DlNDsKkZP0kATAVFVwTVrG9EspkU8,3298
+teareduce/cleanest/__init__.py,sha256=hHFtV6uBx6HAI8LFUDli0urznTUzMotCW9J_4EKGCXc,293
+teareduce/cleanest/__main__.py,sha256=cMzvNWNe2fuTGHLtT3hOc9-NAcMXDZUqHN0SSHWWDnc,5977
 teareduce/cleanest/centerchildparent.py,sha256=wHxOvNrrQ-KBLZAbtQ9bJAxYhGOzqYBF4LgdIQk7UF8,1285
-teareduce/cleanest/cleanest.py,sha256=hDC_3jF9ovHCX8IRAPe9eEGFWt_LeVI5rzS7atK7oWI,5025
-teareduce/cleanest/cosmicraycleanerapp.py,sha256=C-lGOREVXrlaqJsjEuJ66xVNx0z8axXq5f5GQh9dpMA,41226
-teareduce/cleanest/definitions.py,sha256=HLv41cuhUOUyEicRHea0LRTv4Wagm24miSxFt4cZN3g,2546
+teareduce/cleanest/cosmicraycleanerapp.py,sha256=gugC79tdQFhT7plOWKqm5uTtjJCiWIeDpNmaCiE7aA4,50584
+teareduce/cleanest/definitions.py,sha256=L7VXT0SAjv96zgZ_VhMMV1vcf-oxdwefvlmPclBA-ug,2558
 teareduce/cleanest/dilatemask.py,sha256=I5tHAv5VEO6V0Wed8Ar20uLt4F9P-tgjmLL5BAaFvgM,1276
 teareduce/cleanest/find_closest_true.py,sha256=mWdIvhipzAXDRKfePDrP7f0lP4U48cckpHiKwiB4jHI,1320
 teareduce/cleanest/imagedisplay.py,sha256=820Vn-Q0bJyHicOBsxDmfAZxuGOFepEEsm0LTxlPJjc,5848
+teareduce/cleanest/interpolate.py,sha256=qlz4SHw89ahBRx1VHBMkd0IEpFkd96P6FVfsw_LoQDA,5194
 teareduce/cleanest/interpolation_a.py,sha256=zE4VIrC41vapf0Vx9qmh1oacw2qkJwcuMnV3JpSDW8Y,4007
 teareduce/cleanest/interpolation_x.py,sha256=D5hKbobT6lJk18XktP3PXhzEN12zqed6U18yfQ-reLQ,3744
 teareduce/cleanest/interpolation_y.py,sha256=O6yw5nKKlTdV6qsP1Ku6CwGhXB6o3j0_YQirXyILi8c,3759
-teareduce/cleanest/interpolationeditor.py,sha256=EksuNwKOM79MyGlAgxb9j-v7pIFXV8QOcyZDLVQlQjU,13221
-teareduce/cleanest/modalprogressbar.py,sha256=9anz3js_y_9JLjPyA7XxEsLpVwuMN_CTlnQnhf7m3uo,6355
-teareduce/cleanest/parametereditor.py,sha256=IdaX6_VPicwnYw3dvRA0tKoTZYb6Gp-AZB5ksFClv1o,13390
-teareduce/cleanest/reviewcosmicray.py,sha256=_qO9ifkAMqB4Wuvq2wIYZ8_DUniB2lWcxn9l404hXnY,28210
+teareduce/cleanest/interpolationeditor.py,sha256=J5vrioLTwUSMbUeY0ezqNqm3CvLJgKFe7gvZ44Z62sc,13257
+teareduce/cleanest/lacosmicpad.py,sha256=xWaxifoF_B82Gm5czuJmL7Y4Cv0W___LlvcpH633bAo,2047
+teareduce/cleanest/mergemasks.py,sha256=1Vq6Wqn6DClxSAvHwy6QrJGszA8nkmoMHITyprSykHI,2072
+teareduce/cleanest/modalprogressbar.py,sha256=uwd-p92PvOVJnbXd-B8DRcBZ--keKpr4ZN9PLeqm1Ws,6449
+teareduce/cleanest/parametereditor.py,sha256=_0baFbkIUcPyF-teFIRMt1MpA4IzDZc7VHNh1h0qN4A,14229
+teareduce/cleanest/reviewcosmicray.py,sha256=yTY9vNyYSuh_AZsIJAEtJ50mgIKhjgTe-LQob4xQx9U,29497
 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_cleanest.py,sha256=6dRqkw1RQMKsFrC8cEweMvTD6wXhiDv3P4PS57-HEqI,5598
 teareduce/tests/test_sliceregion.py,sha256=S7Zoh2eEBFIEbfsXgWBEMCf7pottjw2oLhqlZJQkAwg,3785
 teareduce/tests/test_version.py,sha256=mKLnbXyvVNc1pATq5PxR8qeoFMPAFL_GilFV6IHLOi0,172
-teareduce-0.5.5.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-teareduce-0.5.5.dist-info/METADATA,sha256=MIifKnlyWPEQyuxUG3OaqqRnydUaE7JYhcBIB-XDu7Q,3113
-teareduce-0.5.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-teareduce-0.5.5.dist-info/entry_points.txt,sha256=6yBvig5jTL2ugqz5SF767AiszzrHKGRASsX1II84kqA,66
-teareduce-0.5.5.dist-info/top_level.txt,sha256=7OkwtX9zNRkGJ7ACgjk4ESgC74qUYcS5O2qcO0v-Si4,10
-teareduce-0.5.5.dist-info/RECORD,,
+teareduce-0.5.8.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+teareduce-0.5.8.dist-info/METADATA,sha256=Xm0x4wiGEoHvS_3tIk7gmaLHZbN0HDuN_Iec_wdQg84,3137
+teareduce-0.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+teareduce-0.5.8.dist-info/entry_points.txt,sha256=6yBvig5jTL2ugqz5SF767AiszzrHKGRASsX1II84kqA,66
+teareduce-0.5.8.dist-info/top_level.txt,sha256=7OkwtX9zNRkGJ7ACgjk4ESgC74qUYcS5O2qcO0v-Si4,10
+teareduce-0.5.8.dist-info/RECORD,,