nettracer3d 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

nettracer3d/nettracer.py

@@ -1903,6 +1903,7 @@ def mirror_points_for_edge_correction(points_array, bounds, max_r, dim=3):
             all_points = np.vstack([all_points, mirrored_points])
     
     return all_points
+    
 def get_max_r_from_proportion(bounds, proportion):
     """
     Calculate max_r based on bounds and proportion, matching your generate_r_values logic.
@@ -3933,7 +3934,7 @@ class Network_3D:
         """
         self._nodes, num_nodes = label_objects(nodes, structure_3d)
 
-    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False):
+    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False, down_factor = None):
 
         """Internal method to merge two labelled node arrays into one"""
 
@@ -3944,7 +3945,10 @@ class Network_3D:
             max_val = np.max(root_nodes)
             other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
         if centroids:
-            new_dict = network_analysis._find_centroids(other_nodes)
+            new_dict = network_analysis._find_centroids(other_nodes, down_factor = down_factor)
+            if down_factor is not None:
+                for item in new_dict:
+                    new_dict[item] = down_factor * new_dict[item]
             self.node_centroids.update(new_dict)
 
         if root_ID is not None:
@@ -3984,7 +3988,7 @@ class Network_3D:
 
         return nodes, identity_dict
 
-    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False):
+    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False, down_factor = None):
         """
         Merges the self._nodes attribute with alternate labelled node images. The alternate nodes can be inputted as a string for a filepath to a tif,
         or as a directory address containing only tif images, which will merge the _nodes attribute with all tifs in the folder. The _node_identities attribute
@@ -4005,19 +4009,21 @@ class Network_3D:
         identity_dict = {} #A dictionary to deliniate the node identities
 
         if centroids:
-            self.node_centroids = network_analysis._find_centroids(self._nodes)
-
+            self.node_centroids = network_analysis._find_centroids(self._nodes, down_factor = down_factor)
+            if down_factor is not None:
+                for item in self.node_centroids:
+                    self.node_centroids[item] = down_factor * self.node_centroids[item]
 
         try: #Try presumes the input is a tif
             addn_nodes = tifffile.imread(addn_nodes_name) #If not this will fail and activate the except block
 
             if label_nodes is True:
                 addn_nodes, num_nodes2 = label_objects(addn_nodes) # Label the node objects. Note this presumes no overlap between node masks.
-                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids) #This method stacks labelled arrays
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor) #This method stacks labelled arrays
                 num_nodes = np.max(node_labels)
 
             else: #If nodes already labelled
-                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids)
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                 num_nodes = int(np.max(node_labels))
 
         except: #Exception presumes the input is a directory containing multiple tifs, to allow multi-node stackage.
@@ -4035,15 +4041,15 @@ class Network_3D:
                     if label_nodes is True:
                         addn_nodes, num_nodes2 = label_objects(addn_nodes)  # Label the node objects. Note this presumes no overlap between node masks.
                         if i == 0:
-                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                         else:
-                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids, down_factor = down_factor)
 
                     else:
                         if i == 0:
-                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                         else:
-                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids, down_factor = down_factor)
                 except Exception as e:
                     print("Could not open additional nodes, verify they are being inputted correctly...")
 
@@ -6049,57 +6055,94 @@ class Network_3D:
         self.node_identities = modify_dict
 
 
-    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True):
-
-        def distribute_points_uniformly(n, shape, z_scale, xy_scale, num, is_2d=False):
+    def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True, mask = None):
 
+        def distribute_points_uniformly(n, shape, z_scale, xy_scale, num, is_2d=False, mask=None):
             from scipy.spatial import KDTree
-
             if n <= 1:
                 return 0
-                        
-            # Calculate total positions and sampling step
-            total_positions = np.prod(shape)
-            if n >= total_positions:
-                # If we want more points than positions, just return scaled unit distance
-                return xy_scale if is_2d else min(z_scale, xy_scale)
             
-            # Create uniformly spaced indices
-            indices = np.linspace(0, total_positions - 1, n, dtype=int)
-            
-            # Convert flat indices to coordinates
-            coords = []
-            for idx in indices:
-                coord = np.unravel_index(idx, shape)
+            if mask is not None:
+                # Handle mask-based distribution
+                # Find all valid positions where mask is True
+                valid_positions = np.where(mask)
+                total_valid_positions = len(valid_positions[0])
+                
+                if total_valid_positions == 0:
+                    raise ValueError("No valid positions found in mask")
+                
+                if n >= total_valid_positions:
+                    # If we want more points than valid positions, return scaled unit distance
+                    return xy_scale if is_2d else min(z_scale, xy_scale)
+                
+                # Create uniformly spaced indices within valid positions
+                valid_indices = np.linspace(0, total_valid_positions - 1, n, dtype=int)
+                
+                # Convert to coordinates and apply scaling
+                coords = []
+                for idx in valid_indices:
+                    if len(shape) == 3:
+                        coord = (valid_positions[0][idx], valid_positions[1][idx], valid_positions[2][idx])
+                        scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
+                    elif len(shape) == 2:
+                        coord = (valid_positions[0][idx], valid_positions[1][idx])
+                        scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
+                    coords.append(scaled_coord)
+                
+                coords = np.array(coords)
+                
+                # Find a good query point (closest to center of valid region)
                 if len(shape) == 3:
-                    # Apply scaling: [z, y, x] with respective scales
-                    scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
-                elif len(shape) == 2:
-                    # Apply scaling: [y, x] with xy_scale
-                    scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
-                coords.append(scaled_coord)
-            
-            coords = np.array(coords)
+                    center_pos = [np.mean(valid_positions[0]) * z_scale, 
+                                 np.mean(valid_positions[1]) * xy_scale,
+                                 np.mean(valid_positions[2]) * xy_scale]
+                else:
+                    center_pos = [np.mean(valid_positions[0]) * xy_scale,
+                                 np.mean(valid_positions[1]) * xy_scale]
+                
+                # Find point closest to center of valid region
+                center_distances = np.sum((coords - center_pos)**2, axis=1)
+                middle_idx = np.argmin(center_distances)
+                query_point = coords[middle_idx]
+                
+            else:
+                # Original behavior when no mask is provided
+                total_positions = np.prod(shape)
+                if n >= total_positions:
+                    return xy_scale if is_2d else min(z_scale, xy_scale)
+                
+                # Create uniformly spaced indices
+                indices = np.linspace(0, total_positions - 1, n, dtype=int)
+                
+                # Convert flat indices to coordinates
+                coords = []
+                for idx in indices:
+                    coord = np.unravel_index(idx, shape)
+                    if len(shape) == 3:
+                        scaled_coord = [coord[0] * z_scale, coord[1] * xy_scale, coord[2] * xy_scale]
+                    elif len(shape) == 2:
+                        scaled_coord = [coord[0] * xy_scale, coord[1] * xy_scale]
+                    coords.append(scaled_coord)
+                
+                coords = np.array(coords)
+                
+                # Pick a point near the middle of the array
+                middle_idx = len(coords) // 2
+                query_point = coords[middle_idx]
             
             # Build KDTree
             tree = KDTree(coords)
             
-            # Pick a point near the middle of the array
-            middle_idx = len(coords) // 2
-            query_point = coords[middle_idx]
-            
             # Find the num+1 nearest neighbors (including the point itself)
             distances, indices = tree.query(query_point, k=num+1)
             
             # Exclude the point itself (distance 0) and get the actual neighbors
             neighbor_distances = distances[1:num+1]
-
             if num == n:
                 neighbor_distances[-1] = neighbor_distances[-2]
             
             avg_distance = np.mean(neighbor_distances)
             
-            
             return avg_distance
 
         do_borders = not centroids
@@ -6162,11 +6205,11 @@ class Network_3D:
             if heatmap:
                 root_set = []
                 compare_set = []
-                if root is None:
-
-                    root_set = list(self.node_centroids.keys())
+                if root is None and not do_borders:
                     compare_set = root_set
-                else:
+                    if not do_borders:
+                        root_set = list(self.node_centroids.keys())
+                elif self.node_identities is not None:
                     for node, iden in self.node_identities.items():
 
                         if iden == root:
@@ -6194,7 +6237,8 @@ class Network_3D:
                     targ = [targ]
 
                 compare_set_neigh = approx_boundaries(self.nodes, targ, self.node_identities, keep_labels = False)
-                avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set_neigh, compare_set_neigh, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num, do_borders = do_borders)
+
+            avg, output = proximity.average_nearest_neighbor_distances(self.node_centroids, root_set_neigh, compare_set_neigh, xy_scale=self.xy_scale, z_scale=self.z_scale, num = num, do_borders = do_borders)
 
         if quant:
             try:
@@ -6236,7 +6280,15 @@ class Network_3D:
             else:
                 is_2d = False
 
-            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, num = num, is_2d = is_2d)
+            if root_set == []:
+                avail_nodes = np.unique(self.nodes)
+                compare_set = list(avail_nodes)
+                if 0 in compare_set:
+                    del compare_set[0]
+                root_set = compare_set
+            elif compare_set == []:
+                compare_set = root_set
+            pred = distribute_points_uniformly(len(compare_set), bounds, self.z_scale, self.xy_scale, num = num, is_2d = is_2d, mask = mask)
 
             node_intensity = {}
             import math
@@ -6244,7 +6296,6 @@ class Network_3D:
 
             for node in root_set:
                 node_intensity[node] = math.log(pred/output[node])
-                #print(output[node])
                 node_centroids[node] = self.node_centroids[node]
 
             if numpy:

nettracer3d/nettracer_gui.py

@@ -4,7 +4,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QG
                             QHBoxLayout, QSlider, QMenuBar, QMenu, QDialog, 
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
-                            QMenu, QTabWidget, QGroupBox)
+                            QMenu, QTabWidget, QGroupBox, QCheckBox)
 from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent, QEventLoop)
 import numpy as np
 import time
@@ -1280,7 +1280,9 @@ class ImageViewerWindow(QMainWindow):
 
                 if my_network.node_identities is not None:
                     identity_menu = QMenu("Show Identity", self)
-                    for item in set(my_network.node_identities.values()):
+                    idens = list(set(my_network.node_identities.values()))
+                    idens.sort()
+                    for item in idens:
                         show_identity = identity_menu.addAction(f"ID: {item}")
                         show_identity.triggered.connect(lambda checked, item=item: self.handle_show_identities(sort=item))
                     context_menu.addMenu(identity_menu)
@@ -5471,7 +5473,6 @@ class ImageViewerWindow(QMainWindow):
 
         elif sort == 'Merge Nodes':
             try:
-
                 if my_network.nodes is None:
                     QMessageBox.critical(
                         self,
@@ -5479,72 +5480,118 @@ class ImageViewerWindow(QMainWindow):
                         "Please load your first set of nodes into the 'Nodes' channel first"
                     )
                     return
-
                 if len(np.unique(my_network.nodes)) < 3:
                     self.show_label_dialog()
-
-                # First ask user what they want to select
-                msg = QMessageBox()
-                msg.setWindowTitle("Selection Type")
-                msg.setText("Would you like to select a TIFF file or a directory?")
-                tiff_button = msg.addButton("TIFF File", QMessageBox.ButtonRole.AcceptRole)
-                dir_button = msg.addButton("Directory", QMessageBox.ButtonRole.AcceptRole)
-                msg.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
-
-                msg.exec()
-
-                # Also if they want centroids:
-                msg2 = QMessageBox()
-                msg2.setWindowTitle("Selection Type")
-                msg2.setText("Would you like to compute node centroids for each image prior to merging?")
-                yes_button = msg2.addButton("Yes", QMessageBox.ButtonRole.AcceptRole)
-                no_button = msg2.addButton("No", QMessageBox.ButtonRole.AcceptRole)
-                msg2.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
-
-                msg2.exec()
-
-                if msg2.clickedButton() == yes_button:
-                    centroids = True
-                else:
-                    centroids = False
-
-                if msg.clickedButton() == tiff_button:
-                    # Code for selecting TIFF files
-                    filename, _ = QFileDialog.getOpenFileName(
-                        self,
-                        "Select TIFF file",
-                        "",
-                        "TIFF files (*.tiff *.tif)"
-                    )
-                    if filename:
-                        selected_path = filename
-
-                elif msg.clickedButton() == dir_button:
-                    # Code for selecting directories
-                    dialog = QFileDialog(self)
-                    dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
-                    dialog.setOption(QFileDialog.Option.ReadOnly)
-                    dialog.setFileMode(QFileDialog.FileMode.Directory)
-                    dialog.setViewMode(QFileDialog.ViewMode.Detail)
-
-                    if dialog.exec() == QFileDialog.DialogCode.Accepted:
-                        selected_path = dialog.directory().absolutePath()
-
-                my_network.merge_nodes(selected_path, root_id = self.node_name, centroids = centroids)
-                self.load_channel(0, my_network.nodes, True)
-
-
-                if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                
+                # Create custom dialog
+                dialog = QDialog(self)
+                dialog.setWindowTitle("Merge Nodes Configuration")
+                dialog.setModal(True)
+                dialog.resize(400, 200)
+                
+                layout = QVBoxLayout(dialog)
+                
+                # Selection type
+                type_layout = QHBoxLayout()
+                type_label = QLabel("Selection Type:")
+                type_combo = QComboBox()
+                type_combo.addItems(["TIFF File", "Directory"])
+                type_layout.addWidget(type_label)
+                type_layout.addWidget(type_combo)
+                layout.addLayout(type_layout)
+                
+                # Centroids checkbox
+                centroids_layout = QHBoxLayout()
+                centroids_check = QCheckBox("Compute node centroids for each image prior to merging")
+                centroids_layout.addWidget(centroids_check)
+                layout.addLayout(centroids_layout)
+                
+                # Down factor for centroid calculation
+                down_factor_layout = QHBoxLayout()
+                down_factor_label = QLabel("Down Factor (for centroid calculation downsampling):")
+                down_factor_edit = QLineEdit()
+                down_factor_edit.setText("1")  # Default value
+                down_factor_edit.setPlaceholderText("Enter down factor (e.g., 1, 2, 4)")
+                down_factor_layout.addWidget(down_factor_label)
+                down_factor_layout.addWidget(down_factor_edit)
+                layout.addLayout(down_factor_layout)
+                
+                # Buttons
+                button_layout = QHBoxLayout()
+                accept_button = QPushButton("Accept")
+                cancel_button = QPushButton("Cancel")
+                button_layout.addWidget(accept_button)
+                button_layout.addWidget(cancel_button)
+                layout.addLayout(button_layout)
+                
+                # Connect buttons
+                accept_button.clicked.connect(dialog.accept)
+                cancel_button.clicked.connect(dialog.reject)
+                
+                # Execute dialog
+                if dialog.exec() == QDialog.DialogCode.Accepted:
+                    # Get values from dialog
+                    selection_type = type_combo.currentText()
+                    centroids = centroids_check.isChecked()
+                    
+                    # Validate and get down_factor
                     try:
-                        self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
-                    except Exception as e:
-                        print(f"Error loading node identity table: {e}")
-                if centroids:
-                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
-
-
+                        down_factor = int(down_factor_edit.text())
+                        if down_factor <= 0:
+                            raise ValueError("Down factor must be positive")
+                    except ValueError as e:
+                        QMessageBox.critical(
+                            self,
+                            "Invalid Input",
+                            f"Invalid down factor: {str(e)}"
+                        )
+                        return
+                    
+                    # Handle file/directory selection based on combo box choice
+                    if selection_type == "TIFF File":
+                        filename, _ = QFileDialog.getOpenFileName(
+                            self,
+                            "Select TIFF file",
+                            "",
+                            "TIFF files (*.tiff *.tif)"
+                        )
+                        if filename:
+                            selected_path = filename
+                        else:
+                            return  # User cancelled file selection
+                    else:  # Directory
+                        file_dialog = QFileDialog(self)
+                        file_dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
+                        file_dialog.setOption(QFileDialog.Option.ReadOnly)
+                        file_dialog.setFileMode(QFileDialog.FileMode.Directory)
+                        file_dialog.setViewMode(QFileDialog.ViewMode.Detail)
+                        if file_dialog.exec() == QFileDialog.DialogCode.Accepted:
+                            selected_path = file_dialog.directory().absolutePath()
+                        else:
+                            return  # User cancelled directory selection
+                    
+                    if down_factor == 1:
+                        down_factor = None
+                    # Call merge_nodes with all parameters
+                    my_network.merge_nodes(
+                        selected_path, 
+                        root_id=self.node_name, 
+                        centroids=centroids,
+                        down_factor=down_factor
+                    )
+                    
+                    self.load_channel(0, my_network.nodes, True)
+                    
+                    if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                        try:
+                            self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                        except Exception as e:
+                            print(f"Error loading node identity table: {e}")
+                    
+                    if centroids:
+                        self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                
             except Exception as e:
-
                 QMessageBox.critical(
                     self,
                     "Error Merging",
@@ -5567,7 +5614,8 @@ class ImageViewerWindow(QMainWindow):
                     )
 
             self.last_load = directory
-            
+            self.last_saved = os.path.dirname(directory)
+            self.last_save_name = directory            
 
             if directory != "":
 
@@ -5649,8 +5697,6 @@ class ImageViewerWindow(QMainWindow):
                 f"Failed to load Network 3D Object: {str(e)}"
             )
 
-
-
     def load_network(self):
         """Load in the network from a .xlsx (need to add .csv support)"""
 
@@ -8993,7 +9039,7 @@ class ComNeighborDialog(QDialog):
 
             mode = self.mode.currentIndex()
 
-            seed = float(self.seed.text()) if self.seed.text().strip() else 42
+            seed = int(self.seed.text()) if self.seed.text().strip() else 42
 
             limit = int(self.limit.text()) if self.limit.text().strip() else None
 
@@ -9190,6 +9236,11 @@ class NearNeighDialog(QDialog):
         self.numpy.setChecked(False)
         self.numpy.clicked.connect(self.toggle_map)
         heatmap_layout.addRow("Overlay:", self.numpy)
+
+        self.mode = QComboBox()
+        self.mode.addItems(["Anywhere", "Within Masked Bounds of Edges", "Within Masked Bounds of Overlay1", "Within Masked Bounds of Overlay2"])
+        self.mode.setCurrentIndex(0)
+        heatmap_layout.addRow("For heatmap, measure theoretical point distribution how?", self.mode)
         
         main_layout.addWidget(heatmap_group)
 
@@ -9281,35 +9332,48 @@ class NearNeighDialog(QDialog):
                 root = None
                 targ = None
 
+            mode = self.mode.currentIndex()
+
+            if mode == 0:
+                mask = None
+            else:
+                try:
+                    mask = self.parent().channel_data[mode] != 0
+                except:
+                    print("Could not binarize mask")
+                    mask = 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
             quant = self.quant.isChecked()
             centroids = self.centroids.isChecked()
+
             if not centroids:
+                print("Using 1 nearest neighbor due to not using centroids")
                 num = 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)"
+                header = f"Avg Shortest Distance to Closest {num} {targ}(s)"
                 header2 = f"{root} Node ID"
                 header3 = f'Theoretical Uniform Distance to Closest {num} {targ}(s)'
             else:
                 title = f"Nearest {num} Neighbor(s) Distance Between Nodes"
-                header = f"Shortest Distance to Closest {num} Nodes"
+                header = f"Avg Shortest Distance to Closest {num} Nodes"
                 header2 = "Root Node ID"
                 header3 = f'Simulated Theoretical Uniform Distance to Closest {num} Nodes'
 
-            if centroids and my_network.node_centroids is None:
+            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, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids)
+                avg, output, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids, mask = mask)
             else:
-                avg, output, overlay, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant, centroids = centroids)
+                avg, output, overlay, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant, centroids = centroids, mask = mask)
                 self.parent().load_channel(3, overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             if quant_overlay is not None:
@@ -10064,9 +10128,33 @@ class ViolinDialog(QDialog):
         
         return df_normalized
 
+    def show_in_table(self, df, metric, title):
+
+        # Create new table
+        table = CustomTableView(self.parent())
+        table.setModel(PandasModel(df))
+
+        try:
+            first_column_name = table.model()._data.columns[0]
+            table.sort_table(first_column_name, ascending=True)
+        except:
+             pass
+        
+        # Add to tabbed widget
+        if title is None:
+            self.parent().tabbed_data.add_table(f"{metric} Analysis", table)
+        else:
+            self.parent().tabbed_data.add_table(f"{title}", table)
+        
+
+
+        # Adjust column widths to content
+        for column in range(table.model().columnCount(None)):
+            table.resizeColumnToContents(column)
+
     def run(self):
 
-        def df_to_dict_by_rows(df, row_indices):
+        def df_to_dict_by_rows(df, row_indices, title):
             """
             Convert a pandas DataFrame to a dictionary by selecting specific rows.
             No normalization - dataframe is already normalized.
