nettracer3d 0.6.9__py3-none-any.whl → 0.7.1__py3-none-any.whl

nettracer3d/morphology.py

@@ -518,6 +518,7 @@ 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, sampling = sampling)
@@ -533,6 +534,7 @@ 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, sampling = sampling)

nettracer3d/nettracer.py

@@ -4431,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:
 
@@ -4490,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 = {}

nettracer3d/nettracer_gui.py

@@ -1246,7 +1246,7 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
-            print(f"Found {len(filtered_df)} direct connections between nodes of ID {sort} and their neighbors (of any ID)")
+            #print(f"Found {len(filtered_df)} direct connections between nodes of ID {sort} and their neighbors (of any ID)")
 
             if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
                 self.mini_overlay = True
@@ -2687,8 +2687,8 @@ 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)
-        random_action = stats_menu.addAction("Generate Equivalent Random Network")
-        random_action.triggered.connect(self.show_random_dialog)
+        ripley_action = stats_menu.addAction("Clustering Analysis")
+        ripley_action.triggered.connect(self.show_ripley_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
         rad_action = stats_menu.addAction("Calculate Radii")
@@ -2707,6 +2707,13 @@ class ImageViewerWindow(QMainWindow):
         id_code_action = overlay_menu.addAction("Code Identities")
         id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
 
+        rand_menu = analysis_menu.addMenu("Randomize")
+        random_action = rand_menu.addAction("Generate Equivalent Random Network")
+        random_action.triggered.connect(self.show_random_dialog)
+        random_nodes = rand_menu.addAction("Scramble Nodes (Centroids)")
+        random_nodes.triggered.connect(self.show_randnode_dialog)
+
+
 
         # Process menu
         process_menu = menubar.addMenu("Process")
@@ -3501,8 +3508,8 @@ class ImageViewerWindow(QMainWindow):
                         nii_img = nib.load(filename)
                         # Get data and transpose to match TIFF orientation
                         # If X needs to become Z, we move axis 2 (X) to position 0 (Z)
-                        data = nii_img.get_fdata()
-                        self.channel_data[channel_index] = np.transpose(data, (2, 1, 0))
+                        arraydata = nii_img.get_fdata()
+                        self.channel_data[channel_index] = np.transpose(arraydata, (2, 1, 0))
                         
                     elif file_extension in ['jpg', 'jpeg', 'png']:
                         from PIL import Image
@@ -4157,10 +4164,18 @@ class ImageViewerWindow(QMainWindow):
         dialog = NeighborIdentityDialog(self)
         dialog.exec()
 
+    def show_ripley_dialog(self):
+        dialog = RipleyDialog(self)
+        dialog.exec()
+
     def show_random_dialog(self):
         dialog = RandomDialog(self)
         dialog.exec()
 
+    def show_randnode_dialog(self):
+        dialog = RandNodeDialog(self)
+        dialog.exec()
+
     def show_rad_dialog(self):
         dialog = RadDialog(self)
         dialog.exec()
@@ -5977,9 +5992,121 @@ class NeighborIdentityDialog(QDialog):
 
 
 
+class RipleyDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle(f"Find Ripley's H Function From Centroids")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        if my_network.node_identities is not None:
+            self.root = QComboBox()
+            self.root.addItems(list(set(my_network.node_identities.values())))  
+            self.root.setCurrentIndex(0)
+            layout.addRow("Root Identity to Search for Neighbors", self.root)
+        else:
+            self.root = None
+
+        if my_network.node_identities is not None:
+            self.targ = QComboBox()
+            self.targ.addItems(list(set(my_network.node_identities.values())))  
+            self.targ.setCurrentIndex(0)
+            layout.addRow("Targ Identity to be Searched For", self.targ)
+        else:
+            self.targ = None
+
+        self.distance = QLineEdit("5")
+        layout.addRow("Bucket Distance for Searching For Clusters (automatically scaled by xy and z scales):", self.distance)
+
+
+        self.proportion = QLineEdit("0.5")
+        layout.addRow("Proportion of image to search? (0-1, high vals increase border artifacts): ", self.proportion)
+
+        self.edgecorrect = QPushButton("Border Correction")
+        self.edgecorrect.setCheckable(True)
+        self.edgecorrect.setChecked(False)
+        layout.addRow("Use Border Correction (Extrapolate for points beyond the border):", self.edgecorrect)
+
+        self.ignore = QPushButton("Ignore Border Roots")
+        self.ignore.setCheckable(True)
+        self.ignore.setChecked(False)
+        layout.addRow("Exclude Root Nodes Near Borders?:", self.ignore)
+
+        # Add Run button
+        run_button = QPushButton("Get Ripley's H")
+        run_button.clicked.connect(self.ripley)
+        layout.addWidget(run_button)
+
+    def ripley(self):
+
+        try:
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+
+            try:
+                root = self.root.currentText()
+            except:
+                root = None
+
+            try:
+                targ = self.targ.currentText()
+            except:
+                targ = None
+
+            try:
+                distance = float(self.distance.text())
+            except:
+                return
+
+
+            try:
+                proportion = abs(float(self.proportion.text()))
+            except:
+                proportion = 0.5
+
+            if proportion > 1 or proportion <= 0:
+                print("Utilizing proportion = 0.5")
+                proportion = 0.5
+
+
+            edgecorrect = self.edgecorrect.isChecked()
+
+            ignore = self.ignore.isChecked()
+
+            if my_network.nodes is not None:
+
+                if my_network.nodes.shape[0] == 1:
+                    bounds = (np.array([0, 0]), np.array([my_network.nodes.shape[2], my_network.nodes.shape[1]]))
+                else:
+                    bounds = (np.array([0, 0, 0]), np.array([my_network.nodes.shape[2], my_network.nodes.shape[1], my_network.nodes.shape[0]]))
+            else:
+                bounds = None
+
+            r_vals, k_vals, h_vals = my_network.get_ripley(root, targ, distance, edgecorrect, bounds, ignore, proportion)
+            
+            k_dict = dict(zip(r_vals, k_vals))
+            h_dict = dict(zip(r_vals, h_vals))
+
+
+            self.parent().format_for_upperright_table(k_dict, metric='Radius (scaled)', value='L Value', title="Ripley's K")
+            self.parent().format_for_upperright_table(h_dict, metric='Radius (scaled)', value='L Normed', title="Ripley's H")
 
 
+            self.accept()
 
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error:",
+                f"Failed to preform cluster analysis: {str(e)}"
+            )
+            import traceback
+            print(traceback.format_exc())
+            print(f"Error: {e}")
 
 class RandomDialog(QDialog):
 
