nettracer3d 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

nettracer3d/neighborhoods.py

@@ -202,10 +202,12 @@ 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"):
+def create_community_heatmap(community_intensity, node_community, node_centroids, shape=None, is_3d=True, 
+                           labeled_array=None, figsize=(12, 8), point_size=50, alpha=0.7, 
+                           colorbar_label="Community Intensity", title="Community Intensity Heatmap"):
     """
     Create a 2D or 3D heatmap showing nodes colored by their community intensities.
+    Can return either matplotlib plot or numpy RGB array for overlay purposes.
     
     Parameters:
     -----------
@@ -220,25 +222,39 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
         Dictionary mapping node IDs to centroids
         Centroids should be [Z, Y, X] for 3D or [1, Y, X] for pseudo-3D
         
+    shape : tuple, optional
+        Shape of the output array in [Z, Y, X] format
+        If None, will be inferred from node_centroids
+        
     is_3d : bool, default=True
-        If True, create 3D plot. If False, create 2D plot.
+        If True, create 3D plot/array. If False, create 2D plot/array.
+        
+    labeled_array : np.ndarray, optional
+        If provided, returns numpy RGB array overlay using this labeled array template
+        instead of matplotlib plot. Uses lookup table approach for efficiency.
         
     figsize : tuple, default=(12, 8)
-        Figure size (width, height)
+        Figure size (width, height) - only used for matplotlib
         
     point_size : int, default=50
-        Size of scatter plot points
+        Size of scatter plot points - only used for matplotlib
         
     alpha : float, default=0.7
-        Transparency of points (0-1)
+        Transparency of points (0-1) - only used for matplotlib
         
     colorbar_label : str, default="Community Intensity"
-        Label for the colorbar
+        Label for the colorbar - only used for matplotlib
+        
+    title : str, default="Community Intensity Heatmap"
+        Title for the plot
         
     Returns:
     --------
-    fig, ax : matplotlib figure and axis objects
+    If labeled_array is None: fig, ax (matplotlib figure and axis objects)
+    If labeled_array is provided: np.ndarray (RGB heatmap array with community intensity colors)
     """
+    import numpy as np
+    import matplotlib.pyplot as plt
     
     # Convert numpy int64 keys to regular ints for consistency
     community_intensity_clean = {}
@@ -254,6 +270,10 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
     
     for node_id, centroid in node_centroids.items():
         try:
+            # Convert node_id to regular int if it's numpy
+            if hasattr(node_id, 'item'):
+                node_id = node_id.item()
+                
             # Get community for this node
             community_id = node_community[node_id]
             
@@ -266,74 +286,392 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
             
             node_positions.append(centroid)
             node_intensities.append(intensity)
-        except:
+        except KeyError:
+            # Skip nodes that don't have community assignments or community intensities
             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)
+    # Determine shape if not provided
+    if shape is None:
+        if len(positions) > 0:
+            max_coords = np.max(positions, axis=0).astype(int)
+            shape = tuple(max_coords + 1)
+        else:
+            shape = (100, 100, 100) if is_3d else (1, 100, 100)
     
-    # Create figure
-    fig = plt.figure(figsize=figsize)
+    # Determine min and max intensities for scaling
+    if len(intensities) > 0:
+        min_intensity = np.min(intensities)
+        max_intensity = np.max(intensities)
+    else:
+        min_intensity, max_intensity = 0, 1
     
-    if is_3d:
-        # 3D plot
-        ax = fig.add_subplot(111, projection='3d')
+    if labeled_array is not None:
+        # Create numpy RGB array output using labeled array and lookup table approach
+        
+        # Create mapping from node ID to community intensity value
+        node_to_community_intensity = {}
+        for node_id, centroid in node_centroids.items():
+            # Convert node_id to regular int if it's numpy
+            if hasattr(node_id, 'item'):
+                node_id = node_id.item()
+            
+            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
+                if community_id in community_intensity_clean:
+                    node_to_community_intensity[node_id] = community_intensity_clean[community_id]
+            except KeyError:
+                # Skip nodes that don't have community assignments
+                pass
+        
+        # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
+        def intensity_to_rgb(intensity, min_val, max_val):
+            """Convert intensity value to RGB using RdBu_r colormap logic"""
+            if max_val == min_val:
+                # All same value, use neutral color
+                return np.array([255, 255, 255], dtype=np.uint8)  # White
+            
+            # Normalize to -1 to 1 range (like RdBu_r colormap)
+            normalized = 2 * (intensity - min_val) / (max_val - min_val) - 1
+            normalized = np.clip(normalized, -1, 1)
+            
+            if normalized > 0:
+                # Positive values: white to red
+                r = 255
+                g = int(255 * (1 - normalized))
+                b = int(255 * (1 - normalized))
+            else:
+                # Negative values: white to blue
+                r = int(255 * (1 + normalized))
+                g = int(255 * (1 + normalized))
+                b = 255
+            
+            return np.array([r, g, b], dtype=np.uint8)
         
