nettracer3d 0.6.8__py3-none-any.whl → 0.7.0__py3-none-any.whl

nettracer3d/modularity.py

@@ -446,31 +446,11 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         except:
             pass
 
-        try:        
-            # Per-community statistics
-            for i, com in enumerate(communities):
-                subgraph = G.subgraph(com)
-                
-                # Basic community metrics
-                stats[f'Community {i+1} Density'] = nx.density(subgraph)
-                stats[f'Community {i+1} Conductance'] = nx.conductance(G, com)
-                stats[f'Community {i+1} Avg Clustering'] = nx.average_clustering(subgraph)
-                
-                # Degree centrality
-                degree_cent = nx.degree_centrality(subgraph)
-                stats[f'Community {i+1} Avg Degree Centrality'] = np.mean(list(degree_cent.values()))
-                
-                # Average path length (only for connected subgraphs)
-                if nx.is_connected(subgraph):
-                    stats[f'Community {i+1} Avg Path Length'] = nx.average_shortest_path_length(subgraph)
-        except:
-            pass
-
-        try:        
+        #try:        
             # Add some Louvain-specific statistics
-            stats['Partition Resolution'] = 1.0  # Default resolution parameter
-        except:
-            pass
+            #stats['Partition Resolution'] = 1.0  # Default resolution parameter
+        #except:
+            #pass
         try:
             stats['Number of Iterations'] = len(set(partition.values()))
         except:
