micro-reader 0.2.0__tar.gz → 0.2.1__tar.gz

{micro_reader-0.2.0 → micro_reader-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: micro-reader
-Version: 0.2.0
+Version: 0.2.1
 Summary: Low-level, memory-bounded pixel reading for microscopy formats: read exactly the rectangle you ask for.
 Project-URL: Homepage, https://github.com/bugraoezdemir/micro-reader
 Project-URL: Source, https://github.com/bugraoezdemir/micro-reader

{micro_reader-0.2.0 → micro_reader-0.2.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "micro-reader"
-version = "0.2.0"
+version = "0.2.1"
 description = "Low-level, memory-bounded pixel reading for microscopy formats: read exactly the rectangle you ask for."
 readme = "README.md"
 requires-python = ">=3.11"

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/_errors.py

@@ -45,8 +45,9 @@ class CompositeWarning(UserWarning):
 
 class CompanionWarning(UserWarning):
     """An OME companion set's metadata came from somewhere other than the file
-    opened, or a member path had to be resolved differently than written
-    (docs/COMPANION.md)."""
+    opened, a member path had to be resolved differently than written, or the
+    companion's bytes had to be read in another encoding than its XML
+    declares (docs/COMPANION.md)."""
 
 
 class SkewedGridWarning(UserWarning):

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/_version.py

@@ -1,2 +1,2 @@
 """micro-reader's version, in one place (the package, the import guard)."""
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/backends/_lif_metadata.py

@@ -8,11 +8,14 @@ element.
   ``NumberOfElements - 1`` in m) is LAS's index space -- FLIM "Phasor
   Plot", "Phasor Mask" and "Pattern Matching Scatter Plot", the only such
   images in every local Leica file -- and gives no pixel size.
-- Channels: colour from ``ChannelDescription`` ``LUTName``; names: the dye
-  names (``MultiBand DyeName``) of the active detectors of the image's
-  confocal setting, only when there is one per channel (sequential scans
-  spread channels over several settings: names unknown).  Channel
-  wavelengths: out of scope for now.
+- Channels: colour from ``ChannelDescription`` ``LUTName``; names from the
+  image's hardware setting (``_channel_names``): confocal, the active
+  detectors' dyes (``DyeName``, else the ``MultiBand`` dye; LAS's ``Leica/``
+  prefix dropped), else the detector's name; widefield, the user's channel
+  name (``UserDefName``), else the filter cube, else the contrasting method,
+  with the emission wavelength -- only when the setting describes exactly
+  the image's channels (sequential scans spread channels over several
+  settings: names unknown).  Excitation wavelengths: out of scope for now.
 - Index values (D5): the image's wavelength along a lambda (``emission``,
   DimID 5) or excitation (``excitation``, DimID 9) dimension, ``Origin`` +
   k x ``Length`` / (N - 1), in nm.
@@ -73,6 +76,57 @@ def _setting(element):
     return None
 
 
