dkist-processing-cryonirsp 0.0.1rc2__tar.gz → 0.0.1rc4__tar.gz

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/.readthedocs.yml

@@ -2,7 +2,7 @@ version: 2
 build:
   os: ubuntu-20.04
   tools:
-    python: "3.10"
+    python: "3.11"
   apt_packages:
     - libopenjp2-7
     - graphviz

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dkist_processing_cryonirsp
-Version: 0.0.1rc2
+Version: 0.0.1rc4
 Summary: Science processing code for the Cryo-NIRSP instrument on DKIST
 Home-page: https://bitbucket.org/dkistdc/dkist_processing_cryonirsp/src/main/
 Author: NSO / AURA
@@ -8,8 +8,8 @@ Author-email: "dkistdc@nso.edu"
 License: MIT
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
 Provides-Extra: test
 Provides-Extra: grogu
 Provides-Extra: docs

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/bitbucket-pipelines.yml

@@ -1,5 +1,5 @@
 #Build Configuration for docker deployment to artifactory
-image: python:3.10
+image: python:3.11
 
 definitions:
   services:
@@ -40,7 +40,7 @@ definitions:
         script:
           - pip install -U pip
           - pip install .[test]
-          - pytest -v --cov -m "not development" dkist_processing_cryonirsp
+          - pytest -v -n auto -m "not development" --cov dkist_processing_cryonirsp
         services:
           - redis
     - step: &push_workflow

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/models/constants.py

@@ -26,6 +26,10 @@ class CryonirspBudName(Enum):
     axis_1_type = "AXIS_1_TYPE"
     axis_2_type = "AXIS_2_TYPE"
     axis_3_type = "AXIS_3_TYPE"
+    roi_1_origin_x = "ROI_1_ORIGIN_X"
+    roi_1_origin_y = "ROI_1_ORIGIN_Y"
+    roi_1_size_x = "ROI_1_SIZE_X"
+    roi_1_size_y = "ROI_1_SIZE_Y"
 
 
 class CryonirspConstants(ConstantsBase):
@@ -70,8 +74,8 @@ class CryonirspConstants(ConstantsBase):
         return self._db_dict[CryonirspBudName.num_meas.value]
 
     @property
-    def time_obs_list(self) -> list[str]:
-        """Construct a list of all the dateobs for this dataset."""
+    def time_obs_list(self) -> tuple[str]:
+        """Construct a sorted tuple of all the dateobs for this dataset."""
         return self._db_dict[CryonirspBudName.time_obs_list.value]
 
     @property
@@ -115,7 +119,6 @@ class CryonirspConstants(ConstantsBase):
     @property
     def num_cs_steps(self) -> int:
         """Find the number of calibration sequence steps."""
-        # NB: Uses regular BudName
         return self._db_dict[BudName.num_cs_steps.value]
 
     @property
@@ -144,3 +147,23 @@ class CryonirspConstants(ConstantsBase):
     def axis_3_type(self) -> str:
         """Find the type of the third array axis."""
         return self._db_dict[CryonirspBudName.axis_3_type.value]
+
+    @property
+    def roi_1_origin_x(self) -> int:
+        """Get the ROI #1 x origin."""
+        return self._db_dict[CryonirspBudName.roi_1_origin_x.value]
+
+    @property
+    def roi_1_origin_y(self) -> int:
+        """Get the ROI #1 y origin."""
+        return self._db_dict[CryonirspBudName.roi_1_origin_y.value]
+
+    @property
+    def roi_1_size_x(self) -> int:
+        """Get the ROI #1 x size."""
+        return self._db_dict[CryonirspBudName.roi_1_size_x.value]
+
+    @property
+    def roi_1_size_y(self) -> int:
+        """Get the ROI #1 y size."""
+        return self._db_dict[CryonirspBudName.roi_1_size_y.value]

dkist_processing_cryonirsp-0.0.1rc4/dkist_processing_cryonirsp/models/filter.py

