nettracer3d 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

nettracer3d/community_extractor.py

@@ -549,54 +549,117 @@ def convert_node_colors_to_names(node_to_color: Dict[int, Tuple[int, int, int]],
         
         num_entries = len(node_to_color)
         
-        # Calculate dynamic spacing based on number of entries
-        entry_height = 0.8
-        total_height = num_entries * entry_height + 1.5  # Extra space for title and margins
+        # Calculate text widths to determine optimal figure size
+        sorted_nodes = sorted(node_to_color.keys())
+        
+        # Create a temporary figure to measure text widths
+        temp_fig, temp_ax = plt.subplots(figsize=(1, 1))
+        
+        max_node_width = 0
+        max_color_width = 0
+        
+        for node in sorted_nodes:
+            color_name = node_to_names[node]
+            
+            # Measure node ID text width
+            node_text = temp_ax.text(0, 0, str(node), fontsize=12, fontweight='bold')
+            node_bbox = node_text.get_window_extent(renderer=temp_fig.canvas.get_renderer())
+            node_width = node_bbox.width
+            max_node_width = max(max_node_width, node_width)
+            
+            # Measure color name text width
+            color_text = temp_ax.text(0, 0, color_name.replace('_', ' ').title(), fontsize=11)
+            color_bbox = color_text.get_window_extent(renderer=temp_fig.canvas.get_renderer())
+            color_width = color_bbox.width
+            max_color_width = max(max_color_width, color_width)
+        
+        plt.close(temp_fig)
+        
+        # Convert pixel widths to figure units (approximate conversion)
+        # This is a rough conversion - matplotlib uses 72 DPI by default
+        dpi = 72
+        max_node_width_fig = max_node_width / dpi
+        max_color_width_fig = max_color_width / dpi
+        
+        # Calculate optimal figure dimensions
+        entry_height = 0.6  # Reduced for tighter spacing
+        margin = 0.3
+        swatch_width = 0.8
+        spacing = 0.2
+        
+        # Calculate total width needed
+        total_width = (margin + max_node_width_fig + spacing + 
+                       swatch_width + spacing + max_color_width_fig + margin)
         
-        # Create figure and axis with proper scaling
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.set_xlim(0, 10)
+        # Ensure minimum width for readability
+        total_width = max(total_width, 4.0)
+        
+        # Calculate total height
+        title_height = 0.8
+        total_height = num_entries * entry_height + title_height + 2 * margin
+        
+        # Create the actual figure with calculated dimensions
+        fig, ax = plt.subplots(figsize=(total_width, total_height))
+        
+        # Set axis limits to match our calculated dimensions
+        ax.set_xlim(0, total_width)
         ax.set_ylim(0, total_height)
         ax.axis('off')
         
         # Title
-        ax.text(5, total_height - 0.5, 'Color Legend', 
-                fontsize=16, fontweight='bold', ha='center')
-        
-        # Sort nodes for consistent display
-        sorted_nodes = sorted(node_to_color.keys())
+        ax.text(total_width/2, total_height - margin - 0.2, 'Color Legend', 
+                fontsize=14, fontweight='bold', ha='center', va='top')
         
         # Create legend entries
         for i, node in enumerate(sorted_nodes):
-            y_pos = total_height - (i + 1) * entry_height - 0.8
+            y_pos = total_height - title_height - margin - (i + 1) * entry_height + entry_height/2
             rgb = node_to_color[node]
             color_name = node_to_names[node]
             
             # Normalize RGB values for matplotlib (0-1 range)
             norm_rgb = tuple(c/255.0 for c in rgb)
             
-            # Draw color swatch (using actual RGB values)
-            swatch = Rectangle((1.0, y_pos - 0.15), 0.8, 0.3, 
-                              facecolor=norm_rgb, edgecolor='black', linewidth=1)
-            ax.add_patch(swatch)
+            # Position calculations
+            node_x = margin
+            swatch_x = margin + max_node_width_fig + spacing
+            color_x = swatch_x + swatch_width + spacing
             
-            # Node ID (exactly as it appears in dict keys)
-            ax.text(0.2, y_pos, str(node), fontsize=12, fontweight='bold', 
+            # Node ID (left-aligned)
+            ax.text(node_x, y_pos, str(node), fontsize=12, fontweight='bold', 
                     va='center', ha='left')
             
-            # Color name (mapped name, nicely formatted)
-            ax.text(2.2, y_pos, color_name.replace('_', ' ').title(), 
+            # Draw color swatch
+            swatch_y = y_pos - entry_height/4
+            swatch = Rectangle((swatch_x, swatch_y), swatch_width, entry_height/2, 
+                              facecolor=norm_rgb, edgecolor='black', linewidth=1)
+            ax.add_patch(swatch)
+            
+            # Color name
+            formatted_name = color_name.replace('_', ' ').title()
+            # Truncate very long color names to prevent layout issues
+            if len(formatted_name) > 25:
+                formatted_name = formatted_name[:22] + "..."
+                
+            ax.text(color_x, y_pos, formatted_name, 
                     fontsize=11, va='center', ha='left')
         
-        # Add border around the legend
-        border = Rectangle((0.1, 0.1), 9.8, total_height - 0.2, 
-                          fill=False, edgecolor='gray', linewidth=2)
+        # Add a subtle border around the entire legend
+        border_margin = 0.1
+        border = Rectangle((border_margin, border_margin), 
+                          total_width - 2*border_margin, 
+                          total_height - 2*border_margin, 
+                          fill=False, edgecolor='lightgray', linewidth=1.5)
         ax.add_patch(border)
         
-        plt.tight_layout()
+        # Remove any extra whitespace
+        plt.tight_layout(pad=0.1)
+        
+        # Adjust the figure to eliminate whitespace
+        ax.margins(0)
+        fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
         
         if save_path:
-            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            plt.savefig(save_path, dpi=300, bbox_inches='tight', pad_inches=0.05)
             
         plt.show()
     

nettracer3d/neighborhoods.py

@@ -347,8 +347,7 @@ 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,
-                                     draw_lines: bool = False):
+                                     neighborhoods: Optional[Dict[int, int]] = None):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -371,8 +370,6 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     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.
-    draw_lines : bool
-        Whether to draw lines between nodes that share identities (default: False)
     
     Returns:
     --------
@@ -456,111 +453,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        # Draw scatter with different markers for multi-identity nodes if draw_lines is enabled
-        if draw_lines:
-            # Separate multi-identity and singleton nodes for different markers
-            singleton_indices = []
-            multi_indices = []
-            singleton_colors = []
-            multi_colors = []
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity
-                    multi_indices.append(i)
-                    multi_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-                else:  # Singleton
-                    singleton_indices.append(i)
-                    singleton_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-            
-            # Draw singleton nodes as circles
-            if singleton_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter1 = plt.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], 
-                                         c=singleton_colors, s=100, alpha=0.7, marker='o')
-                else:
-                    scatter1 = plt.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], 
-                                         c=[point_colors[i] for i in singleton_indices], cmap='viridis', s=100, alpha=0.7, marker='o')
-            
-            # Draw multi-identity nodes as squares
-            if multi_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter2 = plt.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], 
-                                         c=multi_colors, s=100, alpha=0.7, marker='s')
-                else:
-                    scatter2 = plt.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], 
-                                         c=[point_colors[i] for i in multi_indices], cmap='viridis', s=100, alpha=0.7, marker='s')
-                scatter = scatter2  # For colorbar reference
-            else:
-                scatter = scatter1 if singleton_indices else None
+        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:
-            # Original behavior when draw_lines is False
-            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:
-                scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                                    c=point_colors, cmap='viridis', s=100, alpha=0.7)
-        
-        # Draw lines between nodes with shared identities (only if draw_lines=True)
-        if draw_lines:
-            # First pass: identify unique multi-identity configurations and their representatives
-            multi_config_map = {}  # Maps tuple(config) -> {'count': int, 'representative_idx': int}
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity node
-                    config = tuple(vec)  # Convert to hashable tuple
-                    if config not in multi_config_map:
-                        multi_config_map[config] = {'count': 1, 'representative_idx': i}
-                    else:
-                        multi_config_map[config]['count'] += 1
-            
-            # Second pass: draw lines for each unique configuration
-            for config, info in multi_config_map.items():
-                i = info['representative_idx']
-                count = info['count']
-                vec1 = np.array(config)
-                
-                # For each identity this configuration has, find the closest representative
-                identity_indices = np.where(vec1 == 1)[0]
-                
-                for identity_idx in identity_indices:
-                    best_target = None
-                    best_distance = float('inf')
-                    backup_target = None
-                    backup_distance = float('inf')
-                    
-                    # Find closest node with this specific identity
-                    for j, cluster_id2 in enumerate(cluster_ids):
-                        if i != j:  # Don't connect to self
-                            vec2 = cluster_data[cluster_id2]
-                            if vec2[identity_idx] == 1:  # Shares this specific identity
-                                distance = np.linalg.norm(embedding[i] - embedding[j])
-                                
-                                # Prefer singleton nodes
-                                if np.sum(vec2) == 1:  # Singleton
-                                    if distance < best_distance:
-                                        best_distance = distance
-                                        best_target = j
-                                else:  # Multi-identity node (backup)
-                                    if distance < backup_distance:
-                                        backup_distance = distance
-                                        backup_target = j
-                    
-                    # Draw line to best target (prefer singleton, fallback to multi)
-                    target = best_target if best_target is not None else backup_target
-                    if target is not None:
-                        # Calculate relative line weight with reasonable cap
-                        max_count = max(info['count'] for info in multi_config_map.values())
-                        relative_weight = count / max_count  # Normalize to 0-1
-                        line_weight = 0.3 + relative_weight * 1.2  # Scale to 0.3-1.5 range
-                        plt.plot([embedding[i, 0], embedding[target, 0]], 
-                               [embedding[i, 1], embedding[target, 1]], 
-                               alpha=0.3, color='gray', linewidth=line_weight)
+            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
+                                c=point_colors, cmap='viridis', s=100, alpha=0.7)
         
         if label:
             # Add cluster ID labels