@@ -6019,6 +6146,79 @@ class RandomDialog(QDialog):
 
         self.accept()
 
+class RandNodeDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Random Node Parameters")
+        self.setModal(True)
+        layout = QFormLayout(self)
+
+
+        self.mode = QComboBox()
+        self.mode.addItems(["Anywhere", "Within Dimensional Bounds of Nodes", "Within Masked Bounds of Edges", "Within Masked Bounds of Overlay1", "Within Masked Bounds of Overlay2"])
+        self.mode.setCurrentIndex(0)
+        layout.addRow("Mode", self.mode)
+
+        # Add Run button
+        run_button = QPushButton("Get Random Nodes (Will go in Nodes)")
+        run_button.clicked.connect(self.random)
+        layout.addWidget(run_button)
+
+    def random(self):
+
+        try:
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+
+            bounds = None
+            mask = None
+
+            mode = self.mode.currentIndex()
+
+            if mode == 0 and not (my_network.nodes is None and my_network.edges is None and my_network.network_overlay is None and my_network.id_overlay is None):
+                pass
+            elif mode == 1 or (my_network.nodes is None and my_network.edges is None and my_network.network_overlay is None and my_network.id_overlay is None):
+                print("HELLO")
+                # Convert string labels to integers if necessary
+                if any(isinstance(k, str) for k in my_network.node_centroids.keys()):
+                    label_map = {label: idx for idx, label in enumerate(my_network.node_centroids.keys())}
+                    my_network.node_centroids = {label_map[k]: v for k, v in my_network.node_centroids.items()}
+                
+                # Convert centroids to array and keep track of labels
+                labels = np.array(list(my_network.node_centroids.keys()), dtype=np.uint32)
+                centroid_points = np.array([my_network.node_centroids[label] for label in labels])
+                
+                # Calculate shape if not provided
+                max_coords = centroid_points.max(axis=0)
+                max_shape = tuple(max_coord + 1 for max_coord in max_coords)
+                min_coords = centroid_points.min(axis=0)
+                min_shape = tuple(min_coord + 1 for min_coord in min_coords)
+                bounds = (min_shape, max_shape)
+            else:
+                mask = n3d.binarize(self.parent().channel_data[mode - 1])
+
+            centroids, array = my_network.random_nodes(bounds = bounds, mask = mask)
+
+            if my_network.nodes is not None:
+                try:
+                    self.parent().load_channel(0, array, data = True)
+                except:
+                    pass
+
+            self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error:",
+                f"Failed to randomize: {str(e)}"
+            )
+            print(f"Error: {e}")
+
+
 class RadDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -7208,8 +7408,14 @@ class MachineWindow(QMainWindow):
         train_quick.clicked.connect(lambda: self.train_model(speed=True))
         train_detailed = QPushButton("Train More Detailed Model")
         train_detailed.clicked.connect(lambda: self.train_model(speed=False))
