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

teareduce/cleanest/mergemasks.py

@@ -0,0 +1,58 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Merge peak and tail masks for cosmic ray cleaning."""
+
+import numpy as np
+from scipy import ndimage
+
+
+def merge_peak_tail_masks(mask_peaks, mask_tails):
+    """Merge peak and tail masks for cosmic ray cleaning.
+
+    Tail pixels are preserved only if they correspond to CR features
+    that are also present in the peak mask.
+
+    Parameters
+    ----------
+    mask_peaks : ndarray
+        Boolean array indicating the pixels identified as cosmic ray peaks.
+    mask_tails : ndarray
+        Boolean array indicating the pixels identified as cosmic ray tails.
+
+    Returns
+    -------
+    merged_mask : ndarray
+        Boolean array indicating the merged cosmic ray mask.
+    """
+    # check that input masks are numpy arrays
+    if not isinstance(mask_peaks, np.ndarray) or not isinstance(mask_tails, np.ndarray):
+        raise TypeError("Input masks must be numpy arrays.")
+    # check that input masks have the same shape
+    if mask_peaks.shape != mask_tails.shape:
+        raise ValueError("Input masks must have the same shape.")
+    # check that input masks are boolean arrays
+    if mask_peaks.dtype != bool or mask_tails.dtype != bool:
+        raise TypeError("Input masks must be boolean arrays.")
+
+    # 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)
+    # generate mask of ones at peak pixels
+    mask_peaks_ones = np.zeros(mask_peaks.shape, dtype=float)
+    mask_peaks_ones[mask_peaks] = 1.0
+    # preserve only those tail pixels that are flagged as peaks
+    cr_labels_tails_preserved = mask_peaks_ones * cr_labels_tails
+    # generate new mask with preserved tail pixels
+    merged_mask = np.zeros_like(mask_peaks, dtype=bool)
+    for icr in np.unique(cr_labels_tails_preserved):
+        if icr > 0:
+            merged_mask[cr_labels_tails == icr] = True
+
+    return merged_mask

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)
+            total_str = self._format_time(elapsed + 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"Expected Total: {total_str} | 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()

teareduce/cleanest/parametereditor.py

@@ -13,11 +13,13 @@ import tkinter as tk
 from tkinter import ttk
 from tkinter import messagebox
 
+from .centerchildparent import center_on_parent
 from .definitions import lacosmic_default_dict
 
 
 class ParameterEditor:
     """A dialog to edit L.A.Cosmic parameters."""
+
     def __init__(self, root, param_dict, window_title, xmin, xmax, ymin, ymax, imgshape):
         """Initialize the parameter editor dialog.
 
@@ -31,12 +33,16 @@ class ParameterEditor:
             Title of the dialog window.
         xmin : int
             Minimum x-coordinate of the region to be examined.
+            From 1 to NAXIS1.
         xmax : int
             Maximum x-coordinate of the region to be examined.
+            From 1 to NAXIS1.
         ymin : int
             Minimum y-coordinate of the region to be examined.
+            From 1 to NAXIS2.
         ymax : int
             Maximum y-coordinate of the region to be examined.
+            From 1 to NAXIS2.
         imgshape : tuple
             Shape of the image (height, width).
 
@@ -70,16 +76,17 @@ class ParameterEditor:
         self.root.title(window_title)
         self.param_dict = param_dict
         # Set default region values
-        self.param_dict['xmin']['value'] = xmin
-        self.param_dict['xmax']['value'] = xmax
-        self.param_dict['ymin']['value'] = ymin
-        self.param_dict['ymax']['value'] = ymax
+        self.param_dict["xmin"]["value"] = xmin
+        self.param_dict["xmax"]["value"] = xmax
+        self.param_dict["ymin"]["value"] = ymin
+        self.param_dict["ymax"]["value"] = ymax
         self.imgshape = imgshape
-        self.entries = {'run1': {}, 'run2': {}}  # dictionary to hold entry widgets
+        self.entries = {"run1": {}, "run2": {}}  # dictionary to hold entry widgets
         self.result_dict = None
 
         # 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,97 +97,124 @@ class ParameterEditor:
         row = 0
 
         # Subtitle for L.A.Cosmic parameters
-        subtitle_label = tk.Label(main_frame, text="L.A.Cosmic Parameters", font=("Arial", 14, "bold"))
-        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
+        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="L.A.Cosmic Parameters", font=bold_font)
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 10))
         row += 1
 
         # Create labels and entry fields for each parameter.
