teareduce 0.5.9__py3-none-any.whl → 0.6.1__py3-none-any.whl

teareduce/cleanest/interpolationeditor.py

@@ -13,14 +13,34 @@ import tkinter as tk
 from tkinter import messagebox
 from tkinter import ttk
 
+from rich import print
+
 from .centerchildparent import center_on_parent
 from .definitions import VALID_CLEANING_METHODS
+from .definitions import MASKFILL_OPERATOR_VALUES
 
 
 class InterpolationEditor:
     """Dialog to select interpolation cleaning parameters."""
 
-    def __init__(self, root, last_dilation, last_npoints, last_degree, auxdata, xmin, xmax, ymin, ymax, imgshape):
+    def __init__(
+        self,
+        root,
+        last_dilation,
+        last_npoints,
+        last_degree,
+        last_maskfill_size,
+        last_maskfill_operator,
+        last_maskfill_smooth,
+        last_maskfill_verbose,
+        auxdata,
+        cleandata_lacosmic,
+        xmin,
+        xmax,
+        ymin,
+        ymax,
+        imgshape,
+    ):
         """Initialize the interpolation editor dialog.
 
         Parameters
@@ -33,8 +53,18 @@ class InterpolationEditor:
             The last used number of points for interpolation.
         last_degree : int
             The last used degree for interpolation.
+        last_maskfill_size : int
+            The last used maskfill size parameter.
+        last_maskfill_operator : str
+            The last used maskfill operator parameter.
+        last_maskfill_smooth : bool
+            The last used maskfill smooth parameter.
+        last_maskfill_verbose : bool
+            The last used maskfill verbose parameter.
         auxdata : array-like or None
             Auxiliary data for cleaning, if available.
+        cleandata_lacosmic : array-like or None
+            Cleaned data from L.A.Cosmic, if available.
         xmin : float
             Minimum x value of the data. From 1 to NAXIS1.
         xmax : float
@@ -56,8 +86,6 @@ class InterpolationEditor:
             Handle the Cancel button click event.
         action_on_method_change()
             Handle changes in the selected cleaning method.
-        check_interp_methods()
-            Check that all interpolation methods are valid.
 
         Attributes
         ----------
@@ -67,6 +95,8 @@ class InterpolationEditor:
             The last used dilation parameter.
         auxdata : array-like or None
             Auxiliary data for cleaning, if available.
+        cleandata_lacosmic : array-like or None
+            Cleaned data from L.A.Cosmic, if available.
         dict_interp_methods : dict
             Mapping of interpolation method names to their codes.
         cleaning_method : str or None
@@ -75,6 +105,12 @@ class InterpolationEditor:
             The number of points for interpolation.
         degree : int
             The degree for interpolation.
+        maskfill_size : int
+            The size parameter for maskfill.
+        maskfill_operator : str
+            The operator parameter for maskfill.
+        maskfill_smooth : bool
+            The smooth parameter for maskfill.
         xmin : float
             Minimum x value of the data. From 1 to NAXIS1.
         xmax : float
@@ -90,21 +126,15 @@ class InterpolationEditor:
         self.root.title("Cleaning Parameters")
         self.last_dilation = last_dilation
         self.auxdata = auxdata
-        self.dict_interp_methods = {
-            "x interp.": "x",
-            "y interp.": "y",
-            "surface interp.": "a-plane",
-            "median": "a-median",
-            "mean": "a-mean",
-            "lacosmic": "lacosmic",
-            "maskfill": "maskfill",
-            "auxdata": "auxdata",
-        }
-        self.check_interp_methods()
+        self.cleandata_lacosmic = cleandata_lacosmic
         # Initialize parameters
         self.cleaning_method = None
         self.npoints = last_npoints
         self.degree = last_degree
+        self.maskfill_size = last_maskfill_size
+        self.maskfill_operator = last_maskfill_operator
+        self.maskfill_smooth = last_maskfill_smooth
+        self.maskfill_verbose = last_maskfill_verbose
         self.xmin = xmin
         self.xmax = xmax
         self.ymin = ymin
@@ -129,38 +159,48 @@ class InterpolationEditor:
         bold_font = default_font.copy()
         bold_font.configure(weight="bold", size=default_font.cget("size") + 2)
         subtitle_label = tk.Label(main_frame, text="Select Cleaning Method", font=bold_font)
-        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=7, pady=(0, 15))
         row += 1
 
         # Create labels and entry fields for each cleaning method
         row = 1
+        column = 0
         self.cleaning_method_var = tk.StringVar(value="surface interp.")
-        for interp_method in self.dict_interp_methods.keys():
-            valid_method = True
+        for interp_method in VALID_CLEANING_METHODS.keys():
+            state = "normal"
             # Skip replace by L.A.Cosmic values if last dilation is not zero
-            if interp_method == "lacosmic" and self.last_dilation != 0:
-                valid_method = False
+            if interp_method == "lacosmic":
+                if self.last_dilation != 0:
+                    state = "disabled"
+                if self.cleandata_lacosmic is None:
+                    state = "disabled"
             # Skip auxdata method if auxdata is not available
             if interp_method == "auxdata" and self.auxdata is None:
-                valid_method = False
-            if valid_method:
-                tk.Radiobutton(
-                    main_frame,
-                    text=interp_method,
-                    variable=self.cleaning_method_var,
-                    value=interp_method,
-                    command=self.action_on_method_change,
-                ).grid(row=row, column=1, sticky="w")
+                state = "disabled"
+            tk.Radiobutton(
+                main_frame,
+                text=interp_method,
+                variable=self.cleaning_method_var,
+                value=interp_method,
+                command=self.action_on_method_change,
+                state=state,
+            ).grid(row=row, column=column, sticky="w", padx=5, pady=5)
+            column += 1
+            if column > 6:
+                column = 0
                 row += 1
+        row += 1
 
         # Separator
         separator1 = ttk.Separator(main_frame, orient="horizontal")
-        separator1.grid(row=row, column=0, columnspan=3, sticky="ew", pady=(10, 10))
+        separator1.grid(row=row, column=0, columnspan=7, sticky="ew", pady=(10, 10))
         row += 1
 
         # Subtitle for additional parameters
-        subtitle_label = tk.Label(main_frame, text="Additional Parameters", font=bold_font)
-        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label1 = tk.Label(main_frame, text="Fitting Parameters", font=bold_font)
+        subtitle_label1.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label2 = tk.Label(main_frame, text="Maskfill Parameters", font=bold_font)
+        subtitle_label2.grid(row=row, column=3, columnspan=3, pady=(0, 15))
         row += 1
 
         # Create labels and entry fields for each additional parameter
@@ -175,27 +215,61 @@ class InterpolationEditor:
         self.entry_degree = tk.Entry(main_frame, width=10)
         self.entry_degree.insert(0, self.degree)
         self.entry_degree.grid(row=row, column=1, sticky="w")
+        row -= 1
+        label = tk.Label(main_frame, text="Size:")
+        label.grid(row=row, column=3, sticky="e", padx=(0, 10))
+        self.entry_maskfill_size = tk.Entry(main_frame, width=10)
+        self.entry_maskfill_size.insert(0, self.maskfill_size)
+        self.entry_maskfill_size.grid(row=row, column=4, sticky="w")
+        label = tk.Label(main_frame, text="Operator:")
+        label.grid(row=row, column=5, sticky="e", padx=(0, 10))
+        self.entry_maskfill_operator = ttk.Combobox(
+            main_frame, width=10, values=MASKFILL_OPERATOR_VALUES, state="readonly"
+        )
+        self.entry_maskfill_operator.set(self.maskfill_operator)
+        # self.entry_maskfill_operator = tk.Entry(main_frame, width=10)
+        # self.entry_maskfill_operator.insert(0, self.maskfill_operator)
+        self.entry_maskfill_operator.grid(row=row, column=6, sticky="w")
         row += 1
+        label = tk.Label(main_frame, text="Smooth:")
+        label.grid(row=row, column=3, sticky="e", padx=(0, 10))
+        self.entry_maskfill_smooth = tk.Entry(main_frame, width=10)
+        self.entry_maskfill_smooth.insert(0, str(self.maskfill_smooth))
+        self.entry_maskfill_smooth.grid(row=row, column=4, sticky="w")
+        label = tk.Label(main_frame, text="Verbose:")
+        label.grid(row=row, column=5, sticky="e", padx=(0, 10))
+        self.entry_maskfill_verbose = tk.Entry(main_frame, width=10)
+        self.entry_maskfill_verbose.insert(0, str(self.maskfill_verbose))
+        self.entry_maskfill_verbose.grid(row=row, column=6, sticky="w")
+        row += 1
+
+        # Vertical separator
+        separatorv1 = ttk.Separator(main_frame, orient="vertical")
+        separatorv1.grid(row=row - 3, column=2, rowspan=3, sticky="ns", padx=5)
 
         # Separator
         separator2 = ttk.Separator(main_frame, orient="horizontal")
-        separator2.grid(row=row, column=0, columnspan=3, sticky="ew", pady=(10, 10))
+        separator2.grid(row=row, column=0, columnspan=7, sticky="ew", pady=(10, 10))
         row += 1
 
         # Subtitle for region to be examined
         subtitle_label = tk.Label(main_frame, text="Region to be Examined", font=bold_font)
-        subtitle_label.grid(row=row, column=0, columnspan=3, pady=(0, 15))
+        subtitle_label.grid(row=row, column=0, columnspan=7, pady=(0, 15))
         row += 1
 
         # Region to be examined label and entries
         for key in ["xmin", "xmax", "ymin", "ymax"]:
             # Parameter name label
-            label = tk.Label(main_frame, text=f"{key}:", anchor="e", width=15)
-            label.grid(row=row, column=0, sticky="w", pady=5)
+            label = tk.Label(main_frame, text=f"{key}:", anchor="e")
+            if key in ["xmin", "xmax"]:
+                coloff = 0
+            else:
+                coloff = 4
+            label.grid(row=row, column=coloff, sticky="e", pady=5)
             # Entry field
             entry = tk.Entry(main_frame, width=10)
             entry.insert(0, str(self.__dict__[key]))
-            entry.grid(row=row, column=1, padx=10, pady=5)
+            entry.grid(row=row, column=coloff + 1, padx=10, pady=5)
             self.entries[key] = entry  # dictionary to hold entry widgets
             # Type label
             dumtext = "(int)"
@@ -204,32 +278,42 @@ class InterpolationEditor:
             else:
                 dumtext += f" --> [1, {self.imgshape[0]}]"
             type_label = tk.Label(main_frame, text=dumtext, fg="gray", anchor="w", width=15)
-            type_label.grid(row=row, column=2, sticky="w", pady=5)
-            row += 1
+            type_label.grid(row=row, column=coloff + 2, sticky="w", pady=5)
+            if key == "xmax":
+                row -= 1
+            else:
+                row += 1
+
+        # Vertical separator
+        separatorv2 = ttk.Separator(main_frame, orient="vertical")
+        separatorv2.grid(row=row - 2, column=3, rowspan=2, sticky="ns", padx=5)
 
         # Separator
         separator3 = ttk.Separator(main_frame, orient="horizontal")
-        separator3.grid(row=row, column=0, columnspan=3, sticky="ew", pady=(10, 10))
+        separator3.grid(row=row, column=0, columnspan=7, sticky="ew", pady=(10, 10))
         row += 1
 
         # Button frame
         self.button_frame = tk.Frame(main_frame)
-        self.button_frame.grid(row=row, column=0, columnspan=3, pady=(15, 0))
+        self.button_frame.grid(row=row, column=0, columnspan=7, pady=(5, 0))
 
         # OK button
-        self.ok_button = tk.Button(self.button_frame, text="OK", width=5, command=self.on_ok)
+        self.ok_button = ttk.Button(self.button_frame, text="OK", command=self.on_ok)
         self.ok_button.pack(side="left", padx=5)
 
         # Cancel button
-        self.cancel_button = tk.Button(self.button_frame, text="Cancel", width=5, command=self.on_cancel)
+        self.cancel_button = ttk.Button(self.button_frame, text="Cancel", command=self.on_cancel)
         self.cancel_button.pack(side="left", padx=5)
 
+        # Initial focus on OK button
+        self.ok_button.focus_set()
+
         # Initial action depending on the default method
         self.action_on_method_change()
 
     def on_ok(self):
         """Handle the OK button click event."""
-        self.cleaning_method = self.dict_interp_methods[self.cleaning_method_var.get()]
+        self.cleaning_method = VALID_CLEANING_METHODS[self.cleaning_method_var.get()]
         try:
             self.npoints = int(self.entry_npoints.get())
         except ValueError:
@@ -252,6 +336,44 @@ class InterpolationEditor:
             messagebox.showerror("Input Error", "2*Npoints must be greater than Degree for x and y interpolation.")
             return
 
+        try:
+            self.maskfill_size = int(self.entry_maskfill_size.get())
+        except ValueError:
+            messagebox.showerror("Input Error", "Maskfill size must be an integer.")
+            return
+        if self.maskfill_size < 1:
+            messagebox.showerror("Input Error", "Maskfill size must be at least 1.")
+            return
+        if self.maskfill_size % 2 == 0:
+            messagebox.showerror("Input Error", "Maskfill size must be an odd integer.")
+            return
+
+        self.maskfill_operator = self.entry_maskfill_operator.get().strip()
+        if not self.maskfill_operator:
+            messagebox.showerror("Input Error", "Maskfill operator cannot be empty.")
+            return
+        if self.maskfill_operator not in ["median", "mean"]:
+            messagebox.showerror("Input Error", "Maskfill operator must be 'median' or 'mean'.")
+            return
+
+        smooth_str = self.entry_maskfill_smooth.get().strip().lower()
+        if smooth_str == "true":
+            self.maskfill_smooth = True
+        elif smooth_str == "false":
+            self.maskfill_smooth = False
+        else:
+            messagebox.showerror("Input Error", "Maskfill smooth must be True or False.")
+            return
+
+        verbose_str = self.entry_maskfill_verbose.get().strip().lower()
+        if verbose_str == "true":
+            self.maskfill_verbose = True
+        elif verbose_str == "false":
+            self.maskfill_verbose = False
+        else:
+            messagebox.showerror("Input Error", "Maskfill verbose must be True or False.")
+            return
+
         # Retrieve and validate region parameters
         try:
             xmin = int(self.entries["xmin"].get())
@@ -303,31 +425,55 @@ class InterpolationEditor:
     def action_on_method_change(self):
         """Handle changes in the selected cleaning method."""
         selected_method = self.cleaning_method_var.get()
-        print(f"Selected cleaning method: {selected_method}")
+        print(f"Selected cleaning method: [red bold]{selected_method}[/red bold]")
         if selected_method in ["x interp.", "y interp."]:
             self.entry_npoints.config(state="normal")
             self.entry_degree.config(state="normal")
+            self.entry_maskfill_size.config(state="disabled")
+            self.entry_maskfill_operator.config(state="disabled")
+            self.entry_maskfill_smooth.config(state="disabled")
+            self.entry_maskfill_verbose.config(state="disabled")
         elif selected_method == "surface interp.":
             self.entry_npoints.config(state="normal")
             self.entry_degree.config(state="disabled")
+            self.entry_maskfill_size.config(state="disabled")
+            self.entry_maskfill_operator.config(state="disabled")
+            self.entry_maskfill_smooth.config(state="disabled")
+            self.entry_maskfill_verbose.config(state="disabled")
         elif selected_method == "median":
             self.entry_npoints.config(state="normal")
             self.entry_degree.config(state="disabled")
+            self.entry_maskfill_size.config(state="disabled")
+            self.entry_maskfill_operator.config(state="disabled")
+            self.entry_maskfill_smooth.config(state="disabled")
+            self.entry_maskfill_verbose.config(state="disabled")
         elif selected_method == "mean":
             self.entry_npoints.config(state="normal")
             self.entry_degree.config(state="disabled")
+            self.entry_maskfill_size.config(state="disabled")
+            self.entry_maskfill_operator.config(state="disabled")
+            self.entry_maskfill_smooth.config(state="disabled")
+            self.entry_maskfill_verbose.config(state="disabled")
         elif selected_method == "lacosmic":
             self.entry_npoints.config(state="disabled")
             self.entry_degree.config(state="disabled")
+            self.entry_maskfill_size.config(state="disabled")
+            self.entry_maskfill_operator.config(state="disabled")
+            self.entry_maskfill_smooth.config(state="disabled")
+            self.entry_maskfill_verbose.config(state="disabled")
         elif selected_method == "auxdata":
             self.entry_npoints.config(state="disabled")
             self.entry_degree.config(state="disabled")
-
-    def check_interp_methods(self):
-        """Check that all interpolation methods are valid."""
-        for method in self.dict_interp_methods.keys():
-            if method not in VALID_CLEANING_METHODS:
-                raise ValueError(f"Invalid interpolation method: {method}")
-        for method in VALID_CLEANING_METHODS:
-            if method not in self.dict_interp_methods.keys():
-                raise ValueError(f"Interpolation method not mapped: {method}")
+            self.entry_maskfill_size.config(state="disabled")
+            self.entry_maskfill_operator.config(state="disabled")
+            self.entry_maskfill_smooth.config(state="disabled")
+            self.entry_maskfill_verbose.config(state="disabled")
+        elif selected_method == "maskfill":
+            self.entry_npoints.config(state="disabled")
+            self.entry_degree.config(state="disabled")
+            self.entry_maskfill_size.config(state="normal")
+            self.entry_maskfill_operator.config(state="normal")
+            self.entry_maskfill_smooth.config(state="normal")
+            self.entry_maskfill_verbose.config(state="normal")
+        else:
+            messagebox.showerror("Error", f"Unknown cleaning method selected: {selected_method}")

teareduce/cleanest/lacosmicpad.py

@@ -18,14 +18,19 @@ except ModuleNotFoundError as e:
         "`pip install teareduce[cleanest]`."
     ) from e
 import numpy as np
+from rich import print
 
+from .definitions import VALID_LACOSMIC_PSFMODEL_VALUES
+from .gausskernel2d_elliptical import gausskernel2d_elliptical
 
-def lacosmicpad(pad_width, **kwargs):
+
+def lacosmicpad(pad_width, show_arguments=False, **kwargs):
     """Execute LACosmic algorithm on a padded array.
 
     This function pads the input image array before applying the LACosmic
     cosmic ray cleaning algorithm. After processing, the padding is removed
