visor-py 2024.12.1__tar.gz

visor_py-2024.12.1/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, VISoR Group
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

visor_py-2024.12.1/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.1
+Name: visor-py
+Version: 2024.12.1
+Summary: A Python Library for VISoR Image.
+Author-email: Zijian Yi <arrowzeke@gmail.com>
+License: BSD
+Project-URL: repository, https://github.com/visor-tech/visor-py
+Keywords: VISoR
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dask[complete]==2024.9.1
+Requires-Dist: zarr==2.18.3
+Requires-Dist: numcodecs==0.13.0
+
+# visor-py
+A Python Library for VISoR Image.
+
+## Usage
+#### Install Module
+```sh
+pip install visor-py
+```
+
+#### Import Module
+```py
+import visor.image as vimg
+```
+
+#### Examples
+- Read .vsr
+```py
+import visor.image as vimg
+
+# Open .vsr file with read-only ('r') mode
+# img is a visor.Image object 
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+print(img.info)
+```
+
+- Read raw image
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+
+# Read raw image of slice_1_10x from zarr file
+# arr is a visor.Array object
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+print(arr.info)
+```
+
+- Read arrays by named stacks or channels
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+
+# Read stack by label
+# s1_array is a dask.array, dimensions: c,z,y,x
+s1_array = arr.read(stack='stack_1')
+print(f's1_array shape: {s1_array.shape}, dimensions: c,z,y,x')
+
+# Read channel by wavelength
+# c488_array is a dask.array, dimensions: s,z,y,x
+c488_array = arr.read(channel='488')
+print(f'c488_array shape: {c488_array.shape}, dimensions: s,z,y,x')
+
+# Read stack and channel
+# s1c488_array is a dask.array, dimensions: z,y,x
+s1c488_array = arr.read(stack='stack_1', channel='488')
+print(f's1c488_array shape: {s1c488_array.shape}, dimensions: z,y,x')
+```
+
+- Read array by index
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+
+# Read by index
+# the_array is a dask.array
+the_array = arr.array
+print(f'the_array shape: {the_array.shape}, dimensions: s,c,z,y,x')
+# subarr is a dask.array
+subarr = the_array[0,0,:,:,:]
+print(f'subarr shape: {subarr.shape}, dimensions: z,y,x')
+```
+
+- Write .vsr
+```py
+import visor.image as vimg
+import numpy as np
+import dask.array as da
+
+# Open .vsr file with write ('w') mode
+# img is a visor.Image object 
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'w')
+
+# Generate a random array
+# new_arr is a dask array
+new_arr = da.random.random(size=(2, 2, 4, 4, 4), chunks=(1, 1, 2, 2, 2))
+
+# Metadata
+# follow https://visor-tech.github.io/visor-data-schema/
+img_info = {}    # info.json
+arr_info = {}    # .zattrs
+selected = {}    # selected.json
+
+# Write array to .vsr
+img.write(arr=new_arr,
+          img_type='raw',
+          file='slice_1_10x',
+          resolution=0,
+          img_info=img_info,
+          arr_info=arr_info,
+          selected=selected)
+```
+
+## References
+[VISoR Image Schema](https://visor-tech.github.io/visor-data-schema)

visor_py-2024.12.1/README.md

@@ -0,0 +1,111 @@
+# visor-py
+A Python Library for VISoR Image.
+
+## Usage
+#### Install Module
+```sh
+pip install visor-py
+```
+
+#### Import Module
+```py
+import visor.image as vimg
+```
+
+#### Examples
+- Read .vsr
+```py
+import visor.image as vimg
+
+# Open .vsr file with read-only ('r') mode
+# img is a visor.Image object 
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+print(img.info)
+```
+
+- Read raw image
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+
+# Read raw image of slice_1_10x from zarr file
+# arr is a visor.Array object
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+print(arr.info)
+```
+
+- Read arrays by named stacks or channels
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+
+# Read stack by label
+# s1_array is a dask.array, dimensions: c,z,y,x
+s1_array = arr.read(stack='stack_1')
+print(f's1_array shape: {s1_array.shape}, dimensions: c,z,y,x')
+
+# Read channel by wavelength
+# c488_array is a dask.array, dimensions: s,z,y,x
+c488_array = arr.read(channel='488')
+print(f'c488_array shape: {c488_array.shape}, dimensions: s,z,y,x')
+
+# Read stack and channel
+# s1c488_array is a dask.array, dimensions: z,y,x
+s1c488_array = arr.read(stack='stack_1', channel='488')
+print(f's1c488_array shape: {s1c488_array.shape}, dimensions: z,y,x')
+```
+
+- Read array by index
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+
+# Read by index
+# the_array is a dask.array
+the_array = arr.array
+print(f'the_array shape: {the_array.shape}, dimensions: s,c,z,y,x')
+# subarr is a dask.array
+subarr = the_array[0,0,:,:,:]
+print(f'subarr shape: {subarr.shape}, dimensions: z,y,x')
+```
+
+- Write .vsr
+```py
+import visor.image as vimg
+import numpy as np
+import dask.array as da
+
+# Open .vsr file with write ('w') mode
+# img is a visor.Image object 
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'w')
+
+# Generate a random array
+# new_arr is a dask array
+new_arr = da.random.random(size=(2, 2, 4, 4, 4), chunks=(1, 1, 2, 2, 2))
+
+# Metadata
+# follow https://visor-tech.github.io/visor-data-schema/
+img_info = {}    # info.json
+arr_info = {}    # .zattrs
+selected = {}    # selected.json
+
+# Write array to .vsr
+img.write(arr=new_arr,
+          img_type='raw',
+          file='slice_1_10x',
+          resolution=0,
+          img_info=img_info,
+          arr_info=arr_info,
+          selected=selected)
+```
+
+## References
+[VISoR Image Schema](https://visor-tech.github.io/visor-data-schema)

visor_py-2024.12.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "visor-py"
+version = "2024.12.1"
+description = "A Python Library for VISoR Image."
+authors = [
+    { name = "Zijian Yi", email = "arrowzeke@gmail.com" }
+]
+readme = "README.md"
+license = { text = "BSD" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.11"
+dependencies = [
+  "dask[complete]==2024.9.1",
+  "zarr==2.18.3",
+  "numcodecs==0.13.0"
+]
+keywords = ["VISoR"]
+
+[project.urls]
+repository = "https://github.com/visor-tech/visor-py"

visor_py-2024.12.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

visor_py-2024.12.1/visor/image/__init__.py

@@ -0,0 +1,2 @@
+from .core import open_vsr
+__all__ = ['open_vsr']

visor_py-2024.12.1/visor/image/core.py

@@ -0,0 +1,305 @@
+from pathlib import Path
+import os
+import json
+import zarr
+import dask.array as da
+from numcodecs import Blosc
+
+# Schema Reference: https://visor-tech.github.io/visor-data-schema
+
+class Image:
+
+    def __init__(self, path:Path, mode:str):
+        """
+        Constructor of Image
+
+        Parameters:
+            path : the .vsr file path
+            mode : 'r' for read_only
+                   'w' for write
+        """
+        # path
+        path = Path(path)
+        if path.suffix != '.vsr':
+            raise ValueError(f'The path {path} does not have .vsr extension.')
+        if not path.exists() or not path.is_dir():
+            if 'w' == mode:
+                path.mkdir(parents=True, exist_ok=True)
+            else: 
+                raise NotADirectoryError(f'The path {path} is not a directory.')
+        self.path = path
+        self.mode = mode
+
+        # info
+        info_file = path/'info.json'
+        if not info_file.exists():
+            if 'w' == mode:
+                info_file.touch()
+                info_file.write_text('{}')
+            else:
+                raise FileNotFoundError(f'Metadata file info.json is not found in {path}.')
+        with open(info_file) as f:
+            self.info = json.load(f)
+
+        # file structure
+        self.image_types = self._get_image_types()
+        self.transforms = self._get_transforms()
+        self.image_files = {}
+        for image_type in self.image_types:
+            dir = path/f'visor_{image_type}_images'
+            if 'raw' == image_type:
+                with open(dir/'selected.json') as sf:
+                    self.image_files[image_type] = json.load(sf)
+            else:
+                self.image_files[image_type] = [{
+                    "path": d,
+                    "channels": self._get_channels(dir/f/'.zattr')
+                } for d in dir.iterdir() if d.suffix == '.zarr']
+
+
+    def _get_image_types(self):
+        """
+        Private method to get image type list
+
+        Returns:
+            List of image types
+        """
+
+        return [d.name.split('_')[1] for d in self.path.glob('visor_*_images')]
+
+
+    def _get_transforms(self):
+        """
+        Private method to get transform list
+
+        Returns:
+            List of transforms
+        """
+
+        transforms = []
+
+        transforms_dir = self.path/'visor_recon_transforms'
+        if transforms_dir.is_dir():
+            transforms = transforms_dir.iterdir()
+
+        return transforms
+
+
+    def _get_channels(meta_file):
+        """
+        Private method to get channel list from metadata file
+
+        Parameters:
+            meta_file : the metadata file path
+
+        Returns:
+            List of channel wavelengths
+        """
+
+        with open(meta_file) as mf:
+            meta = json.load(mf)
+        return [c['wavelength'] for c in meta['channels']]
+
+
+    def _get_stacks(meta_file):
+        """
+        Private method to get stack list
+
+        Parameters:
+            meta_file : the metadata file path
+        
+        Returns:
+            List of stack labels
+        """
+
+        with open(meta_file) as mf:
+            meta = json.load(mf)
+        return [s['label'] for s in meta['visor_stacks']]
+
+
+    def list(self, img_type=None):
+        """
+        List image files
+
+        Parameters:
+            img_type : optional filter of image type
+
+        Returns:
+            Dictionary of image files
+        """
+
+        if None == img_type:
+            return self.image_files
+        elif img_type not in self.image_files:
+            return {}
+        else:
+            return self.image_files[img_type]
+
+
+    def read(self, img_type:str, zarr_file:str, resolution:int):
+        """
+        Read Array from Image
+
+        Parameters:
+            img_type   : visor image type, e.g. 'raw', 'projn', etc.
+            zarr_file  : zarr file name with '.zarr' extension
+            resolution : resolution level
+
+        Returns:
+            Array
+        """
+
+        return Array(path=self.path/f'visor_{img_type}_images'/zarr_file,
+                     resolution=resolution)
+
+
+    def write(self, arr:da, img_type:str, file:str,
+                    resolution:int, img_info:dict,
+                    arr_info:dict, selected:dict=None,
+                    compression:str='zstd', clevel:int=5):
+        """
+        Read Array from Image
+
+        Parameters:
+            arr         : dask array to write
+            img_type    : visor image type, e.g. 'raw', 'projn', etc.
+            file        : file name without extension
+            resolution  : resolution level
+            img_info    : metadata to write to info.json
+            arr_info    : metadata to write to .zattrs
+            selected    : optional metadata to write to selected.json
+            compression : compression algorithm to use for zarr, default to 'zstd'
+            clevel      : compression level to use for zarr, default to 5
+        """
+
+        if self.mode != 'w':
+            raise PermissionError('"write" method is only available in "w" mode.')
+        
+        zarr_file = self.path/f'visor_{img_type}_images'/f'{file}.zarr'
+        component = str(resolution)
+        da.to_zarr(arr, zarr_file,
+                   dimension_separator=os.sep,
+                   component=component,
+                   compressor=Blosc(cname=compression, clevel=clevel))
+        
+        img_info_file = self.path/'info.json'
+        with open(img_info_file, 'w') as iif:
+            json.dump(img_info, iif, indent=2)
+
+        arr_info_file = zarr_file/'.zattrs'
+        with open(arr_info_file, 'w') as aif:
+            json.dump(arr_info, aif, indent=2)
+
+        if selected and 'raw' == img_type:
+            selected_file = self.path/'visor_raw_images'
+            with open(selected_file, 'w') as sf:
+                json.dump(selected, sf, indent=2)
+
+
+class Array:
+
+    def __init__(self, path:Path, resolution:int):
+        """
+        Constructor of Array
+
+        Parameters:
+            path : the .zarr file path
+            resolution : resolution level
+        """
+        # path
+        if path.suffix != '.zarr':
+            raise ValueError(f'{path} is not a zarr file.')
+        if not path.is_dir():
+            raise NotADirectoryError(f'The path {path} is not a directory.')
+        self.path = path
+        
+        # resolution
+        self.resolution = resolution
+
+        # .zarray
+        zarray_file = path/str(resolution)/'.zarray'
+        if not zarray_file.exists():
+            raise FileNotFoundError(f'Must contain a .zarray file in {path} directory.')
+        
+        # info
+        meta_file = path/'.zattrs'
+        with open(meta_file) as mf:
+            self.info = json.load(mf)
+
+        # dictionares of named dimension
+        self.channel_map = {}
+        if 'channels' in self.info:
+            for channel in self.info['channels']:
+                self.channel_map[channel['wavelength']] = channel['index']
+        self.stack_map = {}
+        if 'visor_stacks' in self.info:
+            for stack in self.info['visor_stacks']:
+                self.stack_map[stack['label']] = stack['index']
+
+        # array
+        _store = zarr.DirectoryStore(path/str(resolution))
+        z_array = zarr.open(_store, mode='r')
+        self.array = da.from_array(z_array, chunks=z_array.chunks)
+
+
+    def read(self, channel=None, stack=None):        
+        """
+        Read a subarray from this array with optional `s` and `c` dimensions.
+        
+        Parameters:
+            stack: str or None, the visor_stack label
+                Get index from stack_map. If None, take all `s` subarrays.
+            channel: str or None, the channel wavelength
+                Get index from channel_map. If None, take all `c` subarrays.
+        
+        Returns:
+            dask.array
+        """
+        # Total dimensions in the array
+        ndim = self.array.ndim
+
+        # Define slices for each dimension
+        arr_slices = [slice(None)] * ndim
+
+        # Validate `stack` and `channel` based on array dimensions
+        if ndim == 5:  # (s, c, z, y, x)
+            if (stack is not None) and (stack not in self.stack_map):
+                raise KeyError(f'stack {stack} does not exist, valid stacks: {list(self.stack_map.keys())}')
+            if (channel is not None) and (channel not in self.channel_map):
+                raise KeyError(f'channel {channel} does not exist, valid channels: {list(self.channel_map.keys())}')
+        elif ndim == 4:  # (c, z, y, x)
+            if (channel is not None) and (channel not in self.channel_map):
+                raise KeyError(f'channel {channel} does not exist, valid channels: {list(self.channel_map.keys())}')
+        elif ndim == 3:  # (z, y, x)
+            if stack is not None or channel is not None:
+                raise IndexError("'s' or 'c' dimensions do not exist in a 3D array")
+
+        # Map the dimensions dynamically based on `ndim`
+        if ndim == 5:  # (s, c, z, y, x)
+            if stack is not None:
+                arr_slices[0] = self.stack_map[stack]
+            if channel is not None:
+                arr_slices[1] = self.channel_map[channel]
+        elif ndim == 4:  # (c, z, y, x)
+            if channel is not None:
+                arr_slices[0] = self.channel_map[channel]
+        elif ndim == 3:  # (z, y, x)
+            pass  # No `s` or `c` dimensions to handle
+
+        # Apply the arr_slices to the array
+        return self.array[tuple(arr_slices)]
+
+
+def open_vsr(path:str, mode:str):
+    """
+    Open vsr file, as an Image object
+
+    Parameters:
+        path : the .vsr file path
+        mode : 'r' for read_only
+               'w' for write
+
+    Returns:
+        Image
+    """
+    return Image(Path(path), mode)

visor_py-2024.12.1/visor/image/tests/test_core.py

@@ -0,0 +1,225 @@
+from pathlib import Path
+import unittest
+import shutil
+
+import visor.image as vimg
+
+class TestBase(unittest.TestCase):
+
+    def setUp(self):
+
+        # Test Data: validated with https://ome.github.io/ome-ngff-validator
+        # simply use ome_zarr command line tool as below:
+        #   $ ome_zarr view visor/image/tests/data/VISOR001/visor_raw_images/slice_1_10x.zarr
+        self.path = Path(__file__).parent/'data'/'VISOR001.vsr'
+
+
+class TestCore(TestBase):
+
+    def test_open_vsr_r(self):
+
+        img = vimg.open_vsr(self.path, 'r')
+        
+        self.assertIsInstance(img, vimg.core.Image)
+        self.assertEqual(img.info['animal_id'], 'VISOR001')
+        self.assertEqual(img.info['project_name'], 'VISOR')
+        self.assertEqual(img.info['species'], 'Mouse')
+        self.assertEqual(img.info['subproject_name'], 'XXX-XXXX-1X7-3X')
+        self.assertEqual(img.image_types, ['raw'])
+        self.assertEqual(img.transforms, [])
+        self.assertEqual(img.image_files, {'raw': [
+            {'path':'slice_1_10x.zarr', 'channels':["488","561"]},
+            {'path':'slice_1_10x_1.zarr', 'channels':["405","640"]},
+        ]})
+
+
+    def test_open_vsr_w(self):
+
+        img = vimg.open_vsr(self.path, 'w')
+        self.assertIsInstance(img, vimg.core.Image)
+
+
+class TestImageReadOnly(TestBase):
+
+    def setUp(self):
+
+        super().setUp()
+        self.img = vimg.open_vsr(self.path, 'r')
+
+        self.zarr_file = 'slice_1_10x.zarr'
+        self.resolution = 0
+
+
+    def test_image_list(self):
+
+        self.assertEqual(self.img.list(), {'raw': [
+            {'path':'slice_1_10x.zarr', 'channels':["488","561"]},
+            {'path':'slice_1_10x_1.zarr', 'channels':["405","640"]},
+        ]})
+        self.assertEqual(self.img.list('raw'), [
+            {'path':'slice_1_10x.zarr', 'channels':["488","561"]},
+            {'path':'slice_1_10x_1.zarr', 'channels':["405","640"]},
+        ])
+        self.assertEqual(self.img.list('projn'), {})
+
+
+    def test_image_read(self):
+
+        arr = self.img.read('raw',self.zarr_file,0)
+
+        self.assertIsInstance(arr, vimg.core.Array)
+        self.assertIn('multiscales', arr.info)
+        self.assertIn('visor_stacks', arr.info)
+        self.assertIn('channels', arr.info)
+        self.assertEqual(arr.channel_map, {'488':0, '561':1})
+        self.assertEqual(arr.stack_map, {'stack_1':0, 'stack_2':1})
+        self.assertEqual(arr.array.shape, (2,2,4,4,4))
+
+    def test_image_write_exception(self):
+
+        arr = self.img.read('raw',self.zarr_file,resolution=self.resolution)
+        with self.assertRaises(PermissionError) as context:
+            self.img.write(arr,'raw',self.zarr_file,0,{},{})
+        self.assertEqual(str(context.exception), '"write" method is only available in "w" mode.')
+
+
+class TestArrayRead(TestBase):
+
+    def setUp(self):
+
+        super().setUp()
+        img = vimg.open_vsr(self.path, 'w')
+        self.arr = img.read('raw','slice_1_10x.zarr',0)
+
+
+    def test_array_read(self):
+
+        arr = self.arr.read()
+        self.assertEqual(arr.shape, (2,2,4,4,4))
+
+
+    def test_array_read_channel(self):
+
+        arr = self.arr.read(channel='488')
+        self.assertEqual(arr.shape, (2,4,4,4))
+
+
+    def test_array_read_stack(self):
+
+        arr = self.arr.read(stack='stack_1')
+        self.assertEqual(arr.shape, (2,4,4,4))
+
+
+    def test_array_read_channel_and_stack(self):
+
+        arr = self.arr.read(channel='488',stack='stack_1')
+        self.assertEqual(arr.shape, (4,4,4))
+
+
+    def test_array_read_channel_not_exist(self):
+
+        with self.assertRaises(KeyError) as context:
+            self.arr.read(channel='777')
+        self.assertEqual(str(context.exception), '"channel 777 does not exist, valid channels: [\'488\', \'561\']"')
+
+
+class TestImageWrite(TestBase):
+
+    def setUp(self):
+
+        super().setUp()
+        self.src_img_type = 'raw'
+        self.src_img_file = 'slice_1_10x'
+
+        self.dst_img_type = 'raw'
+        self.dst_img_file = 'slice_1_10x'
+        
+        self.resolution = 0
+
+        src_img = vimg.open_vsr(self.path, 'r')
+        self.src_img_info = src_img.info
+        self.arr = src_img.read(self.src_img_type,
+                                f'{self.src_img_file}.zarr',
+                                self.resolution)
+        
+        self.dst_path = self.path.parent/'tmp.vsr'
+
+
+    def tearDown(self):
+
+        if self.dst_path.exists():
+            shutil.rmtree(self.dst_path)
+
+
+    def test_image_write(self):
+        
+        dst_img = vimg.open_vsr(self.dst_path, 'w')
+        dst_img.write(self.arr.array,
+                      self.dst_img_type,
+                      self.dst_img_file,
+                      self.resolution,
+                      self.src_img_info,
+                      self.arr.info)
+        arr = dst_img.read(self.dst_img_type,
+                           f'{self.dst_img_file}.zarr',
+                           0)
+        self.assertIsInstance(arr, vimg.core.Array)
+        self.assertIn('multiscales', arr.info)
+        self.assertIn('visor_stacks', arr.info)
+        self.assertIn('channels', arr.info)
+        self.assertEqual(arr.channel_map, {'488':0, '561':1})
+        self.assertEqual(arr.stack_map, {'stack_1':0, 'stack_2':1})
+        self.assertEqual(arr.array.shape, (2,2,4,4,4))
+
+
+# class TestImageUpdate(TestBase):
+
+#     def setUp(self):
+
+#         super().setUp()
+#         self.src_img_type = 'raw'
+#         self.src_img_file = 'slice_1_10x'
+
+#         self.dst_img_type = 'icorr'
+#         self.dst_img_file = 'slice_1_10x'
+        
+#         self.resolution = 0
+
+#         src_img = vimg.open_vsr(self.path, 'r')
+#         self.src_img_info = src_img.info
+#         self.arr = src_img.read(self.src_img_type,
+#                                 f'{self.src_img_file}.zarr',
+#                                 self.resolution)
+        
+#         self.dst_path = self.path/'visor_icorr_images'
+
+
+#     def tearDown(self):
+
+#         if self.dst_path.exists():
+#             shutil.rmtree(self.dst_path)
+
+
+#     def test_image_write(self):
+        
+#         dst_img = vimg.open_vsr(self.dst_path, 'w')
+#         dst_img.write(self.arr.array,
+#                       self.dst_img_type,
+#                       self.dst_img_file,
+#                       self.resolution,
+#                       self.src_img_info,
+#                       self.arr.info)
+#         arr = dst_img.read(self.dst_img_type,
+#                            f'{self.dst_img_file}.zarr',
+#                            0)
+#         self.assertIsInstance(arr, vimg.core.Array)
+#         self.assertIn('multiscales', arr.info)
+#         self.assertIn('visor_stacks', arr.info)
+#         self.assertIn('channels', arr.info)
+#         self.assertEqual(arr.channel_map, {'488':0, '561':1})
+#         self.assertEqual(arr.stack_map, {'stack_1':0, 'stack_2':1})
+#         self.assertEqual(arr.array.shape, (2,2,4,4,4))
+
+
+if __name__ == '__main__':
+    unittest.main()

visor_py-2024.12.1/visor_py.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.1
+Name: visor-py
+Version: 2024.12.1
+Summary: A Python Library for VISoR Image.
+Author-email: Zijian Yi <arrowzeke@gmail.com>
+License: BSD
+Project-URL: repository, https://github.com/visor-tech/visor-py
+Keywords: VISoR
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dask[complete]==2024.9.1
+Requires-Dist: zarr==2.18.3
+Requires-Dist: numcodecs==0.13.0
+
+# visor-py
+A Python Library for VISoR Image.
+
+## Usage
+#### Install Module
+```sh
+pip install visor-py
+```
+
+#### Import Module
+```py
+import visor.image as vimg
+```
+
+#### Examples
+- Read .vsr
+```py
+import visor.image as vimg
+
+# Open .vsr file with read-only ('r') mode
+# img is a visor.Image object 
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+print(img.info)
+```
+
+- Read raw image
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+
+# Read raw image of slice_1_10x from zarr file
+# arr is a visor.Array object
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+print(arr.info)
+```
+
+- Read arrays by named stacks or channels
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+
+# Read stack by label
+# s1_array is a dask.array, dimensions: c,z,y,x
+s1_array = arr.read(stack='stack_1')
+print(f's1_array shape: {s1_array.shape}, dimensions: c,z,y,x')
+
+# Read channel by wavelength
+# c488_array is a dask.array, dimensions: s,z,y,x
+c488_array = arr.read(channel='488')
+print(f'c488_array shape: {c488_array.shape}, dimensions: s,z,y,x')
+
+# Read stack and channel
+# s1c488_array is a dask.array, dimensions: z,y,x
+s1c488_array = arr.read(stack='stack_1', channel='488')
+print(f's1c488_array shape: {s1c488_array.shape}, dimensions: z,y,x')
+```
+
+- Read array by index
+```py
+import visor.image as vimg
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
+arr = img.read(img_type='raw',
+               zarr_file='slice_1_10x.zarr',
+               resolution=0)
+
+# Read by index
+# the_array is a dask.array
+the_array = arr.array
+print(f'the_array shape: {the_array.shape}, dimensions: s,c,z,y,x')
+# subarr is a dask.array
+subarr = the_array[0,0,:,:,:]
+print(f'subarr shape: {subarr.shape}, dimensions: z,y,x')
+```
+
+- Write .vsr
+```py
+import visor.image as vimg
+import numpy as np
+import dask.array as da
+
+# Open .vsr file with write ('w') mode
+# img is a visor.Image object 
+img = vimg.open_vsr('path/to/VISOR001.vsr', 'w')
+
+# Generate a random array
+# new_arr is a dask array
+new_arr = da.random.random(size=(2, 2, 4, 4, 4), chunks=(1, 1, 2, 2, 2))
+
+# Metadata
+# follow https://visor-tech.github.io/visor-data-schema/
+img_info = {}    # info.json
+arr_info = {}    # .zattrs
+selected = {}    # selected.json
+
+# Write array to .vsr
+img.write(arr=new_arr,
+          img_type='raw',
+          file='slice_1_10x',
+          resolution=0,
+          img_info=img_info,
+          arr_info=arr_info,
+          selected=selected)
+```
+
+## References
+[VISoR Image Schema](https://visor-tech.github.io/visor-data-schema)

visor_py-2024.12.1/visor_py.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+visor/__init__.py
+visor/image/__init__.py
+visor/image/core.py
+visor/image/tests/test_core.py
+visor/transform/__init__.py
+visor_py.egg-info/PKG-INFO
+visor_py.egg-info/SOURCES.txt
+visor_py.egg-info/dependency_links.txt
+visor_py.egg-info/requires.txt
+visor_py.egg-info/top_level.txt

visor_py-2024.12.1/visor_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

visor_py-2024.12.1/visor_py.egg-info/requires.txt

@@ -0,0 +1,3 @@
+dask[complete]==2024.9.1
+zarr==2.18.3
+numcodecs==0.13.0

visor_py-2024.12.1/visor_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+visor