nettracer3d 0.7.7__tar.gz → 0.7.9__tar.gz

{nettracer3d-0.7.7/src/nettracer3d.egg-info → nettracer3d-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.7.7
+Version: 0.7.9
 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/
@@ -73,6 +73,6 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.7.7 Updates -- 
+-- Version 0.7.9 Updates -- 
 
-	* See documentation once updated
+	* The GPU segmenter was being imported regardless of GPU status, causing the program to fail without cupy (which should be optional), fixed that.

{nettracer3d-0.7.7 → nettracer3d-0.7.9}/README.md

@@ -34,6 +34,6 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.7.7 Updates -- 
+-- Version 0.7.9 Updates -- 
 
-	* See documentation once updated
+	* The GPU segmenter was being imported regardless of GPU status, causing the program to fail without cupy (which should be optional), fixed that.

{nettracer3d-0.7.7 → nettracer3d-0.7.9}/pyproject.toml

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

{nettracer3d-0.7.7 → nettracer3d-0.7.9}/src/nettracer3d/excelotron.py

@@ -1599,7 +1599,13 @@ class ExcelToDictGUI(QMainWindow):
                                         remapped_data = self.identity_remap_widget.get_remapped_identities(filtered_data)
                                         result_dict[key_name] = remapped_data
                                     elif key_name == 'Numerical IDs':
-                                        # Apply same filtering to Numerical IDs
+                                        
+                                        # Check if user actually dropped a numerical IDs column
+                                        if widget_id not in self.dict_columns or 'data' not in self.dict_columns[widget_id]:
+                                            # Auto-generate sequential IDs and assign to column_data
+                                            column_data = np.array(list(range(1, len(self.df) + 1)))
+                                        
+                                        # Now use the exact same logic as if user provided the data
                                         identity_column_data = None
                                         # Find the identity column data
                                         for other_widget_id in self.dict_columns:
@@ -1620,11 +1626,55 @@ class ExcelToDictGUI(QMainWindow):
                                             result_dict[key_name] = filtered_numerical_ids
                                         else:
                                             result_dict[key_name] = column_data.tolist()
+                                        
+
                                     else:
                                         result_dict[key_name] = column_data.tolist()
                                 else:
                                     result_dict[key_name] = column_data.tolist()
                             break
+
+            for i in range(self.dict_layout.count()):
+                item = self.dict_layout.itemAt(i)
+                if item and item.widget() and hasattr(item.widget(), 'widget_id'):
+                    widget = item.widget()
+                    widget_id = widget.widget_id
+                    key_name = widget.header_input.text().strip()
+                    
+                    # Skip if already processed (has dropped data) or no key name
+                    if widget_id in self.dict_columns or not key_name:
+                        continue
+                        
+                    # Handle auto-generation for Node Identities template
+                    if property_name == 'Node Identities' and key_name == 'Numerical IDs':
+                        
+                        # Find the identity column data
+                        identity_column_data = None
+                        for other_widget_id in self.dict_columns:
+                            for j in range(self.dict_layout.count()):
+                                item_j = self.dict_layout.itemAt(j)
+                                if item_j and item_j.widget() and hasattr(item_j.widget(), 'widget_id'):
+                                    if item_j.widget().widget_id == other_widget_id:
+                                        other_key_name = item_j.widget().header_input.text().strip()
+                                        if other_key_name == 'Identity Column':
+                                            identity_column_data = self.dict_columns[other_widget_id]['data']
+                                            break
+                                if identity_column_data is not None:
+                                    break
+                        
+                        if identity_column_data is not None:
+                            # Auto-generate sequential IDs
+                            auto_generated_ids = np.array(list(range(1, len(self.df) + 1)))
+                            
+                            filtered_indices = self.identity_remap_widget.get_filtered_indices(identity_column_data.tolist())
+                            
+                            filtered_numerical_ids = [auto_generated_ids[i] for i in filtered_indices]
+                            
+                            result_dict[key_name] = filtered_numerical_ids
+                        else:
+                            # Fallback: generate sequential IDs for all rows
+                            result_dict[key_name] = list(range(1, len(self.df) + 1))
+
             
             if not result_dict:
                 QMessageBox.warning(self, "Warning", "No valid dictionary keys defined")

{nettracer3d-0.7.7 → nettracer3d-0.7.9}/src/nettracer3d/neighborhoods.py

@@ -202,6 +202,137 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     
     return embedding
 
+def create_community_heatmap(community_intensity, node_community, node_centroids, is_3d=True, 
+                           figsize=(12, 8), point_size=50, alpha=0.7, colorbar_label="Community Intensity"):
+    """
+    Create a 2D or 3D heatmap showing nodes colored by their community intensities.
+    
+    Parameters:
+    -----------
+    community_intensity : dict
+        Dictionary mapping community IDs to intensity values
+        Keys can be np.int64 or regular ints
+        
+    node_community : dict
+        Dictionary mapping node IDs to community IDs
+        
+    node_centroids : dict
+        Dictionary mapping node IDs to centroids
+        Centroids should be [Z, Y, X] for 3D or [1, Y, X] for pseudo-3D
+        
+    is_3d : bool, default=True
+        If True, create 3D plot. If False, create 2D plot.
+        
+    figsize : tuple, default=(12, 8)
+        Figure size (width, height)
+        
+    point_size : int, default=50
+        Size of scatter plot points
+        
+    alpha : float, default=0.7
+        Transparency of points (0-1)
+        
+    colorbar_label : str, default="Community Intensity"
+        Label for the colorbar
+        
+    Returns:
+    --------
+    fig, ax : matplotlib figure and axis objects
+    """
+    
+    # Convert numpy int64 keys to regular ints for consistency
+    community_intensity_clean = {}
+    for k, v in community_intensity.items():
+        if hasattr(k, 'item'):  # numpy scalar
+            community_intensity_clean[k.item()] = v
+        else:
+            community_intensity_clean[k] = v
+    
+    # Prepare data for plotting
+    node_positions = []
+    node_intensities = []
+    
+    for node_id, centroid in node_centroids.items():
+        try:
+            # Get community for this node
+            community_id = node_community[node_id]
+            
+            # Convert community_id to regular int if it's numpy
+            if hasattr(community_id, 'item'):
+                community_id = community_id.item()
+                
+            # Get intensity for this community
+            intensity = community_intensity_clean[community_id]
+            
+            node_positions.append(centroid)
+            node_intensities.append(intensity)
+        except:
+            pass
+    
+    # Convert to numpy arrays
+    positions = np.array(node_positions)
+    intensities = np.array(node_intensities)
+    
+    # Determine min and max intensities for color scaling
+    min_intensity = np.min(intensities)
+    max_intensity = np.max(intensities)
+    
+    # Create figure
+    fig = plt.figure(figsize=figsize)
+    
+    if is_3d:
+        # 3D plot
+        ax = fig.add_subplot(111, projection='3d')
+        
+        # Extract coordinates (assuming [Z, Y, X] format)
+        z_coords = positions[:, 0]
+        y_coords = positions[:, 1]
+        x_coords = positions[:, 2]
+        
+        # Create scatter plot
+        scatter = ax.scatter(x_coords, y_coords, z_coords, 
+                           c=intensities, s=point_size, alpha=alpha,
+                           cmap='RdBu_r', vmin=min_intensity, vmax=max_intensity)
+        
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        ax.set_title('3D Community Intensity Heatmap')
+        
+    else:
+        # 2D plot (using Y, X coordinates, ignoring Z/first dimension)
+        ax = fig.add_subplot(111)
+        
+        # Extract Y, X coordinates
+        y_coords = positions[:, 1]
+        x_coords = positions[:, 2]
+        
+        # Create scatter plot
+        scatter = ax.scatter(x_coords, y_coords, 
+                           c=intensities, s=point_size, alpha=alpha,
+                           cmap='RdBu_r', vmin=min_intensity, vmax=max_intensity)
+        
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_title('2D Community Intensity Heatmap')
+        ax.grid(True, alpha=0.3)
+        
+        # Set origin to top-left (invert Y-axis)
+        ax.invert_yaxis()
+    
+    # Add colorbar
+    cbar = plt.colorbar(scatter, ax=ax, shrink=0.8)
+    cbar.set_label(colorbar_label)
+    
+    # Add text annotations for min/max values
+    cbar.ax.text(1.05, 0, f'Min: {min_intensity:.3f}\n(Blue)', 
+                transform=cbar.ax.transAxes, va='bottom')
+    cbar.ax.text(1.05, 1, f'Max: {max_intensity:.3f}\n(Red)', 
+                transform=cbar.ax.transAxes, va='top')
+    
+    plt.tight_layout()
+    plt.show()
+
 
 
 # Example usage:

{nettracer3d-0.7.7 → nettracer3d-0.7.9}/src/nettracer3d/nettracer.py

@@ -3831,6 +3831,41 @@ class Network_3D:
             self._nodes = self._nodes.astype(np.uint16)
 
 
+    def com_by_size(self):
+        """Reassign communities based on size, starting with 1 for largest."""
+
+        from collections import Counter
+        
+        # Convert all community values to regular ints (handles numpy scalars)
+        clean_communities = {
+            node: comm.item() if hasattr(comm, 'item') else comm 
+            for node, comm in self.communities.items()
+        }
+        
+        # Count community sizes and create mapping in one go
+        community_sizes = Counter(clean_communities.values())
+        
+        # Create old->new mapping: sort by size (desc), then by community ID for ties
+        old_to_new = {
+            old_comm: new_comm 
+            for new_comm, (old_comm, _) in enumerate(
+                sorted(community_sizes.items(), key=lambda x: (-x[1], x[0])), 
+                start=1
+            )
+        }
+        
+        # Apply mapping
+        self.communities = {
+            node: old_to_new[comm] 
+            for node, comm in clean_communities.items()
+        }
+
+
+
+
+
+
+
     def com_to_node(self, targets = None):
 
         def invert_dict(d):
@@ -4982,7 +5017,7 @@ class Network_3D:
 
             return array
 
-    def community_cells(self, size = 32):
+    def community_cells(self, size = 32, xy_scale = 1, z_scale = 1):
 
         def invert_dict(d):
             inverted = {}
@@ -4991,10 +5026,61 @@ class Network_3D:
                     inverted[value] = key
             return inverted
 
-        com_dict = proximity.partition_objects_into_cells(self.node_centroids, size)
+        size_x = int(size * xy_scale)
+        size_z = int(size * z_scale)
+
+        if size_x == size_z:
+
+            com_dict = proximity.partition_objects_into_cells(self.node_centroids, size_x)
+
+        else:
+
+            com_dict = proximity.partition_objects_into_cells(self.node_centroids, (size_z, size_x, size_x))
 
         self.communities = invert_dict(com_dict)
 
+    def community_heatmap(self, num_nodes = None, is3d = True):
+
+        import math
+
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+
+        if num_nodes == None:
+
+            try:
+                num_nodes = len(self.network.nodes())
+            except:
+                try:
+                    num_nodes = len(self.node_centroids.keys())
+                except:
+                    try:
+                        num_nodes = len(self.node_identities.keys())
+                    except:
+                        try:
+                            unique = np.unique(self.nodes)
+                            num_nodes = len(unique)
+                            if unique[0] == 0:
+                                num_nodes -= 1
+                        except:
+                            return
+
+        coms = invert_dict(self.communities)
+
+        rand_dens = num_nodes / len(coms.keys())
+
+        heat_dict = {}
+
+        for com, nodes in coms.items():
+            heat_dict[com] = math.log(len(nodes)/rand_dens)
+
+        from . import neighborhoods
+        neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, is_3d=is3d)
+
+        return heat_dict