dkist-processing-visp 4.0.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

dkist_processing_visp/models/constants.py

@@ -2,12 +2,15 @@
 
 from enum import Enum
 
+import astropy.units as u
+from astropy.units import Quantity
 from dkist_processing_common.models.constants import ConstantsBase
 
 
 class VispBudName(Enum):
     """Names to be used in Visp buds."""
 
+    arm_id = "ARM_ID"
     num_raster_steps = "NUM_RASTER_STEPS"
     polarimeter_mode = "POLARIMETER_MODE"
     wavelength = "WAVELENGTH"
@@ -22,6 +25,10 @@ class VispBudName(Enum):
     polcal_readout_exp_times = "POLCAL_READOUT_EXP_TIMES"
     non_dark_task_readout_exp_times = "NON_DARK_TASK_READOUT_EXP_TIMES"
     num_map_scans = "NUM_MAP_SCANS"
+    incident_light_angle_deg = "INCIDENT_LIGHT_ANGLE_DEG"
+    reflected_light_angle_deg = "REFLECTED_LIGHT_ANGLE_DEG"
+    grating_constant_inverse_mm = "GRATING_CONSTANT_INVERSE_MM"
+    solar_gain_ip_start_time = "SOLAR_GAIN_IP_START_TIME"
     axis_1_type = "AXIS_1_TYPE"
     axis_2_type = "AXIS_2_TYPE"
     axis_3_type = "AXIS_3_TYPE"
@@ -31,6 +38,16 @@ class VispBudName(Enum):
 class VispConstants(ConstantsBase):
     """Visp specific constants to add to the common constants."""
 
+    @property
+    def arm_id(self) -> str:
+        """
+        Return the current ViSP arm ID.
+
+        Arm IDs are ints in the headers, but we convert them to str here because that's what downstream machinery expects
+        the type to be.
+        """
+        return str(self._db_dict[VispBudName.arm_id])
+
     @property
     def wavelength(self) -> float:
         """Wavelength."""
@@ -76,17 +93,17 @@ class VispConstants(ConstantsBase):
                 raise ValueError(f"No init set known for {retarder_name = }")
 
     @property
-    def lamp_exposure_times(self) -> [float]:
+    def lamp_exposure_times(self) -> list[float]:
         """Find the lamp exposure time."""
         return self._db_dict[VispBudName.lamp_exposure_times.value]
 
     @property
-    def solar_exposure_times(self) -> [float]:
+    def solar_exposure_times(self) -> list[float]:
         """Find the solar exposure time."""
         return self._db_dict[VispBudName.solar_exposure_times.value]
 
     @property
-    def polcal_exposure_times(self) -> [float]:
+    def polcal_exposure_times(self) -> list[float]:
         """Find the polarization calibration exposure time."""
         if self.correct_for_polarization:
             return self._db_dict[VispBudName.polcal_exposure_times.value]
@@ -94,22 +111,22 @@ class VispConstants(ConstantsBase):
             return []
 
     @property
-    def observe_exposure_times(self) -> [float]:
+    def observe_exposure_times(self) -> list[float]:
         """Find the observation exposure time."""
         return self._db_dict[VispBudName.observe_exposure_times.value]
 
     @property
-    def lamp_readout_exp_times(self) -> [float]:
+    def lamp_readout_exp_times(self) -> list[float]:
         """Find the lamp readout exposure time."""
         return self._db_dict[VispBudName.lamp_readout_exp_times.value]
 
     @property
-    def solar_readout_exp_times(self) -> [float]:
+    def solar_readout_exp_times(self) -> list[float]:
         """Find the solar readout exposure time."""
         return self._db_dict[VispBudName.solar_readout_exp_times.value]
 
     @property
-    def polcal_readout_exp_times(self) -> [float]:
+    def polcal_readout_exp_times(self) -> list[float]:
         """Find the polarization calibration readout exposure time."""
         if self.correct_for_polarization:
             return self._db_dict[VispBudName.polcal_readout_exp_times.value]
@@ -117,7 +134,7 @@ class VispConstants(ConstantsBase):
             return []
 
     @property
