nettracer3d 1.1.3__tar.gz → 1.1.6__tar.gz

{nettracer3d-1.1.3/src/nettracer3d.egg-info → nettracer3d-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.1.3
+Version: 1.1.6
 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,6 +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 1.1.3 Updates --
+-- Version 1.1.6 Updates --
 
-	* Some minor text adjustments
+	* Some adjustments

{nettracer3d-1.1.3 → nettracer3d-1.1.6}/README.md

@@ -65,6 +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 1.1.3 Updates --
+-- Version 1.1.6 Updates --
 
-	* Some minor text adjustments
+	* Some adjustments

{nettracer3d-1.1.3 → nettracer3d-1.1.6}/pyproject.toml

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

{nettracer3d-1.1.3 → nettracer3d-1.1.6}/src/nettracer3d/neighborhoods.py

@@ -793,7 +793,7 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
             return np.array([r, g, b], dtype=np.uint8)
         
         # Create lookup table for RGB colors
-        max_label = int(max(max(labeled_array.flat), max(node_to_community_intensity.keys()) if node_to_community_intensity else 0))
+        max_label = max(max(labeled_array.flat), max(node_to_community_intensity.keys()) if node_to_community_intensity else 0)
         color_lut = np.zeros((max_label + 1, 3), dtype=np.uint8)  # Default to black (0,0,0)
         
         # Fill lookup table with RGB colors based on community intensity
@@ -1036,8 +1036,8 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
 
         # Modified usage in your main function:
         # Create lookup table for RGBA colors (note the 4 channels now)
-        max_label = int(max(max(labeled_array.flat), max(node_to_intensity.keys()) if node_to_intensity else 0))
-        color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)
+        max_label = max(max(labeled_array.flat), max(node_to_intensity.keys()) if node_to_intensity else 0)
+        color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)  # Default to transparent (0,0,0,0)
 
         # Fill lookup table with RGBA colors based on intensity
         for node_id, intensity in node_to_intensity.items():