+#: LAS X's dye catalogue prefixes a dye's name (``Leica/ALEXA 488``)
+DYE_PREFIXES = ("Leica/",)
+
+
+def _dye(name):
+    """A dye's name as the user knows it: the catalogue prefix dropped; None for none."""
+    name = (name or "").strip()
+    for prefix in DYE_PREFIXES:
+        if name.startswith(prefix):
+            name = name[len(prefix):]
+    return name or None
+
+
+def _channel_names(setting, n_c: int, luts: list) -> tuple:
+    """``([name or None, ...], [emission or None, ...])`` for the image's *n_c*
+    channels from its hardware setting, or ``([], [])`` when the setting does not
+    describe exactly them (a sequential scan spreads channels over settings).
+
+    Confocal (``ATLConfocalSettingDefinition``): the active detectors, in order; a
+    channel is named after its dye (the detector's ``DyeName``, else the ``MultiBand``
+    dye of its channel; ``_dye``), else after the detector (``HyD S 2``).  Widefield
+    (``ATLCameraSettingDefinition``): the active ``WideFieldChannelInfo`` entries; when
+    there are more than channels (an autofocus channel beside the image's), those whose
+    ``LUT`` matches the channels' ``LUTName``, in order.  A channel is named as the user
+    named it (``UserDefName``), else after its filter cube (``FluoCubeName``), else its
+    contrasting method (``FLUO``, ``BF``); its ``EmissionWavelength`` is in nm."""
+    if setting.tag == "ATLCameraSettingDefinition":
+        infos = [w for w in setting.iter("WideFieldChannelInfo") if w.get("Active") == "1"]
+        if len(infos) != n_c and len(luts) == n_c:
+            picked, left = [], list(infos)
+            for lut in luts:
+                hit = next((w for w in left if (w.get("LUT") or "").lower() == (lut or "").lower()), None)
+                if hit is None:
+                    break
+                picked.append(hit)
+                left.remove(hit)
+            infos = picked
+        if len(infos) != n_c:
+            return [], []
+        names = [w.get("UserDefName") or w.get("FluoCubeName") or w.get("ContrastingMethodName") or None
+                 for w in infos]
+        emissions = [quantity(w.get("EmissionWavelength"), "nanometer") for w in infos]
+        return names, emissions
+    bands = {b.get("Channel"): b.get("DyeName") or None for b in setting.iter("MultiBand")}
+    active = [d for d in setting.iter("Detector") if d.get("IsActive") == "1"]
+    if len(active) != n_c:
+        return [], []
+    return [_dye(d.get("DyeName") or bands.get(d.get("Channel"))) or d.get("Name") or None
+            for d in active], []
+
+
 def _stage_position(element, setting, tile) -> dict:
     """The stage position recorded for the image (*tile*: None) or for its
     tile (``TileScanInfo`` PosX / PosY): {axis: Quantity}.  Both are along
@@ -229,16 +283,13 @@ def lif_metadata(element, shape: dict, index: dict, tiled: bool = False,
     if shape.get("s", 1) > 1:                 # interleaved RGB: one channel, no LUT colour
         colors = []
     setting = _setting(element)
-    names = []
-    if setting is not None:
-        bands = {b.get("Channel"): b.get("DyeName") or None for b in setting.iter("MultiBand")}
-        active = [d.get("Channel") for d in setting.iter("Detector") if d.get("IsActive") == "1"]
-        if len(active) == n_c:
-            names = [bands.get(ch) for ch in active]
+    names, emissions = ([], []) if setting is None else _channel_names(
+        setting, n_c, [c.get("LUTName") for c in descriptions])
     channels = []
     for k in range(n_c):
         channels.append(Channel(name=names[k] if k < len(names) else None,
-                                color=colors[k] if k < len(colors) else None))
+                                color=colors[k] if k < len(colors) else None,
+                                emission_wavelength=emissions[k] if k < len(emissions) else None))
     position = {}
     stage = _stage_position(element, setting, tile)
     if stage:

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/backends/companion.py

@@ -24,6 +24,9 @@ OME-TIFFs: each ``TiffData`` says which file (``UUID FileName``), which pages
   not exist falls back to the same name in the companion's folder, with a
   ``CompanionWarning``.
 - Missing members: as for every file set (``_fileset.keep_fields``).
+- A companion whose bytes are not in the encoding it declares (Prairie View:
+  Windows ``µ`` under UTF-8) is read as cp1252, else latin-1, with a
+  ``CompanionWarning``; one that is no XML either way is a ``CorruptFileError``.
 - The parsed companion is cached per process (``CORE_CACHE`` companions, by
   path, modification time and size), apart from the pixel caches.
 
@@ -34,8 +37,10 @@ separate images (docs/COMPANION.md, "A").
 from __future__ import annotations
 
 import builtins
+import codecs
 import math
 import os
+import re
 import threading
 import warnings
 import xml.etree.ElementTree as ET
@@ -289,6 +294,11 @@ class Core:
 
 #: the first bytes of a TIFF / BigTIFF, either byte order
 TIFF_MAGIC = (b"II*\x00", b"MM\x00*", b"II+\x00", b"MM\x00+")
+#: encodings tried in turn when a companion's bytes are not in the encoding
+#: its XML declaration says: cp1252 first (what Windows software writes, and
+#: what tifffile falls back to for a TIFF description), latin-1 for the few
+#: bytes cp1252 leaves undefined
+FALLBACK_ENCODINGS = ("cp1252", "latin-1")
 
 
 def _ome_root(path: str):
@@ -298,7 +308,7 @@ def _ome_root(path: str):
     with builtins.open(path, "rb") as fh:
         magic = fh.read(4)
     if magic not in TIFF_MAGIC:
-        return ET.parse(path).getroot()
+        return _xml_file_root(path)
     import tifffile
     try:
         with tifffile.TiffFile(path, **PLAIN_PAGES) as tif:
@@ -310,6 +320,52 @@ def _ome_root(path: str):
     return ET.fromstring(text)
 
 
+def _xml_file_root(path: str):
+    """The root element of the XML file *path*.
+
+    A file whose bytes are not in the encoding its declaration says (Prairie
+    View writes ``µ`` as the one Windows byte 0xB5 into every unit attribute,
+    under ``encoding="UTF-8"``) is decoded as cp1252, else latin-1
+    (``FALLBACK_ENCODINGS``), with a ``CompanionWarning`` naming the file and
+    the encoding used.  A file that is no XML in any of them raises the
+    ``ET.ParseError`` of its declared encoding, as before."""
+    try:
+        return ET.parse(path).getroot()
+    except ET.ParseError as exc:
+        error = exc
+    with builtins.open(path, "rb") as fh:
+        raw = fh.read()
+    if raw.startswith(codecs.BOM_UTF8):           # a BOM is no character of the text
+        raw = raw[len(codecs.BOM_UTF8):]
+    declared = _declared_encoding(raw)
+    try:
+        raw.decode(declared)
+    except (UnicodeDecodeError, LookupError) as bad:
+        where = f"byte {bad.start}" if isinstance(bad, UnicodeDecodeError) else "unknown"
+    else:
+        raise error                               # the bytes are fine: it is no XML
+    for encoding in FALLBACK_ENCODINGS:
+        try:
+            text = raw.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+        # the declaration is dropped: it names the encoding the bytes are not in
+        text = re.sub(r"^\s*<\?xml[^>]*\?>", "", text)
+        root = ET.fromstring(text)                # ParseError: no XML in this encoding either
+        warnings.warn(CompanionWarning(
+            f"{path!r}: its XML declares {declared!r} but its bytes are not ({where}); read "
+            f"as {encoding!r}"), stacklevel=5)
+        return root
+    raise error
+
+
+def _declared_encoding(raw: bytes) -> str:
+    """The encoding an XML declaration at the start of *raw* names, else
+    "utf-8" (the XML default)."""
+    found = re.match(rb'\s*<\?xml[^>]*?encoding\s*=\s*["\']([A-Za-z0-9._-]+)["\']', raw)
+    return found.group(1).decode("ascii").lower() if found else "utf-8"
+
+
 def _page_count(path: str) -> int:
     """Pages of a member file (an OME TiffData without IFD or PlaneCount covers
     them all); 1 when the file is missing (it reads as zeros anyway)."""

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/backends/cv7000.py

@@ -13,7 +13,13 @@ micro-reader reads the measurement in that folder.
 - ``MeasurementData.mlf``: one ``MeasurementRecord`` per plane: ``Type``
   ``IMG`` with 1-based ``Row`` / ``Column`` / ``TimePoint`` / ``FieldIndex``
   / ``ZIndex``, ``ActionIndex``, ``Ch``, stage ``X`` / ``Y`` / ``Z`` (um) and
-  the file name; ``ERR`` records log instrument errors (one warning).
+  the file name; ``ERR`` records log instrument errors (one warning).  A
+  plane listed twice is read from the first record whose file exists
+  (Bio-Formats' rule: a metadata-only record never shadows a real one).
+- The files name their elements and attributes in the BTS namespace with
+  any prefix (``bts:``, ``record:``, a default namespace) or none at all;
+  they are matched by namespace URI or local name, never by prefix.  Numbers
+  may use a decimal comma (``0,65``).
 - One micro-reader image per field, axes ``t c z y x``.  A channel is an
   (action, camera channel) pair, as Bio-Formats counts them.  Indices:
   ``plate`` 0, ``acquisition`` 0, ``well`` (row then column), ``field`` =
@@ -40,13 +46,23 @@ Harmony-format export (``Index.idx.xml``) and the settings files (``.wpp``,
 ``.mes``, ``.ppp``, ``.ppf``, ``.icr``, ``*_parameter.xml``) are its parts and
 open it.  The plane TIFFs are the index's members (they open alone).
 
-Missing files: as for every file set (``_fileset.keep_fields``).  Refused:
-several timelines, channels imaged at different timepoints, channels with
-different pixel sizes or image sizes.
+Missing files: as for every file set (``_fileset.keep_fields``).  The
+timelines of the settings file (``TimelineIndex``: each images its own wells,
+fields and actions, its TimePoint numbers running on from the timeline
+before) are merged, as Bio-Formats merges them (checked against its expected
+results for the 14 synthetic packages of Zenodo 21334895): each timeline's
+timepoints are counted from its own first one, a field holds every plane
+recorded for it, a well imaged by two timelines holds the channels of both,
+and the plate's channels are the (action, camera channel) pairs of all its
+records; a plane a second timeline images with the channel and timepoint of
+the first becomes a channel of its own, named after its timeline (Bio-Formats'
+"timeline-qualified overflow").  Refused: channels imaged at different
+timepoints, channels with different pixel sizes or image sizes.
 """
 from __future__ import annotations
 
 import os