+        bold_font_subheader = default_font.copy()
+        bold_font_subheader.configure(weight="bold", size=default_font.cget("size") + 1)
+        label = tk.Label(main_frame, text="Parameter", font=bold_font_subheader, anchor="w", fg="gray")
+        label.grid(row=row, column=0, sticky="e", pady=0)
+        label = tk.Label(main_frame, text="Run 1", font=bold_font_subheader, anchor="w", fg="gray", width=10)
+        label.grid(row=row, column=1, sticky="w", padx=10, pady=0)
+        label = tk.Label(main_frame, text="Run 2", font=bold_font_subheader, anchor="w", fg="gray", width=10)
+        label.grid(row=row, column=2, sticky="w", padx=10, pady=0)
+        label = tk.Label(main_frame, text="Type", font=bold_font_subheader, anchor="w", fg="gray", width=10)
+        label.grid(row=row, column=3, sticky="w", pady=0)
+        row += 1
         # Note: here we are using entry_vars to trace changes in the entries
         # so that we can update the color of run2 entries if they differ from run1.
         self.entry_vars = {}
         for key, info in self.param_dict.items():
-            if not key.startswith('run1_'):
+            if not key.startswith("run1_"):
                 continue
             # Parameter name label
-            label = tk.Label(main_frame, text=f"{key[5:]}:", anchor='e', width=15)
-            label.grid(row=row, column=0, sticky='w', pady=5)
+            label = tk.Label(main_frame, text=f"{key[5:]}:", anchor="e", width=15)
+            label.grid(row=row, column=0, sticky="w", pady=5)
             # Entry field for run1
             self.entry_vars[key] = tk.StringVar()
-            self.entry_vars[key].trace_add('write', lambda *args: self.update_colour_param_run1_run2())
+            self.entry_vars[key].trace_add("write", lambda *args: self.update_colour_param_run1_run2())
             entry = tk.Entry(main_frame, textvariable=self.entry_vars[key], width=10)
-            entry.insert(0, str(info['value']))
+            entry.insert(0, str(info["value"]))
             entry.grid(row=row, column=1, padx=10, pady=5)
             self.entries[key] = entry  # dictionary to hold entry widgets
             # Entry field for run2
-            key2 = 'run2_' + key[5:]
+            key2 = "run2_" + key[5:]
             self.entry_vars[key2] = tk.StringVar()
-            self.entry_vars[key2].trace_add('write', lambda *args: self.update_colour_param_run1_run2())
+            self.entry_vars[key2].trace_add("write", lambda *args: self.update_colour_param_run1_run2())
             entry = tk.Entry(main_frame, textvariable=self.entry_vars[key2], width=10)
-            entry.insert(0, str(self.param_dict[key2]['value']))
+            entry.insert(0, str(self.param_dict[key2]["value"]))
             entry.grid(row=row, column=2, padx=10, pady=5)
-            self.entries['run2_'+key[5:]] = entry  # dictionary to hold entry widgets
+            self.entries["run2_" + key[5:]] = entry  # dictionary to hold entry widgets
             # Type label
-            type_label = tk.Label(main_frame, text=f"({info['type'].__name__})", fg='gray', anchor='w', width=10)
-            type_label.grid(row=row, column=3, sticky='w', pady=5)
+            type_label = tk.Label(main_frame, text=f"({info['type'].__name__})", fg="gray", anchor="w", width=10)
+            type_label.grid(row=row, column=3, sticky="w", pady=5)
             row += 1
         # self.update_colour_param_run1_run2()
 
         # Separator
-        separator1 = ttk.Separator(main_frame, orient='horizontal')
-        separator1.grid(row=row, column=0, columnspan=4, sticky='ew', pady=(10, 10))
+        separator1 = ttk.Separator(main_frame, orient="horizontal")
+        separator1.grid(row=row, column=0, columnspan=4, sticky="ew", pady=(10, 10))
         row += 1
 
         # Subtitle for additional parameters
-        subtitle_label = tk.Label(main_frame, text="Additional Parameters", font=("Arial", 14, "bold"))
-        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
+        subtitle_label = tk.Label(main_frame, text="Additional Parameters", font=bold_font)
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 10))
         row += 1
 
         # Dilation label and entry
