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

teareduce/cleanest/cosmicraycleanerapp.py

@@ -11,24 +11,30 @@
 
 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
 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 tqdm import tqdm
 
+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 MAX_PIXEL_DISTANCE_TO_CR
+from .definitions import DEFAULT_TK_WINDOW_SIZE_X
+from .definitions import DEFAULT_TK_WINDOW_SIZE_Y
+from .definitions import DEFAULT_FONT_FAMILY
+from .definitions import DEFAULT_FONT_SIZE
 from .dilatemask import dilatemask
 from .find_closest_true import find_closest_true
 from .interpolation_a import interpolation_a
@@ -36,21 +42,37 @@ 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
 
 from ..imshow import imshow
 from ..sliceregion import SliceRegion2D
 from ..zscale import zscale
 
 import matplotlib
+
 matplotlib.use("TkAgg")
 
 
 class CosmicRayCleanerApp(ImageDisplay):
     """Main application class for cosmic ray cleaning."""
 
-    def __init__(self, root, input_fits, extension=0, auxfile=None, extension_auxfile=0):
+    def __init__(
+        self,
+        root,
+        input_fits,
+        extension="0",
+        auxfile=None,
+        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.
 
@@ -60,15 +82,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()
@@ -96,6 +132,18 @@ class CosmicRayCleanerApp(ImageDisplay):
         ----------
         root : tk.Tk
             The main Tkinter window.
+        fontfamily : str
+            Font family for the GUI.
+        fontsize : int
+            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
@@ -116,12 +164,16 @@ class CosmicRayCleanerApp(ImageDisplay):
             Boolean mask of detected cosmic ray pixels.
         last_xmin : int
             Last used minimum x-coordinate for region selection.
+            From 1 to NAXIS1.
         last_xmax : int
             Last used maximum x-coordinate for region selection.
+            From 1 to NAXIS1.
         last_ymin : int
             Last used minimum y-coordinate for region selection.
+            From 1 to NAXIS2.
         last_ymax : int
             Last used maximum y-coordinate for region selection.
+            From 1 to NAXIS2.
         last_npoints : int
             Last used number of points for interpolation.
         last_degree : int
@@ -137,11 +189,21 @@ class CosmicRayCleanerApp(ImageDisplay):
         """
         self.root = root
         # self.root.geometry("800x800+50+0")  # This does not work in Fedora
-        self.root.minsize(800, 800)
+        self.width = width
+        self.height = height
+        self.verbose = verbose
+        self.root.minsize(self.width, self.height)
         self.root.update_idletasks()
-        self.root.geometry("+50+0")
         self.root.title("Cosmic Ray Cleaner")
+        self.fontfamily = fontfamily
+        self.fontsize = fontsize
+        self.default_font = tkfont.nametofont("TkDefaultFont")
+        self.default_font.configure(
+            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
@@ -163,6 +225,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).
 
@@ -177,22 +326,51 @@ 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:
-            with fits.open(self.input_fits, mode='readonly') as hdul:
+            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)
+                if "CRMASK" in hdul:
+                    self.mask_fixed = hdul["CRMASK"].data.astype(bool)
                 else:
                     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
+        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:
-                with fits.open(self.auxfile, mode='readonly') as hdul_aux:
+                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}")
@@ -229,15 +407,15 @@ class CosmicRayCleanerApp(ImageDisplay):
             title="Save cleaned FITS file",
             defaultextension=".fits",
             filetypes=[("FITS files", "*.fits"), ("All files", "*.*")],
-            initialfile=suggested_name
+            initialfile=suggested_name,
         )
         try:
-            with fits.open(self.input_fits, mode='readonly') as hdul:
+            with fits.open(self.input_fits, mode="readonly") as hdul:
                 hdul[self.extension].data = self.data
-                if 'CRMASK' in hdul:
-                    hdul['CRMASK'].data = self.mask_fixed.astype(np.uint8)
+                if "CRMASK" in hdul:
+                    hdul["CRMASK"].data = self.mask_fixed.astype(np.uint8)
                 else:
-                    crmask_hdu = fits.ImageHDU(self.mask_fixed.astype(np.uint8), name='CRMASK')
+                    crmask_hdu = fits.ImageHDU(self.mask_fixed.astype(np.uint8), name="CRMASK")
                     hdul.append(crmask_hdu)
                 hdul.writeto(output_fits, overwrite=True)
             print(f"Cleaned data saved to {output_fits}")
@@ -269,25 +447,35 @@ 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.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.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.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.examine_detected_cr_button.pack(side=tk.LEFT, padx=5)
         self.examine_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.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
@@ -297,6 +485,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)
@@ -306,18 +497,37 @@ 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.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)
+        self.plot_frame = tk.Frame(self.root)
+        self.plot_frame.pack(padx=5, pady=5, fill=tk.BOTH, expand=True)
+        fig_dpi = 100
+        image_ratio = 480 / 640  # Default image ratio
+        fig_width_inches = self.width / fig_dpi
+        fig_height_inches = self.height * image_ratio / fig_dpi
+        self.fig, self.ax = plt.subplots(figsize=(fig_width_inches, fig_height_inches), dpi=fig_dpi)
+        self.canvas = FigureCanvasTkAgg(self.fig, master=self.plot_frame)
+        canvas_widget = self.canvas.get_tk_widget()
+        canvas_widget.config(width=self.width, height=self.height * image_ratio)
+        canvas_widget.pack(expand=True)
         # 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.pack(fill=tk.BOTH, expand=True)  # This does not work in Fedora
-        canvas_widget.pack(expand=True)
 
         # Matplotlib toolbar
         self.toolbar_frame = tk.Frame(self.root)
@@ -326,29 +536,81 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.toolbar.update()
 
         # update the image display
-        xlabel = 'X pixel (from 1 to NAXIS1)'
-        ylabel = 'Y pixel (from 1 to NAXIS2)'
+        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.image_aspect = "equal"
+        self.displaying_auxdata = False
+        self.image, _, _ = imshow(
+            fig=self.fig,
+            ax=self.ax,
+            data=self.data,
+            vmin=vmin,
+            vmax=vmax,
+            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)
         # Define parameters for L.A.Cosmic from default dictionary
         editor_window = tk.Toplevel(self.root)
+        center_on_parent(child=editor_window, parent=self.root)
         editor = ParameterEditor(
             root=editor_window,
             param_dict=self.lacosmic_params,
-            window_title='Cosmic Ray Mask Generation Parameters',
+            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
+            imgshape=self.data.shape,
         )
         # Make it modal (blocks interaction with main window)
         editor_window.transient(self.root)
@@ -359,46 +621,53 @@ class CosmicRayCleanerApp(ImageDisplay):
         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']
-            usefulregion = SliceRegion2D(f"[{self.last_xmin}:{self.last_xmax},{self.last_ymin}:{self.last_ymax}]",
-                                         mode="fits").python
+            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"]
+            usefulregion = SliceRegion2D(
+                f"[{self.last_xmin}:{self.last_xmax},{self.last_ymin}:{self.last_ymax}]", mode="fits"
+            ).python
             usefulmask = np.zeros_like(self.data)
             usefulmask[usefulregion] = 1.0
             # Update parameter dictionary with new values
             self.lacosmic_params = updated_params
-            print("Parameters updated:")
-            for key, info in self.lacosmic_params.items():
-                print(f"  {key}: {info['value']}")
-            if self.lacosmic_params['nruns']['value'] not in [1, 2]:
+            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
-            cleandata_lacosmic, mask_crfound = cosmicray_lacosmic(
-                self.data,
-                gain=self.lacosmic_params['run1_gain']['value'],
-                readnoise=self.lacosmic_params['run1_readnoise']['value'],
-                sigclip=self.lacosmic_params['run1_sigclip']['value'],
-                sigfrac=self.lacosmic_params['run1_sigfrac']['value'],
-                objlim=self.lacosmic_params['run1_objlim']['value'],
-                niter=self.lacosmic_params['run1_niter']['value'],
-                verbose=self.lacosmic_params['run1_verbose']['value']
+            print("[bold green]Executing L.A.Cosmic (run 1)...[/bold green]")
+            borderpadd = updated_params["borderpadd"]["value"]
+            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"],
+                sigfrac=self.lacosmic_params["run1_sigfrac"]["value"],
+                objlim=self.lacosmic_params["run1_objlim"]["value"],
+                niter=self.lacosmic_params["run1_niter"]["value"],
+                verbose=self.lacosmic_params["run1_verbose"]["value"],
             )
             # Apply usefulmask to consider only selected region
             cleandata_lacosmic *= usefulmask
             mask_crfound = mask_crfound & (usefulmask.astype(bool))
             # Second execution if nruns == 2
-            if self.lacosmic_params['nruns']['value'] == 2:
-                cleandata_lacosmic2, mask_crfound2 = cosmicray_lacosmic(
-                    self.data,
-                    gain=self.lacosmic_params['run2_gain']['value'],
-                    readnoise=self.lacosmic_params['run2_readnoise']['value'],
-                    sigclip=self.lacosmic_params['run2_sigclip']['value'],
-                    sigfrac=self.lacosmic_params['run2_sigfrac']['value'],
-                    objlim=self.lacosmic_params['run2_objlim']['value'],
-                    niter=self.lacosmic_params['run2_niter']['value'],
-                    verbose=self.lacosmic_params['run2_verbose']['value']
+            if self.lacosmic_params["nruns"]["value"] == 2:
+                print("[bold green]Executing L.A.Cosmic (run 2)...[/bold green]")
+                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"],
+                    sigfrac=self.lacosmic_params["run2_sigfrac"]["value"],
+                    objlim=self.lacosmic_params["run2_objlim"]["value"],
+                    niter=self.lacosmic_params["run2_niter"]["value"],
+                    verbose=self.lacosmic_params["run2_verbose"]["value"],
                 )
                 # Apply usefulmask to consider only selected region
                 cleandata_lacosmic2 *= usefulmask
@@ -407,20 +676,8 @@ 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
-                    print(f'Number of cosmic ray pixels (run1 & run2): {np.sum(mask_crfound)}')
+                    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
             # Select the image region to process
@@ -429,40 +686,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 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)
+            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)
@@ -471,25 +695,25 @@ 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):
         """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'):
+            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')
+                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'):
+            if hasattr(self, "scatter_cr"):
                 self.scatter_cr.remove()
                 del self.scatter_cr
         self.canvas.draw_idle()
@@ -498,21 +722,25 @@ class CosmicRayCleanerApp(ImageDisplay):
         """Apply the selected cleaning method to the detected cosmic rays."""
         if np.any(self.mask_crfound):
             # recalculate labels and number of features
-            structure = [[1, 1, 1],
-                         [1, 1, 1],
-                         [1, 1, 1]]
+            structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
             self.cr_labels, self.num_features = ndimage.label(self.mask_crfound, structure=structure)
             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)
             editor = InterpolationEditor(
                 root=editor_window,
-                last_dilation=self.lacosmic_params['dilation']['value'],
+                last_dilation=self.lacosmic_params["dilation"]["value"],
                 last_npoints=self.last_npoints,
                 last_degree=self.last_degree,
                 auxdata=self.auxdata,
+                xmin=self.last_xmin,
+                xmax=self.last_xmax,
+                ymin=self.last_ymin,
+                ymax=self.last_ymax,
+                imgshape=self.data.shape,
             )
             # Make it modal (blocks interaction with main window)
             editor_window.transient(self.root)