@@ -1128,7 +1128,7 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
 
 def create_violin_plots(data_dict, graph_title="Violin Plots"):
     """
-    Create violin plots from dictionary data with distinct colors.
+    Create violin plots from dictionary data with distinct colors and IQR lines.
     
     Parameters:
     data_dict (dict): Dictionary where keys are column headers (strings) and 
@@ -1140,110 +1140,133 @@ def create_violin_plots(data_dict, graph_title="Violin Plots"):
         return
     
     # Prepare data
+    data_dict = dict(sorted(data_dict.items()))
     labels = list(data_dict.keys())
     data_lists = list(data_dict.values())
     
-    # Generate colors using the community color strategy
+    # Generate colors
     try:
-        # Create a mock community dict for color generation
-        mock_community_dict = {i: i+1 for i in range(len(labels))}  # No outliers for simplicity
-        
-        # Get distinct colors
-        n_colors = len(labels)
-        colors_rgb = community_extractor.generate_distinct_colors(n_colors)
-        
-        # Sort by data size for consistent color assignment (like community sizes)
-        data_sizes = [(i, len(data_lists[i])) for i in range(len(data_lists))]
-        sorted_indices = sorted(data_sizes, key=lambda x: (-x[1], x[0]))
-        
-        # Create color mapping
-        colors = []
-        for i, _ in sorted_indices:
-            color_idx = sorted_indices.index((i, _))
-            if color_idx < len(colors_rgb):
-                # Convert RGB (0-255) to matplotlib format (0-1)
-                rgb_normalized = tuple(c/255.0 for c in colors_rgb[color_idx])
-                colors.append(rgb_normalized)
-            else:
-                colors.append('gray')  # Fallback color
-        
-        # Reorder colors to match original label order
-        final_colors = ['gray'] * len(labels)
-        for idx, (original_idx, _) in enumerate(sorted_indices):
-            final_colors[original_idx] = colors[idx]
-            
+        final_colors = generate_distinct_colors(len(labels))
     except Exception as e:
         print(f"Color generation failed, using default colors: {e}")
-        # Fallback to default matplotlib colors
         final_colors = plt.cm.Set3(np.linspace(0, 1, len(labels)))
     
-    # Create the plot
     fig, ax = plt.subplots(figsize=(max(8, len(labels) * 1.5), 6))
     
     # Create violin plots
-    violin_parts = ax.violinplot(data_lists, positions=range(len(labels)), 
-                                showmeans=False, showmedians=True, showextrema=True)
+    violin_parts = ax.violinplot(
+        data_lists, positions=range(len(labels)),
+        showmeans=False, showmedians=True, showextrema=True
+    )
     
-    # Color the violins
+    # Color violins
     for i, pc in enumerate(violin_parts['bodies']):
         if i < len(final_colors):
             pc.set_facecolor(final_colors[i])
             pc.set_alpha(0.7)
     
-    # Color the other violin elements
+    # Color other violin parts
     for partname in ('cbars', 'cmins', 'cmaxes', 'cmedians'):
         if partname in violin_parts:
             violin_parts[partname].set_edgecolor('black')
             violin_parts[partname].set_linewidth(1)
-            
-    # Add data points as scatter plot overlay with much lower transparency
-    """
-    for i, data in enumerate(data_lists):
-        y = data
-        # Add some jitter to x positions for better visibility
-        x = np.random.normal(i, 0.04, size=len(y))
-        ax.scatter(x, y, alpha=0.2, s=15, color='black', edgecolors='none', zorder=3)  # No borders, more transparent
-    """
     
-    # Calculate reasonable y-axis limits to focus on the bulk of the data
+    # Set y-limits using percentiles to reduce extreme outlier influence
     all_data = [val for sublist in data_lists for val in sublist]
     if all_data:
-        # Use percentiles to exclude extreme outliers from the view
-        y_min = np.percentile(all_data, 5)   # 5th percentile
-        y_max = np.percentile(all_data, 95)  # 95th percentile
-        
-        # Add some padding
+        y_min = np.percentile(all_data, 5)
+        y_max = np.percentile(all_data, 95)
         y_range = y_max - y_min
         y_padding = y_range * 0.15
         ax.set_ylim(y_min - y_padding, y_max + y_padding)
     
-    # Add IQR and median text annotations BELOW the violins
+    # Add IQR and median text annotations and dotted IQR lines
     for i, data in enumerate(data_lists):
         if len(data) > 0:
             q1, median, q3 = np.percentile(data, [25, 50, 75])
             iqr = q3 - q1
+
+            # Add dotted green lines for IQR
+            ax.hlines(
+                [q1, q3],
+                i - 0.25, i + 0.25,
+                colors='green',
+                linestyles='dotted',
+                linewidth=1.5,
+                zorder=3,
+                label='IQR (25th–75th)' if i == 0 else None  # Add label once
+            )
             
-            # Position text below the violin (using current y-axis limits)
+            # Text annotation below the violins
             y_min_current = ax.get_ylim()[0]
             y_text = y_min_current - (ax.get_ylim()[1] - ax.get_ylim()[0]) * 0.15
-            
-            ax.text(i, y_text, f'Median: {median:.2f}\nIQR: {iqr:.2f}', 
-                   horizontalalignment='center', fontsize=8, 
-                   bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.8))
+            ax.text(
+                i, y_text, f'Median: {median:.2f}\nIQR: {iqr:.2f}', 
+                ha='center', fontsize=8, 
+                bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.8)
+            )
     
-    # Customize the plot
+    # Customize appearance
     ax.set_xticks(range(len(labels)))
     ax.set_xticklabels(labels, rotation=45, ha='right')
     ax.set_title(graph_title, fontsize=14, fontweight='bold')
     ax.set_ylabel('Normalized Values (Z-score-like)', fontsize=12)
     ax.grid(True, alpha=0.3)
     
-    # Add a horizontal line at y=0 (the identity centerpoint)
-    ax.axhline(y=0, color='red', linestyle='--', alpha=0.5, linewidth=1, 
-               label='Identity Centerpoint')
+    # Add baseline
+    ax.axhline(y=0, color='red', linestyle='--', alpha=0.5, linewidth=1, label='Identity Centerpoint')
     ax.legend(loc='upper right')
     
-    # Adjust layout to prevent label cutoff and accommodate bottom text
-    plt.subplots_adjust(bottom=0.2)  # Extra space for bottom text
+    plt.subplots_adjust(bottom=0.2)
     plt.tight_layout()
-    plt.show()
+    plt.show()
+
+    # --- Outlier Detection ---
+    outliers_info = []
+    non_outlier_data = []
+
+    for i, data in enumerate(data_lists):
+        if len(data) > 0:
+            q1, median, q3 = np.percentile(data, [25, 50, 75])
+            iqr = q3 - q1
+            lower_bound = q1 - 1.5 * iqr
+            upper_bound = q3 + 1.5 * iqr
+
+            outliers = [val for val in data if val < lower_bound or val > upper_bound]
+            non_outliers = [val for val in data if lower_bound <= val <= upper_bound]
+
+            outliers_info.append({
+                'label': labels[i],
+                'outliers': outliers,
+                'lower_bound': lower_bound,
+                'upper_bound': upper_bound,
+                'total_count': len(data)
+            })
+            non_outlier_data.append(non_outliers)
+        else:
+            outliers_info.append({
+                'label': labels[i],
+                'outliers': [],
+                'lower_bound': None,
+                'upper_bound': None,
+                'total_count': 0
+            })
+            non_outlier_data.append([])
+
+    print("\n" + "="*60)
+    print("OUTLIER DETECTION SUMMARY")
+    print("="*60)
+    total_outliers = 0
+    for info in outliers_info:
+        n_outliers = len(info['outliers'])
+        total_outliers += n_outliers
+        if n_outliers > 0:
+            print(f"{info['label']}: {n_outliers} outliers out of {info['total_count']} points "
+                  f"({n_outliers/info['total_count']*100:.1f}%)")
+            print(f" Outlier Removed Range: [{info['lower_bound']:.2f}, {info['upper_bound']:.2f}]")
+    if total_outliers == 0:
+        print("No outliers detected in any dataset.")
+    else:
+        print(f"\nTotal outliers across all datasets: {total_outliers}")
+    print("="*60 + "\n")
+

{nettracer3d-1.1.3 → nettracer3d-1.1.6}/src/nettracer3d/nettracer.py

@@ -384,6 +384,13 @@ def invert_dict(d):
         inverted.setdefault(value, []).append(key)
     return inverted
 
+def revert_dict(d):
+    inverted = {}
+    for key, value_list in d.items():
+        for value in value_list:
+            inverted[value] = key
+    return inverted
+
 def invert_dict_special(d):
 
     d = invert_dict(d)
@@ -1045,9 +1052,12 @@ def show_3d(arrays_3d=None, arrays_4d=None, down_factor=None, order=0, xy_scale=
         # Downsample arrays if specified
         arrays_3d = [downsample(array, down_factor, order=order) for array in arrays_3d] if arrays_3d is not None else None
         arrays_4d = [downsample(array, down_factor, order=order) for array in arrays_4d] if arrays_4d is not None else None
+        scale = [z_scale * down_factor, xy_scale * down_factor, xy_scale * down_factor]
+    else:
+        scale = [z_scale, xy_scale, xy_scale]
+
     
     viewer = napari.Viewer(ndisplay=3)
-    scale = [z_scale, xy_scale, xy_scale]  # [z, y, x] order for napari
     
     # Add 3D arrays if provided
     if arrays_3d is not None:
@@ -3065,7 +3075,7 @@ class Network_3D:
                 for _ in range(weight):
                     lista.append(u)
                     listb.append(v)
-                    listc.append(weight)
+                    listc.append(0)
             
             self._network_lists = [lista, listb, listc]
 
@@ -4291,6 +4301,88 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
+    def create_id_network(self, n=5):
+        import ast
+        import random
+        
+        if self.node_identities is None:
+            return
+        
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+        
+        # Invert to get identity -> list of nodes
+        identity_to_nodes = invert_dict(self.node_identities)
+        
+        G = nx.Graph()
+        edge_set = set()
+        
+        # Step 1: Connect nodes within same exact identity
+        for identity, nodes in identity_to_nodes.items():
+            if len(nodes) <= 1:
+                continue
+            
+            # Each node chooses n random neighbors from its identity group
+            for node in nodes:
+                available = [other for other in nodes if other != node]
+                num_to_choose = min(n, len(available))
+                neighbors = random.sample(available, num_to_choose)
+                
+                for neighbor in neighbors:
+                    edge = tuple(sorted([node, neighbor]))
+                    edge_set.add(edge)
+        
+        # Step 2: For list-like identities, connect across groups with shared sub-identities
+        for identity, nodes in identity_to_nodes.items():
+            if identity.startswith('['):
+                try:
+                    sub_identities = ast.literal_eval(identity)
+                    
+                    # For each sub-identity in this list-like identity
+                    for sub_id in sub_identities:
+                        # Find all OTHER identity groups that contain this sub-identity
+                        for other_identity, other_nodes in identity_to_nodes.items():
+                            if other_identity == identity:
+                                continue  # Skip connecting to same exact identity (already done in Step 1)
+                            
+                            # Check if other_identity contains sub_id
+                            contains_sub_id = False
+                            
+                            if other_identity.startswith('['):
+                                try:
+                                    other_sub_ids = ast.literal_eval(other_identity)
+                                    if sub_id in other_sub_ids:
+                                        contains_sub_id = True
+                                except (ValueError, SyntaxError):
+                                    pass
+                            elif other_identity == sub_id:
+                                # Single identity that matches our sub-identity
+                                contains_sub_id = True
+                            
+                            if contains_sub_id:
+                                # Each node from current identity connects to n nodes from other_identity
+                                for node in nodes:
+                                    num_to_choose = min(n, len(other_nodes))
+                                    if num_to_choose > 0:
+                                        neighbors = random.sample(other_nodes, num_to_choose)
+                                        
+                                        for neighbor in neighbors:
+                                            edge = tuple(sorted([node, neighbor]))
+                                            edge_set.add(edge)
+                
+                except (ValueError, SyntaxError):
+                    pass  # Not a valid list, treat as already handled in Step 1
+        
+        G.add_edges_from(edge_set)
+        self.network = G
+
+
+
+
+
     def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
         """
         Method to calculate and save to mem all properties of a Network_3D object. In general, after initializing a Network_3D object, this method should be called on the node and edge masks that will be used to calculate the network.
