napari-stitcher 0.1.0__py3-none-any.whl

napari_stitcher/__init__.py

@@ -0,0 +1,16 @@
+__version__ = "0.0.1"
+
+from ._reader import napari_get_reader
+from ._sample_data import make_sample_data
+from ._stitcher_widget import StitcherQWidget
+from ._mosaic_widget import MosaicQWidget
+from ._writer import write_multiple, write_single_image
+
+__all__ = (
+    "napari_get_reader",
+    "write_single_image",
+    "write_multiple",
+    "make_sample_data",
+    "StitcherQWidget",
+    "MosaicQWidget",
+)

napari_stitcher/_mosaic_widget.py

@@ -0,0 +1,192 @@
+"""
+This module is an example of a barebones QWidget plugin for napari
+
+It implements the Widget specification.
+see: https://napari.org/stable/plugins/guides.html?#widgets
+
+Replace code below according to your needs.
+"""
+from typing import TYPE_CHECKING
+import os, tempfile, sys
+
+import numpy as np
+
+from napari.utils import notifications
+
+from magicgui import widgets
+from qtpy.QtWidgets import QVBoxLayout, QWidget
+
+from multiview_stitcher import (
+    registration,
+    fusion,
+    spatial_image_utils,
+    msi_utils,
+    )
+
+from napari_stitcher import _reader, viewer_utils, _utils
+
+if TYPE_CHECKING:
+    import napari
+
+
+class MosaicQWidget(QWidget):
+    # your QWidget.__init__ can optionally request the napari viewer instance
+    # in one of two ways:
+    # 1. use a parameter called `napari_viewer`, as done here
+    # 2. use a type annotation of 'napari.viewer.Viewer' for any parameter
+    def __init__(self, napari_viewer):
+        super().__init__()
+        self.viewer = napari_viewer
+        self.viewer.title = "Napari Stitcher"
+
+        self.setLayout(QVBoxLayout())
+
+        # mosaic arrangement widgets
+        self.overlap = widgets.FloatSlider(
+            value=0.1, min=0, max=0.9999, label='Overlap:')
+        self.n_col = widgets.SpinBox(
+            value=1, min=1, max=100, label='Number of columns:') 
+        self.n_row = widgets.SpinBox(
+            value=1, min=1, max=100, label='Number of rows:') 
+        self.mosaic_arr = widgets.ComboBox(
+            choices=['rows first','columns first','snake by rows','snake by columns'],
+            value='snake by columns', 
+            label='Mosaic arrangement:',
+            tooltip='Select the type of grid arrangement. The tile order is taken from the list of layers.')
+        self.input_order = widgets.ComboBox(
+            choices=['forward','backward'],
+            value='forward', 
+            label='Image order:',
+            tooltip='Whether to arrange the tiles in forward or backward order.')
+        self.button_arrange_tiles = widgets.Button(text='Arrange tiles')
+
+        # organize widgets        
+        self.mosaic_widgets = [
+                            self.overlap,
+                            self.n_col, 
+                            self.n_row, 
+                            self.mosaic_arr,
+                            self.input_order,
+                            self.button_arrange_tiles,
+                            ]
+
+        self.container = widgets.VBox(widgets=\
+                            self.mosaic_widgets
+                            )
+
+        self.container.native.setMinimumWidth = 50
+
+        self.layout().addWidget(self.container.native)
+
+        # connect callbacks
+        self.button_arrange_tiles.clicked.connect(self.arrange_tiles)
+
+
+    def reset(self):
+            
+        self.msims = {}
+        self.input_layers = []
+
+
+    def link_channel_layers(self, layers):
+
+        # link channel layers
+        from napari.experimental import link_layers
+
+        sims = {l.name: msi_utils.get_sim_from_msim(self.msims[l.name])
+                for l in layers}
+
+        channels = [_utils.get_str_unique_to_ch_from_sim_coords(sim.coords) for sim in sims.values()]
+        for ch in channels:
+            ch_layers = list(_utils.filter_layers(layers, sims, ch=ch))
+
+            if len(ch_layers):
+                link_layers(ch_layers, ('contrast_limits', 'visible'))
+
+    
+    def arrange_tiles(self):
+        """
+        Arrange tiles in the viewer according to the selected mosaic arrangement.
+        """
+
+        layer_channels = [
+            l.name if not '::' in l.name else _utils.get_str_unique_to_ch_from_layer_name(l.name)
+            for l in self.viewer.layers]
+
+        layer_views = [
+            _utils.get_str_unique_to_view_from_layer_name(l.name)
+            for l in self.viewer.layers]
+
+        view_order = []
+        for lview in layer_views:
+            if lview not in view_order:
+                view_order.append(lview)
+
+        if self.input_order.value == 'backward':
+            view_order = view_order[::-1]
+        
+        n_channels = len(np.unique(layer_channels))
+        n_tiles = len(np.unique(layer_views))
+
+        if n_tiles != self.n_col.value * self.n_row.value:
+            notifications.notification_manager.receive_info(
+                'Warning: Total number of tiles does not match the selected mosaic arrangement.'
+            )
+            return
+
+        if n_tiles == 0:
+            notifications.notification_manager.receive_info(
+                'No layers loaded.'
+            )
+            return
+
+        tile_w = self.viewer.layers[0].extent.world[1,-1] - self.viewer.layers[0].extent.world[0,-1]  # tile width
+        tile_h = self.viewer.layers[0].extent.world[1,-2] - self.viewer.layers[0].extent.world[0,-2]  # tile height
+        
+        tile_indices = _utils.get_tile_indices(
+                mosaic_arr=self.mosaic_arr.value,
+                n_col=self.n_row.value,
+                n_row=self.n_col.value,
+                n_tiles=n_tiles
+            )
+
+        if self.input_order.value == 'forward':
+            l0_translate = self.viewer.layers[0].translate[-2:]
+        else:
+            l0_translate = self.viewer.layers[-1].translate[-2:]
+
+        for l in self.viewer.layers:
+            view = _utils.get_str_unique_to_view_from_layer_name(l.name)
+            itile = view_order.index(view)
+            tile_index = tile_indices[itile]
+            # print(f'Layer {l.name} -> tile index: {tile_index}')
+            l.translate[-2:] = [
+                l0_translate[0] + tile_index[1] * tile_w - tile_index[1] * tile_w * self.overlap.value,
+                l0_translate[1] + tile_index[0] * tile_h - tile_index[0] * tile_h * self.overlap.value
+            ]
+            l.refresh()
+        
+
+    def __del__(self):
+
+        print('Deleting napari-stitcher mosaic widget')
+
+
+if __name__ == "__main__":
+
+    import napari
+
+    viewer = napari.Viewer()
+    
+    wdg = MosaicQWidget(viewer)
+    viewer.window.add_dock_widget(wdg)
+
+    for irow in range(2):
+        for icol in range(2):
+            for ch in range(2):
+                viewer.add_image(np.random.randint(0, 100, [100] * 3), name=f'layer_{irow}_{icol} :: ch{ch}')
+
+    wdg.n_col.value = 2
+    wdg.n_row.value = 2
+
+    wdg.button_arrange_tiles.clicked()

