nettracer3d 0.9.0__tar.gz → 0.9.1__tar.gz

{nettracer3d-0.9.0/src/nettracer3d.egg-info → nettracer3d-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.9.0
+Version: 0.9.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,16 +110,9 @@ 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.0 Updates --
-	* Note that this includes updates for 0.8.3 - 0.9.0
-	* Bug Fixes
-	* Updated network histogram statistics menu, and moved degree distribution here
-	* Added gray watershed
-	* Updated binary watershed
-	* Improved branch labelling method
-	* Updated branch removal in skeletonization method to no longer trim branches that do not reach their node.
-	* Added default branchpoint and branch-adjacency calculation options.
-	* Improved speed of painting and panning.
-	* Enabled the nearest neighbor method to handle non-centroid objects, for the first neighbor at least. And updated it to actually predict theoretical clustering when coloring the heatmap.
-	* Improved segmenter.
-	* Added centroids UMAP method.
+-- Version 0.9.1 Updates --
+	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
+	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
+	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
+	* The community UMAP can now color them by neighborhood.
+	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.

{nettracer3d-0.9.0 → nettracer3d-0.9.1}/README.md

@@ -65,16 +65,9 @@ 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.0 Updates --
-	* Note that this includes updates for 0.8.3 - 0.9.0
-	* Bug Fixes
-	* Updated network histogram statistics menu, and moved degree distribution here
-	* Added gray watershed
-	* Updated binary watershed
-	* Improved branch labelling method
-	* Updated branch removal in skeletonization method to no longer trim branches that do not reach their node.
-	* Added default branchpoint and branch-adjacency calculation options.
-	* Improved speed of painting and panning.
-	* Enabled the nearest neighbor method to handle non-centroid objects, for the first neighbor at least. And updated it to actually predict theoretical clustering when coloring the heatmap.
-	* Improved segmenter.
-	* Added centroids UMAP method.
+-- Version 0.9.1 Updates --
+	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
+	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
+	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
+	* The community UMAP can now color them by neighborhood.
+	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.

{nettracer3d-0.9.0 → nettracer3d-0.9.1}/pyproject.toml

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

{nettracer3d-0.9.0 → nettracer3d-0.9.1}/src/nettracer3d/neighborhoods.py

@@ -346,7 +346,8 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
                                      random_state: int = 42,
                                      id_dictionary: Optional[Dict[int, str]] = None, 
                                      graph_label = "Community ID",
-                                     title = 'UMAP Visualization of Community Compositions'):
+                                     title = 'UMAP Visualization of Community Compositions',
+                                     neighborhoods: Optional[Dict[int, int]] = None):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -366,6 +367,9 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     id_dictionary : dict, optional
         Dictionary mapping cluster IDs to identity names. If provided, colors will be
         assigned by identity rather than cluster ID, and a legend will be shown.
+    neighborhoods : dict, optional
+        Dictionary mapping node IDs to neighborhood IDs {node_id: neighborhood_id}.
+        If provided, points will be colored by neighborhood using community coloration methods.
     
     Returns:
     --------
@@ -389,25 +393,70 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     # Fit and transform the composition data
     embedding = reducer.fit_transform(compositions)
     
-    # Prepare colors and labels based on whether id_dictionary is provided
-    if id_dictionary is not None:
-        # Get unique identities and assign colors (group all unknown into single "Unknown" category)
+    # Determine coloring scheme based on parameters
+    if neighborhoods is not None:
+        # Use neighborhood coloring - import the community extractor methods
+        from . import community_extractor
+        
+        # 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}
+        
+        # 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)
+        
+        # Get colors using the community coloration method
+        _, neighborhood_color_names = community_extractor.assign_community_colors(
+            filtered_neighborhoods, dummy_array
+        )
+        
+        # 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)}
+        
+        # Map each cluster to its neighborhood color
+        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)
+            else:
+                # Default color for nodes not in any neighborhood
+                point_colors.append((128, 128, 128))  # Gray
+                neighborhood_labels.append("Unknown")
+        
+        # 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]
+        use_neighborhood_coloring = True
+        
+    elif id_dictionary is not None:
+        # Use identity coloring (existing logic)
         identities = [id_dictionary.get(cluster_id, "Unknown") for cluster_id in cluster_ids]
         unique_identities = sorted(list(set(identities)))
         colors = generate_distinct_colors(len(unique_identities))
         identity_to_color = {identity: colors[i] for i, identity in enumerate(unique_identities)}
         point_colors = [identity_to_color[identity] for identity in identities]
         use_identity_coloring = True
+        use_neighborhood_coloring = False
     else:
         # Use default cluster ID coloring
         point_colors = cluster_ids
         use_identity_coloring = False
+        use_neighborhood_coloring = False
     
     # Create visualization
     plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
