teareduce 0.6.5__py3-none-any.whl → 0.6.6__py3-none-any.whl

teareduce/cleanest/cosmicraycleanerapp.py

@@ -18,6 +18,34 @@ import sys
 
 from astropy.io import fits
 
+try:
+    import PyCosmic
+    PYCOSMIC_AVAILABLE = True
+except ModuleNotFoundError as e:
+    print("The 'teareduce.cleanest' module requires the 'PyCosmic' package.\n"
+          "Please install this module using:\n"
+          "`pip install git+https://github.com/nicocardiel/PyCosmic.git@test`"
+    )
+    PYCOSMIC_AVAILABLE = False
+
+try:
+    import deepCR
+except ModuleNotFoundError as e:
+    raise ModuleNotFoundError(
+        "The 'teareduce.cleanest' module requires the 'deepCR' package. "
+        "Please install teareduce with the 'cleanest' extra dependencies: "
+        "`pip install teareduce[cleanest]`."
+    ) from e
+
+try:
+    import cosmic_conn
+except ModuleNotFoundError as e:
+    raise ModuleNotFoundError(
+        "The 'teareduce.cleanest' module requires the 'cosmic-conn' package. "
+        "Please install teareduce with the 'cleanest' extra dependencies: "
+        "`pip install teareduce[cleanest]`."
+    ) from e
+
 try:
     from maskfill import maskfill
 except ModuleNotFoundError as e:
@@ -26,6 +54,8 @@ except ModuleNotFoundError as e:
         "Please install teareduce with the 'cleanest' extra dependencies: "
         "`pip install teareduce[cleanest]`."
     ) from e
+
+from importlib.metadata import version, PackageNotFoundError
 import matplotlib.pyplot as plt
 from matplotlib.backend_bases import key_press_handler
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
@@ -37,7 +67,10 @@ from rich import print
 
 from .askextension import ask_extension_input_image
 from .centerchildparent import center_on_parent
+from .definitions import cosmicconn_default_dict
+from .definitions import deepcr_default_dict
 from .definitions import lacosmic_default_dict
+from .definitions import pycosmic_default_dict
 from .definitions import DEFAULT_NPOINTS_INTERP
 from .definitions import DEFAULT_DEGREE_INTERP
 from .definitions import DEFAULT_MASKFILL_SIZE
@@ -59,7 +92,8 @@ from .imagedisplay import ImageDisplay
 from .lacosmicpad import lacosmicpad
 from .mergemasks import merge_peak_tail_masks
 from .modalprogressbar import ModalProgressBar
-from .parametereditor import ParameterEditor
+from .parametereditor import ParameterEditorLACosmic
+from .parametereditor import ParameterEditorPyCosmic
 from .reviewcosmicray import ReviewCosmicRay
 from .trackedbutton import TrackedTkButton
 
@@ -127,14 +161,26 @@ class CosmicRayCleanerApp(ImageDisplay):
             Save the cleaned data to a FITS file.
         create_widgets()
             Create the GUI widgets.
+        set_cursor_onoff()
+            Toggle the cursor mode on or off.
+        toggle_auxdata()
+            Toggle the use of auxiliary data.
+        toggle_aspect()
+            Toggle the aspect ratio of the displayed image.
         run_lacosmic()
             Run the L.A.Cosmic algorithm.
+        run_pycosmic()
+            Run the PyCosmic algorithm.
+        run_deepcr()
+            Run the DeepCR algorithm.
+        run_cosmicconn()
+            Run the Cosmic-CoNN algorithm.
         toggle_cr_overlay()
             Toggle the overlay of cosmic ray pixels on the image.
         update_cr_overlay()
             Update the overlay of cosmic ray pixels on the image.
-        apply_lacosmic()
-            Apply the L.A.Cosmic algorithm to the data.
+        apply_cleaning()
+            Apply selected cleaning algorithm to the data.
         review_detected_cr()
             Examine detected cosmic rays.
         stop_app()
@@ -160,8 +206,14 @@ class CosmicRayCleanerApp(ImageDisplay):
             Height of the GUI window in pixels.
         verbose : bool
             Enable verbose output.
+        cosmicconn_params : dict
+            Dictionary of Cosmic-CoNN parameters.
+        deepcr_params : dict
+            Dictionary of DeepCR parameters.
         lacosmic_params : dict
             Dictionary of L.A.Cosmic parameters.
+        pycosmic_params : dict
+            Dictionary of PyCosmic parameters.
         input_fits : str
             Path to the FITS file to be cleaned.
         extension : int
@@ -212,6 +264,10 @@ class CosmicRayCleanerApp(ImageDisplay):
             Last used verbose parameter for maskfill.
         cleandata_lacosmic : np.ndarray
             The cleaned data returned from L.A.Cosmic.
+        cleandata_pycosmic : np.ndarray
+            The cleaned data returned from PyCosmic.
+        cleandata_deepcr : np.ndarray
+            The cleaned data returned from DeepCR.
         cr_labels : np.ndarray
             Labeled cosmic ray features.
         num_features : int
@@ -233,9 +289,12 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.default_font.configure(
             family=fontfamily, size=fontsize, weight="normal", slant="roman", underline=0, overstrike=0
         )
+        self.cosmicconn_params = cosmicconn_default_dict.copy()
+        self.deepcr_params = deepcr_default_dict.copy()
         self.lacosmic_params = lacosmic_default_dict.copy()
         self.lacosmic_params["run1_verbose"]["value"] = self.verbose
         self.lacosmic_params["run2_verbose"]["value"] = self.verbose