-        # Extract coordinates (assuming [Z, Y, X] format)
-        z_coords = positions[:, 0]
-        y_coords = positions[:, 1]
-        x_coords = positions[:, 2]
+        # Create lookup table for RGB colors
+        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)
         
-        # 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)
+        # Fill lookup table with RGB colors based on community intensity
+        for node_id, intensity in node_to_community_intensity.items():
+            rgb_color = intensity_to_rgb(intensity, min_intensity, max_intensity)
+            color_lut[int(node_id)] = rgb_color
         
-        ax.set_xlabel('X')
-        ax.set_ylabel('Y')
-        ax.set_zlabel('Z')
-        ax.set_title('3D Community Intensity Heatmap')
+        # Apply lookup table to labeled array - single vectorized operation
+        if is_3d:
+            # Return full 3D RGB array [Z, Y, X, 3]
+            heatmap_array = color_lut[labeled_array]
+        else:
+            # Return 2D RGB array
+            if labeled_array.ndim == 3:
+                # Take middle slice for 2D representation
+                middle_slice = labeled_array.shape[0] // 2
+                heatmap_array = color_lut[labeled_array[middle_slice]]
+            else:
+                # Already 2D
+                heatmap_array = color_lut[labeled_array]
         
+        return heatmap_array
+    
     else:
-        # 2D plot (using Y, X coordinates, ignoring Z/first dimension)
-        ax = fig.add_subplot(111)
+        # Create matplotlib plot
+        fig = plt.figure(figsize=figsize)
         
-        # Extract Y, X coordinates
-        y_coords = positions[:, 1]
-        x_coords = positions[:, 2]
+        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(f'{title}')
+            
+            # Set axis limits based on shape
+            ax.set_xlim(0, shape[2])
+            ax.set_ylim(0, shape[1])
+            ax.set_zlim(0, shape[0])
+            
+        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(f'{title}')
+            ax.grid(True, alpha=0.3)
+            
+            # Set axis limits based on shape
+            ax.set_xlim(0, shape[2])
+            ax.set_ylim(0, shape[1])
+            
+            # Set origin to top-left (invert Y-axis)
+            ax.invert_yaxis()
         
-        # 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)
+        # Add colorbar
+        cbar = plt.colorbar(scatter, ax=ax, shrink=0.8)
+        cbar.set_label(colorbar_label)
         
-        ax.set_xlabel('X')
-        ax.set_ylabel('Y')
-        ax.set_title('2D Community Intensity Heatmap')
-        ax.grid(True, alpha=0.3)
+        # 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')
         
-        # Set origin to top-left (invert Y-axis)
-        ax.invert_yaxis()
+        plt.tight_layout()
+        plt.show()
+
+
+def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True, 
+                        labeled_array=None, figsize=(12, 8), point_size=50, alpha=0.7, 
+                        colorbar_label="Node Intensity", title="Node Clustering Intensity Heatmap"):
+    """
+    Create a 2D or 3D heatmap showing nodes colored by their individual intensities.
+    Can return either matplotlib plot or numpy array for overlay purposes.
     
-    # Add colorbar
-    cbar = plt.colorbar(scatter, ax=ax, shrink=0.8)
-    cbar.set_label(colorbar_label)
+    Parameters:
+    -----------
+    node_intensity : dict
+        Dictionary mapping node IDs to intensity values
+        Keys can be np.int64 or regular ints
+        
+    node_centroids : dict
+        Dictionary mapping node IDs to centroids
+        Centroids should be [Z, Y, X] for 3D or [1, Y, X] for pseudo-3D
+        
+    shape : tuple, optional
+        Shape of the output array in [Z, Y, X] format
+        If None, will be inferred from node_centroids
+        
+    is_3d : bool, default=True
+        If True, create 3D plot/array. If False, create 2D plot/array.
+        
+    labeled_array : np.ndarray, optional
+        If provided, returns numpy array overlay using this labeled array template
+        instead of matplotlib plot. Uses lookup table approach for efficiency.
+        
+    figsize : tuple, default=(12, 8)
+        Figure size (width, height) - only used for matplotlib
+        
+    point_size : int, default=50
+        Size of scatter plot points - only used for matplotlib
+        
+    alpha : float, default=0.7
+        Transparency of points (0-1) - only used for matplotlib
+        
+    colorbar_label : str, default="Node Intensity"
+        Label for the colorbar - only used for matplotlib
+        
+    Returns:
+    --------
+    If labeled_array is None: fig, ax (matplotlib figure and axis objects)
+    If labeled_array is provided: np.ndarray (heatmap array with intensity values)
+    """
+    import numpy as np
+    import matplotlib.pyplot as plt
+    
+    # Convert numpy int64 keys to regular ints for consistency
+    node_intensity_clean = {}
+    for k, v in node_intensity.items():
+        if hasattr(k, 'item'):  # numpy scalar
+            node_intensity_clean[k.item()] = v
+        else:
+            node_intensity_clean[k] = v
     
-    # 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')
+    # Prepare data for plotting/array creation
+    node_positions = []
+    node_intensities = []
     
