Complete native Napari display handoff

Return the registered OpenHCS handler-owned display work unchanged through the generic Napari adapter so bounded rendering remains owned by the display leaf.

Project registered ellipse ROIs through the shared coordinate converter as Napari four-corner bounding boxes, keeping the generic viewer blind to ROI subtype details. Add package-local regressions for both contracts.

Author: trissim

src/polystore/roi_converters.py

@@ -404,21 +404,27 @@ def coordinates_yx(self, shape: PolylineShape) -> np.ndarray:
         return shape.coordinates
 
 
-class EllipseROIShapeNapariPayloadConverter(ROIShapeNapariPayloadConverter):
+class EllipseROIShapeNapariPayloadConverter(
+    CoordinateROIShapeNapariPayloadConverter
+):
     shape_type = ShapeType.ELLIPSE
-
-    def shape_payloads(
-        self,
-        shape: EllipseShape,
-        metadata: Dict[str, Any],
-    ) -> tuple[Dict[str, Any], ...]:
-        return (
-            {
-                "type": "ellipse",
-                "center": [shape.center_y, shape.center_x],
-                "radii": [shape.radius_y, shape.radius_x],
-                "metadata": metadata,
-            },
+    napari_payload_type = "ellipse"
+
+    def coordinates_yx(self, shape: EllipseShape) -> np.ndarray:
+        """Return Napari's four-corner ellipse bounding box in YX order."""
+
+        min_y = shape.center_y - shape.radius_y
+        max_y = shape.center_y + shape.radius_y
+        min_x = shape.center_x - shape.radius_x
+        max_x = shape.center_x + shape.radius_x
+        return np.asarray(
+            (
+                (min_y, min_x),
+                (min_y, max_x),
+                (max_y, max_x),
+                (max_y, min_x),
+            ),
+            dtype=float,
         )
 
 

src/polystore/streaming/receivers/napari/napari_batch_processor.py

@@ -1,7 +1,7 @@
 import logging
-from dataclasses import dataclass
 from collections.abc import Sequence
-from typing import Generic, Optional, TypeVar
+from dataclasses import dataclass
+from typing import Generic, TypeVar
 
 logger = logging.getLogger(__name__)
 NapariBatchItemT = TypeVar("NapariBatchItemT")
@@ -24,8 +24,8 @@ class NapariBatchDisplayRequest(
     display_payload: NapariDisplayPayloadT
     component_names_metadata: NapariComponentNamesMetadataT
 
-    def dispatch_to(self, napari_server) -> None:
-        napari_server.display_layer_batch(
+    def dispatch_to(self, napari_server) -> object:
+        return napari_server.display_layer_batch(
             layer_key=self.layer_key,
             items=self.items,
             display_payload=self.display_payload,
@@ -41,17 +41,17 @@ class NapariBatchProcessor:
     Qt-thread debounce before this processor is called, so this class only
     adapts batch payloads into the server display operation.
     """
-    
+
     def __init__(
         self,
         napari_server,
-        batch_size: Optional[int] = None,
+        batch_size: int | None = None,
         debounce_delay_ms: int = 1000,
         max_debounce_wait_ms: int = 5000,
     ):
         """
         Initialize batch processor.
-        
+
         Args:
             napari_server: Reference to NapariViewerServer for display operations
             batch_size: Reserved for compatibility with viewer configuration
@@ -62,29 +62,29 @@ def __init__(
         self.batch_size = batch_size
         self.debounce_delay_ms = debounce_delay_ms
         self.max_debounce_wait_ms = max_debounce_wait_ms
-        
+
         logger.info(
             f"NapariBatchProcessor: Created with batch_size={batch_size}, "
             f"debounce={debounce_delay_ms}ms, max_wait={max_debounce_wait_ms}ms"
         )
-    
+
     def add_items(
         self,
         layer_key: str,
         items: Sequence[NapariBatchItemT],
         display_payload: NapariDisplayPayloadT,
         component_names_metadata: NapariComponentNamesMetadataT,
-    ):
+    ) -> object:
         """
         Display items already released by the Qt-thread debounce.
-        
+
         Args:
             layer_key: Unique identifier for the layer
             items: List of items to add (images or ROIs)
             display_payload: Viewer-owned display payload object
             component_names_metadata: Component name mappings for dimension labels
         """
-        NapariBatchDisplayRequest(
+        display_work = NapariBatchDisplayRequest(
             layer_key=layer_key,
             items=items,
             display_payload=display_payload,
@@ -95,6 +95,7 @@ def add_items(
             len(items),
             layer_key,
         )
+        return display_work
 
     def flush(self) -> None:
         """Compatibility no-op; OpenHCS owns the Qt-thread debounce timer."""

tests/test_napari_batch_processor.py

@@ -0,0 +1,37 @@
+from polystore.streaming.receivers.napari import NapariBatchProcessor
+
+
+class RecordingNapariServer:
+    def __init__(self, display_work):
+        self.display_work = display_work
+        self.calls = []
+
+    def display_layer_batch(self, **kwargs):
+        self.calls.append(kwargs)
+        return self.display_work
+
+
+def test_napari_batch_processor_returns_handler_owned_display_work():
+    display_work = object()
+    server = RecordingNapariServer(display_work)
+    processor = NapariBatchProcessor(server)
+    items = (object(), object())
+    display_payload = object()
+    component_names_metadata = object()
+
+    result = processor.add_items(
+        "objects",
+        items,
+        display_payload,
+        component_names_metadata,
+    )
+
+    assert result is display_work
+    assert server.calls == [
+        {
+            "layer_key": "objects",
+            "items": items,
+            "display_payload": display_payload,
+            "component_names_metadata": component_names_metadata,
+        }
+    ]

tests/test_roi.py

@@ -2,12 +2,49 @@
 import pytest
 
 from polystore.disk import DiskStorageBackend
-from polystore.roi import ROI
-from polystore.roi import MaskShape
-from polystore.roi import PolygonShape
-from polystore.roi import load_rois_from_json
-from polystore.roi import load_rois_from_zip
-from polystore.roi import extract_rois_from_labeled_mask
+from polystore.roi import (
+    ROI,
+    EllipseShape,
+    MaskShape,
+    PolygonShape,
+    extract_rois_from_labeled_mask,
+    load_rois_from_json,
+    load_rois_from_zip,
+)
+from polystore.roi_converters import NapariROIConverter
+
+
+def test_napari_roi_converter_projects_ellipse_as_native_bounding_box():
+    metadata = {"label": 7, "area": 18.0, "centroid": (10.0, 20.0)}
+
+    payloads = NapariROIConverter.rois_to_shapes(
+        [
+            ROI(
+                shapes=[
+                    EllipseShape(
+                        center_y=10.0,
+                        center_x=20.0,
+                        radius_y=3.0,
+                        radius_x=5.0,
+                    )
+                ],
+                metadata=metadata,
+            )
+        ]
+    )
+
+    assert payloads == [
+        {
+            "type": "ellipse",
+            "coordinates": [
+                [7.0, 15.0],
+                [7.0, 25.0],
+                [13.0, 25.0],
+                [13.0, 15.0],
+            ],
+            "metadata": metadata,
+        }
+    ]
 
 
 def test_extract_rois_from_labeled_mask_applies_spatial_origin_to_polygons():