teareduce 0.6.8__py3-none-any.whl → 0.7.0__py3-none-any.whl

teareduce/cleanest/__main__.py

@@ -1,5 +1,5 @@
 #
-# Copyright 2025 Universidad Complutense de Madrid
+# Copyright 2025-2026 Universidad Complutense de Madrid
 #
 # This file is part of teareduce
 #
@@ -10,11 +10,10 @@
 """Interactive Cosmic Ray cleaning tool."""
 
 import argparse
+import glob
 import tkinter as tk
 from tkinter import filedialog
-from tkinter import simpledialog
 import os
-from pathlib import Path
 import platform
 from rich import print
 from rich_argparse import RichHelpFormatter
@@ -38,14 +37,7 @@ def main():
         formatter_class=RichHelpFormatter,
     )
     parser.add_argument("input_fits", nargs="?", default=None, help="Path to the FITS file to be cleaned.")
-    parser.add_argument("--extension", type=str, default="0", help="FITS extension to use (default: 0).")
-    parser.add_argument("--auxfile", type=str, default=None, help="Auxiliary FITS file")
-    parser.add_argument(
-        "--extension_auxfile",
-        type=str,
-        default="0",
-        help="FITS extension for auxiliary file (default: 0).",
-    )
+    parser.add_argument("--auxfile", type=str, default=None, help="Auxiliary FITS files (comma-separated if several).")
     parser.add_argument(
         "--fontfamily",
         type=str,
@@ -114,17 +106,77 @@ def main():
             use_auxfile = True
         if use_auxfile:
             print(f"Selected auxiliary FITS file: {args.auxfile}")
-            args.extension_auxfile = ask_extension_input_image(args.auxfile, imgshape=None)
+            extension_auxfile = ask_extension_input_image(args.auxfile, imgshape=None)
+            args.auxfile = f"{args.auxfile}[{extension_auxfile}]"
+        else:
+            args.auxfile = None
         root.destroy()
 
-    # Check that input files, and the corresponding extensions, exist
-    if not os.path.isfile(args.input_fits):
-        print(f"Error: File '{args.input_fits}' does not exist.")
-        exit(1)
-    if args.auxfile is not None and not os.path.isfile(args.auxfile):
-        print(f"Error: Auxiliary file '{args.auxfile}' does not exist.")
+    # Check that input file exists
+    if "[" in args.input_fits:
+        input_fits = args.input_fits[: args.input_fits.index("[")]
+        extension = args.input_fits[args.input_fits.index("[") + 1 : args.input_fits.index("]")]
+    else:
+        input_fits = args.input_fits
+        extension = "0"
+    if not os.path.isfile(input_fits):
+        print(f"Error: File '{input_fits}' does not exist.")
         exit(1)
 
+    # Process auxiliary files if provided
+    auxfile_list = []
+    extension_auxfile_list = []
+    if args.auxfile is not None:
+        # Check several auxiliary files separated by commas
+        if "\n" in args.auxfile:
+            if "?" in args.auxfile or "*" in args.auxfile:
+                print("Error: Cannot combine newlines and wildcards in --auxfile specification.")
+                exit(1)
+            # Replace newlines by commas to allow:
+            # --auxfile="`ls file??.fits`"   -> without extensions
+            # --auxfile="`for f in file??.fits; do echo "${f}[primary]"; done`"  -> with extension name (the same for all files!)
+            args.auxfile = args.auxfile.replace("\n", ",")
+        elif "?" in args.auxfile or "*" in args.auxfile:
+            # Handle wildcards to allow:
+            # --auxfile="file??.fits"   -> without extensions
+            # --auxfile="file??.fits[primary]"  -> with extension name (the same for all files!)
+            if "," in args.auxfile:
+                print("Error: Cannot combine wildcards with commas in --auxfile specification.")
+                exit(1)
+            # Expand possible wildcards in the auxiliary file specification
+            if "[" in args.auxfile:
+                s = args.auxfile.strip()
+                ext = None
+                if s.endswith("]"):
+                    ext = s[s.rfind("[") + 1 : s.rfind("]")]
+                    s = s[: s.rfind("[")]
+                matched_files = sorted(glob.glob(s))
+                if len(matched_files) == 0:
+                    print(f"Error: No files matched the pattern '{s}'.")
+                    exit(1)
+                args.auxfile = ",".join([f"{fname}[{ext}]" if ext is not None else fname for fname in matched_files])
+            else:
+                matched_files = sorted(glob.glob(args.auxfile))
+                if len(matched_files) == 0:
+                    print(f"Error: No files matched the pattern '{args.auxfile}'.")
+                    exit(1)
+                args.auxfile = ",".join(matched_files)
+        # Now process the comma-separated auxiliary files
+        for item in args.auxfile.split(","):
+            # Extract possible [ext] from filename
+            if "[" in item:
+                # Separate filename and extension, removing blanks
+                fname = item[: item.index("[")].strip()
+                # Check that file exists
+                if not os.path.isfile(fname):
+                    print(f"Error: File '{fname}' does not exist.")
+                    exit(1)
+                auxfile_list.append(fname)
+                extension_auxfile_list.append(item[item.index("[") + 1 : item.index("]")])
+            else:
+                auxfile_list.append(item.strip())
+                extension_auxfile_list.append("0")
+
     # Initialize Tkinter root
     try:
         root = tk.Tk()
@@ -149,10 +201,10 @@ def main():
     # Create and run the application
     CosmicRayCleanerApp(
         root=root,
-        input_fits=args.input_fits,
-        extension=args.extension,
-        auxfile=args.auxfile,
-        extension_auxfile=args.extension_auxfile,
+        input_fits=input_fits,
+        extension=extension,
+        auxfile_list=auxfile_list,
+        extension_auxfile_list=extension_auxfile_list,
         fontfamily=args.fontfamily,
         fontsize=args.fontsize,
         width=args.width,

teareduce/cleanest/choose_index_with_three_buttons.py

@@ -0,0 +1,126 @@
+#
+# Copyright 2026 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+import tkinter as tk
+from tkinter import simpledialog, ttk
+
+
+class ThreeButtonListDialog(simpledialog.Dialog):
+    """
+    A modal dialog that shows a list of strings and returns:
+      - 1..N : the highlighted item index (1-based) when pressing OK (or double-click / Enter)
+      - 0    : when pressing Cancel or closing the window (Esc or window X)
+      - N+1  : when pressing New (N = len(items))
+    """
+
+    def __init__(self, parent, title, prompt, items):
+        self.prompt = prompt
+        self.items = list(items)
+        self.result = None
+        self._force_new = False  # used to bypass selection validation for "New"
+        super().__init__(parent, title)
+
+    # ---------- Core layout ----------
+    def body(self, master):
+        ttk.Label(master, text=self.prompt).grid(row=0, column=0, columnspan=1, sticky="w", padx=8, pady=(8, 4))
+
+        self.listbox = tk.Listbox(master, height=min(12, max(4, len(self.items))), activestyle="dotbox")
+        for s in self.items:
+            self.listbox.insert(tk.END, s)
+        self.listbox.grid(row=1, column=0, sticky="nsew", padx=(8, 0), pady=4)
+
+        scrollbar = ttk.Scrollbar(master, orient="vertical", command=self.listbox.yview)
+        self.listbox.configure(yscrollcommand=scrollbar.set)
+        scrollbar.grid(row=1, column=1, sticky="ns", pady=4, padx=(0, 8))
+
+        # Keyboard bindings
+        self.listbox.bind("<Double-Button-1>", lambda e: self.ok())  # OK on double-click
+        self.bind("<Return>", lambda e: self.ok())  # Enter = OK
+        self.bind("<Escape>", lambda e: self.cancel())  # Esc = Cancel (→ 0)
+
+        # Resize behavior
+        master.grid_columnconfigure(0, weight=1)
+        master.grid_rowconfigure(1, weight=1)
+
+        if self.items:
+            self.listbox.selection_set(0)
+            self.listbox.activate(0)
+
+        return self.listbox  # initial focus on listbox
+
+    # ---------- Buttons (OK, Cancel, New) ----------
+    def buttonbox(self):
+        box = ttk.Frame(self)
+
+        self.ok_button = ttk.Button(box, text="OK", width=10, command=self.ok)
+        self.ok_button.grid(row=0, column=0, padx=5, pady=8)
+
+        self.cancel_button = ttk.Button(box, text="Cancel", width=10, command=self.cancel)
+        self.cancel_button.grid(row=0, column=1, padx=5, pady=8)
+
+        self.new_button = ttk.Button(box, text="New", width=10, command=self._on_new)
+        self.new_button.grid(row=0, column=2, padx=5, pady=8)
+
+        # Bindings for Return/Escape already set in body()
+        self.bind("<Return>", lambda e: self.ok())
+        self.bind("<Escape>", lambda e: self.cancel())
+
+        box.pack(side="bottom", fill="x")
+
+    # ---------- Dialog flow ----------
+    def validate(self):
+        """
+        Called by OK to decide whether dialog can close.
+        - If 'New' was pressed, allow closing without selection.
+        - Otherwise, ensure there is a highlighted item.
+        """
+        if self._force_new:
+            return True
+        cur = self.listbox.curselection()
+        if not cur:
+            self.bell()
+            return False
+        self._selected_index = cur[0]
+        return True
+
+    def apply(self):
+        """
+        Called after validate(). Set the final result here.
+        """
+        if self._force_new:
+            self.result = len(self.items) + 1  # N+1 (New)
+        else:
+            self.result = self._selected_index + 1  # 1..N (index of selection)
+
+    def _on_new(self):
+        """
+        Trigger New: returns N+1.
+        This must bypass selection validation.
+        """
+        self._force_new = True
+        self.ok()
+
+    # Important: Don't overwrite OK/New results when closing via Dialog.ok().
+    # Dialog.ok() calls validate() -> apply() -> cancel().
+    # Only set 0 in cancel() if result wasn't already set.
+    def cancel(self, event=None):
+        if self.result is None:
+            self.result = 0
+        super().cancel(event)
+
+
+def choose_index_with_three_buttons(parent, title, prompt, items):
+    """
+    Show the dialog and return:
+      - 1..N : highlighted item index (OK)
+      - 0    : Cancel/close
+      - N+1  : New
+    """
+    dlg = ThreeButtonListDialog(parent, title, prompt, items)
+    return dlg.result

teareduce/cleanest/cosmicraycleanerapp.py

@@ -1,5 +1,5 @@
 #
-# Copyright 2025 Universidad Complutense de Madrid
+# Copyright 2025-2026 Universidad Complutense de Madrid
 #
 # This file is part of teareduce
 #
@@ -69,6 +69,7 @@ from rich import print
 
 from .askextension import ask_extension_input_image
 from .centerchildparent import center_on_parent
+from .choose_index_with_three_buttons import choose_index_with_three_buttons
 from .definitions import cosmicconn_default_dict
 from .definitions import deepcr_default_dict
 from .definitions import lacosmic_default_dict
@@ -117,8 +118,8 @@ class CosmicRayCleanerApp(ImageDisplay):
         root,
         input_fits,
         extension="0",
-        auxfile=None,
-        extension_auxfile="0",
+        auxfile_list=[],
+        extension_auxfile_list=[],
         fontfamily=DEFAULT_FONT_FAMILY,
         fontsize=DEFAULT_FONT_SIZE,
         width=DEFAULT_TK_WINDOW_SIZE_X,
@@ -136,10 +137,10 @@ class CosmicRayCleanerApp(ImageDisplay):
             Path to the FITS file to be cleaned.
         extension : str, optional
             FITS extension to use (default is "0").
-        auxfile : str, optional
-            Path to an auxiliary FITS file (default is None).
-        extension_auxfile : str, optional
-            FITS extension for auxiliary file (default is "0").
+        auxfile_list : list of str, optional
+            List of paths to auxiliary FITS files (default is empty list).
+        extension_auxfile_list : list of str, optional
+            List of FITS extensions for auxiliary files (default is empty list).
         fontfamily : str, optional
             Font family for the GUI (default is "Helvetica").
         fontsize : int, optional
@@ -222,12 +223,18 @@ class CosmicRayCleanerApp(ImageDisplay):
             FITS extension to use.
         data : np.ndarray
             The image data from the FITS file.
-        auxfile : str
-            Path to an auxiliary FITS file.
-        extension_auxfile : int
-            FITS extension for auxiliary file.
-        auxdata : np.ndarray
-            The image data from the auxiliary FITS file.
+        auxfile_list : list of str
+            List of Paths to auxiliary FITS files.
+        extension_auxfile_list : list of int
+            List of FITS extensions for auxiliary files.
+        auxdata : list of np.ndarray
+            The list of image data from the auxiliary FITS files.
+        auxdata_mean : np.ndarray
+            The mean image data computed from the auxiliary FITS files.
+        auxdata_median : np.ndarray
+            The median image data computed from the auxiliary FITS files.
+        auxdata_min : np.ndarray
+            The minimum image data computed from the auxiliary FITS files.
         overplot_cr_pixels : bool
             Flag to indicate whether to overlay cosmic ray pixels.
         mask_crfound : np.ndarray
@@ -300,9 +307,12 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.input_fits = input_fits
         self.extension = extension
         self.data = None
-        self.auxfile = auxfile
-        self.extension_auxfile = extension_auxfile
-        self.auxdata = None
+        self.auxfile_list = auxfile_list
+        self.extension_auxfile_list = extension_auxfile_list
+        self.auxdata = []
+        self.auxdata_mean = None
+        self.auxdata_median = None
+        self.auxdata_min = None
         self.overplot_cr_pixels = True
         self.mask_crfound = None
         self.load_fits_file()
@@ -452,7 +462,7 @@ class CosmicRayCleanerApp(ImageDisplay):
             help_text="Toggle the display of auxiliary data.",
         )
         self.toggle_auxdata_button.pack(side=tk.LEFT, padx=5)
-        if self.auxdata is None:
+        if len(self.auxdata) == 0 or self.auxdata is None:
             self.toggle_auxdata_button.config(state=tk.DISABLED)
         else:
             self.toggle_auxdata_button.config(state=tk.NORMAL)
@@ -578,14 +588,14 @@ class CosmicRayCleanerApp(ImageDisplay):
         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.displaying_auxdata = 0  # 0: main data, > 0: auxdata
         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)}",
