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

teareduce/cleanest/cosmicraycleanerapp.py

@@ -11,6 +11,7 @@
 
 import tkinter as tk
 from tkinter import filedialog
+from tkinter import font as tkfont
 from tkinter import messagebox
 import sys
 
@@ -23,12 +24,16 @@ from scipy import ndimage
 import numpy as np
 import os
 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
@@ -38,19 +43,32 @@ from .interpolationeditor import InterpolationEditor
 from .imagedisplay import ImageDisplay
 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,
+    ):
         """
         Initialize the application.
 
@@ -66,6 +84,10 @@ class CosmicRayCleanerApp(ImageDisplay):
             Path to an auxiliary FITS file (default is None).
         extension_auxfile : int, 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).
 
         Methods
         -------
@@ -96,6 +118,12 @@ 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.
         lacosmic_params : dict
             Dictionary of L.A.Cosmic parameters.
         input_fits : str
@@ -116,12 +144,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,10 +169,17 @@ 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.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.input_fits = input_fits
         self.extension = extension
@@ -178,21 +217,21 @@ class CosmicRayCleanerApp(ImageDisplay):
         The loaded data is stored in `self.data` and `self.auxdata` attributes.
         """
         try:
-            with fits.open(self.input_fits, mode='readonly') as hdul:
+            with fits.open(self.input_fits, mode="readonly") as hdul:
                 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}")
         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:
             try:
-                with fits.open(self.auxfile, mode='readonly') as hdul_aux:
+                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}")
@@ -229,15 +268,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}")
@@ -270,18 +309,22 @@ class CosmicRayCleanerApp(ImageDisplay):
         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)
+            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 = 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 = tk.Button(
+            self.button_frame1, text="Replace detected CRs", command=self.apply_lacosmic
+        )
         self.apply_lacosmic_button.pack(side=tk.LEFT, padx=5)
         self.apply_lacosmic_button.config(state=tk.DISABLED)  # Initially disabled
-        self.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 = 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
 
@@ -308,16 +351,22 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.set_zscale_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,13 +375,20 @@ 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, _, _ = 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):
@@ -340,15 +396,16 @@ class CosmicRayCleanerApp(ImageDisplay):
         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,12 +416,13 @@ 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
@@ -372,34 +430,42 @@ class CosmicRayCleanerApp(ImageDisplay):
             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.lacosmic_params["nruns"]["value"] not in [1, 2]:
                 raise ValueError("nruns must be 1 or 2")
             # Execute L.A.Cosmic with updated parameters
+            print("[bold green]Executing L.A.Cosmic (run 1)...[/bold green]")
+            borderpadd = updated_params["borderpadd"]["value"]
+            data_reflection_padded = np.pad(self.data, pad_width=borderpadd, mode="reflect")
             cleandata_lacosmic, mask_crfound = cosmicray_lacosmic(
-                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']
+                ccd=data_reflection_padded,
+                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"],
             )
+            cleandata_lacosmic = cleandata_lacosmic[borderpadd:-borderpadd, borderpadd:-borderpadd]
+            mask_crfound = mask_crfound[borderpadd:-borderpadd, borderpadd:-borderpadd]
             # Apply usefulmask to consider only selected region
             cleandata_lacosmic *= usefulmask
             mask_crfound = mask_crfound & (usefulmask.astype(bool))
             # Second execution if nruns == 2
-            if self.lacosmic_params['nruns']['value'] == 2:
+            if self.lacosmic_params["nruns"]["value"] == 2:
+                print("[bold green]Executing L.A.Cosmic (run 2)...[/bold green]")
                 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']
+                    ccd=data_reflection_padded,
+                    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"],
                 )
+                cleandata_lacosmic2 = cleandata_lacosmic2[borderpadd:-borderpadd, borderpadd:-borderpadd]
+                mask_crfound2 = mask_crfound2[borderpadd:-borderpadd, borderpadd:-borderpadd]
                 # Apply usefulmask to consider only selected region
                 cleandata_lacosmic2 *= usefulmask
                 mask_crfound2 = mask_crfound2 & (usefulmask.astype(bool))
@@ -420,7 +486,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                     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)}')
+                    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
@@ -431,29 +497,31 @@ class CosmicRayCleanerApp(ImageDisplay):
             # 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']
+                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
+                        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)}}")
+                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)}}")
+                    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)}}")
+                print(f"Number of cosmic ray features (grouped pixels)....: {self.num_features:>{len(sdum)}}")
                 self.apply_lacosmic_button.config(state=tk.NORMAL)
                 self.examine_detected_cr_button.config(state=tk.NORMAL)
                 self.update_cr_overlay()
@@ -480,16 +548,16 @@ class CosmicRayCleanerApp(ImageDisplay):
         """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 +566,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,98 +593,119 @@ 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)}}")
+            print(f"Remaining number of cosmic ray pixels...................: {sdum}")
+            print(f"Remaining number of cosmic ray features (grouped pixels): {self.num_features:>{len(sdum)}}")
             # 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)
@@ -623,6 +716,7 @@ class CosmicRayCleanerApp(ImageDisplay):
         """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 +730,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 +744,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)
@@ -672,8 +766,8 @@ class CosmicRayCleanerApp(ImageDisplay):
             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)}}")
+            print(f"Remaining number of cosmic ray pixels...................: {sdum}")
+            print(f"Remaining number of cosmic ray features (grouped pixels): {self.num_features:>{len(sdum)}}")
             # redraw image to show the changes
             self.image.set_data(self.data)
             self.canvas.draw_idle()
@@ -687,12 +781,10 @@ class CosmicRayCleanerApp(ImageDisplay):
     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,11 +792,11 @@ class CosmicRayCleanerApp(ImageDisplay):
 
     def on_key(self, event):
         """Handle key press events."""
-        if event.key == 'q':
+        if event.key == "q":
             pass  # Ignore the "q" key to prevent closing the window
-        elif event.key == ',':
+        elif event.key == ",":
             self.set_minmax()
-        elif event.key == '/':
+        elif event.key == "/":
             self.set_zscale()
         else:
             print(f"Key pressed: {event.key}")
@@ -753,8 +845,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