+        save = QPushButton("Save Model")
+        save.clicked.connect(self.save_model)
+        load = QPushButton("Load Model")
+        load.clicked.connect(self.load_model)
         training_layout.addWidget(train_quick)
         training_layout.addWidget(train_detailed)
+        training_layout.addWidget(save)
+        training_layout.addWidget(load)
         training_group.setLayout(training_layout)
 
         # Group 4: Segmentation Options
@@ -7280,6 +7486,33 @@ class MachineWindow(QMainWindow):
             except:
                 pass
 
+    def save_model(self):
+
+        filename, _ = QFileDialog.getSaveFileName(
+            self,
+            f"Save Model As",
+            "",  # Default directory
+            "numpy data (*.npz);;All Files (*)"  # File type filter
+        )
+        
+        if filename:  # Only proceed if user didn't cancel
+            # If user didn't type an extension, add .tif
+            if not filename.endswith(('.npz')):
+                filename += '.npz'
+
+        self.segmenter.save_model(filename, self.parent().channel_data[2])
+
+    def load_model(self):
+
+        filename, _ = QFileDialog.getOpenFileName(
+            self,
+            f"Load Model",
+            "",
+            "numpy data (*.npz)"
+        )
+
+        self.segmenter.load_model(filename)
+        self.trained = True
 
     def toggle_two(self):
         if self.two.isChecked():

nettracer3d/proximity.py

@@ -7,6 +7,7 @@ from scipy import ndimage
 import concurrent.futures
 import multiprocessing as mp
 import pandas as pd
+import matplotlib.pyplot as plt
 from typing import Dict, Union, Tuple, List, Optional
 
 