+            title=f"data: {os.path.basename(self.input_fits)}[{self.extension}]",
             xlabel=xlabel,
             ylabel=ylabel,
             extent=extent,
@@ -694,8 +704,8 @@ class CosmicRayCleanerApp(ImageDisplay):
         Notes
         -----
         This method loads the FITS file specified by `self.input_fits` and
-        reads the data from the specified extension. If an auxiliary file is
-        provided, it also loads the auxiliary data from the specified extension.
+        reads the data from the specified extension. If auxiliary files are
+        provided, it also loads the auxiliary data from the specified extensions.
         The loaded data is stored in `self.data` and `self.auxdata` attributes.
         """
         # check if extension is compatible with an integer
@@ -725,43 +735,67 @@ class CosmicRayCleanerApp(ImageDisplay):
         self.mask_crfound = np.zeros(self.data.shape, dtype=bool)
         naxis2, naxis1 = self.data.shape
         self.region = SliceRegion2D(f"[1:{naxis1}, 1:{naxis2}]", mode="fits").python
+
         # Read auxiliary file if provided
-        if self.auxfile is not None:
-            # check if extension_auxfile is compatible with an integer
-            try:
-                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}")
-                        print(f"auxdata shape: {self.auxdata.shape}")
-                        raise ValueError("Auxiliary file has different shape.")
-            except Exception as e:
-                sys.exit(f"Error loading auxiliary FITS file: {e}")
+        naux = len(self.auxfile_list)
+        if naux > 0:
+            for i in range(naux):
+                # check if extension_auxfile is compatible with an integer
+                try:
+                    extnum_aux = int(self.extension_auxfile_list[i])
+                    self.extension_auxfile_list[i] = extnum_aux
+                except ValueError:
+                    # Keep as string (delaying checking until opening the file)
+                    self.extension_auxfile_list[i] = self.extension_auxfile_list[i].upper()  # Convert to uppercase
+                try:
+                    with fits.open(self.auxfile_list[i], mode="readonly") as hdul_aux:
+                        if isinstance(self.extension_auxfile_list[i], int):
+                            if self.extension_auxfile_list[i] < 0 or self.extension_auxfile_list[i] >= len(hdul_aux):
+                                raise IndexError(f"Extension index {self.extension_auxfile_list[i]} out of range.")
+                        else:
+                            if self.extension_auxfile_list[i] not in hdul_aux:
+                                raise KeyError(f"Extension name '{self.extension_auxfile_list[i]}' not found.")
+                        print(
+                            f"Reading auxiliary file [bold green]{self.auxfile_list[i]}[/bold green], extension {self.extension_auxfile_list[i]}"
+                        )
+                        self.auxdata.append(hdul_aux[self.extension_auxfile_list[i]].data)
+                        if self.auxdata[i].shape != self.data.shape:
+                            print(f"data shape...: {self.data.shape}")
+                            print(f"auxdata shape: {self.auxdata[i].shape}")
+                            raise ValueError("Auxiliary file has different shape.")
+                except Exception as e:
+                    sys.exit(f"Error loading auxiliary FITS file {self.auxfile_list[i]}:\n{e}")
+            # Compute mean, median, min if multiple auxdata are loaded
+            if naux > 1:
+                data3d = np.zeros((len(self.auxdata),) + self.data.shape, dtype=self.data.dtype)
+                for i in range(len(self.auxdata)):
+                    data3d[i, :, :] = self.auxdata[i]
+                self.auxdata_mean = np.mean(data3d, axis=0)
+                self.auxdata_median = np.median(data3d, axis=0)
+                self.auxdata_min = np.min(data3d, axis=0)
+            else:
+                self.auxdata_mean = self.auxdata[0].copy()
+                self.auxdata_median = self.auxdata[0].copy()
+                self.auxdata_min = self.auxdata[0].copy()
 
     def load_auxdata_from_file(self):
         """Load auxiliary data from a FITS file."""
-        if self.auxfile is not None:
-            overwrite = messagebox.askyesno(
-                "Overwrite Auxiliary Data",
-                f"An auxiliary file is already loaded:\n\n{self.auxfile}\n\n" "Do you want to overwrite it?",
+        if len(self.auxfile_list) > 0:
+            nchoice = choose_index_with_three_buttons(
+                parent=self.root,
+                title="Select Auxiliary Data Index",
+                prompt="Select the auxiliary data to overwrite\nor create new auxiliary data:",
+                items=[
+                    f"Aux. data #{i+1}: {os.path.basename(self.auxfile_list[i])}[{self.extension_auxfile_list[i]}]"
+                    for i in range(len(self.auxfile_list))
+                ],
             )
-            if not overwrite:
+            if nchoice == 0:
                 return
+            else:
+                aux_number = nchoice - 1
+        else:
+            aux_number = 0
         auxfile = filedialog.askopenfilename(
             initialdir=os.getcwd(),
             title="Select auxiliary FITS file",
@@ -782,9 +816,26 @@ class CosmicRayCleanerApp(ImageDisplay):
                         print(f"data shape...: {self.data.shape}")
                         print(f"auxdata shape: {auxdata_loaded.shape}")
                         raise ValueError("Auxiliary file has different shape.")
-                    self.auxfile = auxfile
-                    self.auxdata = auxdata_loaded
-                    self.extension_auxfile = extension
+                    if aux_number == len(self.auxfile_list):
+                        self.auxfile_list.append(auxfile)
+                        self.extension_auxfile_list.append(extension)
+                        self.auxdata.append(auxdata_loaded)
+                    else:
+                        self.auxfile_list[aux_number] = auxfile
+                        self.auxdata[aux_number] = auxdata_loaded
+                        self.extension_auxfile_list[aux_number] = extension
+                    # Compute mean, median, min if multiple auxdata are loaded
+                    if len(self.auxdata) > 1:
+                        data3d = np.zeros((len(self.auxdata),) + self.data.shape, dtype=self.data.dtype)
+                        for i in range(len(self.auxdata)):
+                            data3d[i, :, :] = self.auxdata[i]
+                        self.auxdata_mean = np.mean(data3d, axis=0)
+                        self.auxdata_median = np.median(data3d, axis=0)
+                        self.auxdata_min = np.min(data3d, axis=0)
+                    else:
+                        self.auxdata_mean = self.auxdata[0].copy()
+                        self.auxdata_median = self.auxdata[0].copy()
+                        self.auxdata_min = self.auxdata[0].copy()
                     print(f"Loaded auxiliary data from {auxfile}")
                     self.toggle_auxdata_button.config(state=tk.NORMAL)
             except Exception as e:
@@ -863,23 +914,61 @@ class CosmicRayCleanerApp(ImageDisplay):
             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:
+        """Toggle between main data and auxiliary data for display.
+
+        If multiple auxiliary data are loaded, cycle through them,
+        including mean, median, and min of all auxiliary data.
+        """
+        naux = len(self.auxdata)
+        if naux == 0:
+            self.displaying_auxdata = 0
+        elif naux == 1:
+            if self.displaying_auxdata == 0:
+                self.displaying_auxdata = 1
+            else:
+                self.displaying_auxdata = 0
+        else:
+            self.displaying_auxdata += 1
+            if self.displaying_auxdata > naux + 3:
+                self.displaying_auxdata = 0
+        if self.displaying_auxdata == 0:
             # 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:
+            self.displaying_auxdata = 0
+            self.ax.set_title(f"data: {os.path.basename(self.input_fits)}[{self.extension}]")
+        elif self.displaying_auxdata > 0 and self.displaying_auxdata <= naux:
             # Switch to auxiliary data
             vmin = self.get_vmin()
             vmax = self.get_vmax()
-            self.image.set_data(self.auxdata)
+            self.image.set_data(self.auxdata[self.displaying_auxdata - 1])
+            self.image.set_clim(vmin=vmin, vmax=vmax)
+            self.ax.set_title(
+                f"auxdata: {os.path.basename(self.auxfile_list[self.displaying_auxdata - 1])}[{self.extension_auxfile_list[self.displaying_auxdata - 1]}]"
+            )
+        elif self.displaying_auxdata == naux + 1:
+            # Switch to auxiliary mean data
+            vmin = self.get_vmin()
+            vmax = self.get_vmax()
+            self.image.set_data(self.auxdata_mean)
+            self.image.set_clim(vmin=vmin, vmax=vmax)
+            self.ax.set_title("auxdata: MEAN of all loaded auxiliary data")
+        elif self.displaying_auxdata == naux + 2:
+            # Switch to auxiliary median data
+            vmin = self.get_vmin()
+            vmax = self.get_vmax()
+            self.image.set_data(self.auxdata_median)
+            self.image.set_clim(vmin=vmin, vmax=vmax)
+            self.ax.set_title("auxdata: MEDIAN of all loaded auxiliary data")
+        elif self.displaying_auxdata == naux + 3:
+            # Switch to auxiliary min data
+            vmin = self.get_vmin()
+            vmax = self.get_vmax()
+            self.image.set_data(self.auxdata_min)
             self.image.set_clim(vmin=vmin, vmax=vmax)
-            self.displaying_auxdata = True
-            self.ax.set_title(f"auxdata: {os.path.basename(self.auxfile)}")
+            self.ax.set_title("auxdata: MIN of all loaded auxiliary data")
         self.canvas.draw_idle()
 
     def toggle_aspect(self):
@@ -1337,7 +1426,8 @@ class CosmicRayCleanerApp(ImageDisplay):
                 last_maskfill_operator=self.last_maskfill_operator,
                 last_maskfill_smooth=self.last_maskfill_smooth,
                 last_maskfill_verbose=self.last_maskfill_verbose,
-                auxdata=self.auxdata,
+                auxfile_list=self.auxfile_list,
+                extension_auxfile_list=self.extension_auxfile_list,
                 cleandata_lacosmic=self.cleandata_lacosmic,
                 cleandata_pycosmic=self.cleandata_pycosmic,
                 cleandata_deepcr=self.cleandata_deepcr,
@@ -1422,11 +1512,33 @@ class CosmicRayCleanerApp(ImageDisplay):
                     self.mask_crfound[mask_crfound_region] = False
                     data_has_been_modified = True
                 elif cleaning_method == "auxdata":
-                    if self.auxdata is None:
+                    if len(self.auxdata) == 0:
                         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]
+                    inum = editor.auxiliary_data_index  # 1-based index of auxiliary data
+                    if inum <= len(self.auxdata):
+                        print(
+                            f"Using auxiliary data: "
+                            f"{os.path.basename(self.auxfile_list[inum - 1])}"
+                            f"[{self.extension_auxfile_list[inum - 1]}]"
+                        )
+                        # Replace detected CR pixels with auxiliary data values
+                        self.data[mask_crfound_region] = self.auxdata[inum - 1][mask_crfound_region]
+                    elif inum == len(self.auxdata) + 1:
+                        print("Using auxiliary data: MEAN of all loaded auxiliary data")
+                        # Replace detected CR pixels with auxiliary mean data values
+                        self.data[mask_crfound_region] = self.auxdata_mean[mask_crfound_region]
+                    elif inum == len(self.auxdata) + 2:
+                        print("Using auxiliary data: MEDIAN of all loaded auxiliary data")
+                        # Replace detected CR pixels with auxiliary median data values
+                        self.data[mask_crfound_region] = self.auxdata_median[mask_crfound_region]
+                    elif inum == len(self.auxdata) + 3:
+                        print("Using auxiliary data: MIN of all loaded auxiliary data")
+                        # Replace detected CR pixels with auxiliary min data values
+                        self.data[mask_crfound_region] = self.auxdata_min[mask_crfound_region]
+                    else:
+                        print(f"Invalid auxiliary data index: {inum}. Cleaning skipped!")
+                        return
                     # update mask_fixed to include the newly fixed pixels
                     self.mask_fixed[mask_crfound_region] = True
                     # upate mask_crfound by eliminating the cleaned pixels
@@ -1533,8 +1645,14 @@ class CosmicRayCleanerApp(ImageDisplay):
                 root=review_window,
                 root_width=self.width,
                 root_height=self.height,
+                input_fits=self.input_fits,
                 data=self.data,
                 auxdata=self.auxdata,
+                auxfile_list=self.auxfile_list,
+                extension_auxfile_list=self.extension_auxfile_list,
+                auxdata_mean=self.auxdata_mean,
+                auxdata_median=self.auxdata_median,
+                auxdata_min=self.auxdata_min,
                 cleandata_lacosmic=self.cleandata_lacosmic,
                 cleandata_pycosmic=self.cleandata_pycosmic,
                 cleandata_deepcr=self.cleandata_deepcr,
@@ -1551,8 +1669,14 @@ class CosmicRayCleanerApp(ImageDisplay):
                 root=review_window,
                 root_width=self.width,
                 root_height=self.height,
+                input_fits=self.input_fits,
                 data=self.data,
                 auxdata=self.auxdata,
+                auxfile_list=self.auxfile_list,
+                extension_auxfile_list=self.extension_auxfile_list,
+                auxdata_mean=self.auxdata_mean,
+                auxdata_median=self.auxdata_median,
+                auxdata_min=self.auxdata_min,
                 cleandata_lacosmic=self.cleandata_lacosmic,
                 cleandata_pycosmic=self.cleandata_pycosmic,
                 cleandata_deepcr=self.cleandata_deepcr,
@@ -1616,7 +1740,7 @@ class CosmicRayCleanerApp(ImageDisplay):
             self.set_cursor_onoff()
         elif event.key == "a":
             self.toggle_aspect()
-        elif event.key == "t" and self.auxdata is not None:
+        elif event.key == "t" and len(self.auxdata) > 0:
             self.toggle_auxdata()
         elif event.key == ",":
             self.set_minmax()