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

teareduce/cleanest/definitions.py

@@ -0,0 +1,51 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Definitions for the cleanest module."""
+
+# Default parameters for L.A.Cosmic algorithm
+# Note that 'type' is set to the expected data type for each parameter
+# using the intrinsic Python types, so that they can be easily cast
+# when reading user input.
+lacosmic_default_dict = {
+    # L.A.Cosmic parameters
+    'gain': {'value': 1.0, 'type': float, 'positive': True},
+    'readnoise': {'value': 6.5, 'type': float, 'positive': True},
+    'sigclip': {'value': 4.5, 'type': float, 'positive': True},
+    'sigfrac': {'value': 0.3, 'type': float, 'positive': True},
+    'objlim': {'value': 5.0, 'type': float, 'positive': True},
+    'niter': {'value': 4, 'type': int, 'positive': True},
+    'verbose': {'value': False, 'type': bool},
+    # Dilation of the mask
+    'dilation': {'value': 0, '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}
+}
+
+# Default parameters for cleaning methods
+VALID_CLEANING_METHODS = [
+    'x interp.',
+    'y interp.',
+    'surface interp.',
+    'median',
+    'lacosmic',
+    'auxdata'
+]
+
+# Maximum pixel distance to consider when finding closest CR pixel
+MAX_PIXEL_DISTANCE_TO_CR = 15
+
+# Default number of points for interpolation
+DEFAULT_NPOINTS_INTERP = 2
+
+# Default degree for interpolation
+DEFAULT_DEGREE_INTERP = 1

teareduce/cleanest/find_closest_true.py

@@ -0,0 +1,44 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Find the closest true (CR) pixel to a given (x, y) position."""
+
+import numpy as np
+
+
+def find_closest_true(mask, x, y):
+    """Find the closest True pixel in a boolean mask to the given (x, y) position.
+
+    Parameters
+    ----------
+    mask : 2D numpy.ndarray of bool
+        Boolean mask where True indicates the presence of a cosmic ray pixel.
+    x : int
+        X-coordinate (column index) of the reference position (0-based).
+    y : int
+        Y-coordinate (row index) of the reference position (0-based).
+
+    Returns
+    -------
+    (closest_x, closest_y) : tuple of int
+        Coordinates (0-based) of the closest True pixel in the mask.
+        Returns (None, None) if no True pixels are found.
+    min_distance : float
+        Euclidean distance to the closest True pixel.
+    """
+    true_indices = np.argwhere(mask)
+    if true_indices.size == 0:
+        return None, None
+
+    distances = np.sqrt((true_indices[:, 1] - x) ** 2 + (true_indices[:, 0] - y) ** 2)
+    min_index = np.argmin(distances)
+    closest_y, closest_x = true_indices[min_index]
+    min_distance = distances[min_index]
+
+    return (closest_x, closest_y), min_distance

teareduce/cleanest/imagedisplay.py

