copick-utils 1.0.1__tar.gz → 1.1.0__tar.gz

{copick_utils-1.0.1 → copick_utils-1.1.0}/.github/workflows/conventional-commits.yml

@@ -16,4 +16,4 @@ jobs:
   conventional_commit_title:
     runs-on: ubuntu-latest
     steps:
-      - uses: chanzuckerberg/github-actions/.github/actions/conventional-commits@v6.11.1
+      - uses: chanzuckerberg/github-actions/.github/actions/conventional-commits@v6.13.0

copick_utils-1.1.0/.release-please.manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.1.0"
+}

{copick_utils-1.0.1 → copick_utils-1.1.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [1.1.0](https://github.com/copick/copick-utils/compare/copick-utils-v1.0.2...copick-utils-v1.1.0) (2026-01-26)
+
+
+### ✨ Features
+
+* Add split command. ([#41](https://github.com/copick/copick-utils/issues/41)) ([479bf48](https://github.com/copick/copick-utils/commit/479bf48f9a50e3eb4066b3a41f2b399f110b2553))
+
+
+### 🐞 Bug Fixes
+
+* bump chanzuckerberg/github-actions from 6.12.2 to 6.13.0 ([#40](https://github.com/copick/copick-utils/issues/40)) ([68b21c1](https://github.com/copick/copick-utils/commit/68b21c175e2ca96946ceba9252b86c17e3382fe2))
+
+## [1.0.2](https://github.com/copick/copick-utils/compare/copick-utils-v1.0.1...copick-utils-v1.0.2) (2026-01-06)
+
+
+### 🐞 Bug Fixes
+
+* bump chanzuckerberg/github-actions from 6.11.1 to 6.12.2 ([#38](https://github.com/copick/copick-utils/issues/38)) ([42dcdaa](https://github.com/copick/copick-utils/commit/42dcdaa997ba927d0bff0c123e87920553736c8d))
+
 ## [1.0.1](https://github.com/copick/copick-utils/compare/copick-utils-v1.0.0...copick-utils-v1.0.1) (2025-12-03)
 
 

{copick_utils-1.0.1 → copick_utils-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: copick-utils
-Version: 1.0.1
+Version: 1.1.0
 Summary: Utilities for copick
 Project-URL: Repository, https://github.com/KyleHarrington/copick-utils.git
 Project-URL: Issues, https://github.com/KyleHarrington/copick-utils/issues

{copick_utils-1.0.1 → copick_utils-1.1.0}/pyproject.toml

@@ -76,6 +76,7 @@ skeletonize = "copick_utils.cli.processing_commands:skeletonize"
 fit_spline = "copick_utils.cli.processing_commands:fit_spline"
 validbox = "copick_utils.cli.processing_commands:validbox"
 hull = "copick_utils.cli.processing_commands:hull"
+split = "copick_utils.cli.processing_commands:split"
 
 [project.entry-points."copick.logical.commands"]
 meshop = "copick_utils.cli.logical_commands:meshop"

{copick_utils-1.0.1 → copick_utils-1.1.0}/src/copick_utils/__init__.py

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

{copick_utils-1.0.1 → copick_utils-1.1.0}/src/copick_utils/cli/processing_commands.py

@@ -5,6 +5,7 @@ from copick_utils.cli.fit_spline import fit_spline
 from copick_utils.cli.hull import hull
 from copick_utils.cli.separate_components import separate_components
 from copick_utils.cli.skeletonize import skeletonize
+from copick_utils.cli.split_labels import split
 from copick_utils.cli.validbox import validbox
 
 # All commands are now available for import by the main CLI
@@ -15,4 +16,5 @@ __all__ = [
     "separate_components",
     "filter_components",
     "fit_spline",
+    "split",
 ]

copick_utils-1.1.0/src/copick_utils/cli/split_labels.py

@@ -0,0 +1,148 @@
+"""CLI command for splitting multilabel segmentations into individual single-class segmentations."""
+
+import click
+import copick
+from click_option_group import optgroup
+from copick.cli.util import add_config_option, add_debug_option
+from copick.util.log import get_logger
+from copick.util.uri import parse_copick_uri
+
+from copick_utils.cli.util import add_input_option, add_workers_option
+
+
+@click.command(
+    context_settings={"show_default": True},
+    short_help="Split multilabel segmentations into single-class segmentations.",
+    no_args_is_help=True,
+)
+@add_config_option
+@optgroup.group("\nInput Options", help="Options related to the input segmentation.")
+@optgroup.option(
+    "--run-names",
+    "-r",
+    multiple=True,
+    help="Specific run names to process (default: all runs).",
+)
+@add_input_option("segmentation")
+@optgroup.group("\nTool Options", help="Options related to this tool.")
+@add_workers_option
+@optgroup.group("\nOutput Options", help="Options related to output segmentations.")
+@optgroup.option(
+    "--output-user-id",
+    type=str,
+    default="split",
+    help="User ID for output segmentations.",
+)
+@add_debug_option
+def split(
+    config,
+    run_names,
+    input_uri,
+    workers,
+    output_user_id,
+    debug,
+):
+    """
+    Split multilabel segmentations into individual single-class binary segmentations.
+
+    This command takes a multilabel segmentation and creates separate binary segmentations
+    for each label value. Each output segmentation is named after the corresponding
+    PickableObject (as defined in the copick config) and uses the same session ID as
+    the input.
+
+    \b
+    URI Format:
+        Segmentations: name:user_id/session_id@voxel_spacing
+
+    \b
+    Label-to-Object Mapping:
+        The tool looks up each label value in the pickable_objects configuration
+        and uses the object name for the output segmentation:
+        - Label 1 (ribosome) → ribosome:split/session-001@10.0
+        - Label 2 (membrane) → membrane:split/session-001@10.0
+        - Label 3 (proteasome) → proteasome:split/session-001@10.0
+
+    \b
+    Examples:
+        # Split multilabel segmentation (outputs named by pickable objects)
+        copick process split -i "predictions:model/run-001@10.0"
+
+        # Split with custom output user ID
+        copick process split -i "classes:annotator/manual@10.0" --output-user-id "per-class"
+
+        # Process specific runs only
+        copick process split -i "labels:*/*@10.0" --run-names TS_001 --run-names TS_002
+    """
+
+    logger = get_logger(__name__, debug=debug)
+
+    root = copick.from_file(config)
+    run_names_list = list(run_names) if run_names else None
+
+    # Parse input URI
+    try:
+        input_params = parse_copick_uri(input_uri, "segmentation")
+    except ValueError as e:
+        raise click.BadParameter(f"Invalid input URI: {e}") from e
+
+    segmentation_name = input_params["name"]
+    segmentation_user_id = input_params["user_id"]
+    segmentation_session_id = input_params["session_id"]
+    voxel_spacing = input_params.get("voxel_spacing")
+
+    if voxel_spacing is None or voxel_spacing == "*":
+        raise click.BadParameter("Input URI must include a specific voxel spacing (e.g., @10.0)")
+
+    # Check for patterns in critical fields
+    if "*" in segmentation_name or "*" in segmentation_user_id or "*" in segmentation_session_id:
+        raise click.BadParameter(
+            "Input URI cannot contain wildcards for splitting. "
+            "Please specify exact segmentation name, user_id, and session_id.",
+        )
+
+    logger.info(f"Splitting multilabel segmentation '{segmentation_name}'")
+    logger.debug(f"Input: {segmentation_user_id}/{segmentation_session_id} @ {voxel_spacing}Å")
+    logger.debug(f"Output user ID: {output_user_id}")
+    logger.debug(f"Workers: {workers}")
+
+    # Import batch function
+    from copick_utils.process.split_labels import split_labels_batch
+
+    # Process runs
+    results = split_labels_batch(
+        root=root,
+        segmentation_name=segmentation_name,
+        segmentation_user_id=segmentation_user_id,
+        segmentation_session_id=segmentation_session_id,
+        voxel_spacing=float(voxel_spacing),
+        output_user_id=output_user_id,
+        run_names=run_names_list,
+        workers=workers,
+    )
+
+    # Aggregate results
+    successful = sum(1 for result in results.values() if result and result.get("processed", 0) > 0)
+    total_labels = sum(result.get("labels_split", 0) for result in results.values() if result)
+
+    # Collect all unique object names created
+    all_object_names = set()
+    for result in results.values():
+        if result and result.get("object_names"):
+            all_object_names.update(result["object_names"])
+
+    # Collect all errors
+    all_errors = []
+    for result in results.values():
+        if result and result.get("errors"):
+            all_errors.extend(result["errors"])
+
+    logger.info(f"Completed: {successful}/{len(results)} runs processed successfully")
+    logger.info(f"Total labels split: {total_labels}")
+    logger.info(f"Object names created: {', '.join(sorted(all_object_names))}")
+
+    if all_errors:
+        logger.warning(f"Encountered {len(all_errors)} errors during processing")
+        for error in all_errors[:5]:  # Show first 5 errors
+            logger.warning(f"  - {error}")
+        if len(all_errors) > 5:
+            logger.warning(f"  ... and {len(all_errors) - 5} more errors")

{copick_utils-1.0.1 → copick_utils-1.1.0}/src/copick_utils/process/__init__.py

@@ -9,13 +9,11 @@ from .connected_components import (
 )
 from .skeletonize import (
     TubeSkeletonizer3D,
-    find_matching_segmentations,
     skeletonize_batch,
     skeletonize_segmentation,
 )
 from .spline_fitting import (
     SkeletonSplineFitter,
-    find_matching_segmentations_for_spline,
     fit_spline_batch,
     fit_spline_to_segmentation,
     fit_spline_to_skeleton,
@@ -34,12 +32,10 @@ __all__ = [
     "separate_components_batch",
     "TubeSkeletonizer3D",
     "skeletonize_segmentation",
-    "find_matching_segmentations",
     "skeletonize_batch",
     "SkeletonSplineFitter",
     "fit_spline_to_skeleton",
     "fit_spline_to_segmentation",
-    "find_matching_segmentations_for_spline",
     "fit_spline_batch",
     "create_validbox_mesh",
     "generate_validbox",

copick_utils-1.1.0/src/copick_utils/process/split_labels.py

@@ -0,0 +1,214 @@
+"""Split multilabel segmentations into individual single-class segmentations."""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+import numpy as np
+from copick.util.log import get_logger
+
+if TYPE_CHECKING:
+    from copick.models import CopickRoot, CopickRun, CopickSegmentation
+
+logger = get_logger(__name__)
+
+
+def split_multilabel_segmentation(
+    segmentation: "CopickSegmentation",
+    run: "CopickRun",
+    output_user_id: str = "split",
+) -> List["CopickSegmentation"]:
+    """
+    Split a multilabel segmentation into individual single-class binary segmentations.
+
+    For each label value in the multilabel segmentation, this function looks up the
+    corresponding PickableObject and creates a binary segmentation named after that object.
+
+    Args:
+        segmentation: Input multilabel segmentation to split
+        run: CopickRun object containing the segmentation
+        output_user_id: User ID for output segmentations (default: "split")
+
+    Returns:
+        List of created CopickSegmentation objects, one per label found in the input
+    """
+    # Load segmentation volume
+    volume = segmentation.numpy()
+    if volume is None:
+        raise ValueError("Could not load segmentation data")
+
+    if volume.size == 0:
+        raise ValueError("Empty segmentation data")
+
+    # Get root to access pickable objects configuration
+    root = run.root
+    voxel_size = segmentation.voxel_size
+    input_session_id = segmentation.session_id
+
+    # Find all unique non-zero labels
+    unique_labels = np.unique(volume)
+    unique_labels = unique_labels[unique_labels > 0]  # Skip background (0)
+
+    logger.debug(f"Found {len(unique_labels)} unique labels: {unique_labels.tolist()}")
+
+    output_segmentations = []
+
+    # Process each label
+    for label_value in unique_labels:
+        # Look up the PickableObject with this label
+        pickable_obj = next((obj for obj in root.config.pickable_objects if obj.label == label_value), None)
+
+        if pickable_obj is None:
+            logger.warning(f"No pickable object found for label {label_value}, using label value as name")
+            object_name = str(label_value)
+        else:
+            object_name = pickable_obj.name
+            logger.debug(f"Label {label_value} → object '{object_name}'")
+
+        # Create binary mask for this label
+        binary_mask = (volume == label_value).astype(np.uint8)
+        voxel_count = int(np.sum(binary_mask))
+
+        if voxel_count == 0:
+            logger.warning(f"Label {label_value} has no voxels, skipping")
+            continue
+
+        logger.debug(f"Creating segmentation for '{object_name}' with {voxel_count} voxels")
+
+        # Create output segmentation
+        try:
+            output_seg = run.new_segmentation(
+                name=object_name,
+                user_id=output_user_id,
+                session_id=input_session_id,
+                is_multilabel=False,
+                voxel_size=voxel_size,
+                exist_ok=True,
+            )
+
+            # Store the binary mask
+            output_seg.from_numpy(binary_mask)
+            output_segmentations.append(output_seg)
+
+            logger.debug(f"Successfully created segmentation '{object_name}:{output_user_id}/{input_session_id}'")
+
+        except Exception as e:
+            logger.exception(f"Failed to create segmentation for label {label_value} ('{object_name}'): {e}")
+            continue
+
+    # Log single-line summary
+    if output_segmentations:
+        object_names = [seg.name for seg in output_segmentations]
+        logger.info(f"Run '{run.name}': Split {len(output_segmentations)} labels → {', '.join(object_names)}")
+
+    return output_segmentations
+
+
+def _split_labels_worker(
+    run: "CopickRun",
+    segmentation_name: str,
+    segmentation_user_id: str,
+    segmentation_session_id: str,
+    voxel_spacing: float,
+    output_user_id: str,
+) -> Dict[str, Any]:
+    """
+    Worker function for batch splitting of multilabel segmentations.
+
+    Args:
+        run: CopickRun to process
+        segmentation_name: Name of the input segmentation
+        segmentation_user_id: User ID of the input segmentation
+        segmentation_session_id: Session ID of the input segmentation
+        voxel_spacing: Voxel spacing of the segmentation
+        output_user_id: User ID for output segmentations
+
+    Returns:
+        Dictionary with processing results and statistics
+    """
+    try:
+        # Get the input segmentation
+        segmentations = run.get_segmentations(
+            name=segmentation_name,
+            user_id=segmentation_user_id,
+            session_id=segmentation_session_id,
+            voxel_size=voxel_spacing,
+            is_multilabel=True,
+        )
+
+        if not segmentations:
+            return {"processed": 0, "errors": [f"No multilabel segmentation found for run {run.name}"]}
+
+        segmentation = segmentations[0]
+
+        # Verify it's multilabel
+        if not segmentation.is_multilabel:
+            return {
+                "processed": 0,
+                "errors": [f"Segmentation in run {run.name} is not multilabel (is_multilabel=False)"],
+            }
+
+        # Split the segmentation
+        output_segmentations = split_multilabel_segmentation(
+            segmentation=segmentation,
+            run=run,
+            output_user_id=output_user_id,
+        )
+
+        # Collect object names created
+        object_names = [seg.name for seg in output_segmentations]
+
+        return {
+            "processed": 1,
+            "errors": [],
+            "labels_split": len(output_segmentations),
+            "object_names": object_names,
+        }
+
+    except Exception as e:
+        logger.exception(f"Error processing run {run.name}: {e}")
+        return {"processed": 0, "errors": [f"Error processing run {run.name}: {e}"]}
+
+
+def split_labels_batch(
+    root: "CopickRoot",
+    segmentation_name: str,
+    segmentation_user_id: str,
+    segmentation_session_id: str,
+    voxel_spacing: float,
+    output_user_id: str = "split",
+    run_names: Optional[List[str]] = None,
+    workers: int = 8,
+) -> Dict[str, Any]:
+    """
+    Batch split multilabel segmentations across multiple runs.
+
+    Args:
+        root: The copick root containing runs to process
+        segmentation_name: Name of the input segmentation
+        segmentation_user_id: User ID of the input segmentation
+        segmentation_session_id: Session ID of the input segmentation
+        voxel_spacing: Voxel spacing in angstroms
+        output_user_id: User ID for output segmentations (default: "split")
+        run_names: List of run names to process. If None, processes all runs.
+        workers: Number of worker processes (default: 8)
+
+    Returns:
+        Dictionary with processing results and statistics per run
+    """
+    from copick.ops.run import map_runs
+
+    runs_to_process = [run.name for run in root.runs] if run_names is None else run_names
+
+    results = map_runs(
+        callback=_split_labels_worker,
+        root=root,
+        runs=runs_to_process,
+        workers=workers,
+        task_desc="Splitting multilabel segmentations",
+        segmentation_name=segmentation_name,
+        segmentation_user_id=segmentation_user_id,
+        segmentation_session_id=segmentation_session_id,
+        voxel_spacing=voxel_spacing,
+        output_user_id=output_user_id,
+    )
+
+    return results

copick_utils-1.0.1/.release-please.manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.0.1"
-}