+                                c=point_colors, s=100, alpha=0.7)
+        elif use_identity_coloring:
             scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
                                 c=point_colors, s=100, alpha=0.7)
         else:
@@ -418,7 +467,10 @@ 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 id_dictionary is not None:
+                if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
+                    neighborhood_id = filtered_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")
                     display_label = f'{cluster_id}\n({identity})'
                 
@@ -428,7 +480,20 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
                             fontsize=9, alpha=0.8, ha='left')
         
         # Add appropriate legend/colorbar
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            # Create custom legend for neighborhoods
+            legend_elements = []
+            for neighborhood_id in unique_neighborhoods:
+                color = neighborhood_to_color[neighborhood_id]
+                norm_color = (color[0]/255.0, color[1]/255.0, color[2]/255.0)
+                legend_elements.append(
+                    plt.Line2D([0], [0], marker='o', color='w', 
+                              markerfacecolor=norm_color, 
+                              markersize=10, label=f'Neighborhood {neighborhood_id}')
+                )
+            plt.legend(handles=legend_elements, title='Neighborhoods', 
+                      bbox_to_anchor=(1.05, 1), loc='upper left')
+        elif use_identity_coloring:
             # Create custom legend for identities
             legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
                                         markerfacecolor=identity_to_color[identity], 
@@ -441,7 +506,9 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         
         plt.xlabel('UMAP Component 1')
         plt.ylabel('UMAP Component 2')
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            title += ' (Colored by Neighborhood)'
+        elif use_identity_coloring:
             title += ' (Colored by Identity)'
         plt.title(title)
         
@@ -449,7 +516,10 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         fig = plt.figure(figsize=(14, 10))
         ax = fig.add_subplot(111, projection='3d')
         
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
+                               c=point_colors, s=100, alpha=0.7)
+        elif use_identity_coloring:
             scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
                                c=point_colors, s=100, alpha=0.7)
         else:
@@ -460,7 +530,10 @@ 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 id_dictionary is not None:
+                if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
+                    neighborhood_id = filtered_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")
                     display_label = f'C{cluster_id}\n({identity})'
                 
@@ -471,12 +544,27 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         ax.set_ylabel('UMAP Component 2')
         ax.set_zlabel('UMAP Component 3')
         title = '3D UMAP Visualization of Cluster Compositions'
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            title += ' (Colored by Neighborhood)'
+        elif use_identity_coloring:
             title += ' (Colored by Identity)'
         ax.set_title(title)
         
         # Add appropriate legend/colorbar
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            # Create custom legend for neighborhoods
+            legend_elements = []
+            for neighborhood_id in unique_neighborhoods:
+                color = neighborhood_to_color[neighborhood_id]
+                norm_color = (color[0]/255.0, color[1]/255.0, color[2]/255.0)
+                legend_elements.append(
+                    plt.Line2D([0], [0], marker='o', color='w', 
+                              markerfacecolor=norm_color, 
+                              markersize=10, label=f'Neighborhood {neighborhood_id}')
+                )
+            ax.legend(handles=legend_elements, title='Neighborhoods', 
+                     bbox_to_anchor=(1.05, 1), loc='upper left')
+        elif use_identity_coloring:
             # Create custom legend for identities
             legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
                                         markerfacecolor=identity_to_color[identity], 
@@ -496,12 +584,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         print(f"Classes: {class_labels}")
         for i, cluster_id in enumerate(cluster_ids):
             composition = compositions[i]
-            identity_info = ""
-            if id_dictionary is not None:
+            additional_info = ""
+            if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
+                neighborhood_id = filtered_neighborhoods[cluster_id]
+                additional_info = f" (Neighborhood: {neighborhood_id})"
+            elif id_dictionary is not None:
                 identity = id_dictionary.get(cluster_id, "Unknown")
-                identity_info = f" (Identity: {identity})"
+                additional_info = f" (Identity: {identity})"
             
-            print(f"Cluster {cluster_id}{identity_info}: {composition}")
+            print(f"Cluster {cluster_id}{additional_info}: {composition}")
             # Show which classes dominate this cluster
             dominant_indices = np.argsort(composition)[::-1][:2]  # Top 2
             dominant_classes = [class_labels[idx] for idx in dominant_indices]

{nettracer3d-0.9.0 → nettracer3d-0.9.1}/src/nettracer3d/nettracer.py

@@ -5492,7 +5492,7 @@ class Network_3D:
         neighborhoods.visualize_cluster_composition_umap(self.node_centroids, None, id_dictionary = self.node_identities, graph_label = "Node ID", title = 'UMAP Visualization of Node Centroids') 
 
 
-    def community_id_info_per_com(self, umap = False, label = False, limit = 0, proportional = False):
+    def community_id_info_per_com(self, umap = False, label = 0, limit = 0, proportional = False, neighbors = None):
 
         community_dict = invert_dict(self.communities)
         summation = 0