@@ -0,0 +1,155 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Base class for image display with min/max and zscale controls."""
+
+from tkinter import simpledialog
+import numpy as np
+
+from ..sliceregion import SliceRegion2D
+from ..zscale import zscale
+
+
+# The functionality defined here is used in multiple classes
+class ImageDisplay:
+    """Class to handle image display with min/max and zscale controls.
+
+    Methods
+    -------
+    set_vmin()
+        Prompt user to set a new minimum display value (vmin).
+    set_vmax()
+        Prompt user to set a new maximum display value (vmax).
+    get_vmin()
+        Get the current minimum display value (vmin).
+    get_vmax()
+        Get the current maximum display value (vmax).
+    get_displayed_region()
+        Get the currently displayed region of the image.
+    set_minmax()
+        Set vmin and vmax based on the currently displayed region.
+    set_zscale()
+        Set vmin and vmax using zscale on the currently displayed region.
+
+    Attributes
+    ----------
+    vmin_button : tkinter.Button
+        Button to display and set the minimum display value (vmin).
+    vmax_button : tkinter.Button
+        Button to display and set the maximum display value (vmax).
+    image : matplotlib.image.AxesImage
+        The main image being displayed.
+    image_aux : matplotlib.image.AxesImage, optional
+        An auxiliary image being displayed (if any).
+    canvas : matplotlib.backends.backend_tkagg.FigureCanvasTkAgg
+        The canvas on which the image is drawn.
+
+    Notes
+    -----
+    This class is intented to be used as a parent class for different
+    classes that display images and need functionality to adjust the
+    display limits (vmin and vmax) interactively.
+
+    This class assumes that the image data is stored in `self.data` and that
+    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()
+        old_vmax = self.get_vmax()
+        new_vmin = simpledialog.askfloat("Set vmin", "Enter new vmin:", initialvalue=old_vmin)
+        if new_vmin is None:
+            return
+        if new_vmin >= old_vmax:
+            print("Error: vmin must be less than vmax.")
+            return
+        self.vmin_button.config(text=f"vmin: {new_vmin:.2f}")
+        self.image.set_clim(vmin=new_vmin)
+        if hasattr(self, 'image_aux'):
+            self.image_aux.set_clim(vmin=new_vmin)
+        self.canvas.draw_idle()
+
+    def set_vmax(self):
+        """Prompt user to set a new maximum display value (vmax)."""
+        old_vmin = self.get_vmin()
+        old_vmax = self.get_vmax()
+        new_vmax = simpledialog.askfloat("Set vmax", "Enter new vmax:", initialvalue=old_vmax)
+        if new_vmax is None:
+            return
+        if new_vmax <= old_vmin:
+            print("Error: vmax must be greater than vmin.")
+            return
+        self.vmax_button.config(text=f"vmax: {new_vmax:.2f}")
+        self.image.set_clim(vmax=new_vmax)
+        if hasattr(self, 'image_aux'):
+            self.image_aux.set_clim(vmax=new_vmax)
+        self.canvas.draw_idle()
+
+    def get_vmin(self):
+        """Get the current minimum display value (vmin)."""
+        return float(self.vmin_button.cget("text").split(":")[1])
+
+    def get_vmax(self):
+        """Get the current maximum display value (vmax)."""
+        return float(self.vmax_button.cget("text").split(":")[1])
+
+    def get_displayed_region(self):
+        """Get the currently displayed region of the image."""
+        if hasattr(self, 'ax'):
+            xmin, xmax = self.ax.get_xlim()
+            xmin = int(xmin + 0.5)
+            if xmin < 1:
+                xmin = 1
+            xmax = int(xmax + 0.5)
+            if xmax > self.data.shape[1]:
+                xmax = self.data.shape[1]
+            ymin, ymax = self.ax.get_ylim()
+            ymin = int(ymin + 0.5)
+            if ymin < 1:
+                ymin = 1
+            ymax = int(ymax + 0.5)
+            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
+        else:
+            raise AttributeError("No axis or region defined for set_minmax.")
+        return region
+
+    def set_minmax(self):
+        """Set vmin and vmax based on the currently displayed region."""
+        region = self.get_displayed_region()
+        vmin_new = np.min(self.data[region])
+        vmax_new = np.max(self.data[region])
+        self.vmin_button.config(text=f"vmin: {vmin_new:.2f}")
+        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'):
+            self.image_aux.set_clim(vmin=vmin_new)
+            self.image_aux.set_clim(vmax=vmax_new)
+        self.canvas.draw_idle()
+
+    def set_zscale(self):
+        """Set vmin and vmax using zscale on the currently displayed region."""
+        region = self.get_displayed_region()
+        vmin_new, vmax_new = zscale(self.data[region])
+        self.vmin_button.config(text=f"vmin: {vmin_new:.2f}")
+        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'):
+            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

