octopi 1.4.0__py3-none-any.whl

octopi/extract/localize.py

@@ -0,0 +1,217 @@
+from skimage.morphology import binary_opening, ball
+from scipy.sparse.csgraph import connected_components
+from skimage.segmentation import watershed
+from scipy.sparse import coo_matrix
+from scipy.spatial import cKDTree
+
+from typing import List, Optional, Tuple
+from skimage.measure import regionprops_table
+from copick_utils.io import readers
+import scipy.ndimage as ndi
+from tqdm import tqdm
+import numpy as np
+
+FOUR_THIRDS_PI = 4.0/3.0 * np.pi  # reuse
+
+def process_localization(run,  
+                          objects, 
+                          seg_info: Tuple[str, str, str],
+                          method: str = 'com', 
+                          voxel_size: float = 10,
+                          filter_size: int = None,
+                          radius_min_scale: float = 0.5, 
+                          radius_max_scale: float = 1.0,
+                          pick_session_id: str = '1',
+                          pick_user_id: str = 'monai'): 
+
+    # Check if method is valid
+    if method not in ['watershed', 'com']:
+        raise ValueError(f"Invalid method '{method}'. Expected 'watershed' or 'com'.")
+
+    # Get Segmentation with Error Handling
+    try:
+        seg = readers.segmentation(
+            run, float(voxel_size), 
+            seg_info[0], 
+            user_id=seg_info[1], 
+            session_id=seg_info[2],
+            raise_error=False)
+
+        # Preprocess Segmentation
+        # seg = preprocess_segmentation(seg, voxel_size, objects)
+
+        # If No Segmentation is Found, Return
+        if seg is None:
+            print(f"No segmentation found for {run.name}.")
+            return
+
+    except Exception as e:
+        print(f"[ERROR] - Occurred while reading segmentation from {run.name}: {e}")
+        return
+    
+    # Iterate through all user pickable objects
+    for obj in objects:
+
+        # Extract Particle Radius from Root
+        min_radius = obj[2] * radius_min_scale / voxel_size
+        max_radius = obj[2] * radius_max_scale / voxel_size
+
+        if method == 'watershed':
+            points = extract_particle_centroids_via_watershed(seg, obj[1], filter_size, min_radius, max_radius)
+        elif method == 'com': 
+            points = extract_particle_centroids_via_com(seg, obj[1], min_radius, max_radius)
+        points = np.array(points)
+
+        # Save Coordinates if any 3D points are provided
+        if points.size > 2:
+
+            # Remove Picks that are too close to each other
+            points = remove_repeated_picks(points, min_radius)
+
+            # Swap the coordinates to match the expected format
+            points = points[:,[2,1,0]] 
+
+            # Convert the Picks back to Angstrom
+            points *= voxel_size
+
+            # Save Picks - Overwrite if exists
+            picks = run.new_picks(
+                object_name = obj[0], session_id = pick_session_id, 
+                user_id=pick_user_id, exist_ok=True)
+
+            # Assign Identity As Orientation
+            orientations = np.zeros([points.shape[0], 4, 4])
+            orientations[:,:3,:3] = np.identity(3)
+            orientations[:,3,3] = 1
+
+            picks.from_numpy( points, orientations )
+        else:
+            print(f"{run.name} didn't have any available picks for {obj[0]}!")
+
+
+def extract_particle_centroids_via_watershed(
+    segmentation,
+    segmentation_idx,
+    maxima_filter_size,
+    min_particle_radius,
+    max_particle_radius
+):
+    if not maxima_filter_size or maxima_filter_size <= 0:
+        raise ValueError("Enter a Non-Zero Filter Size!")
+
+    # volumes from radii
+    min_sz = FOUR_THIRDS_PI * (min_particle_radius ** 3)
+    max_sz = FOUR_THIRDS_PI * (max_particle_radius ** 3)
+
+    # boolean mask; early exit
+    mask = (segmentation == segmentation_idx)
+    if not mask.any():
+        print(f"No segmentation with label {segmentation_idx} found.")
+        return []
+
+    # --- crop to bbox to shrink problem size ---
+    z, y, x = np.where(mask)
+    z0, z1 = z.min(), z.max() + 1
+    y0, y1 = y.min(), y.max() + 1
+    x0, x1 = x.min(), x.max() + 1
+    mask_c = mask[z0:z1, y0:y1, x0:x1]
+
+    # --- single-pass morphology (speeds + denoise speckles) ---
+    opened = binary_opening(mask_c, ball(1))  # bool in, bool out
+    if not opened.any():
+        return []
+
+    # --- EDT on bool, result as float32 ---
+    dist = ndi.distance_transform_edt(opened).astype(np.float32, copy=False)
+
+    # --- fast local maxima via maximum_filter ---
+    fp = np.ones((maxima_filter_size,)*3, dtype=bool)
+    local_max = (dist == ndi.maximum_filter(dist, footprint=fp))
+    local_max &= opened  # restrict to mask; avoids borders/zeros
+
+    # markers
+    markers, _ = ndi.label(local_max)
+    if markers.max() == 0:
+        return []
+
+    # --- watershed on cropped ROI ---
+    # connectivity=1 (6-neigh) is a bit faster; adjust if you relied on 26-neigh
+    labels_ws = watershed(-dist, markers=markers, mask=opened)
+
+    # --- vectorized properties & size filter ---
+    props = regionprops_table(labels_ws, properties=("area", "centroid"))
+    area = np.asarray(props["area"])
+    cz = np.asarray(props["centroid-0"])
+    cy = np.asarray(props["centroid-1"])
+    cx = np.asarray(props["centroid-2"])
+
+    keep = (area >= min_sz) & (area <= max_sz)
+    if not np.any(keep):
+        return []
+
+    # add back the crop offset; output as (z,y,x) to match your downstream swap
+    cz += z0
+    cy += y0
+    cx += x0
+    return list(zip(cz[keep], cy[keep], cx[keep]))
+
+def extract_particle_centroids_via_com(
+        segmentation, 
+        segmentation_idx, 
+        min_particle_radius, 
+        max_particle_radius
+    ):
+    """
+    Process a specific label in the segmentation, extract centroids, and save them as picks.
+
+    Args:
+        segmentation (np.ndarray): Multilabel segmentation array.
+        segmentation_idx (int): The specific label from the segmentation to process.
+        min_particle_size (int): Minimum size threshold for particles.
+        max_particle_size (int): Maximum size threshold for particles.
+    """
+
+    # Calculate minimum and maximum particle volumes based on the given radii
+    min_particle_size = (4 / 3) * np.pi * (min_particle_radius ** 3) 
+    max_particle_size = (4 / 3) * np.pi * (max_particle_radius ** 3)
+
+    # Create a binary mask for the specific segmentation label
+    label_objs, _ = ndi.label(segmentation == segmentation_idx)
+
+    # Filter Candidates based on Object Size
+    # Get the sizes of all objects
+    object_sizes = np.bincount(label_objs.flat)
+
+    # Filter the objects based on size
+    valid_objects = np.where((object_sizes > min_particle_size) & (object_sizes < max_particle_size))[0]                        
+
+    # Estimate Coordiantes from CoM for LabelMaps
+    octopiCoords = []
+    for object_num in tqdm(valid_objects):
+        com = ndi.center_of_mass(label_objs == object_num)
+        swapped_com = (com[2], com[1], com[0])
+        octopiCoords.append(swapped_com)
+   
+    return octopiCoords
+
+def remove_repeated_picks(coordinates: np.ndarray,
+                               distance_threshold: float) -> np.ndarray:
+    if coordinates is None or len(coordinates) == 0:
+        return coordinates
+    if len(coordinates) == 1:
+        return coordinates.copy()
+
+    pts = coordinates[:, :3]
+    tree = cKDTree(pts)
+    # Sparse neighbor graph: edges between points within threshold
+    pairs = tree.sparse_distance_matrix(tree, distance_threshold, output_type='coo_matrix')
+    n = len(coordinates)
+    # Make it symmetric and include self-loops
+    A = coo_matrix((np.ones_like(pairs.data), (pairs.row, pairs.col)), shape=(n, n))
+    A = A.maximum(A.T)  # undirected
+    A.setdiag(1)
+
+    n_comp, labels = connected_components(A, directed=False)
+    out = np.vstack([coordinates[labels == k].mean(axis=0) for k in range(n_comp)])
+    return out
+

octopi/extract/membranebound_extract.py

@@ -0,0 +1,263 @@
+from scipy.spatial.transform import Rotation as R
+from copick_utils.io import readers
+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 = readers.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 = readers.segmentation(
+            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 = readers.segmentation(
+            run, 
+            voxel_size, 
+            membrane_info[0],
+            user_id=membrane_info[1], 
+            session_id=membrane_info[2],
+            raise_error=False)
+
+        organelle_seg = readers.segmentation(
+            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 copick_utils.io import readers
+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 = readers.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 = readers.segmentation(
+        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)