The dependency on pyqt5 which gets installed via pip can create trouble if napari has been installed via conda (see https://napari.org/plugins/best_practices.html#don-t-include-pyside2-or-pyqt5-in-your-plugin-s-dependencies). Is there any reason for this dependency? As this plugin is itself a dependency of other plugins like napari-segment-blobs-and-things-with-membranes this can create trouble down the chain.

Hi @haesleinhuepf ,

I wanted to ask whether it is really strictly necessary to use the current PyQt5 requirement?

pyqt5>=5.15.0

It collides with current Spyder versions that only support PyQt up to 5.13:

spyder 5.1.5 requires pyqtwebengine<5.13, which is not installed.
spyder 5.1.5 requires pyqt5<5.13, but you have pyqt5 5.15.6 which is incompatible.

Since the time slicer is used downstream in quite a few plugins of yours (e.g., segment-blobs-and-things-with-membranes, etc.) this is quite a restriction.

Hi @haesleinhuepf ,

I am getting an error in this notebook in the 5th cell on this command:

surface = nppas.largest_label_to_surface(labels)

where nppas is napari-process-points-and-surfaces. Labels is a regular label image as made with skimage.measure.label().

Thanks for looking at it!

Hey @haesleinhuepf! this is the first implementation of the time slicer wrapper using dask instead of computing the time slices based on the current time index. I could re-use some a little of the previous code but the wrappers start to differ from eachother pretty soon. At the moment I'm also unsure if this wrapper can replace the original time slicer function as a substitute so I kept both your old version and the dask version. An idea that I had which could be useful for saving the dask images is a function which processes each time slice and saves it as a separate image (If images are saved one by one it's really easy to load them as dask arrays!)

source:

 if sys.platform.startswith('linux') and running_as_bundled_app():
  .tox/py37-linux/lib/python3.7/site-packages/napari/utils/misc.py:65: in running_as_bundled_app
      metadata = importlib_metadata.metadata(app_module)
  .tox/py37-linux/lib/python3.7/site-packages/importlib_metadata/__init__.py:1005: in metadata
  return Distribution.from_name(distribution_name).metadata
  .tox/py37-linux/lib/python3.7/site-packages/importlib_metadata/__init__.py:562: in from_name
  raiseValueError("A distribution name is required.")
  E   ValueError: A distribution name is required.

See also:

https://github.com/napari/napari/issues/4797

This turns result of time-slicer annotated functions into 4D delayed dask arrays as proposed by @Cryaaa in #5

This PR doesn't fully work yet in the interactive napari user-interface. After setting up a workflow and when going through time, it crashes sometimes with a KeyError while saving the duration of an operation. This is related to a computation finishing while the result has already be replaced. Basically multiple threads writing to the same result. It's this error: https://github.com/dask/dask/issues/896

Reproduce:

• Start napari
• Open the Example dataset clEsperanto > CalibZapwfixed
• Turn it into a 2D+t dataset using Tools > Utilities
• Open the assistant
• Setup a workflow, e.g. Denoise, Threshold, Label
• Move the time-bar a couple of times until it crashes.

I'm not sure yet how to solve this.

Hi Robert @haesleinhuepf ,

I am seeing some issues with using the timeslicer on 4D points/surface data in napari. For instance, using the label_to_surface() function from napari-process-points-and-surfaces throws an error:

ValueError: Input volume should be a 3D numpy array.

which comes from the marching_cubes function under the hood. Here is a small example script to reproduce the error:

import napari
import napari_process_points_and_surfaces as nppas
# Make a blurry sphere
s = 100
data = np.zeros((s, s, s), dtype=float)
x0 = 50
radius = 15

for x in range(s):
    for y in range(s):
        for z in range(s):
            if np.sqrt((x-x0)**2 + (y-x0)**2 + (z-x0)**2) < radius:
                data[x, y, z] = 1.0

viewer = make_napari_viewer()
viewer.add_image(image)

segmentation = image > filters.threshold_otsu(image)
viewer.add_labels(segmentation)

surf = nppas.label_to_surface(segmentation.astype(int))
viewer.add_surface(surf)

When introspecting the call to marching_cubes within the time_slicer function it is also evident that the image is somehow still a 4D image.