@@ -514,6 +494,25 @@ def community_partition(master_list, weighted = False, style = 0, dostats = True
         except:
             pass
 
+        try:        
+            # Per-community statistics
+            for i, com in enumerate(communities):
+                subgraph = G.subgraph(com)
+                
+                # Basic community metrics
+                stats[f'Community {i+1} Density'] = nx.density(subgraph)
+                stats[f'Community {i+1} Conductance'] = nx.conductance(G, com)
+                stats[f'Community {i+1} Avg Clustering'] = nx.average_clustering(subgraph)
+                
+                # Degree centrality
+                degree_cent = nx.degree_centrality(subgraph)
+                stats[f'Community {i+1} Avg Degree Centrality'] = np.mean(list(degree_cent.values()))
+                
+                # Average path length (only for connected subgraphs)
+                if nx.is_connected(subgraph):
+                    stats[f'Community {i+1} Avg Path Length'] = nx.average_shortest_path_length(subgraph)
+        except:
+            pass
         
         return stats
 

nettracer3d/morphology.py

@@ -354,6 +354,7 @@ def process_object_cpu(label, objects, labeled_array, xy_scale = 1, z_scale = 1)
     mask = (subarray == label)
 
 
+    """
     # Determine which dimension needs resampling
     if (z_scale > xy_scale) and mask.shape[0] != 1:
         # Z dimension needs to be stretched
@@ -371,13 +372,13 @@ def process_object_cpu(label, objects, labeled_array, xy_scale = 1, z_scale = 1)
     # Resample the mask if needed
     if zoom_factor:
         mask = ndimage.zoom(mask, zoom_factor, order=0)  # Use order=0 for binary masks
-
+    """
     
     # Compute distance transform on the smaller mask
-    dist_transform = compute_distance_transform_distance(mask)
+    dist_transform = compute_distance_transform_distance(mask, sampling = [z_scale, xy_scale, xy_scale])
     
     # Filter out small values near the edge to focus on more central regions
-    radius = np.max(dist_transform) * cardinal
+    radius = np.max(dist_transform)
     
     return label, radius
 
@@ -474,6 +475,7 @@ def estimate_object_radii_gpu(labeled_array, xy_scale = 1, z_scale = 1):
             # Create binary mask for this object (directly on GPU)
             mask_gpu = (labeled_array_gpu[tuple(padded_slices)] == label)
 
+            """
             # Determine which dimension needs resampling
             if (z_scale > xy_scale) and mask_gpu.shape[0] != 1:
                 # Z dimension needs to be stretched
@@ -491,11 +493,12 @@ def estimate_object_radii_gpu(labeled_array, xy_scale = 1, z_scale = 1):
             # Resample the mask if needed
             if zoom_factor:
                 mask_gpu = cpx.zoom(mask_gpu, zoom_factor, order=0)  # Use order=0 for binary masks
+            """
             
             # Compute distance transform on GPU
-            dist_transform_gpu = compute_distance_transform_distance_GPU(mask_gpu)
+            dist_transform_gpu = compute_distance_transform_distance_GPU(mask_gpu, sampling = [z_scale, xy_scale, xy_scale])
         
-            radius = float(cp.max(dist_transform_gpu).get()) * cardinal
+            radius = float(cp.max(dist_transform_gpu).get())
 
 
             # Store the radius and the scaled radius
@@ -510,14 +513,15 @@ def estimate_object_radii_gpu(labeled_array, xy_scale = 1, z_scale = 1):
         print(f"GPU calculation failed, trying CPU instead -> {e}")
         return estimate_object_radii_cpu(labeled_array)
 
-def compute_distance_transform_distance_GPU(nodes):
+def compute_distance_transform_distance_GPU(nodes, sampling = [1,1,1]):
 
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = cp.squeeze(nodes)  # Convert to 2D for processing
+        del sampling[0]
     
     # Compute the distance transform on the GPU
-    distance = cpx.distance_transform_edt(nodes)
+    distance = cpx.distance_transform_edt(nodes, sampling = sampling)
 
     if is_pseudo_3d:
         cp.expand_dims(distance, axis = 0)
@@ -525,14 +529,15 @@ def compute_distance_transform_distance_GPU(nodes):
     return distance    
 
 
-def compute_distance_transform_distance(nodes):
+def compute_distance_transform_distance(nodes, sampling = [1,1,1]):
 
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d:
         nodes = np.squeeze(nodes)  # Convert to 2D for processing
+        del sampling[0]
 
     # Fallback to CPU if there's an issue with GPU computation
-    distance = ndimage.distance_transform_edt(nodes)
+    distance = ndimage.distance_transform_edt(nodes, sampling = sampling)
     if is_pseudo_3d:
         np.expand_dims(distance, axis = 0)
     return distance

nettracer3d/nettracer.py

@@ -987,6 +987,7 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
 
     del array
 
+    """
     # Determine which dimension needs resampling
     if (z_scaling > xy_scaling):
         # Z dimension needs to be stretched
@@ -1007,17 +1008,18 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     # Resample the mask if needed
     if zoom_factor:
         inv = ndimage.zoom(inv, zoom_factor, order=0)  # Use order=0 for binary masks
-    
+    """
+
     # Compute distance transform (Euclidean)
-    inv = smart_dilate.compute_distance_transform_distance(inv)
+    inv = smart_dilate.compute_distance_transform_distance(inv, sampling = [z_scaling, xy_scaling, xy_scaling])
 
-    inv = inv * cardinal
+    #inv = inv * cardinal
     
     # Threshold the distance transform to get dilated result
     inv = inv <= search_distance
 
-    if rev_factor:
-        inv = ndimage.zoom(inv, rev_factor, order=0)  # Use order=0 for binary masks
+    #if rev_factor:
+        #inv = ndimage.zoom(inv, rev_factor, order=0)  # Use order=0 for binary masks
     
     return inv.astype(np.uint8)
 
@@ -1043,6 +1045,7 @@ def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     # For erosion, we work directly with the foreground (no inversion needed)
     
+    """
     # Determine which dimension needs resampling
     if (z_scaling > xy_scaling):
         # Z dimension needs to be stretched
@@ -1063,21 +1066,22 @@ def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     # Resample the mask if needed
     if zoom_factor:
         array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
+    """
     
     print("Computing a distance transform for a perfect erosion...")
 
-    array = smart_dilate.compute_distance_transform_distance(array)
+    array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
     
     # Apply scaling factor
-    array = array * cardinal
+    #array = array * cardinal
     
     # Threshold the distance transform to get eroded result
     # For erosion, we keep only the points that are at least search_distance from the boundary
     array = array >= search_distance
     
     # Resample back to original dimensions if needed
-    if rev_factor:
-        array = ndimage.zoom(array, rev_factor, order=0)  # Use order=0 for binary masks
+    #if rev_factor:
+        #array = ndimage.zoom(array, rev_factor, order=0)  # Use order=0 for binary masks
     
     return array.astype(np.uint8)
 
@@ -2061,7 +2065,24 @@ def mask(image, mask, directory = None):
 
     mask = mask != 0
 
-    image = image * mask
+    if len(image.shape) == 3:
+
+        image = image * mask
+    else:
+        # Split into separate color channels
+        channels = [image[..., i] for i in range(3)]
+        masked_channels = []
+        
+        for image in channels:
+            # Upsample each channel separately
+            if len(image.shape) == 2:
+                np.expand_dims(image, axis = 0)
+            image = image * mask
+            masked_channels.append(image)
+            
+        # Stack the channels back together
+        image = np.stack(masked_channels, axis=-1)
+
 
     if string_bool:
         if directory is None:
@@ -3363,16 +3384,17 @@ class Network_3D:
         :param skeletonize: (Optional - Val = False, boolean) - A boolean of whether to skeletonize the edges when using them.
         """
 
-
-        directory = encapsulate()
+        if directory is not None:
+            directory = encapsulate()
 
         self._xy_scale = xy_scale
         self._z_scale = z_scale
 
-        try:
-            self.save_scaling(directory)
-        except:
-            pass
+        if directory is not None:
+            try:
+                self.save_scaling(directory)
+            except:
+                pass
 
         if search is None and ignore_search_region == False:
             search = 0
@@ -3383,19 +3405,23 @@ class Network_3D:
         self._nodes = nodes
         del nodes
 
+        if self._nodes.shape[0] == 1:
+            fast_dil = True #Set this to true because the 2D algo always uses the distance transform and doesnt need this special ver
+
         if label_nodes:
             self._nodes, num_nodes = label_objects(self._nodes)
         if other_nodes is not None:
             self.merge_nodes(other_nodes, label_nodes)
 
-        try:
-            self.save_nodes(directory)
-        except:
-            pass
-        try:
-            self.save_node_identities(directory)
-        except:
-            pass
+        if directory is not None:
+            try:
+                self.save_nodes(directory)
+            except:
+                pass
+            try:
+                self.save_node_identities(directory)
+            except:
+                pass
 
         if not ignore_search_region:
             self.calculate_search_region(search, GPU = GPU, fast_dil = fast_dil, GPU_downsample = GPU_downsample)
@@ -3408,31 +3434,35 @@ class Network_3D:
 
         self.calculate_edges(edges, diledge = diledge, inners = inners, hash_inner_edges = hash_inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize)
         del edges
-        try:
-            self.save_edges(directory)
-        except:
-            pass
+        if directory is not None:
+            try:
+                self.save_edges(directory)
+            except:
+                pass
 
         self.calculate_network(search = search, ignore_search_region = ignore_search_region)
 
-        try:
-            self.save_network(directory)
-        except:
-            pass
+        if directory is not None:
+            try:
+                self.save_network(directory)
+            except:
+                pass
 
         if self._nodes is None:
             self.load_nodes(directory)
 
         self.calculate_node_centroids(down_factor)
-        try:
-            self.save_node_centroids(directory)
-        except:
-            pass
+        if directory is not None:
+            try:
+                self.save_node_centroids(directory)
+            except:
+                pass
         self.calculate_edge_centroids(down_factor)
-        try:
-            self.save_edge_centroids(directory)
-        except:
-            pass
+        if directory is not None:
+            try:
+                self.save_edge_centroids(directory)
+            except:
+                pass
 
 
     def draw_network(self, directory = None, down_factor = None, GPU = False):
@@ -4401,6 +4431,101 @@ class Network_3D:
         return neighborhood_dict, proportion_dict, title1, title2, densities
 
 
+    def get_ripley(self, root = None, targ = None, distance = 1, edgecorrect = True, bounds = None, ignore_dims = False, proportion = 0.5):
+
+
+        if root is None or targ is None: #Self clustering in this case
+            roots = self._node_centroids.values()
+            targs = self._node_centroids.values()
+        else:
+            roots = []
+            targs = []
+
+            for node, nodeid in self.node_identities.items(): #Otherwise we need to pull out this info
+                if nodeid == root:
+                    roots.append(self._node_centroids[node])
+                elif nodeid == targ:
+                    targs.append(self._node_centroids[node])
+        
+        rooties = proximity.convert_centroids_to_array(roots, xy_scale = self.xy_scale, z_scale = self.z_scale)
+        targs = proximity.convert_centroids_to_array(roots, xy_scale = self.xy_scale, z_scale = self.z_scale)
+        points_array = np.vstack((rooties, targs))
+        del rooties
+
+        try:
+            if self.nodes.shape[0] == 1:
+                dim = 2
+            else:
+                dim = 3
+        except:
+            dim = 2
+            for centroid in self.node_centroids.values():
+                if centroid[0] != 0:
+                    dim = 3
+                    break
+
+
+        if ignore_dims:
+
+            factor = 0.25
+
+
+            if bounds is None:
+                if dim == 2:
+                    min_coords = np.array([0,0])
+                else:
+                    min_coords = np.array([0,0,0])
+                max_coords = np.max(points_array, axis=0)
+                max_coords = np.flip(max_coords)
+                bounds = (min_coords, max_coords)
+            else:
+                min_coords, max_coords = bounds
+
+            dim_list = max_coords - min_coords
+
+            new_list = []
+
+
+            if dim == 3:
+                for centroid in roots:
+
+                    if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
+                        new_list.append(centroid)
+                        #print(f"dim_list: {dim_list}, centroid: {centroid}, min_coords: {min_coords}, max_coords: {max_coords}")
+            else:
+                for centroid in roots:
+
+                    if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor):
+                        new_list.append(centroid)
+
+            roots = new_list
+            print(f"Utilizing {len(roots)} root points. Note that low n values are unstable.")
+            is_subset = True
+        else:
+            is_subset = False
+
+
+
+
+        roots = proximity.convert_centroids_to_array(roots, xy_scale = self.xy_scale, z_scale = self.z_scale)
+
+
+        if dim == 2:
+            roots = proximity.convert_augmented_array_to_points(roots)
+            targs = proximity.convert_augmented_array_to_points(targs)
+
+        r_vals = proximity.generate_r_values(points_array, distance, bounds = bounds, dim = dim, max_proportion=proportion)
+
+        k_vals =  proximity.optimized_ripleys_k(roots, targs, r_vals, bounds=bounds, edge_correction=edgecorrect, dim = dim, is_subset = is_subset)
+
+        h_vals = proximity.compute_ripleys_h(k_vals, r_vals, dim)
+
+        proximity.plot_ripley_functions(r_vals, k_vals, h_vals, dim)
+
+        return r_vals, k_vals, h_vals
+
+
+
 
 #Morphological stats or network linking:
 
@@ -4460,6 +4585,87 @@ class Network_3D:
 
         return array
 
+
+
+    def random_nodes(self, bounds = None, mask = None):
+
+        if self.nodes is not None:
+            try:
+                self.nodes = np.zeros_like(self.nodes)
+            except:
+                pass
+
+
+        if mask is not None:
+            coords = np.argwhere(mask != 0)
+        else:
+            if bounds is not None:
+                (z1, y1, x1), (z2, y2, x2) = bounds
+                z1, y1, x1 = int(z1), int(y1), int(x1)
+                z2, y2, x2 = int(z2), int(y2), int(x2)
+                z_range = np.arange(z1, z2 + 1)
+                y_range = np.arange(y1, y2 + 1)
+                x_range = np.arange(x1, x2 + 1)
+                z_grid, y_grid, x_grid = np.meshgrid(z_range, y_range, x_range, indexing='ij')
+                del z_range
+                del y_range
+                del x_range
+                coords = np.stack([z_grid.flatten(), y_grid.flatten(), x_grid.flatten()], axis=1)
+                del z_grid
+                del y_grid
+                del x_grid
+            else:
+                shape = ()
+                try:
+                    shape = self.nodes.shape
+                except:
+                    try:
+                        shape = self.edges.shape
+                    except:
+                        try:
+                            shape = self._network_overlay.shape
+                        except:
+                            try:
+                                shape = self._id_overlay.shape
+                            except:
+                                pass
+
+                ranges = [np.arange(s) for s in shape]
+                
+                # Create meshgrid
+                mesh = np.meshgrid(*ranges, indexing='ij')
+                del ranges
+
+                # Stack and reshape
+                coords = np.stack(mesh, axis=-1).reshape(-1, len(shape))
+                del mesh
+
+        if len(coords) < len(self.node_centroids):
+            print(f"Warning: Only {len(coords)} positions available for {len(self.node_centroids)} labels")
+
+        new_centroids = {}
+        
+        # Generate random indices without replacement
+        available_count = min(len(coords), len(self.node_centroids))
+        rand_indices = np.random.choice(len(coords), available_count, replace=False)
+        
+        # Assign random positions to labels
+        for i, label in enumerate(self.node_centroids.keys()):
+            if i < len(rand_indices):
+                centroid = coords[rand_indices[i]]
+                new_centroids[label] = centroid
+                z, y, x = centroid
+                try:
+                    self.nodes[z, y, x] = label
+                except:
+                    pass
+        
+        # Update the centroids dictionary
+        self.node_centroids = new_centroids
+
+        return self.node_centroids, self._nodes
+
+
     def community_id_info(self):
         def invert_dict(d):
             inverted = {}
@@ -4506,11 +4712,28 @@ class Network_3D:
 
 
 
-    def kd_network(self, distance = 100, targets = None):
+    def kd_network(self, distance = 100, targets = None, make_array = False):
 
-        array = self.centroid_array()
+        centroids = copy.deepcopy(self._node_centroids)
+
+        if self._xy_scale == self._z_scale:
+            upsample = None
+            distance = distance/self._xy_scale # Account for scaling
+        else:
+            upsample = [self._xy_scale, self._z_scale] # This means resolutions have to be normalized
+            if self._xy_scale < self._z_scale:
+                distance = distance/self._xy_scale # We always upsample to normalize
+                refactor = self._z_scale/self._xy_scale
+                for node, centroid in centroids.items():
+                    centroids[node] = [centroid[0] * refactor, centroid[1], centroid[2]]
+            elif self._z_scale < self._xy_scale:
+                distance = distance/self._z_scale
+                refactor = self._xy_scale/self._z_scale
+                for node, centroid in centroids.items():
+                    centroids[node] = [centroid[0], centroid[1] * refactor, centroid[2] * refactor]
 
-        neighbors = proximity.find_neighbors_kdtree(array, distance, targets = targets)
+
+        neighbors = proximity.find_neighbors_kdtree(distance, targets = targets, centroids = centroids)
 
         network = create_and_save_dataframe(neighbors)
 
@@ -4520,7 +4743,11 @@ class Network_3D:
 
         self.remove_edge_weights()
 
-        return array
+        if make_array:
+
+            array = self.centroid_array()
+
+            return array