-    plt.tight_layout()
-    plt.show()
-
-
+    for node_id, centroid in node_centroids.items():
+        try:
+            # Convert node_id to regular int if it's numpy
+            if hasattr(node_id, 'item'):
+                node_id = node_id.item()
+                
+            # Get intensity for this node
+            intensity = node_intensity_clean[node_id]
+            
+            node_positions.append(centroid)
+            node_intensities.append(intensity)
+        except KeyError:
+            # Skip nodes that don't have intensity values
+            pass
+    
+    # Convert to numpy arrays
+    positions = np.array(node_positions)
+    intensities = np.array(node_intensities)
+    
+    # Determine shape if not provided
+    if shape is None:
+        if len(positions) > 0:
+            max_coords = np.max(positions, axis=0).astype(int)
+            shape = tuple(max_coords + 1)
+        else:
+            shape = (100, 100, 100) if is_3d else (1, 100, 100)
+    
+    # Determine min and max intensities for scaling
+    if len(intensities) > 0:
+        min_intensity = np.min(intensities)
+        max_intensity = np.max(intensities)
+    else:
+        min_intensity, max_intensity = 0, 1
+    
+    if labeled_array is not None:
+        # Create numpy RGB array output using labeled array and lookup table approach
+        
+        # Create mapping from node ID to intensity value (keep original float values)
+        node_to_intensity = {}
+        for node_id, centroid in node_centroids.items():
+            # Convert node_id to regular int if it's numpy
+            if hasattr(node_id, 'item'):
+                node_id = node_id.item()
+            
+            # Only include nodes that have intensity values
+            if node_id in node_intensity_clean:
+                node_to_intensity[node_id] = node_intensity_clean[node_id]
+        
+        # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
+        def intensity_to_rgb(intensity, min_val, max_val):
+            """Convert intensity value to RGB using RdBu_r colormap logic"""
+            if max_val == min_val:
+                # All same value, use neutral color
+                return np.array([255, 255, 255], dtype=np.uint8)  # White
+            
+            # Normalize to -1 to 1 range (like RdBu_r colormap)
+            normalized = 2 * (intensity - min_val) / (max_val - min_val) - 1
+            normalized = np.clip(normalized, -1, 1)
+            
+            if normalized > 0:
+                # Positive values: white to red
+                r = 255
+                g = int(255 * (1 - normalized))
+                b = int(255 * (1 - normalized))
+            else:
+                # Negative values: white to blue
+                r = int(255 * (1 + normalized))
+                g = int(255 * (1 + normalized))
+                b = 255
+            
+            return np.array([r, g, b], dtype=np.uint8)
+        
+        # Create lookup table for RGB colors
+        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, 3), dtype=np.uint8)  # Default to black (0,0,0)
+        
+        # Fill lookup table with RGB colors based on intensity
+        for node_id, intensity in node_to_intensity.items():
+            rgb_color = intensity_to_rgb(intensity, min_intensity, max_intensity)
+            color_lut[int(node_id)] = rgb_color
+        
+        # Apply lookup table to labeled array - single vectorized operation
+        if is_3d:
+            # Return full 3D RGB array [Z, Y, X, 3]
+            heatmap_array = color_lut[labeled_array]
+        else:
+            # Return 2D RGB array
+            if labeled_array.ndim == 3:
+                # Take middle slice for 2D representation
+                middle_slice = labeled_array.shape[0] // 2
+                heatmap_array = color_lut[labeled_array[middle_slice]]
+            else:
+                # Already 2D
+                heatmap_array = color_lut[labeled_array]
+        
+        return heatmap_array
+    
+    else:
+        # Create matplotlib plot
+        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(f'{title}')
+            
+            # Set axis limits based on shape
+            ax.set_xlim(0, shape[2])
+            ax.set_ylim(0, shape[1])
+            ax.set_zlim(0, shape[0])
+            
+        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(f'{title}')
+            ax.grid(True, alpha=0.3)
+            
+            # Set axis limits based on shape
+            ax.set_xlim(0, shape[2])
+            ax.set_ylim(0, shape[1])
+            
+            # 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:
 if __name__ == "__main__":
@@ -350,5 +688,4 @@ if __name__ == "__main__":
     fig, ax = plot_dict_heatmap(sample_dict, sample_id_set, 
                                title="Sample Heatmap Visualization")
     
-    plt.show()
-
+    plt.show()

nettracer3d/nettracer.py

@@ -4291,7 +4291,7 @@ class Network_3D:
 
 
 
-    def get_degrees(self, down_factor = 1, directory = None, called = False, no_img = 0):
+    def get_degrees(self, down_factor = 1, directory = None, called = False, no_img = 0, heatmap = False):
         """
         Method to obtain information on the degrees of nodes in the network, also generating overlays that relate this information to the 3D structure.
         Overlays include a grayscale image where nodes are assigned a grayscale value corresponding to their degree, and a numerical index where numbers are drawn at nodes corresponding to their degree.
@@ -4301,6 +4301,27 @@ class Network_3D:
         :returns: A dictionary of degree values for each node.
         """
 
