teareduce 0.5.9__py3-none-any.whl → 0.6.1__py3-none-any.whl

teareduce/cleanest/cosmicraycleanerapp.py

@@ -17,6 +17,7 @@ from tkinter import simpledialog
 import sys
 
 from astropy.io import fits
+
 try:
     from maskfill import maskfill
 except ModuleNotFoundError as e:
@@ -34,10 +35,15 @@ import os
 from pathlib import Path
 from rich import print
 
+from .askextension import ask_extension_input_image
 from .centerchildparent import center_on_parent
 from .definitions import lacosmic_default_dict
 from .definitions import DEFAULT_NPOINTS_INTERP
 from .definitions import DEFAULT_DEGREE_INTERP
+from .definitions import DEFAULT_MASKFILL_SIZE
+from .definitions import DEFAULT_MASKFILL_OPERATOR
+from .definitions import DEFAULT_MASKFILL_SMOOTH
+from .definitions import DEFAULT_MASKFILL_VERBOSE
 from .definitions import MAX_PIXEL_DISTANCE_TO_CR
 from .definitions import DEFAULT_TK_WINDOW_SIZE_X
 from .definitions import DEFAULT_TK_WINDOW_SIZE_Y
@@ -52,12 +58,14 @@ from .interpolationeditor import InterpolationEditor
 from .imagedisplay import ImageDisplay
 from .lacosmicpad import lacosmicpad
 from .mergemasks import merge_peak_tail_masks
+from .modalprogressbar import ModalProgressBar
 from .parametereditor import ParameterEditor
 from .reviewcosmicray import ReviewCosmicRay
-from .modalprogressbar import ModalProgressBar
+from .trackedbutton import TrackedTkButton
 
 from ..imshow import imshow
 from ..sliceregion import SliceRegion2D
+from ..version import VERSION
 from ..zscale import zscale
 
 import matplotlib
@@ -127,7 +135,7 @@ class CosmicRayCleanerApp(ImageDisplay):
             Update the overlay of cosmic ray pixels on the image.
         apply_lacosmic()
             Apply the L.A.Cosmic algorithm to the data.
-        examine_detected_cr()
+        review_detected_cr()
             Examine detected cosmic rays.
         stop_app()
             Stop the application.
@@ -182,10 +190,26 @@ class CosmicRayCleanerApp(ImageDisplay):
         last_ymax : int
             Last used maximum y-coordinate for region selection.
             From 1 to NAXIS2.
+        last_inbkg : str or None
+            Last used input background image FITS file.
+        last_extnum_inbkg : int or None
+            Last used FITS extension number for the input background image.
+        last_invar : str or None
+            Last used input variance image FITS file.
+        last_extnum_invar : int or None
+            Last used FITS extension number for the input variance image.
         last_npoints : int
             Last used number of points for interpolation.
         last_degree : int
             Last used degree for interpolation.
+        last_maskfill_size : int
+            Last used size parameter for maskfill.
+        last_maskfill_operator : str
+            Last used operator parameter for maskfill.
+        last_maskfill_smooth : bool
+            Last used smooth parameter for maskfill.
+        last_maskfill_verbose : bool
+            Last used verbose parameter for maskfill.
         cleandata_lacosmic : np.ndarray
             The cleaned data returned from L.A.Cosmic.
         cr_labels : np.ndarray