@@ -10095,6 +10183,10 @@ class ViolinDialog(QDialog):
             for column in masked_df.columns:
                 result_dict[column] = masked_df[column].tolist()
             
+            masked_df.insert(0, "NodeIDs", row_indices)
+            self.show_in_table(masked_df, metric = "NodeID", title = title)
+
+
             return result_dict
 
         from . import neighborhoods
@@ -10112,10 +10204,10 @@ class ViolinDialog(QDialog):
                     if iden in parse:
                         iden_list.append(item)
                 except:
-                    if iden == item:
+                    if (iden == my_network.node_identities[item]):
                         iden_list.append(item)
 
-            violin_dict = df_to_dict_by_rows(self.df, iden_list)
+            violin_dict = df_to_dict_by_rows(self.df, iden_list, f"Z-Score-like Channel Intensities of Identity {iden}, {len(iden_list)} Nodes")
 
             neighborhoods.create_violin_plots(violin_dict, graph_title=f"Z-Score-like Channel Intensities of Identity {iden}, {len(iden_list)} Nodes")
 
@@ -10124,11 +10216,11 @@ class ViolinDialog(QDialog):
 
             com = self.coms.currentText()
 
-            com_dict = n3d.invert_dict(my_network.communities)  # Fixed: should be communities
+            com_dict = n3d.invert_dict(my_network.communities)
 
             com_list = com_dict[int(com)]
 