-    to return an array of the original size.
+    to return an array of the original size. If `inbkg` or `invar` arrays
+    are provided, they are also padded accordingly.
 
     The padding helps to mitigate edge effects that can occur during the
     cosmic ray detection and cleaning process.
@@ -39,6 +44,8 @@ def lacosmicpad(pad_width, **kwargs):
     pad_width : int
         Width of the padding to be applied to the image before executing
         the LACosmic algorithm.
+    show_arguments : bool
+        If True, display LACosmic arguments being employed.
     **kwargs : dict
         Keyword arguments to be passed to the `cosmicray_lacosmic` function.
 
@@ -49,6 +56,7 @@ def lacosmicpad(pad_width, **kwargs):
     mask_array : 2D numpy.ndarray of bool
         The mask array indicating detected cosmic rays.
     """
+    # Check for required 'ccd' argument
     if "ccd" not in kwargs:
         raise ValueError("The 'ccd' keyword argument must be provided.")
     array = kwargs.pop("ccd")
@@ -56,6 +64,91 @@ def lacosmicpad(pad_width, **kwargs):
         raise TypeError("The 'ccd' keyword argument must be a numpy ndarray.")
     # Pad the array
     padded_array = np.pad(array, pad_width, mode="reflect")
+
+    # Pad inbkg if provided
+    if "inbkg" in kwargs:
+        if kwargs["inbkg"] is not None:
+            inbkg = kwargs["inbkg"]
+            if not isinstance(inbkg, np.ndarray):
+                raise TypeError("The 'inbkg' keyword argument must be a numpy ndarray.")
+            kwargs["inbkg"] = np.pad(inbkg, pad_width, mode="reflect")
+    else:
+        kwargs["inbkg"] = None
+
+    # Pad invar if provided
+    if "invar" in kwargs:
+        if kwargs["invar"] is not None:
+            invar = kwargs["invar"]
+            if not isinstance(invar, np.ndarray):
+                raise TypeError("The 'invar' keyword argument must be a numpy ndarray.")
+            kwargs["invar"] = np.pad(invar, pad_width, mode="reflect")
+    else:
+        kwargs["invar"] = None
+
+    # check for fsmode
+    if "fsmode" not in kwargs:
+        raise ValueError("The 'fsmode' keyword argument must be provided.")
+    else:
+        fsmode = kwargs["fsmode"]
+        if fsmode == "convolve":
+            if "psfmodel" not in kwargs:
+                raise ValueError("The 'psfmodel' keyword argument must be provided when fsmode is 'convolve'.")
+            psfmodel = kwargs["psfmodel"]
+            if psfmodel not in VALID_LACOSMIC_PSFMODEL_VALUES:
+                raise ValueError(f"The 'psfmodel' keyword argument must be one of {VALID_LACOSMIC_PSFMODEL_VALUES}.")
+            if "psffwhm" in kwargs:
+                raise ValueError(
+                    "When 'fsmode' is 'convolve', 'psffwhm' should not be provided; use 'psffwhm_x' and 'psffwhm_y' instead."
+                )
+            if "psffwhm_x" not in kwargs or "psffwhm_y" not in kwargs:
+                raise ValueError("When 'fsmode' is 'convolve', both 'psffwhm_x' and 'psffwhm_y' must be provided.")
+            fwhm_x = kwargs["psffwhm_x"]
+            fwhm_y = kwargs["psffwhm_y"]
+            if "psfsize" not in kwargs:
+                raise ValueError("When 'fsmode' is 'convolve', 'psfsize' must be provided.")
+            psfsize = kwargs["psfsize"]
+            if kwargs["psfmodel"] == "gaussxy":
+                if "psfk" in kwargs:
+                    raise ValueError(
+                        "When 'fsmode' is 'convolve' and 'psfmodel' is 'gaussxy', 'psfk' should not be provided; it will be generated from 'psffwhm_x' and 'psffwhm_y'."
+                    )
+                kwargs["psfk"] = gausskernel2d_elliptical(fwhm_x, fwhm_y, psfsize)
+                if show_arguments:
+                    print(
+                        f"Generated elliptical Gaussian kernel with fwhm_x={fwhm_x}, fwhm_y={fwhm_y}, size={psfsize}."
+                    )
+            elif kwargs["psfmodel"] in ["gauss", "moffat"]:
+                kwargs["psffwhm"] = (fwhm_x + fwhm_y) / 2.0  # average for circular psf
+                if show_arguments:
+                    print(f"Set psffwhm to average of fwhm_x and fwhm_y: {kwargs['psffwhm']}.")
+            elif kwargs["psfmodel"] == "gaussx":
+                kwargs["psffwhm"] = fwhm_x
+                if show_arguments:
+                    print(f"Set psffwhm to fwhm_x: {fwhm_x}.")
+            elif kwargs["psfmodel"] == "gaussy":
+                kwargs["psffwhm"] = fwhm_y
+                if show_arguments:
+                    print(f"Set psffwhm to fwhm_y: {fwhm_y}.")
+            else:
+                raise ValueError(f"Unsupported psfmodel: {kwargs['psfmodel']}")
+            if show_arguments:
+                print("Deleting 'psffwhm_x' and 'psffwhm_y' from kwargs.")
+            del kwargs["psffwhm_x"]
+            del kwargs["psffwhm_y"]
+        elif fsmode == "median":
+            # Remove unnecessary parameters for median fsmode
+            for param in ["psfmodel", "psfsize", "psffwhm", "psffwhm_x", "psffwhm_y"]:
+                if param in kwargs:
+                    if show_arguments:
+                        print(f"Removing '{param}' argument since fsmode is 'median'.")
+                    del kwargs[param]
+        else:
+            raise ValueError("The 'fsmode' keyword argument must be either 'convolve' or 'median'.")
+
+    # Show LACosmic arguments if requested
+    if show_arguments:
+        for key, value in kwargs.items():
+            print(f"LACosmic parameter: {key} = {value}")
     # Apply LACosmic algorithm to the padded array
     cleaned_padded_array, mask_padded_array = cosmicray_lacosmic(ccd=padded_array, **kwargs)
     # Remove padding

teareduce/cleanest/mergemasks.py

@@ -11,9 +11,10 @@
 
 import numpy as np
 from scipy import ndimage
+from rich import print
 
 
-def merge_peak_tail_masks(mask_peaks, mask_tails):
+def merge_peak_tail_masks(mask_peaks, mask_tails, verbose=False):
     """Merge peak and tail masks for cosmic ray cleaning.
 
     Tail pixels are preserved only if they correspond to CR features