@@ -196,13 +220,13 @@ class CosmicRayCleanerApp(ImageDisplay):
             Flag to indicate if the review window is active.
         """
         self.root = root
-        # self.root.geometry("800x800+50+0")  # This does not work in Fedora
+        # self.root.geometry("800x700+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")
+        self.root.title(f"Cosmic Ray Cleaner (TEA version {VERSION})")
         self.fontfamily = fontfamily
         self.fontsize = fontsize
         self.default_font = tkfont.nametofont("TkDefaultFont")
@@ -225,8 +249,18 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.last_xmax = self.data.shape[1]
         self.last_ymin = 1
         self.last_ymax = self.data.shape[0]
+        self.last_inbkg = None
+        self.last_extnum_inbkg = None
+        self.inbkg_data = None
+        self.last_invar = None
+        self.last_extnum_invar = None
+        self.invar_data = None
         self.last_npoints = DEFAULT_NPOINTS_INTERP
         self.last_degree = DEFAULT_DEGREE_INTERP
+        self.last_maskfill_size = DEFAULT_MASKFILL_SIZE
+        self.last_maskfill_operator = DEFAULT_MASKFILL_OPERATOR
+        self.last_maskfill_smooth = DEFAULT_MASKFILL_SMOOTH
+        self.last_maskfill_verbose = DEFAULT_MASKFILL_VERBOSE
         self.create_widgets()
         self.cleandata_lacosmic = None
         self.cr_labels = None
@@ -235,7 +269,7 @@ class CosmicRayCleanerApp(ImageDisplay):
 
     def process_detected_cr(self, dilation):
         """Process the detected cosmic ray mask.
-        
+
         Parameters
         ----------
         dilation : int
@@ -246,20 +280,18 @@ class CosmicRayCleanerApp(ImageDisplay):
             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
-                )
+                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....: "
+                    "Number of cosmic ray pixels before dilation.......: "
+                    f"{num_cr_pixels_before_dilation:>{len(sdum)}}"
+                )
+                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,
@@ -267,9 +299,9 @@ 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 ray features (grouped pixels): {self.num_features:>{len(sdum)}}")
+            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.review_detected_cr_button.config(state=tk.NORMAL)
             self.update_cr_overlay()
             self.use_cursor = True
             self.use_cursor_button.config(text="[c]ursor: ON ")
@@ -278,10 +310,17 @@ class CosmicRayCleanerApp(ImageDisplay):
             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)
+            self.review_detected_cr_button.config(state=tk.DISABLED)
 
     def load_detected_cr_from_file(self):
         """Load detected cosmic ray mask from a FITS file."""
+        if np.any(self.mask_crfound):
+            overwrite = messagebox.askyesno(
+                "Overwrite Cosmic Ray Mask",
+                "A cosmic ray mask is already defined.\n\nDo you want to overwrite it?",
+            )
+            if not overwrite:
+                return
         crmask_file = filedialog.askopenfilename(
             initialdir=os.getcwd(),
             title="Select FITS file with cosmic ray mask",
@@ -289,18 +328,7 @@ class CosmicRayCleanerApp(ImageDisplay):
         )
         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
-            )
+            extension = ask_extension_input_image(crmask_file, self.data.shape)
             try:
                 with fits.open(crmask_file, mode="readonly") as hdul:
                     if isinstance(extension, int):
@@ -309,6 +337,8 @@ class CosmicRayCleanerApp(ImageDisplay):
                     else:
                         if extension not in hdul:
                             raise KeyError(f"Extension name '{extension}' not found.")
+                    if hdul[extension].header["BITPIX"] not in [8, 16]:
+                        raise ValueError("Cosmic ray mask must be of integer type (BITPIX=8 or 16).")
                     mask_crfound_loaded = hdul[extension].data.astype(bool)
                     if mask_crfound_loaded.shape != self.data.shape:
                         print(f"data shape...: {self.data.shape}")
@@ -316,9 +346,14 @@ class CosmicRayCleanerApp(ImageDisplay):
                         raise ValueError("Cosmic ray mask has different shape.")
                     self.mask_crfound = mask_crfound_loaded
                     print(f"Loaded cosmic ray mask from {crmask_file}")
+                    dilation = simpledialog.askinteger(
+                        "Dilation", "Enter Dilation (min=0):", initialvalue=0, minvalue=0
+                    )
                     self.process_detected_cr(dilation=dilation)
+                    # self.lacosmic_params["dilation"]["value"] = dilation
+                    self.cleandata_lacosmic = None  # Invalidate previous L.A.Cosmic cleaned data
             except Exception as e:
-                print(f"Error loading cosmic ray mask: {e}")
+                messagebox.showerror("Error", f"Error loading cosmic ray mask: {e}")
 
     def load_fits_file(self):
         """Load the FITS file and auxiliary file (if provided).
@@ -378,7 +413,9 @@ class CosmicRayCleanerApp(ImageDisplay):
                     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}")
+                    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}")
@@ -387,6 +424,43 @@ class CosmicRayCleanerApp(ImageDisplay):
             except Exception as e:
                 sys.exit(f"Error loading auxiliary FITS file: {e}")
 
+    def load_auxdata_from_file(self):
+        """Load auxiliary data from a FITS file."""
+        if self.auxfile is not None:
+            overwrite = messagebox.askyesno(
+                "Overwrite Auxiliary Data",
+                f"An auxiliary file is already loaded:\n\n{self.auxfile}\n\n" "Do you want to overwrite it?",
+            )
+            if not overwrite:
+                return
+        auxfile = filedialog.askopenfilename(
+            initialdir=os.getcwd(),
+            title="Select auxiliary FITS file",
+            filetypes=[("FITS files", "*.fits"), ("All files", "*.*")],
+        )
+        if auxfile:
+            extension = ask_extension_input_image(auxfile, self.data.shape)
+            try:
+                with fits.open(auxfile, 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.")
+                    auxdata_loaded = hdul[extension].data
+                    if auxdata_loaded.shape != self.data.shape:
+                        print(f"data shape...: {self.data.shape}")
+                        print(f"auxdata shape: {auxdata_loaded.shape}")
+                        raise ValueError("Auxiliary file has different shape.")
+                    self.auxfile = auxfile
+                    self.auxdata = auxdata_loaded
+                    self.extension_auxfile = extension
+                    print(f"Loaded auxiliary data from {auxfile}")
+                    self.toggle_auxdata_button.config(state=tk.NORMAL)
+            except Exception as e:
+                print(f"Error loading auxiliary FITS file: {e}")
+
     def save_fits_file(self):
         """Save the cleaned FITS file.
 