-            violin_dict = df_to_dict_by_rows(self.df, com_list)
+            violin_dict = df_to_dict_by_rows(self.df, com_list, f"Z-Score-like Channel Intensities of Community/Neighborhood {com}, {len(com_list)} Nodes")
 
             neighborhoods.create_violin_plots(violin_dict, graph_title=f"Z-Score-like Channel Intensities of Community/Neighborhood {com}, {len(com_list)} Nodes")
 

{nettracer3d-1.0.2.dist-info → nettracer3d-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.2
+Version: 1.0.4
 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/
@@ -110,7 +110,7 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.0.2 Updates --
+-- Version 1.0.4 Updates --
 
-	* Minor fixes
-	* Added ability to generate violin plots using the table generated from merging node identities, showing the relative expression of markers for multiple channels for the nodes belonging to some channel or community/neighborhood
+	* Some small bug fixes and adjustments
+	* Heatmap theoretical distances can now be calculated based on an area constrained within a binary mask.

{nettracer3d-1.0.2.dist-info → nettracer3d-1.0.4.dist-info}/RECORD

@@ -5,8 +5,8 @@ nettracer3d/excelotron.py,sha256=aNof6k-DgMxVyFgsl3ltSCxG4vZW49cuvCBzfzhYhUY,750
 nettracer3d/modularity.py,sha256=pborVcDBvICB2-g8lNoSVZbIReIBlfeBmjFbPYmtq7Y,22443
 nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
 nettracer3d/neighborhoods.py,sha256=lh4_zuTwgTq-u8VHy72buBfZf58FEJo9sH3IIBuZr68,52735
-nettracer3d/nettracer.py,sha256=dZR8wOFUDNmfsn1M615FKbg1n4C_RhtwLh9vtjCryBg,270737
-nettracer3d/nettracer_gui.py,sha256=m1V7S1YMw17YBgcAdE3lRmCbvoBsTZyUl7dOmQ6N6OI,661601
+nettracer3d/nettracer.py,sha256=6r5aGtmiHxGkfCh5lJuREAoloZ3WKvcaRAD7kmWXedk,273957
+nettracer3d/nettracer_gui.py,sha256=0QzoDa6o2z-iVZzM3v4tePFV-tvw-lkD_24tQ0fZ1sU,666134
 nettracer3d/network_analysis.py,sha256=kBzsVaq4dZkMe0k-VGvQIUvM-tK0ZZ8bvb-wtsugZRQ,46150
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
 nettracer3d/node_draw.py,sha256=kZcR1PekLg0riioNeGcALIXQyZ5PtHA_9MT6z7Zovdk,10401
@@ -17,9 +17,9 @@ nettracer3d/segmenter.py,sha256=aOO3PwZ2UeizEIFX7N8midwzTzbEDzgM2jQ7WTdbrUg,7067
 nettracer3d/segmenter_GPU.py,sha256=OUekQljLKPiC4d4hNZmqrRa9HSVQ6HcCnILiAfHE5Hg,78051
 nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
 nettracer3d/smart_dilate.py,sha256=TvRUh6B4q4zIdCO1BWH-xgTdND5OUNmo99eyxG9oIAU,27145
-nettracer3d-1.0.2.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
-nettracer3d-1.0.2.dist-info/METADATA,sha256=1LixOhZlmUtLcP9OrX6WK_mS0M2tuzo3tjGbw4FZrEE,7218
-nettracer3d-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-1.0.2.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-1.0.2.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-1.0.2.dist-info/RECORD,,
+nettracer3d-1.0.4.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
+nettracer3d-1.0.4.dist-info/METADATA,sha256=VMs_Lcaa3xnnLTrror42GmRUJBdzIcyGk0sMtJZZ9Eo,7120
+nettracer3d-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-1.0.4.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-1.0.4.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-1.0.4.dist-info/RECORD,,