+import re
 import warnings
 import xml.etree.ElementTree as ET
 from dataclasses import replace
@@ -65,8 +81,10 @@ NAME = "cv7000"
 SET_INDEX = True
 BTS = "{http://www.yokogawa.co.jp/BTS/BTSSchema/1.0}"
 DETAIL, DATA = "MeasurementDetail.mrf", "MeasurementData.mlf"
-#: the root elements of the files that open a measurement (not .wpp / .mes)
-ENTRY_ROOTS = (b"bts:WellPlate ", b"bts:MeasurementDetail ", b"bts:MeasurementData ")
+#: the root element of a file that opens a measurement (not .wpp / .mes),
+#: with any namespace prefix or none (``<bts:WellPlate ``, ``<plate:WellPlate ``,
+#: ``<WellPlate>``; not ``<bts:WellPlateProduct``)
+ENTRY_ROOT = re.compile(rb"<(?:[A-Za-z_][\w.-]*:)?(?:WellPlate|MeasurementDetail|MeasurementData)[\s/>]")
 
 
 #: the CellVoyager software's default channel ``Target``: it names no channel
@@ -131,11 +149,21 @@ def may_index(name: str) -> bool:
 
 
 def sniff(head: bytes, path: str) -> bool:
-    return b"yokogawa.co.jp/BTS" in head and any(r in head for r in ENTRY_ROOTS)
+    return b"yokogawa.co.jp/BTS" in head and ENTRY_ROOT.search(head) is not None
 
 
 def _a(e, name):