@@ -615,112 +516,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         fig = plt.figure(figsize=(14, 10))
         ax = fig.add_subplot(111, projection='3d')
         
-        # Draw scatter with different markers for multi-identity nodes if draw_lines is enabled
-        if draw_lines:
-            # Separate multi-identity and singleton nodes for different markers
-            singleton_indices = []
-            multi_indices = []
-            singleton_colors = []
-            multi_colors = []
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity
-                    multi_indices.append(i)
-                    multi_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-                else:  # Singleton
-                    singleton_indices.append(i)
-                    singleton_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-            
-            # Draw singleton nodes as circles
-            if singleton_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter1 = ax.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], embedding[singleton_indices, 2],
-                                        c=singleton_colors, s=100, alpha=0.7, marker='o')
-                else:
-                    scatter1 = ax.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], embedding[singleton_indices, 2],
-                                        c=[point_colors[i] for i in singleton_indices], cmap='viridis', s=100, alpha=0.7, marker='o')
-            
-            # Draw multi-identity nodes as squares
-            if multi_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter2 = ax.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], embedding[multi_indices, 2],
-                                        c=multi_colors, s=100, alpha=0.7, marker='s')
-                else:
-                    scatter2 = ax.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], embedding[multi_indices, 2],
-                                        c=[point_colors[i] for i in multi_indices], cmap='viridis', s=100, alpha=0.7, marker='s')
-                scatter = scatter2  # For colorbar reference
-            else:
-                scatter = scatter1 if singleton_indices else None
+        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:
-            # Original behavior when draw_lines is False
-            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:
-                scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                                   c=point_colors, cmap='viridis', s=100, alpha=0.7)
-        
-        # Draw lines between nodes with shared identities (only if draw_lines=True)
-        if draw_lines:
-            # First pass: identify unique multi-identity configurations and their representatives
-            multi_config_map = {}  # Maps tuple(config) -> {'count': int, 'representative_idx': int}
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity node
-                    config = tuple(vec)  # Convert to hashable tuple
-                    if config not in multi_config_map:
-                        multi_config_map[config] = {'count': 1, 'representative_idx': i}
-                    else:
-                        multi_config_map[config]['count'] += 1
-            
-            # Second pass: draw lines for each unique configuration
-            for config, info in multi_config_map.items():
-                i = info['representative_idx']
-                count = info['count']
-                vec1 = np.array(config)
-                
-                # For each identity this configuration has, find the closest representative
-                identity_indices = np.where(vec1 == 1)[0]
-                
-                for identity_idx in identity_indices:
-                    best_target = None
-                    best_distance = float('inf')
-                    backup_target = None
-                    backup_distance = float('inf')
-                    
-                    # Find closest node with this specific identity
-                    for j, cluster_id2 in enumerate(cluster_ids):
-                        if i != j:  # Don't connect to self
-                            vec2 = cluster_data[cluster_id2]
-                            if vec2[identity_idx] == 1:  # Shares this specific identity
-                                distance = np.linalg.norm(embedding[i] - embedding[j])
-                                
-                                # Prefer singleton nodes
-                                if np.sum(vec2) == 1:  # Singleton
-                                    if distance < best_distance:
-                                        best_distance = distance
-                                        best_target = j
-                                else:  # Multi-identity node (backup)
-                                    if distance < backup_distance:
-                                        backup_distance = distance
-                                        backup_target = j
-                    
-                    # Draw line to best target (prefer singleton, fallback to multi)
-                    target = best_target if best_target is not None else backup_target
-                    if target is not None:
-                        # Calculate relative line weight with reasonable cap
-                        max_count = max(info['count'] for info in multi_config_map.values())
-                        relative_weight = count / max_count  # Normalize to 0-1
-                        line_weight = 0.3 + relative_weight * 1.2  # Scale to 0.3-1.5 range
-                        ax.plot([embedding[i, 0], embedding[target, 0]], 
-                               [embedding[i, 1], embedding[target, 1]], 
-                               [embedding[i, 2], embedding[target, 2]], 
-                               alpha=0.3, color='gray', linewidth=line_weight)
+            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
+                               c=point_colors, cmap='viridis', s=100, alpha=0.7)
         
         if label:
             # Add cluster ID labels