+        if heatmap:
+            import statistics
+            degrees_dict = {node: val for (node, val) in self.network.degree()}
+            pred = statistics.mean(list(degrees_dict.values()))
+
+            node_intensity = {}
+            import math
+            node_centroids = {}
+
+            for node in list(self.network.nodes()):
+                node_intensity[node] = math.log(self.network.degree(node)/pred)
+                node_centroids[node] = self.node_centroids[node]
+
+            from . import neighborhoods
+
+            overlay = neighborhoods.create_node_heatmap(node_intensity, node_centroids, shape = self.nodes.shape, is_3d=True, labeled_array = self.nodes)
+
+            return degrees_dict, overlay
+
+
+
         if down_factor > 1:
             centroids = self._node_centroids.copy()
             for item in self._node_centroids:
@@ -4657,18 +4678,16 @@ class Network_3D:
                     dim = 3
                     break
 
-
         if ignore_dims:
 
             factor = 0.25
 
+            big_array = proximity.convert_centroids_to_array(list(self.node_centroids.values()))
 
             if bounds is None:
-                if dim == 2:
-                    min_coords = np.array([0,0])
-                else:
-                    min_coords = np.array([0,0,0])
-                max_coords = np.max(points_array, axis=0)
+                min_coords = np.array([0,0,0])
+                max_coords = [np.max(big_array[:, 0]), np.max(big_array[:, 1]), np.max(big_array[:, 2])]
+                del big_array
                 max_coords = np.flip(max_coords)
                 bounds = (min_coords, max_coords)
             else:
@@ -4683,11 +4702,16 @@ class Network_3D:
 
             new_list = []
 
+
             if dim == 3:
                 for centroid in roots:
 
                     if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
                         new_list.append(centroid)
+
+
+                    #if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
+                        #new_list.append(centroid)
                         #print(f"dim_list: {dim_list}, centroid: {centroid}, min_coords: {min_coords}, max_coords: {max_coords}")
             else:
                 for centroid in roots:
@@ -5068,7 +5092,7 @@ class Network_3D:
 
         self.communities = invert_dict(com_dict)
 
-    def community_heatmap(self, num_nodes = None, is3d = True):
+    def community_heatmap(self, num_nodes = None, is3d = True, numpy = False):
 
         import math
 
@@ -5106,10 +5130,21 @@ class Network_3D:
         for com, nodes in coms.items():
             heat_dict[com] = math.log(len(nodes)/rand_dens)
 
+        try:
+            shape = self.nodes.shape
+        except:
+            big_array = proximity.convert_centroids_to_array(list(self.node_centroids.values()))
+            shape = [np.max(big_array[0, :]) + 1, np.max(big_array[1, :]) + 1, np.max(big_array[2, :]) + 1]
+
         from . import neighborhoods
-        neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, is_3d=is3d)
+        if not numpy:
+            neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, shape = shape, is_3d=is3d)
+
+            return heat_dict
+        else:
+            overlay = neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, shape = shape, is_3d=is3d, labeled_array = self.nodes)
+            return heat_dict, overlay
 
-        return heat_dict
 
     def merge_node_ids(self, path, data):
 
@@ -5161,6 +5196,81 @@ class Network_3D:
                     pass
 
 