-        label = tk.Label(main_frame, text="Dilation:", anchor='e', width=15)
-        label.grid(row=row, column=0, sticky='w', pady=5)
+        label = tk.Label(main_frame, text="Dilation:", anchor="e", width=15)
+        label.grid(row=row, column=0, sticky="w", pady=5)
+        entry = tk.Entry(main_frame, width=10)
+        entry.insert(0, str(self.param_dict["dilation"]["value"]))
+        entry.grid(row=row, column=1, padx=10, pady=5)
+        self.entries["dilation"] = entry
+        type_label = tk.Label(
+            main_frame, text=f"({self.param_dict['dilation']['type'].__name__})", fg="gray", anchor="w", width=10
+        )
+        type_label.grid(row=row, column=2, sticky="w", pady=5)
+        row += 1
+
+        label = tk.Label(main_frame, text="Border Padding:", anchor="e", width=15)
+        label.grid(row=row, column=0, sticky="w", pady=5)
         entry = tk.Entry(main_frame, width=10)
-        entry.insert(0, str(self.param_dict['dilation']['value']))
+        entry.insert(0, str(self.param_dict["borderpadd"]["value"]))
         entry.grid(row=row, column=1, padx=10, pady=5)
-        self.entries['dilation'] = entry
-        type_label = tk.Label(main_frame, text=f"({self.param_dict['dilation']['type'].__name__})",
-                              fg='gray', anchor='w', width=10)
-        type_label.grid(row=row, column=2, sticky='w', pady=5)
+        self.entries["borderpadd"] = entry
+        type_label = tk.Label(
+            main_frame, text=f"({self.param_dict['borderpadd']['type'].__name__})", fg="gray", anchor="w", width=10
+        )
+        type_label.grid(row=row, column=2, sticky="w", pady=5)
         row += 1
 
         # Separator
-        separator2 = ttk.Separator(main_frame, orient='horizontal')
-        separator2.grid(row=row, column=0, columnspan=4, sticky='ew', pady=(10, 10))
+        separator2 = ttk.Separator(main_frame, orient="horizontal")
+        separator2.grid(row=row, column=0, columnspan=4, 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=("Arial", 14, "bold"))
-        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
+        subtitle_label = tk.Label(main_frame, text="Region to be Examined", font=bold_font)
+        subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 10))
         row += 1
 
         # Region to be examined label and entries
         for key, info in self.param_dict.items():
-            if key.lower() in ['xmin', 'xmax', 'ymin', 'ymax']:
+            if key.lower() 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", 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(info['value']))
+                entry.insert(0, str(info["value"]))
                 entry.grid(row=row, column=1, padx=10, pady=5)
                 self.entries[key] = entry  # dictionary to hold entry widgets
                 # Type label
                 dumtext = f"({info['type'].__name__})"
-                if key.lower() in ['xmax', 'ymax']:
+                if key.lower() 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)
+                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=4, sticky='ew', pady=(10, 10))
+        separator3 = ttk.Separator(main_frame, orient="horizontal")
+        separator3.grid(row=row, column=0, columnspan=4, sticky="ew", pady=(10, 10))
         row += 1
 
         # Button frame
@@ -189,15 +223,15 @@ class ParameterEditor:
 
         # OK button
         ok_button = tk.Button(button_frame, text="OK", width=5, command=self.on_ok)
-        ok_button.pack(side='left', padx=5)
+        ok_button.pack(side="left", padx=5)
 
         # Cancel button
         cancel_button = tk.Button(button_frame, text="Cancel", width=5, command=self.on_cancel)
-        cancel_button.pack(side='left', padx=5)
+        cancel_button.pack(side="left", padx=5)
 
         # Reset button
         reset_button = tk.Button(button_frame, text="Reset", width=5, command=self.on_reset)
-        reset_button.pack(side='left', padx=5)
+        reset_button.pack(side="left", padx=5)
 
     def on_ok(self):
         """Validate and save the updated values"""
@@ -205,61 +239,60 @@ class ParameterEditor:
             updated_dict = {}
 
             for key, info in self.param_dict.items():
-                if key == 'nruns':
+                if key == "nruns":
                     continue
                 entry_value = self.entries[key].get()
-                value_type = info['type']
+                value_type = info["type"]
 
                 # Convert string to appropriate type
                 if value_type == bool:
                     # Handle boolean conversion
-                    if entry_value.lower() in ['true', '1', 'yes']:
+                    if entry_value.lower() in ["true", "1", "yes"]:
                         converted_value = True
-                    elif entry_value.lower() in ['false', '0', 'no']:
+                    elif entry_value.lower() in ["false", "0", "no"]:
                         converted_value = False
                     else:
                         raise ValueError(f"Invalid boolean value for {key}")
                 else:
                     converted_value = value_type(entry_value)
-                    if 'positive' in info and info['positive'] and converted_value < 0:
+                    if "positive" in info and info["positive"] and converted_value < 0:
                         raise ValueError(f"Value for {key} must be positive")
 
