Source code for photon_mosaic.extractors.roiextractors

"""Map ROI extractor implementations to BaseImaging and BaseRois"""

import inspect
import re

import numpy as np
from roiextractors.extractorlist import imaging_extractor_dict
from roiextractors.imagingextractor import ImagingExtractor

from photon_mosaic.core import BaseImaging, BaseImagingEpoch


class _BaseROIExtractorImaging(BaseImaging):
    """Base class for ROI extractors that work with BaseImaging data."""

    def __init__(self, imaging_name: str, **kwargs):
        self.roiextractor_imaging_class = imaging_extractor_dict[imaging_name]

        roi_extractor = self.roiextractor_imaging_class(**kwargs)

        segment = _BaseROIExtractorImagingEpoch(roi_extractor)
        BaseImaging.__init__(
            self,
            shape=roi_extractor.get_sample_shape(),
            sampling_frequency=roi_extractor.get_sampling_frequency(),
            dtype=roi_extractor.get_dtype(),
        )
        self.add_epoch(segment)
        self.name = f"{imaging_name} (ROIExtractors)"

        # imaging_name is fixed by the generated subclass, so it must not be re-passed on from_dict
        self._kwargs = kwargs


class _BaseROIExtractorImagingEpoch(BaseImagingEpoch):
    """Base class for ROI extractors that work with BaseImaging data."""

    def __init__(self, roi_extractor_imaging: ImagingExtractor):
        BaseImagingEpoch.__init__(self, sampling_frequency=roi_extractor_imaging.get_sampling_frequency())  # type: ignore[call-arg]
        self.roiextractor_extractor = roi_extractor_imaging

    def get_num_samples(self):
        return self.roiextractor_extractor.get_num_samples()

    def get_series(self, start_frame=None, end_frame=None, plane_indices=None):
        series = self.roiextractor_extractor.get_series(start_frame, end_frame)
        if series.ndim == 3:
            series = series[..., np.newaxis]
        if plane_indices is not None:
            series = series[..., plane_indices]
        return series


# Dynamically create classes and read functions for all imaging extractors


[docs] def get_classes_and_functions_to_import(): import_classes, import_functions = [], [] for imaging_name, imaging_class in imaging_extractor_dict.items(): # Dynamically create a class for each imaging extractor # The class inherits from _BaseROIExtractorImaging and sets imaging_name automatically def make_class(extractor_name): """Factory function to create a class with proper closure over extractor_name.""" class DynamicImagingClass(_BaseROIExtractorImaging): """Dynamically generated imaging class for {extractor_name}.""" def __init__(self, **kwargs): super().__init__(imaging_name=extractor_name, **kwargs) # Set proper class name and module DynamicImagingClass.__name__ = extractor_name DynamicImagingClass.__qualname__ = extractor_name # the classes are attached to photon_mosaic.extractors, so from_dict must look them up there DynamicImagingClass.__module__ = "photon_mosaic.extractors" DynamicImagingClass.__doc__ = imaging_class.__doc__ return DynamicImagingClass # Create the class imaging_class_photon_mosaic = make_class(imaging_name) import_classes.append(imaging_class_photon_mosaic) # Create a read_* function that instantiates the class def make_read_function(cls, extractor_cls): """Factory function to create a read function with proper closure and signature.""" # Get the signature from the original extractor class try: sig = inspect.signature(extractor_cls.__init__) # Remove 'self' parameter params = [p for name, p in sig.parameters.items() if name != "self"] except Exception: # Fallback if we can't get the signature params = [inspect.Parameter("kwargs", inspect.Parameter.VAR_KEYWORD)] def read_function(*args, **kwargs): """Convenience function to create an instance of {cls.__name__}. Returns ------- {cls.__name__} An instance of the imaging class. """ return cls(*args, **kwargs) # Set the signature on the function read_function.__signature__ = inspect.Signature(parameters=params) return read_function # Create and add the read function # Convert CamelCase to snake_case, handling consecutive capitals like TIFF # Insert underscore before uppercase letters that are followed by lowercase snake_case_name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", imaging_name) snake_case_name = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", snake_case_name) snake_case_name = snake_case_name.lower() # Remove _extractor suffix snake_case_name = snake_case_name.replace("_extractor", "") read_func_name = f"read_{snake_case_name}" read_func = make_read_function(imaging_class_photon_mosaic, imaging_class) read_func.__name__ = read_func_name read_func.__qualname__ = read_func_name read_func.__doc__ = imaging_class.__doc__ import_functions.append(read_func) return import_classes, import_functions