napari_stitcher/_reader.py

@@ -0,0 +1,98 @@
+"""
+This module is an example of a barebones numpy reader plugin for napari.
+
+It implements the Reader specification, but your plugin may choose to
+implement multiple readers or even other plugin contributions. see:
+https://napari.org/stable/plugins/guides.html?#readers
+"""
+
+from multiview_stitcher import msi_utils
+from multiview_stitcher.io import read_mosaic_image_into_list_of_spatial_xarrays,\
+    METADATA_TRANSFORM_KEY
+
+from napari_stitcher import viewer_utils
+
+
+def napari_get_reader(path):
+    """A basic implementation of a Reader contribution.
+
+    Parameters
+    ----------
+    path : str or list of str
+        Path to file, or list of paths.
+
+    Returns
+    -------
+    function or None
+        If the path is a recognized format, return a function that accepts the
+        same path or list of paths, and returns a list of layer data tuples.
+    """
+    if isinstance(path, list):
+        # reader plugins may be handed single path, or a list of paths.
+        # if it is a list, it is assumed to be an image stack...
+        # so we are only going to look at the first file.
+        path = path[0]
+
+    # if we know we cannot read the file, we immediately return None.
+    # otherwise we return the *function* that can read ``path``.
+    if path.endswith(".czi"):
+        return read_mosaic
+    else:
+        return None
+    
+
+def read_mosaic(path, scene_index=None):
+    """
+    
+    Read in tiles as layers.
+    
+    Take a path or list of paths and return a list of LayerData tuples.
+
+    Readers are expected to return data as a list of tuples, where each tuple
+    is (data, [add_kwargs, [layer_type]]), "add_kwargs" and "layer_type" are
+    both optional.
+
+    Parameters
+    ----------
+    path : str or list of str
+        Path to file, or list of paths.
+
+    Returns
+    -------
+    layer_data : list of tuples
+        A list of LayerData tuples where each tuple in the list contains
+        (data, metadata, layer_type), where data is a numpy array, metadata is
+        a dict of keyword arguments for the corresponding viewer.add_* method
+        in napari, and layer_type is a lower-case string naming the type of
+        layer. Both "meta", and "layer_type" are optional. napari will
+        default to layer_type=="image" if not provided
+    """
+    # handle both a string and a list of strings
+    paths = [path] if isinstance(path, str) else path
+
+    sims = read_mosaic_image_into_list_of_spatial_xarrays(paths[0], scene_index=scene_index)
+
+    msims = [msi_utils.get_msim_from_sim(sim, scale_factors=[])
+             for sim in sims]
+
+    out_layers = viewer_utils.create_image_layer_tuples_from_msims(
+        msims,
+        transform_key=METADATA_TRANSFORM_KEY,
+        data_as_array=False)
+
+    return out_layers
+
+
+if __name__ == "__main__":
+
+    from multiview_stitcher.sample_data import get_mosaic_sample_data_path
+
+    filename = get_mosaic_sample_data_path()
+
+    sims = read_mosaic_image_into_list_of_spatial_xarrays(filename)
+
+    from multiview_stitcher import msi_utils
+
+    msim = msi_utils.get_msim_from_sim(sims[0], scale_factors=[])
+
+    msim_sel = msi_utils.multiscale_sel_coords(msim, {'c':'EGFP'})

