copick-utils 0.5.0__tar.gz

copick_utils-0.5.0/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024-present Kyle Harrington <czi@kyleharrington.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

copick_utils-0.5.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.3
+Name: copick-utils
+Version: 0.5.0
+Summary: Utilities for copick
+License: MIT
+Author: Kyle Harrington
+Author-email: czi@kyleharrington.com
+Requires-Python: >=3.9
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: copick (>=0.8.0)
+Project-URL: Documentation, https://github.com/KyleHarrington/copick-utils#readme
+Project-URL: Issues, https://github.com/KyleHarrington/copick-utils/issues
+Project-URL: Source, https://github.com/KyleHarrington/copick-utils
+Description-Content-Type: text/markdown
+
+# copick-utils
+
+[![PyPI - Version](https://img.shields.io/pypi/v/copick-utils.svg)](https://pypi.org/project/copick-utils)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/copick-utils.svg)](https://pypi.org/project/copick-utils)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Citation](#citation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install copick-utils
+```
+
+## Citation
+
+If you use `copick-utils` in your research, please cite:
+
+```bibtex
+@article{harrington2024open,
+  title={Open-source Tools for CryoET Particle Picking Machine Learning Competitions},
+  author={Harrington, Kyle I. and Zhao, Zhuowen and Schwartz, Jonathan and Kandel, Saugat and Ermel, Utz and Paraan, Mohammadreza and Potter, Clinton and Carragher, Bridget},
+  journal={bioRxiv},
+  year={2024},
+  doi={10.1101/2024.11.04.621608}
+}
+```
+
+This software was introduced in a NeurIPS 2024 Workshop on Machine Learning in Structural Biology as "Open-source Tools for CryoET Particle Picking Machine Learning Competitions".
+
+## License
+
+`copick-utils` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+
+## Code of Conduct
+
+This project adheres to the Contributor Covenant [code of conduct](https://github.com/chanzuckerberg/.github/blob/main/CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [opensource@chanzuckerberg.com](mailto:opensource@chanzuckerberg.com).
+
+## Reporting Security Issues
+
+If you believe you have found a security issue, please responsibly disclose by contacting us at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com).
+

copick_utils-0.5.0/README.md

@@ -0,0 +1,46 @@
+# copick-utils
+
+[![PyPI - Version](https://img.shields.io/pypi/v/copick-utils.svg)](https://pypi.org/project/copick-utils)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/copick-utils.svg)](https://pypi.org/project/copick-utils)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Citation](#citation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install copick-utils
+```
+
+## Citation
+
+If you use `copick-utils` in your research, please cite:
+
+```bibtex
+@article{harrington2024open,
+  title={Open-source Tools for CryoET Particle Picking Machine Learning Competitions},
+  author={Harrington, Kyle I. and Zhao, Zhuowen and Schwartz, Jonathan and Kandel, Saugat and Ermel, Utz and Paraan, Mohammadreza and Potter, Clinton and Carragher, Bridget},
+  journal={bioRxiv},
+  year={2024},
+  doi={10.1101/2024.11.04.621608}
+}
+```
+
+This software was introduced in a NeurIPS 2024 Workshop on Machine Learning in Structural Biology as "Open-source Tools for CryoET Particle Picking Machine Learning Competitions".
+
+## License
+
+`copick-utils` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+
+## Code of Conduct
+
+This project adheres to the Contributor Covenant [code of conduct](https://github.com/chanzuckerberg/.github/blob/main/CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [opensource@chanzuckerberg.com](mailto:opensource@chanzuckerberg.com).
+
+## Reporting Security Issues
+
+If you believe you have found a security issue, please responsibly disclose by contacting us at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com).

copick_utils-0.5.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "copick-utils"
+version = "0.5.0"
+description = "Utilities for copick"
+readme = "README.md"
+license = "MIT"
+keywords = []
+authors = [
+  "Kyle Harrington <czi@kyleharrington.com>",
+  "Jonathan Schwartz <jonathan.schwartz@czii.org>"
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+packages = [{ include = "copick_utils", from = "src" }]
+
+[tool.poetry.dependencies]
+python = ">=3.9"
+copick = ">=0.8.0"
+
+[tool.poetry.urls]
+Documentation = "https://github.com/KyleHarrington/copick-utils#readme"
+Issues = "https://github.com/KyleHarrington/copick-utils/issues"
+Source = "https://github.com/KyleHarrington/copick-utils"
+
+[tool.poetry.scripts]
+# optional if you expose CLI commands
+# copick-utils = "copick_utils.cli:main"
+
+[tool.coverage.run]
+source_pkgs = ["copick_utils", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/copick_utils/__about__.py",
+]
+
+[tool.coverage.paths]
+copick_utils = ["src/copick_utils", "*/copick-utils/src/copick_utils"]
+tests = ["tests", "*/copick-utils/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

copick_utils-0.5.0/src/copick_utils/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2024-present Kyle Harrington <czi@kyleharrington.com>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.0.1"

copick_utils-0.5.0/src/copick_utils/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2024-present Kyle Harrington <czi@kyleharrington.com>
+#
+# SPDX-License-Identifier: MIT

copick_utils-0.5.0/src/copick_utils/features/skimage.py

@@ -0,0 +1,96 @@
+import numpy as np
+from skimage.feature import multiscale_basic_features
+import zarr
+from numcodecs import Blosc
+
+def compute_skimage_features(tomogram, feature_type, copick_root, intensity=True, edges=True, texture=True, sigma_min=0.5, sigma_max=16.0, feature_chunk_size=None):
+    """
+    Processes the tomogram chunkwise and computes the multiscale basic features.
+    Allows for optional feature chunk size.
+    """
+    image = zarr.open(tomogram.zarr(), mode='r')['0']
+    input_chunk_size = feature_chunk_size if feature_chunk_size else image.chunks
+    chunk_size = input_chunk_size if len(input_chunk_size) == 3 else input_chunk_size[1:]
+    
+    overlap = int(chunk_size[0] / 2)
+    
+    print(f"Processing image with shape {image.shape}")
+    print(f"Using chunk size: {chunk_size}, overlap: {overlap}")
+
+    # Determine number of features by running on a small test array
+    test_chunk = np.zeros((10, 10, 10), dtype=image.dtype)
+    test_features = multiscale_basic_features(
+        test_chunk,
+        intensity=intensity,
+        edges=edges,
+        texture=texture,
+        sigma_min=sigma_min,
+        sigma_max=sigma_max
+    )
+    num_features = test_features.shape[-1]
+
+    # Prepare output Zarr array directly in the tomogram store
+    print(f"Creating new feature store with {num_features} features...")
+    copick_features = tomogram.new_features(feature_type)
+    feature_store = copick_features.zarr()
+
+    # Use the provided feature chunk size if available, otherwise default to the input chunk size
+    if feature_chunk_size is None:
+        feature_chunk_size = (num_features, *chunk_size)
+    else:
+        feature_chunk_size = (num_features, *feature_chunk_size)
+
+    out_array = zarr.create(
+        shape=(num_features, *image.shape),
+        chunks=feature_chunk_size,
+        dtype='float32',
+        compressor=Blosc(cname='zstd', clevel=3, shuffle=2),
+        store=feature_store,
+        overwrite=True
+    )
+
+    # Process each chunk
+    for z in range(0, image.shape[0], chunk_size[0]):
+        for y in range(0, image.shape[1], chunk_size[1]):
+            for x in range(0, image.shape[2], chunk_size[2]):
+                z_start = max(z - overlap, 0)
+                z_end = min(z + chunk_size[0] + overlap, image.shape[0])
+                y_start = max(y - overlap, 0)
+                y_end = min(y + chunk_size[1] + overlap, image.shape[1])
+                x_start = max(x - overlap, 0)
+                x_end = min(x + chunk_size[2] + overlap, image.shape[2])
+
+                chunk = image[z_start:z_end, y_start:y_end, x_start:x_end]
+                chunk_features = multiscale_basic_features(
+                    chunk,
+                    intensity=intensity,
+                    edges=edges,
+                    texture=texture,
+                    sigma_min=sigma_min,
+                    sigma_max=sigma_max
+                )
+
+                # Adjust indices for overlap
+                z_slice = slice(overlap if z_start > 0 else 0, None if z_end == image.shape[0] else -overlap)
+                y_slice = slice(overlap if y_start > 0 else 0, None if y_end == image.shape[1] else -overlap)
+                x_slice = slice(overlap if x_start > 0 else 0, None if x_end == image.shape[2] else -overlap)
+
+                # Ensure contiguous array and correct slicing
+                contiguous_chunk = np.ascontiguousarray(chunk_features[z_slice, y_slice, x_slice].transpose(3, 0, 1, 2))
+
+                out_array[0:num_features, z:z + chunk_size[0], y:y + chunk_size[1], x:x + chunk_size[2]] = contiguous_chunk
+
+    print(f"Features saved under feature type '{feature_type}'")
+    return copick_features
+
+
+if __name__ == "__main__":
+    root = None  # copick.from_file
+    tomo = None  # get a tomogram from root
+    compute_skimage_features(
+        tomogram=tomo,
+        feature_type="skimageFeatures",
+        copick_root=root,
+        intensity=True, edges=True, texture=True, sigma_min=0.5, sigma_max=16.0,
+        feature_chunk_size=None  # Default to detected chunk size
+    )

copick_utils-0.5.0/src/copick_utils/pickers/grid_picker.py

@@ -0,0 +1,69 @@
+import numpy as np
+import zarr
+from copick.models import CopickPoint
+
+def grid_picker(pickable_obj, run, tomogram, grid_spacing_factor, session_id="0", user_id="gridPicker"):
+    """
+    Creates a grid of picks for a pickable object based on a tomogram and grid spacing factor.
+
+    Args:
+        pickable_obj: The pickable object (particle).
+        run: The Copick run.
+        tomogram: The tomogram data.
+        grid_spacing_factor: Factor to multiply the particle radius by to determine grid spacing.
+        session_id: The session ID for the segmentation.
+        user_id: The user ID for segmentation creation.
+    """
+    # Ensure it's a pickable particle object
+    if not pickable_obj.is_particle:
+        print(f"Object {pickable_obj.name} is not a particle.")
+        return
+
+    obj_name = pickable_obj.name
+    radius = pickable_obj.radius
+    if not radius:
+        print(f"Object {obj_name} does not have a valid radius.")
+        return
+
+    grid_spacing = radius * grid_spacing_factor
+
+    # Open the highest resolution of the tomogram
+    image = zarr.open(tomogram.zarr(), mode='r')['0']
+
+    # Create a grid of points
+    points = []
+    for z in np.arange(0, image.shape[0], grid_spacing):
+        for y in np.arange(0, image.shape[1], grid_spacing):
+            for x in np.arange(0, image.shape[2], grid_spacing):
+                points.append(CopickPoint(location={'x': x, 'y': y, 'z': z}))
+
+    # Save the picks
+    pick_set = run.new_picks(obj_name, session_id, user_id)
+    pick_set.points = points
+    pick_set.store()
+
+    print(f"Saved {len(points)} grid points for object {obj_name}.")
+    return pick_set
+
+if __name__ == "__main__":
+    import copick
+
+    copick_config_path = "path/to/copick_config.json"
+    grid_spacing_factor = 1.5
+    tomo_type = "your_tomo_type"
+    voxel_spacing = 1.0
+    session_id = "example_session"
+    user_id = "example_user"
+    run_name = "example_run"
+
+    # Load the Copick root and the run
+    root = copick.from_file(copick_config_path)
+    run = root.get_run(run_name)
+
+    # Get the tomogram and pickable object
+    voxel_spacing_obj = run.get_voxel_spacing(voxel_spacing)
+    tomogram = voxel_spacing_obj.get_tomogram(tomo_type)
+
+    for pickable_obj in root.pickable_objects:
+        create_grid_of_picks(pickable_obj, run, tomogram, grid_spacing_factor, session_id, user_id)
+

copick_utils-0.5.0/src/copick_utils/segmentation/picks_from_segmentation.py

@@ -0,0 +1,67 @@
+import numpy as np
+import scipy.ndimage as ndi
+from skimage.segmentation import watershed
+from skimage.measure import regionprops
+from skimage.morphology import binary_erosion, binary_dilation, ball
+
+
+def picks_from_segmentation(segmentation, segmentation_idx, maxima_filter_size, min_particle_size, max_particle_size, session_id, user_id, pickable_object, run, voxel_spacing=1):
+    """
+    Process a specific label in the segmentation, extract centroids, and save them as picks.
+
+    Args:
+        segmentation (np.ndarray): Multilabel segmentation array.
+        segmentation_idx (int): The specific label from the segmentation to process.
+        maxima_filter_size (int): Size of the maximum detection filter.
+        min_particle_size (int): Minimum size threshold for particles.
+        max_particle_size (int): Maximum size threshold for particles.
+        session_id (str): Session ID for pick saving.
+        user_id (str): User ID for pick saving.
+        pickable_object (str): The name of the object to save picks for.
+        run: A Copick run object that manages pick saving.
+        voxel_spacing (int): The voxel spacing used to scale pick locations (default 1).
+    """
+    # Create a binary mask for the specific segmentation label
+    binary_mask = (segmentation == segmentation_idx).astype(int)
+
+    # Skip if the segmentation label is not present
+    if np.sum(binary_mask) == 0:
+        print(f"No segmentation with label {segmentation_idx} found.")
+        return
+
+    # Structuring element for erosion and dilation
+    struct_elem = ball(1)
+    eroded = binary_erosion(binary_mask, struct_elem)
+    dilated = binary_dilation(eroded, struct_elem)
+
+    # Distance transform and local maxima detection
+    distance = ndi.distance_transform_edt(dilated)
+    local_max = (distance == ndi.maximum_filter(distance, footprint=np.ones((maxima_filter_size, maxima_filter_size, maxima_filter_size))))
+
+    # Watershed segmentation
+    markers, _ = ndi.label(local_max)
+    watershed_labels = watershed(-distance, markers, mask=dilated)
+
+    # Extract region properties and filter based on particle size
+    all_centroids = []
+    for region in regionprops(watershed_labels):
+        if min_particle_size <= region.area <= max_particle_size:
+            all_centroids.append(region.centroid)
+
+    # Save centroids as picks
+    if all_centroids:
+        pick_set = run.new_picks(pickable_object, session_id, user_id)
+
+        positions = np.array(all_centroids)[:, [2, 1, 0]] * voxel_spacing
+        pick_set.from_numpy(positions=positions)
+        pick_set.store()
+        
+        print(f"Centroids for label {segmentation_idx} saved successfully.")
+        return pick_set
+    else:
+        print(f"No valid centroids found for label {segmentation_idx}.")
+        return None
+
+
+# Example call to the function
+# picks_from_segmentation(segmentation_array, label_id, 9, 1000, 50000, session_id, user_id, pickable_object_name, run_object)

copick_utils-0.5.0/src/copick_utils/segmentation/segmentation_from_picks.py

@@ -0,0 +1,161 @@
+import numpy as np
+import zarr
+from scipy.ndimage import zoom
+import copick
+
+def from_picks(pick,
+               seg_volume,
+               radius: float = 10.0,
+               label_value: int = 1,
+               voxel_spacing: float = 10):
+    """
+    Paints picks into a segmentation volume as spheres.
+
+    Parameters:
+    -----------
+    pick : copick.models.CopickPicks
+        Copick object containing `points`, where each point has a `location` attribute with `x`, `y`, `z` coordinates.
+    seg_volume : numpy.ndarray
+        3D segmentation volume (numpy array) where the spheres are painted. Shape should be (Z, Y, X).
+    radius : float, optional
+        The radius of the spheres to be inserted in physical units (not voxel units). Default is 10.0.
+    label_value : int, optional
+        The integer value used to label the sphere regions in the segmentation volume. Default is 1.
+    voxel_spacing : float, optional
+        The spacing of voxels in the segmentation volume, used to scale the radius of the spheres. Default is 10.
+    Returns:
+    --------
+    numpy.ndarray
+        The modified segmentation volume with spheres inserted at pick locations.    
+    """
+    def create_sphere(shape, center, radius, val):
+        zc, yc, xc = center
+        z, y, x = np.indices(shape)
+        distance_sq = (x - xc)**2 + (y - yc)**2 + (z - zc)**2
+        sphere = np.zeros(shape, dtype=np.float32)
+        sphere[distance_sq <= radius**2] = val
+        return sphere
+
+    def get_relative_target_coordinates(center, delta, shape):
+        low = max(int(np.floor(center - delta)), 0)
+        high = min(int(np.ceil(center + delta + 1)), shape)
+        return low, high
+
+    # Adjust radius for voxel spacing
+    radius_voxel = max(radius / voxel_spacing, 1)
+    delta = int(np.ceil(radius_voxel))
+
+    # Paint each pick as a sphere
+    for point in pick.points:
+        # Convert the pick's location from angstroms to voxel units
+        cx, cy, cz = point.location.x / voxel_spacing, point.location.y / voxel_spacing, point.location.z / voxel_spacing
+
+        # Calculate subarray bounds
+        xLow, xHigh = get_relative_target_coordinates(cx, delta, seg_volume.shape[2])
+        yLow, yHigh = get_relative_target_coordinates(cy, delta, seg_volume.shape[1])
+        zLow, zHigh = get_relative_target_coordinates(cz, delta, seg_volume.shape[0])
+
+        # Subarray shape
+        subarray_shape = (zHigh - zLow, yHigh - yLow, xHigh - xLow)
+        if any(dim <= 0 for dim in subarray_shape):
+            continue
+
+        # Compute the local center of the sphere within the subarray
+        local_center = (cz - zLow, cy - yLow, cx - xLow)
+        sphere = create_sphere(subarray_shape, local_center, radius_voxel, label_value)
+
+        # Assign Sphere to Segmentation Target Volume
+        seg_volume[zLow:zHigh, yLow:yHigh, xLow:xHigh] = np.maximum(seg_volume[zLow:zHigh, yLow:yHigh, xLow:xHigh], sphere)
+
+    return seg_volume
+
+
+def downsample_to_exact_shape(array, target_shape):
+    """
+    Downsamples a 3D array to match the target shape using nearest-neighbor interpolation.
+    Ensures that the resulting array has the exact target shape.
+    """
+    zoom_factors = [t / s for t, s in zip(target_shape, array.shape)]
+    return zoom(array, zoom_factors, order=0)
+
+
+def segmentation_from_picks(radius, painting_segmentation_name, run, voxel_spacing, tomo_type, pickable_object, pick_set, user_id="paintedPicks", session_id="0"):
+    """
+    Paints picks from a run into a multiscale segmentation array, representing them as spheres in 3D space.
+
+    Parameters:
+    -----------
+    radius : float
+        Radius of the spheres in physical units.
+    painting_segmentation_name : str
+        The name of the segmentation dataset to be created or modified.
+    run : copick.Run
+        The current Copick run object.
+    voxel_spacing : float
+        The spacing of the voxels in the tomogram data.
+    tomo_type : str
+        The type of tomogram to retrieve.
+    pickable_object : copick.models.CopickObject
+        The object that defines the label value to be used in segmentation.
+    pick_set : copick.models.CopickPicks
+        The set of picks containing the locations to paint spheres.
+    user_id : str, optional
+        The ID of the user creating the segmentation. Default is "paintedPicks".
+    session_id : str, optional
+        The session ID for this segmentation. Default is "0".
+
+    Returns:
+    --------
+    copick.Segmentation
+        The created or modified segmentation object.
+    """
+    # Fetch the tomogram and determine its multiscale structure
+    tomogram = run.get_voxel_spacing(voxel_spacing).get_tomogram(tomo_type)
+    if not tomogram:
+        raise ValueError("Tomogram not found for the given parameters.")
+
+    # Use copick to create a new segmentation if one does not exist
+    segs = run.get_segmentations(user_id=user_id, session_id=session_id, is_multilabel=True, name=painting_segmentation_name, voxel_size=voxel_spacing)
+    if len(segs) == 0:
+        seg = run.new_segmentation(voxel_spacing, painting_segmentation_name, session_id, True, user_id=user_id)
+    else:
+        seg = segs[0]
+
+    segmentation_group = zarr.open(seg.zarr(), mode="a")
+    highest_res_name = "0"
+
+    # Get the highest resolution dimensions and create a new array if necessary
+    tomogram_zarr = zarr.open(tomogram.zarr(), "r")
+
+    highest_res_shape = tomogram_zarr[highest_res_name].shape
+    if highest_res_name not in segmentation_group:
+        segmentation_group.create(highest_res_name, shape=highest_res_shape, dtype=np.uint16, overwrite=True)
+
+    # Initialize or load the highest resolution array
+    highest_res_seg = segmentation_group[highest_res_name][:]
+    highest_res_seg.fill(0)
+
+    # Paint picks into the highest resolution array
+    highest_res_seg = from_picks(pick_set, highest_res_seg, radius, pickable_object.label, voxel_spacing)
+
+    # Write back the highest resolution data
+    segmentation_group[highest_res_name][:] = highest_res_seg
+
+    # Downsample to create lower resolution scales
+    multiscale_metadata = tomogram_zarr.attrs.get('multiscales', [{}])[0].get('datasets', [])
+    for level_index, level_metadata in enumerate(multiscale_metadata):
+        if level_index == 0:
+            continue
+
+        level_name = level_metadata.get("path", str(level_index))
+        expected_shape = tuple(tomogram_zarr[level_name].shape)
+
+        # Compute scaling factors relative to the highest resolution shape
+        scaled_array = downsample_to_exact_shape(highest_res_seg, expected_shape)
+
+        # Create/overwrite the Zarr array for this level
+        segmentation_group.create_dataset(level_name, shape=expected_shape, data=scaled_array, dtype=np.uint16, overwrite=True)
+
+        segmentation_group[level_name][:] = scaled_array
+
+    return seg

copick_utils-0.5.0/src/copick_utils/writers/write.py

@@ -0,0 +1,96 @@
+from typing import Any, Dict, List
+import numpy as np
+
+def tomogram(
+    run,
+    input_volume,
+    voxel_size=10,
+    algorithm="wbp"
+):
+    """
+    Writes a volumetric tomogram into an OME-Zarr format within a Copick directory.
+
+    Parameters:
+    -----------
+    run : copick.Run
+        The current Copick run object.
+    input_volume : np.ndarray
+        The volumetric tomogram data to be written.
+    voxel_size : float, optional
+        The size of the voxels in physical units. Default is 10.
+    algorithm : str, optional
+        The tomographic reconstruction algorithm to use. Default is 'wbp'.
+
+    Returns:
+    --------
+    copick.Tomogram
+        The created or modified tomogram object.
+    """
+    
+    # Retrieve or create voxel spacing
+    voxel_spacing = run.get_voxel_spacing(voxel_size)
+    if voxel_spacing is None:
+        voxel_spacing = run.new_voxel_spacing(voxel_size=voxel_size)
+    
+    # Check if We Need to Create a New Tomogram for Given Algorithm
+    tomogram = voxel_spacing.get_tomogram(algorithm)
+    if tomogram is None:
+        tomogram = voxel_spacing.new_tomogram(tomo_type=algorithm)
+    
+    # Write the tomogram data
+    tomogram.from_numpy(input_volume)
+
+
+def segmentation(
+    run,
+    segmentation_volume,
+    user_id,
+    name="segmentation",
+    session_id="0",
+    voxel_size=10,
+    multilabel=True
+):
+    """
+    Writes a segmentation into an OME-Zarr format within a Copick directory.
+
+    Parameters:
+    -----------
+    run : copick.Run
+        The current Copick run object.
+    segmentation_volume : np.ndarray
+        The segmentation data to be written.
+    user_id : str
+        The ID of the user creating the segmentation.
+    name : str, optional
+        The name of the segmentation dataset to be created or modified. Default is 'segmentation'.
+    session_id : str, optional
+        The session ID for this segmentation. Default is '0'.
+    voxel_size : float, optional
+        The size of the voxels in physical units. Default is 10.
+    multilabel : bool, optional
+        Whether the segmentation is a multilabel segmentation. Default is True.
+
+    Returns:
+    --------
+    copick.Segmentation
+        The created or modified segmentation object.
+    """
+    
+    # Retrieve or create a segmentation
+    segmentations = run.get_segmentations(name=name, user_id=user_id, session_id=session_id)
+
+    # If no segmentation exists or no segmentation at the given voxel size, create a new one
+    if len(segmentations) == 0 or any(seg.voxel_size != voxel_size for seg in segmentations):
+        segmentation = run.new_segmentation(
+            voxel_size=voxel_size,
+            name=name,
+            session_id=session_id,
+            is_multilabel=multilabel,
+            user_id=user_id
+        )
+    else:
+        # Overwrite the current segmentation at the specified voxel size if it exists
+        segmentation = next(seg for seg in segmentations if seg.voxel_size == voxel_size)
+    
+    # Write the segmentation data
+    segmentation.from_numpy(segmentation_volume, dtype=np.uint8)