teareduce 0.4.9__py3-none-any.whl → 0.5.0__py3-none-any.whl

teareduce/cleanest/cosmicraycleanerapp.py

@@ -11,7 +11,8 @@
 
 import tkinter as tk
 from tkinter import filedialog
-from tkinter import simpledialog
+from tkinter import messagebox
+import sys
 
 from astropy.io import fits
 from ccdproc import cosmicray_lacosmic
@@ -20,20 +21,34 @@ from matplotlib.backend_bases import key_press_handler
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
 import numpy as np
 import os
+from rich import print
+from scipy import ndimage
 
+from .definitions import lacosmic_default_dict
+from .definitions import DEFAULT_NPOINTS_INTERP
+from .definitions import DEFAULT_DEGREE_INTERP
+from .definitions import MAX_PIXEL_DISTANCE_TO_CR
+from .find_closest_true import find_closest_true
+from .interpolation_a import interpolation_a
+from .interpolation_x import interpolation_x
+from .interpolation_y import interpolation_y
+from .interpolationeditor import InterpolationEditor
+from .imagedisplay import ImageDisplay
+from .parametereditor import ParameterEditor
 from .reviewcosmicray import ReviewCosmicRay
 
 from ..imshow import imshow
+from ..sliceregion import SliceRegion2D
 from ..zscale import zscale
 
 import matplotlib
 matplotlib.use("TkAgg")
 
 
-class CosmicRayCleanerApp():
+class CosmicRayCleanerApp(ImageDisplay):
     """Main application class for cosmic ray cleaning."""
 
-    def __init__(self, root, input_fits, extension=0, output_fits=None):
+    def __init__(self, root, input_fits, extension=0, auxfile=None, extension_auxfile=0):
         """
         Initialize the application.
 
@@ -45,20 +60,118 @@ class CosmicRayCleanerApp():
             Path to the FITS file to be cleaned.
         extension : int, optional
             FITS extension to use (default is 0).
-        output_fits : str, optional
-            Path to save the cleaned FITS file (default is None, which prompts
-            for a save location).
+        auxfile : str, optional
+            Path to an auxiliary FITS file (default is None).
+        extension_auxfile : int, optional
+            FITS extension for auxiliary file (default is 0).
+
+        Methods
+        -------
+        load_fits_file()
+            Load the FITS file and auxiliary file (if provided).
+        save_fits_file()
+            Save the cleaned data to a FITS file.
+        create_widgets()
+            Create the GUI widgets.
+        run_lacosmic()
+            Run the L.A.Cosmic algorithm.
+        toggle_cr_overlay()
+            Toggle the overlay of cosmic ray pixels on the image.
+        update_cr_overlay()
+            Update the overlay of cosmic ray pixels on the image.
+        apply_lacosmic()
+            Apply the L.A.Cosmic algorithm to the data.
+        examine_detected_cr()
+            Examine detected cosmic rays.
+        stop_app()
+            Stop the application.
+        on_key(event)
+            Handle key press events.
+        on_click(event)
+            Handle mouse click events.
+
+        Attributes
+        ----------
+        root : tk.Tk
+            The main Tkinter window.
+        lacosmic_params : dict
+            Dictionary of L.A.Cosmic parameters.
+        input_fits : str
+            Path to the FITS file to be cleaned.
+        extension : int
+            FITS extension to use.
+        data : np.ndarray
+            The image data from the FITS file.
+        auxfile : str
+            Path to an auxiliary FITS file.
+        extension_auxfile : int
+            FITS extension for auxiliary file.
+        auxdata : np.ndarray
+            The image data from the auxiliary FITS file.
+        overplot_cr_pixels : bool
+            Flag to indicate whether to overlay cosmic ray pixels.
+        mask_crfound : np.ndarray
+            Boolean mask of detected cosmic ray pixels.
+        last_xmin : int
+            Last used minimum x-coordinate for region selection.
+        last_xmax : int
+            Last used maximum x-coordinate for region selection.
+        last_ymin : int
+            Last used minimum y-coordinate for region selection.
+        last_ymax : int
+            Last used maximum y-coordinate for region selection.
+        last_npoints : int
+            Last used number of points for interpolation.
+        last_degree : int
+            Last used degree for interpolation.
+        cleandata_lacosmic : np.ndarray
+            The cleaned data returned from L.A.Cosmic.
+        cr_labels : np.ndarray
+            Labeled cosmic ray features.
+        num_features : int
+            Number of detected cosmic ray features.
+        working_in_review_window : bool
+            Flag to indicate if the review window is active.
         """
         self.root = root
         self.root.title("Cosmic Ray Cleaner")
         self.root.geometry("800x700+50+0")