-                updated_dict[key] = {
-                    'value': converted_value,
-                    'type': value_type
-                }
+                updated_dict[key] = {"value": converted_value, "type": value_type}
 
             # Check whether any run1 and run2 parameters differ
             nruns = 1
             for key in self.param_dict.keys():
-                if key.startswith('run1_'):
+                if key.startswith("run1_"):
                     parname = key[5:]
-                    key2 = 'run2_' + parname
-                    if updated_dict[key]['value'] != updated_dict[key2]['value']:
+                    key2 = "run2_" + parname
+                    if updated_dict[key]["value"] != updated_dict[key2]["value"]:
                         nruns = 2
-                        print(f"Parameter '{parname}' differs between run1 and run2: "
-                              f"{updated_dict[key]['value']} (run1) vs {updated_dict[key2]['value']} (run2)")
+                        print(
+                            f"Parameter '{parname}' differs between run1 and run2: "
+                            f"{updated_dict[key]['value']} (run1) vs {updated_dict[key2]['value']} (run2)"
+                        )
 
             # Additional validation for region limits
             try:
-                if updated_dict['xmax']['value'] <= updated_dict['xmin']['value']:
+                if updated_dict["xmax"]["value"] <= updated_dict["xmin"]["value"]:
                     raise ValueError("xmax must be greater than xmin")
-                if updated_dict['ymax']['value'] <= updated_dict['ymin']['value']:
+                if updated_dict["ymax"]["value"] <= updated_dict["ymin"]["value"]:
                     raise ValueError("ymax must be greater than ymin")
                 self.result_dict = updated_dict
-                self.result_dict['nruns'] = {'value': nruns, 'type': int, 'positive': True}
+                self.result_dict["nruns"] = {"value": nruns, "type": int, "positive": True}
                 if nruns not in [1, 2]:
                     raise ValueError("nruns must be 1 or 2")
                 self.root.destroy()
             except ValueError as e:
-                messagebox.showerror("Invalid Inputs",
-                                     "Error in region limits:\n"
-                                     f"{str(e)}\n\nPlease check your inputs.")
+                messagebox.showerror(
+                    "Invalid Inputs", "Error in region limits:\n" f"{str(e)}\n\nPlease check your inputs."
+                )
 
         except ValueError as e:
-            messagebox.showerror("Invalid Inputs",
-                                 f"Error converting value for {key}:\n{str(e)}\n\n"
-                                 "Please check your inputs.")
+            messagebox.showerror(
+                "Invalid Inputs", f"Error converting value for {key}:\n{str(e)}\n\n" "Please check your inputs."
+            )
 
     def on_cancel(self):
         """Close without saving"""
@@ -269,15 +302,15 @@ class ParameterEditor:
     def on_reset(self):
         """Reset all fields to original values"""
         self.param_dict = lacosmic_default_dict.copy()
-        self.param_dict['xmin']['value'] = 1
-        self.param_dict['xmax']['value'] = self.imgshape[1]
-        self.param_dict['ymin']['value'] = 1
-        self.param_dict['ymax']['value'] = self.imgshape[0]
+        self.param_dict["xmin"]["value"] = 1
+        self.param_dict["xmax"]["value"] = self.imgshape[1]
+        self.param_dict["ymin"]["value"] = 1
+        self.param_dict["ymax"]["value"] = self.imgshape[0]
         for key, info in self.param_dict.items():
-            if key == 'nruns':
+            if key == "nruns":
                 continue
             self.entries[key].delete(0, tk.END)
-            self.entries[key].insert(0, str(info['value']))
+            self.entries[key].insert(0, str(info["value"]))
 
     def get_result(self):
         """Return the updated dictionary"""
@@ -287,10 +320,10 @@ class ParameterEditor:
         """Update the foreground color of run1 and run2 entries."""
         # Highlight run2 parameter if different from run1
         for key in self.param_dict.keys():
-            if key.startswith('run1_'):
+            if key.startswith("run1_"):
                 parname = key[5:]
-                if key in self.entries and 'run2_'+parname in self.entries:
-                    if self.entries[key].get() != self.entries['run2_'+parname].get():
-                        self.entries['run2_'+parname].config(fg='red')
+                if key in self.entries and "run2_" + parname in self.entries:
+                    if self.entries[key].get() != self.entries["run2_" + parname].get():
+                        self.entries["run2_" + parname].config(fg="red")
                     else:
-                        self.entries['run2_'+parname].config(fg='black')
+                        self.entries["run2_" + parname].config(fg="black")