copick-utils 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

copick_utils/__init__.py

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

copick_utils/cli/download.py

@@ -0,0 +1,34 @@
+import click
+
+
+@click.command(
+    context_settings={"show_default": True},
+    short_help="Download tilt series and alignments from the CryoET Data Portal.",
+    no_args_is_help=True,
+)
+@click.option(
+    "-ds",
+    "--dataset",
+    required=True,
+    type=str,
+    help="Dataset ID to download from the CryoET Data Portal.",
+)
+@click.option(
+    "-o",
+    "--output",
+    required=True,
+    default=".",
+    type=str,
+    help="Output directory to save the downloaded files.",
+)
+def project(dataset: str, output: str):
+    """
+    Download tilt series and alignments from the CryoET Data Portal for sub-tomogram averaging with py2rely.
+    """
+    download_project(dataset, output)
+
+
+def download_project(dataset: str, output: str):
+    import copick_utils.io.portal as portal
+
+    portal.download_aretomo_files(dataset, output)

copick_utils/cli/download_commands.py

@@ -0,0 +1,11 @@
+"""CLI commands for downloading data from the CryoET Data Portal.
+
+This module imports all download commands from specialized files for better organization.
+"""
+
+from copick_utils.cli.download import project
+
+# All commands are now available for import by the main CLI
+__all__ = [
+    "project",
+]

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/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/io/portal.py

