Add layer_names property to nImage and refactor channel name logic (#54)

# Description

Provides clean property API for getting the layer name, which is a
combination of current nImage information, including the channel, scene
and path stem. This allows us to adjust things in better abstracted
pieces going forward, and is more similar to the rest of the nImage API.
The layer names property returns a list corresponding to the number of
layers that would be added.

This PR also removes the greedy `get_single_channel_name` and instead
just directly uses lazy `nImage.channel_names` logic throughout.

Author: TimMonko

src/ndevio/nimage.py

@@ -14,7 +14,6 @@
 from .utils._layer_utils import (
     build_layer_tuple,
     determine_in_memory,
-    get_single_channel_name,
     resolve_layer_type,
 )
 
@@ -234,6 +233,53 @@ def path_stem(self) -> str:
             return PurePosixPath(urlparse(self.path).path).stem
         return Path(self.path).stem
 
+    @property
+    def layer_names(self) -> list[str]:
+        """Per-channel layer names for napari.
+
+        Returns one name per output layer — the same count as
+        :meth:`get_layer_data_tuples` returns tuples. The base name is the
+        scene-qualified :attr:`path_stem`; channel names are prepended using
+        ``' :: '`` as a delimiter when present.
+
+        Returns
+        -------
+        list[str]
+            e.g. ``['membrane :: cells.ome', 'nuclei :: cells.ome']``
+            for a 2-channel file, or ``['0 :: cells.ome']`` for a
+            single-channel OME image with a default ``C`` coordinate.
+            Only when no ``C`` dimension is present at all will the name
+            be just ``['cells.ome']``.
+
+        Examples
+        --------
+        >>> nImage("cells.ome.tiff").layer_names
+        ['0 :: cells.ome']
+
+        """
+        # Build scene-qualified base name
+        delim = ' :: '
+        parts: list[str] = []
+        if len(self.scenes) > 1 or self.current_scene != 'Image:0':
+            parts.extend([str(self.current_scene_index), self.current_scene])
+        parts.append(self.path_stem)
+        base_name = delim.join(parts)
+
+        # RGB (Samples dim): single layer, no channel prefix
+        if 'S' in self.dims.order:
+            return [base_name]
+
+        # Use BioImage channel_names — metadata only, no data load
+        channel_names = self.channel_names
+
+        # Single channel (C=1 is squeezed out of layer_data)
+        if self.dims.C == 1:
+            ch_name = channel_names[0]
+            return [f'{ch_name} :: {base_name}' if ch_name else base_name]
+
+        # Multichannel
+        return [f'{ch} :: {base_name}' for ch in channel_names]
+
     @property
     def layer_scale(self) -> tuple[float, ...]:
         """Physical scale for dimensions in layer data.
@@ -358,34 +404,6 @@ def layer_metadata(self) -> dict:
 
         return meta
 
-    def _build_layer_name(self, channel_name: str | None = None) -> str:
-        """Build layer name from channel, scene, and file path.
-
-        Parameters
-        ----------
-        channel_name : str, optional
-            Name of the channel to include in the layer name.
-
-        Returns
-        -------
-        str
-            Formatted layer name like "channel :: 0 :: Image:0 :: filename".
-
-        """
-        delim = ' :: '
-        parts: list[str] = []
-
-        if channel_name:
-            parts.append(channel_name)
-
-        # Include scene info if multi-scene or non-default scene name
-        if len(self.scenes) > 1 or self.current_scene != 'Image:0':
-            parts.extend([str(self.current_scene_index), self.current_scene])
-
-        parts.append(self.path_stem)
-
-        return delim.join(parts)
-
     def get_layer_data_tuples(
         self,
         layer_type: str | None = None,
@@ -440,24 +458,22 @@ def get_layer_data_tuples(
         https://napari.org/dev/plugins/building_a_plugin/guides.html
 
         """
-        # Access layer_data property to ensure it's loaded
         layer_data = self.layer_data
-
         if layer_type is not None:
             channel_types = None  # Global override ignores per-channel
-
+        names = self.layer_names
         base_metadata = self.layer_metadata
         scale = self.layer_scale
         axis_labels = self.layer_axis_labels
         units = self.layer_units
 
         # Handle RGB images (Samples dimension 'S')
-        if 'S' in self.reader.dims.order:
+        if 'S' in self.dims.order:
             return [
                 build_layer_tuple(
                     layer_data.data,
                     layer_type='image',
-                    name=self._build_layer_name(),
+                    name=names[0],
                     metadata=base_metadata,
                     scale=scale,
                     axis_labels=axis_labels,
@@ -470,7 +486,7 @@ def get_layer_data_tuples(
 
         # Single channel (no C dimension to split)
         if channel_dim not in layer_data.dims:
-            channel_name = get_single_channel_name(layer_data, channel_dim)
+            channel_name = self.channel_names[0]
             effective_type = resolve_layer_type(
                 channel_name or '', layer_type, channel_types
             )
@@ -483,7 +499,7 @@ def get_layer_data_tuples(
                 build_layer_tuple(
                     layer_data.data,
                     layer_type=effective_type,
-                    name=self._build_layer_name(channel_name),
+                    name=names[0],
                     metadata=base_metadata,
                     scale=scale,
                     axis_labels=axis_labels,
@@ -493,17 +509,13 @@ def get_layer_data_tuples(
             ]
 
         # Multichannel - split into separate layers
-        channel_names = [
-            str(c) for c in layer_data.coords[channel_dim].data.tolist()
-        ]
+        channel_names = self.channel_names
         channel_axis = layer_data.dims.index(channel_dim)
         total_channels = layer_data.shape[channel_axis]
 
         tuples: list[LayerDataTuple] = []
         for i in range(total_channels):
-            channel_name = (
-                channel_names[i] if i < len(channel_names) else f'channel_{i}'
-            )
+            channel_name = channel_names[i]
             effective_type = resolve_layer_type(
                 channel_name, layer_type, channel_types
             )
@@ -521,7 +533,7 @@ def get_layer_data_tuples(
                 build_layer_tuple(
                     channel_data,
                     layer_type=effective_type,
-                    name=self._build_layer_name(channel_name),
+                    name=names[i],
                     metadata=base_metadata,
                     scale=scale,
                     axis_labels=axis_labels,

src/ndevio/utils/_layer_utils.py

@@ -6,7 +6,6 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    import xarray as xr
     from bioio_base.types import ArrayLike
     from napari.types import LayerDataTuple
 
@@ -16,41 +15,6 @@
 LABEL_KEYWORDS = frozenset({'label', 'mask', 'segmentation', 'seg', 'roi'})
 
 
-def get_single_channel_name(
-    layer_data: xr.DataArray,
-    channel_dim: str,
-) -> str | None:
-    """Extract channel name from coords for single-channel image.
-
-    When an image has been squeezed and no longer has a Channel dimension,
-    the channel name may still be available in the coordinates.
-
-    Parameters
-    ----------
-    layer_data : xr.DataArray
-        The image data array.
-    channel_dim : str
-        Name of the channel dimension (e.g., 'C').
-
-    Returns
-    -------
-    str | None
-        The channel name if found, else None.
-
-    Examples
-    --------
-    >>> # For a squeezed single-channel image with coords
-    >>> get_single_channel_name(data, 'C')
-    'DAPI'
-
-    """
-    if channel_dim in layer_data.coords:
-        coord = layer_data.coords[channel_dim]
-        if coord.size == 1:
-            return str(coord.item())
-    return None
-
-
 def infer_layer_type(channel_name: str) -> str:
     """Infer layer type from channel name keywords.
 

tests/test_nimage.py

@@ -303,6 +303,23 @@ def test_layer_names_include_channel_names(self, resources_dir: Path):
         assert 'membrane' in names[0]
         assert 'nuclei' in names[1]
 
+    def test_layer_names_matches_tuple_names(self, resources_dir: Path):
+        """Test that layer_names property matches names in get_layer_data_tuples."""
+        img = nImage(resources_dir / CELLS3D2CH_OME_TIFF)
+        layer_tuples = img.get_layer_data_tuples()
+
+        # layer_names should match names baked into the tuples
+        assert img.layer_names == [meta['name'] for _, meta, _ in layer_tuples]
+        assert len(img.layer_names) == 2
+        assert 'membrane' in img.layer_names[0]
+        assert 'nuclei' in img.layer_names[1]
+
+    def test_layer_names_single_channel(self, resources_dir: Path):
+        """Test layer_names for a single-channel image."""
+        img = nImage(resources_dir / LOGO_PNG)
+        assert len(img.layer_names) == 1
+        assert img.layer_names[0].endswith(img.path_stem)
+
     def test_single_channel_image_returns_single_tuple(
         self, resources_dir: Path
     ):

tests/test_utils/test_layer_utils.py

@@ -239,38 +239,3 @@ def test_extra_kwargs_override(self):
 
         assert result[1]['colormap'] == 'custom'
         assert result[1]['visible'] is False
-
-
-class TestGetSingleChannelName:
-    """Tests for get_single_channel_name function."""
-
-    def test_returns_channel_name_from_coords(self):
-        """Test extracting channel name from coords."""
-        import numpy as np
-        import xarray as xr
-
-        from ndevio.utils._layer_utils import get_single_channel_name
-
-        data = xr.DataArray(
-            np.zeros((10, 10)),
-            dims=['Y', 'X'],
-            coords={'C': 'DAPI'},  # Single channel coord
-        )
-
-        result = get_single_channel_name(data, 'C')
-        assert result == 'DAPI'
-
-    def test_returns_none_when_no_coord(self):
-        """Test returns None when no channel coord."""
-        import numpy as np
-        import xarray as xr
-
-        from ndevio.utils._layer_utils import get_single_channel_name
-
-        data = xr.DataArray(
-            np.zeros((10, 10)),
-            dims=['Y', 'X'],
-        )
-
-        result = get_single_channel_name(data, 'C')
-        assert result is None