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

teareduce/cleanest/definitions.py

@@ -15,42 +15,35 @@
 # when reading user input.
 lacosmic_default_dict = {
     # L.A.Cosmic parameters for run 1
-    'run1_gain': {'value': 1.0, 'type': float, 'positive': True},
-    'run1_readnoise': {'value': 6.5, 'type': float, 'positive': True},
-    'run1_sigclip': {'value': 5.0, 'type': float, 'positive': True},
-    'run1_sigfrac': {'value': 0.3, 'type': float, 'positive': True},
-    'run1_objlim': {'value': 5.0, 'type': float, 'positive': True},
-    'run1_niter': {'value': 4, 'type': int, 'positive': True},
-    'run1_verbose': {'value': False, 'type': bool},
+    "run1_gain": {"value": 1.0, "type": float, "positive": True},
+    "run1_readnoise": {"value": 6.5, "type": float, "positive": True},
+    "run1_sigclip": {"value": 5.0, "type": float, "positive": True},
+    "run1_sigfrac": {"value": 0.3, "type": float, "positive": True},
+    "run1_objlim": {"value": 5.0, "type": float, "positive": True},
+    "run1_niter": {"value": 4, "type": int, "positive": True},
+    "run1_verbose": {"value": True, "type": bool},
     # L.A.Cosmic parameters for run 2
-    'run2_gain': {'value': 1.0, 'type': float, 'positive': True},
-    'run2_readnoise': {'value': 6.5, 'type': float, 'positive': True},
-    'run2_sigclip': {'value': 3.0, 'type': float, 'positive': True},
-    'run2_sigfrac': {'value': 0.3, 'type': float, 'positive': True},
-    'run2_objlim': {'value': 5.0, 'type': float, 'positive': True},
-    'run2_niter': {'value': 4, 'type': int, 'positive': True},
-    'run2_verbose': {'value': False, 'type': bool},
+    "run2_gain": {"value": 1.0, "type": float, "positive": True},
+    "run2_readnoise": {"value": 6.5, "type": float, "positive": True},
+    "run2_sigclip": {"value": 3.0, "type": float, "positive": True},
+    "run2_sigfrac": {"value": 0.3, "type": float, "positive": True},
+    "run2_objlim": {"value": 5.0, "type": float, "positive": True},
+    "run2_niter": {"value": 4, "type": int, "positive": True},
+    "run2_verbose": {"value": True, "type": bool},
     # Dilation of the mask
-    'dilation': {'value': 0, 'type': int, 'positive': True},
+    "dilation": {"value": 0, "type": int, "positive": True},
+    "borderpadd": {"value": 10, "type": int, "positive": True},
     # Limits for the image section to process (pixels start at 1)
-    'xmin': {'value': 1, 'type': int, 'positive': True},
-    'xmax': {'value': None, 'type': int, 'positive': True},
-    'ymin': {'value': 1, 'type': int, 'positive': True},
-    'ymax': {'value': None, 'type': int, 'positive': True},
+    "xmin": {"value": 1, "type": int, "positive": True},
+    "xmax": {"value": None, "type": int, "positive": True},
+    "ymin": {"value": 1, "type": int, "positive": True},
+    "ymax": {"value": None, "type": int, "positive": True},
     # Number of runs to execute L.A.Cosmic
-    'nruns': {'value': 1, 'type': int, 'positive': True}
+    "nruns": {"value": 1, "type": int, "positive": True},
 }
 
 # Default parameters for cleaning methods
-VALID_CLEANING_METHODS = [
-    'x interp.',
-    'y interp.',
-    'surface interp.',
-    'median',
-    'mean',
-    'lacosmic',
-    'auxdata'
-]
+VALID_CLEANING_METHODS = ["x interp.", "y interp.", "surface interp.", "median", "mean", "lacosmic", "auxdata"]
 
 # Maximum pixel distance to consider when finding closest CR pixel
 MAX_PIXEL_DISTANCE_TO_CR = 15
@@ -60,3 +53,11 @@ DEFAULT_NPOINTS_INTERP = 2
 
 # Default degree for interpolation
 DEFAULT_DEGREE_INTERP = 1
