nettracer3d 0.7.7__py3-none-any.whl → 0.7.9__py3-none-any.whl

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/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/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
 
 
 

nettracer3d/nettracer_gui.py

@@ -25,7 +25,10 @@ import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
 from nettracer3d import segmenter
-from nettracer3d import segmenter_GPU
+try:
+    from nettracer3d import segmenter_GPU as seg_GPU
+except:
+    pass
 from nettracer3d import excelotron
 
 
@@ -205,6 +208,7 @@ class ImageViewerWindow(QMainWindow):
         self.high_button.setChecked(True)
         buttons_layout.addWidget(self.high_button)
         self.highlight = True
+        self.needs_mini = False
 
         self.pen_button = QPushButton("🖊️")
         self.pen_button.setCheckable(True)
@@ -394,11 +398,14 @@ class ImageViewerWindow(QMainWindow):
 
         #self.canvas.mpl_connect('button_press_event', self.on_mouse_click)
 
-        # Initialize measurement points tracking
+        # Initialize measurement tracking
         self.measurement_points = []  # List to store point pairs
-        self.current_point = None  # Store first point of current pair
+        self.angle_measurements = []  # NEW: List to store angle trios
+        self.current_point = None  # Store first point of current pair/trio
+        self.current_second_point = None  # Store second point when building trio
         self.current_pair_index = 0  # Track pair numbering
-        
+        self.current_trio_index = 0  # Track trio numbering
+        self.measurement_mode = "distance"  # "distance" or "angle" mode
 
         # Add these new methods for handling neighbors and components (FOR RIGHT CLICKIGN)
         self.show_neighbors_clicked = None