+    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False):
+
+        root_set = []
+
+        compare_set = []
+
+        if root is None:
+
+            root_set = list(self.node_centroids.keys())
+            compare_set = root_set
+            title = "Nearest Neighbors Between Nodes Heatmap"
+
+        else:
+
+            title = f"Nearest Neighbors of ID {targ} from ID {root} Heatmap"
+
+            for node, iden in self.node_identities.items():
+
+                if iden == root:
+
+                    root_set.append(node)
+
+                elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
+
+                    compare_set.append(node)
+
+        if root == targ:
+
+            compare_set = root_set
+            if len(compare_set) - 1 < num:
+
+                print("Error: Not enough neighbor nodes for requested number of neighbors")
+                return
+
+        if len(compare_set) < num:
+
+            print("Error: Not enough neighbor nodes for requested number of neighbors")
+            return
+
+        avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set, compare_set, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num)
+
+        if heatmap:
+
+
+            from . import neighborhoods
+            try:
+                shape = self.nodes.shape
+            except:
+                big_array = proximity.convert_centroids_to_array(list(self.node_centroids.values()))
+                shape = [np.max(big_array[0, :]) + 1, np.max(big_array[1, :]) + 1, np.max(big_array[2, :]) + 1]
+
+            pred = avg
+
+            node_intensity = {}
+            import math
+            node_centroids = {}
+
+            for node in root_set:
+                node_intensity[node] = math.log(pred/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
+
+            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
+
+
+
+
 
 
 

nettracer3d/nettracer_gui.py

@@ -3432,6 +3432,8 @@ class ImageViewerWindow(QMainWindow):
         ripley_action.triggered.connect(self.show_ripley_dialog)
         heatmap_action = stats_menu.addAction("Community Cluster Heatmap")
         heatmap_action.triggered.connect(self.show_heatmap_dialog)
+        nearneigh_action = stats_menu.addAction("Average Nearest Neighbors")
+        nearneigh_action.triggered.connect(self.show_nearneigh_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
         rad_action = stats_menu.addAction("Calculate Radii")
@@ -5212,6 +5214,10 @@ class ImageViewerWindow(QMainWindow):
         dialog = HeatmapDialog(self)
         dialog.exec()
 
+    def show_nearneigh_dialog(self):
+        dialog = NearNeighDialog(self)
+        dialog.exec()
+
     def show_random_dialog(self):
         dialog = RandomDialog(self)
         dialog.exec()
@@ -7269,6 +7275,174 @@ class DegreeDistDialog(QDialog):
         except Exception as e:
             print(f"An error occurred: {e}")
 
+class NearNeighDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(f"Nearest Neighborhood Averages (Using Centroids)")
+        self.setModal(True)
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        
+        # Identities group box (only if node_identities exists)
+        identities_group = QGroupBox("Identities")
+        identities_layout = QFormLayout(identities_group)
+        
+        if my_network.node_identities is not None:
+
+            self.root = QComboBox()
+            self.root.addItems(list(set(my_network.node_identities.values())))  
+            self.root.setCurrentIndex(0)
+            identities_layout.addRow("Root Identity to Search for Neighbor's IDs?", self.root)
+            
+            self.targ = QComboBox()
+            neighs = list(set(my_network.node_identities.values()))
+            neighs.append("All Others (Excluding Self)")
+            self.targ.addItems(neighs)  
+            self.targ.setCurrentIndex(0)
+            identities_layout.addRow("Neighbor Identities to Search For?", self.targ)
+        else:
+            self.root = None
+            self.targ = None
+
+        self.num = QLineEdit("1")
+        identities_layout.addRow("Number of Nearest Neighbors to Evaluate Per Node?:", self.num)
+
+        
+        main_layout.addWidget(identities_group)
+
+        
+        # Optional Heatmap group box
+        heatmap_group = QGroupBox("Optional Heatmap")
+        heatmap_layout = QFormLayout(heatmap_group)
+        
+        self.map = QPushButton("(If getting distribution): Generate Heatmap?")
+        self.map.setCheckable(True)
+        self.map.setChecked(False)
+        heatmap_layout.addRow("Heatmap:", self.map)
+        
+        self.threed = QPushButton("(For above): Return 3D map? (uncheck for 2D): ")
+        self.threed.setCheckable(True)
+        self.threed.setChecked(True)
+        heatmap_layout.addRow("3D:", self.threed)
+        
+        self.numpy = QPushButton("(For heatmap): Return image overlay instead of graph? (Goes in Overlay 2): ")
+        self.numpy.setCheckable(True)
+        self.numpy.setChecked(False)
+        self.numpy.clicked.connect(self.toggle_map)
+        heatmap_layout.addRow("Overlay:", self.numpy)
+        
+        main_layout.addWidget(heatmap_group)
+        
+        # Get Distribution group box
+        distribution_group = QGroupBox("Get Distribution")
+        distribution_layout = QVBoxLayout(distribution_group)
+        
+        run_button = QPushButton("Get Average Nearest Neighbor (Plus Distribution)")
+        run_button.clicked.connect(self.run)
+        distribution_layout.addWidget(run_button)
+        
+        main_layout.addWidget(distribution_group)
+        
+        # Get All Averages group box (only if node_identities exists)
+        if my_network.node_identities is not None:
+            averages_group = QGroupBox("Get All Averages")
+            averages_layout = QVBoxLayout(averages_group)
+            
+            run_button2 = QPushButton("Get Average Nearest All ID Combinations (No Distribution, No Heatmap)")
+            run_button2.clicked.connect(self.run2)
+            averages_layout.addWidget(run_button2)
+            
+            main_layout.addWidget(averages_group)
+
+    def toggle_map(self):
+
+        if self.numpy.isChecked():
+
+            if not self.map.isChecked():
+
+                self.map.click()
+
+    def run(self):
+
+        try:
+
+            try:
+                root = self.root.currentText()
+            except:
+                root = None
+            try:
+                targ = self.targ.currentText()
+            except:
+                targ = None
+
+            heatmap = self.map.isChecked()
+            threed = self.threed.isChecked()
+            numpy = self.numpy.isChecked()
+            num = int(self.num.text()) if self.num.text().strip() else 1
+
+            if root is not None and targ is not None:
+                title = f"Nearest {num} Neighbor(s) Distance of {targ} from {root}"
+                header = f"Shortest Distance to Closest {num} {targ}(s)"
+                header2 = f"{root} Node ID"
+            else:
+                title = f"Nearest {num} Neighbor(s) Distance Between Nodes"
+                header = f"Shortest Distance to Closest {num} Nodes"
+                header2 = "Root Node ID"
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+                if my_network.node_centroids is None:
+                    return
+
+            if not numpy:
+                avg, output = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed)
+            else:
+                avg, output, overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True)
+                self.parent().load_channel(3, overlay, data = True)
+
+            self.parent().format_for_upperright_table([avg], metric = f'Avg {title}', title = f'Avg {title}')
+            self.parent().format_for_upperright_table(output, header2, header, title = title)
+
+            self.accept()
+
+        except Exception as e:
+            import traceback
+            print(traceback.format_exc())
+
+            print(f"Error: {e}")
+
+    def run2(self):
+
+        try:
+
+            available = list(set(my_network.node_identities.values()))
+
+            num = int(self.num.text()) if self.num.text().strip() else 1
+
+            output_dict = {}
+
+            while len(available) > 1:
+
+                root = available[0]
+
+                for targ in available:
+
+                    avg, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num)
+
+                    output_dict[f"{root} vs {targ}"] = avg
+
+                del available[0]
+
+            self.parent().format_for_upperright_table(output_dict, "ID Combo", "Avg Distance to Nearest", title = "Average Distance to Nearest Neighbors for All ID Combos")
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error: {e}")
+
+
 class NeighborIdentityDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -7455,8 +7629,7 @@ class RipleyDialog(QDialog):
                 "Error:",
                 f"Failed to preform cluster analysis: {str(e)}"
             )