-    def non_dark_task_readout_exp_times(self) -> [float]:
+    def non_dark_task_readout_exp_times(self) -> list[float]:
         """
         Find all readout exposure times that *need* to exist in a dark IP.
 
@@ -127,10 +144,34 @@ class VispConstants(ConstantsBase):
         return self._db_dict[VispBudName.non_dark_task_readout_exp_times.value]
 
     @property
-    def observe_readout_exp_times(self) -> [float]:
+    def observe_readout_exp_times(self) -> list[float]:
         """Find the observation readout exposure time."""
         return self._db_dict[VispBudName.observe_readout_exp_times.value]
 
+    @property
+    def incident_light_angle_deg(self) -> Quantity:
+        """Return the spectrograph incident light angle [deg]."""
+        return self._db_dict[VispBudName.incident_light_angle_deg] * u.deg
+
+    @property
+    def reflected_light_angle_deg(self) -> Quantity:
+        """
+        Return the spectrograph reflected light angle [deg].
+
+        This angle is the incident light angle plus the angular position of the ViSP arm.
+        """
+        return self._db_dict[VispBudName.reflected_light_angle_deg] * u.deg
+
+    @property
+    def grating_constant_inverse_mm(self) -> Quantity:
+        """Return the spectrograph grating constant [1/mm]."""
+        return self._db_dict[VispBudName.grating_constant_inverse_mm] / u.mm
+
+    @property
+    def solar_gain_ip_start_time(self) -> str:
+        """Return the start time of the SOLAR GAIN Instrument Program."""
+        return self._db_dict[VispBudName.solar_gain_ip_start_time]
+
     @property
     def axis_1_type(self) -> str:
         """Find the type of the first array axis."""

dkist_processing_visp/models/fits_access.py

@@ -6,11 +6,15 @@ from enum import StrEnum
 class VispMetadataKey(StrEnum):
     """Controlled list of names for FITS metadata header keys."""
 
+    arm_id = "VSPARMID"
+    number_of_modulator_states = "VSPNUMST"
     raster_scan_step = "VSPSTP"
     total_raster_steps = "VSPNSTP"
     modulator_state = "VSPSTNUM"
-    number_of_modulator_states = "VSPNUMST"
     polarimeter_mode = "VISP_006"
+    grating_angle_deg = "VSPGRTAN"
+    arm_position_deg = "VSPARMPS"
+    grating_constant_inverse_mm = "VSPGRTCN"
     axis_1_type = "CTYPE1"
     axis_2_type = "CTYPE2"
     axis_3_type = "CTYPE3"

dkist_processing_visp/models/metric_code.py

@@ -0,0 +1,10 @@
+"""Controlled list of quality metric codes."""
+
+from enum import StrEnum
+
+
+class VispMetricCode(StrEnum):
+    """Controlled list of quality metric codes."""
+
+    solar_first_vignette = "SOLAR_CAL_FIRST_VIGNETTE"
+    solar_final_vignette = "SOLAR_CAL_FINAL_VIGNETTE"

dkist_processing_visp/models/parameters.py

@@ -1,9 +1,14 @@
 """Visp calibration pipeline parameters."""
 
 from datetime import datetime
+from random import randint
+from typing import Any
 
+import astropy.units as u
+from dkist_processing_common.models.parameters import ParameterArmIdMixin
 from dkist_processing_common.models.parameters import ParameterBase
 from dkist_processing_common.models.parameters import ParameterWavelengthMixin
+from solar_wavelength_calibration import DownloadConfig
 
 
 class VispParsingParameters(ParameterBase):
@@ -22,7 +27,7 @@ class VispParsingParameters(ParameterBase):
         )
 
 
-class VispParameters(ParameterBase, ParameterWavelengthMixin):
+class VispParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmIdMixin):
     """Put all Visp parameters parsed from the input dataset document in a single property."""
 
     @property
@@ -69,7 +74,7 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
 
     @property
     def hairline_mask_spatial_smoothing_width_px(self) -> float:
-        """Amount to smooth the hairling mask in the spatial direction.
+        """Amount to smooth the hairline mask in the spatial direction.
 
         This helps capture the higher-flux wings of the hairlines that would otherwise require a `hairline_fraction`
         that was so low it captures other optical features.
@@ -134,9 +139,34 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
         return self._find_most_recent_past_value("visp_geo_poly_fit_order")
 
     @property
-    def solar_spectral_avg_window(self):
+    def geo_zone_prominence(self):
+        """Relative peak prominence threshold used to identify strong spectral features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_prominence")
+
+    @property
+    def geo_zone_width(self):
+        """Pixel width used to search for strong spectral features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_width")
+
+    @property
+    def geo_zone_bg_order(self):
+        """Order of polynomial fit used to remove continuum when identifying strong spectral features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_bg_order")
+
+    @property
+    def geo_zone_normalization_percentile(self):
+        """Fraction of CDF to use for normalizing spectrum when search for strong features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_normalization_percentile")
+
+    @property
+    def geo_zone_rel_height(self):
+        """Relative height at which to compute the width of strong spectral features."""
+        return self._find_most_recent_past_value("visp_geo_zone_rel_height")
+
+    @property
+    def solar_spatial_median_filter_width_px(self):
         """Pixel width of spatial median filter used to compute characteristic solar spectra."""
-        return self._find_parameter_closest_wavelength("visp_solar_spectral_avg_window")
+        return self._find_parameter_closest_wavelength("visp_solar_spatial_median_filter_width_px")
 
     @property
     def solar_characteristic_spatial_normalization_percentile(self) -> float:
@@ -146,29 +176,108 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
         )
 
     @property
-    def solar_zone_prominence(self):
-        """Relative peak prominence threshold used to identify strong spectral features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_prominence")
+    def solar_vignette_initial_continuum_poly_fit_order(self) -> int:
+        """
+        Define the order of polynomial to use when fitting the initial continuum function.
+
+        Note that "initial" in this context does not refer to an initial guess in the wavecal fitter, but rather the
+        fact that this represents the initial estimate of the vignette signal.
+        """
+        return self._find_most_recent_past_value(
+            "visp_solar_vignette_initial_continuum_poly_fit_order"
+        )
 
     @property