@@ -0,0 +1,46 @@
+"""Cryo filter list and tooling."""
+import astropy.units as u
+from dkist_processing_common.models.wavelength import WavelengthRange
+
+
+class Filter(WavelengthRange):
+    """
+    CRYONirsp filter data structure.
+
+    Parameters
+    ----------
+    filter_id
+        Unique ID of the filter in use
+    """
+
+    filter_id: str
+
+
+CRYONIRSP_CI_FILTERS = [
+    Filter(filter_id="Continuum", min=1049.000 * u.nm, max=1050.000 * u.nm),
+    Filter(filter_id="FeXIII1075", min=1074.200 * u.nm, max=1075.200 * u.nm),
+    Filter(filter_id="FeXIII1080", min=1079.300 * u.nm, max=1080.300 * u.nm),
+    Filter(filter_id="HeI", min=1082.500 * u.nm, max=1083.500 * u.nm),
+    Filter(filter_id="HPaschen-beta", min=1281.300 * u.nm, max=1282.300 * u.nm),
+    Filter(filter_id="JBand", min=1170.000 * u.nm, max=1330.000 * u.nm),
+    Filter(filter_id="SiX", min=1427.500 * u.nm, max=1432.500 * u.nm),
+]
+
+
+def find_associated_ci_filter(filter_id: str) -> Filter:
+    """
+    Given a wavelength, find the Filter that contains that wavelength between its wavemin/wavemax.
+
+    Parameters
+    ----------
+    filter_id
+        Unique ID of the filter in use
+
+    Returns
+    -------
+    A Filter object that contains the wavelength
+    """
+    matching_filters = [f for f in CRYONIRSP_CI_FILTERS if f.filter_id == filter_id]
+    if len(matching_filters) == 1:
+        return matching_filters[0]
+    raise ValueError(f"Found {len(matching_filters)} matching filters when 1 was expected.")

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/models/parameters.py

@@ -15,9 +15,11 @@ class CryonirspParameters(ParameterBase):
         self,
         input_dataset_parameters: dict[str, list[InputDatasetParameterValue]],
         wavelength: float | None = None,
+        arm_id: str | None = None,
     ):
         super().__init__(input_dataset_parameters)
         self._wavelength = wavelength
+        self._arm_id = arm_id
 
     @property
     def geo_upsample_factor(self) -> float:
@@ -35,24 +37,26 @@ class CryonirspParameters(ParameterBase):
         return self._find_most_recent_past_value("cryonirsp_geo_poly_fit_order")
 
     @property
-    def geo_gradient_displacement(self) -> int:
-        """Number of pixels to shift by when computing gradient."""
-        return self._find_most_recent_past_value("cryonirsp_geo_gradient_displacement")
+    def geo_spatial_gradient_displacement(self) -> int:
+        """Number of spatial pixels to shift by when computing gradient."""
+        return self._find_most_recent_past_value("cryonirsp_geo_spatial_gradient_displacement")
 
     @property
-    def geo_strip_spatial_length_divisor(self) -> int:
-        """Divisor applied to the array spatial axis size to compute the strip length."""
-        return self._find_most_recent_past_value("cryonirsp_geo_strip_spatial_length_divisor")
+    def geo_strip_spatial_size_fraction(self) -> float:
+        """Fraction of full spatial size to use for spatial size of strips used to find the beam angle."""
+        return self._find_most_recent_past_value("cryonirsp_geo_strip_spatial_size_fraction")
 
     @property
-    def geo_strip_spectral_width_divisor(self) -> int:
-        """Divisor applied to the array width to compute the vertical strip width."""
-        return self._find_most_recent_past_value("cryonirsp_geo_strip_spectral_width_divisor")
+    def geo_strip_spectral_size_fraction(self) -> float:
+        """Fraction of full spectral size to use for spectral size of strips used to find the beam angle."""
+        return self._find_most_recent_past_value("cryonirsp_geo_strip_spectral_size_fraction")
 
     @property