@@ -0,0 +1,83 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Surface interpolation (plane fit) or median interpolation"""
+
+import numpy as np
+from scipy.ndimage import binary_dilation
+
+
+def interpolation_a(data, mask_fixed, cr_labels, cr_index, npoints, method):
+    """Interpolate cosmic ray pixels using surface fit or median of border pixels.
+
+    Parameters
+    ----------
+    data : 2D numpy.ndarray
+        The image data array where cosmic rays are to be interpolated.
+    mask_fixed : 2D numpy.ndarray of bool
+        A boolean mask array indicating which pixels have been fixed.
+    cr_labels : 2D numpy.ndarray
+        An array labeling cosmic ray features.
+    cr_index : int
+        The index of the current cosmic ray feature to interpolate.
+    npoints : int
+        The number of points to use for interpolation.
+    method : str
+        The interpolation method to use ('surface' or 'median').
+
+    Returns
+    -------
+    interpolation_performed : bool
+        True if interpolation was performed, False otherwise.
+    xfit_all : list
+        X-coordinates of border pixels used for interpolation.
+    yfit_all : list
+        Y-coordinates of border pixels used for interpolation.
+    """
+    # Mask of CR pixels
+    mask = (cr_labels == cr_index)
+    # Dilate the mask to find border pixels
+    dilated_mask = binary_dilation(mask, structure=np.ones((3, 3)), iterations=npoints)
+    # Border pixels are those in the dilated mask but not in the original mask
+    border_mask = dilated_mask & (~mask)
+    # Get coordinates of border pixels
+    yfit_all, xfit_all = np.where(border_mask)
+    zfit_all = data[yfit_all, xfit_all].tolist()
+    # Perform interpolation
+    interpolation_performed = False
+    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
+            # is z = C[0]*x + C[1]*y + C[2]
+            A = np.c_[xfit_all, yfit_all, np.ones(len(xfit_all))]
+            # Least squares polynomial fit
+            C, _, _, _ = np.linalg.lstsq(A, zfit_all, rcond=None)
+            # recompute all CR pixels to take into account "holes" between marked pixels
+            ycr_list, xcr_list = np.where(cr_labels == cr_index)
+            for iy, ix in zip(ycr_list, xcr_list):
+                data[iy, ix] = C[0] * ix + C[1] * iy + C[2]
+                mask_fixed[iy, ix] = True
+            interpolation_performed = True
+        else:
+            print("Not enough points to fit a plane")
+    elif method == 'median':
+        # Compute median of all surrounding points
+        if len(zfit_all) > 0:
+            zmed = np.median(zfit_all)
+            # recompute all CR pixels to take into account "holes" between marked pixels
+            ycr_list, xcr_list = np.where(cr_labels == cr_index)
+            for iy, ix in zip(ycr_list, xcr_list):
+                data[iy, ix] = zmed
+                mask_fixed[iy, ix] = True
+            interpolation_performed = True
+    else:
+        print(f"Unknown interpolation method: {method}")
+
+    return interpolation_performed, xfit_all, yfit_all

teareduce/cleanest/interpolation_x.py

@@ -0,0 +1,80 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Polynomial nterpolation in the X direction"""
+
+import numpy as np
+
+
+def interpolation_x(data, mask_fixed, cr_labels, cr_index, npoints, degree):
+    """Interpolate cosmic ray affected pixels in the X direction.
+    Parameters
+    ----------
+    data : 2D numpy.ndarray
+        The image data array to be processed.
+    mask_fixed : 2D numpy.ndarray of bool
+        A boolean mask array indicating which pixels have been fixed.
+    cr_labels : 2D numpy.ndarray
+        An array labeling cosmic ray features.
+    cr_index : int
+        The index of the current cosmic ray feature to interpolate.
+    npoints : int
+        The number of points to use for interpolation.
+    degree : int
+        The degree of the polynomial to fit.
+
+    Returns
+    -------
+    interpolation_performed : bool
+        True if interpolation was performed, False otherwise.
+    xfit_all : list
+        X-coordinates of border pixels used for interpolation.
+    yfit_all : list
+        Y-coordinates of border pixels used for interpolation.
+    """
+    ycr_list, xcr_list = np.where(cr_labels == cr_index)
+    ycr_min = np.min(ycr_list)
+    ycr_max = np.max(ycr_list)
+    xfit_all = []
+    yfit_all = []
+    interpolation_performed = False
+    for ycr in range(ycr_min, ycr_max + 1):
+        xmarked = xcr_list[np.where(ycr_list == ycr)]
+        if len(xmarked) > 0:
+            jmin = np.min(xmarked)
+            jmax = np.max(xmarked)
+            # mark intermediate pixels too
+            for ix in range(jmin, jmax + 1):
+                cr_labels[ycr, ix] = cr_index
+            xmarked = xcr_list[np.where(ycr_list == ycr)]
+            xfit = []
+            zfit = []
+            for i in range(jmin - npoints, jmin):
+                if 0 <= i < data.shape[1]:
+                    xfit.append(i)
+                    xfit_all.append(i)
+                    yfit_all.append(ycr)
+                    zfit.append(data[ycr, i])
+            for i in range(jmax + 1, jmax + 1 + npoints):
+                if 0 <= i < data.shape[1]:
+                    xfit.append(i)
+                    xfit_all.append(i)
+                    yfit_all.append(ycr)
+                    zfit.append(data[ycr, i])
+            if len(xfit) > degree:
+                p = np.polyfit(xfit, zfit, degree)
+                for i in range(jmin, jmax + 1):
+                    if 0 <= i < data.shape[1]:
+                        data[ycr, i] = np.polyval(p, i)
+                        mask_fixed[ycr, i] = True
+                interpolation_performed = True
+            else:
+                print(f"Not enough points to fit at y={ycr+1}")
+
+    return interpolation_performed, xfit_all, yfit_all