@@ -5768,7 +5860,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 identity_umap(self, data):
+    def identity_umap(self, data, mode = 0):
 
         try:
 
@@ -5788,16 +5880,18 @@ class Network_3D:
                 else:
                     del umap_dict[item]
 
-            from scipy.stats import zscore
+            #from scipy.stats import zscore
 
             # Z-score normalize each marker (column)
-            for key in umap_dict:
-                umap_dict[key] = zscore(umap_dict[key])
-
+            #for key in umap_dict:
+                #umap_dict[key] = zscore(umap_dict[key])
 
             from . import neighborhoods
 
-            neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score') 
+            if mode == 0:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score') 
+            else:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score', neighborhoods = self.communities, original_communities = self.communities) 
 
         except Exception as e:
             import traceback
@@ -5916,7 +6010,6 @@ class Network_3D:
                         neighbor_group[com] = neighbors[node]
                     except:
                         neighbor_group[com] = 0
-                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) 
@@ -5929,6 +6022,19 @@ class Network_3D:
         return output, id_set
 
 
+    def group_nodes_by_intensity(self, data, count = None):
+
+        from . import neighborhoods
+
+        clusters = neighborhoods.cluster_arrays(data, count, seed = 42)
+
+        coms = {}
+
+        for i, cluster in enumerate(clusters):
+            coms[i + 1] = cluster
+
+        self.communities = revert_dict(coms)
+
     def assign_neighborhoods(self, seed, count, limit = None, prev_coms = None, proportional = False, mode = 0):
 
         from . import neighborhoods
@@ -6079,13 +6185,6 @@ class Network_3D:
 
     def community_cells(self, size = 32, xy_scale = 1, z_scale = 1):
 
-        def revert_dict(d):
-            inverted = {}
-            for key, value_list in d.items():
-                for value in value_list:
-                    inverted[value] = key
-            return inverted
-
         size_x = int(size * xy_scale)
         size_z = int(size * z_scale)