-            import traceback
-            print(traceback.format_exc())
+
             print(f"Error: {e}")
 
 class HeatmapDialog(QDialog):
@@ -7479,6 +7652,11 @@ class HeatmapDialog(QDialog):
         self.is3d.setChecked(True)
         layout.addRow("Use 3D Plot (uncheck for 2D)?:", self.is3d)
 
+        self.numpy = QPushButton("(For heatmap): Return image overlay instead of graph? (Goes in Overlay 2): ")
+        self.numpy.setCheckable(True)
+        self.numpy.setChecked(False)
+        layout.addRow("Overlay:", self.numpy)
+
 
         # Add Run button
         run_button = QPushButton("Run")
@@ -7487,25 +7665,40 @@ class HeatmapDialog(QDialog):
 
     def run(self):
 
-        nodecount = int(self.nodecount.text()) if self.nodecount.text().strip() else None
+        try:
 
-        is3d = self.is3d.isChecked()
+            nodecount = int(self.nodecount.text()) if self.nodecount.text().strip() else None
+
+            is3d = self.is3d.isChecked()
 
 
-        if my_network.communities is None:
-            if my_network.network is not None:
-                self.parent().show_partition_dialog()
-            else:
-                self.parent().handle_com_cell()
             if my_network.communities is None:
-                return
+                if my_network.network is not None:
+                    self.parent().show_partition_dialog()
+                else:
+                    self.parent().handle_com_cell()
+                if my_network.communities is None:
+                    return
 
-        heat_dict = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d)
+            numpy = self.numpy.isChecked()
 
-        self.parent().format_for_upperright_table(heat_dict, metric='Community', value='ln(Predicted Community Nodecount/Actual)', title="Community Heatmap")
+            if not numpy:
 
-        self.accept()
+                heat_dict = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d)
 
+            else:
+
+                heat_dict, overlay = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d, numpy = True)
+                self.parent().load_channel(3, overlay, data = True)
+
+
+            self.parent().format_for_upperright_table(heat_dict, metric='Community', value='ln(Predicted Community Nodecount/Actual)', title="Community Heatmap")
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error: {e}")
 
 
 
