nettracer3d 1.0.3__py3-none-any.whl → 1.0.5__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.
@@ -6054,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
@@ -6167,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:
@@ -6199,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:
@@ -6241,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
@@ -6249,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

@@ -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)
@@ -5612,7 +5614,8 @@ class ImageViewerWindow(QMainWindow):
                     )
 
             self.last_load = directory
-            
+            self.last_saved = os.path.dirname(directory)
+            self.last_save_name = directory            
 
             if directory != "":
 
@@ -5694,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)"""
 
@@ -9038,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
 
@@ -9235,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)
 
@@ -9326,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:
@@ -10068,7 +10087,7 @@ class ViolinDialog(QDialog):
         # Convert all remaining columns to float type (batch conversion)
         df_copy = df_copy.astype(float)
         
-        # First, calculate the centerpoint for each column by finding the median across all identity groups
+        # First, calculate the centerpoint for each column by finding the min across all identity groups
         column_centerpoints = {}
         
         for column in df_copy.columns:
@@ -10079,7 +10098,7 @@ class ViolinDialog(QDialog):
                 valid_nodes = [node for node in node_list if node in df_copy.index]
                 if valid_nodes and ((str(identity) == str(column)) or str(identity) == f'{str(column)}+'):
                     # Get the median value for this identity in this column
-                    identity_min = df_copy.loc[valid_nodes, column].median()
+                    identity_min = df_copy.loc[valid_nodes, column].min()
                     centerpoint = identity_min
                     break  # Found the match, no need to continue
             
@@ -10088,6 +10107,7 @@ class ViolinDialog(QDialog):
                 column_centerpoints[column] = centerpoint
             else:
                 # Fallback: if no matching identity, use column median
+                print(f"Could not find {str(column)} in node identities. As a fallback, using the median of all values in this channel rather than the minimum of user-designated valid values.")
                 column_centerpoints[column] = df_copy[column].median()
         
         # Now normalize each column using Z-score-like calculation with identity centerpoint

{nettracer3d-1.0.3.dist-info → nettracer3d-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.3
+Version: 1.0.5
 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,6 +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.3 Updates --
+-- Version 1.0.4 Updates --
 
 	* 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.3.dist-info → nettracer3d-1.0.5.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=_K_npg50qrXU1kj8NeFnlQY0oRMnD_PyvNi23hoQDow,271318
-nettracer3d/nettracer_gui.py,sha256=3nUjgPi2H-OKqBB7PP35kQVXLJNzPJN9wx9Ay_9pt50,665218
+nettracer3d/nettracer.py,sha256=6r5aGtmiHxGkfCh5lJuREAoloZ3WKvcaRAD7kmWXedk,273957
+nettracer3d/nettracer_gui.py,sha256=GannK0Yvq80I0Pz6HxVlfiow6lcLlmJAsisenUq2hPQ,666323
 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.3.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
-nettracer3d-1.0.3.dist-info/METADATA,sha256=jXFL5Ol1kS56twkSbK7qat2uYIFrnw9E7fRwOcojqLs,7013
-nettracer3d-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-1.0.3.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-1.0.3.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-1.0.3.dist-info/RECORD,,
+nettracer3d-1.0.5.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
+nettracer3d-1.0.5.dist-info/METADATA,sha256=_0HLxnSBy83kTuLBk9HlSh_1-sQjoeJwJTXUtGdIEPw,7120
+nettracer3d-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-1.0.5.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-1.0.5.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-1.0.5.dist-info/RECORD,,