-    return e.get(BTS + name)
+    """Attribute *name* of *e*: in the BTS namespace (any prefix), else
+    unprefixed (no namespace, also under a default namespace)."""
+    value = e.get(BTS + name)
+    return e.get(name) if value is None else value
+
+
+def _number(value):
+    """A number's text with a decimal comma (``0,65``) made a point."""
+    if isinstance(value, str) and value.count(",") == 1 and "." not in value:
+        return value.replace(",", ".")
+    return value
 
 
 def _int(e, name):
@@ -147,7 +175,7 @@ def _int(e, name):
 
 def _float(e, name):
     try:
-        return float(_a(e, name))
+        return float(_number(_a(e, name)))
     except (TypeError, ValueError):
         return None
 
@@ -162,7 +190,7 @@ def _parse(path):
 
 
 class _CVImage(PlaneImage):
-    """A field (or a part of a ragged one); *channels*: its (action, Ch)
+    """A field (or a part of a ragged one); *channels*: its (action, Ch, run)
     keys, *records*: its planes' (t, key, z) -> (X, Y, Z, Time)."""
 
     def __init__(self, *args, info: dict, channels: list, dz, records: dict, times: list,
@@ -204,8 +232,19 @@ class _CVImage(PlaneImage):
         position = {a: q for a, q in position.items() if q is not None}
         return Metadata(pixel_sizes={a: q for a, q in sizes.items() if q}, position=position,
                         coordinate_system=self._system if position else None,
-                        channels=tuple(names.get(ch, Channel(name=f"Action {act}, Ch {ch}"))
-                                       for act, ch in self._channels))
+                        channels=tuple(self._channel(names, act, ch, run)
+                                       for act, ch, run in self._channels))
+
+    @staticmethod
+    def _channel(names: dict, act: int, ch: int, run: int) -> Channel:
+        """The channel's description: the settings file's for camera channel *ch*,
+        else a name from the action and channel; a channel a second timeline
+        added (*run*: its TimelineIndex, 0 for the first) says so."""
+        channel = names.get(ch, Channel(name=f"Action {act}, Ch {ch}"))
+        if run:
+            channel = replace(channel, name=f"{channel.name or f'Action {act}, Ch {ch}'} "
+                                            f"(timeline {run})")
+        return channel
 
 
 class _CVFile(File):
