Refine imaging modality attributes and enhance testing coverage for various scanning methods

Author: alessandratrapani

spec/ndx-microscopy.extensions.yaml

@@ -68,7 +68,7 @@ groups:
     attributes:
       - name: scan_direction
         dtype: text
-        doc: Direction of line scanning (horizontal, vertical, or diagonal). # specify fast direction vs slow direction
+        doc: Direction of line scanning (horizontal, vertical, or diagonal).
         required: false
       - name: line_rate
         dtype: float64
@@ -138,7 +138,7 @@ groups:
     doc: Random access scanning method for targeted, high-speed imaging of specific regions.
     attributes:
       - name: max_scan_points
-        dtype: uint32
+        dtype: numeric
         doc: Maximum number of points that can be scanned in a single frame.
         required: false
       - name: dwell_time

src/pynwb/ndx_microscopy/__init__.py

@@ -35,6 +35,14 @@
 )
 
 Microscope = get_class("Microscope", extension_name)
+ImagingModality = get_class("ImagingModality", extension_name)
+LineScanning = get_class("LineScanning", extension_name)
+RasterScanning = get_class("RasterScanning", extension_name)
+ResonantScanning = get_class("ResonantScanning", extension_name)
+TemporalFocusing = get_class("TemporalFocusing", extension_name)
+LightSheet = get_class("LightSheet", extension_name)
+RandomAccessScanning = get_class("RandomAccessScanning", extension_name)
+
 SummaryImage = get_class("SummaryImage", extension_name)
 PlanarImagingSpace = get_class("PlanarImagingSpace", extension_name)
 VolumetricImagingSpace = get_class("VolumetricImagingSpace", extension_name)
@@ -47,14 +55,20 @@
 MicroscopyResponseSeries = get_class("MicroscopyResponseSeries", extension_name)
 MicroscopyResponseSeriesContainer = get_class("MicroscopyResponseSeriesContainer", extension_name)
 
-
 __all__ = [
     "OpticalFilter",
     "ExcitationSource",
     "Indicator",
     "Photodetector",
     "DichroicMirror",
     "Microscope",
+    "ImagingModality",
+    "LineScanning",
+    "RasterScanning",
+    "ResonantScanning",
+    "TemporalFocusing",
+    "LightSheet",
+    "RandomAccessScanning",
     "ExcitationLightPath",
     "EmissionLightPath",
     "ImagingSpace",

src/pynwb/ndx_microscopy/testing/__init__.py

@@ -13,6 +13,13 @@
     mock_MultiPlaneMicroscopyContainer,
     mock_VolumetricImagingSpace,
     mock_VolumetricMicroscopySeries,
+    mock_ImagingModality,
+    mock_LineScanning,
+    mock_RasterScanning,
+    mock_ResonantScanning,
+    mock_TemporalFocusing,
+    mock_LightSheet,
+    mock_RandomAccessScanning,
 )
 
 __all__ = [
@@ -30,4 +37,11 @@
     "mock_VolumetricMicroscopySeries",
     "mock_MicroscopyResponseSeries",
     "mock_MicroscopyResponseSeriesContainer",
+    "mock_ImagingModality",
+    "mock_LineScanning",
+    "mock_RasterScanning",
+    "mock_ResonantScanning",
+    "mock_TemporalFocusing",
+    "mock_LightSheet",
+    "mock_RandomAccessScanning",
 ]

src/pynwb/ndx_microscopy/testing/_mock.py

