copick-utils 0.6.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

copick_utils/cli/input_output_selection.py

@@ -0,0 +1,76 @@
+"""Input/output selection logic for conversion CLI commands."""
+
+import re
+
+
+def _is_regex_pattern(pattern: str) -> bool:
+    """Check if string is a regex pattern by trying to compile it and seeing if it has special chars."""
+    # Check for common regex special characters
+    regex_chars = r"[.*+?^${}()|[\]\\"
+    has_regex_chars = any(char in pattern for char in regex_chars)
+
+    if not has_regex_chars:
+        return False
+
+    # Try to compile as regex
+    try:
+        re.compile(pattern)
+        return True
+    except re.error:
+        return False
+
+
+def validate_placeholders(
+    pick_session_id: str,
+    mesh_session_id: str,
+    individual_meshes: bool,
+) -> None:
+    """
+    Validate that session ID templates contain required placeholders.
+
+    Args:
+        pick_session_id: Input session ID or pattern
+        mesh_session_id: Output session ID template
+        individual_meshes: Whether individual meshes are being created
+
+    Raises:
+        ValueError: If template validation fails
+    """
+    if individual_meshes and "{instance_id}" not in mesh_session_id:
+        raise ValueError(
+            "Session ID template must contain {instance_id} placeholder when individual-meshes is enabled",
+        )
+
+    # Check if this is many-to-many mode (input has regex pattern)
+    if _is_regex_pattern(pick_session_id) and "{input_session_id}" not in mesh_session_id:
+        raise ValueError(
+            "Session ID template must contain {input_session_id} placeholder when using regex input pattern",
+        )
+
+
+def validate_conversion_placeholders(
+    input_session_id: str,
+    output_session_id: str,
+    individual_outputs: bool,
+) -> None:
+    """
+    Validate that session ID templates contain required placeholders.
+
+    Args:
+        input_session_id: Input session ID or pattern
+        output_session_id: Output session ID template
+        individual_outputs: Whether individual outputs are being created
+
+    Raises:
+        ValueError: If template validation fails
+    """
+    if individual_outputs and "{instance_id}" not in output_session_id:
+        raise ValueError(
+            "Session ID template must contain {instance_id} placeholder when individual outputs are enabled",
+        )
+
+    # Check if this is many-to-many mode (input has regex pattern)
+    if _is_regex_pattern(input_session_id) and "{input_session_id}" not in output_session_id:
+        raise ValueError(
+            "Session ID template must contain {input_session_id} placeholder when using regex input pattern",
+        )

copick_utils/cli/logical_commands.py

@@ -0,0 +1,29 @@
+"""CLI commands for logical operations (boolean operations, distance limiting, point filtering).
+
+This module imports all logical operation commands from specialized files for better organization.
+"""
+
+
+from copick_utils.cli.clipmesh import clipmesh
+from copick_utils.cli.clippicks import clippicks
+from copick_utils.cli.clipseg import clipseg
+from copick_utils.cli.enclosed import enclosed
+from copick_utils.cli.meshop import meshop
+from copick_utils.cli.picksin import picksin
+from copick_utils.cli.picksout import picksout
+from copick_utils.cli.segop import segop
+
+# All commands are now available for import by the main CLI
+__all__ = [
+    # Boolean operation commands
+    "meshop",
+    "segop",
+    "enclosed",
+    # Distance limiting commands
+    "clipmesh",
+    "clipseg",
+    "clippicks",
+    # Point filtering commands
+    "picksin",
+    "picksout",
+]

copick_utils/cli/mesh2picks.py