-    def geo_strip_spectral_offset_divisor(self) -> int:
-        """Divisor applied to the array width to compute the vertical strip half-offset."""
-        return self._find_most_recent_past_value("cryonirsp_geo_strip_spectral_offset_divisor")
+    def geo_strip_spectral_offset_size_fraction(self) -> float:
+        """Fraction of full spectral size to set as the +/- offset from spectral center for the two strips used to find the beam angle."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_geo_strip_spectral_offset_size_fraction"
+        )
 
     @property
     def solar_spectral_avg_window(self):
@@ -122,9 +126,22 @@ class CryonirspParameters(ParameterBase):
         return self._find_most_recent_past_value("cryonirsp_beam_boundaries_upsample_factor")
 
     @property
-    def bad_pixel_map_median_filter_size(self) -> int:
+    def beam_boundaries_sp_beam_transition_region_size_fraction(self) -> float:
+        """
+        Fraction of full spectral size to use as the size of the transition region between the two SP beams.
+
+        A region with size = (this parameter * full spectral size) and centered at the center of the spectral dimension
+        will be ignored when extracting the beams.
+        """
+        return self._find_most_recent_past_value(
+            "cryonirsp_beam_boundaries_sp_beam_transition_region_size_fraction"
+        )
+
+    @property
+    def bad_pixel_map_median_filter_size(self) -> list[int, int]:
         """Return the smoothing disk size to be used in the bad pixel map computation."""
-        return self._find_most_recent_past_value("cryonirsp_bad_pixel_map_median_filter_size")
+        filter_size = self._find_parameter_for_arm("cryonirsp_bad_pixel_map_median_filter_size")
+        return filter_size
 
     @property
     def bad_pixel_map_threshold_factor(self) -> float:
@@ -132,35 +149,23 @@ class CryonirspParameters(ParameterBase):
         return self._find_most_recent_past_value("cryonirsp_bad_pixel_map_threshold_factor")
 
     @property
-    def bad_pixel_correction_median_filter_size(self) -> int:
+    def corrections_bad_pixel_median_filter_size(self) -> int:
         """Return the size of the median filter to be used for bad pixel correction."""
         return self._find_most_recent_past_value(
-            "cryonirsp_bad_pixel_correction_median_filter_size"
+            "cryonirsp_corrections_bad_pixel_median_filter_size"
         )
 
     @cached_property
-    def ci_thresholds(self) -> np.ndarray:
-        """Name of parameter associated with the CI linearization thresholds."""
-        param_dict = self._find_most_recent_past_value("cryonirsp_ci_thresholds")
-        return self._get_param_data_from_npy_file(param_dict)
-
-    @cached_property
-    def ci_polyfit(self) -> np.ndarray:
-        """Name of parameter associated with the CI linearization polyfit coefficients."""
-        param_dict = self._find_most_recent_past_value("cryonirsp_ci_polyfit")
-        return self._get_param_data_from_npy_file(param_dict)
+    def linearization_thresholds(self) -> np.ndarray:
+        """Name of parameter associated with the linearization thresholds."""
+        param_dict = self._find_parameter_for_arm("cryonirsp_linearization_thresholds")
+        return self._load_param_value_from_npy_file(param_dict)
 
     @cached_property
-    def sp_thresholds(self) -> np.ndarray:
-        """Name of parameter associated with the SP linearization thresholds."""
-        param_dict = self._find_most_recent_past_value("cryonirsp_sp_thresholds")
-        return self._get_param_data_from_npy_file(param_dict)
-
-    @cached_property
-    def sp_polyfit(self) -> np.ndarray:
-        """Name of parameter associated with the SP linearization polyfit coefficients."""
-        param_dict = self._find_most_recent_past_value("cryonirsp_sp_polyfit")
-        return self._get_param_data_from_npy_file(param_dict)
+    def linearization_polyfit_coeffs(self) -> np.ndarray:
+        """Name of parameter associated with the linearization polyfit coefficients."""
+        param_dict = self._find_parameter_for_arm("cryonirsp_linearization_polyfit_coeffs")
+        return self._load_param_value_from_npy_file(param_dict)
 
     def _find_parameter_closest_wavelength(self, parameter_name: str) -> Any:
         """