@@ -219,35 +258,59 @@ class _CVFile(File):
         detail = _parse(os.path.join(folder, DETAIL))
         data = _parse(os.path.join(folder, DATA))
         rows, columns = _int(detail, "RowCount"), _int(detail, "ColumnCount")
-        sample = detail.find(BTS + "MeasurementSamplePlate")
+        sample = detail.find("{*}MeasurementSamplePlate")
         plate_name = (_a(sample, "Name") if sample is not None else None) or os.path.basename(folder)
-        cameras = {_int(e, "Ch"): e for e in detail.findall(BTS + "MeasurementChannel")}
+        cameras = {_int(e, "Ch"): e for e in detail.findall("{*}MeasurementChannel")}
         settings = _a(detail, "MeasurementSettingFileName")
         channel_info = self._channels(os.path.join(folder, settings)) if settings else {}
 
-        listed: dict = {}     # (row, col, field) -> {(t, (action, ch), z): path}
-        records: dict = {}    # (row, col, field) -> {(t, (action, ch), z): (X, Y, Z, Time)}
-        timelines, errors = set(), []
-        for e in data.findall(BTS + "MeasurementRecord"):
+        # every IMG record of the measurement; the timelines of the settings file
+        # (TimelineIndex) are merged as Bio-Formats merges them: each timeline's
+        # timepoints counted from its own first one (TimePoint numbers run on from
+        # one timeline to the next), then the planes of a field put together
+        # (module docstring)
+        found: list = []      # (timeline, (row, col, field), (TimePoint, (action, ch), z), path, rec)
+        errors = []
+        for e in data.findall("{*}MeasurementRecord"):
             kind = _a(e, "Type")
             if kind == "ERR":
                 errors.append((e.text or "").strip())
                 continue
             if kind != "IMG":
                 continue
-            timelines.add(_a(e, "TimelineIndex"))
+            timeline = _int(e, "TimelineIndex") if _a(e, "TimelineIndex") is not None else 1
             key = (_int(e, "Row") - 1, _int(e, "Column") - 1, _int(e, "FieldIndex"))
             plane = (_int(e, "TimePoint"), (_int(e, "ActionIndex"), _int(e, "Ch")),
                      _int(e, "ZIndex"))
             name = (e.text or "").strip()
