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

copick_utils/converters/plane_from_picks.py

@@ -0,0 +1,251 @@
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
+
+import numpy as np
+import trimesh as tm
+from copick.util.log import get_logger
+from sklearn.decomposition import PCA
+
+from copick_utils.converters.converter_common import (
+    cluster,
+    create_batch_converter,
+    create_batch_worker,
+    store_mesh_with_stats,
+    validate_points,
+)
+from copick_utils.converters.lazy_converter import create_lazy_batch_converter
+
+if TYPE_CHECKING:
+    from copick.models import CopickMesh, CopickRun
+
+logger = get_logger(__name__)
+
+
+def fit_plane_to_points(points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    """Fit a plane to a set of 3D points using PCA.
+
+    Args:
+        points: Nx3 array of points.
+
+    Returns:
+        Tuple of (center, normal_vector).
+    """
+    if len(points) < 3:
+        raise ValueError("Need at least 3 points to fit a plane")
+
+    # Center the points
+    center = np.mean(points, axis=0)
+    centered_points = points - center
+
+    # Use PCA to find the plane
+    pca = PCA(n_components=3)
+    pca.fit(centered_points)
+
+    # The normal vector is the component with the smallest variance (last component)
+    normal = pca.components_[-1]  # Last principal component (smallest variance)
+
+    # Ensure consistent normal direction (pointing upward in z if possible)
+    if normal[2] < 0:
+        normal = -normal
+
+    return center, normal
+
+
+def create_plane_mesh(center: np.ndarray, normal: np.ndarray, points: np.ndarray, padding: float = 1.0) -> tm.Trimesh:
+    """Create a plane mesh that encompasses the given points.
+
+    Args:
+        center: Plane center point.
+        normal: Plane normal vector.
+        points: Original points to determine plane size.
+        padding: Extra padding factor for plane size.
+
+    Returns:
+        Trimesh plane object.
+    """
+    # Create two orthogonal vectors in the plane
+    # Find a vector that's not parallel to the normal
+    temp_vector = np.array([0, 0, 1]) if abs(normal[2]) < 0.9 else np.array([1, 0, 0])
+
+    # Create two orthogonal vectors in the plane
+    u = np.cross(normal, temp_vector)
+    u = u / np.linalg.norm(u)
+    v = np.cross(normal, u)
+    v = v / np.linalg.norm(v)
+
+    # Project points onto the plane to determine size
+    centered_points = points - center
+    u_coords = np.dot(centered_points, u)
+    v_coords = np.dot(centered_points, v)
+
+    # Determine plane extents with padding
+    u_min, u_max = np.min(u_coords), np.max(u_coords)
+    v_min, v_max = np.min(v_coords), np.max(v_coords)
+
+    u_range = (u_max - u_min) * padding
+    v_range = (v_max - v_min) * padding
+
+    u_center = (u_min + u_max) / 2
+    v_center = (v_min + v_max) / 2
+
+    # Create plane vertices
+    vertices = [
+        center + (u_center - u_range / 2) * u + (v_center - v_range / 2) * v,
+        center + (u_center + u_range / 2) * u + (v_center - v_range / 2) * v,
+        center + (u_center + u_range / 2) * u + (v_center + v_range / 2) * v,
+        center + (u_center - u_range / 2) * u + (v_center + v_range / 2) * v,
+    ]
+
+    # Create two triangular faces for the plane
+    faces = [[0, 1, 2], [0, 2, 3]]
+
+    return tm.Trimesh(vertices=vertices, faces=faces)
+
+
+def plane_from_picks(
+    points: np.ndarray,
+    run: "CopickRun",
+    object_name: str,
+    session_id: str,
+    user_id: str,
+    use_clustering: bool = False,
+    clustering_method: str = "dbscan",
+    clustering_params: Optional[Dict[str, Any]] = None,
+    padding: float = 1.2,
+    all_clusters: bool = True,
+    individual_meshes: bool = False,
+    session_id_template: Optional[str] = None,
+) -> Optional[Tuple["CopickMesh", Dict[str, int]]]:
+    """Create plane mesh(es) from pick points.
+
+    Args:
+        points: Nx3 array of pick positions.
+        run: Copick run object.
+        object_name: Name of the mesh object.
+        session_id: Session ID for the mesh.
+        user_id: User ID for the mesh.
+        use_clustering: Whether to cluster points first.
+        clustering_method: Clustering method ('dbscan', 'kmeans').
+        clustering_params: Parameters for clustering.
+            e.g.
+                - {'eps': 5.0, 'min_samples': 3} for DBSCAN
+                - {'n_clusters': 3} for KMeans
+        padding: Padding factor for plane size (1.0 = exact fit, >1.0 = larger plane).
+        all_clusters: If True, use all clusters; if False, use only the largest cluster.
+        individual_meshes: If True, create separate mesh objects for each plane.
+        session_id_template: Template for individual mesh session IDs.
+
+    Returns:
+        Tuple of (CopickMesh object, stats dict) or None if creation failed.
+        Stats dict contains 'vertices_created' and 'faces_created' totals.
+    """
+    if not validate_points(points, 3, "plane"):
+        return None
+
+    if clustering_params is None:
+        clustering_params = {}
+
+    # Define plane creation function
+    def create_plane_from_points(cluster_points):
+        center, normal = fit_plane_to_points(cluster_points)
+        return create_plane_mesh(center, normal, cluster_points, padding)
+
+    # Handle clustering workflow with special plane logic
+    if use_clustering:
+        point_clusters = cluster(
+            points,
+            clustering_method,
+            min_points_per_cluster=3,  # Planes need at least 3 points
+            **clustering_params,
+        )
+
+        if not point_clusters:
+            logger.warning("No valid clusters found")
+            return None
+
+        logger.info(f"Found {len(point_clusters)} clusters")
+
+        if all_clusters and len(point_clusters) > 1:
+            if individual_meshes:
+                # Create separate mesh objects for each plane
+                created_meshes = []
+                total_vertices = 0
+                total_faces = 0
+
+                for i, cluster_points in enumerate(point_clusters):
+                    try:
+                        plane_mesh = create_plane_from_points(cluster_points)
+
+                        # Generate session ID using template if provided
+                        if session_id_template:
+                            plane_session_id = session_id_template.format(
+                                base_session_id=session_id,
+                                instance_id=i,
+                            )
+                        else:
+                            plane_session_id = f"{session_id}-{i:03d}"
+
+                        copick_mesh = run.new_mesh(object_name, plane_session_id, user_id, exist_ok=True)
+                        copick_mesh.mesh = plane_mesh
+                        copick_mesh.store()
+                        created_meshes.append(copick_mesh)
+                        total_vertices += len(plane_mesh.vertices)
+                        total_faces += len(plane_mesh.faces)
+                        logger.info(
+                            f"Created individual plane mesh {i} with {len(plane_mesh.vertices)} vertices",
+                        )
+                    except Exception as e:
+                        logger.error(f"Failed to create mesh {i}: {e}")
+                        continue
+
+                # Return the first mesh and total stats
+                if created_meshes:
+                    stats = {"vertices_created": total_vertices, "faces_created": total_faces}
+                    return created_meshes[0], stats
+                else:
+                    return None
+            else:
+                # Create meshes from all clusters and combine them
+                all_meshes = []
+                for cluster_points in point_clusters:
+                    plane_mesh = create_plane_from_points(cluster_points)
+                    all_meshes.append(plane_mesh)
+
+                # Combine all meshes
+                combined_mesh = tm.util.concatenate(all_meshes)
+        else:
+            # Use largest cluster
+            cluster_sizes = [len(cluster) for cluster in point_clusters]
+            largest_cluster_idx = np.argmax(cluster_sizes)
+            points_to_use = point_clusters[largest_cluster_idx]
+            logger.info(f"Using largest cluster with {len(points_to_use)} points")
+
+            combined_mesh = create_plane_from_points(points_to_use)
+    else:
+        # Use all points without clustering
+        combined_mesh = create_plane_from_points(points)
+
+    # Store mesh and return stats
+    try:
+        return store_mesh_with_stats(run, combined_mesh, object_name, session_id, user_id, "plane")
+    except Exception as e:
+        logger.critical(f"Error creating mesh: {e}")
+        return None
+
+
+# Create worker function using common infrastructure
+_plane_from_picks_worker = create_batch_worker(plane_from_picks, "plane", min_points=3)
+
+
+# Create batch converter using common infrastructure
+plane_from_picks_batch = create_batch_converter(
+    plane_from_picks,
+    "Converting picks to plane meshes",
+    "plane",
+    min_points=3,
+)
+
+# Lazy batch converter for new architecture
+plane_from_picks_lazy_batch = create_lazy_batch_converter(
+    converter_func=plane_from_picks,
+    task_description="Converting picks to plane meshes",
+)

copick_utils/converters/segmentation_from_mesh.py

@@ -0,0 +1,291 @@
+"""Convert meshes to segmentation volumes."""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
+
+import numpy as np
+import trimesh as tm
+from copick.util.log import get_logger
+from trimesh.ray.ray_triangle import RayMeshIntersector
+
+from copick_utils.converters.converter_common import (
+    create_batch_converter,
+    create_batch_worker,
+)
+from copick_utils.converters.lazy_converter import create_lazy_batch_converter
+
+if TYPE_CHECKING:
+    from copick.models import CopickMesh, CopickRun, CopickSegmentation
+
+logger = get_logger(__name__)
+
+
+def ensure_mesh(trimesh_object) -> Optional[tm.Trimesh]:
+    """
+    Convert a trimesh object to a single mesh.
+
+    Args:
+        trimesh_object: A Trimesh or Scene object
+
+    Returns:
+        Single Trimesh object or None if empty
+
+    Raises:
+        ValueError: If input is not a Trimesh or Scene object
+    """
+    if isinstance(trimesh_object, tm.Scene):
+        if len(trimesh_object.geometry) == 0:
+            return None
+        else:
+            return tm.util.concatenate(list(trimesh_object.geometry.values()))
+    elif isinstance(trimesh_object, tm.Trimesh):
+        return trimesh_object
+    else:
+        raise ValueError("Input must be a Trimesh or Scene object")
+
+
+def _onesmask_z(mesh: tm.Trimesh, voxel_dims: Tuple[int, int, int], voxel_spacing: float) -> np.ndarray:
+    """Create mask by ray casting in Z direction."""
+    intersector = RayMeshIntersector(mesh)
+
+    # Create a grid of rays in XY plane, shooting in Z direction
+    grid_x, grid_y = np.mgrid[0 : voxel_dims[0], 0 : voxel_dims[1]]
+    ray_grid = np.vstack([grid_x.ravel(), grid_y.ravel(), -np.ones((grid_x.size,))]).T * voxel_spacing
+    ray_dir = np.zeros((ray_grid.shape[0], 3))
+    ray_dir[:, 2] = 1
+
+    loc, _, _ = intersector.intersects_location(ray_grid, ray_dir)
+
+    # Convert to voxel coordinates and sort by z
+    int_loc = np.round(loc / voxel_spacing).astype("int")
+    sort_idx = int_loc[:, 2].argsort()
+    int_loc = int_loc[sort_idx, :]
+
+    # Build volume by tracking crossings
+    img = np.zeros((voxel_dims[1], voxel_dims[0]), dtype="bool")
+    vol = np.zeros((voxel_dims[2], voxel_dims[1], voxel_dims[0]), dtype="bool")
+
+    for z in range(voxel_dims[2]):
+        idx = int_loc[:, 2] == z
+        img[int_loc[idx, 1], int_loc[idx, 0]] = np.logical_not(img[int_loc[idx, 1], int_loc[idx, 0]])
+        vol[z, :, :] = img
+
+    return vol
+
+
+def _onesmask_x(mesh: tm.Trimesh, voxel_dims: Tuple[int, int, int], voxel_spacing: float) -> np.ndarray:
+    """Create mask by ray casting in X direction."""
+    intersector = RayMeshIntersector(mesh)
+
+    # Create a grid of rays in YZ plane, shooting in X direction
+    grid_y, grid_z = np.mgrid[0 : voxel_dims[1], 0 : voxel_dims[2]]
+    ray_grid = np.vstack([-np.ones((grid_y.size,)), grid_y.ravel(), grid_z.ravel()]).T * voxel_spacing
+    ray_dir = np.zeros((ray_grid.shape[0], 3))
+    ray_dir[:, 0] = 1
+
+    loc, _, _ = intersector.intersects_location(ray_grid, ray_dir)
+
+    # Convert to voxel coordinates and sort by x
+    int_loc = np.round(loc / voxel_spacing).astype("int")
+    sort_idx = int_loc[:, 0].argsort()
+    int_loc = int_loc[sort_idx, :]
+
+    # Build volume by tracking crossings
+    img = np.zeros((voxel_dims[2], voxel_dims[1]), dtype="bool")
+    vol = np.zeros((voxel_dims[2], voxel_dims[1], voxel_dims[0]), dtype="bool")
+
+    for x in range(voxel_dims[0]):
+        idx = int_loc[:, 0] == x
+        img[int_loc[idx, 2], int_loc[idx, 1]] = np.logical_not(img[int_loc[idx, 2], int_loc[idx, 1]])
+        vol[:, :, x] = img
+
+    return vol
+
+
+def mesh_to_volume(mesh: tm.Trimesh, voxel_dims: Tuple[int, int, int], voxel_spacing: float) -> np.ndarray:
+    """
+    Convert a watertight mesh to a binary volume using ray casting.
+
+    Args:
+        mesh: Trimesh object representing the mesh
+        voxel_dims: Dimensions of the output volume (x, y, z)
+        voxel_spacing: Spacing between voxels in physical units
+
+    Returns:
+        Binary volume as numpy array with shape (z, y, x)
+    """
+    vols = []
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        futs = [
+            executor.submit(_onesmask_x, mesh.copy(), voxel_dims, voxel_spacing),
+            executor.submit(_onesmask_z, mesh.copy(), voxel_dims, voxel_spacing),
+        ]
+
+        for f in as_completed(futs):
+            vols.append(f.result())
+
+    return np.logical_and(vols[0], vols[1])
+
+
+def mesh_to_boundary_volume(
+    mesh: tm.Trimesh,
+    voxel_dims: Tuple[int, int, int],
+    voxel_spacing: float,
+    sampling_density: float = 1.0,
+) -> np.ndarray:
+    """
+    Convert a mesh to a binary volume by voxelizing only the surface/boundary.
+
+    Args:
+        mesh: Trimesh object representing the mesh
+        voxel_dims: Dimensions of the output volume (x, y, z)
+        voxel_spacing: Spacing between voxels in physical units
+        sampling_density: Density of surface sampling (samples per voxel edge length)
+
+    Returns:
+        Binary volume as numpy array with shape (z, y, x)
+    """
+    # Sample points on the mesh surface
+    # Calculate number of points based on surface area and sampling density
+    surface_area = mesh.area
+    # Estimate points per unit area based on voxel spacing and density
+    points_per_area = (sampling_density / voxel_spacing) ** 2
+    n_points = max(int(surface_area * points_per_area), 1000)  # Minimum 1000 points
+
+    # Sample points uniformly on the surface
+    surface_points, _ = tm.sample.sample_surface(mesh, n_points)
+
+    # Convert surface points to voxel coordinates
+    voxel_coords = np.round(surface_points / voxel_spacing).astype(int)
+
+    # Create binary volume
+    vol = np.zeros((voxel_dims[2], voxel_dims[1], voxel_dims[0]), dtype=bool)
+
+    # Filter coordinates to be within bounds
+    valid_mask = (
+        (voxel_coords[:, 0] >= 0)
+        & (voxel_coords[:, 0] < voxel_dims[0])
+        & (voxel_coords[:, 1] >= 0)
+        & (voxel_coords[:, 1] < voxel_dims[1])
+        & (voxel_coords[:, 2] >= 0)
+        & (voxel_coords[:, 2] < voxel_dims[2])
+    )
+    voxel_coords = voxel_coords[valid_mask]
+
+    # Set voxels at surface points
+    if len(voxel_coords) > 0:
+        # Convert from (x,y,z) to (z,y,x) indexing for the volume
+        vol[voxel_coords[:, 2], voxel_coords[:, 1], voxel_coords[:, 0]] = True
+
+    return vol
+
+
+def segmentation_from_mesh(
+    mesh: "CopickMesh",
+    run: "CopickRun",
+    object_name: str,
+    session_id: str,
+    user_id: str,
+    voxel_spacing: float,
+    tomo_type: str = "wbp",
+    is_multilabel: bool = False,
+    mode: str = "watertight",
+    boundary_sampling_density: float = 1.0,
+    invert: bool = False,
+) -> Optional[Tuple["CopickSegmentation", Dict[str, int]]]:
+    """
+    Convert a CopickMesh to a segmentation volume.
+
+    Args:
+        mesh: CopickMesh object to convert
+        run: CopickRun object
+        object_name: Name for the output segmentation
+        session_id: Session ID for the output segmentation
+        user_id: User ID for the output segmentation
+        voxel_spacing: Voxel spacing for the segmentation
+        tomo_type: Type of tomogram to use for reference dimensions
+        is_multilabel: Whether the segmentation is multilabel
+        mode: Voxelization mode ('watertight' or 'boundary')
+        boundary_sampling_density: Surface sampling density for boundary mode (samples per voxel edge length)
+        invert: Whether to invert the volume (fill outside instead of inside)
+
+    Returns:
+        Tuple of (CopickSegmentation object, stats dict) or None if creation failed.
+        Stats dict contains 'voxels_created'.
+    """
+    try:
+        # Get the trimesh object from CopickMesh
+        mesh_obj = ensure_mesh(mesh.mesh)
+        if mesh_obj is None:
+            logger.error("Empty mesh")
+            return None
+
+        # Get reference dimensions from tomogram
+        vs = run.get_voxel_spacing(voxel_spacing)
+        if not vs:
+            logger.error(f"Voxel spacing {voxel_spacing} not found")
+            return None
+
+        tomos = vs.get_tomograms(tomo_type=tomo_type)
+        if not tomos:
+            logger.error(f"Tomogram type {tomo_type} not found")
+            return None
+
+        # Get dimensions from zarr
+        import zarr
+
+        tomo_array = zarr.open(tomos[0].zarr())["0"]
+        vox_dim = tomo_array.shape[::-1]  # zarr is (z,y,x), we want (x,y,z)
+
+        # Convert mesh to volume based on mode
+        if mode == "watertight":
+            vol = mesh_to_volume(mesh_obj, vox_dim, voxel_spacing)
+        elif mode == "boundary":
+            vol = mesh_to_boundary_volume(mesh_obj, vox_dim, voxel_spacing, boundary_sampling_density)
+        else:
+            raise ValueError(f"Unknown voxelization mode: {mode}. Must be 'watertight' or 'boundary'.")
+
+        # Apply inversion if requested
+        if invert:
+            vol = ~vol
+
+        # Create or get segmentation
+        seg = run.new_segmentation(
+            name=object_name,
+            user_id=user_id,
+            session_id=session_id,
+            is_multilabel=is_multilabel,
+            voxel_size=voxel_spacing,
+            exist_ok=True,
+        )
+
+        # Store the volume using modern copick API
+        seg.from_numpy(vol.astype(np.uint8))
+
+        stats = {"voxels_created": int(np.sum(vol))}
+        logger.info(f"Created segmentation with {stats['voxels_created']} voxels")
+        return seg, stats
+
+    except Exception as e:
+        logger.error(f"Error creating segmentation: {e}")
+        return None
+
+
+# Create worker function using common infrastructure
+_segmentation_from_mesh_worker = create_batch_worker(segmentation_from_mesh, "segmentation", "mesh", min_points=0)
+
+
+# Create batch converter using common infrastructure
+segmentation_from_mesh_batch = create_batch_converter(
+    segmentation_from_mesh,
+    "Converting meshes to segmentations",
+    "segmentation",
+    "mesh",
+    min_points=0,
+)
+
+# Lazy batch converter for new architecture
+segmentation_from_mesh_lazy_batch = create_lazy_batch_converter(
+    converter_func=segmentation_from_mesh,
+    task_description="Converting meshes to segmentations",
+)

copick_utils/{segmentation → converters}/segmentation_from_picks.py

@@ -1,9 +1,29 @@
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
+
 import numpy as np
 import zarr
+from copick.util.log import get_logger
 from scipy.ndimage import zoom
 
+from copick_utils.converters.converter_common import (
+    create_batch_converter,
+    create_batch_worker,
+)
+from copick_utils.converters.lazy_converter import create_lazy_batch_converter
+
+if TYPE_CHECKING:
+    from copick.models import CopickObject, CopickPicks, CopickRun, CopickSegmentation
+
+logger = get_logger(__name__)
 
-def from_picks(pick, seg_volume, radius: float = 10.0, label_value: int = 1, voxel_spacing: float = 10):
+
+def from_picks(
+    pick: "CopickPicks",
+    seg_volume: np.ndarray,
+    radius: float = 10.0,
+    label_value: int = 1,
+    voxel_spacing: float = 10,
+) -> np.ndarray:
     """
     Paints picks into a segmentation volume as spheres.
 
@@ -74,7 +94,7 @@ def from_picks(pick, seg_volume, radius: float = 10.0, label_value: int = 1, vox
     return seg_volume
 
 
-def downsample_to_exact_shape(array, target_shape):
+def downsample_to_exact_shape(array: np.ndarray, target_shape: tuple) -> np.ndarray:
     """
     Downsamples a 3D array to match the target shape using nearest-neighbor interpolation.
     Ensures that the resulting array has the exact target shape.
@@ -83,17 +103,17 @@ def downsample_to_exact_shape(array, target_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",
-):
+def _create_segmentation_from_picks_legacy(
+    radius: float,
+    painting_segmentation_name: str,
+    run: "CopickRun",
+    voxel_spacing: float,
+    tomo_type: str,
+    pickable_object: "CopickObject",
+    pick_set: "CopickPicks",
+    user_id: str = "paintedPicks",
+    session_id: str = "0",
+) -> "CopickSegmentation":
     """
     Paints picks from a run into a multiscale segmentation array, representing them as spheres in 3D space.
 
@@ -185,3 +205,93 @@ def segmentation_from_picks(
         segmentation_group[level_name][:] = scaled_array
 
     return seg
+
+
+def segmentation_from_picks(
+    picks: "CopickPicks",
+    run: "CopickRun",
+    object_name: str,
+    session_id: str,
+    user_id: str,
+    radius: float,
+    voxel_spacing: float,
+    tomo_type: str = "wbp",
+) -> Optional[Tuple["CopickSegmentation", Dict[str, int]]]:
+    """
+    Convert CopickPicks to a segmentation by painting spheres.
+
+    Args:
+        picks: CopickPicks object to convert
+        run: CopickRun object
+        object_name: Name for the output segmentation
+        session_id: Session ID for the output segmentation
+        user_id: User ID for the output segmentation
+        radius: Radius of the spheres in physical units
+        voxel_spacing: Voxel spacing for the segmentation
+        tomo_type: Type of tomogram to use as reference
+
+    Returns:
+        Tuple of (CopickSegmentation object, stats dict) or None if creation failed.
+        Stats dict contains 'points_converted' and 'voxels_created'.
+    """
+    try:
+        # Get the pickable object for label information
+        root = run.root
+        pickable_object = root.get_object(picks.pickable_object_name)
+        if not pickable_object:
+            logger.error(f"Object '{picks.pickable_object_name}' not found in config")
+            return None
+
+        if not picks.points:
+            logger.error("No points found in pick set")
+            return None
+
+        # Create segmentation using the legacy function
+        seg = _create_segmentation_from_picks_legacy(
+            radius=radius,
+            painting_segmentation_name=object_name,
+            run=run,
+            voxel_spacing=voxel_spacing,
+            tomo_type=tomo_type,
+            pickable_object=pickable_object,
+            pick_set=picks,
+            user_id=user_id,
+            session_id=session_id,
+        )
+
+        # Calculate statistics
+        # For now, we don't have easy access to the actual voxel count, so we estimate
+        # based on number of spheres and their volume
+        sphere_volume_voxels = (4 / 3) * np.pi * (radius / voxel_spacing) ** 3
+        estimated_voxels = int(len(picks.points) * sphere_volume_voxels)
+
+        stats = {
+            "points_converted": len(picks.points),
+            "voxels_created": estimated_voxels,
+        }
+        logger.info(f"Created segmentation from {stats['points_converted']} picks")
+        return seg, stats
+
+    except Exception as e:
+        logger.error(f"Error creating segmentation: {e}")
+        return None
+
+
+# Create worker function using common infrastructure
+_segmentation_from_picks_worker = create_batch_worker(segmentation_from_picks, "segmentation", "picks", min_points=1)
+
+
+# Create batch converter using common infrastructure
+segmentation_from_picks_batch = create_batch_converter(
+    segmentation_from_picks,
+    "Converting picks to segmentations",
+    "segmentation",
+    "picks",
+    min_points=1,
+)
+
+# Lazy batch converter for new architecture
+segmentation_from_picks_lazy_batch = create_lazy_batch_converter(
+    converter_func=segmentation_from_picks,
+    task_description="Converting picks to segmentations",
+)