@@ -7749,7 +7942,7 @@ class DegreeDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Just make table", "Draw degree of node as overlay (literally draws 1, 2, 3, etc... faster)", "Label nodes by degree (nodes will take on the value 1, 2, 3, etc, based on their degree, to export for array based analysis... slower)"])
+        self.mode_selector.addItems(["Just make table", "Draw degree of node as overlay (literally draws 1, 2, 3, etc... faster)", "Label nodes by degree (nodes will take on the value 1, 2, 3, etc, based on their degree, to export for array based analysis)", "Create Heatmap of Degrees"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -7770,6 +7963,14 @@ class DegreeDialog(QDialog):
 
             accepted_mode = self.mode_selector.currentIndex()
 
+            if accepted_mode == 3:
+                degree_dict, overlay = my_network.get_degrees(heatmap = True)
+                self.parent().format_for_upperright_table(degree_dict, 'Node ID', 'Degree', title = 'Degrees of nodes')
+                self.parent().load_channel(3, channel_data = overlay, data = True)
+                self.accept()
+                return
+
+
             try:
                 down_factor = float(self.down_factor.text()) if self.down_factor.text() else 1
             except ValueError:
@@ -10274,7 +10475,7 @@ class CropDialog(QDialog):
         try:
 
             super().__init__(parent)
-            self.setWindowTitle("Crop Image?")
+            self.setWindowTitle("Crop Image (Will transpose any centroids)?")
             self.setModal(True)
 
             layout = QFormLayout(self)
@@ -10330,10 +10531,70 @@ class CropDialog(QDialog):
 
                     self.parent().load_channel(i, array, data = True)
 
+            print("Transposing centroids...")
+
+            try:
+
+                if my_network.node_centroids is not None:
+                    nodes = list(my_network.node_centroids.keys())
+                    centroids = np.array(list(my_network.node_centroids.values()))
+                    
+                    # Transform all at once
+                    transformed = centroids - np.array([zmin, ymin, xmin])
+                    transformed = transformed.astype(int)
+                    
+                    # Boolean mask for valid coordinates
+                    valid_mask = ((transformed >= 0) & 
+                                  (transformed <= np.array([zmax, ymax, xmax]))).all(axis=1)
+                    
+                    # Rebuild dictionary with only valid entries
+                    my_network.node_centroids = {
+                        nodes[int(i)]: [int(transformed[i, 0]), int(transformed[i, 1]), int(transformed[i, 2])]
+                        for i in range(len(nodes)) if valid_mask[i]
+                    }
+                    
+                    self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
+            except Exception as e:
+
+                print(f"Error transposing node centroids: {e}")
+
+            try:
+
+                if my_network.edge_centroids is not None:
+
+                    if my_network.edge_centroids is not None:
+                        nodes = list(my_network.edge_centroids.keys())
+                        centroids = np.array(list(my_network.edge_centroids.values()))
+                        
+                        # Transform all at once
+                        transformed = centroids - np.array([zmin, ymin, xmin])
+                        transformed = transformed.astype(int)
+                        
+                        # Boolean mask for valid coordinates
+                        valid_mask = ((transformed >= 0) & 
+                                      (transformed <= np.array([zmax, ymax, xmax]))).all(axis=1)
+                        
+                        # Rebuild dictionary with only valid entries
+                        my_network.edge_centroids = {
+                            nodes[int(i)]: [int(transformed[i, 0]), int(transformed[i, 1]), int(transformed[i, 2])]
+                            for i in range(len(nodes)) if valid_mask[i]
+                        }
+                        
+                        self.parent().format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+
+            except Exception as e:
+
+                print(f"Error transposing edge centroids: {e}")
+
+
             self.accept()
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error cropping: {e}")
 
 

nettracer3d/node_draw.py

@@ -201,18 +201,28 @@ def degree_draw(degree_dict, centroid_dict, nodes):
     return draw_array
 
 def degree_infect(degree_dict, nodes):
-
-    num_nodes = int(np.max(nodes))
-    return_nodes = nodes.copy()
-
-    for node in range(1, num_nodes + 1):
-        if node not in degree_dict:
-            continue
-        else:
-            idxs = np.argwhere(nodes == node)
-            for idx in idxs:
-                return_nodes[tuple(idx)] = degree_dict[node]
-
+    return_nodes = np.zeros_like(nodes)  # Start with all zeros
+    
+    if not degree_dict:  # Handle empty dict
+        return return_nodes
+    
+    # Create arrays for old and new values
+    old_vals = np.array(list(degree_dict.keys()))
+    new_vals = np.array(list(degree_dict.values()))
+    
+    # Sort for searchsorted to work correctly
+    sort_idx = np.argsort(old_vals)
+    old_vals_sorted = old_vals[sort_idx]
+    new_vals_sorted = new_vals[sort_idx]
+    
+    # Find which nodes exist in the dictionary
+    mask = np.isin(nodes, old_vals_sorted)
+    
+    # Only process nodes that exist in the dictionary
+    if np.any(mask):
+        indices = np.searchsorted(old_vals_sorted, nodes[mask])
+        return_nodes[mask] = new_vals_sorted[indices]
+    
     return return_nodes
 
 

nettracer3d/proximity.py

@@ -296,6 +296,69 @@ def extract_pairwise_connections(connections):
     return output
 
 
+def average_nearest_neighbor_distances(point_centroids, root_set, compare_set, xy_scale=1.0, z_scale=1.0, num = 1):
+    """
+    Calculate the average distance between each point in root_set and its nearest neighbor in compare_set.
+    
+    Args:
+        point_centroids (dict): Dictionary mapping point IDs to [Z, Y, X] coordinates
+        root_set (set): Set of point IDs to find nearest neighbors for
+        compare_set (set): Set of point IDs to search for nearest neighbors in
+        xy_scale (float): Scaling factor for X and Y coordinates
+        z_scale (float): Scaling factor for Z coordinate
+    
+    Returns:
+        float: Average distance to nearest neighbors
+    """
+    
+    # Extract and scale coordinates for compare_set
+    compare_coords = []
+    compare_ids = list(compare_set)
+    
+    for point_id in compare_ids:
+        z, y, x = point_centroids[point_id]
+        compare_coords.append([z * z_scale, y * xy_scale, x * xy_scale])
+    
+    compare_coords = np.array(compare_coords)
+    
+    # Build KDTree for efficient nearest neighbor search
+    tree = KDTree(compare_coords)
+    
+    distances = {}
+    same_sets = root_set == compare_set
+    
+    for root_id in root_set:
+        # Get scaled coordinates for root point
+        z, y, x = point_centroids[root_id]
+        root_coord = np.array([z * z_scale, y * xy_scale, x * xy_scale])
+        
+        if same_sets:
+            # When sets are the same, find 2 nearest neighbors and take the second one
+            # (first one would be the point itself)
+            distances_to_all, indices = tree.query(root_coord, k= (num + 1))
+
+            temp_dist = 0
+            for i in range(1, len(distances_to_all)):
+                temp_dist += distances_to_all[i]
+
+            distances[root_id] = temp_dist/(len(distances_to_all) - 1)
+
+        else:
+            # Different sets, find nearest neighbors
+            distances_to_all, _ = tree.query(root_coord, k=num)
+            temp_dist = 0
+            for val in distances_to_all:
+                temp_dist += val
+
+            distances[root_id] = temp_dist/(len(distances_to_all))
+
+    avg = np.mean(list(distances.values())) if list(distances.values()) else 0.0
+
+    
+    # Return average distance
+    return avg, distances
+
+
 
 #voronois:
 def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, int, int], List[int]]], 