@@ -25,6 +26,8 @@ def merge_peak_tail_masks(mask_peaks, mask_tails):
         Boolean array indicating the pixels identified as cosmic ray peaks.
     mask_tails : ndarray
         Boolean array indicating the pixels identified as cosmic ray tails.
+    verbose: bool
+        If True, print additional information during processing.
 
     Returns
     -------
@@ -41,6 +44,10 @@ def merge_peak_tail_masks(mask_peaks, mask_tails):
     if mask_peaks.dtype != bool or mask_tails.dtype != bool:
         raise TypeError("Input masks must be boolean arrays.")
 
+    if verbose:
+        ndigits = np.max([len(str(np.sum(mask_peaks))), len(str(np.sum(mask_tails)))])
+        print(f"Number of cosmic ray pixels (peaks)...............: {np.sum(mask_peaks):{ndigits}d}")
+        print(f"Number of cosmic ray pixels (tails)...............: {np.sum(mask_tails):{ndigits}d}")
     # find structures in tail mask
     structure = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
     cr_labels_tails, num_crs_tails = ndimage.label(mask_tails, structure=structure)
@@ -55,4 +62,7 @@ def merge_peak_tail_masks(mask_peaks, mask_tails):
         if icr > 0:
             merged_mask[cr_labels_tails == icr] = True
 
+    if verbose:
+        print(f"Number of cosmic ray pixels (merged peaks & tails): {np.sum(merged_mask):{ndigits}d}")
+
     return merged_mask