fix(ome_zarr): 🐛 canonicalize TIFF-sequence axes to channel-first

sequence_pattern derived axis order straight from the regex's named
groups, so a filename layout like _T0_Z000_C0_ put the channel axis
at position 2 instead of 0 — load_ome_zarr/tile_process hard-assume
axis 0 is the channel (arr[channel]), so channel= silently sliced the
wrong axis for any multi-Z, multi-channel sequence.

Reorder to patchworks' czyx convention and drop singleton non-spatial
axes (e.g. a constant T0), matching what _open_bioio/_open_imaris
already do, regardless of the pattern's group order.

Author: lguerard

docs/guide/ome_zarr_napari.md

@@ -66,7 +66,7 @@ sample_T0_Z001_C1_V0.tif
 
 Pass `sequence_pattern=` and let `source` be a glob over the folder instead of
 one file path. The pattern is a regex whose **named groups** map to axis
-labels — axis order follows the order the groups appear in the pattern:
+labels — one file per group of indices:
 
 ```python
 to_ome_zarr(
@@ -77,6 +77,13 @@ to_ome_zarr(
 )
 ```
 
+You don't need to order the named groups to match how the axes should come
+out: the result is always reordered to patchworks' `c, z, y, x` convention —
+required for `channel=` selection (`load_ome_zarr`/`tile_process` always read
+the channel from axis 0) — and a constant axis like `T0` above (one value, no
+real time series) is dropped automatically, the same way the bioio/Imaris
+readers already drop a singleton time axis.
+
 Each file becomes exactly **one dask chunk**, decoded lazily on access — no
 data is duplicated or eagerly loaded, so this scales to huge (multi-TB)
 sequences (built on `tifffile.TiffSequence`, the same mechanism Cellpose's

src/patchworks/plugins/ome_zarr.py

@@ -701,15 +701,19 @@ def _open_tiff_sequence(
     sequence_pattern : str
         Regular expression parsing each file name into axis labels and
         indices, e.g. ``r"_T(?P<T>\\d+)_Z(?P<Z>\\d+)_C(?P<C>\\d+)_V\\d+"``.
-        Named groups become axis labels directly; axis order follows the
-        order groups appear in the pattern.
+        Named groups become axis labels directly — the order they appear in
+        the *pattern* (not the filename) doesn't matter, the result is
+        always reordered to patchworks' ``tczyx`` convention and any
+        singleton non-spatial axis (e.g. a constant ``T0``) is dropped, same
+        as the bioio/Imaris readers, so a real channel axis always ends up
+        first (required by :func:`patchworks.load_ome_zarr`).
 
     Returns
     -------
     tuple
         ``(array, axes, pixel_size)`` — a lazy dask array, its axes string
-        (parsed axes + trailing ``"yx"``) and a ``{axis: micrometers}``
-        calibration dict read from the first file.
+        (parsed axes, canonicalised, + trailing ``"yx"``) and a
+        ``{axis: micrometers}`` calibration dict read from the first file.
     """
     try:
         import tifffile
@@ -722,7 +726,33 @@ def _open_tiff_sequence(
 
     ts = tifffile.TiffSequence(pattern, pattern=sequence_pattern)
     arr = da.from_zarr(zarr.open(store=ts.aszarr()))
-    axes = ts.axes.lower() + "yx"
+    full_axes = ts.axes.lower() + "yx"
+
+    # Canonicalise to patchworks' tczyx axis order regardless of the order
+    # sequence_pattern's groups happen to appear in (unrecognised axes sort
+    # last, before y/x).
+    order = sorted(
+        range(len(full_axes)),
+        key=lambda i: (
+            _DEFAULT_ORDER.index(full_axes[i])
+            if full_axes[i] in _DEFAULT_ORDER
+            else len(_DEFAULT_ORDER)
+        ),
+    )
+    arr = arr.transpose(order)
+    ordered_axes = "".join(full_axes[i] for i in order)
+
+    # Drop singleton non-spatial axes (e.g. a constant T), matching
+    # _open_bioio/_open_imaris, so a real channel axis lands at position 0.
+    keep = [
+        i
+        for i, a in enumerate(ordered_axes)
+        if a in _SPATIAL_AXES or arr.shape[i] > 1
+    ]
+    index = tuple(slice(None) if i in keep else 0 for i in range(arr.ndim))
+    arr = arr[index]
+    axes = "".join(ordered_axes[i] for i in keep)
+
     pixel_size = _tiff_pixel_size(ts[0])
     logger.info(
         "tifffile sequence opened %s files as %s %s cal=%s",
@@ -979,8 +1009,11 @@ def to_ome_zarr(
         and indices via named groups, e.g.
         ``r"_T(?P<T>\\d+)_Z(?P<Z>\\d+)_C(?P<C>\\d+)_V\\d+"``. Each file
         becomes exactly one chunk, read lazily on access (no data
-        duplicated) — see :func:`tifffile.TiffSequence`. Axis order follows
-        the order named groups appear in the pattern.
+        duplicated) — see :func:`tifffile.TiffSequence`. The result is
+        always reordered to patchworks' ``czyx`` convention regardless of
+        the order named groups appear in the pattern, and any singleton
+        non-spatial axis (e.g. a constant ``T0``) is dropped, so a real
+        channel axis always ends up first.
     n_levels : int, optional
         Maximum number of pyramid levels including full resolution.
     downscale : int, optional

tests/test_ome_zarr.py

@@ -80,7 +80,12 @@ def test_non_spatial_axis_not_downsampled(tmp_path):
 
 
 def test_tiff_sequence_conversion(tmp_path):
-    """A folder of single-plane TIFFs is wrapped lazily and converted."""
+    """A folder of single-plane TIFFs is wrapped lazily and converted.
+
+    The filename pattern lists Z before C, but the output must still come
+    out channel-first (patchworks' tczyx convention), since load_ome_zarr /
+    tile_process hard-assume axis 0 is the channel axis.
+    """
     tifffile = pytest.importorskip("tifffile")
     n_z, n_c, size = 3, 2, 8
     for z in range(n_z):
@@ -102,14 +107,43 @@ def test_tiff_sequence_conversion(tmp_path):
     )
 
     result = np.asarray(load_ome_zarr(out, channel=None))
-    assert result.shape == (n_z, n_c, size, size)
+    assert result.shape == (n_c, n_z, size, size)  # channel-first, not z-first
     # each plane's constant value encodes its (z, c) position.
     assert (
         result[:, :, 0, 0]
-        == [[z * 10 + c for c in range(n_c)] for z in range(n_z)]
+        == [[z * 10 + c for z in range(n_z)] for c in range(n_c)]
     ).all()
     assert _level_scale(out, 0) == pytest.approx([1.0, 1.0, 0.5, 0.5])
 
+    # per-channel selection picks the right plane regardless of pattern order.
+    ch1 = np.asarray(load_ome_zarr(out, channel=1))
+    assert ch1.shape == (n_z, size, size)
+    assert (ch1[:, 0, 0] == [z * 10 + 1 for z in range(n_z)]).all()
+
+
+def test_tiff_sequence_drops_singleton_time_axis(tmp_path):
+    """A constant T in the pattern is dropped, keeping channel at axis 0."""
+    tifffile = pytest.importorskip("tifffile")
+    n_z, n_c, size = 2, 3, 8
+    for z in range(n_z):
+        for c in range(n_c):
+            img = np.full((size, size), z * 10 + c, dtype="uint16")
+            tifffile.imwrite(tmp_path / f"sample_T0_Z{z:03d}_C{c}_V0.tif", img)
+
+    out = tmp_path / "out.zarr"
+    to_ome_zarr(
+        str(tmp_path / "*.tif"),
+        out,
+        sequence_pattern=r"_T(?P<T>\d+)_Z(?P<Z>\d+)_C(?P<C>\d+)_V\d+",
+        n_levels=1,
+    )
+
+    result = np.asarray(load_ome_zarr(out, channel=None))
+    assert result.shape == (n_c, n_z, size, size)  # no leftover T axis
+    ch2 = np.asarray(load_ome_zarr(out, channel=2))
+    assert ch2.shape == (n_z, size, size)
+    assert (ch2[:, 0, 0] == [z * 10 + 2 for z in range(n_z)]).all()
+
 
 def test_axes_length_mismatch(tmp_path):
     with pytest.raises(ValueError):