@@ -0,0 +1,170 @@
+"""CLI commands for converting meshes to picks."""
+
+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_output_option, add_tomogram_option, add_workers_option
+from copick_utils.util.config_models import create_simple_config
+
+
+@click.command(
+    context_settings={"show_default": True},
+    short_help="Convert mesh to picks.",
+    no_args_is_help=True,
+)
+@add_config_option
+@optgroup.group("\nInput Options", help="Options related to the input meshes.")
+@optgroup.option(
+    "--run-names",
+    "-r",
+    multiple=True,
+    help="Specific run names to process (default: all runs).",
+)
+@add_input_option("mesh")
+@add_tomogram_option(required=True)
+@optgroup.group("\nTool Options", help="Options related to this tool.")
+@optgroup.option(
+    "--sampling-type",
+    type=click.Choice(["inside", "surface", "outside", "vertices"]),
+    required=True,
+    help="Type of sampling: inside (points inside mesh), surface (points on mesh surface), outside (points outside mesh), vertices (return mesh vertices).",
+)
+@optgroup.option(
+    "--n-points",
+    type=int,
+    default=1000,
+    help="Number of points to sample (ignored for 'vertices' type).",
+)
+@optgroup.option(
+    "--min-dist",
+    type=float,
+    help="Minimum distance between points (default: 2 * voxel_spacing).",
+)
+@optgroup.option(
+    "--edge-dist",
+    type=float,
+    default=32.0,
+    help="Distance from volume edges in voxels.",
+)
+@optgroup.option(
+    "--include-normals/--no-include-normals",
+    is_flag=True,
+    default=False,
+    help="Include surface normals as orientations (surface sampling only).",
+)
+@optgroup.option(
+    "--random-orientations/--no-random-orientations",
+    is_flag=True,
+    default=False,
+    help="Generate random orientations for points.",
+)
+@optgroup.option(
+    "--seed",
+    type=int,
+    help="Random seed for reproducible results.",
+)
+@add_workers_option
+@optgroup.group("\nOutput Options", help="Options related to output picks.")
+@add_output_option("picks", default_tool="mesh2picks")
+@add_debug_option
+def mesh2picks(
+    config,
+    run_names,
+    input_uri,
+    tomogram_uri,
+    sampling_type,
+    n_points,
+    min_dist,
+    edge_dist,
+    include_normals,
+    random_orientations,
+    seed,
+    workers,
+    output_uri,
+    debug,
+):
+    """
+    Convert meshes to picks using different sampling strategies.
+
+    \b
+    URI Format:
+        Meshes: object_name:user_id/session_id
+        Picks: object_name:user_id/session_id
+        Tomograms: tomo_type@voxel_spacing
+
+    \b
+    Examples:
+        # Convert single mesh to picks with surface sampling
+        copick convert mesh2picks -i "boundary:user1/boundary-001" --tomogram wbp@10.0 --sampling-type surface -o "boundary"
+
+        # Convert all boundary meshes using pattern matching
+        copick convert mesh2picks -i "boundary:user1/boundary-.*" -t wbp@10.0 --sampling-type inside -o "{input_session_id}"
+    """
+    from copick_utils.converters.picks_from_mesh import picks_from_mesh_lazy_batch
+
+    logger = get_logger(__name__, debug=debug)
+
+    root = copick.from_file(config)
+    run_names_list = list(run_names) if run_names else None
+
+    # Parse tomogram URI to extract tomo_type and voxel_spacing
+    try:
+        tomogram_params = parse_copick_uri(tomogram_uri, "tomogram")
+    except ValueError as e:
+        raise click.BadParameter(f"Invalid tomogram URI: {e}") from e
+
+    tomo_type = tomogram_params["tomo_type"]
+    voxel_spacing = tomogram_params["voxel_spacing"]
+    if isinstance(voxel_spacing, str):
+        voxel_spacing = float(voxel_spacing)
+
+    # Create config directly from URIs with smart defaults
+    try:
+        task_config = create_simple_config(
+            input_uri=input_uri,
+            input_type="mesh",
+            output_uri=output_uri,
+            output_type="picks",
+            command_name="mesh2picks",
+        )
+    except ValueError as e:
+        raise click.BadParameter(str(e)) from e
+
+    # Extract parameters for logging
+    input_params = parse_copick_uri(input_uri, "mesh")
+    output_params = parse_copick_uri(output_uri, "picks")
+
+    logger.info(f"Converting mesh to picks for object '{input_params['object_name']}'")
+    logger.info(f"Source mesh pattern: {input_params['user_id']}/{input_params['session_id']}")
+    logger.info(
+        f"Target picks template: {output_params['object_name']} ({output_params['user_id']}/{output_params['session_id']})",
+    )
+    logger.info(f"Tomogram: {tomo_type}@{voxel_spacing}")
+    logger.info(f"Sampling type: {sampling_type}, n_points: {n_points}")
+
+    # Parallel discovery and processing with consistent architecture!
+    results = picks_from_mesh_lazy_batch(
+        root=root,
+        config=task_config,
+        run_names=run_names_list,
+        workers=workers,
+        sampling_type=sampling_type,
+        n_points=n_points,
+        voxel_spacing=voxel_spacing,
+        tomo_type=tomo_type,
+        min_dist=min_dist,
+        edge_dist=edge_dist,
+        include_normals=include_normals,
+        random_orientations=random_orientations,
+        seed=seed,
+    )
+
+    successful = sum(1 for result in results.values() if result and result.get("processed", 0) > 0)
+    total_points = sum(result.get("points_created", 0) for result in results.values() if result)
+
+    logger.info(f"Completed: {successful}/{len(results)} runs processed successfully")
+    logger.info(f"Total points created: {total_points}")

copick_utils/cli/mesh2seg.py