-    def solar_zone_width(self):
-        """Pixel width used to search for strong spectral features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_width")
+    def solar_vignette_crval_bounds_px(self) -> float:
+        """
+        Define the bounds (in *pixels*) on crval when fitting the initial vignette signal.
+
+        The actual bounds on the value of crval are equal to ± the initial dispersion times this number. Note that the
+        total range searched by the fitting algorithm will be twice this number (in pixels).
+        """
+        return self._find_most_recent_past_value("visp_solar_vignette_crval_bounds_px") * u.pix
 
     @property
-    def solar_zone_bg_order(self):
-        """Order of polynomial fit used to remove continuum when identifying strong spectral features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_bg_order")
+    def solar_vignette_dispersion_bounds_fraction(self) -> float:
+        """
+        Define the ± fraction away from the initial value for bounds on dispersion when fitting the initial vignette signal.
+
+        This value should be between 0 and 1. For example, the minimum bound is `init_value * (1 - solar_vignette_dispersion_bounds_fraction)`.
+        """
+        return self._find_most_recent_past_value("visp_solar_vignette_dispersion_bounds_fraction")
 
     @property
-    def solar_zone_normalization_percentile(self):
-        """Fraction of CDF to use for normalzing spectrum when search for strong features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_normalization_percentile")
+    def solar_vignette_wavecal_fit_kwargs(self) -> dict[str, Any]:
+        """Define extra keyword arguments to pass to the wavelength calibration fitter."""
+        doc_dict = self._find_most_recent_past_value("visp_solar_vignette_wavecal_fit_kwargs")
+        rng_kwarg = dict()
+        fitting_method = doc_dict.get("method", False)
+        if fitting_method in ["basinhopping", "differential_evolution", "dual_annealing"]:
+            rng = randint(1, 1_000_000)
+            rng_kwarg["rng"] = rng
+
+        # The order here allows us to override `rng` in a parameter value
+        fit_kwargs = rng_kwarg | doc_dict
+        return fit_kwargs
 
     @property
-    def solar_zone_rel_height(self):
-        """Relative height at which to compute the width of strong spectral features."""
-        return self._find_most_recent_past_value("visp_solar_zone_rel_height")
+    def solar_vignette_spectral_poly_fit_order(self) -> int:
+        """Define the order of spectral polynomial used when computing the full, 2D vignette signal."""
+        return self._find_most_recent_past_value("visp_solar_vignette_spectral_poly_fit_order")
+
+    @property
+    def solar_vignette_min_samples(self) -> float:
+        """Return fractional number of samples required for the RANSAC regressor used to fit the 2D vignette signal."""
+        return self._find_most_recent_past_value("visp_solar_vignette_min_samples")
+
+    @property
+    def wavecal_camera_lens_parameters(self) -> list[u.Quantity]:
+        r"""
+        Define the 2nd order polynomial coefficients for computing the total camera focal length as a function of wavelength.
+
+        The total focal length of the lens is :math:`f = a_0 + a_1\lambda + a_2\lambda^2` where this property is
+        :math:`[a_0, a_1, a_2]`
+        """
+        value_list = self._find_parameter_for_arm("visp_wavecal_camera_lens_parameters")
+        unit_list = [u.m, u.m / u.nm, u.m / u.nm**2]
+        return [v * u for v, u in zip(value_list, unit_list)]
+
+    @property
+    def wavecal_pixel_pitch_micron_per_pix(self) -> u.Quantity:
+        """Define the physical size of ViSP detector pixels."""
+        return (
+            self._find_most_recent_past_value("visp_wavecal_pixel_pitch_micron_per_pix")
+            * u.micron
+            / u.pix
+        )
+
+    @property
+    def wavecal_atlas_download_config(self) -> DownloadConfig:
+        """Define the `~solar_wavelength_calibration.DownloadConfig` used to grab the Solar atlas used for wavelength calibration."""
+        config_dict = self._find_most_recent_past_value("visp_wavecal_atlas_download_config")
+        return DownloadConfig.model_validate(config_dict)
+
+    @property
+    def wavecal_init_crval_guess_normalization_percentile(self) -> float | None:
+        """Define the CDF percentage used to normalize the Atlas to the input spectrum level when computing an initial CRVAL guess."""
+        return self._find_most_recent_past_value(
+            "visp_wavecal_init_crval_guess_normalization_percentile"
+        )
+
+    @property
+    def wavecal_init_resolving_power(self) -> int:
+        """Define the initial guess for ViSP resolving power in wavecal fits."""
+        return self._find_most_recent_past_value("visp_wavecal_init_resolving_power")
+
+    @property
+    def wavecal_init_straylight_fraction(self) -> float:
+        """Define the initial guess for straylight fraction in wavecal fits."""
+        return self._find_most_recent_past_value("visp_wavecal_init_straylight_fraction")
+
+    @property
+    def wavecal_init_opacity_factor(self) -> float:
+        """Define the initial guess for opacity factor in wavecal fits."""
+        return self._find_most_recent_past_value("visp_wavecal_init_opacity_factor")
 
     @property
     def polcal_spatial_median_filter_width_px(self) -> int:

dkist_processing_visp/parsers/spectrograph_configuration.py

@@ -0,0 +1,75 @@
+"""Buds for parsing the incident and reflected light angles of the ViSP spectrograph."""
+
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.flower_pot import Stem
+from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+
+from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.fits_access import VispMetadataKey
+from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
+
+
+def convert_grating_angle_to_incident_light_angle(grating_angle: float) -> float:
+    """Convert the raw header "grating angle" to the incident light angle expected by the solar wavecal library."""
+    return -1 * grating_angle
+
+
+class IncidentLightAngleBud(TaskUniqueBud):
+    """Special case of `TaskUniqueBud` so we can apply the sign shift to the header incident light angle values."""
+
+    def __init__(self):
+        super().__init__(
+            constant_name=VispBudName.incident_light_angle_deg.value,
+            metadata_key=VispMetadataKey.grating_angle_deg,
+            ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
+            task_type_parsing_function=parse_header_ip_task_with_gains,
+        )
+
+    def setter(self, fits_obj: VispL0FitsAccess) -> float | type[SpilledDirt]:
+        """Apply a sign flip to the raw header value for incident light angle."""
+        grating_angle = super().setter(fits_obj)
+
+        if grating_angle is SpilledDirt:
+            return grating_angle
+
+        return convert_grating_angle_to_incident_light_angle(grating_angle)
+
+
+class ReflectedLightAngleBud(Stem):
+    """Bud that combines the incident light angle and arm position header values to compute the reflected light angle."""
+
+    key_to_petal_dict: dict[str, float]
+
+    def __init__(self):
+        super().__init__(stem_name=VispBudName.reflected_light_angle_deg.value)
+        self.ip_task_types = [
+            task.casefold() for task in [TaskName.observe.value, TaskName.solar_gain.value]
+        ]
+
+    def setter(self, fits_obj: VispL0FitsAccess) -> float | type[SpilledDirt]:
+        """
+        Compute the reflected light angle.
+
+        The reflected light angle is `-1 * fits_objs.grating_angle_deg + fits_obj.arm_position_deg`.
+        """
+        task = parse_header_ip_task_with_gains(fits_obj)
+
+        if task.casefold() in self.ip_task_types:
+            incident_light_angle = convert_grating_angle_to_incident_light_angle(
+                fits_obj.grating_angle_deg
+            )
+            arm_position = fits_obj.arm_position_deg
+            return incident_light_angle + arm_position
+
+        return SpilledDirt
+
+    def getter(self, key: str) -> float:
+        """Get the value for the reflected light angle and raise an error if it is not unique."""
+        value_set = set(self.key_to_petal_dict.values())
+        if len(value_set) > 1:
+            raise ValueError(
+                f"Multiple {self.stem_name} values found for key {key}. Values: {value_set}"
+            )
+        return value_set.pop()

dkist_processing_visp/parsers/visp_l0_fits_access.py

@@ -32,6 +32,7 @@ class VispL0FitsAccess(L0FitsAccess):
     ):
         super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
 
+        self.arm_id: int = self.header[VispMetadataKey.arm_id]
         self.number_of_modulator_states: int = self.header[
             VispMetadataKey.number_of_modulator_states
         ]
@@ -39,6 +40,11 @@ class VispL0FitsAccess(L0FitsAccess):
         self.total_raster_steps: int = self.header[VispMetadataKey.total_raster_steps]
         self.modulator_state: int = self.header[VispMetadataKey.modulator_state]
         self.polarimeter_mode: str = self.header[VispMetadataKey.polarimeter_mode]
+        self.grating_angle_deg: float = self.header[VispMetadataKey.grating_angle_deg]
+        self.arm_position_deg: float = self.header[VispMetadataKey.arm_position_deg]
+        self.grating_constant_inverse_mm: float = self.header[
+            VispMetadataKey.grating_constant_inverse_mm
+        ]
         self.axis_1_type: str = self.header[VispMetadataKey.axis_1_type]
         self.axis_2_type: str = self.header[VispMetadataKey.axis_2_type]
         self.axis_3_type: str = self.header[VispMetadataKey.axis_3_type]

dkist_processing_visp/tasks/geometric.py

@@ -7,9 +7,11 @@ See :doc:`this page </geometric>` for more information.
 from typing import Generator
 
 import numpy as np
+import peakutils
 import peakutils as pku
 import scipy.ndimage as spnd
 import scipy.optimize as spo
+import scipy.signal as sps
 import skimage.exposure as skie
 import skimage.metrics as skim
 import skimage.morphology as skimo
@@ -33,7 +35,6 @@ from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
 from dkist_processing_visp.tasks.mixin.beam_access import BeamAccessMixin
 from dkist_processing_visp.tasks.mixin.corrections import CorrectionsMixin
-from dkist_processing_visp.tasks.mixin.line_zones import LineZonesMixin
 from dkist_processing_visp.tasks.visp_base import VispTaskBase
 
 __all__ = ["GeometricCalibration"]
@@ -44,7 +45,6 @@ class GeometricCalibration(
     BeamAccessMixin,
     CorrectionsMixin,
     QualityMixin,
-    LineZonesMixin,
 ):
     """
     Task class for computing the spectral geometry. Geometry is represented by three quantities.