@@ -288,7 +289,6 @@ def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, i
     Returns:
         3D numpy array where each cell contains the label of the closest centroid as uint32
     """
-    from scipy.spatial import cKDTree
     
     # Convert string labels to integers if necessary
     if any(isinstance(k, str) for k in centroids.keys()):
@@ -305,7 +305,7 @@ def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, i
         shape = tuple(max_coord + 1 for max_coord in max_coords)
     
     # Create KD-tree
-    tree = cKDTree(centroid_points)
+    tree = KDTree(centroid_points)
     
     # Create coordinate arrays
     coords = np.array(np.meshgrid(
@@ -322,4 +322,328 @@ def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, i
     label_array = labels[indices].astype(np.uint32)
     
     # Reshape to final shape
-    return label_array.reshape(shape)
+    return label_array.reshape(shape)
+
+
+
+#Ripley cluster analysis:
+
+def convert_centroids_to_array(centroids_list, xy_scale = 1, z_scale = 1):
+    """
+    Convert a dictionary of centroids to a numpy array suitable for Ripley's K calculation.
+    
+    Parameters:
+    centroids_list: List of centroid coordinate arrays
+    
+    Returns:
+    numpy array of shape (n, d) where n is number of points and d is dimensionality
+    """
+    # Determine how many centroids we have
+    n_points = len(centroids_list)
+    
+    # Get dimensionality from the first centroid
+    dim = len(list(centroids_list)[0])
+    
+    # Create empty array
+    points_array = np.zeros((n_points, dim))
+    
+    # Fill array with coordinates
+    for i, coords in enumerate(centroids_list):
+        points_array[i] = coords
+
+    points_array[:, 1:] = points_array[:, 1:] * xy_scale #account for scaling
+
+    points_array[:, 0] = points_array[:, 0] * z_scale #account for scaling
+        
+    return points_array
+
+def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_proportion=0.5):
+    """
+    Generate an array of r values based on point distribution and step size.
+    
+    Parameters:
+    points_array: numpy array of shape (n, d) with point coordinates
+    step_size: user-defined step size for r values
+    max_proportion: maximum proportion of the study area extent to use (default 0.5)
+                   This prevents analyzing at distances where edge effects dominate
+    
+    Returns:
+    numpy array of r values
+    """
+
+    if bounds is None:
+        if dim == 2:
+            min_coords = np.array([0,0])
+        else:
+            min_coords = np.array([0,0,0])
+        max_coords = np.max(points_array, axis=0)
+        max_coords = np.flip(max_coords)
+    else:
+        min_coords, max_coords = bounds
+
+    
+    # Calculate the longest dimension
+    dimensions = max_coords - min_coords
+    max_dimension = np.max(dimensions)
+    
+    # Calculate maximum r value (typically half the shortest side for 2D,
+    # or scaled by max_proportion for general use)
+    max_r = max_dimension * max_proportion
+    
+    # Generate r values from 0 to max_r with step_size increments
+    num_steps = int(max_r / step_size)
+    r_values = np.linspace(step_size, max_r, num_steps)
+
+    if r_values[0] == 0:
+        np.delete(r_values, 0)
+    
+    return r_values
+
+def convert_augmented_array_to_points(augmented_array):
+    """
+    Convert an array where first column is 1 and remaining columns are coordinates.
+    
+    Parameters:
+    augmented_array: 2D array where first column is 1 and rest are coordinates
+    
+    Returns:
+    numpy array with just the coordinate columns
+    """
+    # Extract just the coordinate columns (all except first column)
+    return augmented_array[:, 1:]
+
+def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None, edge_correction=True, dim = 2, is_subset = False):
+    """
+    Optimized computation of Ripley's K function using KD-Tree with simplified but effective edge correction.
+    
+    Parameters:
+    reference_points: numpy array of shape (n, d) containing coordinates (d=2 or d=3)
+    subset_points: numpy array of shape (m, d) containing coordinates
+    r_values: numpy array of distances at which to compute K
+    bounds: tuple of (min_coords, max_coords) defining the study area boundaries
+    edge_correction: Boolean indicating whether to apply edge correction
+    
+    Returns:
+    K_values: numpy array of K values corresponding to r_values
+    """
+    n_ref = len(reference_points)
+    n_subset = len(subset_points)
+    
+    # Determine bounds if not provided
+    if bounds is None:
+        min_coords = np.min(reference_points, axis=0)
+        max_coords = np.max(reference_points, axis=0)
+        bounds = (min_coords, max_coords)
+    
+    # Calculate volume of study area
+    min_bounds, max_bounds = bounds
+    sides = max_bounds - min_bounds
+    volume = np.prod(sides)
+    
+    # Point intensity (points per unit volume)
+    intensity = n_ref / volume
+    
+    # Build KD-Tree for efficient nearest neighbor search
+    tree = KDTree(reference_points)
+    
+    # Initialize K values
+    K_values = np.zeros(len(r_values))
+    
+    # For each r value, compute cumulative counts
+    for i, r in enumerate(r_values):
+        total_count = 0
+        
+        # Query the tree for all points within radius r of each subset point
+        for j, point in enumerate(subset_points):
+            # Find all reference points within radius r
+            indices = tree.query_ball_point(point, r)
+            count = len(indices)
+            
+            # Apply edge correction if needed
+            if edge_correction:
+                # Calculate edge correction weight
+                weight = 1.0
+                
+                if dim == 2:
+                    # For 2D - check all four boundaries
+                    x, y = point
+                    
+                    # Distances to all boundaries
+                    x_min_dist = x - min_bounds[0]
+                    x_max_dist = max_bounds[0] - x
+                    y_min_dist = y - min_bounds[1]
+                    y_max_dist = max_bounds[1] - y
+                    
+                    proportion_in = 1.0
+                    # Apply correction for each boundary if needed
+                    if x_min_dist < r:
+                        proportion_in -= 0.5 * (1 - x_min_dist/r)
+                    if x_max_dist < r:
+                        proportion_in -= 0.5 * (1 - x_max_dist/r)
+                    if y_min_dist < r:
+                        proportion_in -= 0.5 * (1 - y_min_dist/r)
+                    if y_max_dist < r:
+                        proportion_in -= 0.5 * (1 - y_max_dist/r)
+                    
+                    # Corner correction
+                    if ((x_min_dist < r and y_min_dist < r) or 
+                        (x_min_dist < r and y_max_dist < r) or
+                        (x_max_dist < r and y_min_dist < r) or
+                        (x_max_dist < r and y_max_dist < r)):
+                        proportion_in += 0.1  # Add a small boost for corners
+                    
+                elif dim == 3:
+                    # For 3D - check all six boundaries
+                    x, y, z = point
+                    
+                    # Distances to all boundaries
+                    x_min_dist = x - min_bounds[0]
+                    x_max_dist = max_bounds[0] - x
+                    y_min_dist = y - min_bounds[1]
+                    y_max_dist = max_bounds[1] - y
+                    z_min_dist = z - min_bounds[2]
+                    z_max_dist = max_bounds[2] - z
+                    
+                    proportion_in = 1.0
+                    # Apply correction for each boundary if needed
+                    if x_min_dist < r:
+                        proportion_in -= 0.25 * (1 - x_min_dist/r)
+                    if x_max_dist < r:
+                        proportion_in -= 0.25 * (1 - x_max_dist/r)
+                    if y_min_dist < r:
+                        proportion_in -= 0.25 * (1 - y_min_dist/r)
+                    if y_max_dist < r:
+                        proportion_in -= 0.25 * (1 - y_max_dist/r)
+                    if z_min_dist < r:
+                        proportion_in -= 0.25 * (1 - z_min_dist/r)
+                    if z_max_dist < r:
+                        proportion_in -= 0.25 * (1 - z_max_dist/r)
+                    
+                    # Corner correction for 3D (if point is near a corner)
+                    num_close_edges = (
+                        (x_min_dist < r) + (x_max_dist < r) +
+                        (y_min_dist < r) + (y_max_dist < r) +
+                        (z_min_dist < r) + (z_max_dist < r)
+                    )
+                    if num_close_edges >= 2:
+                        proportion_in += 0.05 * num_close_edges  # Stronger boost for more edges
+                
+                # Ensure proportion_in stays within reasonable bounds
+                proportion_in = max(0.1, min(1.0, proportion_in))
+                weight = 1.0 / proportion_in
+                
+                count *= weight
+            
+            total_count += count
+        
+        # Subtract self-counts if points appear in both sets
+        if is_subset or np.array_equal(reference_points, subset_points):
+            total_count -= n_ref  # Subtract all self-counts
+        
+        # Normalize
+        K_values[i] = total_count / (n_subset * intensity)
+    
+    return K_values
+
+def ripleys_h_function_3d(k_values, r_values):
+    """
+    Convert K values to H values for 3D point patterns with edge correction.
+    
+    Parameters:
+    k_values: numpy array of K function values
+    r_values: numpy array of distances at which K was computed
+    edge_weights: optional array of edge correction weights
+    
+    Returns:
+    h_values: numpy array of H function values
+    """
+    h_values = np.cbrt(k_values / (4/3 * np.pi)) - r_values
+    
+    return h_values
+
+def ripleys_h_function_2d(k_values, r_values):
+    """
+    Convert K values to H values for 2D point patterns with edge correction.
+    
+    Parameters:
+    k_values: numpy array of K function values
+    r_values: numpy array of distances at which K was computed
+    edge_weights: optional array of edge correction weights
+    
+    Returns:
+    h_values: numpy array of H function values
+    """
+    h_values = np.sqrt(k_values / np.pi) - r_values
+    
+    return h_values
+
+def compute_ripleys_h(k_values, r_values, dimension=2):
+    """
+    Compute Ripley's H function (normalized K) with edge correction.
+    
+    Parameters:
+    k_values: numpy array of K function values
+    r_values: numpy array of distances at which K was computed
+    edge_weights: optional array of edge correction weights
+    dimension: dimensionality of the point pattern (2 for 2D, 3 for 3D)
+    
+    Returns:
+    h_values: numpy array of H function values
+    """
+    if dimension == 2:
+        return ripleys_h_function_2d(k_values, r_values)
+    elif dimension == 3:
+        return ripleys_h_function_3d(k_values, r_values)
+    else:
+        raise ValueError("Dimension must be 2 or 3")
+
+def plot_ripley_functions(r_values, k_values, h_values, dimension=2, figsize=(12, 5)):
+    """
+    Plot Ripley's K and H functions with theoretical Poisson distribution references
+    adjusted for edge effects.
+    
+    Parameters:
+    r_values: numpy array of distances at which K and H were computed
+    k_values: numpy array of K function values
+    h_values: numpy array of H function values (normalized K)
+    edge_weights: optional array of edge correction weights
+    dimension: dimensionality of the point pattern (2 for 2D, 3 for 3D)
+    figsize: tuple specifying figure size (width, height)
+    """
+
+    #plt.figure()
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+    
+    # Theoretical values for complete spatial randomness (CSR)
+    if dimension == 2:
+        theo_k = np.pi * r_values**2  # πr² for 2D
+    elif dimension == 3:
+        theo_k = (4/3) * np.pi * r_values**3  # (4/3)πr³ for 3D
+    else:
+        raise ValueError("Dimension must be 2 or 3")
+    
+    # Theoretical H values are always 0 for CSR
+    theo_h = np.zeros_like(r_values)
+    
+    # Plot K function
+    ax1.plot(r_values, k_values, 'b-', label='Observed K(r)')
+    ax1.plot(r_values, theo_k, 'r--', label='Theoretical K(r) for CSR')
+    ax1.set_xlabel('Distance (r)')
+    ax1.set_ylabel('L(r)')
+    ax1.set_title("Ripley's K Function")
+    ax1.legend()
+    ax1.grid(True, alpha=0.3)
+    
+    # Plot H function
+    ax2.plot(r_values, h_values, 'b-', label='Observed H(r)')
+    ax2.plot(r_values, theo_h, 'r--', label='Theoretical H(r) for CSR')
+    ax2.set_xlabel('Distance (r)')
+    ax2.set_ylabel('L(r) Normalized')
+    ax2.set_title("Ripley's H Function")
+    ax2.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+    ax2.legend()
+    ax2.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    plt.show()
+    #plt.clf()

nettracer3d/segmenter.py

@@ -75,6 +75,12 @@ class InteractiveSegmenter:
         self.dogs = [(1, 2), (2, 4), (4, 8)]
         self.master_chunk = 49
 
+        #Data when loading prev model:
+        self.previous_foreground = None
+        self.previous_background = None
+        self.previous_z_fore = None
+        self.previous_z_back = None
+
     def segment_slice_chunked(self, slice_z, block_size = 49):
         """
         A completely standalone method to segment a single z-slice in chunks
