fix bug and clean up

_utils/image_io.py

@@ -7,6 +7,7 @@ for both the preview and the model.
 
 import os
 import tempfile
+from contextlib import contextmanager
 from typing import NamedTuple
 
 import numpy as np
@@ -22,6 +23,15 @@ except ImportError:  # pragma: no cover - tifffile is a project dependency
 RECOMMENDED_SIZE = 512
 WARN_SIZE = 3072
 MAX_SIZE = 4096
+# Warn below this: a shorter side under 32px means >16x upscaling to 512, so
+# there is almost no real detail for the model to work with.
+MIN_SIZE = 32
+# An integer image is a low-dynamic-range candidate when its full span is tiny
+# relative to the dtype's max. Float has no fixed range, so it is skipped.
+NARROW_RANGE_FRAC = 0.02
+# Sparse fluorescence can have a narrow span but still be valid; only flag it
+# when the max is not meaningfully above the 99th percentile.
+BRIGHT_TAIL_FRAC = 0.1
 # Measured on the uncompressed array, not the file size on disk: compression
 # makes disk size a poor proxy for what opening the file actually allocates.
 MAX_READ_BYTES = 300 * 1024 ** 2
@@ -33,14 +43,54 @@ _UNKNOWN = ("Q", "I")      # file named no axis; only these may be *guessed* as
 
 
 TIFF_EXTENSIONS = (
-    sorted("." + e for e in tifffile.TIFF.FILE_EXTENSIONS if "." not in e)
-    if tifffile is not None else [".tif", ".tiff"]
+    sorted(
+        {".ome.tif", ".ome.tiff"}
+        | {"." + e for e in tifffile.TIFF.FILE_EXTENSIONS if "." not in e}
+    )
+    if tifffile is not None else [".ome.tif", ".ome.tiff", ".tif", ".tiff"]
 )
 
 
+def _series_planes(series):
+    """Number of 2D planes in a series: the product of every axis that is not
+    spatial (Y/X) or RGB samples (S). Axes-aware on purpose - a positional
+    shape[:-2] would miscount RGB, which tifffile stores as a trailing S axis."""
+    planes = int(np.prod([
+        dim for axis, dim in zip(str(series.axes), series.shape)
+        if axis not in ("Y", "X", "S")
+    ]))
+    return planes or 1
+
+
+def _ome_needs_single_file(tif):
+    """True for a multi-file OME-TIFF whose logical series spans more planes than
+    this file holds: its data lives in sibling files that are not part of a
+    single upload, so the assembled series would zero-fill the out-of-file
+    planes. A self-contained OME has all its planes in-file (planes == pages)."""
+    try:
+        return bool(tif.is_ome) and _series_planes(tif.series[0]) > len(tif.pages)
+    except Exception:  # noqa: BLE001 - detection must never break the read
+        return False
+
+
+@contextmanager
+def _open_tiff(path):
+    """Open a TIFF; for a multi-file OME set whose series spans beyond this file,
+    reopen just this file's own pages (is_ome=False) so out-of-file planes are
+    not zero-filled. Detection is lazy (shape/pages only, no pixel decode)."""
+    tif = tifffile.TiffFile(path)
+    try:
+        if _ome_needs_single_file(tif):
+            tif.close()
+            tif = tifffile.TiffFile(path, is_ome=False)
+        yield tif
+    finally:
+        tif.close()
+
+
 def _read_tiff(path):
     """Read a TIFF-family file into (array, axes). Raises if not readable."""
-    with tifffile.TiffFile(path) as tif:
+    with _open_tiff(path) as tif:
         series = tif.series[0]
         page = tif.pages[0]
         arr = np.asarray(series.asarray())
@@ -82,7 +132,7 @@ def _shape_axes(path):
     """Return (shape, axes) from metadata only - no pixel decode."""
     if tifffile is not None:
         try:
-            with tifffile.TiffFile(path) as tif:
+            with _open_tiff(path) as tif:
                 series = tif.series[0]
                 return tuple(series.shape), str(series.axes)
         except Exception:  # noqa: BLE001 - fall through to PIL