@@ -664,6 +671,18 @@ class ImageViewerWindow(QMainWindow):
             edge_indices (list): List of edge indices to highlight
         """
 
+        if not self.high_button.isChecked():
+
+            if len(self.clicked_values['edges']) > 0:
+                self.format_for_upperright_table(self.clicked_values['edges'], title = 'Selected Edges')
+                self.needs_mini = True
+            if len(self.clicked_values['nodes']) > 0:
+                self.format_for_upperright_table(self.clicked_values['nodes'], title = 'Selected Nodes')
+                self.needs_mini = True
+
+            return
+
+
         def process_chunk(chunk_data, indices_to_check):
             """Process a single chunk of the array to create highlight mask"""
             mask = np.isin(chunk_data, indices_to_check)
@@ -828,21 +847,38 @@ class ImageViewerWindow(QMainWindow):
                     override_obj.triggered.connect(self.handle_override)
                     context_menu.addMenu(highlight_menu)
 
-                # Create measure menu
-                measure_menu = QMenu("Measure", self)
-
+                # Create measurement submenu
+                measure_menu = context_menu.addMenu("Measurements")
+                
+                # Distance measurement options
+                distance_menu = measure_menu.addMenu("Distance")
                 if self.current_point is None:
-                    # If no point is placed, show option to place first point
-                    show_point_menu = measure_menu.addAction("Place Measurement Point")
+                    show_point_menu = distance_menu.addAction("Place First Point")
                     show_point_menu.triggered.connect(
-                        lambda: self.place_point(x_idx, y_idx, self.current_slice))
+                        lambda: self.place_distance_point(x_idx, y_idx, self.current_slice))
                 else:
-                    # If first point is placed, show option to place second point
-                    show_point_menu = measure_menu.addAction("Place Second Point")
+                    show_point_menu = distance_menu.addAction("Place Second Point")
                     show_point_menu.triggered.connect(
-                        lambda: self.place_point(x_idx, y_idx, self.current_slice))
-
-                show_remove_menu = measure_menu.addAction("Remove Measurement Points")
+                        lambda: self.place_distance_point(x_idx, y_idx, self.current_slice))
+                
+                # Angle measurement options
+                angle_menu = measure_menu.addMenu("Angle")
+                if self.current_point is None:
+                    angle_first = angle_menu.addAction("Place First Point (A)")
+                    angle_first.triggered.connect(
+                        lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
+                elif self.current_second_point is None:
+                    angle_second = angle_menu.addAction("Place Second Point (B - Vertex)")
+                    angle_second.triggered.connect(
+                        lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
+                else:
+                    angle_third = angle_menu.addAction("Place Third Point (C)")
+                    angle_third.triggered.connect(
+                        lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
+                
+                show_remove_menu = measure_menu.addAction("Remove All Measurements")
+                show_remove_menu.triggered.connect(self.handle_remove_all_measurements)
+                
                 context_menu.addMenu(measure_menu)
                 
                 # Connect actions to callbacks
@@ -860,7 +896,6 @@ class ImageViewerWindow(QMainWindow):
                 if self.highlight_overlay is not None or self.mini_overlay_data is not None:
                     highlight_select = context_menu.addAction("Add highlight in network selection")
                     highlight_select.triggered.connect(self.handle_highlight_select)
-                show_remove_menu.triggered.connect(self.handle_remove_points)
                 
                 cursor_pos = QCursor.pos()
                 context_menu.exec(cursor_pos)
@@ -869,24 +904,25 @@ class ImageViewerWindow(QMainWindow):
                 pass
 
 
-    def place_point(self, x, y, z):
-        """Place a measurement point at the specified coordinates."""
+    def place_distance_point(self, x, y, z):
+        """Place a measurement point for distance measurement."""
         if self.current_point is None:
             # This is the first point
             self.current_point = (x, y, z)
             self.ax.plot(x, y, 'yo', markersize=8)
-            # Add pair index label above the point
-            self.ax.text(x, y+5, str(self.current_pair_index), 
-                        color='white', ha='center', va='bottom')
+            self.ax.text(x, y+5, f"D{self.current_pair_index}", 
+                        color='yellow', ha='center', va='bottom')
             self.canvas.draw()
-
+            self.measurement_mode = "distance"
         else:
             # This is the second point
             x1, y1, z1 = self.current_point
             x2, y2, z2 = x, y, z
             
             # Calculate distance
-            distance = np.sqrt(((x2-x1)*my_network.xy_scale)**2 + ((y2-y1)*my_network.xy_scale)**2 + ((z2-z1)*my_network.z_scale)**2)
+            distance = np.sqrt(((x2-x1)*my_network.xy_scale)**2 + 
+                              ((y2-y1)*my_network.xy_scale)**2 + 
+                              ((z2-z1)*my_network.z_scale)**2)
             distance2 = np.sqrt(((x2-x1))**2 + ((y2-y1))**2 + ((z2-z1))**2)
             
             # Store the point pair
@@ -900,9 +936,8 @@ class ImageViewerWindow(QMainWindow):
             
             # Draw second point and line
             self.ax.plot(x2, y2, 'yo', markersize=8)
-            # Add pair index label above the second point
-            self.ax.text(x2, y2+5, str(self.current_pair_index), 
-                        color='white', ha='center', va='bottom')
+            self.ax.text(x2, y2+5, f"D{self.current_pair_index}", 
+                        color='yellow', ha='center', va='bottom')
             if z1 == z2:  # Only draw line if points are on same slice
                 self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
             self.canvas.draw()
@@ -913,46 +948,194 @@ class ImageViewerWindow(QMainWindow):
             # Reset for next pair
             self.current_point = None
             self.current_pair_index += 1
+            self.measurement_mode = "distance"
+
+    def place_angle_point(self, x, y, z):
+        """Place a measurement point for angle measurement."""
+        if self.current_point is None:
+            # First point (A)
+            self.current_point = (x, y, z)
+            self.ax.plot(x, y, 'go', markersize=8)
+            self.ax.text(x, y+5, f"A{self.current_trio_index}", 
+                        color='green', ha='center', va='bottom')
+            self.canvas.draw()
+            self.measurement_mode = "angle"
+            
+        elif self.current_second_point is None:
+            # Second point (B - vertex)
+            self.current_second_point = (x, y, z)
+            x1, y1, z1 = self.current_point
+            
+            self.ax.plot(x, y, 'go', markersize=8)
+            self.ax.text(x, y+5, f"B{self.current_trio_index}", 
+                        color='green', ha='center', va='bottom')
+            
+            # Draw line from A to B
+            if z1 == z:
+                self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)
+            self.canvas.draw()
+            
+        else:
+            # Third point (C)
+            x1, y1, z1 = self.current_point  # Point A
+            x2, y2, z2 = self.current_second_point  # Point B (vertex)
+            x3, y3, z3 = x, y, z  # Point C
+            
+            # Calculate angles and distances
+            angle_data = self.calculate_3d_angle(
+                (x1, y1, z1), (x2, y2, z2), (x3, y3, z3)
+            )
+            
+            # Store the trio
+            self.angle_measurements.append({
+                'trio_index': self.current_trio_index,
+                'point_a': (x1, y1, z1),
+                'point_b': (x2, y2, z2),  # vertex
+                'point_c': (x3, y3, z3),
+                **angle_data
+            })
+            
+            # Also add the two distances as separate pairs
+            dist_ab = np.sqrt(((x2-x1)*my_network.xy_scale)**2 + 
+                             ((y2-y1)*my_network.xy_scale)**2 + 
+                             ((z2-z1)*my_network.z_scale)**2)
+            dist_bc = np.sqrt(((x3-x2)*my_network.xy_scale)**2 + 
+                             ((y3-y2)*my_network.xy_scale)**2 + 
+                             ((z3-z2)*my_network.z_scale)**2)
+            
+            dist_ab_voxel = np.sqrt((x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2)
+            dist_bc_voxel = np.sqrt((x3-x2)**2 + (y3-y2)**2 + (z3-z2)**2)
+            
+            self.measurement_points.extend([
+                {
+                    'pair_index': f"A{self.current_trio_index}-B{self.current_trio_index}",
+                    'point1': (x1, y1, z1),
+                    'point2': (x2, y2, z2),
+                    'distance': dist_ab,
+                    'distance2': dist_ab_voxel
+                },
+                {
+                    'pair_index': f"B{self.current_trio_index}-C{self.current_trio_index}",
+                    'point1': (x2, y2, z2),
+                    'point2': (x3, y3, z3),
+                    'distance': dist_bc,
+                    'distance2': dist_bc_voxel
+                }
+            ])
+            
+            # Draw third point and line
+            self.ax.plot(x3, y3, 'go', markersize=8)
+            self.ax.text(x3, y3+5, f"C{self.current_trio_index}", 
+                        color='green', ha='center', va='bottom')
+            
+            if z2 == z3:  # Draw line from B to C if on same slice
+                self.ax.plot([x2, x3], [y2, y3], 'g--', alpha=0.7)
+            self.canvas.draw()
+            
+            # Update measurement display
+            self.update_measurement_display()
+            
+            # Reset for next trio
+            self.current_point = None
+            self.current_second_point = None
+            self.current_trio_index += 1
+            self.measurement_mode = "angle"
+
+    def calculate_3d_angle(self, point_a, point_b, point_c):
+        """Calculate 3D angle at vertex B between points A-B-C."""
+        x1, y1, z1 = point_a
+        x2, y2, z2 = point_b  # vertex
+        x3, y3, z3 = point_c
+        
+        # Apply scaling
+        scaled_a = np.array([x1 * my_network.xy_scale, y1 * my_network.xy_scale, z1 * my_network.z_scale])
+        scaled_b = np.array([x2 * my_network.xy_scale, y2 * my_network.xy_scale, z2 * my_network.z_scale])
+        scaled_c = np.array([x3 * my_network.xy_scale, y3 * my_network.xy_scale, z3 * my_network.z_scale])
+        
+        # Create vectors from vertex B
+        vec_ba = scaled_a - scaled_b
+        vec_bc = scaled_c - scaled_b
+        
+        # Calculate angle using dot product
+        dot_product = np.dot(vec_ba, vec_bc)
+        magnitude_ba = np.linalg.norm(vec_ba)
+        magnitude_bc = np.linalg.norm(vec_bc)
+        
+        # Avoid division by zero
+        if magnitude_ba == 0 or magnitude_bc == 0:
+            return {'angle_degrees': 0}
+        
+        cos_angle = dot_product / (magnitude_ba * magnitude_bc)
+        cos_angle = np.clip(cos_angle, -1.0, 1.0)  # Handle numerical errors
+        
+        angle_radians = np.arccos(cos_angle)
+        angle_degrees = np.degrees(angle_radians)
+        
+        return {'angle_degrees': angle_degrees}
 
-    def handle_remove_points(self):
-        """Remove all measurement points."""
+    def handle_remove_all_measurements(self):
+        """Remove all measurement points and angles."""
         self.measurement_points = []
+        self.angle_measurements = []
         self.current_point = None
+        self.current_second_point = None
         self.current_pair_index = 0
+        self.current_trio_index = 0
+        self.measurement_mode = "distance"
         self.update_display()
         self.update_measurement_display()
 
-    # Modify the update_measurement_display method:
     def update_measurement_display(self):
         """Update the measurement information display in the top right widget."""
+        # Distance measurements
         if not self.measurement_points:
-            # Create empty DataFrame with no specific headers
-            df = pd.DataFrame()
+            distance_df = pd.DataFrame()
         else:
-            # Create data for DataFrame with measurement-specific headers
-            data = []
+            distance_data = []
             for point in self.measurement_points:
                 x1, y1, z1 = point['point1']
                 x2, y2, z2 = point['point2']
-                data.append({
+                distance_data.append({
                     'Pair ID': point['pair_index'],
                     'Point 1 (X,Y,Z)': f"({x1:.1f}, {y1:.1f}, {z1})",
                     'Point 2 (X,Y,Z)': f"({x2:.1f}, {y2:.1f}, {z2})",
                     'Scaled Distance': f"{point['distance']:.2f}",
                     'Voxel Distance': f"{point['distance2']:.2f}"
                 })
-            df = pd.DataFrame(data)
+            distance_df = pd.DataFrame(distance_data)
         
-        # Create new table for measurements
-        table = CustomTableView(self)
-        table.setModel(PandasModel(df))
+        # Angle measurements
+        if not self.angle_measurements:
+            angle_df = pd.DataFrame()
+        else:
+            angle_data = []
+            for angle in self.angle_measurements:
+                xa, ya, za = angle['point_a']
+                xb, yb, zb = angle['point_b']
+                xc, yc, zc = angle['point_c']
+                angle_data.append({
+                    'Trio ID': f"A{angle['trio_index']}-B{angle['trio_index']}-C{angle['trio_index']}",
+                    'Point A (X,Y,Z)': f"({xa:.1f}, {ya:.1f}, {za})",
+                    'Point B (X,Y,Z)': f"({xb:.1f}, {yb:.1f}, {zb})",
+                    'Point C (X,Y,Z)': f"({xc:.1f}, {yc:.1f}, {zc})",
+                    'Angle (°)': f"{angle['angle_degrees']:.1f}"
+                })
+            angle_df = pd.DataFrame(angle_data)
         
-        # Add to tabbed widget
-        self.tabbed_data.add_table("Measurements", table)
+        # Create tables
+        if not distance_df.empty:
+            distance_table = CustomTableView(self)
+            distance_table.setModel(PandasModel(distance_df))
+            self.tabbed_data.add_table("Distance Measurements", distance_table)
+            for column in range(distance_table.model().columnCount(None)):
+                distance_table.resizeColumnToContents(column)
         
-        # Adjust column widths to content
-        for column in range(table.model().columnCount(None)):
-            table.resizeColumnToContents(column)
+        if not angle_df.empty:
+            angle_table = CustomTableView(self)
+            angle_table.setModel(PandasModel(angle_df))
+            self.tabbed_data.add_table("Angle Measurements", angle_table)
+            for column in range(angle_table.model().columnCount(None)):
+                angle_table.resizeColumnToContents(column)
 
 
     def show_network_table(self):
@@ -1732,6 +1915,12 @@ class ImageViewerWindow(QMainWindow):
         self.highlight = self.high_button.isChecked()
         current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
         current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+
+        if self.high_button.isChecked():
+            if self.highlight_overlay is None and ((len(self.clicked_values['nodes']) + len(self.clicked_values['edges'])) > 0):
+                if self.needs_mini:
+                    self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+                    self.needs_mini = False
         
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
@@ -2704,6 +2893,8 @@ class ImageViewerWindow(QMainWindow):
         network_menu = analysis_menu.addMenu("Network")
         netshow_action = network_menu.addAction("Show Network")
         netshow_action.triggered.connect(self.show_netshow_dialog)
+        report_action = network_menu.addAction("Generic Network Report")
+        report_action.triggered.connect(self.handle_report)
         partition_action = network_menu.addAction("Community Partition + Generic Community Stats")
         partition_action.triggered.connect(self.show_partition_dialog)
         com_identity_action = network_menu.addAction("Identity Makeup of Network Communities (and UMAP)")
@@ -2723,8 +2914,10 @@ class ImageViewerWindow(QMainWindow):
         degree_dist_action.triggered.connect(self.show_degree_dist_dialog)
         neighbor_id_action = stats_menu.addAction("Identity Distribution of Neighbors")
         neighbor_id_action.triggered.connect(self.show_neighbor_id_dialog)
-        ripley_action = stats_menu.addAction("Clustering Analysis")
+        ripley_action = stats_menu.addAction("Ripley Clustering Analysis")
         ripley_action.triggered.connect(self.show_ripley_dialog)
+        heatmap_action = stats_menu.addAction("Community Cluster Heatmap")
+        heatmap_action.triggered.connect(self.show_heatmap_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
         rad_action = stats_menu.addAction("Calculate Radii")
@@ -4396,6 +4589,44 @@ class ImageViewerWindow(QMainWindow):
         dialog = NetShowDialog(self)
         dialog.exec()
 
+    def handle_report(self):
+
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+
+        stats = {}
+        
+        try:
+            # Basic graph properties
+            stats['num_nodes'] = my_network.network.number_of_nodes()
+            stats['num_edges'] = my_network.network.number_of_edges()
+        except:
+            pass
+
+        try:
+            idens = invert_dict(my_network.node_identities)
+
+            for iden, nodes in idens.items():
+                stats[f'num_nodes_{iden}'] = len(nodes)
+        except:
+            pass
+
+        try:
+
+            coms = invert_dict(my_network.communities)
+
+            for com, nodes in coms.items():
+                stats[f'num_nodes_community_{com}'] = len(nodes)
+        except:
+            pass
+
+        self.format_for_upperright_table(stats, title = 'Network Report')
+
+
+
     def show_partition_dialog(self):
         dialog = PartitionDialog(self)
         dialog.exec()
@@ -4431,6 +4662,10 @@ class ImageViewerWindow(QMainWindow):
         dialog = RipleyDialog(self)
         dialog.exec()
 
+    def show_heatmap_dialog(self):
+        dialog = HeatmapDialog(self)
+        dialog.exec()
+
     def show_random_dialog(self):
         dialog = RandomDialog(self)
         dialog.exec()
@@ -5660,8 +5895,7 @@ class ArbitraryDialog(QDialog):
             
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Error processing selections: {str(e)}")
-            import traceback
-            print(traceback.format_exc())
+
 
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
@@ -6223,7 +6457,7 @@ class ComNeighborDialog(QDialog):
         layout.addRow("Min Community Size to be grouped (Smaller communities will be placed in neighborhood 0 - does not apply if empty)", self.limit)
 
         # Add Run button
-        run_button = QPushButton("Get Neighborhoods (Note this overwrites current communities - save your coms first)")
+        run_button = QPushButton("Get Communities")
         run_button.clicked.connect(self.run)
         layout.addWidget(run_button)
 
@@ -6277,6 +6511,12 @@ class ComCellDialog(QDialog):
         self.size = QLineEdit("")
         layout.addRow("Cell Size:", self.size)
 
+        self.xy_scale = QLineEdit(f"{my_network.xy_scale}")
+        layout.addRow("xy scale:", self.xy_scale)
+
+        self.z_scale = QLineEdit(f"{my_network.z_scale}")
+        layout.addRow("z scale:", self.z_scale)
+
         # Add Run button
         run_button = QPushButton("Get Neighborhoods (Note this overwrites current communities - save your coms first)")
         run_button.clicked.connect(self.run)
@@ -6286,7 +6526,9 @@ class ComCellDialog(QDialog):
 
         try:
 
-            size = int(self.size.text()) if self.size.text().strip() else None
+            size = float(self.size.text()) if self.size.text().strip() else None
+            xy_scale = float(self.xy_scale.text()) if self.xy_scale.text().strip() else 1
+            z_scale = float(self.z_scale.text()) if self.z_scale.text().strip() else 1
 
             if size is None:
                 return
@@ -6296,7 +6538,7 @@ class ComCellDialog(QDialog):
             if my_network.node_centroids is None:
                 return
 
-            my_network.community_cells(size = size)
+            my_network.community_cells(size = size, xy_scale = xy_scale, z_scale = z_scale)
 
             self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'CommunityID')
 
@@ -6577,6 +6819,60 @@ class RipleyDialog(QDialog):
             print(traceback.format_exc())
             print(f"Error: {e}")
 
+class HeatmapDialog(QDialog):
+
+    def __init__(self, parent = None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Heatmap Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.nodecount = QLineEdit("")
+        layout.addRow("(Optional) Total Number of Nodes?:", self.nodecount)
+
+
+        # stats checkbox (default True)
+        self.is3d = QPushButton("3D")
+        self.is3d.setCheckable(True)
+        self.is3d.setChecked(True)
+        layout.addRow("Use 3D Plot (uncheck for 2D)?:", self.is3d)
+
+
+        # Add Run button
+        run_button = QPushButton("Run")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+    def run(self):
+
+        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
+
+        heat_dict = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d)
+
+        self.parent().format_for_upperright_table(heat_dict, metric='Community', value='ln(Predicted Community Nodecount/Actual)', title="Community Heatmap")
+
+        self.accept()
+
+
+
+
+
+
+
+
 class RandomDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -7997,7 +8293,7 @@ class MachineWindow(QMainWindow):
         if not GPU:
             self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=False)
         else:
-            self.segmenter = segmenter_GPU.InteractiveSegmenter(active_data)
+            self.segmenter = seg_GPU.InteractiveSegmenter(active_data)
 
         self.segmentation_worker = None
 
@@ -8103,7 +8399,7 @@ class MachineWindow(QMainWindow):
         if self.GPU.isChecked():
 
             try:
-                self.segmenter = segmenter_GPU.InteractiveSegmenter(active_data)
+                self.segmenter = seg_GPU.InteractiveSegmenter(active_data)
                 print("Using GPU")
             except:
                 self.GPU.setChecked(False)
@@ -10361,6 +10657,12 @@ class ModifyDialog(QDialog):
         self.isolate.setChecked(False)
         layout.addRow("Isolate connections between two specific node types (if assigned)?:", self.isolate)
 
+        # isolate checkbox (default false)
+        self.com_sizes = QPushButton("Communities By Size")
+        self.com_sizes.setCheckable(True)
+        self.com_sizes.setChecked(False)
+        layout.addRow("Rearrange Community IDs by size?:", self.com_sizes)
+
         # Community collapse checkbox (default False)
         self.comcollapse = QPushButton("Communities -> nodes")
         self.comcollapse.setCheckable(True)
@@ -10403,6 +10705,7 @@ class ModifyDialog(QDialog):
             isolate = self.isolate.isChecked()
             comcollapse = self.comcollapse.isChecked()
             remove = self.remove.isChecked()
+            com_size = self.com_sizes.isChecked()
 
 
             if isolate and my_network.node_identities is not None:
@@ -10453,6 +10756,14 @@ class ModifyDialog(QDialog):
                     self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
                 except:
                     pass
+            if com_size:
+                if my_network.communities is None:
+                    self.parent().show_partition_dialog()
+                    if my_network.communities is None:
+                        return
+                my_network.com_by_size()
+                self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'Community', 'Node Communities')
+
             if comcollapse:
                 if my_network.communities is None:
                     self.parent().show_partition_dialog()
@@ -10482,6 +10793,8 @@ class ModifyDialog(QDialog):
             self.accept()
 
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             print(f"An error occurred: {e}")
 
 
@@ -10612,85 +10925,107 @@ class CalcAllDialog(QDialog):
     prev_fastdil = False
     prev_overlays = False
     prev_updates = True
-
+    
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Calculate All Parameters")
+        self.setWindowTitle("Calculate Connectivity Network Parameters")
         self.setModal(True)
         
-        layout = QFormLayout(self)
+        # Main layout
+        main_layout = QVBoxLayout(self)
         
-        # Directory (empty by default)
-        self.directory = QLineEdit(self.prev_directory)
-        self.directory.setPlaceholderText("Leave empty for 'my_network'")
-        layout.addRow("Output Directory:", self.directory)
+        # Important Parameters Group
+        important_group = QGroupBox("Important Parameters")
+        important_layout = QFormLayout(important_group)
         
-        # Load previous values for all inputs
         self.xy_scale = QLineEdit(f'{my_network.xy_scale}')
-        layout.addRow("xy_scale:", self.xy_scale)
+        important_layout.addRow("xy_scale:", self.xy_scale)
         
         self.z_scale = QLineEdit(f'{my_network.z_scale}')
-        layout.addRow("z_scale:", self.z_scale)
-
+        important_layout.addRow("z_scale:", self.z_scale)
+        
         self.search = QLineEdit(self.prev_search)
         self.search.setPlaceholderText("Leave empty for None")
-        layout.addRow("Node Search (float):", self.search)
-
+        important_layout.addRow("Node Search (float):", self.search)
+        
         self.diledge = QLineEdit(self.prev_diledge)
         self.diledge.setPlaceholderText("Leave empty for None")
-        layout.addRow("Edge Reconnection Distance (float):", self.diledge)
-
-        self.down_factor = QLineEdit(self.prev_down_factor)
-        self.down_factor.setPlaceholderText("Leave empty for None")
-        layout.addRow("Downsample for Centroids (int):", self.down_factor)
-
-        self.GPU_downsample = QLineEdit(self.prev_GPU_downsample)
-        self.GPU_downsample.setPlaceholderText("Leave empty for None")
-        layout.addRow("Downsample for Distance Transform (GPU) (int):", self.GPU_downsample)
-
+        important_layout.addRow("Edge Reconnection Distance (float):", self.diledge)
+        
+        self.label_nodes = QPushButton("Label")
+        self.label_nodes.setCheckable(True)
+        self.label_nodes.setChecked(self.prev_label_nodes)
+        important_layout.addRow("Re-Label Nodes (WARNING - OVERRIDES ANY CURRENT LABELS):", self.label_nodes)
+        
+        main_layout.addWidget(important_group)
+        
+        # Optional Parameters Group
+        optional_group = QGroupBox("Optional Parameters")
+        optional_layout = QFormLayout(optional_group)
+        
         self.other_nodes = QLineEdit(self.prev_other_nodes)
         self.other_nodes.setPlaceholderText("Leave empty for None")
-        layout.addRow("Filepath or directory containing additional node images:", self.other_nodes)
-
+        optional_layout.addRow("Filepath or directory containing additional node images:", self.other_nodes)
+        
         self.remove_trunk = QLineEdit(self.prev_remove_trunk)
         self.remove_trunk.setPlaceholderText("Leave empty for 0")
-        layout.addRow("Times to remove edge trunks (int): ", self.remove_trunk)
-
-        # Load previous button states
-        self.gpu = QPushButton("GPU")
-        self.gpu.setCheckable(True)
-        self.gpu.setChecked(self.prev_gpu)
-        layout.addRow("Use GPU:", self.gpu)
-
-        self.label_nodes = QPushButton("Label")
-        self.label_nodes.setCheckable(True)
-        self.label_nodes.setChecked(self.prev_label_nodes)
-        layout.addRow("Re-Label Nodes (WARNING - OVERRIDES ANY CURRENT LABELS):", self.label_nodes)
-
+        optional_layout.addRow("Times to remove edge trunks (int):", self.remove_trunk)
+        
         self.inners = QPushButton("Inner Edges")
         self.inners.setCheckable(True)
         self.inners.setChecked(self.prev_inners)
-        layout.addRow("Use Inner Edges:", self.inners)
-
+        optional_layout.addRow("Use Inner Edges:", self.inners)
+        
+        main_layout.addWidget(optional_group)
+        
+        # Speed Up Options Group
+        speedup_group = QGroupBox("Speed Up Options")
+        speedup_layout = QFormLayout(speedup_group)
+        
+        self.down_factor = QLineEdit(self.prev_down_factor)
+        self.down_factor.setPlaceholderText("Leave empty for None")
+        speedup_layout.addRow("Downsample for Centroids (int):", self.down_factor)
+        
+        self.GPU_downsample = QLineEdit(self.prev_GPU_downsample)
+        self.GPU_downsample.setPlaceholderText("Leave empty for None")
+        speedup_layout.addRow("Downsample for Distance Transform (GPU) (int):", self.GPU_downsample)
+        
+        self.gpu = QPushButton("GPU")
+        self.gpu.setCheckable(True)
+        self.gpu.setChecked(self.prev_gpu)
+        speedup_layout.addRow("Use GPU:", self.gpu)
+        
         self.fastdil = QPushButton("Fast Dilate")
         self.fastdil.setCheckable(True)
         self.fastdil.setChecked(self.prev_fastdil)
-        layout.addRow("Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
-
+        speedup_layout.addRow("Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
+        
+        main_layout.addWidget(speedup_group)
+        
+        # Output Options Group
+        output_group = QGroupBox("Output Options")
+        output_layout = QFormLayout(output_group)
+        
+        self.directory = QLineEdit(self.prev_directory)
+        self.directory.setPlaceholderText("Will Have to Save Manually If Empty")
+        output_layout.addRow("Output Directory:", self.directory)
+        
         self.overlays = QPushButton("Overlays")
         self.overlays.setCheckable(True)
         self.overlays.setChecked(self.prev_overlays)
-        layout.addRow("Generate Overlays:", self.overlays)
-
+        output_layout.addRow("Generate Overlays:", self.overlays)
+        
         self.update = QPushButton("Update")
         self.update.setCheckable(True)
         self.update.setChecked(self.prev_updates)
-        layout.addRow("Update Node/Edge in NetTracer3D:", self.update)
+        output_layout.addRow("Update Node/Edge in NetTracer3D:", self.update)
+        
+        main_layout.addWidget(output_group)
         
         # Add Run button
         run_button = QPushButton("Run Calculate All")
         run_button.clicked.connect(self.run_calc_all)
-        layout.addRow(run_button)
+        main_layout.addWidget(run_button)
 
     def run_calc_all(self):
 
@@ -10867,65 +11202,87 @@ class CalcAllDialog(QDialog):
                 f"Error running calculate all: {str(e)}"
             )
 
-class ProxDialog(QDialog):
 
+class ProxDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setWindowTitle("Calculate Proximity Network")
         self.setModal(True)
-
-        layout = QFormLayout(self)
-
-        # Directory (empty by default)
-        self.directory = QLineEdit('')
-        self.directory.setPlaceholderText("Leave empty for 'my_network'")
-        layout.addRow("Output Directory:", self.directory)
-
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        
+        # Important Parameters Group
+        important_group = QGroupBox("Important Parameters")
+        important_layout = QFormLayout(important_group)
+        
         self.search = QLineEdit()
         self.search.setPlaceholderText("search")
-        layout.addRow("Search Region Distance? (enter true value corresponding to scaling, ie in microns):", self.search)
-
-        # Load previous values for all inputs
+        important_layout.addRow("Search Region Distance? (enter true value corresponding to scaling, ie in microns):", self.search)
+        
         self.xy_scale = QLineEdit(f"{my_network.xy_scale}")
-        layout.addRow("xy_scale:", self.xy_scale)
+        important_layout.addRow("xy_scale:", self.xy_scale)
         
         self.z_scale = QLineEdit(f"{my_network.z_scale}")
-        layout.addRow("z_scale:", self.z_scale)
-
-        # Add mode selection dropdown
+        important_layout.addRow("z_scale:", self.z_scale)
+        
+        main_layout.addWidget(important_group)
+        
+        # Mode Group
+        mode_group = QGroupBox("Mode")
+        mode_layout = QFormLayout(mode_group)
+        
         self.mode_selector = QComboBox()
         self.mode_selector.addItems(["From Centroids (fast but ignores shape - use for small or spherical objects - search STARTS at centroid)", "From Morphological Shape (slower but preserves shape - use for oddly shaped objects - search STARTS at object border)"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
-        layout.addRow("Execution Mode:", self.mode_selector)
-
-        self.fastdil = QPushButton("Fast Dilate")
-        self.fastdil.setCheckable(True)
-        self.fastdil.setChecked(False)
-        layout.addRow("(If using morphological) Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
-
+        mode_layout.addRow("Execution Mode:", self.mode_selector)
+        
         if my_network.node_identities is not None:
             self.id_selector = QComboBox()
             # Add all options from id dictionary
             self.id_selector.addItems(['None'] + list(set(my_network.node_identities.values())))
             self.id_selector.setCurrentIndex(0)  # Default to Mode 1
-            layout.addRow("Create Networks only from a specific node identity?:", self.id_selector)
+            mode_layout.addRow("Create Networks only from a specific node identity?:", self.id_selector)
         else:
             self.id_selector = None
-
+        
+        main_layout.addWidget(mode_group)
+        
+        # Output Options Group
+        output_group = QGroupBox("Output Options")
+        output_layout = QFormLayout(output_group)
+        
+        self.directory = QLineEdit('')
+        self.directory.setPlaceholderText("Leave empty for 'my_network'")
+        output_layout.addRow("Output Directory:", self.directory)
+        
         self.overlays = QPushButton("Overlays")
         self.overlays.setCheckable(True)
         self.overlays.setChecked(True)
-        layout.addRow("Generate Overlays:", self.overlays)
-
+        output_layout.addRow("Generate Overlays:", self.overlays)
+        
         self.populate = QPushButton("Populate Nodes from Centroids?")
         self.populate.setCheckable(True)
         self.populate.setChecked(False)
-        layout.addRow("If using centroid search:", self.populate)
-
+        output_layout.addRow("If using centroid search:", self.populate)
+        
+        main_layout.addWidget(output_group)
+        
+        # Speed Up Options Group
+        speedup_group = QGroupBox("Speed Up Options")
+        speedup_layout = QFormLayout(speedup_group)
+        
+        self.fastdil = QPushButton("Fast Dilate")
+        self.fastdil.setCheckable(True)
+        self.fastdil.setChecked(False)
+        speedup_layout.addRow("(If using morphological) Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
+        
+        main_layout.addWidget(speedup_group)
+        
         # Add Run button
         run_button = QPushButton("Run Proximity Network")
         run_button.clicked.connect(self.prox)
-        layout.addRow(run_button)
+        main_layout.addWidget(run_button)
 
     def prox(self):
 

nettracer3d/proximity.py

@@ -723,7 +723,7 @@ def partition_objects_into_cells(object_centroids, cell_size):
                       cell_indices[1] * num_cells[2] + 
                       cell_indices[2])
         
-        cell_assignments[int(cell_number)].append(label)
+        cell_assignments[int(cell_number)].append(int(label))
     
     # Convert defaultdict to regular dict and sort keys
     return dict(sorted(cell_assignments.items()))

{nettracer3d-0.7.7.dist-info → nettracer3d-0.7.9.dist-info}/METADATA

@@ -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.dist-info → nettracer3d-0.7.9.dist-info}/RECORD

@@ -1,23 +1,23 @@
 nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nettracer3d/community_extractor.py,sha256=BrONCLRLYUdMfLe_018AQi0k0J7xwVahc_lmsOO5Pwo,23086
-nettracer3d/excelotron.py,sha256=jTAwMKIvyLgQBhDSHAhlTH02c9rQAKMck4ic5lE2KM4,68224
+nettracer3d/excelotron.py,sha256=lS5vnpoOGZWp7fdqVpTPqeC-mUKrfwDrWHfx4PQ7Uzg,71384
 nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,21788
 nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
-nettracer3d/neighborhoods.py,sha256=oCnvfGSjWdpPUdzUn_WhQVSIptGIYSVI0rmzWP_CfE0,7795
-nettracer3d/nettracer.py,sha256=RR3UFReS86AHQXHBZkzwQfhtA8pFtDK9K41pvxY5lbg,223147
-nettracer3d/nettracer_gui.py,sha256=8ZaReS5KbY4hgIWn65FHkBlTyrWwwowbsr09DATq3g4,454229
+nettracer3d/neighborhoods.py,sha256=kkKR8m6Gjw34cDd_mytAIwLxqvuNBtQb2hU4JuBY9pI,12301
+nettracer3d/nettracer.py,sha256=M1KFIPg7WCzm8BXQOreuEVhgjg0PpLKRg4Y88DyVuK8,225843
+nettracer3d/nettracer_gui.py,sha256=wdx_9putVHl0H4NIf_Bnmj0epgDb7OEMZYXb8pD8cYo,468815
 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=A81hNug8G4Rxx8OizhhzcnAP2ozoZghl52q3Kgefw3I,27991
+nettracer3d/proximity.py,sha256=5n8qxqxmmMtq5bqVpSkqw3EefuZIyGdLybVs18D3ZNg,27996
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
 nettracer3d/segmenter.py,sha256=BD9vxnblDKXfmR8hLP_iVqqfVngH6opz4Q7V6sxc2KM,60062
 nettracer3d/segmenter_GPU.py,sha256=Fqr0Za6X2ss4rfaziqOhvhBfbGDPHkHw6fVxs39lZaU,53862
 nettracer3d/simple_network.py,sha256=Ft_81VhVQ3rqoXvuYnsckXuxCcQSJfakhOfkFaclxZY,9340
 nettracer3d/smart_dilate.py,sha256=DOEOQq9ig6-AO4MpqAG0CqrGDFqw5_UBeqfSedqHk28,25933
-nettracer3d-0.7.7.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.7.7.dist-info/METADATA,sha256=VvJgZUXLw2U4nMlLO2fuMvEc9Pt3EVaeS3jrXpC7e5c,4141
-nettracer3d-0.7.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-0.7.7.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.7.7.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.7.7.dist-info/RECORD,,
+nettracer3d-0.7.9.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.7.9.dist-info/METADATA,sha256=3EyPBVXOMeZqA9D4vTpBvhOo6wOj_5KHW5lacpuApEk,4254
+nettracer3d-0.7.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.7.9.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.7.9.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.7.9.dist-info/RECORD,,