@@ -1757,10 +1763,11 @@ class InteractiveSegmenter:
             except:
                 pass
 
-    def train_batch(self, foreground_array, speed = True, use_gpu = False, use_two = False, mem_lock = False):
+    def train_batch(self, foreground_array, speed = True, use_gpu = False, use_two = False, mem_lock = False, saving = False):
         """Train directly on foreground and background arrays"""
 
-        print("Training model...")
+        if not saving:
+            print("Training model...")
         self.speed = speed
         self.cur_gpu = use_gpu
         if mem_lock != self.mem_lock:
@@ -1969,12 +1976,40 @@ class InteractiveSegmenter:
                 z_back, y_back, x_back = np.where(foreground_array == 2)
                 background_features = self.feature_cache[z_back, y_back, x_back]
             except:
-                print("Features maps computed, but no segmentation examples were provided so the model was not trained")
+                pass
+
+
+        if self.previous_foreground is not None:
+            failed = True
+            try:
+                foreground_features = np.vstack([self.previous_foreground, foreground_features])
+                failed = False
+            except:
+                pass
+            try:
+                background_features = np.vstack([self.previous_background, background_features])
+                failed = False
+            except:
+                pass
+            try:
+                z_fore = np.concatenate([self.previous_z_fore, z_fore])
+            except:
+                pass
+            try:
+                z_back = np.concatenate([self.previous_z_back, z_back])
+            except:
+                pass
+            if failed:
+                print("Could not combine new model with old loaded model. Perhaps you are trying to combine a quick model with a deep model? I cannot combine these...")
+
+        if saving:
 