+
+# Default Tk window size
+DEFAULT_TK_WINDOW_SIZE_X = 800
+DEFAULT_TK_WINDOW_SIZE_Y = 700
+
+# Default font settings
+DEFAULT_FONT_FAMILY = "Helvetica"
+DEFAULT_FONT_SIZE = 14

teareduce/cleanest/imagedisplay.py

@@ -60,6 +60,7 @@ class ImageDisplay:
     the displayed region can be determined from either the axes limits or a
     predefined region attribute.
     """
+
     def set_vmin(self):
         """Prompt user to set a new minimum display value (vmin)."""
         old_vmin = self.get_vmin()
@@ -72,7 +73,7 @@ class ImageDisplay:
             return
         self.vmin_button.config(text=f"vmin: {new_vmin:.2f}")
         self.image.set_clim(vmin=new_vmin)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmin=new_vmin)
         self.canvas.draw_idle()
 
@@ -88,7 +89,7 @@ class ImageDisplay:
             return
         self.vmax_button.config(text=f"vmax: {new_vmax:.2f}")
         self.image.set_clim(vmax=new_vmax)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmax=new_vmax)
         self.canvas.draw_idle()
 
@@ -102,7 +103,7 @@ class ImageDisplay:
 
     def get_displayed_region(self):
         """Get the currently displayed region of the image."""
-        if hasattr(self, 'ax'):
+        if hasattr(self, "ax"):
             xmin, xmax = self.ax.get_xlim()
             xmin = int(xmin + 0.5)
             if xmin < 1:
@@ -118,10 +119,8 @@ class ImageDisplay:
             if ymax > self.data.shape[0]:
                 ymax = self.data.shape[0]
             print(f"Setting min/max using axis limits: x=({xmin:.2f}, {xmax:.2f}), y=({ymin:.2f}, {ymax:.2f})")
-            region = self.region = SliceRegion2D(
-                f'[{xmin}:{xmax}, {ymin}:{ymax}]', mode='fits'
-            ).python
-        elif hasattr(self, 'region'):
+            region = self.region = SliceRegion2D(f"[{xmin}:{xmax}, {ymin}:{ymax}]", mode="fits").python
+        elif hasattr(self, "region"):
             region = self.region
         else:
             raise AttributeError("No axis or region defined for set_minmax.")
@@ -136,7 +135,7 @@ class ImageDisplay:
         self.vmax_button.config(text=f"vmax: {vmax_new:.2f}")
         self.image.set_clim(vmin=vmin_new)
         self.image.set_clim(vmax=vmax_new)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmin=vmin_new)
             self.image_aux.set_clim(vmax=vmax_new)
         self.canvas.draw_idle()
@@ -149,7 +148,7 @@ class ImageDisplay:
         self.vmax_button.config(text=f"vmax: {vmax_new:.2f}")
         self.image.set_clim(vmin=vmin_new)
         self.image.set_clim(vmax=vmax_new)
-        if hasattr(self, 'image_aux'):
+        if hasattr(self, "image_aux"):
             self.image_aux.set_clim(vmin=vmin_new)
             self.image_aux.set_clim(vmax=vmax_new)
         self.canvas.draw_idle()

teareduce/cleanest/interpolation_a.py

@@ -53,14 +53,10 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
     by cosmic rays are interpolated.
     """
     # Mask of CR pixels
-    mask = (cr_labels == cr_index)
+    mask = cr_labels == cr_index
     # Dilate the mask to find border pixels
     # dilated_mask = binary_dilation(mask, structure=np.ones((3, 3)), iterations=npoints)
-    dilated_mask = dilatemask(
-        mask=mask,
-        iterations=npoints,
-        connectivity=1
-    )
+    dilated_mask = dilatemask(mask=mask, iterations=npoints, connectivity=1)
     # Border pixels are those in the dilated mask but not in the original mask
     border_mask = dilated_mask & (~mask)
     # Get coordinates of border pixels
@@ -68,7 +64,7 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
     zfit_all = data[yfit_all, xfit_all].tolist()
     # Perform interpolation
     interpolation_performed = False
