nettracer3d 0.9.9__tar.gz → 1.0.1__tar.gz

{nettracer3d-0.9.9/src/nettracer3d.egg-info → nettracer3d-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.9.9
+Version: 1.0.1
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,7 +110,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.9.9 Updates --
+-- Version 1.0.1 Updates --
 
-	* Tables can now be opened to the rightside upper widget if they are the right format.
-	* Similarly, tables that have the format node id column:numerical values can now be used liberally to threshold the nodes, meaning most outputs of network analysis can be used to threshold nodes.
+	* Bug fixes, mainly

{nettracer3d-0.9.9 → nettracer3d-1.0.1}/README.md

@@ -65,7 +65,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.9.9 Updates --
+-- Version 1.0.1 Updates --
 
-	* Tables can now be opened to the rightside upper widget if they are the right format.
-	* Similarly, tables that have the format node id column:numerical values can now be used liberally to threshold the nodes, meaning most outputs of network analysis can be used to threshold nodes.
+	* Bug fixes, mainly

{nettracer3d-0.9.9 → nettracer3d-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.9.9"
+version = "1.0.1"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]

{nettracer3d-0.9.9 → nettracer3d-1.0.1}/src/nettracer3d/community_extractor.py

@@ -733,17 +733,33 @@ def assign_node_colors(node_list: List[int], labeled_array: np.ndarray) -> Tuple
     return rgba_array, node_to_color_names
 
 def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.ndarray) -> Tuple[np.ndarray, Dict[int, str]]:
-    """fast version using lookup table approach."""
+    """Fast version using lookup table approach with brown outliers for community 0."""
+    
+    # Separate outliers (community 0) from regular communities
+    outliers = {node: comm for node, comm in community_dict.items() if comm == 0}
+    non_outlier_dict = {node: comm for node, comm in community_dict.items() if comm != 0}
     
-    # Same setup as before
-    communities = set(community_dict.values())
-    community_sizes = Counter(community_dict.values())
-    sorted_communities = sorted(communities, key=lambda x: community_sizes[x], reverse=True)
+    # Get communities excluding outliers
+    communities = set(non_outlier_dict.values()) if non_outlier_dict else set()
     
-    colors = generate_distinct_colors(len(communities))
+    # Generate colors for non-outlier communities only
+    colors = generate_distinct_colors(len(communities)) if communities else []
     colors_rgba = np.array([(r, g, b, 255) for r, g, b in colors], dtype=np.uint8)
     
-    community_to_color = {comm: colors_rgba[i] for i, comm in enumerate(sorted_communities)}
+    # Sort communities by size for consistent color assignment
+    if non_outlier_dict:
+        community_sizes = Counter(non_outlier_dict.values())
+        sorted_communities = sorted(communities, key=lambda x: (-community_sizes[x], x))
+        community_to_color = {comm: colors_rgba[i] for i, comm in enumerate(sorted_communities)}
+    else:
+        community_to_color = {}
+    
+    # Add brown color for outliers (community 0)
+    brown_rgba = np.array([139, 69, 19, 255], dtype=np.uint8)  # Brown color
+    if outliers:
+        community_to_color[0] = brown_rgba
+    
+    # Create node to color mapping using original community_dict
     node_to_color = {node: community_to_color[comm] for node, comm in community_dict.items()}
     
     # Create lookup table - this is the key optimization
@@ -756,7 +772,7 @@ def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.nd
     # Single vectorized operation - this is much faster!
     rgba_array = color_lut[labeled_array]
     
-    # Rest remains the same
+    # Convert to RGB for color names (including brown for outliers)
     community_to_color_rgb = {k: tuple(v[:3]) for k, v in community_to_color.items()}
     node_to_color_names = convert_node_colors_to_names(community_to_color_rgb)
     

{nettracer3d-0.9.9 → nettracer3d-1.0.1}/src/nettracer3d/neighborhoods.py

@@ -347,7 +347,8 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
                                      id_dictionary: Optional[Dict[int, str]] = None, 
                                      graph_label = "Community ID",
                                      title = 'UMAP Visualization of Community Compositions',
-                                     neighborhoods: Optional[Dict[int, int]] = None):
+                                     neighborhoods: Optional[Dict[int, int]] = None,
+                                     original_communities = None):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -394,37 +395,50 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     embedding = reducer.fit_transform(compositions)
     
     # Determine coloring scheme based on parameters
-    if neighborhoods is not None:
+    if neighborhoods is not None and original_communities is not None:
         # Use neighborhood coloring - import the community extractor methods
         from . import community_extractor
+        from collections import Counter
         
-        # Filter neighborhoods to only include cluster_ids that exist in our data
-        filtered_neighborhoods = {node_id: neighborhood_id 
-                                for node_id, neighborhood_id in neighborhoods.items() 
-                                if node_id in cluster_ids}
+        # Use original_communities (which is {node: neighborhood}) for color generation
+        # This ensures we use the proper node counts for sorting
         
-        # Create a dummy labeled array just for the coloring function
-        # We only need the coloring logic, not actual clustering
-        dummy_array = np.array(cluster_ids)
+        # Separate outliers (neighborhood 0) from regular neighborhoods in ORIGINAL structure
+        outlier_neighborhoods = {node: neighborhood for node, neighborhood in original_communities.items() if neighborhood == 0}
+        non_outlier_neighborhoods = {node: neighborhood for node, neighborhood in original_communities.items() if neighborhood != 0}
         
