octopi 1.0__py3-none-any.whl

octopi/extract/membranebound_extract.py

@@ -0,0 +1,262 @@
+from scipy.spatial.transform import Rotation as R
+from octopi import utils, io
+import scipy.ndimage as ndi
+from typing import Tuple
+import numpy as np
+import math
+
+def process_membrane_bound_extract(run,
+                                   voxel_size: float,
+                                   picks_info: Tuple[str, str, str],
+                                   membrane_info: Tuple[str, str, str],
+                                   organelle_info: Tuple[str, str, str],
+                                   save_user_id: str,
+                                   save_session_id: str,
+                                   distance_threshold: float):
+
+    """
+    Process membrane-bound particles and extract their coordinates and orientations.
+    
+    Args:
+        run: CoPick run object.
+        voxel_size: Voxel size for coordinate scaling.
+        segmentation_name: Name of the segmentation object.
+        segmentation_user_id: User ID for the segmentation.
+        segmentation_session_id: Session ID for the segmentation.
+        picks_name: Name of the particle picks object.
+        picks_user_id: User ID for the particle picks.
+        picks_session_id: Session ID for the particle picks.
+        save_user_id: User ID for saving processed picks.
+        save_session_id: Session ID for saving close picks.
+        distance_threshold: Maximum distance to consider a particle close to the membrane.
+        organelle_seg: Whether to compute organelle centers from segmentation.
+    """  
+
+    # Increment session ID for the second class
+    new_session_id = str(int(save_session_id) + 1)  # Convert to string after increment                                  
+
+    # Need Better Error Handing for Missing Picks
+    coordinates = io.get_copick_coordinates(
+        run, 
+        picks_info[0], picks_info[1], picks_info[2],
+        voxel_size,
+        raise_error=False
+    )
+
+    # If No Coordinates are Found, Return
+    if coordinates is None:
+        print(f'[Warning] RunID: {run.name} - No Coordinates Found for {picks_info[0]}, {picks_info[1]}, {picks_info[2]}')
+        return
+
+    nPoints = len(coordinates)
+
+    # Determine which Segmentation to Use for Filtering
+    if membrane_info is None:
+        # Flag to distinguish between organelle and membrane segmentation
+        membranes_provided = False
+        seg = io.get_segmentation_array(run, 
+                                    voxel_size, 
+                                    organelle_info[0],
+                                    user_id=organelle_info[1], 
+                                    session_id=organelle_info[2],
+                                    raise_error=False)
+        # If No Segmentation is Found, Return
+        if seg is None: return     
+        elif nPoints == 0 or np.unique(seg).max() == 0:
+            print(f'[Warning] RunID: {run.name} - Organelle-Seg Unique Values: {np.unique(seg)}, nPoints: {nPoints}')
+            return                                            
+    else:
+        # Read both Organelle and Membrane Segmentations
+        membranes_provided = True
+        seg = io.get_segmentation_array(
+            run, 
+            voxel_size, 
+            membrane_info[0],
+            user_id=membrane_info[1], 
+            session_id=membrane_info[2],
+            raise_error=False)
+
+        organelle_seg = io.get_segmentation_array(
+            run, 
+            voxel_size, 
+            organelle_info[0],
+            user_id=organelle_info[1], 
+            session_id=organelle_info[2],
+            raise_error=False)
+        
+        # If No Segmentation is Found, Return
+        if seg is None or seg is None: return
+        elif nPoints == 0 or np.unique(seg).max() == 0:
+            print(f'[Warning] RunID: {run.name} - Organelle-Seg Unique Values: {np.unique(seg)}, nPoints: {nPoints}')
+            return
+        
+        # Tempory Solution to Ensure Labels are the Same:
+        seg[seg > 0] += 1
+
+    if nPoints > 0:
+
+        # Step 1: Find Closest Points to Segmentation of Interest
+        points, closest_labels = closest_organelle_points(
+            organelle_seg, 
+            coordinates, 
+            max_distance=distance_threshold, 
+            return_labels_array=True
+        )
+
+        # Identify close and far indices
+        close_indices = np.where(closest_labels != -1)[0]
+        far_indices = np.where(closest_labels == -1)[0]
+
+        # Initialize orientations array
+        orientations = np.zeros([nPoints, 4, 4])
+        orientations[:,3,3] = 1 
+
+        # Step 2: Get Organelle Centers (Optional if an organelle segmentation is provided)
+        organelle_centers = organelle_points(organelle_seg)
+
+        # Step 3: Get All the Rotation Matrices from Euler Angles Based on Normal Vector
+        if len(close_indices) > 0:
+
+            # Get Organelle Centers for Close Points
+            close_labels = closest_labels[close_indices]
+            close_centers = np.array([organelle_centers[str(int(label))] for label in close_labels])
+
+            # Calculate orientations
+            for i, idx in enumerate(close_indices):
+                rot = mCalcAngles(coordinates[idx], close_centers[i])
+                r = R.from_euler('ZYZ', rot, degrees=True)
+                orientations[idx,:3,:3] = r.inv().as_matrix()  
+
+        # Swap z and x coordinates (0 and 2) before scaling Back to Angstroms
+        coordinates[:, [0, 2]] = coordinates[:, [2, 0]]
+        coordinates = coordinates * voxel_size
+        
+        # Save the close points in CoPick project
+        if len(close_indices) > 0:
+            try:
+                close_picks = run.new_picks(object_name=picks_info[0], user_id=save_user_id, session_id=save_session_id)
+            except:
+                close_picks = run.get_picks(object_name=picks_info[0], user_id=save_user_id, session_id=save_session_id)[0]
+            close_picks.from_numpy(coordinates[close_indices], orientations[close_indices])
+
+        # Save the far points Coordinates in another CoPick pick
+        if len(far_indices) > 0:                       
+            try:
+                far_picks = run.new_picks(object_name=picks_info[0], user_id=save_user_id, session_id=new_session_id)
+            except:
+                far_picks = run.get_picks(object_name=picks_info[0], user_id=save_user_id, session_id=new_session_id)[0]
+
+            # Assume We Don't Know The Orientation for Anything Far From Membranes
+            empty_orientations =  np.zeros(orientations[far_indices].shape)
+            empty_orientations[:,-1,-1] = 1
+            far_picks.from_numpy(coordinates[far_indices], empty_orientations)
+
+
+def organelle_points(mask, xyz_order=False): 
+
+    unique_labels = np.unique(mask)
+    unique_labels = unique_labels[unique_labels > 0]  # Ignore background (label 0)
+
+    coordinates = {}
+    for label in unique_labels:
+        center_of_mass = ndi.center_of_mass(mask == label)
+        if xyz_order:
+            center_of_mass = center_of_mass[::-1]
+        coordinates[str(label)] = center_of_mass
+        # coordinates[str(label)] = ndimage.center_of_mass(mask == label)
+    return coordinates     
+
+def closest_organelle_points(mask, coords, min_distance = 0, max_distance=float('inf'), return_labels_array=False):
+    """
+    Filter points in `coords` based on their proximity to the lysosome membrane.
+
+    Args:
+        mask (numpy.ndarray): 3D segmentation mask with integer labels.
+        coords (numpy.ndarray): Array of shape (N, 3) with 3D coordinates.
+        min_distance (float): Minimum distance threshold for a point to be considered.
+        max_distance (float): Maximum distance threshold for a point to be considered.
+        return_labels_array (bool): Whether to return the labels array matching the
+                                    original order of coords.
+
+    Returns:
+        dict: A dictionary where keys are mask labels and values are lists of points
+              (3D coordinates) within the specified distance range.
+        numpy.ndarray (optional): Array of shape (N,) with the label for each coordinate,
+                                   or -1 if the point is outside the specified range.
+                                   Only returned if `return_labels_array=True`.
+    """
+
+    unique_labels = np.unique(mask)
+    unique_labels = unique_labels[unique_labels > 0]  # Ignore background (label 0)
+
+    # Combine all mask points and keep track of their labels
+    all_mask_points = []
+    all_labels = []
+    for label in unique_labels:
+        label_points = np.argwhere(mask == label)
+        all_mask_points.append(label_points)
+        all_labels.extend([label] * len(label_points))
+
+    # Combine all mask points and labels into arrays
+    all_mask_points = np.vstack(all_mask_points)
+    all_labels = np.array(all_labels)    
+
+    # Initialize a dictionary to store filtered points for each label
+    label_to_filtered_points = {label: [] for label in unique_labels}
+    label_to_filtered_points['far'] = []  # Initialize 'far' key to store rejected points    
+
+    # Initialize an array to store the closest label or -1 for out-of-range points
+    closest_labels = np.full(len(coords), -1, dtype=int)
+
+    # Compute the closest label and filter based on distance
+    for i, coord in enumerate(coords):
+        distances = np.linalg.norm(all_mask_points - coord, axis=1)
+        min_index = np.argmin(distances)
+        closest_label = all_labels[min_index]
+        min_distance_to_membrane = distances[min_index]
+
+        # Check if the distance is within the allowed range
+        if min_distance <= min_distance_to_membrane <= max_distance:
+            closest_labels[i] = closest_label
+            label_to_filtered_points[closest_label].append(coord)
+        else:
+            label_to_filtered_points['far'].append(coord)
+
+    # Convert lists to NumPy arrays for easier handling
+    for label in label_to_filtered_points:
+        label_to_filtered_points[label] = np.array(label_to_filtered_points[label])
+
+    if return_labels_array:
+        return label_to_filtered_points, closest_labels
+    else:
+        # Concatenate all points into a single NumPy array
+        concatenated_points = np.vstack([points for points in label_to_filtered_points.values() if points.size > 0])        
+        return concatenated_points
+
+# Create Class to Estimate Eulers from Centers of Lysate
+def mCalcAngles(mbProtein, membrane_point):
+
+    deltaX = mbProtein[0] - membrane_point[0]
+    deltaY = mbProtein[1] - membrane_point[1]
+    deltaZ = mbProtein[2] - membrane_point[2]
+    #-----------------------------
+    # angRotion is in [-180, 180]
+    #-----------------------------
+    angRot = math.atan(deltaY / (deltaX + 1e-30))
+    angRot *= (180 / math.pi)
+    if deltaX < 0 and deltaY > 0:
+        angRot += 180
+    elif deltaX < 0 and deltaY < 0:
+        angRot -= 180
+    angRot = float("{:.2f}".format(angRot))
+    #------------------------
+    # angTilt is in [0, 180]
+    #------------------------
+    rXY = math.sqrt(deltaX * deltaX + deltaY * deltaY)
+    angTilt = math.atan(rXY / (deltaZ + 1e-30))
+    angTilt *= (180 / math.pi)
+    if angTilt < 0:
+        angTilt += 180.0
+    angTilt = float("{:.2f}".format(angTilt))
+
+    return (angRot, angTilt, 0) 

