impy-array 2.5.2__tar.gz → 2.5.3__tar.gz

{impy_array-2.5.2 → impy_array-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: impy-array
-Version: 2.5.2
+Version: 2.5.3
 Summary: Speed up coding/extending image analysis in Python.
 Project-URL: Download, https://github.com/hanjinliu/impy
 Author-email: Hanjin Liu <liuhanjin-sc@g.ecc.u-tokyo.ac.jp>

{impy_array-2.5.2 → impy_array-2.5.3}/impy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.5.2"
+__version__ = "2.5.3"
 __author__ = "Hanjin Liu"
 __email__ = "liuhanjin-sc@g.ecc.u-tokyo.ac.jp"
 

{impy_array-2.5.2 → impy_array-2.5.3}/impy/array_api.py

@@ -97,7 +97,7 @@ class XP:
         self.angle = np.angle
         self.abs = np.abs
         self.mod = np.mod
-        self.fix = np.fix
+        self.trunc = np.trunc
         self.round = np.round
         self.gradient = np.gradient
         self.tensordot = np.tensordot
@@ -165,7 +165,7 @@ class XP:
         self.angle = cp.angle
         self.abs = cp.abs
         self.mod = cp.mod
-        self.fix = cp.fix
+        self.trunc = cp.trunc
         self.round = cp.round
         try:
             self.gradient = cp.gradient

{impy_array-2.5.2 → impy_array-2.5.3}/impy/arrays/_utils/_corr.py

@@ -38,16 +38,16 @@ def subpixel_pcc(
 ):
     power, product = _pcc_and_power_spec(f0, f1, max_shifts)
     maxima = xp.unravel_index(xp.argmax(power), power.shape)
-    midpoints = xp.array([np.fix(axis_size / 2) for axis_size in power.shape])
+    midpoints = xp.array([np.trunc(axis_size / 2) for axis_size in power.shape])
 
     shifts = xp.asarray(maxima, dtype=np.float32)
     shifts[shifts > midpoints] -= xp.array(power.shape)[shifts > midpoints]
     # Initial shift estimate in upsampled grid
-    shifts = xp.fix(shifts * upsample_factor) / upsample_factor
+    shifts = xp.trunc(shifts * upsample_factor) / upsample_factor
     if upsample_factor > 1:
         upsampled_region_size = np.ceil(upsample_factor * 1.5)
         # Center of output array at dftshift + 1
-        dftshift = xp.fix(upsampled_region_size / 2.0)
+        dftshift = xp.trunc(upsampled_region_size / 2.0)
         upsample_factor = xp.array(upsample_factor, dtype=np.float32)
         # Matrix multiply DFT around the current shift estimate
         sample_region_offset = dftshift - shifts*upsample_factor

{impy_array-2.5.2 → impy_array-2.5.3}/impy/io/_zarr.py

@@ -5,8 +5,6 @@ import numpy as np
 from impy.io._registry import IO
 from impy.io._utils import get_channel_labels, ImpyArray, ImageData
 
-from impy.axes import ImageAxesError
-
 
 @IO.mark_reader(".zarr")
 def _(path: str, memmap: bool = False) -> ImageData:
@@ -32,6 +30,7 @@ def _(path: str, memmap: bool = False) -> ImageData:
 def _(path: str, img: ImpyArray, lazy: bool = False):
     """The zarr writer."""
     import zarr
+    from dask import array as da
 
     f = zarr.open(path, mode="w")
     metadata = img.metadata.copy()
@@ -44,6 +43,5 @@ def _(path: str, img: ImpyArray, lazy: bool = False):
     if lazy:
         img.value.to_zarr(url=os.path.join(path, "data"))
     else:
-        z = img.value
-        f.array("data", z)
+        da.from_array(img.value).to_zarr(url=os.path.join(path, "data"))
     return None

{impy_array-2.5.2 → impy_array-2.5.3}/impy/viewer/utils.py

@@ -127,19 +127,10 @@ def add_labeledarray(viewer: napari.Viewer, img: LabeledArray, **kwargs):
         channel_axis=chn_ax,
         scale=scale,
         name=name if len(name) > 1 else name[0],
+        units=[a.unit for a in img.axes],
         **kwargs
     )
 
-    if viewer.scale_bar.unit:
-        if viewer.scale_bar.unit != img.scale_unit:
-            msg = (
-                f"Incompatible scales. Viewer is {viewer.scale_bar.unit} while "
-                f"image is {img.scale_unit}."
-            )
-            warnings.warn(msg)
-    else:
-        viewer.scale_bar.unit = img.scale_unit
-
     new_axes = [str(a) for a in img.axes if a != "c"]
     # add axis labels to slide bars and image orientation.
     if len(new_axes) >= len(viewer.dims.axis_labels):