-        # Get colors using the community coloration method
-        _, neighborhood_color_names = community_extractor.assign_community_colors(
-            filtered_neighborhoods, dummy_array
-        )
+        # Get neighborhoods excluding outliers
+        unique_neighborhoods = set(non_outlier_neighborhoods.values()) if non_outlier_neighborhoods else set()
         
-        # Create color mapping for our points
-        unique_neighborhoods = sorted(list(set(filtered_neighborhoods.values())))
-        colors = community_extractor.generate_distinct_colors(len(unique_neighborhoods))
-        neighborhood_to_color = {neighborhood: colors[i] for i, neighborhood in enumerate(unique_neighborhoods)}
+        # Generate colors for non-outlier neighborhoods only (same as assign_community_colors)
+        colors = community_extractor.generate_distinct_colors(len(unique_neighborhoods)) if unique_neighborhoods else []
         
-        # Map each cluster to its neighborhood color
+        # Sort neighborhoods by size for consistent color assignment (same logic as assign_community_colors)
+        # Use the ORIGINAL node counts from original_communities
+        if non_outlier_neighborhoods:
+            neighborhood_sizes = Counter(non_outlier_neighborhoods.values())
+            sorted_neighborhoods = sorted(unique_neighborhoods, key=lambda x: (-neighborhood_sizes[x], x))
+            neighborhood_to_color = {neighborhood: colors[i] for i, neighborhood in enumerate(sorted_neighborhoods)}
+        else:
+            neighborhood_to_color = {}
+        
+        # Add brown color for outliers (neighborhood 0) - same as assign_community_colors
+        if outlier_neighborhoods:
+            neighborhood_to_color[0] = (139, 69, 19)  # Brown color (RGB, not RGBA here)
+        
+        # Map each cluster to its neighborhood color using 'neighborhoods' ({community: neighborhood}) for assignment
         point_colors = []
         neighborhood_labels = []
         for cluster_id in cluster_ids:
-            if cluster_id in filtered_neighborhoods:
-                neighborhood_id = filtered_neighborhoods[cluster_id]
-                point_colors.append(neighborhood_to_color[neighborhood_id])
-                neighborhood_labels.append(neighborhood_id)
+            if cluster_id in neighborhoods:
+                neighborhood_id = neighborhoods[cluster_id]  # This is {community: neighborhood}
+                if neighborhood_id in neighborhood_to_color:
+                    point_colors.append(neighborhood_to_color[neighborhood_id])
+                    neighborhood_labels.append(neighborhood_id)
+                else:
+                    # Default color for neighborhoods not found
+                    point_colors.append((128, 128, 128))  # Gray
+                    neighborhood_labels.append("Unknown")
             else:
                 # Default color for nodes not in any neighborhood
                 point_colors.append((128, 128, 128))  # Gray
@@ -432,6 +446,10 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         
         # Normalize RGB values for matplotlib (0-1 range)
         point_colors = [(r/255.0, g/255.0, b/255.0) for r, g, b in point_colors]
+        
+        # Get unique neighborhoods for legend
+        unique_neighborhoods_for_legend = sorted(list(set(neighborhood_to_color.keys())))
+        
         use_neighborhood_coloring = True
         
     elif id_dictionary is not None:
@@ -467,8 +485,8 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
             # Add cluster ID labels
             for i, cluster_id in enumerate(cluster_ids):
                 display_label = f'{cluster_id}'
-                if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
-                    neighborhood_id = filtered_neighborhoods[cluster_id]
+                if use_neighborhood_coloring and cluster_id in neighborhoods:
+                    neighborhood_id = neighborhoods[cluster_id]
                     display_label = f'{cluster_id}\n(N{neighborhood_id})'
                 elif id_dictionary is not None:
                     identity = id_dictionary.get(cluster_id, "Unknown")
@@ -483,7 +501,7 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         if use_neighborhood_coloring:
             # Create custom legend for neighborhoods
             legend_elements = []