@@ -0,0 +1,149 @@
+"""
+A minimal example using minimal libraries / imports to download relevant AreTomo files
+from the CryoET Data Portal. Downloads the corresponding files, using the run ID as the
+base filename.
+
+Original implementation by Daniel Ji and Utz Ermel.
+"""
+import multiprocessing
+import os
+
+import cryoet_data_portal as cdp
+import mdocfile
+import numpy as np
+import pandas as pd
+import requests
+import s3fs
+
+global_client = cdp.Client()
+
+
+def download_aretomo_files(dataset_id: int, output_dir: str):
+    print(f"Fetching tiltseries for dataset id {dataset_id}...", flush=True)
+    tiltseries_list: list[cdp.TiltSeries] = [
+        tiltseries for run in cdp.Dataset.get_by_id(global_client, dataset_id).runs for tiltseries in run.tiltseries
+    ]  # a bit slow for some reason, can take some time
+    tiltseries_run_ids_and_ts_ids = [(ts.run.id, ts.id) for ts in tiltseries_list]
+    print(
+        f"Found {len(tiltseries_run_ids_and_ts_ids)} tiltseries for dataset id {dataset_id}. Starting downloads...",
+        flush=True,
+    )
+    with multiprocessing.Pool(processes=8) as pool:  # adjust number of processes as needed
+        for _ in pool.imap_unordered(
+            _worker_download_aretomo_files_for_tiltseries,
+            [
+                (dataset_id, run_name, output_dir, tiltseries_id)
+                for run_name, tiltseries_id in tiltseries_run_ids_and_ts_ids
+            ],
+        ):
+            pass
+
+
+def _worker_download_aretomo_files_for_tiltseries(args):
+    dataset_id, run_name, output_dir, tiltseries_id = args
+    download_aretomo_files_for_tiltseries(dataset_id, run_name, output_dir, tiltseries_id)
+
+
+# note: this function assumes that there is only one tiltseries per run
+# note: the tiltseries name is equivlaent to the run name
+# if tiltseries_id is provided, will be prioritized over dataset_id + run_name
+def download_aretomo_files_for_tiltseries(dataset_id: int, run_name: str, output_dir: str, tiltseries_id: int = None):
+    print(f"[{run_name}] Downloading AreTomo files for tiltseries id {tiltseries_id}...", flush=True)
+
+    client = cdp.Client()
+    s3 = s3fs.S3FileSystem(anon=True)
+    if not tiltseries_id:
+        all_tiltseries = cdp.TiltSeries.find(
+            client,
+            query_filters=[cdp.TiltSeries.run.dataset_id == dataset_id, cdp.TiltSeries.run.name == run_name],
+        )
+        if len(all_tiltseries) == 0:
+            raise ValueError(f"No tiltseries found for dataset_id {dataset_id} and run_name {run_name}")
+        if len(all_tiltseries) > 1:
+            raise ValueError(f"Multiple tiltseries found for dataset_id {dataset_id} and run_name {run_name}")
+        tiltseries = all_tiltseries[0]
+    else:
+        tiltseries = cdp.TiltSeries.get_by_id(client, tiltseries_id)
+
+    # get the s3 folder path and then glob for *.tlt / *.rawtlt files to download them, renaming the base to match the run id
+    s3_folder_path = tiltseries.s3_mrc_file.rsplit("/", 1)[0] + "/"
+    tlt_files = s3.glob(s3_folder_path + "*.tlt") + s3.glob(s3_folder_path + "*.rawtlt")
+    for tlt_file in tlt_files:
+        base_name = os.path.basename(tlt_file)
+        ext = os.path.splitext(base_name)[1]
+        dest_file = os.path.join(output_dir, f"{tiltseries.run.id}{ext}")
+        s3.get(tlt_file, dest_file)
+        print(f"[{tiltseries.run.id}] Downloaded {base_name} as {os.path.basename(dest_file)}.", flush=True)
+
+    # do the same for "*CTF*.txt" files and "*ctf*.txt" files
+    ctf_files = s3.glob(s3_folder_path + "*CTF*.txt") + s3.glob(s3_folder_path + "*ctf*.txt")
+    if len(ctf_files) == 0:
+        print(f"WARNING: No CTF files found for tiltseries id {tiltseries.id}")
+    else:
+        ctf_file = ctf_files[0]
+        base_name = os.path.basename(ctf_file)
+        if len(ctf_files) > 1:
+            print(f"WARNING: Multiple CTF files found for tiltseries id {tiltseries.id}, using {base_name}")
+        ext = os.path.splitext(base_name)[1]
+        dest_file = os.path.join(output_dir, f"{tiltseries.run.id}_CTF.txt")
+        s3.get(ctf_file, dest_file)
+        print(f"[{tiltseries.run.id}] Downloaded {base_name} as {os.path.basename(dest_file)}.", flush=True)
+
+    # now find the corresponding alignment for this tiltseries and download the "*.aln" file
+    if len(tiltseries.alignments) == 0:
+        print(f"WARNING: No alignments found for tiltseries id {tiltseries.id}")
+    elif len(tiltseries.alignments) > 1:
+        print(f"WARNING: Multiple alignments found for tiltseries id {tiltseries.id}")
+    else:
+        alignment = tiltseries.alignments[0]
+        s3_alignment_folder_path = alignment.s3_alignment_metadata.rsplit("/", 1)[0] + "/"
+        aln_files = s3.glob(s3_alignment_folder_path + "*.aln")
+        if len(aln_files) == 0:
+            raise ValueError(f"No .aln files found for run name {tiltseries.run.name} and alignment id {alignment.id}")
+        aln_file = aln_files[0]
+        base_name = os.path.basename(aln_file)
+        if len(aln_files) > 1:
+            print(f"WARNING: Multiple .aln files found for run name {tiltseries.run.name}, using {base_name}")
+        ext = os.path.splitext(base_name)[1]
+        dest_file = os.path.join(output_dir, f"{tiltseries.run.id}{ext}")
+        s3.get(aln_file, dest_file)
+        print(f"[{tiltseries.run.id}] Downloaded {base_name} as {os.path.basename(dest_file)}.", flush=True)
+
+    # now get the mdoc file from the Frames/ folder
+    frames = tiltseries.run.frames
+    if len(frames) == 0:
+        raise ValueError(f"No frames found for run name {tiltseries.run.name}")
+    frame = frames[0]
+    s3_frames_folder_path = frame.s3_frame_path.rsplit("/", 1)[0] + "/"
+    mdoc_files = s3.glob(s3_frames_folder_path + "*.mdoc")
+    if len(mdoc_files) == 0:
+        raise ValueError(f"No .mdoc files found for run name {tiltseries.run.name}")
+    mdoc_file = mdoc_files[0]
+    base_name = os.path.basename(mdoc_file)
+    if len(mdoc_files) > 1:
+        print(f"WARNING: Multiple .mdoc files found for run name {tiltseries.run.name}, using {base_name}")
+    ext = os.path.splitext(base_name)[1]
+    dest_file = os.path.join(output_dir, f"{tiltseries.run.id}{ext}")
+    s3.get(mdoc_file, dest_file)
+    print(f"[{tiltseries.run.id}] Downloaded {base_name} as {os.path.basename(dest_file)}.", flush=True)
+
+    # download tiltseries mrc file
+    tiltseries_file = os.path.join(output_dir, f"{tiltseries.run.id}.mrc")
+    tiltseries_url = tiltseries.https_mrc_file
+    response = requests.get(tiltseries_url, stream=True)
+    response.raise_for_status()
+    with open(tiltseries_file, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            f.write(chunk)
+    print(f"[{tiltseries.run.id}] Downloaded tiltseries mrc file as {os.path.basename(tiltseries_file)}.", flush=True)
+
+    # create imod file for order list
+    mdoc = mdocfile.read(os.path.join(output_dir, f"{tiltseries.run.id}.mdoc"))
+    order_list = mdoc["TiltAngle"]
+    imodpath = os.path.join(output_dir, f"{tiltseries.run.id}_Imod")
+    os.makedirs(imodpath, exist_ok=True)
+    number = np.arange(len(order_list)) + 1
+
+    # save in csv with 'ImageNumber', 'TiltAngle' headers
+    df = pd.DataFrame({"ImageNumber": number, "TiltAngle": order_list})
+    df.to_csv(os.path.join(imodpath, f"{tiltseries.run.id}_order_list.csv"), index=False)

copick_utils/io/readers.py

@@ -1,82 +1,125 @@
 import numpy as np
-
-
-def tomogram(run, voxel_size: float = 10, algorithm: str = "wbp", raise_error: bool = False):
-    voxel_spacing_obj = run.get_voxel_spacing(voxel_size)
-
-    if voxel_spacing_obj is None:
-        # Query Avaiable Voxel Spacings
-        availableVoxelSpacings = [tomo.voxel_size for tomo in run.voxel_spacings]
-
-        # Report to the user which voxel spacings they can use
-        message = (
-            f"[Warning] No tomogram found for {run.name} with voxel size {voxel_size} and tomogram type {algorithm}"
-            f"Available spacings are: {', '.join(map(str, availableVoxelSpacings))}"
-        )
-        if raise_error:
-            raise ValueError(message)
-        else:
-            print(message)
+from copick.util.uri import resolve_copick_objects
+
+
+def tomogram(run, voxel_size: float = 10, algorithm: str = "wbp", raise_error: bool = False, verbose=True):
+    """
+    Reads a tomogram from a Copick run.
+
+    Parameters:
+    -----------
+    run: copick.Run
+    voxel_size: float
+    algorithm: str
+    raise_error: bool
+    verbose: bool
+    Returns:
+    --------
+    vol: np.ndarray - The tomogram.
+    """
+
+    # Get the tomogram from the Copick URI
+    try:
+        uri = f"{algorithm}@{voxel_size}"
+        vol = resolve_copick_objects(uri, run.root, "tomogram", run_name=run.name)
+        return vol[0].numpy()
+    except Exception as err:  # Report which orbject is missing
+        # Try to resolve the tomogram using the Copick URI
+        voxel_spacing_obj = run.get_voxel_spacing(voxel_size)
+
+        if voxel_spacing_obj is None:
+            # Query Avaiable Voxel Spacings
+            availableVoxelSpacings = [tomo.voxel_size for tomo in run.voxel_spacings]
+
+            # Report to the user which voxel spacings they can use
+            message = (
+                f"[Warning] No tomogram found for {run.name} with uri: {uri}\n"
+                f"Available voxel sizes are: {', '.join(map(str, availableVoxelSpacings))}"
+            )
+            if raise_error:
+                raise ValueError(message) from err
+            elif verbose:
+                print(message)
             return None
 
-    tomogram = voxel_spacing_obj.get_tomogram(algorithm)
-    if tomogram is None:
-        # Get available algorithms
-        availableAlgorithms = [tomo.tomo_type for tomo in run.get_voxel_spacing(voxel_size).tomograms]
-
-        # Report to the user which algorithms are available
-        message = (
-            f"[Warning] No tomogram found for {run.name} with voxel size {voxel_size} and tomogram type {algorithm}"
-            f"Available algorithms are: {', '.join(availableAlgorithms)}"
-        )
-        if raise_error:
-            raise ValueError(message)
-        else:
-            print(message)
+        tomogram = voxel_spacing_obj.get_tomogram(algorithm)
+        if tomogram is None:
+            # Get available algorithms
+            availableAlgorithms = [tomo.tomo_type for tomo in run.get_voxel_spacing(voxel_size).tomograms]
+
+            # Report to the user which algorithms are available
+            message = (
+                f"[Warning] No tomogram found for {run.name} with uri: {uri}\n"
+                f"Available algorithms @{voxel_size}A are: {', '.join(availableAlgorithms)}"
+            )
+            if raise_error:
+                raise ValueError(message) from err
+            elif verbose:
+                print(message)
             return None
 
-    return tomogram.numpy()
 
+def segmentation(run, voxel_spacing: float, name: str, user_id=None, session_id=None, raise_error=False, verbose=True):
+    """
+    Reads a segmentation from a Copick run.
+
+    Parameters:
+    -----------
+    run: copick.Run
+    voxel_spacing: float
+    name: str
+    user_id: str
+    session_id: str
+    raise_error: bool
+    verbose: bool
+    Returns:
+    --------
+    seg: np.ndarray - The segmentation.
+    """
+
+    # Construct the Target URI
+    if session_id is None and user_id is None:
+        uri = f"{name}@{voxel_spacing}"
+    elif session_id is None:
+        uri = f"{name}:{user_id}@{voxel_spacing}"
+    else:
+        uri = f"{name}:{user_id}/{session_id}@{voxel_spacing}"
+
+    # Try to resolve the segmentation using the Copick URI
+    try:
+        segs = resolve_copick_objects(uri, run.root, "segmentation", run_name=run.name)
+        return segs[0].numpy()
+    except Exception as err:
+        # Force the voxel spacing to be a float
+        voxel_spacing = float(voxel_spacing)
 
-def segmentation(run, voxel_spacing: float, segmentation_name: str, session_id=None, user_id=None, raise_error=False):
-    seg = run.get_segmentations(
-        name=segmentation_name,
-        session_id=session_id,
-        user_id=user_id,
-        voxel_size=voxel_spacing,
-    )
-
-    # No Segmentations Are Available, Result in Error
-    if len(seg) == 0:
         # Get all available segmentations with their metadata
         available_segs = run.get_segmentations(voxel_size=voxel_spacing)
-        seg_info = [(s.name, s.user_id, s.session_id) for s in available_segs]
 
-        # Format the information for display
-        seg_details = [f"(name: {name}, user_id: {uid}, session_id: {sid})" for name, uid, sid in seg_info]
+        if len(available_segs) == 0:
+            available_segs = run.get_segmentations()
+            message = (
+                f"No segmentation found for URI: {uri}\n"
+                f"Available segmentations avaiable w/following voxel sizes: {', '.join(map(str, [s.voxel_size for s in available_segs]))}"
+            )
+        else:
+            seg_info = [(s.name, s.user_id, s.session_id) for s in available_segs]
 
-        message = (
-            f"\nNo segmentation found matching:\n"
-            f"  name: {segmentation_name}, user_id: {user_id}, session_id: {session_id}\n"
-            f"Available segmentations in {run.name} are:\n  " + "\n  ".join(seg_details)
-        )
+            # Format the information for display
+            seg_details = [f"(name: {name}, user_id: {uid}, session_id: {sid})" for name, uid, sid in seg_info]
+
+            message = (
+                f"\nNo segmentation at {voxel_spacing} A found matching:\n"
+                f"  name: {name}, user_id: {user_id}, session_id: {session_id}\n"
+                f"Available segmentations in {run.name} are:\n  " + "\n  ".join(seg_details)
+            )
         if raise_error:
-            raise ValueError(message)
-        else:
+            raise ValueError(message) from err
+        elif verbose:
             print(message)
+        else:
             return None
 
-    # No Segmentations Are Available, Result in Error
-    if len(seg) > 1:
-        print(
-            f"[Warning] More Than 1 Segmentation is Available for the Query Information. "
-            f"Available Segmentations are: {seg} "
-            f"Defaulting to Loading: {seg[0]}\n",
-        )
-    seg = seg[0]
-
-    return seg.numpy()
-
 
 def coordinates(
     run,  # CoPick run object containing the segmentation data
@@ -85,7 +128,25 @@ def coordinates(
     session_id: str = None,  # Identifier of the session that generated the picks
     voxel_size: float = 10,  # Voxel size of the tomogram, used for scaling the coordinates
     raise_error: bool = False,
+    verbose: bool = True,
 ):
+    """
+    Reads the coordinates of the picks from a Copick run.
+
+    Parameters:
+    -----------
+    run: copick.Run
+    name: str
+    user_id: str
+    session_id: str
+    voxel_size: float
+    raise_error: bool
+    verbose: bool
+
+    Returns:
+    --------
+    coordinates: np.ndarray - The 3D coordinates of the picks in voxel space.
+    """
     # Retrieve the pick points associated with the specified object and user ID
     picks = run.get_picks(object_name=name, user_id=user_id, session_id=session_id)
 
@@ -105,18 +166,22 @@ def coordinates(
         )
         if raise_error:
             raise ValueError(message)
-        else:
+        elif verbose:
             print(message)
-            return None
+        return None
+
     elif len(picks) > 1:
         # Format pick information for display
         picks_info = [(p.pickable_object_name, p.user_id, p.session_id) for p in picks]
         picks_details = [f"(name: {name}, user_id: {uid}, session_id: {sid})" for name, uid, sid in picks_info]
 
-        print(
-            "[Warning] More than 1 pick is available for the query information."
-            "\nAvailable picks are:\n  " + "\n  ".join(picks_details) + f"\nDefaulting to loading:\n {picks[0]}\n",
-        )
+        if verbose:
+            print(
+                "[Warning] More than 1 pick is available for the query information."
+                "\nAvailable picks are:\n  " + "\n  ".join(picks_details) + f"\n"
+                f"Defaulting to loading:\n {picks[0]}\n",
+            )
+
     points = picks[0].points
 
     # Initialize an array to store the coordinates

copick_utils/io/writers.py

@@ -28,17 +28,17 @@ def tomogram(run, input_volume, voxel_size=10, algorithm="wbp"):
         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)
+    tomo = voxel_spacing.get_tomogram(algorithm)
+    if tomo is None:
+        tomo = voxel_spacing.new_tomogram(tomo_type=algorithm)
 
     # Write the tomogram data
-    tomogram.from_numpy(input_volume)
+    tomo.from_numpy(input_volume)
 
 
 def segmentation(
     run,
-    segmentation_volume,
+    seg_vol,
     user_id,
     name="segmentation",
     session_id="0",
@@ -52,7 +52,7 @@ def segmentation(
     -----------
     run : copick.Run
         The current Copick run object.
-    segmentation_volume : np.ndarray
+    seg_vol : np.ndarray
         The segmentation data to be written.
     user_id : str
         The ID of the user creating the segmentation.
@@ -76,7 +76,7 @@ def segmentation(
 
     # 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(
+        seg = run.new_segmentation(
             voxel_size=voxel_size,
             name=name,
             session_id=session_id,
@@ -85,7 +85,7 @@ def segmentation(
         )
     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)
+        seg = next(seg for seg in segmentations if seg.voxel_size == voxel_size)
 
     # Write the segmentation data
-    segmentation.from_numpy(segmentation_volume, dtype=np.uint8)
+    seg.from_numpy(seg_vol, dtype=np.uint8)

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/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.2.dist-info → copick_utils-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: copick-utils
-Version: 1.0.2
+Version: 1.2.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
@@ -33,6 +33,7 @@ Requires-Dist: click-option-group
 Requires-Dist: copick>=1.16.0
 Requires-Dist: manifold3d
 Requires-Dist: mapbox-earcut
+Requires-Dist: mdocfile
 Requires-Dist: numpy
 Requires-Dist: rtree
 Requires-Dist: scikit-image

{copick_utils-1.0.2.dist-info → copick_utils-1.2.0.dist-info}/RECORD

@@ -1,9 +1,11 @@
-copick_utils/__init__.py,sha256=KV4Of88sktfBOKjUJLLuaknxcX88-X8dHO3hfmY1TKQ,135
+copick_utils/__init__.py,sha256=XY1t2MuZi-EFIR_wNRRTMCYSR3FyJStb4E0oxUyQoA8,135
 copick_utils/cli/__init__.py,sha256=51i1xC-N2laWLdZLdpsKMSB9LdO3BEdqDdWIbyxJ8f0,634
 copick_utils/cli/clipmesh.py,sha256=M1MP8lw16diGHajipFXbZDQ4ZrsTvFiqAaHji0Smmtc,6172
 copick_utils/cli/clippicks.py,sha256=7lmEZj8GDyVqc9l_rvGhAFTYWUhSEnwZcWu8w9LStBU,5857
 copick_utils/cli/clipseg.py,sha256=atx01VUBdk5xLSwEHh43bN7HEKV2bjVgDmaNaLwJQ5E,6437
 copick_utils/cli/conversion_commands.py,sha256=7I729S_9R7l67NzwfKaEWZAxcq0NbBhflZHKxTXaZhk,1045
+copick_utils/cli/download.py,sha256=mwGlfpHHOIcGWRKCwfNrOs97udsAv8dvOh2d9-If7Bc,831
+copick_utils/cli/download_commands.py,sha256=XgDyoXAA79c0w30HuUWQEucmVH73YpOIjsnkYnUN7Es,298
 copick_utils/cli/enclosed.py,sha256=gsJxapWCqH4IOMDyTTd_akv4L1qzuBfbRJEDBES6Wik,7209
 copick_utils/cli/filter_components.py,sha256=hOs8h0648Ws-rzVxTh7w8Futjk4aEOpavoqrJMvr-2Q,6163
 copick_utils/cli/fit_spline.py,sha256=BdLujzR9sen6IGlmZ9pGbhqs6Kjzk5MuAgmq3ewyMhk,6491
@@ -21,12 +23,13 @@ copick_utils/cli/picks2sphere.py,sha256=P-xFFDJdEowxHF20aLMO2Xymv7VHAaP4paBbgPWe
 copick_utils/cli/picks2surface.py,sha256=vXprZa3tHndSE3Sp1yPOEqyv2kRkAbV7QlHjF8oE1zg,5712
 copick_utils/cli/picksin.py,sha256=SD32-BJoxB2dGQU54ksuq2rCmcGjnQLldE0hrnV8pLA,5485
 copick_utils/cli/picksout.py,sha256=odm2JeTyDzBrXkr2SCsbE3REGj589bCgPOq3ldj8soA,5568
-copick_utils/cli/processing_commands.py,sha256=s9Mn0mvKQ60XQN6o6eyO2x7qZX_Hpq0K3kPwMuLHlKY,576
+copick_utils/cli/processing_commands.py,sha256=3-zZhyM279_mQB8Z4-XM0DDowF8YK3i5cFOhUaw7MOM,637
 copick_utils/cli/seg2mesh.py,sha256=9fv3zaVHxAS4VhhlvU6qJ7W7wWjAYDedzDNeiaMZxTk,4732
 copick_utils/cli/seg2picks.py,sha256=05RUsOJETnOc9zMmW_x3DVr1t2F01w2e2R8sAaJrHg8,4549
 copick_utils/cli/segop.py,sha256=K_ju0MB4n-k5-wkOI7gOvkHCUslgHZCZUOFn-k2ta9M,9372
 copick_utils/cli/separate_components.py,sha256=m0c5v4ZXSeoUURcVoY7jCE6I_jGbTdZXqEoLUiURIHs,5670
 copick_utils/cli/skeletonize.py,sha256=CV_J9nibqLpKmckNRG6-7zlq6ROqPBLk166yDzhxJ5w,5646
+copick_utils/cli/split_labels.py,sha256=J09-qAPLtzcmid6yln37zu9HwVRYz8wLzJ6PvHWgEgU,5443
 copick_utils/cli/util.py,sha256=tne45hU9dL0AepQhV9KKqkKjAMAfweR9_GLGHJnisnc,18011
 copick_utils/cli/validbox.py,sha256=Z-HY73QnWwxL-cLHLiIWNnYz4t-4jf63ho8pfk38xXU,5364
 copick_utils/converters/__init__.py,sha256=f3_UJJ2jJqkOAaEy6y4i3x1baFZEem9aTrGGdBQgXFQ,1701
@@ -45,8 +48,9 @@ copick_utils/converters/surface_from_picks.py,sha256=PHRVtdaDikygT3kmTJKUnw2Gvj_
 copick_utils/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 copick_utils/features/skimage.py,sha256=Sz-348tTT44lLS825z14iIOM3L_tALXQctUF1HbnWnw,4209
 copick_utils/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-copick_utils/io/readers.py,sha256=bE7IBPohNjsFgD6HRPTrWte6OjaJ0NrF4RS8Dwgf3nA,5435
-copick_utils/io/writers.py,sha256=iYyNkpBgrD0_N0N-LoyCOfIrk46WHWocKvkUUQYXMRg,2985
+copick_utils/io/portal.py,sha256=fqk0ihdrkM8ayc5tfG5EIleYqKC-JehxL88TcYNySq8,7264
+copick_utils/io/readers.py,sha256=Ll1NPEasPbddQK-oE7XIBC2EV15VuzGeK-V2oApl9Cg,7278
+copick_utils/io/writers.py,sha256=mv34fLZLKa4q5cBJ2pP1tenwDz8qWoahk0suCcpsK-w,2906
 copick_utils/logical/__init__.py,sha256=coOdLd7vH6TCsoHj9T1Hj5hqnfiGM5CrVkmjVB-HdbM,1181
 copick_utils/logical/distance_operations.py,sha256=cVn8YywwrgNEaKJxnZ6KbsJwwx7fJ2VDDaUEgat0b9A,24071
 copick_utils/logical/enclosed_operations.py,sha256=f388K37vS4wCN5D0FL5lnvO29pd23pmC0LlXhNuNsS0,8583
@@ -55,17 +59,18 @@ copick_utils/logical/point_operations.py,sha256=a2KrTqSuXeb-GNvFywN7iDuATkTDsSz0
 copick_utils/logical/segmentation_operations.py,sha256=AlPHq3t7Hw46svW6qBnr3i1PPulcNvDNikoYD7_RnrI,12090
 copick_utils/pickers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 copick_utils/pickers/grid_picker.py,sha256=KKfdv3fDmeY7XwqiVADRQJibr1eyjYoG9ZpaihcrgHw,2345
-copick_utils/process/__init__.py,sha256=ERh5Ka4vU0_ub4_UZFDWOXbr-my79s3RekfS9dV41wE,1227
+copick_utils/process/__init__.py,sha256=lbjTjGxGQZdQgzt_ommpmCwety6tIWtGRp7tKzzAuDk,1069
 copick_utils/process/connected_components.py,sha256=9h_Feu3wxYWW84evaUmW73_UY0fGmTszS55R8oljjEo,13601
 copick_utils/process/filter_components.py,sha256=dU0l0PJ6ZejY6ANqsrDRtQ1RevdKWn6Txl4nr0sBq14,10587
 copick_utils/process/hull.py,sha256=tLah4_fcwIuiy9Kaly5sVVDHltGBh6euyO3i9W99pms,3191
 copick_utils/process/skeletonize.py,sha256=gLQgQdYlyuqFHyC19vzx8-gna15UiAM_1i85hF-mkMg,11713
 copick_utils/process/spline_fitting.py,sha256=6pBr4w7cKZb5xaKaU3b1R5A6cIVDrCTRKTVVUL4vDSI,25025
+copick_utils/process/split_labels.py,sha256=5BZw4gzh57_4DgmYErwSwjWzBJKkiYbf3qu4On2MvCU,7352
 copick_utils/process/validbox.py,sha256=5uEbVjmyNJxp__2XJal1jP7Ecpqv2uZsBkAy26zpxx8,9494
 copick_utils/util/__init__.py,sha256=V76KYVdhERpiXkCsaap4WQBbvfXG04x3vGvdSayzpmk,190
 copick_utils/util/config_models.py,sha256=vzih8OsmvKQk8rULYyY6f6yiRHUnk48KKrCES5Pvq4w,21964
-copick_utils-1.0.2.dist-info/METADATA,sha256=D0LJF7w4_FX3kByXK8ee_Qn10sDSNgSZpBYZ47xrcaw,4562
-copick_utils-1.0.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-copick_utils-1.0.2.dist-info/entry_points.txt,sha256=qDi4JAAncjmkB86tEivSpc9QVr6YbdFC3T0SwIabNaM,1504
-copick_utils-1.0.2.dist-info/licenses/LICENSE,sha256=3UHKsYd99Gh_qf1a9s8G5sdKqafgbGs5WIMoeX0OcdY,1105
-copick_utils-1.0.2.dist-info/RECORD,,
+copick_utils-1.2.0.dist-info/METADATA,sha256=90qt-hq06uei8nx3nEIa8sGHpimmm59xcYJqBQMJ2fI,4586
+copick_utils-1.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+copick_utils-1.2.0.dist-info/entry_points.txt,sha256=Vve0xfXIa463rKfI6ELKATtHzacLxNvgWffyLkYIrzQ,1636
+copick_utils-1.2.0.dist-info/licenses/LICENSE,sha256=3UHKsYd99Gh_qf1a9s8G5sdKqafgbGs5WIMoeX0OcdY,1105
+copick_utils-1.2.0.dist-info/RECORD,,

{copick_utils-1.0.2.dist-info → copick_utils-1.2.0.dist-info}/entry_points.txt

@@ -10,6 +10,9 @@ picks2surface = copick_utils.cli.conversion_commands:picks2surface
 seg2mesh = copick_utils.cli.conversion_commands:seg2mesh
 seg2picks = copick_utils.cli.conversion_commands:seg2picks
 
+[copick.download.commands]
+project = copick_utils.cli.download_commands:project
+
 [copick.logical.commands]
 clipmesh = copick_utils.cli.logical_commands:clipmesh
 clippicks = copick_utils.cli.logical_commands:clippicks
@@ -26,4 +29,5 @@ fit_spline = copick_utils.cli.processing_commands:fit_spline
 hull = copick_utils.cli.processing_commands:hull
 separate_components = copick_utils.cli.processing_commands:separate_components
 skeletonize = copick_utils.cli.processing_commands:skeletonize
+split = copick_utils.cli.processing_commands:split
 validbox = copick_utils.cli.processing_commands:validbox