+        self.pycosmic_params = pycosmic_default_dict.copy()
         self.input_fits = input_fits
         self.extension = extension
         self.data = None
@@ -263,10 +322,276 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.last_maskfill_verbose = DEFAULT_MASKFILL_VERBOSE
         self.create_widgets()
         self.cleandata_lacosmic = None
+        self.cleandata_pycosmic = None
+        self.cleandata_deepcr = None
         self.cr_labels = None
         self.num_features = 0
         self.working_in_review_window = False
 
+    def create_widgets(self):
+        """Create the GUI widgets.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method sets up the GUI layout, including buttons for running
+        L.A.Cosmic, toggling cosmic ray overlay, applying cleaning methods,
+        examining detected cosmic rays, saving the cleaned FITS file, and
+        stopping the application. It also initializes the matplotlib figure
+        and canvas for image display, along with the toolbar for navigation.
+        The relevant attributes are stored in the instance for later use.
+        """
+        # Define instance of TrackedTkButton, that facilitates to show help information
+        # for each button displayed in the current application window.
+        tkbutton = TrackedTkButton(self.root)
+
+        # Row 1 of buttons
+        self.button_frame1 = tk.Frame(self.root)
+        self.button_frame1.pack(pady=5)
+        # --- L.A.Cosmic button
+        self.run_lacosmic_button = tkbutton.new(
+            self.button_frame1,
+            text="Run L.A.Cosmic",
+            command=self.run_lacosmic,
+            help_text="Run the L.A.Cosmic algorithm to detect cosmic rays in the image.",
+        )
+        self.run_lacosmic_button.pack(side=tk.LEFT, padx=5)
+        # --- PyCosmic button
+        self.run_pycosmic_button = tkbutton.new(
+            self.button_frame1,
+            text="Run PyCosmic",
+            command=self.run_pycosmic,
+            help_text="Run the PyCosmic algorithm to detect cosmic rays in the image.",
+        )
+        self.run_pycosmic_button.pack(side=tk.LEFT, padx=5)
+        if not PYCOSMIC_AVAILABLE:
+            self.run_pycosmic_button.config(state=tk.DISABLED)
+        # --- DeepCR button
+        self.run_deepcr_button = tkbutton.new(
+            self.button_frame1,
+            text="Run DeepCR",
+            command=self.run_deepcr,
+            help_text="Run the DeepCR algorithm to detect cosmic rays in the image.",
+        )
+        self.run_deepcr_button.pack(side=tk.LEFT, padx=5)
+        # --- Cosmic-CoNN button
+        self.run_cosmiccnn_button = tkbutton.new(
+            self.button_frame1,
+            text="Run Cosmic-CoNN",
+            command=self.run_cosmiccnn,
+            help_text="Run the Cosmic-CoNN algorithm to detect cosmic rays in the image.",
+        )
+        self.run_cosmiccnn_button.pack(side=tk.LEFT, padx=5)
+        # --- Stop program button
+        self.stop_button = tkbutton.new(
+            self.button_frame1, text="Stop program", command=self.stop_app, help_text="Stop the application."
+        )
+        self.stop_button.pack(side=tk.LEFT, padx=5)
+
+
+        # Row 2 of buttons
+        self.button_frame2 = tk.Frame(self.root)
+        self.button_frame2.pack(pady=5)
+        # --- Load auxdata button
+        self.load_auxdata_button = tkbutton.new(
+            self.button_frame2,
+            text="Load auxdata",
+            command=self.load_auxdata_from_file,
+            help_text="Load an auxiliary FITS file for display.",
+        )
+        self.load_auxdata_button.pack(side=tk.LEFT, padx=5)
+        # --- Load detected CR button
+        self.load_detected_cr_button = tkbutton.new(
+            self.button_frame2,
+            text="Load CR mask",
+            command=self.load_detected_cr_from_file,
+            help_text="Load a previously saved cosmic ray mask from a FITS file.",
+        )
+        self.load_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        # --- Replace detected CR button
+        self.replace_detected_cr_button = tkbutton.new(
+            self.button_frame2,
+            text="Replace detected CRs",
+            command=self.apply_cleaning,
+            help_text="Apply the cleaning to the detected cosmic rays.",
+        )
+        self.replace_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        self.replace_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
+        # --- Review detected CR button
+        self.review_detected_cr_button = tkbutton.new(
+            self.button_frame2,
+            text="Review detected CRs",
+            command=lambda: self.review_detected_cr(1),
+            help_text="Review the detected cosmic rays.",
+        )
+        self.review_detected_cr_button.pack(side=tk.LEFT, padx=5)
+        self.review_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
+
+        # Row 3 of buttons
+        self.button_frame3 = tk.Frame(self.root)
+        self.button_frame3.pack(pady=5)
+        # --- Cursor ON/OFF button
+        self.use_cursor = False
+        self.use_cursor_button = tkbutton.new(
+            self.button_frame3,
+            text="[c]ursor: OFF",
+            command=self.set_cursor_onoff,
+            help_text="Toggle the cursor ON or OFF (to select CR with mouse).",
+            alttext="[c]ursor: ??",
+        )
+        self.use_cursor_button.pack(side=tk.LEFT, padx=5)
+        # --- Toggle auxdata button
+        self.toggle_auxdata_button = tkbutton.new(
+            self.button_frame3,
+            text="[t]oggle data",
+            command=self.toggle_auxdata,
+            help_text="Toggle the display of auxiliary data.",
+        )
+        self.toggle_auxdata_button.pack(side=tk.LEFT, padx=5)
+        if self.auxdata is None:
+            self.toggle_auxdata_button.config(state=tk.DISABLED)
+        else:
+            self.toggle_auxdata_button.config(state=tk.NORMAL)
+        # --- Toggle aspect button
+        self.image_aspect = "equal"
+        self.toggle_aspect_button = tkbutton.new(
+            self.button_frame3,
+            text=f"[a]spect: {self.image_aspect}",
+            command=self.toggle_aspect,
+            help_text="Toggle the image aspect ratio.",
+        )
+        self.toggle_aspect_button.pack(side=tk.LEFT, padx=5)
+        # --- Save cleaned FITS button
+        self.save_button = tkbutton.new(
+            self.button_frame3,
+            text="Save cleaned FITS",
+            command=self.save_fits_file,
+            help_text="Save the cleaned FITS file.",
+        )
+        self.save_button.pack(side=tk.LEFT, padx=5)
+        self.save_button.config(state=tk.DISABLED)  # Initially disabled
+        # --- Save current mask button
+        self.save_crmask_button = tkbutton.new(
+            self.button_frame3,
+            text="Save CR mask",
+            command=self.save_crmask_to_file,
+            help_text="Save the current cosmic ray mask to a FITS file.",
+        )
+        self.save_crmask_button.pack(side=tk.LEFT, padx=5)
+        self.save_crmask_button.config(state=tk.DISABLED)  # Initially disabled
+
+        # Row 4 of buttons
+        self.button_frame4 = tk.Frame(self.root)
+        self.button_frame4.pack(pady=5)
+        # --- vmin button
+        vmin, vmax = zscale(self.data)
+        self.vmin_button = tkbutton.new(
+            self.button_frame4,
+            text=f"vmin: {vmin:.2f}",
+            command=self.set_vmin,
+            help_text="Set the minimum value for the display scale.",
+            alttext="vmin: ??",
+        )
+        self.vmin_button.pack(side=tk.LEFT, padx=5)
+        # --- vmax button
+        self.vmax_button = tkbutton.new(
+            self.button_frame4,
+            text=f"vmax: {vmax:.2f}",
+            command=self.set_vmax,
+            help_text="Set the maximum value for the display scale.",
+            alttext="vmax: ??",
+        )
+        self.vmax_button.pack(side=tk.LEFT, padx=5)
+        # --- minmax button
+        self.set_minmax_button = tkbutton.new(
+            self.button_frame4,
+            text="minmax [,]",
+            command=self.set_minmax,
+            help_text="Set the minimum and maximum values for the display scale.",
+        )
+        self.set_minmax_button.pack(side=tk.LEFT, padx=5)
+        # --- zscale button
+        self.set_zscale_button = tkbutton.new(
+            self.button_frame4,
+            text="zscale [/]",
+            command=self.set_zscale,
+            help_text="Set the display scale using zscale.",
+        )
+        self.set_zscale_button.pack(side=tk.LEFT, padx=5)
+        # --- Overplot CR pixels button
+        if self.overplot_cr_pixels:
+            self.overplot_cr_button = tkbutton.new(
+                self.button_frame4,
+                text="CR overlay: ON ",
+                command=self.toggle_cr_overlay,
+                help_text="Toggle the cosmic ray overlay ON or OFF.",
+                alttext="CR overlay: ??",
+            )
+        else:
+            self.overplot_cr_button = tkbutton.new(
+                self.button_frame4,
+                text="CR overlay: OFF",
+                command=self.toggle_cr_overlay,
+                help_text="Toggle the cosmic ray overlay ON or OFF.",
+                alttext="CR overlay: ??",
+            )
+        self.overplot_cr_button.pack(side=tk.LEFT, padx=5)
+        # --- Help button
+        self.help_button = tkbutton.new(
+            self.button_frame4,
+            text="Help",
+            command=tkbutton.show_help,
+            help_text="Show help information for all buttons.",
+        )
+        self.help_button.pack(side=tk.LEFT, padx=5)
+
+        # Figure
+        self.plot_frame = tk.Frame(self.root)
+        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()
+
+        # Matplotlib toolbar
+        self.toolbar_frame = tk.Frame(self.root)
+        self.toolbar_frame.pack(fill=tk.X, expand=False, pady=5)
+        self.toolbar = NavigationToolbar2Tk(self.canvas, self.toolbar_frame)
+        self.toolbar.update()
+
+        # update the image display
+        xlabel = "X pixel (from 1 to NAXIS1)"
+        ylabel = "Y pixel (from 1 to NAXIS2)"
+        extent = [0.5, self.data.shape[1] + 0.5, 0.5, self.data.shape[0] + 0.5]
+        self.image_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 process_detected_cr(self, dilation):
         """Process the detected cosmic ray mask.
 
@@ -283,17 +608,12 @@ class CosmicRayCleanerApp(ImageDisplay):
                 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)
-            if dilation > 0:
-                print(
-                    "Number of cosmic ray pixels before dilation.......: "
-                    f"{num_cr_pixels_before_dilation:>{len(sdum)}}"
-                )
                 print(
                     f"Number of cosmic ray pixels after dilation........: "
                     f"{num_cr_pixels_after_dilation:>{len(sdum)}}"
                 )
+            else:
+                sdum = str(num_cr_pixels_before_dilation)
             # 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.
@@ -338,7 +658,14 @@ class CosmicRayCleanerApp(ImageDisplay):
                         if extension not in hdul:
                             raise KeyError(f"Extension name '{extension}' not found.")
                     if hdul[extension].header["BITPIX"] not in [8, 16]:
-                        raise ValueError("Cosmic ray mask must be of integer type (BITPIX=8 or 16).")
+                        answer = messagebox.askyesno(
+                            f"Invalid Mask Data Type",
+                            f"Invalid Mask Data Type: {hdul[extension].header['BITPIX']}\n"
+                            "Cosmic ray mask is not of integer type (BITPIX=8 or 16).\n\n"
+                            "Do you want to continue loading it anyway?",
+                        )
+                        if not answer:
+                            return
                     mask_crfound_loaded = hdul[extension].data.astype(bool)
                     if mask_crfound_loaded.shape != self.data.shape:
                         print(f"data shape...: {self.data.shape}")
@@ -350,8 +677,9 @@ class CosmicRayCleanerApp(ImageDisplay):
                         "Dilation", "Enter Dilation (min=0):", initialvalue=0, minvalue=0
                     )
                     self.process_detected_cr(dilation=dilation)
-                    # self.lacosmic_params["dilation"]["value"] = dilation
+                    self.cleandata_deepcr = None  # Invalidate previous DeepCR cleaned data
                     self.cleandata_lacosmic = None  # Invalidate previous L.A.Cosmic cleaned data
+                    self.cleandata_pycosmic = None  # Invalidate previous PyCosmic cleaned data
             except Exception as e:
                 messagebox.showerror("Error", f"Error loading cosmic ray mask: {e}")
 
@@ -508,222 +836,30 @@ class CosmicRayCleanerApp(ImageDisplay):
         except Exception as e:
             print(f"Error saving FITS file: {e}")
 
-    def create_widgets(self):
-        """Create the GUI widgets.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        This method sets up the GUI layout, including buttons for running
-        L.A.Cosmic, toggling cosmic ray overlay, applying cleaning methods,
-        examining detected cosmic rays, saving the cleaned FITS file, and
-        stopping the application. It also initializes the matplotlib figure
-        and canvas for image display, along with the toolbar for navigation.
-        The relevant attributes are stored in the instance for later use.
-        """
-        # Define instance of TrackedTkButton, that facilitates to show help information
-        # for each button displayed in the current application window.
-        tkbutton = TrackedTkButton(self.root)
-
-        # Row 1 of buttons
-        self.button_frame1 = tk.Frame(self.root)
-        self.button_frame1.pack(pady=5)
-        self.run_lacosmic_button = tkbutton.new(
-            self.button_frame1,
-            text="Run L.A.Cosmic",
-            command=self.run_lacosmic,
-            help_text="Run the L.A.Cosmic algorithm to detect cosmic rays in the image.",
-        )
-        self.run_lacosmic_button.pack(side=tk.LEFT, padx=5)
-        self.load_auxdata_button = tkbutton.new(
-            self.button_frame1,
-            text="Load auxdata",
-            command=self.load_auxdata_from_file,
-            help_text="Load an auxiliary FITS file for display.",
-        )
-        self.load_auxdata_button.pack(side=tk.LEFT, padx=5)
-        self.load_detected_cr_button = tkbutton.new(
-            self.button_frame1,
-            text="Load CR mask",
-            command=self.load_detected_cr_from_file,
-            help_text="Load a previously saved cosmic ray mask from a FITS file.",
-        )
-        self.load_detected_cr_button.pack(side=tk.LEFT, padx=5)
-        self.replace_detected_cr_button = tkbutton.new(
-            self.button_frame1,
-            text="Replace detected CRs",
-            command=self.apply_lacosmic,
-            help_text="Apply the cleaning to the detected cosmic rays.",
-        )
-        self.replace_detected_cr_button.pack(side=tk.LEFT, padx=5)
-        self.replace_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
-        self.review_detected_cr_button = tkbutton.new(
-            self.button_frame1,
-            text="Review detected CRs",
-            command=lambda: self.review_detected_cr(1),
-            help_text="Review the detected cosmic rays.",
-        )
-        self.review_detected_cr_button.pack(side=tk.LEFT, padx=5)
-        self.review_detected_cr_button.config(state=tk.DISABLED)  # Initially disabled
-
-        # Row 2 of buttons
-        self.button_frame2 = tk.Frame(self.root)
-        self.button_frame2.pack(pady=5)
-        self.use_cursor = False
-        self.use_cursor_button = tkbutton.new(
-            self.button_frame2,
-            text="[c]ursor: OFF",
-            command=self.set_cursor_onoff,
-            help_text="Toggle the cursor ON or OFF (to select CR with mouse).",
-            alttext="[c]ursor: ??",
-        )
-        self.use_cursor_button.pack(side=tk.LEFT, padx=5)
-        self.toggle_auxdata_button = tkbutton.new(
-            self.button_frame2,
-            text="[t]oggle data",
-            command=self.toggle_auxdata,
-            help_text="Toggle the display of auxiliary data.",
-        )
-        self.toggle_auxdata_button.pack(side=tk.LEFT, padx=5)
-        if self.auxdata is None:
-            self.toggle_auxdata_button.config(state=tk.DISABLED)
-        else:
-            self.toggle_auxdata_button.config(state=tk.NORMAL)
-        self.image_aspect = "equal"
-        self.toggle_aspect_button = tkbutton.new(
-            self.button_frame2,
-            text=f"[a]spect: {self.image_aspect}",
-            command=self.toggle_aspect,
-            help_text="Toggle the image aspect ratio.",
-        )
-        self.toggle_aspect_button.pack(side=tk.LEFT, padx=5)
-        self.save_button = tkbutton.new(
-            self.button_frame2,
-            text="Save cleaned FITS",
-            command=self.save_fits_file,
-            help_text="Save the cleaned FITS file.",
-        )
-        self.save_button.pack(side=tk.LEFT, padx=5)
-        self.save_button.config(state=tk.DISABLED)  # Initially disabled
-        self.stop_button = tkbutton.new(
-            self.button_frame2, text="Stop program", command=self.stop_app, help_text="Stop the application."
-        )
-        self.stop_button.pack(side=tk.LEFT, padx=5)
-
-        # Row 3 of buttons
-        self.button_frame3 = tk.Frame(self.root)
-        self.button_frame3.pack(pady=5)
-        vmin, vmax = zscale(self.data)
-        self.vmin_button = tkbutton.new(
-            self.button_frame3,
-            text=f"vmin: {vmin:.2f}",
-            command=self.set_vmin,
-            help_text="Set the minimum value for the display scale.",
-            alttext="vmin: ??",
-        )
-        self.vmin_button.pack(side=tk.LEFT, padx=5)
-        self.vmax_button = tkbutton.new(
-            self.button_frame3,
-            text=f"vmax: {vmax:.2f}",
-            command=self.set_vmax,
-            help_text="Set the maximum value for the display scale.",
-            alttext="vmax: ??",
-        )
-        self.vmax_button.pack(side=tk.LEFT, padx=5)
-        self.set_minmax_button = tkbutton.new(
-            self.button_frame3,
-            text="minmax [,]",
-            command=self.set_minmax,
-            help_text="Set the minimum and maximum values for the display scale.",
-        )
-        self.set_minmax_button.pack(side=tk.LEFT, padx=5)
-        self.set_zscale_button = tkbutton.new(
-            self.button_frame3,
-            text="zscale [/]",
-            command=self.set_zscale,
-            help_text="Set the display scale using zscale.",
-        )
-        self.set_zscale_button.pack(side=tk.LEFT, padx=5)
-        if self.overplot_cr_pixels:
-            self.overplot_cr_button = tkbutton.new(
-                self.button_frame3,
-                text="CR overlay: ON ",
-                command=self.toggle_cr_overlay,
-                help_text="Toggle the cosmic ray overlay ON or OFF.",
-                alttext="CR overlay: ??",
-            )
-        else:
-            self.overplot_cr_button = tkbutton.new(
-                self.button_frame3,
-                text="CR overlay: OFF",
-                command=self.toggle_cr_overlay,
-                help_text="Toggle the cosmic ray overlay ON or OFF.",
-                alttext="CR overlay: ??",
-            )
-        self.overplot_cr_button.pack(side=tk.LEFT, padx=5)
-        self.help_button = tkbutton.new(
-            self.button_frame3,
-            text="Help",
-            command=tkbutton.show_help,
-            help_text="Show help information for all buttons.",
-        )
-        self.help_button.pack(side=tk.LEFT, padx=5)
-
-        # Figure
-        self.plot_frame = tk.Frame(self.root)
-        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()
-
-        # Matplotlib toolbar
-        self.toolbar_frame = tk.Frame(self.root)
-        self.toolbar_frame.pack(fill=tk.X, expand=False, pady=5)
-        self.toolbar = NavigationToolbar2Tk(self.canvas, self.toolbar_frame)
-        self.toolbar.update()
-
-        # update the image display
-        xlabel = "X pixel (from 1 to NAXIS1)"
-        ylabel = "Y pixel (from 1 to NAXIS2)"
-        extent = [0.5, self.data.shape[1] + 0.5, 0.5, self.data.shape[0] + 0.5]
-        self.image_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 save_crmask_to_file(self):
+        """Save the current cosmic ray mask to a FITS file."""
+        output_fits = filedialog.asksaveasfilename(
+            initialdir=os.getcwd(),
+            title="Save last CR mask into a FITS file",
+            defaultextension=".fits",
+            filetypes=[("FITS files", "*.fits"), ("All files", "*.*")],
+            initialfile=None,
+        )
+        try:
+            hdu = fits.PrimaryHDU(self.mask_crfound.astype(np.uint8))
+            hdu.writeto(output_fits, overwrite=True)
+            print(f"Last mask saved to {output_fits}")
+        except Exception as e:
+            print(f"Error saving mask into a FITS file: {e}")  
+  
+    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."""
@@ -767,13 +903,14 @@ class CosmicRayCleanerApp(ImageDisplay):
             if not overwrite:
                 return
         self.run_lacosmic_button.config(state=tk.DISABLED)