@@ -186,8 +191,13 @@ class CryonirspParameters(ParameterBase):
         return chosen_value
 
     @staticmethod
-    def _get_param_data_from_npy_file(param_dict: dict) -> np.ndarray:
+    def _load_param_value_from_npy_file(param_dict: dict) -> np.ndarray:
         """Return the data associated with a parameter file saved in numpy format."""
         file_path = param_dict["param_path"]
         result = np.load(file_path)
         return result
+
+    def _find_parameter_for_arm(self, parameter_name: str) -> Any:
+        full_param_name = f"{parameter_name}_{self._arm_id.lower()}"
+        param = self._find_most_recent_past_value(full_param_name)
+        return param

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/parsers/cryonirsp_l0_fits_access.py

@@ -32,6 +32,10 @@ class CryonirspRampFitsAccess(L0FitsAccess):
         self.camera_readout_mode = self.header["CNCAMMD"]
         self.curr_frame_in_ramp: int = self.header["CNCNDR"]
         self.arm_id: str = self.header["CNARMID"]
+        self.roi_1_origin_x = self.header["HWROI1OX"]
+        self.roi_1_origin_y = self.header["HWROI1OY"]
+        self.roi_1_size_x = self.header["HWROI1SX"]
+        self.roi_1_size_y = self.header["HWROI1SY"]
 
 
 class CryonirspL0FitsAccess(L0FitsAccess):

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/parsers/map_repeats.py

@@ -52,7 +52,7 @@ class SingleScanStep:
         return self.date_obs < other.date_obs
 
     def __hash__(self) -> int:
