nettracer3d 0.9.3__py3-none-any.whl → 0.9.5__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/excelotron.py

@@ -4,7 +4,7 @@ import numpy as np
 from PyQt6.QtWidgets import (QApplication, QMainWindow, QHBoxLayout, QVBoxLayout, 
                            QWidget, QTableWidget, QTableWidgetItem, QPushButton, 
                            QLabel, QLineEdit, QScrollArea, QFrame, QMessageBox,
-                           QHeaderView, QAbstractItemView, QSplitter, QTabWidget)
+                           QHeaderView, QAbstractItemView, QSplitter, QTabWidget, QCheckBox)
 from PyQt6.QtCore import Qt, QMimeData, pyqtSignal
 from PyQt6.QtGui import QDragEnterEvent, QDropEvent, QDrag, QPainter, QPixmap
 import os
@@ -502,6 +502,35 @@ class ClassifierGroupWidget(QFrame):
         
         header_layout.addStretch()
         
+        # Hierarchical toggle
+        self.hierarchical_checkbox = QCheckBox("Hierarchical")
+        self.hierarchical_checkbox.setChecked(True)  # Default to hierarchical
+        self.hierarchical_checkbox.setStyleSheet("""
+            QCheckBox {
+                font-weight: bold;
+                color: #007acc;
+                padding: 5px;
+            }
+            QCheckBox::indicator {
+                width: 18px;
+                height: 18px;
+            }
+            QCheckBox::indicator:unchecked {
+                border: 2px solid #007acc;
+                background-color: white;
+                border-radius: 3px;
+            }
+            QCheckBox::indicator:checked {
+                border: 2px solid #007acc;
+                background-color: #007acc;
+                border-radius: 3px;
+            }
+            QCheckBox::indicator:checked:hover {
+                background-color: #005a9e;
+            }
+        """)
+        header_layout.addWidget(self.hierarchical_checkbox)
+        
         # Add classifier button
         add_btn = QPushButton("+ Add Classifier")
         add_btn.setStyleSheet("""
@@ -559,7 +588,7 @@ class ClassifierGroupWidget(QFrame):
         layout.addWidget(preview_btn)
         
         self.setLayout(layout)
-    
+
     def add_classifier(self):
         self.classifier_counter += 1
         classifier_id = self.classifier_counter
@@ -597,25 +626,50 @@ class ClassifierGroupWidget(QFrame):
         matched_identities = set()
         classifier_usage = {classifier_id: 0 for classifier_id in classifier_ids}  # Now classifier_ids is defined
         
+
         for identity in original_identities:
-            identity_str = str(identity)
-            
-            # Check classifiers in order
-            for classifier_id in classifier_ids:
-                classifier = self.classifiers[classifier_id]
-                
-                if classifier.matches_identity(identity_str):
-                    # This classifier matches
-                    matched_identities.add(identity)
-                    classifier_usage[classifier_id] += 1  # Track usage
+                    identity_str = str(identity)
                     
-                    # Set the new ID if provided
-                    new_id = classifier.get_new_id()
-                    if new_id and identity in self.identity_remap_widget.identity_mappings:
-                        self.identity_remap_widget.identity_mappings[identity]['new_edit'].setText(new_id)
-                    
-                    # Move to next identity (hierarchical - first match wins)
-                    break
+                    # Check classifiers in order
+                    for classifier_id in classifier_ids:
+                        classifier = self.classifiers[classifier_id]
+                        
+                        if classifier.matches_identity(identity_str):
+                            # This classifier matches
+                            matched_identities.add(identity)
+                            classifier_usage[classifier_id] += 1  # Track usage
+                            
+                            # Set the new ID if provided
+                            new_id = classifier.get_new_id()
+                            if new_id and identity in self.identity_remap_widget.identity_mappings:
+                                if self.hierarchical_checkbox.isChecked():
+                                    # Hierarchical mode - just set the new ID
+                                    self.identity_remap_widget.identity_mappings[identity]['new_edit'].setText(new_id)
+                                else:
+                                    # Non-hierarchical mode - append to existing or create new
+                                    current_text = self.identity_remap_widget.identity_mappings[identity]['new_edit'].text().strip()
+                                    if current_text:
+                                        # Parse existing text to see if it's already a list
+                                        try:
+                                            existing_list = literal_eval(current_text)
+                                            if isinstance(existing_list, list):
+                                                existing_list.append(new_id)
+                                                new_text = str(existing_list)
+                                            else:
+                                                # Current text is a single value, make it a list
+                                                new_text = str([current_text, new_id])
+                                        except:
+                                            # If parsing fails, treat as single value
+                                            new_text = str([current_text, new_id])
+                                    else:
+                                        # No existing text, just set the new ID
+                                        new_text = new_id
+                                    
+                                    self.identity_remap_widget.identity_mappings[identity]['new_edit'].setText(new_text)
+                            
+                            # Only break if hierarchical mode (first match wins)
+                            if self.hierarchical_checkbox.isChecked():
+                                break
         
         # Remove identities that didn't match any classifier
         unmatched_identities = set(original_identities) - matched_identities

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,
+                                     draw_lines: bool = False):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -370,6 +371,8 @@ 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:
     --------
@@ -453,15 +456,111 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        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)
+        # 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
         else:
-            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                                c=point_colors, cmap='viridis', s=100, alpha=0.7)
+            # 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)
         
         if label:
             # Add cluster ID labels
@@ -516,15 +615,112 @@ 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_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)
+        # 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
         else:
-            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                               c=point_colors, cmap='viridis', s=100, alpha=0.7)
+            # 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)
         
         if label:
             # Add cluster ID labels