@@ -173,7 +164,7 @@ def add_labels(
 
     out_layers = []
     for lbl, name in zip(lbls, names):
-        layer = viewer.add_labels(lbl.value, name=name, **kw)
+        layer = viewer.add_labels(lbl.value, name=name, units=[a.unit for a in lbl.axes], **kw)
         out_layers.append(layer)
     return out_layers
 
@@ -188,17 +179,23 @@ def add_dask(viewer: napari.Viewer, img: LazyImgArray, **kwargs):
     else:
         name = ["[Lazy]" + name]
 
-    layer = viewer.add_image(img, channel_axis=chn_ax, scale=scale,
-                             name=name if len(name)>1 else name[0], **kwargs)
-    viewer.scale_bar.unit = img.scale_unit
+    layer = viewer.add_image(
+        img,
+        channel_axis=chn_ax,
+        scale=scale,
+        name=name if len(name)>1 else name[0],
+        units=[a.unit for a in img.axes],
+        **kwargs
+    )
     new_axes = [str(a) for a in img.axes if a != "c"]
     # add axis labels to slide bars and image orientation.
     if len(new_axes) >= len(viewer.dims.axis_labels):
         viewer.dims.axis_labels = new_axes
     return layer
 
-def add_points(viewer:napari.Viewer, points: AxesFrame, **kwargs):
+def add_points(viewer: napari.Viewer, points: AxesFrame, **kwargs):
     from ..frame import MarkerFrame
+
     if isinstance(points, MarkerFrame):
         scale = make_world_scale(points)
         points = points.get_coords()
@@ -382,4 +379,4 @@ class ComplexArrayView:
         return self._data.nbytes
 
     def __getitem__(self, key):
-        return self.__class__(self._data[key])
+        return self.__class__(self._data[key])

{impy_array-2.5.2 → impy_array-2.5.3}/impy/viewer/viewer.py

@@ -8,7 +8,7 @@ import numpy as np
 
 from .utils import (
     layer_to_impy_object,
-    add_dask, 
+    add_dask,
     add_labeledarray,
     add_labels,
     add_paths,
@@ -31,8 +31,8 @@ if TYPE_CHECKING:
     import pandas as pd
     from numpy.typing import ArrayLike
 
-# TODO: 
-# - Layer does not remember the original data after c-split ... this will be solved after 
+# TODO:
+# - Layer does not remember the original data after c-split ... this will be solved after
 #   layer group is implemented in napari.
 # - channel axis will be dropped in the future: https://github.com/napari/napari/issues/3019
 
@@ -41,16 +41,16 @@ ImpyObject = NewType("ImpyObject", Any)
 class napariViewers:
     """
     The controller of ``napari.Viewer``s from ``impy``. Always access by ``ip.gui``.
-    """    
+    """
     def __init__(self):
-        self._viewers: WeakValueDictionary[str, "napari.Viewer"] = WeakValueDictionary()
+        self._viewers: WeakValueDictionary[str, napari.Viewer] = WeakValueDictionary()
         self._front_viewer: str = None
         self._axes: Axes = None
-    
+
     def __repr__(self):
         w = "".join([f"<{k}>" for k in self._viewers.keys()])
         return f"{self.__class__}{w}"
-    
+
     def __getitem__(self, key: str) -> napariViewers:
         """
         This method looks strange but intuitive because you can access the last viewer by
@@ -62,33 +62,33 @@ class napariViewers:
         ----------
         key : str
             Viewer's title
-        """        
+        """
         if key in self._viewers.keys():
             self._front_viewer = key
         else:
             self.start(key)
         return self
-    
+
     @property
-    def viewer(self) -> "napari.Viewer":
+    def viewer(self) -> napari.Viewer:
         """The most front viewer you're using"""
         if self._front_viewer not in self._viewers.keys():
             self.start()
         return self._viewers[self._front_viewer]
-        
+
     @property
-    def layers(self) -> "LayerList":
-        """Napari layer list. Identical to ``ip.gui.viewer.layers``."""        
+    def layers(self) -> LayerList:
+        """Napari layer list. Identical to ``ip.gui.viewer.layers``."""
         return self.viewer.layers
-    
+
     @property
     def current_slice(self) -> tuple[slice | int, ...]:
         """
-        Return a tuple of slicer that corresponds to current field of view. 
-        
-        For instance, when the viewer is displaying yx-plane at t=1, then this property 
+        Return a tuple of slicer that corresponds to current field of view.
+
+        For instance, when the viewer is displaying yx-plane at t=1, then this property
         returns ``(1, slice(None), slice(None))``.
-        """        
+        """
         current_step = list(self.viewer.dims.current_step)
         ndim = min(self.viewer.dims.ndisplay, self.viewer.dims.ndim)
         active_plane = list(self.viewer.dims.order[-ndim:])
@@ -96,60 +96,58 @@ class napariViewers:
             current_step[i] = slice(None)
         return tuple(current_step)
 
-    
+
     @property
     def selection(self) -> list[ImpyObject]:
-        """Return selected layers' data as a list of impy objects."""        
-        return [layer_to_impy_object(self.viewer, layer) 
+        """Return selected layers' data as a list of impy objects."""
+        return [layer_to_impy_object(self.viewer, layer)
                 for layer in self.viewer.layers.selection]
-    
+
     @property
     def cursor_pos(self) -> np.ndarray:
         """Return cursor position. Scale is considered."""
         return np.array(self.viewer.cursor.position) / self.scale
-    
+
     @property
     def axes(self) -> Axes:
         """
-        Axes information of current viewer. 
-        
+        Axes information of current viewer.
+
         Defined to make compatible with ``ImgArray``.
         """
         d = self.viewer.dims
-        unit = self.viewer.scale_bar.unit
         axes: list[Axis] = []
         for a, r in zip(d.axis_labels, d.range):
             if a in ["z", "y", "x"]:
-                axis = Axis(a, {"scale": r[2], "unit": unit})
+                axis = Axis(a, {"scale": r[2]})
             else:
                 axis = Axis(a)
             axes.append(axis)
         self._axes = Axes(axes)  # because scale-view uses a weakref
         return self._axes
-    
+
     @property
     def scale(self) -> ScaleView:
-        """
-        Scale information of current viewer.
-        
+        """Scale information of current viewer.
+
         Defined to make compatible with ``ImgArray``.
-        """        
+        """
         return self.axes.scale
-    
+
     def start(self, key: str = "impy"):
         """Create a napari window with name ``key``."""
         if not isinstance(key, str):
             raise TypeError("`key` must be str.")
         if key in self._viewers.keys():
             raise ValueError(f"Key {key} already exists.")
-        
+
         viewer = napari.Viewer(title=key)
         self._viewers[key] = viewer
         self._front_viewer = key
         return None
 
     def get(
-        self, 
+        self,
         kind: str = "image",
         layer_state: str = "visible",
         returns: str = "last"
@@ -161,7 +159,7 @@ class napariViewers:
         ----------
         kind : str, optional
             Kind of layers/shapes to return.
-            
+
                 - "image": Image layer.
                 - "labels": Labels layer
                 - "points": Points layer.
@@ -174,41 +172,41 @@ class napariViewers:
                 - "path": Path shapes in Shapes layer.
                 - "polygon": Polygon shapes in Shapes layer.
                 - "ellipse": Ellipse shapes in Shapes layer.
-                
+
         layer_state : {"selected", "visible", "any"}, default is "any"
             How to filter layer list.
-            
+
                 - "selected": Only selected layers will be searched.
                 - "visible": Only visible layers will be searched.
-                - "any": All the layers will be searched.    
-                
+                - "any": All the layers will be searched.
+
         returns : {"first", "last", "all"}
             What will be returned in case that there are multiple layers/shapes.
-            
+
                 - "first": Only the first object will be returned.
                 - "last": Only the last object will be returned.
                 - "all": All the objects will be returned as a list.
-        
+
         Returns
         -------
         ImgArray, Label, MarkerFrame or TrackFrame, np.ndarray, or list of one of them.
             impy object(s) that satisfies the options.
-        
+
         Examples
         --------
         1. Get the front image.
-        
+
             >>> ip.gui.get("image")
-        
+
         2. Get all the selected images as a list.
-            
+
             >>> ip.gui.get("image", layer_state="selected", returns="all")
-            
+
         3. Get all the lines from the front visible shapes layer.
-            
-            >>> ip.gui.get("line", layer_state="visible") 
-            
-        """        
+
+            >>> ip.gui.get("line", layer_state="visible")
+
+        """
         if layer_state == "selected":
             layer_list = list(self.viewer.layers.selection)
         elif layer_state == "visible":
@@ -217,16 +215,16 @@ class napariViewers:
             layer_list = self.viewer.layers
         else:
             raise ValueError("`filter` must be 'selected', 'visible' or 'any'")
-            
+
         kind = kind.capitalize()
         out = []
         if kind in ("Image", "Labels", "Points", "Shapes", "Tracks", "Vectors", "Surface"):
             layer_type = getattr(napari.layers, kind)
-            
+
             for layer in layer_list:
                 if isinstance(layer, layer_type):
                     out.append(layer_to_impy_object(self.viewer, layer))
-            
+
         elif kind in ("Line", "Rectangle", "Path", "Polygon", "Ellipse"):
             layer_type = napari.layers.Shapes
             shape_type = kind.lower()
@@ -236,10 +234,10 @@ class napariViewers:
                 for s, t in zip(layer.data, layer.shape_type):
                     if t == shape_type:
                         out.append(s)
-            
+
         else:
             raise TypeError(f"Cannot interpret type {kind}")
-        
+
         try:
             if returns == "first":
                 out = out[0]
@@ -247,19 +245,19 @@ class napariViewers:
                 out = out[-1]
             elif returns != "all":
                 raise ValueError("`returns` must be 'first', 'last' or 'all'")
-            
+
         except IndexError:
             if layer_state != "none":
                 msg = f"No {layer_state} {kind.lower()} found in the viewer layer list."
             else:
                 msg = f"No {kind.lower()} found in the viewer layer list."
             raise IndexError(msg)
-        
+
         return out
-    
+
     def cursor_to_pixel(
-        self, 
-        ref: "napari.layers.Image" | int | str | LabeledArray | LazyImgArray, 
+        self,
+        ref: napari.layers.Image | int | str | LabeledArray | LazyImgArray,
         ndim: int = None
     ) -> np.ndarray:
         """
@@ -269,17 +267,17 @@ class napariViewers:
         Parameters
         ----------
         ref : napari.layers.Image, int, str, LabeledArray or LazyImgArray
-            Reference layer or its identifier. To determine the reference layer, this parameter is interpreted in 
+            Reference layer or its identifier. To determine the reference layer, this parameter is interpreted in
             different ways depending on its type:
 
-            - napari.layers.Image ... layer itself 
+            - napari.layers.Image ... layer itself
             - int ... the index of layer list
             - str ... the name of layer list
             - LabeledArray or LazyImgArray ... layer that has same object as data
-        
+
         ndim : int, optional
             If specified, the last ndim coordinates will be returned.
-        
+
         Returns
         -------
         np.ndarray
@@ -295,13 +293,13 @@ class napariViewers:
                     break
             else:
                 raise ValueError("Input image was not found in napari layer list.")
-        
+
         elif isinstance(ref, (Image, Labels)):
             layer = ref
         else:
             raise TypeError("`layer` must be an image layer, int, str or impy's LabeledArray, "
                            f"but got {type(ref)}")
-        
+
         if not isinstance(layer, (Image, Labels)):
             raise TypeError(f"Layer {layer} is not an image or labels layer.")
 
@@ -309,7 +307,7 @@ class napariViewers:
         cursor_coords = np.array(self.viewer.cursor.position[-ndim:])
         pos = (cursor_coords - layer.translate)/layer.scale
         return (pos + 0.5).astype(np.int64)
-        
+
     def add(self, obj: ImpyObject, **kwargs):
         """
         Add images, points, labels, tracks etc to viewer.
@@ -318,76 +316,76 @@ class napariViewers:
         ----------
         obj : ImpyObject
             Object to add.
-        """        
+        """
         import pandas as pd
         from dask import array as da
         from impy.frame import MarkerFrame, TrackFrame, PathFrame
-        
+
         try:
             self.viewer.window.activate()
         except RuntimeError:
             # Restart viewer
             viewer = napari.Viewer(title=self._front_viewer)
             self._viewers[self._front_viewer] = viewer
-        
+
         # Add image and its labels
         if isinstance(obj, LabeledArray):
             self._add_image(obj, **kwargs)
-        
+
         # Add points
         elif isinstance(obj, MarkerFrame):
             add_points(self.viewer, obj, **kwargs)
-        
+
         # Add labels
         elif isinstance(obj, Label):
             add_labels(self.viewer, obj, **kwargs)
-        
+
         # Add tracks
         elif isinstance(obj, TrackFrame):
             add_tracks(self.viewer, obj, **kwargs)
-        
+
         # Add path
         elif isinstance(obj, PathFrame):
             add_paths(self.viewer, obj, **kwargs)
-        
+
         # Add a table
         elif isinstance(obj, (pd.DataFrame, PropArray)):
             self.add_table(obj, **kwargs)
-        
+
         # Add a lazy-loaded image
         elif isinstance(obj, LazyImgArray):
             if obj.gb > Const["MAX_GB"] and self.viewer.dims.ndisplay == 3:
                 raise MemoryError("Cannot send large files while the viewer is 3D mode.")
             add_dask(self.viewer, obj, **kwargs)
-        
+
         # Add an array as an image
         elif type(obj) is np.ndarray:
             self._add_image(ip_array(obj))
-        
+
         # Add an dask array as an image
         elif type(obj) is da.core.Array:
             self._add_image(ip_aslazy(obj))
-        
+
         # Add an image from a path
         elif isinstance(obj, (str, Path)):
             viewer_imread(self.viewer, obj)
-            
+
         # Add many objects of same type
         elif isinstance(obj, DataList):
             [self.add(each, **kwargs) for each in obj]
-        
+
         # Add a RoiList object as a shapes
         elif type(obj).__name__ == "RoiList":
             add_rois(self.viewer, obj, **kwargs)
-        
+
         # Add a Roi object as a shape
         elif hasattr(obj, "from_imagejroi"):
             add_rois(self.viewer, [obj], **kwargs)
-        
+
         else:
             raise TypeError(f"Could not interpret type: {type(obj)}")
-    
-        
+
+
     def add_surface(
         self,
         image3d: LabeledArray,
@@ -403,11 +401,11 @@ class napariViewers:
         ----------
         image3d : LabeledArray
             3D image from which surface will be generated
-        level, step_size, mask : 
+        level, step_size, mask :
             Passed to ``skimage.measure.marching_cubes``
-        """        
+        """
         from skimage.measure import marching_cubes
-        verts, faces, _, values = marching_cubes(image3d, level=level, 
+        verts, faces, _, values = marching_cubes(image3d, level=level,
                                                  step_size=step_size, mask=mask)
         scale = make_world_scale(image3d)
         name = f"[Surf]{image3d.name}"
@@ -417,8 +415,8 @@ class napariViewers:
             warnings.simplefilter("ignore")
             self.viewer.add_surface((verts, faces, values), **kw)
         return None
-    
-    
+
+
     def goto(self, **kwargs) -> tuple[int, ...]:
         """
         Change the current step of the viewer.
@@ -426,24 +424,24 @@ class napariViewers:
         Examples
         --------
         1. Go to t=3.
-        
+
             >>> ip.gui.goto(t=3)
-        
-        2. Go to t=3 and last z. 
-        
+
+        2. Go to t=3 and last z.
+
             >>> ip.gui.goto(t=3, z=-1)
-            
-        """        
+
+        """
         step = list(self.viewer.dims.current_step)
         for axis, ind in kwargs.items():
             i = self.axisof(axis)
             if ind < 0:
                 ind = self.viewer.dims.nsteps[i] + ind # support minus indexing
             step[i] = min(max(int(ind), 0), self.viewer.dims.nsteps[i]-1) # between min/max
-        
+
         self.viewer.dims.current_step = step
         return step
-    
+
     def stepof(self, symbol: AxisLike) -> int:
         """
         Get the current step of certain axis.
@@ -452,13 +450,13 @@ class napariViewers:
         ----------
         symbol : AxisLike
             Axis symbol
-        """        
+        """
         i = self.axes.find(symbol)
         return self.viewer.dims.current_step[i]
 
     def axisof(self, symbol: AxisLike) -> int:
         return self.axes.find(symbol)
-    
+
     def _add_image(self, img: LabeledArray, **kwargs):
         layer = add_labeledarray(self.viewer, img, **kwargs)
         if isinstance(layer, list):
@@ -468,30 +466,30 @@ class napariViewers:
         if img.labels is not None:
             add_labels(self.viewer, img.labels, name=name, metadata={"destination_image": img})
         return None
-    
+
     def add_table(self, table: pd.DataFrame | dict[str, ArrayLike], **kwargs):
         from magicgui.widgets import Table
         table = Table(value=table)
         self.viewer.window.add_dock_widget(table, **kwargs)
         return table
-    
+
     def add_image(self, *args, **kwargs):
         return self.viewer.add_image(*args, **kwargs)
-    
+
     def add_shapes(self, *args, **kwargs):
         return self.viewer.add_shapes(*args, **kwargs)
-    
+
     def add_surface(self, *args, **kwargs):
         return self.viewer.add_surface(*args, **kwargs)
-    
+
     def add_points(self, *args, **kwargs):
         return self.viewer.add_points(*args, **kwargs)
-    
+
     def add_labels(self, *args, **kwargs):
         return self.viewer.add_labels(*args, **kwargs)
-    
+
     def add_vectors(self, *args, **kwargs):
         return self.viewer.add_vectors(*args, **kwargs)
-    
+
     def add_tracks(self, *args, **kwargs):
         return self.viewer.add_tracks(*args, **kwargs)