mozarrt 0.1.0__py3-none-any.whl

mozarrt/__init__.py

@@ -0,0 +1,3 @@
+from .mobie_collection import MoBIECollectionEntry, collection_dataframe
+
+__all__ = ["MoBIECollectionEntry", "collection_dataframe"]

mozarrt/cli.py

@@ -0,0 +1,18 @@
+from cyclopts import App
+
+from mozarrt.collect import create_plate_project, folder, plate
+from mozarrt.folder import project
+
+app = App()
+plate_app = App(
+    name="plate",
+    help="Actions that take an HCS plate OME-Zarr as input",
+)
+folder_app = App(
+    name="folder",
+    help="Actions that take a folder with OME-Zarr datasets as input",
+)
+
+folder_app.command(project)
+app.command(plate_app)
+app.command(folder_app)

mozarrt/collect.py

@@ -0,0 +1,220 @@
+from collections import defaultdict
+from cyclopts.types import ExistingDirectory
+from loguru import logger
+from natsort import natsorted
+from ngio import OmeZarrContainer, open_ome_zarr_container, open_ome_zarr_plate
+from ngio.hcs import OmeZarrPlate
+from mobiedantic import Project, Dataset
+from pathlib import Path
+
+from mozarrt.mobie_collection import MoBIECollectionEntry, collection_dataframe
+
+def _create_intensities_entry(
+        uri: str,
+        name: str,
+        channel: int,
+        grid: str,
+        display: str,
+        # grid_position: tuple[int, int],
+    ) -> MoBIECollectionEntry:
+    return MoBIECollectionEntry(
+        uri=uri,
+        name=name,
+        type="intensities",
+        format="OmeZarr",
+        channel=channel,
+        contrast_limits=(0, 255),
+        view="all",
+        display=display,
+        grid=grid,
+        # grid_position=grid_position,
+    )
+
+def _create_labels_entry(
+        uri: str,
+        name: str,
+        channel: int,
+        grid: str,
+        display: str,
+        # grid_position: tuple[int, int],
+    ) -> MoBIECollectionEntry:
+    return MoBIECollectionEntry(
+        uri=uri,
+        name=name,
+        type="labels",
+        format="OmeZarr",
+        channel=channel,
+        view="all",
+        grid=grid,
+        display=display,
+        # grid_position=grid_position,
+    )
+
+def _create_spots_entry(
+        uri: str,
+        name: str,
+        grid: str,
+        display: str,
+        # grid_position: tuple[int, int],
+    ) -> MoBIECollectionEntry:
+    return MoBIECollectionEntry(
+        uri=uri,
+        name=name,
+        type="spots",
+        view="all",
+        grid=grid,
+        display=display,
+        # grid_position=grid_position,
+    )
+
+def plate(
+    plate_zarr_path: ExistingDirectory,
+    output_directory: ExistingDirectory,
+    /,
+):
+    # Open plate zarr container
+    plate = open_ome_zarr_plate(plate_zarr_path)
+
+    mobie_collection_entries: list[MoBIECollectionEntry] = []
+
+    sub_path = "0"
+
+    for well_path, well in plate.get_wells().items():
+        logger.info(f"Processing well: {well_path}")
+        assert sub_path in well.paths()
+        # For each well, generate MoBIECollectionEntry
+        well_image = well.get_image(sub_path).get_image()
+        logger.info(well_image.channels_meta)
+        for ch_idx, channel in enumerate(well_image.channels_meta.channels):
+            logger.info(f"  Channel: {channel.label}")
+            entry = _create_intensities_entry(
+                uri=f"{plate_zarr_path}/{well_path}/{sub_path}",
+                name=f"{well_path}_c{ch_idx}",
+                channel=ch_idx,
+                display=channel.label,
+                grid=f"{ch_idx}_grid",
+                # grid_position=(0, 0), # TODO compute position from well_path
+            )
+            mobie_collection_entries.append(entry)
+
+    df = collection_dataframe(mobie_collection_entries)
+    output_path = Path(output_directory) / "mobie_collection.csv"
+    df.to_csv(output_path, index=False)
+
+def folder(
+    input_directory: ExistingDirectory,
+    output_directory: ExistingDirectory,
+    /,
+    *,
+    intensity_paths: list[str] | None = None,
+    label_paths: list[str] | None = None,
+):
+    mobie_collection_entries: list[MoBIECollectionEntry] = []
+    # Loop over all (.zarr) directories in input_directory
+    for zarr_dir in Path(input_directory).rglob("*.zarr"):
+        # Open zarr container
+        container = open_ome_zarr_container(zarr_dir)
+        logger.info(f"Processing {zarr_dir}")
+        image = container.get_image()
+        logger.info(image)
+        logger.info(image.path)
+        logger.info(image.channels_meta)
+        for channel in image.channel_labels:
+            logger.info(channel)
+            logger.info(image.get_channel_idx(channel))
+        for channel in image.channels_meta.channels:
+            logger.info(channel)
+            logger.info(channel.label)
+            logger.info(channel.channel_visualisation.start)
+        # Append an intensities entry for each channel
+    #     for channel_index in range(image.get_channel_count()):
+    #         entry = _create_intensities_entry(
+    #             uri=str(zarr_dir.resolve()), # TODO path to image
+    #             name=f"{zarr_dir.stem}_c{channel_index}",
+    #             channel=channel_index,
+    #             grid=f"channel_{channel_index}_grid",
+    #             grid_position=(0, 0), # TODO compute position from filename/folder content
+    #         )
+    #         mobie_collection_entries.append(entry)
+
+    # df = collection_dataframe(mobie_collection_entries)
+    # output_path = output_directory / "mobie_collection.csv"
+    # df.to_csv(output_path, index=False)
+
+def create_plate_project(
+    plate_zarr_path: ExistingDirectory,
+    output_directory: ExistingDirectory,
+    /,
+) -> Project:
+    plate: OmeZarrPlate = open_ome_zarr_plate(plate_zarr_path)
+    logger.info(f"Creating MoBIE Project for plate at {plate_zarr_path}")
+    # Initialize Project
+    project: Project = Project(output_directory)
+    project.initialize_model(
+        description="Test project",
+    )
+
+    # Create Dataset for plate
+    plate_dataset: Dataset = project.new_dataset(
+        # name=plate.meta.plate.name,
+        name=plate_zarr_path.name,
+    )
+    plate_dataset.initialize_with_paths(
+        path_dict={},
+        is2d=True,
+    )
+
+    plate_dataset.save()
+
+    # From the first well, get subpaths and channel names
+    # Then, for each subpath and each channel, create sources and merged grid views
+    first_well = plate.get_well(row=plate.rows[0], column=plate.columns[0])
+    path_names = first_well.paths()
+    logger.info(f"Path names in first well: {path_names}")
+    first_well_image = first_well.get_image(path_names[0]).get_image()
+    channel_names = [
+        channel.label for channel in first_well_image.channels_meta.channels
+    ]
+    logger.info(f"Channel names: {channel_names}")
+
+    # format: sources[sub_path][channel_name] = pathdict (name: Path)
+    sources = defaultdict(lambda: defaultdict(dict))
+    sources_per_well = defaultdict(list)
+
+    for well_path in plate.wells_paths():
+        logger.info(f"Processing well: {well_path}")
+        # add sources for each subpath and channel
+        for sub_path in path_names:
+            for channel in channel_names:
+                logger.info(f"  Channel: {channel}")
+                source_path = plate_zarr_path / well_path / sub_path
+                source_name = f"{well_path.replace("/", "")}_{channel}"
+                sources[sub_path][channel][source_name] = source_path
+                sources_per_well[well_path].append(source_name)
+    
+    for sub_path, channel_dict in sources.items():
+        for channel_index, channel_name in enumerate(channel_names):
+            logger.info(f"Adding source for subpath {sub_path}, channel {channel_name}...")
+            plate_dataset.add_sources(
+                path_dict=channel_dict[channel_name],
+                channel_index=channel_index,
+                data_format="ome.zarr",
+            )
+            plate_dataset.add_merged_grid(
+                name=f"merged_grid_{sub_path}_{channel_name}",
+                sources=list(channel_dict[channel_name]),
+            )
+    
+    # Add region view containing all wells
+    plate_dataset.add_region_view(
+        name="all_wells",
+        map_of_sources=sources_per_well,
+    )
+
+
+    plate_dataset.save()
+    project.save()
+    # add sources for each well and channel
+    # add merged grid view for each channel, containing all well sources for that channel
+    # add sources for labels
+