{nettracer3d-0.8.0.dist-info → nettracer3d-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.0
+Version: 0.8.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/
@@ -73,11 +73,8 @@ 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.8.0 Updates -- 
+-- Version 0.8.1 Updates -- 
 
-	* Added ability to threshold nodes by degree.
-	* Improved image viewer window performance.
-	* Bug fixes and a few optimizations.
-	* Added ability to 'merge node identities' which just uses the nodes image as a reference for collecting 'identity' information from a group of other images - ie can use with cell nuclei (DAPI) to see what markers from the same imaging session overlap.
-	* Added ability to search for specific nodes directly in the nodes image with 'shift + f' or right click.
-	
+	* Added nearest neighbor evaluation function (Analysis -> Stats -> Avg Nearest Neighbor)
+	* Added heatmap outputs for node degrees (Analysis -> Data/Overlays -> Get Degree Information).
+	* Bug fixes and misc improvements.

{nettracer3d-0.8.0.dist-info → nettracer3d-0.8.1.dist-info}/RECORD

@@ -3,21 +3,21 @@ nettracer3d/community_extractor.py,sha256=ZOz97Au4k7dHK8azarWQtxCPyvwzGmDHNL8kTI
 nettracer3d/excelotron.py,sha256=lS5vnpoOGZWp7fdqVpTPqeC-mUKrfwDrWHfx4PQ7Uzg,71384
 nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,21788
 nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
-nettracer3d/neighborhoods.py,sha256=kkKR8m6Gjw34cDd_mytAIwLxqvuNBtQb2hU4JuBY9pI,12301
-nettracer3d/nettracer.py,sha256=494nHDmdrdfecTAShbXc0eFE2tG6WKJtEqKvJyt4sh4,227141
-nettracer3d/nettracer_gui.py,sha256=Pc_t5pDk0P4gpyC1axx37JJX6EpMvXdj0UHbqjqENrQ,501757
+nettracer3d/neighborhoods.py,sha256=LnflCJdlNOuILal_fsT-idp1IROQH2PvLG-Ro3m55vo,26757
+nettracer3d/nettracer.py,sha256=F91vCLJ-OB5qGLjOXRjNh2qE3vFkXYh_VPpFud2Cu4o,231437
+nettracer3d/nettracer_gui.py,sha256=rRm3hquNbJJ8wbqPyojK45jFKc--Y72L4Ia9_dMSONE,512171
 nettracer3d/network_analysis.py,sha256=h-5yzUWdE0hcWYy8wcBA5LV1bRhdqiMnKbQLrRzb1Sw,41443
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
-nettracer3d/proximity.py,sha256=hPmTPFGUziPMVwfWRLVV9gUjqSL7nzLD6WAVLekvxbE,28545
+nettracer3d/node_draw.py,sha256=LoeTFeOcrX6kPquZvCqYnMW-jDd9oqKM27r-rTlKEtY,10274
+nettracer3d/proximity.py,sha256=3cgF9hWYlzodO_vFc9TA2QO1tZG6jqYbz4_AG89EKDE,30867
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
 nettracer3d/segmenter.py,sha256=VatOSpc41lxhPuYLTTejCxG1CcwP5hwiQ3ZFK9OBavA,60115
 nettracer3d/segmenter_GPU.py,sha256=sFVmz_cYIVOQqnfFV3peK9hzb6IoIV5WDQHH9Lws96I,53915
 nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
 nettracer3d/smart_dilate.py,sha256=DOEOQq9ig6-AO4MpqAG0CqrGDFqw5_UBeqfSedqHk28,25933
-nettracer3d-0.8.0.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.8.0.dist-info/METADATA,sha256=2bK3auAT6Xr7y_VDBaZE_cB4dgShYtF0qrIzcuTDflU,4605
-nettracer3d-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-0.8.0.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.8.0.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.8.0.dist-info/RECORD,,
+nettracer3d-0.8.1.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.8.1.dist-info/METADATA,sha256=kw33GSA0zjO1PbRkCfMDjh-opacoSn1OSx7X5M8UA88,4332
+nettracer3d-0.8.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.8.1.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.8.1.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.8.1.dist-info/RECORD,,