-        # Not strictly necessary, but does allow for using set() on these objects
+        """Not strictly necessary, but does allow for using set() on these objects."""
         return hash(
             (
                 self.scan_step,
@@ -104,7 +104,7 @@ class MapScanFlower(MapScanStemBase):
         """Compute the map scan number for a single frame.
 
         The frame implies a SingleScanStep. That object is then compared to the sorted list of objects for a single
-        (raster_step, modstate) tuple. The location within that sorted list is the map scan number.
+        (raster_step, meas_num, modstate, sub_repeat) tuple. The location within that sorted list is the map scan number.
         """
         scan_step_obj = self.key_to_petal_dict[key]
         step_list = sorted(
@@ -136,7 +136,6 @@ class NumMapScansBud(MapScanStemBase):
         it will not be included.
         Assumes the incomplete map_scan is always the last one due to summit abort or cancellation.
         """
-        # grab header value (fits access attribute from parse file: num subrepeats) of subrepeats and loop through here
         map_scans_per_scan_step = []
         for meas_dict in self.scan_step_dict.values():
             for mod_dict in meas_dict.values():

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/parsers/task.py

@@ -10,14 +10,10 @@ from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import Cryonirs
 
 def parse_header_ip_task(fits_obj: CryonirspL0FitsAccess) -> str:
     """
-    Parse CryoNIRSP tasks.
+    Parse CryoNIRSP tasks that aren't fully captured by the single IPTASK keyword.
 
-    Parameters
-    ----------
-    fits_obj:
-        A single FitsAccess object
+    Right now this just distinguishes between solar and lamp gain images.
     """
-    # Distinguish between lamp and solar gains
     if (
         fits_obj.ip_task_type.upper() == TaskName.gain.value
         and fits_obj.gos_level3_status == "lamp"
@@ -30,7 +26,6 @@ def parse_header_ip_task(fits_obj: CryonirspL0FitsAccess) -> str:
     ):
         return TaskName.solar_gain.value
 
-    # Everything else is unchanged
     return fits_obj.ip_task_type
 
 

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/parsers/time.py

@@ -32,7 +32,8 @@ class CryonirspTaskExposureTimesBud(TaskExposureTimesBud):
         fits_obj:
             A single FitsAccess object
         """
-        ip_task_type = parse_header_ip_task(fits_obj)  # This is where it's different
+        # This is where it's different than the common `TaskExposureTimesBud`
+        ip_task_type = parse_header_ip_task(fits_obj)
         if ip_task_type.lower() == self.ip_task_type.lower():
             raw_exp_time = getattr(fits_obj, self.metadata_key)
             return round(raw_exp_time, 6)
@@ -64,9 +65,9 @@ class CryonirspTimeObsBud(Stem):
         """
         return fits_obj.time_obs
 
-    def getter(self, key: Hashable) -> Hashable:
+    def getter(self, key: Hashable) -> tuple:
         """
-        Get the list of time_obs values.
+        Get the sorted tuple of time_obs values.
 
         Parameters
         ----------

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/tasks/assemble_movie.py

@@ -114,7 +114,7 @@ class CIAssembleCryonirspMovie(AssembleCryonirspMovieBase):
         """
         map_scan_num = n // self.constants.num_scan_steps + 1
         scan_step = n % self.constants.num_scan_steps + 1
-        # Note: Use only the first measurement for the movie
+
         tags = [
             CryonirspTag.map_scan(map_scan_num),
             CryonirspTag.scan_step(scan_step),

{dkist_processing_cryonirsp-0.0.1rc2 → dkist_processing_cryonirsp-0.0.1rc4}/dkist_processing_cryonirsp/tasks/bad_pixel_map.py

@@ -2,10 +2,10 @@
 import numpy as np
 import scipy.ndimage as spnd
 from dkist_processing_math.statistics import average_numpy_arrays
+from logging42 import logger
 
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.models.task_name import CryonirspTaskName
-from dkist_processing_cryonirsp.models.task_name import TaskName
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 
@@ -40,31 +40,32 @@ class BadPixelMapCalibration(CryonirspTaskBase):
         None
 
         """
-        # Step 1:
         with self.apm_task_step(f"Compute average uncorrected solar gain image"):
+            logger.info("Averaging uncorrected solar gain images")
             average_solar_gain_array = self._compute_average_gain_array()
+
         with self.apm_task_step(f"Compute the bad pixel map"):
-            # Step 2:
-            filter_size = self.parameters.bad_pixel_map_median_filter_size
-            # TODO: Distinguish between SP and CI here? May need two parameters
-            # TODO: as a 2D kernel does not need to be as large as the 1D kernel length.
-            # Filter only along the slit so as not to broaden the spectral lines.
-            # Broadening the spectral lines causes them to leak into the difference
-            # array calculated below and possibly get classified as bad pixels
-            # Use constant mode and the median for cval, as this gives better
-            # filtering ability and behavior at the edge pixels
-            filtered_array = spnd.median_filter(
-                average_solar_gain_array,
-                size=(filter_size, 1),
-                mode="constant",
-                cval=np.median(average_solar_gain_array),
-            )
-            # Step 3:
-            diff = filtered_array - average_solar_gain_array
-            # Step 4:
-            thresh = self.parameters.bad_pixel_map_threshold_factor
-            bad_pixel_map = np.array((np.abs(diff) > thresh * diff.std()), dtype=int)
-        # Step 5:
+            with self.apm_processing_step("Smooth array with median filter"):
+                logger.info("Smoothing array with median filter")
+                filter_size = self.parameters.bad_pixel_map_median_filter_size
+                filtered_array = spnd.median_filter(
+                    average_solar_gain_array,
+                    size=filter_size,
+                    mode="constant",
+                    cval=np.nanmedian(average_solar_gain_array),
+                )
+
+            with self.apm_processing_step("Identify bad pixels"):
+                logger.info("Identifying bad pixels")
+                thresh = self.parameters.bad_pixel_map_threshold_factor
+
+                diff = filtered_array - average_solar_gain_array
+                bad_pixel_map = np.array((np.abs(diff) > thresh * diff.std()), dtype=int)
+
+                # Find and fix any residual zeros that slipped through the bad pixel map.
+                zeros = np.where(average_solar_gain_array == 0.0)
+                bad_pixel_map[zeros] = 1
+
         with self.apm_writing_step("Writing bad pixel map"):
             self.intermediate_frame_write_arrays(
                 bad_pixel_map, task=CryonirspTaskName.bad_pixel_map.value
@@ -83,7 +84,6 @@ class BadPixelMapCalibration(CryonirspTaskBase):
         -------
         The average gain array
         """
-        # Get the linearized solar gain arrays
         lin_corr_gain_arrays = self.linearized_frame_full_array_generator(
             tags=[
                 CryonirspTag.task_solar_gain(),

dkist_processing_cryonirsp-0.0.1rc4/dkist_processing_cryonirsp/tasks/beam_boundaries_base.py

@@ -0,0 +1,199 @@
+"""CryoNIRSP compute beam boundary task."""
+from abc import abstractmethod
+
+import numpy as np
+from dkist_processing_math.statistics import average_numpy_arrays
+from logging42 import logger
+from skimage import filters
+from skimage import img_as_ubyte
+from skimage.exposure import rescale_intensity
+from skimage.morphology import disk
+
+from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
+
+
+class BeamBoundariesCalibrationBase(CryonirspTaskBase):
+    """
+    Task class for calculation of the beam boundaries for later use during calibration.
+
+    Parameters
+    ----------
+    recipe_run_id : int
+        id of the recipe run used to identify the workflow run this task is part of
+    workflow_name : str
+        name of the workflow to which this instance of the task belongs
+    workflow_version : str
+        version of the workflow to which this instance of the task belongs
+
+    """
+
+    def run(self):
+        """
+        Compute the beam boundaries by analyzing a set of solar gain images.
+
+        Steps:
+        1. Compute the average gain image
+        2. Correct any bad pixels
+        3. Smooth the image using a median filter with radius 3
+        4. Use a bimodal threshold filter to segment the image into illuminated and non-illuminated regions
+        5. Compute the boundaries of the illuminated region
+        6. Extract the illuminated portion of the image
+        7. Split the beams using a 10% buffer region around the horizontal mid-point
+        8. Find the horizontal shift between the two images
+        9. Identify the boundaries of the overlap
+        10. Save the boundaries as a fits file (json?)
+
+
+        Returns
+        -------
+        None
+
+        """
+        # Step 1:
+        with self.apm_processing_step(f"Compute average solar gain image"):
+            logger.info("Averaging solar gain image")
+            average_solar_gain_array = self._compute_average_gain_array()
+
+        # Step 2:
+        with self.apm_task_step(f"Retrieve bad pixel map"):
+            logger.info("Retrieving bad pixel map")
+            bad_pixel_map = self.intermediate_frame_load_full_bad_pixel_map()
+            corrected_solar_gain_array = self.corrections_correct_bad_pixels(
+                average_solar_gain_array, bad_pixel_map
+            )
+
+        # Step 3
+        with self.apm_processing_step(f"Smooth the array to get good segmentation"):
+            logger.info("Smoothing corrected solar gain array")
+            smoothed_solar_gain_array = self._smooth_gain_array(corrected_solar_gain_array)
+
+        # Step 4:
+        with self.apm_processing_step(
+            f"Segment the array into illuminated and non-illuminated pixels"
+        ):
+            logger.info(
+                "Segmenting smoothed solar gain array into illuminated and non-illuminated pixels "
+            )
+            segmented_array = self._segment_array(smoothed_solar_gain_array)
+
+        # Step 5:
+        with self.apm_processing_step(f"Define the boundaries of the illuminated region"):
+            logger.info("Defining boundaries of illuminated region")
+            illuminated_boundaries = self._compute_illuminated_boundaries(segmented_array)
+
+        # Steps 6 - 9:
+        with self.apm_processing_step(f"Compute the beam boundaries of the illuminated region"):
+            logger.info("Computing beam boundaries of illuminated region")
+            boundaries = self._compute_beam_boundaries(
+                smoothed_solar_gain_array, illuminated_boundaries
+            )
+
+        # Step 10:
+        with self.apm_writing_step("Writing beam boundaries"):
+            logger.info("Writing beam boundaries")
+            for beam, array in enumerate(boundaries, start=1):
+                self.intermediate_frame_write_arrays(
+                    array, task_tag=CryonirspTag.task_beam_boundaries(), beam=beam
+                )
+
+    def _compute_average_gain_array(self) -> np.ndarray:
+        """
+        Compute an average of uncorrected solar gain arrays.
+
+        We are computing the overall illumination pattern for both beams simultaneously,
+        so no dark correction is required and no beam splitting is used at this point.
+        Solar gain images are used because they have larger flux than the lamp gain images
+        and the lamp gain images do not have the same illumination pattern as the solar
+        gain images.
+
+        Returns
+        -------
+        The average gain array
+        """
+        lin_corr_gain_arrays = self.linearized_frame_full_array_generator(
+            tags=[
+                CryonirspTag.task_solar_gain(),
+                CryonirspTag.linearized(),
+                CryonirspTag.frame(),
+            ]
+        )
+        averaged_gain_data = average_numpy_arrays(lin_corr_gain_arrays)
+        return averaged_gain_data
+
+    def _smooth_gain_array(self, array: np.ndarray) -> np.ndarray:
+        """
+        Smooth the input array with morphological filtering using a disk shape.
+
+        The array is smoothed to help eliminate artifacts in the image segmentation step.
+
+        Parameters
+        ----------
+        array
+            The input array to be smoothed
+
+        Returns
+        -------
+        The smoothed output array
+        """
+        # skimage.filters requires ubyte arrays and float->ubyte conversion only works with float in range [-1, 1]
+        norm_gain = img_as_ubyte(rescale_intensity(array, out_range=(0, 1.0)))
+
+        disk_size = self.parameters.beam_boundaries_smoothing_disk_size
+        norm_gain = filters.rank.median(norm_gain, disk(disk_size))
+        return norm_gain
+
+    @staticmethod
+    def _segment_array(array: np.ndarray) -> np.ndarray:
+        """
+        Segment the array into illuminated (True) and non-illuminated (False) regions.
+
+        Parameters
+        ----------
+        array
+            The array to be segmented
+
+        Returns
+        -------
+        The boolean segmented output array
+        """
+        thresh = filters.threshold_minimum(array)
+        logger.info(f"Segmentation threshold = {thresh}")
+        segmented_array = (array > thresh).astype(bool)
+        return segmented_array
+
+    @abstractmethod
+    def _compute_illuminated_boundaries(self, array: np.ndarray) -> list[int]:
+        """
+        Compute the inscribed rectangular extent of the illuminated portion of the array.
+
+        Parameters
+        ----------
+        array
+            The segmented boolean array over which the illuminated boundaries are to be computed
+
+        Returns
+        -------
+        The illuminated region boundaries, [y_min, y_max, x_min, x_max]
+        """
+        pass
+
+    @abstractmethod
+    def _compute_beam_boundaries(
+        self, smoothed_solar_gain_array: np.ndarray, illuminated_boundaries: list[int]
+    ):
+        """
+        Compute the beam boundaries from the illuminated beam.
+
+        Parameters
+        ----------
+        smoothed_solar_gain_array
+            The smoothed solar gain array, ready for beam identification
+        illuminated_boundaries
+            The boundaries of the illuminated beam [y_min, y_max, x_min, x_max]
+
+        Returns
+        -------
+        A list of beam boundary arrays, one for each beam
+        """
+        pass