mozarrt/folder.py

@@ -0,0 +1,86 @@
+from collections import defaultdict
+from cyclopts.types import ExistingDirectory
+from loguru import logger
+from mobiedantic import Project, Dataset
+from natsort import natsorted
+from ngio import open_ome_zarr_container
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ngio import OmeZarrContainer, Image
+
+def project(
+    input_directory: ExistingDirectory,
+    output_directory: ExistingDirectory,
+    /,
+    *,
+    description: str | None = None,
+):
+    project: Project = Project(output_directory)
+    project.initialize_model(
+        description=description or "Folder Project",
+    )
+    dataset: Dataset = project.new_dataset(
+        name=input_directory.name,
+    )
+
+    # Create sources for each zarr (and each channel within it)
+    # then add merged grid views for each channel
+
+    zarr_dirs = natsorted(Path(input_directory).glob("*.zarr"))
+    first_zarr: OmeZarrContainer = open_ome_zarr_container(zarr_dirs[0])
+    first_zarr_image: Image = first_zarr.get_image()
+    
+    # Determine if data is 2D based on number of spatial axes (excluding channel dimension)
+    axes_names = first_zarr_image.axes
+    # Count spatial axes (z, y, x) - typically 2D has [y, x] and 3D has [z, y, x]
+    is2d = "z" not in axes_names
+    logger.info(f"Axes: {axes_names}, is2D: {is2d}")
+    
+    dataset.initialize_with_paths(
+        path_dict={},
+        is2d=is2d,
+    )
+    
+    channel_names = [
+        channel.label for channel in first_zarr_image.channels_meta.channels
+    ]
+    logger.info(f"Channel names: {channel_names}")
+
+
+    # format: sources[channel_name] = pathdict (name: Path)
+    sources = defaultdict(dict)
+    position_map = defaultdict(list)
+
+    for zarr_dir in zarr_dirs:
+        logger.info(f"Processing {zarr_dir}")
+        position: OmeZarrContainer = open_ome_zarr_container(zarr_dir)
+        logger.info(position.meta)
+        for channel_name in channel_names:
+            logger.info(f"  Channel: {channel_name}")
+            source_path = zarr_dir
+            source_name = f"{zarr_dir.stem}_{channel_name}"
+            sources[channel_name][source_name] = source_path
+            position_map[zarr_dir.stem].append(source_name)
+
+    for channel_index, channel_name in enumerate(channel_names):
+        logger.info(f"Adding source for channel {channel_name}...")
+        dataset.add_sources(
+            path_dict=sources[channel_name],
+            channel_index=channel_index,
+            data_format="ome.zarr",
+        )
+        dataset.add_merged_grid(
+            name=f"merged_grid_{channel_name}",
+            sources=list(sources[channel_name]),
+        )
+    
+    # Add region view containing all positions
+    dataset.add_region_view(
+        name="all_positions",
+        map_of_sources=position_map,
+    )
+
+    dataset.save()
+    project.save()