teareduce/cleanest/interpolation_y.py

@@ -0,0 +1,81 @@
+#
+# Copyright 2025 Universidad Complutense de Madrid
+#
+# This file is part of teareduce
+#
+# SPDX-License-Identifier: GPL-3.0+
+# License-Filename: LICENSE.txt
+#
+
+"""Polynomial nterpolation in the Y direction"""
+
+import numpy as np
+
+
+def interpolation_y(data, mask_fixed, cr_labels, cr_index, npoints, degree):
+    """Interpolate cosmic ray affected pixels in Y direction.
+    Parameters
+    ----------
+    data : 2D numpy.ndarray
+        The image data array to be processed.
+    mask_fixed : 2D numpy.ndarray of bool
+        A boolean mask array indicating which pixels have been fixed.
+    cr_labels : 2D numpy.ndarray
+        An array labeling cosmic ray features.
+    cr_index : int
+        The index of the current cosmic ray feature to interpolate.
+    npoints : int
+        The number of points to use for interpolation.
+    degree : int
+        The degree of the polynomial to fit.
+
+    Returns
+    -------
+    interpolation_performed : bool
+        True if interpolation was performed, False otherwise.
+    xfit_all : list
+        X-coordinates of border pixels used for interpolation.
+    yfit_all : list
+        Y-coordinates of border pixels used for interpolation.
+    """
+    ycr_list, xcr_list = np.where(cr_labels == cr_index)
+    xcr_min = np.min(xcr_list)
+    xcr_max = np.max(xcr_list)
+    xfit_all = []
+    yfit_all = []
+    interpolation_performed = False
+    for xcr in range(xcr_min, xcr_max + 1):
+        ymarked = ycr_list[np.where(xcr_list == xcr)]
+        if len(ymarked) > 0:
+            imin = np.min(ymarked)
+            imax = np.max(ymarked)
+            # mark intermediate pixels too
+            for iy in range(imin, imax + 1):
+                cr_labels[iy, xcr] = cr_index
+            ymarked = ycr_list[np.where(xcr_list == xcr)]
+            yfit = []
+            zfit = []
+            for i in range(imin - npoints, imin):
+                if 0 <= i < data.shape[0]:
+                    yfit.append(i)
+                    yfit_all.append(i)
+                    xfit_all.append(xcr)
+                    zfit.append(data[i, xcr])
+            for i in range(imax + 1, imax + 1 + npoints):
+                if 0 <= i < data.shape[0]:
+                    yfit.append(i)
+                    yfit_all.append(i)
+                    xfit_all.append(xcr)
+                    zfit.append(data[i, xcr])
+            if len(yfit) > degree:
+                p = np.polyfit(yfit, zfit, degree)
+                for i in range(imin, imax + 1):
+                    if 0 <= i < data.shape[1]:
+                        data[i, xcr] = np.polyval(p, i)
+                        mask_fixed[i, xcr] = True
+                interpolation_performed = True
+            else:
+                print(f"Not enough points to fit at x={xcr+1}")
+                return
+
+    return interpolation_performed, xfit_all, yfit_all