@@ -243,9 +293,57 @@ def inspect_image(path):
         return ImageInfo(1, 1, "", False, (), 0, 0)
 
 
-def count_frames(path):
-    """Return how many frames a file's stack (Z/T) axis has (1 if not a stack)."""
-    return inspect_image(path).frames
+class PixelReport(NamedTuple):
+    """Pixel-level sanity checks on decoded image data (see ``pixel_stats``).
+
+    decoded   - False if the pixels could not be read (corrupt / truncated file)
+    finite    - False if the frame contains NaN/inf (only checked for float data)
+    vmin/vmax - min and max pixel value of the frame
+    dtype_max - np.iinfo(dtype).max for integer data, else 0.0
+    low_range - True if an integer frame's robust span is a tiny fraction of the
+                dtype range (low contrast / narrow dynamic range)
+    """
+    decoded: bool
+    finite: bool
+    vmin: float
+    vmax: float
+    dtype_max: float
+    low_range: bool
+
+
+def pixel_stats(path, frame=0, sub_frame=None):
+    """Decode image pixels and report problems (blank / non-finite / corrupt /
+    low dynamic range).
+
+    Works on the raw reduced frame, not the RGB-padded one, so a 2-channel
+    image's zero-padded third channel does not skew the min/max/finite stats.
+    Only call once the header size guard has passed, so decoding is bounded.
+    """
+    try:
+        raw, axes = _read_array(path)
+        arr = _reduce_to_hwc(raw, axes, frame=frame, sub_frame=sub_frame)
+    except Exception:  # noqa: BLE001 - unreadable pixels
+        return PixelReport(False, True, 0.0, 0.0, 0.0, False)
+
+    if np.issubdtype(arr.dtype, np.floating) and not np.isfinite(arr).all():
+        return PixelReport(True, False, 0.0, 0.0, 0.0, False)
+
+    vmin, vmax = float(arr.min()), float(arr.max())
+    is_int = np.issubdtype(arr.dtype, np.integer)
+    dtype_max = float(np.iinfo(arr.dtype).max) if is_int else 0.0
+    low_range = False
+    if is_int and vmax > vmin and dtype_max > 0:
+        narrow = (vmax - vmin) < NARROW_RANGE_FRAC * dtype_max
+        if narrow:
+            # Among narrow images, spare fluorescence (dark background + sparse
+            # bright objects) by checking for a bright tail: its max sits far
+            # above the 99th percentile. A dense narrow band (values packed in a
+            # thin range) has none, so only that is flagged as low dynamic range.
+            p99 = float(np.percentile(arr, 99))
+            bright_tail = (vmax - p99) / (vmax - vmin)
+            low_range = bright_tail < BRIGHT_TAIL_FRAC
+    return PixelReport(True, True, vmin, vmax, dtype_max, low_range)
+
 
 
 def array_nbytes(path):
