- some workarounds to get jars and shared libs in the right place for python

- add most ndbioimage python code and use rs code as bfread

.gitignore

@@ -71,3 +71,5 @@ docs/_build/
 
 # Pyenv
 .python-version
+
+/tests/files/*

Cargo.toml

@@ -13,7 +13,7 @@ exclude = ["/tests"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
 name = "ndbioimage"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 anyhow = "1.0.95"
@@ -31,9 +31,9 @@ optional = true
 rayon = "1.10.0"
 
 [build-dependencies]
-anyhow = { version = "1.0.95"}
-j4rs = { version = "0.22", features = [] }
-retry = { version = "2.0.0"}
+anyhow = "1.0.95"
+j4rs = "0.22.0"
+retry = "2.0.0"
 
 [features]
 python = ["dep:pyo3", "dep:numpy"]

build.rs

@@ -1,21 +1,58 @@
-// copied from https://github.com/AzHicham/bioformats-rs
-
+#[cfg(not(feature = "python"))]
 use j4rs::{errors::J4RsError, JvmBuilder, MavenArtifact, MavenArtifactRepo, MavenSettings};
+
+#[cfg(not(feature = "python"))]
 use retry::{delay, delay::Exponential, retry};
 
+#[cfg(feature = "python")]
+use j4rs::Jvm;
+
 fn main() -> anyhow::Result<()> {
     println!("cargo:rerun-if-changed=build.rs");
 
-    if std::env::var("DOCS_RS").is_ok() {
-        Ok(())
-    } else {
-        Ok(retry(
+    #[cfg(not(feature = "python"))]
+    if std::env::var("DOCS_RS").is_err() {
+        retry(
             Exponential::from_millis(1000).map(delay::jitter).take(4),
             deploy_java_artifacts,
-        )?)
+        )?
     }
+
+    #[cfg(feature = "python")]
+    {
+        let py_src_path = std::env::current_dir()?.join("py").join("ndbioimage");
+        let py_jassets_path = py_src_path.join("jassets");
+        let py_deps_path = py_src_path.join("deps");
+        if py_jassets_path.exists() {
+            std::fs::remove_dir_all(&py_jassets_path)?;
+        }
+        if py_deps_path.exists() {
+            std::fs::remove_dir_all(&py_deps_path)?;
+        }
+
+        Jvm::copy_j4rs_libs_under(py_src_path.to_str().unwrap())?;
+
+        // rename else maturin will ignore them
+        for file in std::fs::read_dir(&py_deps_path)? {
+            let f = file?.path().to_str().unwrap().to_string();
+            if !f.ends_with("_") {
+                std::fs::rename(&f, std::format!("{f}_"))?;
+            }
+        }
+
+        // remove so we don't include too much accidentally
+        for file in std::fs::read_dir(&py_jassets_path)? {
+            let f = file?.path();
+            if !f.file_name().unwrap().to_str().unwrap().starts_with("j4rs") {
+                std::fs::remove_file(&f)?;
+            }
+        }
+    }
+
+    Ok(())
 }
 
+#[cfg(not(feature = "python"))]
 fn deploy_java_artifacts() -> Result<(), J4RsError> {
     let jvm = JvmBuilder::new()
         .with_maven_settings(MavenSettings::new(vec![MavenArtifactRepo::from(
@@ -23,10 +60,10 @@ fn deploy_java_artifacts() -> Result<(), J4RsError> {
         )]))
         .build()?;
 
-    jvm.deploy_artifact(&MavenArtifact::from("ome:bioformats_package:8.0.1"))?;
+    jvm.deploy_artifact(&MavenArtifact::from("ome:bioformats_package:8.1.0"))?;
 
     #[cfg(feature = "gpl-formats")]
-    jvm.deploy_artifact(&MavenArtifact::from("ome:formats-gpl:8.0.1"))?;
+    jvm.deploy_artifact(&MavenArtifact::from("ome:formats-gpl:8.1.0"))?;
 
     Ok(())
 }

py/ndbioimage/readers/__init__.py

@@ -0,0 +1 @@
+__all__ = 'bfread', 'cziread', 'fijiread', 'ndread', 'seqread', 'tifread', 'metaseriesread'

py/ndbioimage/readers/bfread.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from abc import ABC
+from pathlib import Path
+
+import numpy as np
+
+from .. import rs
+from .. import AbstractReader
+
+for file in (Path(__file__).parent / "deps").glob("*_"):
+    file.rename(str(file)[:-1])
+
+if not list((Path(__file__).parent / "jassets").glob("bioformats*.jar")):
+    rs.download_bioformats(True)
+
+
+class Reader(AbstractReader, ABC):
+    priority = 99  # panic and open with BioFormats
+    do_not_pickle = 'reader'
+
+    @staticmethod
+    def _can_open(path: Path) -> bool:
+        try:
+            _ = rs.Reader(path)
+            return True
+        except Exception:
+            return False
+
+    def open(self) -> None:
+        self.reader = rs.Reader(str(self.path), int(self.series))
+
+    def __frame__(self, c: int, z: int, t: int) -> np.ndarray:
+        return self.reader.get_frame(int(c), int(z), int(t))
+
+    def close(self) -> None:
+        self.reader.close()

py/ndbioimage/readers/cziread.py

@@ -0,0 +1,606 @@
+import re
+import warnings
+from abc import ABC
+from functools import cached_property
+from io import BytesIO
+from itertools import product
+from pathlib import Path
+from typing import Any, Callable, Optional, TypeVar
+
+import czifile
+import imagecodecs
+import numpy as np
+from lxml import etree
+from ome_types import OME, model
+from tifffile import repeat_nd
+
+from .. import AbstractReader
+
+try:
+    # TODO: use zoom from imagecodecs implementation when available
+    from scipy.ndimage.interpolation import zoom
+except ImportError:
+    try:
+        from ndimage.interpolation import zoom
+    except ImportError:
+        zoom = None
+
+
+Element = TypeVar('Element')
+
+
+def zstd_decode(data: bytes) -> bytes:  # noqa
+    """ decode zstd bytes, copied from BioFormats ZeissCZIReader """
+    def read_var_int(stream: BytesIO) -> int:  # noqa
+        a = stream.read(1)[0]
+        if a & 128:
+            b = stream.read(1)[0]
+            if b & 128:
+                c = stream.read(1)[0]
+                return (c << 14) | ((b & 127) << 7) | (a & 127)
+            return (b << 7) | (a & 127)
+        return a & 255
+
+    try:
+        with BytesIO(data) as stream:
+            size_of_header = read_var_int(stream)
+            high_low_unpacking = False
+            while stream.tell() < size_of_header:
+                chunk_id = read_var_int(stream)
+                # only one chunk ID defined so far
+                if chunk_id == 1:
+                    high_low_unpacking = (stream.read(1)[0] & 1) == 1
+                else:
+                    raise ValueError(f'Invalid chunk id: {chunk_id}')
+            pointer = stream.tell()
+    except Exception:  # noqa
+        high_low_unpacking = False
+        pointer = 0
+
+    decoded = imagecodecs.zstd_decode(data[pointer:])
+    if high_low_unpacking:
+        second_half = len(decoded) // 2
+        return bytes([decoded[second_half + i // 2] if i % 2 else decoded[i // 2] for i in range(len(decoded))])
+    else:
+        return decoded
+
+
+def data(self, raw: bool = False, resize: bool = True, order: int = 0) -> np.ndarray:
+    """Read image data from file and return as numpy array."""
+    DECOMPRESS = czifile.czifile.DECOMPRESS  # noqa
+    DECOMPRESS[5] = imagecodecs.zstd_decode
+    DECOMPRESS[6] = zstd_decode
+
+    de = self.directory_entry
+    fh = self._fh
+    if raw:
+        with fh.lock:
+            fh.seek(self.data_offset)
+            data = fh.read(self.data_size)  # noqa
+        return data
+    if de.compression:
+        # if de.compression not in DECOMPRESS:
+        #     raise ValueError('compression unknown or not supported')
+        with fh.lock:
+            fh.seek(self.data_offset)
+            data = fh.read(self.data_size)  # noqa
+        data = DECOMPRESS[de.compression](data)  # noqa
+        if de.compression == 2:
+            # LZW
+            data = np.fromstring(data, de.dtype)  # noqa
+        elif de.compression in (5, 6):
+            # ZSTD
+            data = np.frombuffer(data, de.dtype)  # noqa
+    else:
+        dtype = np.dtype(de.dtype)
+        with fh.lock:
+            fh.seek(self.data_offset)
+            data = fh.read_array(dtype, self.data_size // dtype.itemsize)  # noqa
+
+    data = data.reshape(de.stored_shape)  # noqa
+    if de.compression != 4 and de.stored_shape[-1] in (3, 4):
+        if de.stored_shape[-1] == 3:
+            # BGR -> RGB
+            data = data[..., ::-1]  # noqa
+        else:
+            # BGRA -> RGBA
+            tmp = data[..., 0].copy()
+            data[..., 0] = data[..., 2]
+            data[..., 2] = tmp
+    if de.stored_shape == de.shape or not resize:
+        return data
+
+    # sub / supersampling
+    factors = [j / i for i, j in zip(de.stored_shape, de.shape)]
+    factors = [(int(round(f)) if abs(f - round(f)) < 0.0001 else f)
+               for f in factors]
+
+    # use repeat if possible
+    if order == 0 and all(isinstance(f, int) for f in factors):
+        data = repeat_nd(data, factors).copy()  # noqa
+        data.shape = de.shape
+        return data
+
+    # remove leading dimensions with size 1 for speed
+    shape = list(de.stored_shape)
+    i = 0
+    for s in shape:
+        if s != 1:
+            break
+        i += 1
+    shape = shape[i:]
+    factors = factors[i:]
+    data.shape = shape
+
+    # resize RGB components separately for speed
+    if zoom is None:
+        raise ImportError("cannot import 'zoom' from scipy or ndimage")
+    if shape[-1] in (3, 4) and factors[-1] == 1.0:
+        factors = factors[:-1]
+        old = data
+        data = np.empty(de.shape, de.dtype[-2:])  # noqa
+        for i in range(shape[-1]):
+            data[..., i] = zoom(old[..., i], zoom=factors, order=order)
+    else:
+        data = zoom(data, zoom=factors, order=order)  # noqa
+
+    data.shape = de.shape
+    return data
+
+
+# monkeypatch zstd into czifile
+czifile.czifile.SubBlockSegment.data = data
+
+
+class Reader(AbstractReader, ABC):
+    priority = 0
+    do_not_pickle = 'reader', 'filedict'
+
+    @staticmethod
+    def _can_open(path: Path) -> bool:
+        return isinstance(path, Path) and path.suffix == '.czi'
+
+    def open(self) -> None:
+        self.reader = czifile.CziFile(self.path)
+        filedict = {}
+        for directory_entry in self.reader.filtered_subblock_directory:
+            idx = self.get_index(directory_entry, self.reader.start)
+            if 'S' not in self.reader.axes or self.series in range(*idx[self.reader.axes.index('S')]):
+                for c in range(*idx[self.reader.axes.index('C')]):
+                    for z in range(*idx[self.reader.axes.index('Z')]):
+                        for t in range(*idx[self.reader.axes.index('T')]):
+                            if (c, z, t) in filedict:
+                                filedict[c, z, t].append(directory_entry)
+                            else:
+                                filedict[c, z, t] = [directory_entry]
+        if len(filedict) == 0:
+            raise FileNotFoundError(f'Series {self.series} not found in {self.path}.')
+        self.filedict = filedict  # noqa
+
+    def close(self) -> None:
+        self.reader.close()
+
+    def get_ome(self) -> OME:
+        return OmeParse.get_ome(self.reader, self.filedict)
+
+    def __frame__(self, c: int = 0, z: int = 0, t: int = 0) -> np.ndarray:
+        f = np.zeros(self.base_shape['yx'], self.dtype)
+        if (c, z, t) in self.filedict:
+            directory_entries = self.filedict[c, z, t]
+            x_min = min([f.start[f.axes.index('X')] for f in directory_entries])
+            y_min = min([f.start[f.axes.index('Y')] for f in directory_entries])
+            xy_min = {'X': x_min, 'Y': y_min}
+            for directory_entry in directory_entries:
+                subblock = directory_entry.data_segment()
+                tile = subblock.data(resize=True, order=0)
+                axes_min = [xy_min.get(ax, 0) for ax in directory_entry.axes]
+                index = [slice(i - j - m, i - j + k)
+                         for i, j, k, m in zip(directory_entry.start, self.reader.start, tile.shape, axes_min)]
+                index = tuple(index[self.reader.axes.index(i)] for i in 'YX')
+                f[index] = tile.squeeze()
+        return f
+
+    @staticmethod
+    def get_index(directory_entry: czifile.DirectoryEntryDV, start: tuple[int]) -> list[tuple[int, int]]:
+        return [(i - j, i - j + k) for i, j, k in zip(directory_entry.start, start, directory_entry.shape)]
+
+
+class OmeParse:
+    size_x: int
+    size_y: int
+    size_c: int
+    size_z: int
+    size_t: int
+
+    nm = model.UnitsLength.NANOMETER
+    um = model.UnitsLength.MICROMETER
+
+    @classmethod
+    def get_ome(cls, reader: czifile.CziFile, filedict: dict[tuple[int, int, int], Any]) -> OME:
+        new = cls(reader, filedict)
+        new.parse()
+        return new.ome
+
+    def __init__(self, reader: czifile.CziFile, filedict: dict[tuple[int, int, int], Any]) -> None:
+        self.reader = reader
+        self.filedict = filedict
+        xml = reader.metadata()
+        self.attachments = {i.attachment_entry.name: i.attachment_entry.data_segment()
+                            for i in reader.attachments()}
+        self.tree = etree.fromstring(xml)
+        self.metadata = self.tree.find('Metadata')
+        version = self.metadata.find('Version')
+        if version is not None:
+            self.version = version.text
+        else:
+            self.version = self.metadata.find('Experiment').attrib['Version']
+
+        self.ome = OME()
+        self.information = self.metadata.find('Information')
+        self.display_setting = self.metadata.find('DisplaySetting')
+        self.experiment = self.metadata.find('Experiment')
+        self.acquisition_block = self.experiment.find('ExperimentBlocks').find('AcquisitionBlock')
+        self.instrument = self.information.find('Instrument')
+        self.image = self.information.find('Image')
+
+        if self.version == '1.0':
+            self.experiment = self.metadata.find('Experiment')
+            self.acquisition_block = self.experiment.find('ExperimentBlocks').find('AcquisitionBlock')
+            self.multi_track_setup = self.acquisition_block.find('MultiTrackSetup')
+        else:
+            self.experiment = None
+            self.acquisition_block = None
+            self.multi_track_setup = None
+
+    def parse(self) -> None:
+        self.get_experimenters()
+        self.get_instruments()
+        self.get_detectors()
+        self.get_objectives()
+        self.get_tubelenses()
+        self.get_light_sources()
+        self.get_filters()
+        self.get_pixels()
+        self.get_channels()
+        self.get_planes()
+        self.get_annotations()
+
+    @staticmethod
+    def text(item: Optional[Element], default: str = "") -> str:
+        return default if item is None else item.text
+
+    @staticmethod
+    def def_list(item: Any) -> list[Any]:
+        return [] if item is None else item
+
+    @staticmethod
+    def try_default(fun: Callable[[Any, ...], Any] | type, default: Any = None, *args: Any, **kwargs: Any) -> Any:
+        try:
+            return fun(*args, **kwargs)
+        except Exception:  # noqa
+            return default
+
+    def get_experimenters(self) -> None:
+        if self.version == '1.0':
+            self.ome.experimenters = [
+                model.Experimenter(id='Experimenter:0',
+                                   user_name=self.information.find('User').find('DisplayName').text)]
+        elif self.version in ('1.1', '1.2'):
+            self.ome.experimenters = [
+                model.Experimenter(id='Experimenter:0',
+                                   user_name=self.information.find('Document').find('UserName').text)]
+
+    def get_instruments(self) -> None:
+        if self.version == '1.0':
+            self.ome.instruments.append(model.Instrument(id=self.instrument.attrib['Id']))
+        elif self.version in ('1.1', '1.2'):
+            for _ in self.instrument.find('Microscopes'):
+                self.ome.instruments.append(model.Instrument(id='Instrument:0'))
+
+    def get_detectors(self) -> None:
+        if self.version == '1.0':
+            for detector in self.instrument.find('Detectors'):
+                try:
+                    detector_type = model.Detector_Type(self.text(detector.find('Type')).upper() or "")
+                except ValueError:
+                    detector_type = model.Detector_Type.OTHER
+
+                self.ome.instruments[0].detectors.append(
+                    model.Detector(
+                        id=detector.attrib['Id'], model=self.text(detector.find('Manufacturer').find('Model')),
+                        amplification_gain=float(self.text(detector.find('AmplificationGain'))),
+                        gain=float(self.text(detector.find('Gain'))), zoom=float(self.text(detector.find('Zoom'))),
+                        type=detector_type
+                    ))
+        elif self.version in ('1.1', '1.2'):
+            for detector in self.instrument.find('Detectors'):
+                try:
+                    detector_type = model.Detector_Type(self.text(detector.find('Type')).upper() or "")
+                except ValueError:
+                    detector_type = model.Detector_Type.OTHER
+
+                self.ome.instruments[0].detectors.append(
+                    model.Detector(
+                        id=detector.attrib['Id'].replace(' ', ''),
+                        model=self.text(detector.find('Manufacturer').find('Model')),
+                        type=detector_type
+                    ))
+
+    def get_objectives(self) -> None:
+        for objective in self.instrument.find('Objectives'):
+            self.ome.instruments[0].objectives.append(
+                model.Objective(
+                    id=objective.attrib['Id'],
+                    model=self.text(objective.find('Manufacturer').find('Model')),
+                    immersion=self.text(objective.find('Immersion')),  # type: ignore
+                    lens_na=float(self.text(objective.find('LensNA'))),
+                    nominal_magnification=float(self.text(objective.find('NominalMagnification')))))
+
+    def get_tubelenses(self) -> None:
+        if self.version == '1.0':
+            for idx, tube_lens in enumerate({self.text(track_setup.find('TubeLensPosition'))
+                                             for track_setup in self.multi_track_setup}):
+                try:
+                    nominal_magnification = float(re.findall(r'\d+[,.]\d*', tube_lens)[0].replace(',', '.'))
+                except Exception:  # noqa
+                    nominal_magnification = 1.0
+
+                self.ome.instruments[0].objectives.append(
+                    model.Objective(id=f'Objective:Tubelens:{idx}', model=tube_lens,
+                                    nominal_magnification=nominal_magnification))
+        elif self.version in ('1.1', '1.2'):
+            for tubelens in self.def_list(self.instrument.find('TubeLenses')):
+                try:
+                    nominal_magnification = float(re.findall(r'\d+(?:[,.]\d*)?',
+                                                             tubelens.attrib['Name'])[0].replace(',', '.'))
+                except Exception:  # noqa
+                    nominal_magnification = 1.0
+
+                self.ome.instruments[0].objectives.append(
+                    model.Objective(
+                        id=f"Objective:{tubelens.attrib['Id']}",
+                        model=tubelens.attrib['Name'],
+                        nominal_magnification=nominal_magnification))
+
+    def get_light_sources(self) -> None:
+        if self.version == '1.0':
+            for light_source in self.def_list(self.instrument.find('LightSources')):
+                try:
+                    if light_source.find('LightSourceType').find('Laser') is not None:
+                        self.ome.instruments[0].lasers.append(
+                            model.Laser(
+                                id=light_source.attrib['Id'],
+                                model=self.text(light_source.find('Manufacturer').find('Model')),
+                                power=float(self.text(light_source.find('Power'))),
+                                wavelength=float(
+                                    self.text(light_source.find('LightSourceType').find('Laser').find('Wavelength')))))
+                except AttributeError:
+                    pass
+        elif self.version in ('1.1', '1.2'):
+            for light_source in self.def_list(self.instrument.find('LightSources')):
+                try:
+                    if light_source.find('LightSourceType').find('Laser') is not None:
+                        self.ome.instruments[0].lasers.append(
+                            model.Laser(
+                                id=f"LightSource:{light_source.attrib['Id']}",
+                                power=float(self.text(light_source.find('Power'))),
+                                wavelength=float(light_source.attrib['Id'][-3:])))  # TODO: follow Id reference
+                except (AttributeError, ValueError):
+                    pass
+
+    def get_filters(self) -> None:
+        if self.version == '1.0':
+            for idx, filter_ in enumerate({self.text(beam_splitter.find('Filter'))
+                                           for track_setup in self.multi_track_setup
+                                           for beam_splitter in track_setup.find('BeamSplitters')}):
+                self.ome.instruments[0].filter_sets.append(
+                    model.FilterSet(id=f'FilterSet:{idx}', model=filter_)
+                )
+
+    def get_pixels(self) -> None:
+        x_min = min([f.start[f.axes.index('X')] for f in self.filedict[0, 0, 0]])
+        y_min = min([f.start[f.axes.index('Y')] for f in self.filedict[0, 0, 0]])
+        x_max = max([f.start[f.axes.index('X')] + f.shape[f.axes.index('X')] for f in self.filedict[0, 0, 0]])
+        y_max = max([f.start[f.axes.index('Y')] + f.shape[f.axes.index('Y')] for f in self.filedict[0, 0, 0]])
+        self.size_x = x_max - x_min
+        self.size_y = y_max - y_min
+        self.size_c, self.size_z, self.size_t = (self.reader.shape[self.reader.axes.index(directory_entry)]
+                                                 for directory_entry in 'CZT')
+        image = self.information.find('Image')
+        pixel_type = self.text(image.find('PixelType'), 'Gray16')
+        if pixel_type.startswith('Gray'):
+            pixel_type = 'uint' + pixel_type[4:]
+        objective_settings = image.find('ObjectiveSettings')
+
+        self.ome.images.append(
+            model.Image(
+                id='Image:0',
+                name=f"{self.text(self.information.find('Document').find('Name'))} #1",
+                pixels=model.Pixels(
+                    id='Pixels:0', size_x=self.size_x, size_y=self.size_y,
+                    size_c=self.size_c, size_z=self.size_z, size_t=self.size_t,
+                    dimension_order='XYCZT', type=pixel_type,  # type: ignore
+                    significant_bits=int(self.text(image.find('ComponentBitCount'))),
+                    big_endian=False, interleaved=False, metadata_only=True),  # type: ignore
+                experimenter_ref=model.ExperimenterRef(id='Experimenter:0'),
+                instrument_ref=model.InstrumentRef(id='Instrument:0'),
+                objective_settings=model.ObjectiveSettings(
+                    id=objective_settings.find('ObjectiveRef').attrib['Id'],
+                    medium=self.text(objective_settings.find('Medium')),  # type: ignore
+                    refractive_index=float(self.text(objective_settings.find('RefractiveIndex')))),
+                stage_label=model.StageLabel(
+                    name=f'Scene position #0',
+                    x=self.positions[0], x_unit=self.um,
+                    y=self.positions[1], y_unit=self.um,
+                    z=self.positions[2], z_unit=self.um)))
+
+        for distance in self.metadata.find('Scaling').find('Items'):
+            if distance.attrib['Id'] == 'X':
+                self.ome.images[0].pixels.physical_size_x = float(self.text(distance.find('Value'))) * 1e6
+            elif distance.attrib['Id'] == 'Y':
+                self.ome.images[0].pixels.physical_size_y = float(self.text(distance.find('Value'))) * 1e6
+            elif self.size_z > 1 and distance.attrib['Id'] == 'Z':
+                self.ome.images[0].pixels.physical_size_z = float(self.text(distance.find('Value'))) * 1e6
+
+    @cached_property
+    def positions(self) -> tuple[float, float, Optional[float]]:
+        if self.version == '1.0':
+            scenes = self.image.find('Dimensions').find('S').find('Scenes')
+            positions = scenes[0].find('Positions')[0]
+            return float(positions.attrib['X']), float(positions.attrib['Y']), float(positions.attrib['Z'])
+        elif self.version in ('1.1', '1.2'):
+            try:  # TODO
+                scenes = self.image.find('Dimensions').find('S').find('Scenes')
+                center_position = [float(pos) for pos in self.text(scenes[0].find('CenterPosition')).split(',')]
+            except AttributeError:
+                center_position = [0, 0]
+            return center_position[0], center_position[1], None
+
+    @cached_property
+    def channels_im(self) -> dict:
+        return {channel.attrib['Id']: channel for channel in self.image.find('Dimensions').find('Channels')}
+
+    @cached_property
+    def channels_ds(self) -> dict:
+        return {channel.attrib['Id']: channel for channel in self.display_setting.find('Channels')}
+
+    @cached_property
+    def channels_ts(self) -> dict:
+        return {detector.attrib['Id']: track_setup
+                for track_setup in
+                self.experiment.find('ExperimentBlocks').find('AcquisitionBlock').find('MultiTrackSetup')
+                for detector in track_setup.find('Detectors')}
+
+    def get_channels(self) -> None:
+        if self.version == '1.0':
+            for idx, (key, channel) in enumerate(self.channels_im.items()):
+                detector_settings = channel.find('DetectorSettings')
+                laser_scan_info = channel.find('LaserScanInfo')
+                detector = detector_settings.find('Detector')
+                try:
+                    binning = model.Binning(self.text(detector_settings.find('Binning')))
+                except ValueError:
+                    binning = model.Binning.OTHER
+
+                filterset = self.text(self.channels_ts[key].find('BeamSplitters')[0].find('Filter'))
+                filterset_idx = [filterset.model for filterset in self.ome.instruments[0].filter_sets].index(filterset)
+
+                light_sources_settings = channel.find('LightSourcesSettings')
+                # no space in ome for multiple lightsources simultaneously
+                if len(light_sources_settings) > idx:
+                    light_source_settings = light_sources_settings[idx]
+                else:
+                    light_source_settings = light_sources_settings[0]
+                light_source_settings = model.LightSourceSettings(
+                    id=light_source_settings.find('LightSource').attrib['Id'],
+                    attenuation=float(self.text(light_source_settings.find('Attenuation'))),
+                    wavelength=float(self.text(light_source_settings.find('Wavelength'))),
+                    wavelength_unit=self.nm)
+
+                self.ome.images[0].pixels.channels.append(
+                    model.Channel(
+                        id=f'Channel:{idx}',
+                        name=channel.attrib['Name'],
+                        acquisition_mode=self.text(channel.find('AcquisitionMode')),  # type: ignore
+                        color=model.Color(self.text(self.channels_ds[channel.attrib['Id']].find('Color'), 'white')),
+                        detector_settings=model.DetectorSettings(id=detector.attrib['Id'], binning=binning),
+                        # emission_wavelength=text(channel.find('EmissionWavelength')),  # TODO: fix
+                        excitation_wavelength=light_source_settings.wavelength,
+                        filter_set_ref=model.FilterSetRef(id=self.ome.instruments[0].filter_sets[filterset_idx].id),
+                        illumination_type=self.text(channel.find('IlluminationType')),  # type: ignore
+                        light_source_settings=light_source_settings,
+                        samples_per_pixel=int(self.text(laser_scan_info.find('Averaging')))))
+        elif self.version in ('1.1', '1.2'):
+            for idx, (key, channel) in enumerate(self.channels_im.items()):
+                detector_settings = channel.find('DetectorSettings')
+                laser_scan_info = channel.find('LaserScanInfo')
+                detector = detector_settings.find('Detector')
+                try:
+                    color = model.Color(self.text(self.channels_ds[channel.attrib['Id']].find('Color'), 'white'))
+                except Exception:  # noqa
+                    color = None
+                try:
+                    if (i := self.text(channel.find('EmissionWavelength'))) != '0':
+                        emission_wavelength = float(i)
+                    else:
+                        emission_wavelength = None
+                except Exception:  # noqa
+                    emission_wavelength = None
+                if laser_scan_info is not None:
+                    samples_per_pixel = int(self.text(laser_scan_info.find('Averaging'), '1'))
+                else:
+                    samples_per_pixel = 1
+                try:
+                    binning = model.Binning(self.text(detector_settings.find('Binning')))
+                except ValueError:
+                    binning = model.Binning.OTHER
+
+                light_sources_settings = channel.find('LightSourcesSettings')
+                # no space in ome for multiple lightsources simultaneously
+                if light_sources_settings is not None:
+                    light_source_settings = light_sources_settings[0]
+                    light_source_settings = model.LightSourceSettings(
+                        id='LightSource:' + '_'.join([light_source_settings.find('LightSource').attrib['Id']
+                                                      for light_source_settings in light_sources_settings]),
+                        attenuation=self.try_default(float, None, self.text(light_source_settings.find('Attenuation'))),
+                        wavelength=self.try_default(float, None, self.text(light_source_settings.find('Wavelength'))),
+                        wavelength_unit=self.nm)
+                else:
+                    light_source_settings = None
+
+                self.ome.images[0].pixels.channels.append(
+                    model.Channel(
+                        id=f'Channel:{idx}',
+                        name=channel.attrib['Name'],
+                        acquisition_mode=self.text(channel.find('AcquisitionMode')).replace(  # type: ignore
+                            'SingleMoleculeLocalisation', 'SingleMoleculeImaging'),
+                        color=color,
+                        detector_settings=model.DetectorSettings(
+                            id=detector.attrib['Id'].replace(' ', ""),
+                            binning=binning),
+                        emission_wavelength=emission_wavelength,
+                        excitation_wavelength=self.try_default(float, None,
+                                                               self.text(channel.find('ExcitationWavelength'))),
+                        # filter_set_ref=model.FilterSetRef(id=ome.instruments[0].filter_sets[filterset_idx].id),
+                        illumination_type=self.text(channel.find('IlluminationType')),  # type: ignore
+                        light_source_settings=light_source_settings,
+                        samples_per_pixel=samples_per_pixel))
+
+    def get_planes(self) -> None:
+        try:
+            exposure_times = [float(self.text(channel.find('LaserScanInfo').find('FrameTime')))
+                              for channel in self.channels_im.values()]
+        except Exception:  # noqa
+            exposure_times = [None] * len(self.channels_im)
+        delta_ts = self.attachments['TimeStamps'].data()
+        dt = np.diff(delta_ts)
+        if len(dt) and np.std(dt) / np.mean(dt) > 0.02:
+            dt = np.median(dt[dt > 0])
+            delta_ts = dt * np.arange(len(delta_ts))
+            warnings.warn(f'delta_t is inconsistent, using median value: {dt}')
+
+        for t, z, c in product(range(self.size_t), range(self.size_z), range(self.size_c)):
+            self.ome.images[0].pixels.planes.append(
+                model.Plane(the_c=c, the_z=z, the_t=t, delta_t=delta_ts[t],
+                            exposure_time=exposure_times[c],
+                            position_x=self.positions[0], position_x_unit=self.um,
+                            position_y=self.positions[1], position_y_unit=self.um,
+                            position_z=self.positions[2], position_z_unit=self.um))
+
+    def get_annotations(self) -> None:
+        idx = 0
+        for layer in [] if (ml := self.metadata.find('Layers')) is None else ml:
+            rectangle = layer.find('Elements').find('Rectangle')
+            if rectangle is not None:
+                geometry = rectangle.find('Geometry')
+                roi = model.ROI(id=f'ROI:{idx}', description=self.text(layer.find('Usage')))
+                roi.union.append(
+                    model.Rectangle(
+                        id='Shape:0:0',
+                        height=float(self.text(geometry.find('Height'))),
+                        width=float(self.text(geometry.find('Width'))),
+                        x=float(self.text(geometry.find('Left'))),
+                        y=float(self.text(geometry.find('Top')))))
+                self.ome.rois.append(roi)
+                self.ome.images[0].roi_refs.append(model.ROIRef(id=f'ROI:{idx}'))
+                idx += 1

py/ndbioimage/readers/fijiread.py

@@ -0,0 +1,59 @@
+from abc import ABC
+from itertools import product
+from pathlib import Path
+from struct import unpack
+from warnings import warn
+
+import numpy as np
+from ome_types import model
+from tifffile import TiffFile
+
+from .. import AbstractReader
+
+
+class Reader(AbstractReader, ABC):
+    """ Can read some tif files written with Fiji which are broken because Fiji didn't finish writing. """
+    priority = 90
+    do_not_pickle = 'reader'
+
+    @staticmethod
+    def _can_open(path):
+        if isinstance(path, Path) and path.suffix in ('.tif', '.tiff'):
+            with TiffFile(path) as tif:
+                return tif.is_imagej and not tif.is_bigtiff
+        else:
+            return False
+
+    def __frame__(self, c, z, t):  # Override this, return the frame at c, z, t
+        self.reader.filehandle.seek(self.offset + t * self.count)
+        return np.reshape(unpack(self.fmt, self.reader.filehandle.read(self.count)), self.base_shape['yx'])
+
+    def open(self):
+        warn(f'File {self.path.name} is probably damaged, opening with fijiread.')
+        self.reader = TiffFile(self.path)
+        assert self.reader.pages[0].compression == 1, 'Can only read uncompressed tiff files.'
+        assert self.reader.pages[0].samplesperpixel == 1, 'Can only read 1 sample per pixel.'
+        self.offset = self.reader.pages[0].dataoffsets[0]  # noqa
+        self.count = self.reader.pages[0].databytecounts[0]  # noqa
+        self.bytes_per_sample = self.reader.pages[0].bitspersample // 8  # noqa
+        self.fmt = self.reader.byteorder + self.count // self.bytes_per_sample * 'BHILQ'[self.bytes_per_sample - 1]  # noqa
+
+    def close(self):
+        self.reader.close()
+
+    def get_ome(self):
+        size_y, size_x = self.reader.pages[0].shape
+        size_c, size_z = 1, 1
+        size_t = int(np.floor((self.reader.filehandle.size - self.reader.pages[0].dataoffsets[0]) / self.count))
+        pixel_type = model.PixelType(self.reader.pages[0].dtype.name)
+        ome = model.OME()
+        ome.instruments.append(model.Instrument())
+        ome.images.append(
+            model.Image(
+                pixels=model.Pixels(
+                    size_c=size_c, size_z=size_z, size_t=size_t, size_x=size_x, size_y=size_y,
+                    dimension_order='XYCZT', type=pixel_type),
+                objective_settings=model.ObjectiveSettings(id='Objective:0')))
+        for c, z, t in product(range(size_c), range(size_z), range(size_t)):
+            ome.images[0].pixels.planes.append(model.Plane(the_c=c, the_z=z, the_t=t, delta_t=0))
+        return ome

py/ndbioimage/readers/metaseriesread.py

@@ -0,0 +1,80 @@
+import re
+from abc import ABC
+from pathlib import Path
+from typing import Optional
+
+import tifffile
+from ome_types import model
+from ome_types.units import _quantity_property  # noqa
+
+from .. import AbstractReader
+
+
+class Reader(AbstractReader, ABC):
+    priority = 20
+    do_not_pickle = 'last_tif'
+
+    @staticmethod
+    def _can_open(path):
+        return isinstance(path, Path) and (path.is_dir() or
+                                           (path.parent.is_dir() and path.name.lower().startswith('pos')))
+
+    @staticmethod
+    def get_positions(path: str | Path) -> Optional[list[int]]:
+        pat = re.compile(rf's(\d)_t\d+\.(tif|TIF)$')
+        return sorted({int(m.group(1)) for file in Path(path).iterdir() if (m := pat.search(file.name))})
+
+    def get_ome(self):
+        ome = model.OME()
+        tif = self.get_tif(0)
+        metadata = tif.metaseries_metadata
+        size_z = len(tif.pages)
+        page = tif.pages[0]
+        shape = {axis.lower(): size for axis, size in zip(page.axes, page.shape)}
+        size_x, size_y = shape['x'], shape['y']
+
+        ome.instruments.append(model.Instrument())
+
+        size_c = 1
+        size_t = max(self.filedict.keys()) + 1
+        pixel_type = f"uint{metadata['PlaneInfo']['bits-per-pixel']}"
+        ome.images.append(
+            model.Image(
+                pixels=model.Pixels(
+                    size_c=size_c, size_z=size_z, size_t=size_t,
+                    size_x=size_x, size_y=size_y,
+                    dimension_order='XYCZT', type=pixel_type),
+                objective_settings=model.ObjectiveSettings(id='Objective:0')))
+        return ome
+
+    def open(self):
+        pat = re.compile(rf's{self.series}_t\d+\.(tif|TIF)$')
+        filelist = sorted([file for file in self.path.iterdir() if pat.search(file.name)])
+        pattern = re.compile(r't(\d+)$')
+        self.filedict = {int(pattern.search(file.stem).group(1)) - 1: file for file in filelist}
+        if len(self.filedict) == 0:
+            raise FileNotFoundError
+        self.last_tif = 0, tifffile.TiffFile(self.filedict[0])
+
+    def close(self) -> None:
+        self.last_tif[1].close()
+
+    def get_tif(self, t: int = None):
+        last_t, tif = self.last_tif
+        if (t is None or t == last_t) and not tif.filehandle.closed:
+            return tif
+        else:
+            tif.close()
+            tif = tifffile.TiffFile(self.filedict[t])
+            self.last_tif = t, tif
+            return tif
+
+    def __frame__(self, c=0, z=0, t=0):
+        tif = self.get_tif(t)
+        page = tif.pages[z]
+        if page.axes.upper() == 'YX':
+            return page.asarray()
+        elif page.axes.upper() == 'XY':
+            return page.asarray().T
+        else:
+            raise NotImplementedError(f'reading axes {page.axes} is not implemented')

py/ndbioimage/readers/ndread.py

@@ -0,0 +1,53 @@
+from abc import ABC
+from itertools import product
+
+import numpy as np
+from ome_types import model
+
+from .. import AbstractReader
+
+
+class Reader(AbstractReader, ABC):
+    priority = 20
+
+    @staticmethod
+    def _can_open(path):
+        return isinstance(path, np.ndarray) and 1 <= path.ndim <= 5
+
+    def get_ome(self):
+        def shape(size_x=1, size_y=1, size_c=1, size_z=1, size_t=1):  # noqa
+            return size_x, size_y, size_c, size_z, size_t
+        size_x, size_y, size_c, size_z, size_t = shape(*self.array.shape)
+        try:
+            pixel_type = model.PixelType(self.array.dtype.name)
+        except ValueError:
+            if self.array.dtype.name.startswith('int'):
+                pixel_type = model.PixelType('int32')
+            else:
+                pixel_type = model.PixelType('float')
+
+        ome = model.OME()
+        ome.instruments.append(model.Instrument())
+        ome.images.append(
+            model.Image(
+                pixels=model.Pixels(
+                    size_c=size_c, size_z=size_z, size_t=size_t, size_x=size_x, size_y=size_y,
+                    dimension_order='XYCZT', type=pixel_type),
+                objective_settings=model.ObjectiveSettings(id='Objective:0')))
+        for c, z, t in product(range(size_c), range(size_z), range(size_t)):
+            ome.images[0].pixels.planes.append(model.Plane(the_c=c, the_z=z, the_t=t, delta_t=0))
+        return ome
+
+    def open(self):
+        if isinstance(self.path, np.ndarray):
+            self.array = np.array(self.path)
+            while self.array.ndim < 5:
+                self.array = np.expand_dims(self.array, -1)  # noqa
+            self.path = 'numpy array'
+
+    def __frame__(self, c, z, t):
+        frame = self.array[:, :, c, z, t]
+        if self.axes.find('y') > self.axes.find('x'):
+            return frame.T
+        else:
+            return frame

py/ndbioimage/readers/seqread.py

@@ -0,0 +1,146 @@
+import re
+from abc import ABC
+from datetime import datetime
+from itertools import product
+from pathlib import Path
+
+import tifffile
+import yaml
+from ome_types import model
+from ome_types.units import _quantity_property  # noqa
+
+from .. import AbstractReader
+
+
+def lazy_property(function, field, *arg_fields):
+    def lazy(self):
+        if self.__dict__.get(field) is None:
+            self.__dict__[field] = function(*[getattr(self, arg_field) for arg_field in arg_fields])
+            try:
+                self.model_fields_set.add(field)
+            except Exception:  # noqa
+                pass
+        return self.__dict__[field]
+    return property(lazy)
+
+
+class Plane(model.Plane):
+    """ Lazily retrieve delta_t from metadata """
+    def __init__(self, t0, file, **kwargs):  # noqa
+        super().__init__(**kwargs)
+        # setting fields here because they would be removed by ome_types/pydantic after class definition
+        setattr(self.__class__, 'delta_t', lazy_property(self.get_delta_t, 'delta_t', 't0', 'file'))
+        setattr(self.__class__, 'delta_t_quantity', _quantity_property('delta_t'))
+        self.__dict__['t0'] = t0  # noqa
+        self.__dict__['file'] = file  # noqa
+
+    @staticmethod
+    def get_delta_t(t0, file):
+        with tifffile.TiffFile(file) as tif:
+            info = yaml.safe_load(tif.pages[0].tags[50839].value['Info'])
+        return float((datetime.strptime(info['Time'], '%Y-%m-%d %H:%M:%S %z') - t0).seconds)
+
+
+class Reader(AbstractReader, ABC):
+    priority = 10
+
+    @staticmethod
+    def _can_open(path):
+        pat = re.compile(r'(?:\d+-)?Pos.*', re.IGNORECASE)
+        return (isinstance(path, Path) and path.is_dir() and
+                (pat.match(path.name) or any(file.is_dir() and pat.match(file.stem) for file in path.iterdir())))
+
+    def get_ome(self):
+        ome = model.OME()
+        with tifffile.TiffFile(self.filedict[0, 0, 0]) as tif:
+            metadata = {key: yaml.safe_load(value) for key, value in tif.pages[0].tags[50839].value.items()}
+        ome.experimenters.append(
+            model.Experimenter(id='Experimenter:0', user_name=metadata['Info']['Summary']['UserName']))
+        objective_str = metadata['Info']['ZeissObjectiveTurret-Label']
+        ome.instruments.append(model.Instrument())
+        ome.instruments[0].objectives.append(
+            model.Objective(
+                id='Objective:0', manufacturer='Zeiss', model=objective_str,
+                nominal_magnification=float(re.findall(r'(\d+)x', objective_str)[0]),
+                lens_na=float(re.findall(r'/(\d\.\d+)', objective_str)[0]),
+                immersion=model.Objective_Immersion.OIL if 'oil' in objective_str.lower() else None))
+        tubelens_str = metadata['Info']['ZeissOptovar-Label']
+        ome.instruments[0].objectives.append(
+            model.Objective(
+                id='Objective:Tubelens:0', manufacturer='Zeiss', model=tubelens_str,
+                nominal_magnification=float(re.findall(r'\d?\d*[,.]?\d+(?=x$)', tubelens_str)[0].replace(',', '.'))))
+        ome.instruments[0].detectors.append(
+            model.Detector(
+                id='Detector:0', amplification_gain=100))
+        ome.instruments[0].filter_sets.append(
+            model.FilterSet(id='FilterSet:0', model=metadata['Info']['ZeissReflectorTurret-Label']))
+
+        pxsize = metadata['Info']['PixelSizeUm']
+        pxsize_cam = 6.5 if 'Hamamatsu' in metadata['Info']['Core-Camera'] else None
+        if pxsize == 0:
+            pxsize = pxsize_cam / ome.instruments[0].objectives[0].nominal_magnification
+        pixel_type = metadata['Info']['PixelType'].lower()
+        if pixel_type.startswith('gray'):
+            pixel_type = 'uint' + pixel_type[4:]
+        else:
+            pixel_type = 'uint16'  # assume
+
+        size_c, size_z, size_t = (max(i) + 1 for i in zip(*self.filedict.keys()))
+        t0 = datetime.strptime(metadata['Info']['Time'], '%Y-%m-%d %H:%M:%S %z')
+        ome.images.append(
+            model.Image(
+                pixels=model.Pixels(
+                    size_c=size_c, size_z=size_z, size_t=size_t,
+                    size_x=metadata['Info']['Width'], size_y=metadata['Info']['Height'],
+                    dimension_order='XYCZT',  # type: ignore
+                    type=pixel_type, physical_size_x=pxsize, physical_size_y=pxsize,
+                    physical_size_z=metadata['Info']['Summary']['z-step_um']),
+                objective_settings=model.ObjectiveSettings(id='Objective:0')))
+
+        for c, z, t in product(range(size_c), range(size_z), range(size_t)):
+            ome.images[0].pixels.planes.append(
+                Plane(t0, self.filedict[c, z, t],
+                      the_c=c, the_z=z, the_t=t, exposure_time=metadata['Info']['Exposure-ms'] / 1000))
+
+        # compare channel names from metadata with filenames
+        pattern_c = re.compile(r'img_\d{3,}_(.*)_\d{3,}$', re.IGNORECASE)
+        for c in range(size_c):
+            ome.images[0].pixels.channels.append(
+                model.Channel(
+                    id=f'Channel:{c}', name=pattern_c.findall(self.filedict[c, 0, 0].stem)[0],
+                    detector_settings=model.DetectorSettings(
+                        id='Detector:0', binning=metadata['Info']['Hamamatsu_sCMOS-Binning']),
+                    filter_set_ref=model.FilterSetRef(id='FilterSet:0')))
+        return ome
+
+    def open(self):
+        # /some_path/Pos4: path = /some_path, series = 4
+        # /some_path/5-Pos_001_005: path = /some_path/5-Pos_001_005, series = 0
+        if re.match(r'(?:\d+-)?Pos.*', self.path.name, re.IGNORECASE) is None:
+            pat = re.compile(rf'^(?:\d+-)?Pos{self.series}$', re.IGNORECASE)
+            files = sorted(file for file in self.path.iterdir() if pat.match(file.name))
+            if len(files):
+                path = files[0]
+            else:
+                raise FileNotFoundError(self.path / pat.pattern)
+        else:
+            path = self.path
+
+        pat = re.compile(r'^img_\d{3,}.*\d{3,}.*\.tif$', re.IGNORECASE)
+        filelist = sorted([file for file in path.iterdir() if pat.search(file.name)])
+        with tifffile.TiffFile(self.path / filelist[0]) as tif:
+            metadata = {key: yaml.safe_load(value) for key, value in tif.pages[0].tags[50839].value.items()}
+
+        # compare channel names from metadata with filenames
+        cnamelist = metadata['Info']['Summary']['ChNames']
+        cnamelist = [c for c in cnamelist if any([c in f.name for f in filelist])]
+
+        pattern_c = re.compile(r'img_\d{3,}_(.*)_\d{3,}$', re.IGNORECASE)
+        pattern_z = re.compile(r'(\d{3,})$')
+        pattern_t = re.compile(r'img_(\d{3,})', re.IGNORECASE)
+        self.filedict = {(cnamelist.index(pattern_c.findall(file.stem)[0]),  # noqa
+                          int(pattern_z.findall(file.stem)[0]),
+                          int(pattern_t.findall(file.stem)[0])): file for file in filelist}
+
+    def __frame__(self, c=0, z=0, t=0):
+        return tifffile.imread(self.path / self.filedict[(c, z, t)])

py/ndbioimage/readers/tifread.py

@@ -0,0 +1,85 @@
+from abc import ABC
+from functools import cached_property
+from itertools import product
+from pathlib import Path
+
+import numpy as np
+import tifffile
+import yaml
+from ome_types import model
+
+from .. import AbstractReader
+
+
+class Reader(AbstractReader, ABC):
+    priority = 0
+    do_not_pickle = 'reader'
+
+    @staticmethod
+    def _can_open(path):
+        if isinstance(path, Path) and path.suffix in ('.tif', '.tiff'):
+            with tifffile.TiffFile(path) as tif:
+                return tif.is_imagej and tif.pages[-1]._nextifd() == 0  # noqa
+        else:
+            return False
+
+    @cached_property
+    def metadata(self):
+        return {key: yaml.safe_load(value) if isinstance(value, str) else value
+                for key, value in self.reader.imagej_metadata.items()}
+
+    def get_ome(self):
+        page = self.reader.pages[0]
+        size_y = page.imagelength
+        size_x = page.imagewidth
+        if self.p_ndim == 3:
+            size_c = page.samplesperpixel
+            size_t = self.metadata.get('frames', 1)  # // C
+        else:
+            size_c = self.metadata.get('channels', 1)
+            size_t = self.metadata.get('frames', 1)
+        size_z = self.metadata.get('slices', 1)
+        if 282 in page.tags and 296 in page.tags and page.tags[296].value == 1:
+            f = page.tags[282].value
+            pxsize = f[1] / f[0]
+        else:
+            pxsize = None
+
+        dtype = page.dtype.name
+        if dtype not in ('int8', 'int16', 'int32', 'uint8', 'uint16', 'uint32',
+                         'float', 'double', 'complex', 'double-complex', 'bit'):
+            dtype = 'float'
+
+        interval_t = self.metadata.get('interval', 0)
+
+        ome = model.OME()
+        ome.instruments.append(model.Instrument(id='Instrument:0'))
+        ome.instruments[0].objectives.append(model.Objective(id='Objective:0'))
+        ome.images.append(
+            model.Image(
+                id='Image:0',
+                pixels=model.Pixels(
+                    id='Pixels:0',
+                    size_c=size_c, size_z=size_z, size_t=size_t, size_x=size_x, size_y=size_y,
+                    dimension_order='XYCZT', type=dtype,  # type: ignore
+                    physical_size_x=pxsize, physical_size_y=pxsize),
+                objective_settings=model.ObjectiveSettings(id='Objective:0')))
+        for c, z, t in product(range(size_c), range(size_z), range(size_t)):
+            ome.images[0].pixels.planes.append(model.Plane(the_c=c, the_z=z, the_t=t, delta_t=interval_t * t))
+        return ome
+
+    def open(self):
+        self.reader = tifffile.TiffFile(self.path)
+        page = self.reader.pages[0]
+        self.p_ndim = page.ndim  # noqa
+        if self.p_ndim == 3:
+            self.p_transpose = [i for i in [page.axes.find(j) for j in 'SYX'] if i >= 0]  # noqa
+
+    def close(self):
+        self.reader.close()
+
+    def __frame__(self, c, z, t):
+        if self.p_ndim == 3:
+            return np.transpose(self.reader.asarray(z + t * self.base_shape['z']), self.p_transpose)[c]
+        else:
+            return self.reader.asarray(c + z * self.base_shape['c'] + t * self.base_shape['c'] * self.base_shape['z'])

py/ndbioimage/rs.py

@@ -0,0 +1,9 @@
+from .ndbioimage_rs import Reader, download_bioformats  # noqa
+from pathlib import Path
+
+
+if not list((Path(__file__).parent / "jassets").glob("bioformats*.jar")):
+    download_bioformats(True)
+
+for file in (Path(__file__).parent / "deps").glob("*_"):
+    file.rename(str(file)[:-1])

py/ndbioimage/transform.txt

@@ -0,0 +1,7 @@
+#Insight Transform File V1.0
+#Transform 0
+Transform: CompositeTransform_double_2_2
+#Transform 1
+Transform: AffineTransform_double_2_2
+Parameters: 1 0 0 1 0 0
+FixedParameters: 255.5 255.5

py/ndbioimage/transforms.py

@@ -0,0 +1,462 @@
+import warnings
+from copy import deepcopy
+from pathlib import Path
+
+import numpy as np
+import yaml
+from parfor import Chunks, pmap
+from skimage import filters
+from tiffwrite import IJTiffFile
+from tqdm.auto import tqdm
+
+try:
+    # best if SimpleElastix is installed: https://simpleelastix.readthedocs.io/GettingStarted.html
+    import SimpleITK as sitk  # noqa
+except ImportError:
+    sitk = None
+
+try:
+    from pandas import DataFrame, Series, concat
+except ImportError:
+    DataFrame, Series, concat = None, None, None
+
+
+if hasattr(yaml, 'full_load'):
+    yamlload = yaml.full_load
+else:
+    yamlload = yaml.load
+
+
+class Transforms(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.default = Transform()
+
+    @classmethod
+    def from_file(cls, file, C=True, T=True):
+        with open(Path(file).with_suffix('.yml')) as f:
+            return cls.from_dict(yamlload(f), C, T)
+
+    @classmethod
+    def from_dict(cls, d, C=True, T=True):
+        new = cls()
+        for key, value in d.items():
+            if isinstance(key, str) and C:
+                new[key.replace(r'\:', ':').replace('\\\\', '\\')] = Transform.from_dict(value)
+            elif T:
+                new[key] = Transform.from_dict(value)
+        return new
+
+    @classmethod
+    def from_shifts(cls, shifts):
+        new = cls()
+        for key, shift in shifts.items():
+            new[key] = Transform.from_shift(shift)
+        return new
+
+    def __mul__(self, other):
+        new = Transforms()
+        if isinstance(other, Transforms):
+            for key0, value0 in self.items():
+                for key1, value1 in other.items():
+                    new[key0 + key1] = value0 * value1
+            return new
+        elif other is None:
+            return self
+        else:
+            for key in self.keys():
+                new[key] = self[key] * other
+            return new
+
+    def asdict(self):
+        return {key.replace('\\', '\\\\').replace(':', r'\:') if isinstance(key, str) else key: value.asdict()
+                for key, value in self.items()}
+
+    def __getitem__(self, item):
+        return np.prod([self[i] for i in item[::-1]]) if isinstance(item, tuple) else super().__getitem__(item)
+
+    def __missing__(self, key):
+        return self.default
+
+    def __getstate__(self):
+        return self.__dict__
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+    def __hash__(self):
+        return hash(frozenset((*self.__dict__.items(), *self.items())))
+
+    def save(self, file):
+        with open(Path(file).with_suffix('.yml'), 'w') as f:
+            yaml.safe_dump(self.asdict(), f, default_flow_style=None)
+
+    def copy(self):
+        return deepcopy(self)
+
+    def adapt(self, origin, shape, channel_names):
+        def key_map(a, b):
+            def fun(b, key_a):
+                for key_b in b:
+                    if key_b in key_a or key_a in key_b:
+                        return key_a, key_b
+
+            return {n[0]: n[1] for key_a in a if (n := fun(b, key_a))}
+
+        for value in self.values():
+            value.adapt(origin, shape)
+        self.default.adapt(origin, shape)
+        transform_channels = {key for key in self.keys() if isinstance(key, str)}
+        if set(channel_names) - transform_channels:
+            mapping = key_map(channel_names, transform_channels)
+            warnings.warn(f'The image file and the transform do not have the same channels,'
+                          f' creating a mapping: {mapping}')
+            for key_im, key_t in mapping.items():
+                self[key_im] = self[key_t]
+
+    @property
+    def inverse(self):
+        # TODO: check for C@T
+        inverse = self.copy()
+        for key, value in self.items():
+            inverse[key] = value.inverse
+        return inverse
+
+    def coords_pandas(self, array, channel_names, columns=None):
+        if isinstance(array, DataFrame):
+            return concat([self.coords_pandas(row, channel_names, columns) for _, row in array.iterrows()], axis=1).T
+        elif isinstance(array, Series):
+            key = []
+            if 'C' in array:
+                key.append(channel_names[int(array['C'])])
+            if 'T' in array:
+                key.append(int(array['T']))
+            return self[tuple(key)].coords(array, columns)
+        else:
+            raise TypeError('Not a pandas DataFrame or Series.')
+
+    def with_beads(self, cyllens, bead_files):
+        assert len(bead_files) > 0, 'At least one file is needed to calculate the registration.'
+        transforms = [self.calculate_channel_transforms(file, cyllens) for file in bead_files]
+        for key in {key for transform in transforms for key in transform.keys()}:
+            new_transforms = [transform[key] for transform in transforms if key in transform]
+            if len(new_transforms) == 1:
+                self[key] = new_transforms[0]
+            else:
+                self[key] = Transform()
+                self[key].parameters = np.mean([t.parameters for t in new_transforms], 0)
+                self[key].dparameters = (np.std([t.parameters for t in new_transforms], 0) /
+                                        np.sqrt(len(new_transforms))).tolist()
+        return self
+
+    @staticmethod
+    def get_bead_files(path):
+        from . import Imread
+        files = []
+        for file in path.iterdir():
+            if file.name.lower().startswith('beads'):
+                try:
+                    with Imread(file):
+                        files.append(file)
+                except Exception:
+                    pass
+        files = sorted(files)
+        if not files:
+            raise Exception('No bead file found!')
+        checked_files = []
+        for file in files:
+            try:
+                if file.is_dir():
+                    file /= 'Pos0'
+                with Imread(file):  # check for errors opening the file
+                    checked_files.append(file)
+            except (Exception,):
+                continue
+        if not checked_files:
+            raise Exception('No bead file found!')
+        return checked_files
+
+    @staticmethod
+    def calculate_channel_transforms(bead_file, cyllens):
+        """ When no channel is not transformed by a cylindrical lens, assume that the image is scaled by a factor 1.162
+            in the horizontal direction """
+        from . import Imread
+
+        with Imread(bead_file, axes='zcyx') as im:  # noqa
+            max_ims = im.max('z')
+            goodch = [c for c, max_im in enumerate(max_ims) if not im.is_noise(max_im)]
+            if not goodch:
+                goodch = list(range(len(max_ims)))
+            untransformed = [c for c in range(im.shape['c']) if cyllens[im.detector[c]].lower() == 'none']
+
+            good_and_untrans = sorted(set(goodch) & set(untransformed))
+            if good_and_untrans:
+                masterch = good_and_untrans[0]
+            else:
+                masterch = goodch[0]
+            transform = Transform()
+            if not good_and_untrans:
+                matrix = transform.matrix
+                matrix[0, 0] = 0.86
+                transform.matrix = matrix
+            transforms = Transforms()
+            for c in tqdm(goodch, desc='Calculating channel transforms'):  # noqa
+                if c == masterch:
+                    transforms[im.channel_names[c]] = transform
+                else:
+                    transforms[im.channel_names[c]] = Transform.register(max_ims[masterch], max_ims[c]) * transform
+        return transforms
+
+    @staticmethod
+    def save_channel_transform_tiff(bead_files, tiffile):
+        from . import Imread
+        n_channels = 0
+        for file in bead_files:
+            with Imread(file) as im:
+                n_channels = max(n_channels, im.shape['c'])
+        with IJTiffFile(tiffile) as tif:
+            for t, file in enumerate(bead_files):
+                with Imread(file) as im:
+                    with Imread(file).with_transform() as jm:
+                        for c in range(im.shape['c']):
+                            tif.save(np.hstack((im(c=c, t=0).max('z'), jm(c=c, t=0).max('z'))), c, 0, t)
+
+    def with_drift(self, im):
+        """ Calculate shifts relative to the first frame
+            divide the sequence into groups,
+            compare each frame to the frame in the middle of the group and compare these middle frames to each other
+        """
+        im = im.transpose('tzycx')
+        t_groups = [list(chunk) for chunk in Chunks(range(im.shape['t']), size=round(np.sqrt(im.shape['t'])))]
+        t_keys = [int(np.round(np.mean(t_group))) for t_group in t_groups]
+        t_pairs = [(int(np.round(np.mean(t_group))), frame) for t_group in t_groups for frame in t_group]
+        t_pairs.extend(zip(t_keys, t_keys[1:]))
+        fmaxz_keys = {t_key: filters.gaussian(im[t_key].max('z'), 5) for t_key in t_keys}
+
+        def fun(t_key_t, im, fmaxz_keys):
+            t_key, t = t_key_t
+            if t_key == t:
+                return 0, 0
+            else:
+                fmaxz = filters.gaussian(im[t].max('z'), 5)
+                return Transform.register(fmaxz_keys[t_key], fmaxz, 'translation').parameters[4:]
+
+        shifts = np.array(pmap(fun, t_pairs, (im, fmaxz_keys), desc='Calculating image shifts.'))
+        shift_keys_cum = np.zeros(2)
+        for shift_keys, t_group in zip(np.vstack((-shifts[0], shifts[im.shape['t']:])), t_groups):
+            shift_keys_cum += shift_keys
+            shifts[t_group] += shift_keys_cum
+
+        for i, shift in enumerate(shifts[:im.shape['t']]):
+            self[i] = Transform.from_shift(shift)
+        return self
+
+
+class Transform:
+    def __init__(self):
+        if sitk is None:
+            self.transform = None
+        else:
+            self.transform = sitk.ReadTransform(str(Path(__file__).parent / 'transform.txt'))
+        self.dparameters = [0., 0., 0., 0., 0., 0.]
+        self.shape = [512., 512.]
+        self.origin = [255.5, 255.5]
+        self._last, self._inverse = None, None
+
+    def __reduce__(self):
+        return self.from_dict, (self.asdict(),)
+
+    def __repr__(self):
+        return self.asdict().__repr__()
+
+    def __str__(self):
+        return self.asdict().__str__()
+
+    @classmethod
+    def register(cls, fix, mov, kind=None):
+        """ kind: 'affine', 'translation', 'rigid' """
+        if sitk is None:
+            raise ImportError('SimpleElastix is not installed: '
+                              'https://simpleelastix.readthedocs.io/GettingStarted.html')
+        new = cls()
+        kind = kind or 'affine'
+        new.shape = fix.shape
+        fix, mov = new.cast_image(fix), new.cast_image(mov)
+        # TODO: implement RigidTransform
+        tfilter = sitk.ElastixImageFilter()
+        tfilter.LogToConsoleOff()
+        tfilter.SetFixedImage(fix)
+        tfilter.SetMovingImage(mov)
+        tfilter.SetParameterMap(sitk.GetDefaultParameterMap(kind))
+        tfilter.Execute()
+        transform = tfilter.GetTransformParameterMap()[0]
+        if kind == 'affine':
+            new.parameters = [float(t) for t in transform['TransformParameters']]
+            new.shape = [float(t) for t in transform['Size']]
+            new.origin = [float(t) for t in transform['CenterOfRotationPoint']]
+        elif kind == 'translation':
+            new.parameters = [1.0, 0.0, 0.0, 1.0] + [float(t) for t in transform['TransformParameters']]
+            new.shape = [float(t) for t in transform['Size']]
+            new.origin = [(t - 1) / 2 for t in new.shape]
+        else:
+            raise NotImplementedError(f'{kind} tranforms not implemented (yet)')
+        new.dparameters = 6 * [np.nan]
+        return new
+
+    @classmethod
+    def from_shift(cls, shift):
+        return cls.from_array(np.array(((1, 0, shift[0]), (0, 1, shift[1]), (0, 0, 1))))
+
+    @classmethod
+    def from_array(cls, array):
+        new = cls()
+        new.matrix = array
+        return new
+
+    @classmethod
+    def from_file(cls, file):
+        with open(Path(file).with_suffix('.yml')) as f:
+            return cls.from_dict(yamlload(f))
+
+    @classmethod
+    def from_dict(cls, d):
+        new = cls()
+        new.origin = None if d['CenterOfRotationPoint'] is None else [float(i) for i in d['CenterOfRotationPoint']]
+        new.parameters = ((1., 0., 0., 1., 0., 0.) if d['TransformParameters'] is None else
+                          [float(i) for i in d['TransformParameters']])
+        new.dparameters = ([(0., 0., 0., 0., 0., 0.) if i is None else float(i) for i in d['dTransformParameters']]
+                           if 'dTransformParameters' in d else 6 * [np.nan] and d['dTransformParameters'] is not None)
+        new.shape = None if d['Size'] is None else [None if i is None else float(i) for i in d['Size']]
+        return new
+
+    def __mul__(self, other):  # TODO: take care of dmatrix
+        result = self.copy()
+        if isinstance(other, Transform):
+            result.matrix = self.matrix @ other.matrix
+            result.dmatrix = self.dmatrix @ other.matrix + self.matrix @ other.dmatrix
+        else:
+            result.matrix = self.matrix @ other
+            result.dmatrix = self.dmatrix @ other
+        return result
+
+    def is_unity(self):
+        return self.parameters == [1, 0, 0, 1, 0, 0]
+
+    def copy(self):
+        return deepcopy(self)
+
+    @staticmethod
+    def cast_image(im):
+        if not isinstance(im, sitk.Image):
+            im = sitk.GetImageFromArray(np.asarray(im))
+        return im
+
+    @staticmethod
+    def cast_array(im):
+        if isinstance(im, sitk.Image):
+            im = sitk.GetArrayFromImage(im)
+        return im
+
+    @property
+    def matrix(self):
+        return np.array(((*self.parameters[:2], self.parameters[4]),
+                         (*self.parameters[2:4], self.parameters[5]),
+                         (0, 0, 1)))
+
+    @matrix.setter
+    def matrix(self, value):
+        value = np.asarray(value)
+        self.parameters = [*value[0, :2], *value[1, :2], *value[:2, 2]]
+
+    @property
+    def dmatrix(self):
+        return np.array(((*self.dparameters[:2], self.dparameters[4]),
+                         (*self.dparameters[2:4], self.dparameters[5]),
+                         (0, 0, 0)))
+
+    @dmatrix.setter
+    def dmatrix(self, value):
+        value = np.asarray(value)
+        self.dparameters = [*value[0, :2], *value[1, :2], *value[:2, 2]]
+
+    @property
+    def parameters(self):
+        if self.transform is not None:
+            return list(self.transform.GetParameters())
+        else:
+            return [1., 0., 0., 1., 0., 0.]
+
+    @parameters.setter
+    def parameters(self, value):
+        if self.transform is not None:
+            value = np.asarray(value)
+            self.transform.SetParameters(value.tolist())
+
+    @property
+    def origin(self):
+        if self.transform is not None:
+            return self.transform.GetFixedParameters()
+
+    @origin.setter
+    def origin(self, value):
+        if self.transform is not None:
+            value = np.asarray(value)
+            self.transform.SetFixedParameters(value.tolist())
+
+    @property
+    def inverse(self):
+        if self.is_unity():
+            return self
+        if self._last is None or self._last != self.asdict():
+            self._last = self.asdict()
+            self._inverse = Transform.from_dict(self.asdict())
+            self._inverse.transform = self._inverse.transform.GetInverse()
+            self._inverse._last = self._inverse.asdict()
+            self._inverse._inverse = self
+        return self._inverse
+
+    def adapt(self, origin, shape):
+        self.origin -= np.array(origin) + (self.shape - np.array(shape)[:2]) / 2
+        self.shape = shape[:2]
+
+    def asdict(self):
+        return {'CenterOfRotationPoint': self.origin, 'Size': self.shape, 'TransformParameters': self.parameters,
+                'dTransformParameters': np.nan_to_num(self.dparameters, nan=1e99).tolist()}
+
+    def frame(self, im, default=0):
+        if self.is_unity():
+            return im
+        else:
+            if sitk is None:
+                raise ImportError('SimpleElastix is not installed: '
+                                  'https://simpleelastix.readthedocs.io/GettingStarted.html')
+            dtype = im.dtype
+            im = im.astype('float')
+            intp = sitk.sitkBSpline if np.issubdtype(dtype, np.floating) else sitk.sitkNearestNeighbor
+            return self.cast_array(sitk.Resample(self.cast_image(im), self.transform, intp, default)).astype(dtype)
+
+    def coords(self, array, columns=None):
+        """ Transform coordinates in 2 column numpy array,
+            or in pandas DataFrame or Series objects in columns ['x', 'y']
+        """
+        if self.is_unity():
+            return array.copy()
+        elif DataFrame is not None and isinstance(array, (DataFrame, Series)):
+            columns = columns or ['x', 'y']
+            array = array.copy()
+            if isinstance(array, DataFrame):
+                array[columns] = self.coords(np.atleast_2d(array[columns].to_numpy()))
+            elif isinstance(array, Series):
+                array[columns] = self.coords(np.atleast_2d(array[columns].to_numpy()))[0]
+            return array
+        else:  # somehow we need to use the inverse here to get the same effect as when using self.frame
+            return np.array([self.inverse.transform.TransformPoint(i.tolist()) for i in np.asarray(array)])
+
+    def save(self, file):
+        """ save the parameters of the transform calculated
+            with affine_registration to a yaml file
+        """
+        if not file[-3:] == 'yml':
+            file += '.yml'
+        with open(file, 'w') as f:
+            yaml.safe_dump(self.asdict(), f, default_flow_style=None)

pyproject.toml

@@ -1,9 +1,9 @@
 [build-system]
-requires = ["maturin>=1.8,<2.0"]
+requires = ["maturin>=1.8.2"]
 build-backend = "maturin"
 
 [project]
-name = "ndbioimage_rs"
+name = "ndbioimage"
 requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Rust",
@@ -11,5 +11,12 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dynamic = ["version"]
+
 [tool.maturin]
-features = ["pyo3/extension-module"]
+python-source = "py"
+features = ["pyo3/extension-module", "python", "gpl-formats"]
+module-name = "ndbioimage.ndbioimage_rs"
+exclude = ["py/ndbioimage/jassets/*", "py/ndbioimage/deps/*"]
+
+[tool.isort]
+line_length = 119

src/bioformats.rs

@@ -10,11 +10,51 @@ thread_local! {
 /// Ensure 1 jvm per thread
 fn jvm() -> Rc<Jvm> {
     JVM.with(|cell| {
-        cell.get_or_init(move || Rc::new(JvmBuilder::new().build().expect("Failed to build JVM")))
-            .clone()
+        cell.get_or_init(move || {
+            #[cfg(feature = "python")]
+            let path = crate::py::ndbioimage_file().unwrap();
+
+            #[cfg(not(feature = "python"))]
+            let path = std::env::current_exe()
+                .unwrap()
+                .parent()
+                .unwrap()
+                .to_path_buf();
+
+            let class_path = path.parent().unwrap();
+            Rc::new(
+                JvmBuilder::new()
+                    .with_base_path(class_path.to_str().unwrap())
+                    .build()
+                    .expect("Failed to build JVM"),
+            )
+        })
+        .clone()
     })
 }
 
+#[cfg(feature = "python")]
+pub(crate) fn download_bioformats(gpl_formats: bool) -> Result<()> {
+    let path = crate::py::ndbioimage_file().unwrap();
+    let class_path = path.parent().unwrap();
+    let jvm = JvmBuilder::new()
+        .with_base_path(class_path.to_str().unwrap())
+        .with_maven_settings(j4rs::MavenSettings::new(vec![
+            j4rs::MavenArtifactRepo::from(
+                "openmicroscopy::https://artifacts.openmicroscopy.org/artifactory/ome.releases",
+            ),
+        ]))
+        .build()?;
+
+    jvm.deploy_artifact(&j4rs::MavenArtifact::from("ome:bioformats_package:8.1.0"))?;
+
+    if gpl_formats {
+        jvm.deploy_artifact(&j4rs::MavenArtifact::from("ome:formats-gpl:8.1.0"))?;
+    }
+
+    Ok(())
+}
+
 macro_rules! method_return {
     ($R:ty$(|c)?) => { Result<$R> };
     () => { Result<()> };
@@ -113,7 +153,7 @@ impl ImageReader {
         Ok(jvm()
             .chain(&mds)?
             .cast("loci.formats.ome.OMEPyramidStore")?
-            .invoke("dumpXML", &[])?
+            .invoke("dumpXML", InvocationArg::empty())?
             .to_rust()?)
     }
 

src/lib.rs

@@ -215,7 +215,7 @@ impl Reader {
     }
 
     /// Get ome metadata as xml string
-    pub fn ome_xml(&self) -> Result<String> {
+    pub fn get_ome_xml(&self) -> Result<String> {
         self.image_reader.ome_xml()
     }
 
@@ -396,7 +396,7 @@ mod tests {
     fn ome_xml() -> Result<()> {
         let file = "Experiment-2029.czi";
         let reader = open(file)?;
-        let xml = reader.ome_xml()?;
+        let xml = reader.get_ome_xml()?;
         println!("{}", xml);
         Ok(())
     }

src/py.rs

@@ -1,7 +1,7 @@
+use crate::bioformats::download_bioformats;
 use crate::{Frame, Reader};
-use numpy::{IntoPyArray, PyArrayMethods, ToPyArray};
+use numpy::ToPyArray;
 use pyo3::prelude::*;
-use pyo3::BoundObject;
 use std::path::PathBuf;
 
 #[pyclass(subclass)]
@@ -41,11 +41,35 @@ impl PyReader {
             Frame::DOUBLE(arr) => arr.to_pyarray(py).into_any(),
         })
     }
+
+    fn get_ome_xml(&self) -> PyResult<String> {
+        let reader = Reader::new(&self.path, self.series)?; // TODO: prevent making a new Reader each time
+        Ok(reader.get_ome_xml()?)
+    }
+}
+
+pub(crate) fn ndbioimage_file() -> anyhow::Result<PathBuf> {
+    let file = Python::with_gil(|py| {
+        py.import("ndbioimage")
+            .unwrap()
+            .filename()
+            .unwrap()
+            .to_string()
+    });
+    Ok(PathBuf::from(file))
 }
 
 #[pymodule]
 #[pyo3(name = "ndbioimage_rs")]
 fn ndbioimage_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyReader>()?;
+
+    #[pyfn(m)]
+    #[pyo3(name = "download_bioformats")]
+    fn py_download_bioformats(gpl_formats: bool) -> PyResult<()> {
+        download_bioformats(gpl_formats)?;
+        Ok(())
+    }
+
     Ok(())
 }