+            return foreground_features, background_features, z_fore, z_back
 
         # Combine features and labels
         X = np.vstack([foreground_features, background_features])
         y = np.hstack([np.ones(len(z_fore)), np.zeros(len(z_back))])
+
         
         # Train the model
         try:
@@ -1988,6 +2023,54 @@ class InteractiveSegmenter:
 
 
 
+        print("Done")
+
+
+    def save_model(self, file_name, foreground_array):
+
+        print("Saving model data")
+
+        foreground_features, background_features, z_fore, z_back = self.train_batch(foreground_array, speed = self.speed, use_gpu = self.use_gpu, use_two = self.use_two, mem_lock = self.mem_lock, saving = True)
+
+
+        np.savez(file_name, 
+                 foreground_features=foreground_features,
+                 background_features=background_features,
+                 z_fore=z_fore,
+                 z_back=z_back,
+                 speed=self.speed,
+                 use_gpu=self.use_gpu,
+                 use_two=self.use_two,
+                 mem_lock=self.mem_lock)
+
+        print(f"Model data saved to {file_name}")
+
+
+    def load_model(self, file_name):
+
+        print("Loading model data")
+
+        data = np.load(file_name)
+
+        # Unpack the arrays
+        self.previous_foreground = data['foreground_features']
+        self.previous_background = data['background_features']
+        self.previous_z_fore = data['z_fore']
+        self.previous_z_back = data['z_back']
+        self.speed = bool(data['speed'])
+        self.use_gpu = bool(data['use_gpu'])
+        self.use_two = bool(data['use_two'])
+        self.mem_lock = bool(data['mem_lock'])
+
+        X = np.vstack([self.previous_foreground, self.previous_background])
+        y = np.hstack([np.ones(len(self.previous_z_fore)), np.zeros(len(self.previous_z_back))])
+
+        try:
+            self.model.fit(X, y)
+        except:
+            print(X)
+            print(y)
+
         print("Done")
 
     def get_feature_map_slice(self, z, speed, use_gpu):