octopi/extract/midpoint_extract.py

@@ -0,0 +1,193 @@
+from octopi.extract import membranebound_extract as extract
+from scipy.spatial.transform import Rotation as R
+from octopi import io
+from scipy.spatial import cKDTree
+from typing import Tuple
+import numpy as np
+
+def process_midpoint_extract(
+    run, 
+    voxel_size: float, 
+    picks_info: Tuple[str, str, str],
+    organelle_info: Tuple[str, str, str],
+    distance_min: float, distance_max: float, 
+    distance_threshold: float,
+    save_session_id: str):
+
+    """
+    Process coordinates and extract the mid-point between two neighbor coordinates.
+
+    Args:
+        run: CoPick run object.
+        voxel_size: Voxel size for coordinate scaling.
+        picks_info: Tuple of picks name, user_id, and session_id.
+        distance_min: Minimum distance for valid nearest neighbors.
+        distance_max: Maximum distance for valid nearest neighbors.
+        save_user_id: User ID to save the new picks.
+        save_session_id: Session ID to save the new picks.
+    """
+
+    # Pull Picks that Are used for Midpoint Extraction
+    coordinates = io.get_copick_coordinates(
+        run, 
+        picks_info[0], picks_info[1], picks_info[2],
+        voxel_size
+    )
+    nPoints = len(coordinates)
+    
+    # Create Base Query for Saving Picks
+    save_picks_info = list(picks_info)
+    save_picks_info[2] = save_session_id
+
+    # Get Organelle Segmentation
+    seg = io.get_segmentation_array(
+        run, 
+        voxel_size, 
+        organelle_info[0],
+        user_id=organelle_info[1], 
+        session_id=organelle_info[2],
+        raise_error=False
+    )
+    # If No Segmentation is Found, Return
+    if seg is None: return     
+    elif nPoints == 0 or np.unique(seg).max() == 0:
+        print(f'[Warning] RunID: {run.name} - Seg Unique Values: {np.unique(seg)}, nPoints: {nPoints}')
+        return        
+
+    if nPoints > 0:
+
+        # Step 1: Find Closest Points to Segmentation of Interest
+        points, closest_labels = extract.closest_organelle_points(
+            seg, 
+            coordinates, 
+            max_distance=distance_threshold, 
+            return_labels_array=True
+        )
+    
+        # Step 2: Find Midpoints of Closest Points
+        midpoints, endpoints = find_midpoints_in_range(
+            points, 
+            distance_min, 
+            distance_max
+        )
+        
+        # Only Process and Save if There Are Any Midpoints
+        if len(midpoints) > 0:
+
+            # Step 3: Get Organelle Centers (Optional if an organelle segmentation is provided)
+            organelle_centers = extract.organelle_points(seg)
+
+            save_picks_info[1] = picks_info[1] + '-midpoint'
+            save_oriented_points(
+                run, voxel_size, 
+                midpoints, 
+                organelle_centers,
+                save_picks_info
+            )
+
+            save_picks_info[1] = picks_info[1] + '-endpoint'
+            save_oriented_points(
+                run, voxel_size, 
+                endpoints, 
+                organelle_centers,
+                save_picks_info
+            )
+
+def find_midpoints_in_range(lysosome_points, min_distance, max_distance):
+    """
+    Compute the midpoints of all nearest-neighbor pairs within a given distance range.
+    
+    Args:
+        lysosome_points (dict): A dictionary where keys are lysosome labels and values
+                                are NumPy arrays of points associated with each label.
+        min_distance (float): Minimum distance for valid nearest neighbors.
+        max_distance (float): Maximum distance for valid nearest neighbors.
+    
+    Returns:
+        dict: A dictionary where keys are lysosome labels and values are arrays of midpoints
+              for pairs within the specified distance range.
+        dict: A dictionary where keys are lysosome labels and values are arrays of endpoints
+    """
+    midpoints = {}
+    endpoints = {}
+    
+    for label, points in lysosome_points.items():
+        if len(points) < 2:
+            # Skip if fewer than 2 points (no neighbors to compute)
+            midpoints[label] = np.array([])
+            continue
+        
+        # Use cKDTree for efficient neighbor queries
+        tree = cKDTree(points)
+        distances, indices = tree.query(points, k=2)  # k=2 gets the closest neighbor only
+        
+        valid_pairs = set()  # Use a set to avoid duplicate pairings
+        
+        for i, (dist, neighbor_idx) in enumerate(zip(distances[:, 1], indices[:, 1])):
+            if min_distance <= dist <= max_distance:
+                # Ensure the pair is only added once (sorted tuple prevents duplicates)
+                pair = tuple(sorted((i, neighbor_idx)))
+                valid_pairs.add(pair)
+        
+        # Calculate midpoints for unique valid pairs
+        midpoints[label] = np.array([
+            (points[i] + points[j]) / 2 for i, j in valid_pairs
+        ])
+
+        # Get Endpoints
+        endpoint_pairs = np.array([
+            (points[i], points[j]) for i, j in valid_pairs
+        ])
+        unique_endpoints = np.unique(endpoint_pairs.reshape(-1, 3), axis=0)
+        endpoints[label] = unique_endpoints
+
+    # Return EndPoints and Midpoints
+    return midpoints, endpoints
+
+# Assuming `test` is the dictionary or list of arrays
+def concatenate_all_midpoints(midpoints_dict):
+    """
+    Concatenate all arrays of midpoints into a single NumPy array.
+    
+    Args:
+        midpoints_dict (dict): Dictionary with lysosome labels as keys and arrays of midpoints as values.
+    
+    Returns:
+        numpy.ndarray: Single concatenated array of all midpoints.
+    """
+    all_midpoints = [midpoints for midpoints in midpoints_dict.values() if len(midpoints) > 0]
+    if all_midpoints:
+        concatenated_array = np.vstack(all_midpoints)
+    else:
+        concatenated_array = np.array([])  # Return an empty array if no midpoints exist
+    return concatenated_array
+
+
+
+def save_oriented_points(run, voxel_size, points, organelle_centers, picks_info):
+
+    # Step 5: Concatenate All Midpoints
+    concatenated_points = concatenate_all_midpoints(points)   
+    nPoints = concatenated_points.shape[0]
+
+    # Initialize orientations array
+    orientations = np.zeros([nPoints, 4, 4])
+    orientations[:,3,3] = 1 
+
+    # Step 4: Get Rotation Matrices from Euler Angles Based on Normal Vector
+    idx = 0
+    for key, points in points.items():
+        if points.size > 0:
+            for point in points:
+                rot = extract.mCalcAngles(point, organelle_centers[str(key)])
+                r = R.from_euler('ZYZ', rot, degrees=True)
+                orientations[idx,:3,:3] = r.inv().as_matrix() 
+                idx += 1
+        
+    # Swap z and x coordinates (0 and 2) before scaling Back to Angstroms
+    concatenated_points[:, [0, 2]] = concatenated_points[:, [2, 0]]
+    concatenated_points = concatenated_points * voxel_size
+
+    # Step 4: Save Midpoints to Copick
+    close_picks = run.new_picks(object_name=picks_info[0], user_id=picks_info[1], session_id=picks_info[2])
+    close_picks.from_numpy(concatenated_points, orientations)