@@ -0,0 +1,167 @@
+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_mesh_voxelization_options,
+    add_output_option,
+    add_workers_option,
+)
+from copick_utils.util.config_models import create_simple_config
+
+
+@click.command(
+    context_settings={"show_default": True},
+    short_help="Convert mesh to segmentation.",
+    no_args_is_help=True,
+)
+@add_config_option
+@optgroup.group("\nInput Options", help="Options related to the input meshes.")
+@optgroup.option(
+    "--run-names",
+    "-r",
+    multiple=True,
+    help="Specific run names to process (default: all runs).",
+)
+@add_input_option("mesh")
+@optgroup.group("\nTool Options", help="Options related to this tool.")
+@add_mesh_voxelization_options
+@optgroup.option(
+    "--tomo-type",
+    "-tt",
+    default="wbp",
+    help="Type of tomogram to use as reference.",
+)
+@add_workers_option
+@optgroup.group("\nOutput Options", help="Options related to output segmentations.")
+@add_output_option("segmentation", default_tool="mesh2seg")
+@add_debug_option
+def mesh2seg(
+    config,
+    run_names,
+    input_uri,
+    mode,
+    boundary_sampling_density,
+    invert,
+    tomo_type,
+    workers,
+    output_uri,
+    debug,
+):
+    """
+    Convert meshes to segmentation volumes with multiple voxelization modes.
+
+    \b
+    URI Format:
+        Meshes: object_name:user_id/session_id
+        Segmentations: name:user_id/session_id@voxel_spacing?multilabel=true
+
+    \b
+    Pattern Matching:
+        - Exact: "membrane:user1/session1"
+        - Glob: "membrane:user1/session*" or "membrane:*/manual-*"
+        - Regex: "re:membrane:user\\d+/session\\d+"
+        - Wildcard: "membrane" (expands to "membrane:*/*")
+
+    \b
+    Voxelization modes:
+        - watertight: Fill entire interior volume using ray casting
+        - boundary: Voxelize only the surface with controllable sampling density
+
+    \b
+    Additional options:
+        - --invert: Fill outside instead of inside (watertight mode)
+        - --boundary-sampling-density: Surface sampling density (boundary mode)
+
+    \b
+    Examples:
+        # Convert mesh interior to segmentation (default)
+        copick convert mesh2seg -i "membrane:user1/manual-001" -o "membrane:mesh2seg/from-mesh-001@10.0"
+
+        # Convert mesh boundary only with high sampling density
+        copick convert mesh2seg --mode boundary --boundary-sampling-density 2.0 \\
+            -i "membrane:user1/manual-001" -o "membrane:mesh2seg/boundary-001@10.0"
+
+        # Invert watertight mesh (fill outside)
+        copick convert mesh2seg --invert -i "membrane:user1/manual-001" -o "membrane:mesh2seg/inverted-001@10.0"
+
+        # Convert all manual meshes using pattern matching with multilabel output
+        copick convert mesh2seg -i "membrane:user1/manual-.*" -o "membrane:mesh2seg/from-mesh-{input_session_id}@10.0?multilabel=true"
+    """
+    from copick_utils.converters.segmentation_from_mesh import segmentation_from_mesh_lazy_batch
+
+    logger = get_logger(__name__, debug=debug)
+
+    root = copick.from_file(config)
+    run_names_list = list(run_names) if run_names else None
+
+    # Create config directly from URIs with smart defaults
+    try:
+        task_config = create_simple_config(
+            input_uri=input_uri,
+            input_type="mesh",
+            output_uri=output_uri,
+            output_type="segmentation",
+            command_name="mesh2seg",
+        )
+    except ValueError as e:
+        raise click.BadParameter(str(e)) from e
+
+    # Extract parameters for logging and processing
+    input_params = parse_copick_uri(input_uri, "mesh")
+    output_params = parse_copick_uri(output_uri, "segmentation")
+
+    voxel_spacing_output = output_params["voxel_spacing"]
+    if isinstance(voxel_spacing_output, str):
+        voxel_spacing_output = float(voxel_spacing_output)
+    multilabel_output = output_params.get("multilabel") or False
+
+    logger.info(f"Converting mesh to segmentation for object '{input_params['object_name']}'")
+    logger.info(f"Source mesh pattern: {input_params['user_id']}/{input_params['session_id']}")
+    logger.info(
+        f"Target segmentation template: {output_params['name']} ({output_params['user_id']}/{output_params['session_id']})",
+    )
+    logger.info(f"Mode: {mode}, voxel spacing: {voxel_spacing_output}, multilabel: {multilabel_output}")
+    if mode == "boundary":
+        logger.info(f"Boundary sampling density: {boundary_sampling_density}")
+    if invert:
+        logger.info("Volume inversion: enabled")
+
+    # Parallel discovery and processing - no sequential bottleneck!
+    results = segmentation_from_mesh_lazy_batch(
+        root=root,
+        config=task_config,
+        run_names=run_names_list,
+        workers=workers,
+        voxel_spacing=voxel_spacing_output,
+        tomo_type=tomo_type,
+        is_multilabel=multilabel_output,
+        mode=mode,
+        boundary_sampling_density=boundary_sampling_density,
+        invert=invert,
+    )
+
+    successful = sum(1 for result in results.values() if result and result.get("processed", 0) > 0)
+    total_voxels = sum(result.get("voxels_created", 0) for result in results.values() if result)
+    total_processed = sum(result.get("processed", 0) for result in results.values() if result)
+
+    # 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 conversion tasks completed: {total_processed}")
+    logger.info(f"Total voxels created: {total_voxels}")
+
+    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")