+        self.lacosmic_params = lacosmic_default_dict.copy()
         self.input_fits = input_fits
         self.extension = extension
-        self.output_fits = output_fits
+        self.data = None
+        self.auxfile = auxfile
+        self.extension_auxfile = extension_auxfile
+        self.auxdata = None
+        self.overplot_cr_pixels = True
+        self.mask_crfound = None
         self.load_fits_file()
+        self.last_xmin = 1
+        self.last_xmax = self.data.shape[1]
+        self.last_ymin = 1
+        self.last_ymax = self.data.shape[0]
+        self.last_npoints = DEFAULT_NPOINTS_INTERP
+        self.last_degree = DEFAULT_DEGREE_INTERP
         self.create_widgets()
+        self.cleandata_lacosmic = None
+        self.cr_labels = None
+        self.num_features = 0
+        self.working_in_review_window = False
 
     def load_fits_file(self):
+        """Load the FITS file and auxiliary file (if provided).
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method loads the FITS file specified by `self.input_fits` and
+        reads the data from the specified extension. If an auxiliary file is
+        provided, it also loads the auxiliary data from the specified extension.
+        The loaded data is stored in `self.data` and `self.auxdata` attributes.
+        """
         try:
             with fits.open(self.input_fits, mode='readonly') as hdul:
                 self.data = hdul[self.extension].data
@@ -68,14 +181,45 @@ class CosmicRayCleanerApp():
                     self.mask_fixed = np.zeros(self.data.shape, dtype=bool)
         except Exception as e:
             print(f"Error loading FITS file: {e}")
+        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:
+            try:
+                with fits.open(self.auxfile, mode='readonly') as hdul_aux:
+                    self.auxdata = hdul_aux[self.extension_auxfile].data
+                    if self.auxdata.shape != self.data.shape:
+                        print(f"data shape...: {self.data.shape}")
+                        print(f"auxdata shape: {self.auxdata.shape}")
+                        raise ValueError("Auxiliary file has different shape.")
+            except Exception as e:
+                sys.exit(f"Error loading auxiliary FITS file: {e}")
 
     def save_fits_file(self):
-        if self.output_fits is None:
-            base, ext = os.path.splitext(self.input_fits)
-            suggested_name = f"{base}_cleaned"
-        else:
-            suggested_name, _ = os.path.splitext(self.output_fits)
-        self.output_fits = filedialog.asksaveasfilename(
+        """Save the cleaned FITS file.
+
+        This method prompts the user to select a location and filename to
+        save the cleaned FITS file. It writes the cleaned data and
+        the cosmic ray mask to the specified FITS file.
+
+        If the initial file contains a 'CRMASK' extension, it updates
+        that extension with the new mask. Otherwise, it creates a new
+        'CRMASK' extension to store the mask.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        After successfully saving the cleaned FITS file, the chosen output
+        filename is stored in `self.input_fits`, and the save button is disabled
+        to prevent multiple saves without further modifications.
+        """
+        base, ext = os.path.splitext(self.input_fits)
+        suggested_name = f"{base}_cleaned"
+        output_fits = filedialog.asksaveasfilename(
             initialdir=os.getcwd(),
             title="Save cleaned FITS file",
             defaultextension=".fits",
@@ -90,114 +234,471 @@ class CosmicRayCleanerApp():
                 else:
                     crmask_hdu = fits.ImageHDU(self.mask_fixed.astype(np.uint8), name='CRMASK')
                     hdul.append(crmask_hdu)
-                hdul.writeto(self.output_fits, overwrite=True)
-            print(f"Cleaned data saved to {self.output_fits}")
+                hdul.writeto(output_fits, overwrite=True)
+            print(f"Cleaned data saved to {output_fits}")
+            self.ax.set_title(os.path.basename(output_fits))
+            self.canvas.draw_idle()
+            self.input_fits = os.path.basename(output_fits)
+            self.save_button.config(state=tk.DISABLED)
         except Exception as e:
             print(f"Error saving FITS file: {e}")
 
     def create_widgets(self):
-        # Row 1
+        """Create the GUI widgets.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method sets up the GUI layout, including buttons for running
+        L.A.Cosmic, toggling cosmic ray overlay, applying cleaning methods,
+        examining detected cosmic rays, saving the cleaned FITS file, and
+        stopping the application. It also initializes the matplotlib figure
+        and canvas for image display, along with the toolbar for navigation.
+        The relevant attributes are stored in the instance for later use.
+        """
+        # Row 1 of buttons
         self.button_frame1 = tk.Frame(self.root)
-        self.button_frame1.grid(row=0, column=0, pady=5)
+        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)
-        self.save_button = tk.Button(self.button_frame1, text="Save cleaned FITS", command=self.save_fits_file)
-        self.save_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.button_frame1, text="Replace all 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.examine_detected_cr_button = tk.Button(self.button_frame1, text="Examine detected CRs",
+                                                    command=lambda: self.examine_detected_cr(1))
+        self.examine_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        self.examine_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
 