-            for neighborhood_id in unique_neighborhoods:
+            for neighborhood_id in unique_neighborhoods_for_legend:
                 color = neighborhood_to_color[neighborhood_id]
                 norm_color = (color[0]/255.0, color[1]/255.0, color[2]/255.0)
                 legend_elements.append(
@@ -530,8 +548,8 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
             # Add cluster ID labels
             for i, cluster_id in enumerate(cluster_ids):
                 display_label = f'C{cluster_id}'
-                if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
-                    neighborhood_id = filtered_neighborhoods[cluster_id]
+                if use_neighborhood_coloring and cluster_id in neighborhoods:
+                    neighborhood_id = neighborhoods[cluster_id]
                     display_label = f'C{cluster_id}\n(N{neighborhood_id})'
                 elif id_dictionary is not None:
                     identity = id_dictionary.get(cluster_id, "Unknown")
@@ -554,7 +572,7 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         if use_neighborhood_coloring:
             # Create custom legend for neighborhoods
             legend_elements = []
-            for neighborhood_id in unique_neighborhoods:
+            for neighborhood_id in unique_neighborhoods_for_legend:
                 color = neighborhood_to_color[neighborhood_id]
                 norm_color = (color[0]/255.0, color[1]/255.0, color[2]/255.0)
                 legend_elements.append(
@@ -585,8 +603,8 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         for i, cluster_id in enumerate(cluster_ids):
             composition = compositions[i]
             additional_info = ""
-            if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
-                neighborhood_id = filtered_neighborhoods[cluster_id]
+            if use_neighborhood_coloring and cluster_id in neighborhoods:
+                neighborhood_id = neighborhoods[cluster_id]
                 additional_info = f" (Neighborhood: {neighborhood_id})"
             elif id_dictionary is not None:
                 identity = id_dictionary.get(cluster_id, "Unknown")

{nettracer3d-0.9.9 → nettracer3d-1.0.1}/src/nettracer3d/nettracer.py

@@ -992,6 +992,61 @@ def z_project(array3d, method='max'):
         raise ValueError("Method must be one of: 'max', 'mean', 'min', 'sum', 'std'")
 
 def fill_holes_3d(array, head_on = False, fill_borders = True):
+    def process_slice(slice_2d, border_threshold=0.08, fill_borders = True):
+        """
+        Process a 2D slice, considering components that touch less than border_threshold
+        of any border length as potential holes.
+        
+        Args:
+            slice_2d: 2D binary array
+            border_threshold: proportion of border that must be touched to be considered background
+        """
+        from scipy.ndimage import binary_fill_holes
+        
+        slice_2d = slice_2d.astype(np.uint8)
+
+        # Apply scipy's binary_fill_holes to the result
+        slice_2d = binary_fill_holes(slice_2d)
+        
+        return slice_2d
+        
+    print("Filling Holes...")
+    
+    array = binarize(array)
+    #inv_array = invert_array(array)
+    
+    # Create arrays for all three planes
+    array_xy = np.zeros_like(array, dtype=np.uint8)
+    array_xz = np.zeros_like(array, dtype=np.uint8)
+    array_yz = np.zeros_like(array, dtype=np.uint8)
+    
+    # Process XY plane
+    for z in range(array.shape[0]):
+        array_xy[z] = process_slice(array[z], fill_borders = fill_borders)
+        
+    if (array.shape[0] > 3) and not head_on: #only use these dimensions for sufficiently large zstacks
+        
+        # Process XZ plane    
+        for y in range(array.shape[1]):
+            slice_xz = array[:, y, :]
+            array_xz[:, y, :] = process_slice(slice_xz, fill_borders = fill_borders)
+            
+        # Process YZ plane
+        for x in range(array.shape[2]):
+            slice_yz = array[:, :, x]
+            array_yz[:, :, x] = process_slice(slice_yz, fill_borders = fill_borders)
+        
+        # Combine results from all three planes
+        filled = (array_xy | array_xz | array_yz) * 255
+        return array + filled
+    else:
+        # Apply scipy's binary_fill_holes to each XY slice
+        from scipy.ndimage import binary_fill_holes
+        for z in range(array_xy.shape[0]):
+            array_xy[z] = binary_fill_holes(array_xy[z])
+        return array_xy * 255
+
+def fill_holes_3d_old(array, head_on = False, fill_borders = True):
 
     def process_slice(slice_2d, border_threshold=0.08, fill_borders = True):
         """
@@ -5659,7 +5714,8 @@ class Network_3D:
                         neighbor_group[com] = neighbors[node]
                     except:
                         neighbor_group[com] = 0
-                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group)
+                print(neighbors)
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group, original_communities = neighbors)
             elif label == 1:
                 neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = True) 
             else:

{nettracer3d-0.9.9 → nettracer3d-1.0.1}/src/nettracer3d/nettracer_gui.py

@@ -1027,7 +1027,6 @@ class ImageViewerWindow(QMainWindow):
 
         """Highlight overlay generation method specific for the segmenter interactive mode"""
 
-
         def process_chunk_bounds(chunk_data, indices_to_check):
             """Process a single chunk of the array to create highlight mask"""
             mask = (chunk_data >= indices_to_check[0]) & (chunk_data <= indices_to_check[1])
@@ -1106,6 +1105,30 @@ class ImageViewerWindow(QMainWindow):
             current_ylim = self.ax.get_ylim()
             self.update_display_pan_mode(current_xlim, current_ylim)
 
+        if my_network.network is not None:
+            try:
+                if self.active_channel == 0:
+
+                    # Get the existing DataFrame from the model
+                    original_df = self.network_table.model()._data
+                    
+                    # Create mask for rows where one column is any original node AND the other column is any neighbor
+                    mask = (
+                        (original_df.iloc[:, 0].isin(indices)) &
+                        (original_df.iloc[:, 1].isin(indices)))
+                    
+                    # Filter the DataFrame to only include direct connections
+                    filtered_df = original_df[mask].copy()
+                    
+                    # Create new model with filtered DataFrame and update selection table
+                    new_model = PandasModel(filtered_df)
+                    self.selection_table.setModel(new_model)
+                    
+                    # Switch to selection table
+                    self.selection_button.click()
+            except:
+                pass
+
 
 
     def create_mini_overlay(self, node_indices = None, edge_indices = None):
@@ -1297,32 +1320,40 @@ class ImageViewerWindow(QMainWindow):
                 # Create measurement submenu
                 measure_menu = context_menu.addMenu("Measurements")
                 
-                # Distance measurement options
                 distance_menu = measure_menu.addMenu("Distance")
                 if self.current_point is None:
                     show_point_menu = distance_menu.addAction("Place First Point")
                     show_point_menu.triggered.connect(
                         lambda: self.place_distance_point(x_idx, y_idx, self.current_slice))
-                else:
+                elif (self.current_point is not None and 
+                      hasattr(self, 'measurement_mode') and 
+                      self.measurement_mode == "distance"):
                     show_point_menu = distance_menu.addAction("Place Second Point")
                     show_point_menu.triggered.connect(
                         lambda: self.place_distance_point(x_idx, y_idx, self.current_slice))
-                
+
                 # Angle measurement options
                 angle_menu = measure_menu.addMenu("Angle")
                 if self.current_point is None:
                     angle_first = angle_menu.addAction("Place First Point (A)")
                     angle_first.triggered.connect(
                         lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
-                elif self.current_second_point is None:
+                elif (self.current_point is not None and 
+                      self.current_second_point is None and 
+                      hasattr(self, 'measurement_mode') and 
+                      self.measurement_mode == "angle"):
                     angle_second = angle_menu.addAction("Place Second Point (B - Vertex)")
                     angle_second.triggered.connect(
                         lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
-                else:
+                elif (self.current_point is not None and 
+                      self.current_second_point is not None and 
+                      hasattr(self, 'measurement_mode') and 
+                      self.measurement_mode == "angle"):
                     angle_third = angle_menu.addAction("Place Third Point (C)")
                     angle_third.triggered.connect(
                         lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
                 
+                
                 show_remove_menu = measure_menu.addAction("Remove All Measurements")
                 show_remove_menu.triggered.connect(self.handle_remove_all_measurements)
                 
@@ -1350,15 +1381,22 @@ class ImageViewerWindow(QMainWindow):
             except IndexError:
                 pass
 
-
     def place_distance_point(self, x, y, z):
         """Place a measurement point for distance measurement."""
         if self.current_point is None:
             # This is the first point
             self.current_point = (x, y, z)
-            self.ax.plot(x, y, 'yo', markersize=8)
-            self.ax.text(x, y+5, f"D{self.current_pair_index}", 
+            
+            # Create and store the artists
+            pt = self.ax.plot(x, y, 'yo', markersize=8)[0]
+            txt = self.ax.text(x, y+5, f"D{self.current_pair_index}", 
                         color='yellow', ha='center', va='bottom')
+            
+            # Add to measurement_artists so they can be managed by update_display
+            if not hasattr(self, 'measurement_artists'):
+                self.measurement_artists = []
+            self.measurement_artists.extend([pt, txt])
+            
             self.canvas.draw()
             self.measurement_mode = "distance"
         else:
@@ -1372,21 +1410,28 @@ class ImageViewerWindow(QMainWindow):
                               ((z2-z1)*my_network.z_scale)**2)
             distance2 = np.sqrt(((x2-x1))**2 + ((y2-y1))**2 + ((z2-z1))**2)
             
-            # Store the point pair
+            # Store the point pair with type indicator
             self.measurement_points.append({
                 'pair_index': self.current_pair_index,
                 'point1': self.current_point,
                 'point2': (x2, y2, z2),
                 'distance': distance,
-                'distance2': distance2
+                'distance2': distance2,
+                'type': 'distance'  # Added type tracking
             })
             
-            # Draw second point and line
-            self.ax.plot(x2, y2, 'yo', markersize=8)
-            self.ax.text(x2, y2+5, f"D{self.current_pair_index}", 
+            # Draw second point and line, storing the artists
+            pt2 = self.ax.plot(x2, y2, 'yo', markersize=8)[0]
+            txt2 = self.ax.text(x2, y2+5, f"D{self.current_pair_index}", 
                         color='yellow', ha='center', va='bottom')
+            
+            # Add to measurement_artists
+            self.measurement_artists.extend([pt2, txt2])
+            
             if z1 == z2:  # Only draw line if points are on same slice
-                self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+                line = self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)[0]
+                self.measurement_artists.append(line)
+                
             self.canvas.draw()
             
             # Update measurement display
@@ -1399,12 +1444,19 @@ class ImageViewerWindow(QMainWindow):
 
     def place_angle_point(self, x, y, z):
         """Place a measurement point for angle measurement."""
+        if not hasattr(self, 'measurement_artists'):
+            self.measurement_artists = []
+            
         if self.current_point is None:
             # First point (A)
             self.current_point = (x, y, z)
-            self.ax.plot(x, y, 'go', markersize=8)
-            self.ax.text(x, y+5, f"A{self.current_trio_index}", 
+            
+            # Create and store artists
+            pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+            txt = self.ax.text(x, y+5, f"A{self.current_trio_index}", 
                         color='green', ha='center', va='bottom')
+            self.measurement_artists.extend([pt, txt])
+            
             self.canvas.draw()
             self.measurement_mode = "angle"
             
@@ -1413,13 +1465,16 @@ class ImageViewerWindow(QMainWindow):
             self.current_second_point = (x, y, z)
             x1, y1, z1 = self.current_point
             
-            self.ax.plot(x, y, 'go', markersize=8)
-            self.ax.text(x, y+5, f"B{self.current_trio_index}", 
+            # Create and store artists
+            pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+            txt = self.ax.text(x, y+5, f"B{self.current_trio_index}", 
                         color='green', ha='center', va='bottom')
+            self.measurement_artists.extend([pt, txt])
             
             # Draw line from A to B
             if z1 == z:
-                self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)
+                line = self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)[0]
+                self.measurement_artists.append(line)
             self.canvas.draw()
             
         else:
@@ -1442,7 +1497,7 @@ class ImageViewerWindow(QMainWindow):
                 **angle_data
             })
             
-            # Also add the two distances as separate pairs
+            # Also add the two distances as separate pairs with type indicator
             dist_ab = np.sqrt(((x2-x1)*my_network.xy_scale)**2 + 
                              ((y2-y1)*my_network.xy_scale)**2 + 
                              ((z2-z1)*my_network.z_scale)**2)
@@ -1459,24 +1514,28 @@ class ImageViewerWindow(QMainWindow):
                     'point1': (x1, y1, z1),
                     'point2': (x2, y2, z2),
                     'distance': dist_ab,
-                    'distance2': dist_ab_voxel
+                    'distance2': dist_ab_voxel,
+                    'type': 'angle'  # Added type tracking
                 },
                 {
                     'pair_index': f"B{self.current_trio_index}-C{self.current_trio_index}",
                     'point1': (x2, y2, z2),
                     'point2': (x3, y3, z3),
                     'distance': dist_bc,
-                    'distance2': dist_bc_voxel
+                    'distance2': dist_bc_voxel,
+                    'type': 'angle'  # Added type tracking
                 }
             ])
             
-            # Draw third point and line
-            self.ax.plot(x3, y3, 'go', markersize=8)
-            self.ax.text(x3, y3+5, f"C{self.current_trio_index}", 
+            # Draw third point and line, storing artists
+            pt3 = self.ax.plot(x3, y3, 'go', markersize=8)[0]
+            txt3 = self.ax.text(x3, y3+5, f"C{self.current_trio_index}", 
                         color='green', ha='center', va='bottom')
+            self.measurement_artists.extend([pt3, txt3])
             
             if z2 == z3:  # Draw line from B to C if on same slice
-                self.ax.plot([x2, x3], [y2, y3], 'g--', alpha=0.7)
+                line = self.ax.plot([x2, x3], [y2, y3], 'g--', alpha=0.7)[0]
+                self.measurement_artists.append(line)
             self.canvas.draw()
             
             # Update measurement display
@@ -1488,6 +1547,7 @@ class ImageViewerWindow(QMainWindow):
             self.current_trio_index += 1
             self.measurement_mode = "angle"
 
+
     def calculate_3d_angle(self, point_a, point_b, point_c):
         """Calculate 3D angle at vertex B between points A-B-C."""
         x1, y1, z1 = point_a
@@ -1802,23 +1862,27 @@ class ImageViewerWindow(QMainWindow):
 
                 nodes = list(set(nodes))
 
-                # Get the existing DataFrame from the model
-                original_df = self.network_table.model()._data
+                try:
 
-                # Create mask for rows for nodes in question
-                mask = (
-                    (original_df.iloc[:, 0].isin(nodes) & original_df.iloc[:, 1].isin(nodes))
-                    )
-                
-                # Filter the DataFrame to only include direct connections
-                filtered_df = original_df[mask].copy()
-                
-                # Create new model with filtered DataFrame and update selection table
-                new_model = PandasModel(filtered_df)
-                self.selection_table.setModel(new_model)
-                
-                # Switch to selection table
-                self.selection_button.click()
+                    # Get the existing DataFrame from the model
+                    original_df = self.network_table.model()._data
+
+                    # Create mask for rows for nodes in question
+                    mask = (
+                        (original_df.iloc[:, 0].isin(nodes) & original_df.iloc[:, 1].isin(nodes))
+                        )
+                    
+                    # Filter the DataFrame to only include direct connections
+                    filtered_df = original_df[mask].copy()
+                    
+                    # Create new model with filtered DataFrame and update selection table
+                    new_model = PandasModel(filtered_df)
+                    self.selection_table.setModel(new_model)
+                    
+                    # Switch to selection table
+                    self.selection_button.click()
+                except:
+                    pass
 
                 if edges:
                     edge_indices = filtered_df.iloc[:, 2].unique().tolist()
@@ -3755,6 +3819,12 @@ class ImageViewerWindow(QMainWindow):
             self.ax.clear()
             self.ax.set_facecolor('black')
             
+            # Reset measurement artists since we cleared the axes
+            if not hasattr(self, 'measurement_artists'):
+                self.measurement_artists = []
+            else:
+                self.measurement_artists = []  # Reset since ax.clear() removed all artists
+            
             # Get original dimensions (before downsampling)
             if hasattr(self, 'original_dims') and self.original_dims:
                 height, width = self.original_dims
@@ -3836,23 +3906,129 @@ class ImageViewerWindow(QMainWindow):
             for spine in self.ax.spines.values():
                 spine.set_color('black')
                 
-            # Add measurement points if they exist (coordinates remain in original space)
-            for point in self.measurement_points:
-                x1, y1, z1 = point['point1']
-                x2, y2, z2 = point['point2']
-                pair_idx = point['pair_index']
-                
-                if z1 == self.current_slice:
-                    self.ax.plot(x1, y1, 'yo', markersize=8)
-                    self.ax.text(x1, y1+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
-                if z2 == self.current_slice:
-                    self.ax.plot(x2, y2, 'yo', markersize=8)
-                    self.ax.text(x2, y2+5, str(pair_idx), 
-                                color='white', ha='center', va='bottom')
+            # Add measurement points if they exist (using the same logic as main update_display)
+            if hasattr(self, 'measurement_points') and self.measurement_points:
+                for point in self.measurement_points:
+                    x1, y1, z1 = point['point1']
+                    x2, y2, z2 = point['point2']
+                    pair_idx = point['pair_index']
+                    point_type = point.get('type', 'distance')  # Default to distance for backward compatibility
+                    
+                    # Determine colors based on type
+                    if point_type == 'angle':
+                        marker_color = 'go'
+                        text_color = 'green'
+                        line_color = 'g--'
+                    else:  # distance
+                        marker_color = 'yo'
+                        text_color = 'yellow'
+                        line_color = 'r--'
+                    
+                    # Check if points are in visible region and on current slice
+                    point1_visible = (z1 == self.current_slice and 
+                                    current_xlim[0] <= x1 <= current_xlim[1] and 
+                                    current_ylim[1] <= y1 <= current_ylim[0])
+                    point2_visible = (z2 == self.current_slice and 
+                                    current_xlim[0] <= x2 <= current_xlim[1] and 
+                                    current_ylim[1] <= y2 <= current_ylim[0])
+                    
+                    # Draw individual points if they're on the current slice
+                    if point1_visible:
+                        pt1 = self.ax.plot(x1, y1, marker_color, markersize=8)[0]
+                        txt1 = self.ax.text(x1, y1+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt1, txt1])
                         
-                if z1 == z2 == self.current_slice:
-                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+                    if point2_visible:
+                        pt2 = self.ax.plot(x2, y2, marker_color, markersize=8)[0]
+                        txt2 = self.ax.text(x2, y2+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt2, txt2])
+                        
+                    # Draw connecting line if both points are on the same slice
+                    if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
+                        line = self.ax.plot([x1, x2], [y1, y2], line_color, alpha=0.5)[0]
+                        self.measurement_artists.append(line)
+
+            # Handle angle measurements if they exist
+            if hasattr(self, 'angle_measurements') and self.angle_measurements:
+                for angle in self.angle_measurements:
+                    xa, ya, za = angle['point_a']
+                    xb, yb, zb = angle['point_b']  # vertex
+                    xc, yc, zc = angle['point_c']
+                    trio_idx = angle['trio_index']
+                    
+                    # Check if points are on current slice and visible
+                    point_a_visible = (za == self.current_slice and 
+                                     current_xlim[0] <= xa <= current_xlim[1] and 
+                                     current_ylim[1] <= ya <= current_ylim[0])
+                    point_b_visible = (zb == self.current_slice and 
+                                     current_xlim[0] <= xb <= current_xlim[1] and 
+                                     current_ylim[1] <= yb <= current_ylim[0])
+                    point_c_visible = (zc == self.current_slice and 
+                                     current_xlim[0] <= xc <= current_xlim[1] and 
+                                     current_ylim[1] <= yc <= current_ylim[0])
+                    
+                    # Draw points
+                    if point_a_visible:
+                        pt_a = self.ax.plot(xa, ya, 'go', markersize=8)[0]
+                        txt_a = self.ax.text(xa, ya+5, f"A{trio_idx}", color='green', ha='center', va='bottom')
+                        self.measurement_artists.extend([pt_a, txt_a])
+                        
+                    if point_b_visible:
+                        pt_b = self.ax.plot(xb, yb, 'go', markersize=8)[0]
+                        txt_b = self.ax.text(xb, yb+5, f"B{trio_idx}", color='green', ha='center', va='bottom')
+                        self.measurement_artists.extend([pt_b, txt_b])
+                        
+                    if point_c_visible:
+                        pt_c = self.ax.plot(xc, yc, 'go', markersize=8)[0]
+                        txt_c = self.ax.text(xc, yc+5, f"C{trio_idx}", color='green', ha='center', va='bottom')
+                        self.measurement_artists.extend([pt_c, txt_c])
+                    
+                    # Draw lines only if points are on current slice
+                    if za == zb == self.current_slice and (point_a_visible or point_b_visible):
+                        line_ab = self.ax.plot([xa, xb], [ya, yb], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line_ab)
+                        
+                    if zb == zc == self.current_slice and (point_b_visible or point_c_visible):
+                        line_bc = self.ax.plot([xb, xc], [yb, yc], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line_bc)
+
+            # Handle any partial measurements in progress (individual points without pairs yet)
+            if hasattr(self, 'current_point') and self.current_point is not None:
+                x, y, z = self.current_point
+                if z == self.current_slice:
+                    if hasattr(self, 'measurement_mode') and self.measurement_mode == "angle":
+                        # Show green for angle mode
+                        pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                        if hasattr(self, 'current_trio_index'):
+                            txt = self.ax.text(x, y+5, f"A{self.current_trio_index}", color='green', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "A", color='green', ha='center', va='bottom')
+                    else:
+                        # Show yellow for distance mode (default)
+                        pt = self.ax.plot(x, y, 'yo', markersize=8)[0]
+                        if hasattr(self, 'current_pair_index'):
+                            txt = self.ax.text(x, y+5, f"D{self.current_pair_index}", color='yellow', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "D", color='yellow', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
+
+            # Handle second point in angle measurements
+            if hasattr(self, 'current_second_point') and self.current_second_point is not None:
+                x, y, z = self.current_second_point
+                if z == self.current_slice:
+                    pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                    if hasattr(self, 'current_trio_index'):
+                        txt = self.ax.text(x, y+5, f"B{self.current_trio_index}", color='green', ha='center', va='bottom')
+                    else:
+                        txt = self.ax.text(x, y+5, "B", color='green', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
+                    
+                    # Draw line from A to B if both are on current slice
+                    if (hasattr(self, 'current_point') and self.current_point is not None and 
+                        self.current_point[2] == self.current_slice):
+                        x1, y1, z1 = self.current_point
+                        line = self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line)
             
             #self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
 
@@ -3968,7 +4144,34 @@ class ImageViewerWindow(QMainWindow):
                         if len(self.clicked_values['edges']):
                             self.highlight_value_in_tables(self.clicked_values['edges'][-1])
                             self.handle_info('edge')
-            
+
+                    try:
+                        if len(self.clicked_values['nodes']) > 0 or len(self.clicked_values['edges']) > 0:  # Check if we have any nodes selected
+
+                            old_nodes = copy.deepcopy(self.clicked_values['nodes']) 
+
+                            # Get the existing DataFrame from the model
+                            original_df = self.network_table.model()._data
+                            
+                            # Create mask for rows where one column is any original node AND the other column is any neighbor
+                            mask = (
+                                ((original_df.iloc[:, 0].isin(self.clicked_values['nodes'])) &
+                                (original_df.iloc[:, 1].isin(self.clicked_values['nodes']))) |
+                                (original_df.iloc[:, 2].isin(self.clicked_values['edges']))
+                                )
+                            
+                            # Filter the DataFrame to only include direct connections
+                            filtered_df = original_df[mask].copy()
+                            
+                            # Create new model with filtered DataFrame and update selection table
+                            new_model = PandasModel(filtered_df)
+                            self.selection_table.setModel(new_model)
+                            
+                            # Switch to selection table
+                            self.selection_button.click()
+                    except:
+                        pass
+                
             elif not self.selecting and self.selection_start:  # If we had a click but never started selection
                 # Handle as a normal click
                 self.on_mouse_click(event)
@@ -4514,7 +4717,7 @@ class ImageViewerWindow(QMainWindow):
         
         
         # Add after your other buttons
-        self.popup_button = QPushButton("⤴")  # or "🔗" or "⤴"
+        self.popup_button = QPushButton("⤴") 
         self.popup_button.setFixedSize(40, 40)
         self.popup_button.setToolTip("Pop out canvas")
         self.popup_button.clicked.connect(self.popup_canvas)
@@ -6175,8 +6378,6 @@ class ImageViewerWindow(QMainWindow):
                 if self.resume:
                     self.machine_window.segmentation_worker.resume()
                     self.resume = False
-                if self.prev_down != self.downsample_factor:
-                    self.validate_downsample_input(text = self.prev_down)
            
             if self.static_background is not None:
                 # Your existing virtual strokes conversion logic
@@ -6233,10 +6434,13 @@ class ImageViewerWindow(QMainWindow):
                 for img in list(self.ax.get_images()):
                     img.remove()
                 # Clear measurement points
-                for artist in self.measurement_artists:
-                    artist.remove()
-                self.measurement_artists.clear()
-
+                if hasattr(self, 'measurement_artists'):
+                    for artist in self.measurement_artists:
+                        try:
+                            artist.remove()
+                        except:
+                            pass  # Artist might already be removed
+                self.measurement_artists = []  # Reset the list
             # Determine the current view bounds (either from preserve_zoom or current state)
             if preserve_zoom:
                 current_xlim, current_ylim = preserve_zoom
@@ -6303,7 +6507,6 @@ class ImageViewerWindow(QMainWindow):
                     return cropped[::factor, ::factor, :]
                 else:
                     return cropped
-
             
             # Update channel images efficiently with cropping and downsampling
             for channel in range(4):
@@ -6378,10 +6581,7 @@ class ImageViewerWindow(QMainWindow):
                             
                             im = self.ax.imshow(normalized_image, alpha=0.7, cmap=custom_cmap,
                                               vmin=0, vmax=1, extent=crop_extent)
-
             # Handle preview, overlays, and measurements (apply cropping here too)
-            #if self.preview and not called:
-             #   self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
 
             # Overlay handling (optimized with cropping and downsampling)
             if self.mini_overlay and self.highlight and self.machine_window is None:
@@ -6403,34 +6603,88 @@ class ImageViewerWindow(QMainWindow):
                         [(0, 0, 0, 0), (1, 1, 0, 1), (0, 0.7, 1, 1)])
                     self.ax.imshow(display_highlight, cmap=highlight_cmap, vmin=0, vmax=2, alpha=0.3, extent=crop_extent)
 
-            # Redraw measurement points efficiently (no cropping needed - these are vector graphics)
+            # Redraw measurement points efficiently
             # Only draw points that are within the visible region for additional performance
-            for point in self.measurement_points:
-                x1, y1, z1 = point['point1']
-                x2, y2, z2 = point['point2']
-                pair_idx = point['pair_index']
-                
-                # Check if points are in visible region
-                point1_visible = (z1 == self.current_slice and 
-                                current_xlim[0] <= x1 <= current_xlim[1] and 
-                                current_ylim[1] <= y1 <= current_ylim[0])
-                point2_visible = (z2 == self.current_slice and 
-                                current_xlim[0] <= x2 <= current_xlim[1] and 
-                                current_ylim[1] <= y2 <= current_ylim[0])
-                
-                if point1_visible:
-                    pt1 = self.ax.plot(x1, y1, 'yo', markersize=8)[0]
-                    txt1 = self.ax.text(x1, y1+5, str(pair_idx), color='white', ha='center', va='bottom')
-                    self.measurement_artists.extend([pt1, txt1])
+
+            if hasattr(self, 'measurement_points') and self.measurement_points:
+                for point in self.measurement_points:
+                    x1, y1, z1 = point['point1']
+                    x2, y2, z2 = point['point2']
+                    pair_idx = point['pair_index']
+                    point_type = point.get('type', 'distance')  # Default to distance for backward compatibility
+                    
+                    # Determine colors based on type
+                    if point_type == 'angle':
+                        marker_color = 'go'
+                        text_color = 'green'
+                        line_color = 'g--'
+                    else:  # distance
+                        marker_color = 'yo'
+                        text_color = 'yellow'
+                        line_color = 'r--'
                     
-                if point2_visible:
-                    pt2 = self.ax.plot(x2, y2, 'yo', markersize=8)[0]
-                    txt2 = self.ax.text(x2, y2+5, str(pair_idx), color='white', ha='center', va='bottom')
-                    self.measurement_artists.extend([pt2, txt2])
+                    # Check if points are in visible region and on current slice
+                    point1_visible = (z1 == self.current_slice and 
+                                    current_xlim[0] <= x1 <= current_xlim[1] and 
+                                    current_ylim[1] <= y1 <= current_ylim[0])
+                    point2_visible = (z2 == self.current_slice and 
+                                    current_xlim[0] <= x2 <= current_xlim[1] and 
+                                    current_ylim[1] <= y2 <= current_ylim[0])
+                    
+                    # Always draw individual points if they're on the current slice (even without lines)
+                    if point1_visible:
+                        pt1 = self.ax.plot(x1, y1, marker_color, markersize=8)[0]
+                        txt1 = self.ax.text(x1, y1+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt1, txt1])
+                        
+                    if point2_visible:
+                        pt2 = self.ax.plot(x2, y2, marker_color, markersize=8)[0]
+                        txt2 = self.ax.text(x2, y2+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt2, txt2])
+                        
+                    # Only draw connecting line if both points are on the same slice AND visible
+                    if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
+                        line = self.ax.plot([x1, x2], [y1, y2], line_color, alpha=0.5)[0]
+                        self.measurement_artists.append(line)
+
+            # Also handle any partial measurements in progress (individual points without pairs yet)
+            # This shows individual points even when a measurement isn't complete
+            if hasattr(self, 'current_point') and self.current_point is not None:
+                x, y, z = self.current_point
+                if z == self.current_slice:
+                    if hasattr(self, 'measurement_mode') and self.measurement_mode == "angle":
+                        # Show green for angle mode
+                        pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                        if hasattr(self, 'current_trio_index'):
+                            txt = self.ax.text(x, y+5, f"A{self.current_trio_index}", color='green', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "A", color='green', ha='center', va='bottom')
+                    else:
+                        # Show yellow for distance mode (default)
+                        pt = self.ax.plot(x, y, 'yo', markersize=8)[0]
+                        if hasattr(self, 'current_pair_index'):
+                            txt = self.ax.text(x, y+5, f"D{self.current_pair_index}", color='yellow', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "D", color='yellow', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
+
+            # Handle second point in angle measurements
+            if hasattr(self, 'current_second_point') and self.current_second_point is not None:
+                x, y, z = self.current_second_point
+                if z == self.current_slice:
+                    pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                    if hasattr(self, 'current_trio_index'):
+                        txt = self.ax.text(x, y+5, f"B{self.current_trio_index}", color='green', ha='center', va='bottom')
+                    else:
+                        txt = self.ax.text(x, y+5, "B", color='green', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
                     
-                if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
-                    line = self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)[0]
-                    self.measurement_artists.append(line)
+                    # Draw line from A to B if both are on current slice
+                    if (hasattr(self, 'current_point') and self.current_point is not None and 
+                        self.current_point[2] == self.current_slice):
+                        x1, y1, z1 = self.current_point
+                        line = self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line)
 
             # Store current view limits for next update
             self.ax._current_xlim = current_xlim
@@ -6449,9 +6703,10 @@ class ImageViewerWindow(QMainWindow):
             if reset_resize:
                 self.resizing = False
             
-            # Use draw_idle for better performance
+            # draw_idle
             self.canvas.draw_idle()
 
+
         except Exception as e:
             pass
             #import traceback
@@ -12210,13 +12465,23 @@ class HoleDialog(QDialog):
             borders = self.borders.isChecked()
             headon = self.headon.isChecked()
             sep_holes = self.sep_holes.isChecked()
+
+            if borders:
             
-            # Call dilate method with parameters
-            result = n3d.fill_holes_3d(
-                active_data,
-                head_on = headon,
-                fill_borders = borders
-            )
+                # Call dilate method with parameters
+                result = n3d.fill_holes_3d_old(
+                    active_data,
+                    head_on = headon,
+                    fill_borders = borders
+                )
+
+            else:
+                # Call dilate method with parameters
+                result = n3d.fill_holes_3d(
+                    active_data,
+                    head_on = headon,
+                    fill_borders = borders
+                )
 
             if not sep_holes:
                 self.parent().load_channel(self.parent().active_channel, result, True)
@@ -13108,7 +13373,7 @@ class GenNodesDialog(QDialog):
 
             if my_network.edges is None and my_network.nodes is not None:
                 self.parent().load_channel(1, my_network.nodes, data = True)
-                self.parent().delete_channel(0, True)
+                self.parent().delete_channel(0, False)
             # Get directory (None if empty)
             #directory = self.directory.text() if self.directory.text() else None
             
@@ -13340,7 +13605,7 @@ class BranchDialog(QDialog):
 
             if my_network.edges is None and my_network.nodes is not None:
                 self.parent().load_channel(1, my_network.nodes, data = True)
-                self.parent().delete_channel(0, True)
+                self.parent().delete_channel(0, False)
 
             original_shape = my_network.edges.shape
             original_array = copy.deepcopy(my_network.edges)

{nettracer3d-0.9.9 → nettracer3d-1.0.1/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.9.9
+Version: 1.0.1
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,7 +110,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.9.9 Updates --
+-- Version 1.0.1 Updates --
 
-	* Tables can now be opened to the rightside upper widget if they are the right format.
-	* Similarly, tables that have the format node id column:numerical values can now be used liberally to threshold the nodes, meaning most outputs of network analysis can be used to threshold nodes.
+	* Bug fixes, mainly