teareduce 0.4.9__py3-none-any.whl → 0.5.1__py3-none-any.whl

teareduce/cleanest/interpolationeditor.py

@@ -0,0 +1,207 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Interpolation editor dialog for interpolation parameters."""
+
+import tkinter as tk
+from tkinter import messagebox
+
+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):
+        """Initialize the interpolation editor dialog.
+
+        Parameters
+        ----------
+        root : tk.Tk
+            The root Tkinter window.
+        last_dilation : int
+            The last used dilation parameter.
+        last_npoints : int
+            The last used number of points for interpolation.
+        last_degree : int
+            The last used degree for interpolation.
+        auxdata : array-like or None
+            Auxiliary data for cleaning, if available.
+
+        Methods
+        -------
+        create_widgets()
+            Create the widgets for the dialog.
+        on_ok()
+            Handle the OK button click event.
+        on_cancel()
+            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
+        ----------
+        root : tk.Tk
+            The root Tkinter window.
+        last_dilation : int
+            The last used dilation parameter.
+        auxdata : array-like or None
+            Auxiliary data for cleaning, if available.
+        dict_interp_methods : dict
+            Mapping of interpolation method names to their codes.
+        cleaning_method : str or None
+            The selected cleaning method code.
+        npoints : int
+            The number of points for interpolation.
+        degree : int
+            The degree for interpolation.
+        """
+        self.root = root
+        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",
+            "lacosmic": "lacosmic",
+            "auxdata": "auxdata"
+        }
+        self.check_interp_methods()
+        # Initialize parameters
+        self.cleaning_method = None
+        self.npoints = last_npoints
+        self.degree = last_degree
+        # Create the form
+        self.create_widgets()
+
+    def create_widgets(self):
+        """Create the widgets for the dialog."""
+        # Main frame
+        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))
+
+        # Create labels and entry fields for each cleaning method
+        row = 1
+        self.cleaning_method_var = tk.StringVar(value="surface interp.")
+        for interp_method in self.dict_interp_methods.keys():
+            valid_method = True
+            # 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
+            # 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=0, sticky='w')
+                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))
+        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')
+        row += 1
+        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')
+        row += 1
+
+        # Button frame
+        self.button_frame = tk.Frame(main_frame)
+        self.button_frame.grid(row=row, column=0, columnspan=2, 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)
+
+        # 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)
+
+        # 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()]
+        try:
+            self.npoints = int(self.entry_npoints.get())
+        except ValueError:
+            messagebox.showerror("Input Error", "Npoints must be a positive integer.")
+            return
+        if self.npoints < 1:
+            messagebox.showerror("Input Error", "Npoints must be at least 1.")
+            return
+
+        try:
+            self.degree = int(self.entry_degree.get())
+        except ValueError:
+            messagebox.showerror("Input Error", "Degree must be an integer.")
+            return
+        if self.degree < 0:
+            messagebox.showerror("Input Error", "Degree must be non-negative.")
+            return
+
+        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
+
+        self.root.destroy()
+
+    def on_cancel(self):
+        """Close the dialog without saving selected parameters."""
+        self.cleaning_method = None
+        self.npoints = None
+        self.degree = None
+        self.root.destroy()
+
+    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}")
+        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 == '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."""
+        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}")

teareduce/cleanest/parametereditor.py

@@ -0,0 +1,251 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Parameter editor dialog for L.A.Cosmic parameters."""
+
+import tkinter as tk
+from tkinter import ttk
+from tkinter import messagebox
+
+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.
+
+        Parameters
+        ----------
+        root : tk.Tk
+            The root Tkinter window.
+        param_dict : dict
+            Dictionary with L.A.Cosmic parameters.
+        window_title : str
+            Title of the dialog window.
+        xmin : int
+            Minimum x-coordinate of the region to be examined.
+        xmax : int
+            Maximum x-coordinate of the region to be examined.
+        ymin : int
+            Minimum y-coordinate of the region to be examined.
+        ymax : int
+            Maximum y-coordinate of the region to be examined.
+        imgshape : tuple
+            Shape of the image (height, width).
+
+        Methods
+        -------
+        create_widgets()
+            Create the widgets for the dialog.
+        on_ok()
+            Validate and save the updated values.
+        on_cancel()
+            Close the dialog without saving.
+        on_reset()
+            Reset all fields to original values.
+        get_result()
+            Return the updated dictionary.
+
+        Attributes
+        ----------
+        root : tk.Tk
+            The root Tkinter window.
+        param_dict : dict
+            Dictionary with L.A.Cosmic parameters.
+        imgshape : tuple
+            Shape of the image (height, width).
+        entries : dict
+            Dictionary to hold entry widgets.
+        result_dict : dict or None
+            The updated dictionary of parameters or None if cancelled.
+        """
+        self.root = root
+        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.imgshape = imgshape
+        self.entries = {}  # dictionary to hold entry widgets
+        self.result_dict = None
+
+        # Create the form
+        self.create_widgets()
+
+    def create_widgets(self):
+        """Create the widgets for the dialog."""
+        # Main frame
+        main_frame = tk.Frame(self.root, padx=10, pady=10)
+        main_frame.pack()
+
+        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=3, pady=(0, 15))
+        row += 1
+
+        # Create labels and entry fields for each parameter
+        for key, info in self.param_dict.items():
+            if key.lower() not in ['dilation', '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(info['value']))
+                entry.grid(row=row, column=1, padx=10, pady=5)
+                self.entries[key] = 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=2, sticky='w', pady=5)
+                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=("Arial", 14, "bold"))
+        subtitle_label.grid(row=row, column=0, columnspan=3, 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)
+        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
+
+        # 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=("Arial", 14, "bold"))
+        subtitle_label.grid(row=row, column=0, columnspan=3, 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']:
+                # 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(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']:
+                    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
+        button_frame = tk.Frame(main_frame)
+        button_frame.grid(row=row, column=0, columnspan=3, pady=(5, 0))
+
+        # OK button
+        ok_button = tk.Button(button_frame, text="OK", width=5, command=self.on_ok)
+        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)
+
+        # Reset button
+        reset_button = tk.Button(button_frame, text="Reset", width=5, command=self.on_reset)
+        reset_button.pack(side='left', padx=5)
+
+    def on_ok(self):
+        """Validate and save the updated values"""
+        try:
+            updated_dict = {}
+
+            for key, info in self.param_dict.items():
+                entry_value = self.entries[key].get()
+                value_type = info['type']
+
+                # Convert string to appropriate type
+                if value_type == bool:
+                    # Handle boolean conversion
+                    if entry_value.lower() in ['true', '1', 'yes']:
+                        converted_value = True
+                    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:
+                        raise ValueError(f"Value for {key} must be positive")
+
+                updated_dict[key] = {
+                    'value': converted_value,
+                    'type': value_type
+                }
+
+            # Additional validation for region limits
+            try:
+                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']:
+                    raise ValueError("ymax must be greater than ymin")
+                self.result_dict = updated_dict
+                self.root.destroy()
+            except ValueError as e:
+                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.")
+
+    def on_cancel(self):
+        """Close without saving"""
+        self.result_dict = None
+        self.root.destroy()
+
+    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]
+        for key, info in self.param_dict.items():
+            self.entries[key].delete(0, tk.END)
+            self.entries[key].insert(0, str(info['value']))
+
+    def get_result(self):
+        """Return the updated dictionary"""
+        return self.result_dict