-    if method == 'surface':
+    if method == "surface":
         if len(xfit_all) > 3:
             # Construct the design matrix for a 2D polynomial fit to a plane,
             # where each row corresponds to a point (x, y, z) and the model
@@ -84,10 +80,10 @@ def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
             interpolation_performed = True
         else:
             print("Not enough points to fit a plane")
-    elif method in ['median', 'mean']:
+    elif method in ["median", "mean"]:
         # Compute median of all surrounding points
         if len(zfit_all) > 0:
-            if method == 'median':
+            if method == "median":
                 zval = np.median(zfit_all)
             else:
                 zval = np.mean(zfit_all)

teareduce/cleanest/interpolationeditor.py

@@ -11,13 +11,16 @@
 
 import tkinter as tk
 from tkinter import messagebox
+from tkinter import ttk
 
+from .centerchildparent import center_on_parent
 from .definitions import VALID_CLEANING_METHODS
 
 
 class InterpolationEditor:
     """Dialog to select interpolation cleaning parameters."""
-    def __init__(self, root, last_dilation, last_npoints, last_degree, auxdata):
+
+    def __init__(self, root, last_dilation, last_npoints, last_degree, auxdata, xmin, xmax, ymin, ymax, imgshape):
         """Initialize the interpolation editor dialog.
 
         Parameters
@@ -32,6 +35,16 @@ class InterpolationEditor:
             The last used degree for interpolation.
         auxdata : array-like or None
             Auxiliary data for cleaning, if available.
+        xmin : float
+            Minimum x value of the data. From 1 to NAXIS1.
+        xmax : float
+            Maximum x value of the data. From 1 to NAXIS1.
+        ymin : float
+            Minimum y value of the data. From 1 to NAXIS2.
+        ymax : float
+            Maximum y value of the data. From 1 to NAXIS2.
+        imgshape : tuple
+            Shape of the image data (height, width).
 
         Methods
         -------
@@ -62,6 +75,16 @@ class InterpolationEditor:
             The number of points for interpolation.
         degree : int
             The degree for interpolation.
+        xmin : float
+            Minimum x value of the data. From 1 to NAXIS1.
+        xmax : float
+            Maximum x value of the data. From 1 to NAXIS1.
+        ymin : float
+            Minimum y value of the data. From 1 to NAXIS2.
+        ymax : float
+            Maximum y value of the data. From 1 to NAXIS2.
+        imgshape : tuple
+            Shape of the image data (height, width).
         """
         self.root = root
         self.root.title("Cleaning Parameters")
@@ -74,15 +97,23 @@ class InterpolationEditor:
             "median": "a-median",
             "mean": "a-mean",
             "lacosmic": "lacosmic",
-            "auxdata": "auxdata"
+            "auxdata": "auxdata",
         }
         self.check_interp_methods()
         # Initialize parameters
         self.cleaning_method = None
         self.npoints = last_npoints
         self.degree = last_degree
+        self.xmin = xmin
+        self.xmax = xmax
+        self.ymin = ymin
+        self.ymax = ymax
+        self.imgshape = imgshape
+        # Dictionary to hold entry widgets for region parameters
+        self.entries = {}
         # Create the form
         self.create_widgets()
+        center_on_parent(child=self.root, parent=self.root.master)
 
     def create_widgets(self):
         """Create the widgets for the dialog."""
@@ -90,9 +121,15 @@ class InterpolationEditor:
         main_frame = tk.Frame(self.root, padx=10, pady=10)
         main_frame.pack()
 
-        # Title
-        title_label = tk.Label(main_frame, text="Select Cleaning Method", font=("Arial", 14, "bold"))
-        title_label.grid(row=0, column=0, columnspan=2, pady=(0, 15))
+        row = 0
+
+        # Subtitle for cleaning method selection
+        default_font = tk.font.nametofont("TkDefaultFont")
+        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))
+        row += 1
 
         # Create labels and entry fields for each cleaning method
         row = 1
@@ -111,35 +148,80 @@ class InterpolationEditor:
                     text=interp_method,
                     variable=self.cleaning_method_var,
                     value=interp_method,