nettracer3d/smart_dilate.py

@@ -188,9 +188,6 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = Fa
     Returns:
     Dilated 3D array
     """
-    if array.shape[0] == 1:
-
-        return nettracer.dilate_2D(array, search_distance, scaling = xy_scaling)
 
     # Determine which dimension needs resampling. the moral of the story is read documentation before you do something unecessary.
     """
@@ -235,7 +232,6 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, GPU = Fa
     # Threshold the distance transform to get dilated result
     inv = inv <= search_distance
 
-
     return inv.astype(np.uint8), indices, array
 
 
@@ -475,6 +471,7 @@ def compute_distance_transform_GPU(nodes, return_dists = False, sampling = [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]
     
     # Convert numpy array to CuPy array
     nodes_cp = cp.asarray(nodes)
@@ -507,6 +504,7 @@ def compute_distance_transform(nodes, return_dists = False, 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]
 
     dists, nearest_label_indices = distance_transform_edt(nodes, return_indices=True, sampling = sampling)
 
@@ -533,6 +531,7 @@ def compute_distance_transform_distance_GPU(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]
 
     # Convert numpy array to CuPy array
     nodes_cp = cp.asarray(nodes)
@@ -554,6 +553,7 @@ 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 = distance_transform_edt(nodes, sampling = sampling)

{nettracer3d-0.6.9.dist-info → nettracer3d-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.6.9
+Version: 0.7.1
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -9,26 +9,26 @@ Project-URL: Reference_Citation_For_Use, https://doi.org/10.1101/2024.07.29.6056
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
-Requires-Python: ==3.11
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy==1.26.4
-Requires-Dist: scipy==1.14.1
-Requires-Dist: scikit-image==0.25.0
-Requires-Dist: Pillow==11.1.0
-Requires-Dist: matplotlib==3.9.2
-Requires-Dist: networkx==3.2.1
-Requires-Dist: opencv-python-headless==4.10.0.84
-Requires-Dist: openpyxl==3.1.2
-Requires-Dist: pandas==2.2.0
-Requires-Dist: napari==0.5.5
-Requires-Dist: python-louvain==0.16
-Requires-Dist: tifffile==2023.7.18
-Requires-Dist: qtrangeslider==0.1.5
-Requires-Dist: PyQt6==6.8.0
-Requires-Dist: scikit-learn==1.6.1
-Requires-Dist: nibabel==5.2.0
-Requires-Dist: setuptools>=65.0.0
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: Pillow
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: opencv-python-headless
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: napari
+Requires-Dist: python-louvain
+Requires-Dist: tifffile
+Requires-Dist: qtrangeslider
+Requires-Dist: PyQt6
+Requires-Dist: scikit-learn
+Requires-Dist: nibabel
+Requires-Dist: setuptools
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -73,12 +73,14 @@ 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.6.9 updates --
+-- Version 0.7.0 Updates -- 
 
-1. Adjusted all distance transform-based dilation/radius calculating methods to simply use the already supported scipy.ndimage.distance_transform_edt() sampling parameter to account for differentially scaled axis (previously the image was being resampled but now it no longer will need to do that).
+1. Added new function in 'Analyze -> Stats -> Cluster Analysis'
+    * This function allows the user to create a ripley's K or H function to compare the relative clustering of two types of nodes, or of one type of node vs itself.
 
-2. Added new right click option to extract highlighted regions and implant their data onto a separate image or into a new empty image.
+2. Added new function in 'Analyze -> Randomize -> Scramble Nodes'
+    * This function randomly rearranges the node (centroids) for comparison with other centroid-using methods, as a possible way to demonstrate non-random behavior.
+    * The randomize menu is likewise new and the 'Generate Equivalent Random Network' method was moved there.
 
-3. General bug fixes and improvements.
-
-4. Now specifies python 3.11. 
+3. Bug fixes.
+    * Importantly fixed a bug with dt-based dilation not working in 2D, which I had accidentally introduced recently.

nettracer3d-0.7.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/community_extractor.py,sha256=5v9SCCLX3P1RX0fjPVKH5NHMFkMolZ5BTe0bR_a67xg,24479
+nettracer3d/modularity.py,sha256=FH3GpTHorRNkdQULe-2DWgFE3i0_u__hrao7Nx_6Ge4,30249
+nettracer3d/morphology.py,sha256=kEzuzBxHHpWt3o_LHMXYJGJT8-Z_dEP99QpZjOkavzE,19742
+nettracer3d/nettracer.py,sha256=dnnWEr9xpzoxV-NqLJm4DAFmZJ25CSjhA85AR_LT8Qc,218452
+nettracer3d/nettracer_gui.py,sha256=jeqsjaLGdaXdPcuy3Z3iEVnaOvyGDTEjD8uVkoNPFtk,426501
+nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
+nettracer3d/proximity.py,sha256=2Fj1UTKDEFBf7r1SgWXhiSINOTMjP4G5_Egu58l2zTk,24756
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=gJS2AXqHhnw29cbzIxAah2LsrE7_7XnzG7mYSAovZ4I,87847
+nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
+nettracer3d/smart_dilate.py,sha256=MNFz-7P56OFwkNx2N24SH4gV0kL3KwzmZvAxg-T7f3U,25781
+nettracer3d-0.7.1.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.7.1.dist-info/METADATA,sha256=-RaYqwgIm9jxvt5ihvTLlhR-TMlS2YH38SAUHvQWxUA,4823
+nettracer3d-0.7.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+nettracer3d-0.7.1.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.7.1.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.7.1.dist-info/RECORD,,

{nettracer3d-0.6.9.dist-info → nettracer3d-0.7.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nettracer3d-0.6.9.dist-info/RECORD

@@ -1,20 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=5v9SCCLX3P1RX0fjPVKH5NHMFkMolZ5BTe0bR_a67xg,24479
-nettracer3d/modularity.py,sha256=FH3GpTHorRNkdQULe-2DWgFE3i0_u__hrao7Nx_6Ge4,30249
-nettracer3d/morphology.py,sha256=y6OXLvyRmIBFpF3snC7ZirOW3Hg9jsHE11wbe0HrzQM,19692
-nettracer3d/nettracer.py,sha256=muv5Z33KOLKzzzbnNLDad_z1LYCKbuQUuKQLFQ0HAPY,211734
-nettracer3d/nettracer_gui.py,sha256=UCls6Z8O3SaXJUyxzdJlPDxIug7w290VbrojSWQDKs8,417722
-nettracer3d/network_analysis.py,sha256=q1q7lxtA3lebxitfC_jfiT9cnpYXJw4q0Oy2_-Aj8qE,48068
-nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
-nettracer3d/proximity.py,sha256=-HoJseoD2O2Q1eLDBMMmM_UYPqM1vZg7bpG4_9Ime-o,12516
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=GnQTVisQUKhackgjFxoldMlbArHEwHGiZPwv-sgPTj0,85072
-nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=SKm5OSu7jcnA7eUKz58_LscadV-lCvY2ZzdVzCvTmkY,25796
-nettracer3d-0.6.9.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.6.9.dist-info/METADATA,sha256=5JFlDK6cwwRKV25onj8KGX6ylD4vFXMaoZM1lzZCGaw,4755
-nettracer3d-0.6.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nettracer3d-0.6.9.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.6.9.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.6.9.dist-info/RECORD,,