@@ -521,108 +749,134 @@ class CosmicRayCleanerApp(ImageDisplay):
             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
+            cleaning_region = SliceRegion2D(
+                f"[{editor.xmin}:{editor.xmax},{editor.ymin}:{editor.ymax}]", mode="fits"
+            ).python
+            print(
+                "Applying cleaning method to region "
+                f"x=[{editor.xmin},{editor.xmax}], y=[{editor.ymin},{editor.ymax}]"
+            )
+            mask_crfound_region = np.zeros_like(self.mask_crfound, dtype=bool)
+            mask_crfound_region[cleaning_region] = self.mask_crfound[cleaning_region]
+            data_has_been_modified = False
+            if np.any(mask_crfound_region):
+                if cleaning_method == "lacosmic":
+                    # Replace detected CR pixels with L.A.Cosmic values
+                    self.data[mask_crfound_region] = self.cleandata_lacosmic[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!")
+                        return
+                    # Replace detected CR pixels with auxiliary data values
+                    self.data[mask_crfound_region] = self.auxdata[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
+                else:
+                    # Determine features to process within the selected region
+                    features_in_region = np.unique(self.cr_labels[mask_crfound_region])
+                    with ModalProgressBar(
+                        parent=self.root, iterable=range(1, self.num_features + 1), desc="Cleaning cosmic rays"
+                    ) as pbar:
+                        for i in pbar:
+                            if i in features_in_region:
+                                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",
+                                    )
+                                elif cleaning_method == "a-mean":
+                                    interpolation_performed, _, _ = interpolation_a(
+                                        data=self.data,
+                                        mask_fixed=tmp_mask_fixed,
+                                        cr_labels=self.cr_labels,
+                                        cr_index=i,
+                                        npoints=editor.npoints,
+                                        method="mean",
+                                    )
+                                else:
+                                    raise ValueError(f"Unknown cleaning method: {cleaning_method}")
+                                if interpolation_performed:
+                                    # 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
+                                    # mark that data has been modified
+                                    data_has_been_modified = True
+            # If any pixels were cleaned, print message
+            if data_has_been_modified:
+                print("Cosmic ray cleaning applied.")
             else:
-                for i in tqdm(range(1, self.num_features + 1)):
-                    tmp_mask_fixed = np.zeros_like(self.data, dtype=bool)
-                    if cleaning_method == 'x':
-                        interpolation_performed, _, _ = interpolation_x(
-                            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'
-                        )
-                    elif cleaning_method == 'a-mean':
-                        interpolation_performed, _, _ = interpolation_a(
-                            data=self.data,
-                            mask_fixed=tmp_mask_fixed,
-                            cr_labels=self.cr_labels,
-                            cr_index=i,
-                            npoints=editor.npoints,
-                            method='mean'
-                        )
-                    else:
-                        raise ValueError(f"Unknown cleaning method: {cleaning_method}")
-                    if interpolation_performed:
-                        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}")
+                print("No cosmic ray pixels 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)
-            sdum = str(np.sum(self.mask_crfound))
-            print(f"Remaining number of cosmic ray pixels...........: {sdum}")
-            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features:>{len(sdum)}}")
+            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()
-            if num_cr_cleaned > 0:
+            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.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):
         """Open a window to examine and possibly clean detected cosmic rays."""
         self.working_in_review_window = True
         review_window = tk.Toplevel(self.root)