-            listed.setdefault(key, {})[plane] = os.path.join(folder, name) if name else None
-            records.setdefault(key, {})[plane] = (_float(e, "X"), _float(e, "Y"), _float(e, "Z"),
-                                                  self._time(_a(e, "Time")))
+            found.append((timeline, key, plane, os.path.join(folder, name) if name else None,
+                          (_float(e, "X"), _float(e, "Y"), _float(e, "Z"),
+                           self._time(_a(e, "Time")))))
+        ranks = {}            # timeline -> {TimePoint: its rank in the timeline}
+        for timeline, _key, (tp, _ch, _z), _p, _rec in found:
+            ranks.setdefault(timeline, set()).add(tp)
+        ranks = {line: {tp: k for k, tp in enumerate(sorted(tps))} for line, tps in ranks.items()}
+        listed: dict = {}     # (row, col, field) -> {(t, (action, ch), z): path}
+        records: dict = {}    # (row, col, field) -> {(t, (action, ch), z): (X, Y, Z, Time)}
+        owner: dict = {}      # (row, col, field), plane -> the timeline it came from
+        for timeline, key, (tp, (action, ch), z), file, rec in found:
+            # a channel is (action, camera channel, 0); a plane another timeline
+            # imaged already with the same channel and timepoint becomes a channel
+            # of its own, qualified by its timeline (Bio-Formats' "overflow")
+            plane = (ranks[timeline][tp], (action, ch, 0), z)
+            field = listed.setdefault(key, {})
+            if plane in field and owner[(key, plane)] != timeline and field[plane] != file:
+                plane = (plane[0], (action, ch, timeline), z)
+            if plane in field:
+                # a plane listed again: the first record whose file exists is kept
+                # (a metadata-only record never shadows a real one, module docstring)
+                if field[plane] and os.path.isfile(field[plane]):
+                    continue
+            field[plane] = file
+            owner[(key, plane)] = timeline
+            records.setdefault(key, {})[plane] = rec
         if not listed:
             raise CorruptFileError(f"{path!r}: the measurement lists no images")
-        if len(timelines) > 1:
-            raise UnsupportedFormatError(
-                f"{path!r}: {len(timelines)} timelines in one measurement are not read yet")
         if errors:
             warnings.warn(f"{path!r}: the instrument logged {len(errors)} error"
                           f"{'' if len(errors) == 1 else 's'} (e.g. {errors[0]!r})", stacklevel=3)
@@ -255,7 +318,7 @@ class _CVFile(File):
         wanted = sorted({p for field in listed.values() for p in field})
         times = sorted({t for t, _k, _z in wanted})
         check_times(wanted, path)
-        used = sorted({ch for _t, (_a_, ch), _z in wanted})
+        used = sorted({ch for _t, (_a_, ch, _run), _z in wanted})
         sizes = {(_float(cameras[ch], "HorizontalPixelDimension"),
                   _float(cameras[ch], "VerticalPixelDimension"),
                   _a(cameras[ch], "HorizontalPixels"), _a(cameras[ch], "VerticalPixels"))
@@ -274,8 +337,8 @@ class _CVFile(File):
             shape_hint = (_int(camera, "VerticalPixels"), _int(camera, "HorizontalPixels"))
         dtype, unit, shape_yx = self._members.plane_info(first, shape_hint)
         info = {"pixel_sizes": {} if camera is None else {
-                    "x": quantity(_a(camera, "HorizontalPixelDimension"), "micrometer"),
-                    "y": quantity(_a(camera, "VerticalPixelDimension"), "micrometer")},
+                    "x": quantity(_float(camera, "HorizontalPixelDimension"), "micrometer"),
+                    "y": quantity(_float(camera, "VerticalPixelDimension"), "micrometer")},
                 "channels": channel_info}
 
         wells_rc = sorted({(r, c) for r, c, _f in kept})
@@ -332,13 +395,13 @@ class _CVFile(File):
         if not os.path.isfile(mes):
             return {}
         root = _parse(mes)
-        lights = {e.get(BTS + "Name"): _float(e, "WaveLength")
-                  for e in root.iter(BTS + "LightSource")}
+        lights = {_a(e, "Name"): _float(e, "WaveLength")
+                  for e in root.iterfind(".//{*}LightSource")}
         out, fallback = {}, {}