@@ -70,6 +70,127 @@ def mock_EmissionLightPath(
     return emission_light_path
 
 
+def mock_ImagingModality(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of an ImagingModality type to be used for rapid testing.",
+) -> ndx_microscopy.ImagingModality:
+    """Base class for describing microscopy imaging modalities."""
+    imaging_modality = ndx_microscopy.ImagingModality(
+        name=name or name_generator("ImagingModality"),
+        description=description,
+    )
+    return imaging_modality
+
+
+def mock_LineScanning(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of a LineScanning type to be used for rapid testing.",
+    scan_direction: Optional[str] = "horizontal",
+    line_rate: Optional[float] = 500.0,
+    dwell_time: Optional[float] = 0.001,
+) -> ndx_microscopy.LineScanning:
+    """Line scanning method used in microscopy, particularly common in two-photon imaging."""
+    line_scanning = ndx_microscopy.LineScanning(
+        name=name or name_generator("LineScanning"),
+        description=description,
+        scan_direction=scan_direction,
+        line_rate=line_rate,
+        dwell_time=dwell_time,
+    )
+    return line_scanning
+
+
+def mock_RasterScanning(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of a RasterScanning type to be used for rapid testing.",
+    scan_pattern: Optional[str] = "bidirectional",
+    dwell_time: Optional[float] = 0.0005,
+) -> ndx_microscopy.RasterScanning:
+    """Raster scanning method with grid-like point-by-point or line-by-line acquisition."""
+    raster_scanning = ndx_microscopy.RasterScanning(
+        name=name or name_generator("RasterScanning"),
+        description=description,
+        scan_pattern=scan_pattern,
+        dwell_time=dwell_time,
+    )
+    return raster_scanning
+
+
+def mock_ResonantScanning(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of a ResonantScanning type to be used for rapid testing.",
+    resonant_frequency: Optional[float] = 8000.0,
+    resonant_amplitude: Optional[float] = 1.5,
+) -> ndx_microscopy.ResonantScanning:
+    """Resonant scanning method using a rapidly oscillating mirror for high-speed imaging."""
+    resonant_scanning = ndx_microscopy.ResonantScanning(
+        name=name or name_generator("ResonantScanning"),
+        description=description,
+        resonant_frequency=resonant_frequency,
+        resonant_amplitude=resonant_amplitude,
+    )
+    return resonant_scanning
+
+
+def mock_TemporalFocusing(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of a TemporalFocusing type to be used for rapid testing.",
+    lateral_point_spread_function_in_um: str = "0.5 ± 0.1",
+    axial_point_spread_function_in_um: str = "2.0 ± 0.3",
+    pulse_duration: Optional[float] = 0.0000001,  # 100 nanoseconds
+) -> ndx_microscopy.TemporalFocusing:
+    """Temporal focusing scanning method for depth-resolved imaging."""
+    temporal_focusing = ndx_microscopy.TemporalFocusing(
+        name=name or name_generator("TemporalFocusing"),
+        description=description,
+        lateral_point_spread_function_in_um=lateral_point_spread_function_in_um,
+        axial_point_spread_function_in_um=axial_point_spread_function_in_um,
+        pulse_duration=pulse_duration,
+    )
+    return temporal_focusing
+
+
+def mock_LightSheet(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of a LightSheet type to be used for rapid testing.",
+    sheet_thickness_in_um: Optional[float] = 5.0,
+    illumination_angle: Optional[float] = 45.0,
+) -> ndx_microscopy.LightSheet:
+    """Light sheet method."""
+    light_sheet = ndx_microscopy.LightSheet(
+        name=name or name_generator("LightSheet"),
+        description=description,
+        sheet_thickness_in_um=sheet_thickness_in_um,
+        illumination_angle=illumination_angle,
+    )
+    return light_sheet
+
+
+def mock_RandomAccessScanning(
+    *,
+    name: Optional[str] = None,
+    description: str = "A mock instance of a RandomAccessScanning type to be used for rapid testing.",
+    max_scan_points: Optional[int] = 1000,
+    dwell_time: Optional[float] = 0.0001,
+    scanning_pattern: Optional[str] = "spiral",
+) -> ndx_microscopy.RandomAccessScanning:
+    """Random access scanning method for targeted, high-speed imaging of specific regions."""
+    random_access_scanning = ndx_microscopy.RandomAccessScanning(
+        name=name or name_generator("RandomAccessScanning"),
+        description=description,
+        max_scan_points=max_scan_points,
+        dwell_time=dwell_time,
+        scanning_pattern=scanning_pattern,
+    )
+    return random_access_scanning
+
+
 def mock_PlanarImagingSpace(
     *,
     name: Optional[str] = None,
@@ -79,6 +200,7 @@ def mock_PlanarImagingSpace(
     location: str = "The location targeted by the mock imaging space.",
     reference_frame: str = "The reference frame of the mock planar imaging space.",
     orientation: str = "The orientation of the mock planar imaging space.",
+    imaging_modality: ndx_microscopy.ImagingModality = None,
 ) -> ndx_microscopy.PlanarImagingSpace:
     planar_imaging_space = ndx_microscopy.PlanarImagingSpace(
         name=name or name_generator("PlanarImagingSpace"),
@@ -88,6 +210,7 @@ def mock_PlanarImagingSpace(
         location=location,
         reference_frame=reference_frame,
         orientation=orientation,
+        imaging_modality=imaging_modality or mock_ImagingModality(),
     )
     return planar_imaging_space
 
@@ -101,6 +224,7 @@ def mock_VolumetricImagingSpace(
     location: str = "The location targeted by the mock imaging space.",
     reference_frame: str = "The reference frame of the mock volumetric imaging space.",
     orientation: str = "The orientation of the mock planar imaging space.",
+    imaging_modality: ndx_microscopy.ImagingModality = None,
 ) -> ndx_microscopy.VolumetricImagingSpace:
     volumetric_imaging_space = ndx_microscopy.VolumetricImagingSpace(
         name=name or name_generator("VolumetricImagingSpace"),
@@ -110,6 +234,7 @@ def mock_VolumetricImagingSpace(
         location=location,
         reference_frame=reference_frame,
         orientation=orientation,
+        imaging_modality=imaging_modality or mock_ImagingModality(),
     )
     return volumetric_imaging_space
 

src/pynwb/tests/test_constructors.py

@@ -17,13 +17,27 @@
     mock_VolumetricMicroscopySeries,
     mock_MicroscopyResponseSeries,
     mock_MicroscopyResponseSeriesContainer,
+    mock_ImagingModality,
+    mock_LineScanning,
+    mock_RasterScanning,
+    mock_ResonantScanning,
+    mock_TemporalFocusing,
+    mock_LightSheet,
+    mock_RandomAccessScanning,
 )
 from ndx_microscopy import (
     Segmentation,
     Segmentation2D,
     Segmentation3D,
     PlanarImagingSpace,
     VolumetricImagingSpace,
+    ImagingModality,
+    LineScanning,
+    RasterScanning,
+    ResonantScanning,
+    TemporalFocusing,
+    LightSheet,
+    RandomAccessScanning,
 )
 
 
@@ -47,6 +61,79 @@ def test_constructor_emission_light_path():
     )
 
 
+def test_constructor_imaging_modality():
+    """Test constructor for base ImagingModality class."""
+    imaging_modality = mock_ImagingModality()
+    assert imaging_modality.description == "A mock instance of an ImagingModality type to be used for rapid testing."
+    assert isinstance(imaging_modality, ImagingModality)
+
+
+def test_constructor_line_scanning():
+    """Test constructor for LineScanning class."""
+    line_scanning = mock_LineScanning()
+    assert line_scanning.description == "A mock instance of a LineScanning type to be used for rapid testing."
+    assert line_scanning.scan_direction == "horizontal"
+    assert line_scanning.line_rate == 500.0
+    assert line_scanning.dwell_time == 0.001
+    assert isinstance(line_scanning, LineScanning)
+    assert isinstance(line_scanning, ImagingModality)  # Test inheritance
+
+
+def test_constructor_raster_scanning():
+    """Test constructor for RasterScanning class."""
+    raster_scanning = mock_RasterScanning()
+    assert raster_scanning.description == "A mock instance of a RasterScanning type to be used for rapid testing."
+    assert raster_scanning.scan_pattern == "bidirectional"
+    assert raster_scanning.dwell_time == 0.0005
+    assert isinstance(raster_scanning, RasterScanning)
+    assert isinstance(raster_scanning, ImagingModality)  # Test inheritance
+
+
+def test_constructor_resonant_scanning():
+    """Test constructor for ResonantScanning class."""
+    resonant_scanning = mock_ResonantScanning()
+    assert resonant_scanning.description == "A mock instance of a ResonantScanning type to be used for rapid testing."
+    assert resonant_scanning.resonant_frequency == 8000.0
+    assert resonant_scanning.resonant_amplitude == 1.5
+    assert isinstance(resonant_scanning, ResonantScanning)
+    assert isinstance(resonant_scanning, ImagingModality)  # Test inheritance
+
+
+def test_constructor_temporal_focusing():
+    """Test constructor for TemporalFocusing class."""
+    temporal_focusing = mock_TemporalFocusing()
+    assert temporal_focusing.description == "A mock instance of a TemporalFocusing type to be used for rapid testing."
+    assert temporal_focusing.lateral_point_spread_function_in_um == "0.5 ± 0.1"
+    assert temporal_focusing.axial_point_spread_function_in_um == "2.0 ± 0.3"
+    assert temporal_focusing.pulse_duration == 0.0000001
+    assert isinstance(temporal_focusing, TemporalFocusing)
+    assert isinstance(temporal_focusing, ImagingModality)  # Test inheritance
+
+
+def test_constructor_light_sheet():
+    """Test constructor for LightSheet class."""
+    light_sheet = mock_LightSheet()
+    assert light_sheet.description == "A mock instance of a LightSheet type to be used for rapid testing."
+    assert light_sheet.sheet_thickness_in_um == 5.0
+    assert light_sheet.illumination_angle == 45.0
+    assert isinstance(light_sheet, LightSheet)
+    assert isinstance(light_sheet, ImagingModality)  # Test inheritance
+
+
+def test_constructor_random_access_scanning():
+    """Test constructor for RandomAccessScanning class."""
+    random_access_scanning = mock_RandomAccessScanning()
+    assert (
+        random_access_scanning.description
+        == "A mock instance of a RandomAccessScanning type to be used for rapid testing."
+    )
+    assert random_access_scanning.max_scan_points == 1000
+    assert random_access_scanning.dwell_time == 0.0001
+    assert random_access_scanning.scanning_pattern == "spiral"
+    assert isinstance(random_access_scanning, RandomAccessScanning)
+    assert isinstance(random_access_scanning, ImagingModality)  # Test inheritance
+
+
 def test_constructor_planar_imaging_space():
     planar_imaging_space = mock_PlanarImagingSpace()
     assert (