@@ -5581,7 +5581,19 @@ class Network_3D:
         if umap:
             from . import neighborhoods
 
-            neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = label) 
+
+            if self.communities is not None and label == 2:
+                neighbor_group = {}
+                for node, com in self.communities.items():
+                    neighbor_group[com] = neighbors[node]
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group)
+            elif label == 1:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = True) 
+            else:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = False) 
+
+
+            #neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = label) 
 
         return output, id_set
 
@@ -5856,44 +5868,57 @@ class Network_3D:
 
     def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True):
 
+        def distribute_points_uniformly(n, shape, z_scale, xy_scale, num, is_2d=False):
+
+            from scipy.spatial import KDTree
 
-        def distribute_points_uniformly(n, shape, z_scale, xy_scale, is_2d=False):
             if n <= 1:
                 return 0
-            
-            # Calculate total number of positions
+                        
+            # Calculate total positions and sampling step
             total_positions = np.prod(shape)
+            if n >= total_positions:
+                # If we want more points than positions, just return scaled unit distance
+                return xy_scale if is_2d else min(z_scale, xy_scale)
             
-            # Calculate the flat index spacing
-            flat_spacing = total_positions / n
+            # Create uniformly spaced indices
+            indices = np.linspace(0, total_positions - 1, n, dtype=int)
             
-            # Get the first two flat indices
-            idx1 = 0
-            idx2 = int(flat_spacing)
+            # Convert flat indices to coordinates
+            coords = []
+            for idx in indices:
+                coord = np.unravel_index(idx, shape)
+                if len(shape) == 3:
+                    # Apply scaling: [z, y, x] with respective scales
+                    scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
+                elif len(shape) == 2:
+                    # Apply scaling: [y, x] with xy_scale
+                    scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
+                coords.append(scaled_coord)
             
-            # Convert to multi-dimensional coordinates theoretically
-            coord1 = np.unravel_index(idx1, shape)
-            coord2 = np.unravel_index(idx2, shape)
+            coords = np.array(coords)
             
-            # Apply scaling
-            if len(shape) == 3:
-                p1 = np.array([coord1[0] * z_scale, coord1[1] * xy_scale, coord1[2] * xy_scale])
-                p2 = np.array([coord2[0] * z_scale, coord2[1] * xy_scale, coord2[2] * xy_scale])
-            elif len(shape) == 2:
-                p1 = np.array([coord1[0] * xy_scale, coord1[1] * xy_scale])
-                p2 = np.array([coord2[0] * xy_scale, coord2[1] * xy_scale])
+            # Build KDTree
+            tree = KDTree(coords)
             
-            # Calculate neighbor distance
-            neighbor_distance = np.linalg.norm(p2 - p1)
+            # Pick a point near the middle of the array
+            middle_idx = len(coords) // 2
+            query_point = coords[middle_idx]
             
-            # Apply the dimensional factor
-            if is_2d:
-                neighbor_distance = neighbor_distance * 0.38
-            else:
-                neighbor_distance = neighbor_distance * 0.45
+            # Find the num+1 nearest neighbors (including the point itself)
+            distances, indices = tree.query(query_point, k=num+1)
+            
+            # Exclude the point itself (distance 0) and get the actual neighbors
+            neighbor_distances = distances[1:num+1]
+
+            if num == n:
+                neighbor_distances[-1] = neighbor_distances[-2]
+            
+            avg_distance = np.mean(neighbor_distances)
             
-            return neighbor_distance
             
+            return avg_distance
+
         do_borders = not centroids
 
         if centroids:
@@ -6017,7 +6042,7 @@ class Network_3D:
             else:
                 is_2d = False
 
-            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, is_2d = is_2d)
+            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, num = num, is_2d = is_2d)
 
             node_intensity = {}
             import math
@@ -6025,18 +6050,22 @@ class Network_3D:
 
             for node in root_set:
                 node_intensity[node] = math.log(pred/output[node])
+                #print(output[node])
                 node_centroids[node] = self.node_centroids[node]
 
             if numpy:
 
                 overlay = neighborhoods.create_node_heatmap(node_intensity, node_centroids, shape = shape, is_3d=threed, labeled_array = self.nodes, colorbar_label="Clustering Intensity", title = title)
 
-                return avg, output, overlay, quant_overlay
+                return avg, output, overlay, quant_overlay, pred
 
             else:
                 neighborhoods.create_node_heatmap(node_intensity, node_centroids, shape = shape, is_3d=threed, labeled_array = None, colorbar_label="Clustering Intensity", title = title)
 
-        return avg, output, quant_overlay
+        else:
+            pred = None
+
+        return avg, output, quant_overlay, pred