-        for e in root.iter(BTS + "Channel"):
+        for e in root.iterfind(".//{*}Channel"):
             if _a(e, "Ch") is None:
                 continue
-            light = e.find(BTS + "LightSourceName")
+            light = e.find("{*}LightSourceName")
             light = light.text.strip() if light is not None and light.text else None
             ex = lights.get(light) if light else None
             em = None

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/backends/czi.py

@@ -315,6 +315,10 @@ class _PlaneTiles:
         self.rects = [(s.y - oy, s.y - oy + s.height, s.x - ox, s.x - ox + s.width)
                       for s in subblocks]
         self.cell = (max(s.height for s in subblocks), max(s.width for s in subblocks))
+        # a compressed tile is decoded whole: a band shorter than it would decode the
+        # same tile again for every band it crosses (the cache holds a few tiles)
+        self.decoded_rows = max((s.height for s in subblocks if s.compression != UNCOMPRESSED),
+                                default=0)
         self.grid: dict = {}
         for i, (y0, y1, x0, x1) in enumerate(self.rects):
             for cy in range(y0 // self.cell[0], (y1 - 1) // self.cell[0] + 1):
@@ -782,8 +786,9 @@ class _CziImage(Image):
             if tiles is None:
                 continue                                    # nothing acquired: background
             dst = out[tuple(k - s.start for k, s in zip(key, plane_spans))]
-            for b0 in range(ys.start, ys.stop, per_task):
-                b1 = min(ys.stop, b0 + per_task)
+            rows_per_task = max(per_task, tiles.decoded_rows)
+            for b0 in range(ys.start, ys.stop, rows_per_task):
+                b1 = min(ys.stop, b0 + rows_per_task)
                 part = dst[b0 - ys.start:b1 - ys.start]
                 tasks.append(lambda a=(tiles, b0, b1, xs, part): self._draw_band(*a))
         read = _pool.run(tasks)

{micro_reader-0.2.0 → micro_reader-0.2.1}/src/micro_reader/backends/harmony.py

@@ -13,6 +13,9 @@ the index file: micro-reader reads the plate it describes.
   0 or 1 depending on the instrument).
 - Indices: ``plate`` 0, ``acquisition`` 0 (one measurement per index file),
   ``well`` (the wells with images, row then column), ``field`` = FieldID - 1.
+- The plate's name: the index's ``Name``, else its ``PlateID``, else the
+  measurement folder's name (the folder above ``Images``; an index whose
+  ``Name`` and ``PlateID`` are empty is common), as outputs are named.
 - Missing planes (empty ``URL`` or no file; vendors list planes they did not
   write): a field missing some reads them as zeros, a field missing all is
   left out, with one ``MissingImagesWarning`` (``_fileset.keep_fields``).
@@ -25,9 +28,12 @@ the index file: micro-reader reads the plate it describes.
   the field's well.
 
 The measurement folder is also a composite (docs/COMPOSITE.md): next to