+        center_on_parent(child=review_window, parent=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)
@@ -636,9 +890,9 @@ class CosmicRayCleanerApp(ImageDisplay):
                 num_features=1,
                 first_cr_index=1,
                 single_cr=True,
-                last_dilation=self.lacosmic_params['dilation']['value'],
+                last_dilation=self.lacosmic_params["dilation"]["value"],
                 last_npoints=self.last_npoints,
-                last_degree=self.last_degree
+                last_degree=self.last_degree,
             )
         else:
             review = ReviewCosmicRay(
@@ -650,9 +904,9 @@ class CosmicRayCleanerApp(ImageDisplay):
                 num_features=self.num_features,
                 first_cr_index=first_cr_index,
                 single_cr=single_cr,
-                last_dilation=self.lacosmic_params['dilation']['value'],
+                last_dilation=self.lacosmic_params["dilation"]["value"],
                 last_npoints=self.last_npoints,
-                last_degree=self.last_degree
+                last_degree=self.last_degree,
             )
         # Make it modal (blocks interaction with main window)
         review_window.transient(self.root)
@@ -671,9 +925,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))
-            print(f"Remaining number of cosmic ray pixels...........: {sdum}")
-            print(f"Remaining number of cosmic rays (grouped pixels): {self.num_features:>{len(sdum)}}")
+            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()
@@ -681,18 +939,16 @@ 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):
         """Stop the application, prompting to save if there are unsaved changes."""
         proceed_with_stop = True
-        if self.save_button['state'] == tk.NORMAL:
+        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
+                "Unsaved Changes", "You have unsaved changes.\nDo you really want to quit?", default=messagebox.NO
             )
         if proceed_with_stop:
             self.root.quit()
@@ -700,14 +956,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
-        elif event.key == ',':
+        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 == '/':
+        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."""
@@ -722,6 +1003,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:
@@ -753,8 +1038,8 @@ class CosmicRayCleanerApp(ImageDisplay):
                 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
+                    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