@@ -450,74 +524,153 @@ class CosmicRayCleanerApp(ImageDisplay):
         and canvas for image display, along with the toolbar for navigation.
         The relevant attributes are stored in the instance for later use.
         """
+        # Define instance of TrackedTkButton, that facilitates to show help information
+        # for each button displayed in the current application window.
+        tkbutton = TrackedTkButton(self.root)
+
         # Row 1 of buttons
         self.button_frame1 = tk.Frame(self.root)
         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 = tkbutton.new(
+            self.button_frame1,
+            text="Run L.A.Cosmic",
+            command=self.run_lacosmic,
+            help_text="Run the L.A.Cosmic algorithm to detect cosmic rays in the image.",
+        )
         self.run_lacosmic_button.pack(side=tk.LEFT, padx=5)
-        self.load_detected_cr_button = tk.Button(
-            self.button_frame1, text="Load detected CRs", command=self.load_detected_cr_from_file
+        self.load_auxdata_button = tkbutton.new(
+            self.button_frame1,
+            text="Load auxdata",
+            command=self.load_auxdata_from_file,
+            help_text="Load an auxiliary FITS file for display.",
+        )
+        self.load_auxdata_button.pack(side=tk.LEFT, padx=5)
+        self.load_detected_cr_button = tkbutton.new(
+            self.button_frame1,
+            text="Load CR mask",
+            command=self.load_detected_cr_from_file,
+            help_text="Load a previously saved cosmic ray mask from a FITS 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.replace_detected_cr_button = tkbutton.new(
+            self.button_frame1,
+            text="Replace detected CRs",
+            command=self.apply_lacosmic,
+            help_text="Apply the cleaning to the detected cosmic rays.",
         )
         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)
+        self.review_detected_cr_button = tkbutton.new(
+            self.button_frame1,
+            text="Review detected CRs",
+            command=lambda: self.review_detected_cr(1),
+            help_text="Review the detected cosmic rays.",
         )
-        self.examine_detected_cr_button.pack(side=tk.LEFT, padx=5)
-        self.examine_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
+        self.review_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        self.review_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
 
         # 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.use_cursor = False
+        self.use_cursor_button = tkbutton.new(
+            self.button_frame2,
+            text="[c]ursor: OFF",
+            command=self.set_cursor_onoff,
+            help_text="Toggle the cursor ON or OFF (to select CR with mouse).",
+            alttext="[c]ursor: ??",
+        )
+        self.use_cursor_button.pack(side=tk.LEFT, padx=5)
+        self.toggle_auxdata_button = tkbutton.new(
+            self.button_frame2,
+            text="[t]oggle data",
+            command=self.toggle_auxdata,
+            help_text="Toggle the display of auxiliary data.",
+        )
         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 = tkbutton.new(
+            self.button_frame2,
+            text=f"[a]spect: {self.image_aspect}",
+            command=self.toggle_aspect,
+            help_text="Toggle the image aspect ratio.",
         )
         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 = tkbutton.new(
+            self.button_frame2,
+            text="Save cleaned FITS",
+            command=self.save_fits_file,
+            help_text="Save the cleaned FITS file.",
+        )
         self.save_button.pack(side=tk.LEFT, padx=5)
         self.save_button.config(state=tk.DISABLED)  # Initially disabled
-        self.stop_button = tk.Button(self.button_frame2, text="Stop program", command=self.stop_app)
+        self.stop_button = tkbutton.new(
+            self.button_frame2, text="Stop program", command=self.stop_app, help_text="Stop the application."
+        )
         self.stop_button.pack(side=tk.LEFT, padx=5)
 
         # 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 = tkbutton.new(
+            self.button_frame3,
+            text=f"vmin: {vmin:.2f}",
+            command=self.set_vmin,
+            help_text="Set the minimum value for the display scale.",
+            alttext="vmin: ??",
+        )
         self.vmin_button.pack(side=tk.LEFT, padx=5)
-        self.vmax_button = tk.Button(self.button_frame3, text=f"vmax: {vmax:.2f}", command=self.set_vmax)
+        self.vmax_button = tkbutton.new(
+            self.button_frame3,
+            text=f"vmax: {vmax:.2f}",
+            command=self.set_vmax,
+            help_text="Set the maximum value for the display scale.",
+            alttext="vmax: ??",
+        )
         self.vmax_button.pack(side=tk.LEFT, padx=5)
-        self.set_minmax_button = tk.Button(self.button_frame3, text="minmax [,]", command=self.set_minmax)
+        self.set_minmax_button = tkbutton.new(
+            self.button_frame3,
+            text="minmax [,]",
+            command=self.set_minmax,
+            help_text="Set the minimum and maximum values for the display scale.",
+        )
         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 = tkbutton.new(
+            self.button_frame3,
+            text="zscale [/]",
+            command=self.set_zscale,
+            help_text="Set the display scale using zscale.",
+        )
         self.set_zscale_button.pack(side=tk.LEFT, padx=5)
         if self.overplot_cr_pixels:
-            self.overplot_cr_button = tk.Button(
+            self.overplot_cr_button = tkbutton.new(
                 self.button_frame3,
                 text="CR overlay: ON ",
                 command=self.toggle_cr_overlay,
+                help_text="Toggle the cosmic ray overlay ON or OFF.",
+                alttext="CR overlay: ??",
             )
         else:
-            self.overplot_cr_button = tk.Button(
+            self.overplot_cr_button = tkbutton.new(
                 self.button_frame3,
                 text="CR overlay: OFF",
                 command=self.toggle_cr_overlay,
+                help_text="Toggle the cosmic ray overlay ON or OFF.",
+                alttext="CR overlay: ??",
             )
         self.overplot_cr_button.pack(side=tk.LEFT, padx=5)
+        self.help_button = tkbutton.new(
+            self.button_frame3,
+            text="Help",
+            command=tkbutton.show_help,
+            help_text="Show help information for all buttons.",
+        )
+        self.help_button.pack(side=tk.LEFT, padx=5)
 
         # Figure
         self.plot_frame = tk.Frame(self.root)
@@ -606,6 +759,13 @@ class CosmicRayCleanerApp(ImageDisplay):
 
     def run_lacosmic(self):
         """Run L.A.Cosmic to detect cosmic rays."""
+        if np.any(self.mask_crfound):
+            overwrite = messagebox.askyesno(
+                "Overwrite Cosmic Ray Mask",
+                "A cosmic ray mask is already defined.\n\nDo you want to overwrite it?",
+            )
+            if not overwrite:
+                return
         self.run_lacosmic_button.config(state=tk.DISABLED)
         # Define parameters for L.A.Cosmic from default dictionary
         editor_window = tk.Toplevel(self.root)
@@ -619,6 +779,10 @@ class CosmicRayCleanerApp(ImageDisplay):
             ymin=self.last_ymin,
             ymax=self.last_ymax,
             imgshape=self.data.shape,
+            inbkg=self.last_inbkg,
+            extnum_inbkg=self.last_extnum_inbkg,
+            invar=self.last_invar,
+            extnum_invar=self.last_extnum_invar,
         )
         # Make it modal (blocks interaction with main window)
         editor_window.transient(self.root)
@@ -633,6 +797,24 @@ class CosmicRayCleanerApp(ImageDisplay):
             self.last_xmax = updated_params["xmax"]["value"]
             self.last_ymin = updated_params["ymin"]["value"]
             self.last_ymax = updated_params["ymax"]["value"]
+            self.last_inbkg = updated_params["inbkg"]["value"]
+            self.last_extnum_inbkg = updated_params["extnum_inbkg"]["value"]
+            self.last_invar = updated_params["invar"]["value"]
+            self.last_extnum_invar = updated_params["extnum_invar"]["value"]
+            if self.last_inbkg is not None:
+                with fits.open(self.last_inbkg, mode="readonly") as hdul_inbkg:
+                    if self.last_extnum_inbkg < 0 or self.last_extnum_inbkg >= len(hdul_inbkg):
+                        raise IndexError(f"Extension index {self.last_extnum_inbkg} out of range.")
+                    self.inbkg_data = hdul_inbkg[self.last_extnum_inbkg].data.astype(np.float32)
+            else:
+                self.inbkg_data = None
+            if self.last_invar is not None:
+                with fits.open(self.last_invar, mode="readonly") as hdul_invar:
+                    if self.last_extnum_invar < 0 or self.last_extnum_invar >= len(hdul_invar):
+                        raise IndexError(f"Extension index {self.last_extnum_invar} out of range.")
+                    self.invar_data = hdul_invar[self.last_extnum_invar].data.astype(np.float32)
+            else:
+                self.invar_data = None
             usefulregion = SliceRegion2D(
                 f"[{self.last_xmin}:{self.last_xmax},{self.last_ymin}:{self.last_ymax}]", mode="fits"
             ).python
@@ -651,14 +833,27 @@ class CosmicRayCleanerApp(ImageDisplay):
             borderpadd = updated_params["borderpadd"]["value"]
             cleandata_lacosmic, mask_crfound = lacosmicpad(
                 pad_width=borderpadd,
+                show_arguments=self.verbose,
                 ccd=self.data,
-                gain=self.lacosmic_params["run1_gain"]["value"],
-                readnoise=self.lacosmic_params["run1_readnoise"]["value"],
+                gain_apply=True,  # Always apply gain
                 sigclip=self.lacosmic_params["run1_sigclip"]["value"],
                 sigfrac=self.lacosmic_params["run1_sigfrac"]["value"],
                 objlim=self.lacosmic_params["run1_objlim"]["value"],
+                gain=self.lacosmic_params["run1_gain"]["value"],
+                readnoise=self.lacosmic_params["run1_readnoise"]["value"],
+                satlevel=self.lacosmic_params["run1_satlevel"]["value"],
                 niter=self.lacosmic_params["run1_niter"]["value"],
+                sepmed=self.lacosmic_params["run1_sepmed"]["value"],
+                cleantype=self.lacosmic_params["run1_cleantype"]["value"],
+                fsmode=self.lacosmic_params["run1_fsmode"]["value"],
+                psfmodel=self.lacosmic_params["run1_psfmodel"]["value"],
+                psffwhm_x=self.lacosmic_params["run1_psffwhm_x"]["value"],
+                psffwhm_y=self.lacosmic_params["run1_psffwhm_y"]["value"],
+                psfsize=self.lacosmic_params["run1_psfsize"]["value"],
+                psfbeta=self.lacosmic_params["run1_psfbeta"]["value"],
                 verbose=self.lacosmic_params["run1_verbose"]["value"],
+                inbkg=self.inbkg_data,
+                invar=self.invar_data,
             )
             # Apply usefulmask to consider only selected region
             cleandata_lacosmic *= usefulmask
@@ -668,24 +863,34 @@ class CosmicRayCleanerApp(ImageDisplay):
                 print("[bold green]Executing L.A.Cosmic (run 2)...[/bold green]")
                 cleandata_lacosmic2, mask_crfound2 = lacosmicpad(
                     pad_width=borderpadd,
+                    show_arguments=self.verbose,
                     ccd=self.data,
-                    gain=self.lacosmic_params["run2_gain"]["value"],
-                    readnoise=self.lacosmic_params["run2_readnoise"]["value"],
+                    gain_apply=True,  # Always apply gain
                     sigclip=self.lacosmic_params["run2_sigclip"]["value"],
                     sigfrac=self.lacosmic_params["run2_sigfrac"]["value"],
                     objlim=self.lacosmic_params["run2_objlim"]["value"],
+                    gain=self.lacosmic_params["run2_gain"]["value"],
+                    readnoise=self.lacosmic_params["run2_readnoise"]["value"],
+                    satlevel=self.lacosmic_params["run2_satlevel"]["value"],
                     niter=self.lacosmic_params["run2_niter"]["value"],
+                    sepmed=self.lacosmic_params["run2_sepmed"]["value"],
+                    cleantype=self.lacosmic_params["run2_cleantype"]["value"],
+                    fsmode=self.lacosmic_params["run2_fsmode"]["value"],
+                    psfmodel=self.lacosmic_params["run2_psfmodel"]["value"],
+                    psffwhm_x=self.lacosmic_params["run2_psffwhm_x"]["value"],
+                    psffwhm_y=self.lacosmic_params["run2_psffwhm_y"]["value"],
+                    psfsize=self.lacosmic_params["run2_psfsize"]["value"],
+                    psfbeta=self.lacosmic_params["run2_psfbeta"]["value"],
                     verbose=self.lacosmic_params["run2_verbose"]["value"],
+                    inbkg=self.inbkg_data,
+                    invar=self.invar_data,
                 )
                 # 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)}")
-                    mask_crfound = merge_peak_tail_masks(mask_crfound, mask_crfound2)
-                    print(f"Number of cosmic ray pixels (run1 & run2): {np.sum(mask_crfound)}")
+                    mask_crfound = merge_peak_tail_masks(mask_crfound, mask_crfound2, verbose=True)
                 # Use the cleandata from the second run
                 cleandata_lacosmic = cleandata_lacosmic2
             # Select the image region to process
@@ -732,9 +937,6 @@ 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))
-            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)
             center_on_parent(child=editor_window, parent=self.root)
@@ -743,7 +945,12 @@ class CosmicRayCleanerApp(ImageDisplay):
                 last_dilation=self.lacosmic_params["dilation"]["value"],
                 last_npoints=self.last_npoints,
                 last_degree=self.last_degree,
+                last_maskfill_size=self.last_maskfill_size,
+                last_maskfill_operator=self.last_maskfill_operator,
+                last_maskfill_smooth=self.last_maskfill_smooth,
+                last_maskfill_verbose=self.last_maskfill_verbose,
                 auxdata=self.auxdata,
+                cleandata_lacosmic=self.cleandata_lacosmic,
                 xmin=self.last_xmin,
                 xmax=self.last_xmax,
                 ymin=self.last_ymin,
@@ -760,8 +967,13 @@ class CosmicRayCleanerApp(ImageDisplay):
             if cleaning_method is None:
                 print("Interpolation method selection cancelled. No cleaning applied!")
                 return
+            # Update last employed parameters
             self.last_npoints = editor.npoints
             self.last_degree = editor.degree
+            self.last_maskfill_size = editor.maskfill_size
+            self.last_maskfill_operator = editor.maskfill_operator
+            self.last_maskfill_smooth = editor.maskfill_smooth
+            self.last_maskfill_verbose = editor.maskfill_verbose
             cleaning_region = SliceRegion2D(
                 f"[{editor.xmin}:{editor.xmax},{editor.ymin}:{editor.ymax}]", mode="fits"
             ).python
@@ -783,12 +995,19 @@ class CosmicRayCleanerApp(ImageDisplay):
                     data_has_been_modified = True
                 elif cleaning_method == "maskfill":
                     # Replace detected CR pixels with local median values
+                    print(
+                        f"Maskfill parameters: size={self.last_maskfill_size}, "
+                        f"operator={self.last_maskfill_operator}, "
+                        f"smooth={self.last_maskfill_smooth}, "
+                        f"verbose={self.last_maskfill_verbose}"
+                    )
                     smoothed_output, _ = maskfill(
                         input_image=self.data,
                         mask=mask_crfound_region,
-                        size=3,
-                        operator="median",
-                        smooth=True,
+                        size=self.last_maskfill_size,
+                        operator=self.last_maskfill_operator,
+                        smooth=self.last_maskfill_smooth,
+                        verbose=self.last_maskfill_verbose,
                     )
                     self.data[mask_crfound_region] = smoothed_output[mask_crfound_region]
                     # update mask_fixed to include the newly fixed pixels
@@ -891,11 +1110,11 @@ class CosmicRayCleanerApp(ImageDisplay):
             if data_has_been_modified:
                 self.save_button.config(state=tk.NORMAL)
             if self.num_features == 0:
-                self.examine_detected_cr_button.config(state=tk.DISABLED)
+                self.review_detected_cr_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):
+    def review_detected_cr(self, first_cr_index=1, single_cr=False, ixpix=None, iypix=None):
         """Open a window to examine and possibly clean detected cosmic rays."""
         self.working_in_review_window = True
         review_window = tk.Toplevel(self.root)
@@ -906,6 +1125,8 @@ class CosmicRayCleanerApp(ImageDisplay):
             tmp_cr_labels[iypix - 1, ixpix - 1] = 1
             review = ReviewCosmicRay(
                 root=review_window,
+                root_width=self.width,
+                root_height=self.height,
                 data=self.data,
                 auxdata=self.auxdata,
                 cleandata_lacosmic=self.cleandata_lacosmic,
@@ -920,6 +1141,8 @@ class CosmicRayCleanerApp(ImageDisplay):
         else:
             review = ReviewCosmicRay(
                 root=review_window,
+                root_width=self.width,
+                root_height=self.height,
                 data=self.data,
                 auxdata=self.auxdata,
                 cleandata_lacosmic=self.cleandata_lacosmic,
@@ -961,7 +1184,7 @@ class CosmicRayCleanerApp(ImageDisplay):
         if review.num_cr_cleaned > 0:
             self.save_button.config(state=tk.NORMAL)
         if self.num_features == 0:
-            self.examine_detected_cr_button.config(state=tk.DISABLED)
+            self.review_detected_cr_button.config(state=tk.DISABLED)
             self.replace_detected_cr_button.config(state=tk.DISABLED)
         self.update_cr_overlay()
 
@@ -1069,4 +1292,4 @@ class CosmicRayCleanerApp(ImageDisplay):
             else:
                 ixpix = None
                 iypix = None
-            self.examine_detected_cr(label_at_click, single_cr=True, ixpix=ixpix, iypix=iypix)
+            self.review_detected_cr(label_at_click, single_cr=True, ixpix=ixpix, iypix=iypix)