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

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,7 +97,10 @@ 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"))
+        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, 15))
         row += 1
 
@@ -99,88 +109,101 @@ class ParameterEditor:
         # 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 = tk.Label(main_frame, text="Additional Parameters", font=bold_font)
         subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
         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 = tk.Label(main_frame, text="Region to be Examined", font=bold_font)
         subtitle_label.grid(row=row, column=0, columnspan=4, pady=(0, 15))
         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 +212,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 +228,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 +291,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 +309,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")