Merge pull request #543 from thewtex/python-37

thewtex · web-flow · commit ecaa868e8203 · 2022-10-04T15:08:00.000-04:00
ENH: Python 3.7 support
diff --git a/.github/workflows/notebook-test.yml b/.github/workflows/notebook-test.yml
@@ -6,22 +6,29 @@ jobs:
   run:
     runs-on: ubuntu-latest
     name: Test notebooks with nbmake
+    strategy:
+      matrix:
+        python-version: ['3.7', '3.8', '3.9', '3.10']
     steps:
       - uses: actions/checkout@v3
 
-      - uses: actions/setup-python@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v3
         with:
-          python-version: '3.9'
+          python-version: ${{ matrix.python-version }}
+
       - uses: actions/setup-java@v3
         with:
           java-version: '8'
           distribution: 'zulu'
+
       - name: Install test dependencies
         run: |
           python3 -m pip install --upgrade pip
           python3 -m pip install -e ".[test]"
           python3 -m pip install pyimagej
           python3 -c "import imagej; ij = imagej.init('2.5.0'); print(ij.getVersion())"
+
       - name: Test notebooks
         run: |
           pytest --nbmake --nbmake-timeout=3000  examples/*.ipynb examples/integrations/dask/*.ipynb
diff --git a/itkwidgets/integrations/__init__.py b/itkwidgets/integrations/__init__.py
@@ -1,18 +1,13 @@
-from collections.abc import MutableMapping
-from re import S
-
 import itkwasm
 import numpy as np
 import zarr
-from multiscale_spatial_image import MultiscaleSpatialImage, to_multiscale, itk_image_to_multiscale, Methods
-from spatial_image import to_spatial_image, is_spatial_image
+from ngff_zarr import to_multiscales, to_ngff_zarr, to_ngff_image, itk_image_to_ngff_image, Methods
 
 import dask
-import xarray as xr
-from .itk import HAVE_ITK, itk_image_to_wasm_image, itk_group_spatial_object_to_wasm_point_set
+from .itk import HAVE_ITK, itk_group_spatial_object_to_wasm_point_set
 from .pytorch import HAVE_TORCH
-from .vtk import HAVE_VTK, vtk_image_to_spatial_image, vtk_polydata_to_vtkjs
-from .xarray import xarray_data_array_to_numpy, xarray_data_set_to_numpy
+from .vtk import HAVE_VTK, vtk_image_to_ngff_image, vtk_polydata_to_vtkjs
+from .xarray import HAVE_XARRAY, HAVE_MULTISCALE_SPATIAL_IMAGE, xarray_data_array_to_numpy, xarray_data_set_to_numpy
 from ..render_types import RenderType
 
 def _spatial_image_scale_factors(spatial_image, min_length):
@@ -36,99 +31,99 @@ def _spatial_image_scale_factors(spatial_image, min_length):
 
     return scale_factors
 
-def _make_multiscale_store(multiscale):
+def _make_multiscale_store():
     # Todo: for very large images serialize to disk cache
+    # -> create DirectoryStore in cache directory and return as the chunk_store
     store = zarr.storage.MemoryStore(dimension_separator='/')
-    multiscale.to_zarr(store, compute=True)
-    return store
+    return store, None
 
 def _get_viewer_image(image, label=False):
+    # NGFF Zarr
+    if isinstance(image, zarr.Group) and 'multiscales' in image.attrs:
+        return image.store
+
     min_length = 64
     if label:
         method = Methods.DASK_IMAGE_NEAREST
     else:
         method = Methods.DASK_IMAGE_GAUSSIAN
-    if isinstance(image, MultiscaleSpatialImage):
-        return _make_multiscale_store(image)
+    
+    store, chunk_store = _make_multiscale_store()
+
+    if HAVE_MULTISCALE_SPATIAL_IMAGE:
+        if isinstance(image, MultiscaleSpatialImage):
+            image.to_zarr(store, compute=True)
+            return store
+
+    if isinstance(image, itkwasm.Image):
+        ngff_image = itk_image_to_ngff_image(image)
+        multiscales = to_multiscales(ngff_image, method=method)
+        to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
 
-    # Todo: support for itkwasm.Image
     if HAVE_ITK:
         import itk
         if isinstance(image, itk.Image):
-            dimension = image.GetImageDimension()
-            size = np.array(itk.size(image))
-            scale_factors = []
-            dims = ('x', 'y', 'z')
-            previous = {'x': 1, 'y': 1, 'z': 1}
-            while (size > min_length).any():
-                to_skip = size <= size.max() / 2
-                scale_factor = {}
-                for dim in range(dimension):
-                    if to_skip[dim]:
-                        scale_factor[dims[dim]] = previous[dims[dim]]
-                        continue
-                    scale_factor[dims[dim]] = 2 * previous[dims[dim]]
-                    size[dim] = int(size[dim] / 2)
-                previous = scale_factor
-                scale_factors.append(scale_factor)
-
-            multiscale = itk_image_to_multiscale(image, scale_factors=scale_factors, method=method)
-            return _make_multiscale_store(multiscale)
+            ngff_image = itk_image_to_ngff_image(image)
+            multiscales = to_multiscales(ngff_image, method=method)
+            to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
+            return store
 
     if HAVE_VTK:
         import vtk
         if isinstance(image, vtk.vtkImageData):
-            spatial_image = vtk_image_to_spatial_image(image)
-            scale_factors = _spatial_image_scale_factors(spatial_image, min_length)
-            multiscale = to_multiscale(spatial_image, scale_factors, method=method)
-            return _make_multiscale_store(multiscale)
+            ngff_image = vtk_image_to_ngff_image(image)
+            multiscales = to_multiscales(ngff_image, method=method)
+            to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
+            return store
 
     if isinstance(image, dask.array.core.Array):
-        spatial_image = to_spatial_image(image)
-        scale_factors = _spatial_image_scale_factors(spatial_image, min_length)
-        multiscale = to_multiscale(spatial_image, scale_factors, method=method)
-        return _make_multiscale_store(multiscale)
+        ngff_image = to_ngff_image(image)
+        multiscales = to_multiscales(ngff_image, method=method)
+        to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
+        return store
 
     if isinstance(image, zarr.Array):
-        spatial_image = to_spatial_image(image)
-        scale_factors = _spatial_image_scale_factors(spatial_image, min_length)
-        multiscale = to_multiscale(spatial_image, scale_factors, method=method)
-        return _make_multiscale_store(multiscale)
-
-    # NGFF Zarr
-    if isinstance(image, zarr.Group) and 'multiscales' in image.attrs:
-        return image.store
+        ngff_image = to_ngff_image(image)
+        multiscales = to_multiscales(ngff_image, method=method)
+        to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
+        return store
 
     if HAVE_TORCH:
         import torch
         if isinstance(image, torch.Tensor):
-            spatial_image = to_spatial_image(image.numpy())
-            scale_factors = _spatial_image_scale_factors(spatial_image, min_length)
-            multiscale = to_multiscale(spatial_image, scale_factors, method=method)
-            return _make_multiscale_store(multiscale)
+            ngff_image = to_ngff_image(image.numpy())
+            multiscales = to_multiscales(ngff_image, method=method)
+            to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
+            return store
 
     # Todo: preserve dask Array, if present, check if dims are NGFF -> use dims, coords
     # Check if coords are uniform, if not, resample
-    if isinstance(image, xr.DataArray):
-        if is_spatial_image(image):
-            scale_factors = _spatial_image_scale_factors(image, min_length)
-            multiscale = to_multiscale(image, scale_factors, method=method)
-            return _make_multiscale_store(multiscale)
-
-        return xarray_data_array_to_numpy(image)
-    if isinstance(image, xr.Dataset):
-        da = image[next(iter(image.variables.keys()))]
-        if is_spatial_image(da):
-            scale_factors = _spatial_image_scale_factors(da, min_length)
-            multiscale = to_multiscale(da, scale_factors, method=method)
-            return _make_multiscale_store(multiscale)
-        return xarray_data_set_to_numpy(image)
+    if HAVE_XARRAY:
+        import xarray as xr
+        if isinstance(image, xr.DataArray):
+            # if HAVE_MULTISCALE_SPATIAL_IMAGE:
+            #     from spatial_image import is_spatial_image
+            #     if is_spatial_image(image):
+            #         from multiscale_spatial_image import to_multiscale
+            #         scale_factors = _spatial_image_scale_factors(image, min_length)
+            #         multiscale = to_multiscale(image, scale_factors, method=method)
+            #         return _make_multiscale_store(multiscale)
+
+            return xarray_data_array_to_numpy(image)
+        if isinstance(image, xr.Dataset):
+            # da = image[next(iter(image.variables.keys()))]
+            # if is_spatial_image(da):
+            #     scale_factors = _spatial_image_scale_factors(da, min_length)
+            #     multiscale = to_multiscale(da, scale_factors, method=method)
+            #     return _make_multiscale_store(multiscale)
+            return xarray_data_set_to_numpy(image)
 
     if isinstance(image, np.ndarray):
-        spatial_image = to_spatial_image(image)
-        scale_factors = _spatial_image_scale_factors(spatial_image, min_length)
-        multiscale = to_multiscale(spatial_image, scale_factors, method=method)
-        return _make_multiscale_store(multiscale)
+        ngff_image = to_ngff_image(image)
+        multiscales = to_multiscales(ngff_image, method=method)
+        to_ngff_zarr(store, multiscales, chunk_store=chunk_store)
+        return store
+
     raise RuntimeError("Could not process the viewer image")
 
 
@@ -143,10 +138,12 @@ def _get_viewer_point_sets(point_sets):
         import torch
         if isinstance(point_sets, torch.Tensor):
             return point_sets.numpy()
-    if isinstance(point_sets, xr.DataArray):
-        return xarray_data_array_to_numpy(point_sets)
-    if isinstance(point_sets, xr.Dataset):
-        return xarray_data_set_to_numpy(point_sets)
+    if HAVE_XARRAY:
+        import xarray as xr
+        if isinstance(point_sets, xr.DataArray):
+            return xarray_data_array_to_numpy(point_sets)
+        if isinstance(point_sets, xr.Dataset):
+            return xarray_data_set_to_numpy(point_sets)
     return point_sets
 
 
@@ -155,8 +152,10 @@ def _detect_render_type(data, input_type) -> RenderType:
         return RenderType.IMAGE
     elif isinstance(data, itkwasm.PointSet):
         return RenderType.POINT_SET
-    elif isinstance(data, MultiscaleSpatialImage):
-        return RenderType.IMAGE
+    elif HAVE_MULTISCALE_SPATIAL_IMAGE:
+        from multiscale_spatial_image import MultiscaleSpatialImage
+        if isinstance(data, MultiscaleSpatialImage):
+            return RenderType.IMAGE
     elif isinstance(data, (zarr.Array, zarr.Group)):
         # For now assume zarr.Group is an image
         # In the future, once NGFF supports point sets fully
@@ -194,11 +193,13 @@ def _detect_render_type(data, input_type) -> RenderType:
                 return RenderType.POINT_SET
             else:
                 return RenderType.IMAGE
-    if isinstance(data, xr.DataArray):
-        if input_type == 'point_sets':
-            return RenderType.POINT_SET
-        else:
-            return RenderType.IMAGE
+    if HAVE_XARRAY:
+        import xarray as xr
+        if isinstance(data, xr.DataArray):
+            if input_type == 'point_sets':
+                return RenderType.POINT_SET
+            else:
+                return RenderType.IMAGE
     if isinstance(data, xr.Dataset):
         if input_type == 'point_sets':
             return RenderType.POINT_SET
diff --git a/itkwidgets/integrations/itk.py b/itkwidgets/integrations/itk.py
@@ -12,19 +12,11 @@
     
 
 if HAVE_ITK:
-    def itk_image_to_wasm_image(image):
-        image_dict = itk.dict_from_image(image)
-        wasm_image = itkwasm.Image(**image_dict)
-        return wasm_image
-
     def itk_group_spatial_object_to_wasm_point_set(point_set):
         point_set_dict = itk.dict_from_pointset(point_set)
         wasm_point_set = itkwasm.PointSet(**point_set_dict)
         return wasm_point_set
 
 else:
-    def itk_image_to_wasm_image(image):
-        raise RuntimeError('itk 5.3rc4 or newer is required. `pip install --upgrade --pre itk`')
-
     def itk_group_spatial_object_to_wasm_point_set(point_set):
         raise RuntimeError('itk 5.3rc4 or newer is required. `pip install --upgrade --pre itk`')
diff --git a/itkwidgets/integrations/vtk.py b/itkwidgets/integrations/vtk.py
@@ -6,10 +6,10 @@
 except ImportError:
     pass
 
-from spatial_image import to_spatial_image
+from ngff_zarr import ngff_image, to_ngff_image
 
 
-def vtk_image_to_spatial_image(image):
+def vtk_image_to_ngff_image(image):
     array = vtk_to_numpy(image.GetPointData().GetScalars())
     dimensions = list(image.GetDimensions())
     array.shape = dimensions[::-1]
@@ -20,9 +20,9 @@ def vtk_image_to_spatial_image(image):
     spacing = image.GetSpacing()
     scale = { 'x': spacing[0], 'y': spacing[1], 'z': spacing[2] }
 
-    spatial_image = to_spatial_image(array, scale=scale, translation=translation)
+    ngff_image = to_ngff_image(array, scale=scale, translation=translation)
 
-    return spatial_image
+    return ngff_image
 
 def vtk_polydata_to_vtkjs(point_set):
     array = vtk_to_numpy(point_set.GetPoints().GetData())
diff --git a/itkwidgets/integrations/xarray.py b/itkwidgets/integrations/xarray.py
@@ -5,6 +5,13 @@
 except ImportError:
     pass
 
+HAVE_MULTISCALE_SPATIAL_IMAGE = False
+try:
+    import multiscale_spatial_image
+    HAVE_MULTISCALE_SPATIAL_IMAGE = True
+except ImportError:
+    pass
+
 def xarray_data_array_to_numpy(data_array):
     return data_array.to_numpy()
 
diff --git a/pyproject.toml b/pyproject.toml
@@ -33,13 +33,13 @@ keywords = [
     "webgpu",
 ]
 
-requires-python = ">=3.8"
+requires-python = ">=3.7"
 dependencies = [
     "itkwasm >= 1.0b1",
     "imjoy-rpc >= 0.5.16",
     "imjoy-utils >= 0.1.2",
+    "ngff-zarr[dask-image] >= 0.1.0",
     "numcodecs",
-    "multiscale_spatial_image[dask-image] >= 0.11.1",
     "zarr",
 ]
 

Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,13 @@ keywords = [`
`33`	`33`	`"webgpu",`
`34`	`34`	`]`
`35`	`35`
`36`		`-requires-python = ">=3.8"`
	`36`	`+requires-python = ">=3.7"`
`37`	`37`	`dependencies = [`
`38`	`38`	`"itkwasm >= 1.0b1",`
`39`	`39`	`"imjoy-rpc >= 0.5.16",`
`40`	`40`	`"imjoy-utils >= 0.1.2",`
	`41`	`+ "ngff-zarr[dask-image] >= 0.1.0",`
`41`	`42`	`"numcodecs",`
`42`		`- "multiscale_spatial_image[dask-image] >= 0.11.1",`
`43`	`43`	`"zarr",`
`44`	`44`	`]`
`45`	`45`