-``Images/`` it holds ``Assaylayout/`` (the plate map) and ``FFC_Profile/`` (the
-flat-field model); their files, those two folders and the measurement folder
-itself are parts of ``Images/Index.idx.xml`` and open it.
+``Images/`` it holds ``Assaylayout/`` (the plate map), ``FFC_Profile/`` (the
+flat-field model) and, once Harmony's analysis has run, ``Evaluation1/``,
+``Evaluation2/``, ... (its results: ``PlateResults.xml``, ``ObjectList_*.xml``,
+the ``.aas`` analysis script); their files, those folders, the other files in
+the measurement folder and the measurement folder itself are parts of
+``Images/Index.idx.xml`` and open it.
 """
 from __future__ import annotations
 
@@ -50,14 +56,22 @@ SET_INDEX = True
 #: where a measurement folder keeps its index (letter case aside: the "hs"
 #: archive of Harmony 5.2 / 6 writes ``images/index.xml``), and its side
 #: folders (lower case): classic ``Assaylayout`` / ``FFC_Profile``, hs
-#: ``flatfieldcorrection`` / ``index`` (measurement descriptions)
+#: ``flatfieldcorrection`` / ``index`` (measurement descriptions), and the
+#: analysis results ``Evaluation<n>`` (``SIDE_FOLDER_PATTERN``)
 IMAGES_FOLDERS = ("Images", "images")
 INDEX_FILES = ("Index.idx.xml", "Index.xml", "index.xml", "index.idx.xml")
 SIDE_FOLDERS = ("assaylayout", "ffc_profile", "flatfieldcorrection", "index")
+SIDE_FOLDER_PATTERN = re.compile(r"evaluation\d+")
 #: plane files: members of the index, opened as themselves (never parts)
 PLANE_SUFFIXES = (".tif", ".tiff")
 
 
+def _side_folder(name: str) -> bool:
+    """Is a folder called *name* (any letter case) a measurement's side folder?"""
+    name = name.lower()
+    return name in SIDE_FOLDERS or SIDE_FOLDER_PATTERN.fullmatch(name) is not None
+
+
 def _measurement_index(measurement: str):
     """The index file of the measurement folder *measurement*, or None (the
     spellings above only: ``owner`` runs on every open, so no folder listing)."""
@@ -71,6 +85,16 @@ def _measurement_index(measurement: str):
     return None
 
 
+def _measurement_name(images: str) -> str:
+    """The name of the measurement folder of the index in folder *images*: the
+    folder above ``Images``, or *images* itself when the index sits among its
+    planes (zenodo-15149351); ``""`` at a drive root."""
+    folder = os.path.abspath(images)
+    if os.path.basename(folder).lower() == "images":
+        folder = os.path.dirname(folder)
+    return os.path.basename(folder)
+
+
 def _spelled(path: str) -> str:
     """*path* with its folder's and file's names as stored (a case-insensitive
     file system finds ``Index.xml`` for ``index.xml``)."""
@@ -91,7 +115,7 @@ def may_own(folder: str, name: str, folders) -> bool:
     in a measurement folder (next to ``Images``) or, unless it is a plane,
     in ``Images`` may be a part."""
     base = folders.base(folder).lower()
-    return base in SIDE_FOLDERS or "images" in folders.names(folder) or \
+    return _side_folder(base) or "images" in folders.names(folder) or \
         (base == "images" and not name.lower().endswith(PLANE_SUFFIXES))
 
 
@@ -102,10 +126,10 @@ def owner(path: str, head):
     path = os.path.abspath(path)
     parent = os.path.dirname(path)
     if os.path.isdir(path):
-        if os.path.basename(path).lower() in SIDE_FOLDERS:
+        if _side_folder(os.path.basename(path)):
             path = os.path.dirname(path)
         index = _measurement_index(path)
-    elif os.path.basename(parent).lower() in SIDE_FOLDERS:
+    elif _side_folder(os.path.basename(parent)):
         index = _measurement_index(os.path.dirname(parent))
     elif os.path.basename(parent).lower() == "images":
         if path.lower().endswith(PLANE_SUFFIXES):
@@ -296,8 +320,9 @@ class _HarmonyFile(File):
         shape = (len(tps), len(chs), len(pls)) + shape_yx
         position = {(tp, ch, pl): (tps.index(tp), chs.index(ch), pls.index(pl))
                     for tp, ch, pl in wanted}
-        plate_name = _text(plate_e, "Name") or _text(plate_e, "PlateID") or ""
-        base = plate_name or os.path.basename(os.path.dirname(folder)) or os.path.basename(path)
+        plate_name = (_text(plate_e, "Name") or _text(plate_e, "PlateID")
+                      or _measurement_name(folder) or "")
+        base = plate_name or os.path.basename(path)
         row_names, column_names = layout(rows, columns, wells_rc, path)
         plates = [Plate(name=plate_name, rows=row_names, columns=column_names,
                         wells=tuple(Well(r, c, f"{row_label(r)}{c + 1}") for r, c in wells_rc))]