-                    command=self.action_on_method_change
-                ).grid(row=row, column=0, sticky='w')
+                    command=self.action_on_method_change,
+                ).grid(row=row, column=1, sticky="w")
                 row += 1
 
+        # Separator
+        separator1 = ttk.Separator(main_frame, orient="horizontal")
+        separator1.grid(row=row, column=0, columnspan=3, 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))
+        row += 1
+
         # Create labels and entry fields for each additional parameter
-        label = tk.Label(main_frame, text='Npoints:')
-        label.grid(row=row, column=0, sticky='e', padx=(0, 10))
+        label = tk.Label(main_frame, text="Npoints:")
+        label.grid(row=row, column=0, sticky="e", padx=(0, 10))
         self.entry_npoints = tk.Entry(main_frame, width=10)
         self.entry_npoints.insert(0, self.npoints)
-        self.entry_npoints.grid(row=row, column=1, sticky='w')
+        self.entry_npoints.grid(row=row, column=1, sticky="w")
         row += 1
-        label = tk.Label(main_frame, text='Degree:')
-        label.grid(row=row, column=0, sticky='e', padx=(0, 10))
+        label = tk.Label(main_frame, text="Degree:")
+        label.grid(row=row, column=0, sticky="e", padx=(0, 10))
         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')
+        self.entry_degree.grid(row=row, column=1, sticky="w")
+        row += 1
+
+        # Separator
+        separator2 = ttk.Separator(main_frame, orient="horizontal")
+        separator2.grid(row=row, column=0, columnspan=3, 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))
+        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)
+            # 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)
+            self.entries[key] = entry  # dictionary to hold entry widgets
+            # Type label
+            dumtext = "(int)"
+            if key in ["xmin", "xmax"]:
+                dumtext += f" --> [1, {self.imgshape[1]}]"
+            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
+
+        # Separator
+        separator3 = ttk.Separator(main_frame, orient="horizontal")
+        separator3.grid(row=row, column=0, columnspan=3, 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=2, pady=(15, 0))
+        self.button_frame.grid(row=row, column=0, columnspan=3, pady=(15, 0))
 
         # OK button
         self.ok_button = tk.Button(self.button_frame, text="OK", width=5, command=self.on_ok)
-        self.ok_button.pack(side='left', padx=5)
+        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.pack(side='left', padx=5)
+        self.cancel_button.pack(side="left", padx=5)
 
         # Initial action depending on the default method
         self.action_on_method_change()
@@ -165,10 +247,49 @@ class InterpolationEditor:
             messagebox.showerror("Input Error", "Degree must be non-negative.")
             return
 
-        if self.cleaning_method in ['x', 'y'] and 2 * self.npoints <= self.degree:
+        if self.cleaning_method in ["x", "y"] and 2 * self.npoints <= self.degree:
             messagebox.showerror("Input Error", "2*Npoints must be greater than Degree for x and y interpolation.")
             return
 
