dkist-processing-trend 0.1.0__py3-none-any.whl

dkist_processing_trend/tasks/visp/visp_dmpd.py

@@ -0,0 +1,410 @@
+"""Task for producing ViSP Demodulated PolcalData (DMPD)."""
+
+from dataclasses import dataclass
+from functools import cached_property
+
+import numpy as np
+from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.codecs.fits import fits_array_decoder
+from dkist_processing_common.codecs.fits import fits_array_encoder
+from dkist_processing_math.arithmetic import divide_arrays_by_array
+from dkist_processing_math.arithmetic import subtract_array_from_arrays
+from dkist_processing_math.linear_algebra import nd_left_matrix_multiply
+from dkist_processing_math.statistics import average_numpy_arrays
+from dkist_service_configuration.logging import logger
+from scipy.ndimage import affine_transform
+
+from dkist_processing_trend.models.fit_options import FitOptions
+from dkist_processing_trend.models.instrument_options import VispInstrumentOptions
+from dkist_processing_trend.models.tags import TrendTag
+from dkist_processing_trend.tasks.trend_base import TrendArmTaskBase
+from dkist_processing_trend.tasks.visp.visp_extract_beam import extract_visp_beam
+
+__all__ = ["VispDemodulatedPolcalData"]
+
+
+@dataclass
+class VispCalibrationCollection:
+    """Dataclass to hold all calibration objects needed for ViSP "science" calibration."""
+
+    dark: np.ndarray
+    gain: np.ndarray
+    angle: dict
+    shift: dict
+    demod_matrices: dict
+
+    @cached_property
+    def beams_overlap_slice(self) -> tuple[slice, slice]:
+        """
+        Compute array slices that will extract the largest region with overlap from both beams.
+
+        This is done by considering the shifts computed by the GeometricCalibration task. Any sub-pixel
+        overlaps are rounded to the next integer that still guarantees overlap.
+
+        When "start pixels" are mentioned, those are pixels being counted from zero on a given axis in the positive direction.
+        When "end pixels" are mentioned, those are pixels being counted from the end of a given axis in the negative direction.
+        """
+        logger.info("Computing beam overlap slices")
+        # This will be a flat list of (x, y) pairs for both beams
+        flat_shifts = list(self.shift.values())
+        # Split out into an x list and a y list
+        all_x_shifts, all_y_shifts = zip(*flat_shifts)
+        all_x_shifts = np.array(all_x_shifts)
+        all_y_shifts = np.array(all_y_shifts)
+
+        logger.info(f"All x shifts: {all_x_shifts}")
+        logger.info(f"All y shifts: {all_y_shifts}")
+
+        # The amount we need to "slice in" from the start of the array is equivalent to the absolute value of the most negative shift.
+        # The call to `np.ceil` ensures that the integer rounding doesn't allow non-overlap regions to leak in.
+        start_pixels_to_slice_x = int(np.ceil(abs(np.min(all_x_shifts))))
+        start_pixels_to_slice_y = int(np.ceil(abs(np.min(all_y_shifts))))
+
+        # The amount we need to "chop off" the end of the array is the most positive shift.
+        #
+        # Here we rely on the fact that the fiducial array's shift is *always* (0, 0)
+        # (see `geometric.compute_modstate_offset`). Thus, if there are no negative shifts then the following lines
+        # will result in None. This is required for slicing because array[x:0] is no good. So if the max is 0 then we
+        # end up with array[x:None] which goes all the way to the end of the array.
+        #
+        # The call to `np.ceil` ensures that the integer rounding doesn't allow non-overlap regions to leak in.
+        # (because more negative slices will cut out more data).
+        end_pixels_to_slice_x = int(np.ceil(np.max(all_x_shifts))) or None
+        end_pixels_to_slice_y = int(np.ceil(np.max(all_y_shifts))) or None
+
+        # As the pixels to remove from the end of axes is given as a positive number, we need to make it negative for slicing.
+        if end_pixels_to_slice_x is not None:
+            end_pixels_to_slice_x *= -1
+
+        if end_pixels_to_slice_y is not None:
+            end_pixels_to_slice_y *= -1
+
+        # Construct the slices
+        x_slice = slice(start_pixels_to_slice_x, end_pixels_to_slice_x)
+        y_slice = slice(start_pixels_to_slice_y, end_pixels_to_slice_y)
+
+        logger.info(f"Trimming non-overlapping beam edges by ({x_slice}, {y_slice})")
+        return x_slice, y_slice
+
+
+class VispDemodulatedPolcalData(TrendArmTaskBase):
+    """
+    Task class for producing demodulated polcal data (DMPD) for ViSP.
+
+    Demodulated polcal data is essentially a "science" reduction of the input POLCAL data.
+
+    Parameters
+    ----------
+    arm_id
+        id of the instrument arm to operate on
+
+    recipe_run_id
+        id of the recipe run used to identify the workflow run this task is part of
+
+    workflow_name
+        name of the workflow to which this instance of the task belongs
+
+    workflow_version
+        version of the workflow to which this instance of the task belongs
+    """
+
+    record_provenance = True
+
+    def run(self):
+        """
+        Loop over all PAC and instrument options and produce a set of demodulated polcal data for each.
+
+        The "set" includes data for each beam prior to combination and then a final array for the combined data.
+
+        Generally, the algorithm for each set of PAC and instrument options is:
+
+        #. Collect all calibration objects needed (dark, gain, geometric, demodulation matrices)
+        #. Apply dark and gain corrections
+        #. Split by beam and demodulated
+        #. Apply geometric corrections
+        #. Combined beams
+        #. Save each beam's output and the combined output
+        """
+        for fit_options in self.parameters.fit_options_list:
+            for inst_options in self.parameters.instrument_processing_options:
+                log_str = f"fit option {fit_options.name} and instrument option {inst_options.name}"
+
+                logger.info(f"Collecting calibration objects for {log_str}")
+                calibrations = self.collect_calibration_objects(
+                    fit_options=fit_options, instrument_options=inst_options
+                )
+                beam_array = extract_visp_beam(
+                    calibrations.gain, beam=1, beam_border=self.parameters.visp_beam_border
+                )
+                beam_shape = beam_array.shape
+                x_slice, y_slice = calibrations.beams_overlap_slice
+                cut_shape = beam_array[x_slice, y_slice].shape
+
+                with self.telemetry_span(f"Processing {self.constants.num_cs_steps} CS steps"):
+                    beam1_full_dmpd = np.full(
+                        (1, self.constants.num_cs_steps, 4, *cut_shape), np.nan, dtype=np.float32
+                    )
+                    beam2_full_dmpd = np.full_like(beam1_full_dmpd, np.nan)
+                    combined_full_dmpd = np.full_like(beam1_full_dmpd, np.nan)
+                    for cs_step in range(self.constants.num_cs_steps):
+                        logger.info(
+                            f"Processing demodulated polcal data for {cs_step = } with {log_str}"
+                        )
+                        beam1_dmpd, beam2_dmpd, combined_dmpd = self.process_single_cs_step(
+                            cs_step=cs_step, calibrations=calibrations, beam_shape=beam_shape
+                        )
+
+                        # np.moveaxis here because the stokes axis is the last axis in `self.process_single_cs_step`
+                        # (to make math easier), but we want the DMPD outputs to have stokes before the array axes.
+                        beam1_full_dmpd[0, cs_step, :, :, :] = np.moveaxis(beam1_dmpd, -1, 0)
+                        beam2_full_dmpd[0, cs_step, :, :, :] = np.moveaxis(beam2_dmpd, -1, 0)
+                        combined_full_dmpd[0, cs_step, :, :, :] = np.moveaxis(combined_dmpd, -1, 0)
+
+                self.write_dmpd(
+                    beam1_full_dmpd,
+                    beam=1,
+                    fit_options=fit_options,
+                    instrument_options=inst_options,
+                )
+                del beam1_full_dmpd
+
+                self.write_dmpd(
+                    beam2_full_dmpd,
+                    beam=2,
+                    fit_options=fit_options,
+                    instrument_options=inst_options,
+                )
+                del beam2_full_dmpd
+
+                self.write_dmpd(
+                    combined_full_dmpd,
+                    fit_options=fit_options,
+                    instrument_options=inst_options,
+                    beam=None,
+                )
+                del combined_dmpd
+
+    def collect_calibration_objects(
+        self, fit_options: FitOptions, instrument_options: VispInstrumentOptions
+    ) -> VispCalibrationCollection:
+        """Collect the INTERMEDIATE calibration objects needed to correct demodulated polcal data."""
+        angle_dict = dict()
+        shift_dict = dict()
+        demod_dict = dict()
+
+        base_tags = [TrendTag.intermediate(), TrendTag.arm_id(self.arm_id)]
+
+        # Dark
+        ######
+        full_dark_array = next(
+            self.read(
+                tags=base_tags + [TrendTag.frame(), TrendTag.task_dark()],
+                decoder=fits_array_decoder,
+            )
+        )
+
+        # Gain
+        #######
+        full_gain_array = next(
+            self.read(
+                tags=base_tags + [TrendTag.frame(), TrendTag.task_gain()],
+                decoder=fits_array_decoder,
+            )
+        )
+
+        for beam in [1, 2]:
+            beam_tags = base_tags + [TrendTag.beam(beam)]
+
+            # Geo
+            #######
+            geo_dict = next(
+                self.read(
+                    tags=beam_tags + [TrendTag.task_visp_geometric_calibration()],
+                    decoder=asdf_decoder,
+                )
+            )
+            angle_dict[TrendTag.beam(beam)] = geo_dict["angle_rad"]
+            shift_dict[TrendTag.beam(beam)] = geo_dict["shift"]
+
+            # Demod
+            #######
+            demod_matrices = next(
+                self.read(
+                    tags=beam_tags
+                    + [
+                        TrendTag.pac_fit_options(fit_options.name),
+                        TrendTag.instrument_processing_options(instrument_options.name),
+                        TrendTag.task_processed_demodulation_matrices(),
+                    ],
+                    decoder=fits_array_decoder,
+                )
+            )
+            demod_dict[TrendTag.beam(beam)] = demod_matrices
+
+        return VispCalibrationCollection(
+            dark=full_dark_array,
+            gain=full_gain_array,
+            angle=angle_dict,
+            shift=shift_dict,
+            demod_matrices=demod_dict,
+        )
+
+    def process_single_cs_step(
+        self,
+        cs_step: int,
+        calibrations: VispCalibrationCollection,
+        beam_shape: tuple[int, int],
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Fully process the data for a single CS step.
+
+        To simplify the code, the dark and gain corrections are done on the full-frame before beam extraction.
+        Demodulation and geometric corrections are applied on a per-beam basis.
+
+        All outputs are trimmed to only include the regions that exist in both beams.
+
+        Returns
+        -------
+        The corrected beam 1 array
+        The corrected beam 2 array
+        The corrected combined array
+        """
+        modstate_full_frame_data_list = []
+        for modstate in range(1, self.constants.num_modstates + 1):
+            tags = [
+                TrendTag.input(),
+                TrendTag.frame(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.task_polcal(),
+                TrendTag.cs_step(cs_step),
+                TrendTag.modstate(modstate),
+            ]
+            input_arrays = self.read(tags=tags, decoder=fits_array_decoder)
+            avg_input = average_numpy_arrays(input_arrays)
+
+            dark_corrected = subtract_array_from_arrays(
+                arrays=avg_input, array_to_subtract=calibrations.dark
+            )
+            gain_corrected = next(
+                divide_arrays_by_array(arrays=dark_corrected, array_to_divide_by=calibrations.gain)
+            )
+
+            modstate_full_frame_data_list.append(gain_corrected)
+
+        final_beam_data_list = []
+        for beam in [1, 2]:
+            demod_matrices = calibrations.demod_matrices[TrendTag.beam(beam)]
+            beam_stack = np.full(beam_shape + (self.constants.num_modstates,), np.nan)
+            for modstate in range(1, self.constants.num_modstates + 1):
+                full_frame_data = modstate_full_frame_data_list[modstate - 1]
+                beam_data = extract_visp_beam(
+                    full_frame_data, beam=beam, beam_border=self.parameters.visp_beam_border
+                )
+                beam_stack[:, :, modstate - 1] = beam_data
+
+            demodulated_data = nd_left_matrix_multiply(
+                vector_stack=beam_stack,
+                matrix_stack=demod_matrices,
+            )
+
+            geo_corrected = np.full_like(demodulated_data, np.nan)
+            for s in range(demodulated_data.shape[-1]):
+                geo_corrected[:, :, s] = self.correct_geometry(
+                    demodulated_data[:, :, s],
+                    angle=calibrations.angle[TrendTag.beam(beam)],
+                    shift=calibrations.shift[TrendTag.beam(beam)],
+                )
+
+            x_slice, y_slice = calibrations.beams_overlap_slice
+            cut_array = geo_corrected[x_slice, y_slice, :].astype(np.float32)
+
+            final_beam_data_list.append(cut_array)
+
+        combined_data = self.combine_beams(
+            beam1_data=final_beam_data_list[0], beam2_data=final_beam_data_list[1]
+        ).astype(np.float32)
+
+        return final_beam_data_list[0], final_beam_data_list[1], combined_data
+
+    def combine_beams(self, beam1_data: np.ndarray, beam2_data: np.ndarray) -> np.ndarray:
+        r"""
+        Combine polarimetric beams so that polarization states are normalized by the intensity state (Stokes I).
+
+        In other words:
+
+        .. math::
+
+                I_{avg} & = (I_1 + I_2) / 2
+
+                Q_{avg} & = I_{avg} (Q_1 / I_1 + Q_2 / I_2) / 2
+
+        ...and the same for U and V
+        """
+        avg_data = np.zeros_like(beam1_data)
+
+        # Rely on the fact that the Stokes states are in order after demodulation
+        avg_I = (beam1_data[:, :, 0] + beam2_data[:, :, 0]) / 2.0
+        avg_data[:, :, 0] = avg_I
+
+        for stokes in range(1, 4):
+            beam1_norm = beam1_data[:, :, stokes] / beam1_data[:, :, 0]
+            beam2_norm = beam2_data[:, :, stokes] / beam2_data[:, :, 0]
+            avg_data[:, :, stokes] = avg_I * (beam1_norm + beam2_norm) / 2.0
+
+        return avg_data
+
+    def correct_geometry(
+        self, array: np.ndarray, angle: float, shift: tuple[float, float]
+    ) -> np.ndarray:
+        """
+        Rotate and shift an array.
+
+        Note that the input ``angle`` and ``shift`` arguments are the *amount to rotate/shift by*. They are passed straight
+        through to the affine transform.
+        """
+        array_shape = array.shape
+        cosine_angle = np.cos(angle)
+        sine_angle = np.sin(angle)
+        inverse_rotation_matrix = np.array(
+            [[cosine_angle, -sine_angle], [sine_angle, cosine_angle]],
+            dtype=np.float64,
+        )
+
+        rotation_center = 0.5 * (np.asarray(array_shape, dtype=np.float64) - 1.0)
+        transform_offset = rotation_center + shift - inverse_rotation_matrix @ rotation_center
+
+        corrected_array = affine_transform(
+            array,
+            matrix=inverse_rotation_matrix,
+            offset=transform_offset,
+            order=5,
+            mode="nearest",
+            cval=np.nan,
+            prefilter=True,
+        )
+        return corrected_array
+
+    def write_dmpd(
+        self,
+        array: np.ndarray,
+        beam: int | None,
+        fit_options: FitOptions,
+        instrument_options: VispInstrumentOptions,
+    ) -> None:
+        """
+        Write a demodulated polcal data output to scratch.
+
+        If ``beam`` is not `None` then the output will be tagged as a `~dkist_processing_trend.models.tags.TrendTag.task_single_beam_demodulated_polcal_data`,
+        otherwise the output is tagged with `~dkist_processing_trend.models.tags.TrendTag.task_demodulated_polcal_data`.
+        """
+        tags = [
+            TrendTag.intermediate(),
+            TrendTag.arm_id(self.arm_id),
+            TrendTag.pac_fit_options(fit_options.name),
+            TrendTag.instrument_processing_options(instrument_options.name),
+        ]
+        if beam is not None:
+            tags += [TrendTag.beam(beam), TrendTag.task_single_beam_demodulated_polcal_data()]
+        else:
+            tags.append(TrendTag.task_demodulated_polcal_data())
+        self.write(data=array, tags=tags, encoder=fits_array_encoder)

dkist_processing_trend/tasks/visp/visp_extract_beam.py

@@ -0,0 +1,14 @@
+"""Function to split apart the two ViSP beams."""
+
+from typing import Literal
+
+import numpy as np
+
+
+def extract_visp_beam(array: np.ndarray, beam: Literal[1, 2], beam_border: int) -> np.ndarray:
+    """Extract a single beam from a raw, dual-beam array."""
+    if beam == 1:
+        return np.copy(array[:beam_border, ...])
+    if beam == 2:
+        return np.copy(array[beam_border:, ...][::-1, :])
+    raise ValueError(f"ViSP only has beams 1 and 2. Can't extract data for beam '{beam}'.")

dkist_processing_trend/tasks/visp/visp_geometric.py

@@ -0,0 +1,260 @@
+"""Task for computing the ViSP beam offset."""
+
+from typing import Literal
+
+import numpy as np
+import peakutils as pku
+import scipy.ndimage as spnd
+from astropy.modeling import fitting
+from astropy.modeling import models
+from astropy.stats import sigma_clip
+from dkist_processing_common.codecs.asdf import asdf_encoder
+from dkist_processing_common.codecs.fits import fits_array_decoder
+from dkist_processing_math.statistics import average_numpy_arrays
+from dkist_service_configuration.logging import logger
+from skimage.registration import phase_cross_correlation
+
+from dkist_processing_trend.models.tags import TrendTag
+from dkist_processing_trend.tasks.trend_base import TrendArmTaskBase
+from dkist_processing_trend.tasks.visp.visp_extract_beam import extract_visp_beam
+
+__all__ = ["VispGeometricCalibration"]
+
+
+class VispGeometricCalibration(TrendArmTaskBase):
+    """
+    Compute the X/Y offset between the two ViSP beams.
+
+    Unlike the main L1 pipeline, this task does not treat each modstate separately and does not compute a rotational offset.
+    For the purposes of the Trend pipeline a simple X/Y shift is sufficient.
+
+    Parameters
+    ----------
+    arm_id
+        id of the instrument arm to operate on
+
+    recipe_run_id
+        id of the recipe run used to identify the workflow run this task is part of
+
+    workflow_name
+        name of the workflow to which this instance of the task belongs
+
+    workflow_version
+        version of the workflow to which this instance of the task belongs
+    """
+
+    record_provenance = True
+
+    def run(self):
+        """
+        Compute the X/Y shift between ViSP beam 1 and 2.
+
+        Algorithm:
+
+        #. Compute the average of all input POLCAL_GAIN frames (i.e., "clear" CS step)
+        #. Split this average into beams 1 and 2
+        #. Compute the rotation angle for each beam
+        #. Correct each beam for its measured rotation angle
+        #. Collapse each beam along both the spectral and spatial axis and  use `~skimage.registration.phase_cross_correlation` to compute the shift along each axis
+        #. Write the shifts and angles to scratch
+
+        NOTE: The outputs of this task are angles and shifts that should be used *directly* with the geometric correction
+        method; no inverting/sign flipping is needed.
+        """
+        with self.telemetry_span("Compute average clear array"):
+            logger.info("Computing average clear array")
+            full_avg_array = self.compute_avg_clear_array()
+
+        logger.info("Extracting beams")
+        beam_border = self.parameters.visp_beam_border
+        beam1_array = extract_visp_beam(full_avg_array, beam=1, beam_border=beam_border)
+        beam2_array = extract_visp_beam(full_avg_array, beam=2, beam_border=beam_border)
+
+        with self.telemetry_span("Compute beam angles"):
+            logger.info("Computing beam angles")
+            beam1_angle_rad = self.compute_beam_angle(array=beam1_array)
+            beam1_angle_deg = np.rad2deg(beam1_angle_rad)
+            logger.info(f"Beam 1 angle = {beam1_angle_deg:.5f} deg")
+
+            beam2_angle_rad = self.compute_beam_angle(array=beam2_array)
+            beam2_angle_deg = np.rad2deg(beam2_angle_rad)
+            logger.info(f"Beam 2 angle = {beam2_angle_deg:.5f} deg")
+
+        with self.telemetry_span("Compute beam offset"):
+            logger.info("Computing beam offsets")
+
+            logger.info("Removing beam angles")
+            beam1_rotated = spnd.rotate(
+                beam1_array, angle=-beam1_angle_deg, reshape=False, cval=np.nanmedian(beam1_array)
+            )
+            beam2_rotated = spnd.rotate(
+                beam2_array, angle=-beam2_angle_deg, reshape=False, cval=np.nanmedian(beam2_array)
+            )
+
+            logger.info("Filtering beams")
+            beam1_filtered = self.high_pass_filter_array(beam1_rotated)
+            beam2_filtered = self.high_pass_filter_array(beam2_rotated)
+
+            shift = np.full(2, np.nan)
+            for i, (ax_name, ax) in enumerate(zip(["spectral", "spatial"], [0, 1])):
+                logger.info(f"Computing {ax_name} shift")
+                shift[i] = self.compute_single_axis_shift(
+                    reference_array=beam1_filtered, target_array=beam2_filtered, axis=ax
+                )
+
+            logger.info(f"Measured {shift = }")
+
+        logger.info("Writing angles and shift to scratch")
+        beam1_geo_data = {"angle_rad": beam1_angle_rad, "shift": np.array([0, 0.0])}
+        self.write(
+            data=beam1_geo_data,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.beam(1),
+                TrendTag.task_visp_geometric_calibration(),
+            ],
+            encoder=asdf_encoder,
+        )
+
+        beam2_geo_data = {
+            "angle_rad": beam2_angle_rad,
+            "shift": -shift,
+        }
+        self.write(
+            data=beam2_geo_data,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.beam(2),
+                TrendTag.task_visp_geometric_calibration(),
+            ],
+            encoder=asdf_encoder,
+        )
+
+    def compute_avg_clear_array(self) -> np.ndarray:
+        """Compute the average of all "clear" CS step arrays."""
+        tags = [TrendTag.input(), TrendTag.arm_id(self.arm_id), TrendTag.task_polcal_gain()]
+        logger.info(f"Using {self.count(tags)} INPUT clear arrays.")
+        clear_arrays = self.read(tags=tags, decoder=fits_array_decoder)
+        avg_array = average_numpy_arrays(clear_arrays)
+        return avg_array
+
+    def compute_beam_angle(self, array: np.ndarray) -> float:
+        """
+        Compute the rotation angle of a single beam.
+
+        The angle is computed by measuring the slope of the slit hairlines; the arctan of the slope then gives the rotation angle.
+        To measure the slope of the hairlines, first the hairline signal is isolated with by smoothing the image in the spatial
+        direction (which will remove the hairlines) and then subtracting this smoothed array from the input image.
+        Once the hairlines have been isolated, the location of hairline center is measured with `peakutils <https://pypi.org/project/PeakUtils/>`_.
+        Finally, a line is fit to the the location of hairline center as a function of wavelength and the slope of this line is
+        used to find the angle.
+
+        Multiple hairlines (always 2, and sometimes more if there are reflections) have their angles computed separately
+        and then average together for the final result.
+
+        Returns
+        -------
+        The rotation angle of the given array, in radians.
+        """
+        no_hairline_array = spnd.median_filter(array, size=(1, 30))
+        hairline_only_array = (array - no_hairline_array) / no_hairline_array
+
+        # Turn low-signal hairlines into "emission" lines so peakutils can find them
+        hairline_only_array *= -1
+
+        hairline_1d = np.nanmedian(hairline_only_array, axis=0)
+        hairline_locs = pku.indexes(hairline_1d, thres=0.8)
+
+        num_wave, num_spat = array.shape
+        fit_centers = np.full((len(hairline_locs), num_wave), np.nan)
+        spectral_abscissa = np.arange(num_wave)
+        spatial_abscissa = np.arange(num_spat)
+        for i in range(num_wave):
+            try:
+                interp_center = pku.interpolate(
+                    spatial_abscissa, hairline_only_array[i, :], ind=hairline_locs, width=10
+                )
+                fit_centers[:, i] = interp_center
+            except:
+                logger.info(f"Failed to fit hairline center for spectral pixel {i}. Ignoring.")
+
+        hairline_angles = []
+        for hairline in range(fit_centers.shape[0]):
+            fit_angle = self.fit_angle_from_slope(
+                abscissa=spectral_abscissa, centers=fit_centers[hairline]
+            )
+            hairline_angles.append(fit_angle)
+
+        return np.mean(hairline_angles)
+
+    @staticmethod
+    def fit_angle_from_slope(abscissa: np.ndarray, centers: np.ndarray, sigma: float = 3) -> float:
+        """
+        Fit a 1-degree polynomial (i.e., a line) to the hairline centers and compute an angle from the slope.
+
+        Outliers are iteratively removed using a sigma clipping algorithm as detailed here:
+        https://docs.astropy.org/en/stable/modeling/example-fitting-line.html#iterative-fitting-using-sigma-clipping
+
+        Returns
+        -------
+        The slope of the line, in radians.
+        """
+        line_fitter = fitting.LinearLSQFitter()
+        outlier_rejection_fitter = fitting.FittingWithOutlierRemoval(
+            fitter=line_fitter,
+            outlier_func=sigma_clip,
+            sigma=sigma,
+            cenfunc="median",
+            stdfunc="std",
+        )
+        linear_model = models.Linear1D()
+
+        fit_line = outlier_rejection_fitter(model=linear_model, x=abscissa, y=centers)[0]
+        angle_rad = np.arctan(fit_line.slope.value)
+        return angle_rad
+
+    @staticmethod
+    def high_pass_filter_array(array: np.ndarray) -> np.ndarray:
+        """
+        Remove low-frequency signal in an array by dividing it by a smoothed copy.
+
+        The smoothing is done with a Gaussian smoothing kernel. The resulting array has strong spectral features
+        and hairlines accentuated over the continuum.
+        """
+        # The sigma value is hardcoded in the ViSP L1 pipeline, too. It's valid for all ViSP data for all time.
+        return array / spnd.gaussian_filter(array, sigma=5)
+
+    def compute_single_axis_shift(
+        self, reference_array: np.ndarray, target_array: np.ndarray, axis: Literal[0, 1]
+    ) -> float:
+        """
+        Compute the offset between two arrays along a single axis.
+
+        ViSP data have strong, high-frequency signals along both of their axes; the solar spectrum and the slit hairlines.
+        This method isolates one of those signals by first computing a derivative along the axis of interest. Because
+        the two signals are orthogonal this derivative both accentuates the strong features along the axis of interest and
+        removes the signal in the orthogonal direction (e.g., the hairlines are constant along the spectral axis).
+
+        The resulting derivative is then collapsed along the orthogonal axis, via median, into a single vector, which
+        increases the signal to noise and simplifies the final correlation.
+
+        The single vectors from both arrays are then registered via `~skimage.registration.phase_cross_correlation` to
+        produce the final shift.
+        """
+        opposite_axis = abs(axis - 1)
+
+        reference_deriv = np.diff(reference_array, axis=axis)
+        reference_1d_signal = np.nanmedian(reference_deriv, axis=opposite_axis)
+
+        target_deriv = np.diff(target_array, axis=axis)
+        target_1d_signal = np.nanmedian(target_deriv, axis=opposite_axis)
+
+        shift = phase_cross_correlation(
+            reference_image=reference_1d_signal,
+            moving_image=target_1d_signal,
+            upsample_factor=self.parameters.visp_geo_upsample_factor,
+            normalization=None,
+        )[0]
+        return shift.item(0)