@@ -1074,11 +1074,11 @@ class GeometricCalibration(
         `compute_single_state_offset`.
         """
         zone_kwargs = {
-            "prominence": self.parameters.solar_zone_prominence,
-            "width": self.parameters.solar_zone_width,
-            "bg_order": self.parameters.solar_zone_bg_order,
-            "normalization_percentile": self.parameters.solar_zone_normalization_percentile,
-            "rel_height": self.parameters.solar_zone_rel_height,
+            "prominence": self.parameters.geo_zone_prominence,
+            "width": self.parameters.geo_zone_width,
+            "bg_order": self.parameters.geo_zone_bg_order,
+            "normalization_percentile": self.parameters.geo_zone_normalization_percentile,
+            "rel_height": self.parameters.geo_zone_rel_height,
         }
         zones = self.compute_line_zones(array, **zone_kwargs)
         logger.info(f"Found {zones = }")
@@ -1088,6 +1088,114 @@ class GeometricCalibration(
 
         return mask
 
+    def compute_line_zones(
+        self,
+        spec_2d: np.ndarray,
+        prominence: float = 0.2,
+        width: float = 2,
+        bg_order: int = 22,
+        normalization_percentile: int = 99,
+        rel_height: float = 0.97,
+    ) -> list[tuple[int, int]]:
+        """
+        Identify spectral regions around strong spectra features.
+
+        Parameters
+        ----------
+        spec_2d
+            Data
+
+        prominence
+            Zone prominence threshold used to identify strong spectral features
+
+        width
+            Zone width
+
+        bg_order
+            Order of polynomial fit used to remove continuum when identifying strong spectral features
+
+        normalization_percentile
+            Compute this percentile of the data along a specified axis
+
+        rel_height
+            The relative height at which the peak width is measured as a percentage of its prominence. E.g., 1.0 measures
+            the peak width at the lowest contour line.
+
+        Returns
+        -------
+        regions
+            List of indices defining the found spectral lines
+
+        """
+        logger.info(
+            f"Finding zones using {prominence=}, {width=}, {bg_order=}, {normalization_percentile=}, and {rel_height=}"
+        )
+        # Compute average along slit to improve signal. Line smearing isn't important here
+        avg_1d = np.mean(spec_2d, axis=1)
+
+        # Convert to an emission spectrum and remove baseline continuum so peakutils has an easier time
+        em_spec = -1 * avg_1d + avg_1d.max()
+        em_spec /= np.nanpercentile(em_spec, normalization_percentile)
+        baseline = peakutils.baseline(em_spec, bg_order)
+        em_spec -= baseline
+
+        # Find indices of peaks
+        peak_idxs = sps.find_peaks(em_spec, prominence=prominence, width=width)[0]
+
+        # Find the rough width based only on the height of the peak
+        #  rips and lips are the right and left borders of the region around the peak
+        _, _, rips, lips = sps.peak_widths(em_spec, peak_idxs, rel_height=rel_height)
+
+        # Convert to ints so they can be used as indices
+        rips = np.floor(rips).astype(int)
+        lips = np.ceil(lips).astype(int)
+
+        # Remove any regions that are contained within another region
+        ranges_to_remove = self.identify_overlapping_zones(rips, lips)
+        rips = np.delete(rips, ranges_to_remove)
+        lips = np.delete(lips, ranges_to_remove)
+
+        return list(zip(rips, lips))
+
+    @staticmethod
+    def identify_overlapping_zones(rips: np.ndarray, lips: np.ndarray) -> list[int]:
+        """
+        Identify line zones that overlap with other zones. Any overlap greater than 1 pixel is flagged.
+
+        Parameters
+        ----------
+        rips
+            Right borders of the region around the peak
+
+        lips
+            Left borders of the region around the peak
+
+        Returns
+        -------
+        overlapping regions
+            List indices into the input arrays that represent an overlapped region that can be removed
+        """
+        all_ranges = [np.arange(zmin, zmax) for zmin, zmax in zip(rips, lips)]
+        ranges_to_remove = []
+        for i in range(len(all_ranges)):
+            target_range = all_ranges[i]
+            for j in range(i + 1, len(all_ranges)):
+                if (
+                    np.intersect1d(target_range, all_ranges[j]).size > 1
+                ):  # Allow for a single overlap just to be nice
+                    if target_range.size > all_ranges[j].size:
+                        ranges_to_remove.append(j)
+                        logger.info(
+                            f"Zone ({all_ranges[j][0]}, {all_ranges[j][-1]}) inside zone ({target_range[0]}, {target_range[-1]})"
+                        )
+                    else:
+                        ranges_to_remove.append(i)
+                        logger.info(
+                            f"Zone ({target_range[0]}, {target_range[-1]}) inside zone ({all_ranges[j][0]}, {all_ranges[j][-1]})"
+                        )
+
+        return ranges_to_remove
+
     @staticmethod
     def high_pass_filter_array(array: np.ndarray) -> np.ndarray:
         """Perform a simple high-pass filter to accentuate narrow features (hairlines and spectra)."""