+        print("[bold green]Define L.A.Cosmic parameters...[/bold green]")
         # 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(
+        editor = ParameterEditorLACosmic(
             root=editor_window,
             param_dict=self.lacosmic_params,
-            window_title="Cosmic Ray Mask Generation Parameters",
+            window_title="Mask Generation Parameters (L.A.Cosmic)",
             xmin=self.last_xmin,
             xmax=self.last_xmax,
             ymin=self.last_ymin,
@@ -834,6 +971,7 @@ class CosmicRayCleanerApp(ImageDisplay):
             cleandata_lacosmic, mask_crfound = lacosmicpad(
                 pad_width=borderpadd,
                 show_arguments=self.verbose,
+                display_ccdproc_version=True,
                 ccd=self.data,
                 gain_apply=True,  # Always apply gain
                 sigclip=self.lacosmic_params["run1_sigclip"]["value"],
@@ -864,6 +1002,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 cleandata_lacosmic2, mask_crfound2 = lacosmicpad(
                     pad_width=borderpadd,
                     show_arguments=self.verbose,
+                    display_ccdproc_version=False,
                     ccd=self.data,
                     gain_apply=True,  # Always apply gain
                     sigclip=self.lacosmic_params["run2_sigclip"]["value"],
@@ -900,9 +1039,257 @@ class CosmicRayCleanerApp(ImageDisplay):
             self.mask_crfound[usefulregion] = mask_crfound[usefulregion]
             # Process the mask: dilation and labeling
             self.process_detected_cr(dilation=self.lacosmic_params["dilation"]["value"])
+            # Invalidate previous cleaned data from other methods
+            self.cleandata_deepcr = None
+            self.cleandata_pycosmic = None
         else:
             print("Parameter editing cancelled. L.A.Cosmic detection skipped!")
         self.run_lacosmic_button.config(state=tk.NORMAL)
+        self.save_crmask_button.config(state=tk.NORMAL)
+
+    def run_pycosmic(self):
+        """Run PyCosmic to detect cosmic rays."""
+        if np.any(self.mask_crfound):
+            overwrite = messagebox.askyesno(
+                "Overwrite Cosmic Ray Mask",
+                "A cosmic ray mask is already defined.\n\nDo you want to overwrite it?",
+            )
+            if not overwrite:
+                return
+        self.run_pycosmic_button.config(state=tk.DISABLED)
+        print("[bold green]Define PyCosmic parameters...[/bold green]")
+        # Define parameters for PyCosmic from default dictionary
+        editor_window = tk.Toplevel(self.root)
+        center_on_parent(child=editor_window, parent=self.root)
+        editor = ParameterEditorPyCosmic(
+            root=editor_window,
+            param_dict=self.pycosmic_params,
+            window_title="Mask Generation Parameters (PyCosmic)",
+            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)
+        editor_window.grab_set()
+        # Wait for the editor window to close
+        self.root.wait_window(editor_window)
+        # Get the result after window closes
+        updated_params = editor.get_result()
+        if updated_params is not None:
+            # Update last used region values
+            self.last_xmin = updated_params["xmin"]["value"]
+            self.last_xmax = updated_params["xmax"]["value"]
+            self.last_ymin = updated_params["ymin"]["value"]
+            self.last_ymax = updated_params["ymax"]["value"]
+            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.pycosmic_params = updated_params
+            if self.verbose:
+                print("Parameters updated:")
+                for key, info in self.pycosmic_params.items():
+                    print(f"  {key}: {info['value']}")
+            if self.pycosmic_params["nruns"]["value"] not in [1, 2]:
+                raise ValueError("nruns must be 1 or 2")
+            # Execute PyCosmic with updated parameters
+            try:
+                pycosmic_version = version("PyCosmic")
+            except Exception:
+                pycosmic_version = "unknown"
+            print(f"Using PyCosmic version: {pycosmic_version}")
+            if self.pycosmic_params["run1_verbose"]["value"]:
+                end = "\n"
+                for key, info in self.pycosmic_params.items():
+                    print(f"PyCosmic parameter: {key} = {info['value']}")
+            else:
+                end = ""
+            print("[bold green]Executing PyCosmic (run 1)...[/bold green]")
+            print(f"(please wait...) ", end=end)
+            out = PyCosmic.det_cosmics(
+                data=self.data,
+                sigma_det=self.pycosmic_params["run1_sigma_det"]["value"],
+                rlim=self.pycosmic_params["run1_rlim"]["value"],
+                iterations=self.pycosmic_params["run1_iterations"]["value"],
+                fwhm_gauss=[
+                    self.pycosmic_params["run1_fwhm_gauss_x"]["value"],
+                    self.pycosmic_params["run1_fwhm_gauss_y"]["value"],
+                ],
+                replace_box=[
+                    self.pycosmic_params["run1_replace_box_x"]["value"],
+                    self.pycosmic_params["run1_replace_box_y"]["value"],
+                ],
+                replace_error=self.pycosmic_params["run1_replace_error"]["value"],
+                increase_radius=self.pycosmic_params["run1_increase_radius"]["value"],
+                gain=self.pycosmic_params["run1_gain"]["value"],
+                rdnoise=self.pycosmic_params["run1_rdnoise"]["value"],
+                bias=self.pycosmic_params["run1_bias"]["value"],
+                verbose=self.pycosmic_params["run1_verbose"]["value"],
+            )
+            print(f"Done!")
+            cleandata_pycosmic = out.data
+            mask_crfound = out.mask.astype(bool)
+            # Apply usefulmask to consider only selected region
+            cleandata_pycosmic *= usefulmask
+            mask_crfound = mask_crfound & (usefulmask.astype(bool))
+            # Second execution if nruns == 2
+            if self.pycosmic_params["nruns"]["value"] == 2:
+                print("[bold green]Executing PyCosmic (run 2)...[/bold green]")
+                print(f"(please wait...) ", end=end)
+                out2 = PyCosmic.det_cosmics(
+                    data=self.data,
+                    sigma_det=self.pycosmic_params["run2_sigma_det"]["value"],
+                    rlim=self.pycosmic_params["run2_rlim"]["value"],
+                    iterations=self.pycosmic_params["run2_iterations"]["value"],
+                    fwhm_gauss=[
+                        self.pycosmic_params["run2_fwhm_gauss_x"]["value"],
+                        self.pycosmic_params["run2_fwhm_gauss_y"]["value"],
+                    ],
+                    replace_box=[
+                        self.pycosmic_params["run2_replace_box_x"]["value"],
+                        self.pycosmic_params["run2_replace_box_y"]["value"],
+                    ],
+                    replace_error=self.pycosmic_params["run2_replace_error"]["value"],
+                    increase_radius=self.pycosmic_params["run2_increase_radius"]["value"],
+                    gain=self.pycosmic_params["run2_gain"]["value"],
+                    rdnoise=self.pycosmic_params["run2_rdnoise"]["value"],
+                    bias=self.pycosmic_params["run2_bias"]["value"],
+                    verbose=self.pycosmic_params["run2_verbose"]["value"],
+                )
+                print(f"Done!")
+                cleandata_pycosmic2 = out2.data
+                mask_crfound2 = out2.mask.astype(bool)
+                # Apply usefulmask to consider only selected region
+                cleandata_pycosmic2 *= usefulmask
+                mask_crfound2 = mask_crfound2 & (usefulmask.astype(bool))
+                # Combine results from both runs
+                if np.any(mask_crfound):
+                    mask_crfound = merge_peak_tail_masks(mask_crfound, mask_crfound2, verbose=True)
+                # Use the cleandata from the second run
+                cleandata_pycosmic = cleandata_pycosmic2
+            # Select the image region to process
+            self.cleandata_pycosmic = self.data.copy()
+            self.cleandata_pycosmic[usefulregion] = cleandata_pycosmic[usefulregion]
+            self.mask_crfound = np.zeros_like(self.data, dtype=bool)
+            self.mask_crfound[usefulregion] = mask_crfound[usefulregion]
+            # Process the mask: labeling (dilation is not necessary for PyCosmic; this
+            # algorithm already includes a parameter 'increase_radius' to grow the detected CRs)
+            self.process_detected_cr(dilation=0)
+            # Invalidate previous cleaned data from other methods
+            self.cleandata_lacosmic = None
+            self.cleandata_deepcr = None
+        else:
+            print("Parameter editing cancelled. PyCosmic detection skipped!")
+        self.run_pycosmic_button.config(state=tk.NORMAL)
+        self.save_crmask_button.config(state=tk.NORMAL)
+
+    def run_deepcr(self):
+        """Run DeepCR to detect cosmic rays."""
+        if np.any(self.mask_crfound):
+            overwrite = messagebox.askyesno(
+                "Overwrite Cosmic Ray Mask",
+                "A cosmic ray mask is already defined.\n\nDo you want to overwrite it?",
+            )
+            if not overwrite:
+                return
+        self.run_deepcr_button.config(state=tk.DISABLED)
+        print("[bold green]Executing DeepCR...[/bold green]")
+        # Initialize the DeepCR model
+        mdl = deepCR.deepCR(mask=self.deepcr_params["mask"]["value"])
+        # Ask for threshold value and update parameter
+        threshold = simpledialog.askfloat(
+            "Threshold",
+            "Enter DeepCR probability threshold (0.0 - 1.0):",
+            initialvalue=self.deepcr_params["threshold"]["value"],
+            minvalue=0.0,
+            maxvalue=1.0,
+        )
+        if threshold is None:
+            print("Threshold input cancelled. DeepCR detection skipped!")
+            self.run_deepcr_button.config(state=tk.NORMAL)
+            return
+        self.deepcr_params["threshold"]["value"] = threshold
+        print(f"Running DeepCR version: {deepCR.__version__}  (please wait...)", end="")
+        self.mask_crfound, self.cleandata_deepcr = mdl.clean(
+            self.data,
+            threshold=self.deepcr_params["threshold"]["value"],
+            inpaint=True,
+        )
+        print(" Done!")
+        # Process the mask: dilation and labeling
+        dilation = simpledialog.askinteger(
+            "Dilation",
+            "Note: Applying dilation will prevent the use of the DeepCR cleaned data.\n\n" "Enter Dilation (min=0):",
+            initialvalue=self.deepcr_params["dilation"]["value"],
+            minvalue=0,
+        )
+        if dilation is None:
+            print("Dilation input cancelled. DeepCR detection skipped!")
+            self.run_deepcr_button.config(state=tk.NORMAL)
+            return
+        if dilation > 0:
+            self.cleandata_deepcr = None  # Invalidate DeepCR cleaned data if dilation applied
+        self.deepcr_params["dilation"]["value"] = dilation
+        self.process_detected_cr(dilation=self.deepcr_params["dilation"]["value"])
+        # Invalidate previous cleaned data from other methods
+        self.cleandata_lacosmic = None
+        self.cleandata_pycosmic = None
+        self.run_deepcr_button.config(state=tk.NORMAL)
+        self.save_crmask_button.config(state=tk.NORMAL)
+
+    def run_cosmiccnn(self):
+        """Run Cosmic-CoNN to detect cosmic rays."""
+        if np.any(self.mask_crfound):
+            overwrite = messagebox.askyesno(
+                "Overwrite Cosmic Ray Mask",
+                "A cosmic ray mask is already defined.\n\nDo you want to overwrite it?",
+            )
+            if not overwrite:
+                return
+        self.run_cosmiccnn_button.config(state=tk.DISABLED)
+        print("[bold green]Executing Cosmic-CoNN...[/bold green]")
+        # Initialize the generic ground-imaging model
+        cr_model = cosmic_conn.init_model("ground_imaging")
+        # The model outputs a CR probability map
+        print(f"Running Cosmic-CoNN version: {cosmic_conn.__version__}  (please wait...)", end="")
+        cr_prob = cr_model.detect_cr(self.data.astype(np.float32))
+        print(" Done!")
+        # Ask for threshold value and update parameter
+        threshold = simpledialog.askfloat(
+            "Threshold",
+            "Enter Cosmic-CoNN probability threshold (0.0 - 1.0):",
+            initialvalue=self.cosmicconn_params["threshold"]["value"],
+            minvalue=0.0,
+            maxvalue=1.0,
+        )
+        if threshold is None:
+            print("Threshold input cancelled. Cosmic-CoNN detection skipped!")
+            self.run_cosmiccnn_button.config(state=tk.NORMAL)
+            return
+        self.cosmicconn_params["threshold"]["value"] = threshold
+        # Threshold the probability map to create a binary mask
+        self.mask_crfound = cr_prob > self.cosmicconn_params["threshold"]["value"]
+        # Process the mask: dilation and labeling
+        dilation = simpledialog.askinteger(
+            "Dilation", "Enter Dilation (min=0):", initialvalue=self.cosmicconn_params["dilation"]["value"], minvalue=0
+        )
+        if dilation is None:
+            print("Dilation input cancelled. Cosmic-CoNN detection skipped!")
+            self.run_cosmiccnn_button.config(state=tk.NORMAL)
+            return
+        self.cosmicconn_params["dilation"]["value"] = dilation
+        self.process_detected_cr(dilation=self.cosmicconn_params["dilation"]["value"])
+        # Invalidate previous cleaned data from other methods
+        self.cleandata_lacosmic = None
+        self.cleandata_pycosmic = None
+        self.cleandata_deepcr = None
+        self.run_cosmiccnn_button.config(state=tk.NORMAL)
+        self.save_crmask_button.config(state=tk.NORMAL)
 
     def toggle_cr_overlay(self):
         """Toggle the overlay of cosmic ray pixels on the image."""
@@ -931,7 +1318,7 @@ class CosmicRayCleanerApp(ImageDisplay):
                 del self.scatter_cr
         self.canvas.draw_idle()
 
-    def apply_lacosmic(self):
+    def apply_cleaning(self):
         """Apply the selected cleaning method to the detected cosmic rays."""
         if np.any(self.mask_crfound):
             # recalculate labels and number of features
@@ -951,6 +1338,8 @@ class CosmicRayCleanerApp(ImageDisplay):
                 last_maskfill_verbose=self.last_maskfill_verbose,
                 auxdata=self.auxdata,
                 cleandata_lacosmic=self.cleandata_lacosmic,
+                cleandata_pycosmic=self.cleandata_pycosmic,
+                cleandata_deepcr=self.cleandata_deepcr,
                 xmin=self.last_xmin,
                 xmax=self.last_xmax,
                 ymin=self.last_ymin,
@@ -993,6 +1382,22 @@ class CosmicRayCleanerApp(ImageDisplay):
                     # upate mask_crfound by eliminating the cleaned pixels
                     self.mask_crfound[mask_crfound_region] = False
                     data_has_been_modified = True
+                elif cleaning_method == "pycosmic":
+                    # Replace detected CR pixels with PyCosmic values
+                    self.data[mask_crfound_region] = self.cleandata_pycosmic[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 == "deepcr":
+                    # Replace detected CR pixels with DeepCR values
+                    self.data[mask_crfound_region] = self.cleandata_deepcr[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 == "maskfill":
                     # Replace detected CR pixels with local median values
                     print(
@@ -1098,7 +1503,7 @@ 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)
             num_cr_remaining = np.sum(self.mask_crfound)
-            sdum = str(num_cr_remaining)
+            sdum = str(int(num_cr_remaining + 0.5))
             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:
@@ -1130,6 +1535,8 @@ class CosmicRayCleanerApp(ImageDisplay):
                 data=self.data,
                 auxdata=self.auxdata,
                 cleandata_lacosmic=self.cleandata_lacosmic,
+                cleandata_pycosmic=self.cleandata_pycosmic,
+                cleandata_deepcr=self.cleandata_deepcr,
                 cr_labels=tmp_cr_labels,
                 num_features=1,
                 first_cr_index=1,
@@ -1146,6 +1553,8 @@ class CosmicRayCleanerApp(ImageDisplay):
                 data=self.data,
                 auxdata=self.auxdata,
                 cleandata_lacosmic=self.cleandata_lacosmic,
+                cleandata_pycosmic=self.cleandata_pycosmic,
+                cleandata_deepcr=self.cleandata_deepcr,
                 cr_labels=self.cr_labels,
                 num_features=self.num_features,
                 first_cr_index=first_cr_index,
@@ -1172,7 +1581,7 @@ 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)
             num_remaining = np.sum(self.mask_crfound)
-            sdum = str(num_remaining)
+            sdum = str(int(num_remaining + 0.5))
             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: