nettracer3d 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

nettracer3d/proximity.py

@@ -89,9 +89,11 @@ def process_label(args):
     nodes, label, dilate_xy, dilate_z, array_shape = args
     print(f"Processing node {label}")
     indices = np.argwhere(nodes == label)
+    if len(indices) == 0:
+        return None, None
     z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
     if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
-        return None, None, None
+        return None, None
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     return label, sub_nodes
 

nettracer3d/segmenter.py

@@ -0,0 +1,290 @@
+from sklearn.ensemble import RandomForestClassifier
+import numpy as np
+import cupy as cp
+import torch
+from concurrent.futures import ThreadPoolExecutor
+import threading
+import cupyx.scipy.ndimage as cpx
+
+
+class InteractiveSegmenter:
+    def __init__(self, image_3d, use_gpu=True):
+        self.image_3d = image_3d
+        self.patterns = []
+
+        self.use_gpu = use_gpu and cp.cuda.is_available()
+        if self.use_gpu:
+            print(f"Using GPU: {torch.cuda.get_device_name()}")
+            self.image_gpu = cp.asarray(image_3d)
+        
+        self.model = RandomForestClassifier(
+            n_estimators=100,
+            n_jobs=-1,
+            max_depth=None
+        )
+        self.feature_cache = None
+        self.lock = threading.Lock()
+
+    def compute_feature_maps(self):
+        """Compute all feature maps using GPU acceleration"""
+        if not self.use_gpu:
+            return super().compute_feature_maps()
+        
+        features = []
+        image = self.image_gpu
+        original_shape = self.image_3d.shape
+        
+        # Gaussian smoothing at different scales
+        print("Obtaining gaussians")
+        for sigma in [0.5, 1.0, 2.0, 4.0]:
+            smooth = cp.asnumpy(self.gaussian_filter_gpu(image, sigma))
+            features.append(smooth)
+        
+        print("Obtaining dif of gaussians")
+
+        # Difference of Gaussians
+        for (s1, s2) in [(1, 2), (2, 4)]:
+            g1 = self.gaussian_filter_gpu(image, s1)
+            g2 = self.gaussian_filter_gpu(image, s2)
+            dog = cp.asnumpy(g1 - g2)
+            features.append(dog)
+        
+        # Convert image to PyTorch tensor for gradient operations
+        image_torch = torch.from_numpy(self.image_3d).cuda()
+        image_torch = image_torch.float().unsqueeze(0).unsqueeze(0)
+        
+        # Calculate required padding
+        kernel_size = 3
+        padding = kernel_size // 2
+        
+        # Create a single padded version with same padding
+        pad = torch.nn.functional.pad(image_torch, (padding, padding, padding, padding, padding, padding), mode='replicate')
+        
+        print("Computing sobel kernels")
+
+        # Create sobel kernels
+        sobel_x = torch.tensor([-1, 0, 1], device='cuda').float().view(1,1,1,1,3)
+        sobel_y = torch.tensor([-1, 0, 1], device='cuda').float().view(1,1,1,3,1)
+        sobel_z = torch.tensor([-1, 0, 1], device='cuda').float().view(1,1,3,1,1)
+        
+        # Compute gradients
+        print("Computing gradiants")
+
+        gx = torch.nn.functional.conv3d(pad, sobel_x, padding=0)[:,:,:original_shape[0],:original_shape[1],:original_shape[2]]
+        gy = torch.nn.functional.conv3d(pad, sobel_y, padding=0)[:,:,:original_shape[0],:original_shape[1],:original_shape[2]]
+        gz = torch.nn.functional.conv3d(pad, sobel_z, padding=0)[:,:,:original_shape[0],:original_shape[1],:original_shape[2]]
+        
+        # Compute gradient magnitude
+        print("Computing gradiant mags")
+
+        gradient_magnitude = torch.sqrt(gx**2 + gy**2 + gz**2)
+        gradient_feature = gradient_magnitude.cpu().numpy().squeeze()
+        
+        features.append(gradient_feature)
+        
+        # Verify shapes
+        for i, feat in enumerate(features):
+            if feat.shape != original_shape:
+                raise ValueError(f"Feature {i} has shape {feat.shape}, expected {original_shape}")
+        
+        return np.stack(features, axis=-1)
+
+    def gaussian_filter_gpu(self, image, sigma):
+        """GPU-accelerated Gaussian filter"""
+        # Create Gaussian kernel
+        result = cpx.gaussian_filter(image, sigma=sigma)
+
+        return result
+
+
+    def train(self):
+        """Train random forest on accumulated patterns"""
+        if len(self.patterns) < 2:
+            return
+        
+        X = []
+        y = []
+        for pattern in self.patterns:
+            X.extend(pattern['features'])
+            y.extend([pattern['is_foreground']] * len(pattern['features']))
+        
+        X = np.array(X)
+        y = np.array(y)
+        self.model.fit(X, y)
+        self.patterns = []
+
+    def process_chunk(self, chunk_coords):
+        """Process a chunk of coordinates"""
+        features = [self.feature_cache[z, y, x] for z, y, x in chunk_coords]
+        predictions = self.model.predict(features)
+        
+        foreground = set()
+        background = set()
+        for coord, pred in zip(chunk_coords, predictions):
+            if pred:
+                foreground.add(coord)
+            else:
+                background.add(coord)
+        
+        return foreground, background
+
+    def segment_volume(self, chunk_size=32):
+        """Segment volume using parallel processing of chunks"""
+        if self.feature_cache is None:
+            with self.lock:
+                if self.feature_cache is None:
+                    self.feature_cache = self.compute_feature_maps()
+        
+        # Create chunks of coordinates
+        chunks = []
+        for z in range(0, self.image_3d.shape[0], chunk_size):
+            for y in range(0, self.image_3d.shape[1], chunk_size):
+                for x in range(0, self.image_3d.shape[2], chunk_size):
+                    chunk_coords = [
+                        (zz, yy, xx) 
+                        for zz in range(z, min(z + chunk_size, self.image_3d.shape[0]))
+                        for yy in range(y, min(y + chunk_size, self.image_3d.shape[1]))
+                        for xx in range(x, min(x + chunk_size, self.image_3d.shape[2]))
+                    ]
+                    chunks.append(chunk_coords)
+        
+        foreground_coords = set()
+        background_coords = set()
+        
+        # Process chunks in parallel
+        with ThreadPoolExecutor() as executor:
+            futures = [executor.submit(self.process_chunk, chunk) for chunk in chunks]
+            
+            for i, future in enumerate(futures):
+                fore, back = future.result()
+                foreground_coords.update(fore)
+                background_coords.update(back)
+                if i % 10 == 0:
+                    print(f"Processed {i}/{len(chunks)} chunks")
+        
+        return foreground_coords, background_coords
+
+    def cleanup(self):
+        """Clean up GPU memory"""
+        if self.use_gpu:
+            cp.get_default_memory_pool().free_all_blocks()
+            torch.cuda.empty_cache()
+
+    def train_batch(self, foreground_array, background_array):
+        """Train directly on foreground and background arrays"""
+        if self.feature_cache is None:
+            with self.lock:
+                if self.feature_cache is None:
+                    self.feature_cache = self.compute_feature_maps()
+        
+        # Get foreground coordinates and features
+        z_fore, y_fore, x_fore = np.where(foreground_array > 0)
+        foreground_features = self.feature_cache[z_fore, y_fore, x_fore]
+        
+        # Get background coordinates and features
+        z_back, y_back, x_back = np.where(background_array > 0)
+        background_features = self.feature_cache[z_back, y_back, x_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
+        self.model.fit(X, y)
+
+        print("Done")
+
+
+
+
+
+
+
+
+
+        def segment_volume_subprocess(self, chunk_size=32, current_z=None, current_x=None, current_y=None):
+            """
+            Segment volume prioritizing chunks near user location.
+            Returns chunks as they're processed.
+            """
+            if self.feature_cache is None:
+                with self.lock:
+                    if self.feature_cache is None:
+                        self.feature_cache = self.compute_feature_maps()
+            
+            # Create chunks with position information
+            chunks_info = []
+            for z in range(0, self.image_3d.shape[0], chunk_size):
+                for y in range(0, self.image_3d.shape[1], chunk_size):
+                    for x in range(0, self.image_3d.shape[2], chunk_size):
+                        chunk_coords = [
+                            (zz, yy, xx) 
+                            for zz in range(z, min(z + chunk_size, self.image_3d.shape[0]))
+                            for yy in range(y, min(y + chunk_size, self.image_3d.shape[1]))
+                            for xx in range(x, min(x + chunk_size, self.image_3d.shape[2]))
+                        ]
+                        
+                        # Store chunk with its corner position
+                        chunks_info.append({
+                            'coords': chunk_coords,
+                            'corner': (z, y, x),
+                            'processed': False
+                        })
+
+            def get_chunk_priority(chunk):
+                """Calculate priority based on distance from user position"""
+                z, y, x = chunk['corner']
+                priority = 0
+                
+                # Priority based on Z distance (always used)
+                if current_z is not None:
+                    priority += abs(z - current_z)
+                
+                # Add X/Y distance if provided
+                if current_x is not None and current_y is not None:
+                    xy_distance = ((x - current_x) ** 2 + (y - current_y) ** 2) ** 0.5
+                    priority += xy_distance
+                    
+                return priority
+
+            with ThreadPoolExecutor() as executor:
+                futures = {}  # Track active futures
+                
+                while True:
+                    # Sort unprocessed chunks by priority
+                    unprocessed_chunks = [c for c in chunks_info if not c['processed']]
+                    if not unprocessed_chunks:
+                        break
+                        
+                    # Sort by distance from current position
+                    unprocessed_chunks.sort(key=get_chunk_priority)
+                    
+                    # Submit new chunks to replace completed ones
+                    while len(futures) < executor._max_workers and unprocessed_chunks:
+                        chunk = unprocessed_chunks.pop(0)
+                        future = executor.submit(self.process_chunk, chunk['coords'])
+                        futures[future] = chunk
+                        chunk['processed'] = True
+                    
+                    # Check completed futures
+                    done, _ = concurrent.futures.wait(
+                        futures.keys(),
+                        timeout=0.1,
+                        return_when=concurrent.futures.FIRST_COMPLETED
+                    )
+                    
+                    # Process completed chunks
+                    for future in done:
+                        chunk = futures[future]
+                        fore, back = future.result()
+                        
+                        # Yield chunk results with position information
+                        yield {
+                            'foreground': fore,
+                            'background': back,
+                            'corner': chunk['corner'],
+                            'size': chunk_size
+                        }
+                        
+                        del futures[future]
+

nettracer3d/smart_dilate.py

@@ -383,42 +383,83 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
     return dilated_nodes_with_labels
 
 def compute_distance_transform_GPU(nodes):
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+    
     # Convert numpy array to CuPy array
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    distance, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    _, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
     
     # Convert results back to numpy arrays
     nearest_label_indices_np = cp.asnumpy(nearest_label_indices)
     
+    if is_pseudo_3d:
+        # For 2D input, we get (2, H, W) but need (3, 1, H, W)
+        H, W = nearest_label_indices_np[0].shape
+        indices_4d = np.zeros((3, 1, H, W), dtype=nearest_label_indices_np.dtype)
+        indices_4d[1:, 0] = nearest_label_indices_np  # Copy Y and X coordinates
+        # indices_4d[0] stays 0 for all Z coordinates
+        nearest_label_indices_np = indices_4d
+
+    
+
+
     return nearest_label_indices_np
 
 
 def compute_distance_transform(nodes):
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
     distance, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+
+    if is_pseudo_3d:
+        # For 2D input, we get (2, H, W) but need (3, 1, H, W)
+        H, W = nearest_label_indices_np[0].shape
+        indices_4d = np.zeros((3, 1, H, W), dtype=nearest_label_indices_np.dtype)
+        indices_4d[1:, 0] = nearest_label_indices_np  # Copy Y and X coordinates
+        # indices_4d[0] stays 0 for all Z coordinates
+        nearest_label_indices_np = indices_4d
+
     return nearest_label_indices
 
 
 
 def compute_distance_transform_distance_GPU(nodes):
 
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
     # Convert numpy array to CuPy array
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    distance, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    distance, _ = cpx.distance_transform_edt(nodes_cp, return_indices=True)
     
     # Convert results back to numpy arrays
     distance = cp.asnumpy(distance)
+
+    if is_pseudo_3d:
+        np.expand_dims(distance, axis = 0)
     
     return distance    
 
 
 def compute_distance_transform_distance(nodes):
 
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
     # Fallback to CPU if there's an issue with GPU computation
-    distance, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+    distance, _ = distance_transform_edt(nodes, return_indices=True)
+    if is_pseudo_3d:
+        np.expand_dims(distance, axis = 0)
     return distance
 
 

{nettracer3d-0.4.2.dist-info → nettracer3d-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.4.2
+Version: 0.4.4
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
@@ -23,6 +23,7 @@ Requires-Dist: pandas
 Requires-Dist: napari
 Requires-Dist: python-louvain
 Requires-Dist: tifffile
+Requires-Dist: qtrangeslider
 Requires-Dist: PyQt6
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
@@ -31,15 +32,8 @@ Requires-Dist: cupy-cuda12x; extra == "cuda12"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
 
-NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
+NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
-#Start
-
-from nettracer3d import nettracer_gui
-
-nettracer_gui.run_gui()
-
-#End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
 for a user manual that provides older documentation.

nettracer3d-0.4.4.dist-info/RECORD

@@ -0,0 +1,21 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/community_extractor.py,sha256=8bRDJOfZhOFLtpkJVaDQrQ4O8wUywyr-EfVvW5fxyPs,31700
+nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,8298
+nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
+nettracer3d/morphology.py,sha256=CsRWB0DY-vBBlKdF9IQwgfYYZswuE7n1Iu_Osxgmxnw,13042
+nettracer3d/nettracer.py,sha256=x-4xjEJNWzTy5gKvpGAmRzlWD3Wx-lomH_ItqRNv9v8,207727
+nettracer3d/nettracer_gui.py,sha256=1b5sFTCe3Jinc200vRTknGsY_Xm2rj-BG2CDyo-gHGU,324790
+nettracer3d/network_analysis.py,sha256=MJBBjslA1k_R8ymid77U-qGSgzxFVfzGVQhE0IdhnbE,48046
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=BMiD_FrlOHeGD4AQZ_Emd152PfxFuMgGf2x4S0TOTnw,9752
+nettracer3d/proximity.py,sha256=B1pmFegx5Wb0JKI5rvpILv2VRU09f6M2iljAQAqBja0,11059
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=Inp3m6ajgR03zh_JyJt3Qntb-ZXmxuxVDBbmQnhb3pM,11619
+nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
+nettracer3d/smart_dilate.py,sha256=JALeAZ7LLU2psTuI5wlCZobtDx8I0CfihdoEblwfhOY,23520
+nettracer3d-0.4.4.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.4.4.dist-info/METADATA,sha256=4os3ofWdAzCFAfKt0LvFlUE4atoVKO26s0OKUq1NO7s,2884
+nettracer3d-0.4.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nettracer3d-0.4.4.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.4.4.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.4.4.dist-info/RECORD,,

nettracer3d-0.4.2.dist-info/RECORD

@@ -1,20 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=8bRDJOfZhOFLtpkJVaDQrQ4O8wUywyr-EfVvW5fxyPs,31700
-nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,8298
-nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
-nettracer3d/morphology.py,sha256=wv7v06YUcn5lMyefcc_znQlXF5iDxvUdoc0fXOKlGTw,12982
-nettracer3d/nettracer.py,sha256=sFwHz-Ghoft3nNS3H691EcMTpoeLKT3I_X-6m6vXpyg,203264
-nettracer3d/nettracer_gui.py,sha256=GSTICp2V0MAwMpw6RcUrR0kdF721bpBOGMHnOK2LHLM,290039
-nettracer3d/network_analysis.py,sha256=MJBBjslA1k_R8ymid77U-qGSgzxFVfzGVQhE0IdhnbE,48046
-nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=BMiD_FrlOHeGD4AQZ_Emd152PfxFuMgGf2x4S0TOTnw,9752
-nettracer3d/proximity.py,sha256=KYs4QUbt1U79RLzTvt8BmrxeGVaeKOQ2brtzTjjA78c,11011
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=howfO6Lw5PxNjkaOBSCjkmf7fyau_-_8iTct2mAuTAQ,22083
-nettracer3d-0.4.2.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.4.2.dist-info/METADATA,sha256=ffklpH2f0M7A5xOTDE9blsCn-yZnCXhe0GaBpgUQcEI,2894
-nettracer3d-0.4.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nettracer3d-0.4.2.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.4.2.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.4.2.dist-info/RECORD,,