+        # Retrieve and validate region parameters
+        try:
+            xmin = int(self.entries["xmin"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "xmin must be an integer.")
+            return
+        try:
+            xmax = int(self.entries["xmax"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "xmax must be an integer.")
+            return
+        if xmin >= xmax:
+            messagebox.showerror("Input Error", "xmin must be less than xmax.")
+            return
+        try:
+            ymin = int(self.entries["ymin"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "ymin must be an integer.")
+            return
+        try:
+            ymax = int(self.entries["ymax"].get())
+        except ValueError:
+            messagebox.showerror("Input Error", "ymax must be an integer.")
+            return
+        if ymin >= ymax:
+            messagebox.showerror("Input Error", "ymin must be less than ymax.")
+            return
+        for key, entry in self.entries.items():
+            value = int(entry.get())
+            if key in ["xmin", "xmax"]:
+                if not (1 <= value <= self.imgshape[1]):
+                    messagebox.showerror("Input Error", f"{key} must be in the range [1, {self.imgshape[1]}].")
+                    return
+            else:
+                if not (1 <= value <= self.imgshape[0]):
+                    messagebox.showerror("Input Error", f"{key} must be in the range [1, {self.imgshape[0]}].")
+                    return
+            self.__dict__[key] = value
+
         self.root.destroy()
 
     def on_cancel(self):
@@ -182,24 +303,24 @@ class InterpolationEditor:
         """Handle changes in the selected cleaning method."""
         selected_method = self.cleaning_method_var.get()
         print(f"Selected cleaning method: {selected_method}")
-        if selected_method in ['x interp.', 'y interp.']:
-            self.entry_npoints.config(state='normal')
-            self.entry_degree.config(state='normal')
-        elif selected_method == 'surface interp.':
-            self.entry_npoints.config(state='normal')
-            self.entry_degree.config(state='disabled')
-        elif selected_method == 'median':
-            self.entry_npoints.config(state='normal')
-            self.entry_degree.config(state='disabled')
-        elif selected_method == 'mean':
-            self.entry_npoints.config(state='normal')
-            self.entry_degree.config(state='disabled')
-        elif selected_method == 'lacosmic':
-            self.entry_npoints.config(state='disabled')
-            self.entry_degree.config(state='disabled')
-        elif selected_method == 'auxdata':
-            self.entry_npoints.config(state='disabled')
-            self.entry_degree.config(state='disabled')
+        if selected_method in ["x interp.", "y interp."]:
+            self.entry_npoints.config(state="normal")
+            self.entry_degree.config(state="normal")
+        elif selected_method == "surface interp.":
+            self.entry_npoints.config(state="normal")
+            self.entry_degree.config(state="disabled")
+        elif selected_method == "median":
+            self.entry_npoints.config(state="normal")
+            self.entry_degree.config(state="disabled")
+        elif selected_method == "mean":
+            self.entry_npoints.config(state="normal")
+            self.entry_degree.config(state="disabled")
+        elif selected_method == "lacosmic":
+            self.entry_npoints.config(state="disabled")
+            self.entry_degree.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."""

teareduce/cleanest/modalprogressbar.py

@@ -0,0 +1,182 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Module defining a progress bar widget for Tkinter."""
+
+import tkinter as tk
+from tkinter import ttk
+import time
+
+
+class ModalProgressBar:
+    def __init__(
+        self, parent, iterable=None, total=None, desc="Processing", completion_msg="Processing completed successfully!"
+    ):
+        self.parent = parent
+        self.iterable = iterable
+        self.total = total if total is not None else (len(iterable) if iterable is not None else 100)
+        self.current = 0
+        self.start_time = time.time()
+        self.window = None
+        self.desc = desc
+        self.completion_msg = completion_msg
+        self.continue_clicked = False
+
+    def __enter__(self):
+        # Create the modal window when entering context
+        self.window = tk.Toplevel(self.parent)
+        self.window.title("Progress")
+
+        # Make it modal
+        self.window.transient(self.parent)
+        self.window.grab_set()
+        self.window.protocol("WM_DELETE_WINDOW", lambda: None)
+
+        # Set geometry and force it
+        minwinsize_x = 400
+        minwinsize_y = 120
+        self.window.minsize(minwinsize_x, minwinsize_y)
+        self.window.update_idletasks()
+        self.window.update()
+
+        # Center on parent
+        self._center_on_parent()
+
+        # UI elements
+        default_font = tk.font.nametofont("TkDefaultFont")
+        bold_font = default_font.copy()
+        bold_font.configure(weight="bold", size=default_font.cget("size") + 2)
+        self.desc_label = tk.Label(self.window, text=self.desc, font=bold_font)
+        self.desc_label.pack(padx=10, pady=5)
+
+        self.progress = ttk.Progressbar(self.window, length=minwinsize_x - 20, mode="determinate", maximum=self.total)
+        self.progress.pack(padx=10, pady=10)
+
+        self.status_label = tk.Label(self.window, text=f"0/{self.total} (0.0%)")
+        self.status_label.pack(padx=10, pady=2)
+
+        self.time_label = tk.Label(self.window, text="Elapsed: 0s | ETA: --")
+        self.time_label.pack(padx=10, pady=2)
+
+        # Continue button (to close the dialog after completion; hidden until done)
+        self.continue_button = tk.Button(self.window, text="Continue", command=self._on_continue)
+        self.continue_button.pack(padx=10, pady=10)
+        self.continue_button.pack_forget()  # Hide initially
+
+        # Force another update
+        self.window.update_idletasks()
+        self.window.update()
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.window:
+            # Show completion screen instead of closing
+            self._show_completion()
+
+            # Wait for user to click Continue
+            self.window.wait_variable(self._continue_var)
+
+            # Now close
+            self._destroy()
+        return False
+
+    def __iter__(self):
+        """Allow iteration like tqdm"""
+        if self.iterable is None:
+            raise ValueError("No iterable provided for iteration")
+
+        for item in self.iterable:
+            yield item
+            self.update(1)
+
+    def _center_on_parent(self):
+        self.window.update_idletasks()
+        x = self.parent.winfo_x() + (self.parent.winfo_width() // 2) - (self.window.winfo_width() // 2)
+        y = self.parent.winfo_y() + (self.parent.winfo_height() // 2) - (self.window.winfo_height() // 2)
+        self.window.geometry(f"+{x}+{y}")
+
+    def update(self, n=1):
+        self.current += n
+        self.progress["value"] = self.current
+        percentage = (self.current / self.total) * 100
+
+        elapsed = time.time() - self.start_time
+
+        if self.current > 0:
+            rate = self.current / elapsed
+            remaining = self.total - self.current
+            eta_seconds = remaining / rate if rate > 0 else 0
+
+            elapsed_str = self._format_time(elapsed)
+            eta_str = self._format_time(eta_seconds)
+            rate_str = f"{rate:.2f} CR/s" if rate >= 1 else f"{1/rate:.2f} s/CR"
+
+            self.status_label.config(text=f"{self.current}/{self.total} ({percentage:.1f}%) | {rate_str}")
+            self.time_label.config(text=f"Elapsed: {elapsed_str} | ETA: {eta_str}")
+
+        self.window.update_idletasks()
+        self.window.update()
+
+    def _format_time(self, seconds):
+        if seconds < 60:
+            return f"{seconds:.1f} s"
+        elif seconds < 3600:
+            minutes = int(seconds // 60)
+            secs = int(seconds % 60)
+            return f"{minutes}m {secs} s"
+        else:
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            return f"{hours}h {minutes} m"
+
+    def _show_completion(self):
+        """Transform the window into a completion dialog"""
+        elapsed = time.time() - self.start_time
+        elapsed_str = self._format_time(elapsed)
+
+        # Update title
+        self.window.title("Completed")
+
+        # Update description to show completion message
+        default_font = tk.font.nametofont("TkDefaultFont")
+        bold_font = default_font.copy()
+        bold_font.configure(weight="bold", size=default_font.cget("size") + 2)
+        self.desc_label.config(text=self.completion_msg, fg="green", font=bold_font)
+
+        # Hide progress bar
+        self.progress.pack_forget()
+
+        # Update status to show final stats
+        avg_rate = self.current / elapsed if elapsed > 0 else 0
+        rate_str = f"{avg_rate:.2f} CR/s" if avg_rate >= 1 else f"{1/avg_rate:.2f} s/CR"
+        self.status_label.config(text=f"Processed {self.current} CRs | {rate_str}")
+
+        # Update time label
+        self.time_label.config(text=f"Total time: {elapsed_str}")
+
+        # Show the Continue button
+        self.continue_button.pack(padx=10, pady=15)
+
+        # Create a variable to track when Continue is clicked
+        self._continue_var = tk.BooleanVar(value=False)
+
+        # Re-enable close button to work like Continue
+        self.window.protocol("WM_DELETE_WINDOW", self._on_continue)
+
+        self.window.update()
+        self._center_on_parent()
+
+    def _on_continue(self):
+        """Called when Continue button is clicked"""
+        self._continue_var.set(True)
+
+    def _destroy(self):
+        self.window.grab_release()
+        self.window.destroy()