-        # Row 2
+        # Row 2 of buttons
         self.button_frame2 = tk.Frame(self.root)
-        self.button_frame2.grid(row=1, column=0, pady=5)
-        vmin, vmax = zscale(self.data)
-        self.vmin_button = tk.Button(self.button_frame2, text=f"vmin: {vmin:.2f}", command=self.set_vmin)
-        self.vmin_button.pack(side=tk.LEFT, padx=5)
-        self.vmax_button = tk.Button(self.button_frame2, text=f"vmax: {vmax:.2f}", command=self.set_vmax)
-        self.vmax_button.pack(side=tk.LEFT, padx=5)
+        self.button_frame2.pack(pady=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
         self.stop_button = tk.Button(self.button_frame2, text="Stop program", command=self.stop_app)
         self.stop_button.pack(side=tk.LEFT, padx=5)
 
-        # Main frame for figure and toolbar
-        self.main_frame = tk.Frame(self.root)
-        self.main_frame.grid(row=2, column=0, sticky="nsew")
-        self.root.grid_rowconfigure(2, weight=1)
-        self.root.grid_columnconfigure(0, weight=1)
-        self.main_frame.grid_rowconfigure(0, weight=1)
-        self.main_frame.grid_columnconfigure(0, weight=1)
-
-        # Create figure and axis
-        self.fig, self.ax = plt.subplots(figsize=(8, 6))
-        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, _, _ = imshow(self.fig, self.ax, self.data, vmin=vmin, vmax=vmax,
-                                  xlabel=xlabel, ylabel=ylabel, extent=extent)
-        # Note: tight_layout should be called before defining the canvas
-        self.fig.tight_layout()
+        # Row 3 of buttons
+        self.button_frame3 = tk.Frame(self.root)
+        self.button_frame3.pack(pady=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)
+        self.vmax_button = tk.Button(self.button_frame3, text=f"vmax: {vmax:.2f}", command=self.set_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.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)
 
-        # Create canvas and toolbar
-        self.canvas = FigureCanvasTkAgg(self.fig, master=self.main_frame)
+        # Figure
+        self.fig, self.ax = plt.subplots(figsize=(7, 5.5))
+        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"
         self.canvas.mpl_disconnect(self.canvas.mpl_connect("key_press_event", key_press_handler))
         self.canvas.mpl_connect("key_press_event", self.on_key)
         self.canvas.mpl_connect("button_press_event", self.on_click)
         canvas_widget = self.canvas.get_tk_widget()
-        canvas_widget.grid(row=0, column=0, sticky="nsew")
+        canvas_widget.pack(fill=tk.BOTH, expand=True)
 
         # Matplotlib toolbar
-        self.toolbar_frame = tk.Frame(self.main_frame)
-        self.toolbar_frame.grid(row=1, column=0, sticky="ew")
+        self.toolbar_frame = tk.Frame(self.root)
+        self.toolbar_frame.pack(fill=tk.X, expand=False, pady=5)
         self.toolbar = NavigationToolbar2Tk(self.canvas, self.toolbar_frame)
         self.toolbar.update()
 
-    def set_vmin(self):
-        old_vmin = self.get_vmin()
-        new_vmin = simpledialog.askfloat("Set vmin", "Enter new vmin:", initialvalue=old_vmin)
-        if new_vmin is None:
-            return
-        self.vmin_button.config(text=f"vmin: {new_vmin:.2f}")
-        self.image.set_clim(vmin=new_vmin)
-        self.canvas.draw()
-
-    def set_vmax(self):
-        old_vmax = self.get_vmax()
-        new_vmax = simpledialog.askfloat("Set vmax", "Enter new vmax:", initialvalue=old_vmax)
-        if new_vmax is None:
-            return
-        self.vmax_button.config(text=f"vmax: {new_vmax:.2f}")
-        self.image.set_clim(vmax=new_vmax)
-        self.canvas.draw()
-
-    def get_vmin(self):
-        return float(self.vmin_button.cget("text").split(":")[1])
-
-    def get_vmax(self):
-        return float(self.vmax_button.cget("text").split(":")[1])
+        # update the image display
+        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, _, _ = imshow(self.fig, self.ax, self.data, vmin=vmin, vmax=vmax,
+                                  title=os.path.basename(self.input_fits),
+                                  xlabel=xlabel, ylabel=ylabel,
+                                  extent=extent)
+        self.fig.tight_layout()
 
     def run_lacosmic(self):
+        """Run L.A.Cosmic to detect cosmic rays."""
         self.run_lacosmic_button.config(state=tk.DISABLED)
-        self.stop_button.config(state=tk.DISABLED)
-        # Parameters for L.A.Cosmic can be adjusted as needed
-        _, mask_crfound = cosmicray_lacosmic(self.data, sigclip=4.5, sigfrac=0.3, objlim=5.0, verbose=True)
-        ReviewCosmicRay(
-            root=self.root,
-            data=self.data,
-            mask_fixed=self.mask_fixed,
-            mask_crfound=mask_crfound
+        # Define parameters for L.A.Cosmic from default dictionary
+        editor_window = tk.Toplevel(self.root)
+        editor = ParameterEditor(
+            root=editor_window,
+            param_dict=self.lacosmic_params,
+            window_title='Cosmic Ray Mask Generation Parameters',
+            xmin=self.last_xmin,
+            xmax=self.last_xmax,
+            ymin=self.last_ymin,
+            ymax=self.last_ymax,
+            imgshape=self.data.shape
         )
-        print("L.A.Cosmic cleaning applied.")
+        # Make it modal (blocks interaction with main window)
+        editor_window.transient(self.root)
+        editor_window.grab_set()
+        # Wait for the editor window to close
+        self.root.wait_window(editor_window)
+        # Get the result after window closes
+        updated_params = editor.get_result()
+        if updated_params is not None:
+            # Update last used region values
+            self.last_xmin = updated_params['xmin']['value']
+            self.last_xmax = updated_params['xmax']['value']
+            self.last_ymin = updated_params['ymin']['value']
+            self.last_ymax = updated_params['ymax']['value']
+            # 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']}")
+            # Execute L.A.Cosmic with updated parameters
+            cleandata_lacosmic, mask_crfound = cosmicray_lacosmic(
+                self.data,
+                gain=self.lacosmic_params['gain']['value'],
+                readnoise=self.lacosmic_params['readnoise']['value'],
+                sigclip=self.lacosmic_params['sigclip']['value'],
+                sigfrac=self.lacosmic_params['sigfrac']['value'],
+                objlim=self.lacosmic_params['objlim']['value'],
+                niter=self.lacosmic_params['niter']['value'],
+                verbose=self.lacosmic_params['verbose']['value']
+            )
+            # Select the image region to process
+            fits_region = f"[{updated_params['xmin']['value']}:{updated_params['xmax']['value']}"
+            fits_region += f",{updated_params['ymin']['value']}:{updated_params['ymax']['value']}]"
+            region = SliceRegion2D(fits_region, mode="fits").python
+            self.cleandata_lacosmic = self.data.copy()
+            self.cleandata_lacosmic[region] = cleandata_lacosmic[region]
+            self.mask_crfound = np.zeros_like(self.data, dtype=bool)
+            self.mask_crfound[region] = mask_crfound[region]
+            # Process the mask: dilation and labeling
+            if np.any(self.mask_crfound):
+                num_cr_pixels_before_dilation = np.sum(self.mask_crfound)
+                dilation = self.lacosmic_params['dilation']['value']
+                if dilation > 0:
+                    # Dilate the mask by the specified number of pixels
+                    structure = ndimage.generate_binary_structure(2, 2)  # 8-connectivity
+                    self.mask_crfound = ndimage.binary_dilation(
+                        self.mask_crfound,
+                        structure=structure,
+                        iterations=self.lacosmic_params['dilation']['value']
+                    )
+                    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 rays features (grouped pixels)...: {self.num_features:{len(sdum)}}")
+                self.apply_lacosmic_button.config(state=tk.NORMAL)
+                self.examine_detected_cr_button.config(state=tk.NORMAL)
+                self.update_cr_overlay()
+            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)
+        else:
+            print("Parameter editing cancelled. L.A.Cosmic detection skipped!")
         self.run_lacosmic_button.config(state=tk.NORMAL)
-        self.stop_button.config(state=tk.NORMAL)
+
+    def toggle_cr_overlay(self):
+        """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")
+        else:
+            self.overplot_cr_button.config(text="CR overlay: Off")
+        self.update_cr_overlay()
+
+    def update_cr_overlay(self):
+        """Update the overlay of cosmic ray pixels on the image."""
+        if self.overplot_cr_pixels:
+            # Remove previous CR pixel overlay (if any)
+            if hasattr(self, 'scatter_cr'):
+                self.scatter_cr.remove()
+                del self.scatter_cr
+            # Overlay CR pixels in red
+            if np.any(self.mask_crfound):
+                y_indices, x_indices = np.where(self.mask_crfound)
+                self.scatter_cr = self.ax.scatter(x_indices + 1, y_indices + 1, s=1, c='red', marker='o')
+        else:
+            # Remove CR pixel overlay
+            if hasattr(self, 'scatter_cr'):
+                self.scatter_cr.remove()
+                del self.scatter_cr
+        self.canvas.draw_idle()
+
+    def apply_lacosmic(self):
+        """Apply the selected cleaning method to the detected cosmic rays."""
+        if np.any(self.mask_crfound):
+            # recalculate labels and number of features
+            structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+            self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
+            print(f"Number of cosmic ray pixels detected by L.A.Cosmic...........: {np.sum(self.mask_crfound)}")
+            print(f"Number of cosmic rays (grouped pixels) detected by L.A.Cosmic: {self.num_features}")
+            # Define parameters for L.A.Cosmic from default dictionary
+            editor_window = tk.Toplevel(self.root)
+            editor = InterpolationEditor(
+                root=editor_window,
+                last_dilation=self.lacosmic_params['dilation']['value'],
+                last_npoints=self.last_npoints,
+                last_degree=self.last_degree,
+                auxdata=self.auxdata
+            )
+            # Make it modal (blocks interaction with main window)
+            editor_window.transient(self.root)
+            editor_window.grab_set()
+            # Wait for the editor window to close
+            self.root.wait_window(editor_window)
+            # Get the result after window closes
+            cleaning_method = editor.cleaning_method
+            num_cr_cleaned = 0
+            if cleaning_method is None:
+                print("Interpolation method selection cancelled. No cleaning applied!")
+                return
+            self.last_npoints = editor.npoints
+            self.last_degree = editor.degree
+            if cleaning_method == 'lacosmic':
+                # Replace all detected CR pixels with L.A.Cosmic values
+                self.data[self.mask_crfound] = self.cleandata_lacosmic[self.mask_crfound]
+                # update mask_fixed to include the newly fixed pixels
+                self.mask_fixed[self.mask_crfound] = True
+                # upate mask_crfound by eliminating the cleaned pixels
+                self.mask_crfound[self.mask_crfound] = False
+                num_cr_cleaned = self.num_features
+            elif cleaning_method == 'auxdata':
+                if self.auxdata is None:
+                    print("No auxiliary data available. Cleaning skipped!")
+                    return
+                # Replace all detected CR pixels with auxiliary data values
+                self.data[self.mask_crfound] = self.auxdata[self.mask_crfound]
+                # update mask_fixed to include the newly fixed pixels
+                self.mask_fixed[self.mask_crfound] = True
+                # upate mask_crfound by eliminating the cleaned pixels
+                self.mask_crfound[self.mask_crfound] = False
+                num_cr_cleaned = self.num_features
+            else:
+                for i in range(1, self.num_features + 1):
+                    tmp_mask_fixed = np.zeros_like(self.data, dtype=bool)
+                    if cleaning_method == 'x':
+                        interpolation_performed, _, _ = interpolation_x(
+                            data=self.data,
+                            mask_fixed=tmp_mask_fixed,
+                            cr_labels=self.cr_labels,
+                            cr_index=i,
+                            npoints=editor.npoints,
+                            degree=editor.degree
+                        )
+                    elif cleaning_method == 'y':
+                        interpolation_performed, _, _ = interpolation_y(
+                            data=self.data,
+                            mask_fixed=tmp_mask_fixed,
+                            cr_labels=self.cr_labels,
+                            cr_index=i,
+                            npoints=editor.npoints,
+                            degree=editor.degree
+                        )
+                    elif cleaning_method == 'a-plane':
+                        interpolation_performed, _, _ = interpolation_a(
+                            data=self.data,
+                            mask_fixed=tmp_mask_fixed,
+                            cr_labels=self.cr_labels,
+                            cr_index=i,
+                            npoints=editor.npoints,
+                            method='surface'
+                        )
+                    elif cleaning_method == 'a-median':
+                        interpolation_performed, _, _ = interpolation_a(
+                            data=self.data,
+                            mask_fixed=tmp_mask_fixed,
+                            cr_labels=self.cr_labels,
+                            cr_index=i,
+                            npoints=editor.npoints,
+                            method='median'
+                        )
+                    else:
+                        raise ValueError(f"Unknown cleaning method: {cleaning_method}")
+                    if interpolation_performed:
+                        num_cr_cleaned += 1
+                        # update mask_fixed to include the newly fixed pixels
+                        self.mask_fixed[tmp_mask_fixed] = True
+                        # upate mask_crfound by eliminating the cleaned pixels
+                        self.mask_crfound[tmp_mask_fixed] = False
+            print(f"Number of cosmic rays identified and cleaned: {num_cr_cleaned}")
+            # recalculate labels and number of features
+            structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+            self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
+            print(f"Remaining number of cosmic ray pixels...........: {np.sum(self.mask_crfound)}")
+            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features}")
+            # redraw image to show the changes
+            self.image.set_data(self.data)
+            self.canvas.draw_idle()
+            if 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.apply_lacosmic_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):
+        """Open a window to examine and possibly clean detected cosmic rays."""
+        self.working_in_review_window = True
+        review_window = tk.Toplevel(self.root)
+        if ixpix is not None and iypix is not None:
+            # select single pixel based on provided coordinates
+            tmp_cr_labels = np.zeros_like(self.data, dtype=int)
+            tmp_cr_labels[iypix - 1, ixpix - 1] = 1
+            review = ReviewCosmicRay(
+                root=review_window,
+                data=self.data,
+                auxdata=self.auxdata,
+                cleandata_lacosmic=self.cleandata_lacosmic,
+                cr_labels=tmp_cr_labels,
+                num_features=1,
+                first_cr_index=1,
+                single_cr=True,
+                last_dilation=self.lacosmic_params['dilation']['value'],
+                last_npoints=self.last_npoints,
+                last_degree=self.last_degree
+            )
+        else:
+            review = ReviewCosmicRay(
+                root=review_window,
+                data=self.data,
+                auxdata=self.auxdata,
+                cleandata_lacosmic=self.cleandata_lacosmic,
+                cr_labels=self.cr_labels,
+                num_features=self.num_features,
+                first_cr_index=first_cr_index,
+                single_cr=single_cr,
+                last_dilation=self.lacosmic_params['dilation']['value'],
+                last_npoints=self.last_npoints,
+                last_degree=self.last_degree
+            )
+        # Make it modal (blocks interaction with main window)
+        review_window.transient(self.root)
+        review_window.grab_set()
+        self.root.wait_window(review_window)
+        self.working_in_review_window = False
+        # Get the result after window closes
+        if review.num_cr_cleaned > 0:
+            self.last_npoints = review.npoints
+            self.last_degree = review.degree
+            print(f"Number of cosmic rays identified and cleaned: {review.num_cr_cleaned}")
+            # update mask_fixed to include the newly fixed pixels
+            self.mask_fixed[review.mask_fixed] = True
+            # upate mask_crfound by eliminating the cleaned pixels
+            self.mask_crfound[review.mask_fixed] = False
+            # recalculate labels and number of features
+            structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+            self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
+            print(f"Remaining number of cosmic ray pixels...........: {np.sum(self.mask_crfound)}")
+            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features}")
+            # redraw image to show the changes
+            self.image.set_data(self.data)
+            self.canvas.draw_idle()
+        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.apply_lacosmic_button.config(state=tk.DISABLED)
+        self.update_cr_overlay()
 
     def stop_app(self):
-        self.root.quit()
-        self.root.destroy()
+        """Stop the application, prompting to save if there are unsaved changes."""
+        proceed_with_stop = True
+        if self.save_button['state'] == tk.NORMAL:
+            print("Warning: There are unsaved changes!")
+            proceed_with_stop = messagebox.askyesno(
+                "Unsaved Changes",
+                "You have unsaved changes.\nDo you really want to quit?",
+                default=messagebox.NO
+            )
+        if proceed_with_stop:
+            self.root.quit()
+            self.root.destroy()
 
     def on_key(self, event):
+        """Handle key press events."""
         if event.key == 'q':
             pass  # Ignore the "q" key to prevent closing the window
+        elif event.key == ',':
+            self.set_minmax()
+        elif event.key == '/':
+            self.set_zscale()
         else:
             print(f"Key pressed: {event.key}")
 
     def on_click(self, event):
-        if event.inaxes:
+        """Handle mouse click events on the image."""
+        # ignore clicks if we are working in the review window
+        if self.working_in_review_window:
+            print("Currently working in review window; click ignored.")
+            return
+
+        # check the toolbar is not active
+        toolbar = self.fig.canvas.toolbar
+        if toolbar.mode != "":
+            print(f"Toolbar mode '{toolbar.mode}' active; click ignored.")
+            return
+
+        # ignore clicks outside the expected axes
+        # (note that the color bar is a different axes)
+        if event.inaxes == self.ax:
             x, y = event.xdata, event.ydata
-            print(f"Clicked at image coordinates: ({x:.2f}, {y:.2f})")
+            ix = int(x + 0.5)
+            iy = int(y + 0.5)
+            print(f"Clicked at image coordinates: ({ix}, {iy})")
+            label_at_click = 0
+            if self.mask_crfound is None:
+                print("No cosmic ray pixels detected (mask_crfound is None)")
+            elif not np.any(self.mask_crfound):
+                print("No remaining cosmic ray pixels in mask_crfound")
+            else:
+                label_at_click = self.cr_labels[iy - 1, ix - 1]
+                if label_at_click == 0:
+                    (closest_x, closest_y), min_distance = find_closest_true(self.mask_crfound, ix - 1, iy - 1)
+                    if closest_x is None and closest_y is None:
+                        print("No remaining cosmic ray pixels")
+                    elif min_distance > MAX_PIXEL_DISTANCE_TO_CR * 1.4142135:
+                        print("No nearby cosmic ray pixels found in searching square")
+                    else:
+                        label_at_click = self.cr_labels[closest_y, closest_x]
+                        print(f"Clicked pixel is part of cosmic ray number {label_at_click}.")
+            if label_at_click == 0:
+                # Find pixel with maximum value within a square region around the click
+                semiwidth = MAX_PIXEL_DISTANCE_TO_CR
+                jmin = (ix - 1) - semiwidth if (ix - 1) - semiwidth >= 0 else 0
+                jmax = (ix - 1) + semiwidth if (ix - 1) + semiwidth < self.data.shape[1] else self.data.shape[1] - 1
+                imin = (iy - 1) - semiwidth if (iy - 1) - semiwidth >= 0 else 0
+                imax = (iy - 1) + semiwidth if (iy - 1) + semiwidth < self.data.shape[0] else self.data.shape[0] - 1
+                ijmax = np.unravel_index(
+                    np.argmax(self.data[imin:imax+1, jmin:jmax+1]),
+                    self.data[imin:imax+1, jmin:jmax+1].shape
+                )
+                ixpix = ijmax[1] + jmin + 1
+                iypix = ijmax[0] + imin + 1
+            else:
+                ixpix = None
+                iypix = None
+            self.examine_detected_cr(label_at_click, single_cr=True, ixpix=ixpix, iypix=iypix)