nettracer3d 0.6.9__tar.gz → 0.7.1__tar.gz

{nettracer3d-0.6.9/src/nettracer3d.egg-info → nettracer3d-0.7.1}/PKG-INFO

@@ -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.6.9 → nettracer3d-0.7.1}/README.md

@@ -34,12 +34,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.6.9 → nettracer3d-0.7.1}/pyproject.toml

@@ -1,33 +1,33 @@
 [project]
 name = "nettracer3d"
-version = "0.6.9"
+version = "0.7.1"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]
 description = "Scripts for intializing and analyzing networks from segmentations of three dimensional images."
 
 dependencies = [
-    "numpy == 1.26.4",
-    "scipy == 1.14.1",
-    "scikit-image == 0.25.0",
-    "Pillow == 11.1.0",
-    "matplotlib == 3.9.2",
-    "networkx == 3.2.1",
-    "opencv-python-headless == 4.10.0.84",
-    "openpyxl == 3.1.2",
-    "pandas == 2.2.0",
-    "napari == 0.5.5",
-    "python-louvain == 0.16",
-    "tifffile == 2023.7.18",
-    "qtrangeslider == 0.1.5",
-    "PyQt6 == 6.8.0",
-    "scikit-learn == 1.6.1",
-    "nibabel == 5.2.0",
-    "setuptools >= 65.0.0"
+    "numpy",
+    "scipy",
+    "scikit-image",
+    "Pillow",
+    "matplotlib",
+    "networkx",
+    "opencv-python-headless",
+    "openpyxl",
+    "pandas",
+    "napari",
+    "python-louvain",
+    "tifffile",
+    "qtrangeslider",
+    "PyQt6",
+    "scikit-learn",
+    "nibabel",
+    "setuptools"
 ]
 
 readme = "README.md"
-requires-python = "==3.11"
+requires-python = ">=3.7"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: Other/Proprietary License",

{nettracer3d-0.6.9 → nettracer3d-0.7.1}/src/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-0.6.9 → nettracer3d-0.7.1}/src/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-0.6.9 → nettracer3d-0.7.1}/src/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():