@@ -256,7 +354,7 @@ def array_nbytes(path):
     """
     if tifffile is not None:
         try:
-            with tifffile.TiffFile(path) as tif:
+            with _open_tiff(path) as tif:
                 series = tif.series[0]
                 return int(np.prod(series.shape)) * int(np.dtype(series.dtype).itemsize)
         except Exception:  # noqa: BLE001 - fall through to PIL

app.py

@@ -22,8 +22,8 @@ from inference_seg import load_model as load_seg_model, run as run_seg
 from inference_count import load_model as load_count_model, run as run_count
 from inference_track import load_model as load_track_model, run as run_track
 from _utils.image_io import (
-    standardize_image, inspect_image, image_size, array_nbytes,
-    RECOMMENDED_SIZE, WARN_SIZE, MAX_SIZE, MAX_READ_BYTES, TIFF_EXTENSIONS,
+    standardize_image, inspect_image, image_size, array_nbytes, pixel_stats,
+    RECOMMENDED_SIZE, WARN_SIZE, MAX_SIZE, MIN_SIZE, MAX_READ_BYTES, TIFF_EXTENSIONS,
 )
 
 HF_TOKEN = os.getenv("HF_TOKEN")
@@ -345,22 +345,28 @@ def _human_bytes(n):
 
 
 def check_image(img_path):
-    """Check a file from its header only (no pixel decode).
-
-    Returns a rejection message if the file cannot be used, otherwise None:
-      * unreadable / unsupported format
-      * dimensions over MAX_SIZE
-      * full array over MAX_READ_BYTES (a small time-lapse can still be huge)
-    Also emits an advisory warning over WARN_SIZE, since the model resizes every
-    input to RECOMMENDED_SIZE and a larger image only loses detail.
+    """Validate an uploaded file, cheapest checks first.
+
+    Returns a rejection message if the file cannot be used, otherwise None.
+    Reject: empty file; unreadable / unsupported format; dimensions over
+    MAX_SIZE; full array over MAX_READ_BYTES (a small time-lapse can still be
+    huge); corrupt pixels; non-finite (NaN/inf) pixels. Advisory ``gr.Warning``
+    (does not reject): larger than WARN_SIZE; smaller than MIN_SIZE; blank
+    (uniform) image; very narrow dynamic range.
+
+    Only the header is touched until the size guards pass; pixel checks decode
+    image data afterwards, when doing so is bounded by the memory guard.
     """
+    if os.path.exists(img_path) and os.path.getsize(img_path) == 0:
+        return "This file is empty (0 bytes). Please upload a valid image file."
+
     w, h = image_size(img_path)
     if w <= 0 or h <= 0:
         # Neither reader could parse the header, so say so rather than failing
         # silently further down.
         ext = os.path.splitext(img_path)[1].lower() or "(no extension)"
         return (f"Could not read {ext} as an image. Supported formats: "
-                f"TIFF / OME-TIFF (8/16/32-bit, stacks, multi-channel), PNG, JPG, and other formats suported by tiffile. "
+                f"TIFF / OME-TIFF (8/16/32-bit, stacks, multi-channel), PNG, JPG, and other formats supported by tifffile. "
                 f"Please export to TIFF/PNG/JPG (e.g. from ImageJ/Fiji) first.")
 
     if w > MAX_SIZE or h > MAX_SIZE:
@@ -383,8 +389,35 @@ def check_image(img_path):
         gr.Warning(f"Image is {w}×{h} and will be resized to "
                    f"{RECOMMENDED_SIZE}×{RECOMMENDED_SIZE}, so fine detail could be lost. "
                    f"You can try cropping the image for better results.",
-                #    f"For best results, try cropping the image to focus on the region of interest.",
                    duration=None, title="⚠️ Large image")
+
+    if 0 < min(w, h) < MIN_SIZE:
+        gr.Warning(f"Image is only {w}×{h} and will be upscaled to "
+                   f"{RECOMMENDED_SIZE}×{RECOMMENDED_SIZE}, so results may be unreliable. "
+                   f"A larger image may work better.",
+                   duration=None, title="⚠️ Very small image")
+
+    # Size guards passed, so pixel decoding is bounded. Check problems that
+    # the header cannot reveal.
+    rep = pixel_stats(img_path)
+    if not rep.decoded:
+        return ("This image appears to be corrupted or truncated and could not be read. "
+                "Please re-export it (e.g. from ImageJ/Fiji) and try again.")
+    if not rep.finite:
+        return ("This image contains invalid pixel values (NaN or infinity). "
+                "Please clean or re-export it before uploading.")
+    if rep.vmin == rep.vmax:
+        if rep.vmax == 0:
+            kind = "completely black"
+        elif rep.dtype_max and rep.vmax >= rep.dtype_max:
+            kind = "completely white"
+        else:
+            kind = "a single uniform value"
+        gr.Warning(f"This image is {kind}, it has no visible content, so results will not be meaningful.",
+                   duration=None, title="⚠️ Blank image")
+    elif rep.low_range:
+        gr.Warning("This image may use a very narrow intensity range (low contrast). Signal may be too weak for reliable results; consider adjusting acquisition or contrast before uploading.",
+                   duration=None, title="⚠️ Low dynamic range")
     return None