mozarrt/mobie_collection.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Literal
+
+@dataclass
+class MoBIECollectionEntry:
+    uri: str
+    name: str | None = None
+    type: Literal["intensities", "labels", "spots"] | None = None
+    channel: int | None = None
+    color: str | None = None
+    blend: Literal["sum", "alpha"] | None = None
+    affine: tuple[float] | None = None
+    tps: str | None = None
+    view: str | None = None
+    exclusive: bool | None = None
+    group: str | None = None
+    contrast_limits: tuple[int, int] | None = None
+    grid: str | None = None  # name of the grid
+    grid_position: tuple[int, int] | None = None
+    display: str | None = None
+    format: Literal["OmeZarr"] | None = None
+    spot_radius: float | None = None
+    bounding_box: str | None = None
+
+
+def collection_dataframe(entries: list[MoBIECollectionEntry]):
+    """Convert a list of MoBIECollectionEntry to a pandas DataFrame."""
+    import pandas as pd
+    df = pd.DataFrame(entries)
+    return df

mozarrt-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: mozarrt
+Version: 0.1.0
+Summary: MoBIE OME-Zarr Tools
+Author-email: Jan Eglinger <jan.eglinger@fmi.ch>
+Requires-Python: >=3.12
+Requires-Dist: cyclopts<5,>=4.5.0
+Requires-Dist: loguru<0.8,>=0.7.3
+Requires-Dist: mobiedantic<0.5,>=0.4.1
+Requires-Dist: natsort<9,>=8.4.0
+Requires-Dist: ngio<0.6,>=0.5.3
+Requires-Dist: pandas<3,>=2.3.3

mozarrt-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+mozarrt/__init__.py,sha256=zumS9pWC3YakVXRQI4CSH-if4W_qq2s7yDJv-1emQE0,133
+mozarrt/cli.py,sha256=LgjzmQI4htOIK5kyqWTKlPm20cxO9S5dfXjLY918A6o,422
+mozarrt/collect.py,sha256=gKt7LdVoL85VqqUsbjTavNcfd-ziYnoRMJ-Ws4T0jY4,7590
+mozarrt/folder.py,sha256=SEWirMFxD4RlxjZLx6h2kcsujYnRG6S4Y8zwNlJAJXw,2826
+mozarrt/mobie_collection.py,sha256=gHmwSiKsma0r5Ru37MeRGbqljWD7YVzyyBkCmOMzGfA,977
+mozarrt-0.1.0.dist-info/METADATA,sha256=HlvEHlgNdZcpYJCo8BrdnMAGUAnNfQ34SpVUbcovlpc,358
+mozarrt-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mozarrt-0.1.0.dist-info/entry_points.txt,sha256=VC78V3AHovyTKycOoSZG9qbTal6t_I6I3cQAJH71qEE,44
+mozarrt-0.1.0.dist-info/RECORD,,

mozarrt-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mozarrt-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mozarrt = mozarrt.cli:app