napari_stitcher/_sample_data.py

@@ -0,0 +1,66 @@
+"""
+This module is an example of a barebones sample data provider for napari.
+
+It implements the "sample data" specification.
+see: https://napari.org/stable/plugins/guides.html?#sample-data
+
+Replace code below according to your needs.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from pathlib import Path
+
+from napari_stitcher import viewer_utils
+from napari_stitcher._reader import read_mosaic
+
+from multiview_stitcher.sample_data import get_mosaic_sample_data_path
+from multiview_stitcher.io import METADATA_TRANSFORM_KEY
+from multiview_stitcher.sample_data import generate_tiled_dataset
+from multiview_stitcher.msi_utils import get_msim_from_sim
+
+
+def make_sample_data():
+    """Generates an image"""
+    # Return list of tuples
+    # [(data1, add_image_kwargs1), (data2, add_image_kwargs2)]
+    # Check the documentation for more information about the
+    # add_image_kwargs
+    # https://napari.org/stable/api/napari.Viewer.html#napari.Viewer.add_image
+
+    sample_path = get_mosaic_sample_data_path()
+
+    return read_mosaic([sample_path])
+
+
+def drifting_timelapse_with_stage_shifts_no_overlap_2d():
+
+    sims = generate_tiled_dataset(
+        ndim=2, N_t=20, N_c=1,
+        tile_size=30, tiles_x=3, tiles_y=3, tiles_z=1,
+        drift_scale=2., shift_scale=2.,
+        overlap=0, zoom=8, dtype=np.uint8)
+    
+    msims = [get_msim_from_sim(sim) for sim in sims]
+
+    layer_tuples = viewer_utils.create_image_layer_tuples_from_msims(
+        msims, transform_key=METADATA_TRANSFORM_KEY)
+
+    return layer_tuples
+
+
+def timelapse_with_stage_shifts_with_overlap_3d():
+
+    sims = generate_tiled_dataset(
+        ndim=3, N_t=20, N_c=1,
+        tile_size=30, tiles_x=3, tiles_y=3, tiles_z=1,
+        drift_scale=0., shift_scale=2.,
+        overlap=3, zoom=8, dtype=np.uint8)
+    
+    msims = [get_msim_from_sim(sim) for sim in sims]
+
+    layer_tuples = viewer_utils.create_image_layer_tuples_from_msims(
+        msims, transform_key=METADATA_TRANSFORM_KEY)
+
+    return layer_tuples