nettracer3d 1.1.9__tar.gz → 1.2.3__tar.gz

{nettracer3d-1.1.9/src/nettracer3d.egg-info → nettracer3d-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.1.9
+Version: 1.2.3
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,12 +110,8 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.1.9 Updates --
+-- Version 1.2.3 Updates --
 
-	* Fixed saving of Boolean True/False arrays.
-	* Fixed branch functions not working correctly when a temporary downsample was being applied
-	* Added the 'filaments tracer' which can be used to improve vessel based segmentations
-	* Removed options for 'cubic' downsampling during processing as this option actually made outputs worse.
-	* Rearranged the 'Analyze -> Stats' menu
+	* Tweaked the 'branch unification params' - now hard rejects any sharp forks in the branches so branches will mostly be straight.
 	
 	

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/README.md

@@ -65,12 +65,8 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.1.9 Updates --
+-- Version 1.2.3 Updates --
 
-	* Fixed saving of Boolean True/False arrays.
-	* Fixed branch functions not working correctly when a temporary downsample was being applied
-	* Added the 'filaments tracer' which can be used to improve vessel based segmentations
-	* Removed options for 'cubic' downsampling during processing as this option actually made outputs worse.
-	* Rearranged the 'Analyze -> Stats' menu
+	* Tweaked the 'branch unification params' - now hard rejects any sharp forks in the branches so branches will mostly be straight.
 	
 	

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "1.1.9"
+version = "1.2.3"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]

nettracer3d-1.2.3/src/nettracer3d/branch_stitcher.py

@@ -0,0 +1,420 @@
+import numpy as np
+import networkx as nx
+from . import nettracer as n3d
+from scipy.ndimage import distance_transform_edt, gaussian_filter, binary_fill_holes
+from scipy.spatial import cKDTree
+from skimage.morphology import remove_small_objects, skeletonize
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class VesselDenoiser:
+    """
+    Denoise vessel segmentations using graph-based geometric features
+    """
+    
+    def __init__(self, 
+                 score_thresh = 2):
+
+        self.score_thresh = score_thresh
+
+
+    def select_kernel_points_topology(self, data, skeleton):
+        """
+        ENDPOINTS ONLY version: Returns only skeleton endpoints (degree=1 nodes)
+        """
+        skeleton_coords = np.argwhere(skeleton)
+        if len(skeleton_coords) == 0:
+            return skeleton_coords
+        
+        # Map coord -> index
+        coord_to_idx = {tuple(c): i for i, c in enumerate(skeleton_coords)}
+        
+        # Build full 26-connected skeleton graph
+        skel_graph = nx.Graph()
+        for i, c in enumerate(skeleton_coords):
+            skel_graph.add_node(i, pos=c)
+        
+        nbr_offsets = [(dz, dy, dx)
+                       for dz in (-1, 0, 1)
+                       for dy in (-1, 0, 1)
+                       for dx in (-1, 0, 1)
+                       if not (dz == dy == dx == 0)]
+        
+        for i, c in enumerate(skeleton_coords):
+            cz, cy, cx = c
+            for dz, dy, dx in nbr_offsets:
+                nb = (cz + dz, cy + dy, cx + dx)
+                j = coord_to_idx.get(nb, None)
+                if j is not None and j > i:
+                    skel_graph.add_edge(i, j)
+        
+        # Get degree per voxel
+        deg = dict(skel_graph.degree())
+        
+        # ONLY keep endpoints (degree=1)
+        endpoints = {i for i, d in deg.items() if d == 1}
+        
+        # Return endpoint coordinates
+        kernel_coords = np.array([skeleton_coords[i] for i in endpoints])
+        return kernel_coords
+        
+    
+    def extract_kernel_features(self, skeleton, distance_map, kernel_pos, radius=5):
+        """Extract geometric features for a kernel at a skeleton point"""
+        z, y, x = kernel_pos
+        shape = skeleton.shape
+        
+        features = {}
+        
+        # Vessel radius at this point
+        features['radius'] = distance_map[z, y, x]
+        
+        # Local skeleton density (connectivity measure)
+        z_min = max(0, z - radius)
+        z_max = min(shape[0], z + radius + 1)
+        y_min = max(0, y - radius)
+        y_max = min(shape[1], y + radius + 1)
+        x_min = max(0, x - radius)
+        x_max = min(shape[2], x + radius + 1)
+        
+        local_region = skeleton[z_min:z_max, y_min:y_max, x_min:x_max]
+        features['local_density'] = np.sum(local_region) / max(local_region.size, 1)
+        
+        # Local direction vector
+        features['direction'] = self._compute_local_direction(
+            skeleton, kernel_pos, radius
+        )
+        
+        # Position
+        features['pos'] = np.array(kernel_pos)
+        
+        # ALL kernels are endpoints in this version
+        features['is_endpoint'] = True
+        
+        return features
+
+    
+    def _compute_local_direction(self, skeleton, pos, radius=5):
+        """Compute principal direction of skeleton in local neighborhood"""
+        z, y, x = pos
+        shape = skeleton.shape
+        
+        z_min = max(0, z - radius)
+        z_max = min(shape[0], z + radius + 1)
+        y_min = max(0, y - radius)
+        y_max = min(shape[1], y + radius + 1)
+        x_min = max(0, x - radius)
+        x_max = min(shape[2], x + radius + 1)
+        
+        local_skel = skeleton[z_min:z_max, y_min:y_max, x_min:x_max]
+        coords = np.argwhere(local_skel)
+        
+        if len(coords) < 2:
+            return np.array([0., 0., 1.])
+        
+        # PCA to find principal direction
+        centered = coords - coords.mean(axis=0)
+        cov = np.cov(centered.T)
+        eigenvalues, eigenvectors = np.linalg.eigh(cov)
+        principal_direction = eigenvectors[:, -1]  # largest eigenvalue
+        
+        return principal_direction / (np.linalg.norm(principal_direction) + 1e-10)
+    
+    def group_endpoints_by_vertex(self, skeleton_points, verts):
+        """
+        Group endpoints by which vertex (labeled blob) they belong to
+        
+        Returns:
+        --------
+        vertex_to_endpoints : dict
+            Dictionary mapping vertex_label -> [list of endpoint indices]
+        """
+        vertex_to_endpoints = {}
+        
+        for idx, pos in enumerate(skeleton_points):
+            z, y, x = pos.astype(int)
+            vertex_label = int(verts[z, y, x])
+            
+            # Skip if endpoint is not in any vertex (label=0)
+            if vertex_label == 0:
+                continue
+            
+            if vertex_label not in vertex_to_endpoints:
+                vertex_to_endpoints[vertex_label] = []
+            
+            vertex_to_endpoints[vertex_label].append(idx)
+        
+        return vertex_to_endpoints
+    
+    def compute_edge_features(self, feat_i, feat_j):
+        """
+        Compute features for potential connection between two endpoints
+        NO DISTANCE-BASED FEATURES - only radius and direction
+        """
+        features = {}
+        
+        # Euclidean distance (for reference only, not used in scoring)
+        pos_diff = feat_j['pos'] - feat_i['pos']
+        features['distance'] = np.linalg.norm(pos_diff)
+        
+        # Radius similarity
+        r_i, r_j = feat_i['radius'], feat_j['radius']
+        features['radius_diff'] = abs(r_i - r_j)
+        features['radius_ratio'] = min(r_i, r_j) / (max(r_i, r_j) + 1e-10)
+        features['mean_radius'] = (r_i + r_j) / 2.0
+        
+        # Direction alignment
+        direction_vec = pos_diff / (features['distance'] + 1e-10)
+        
+        # Alignment with both local directions
+        align_i = abs(np.dot(feat_i['direction'], direction_vec))
+        align_j = abs(np.dot(feat_j['direction'], direction_vec))
+        features['alignment'] = (align_i + align_j) / 2.0
+        
+        # Smoothness: how well does connection align with both local directions
+        features['smoothness'] = min(align_i, align_j)
+        
+        # Density similarity
+        features['density_diff'] = abs(feat_i['local_density'] - feat_j['local_density'])
+        
+        return features
+    
+    def score_connection(self, edge_features):
+        score = 0.0
+
+        # HARD REJECT for definite forks/sharp turns
+        if edge_features['smoothness'] < 0.5:  # At least one endpoint pointing away
+            return -999
+        
+        # Base similarity scoring
+        score += edge_features['radius_ratio'] * 10.0
+        score += edge_features['alignment'] * 8.0
+        score += edge_features['smoothness'] * 6.0
+        score -= edge_features['density_diff'] * 0.5
+        
+        # PENALTY for poor directional alignment (punish forks!)
+        # Alignment < 0.5 means vessels are pointing in different directions
+        # This doesn't trigger that often so it might be redundant with the above step
+        if edge_features['alignment'] < 0.5:
+            penalty = (0.5 - edge_features['alignment']) * 15.0
+            score -= penalty
+        
+        # ADDITIONAL PENALTY for sharp turns/forks --- no longer in use since we now hard reject these, but I left this in here to reverse it later potentially
+        # Smoothness < 0.4 means at least one endpoint points away
+        #if edge_features['smoothness'] < 0.4:
+         #   penalty = (0.4 - edge_features['smoothness']) * 20.0
+          #  score -= penalty
+        
+        # Size bonus: ONLY if vessels already match well
+        
+        if edge_features['radius_ratio'] > 0.7 and edge_features['alignment'] > 0.5:
+            mean_radius = edge_features['mean_radius']
+            score += mean_radius * 1.5
+        
+        return score
+    
+    def connect_vertices_across_gaps(self, skeleton_points, kernel_features, 
+                                     labeled_skeleton, vertex_to_endpoints, verbose=False):
+        """
+        Connect vertices by finding best endpoint pair across each vertex
+        Each vertex makes at most one connection
+        """
+        # Initialize label dictionary: label -> label (identity mapping)
+        unique_labels = np.unique(labeled_skeleton[labeled_skeleton > 0])
+        label_dict = {int(label): int(label) for label in unique_labels}
+        
+        # Map endpoint index to its skeleton label
+        endpoint_to_label = {}
+        for idx, pos in enumerate(skeleton_points):
+            z, y, x = pos.astype(int)
+            label = int(labeled_skeleton[z, y, x])
+            endpoint_to_label[idx] = label
+        
+        # Find root label (union-find helper)
+        def find_root(label):
+            root = label
+            while label_dict[root] != root:
+                root = label_dict[root]
+            return root
+        
+        # Iterate through each vertex
+        for vertex_label, endpoint_indices in vertex_to_endpoints.items():
+            if len(endpoint_indices) < 2:
+                # Need at least 2 endpoints to make a connection
+                continue
+            
+            if verbose and len(endpoint_indices) > 0:
+                print(f"\nVertex {vertex_label}: {len(endpoint_indices)} endpoints")
+            
+            # Find best pair of endpoints to connect
+            best_i = None
+            best_j = None
+            best_score = -np.inf
+            
+            # Try all pairs of endpoints within this vertex
+            for i in range(len(endpoint_indices)):
+                for j in range(i + 1, len(endpoint_indices)):
+                    idx_i = endpoint_indices[i]
+                    idx_j = endpoint_indices[j]
+                    
+                    feat_i = kernel_features[idx_i]
+                    feat_j = kernel_features[idx_j]
+                    
+                    label_i = endpoint_to_label[idx_i]
+                    label_j = endpoint_to_label[idx_j]
+                    
+                    root_i = find_root(label_i)
+                    root_j = find_root(label_j)
+                    
+                    # Skip if already unified
+                    if root_i == root_j:
+                        continue
+                    
+                    # Compute edge features (no skeleton needed, no distance penalty)
+                    edge_feat = self.compute_edge_features(feat_i, feat_j)
+                    
+                    # Score this connection
+                    score = self.score_connection(edge_feat)
+                    
+                    # Apply threshold
+                    if score > self.score_thresh and score > best_score:
+                        best_score = score
+                        best_i = idx_i
+                        best_j = idx_j
+            
+            # Make the best connection for this vertex
+            if best_i is not None and best_j is not None:
+                label_i = endpoint_to_label[best_i]
+                label_j = endpoint_to_label[best_j]
+                
+                root_i = find_root(label_i)
+                root_j = find_root(label_j)
+                
+                # Unify labels: point larger label to smaller label
+                if root_i < root_j:
+                    label_dict[root_j] = root_i
+                    unified_label = root_i
+                else:
+                    label_dict[root_i] = root_j
+                    unified_label = root_j
+                
+                if verbose:
+                    feat_i = kernel_features[best_i]
+                    feat_j = kernel_features[best_j]
+                    print(f"  ✓ Connected labels {label_i} <-> {label_j} (unified as {unified_label})")
+                    print(f"    Score: {best_score:.2f} | Radii: {feat_i['radius']:.1f}, {feat_j['radius']:.1f}")
+        
+        return label_dict
+    
+    def denoise(self, data, skeleton, labeled_skeleton, verts, verbose=False):
+        """
+        Main pipeline: unify skeleton labels by connecting endpoints at vertices
+        
+        Parameters:
+        -----------
+        data : ndarray
+            3D binary segmentation (for distance transform)
+        skeleton : ndarray
+            3D binary skeleton
+        labeled_skeleton : ndarray
+            Labeled skeleton (each branch has unique label)
+        verts : ndarray
+            Labeled vertices (blobs where branches meet)
+        verbose : bool
+            Print progress
+            
+        Returns:
+        --------
+        label_dict : dict
+            Dictionary mapping old labels to unified labels
+        """
+        if verbose:
+            print("Starting skeleton label unification...")
+            print(f"Initial unique labels: {len(np.unique(labeled_skeleton[labeled_skeleton > 0]))}")
+        
+        # Compute distance transform
+        if verbose:
+            print("Computing distance transform...")
+        distance_map = distance_transform_edt(data)
+        
+        # Extract endpoints
+        if verbose:
+            print("Extracting skeleton endpoints...")
+        kernel_points = self.select_kernel_points_topology(data, skeleton)
+        
+        if verbose:
+            print(f"Found {len(kernel_points)} endpoints")
+        
+        # Group endpoints by vertex
+        if verbose:
+            print("Grouping endpoints by vertex...")
+        vertex_to_endpoints = self.group_endpoints_by_vertex(kernel_points, verts)
+        
+        if verbose:
+            print(f"Found {len(vertex_to_endpoints)} vertices with endpoints")
+            vertices_with_multiple = sum(1 for v in vertex_to_endpoints.values() if len(v) >= 2)
+            print(f"  {vertices_with_multiple} vertices have 2+ endpoints (connection candidates)")
+        
+        # Extract features for each endpoint
+        if verbose:
+            print("Extracting endpoint features...")
+        kernel_features = []
+        for pt in kernel_points:
+            feat = self.extract_kernel_features(skeleton, distance_map, pt)
+            kernel_features.append(feat)
+        
+        # Connect vertices
+        if verbose:
+            print("Connecting endpoints at vertices...")
+        label_dict = self.connect_vertices_across_gaps(
+            kernel_points, kernel_features, labeled_skeleton, 
+            vertex_to_endpoints, verbose
+        )
+        
+        # Compress label dictionary (path compression for union-find)
+        if verbose:
+            print("\nCompressing label mappings...")
+        for label in list(label_dict.keys()):
+            root = label
+            while label_dict[root] != root:
+                root = label_dict[root]
+            label_dict[label] = root
+        
+        # Count final unified components
+        final_labels = set(label_dict.values())
+        if verbose:
+            print(f"Final unified labels: {len(final_labels)}")
+            print(f"Reduced from {len(label_dict)} to {len(final_labels)} components")
+        
+        return label_dict
+
+
+def trace(data, labeled_skeleton, verts, score_thresh=10, verbose=False):
+    """
+    Trace and unify skeleton labels using vertex-based endpoint grouping
+    """
+    skeleton = n3d.binarize(labeled_skeleton)
+    
+    # Create denoiser
+    denoiser = VesselDenoiser(score_thresh=score_thresh)
+    
+    # Run label unification
+    label_dict = denoiser.denoise(data, skeleton, labeled_skeleton, verts, verbose=verbose)
+    
+    # Apply unified labels efficiently (SINGLE PASS)
+    # Create lookup array: index by old label, get new label
+    max_label = np.max(labeled_skeleton)
+    label_map = np.arange(max_label + 1)  # Identity mapping by default
+    
+    for old_label, new_label in label_dict.items():
+        label_map[old_label] = new_label
+    
+    # Single array indexing operation
+    relabeled_skeleton = label_map[labeled_skeleton]
+    
+    return relabeled_skeleton
+
+
+if __name__ == "__main__":
+    print("Test area")

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/src/nettracer3d/filaments.py

@@ -633,8 +633,6 @@ class VesselDenoiser:
                         edge_feat["skeleton_steps"] = steps
                         G.add_edge(k_id, j_id, **edge_feat)
 
-        # CRITICAL FIX FOR ISSUE 1: Second pass to catch any directly adjacent kernels
-        # that might have been missed due to complex topology
         # This ensures ALL kernels that are neighbors in the skeleton are connected
         for k_id, s_idx in kernel_to_skel_idx.items():
             # Check all neighbors of this kernel in the skeleton
@@ -656,24 +654,20 @@ class VesselDenoiser:
     def connect_endpoints_across_gaps(self, G, skeleton_points, kernel_features, skeleton):
         """
         Second stage: Let endpoints reach out to connect across gaps
-        Only endpoints can initiate connections
-        
-        Strategy:
-        - Within same component: reconnect broken paths (gap filling)
-        - Between components: only connect if strong evidence (path support, alignment)
+        Optimized version using Union-Find for fast connectivity checks
         """
+        from scipy.cluster.hierarchy import DisjointSet
+        
         # Identify all endpoints
         endpoint_nodes = [i for i, feat in enumerate(kernel_features) if feat['is_endpoint']]
         
         if len(endpoint_nodes) == 0:
             return G
         
-        # Get initial component membership
-        components = list(nx.connected_components(G))
-        node_to_component = {}
-        for comp_idx, comp in enumerate(components):
-            for node in comp:
-                node_to_component[node] = comp_idx
+        # Initialize Union-Find with existing graph connections
+        ds = DisjointSet(range(len(skeleton_points)))
+        for u, v in G.edges():
+            ds.merge(u, v)
         
         # Build KD-tree for all points
         tree = cKDTree(skeleton_points)
@@ -682,7 +676,6 @@ class VesselDenoiser:
             feat_i = kernel_features[endpoint_idx]
             pos_i = skeleton_points[endpoint_idx]
             direction_i = feat_i['direction']
-            component_i = node_to_component.get(endpoint_idx, -1)
             
             # Use radius-aware connection distance
             if self.radius_aware_distance:
@@ -698,32 +691,24 @@ class VesselDenoiser:
                 if endpoint_idx == j:
                     continue
                 
-                # Skip if already connected via any path
-                try:
-                    if nx.has_path(G, endpoint_idx, j):
-                        continue
-                except:
-                    pass
+                # FAST connectivity check - O(1) amortized instead of O(V+E)
+                if ds.connected(endpoint_idx, j):
+                    continue
                 
                 feat_j = kernel_features[j]
                 pos_j = skeleton_points[j]
                 is_endpoint_j = feat_j['is_endpoint']
-                component_j = node_to_component.get(j, -1)
                 
-                # Check if they're in the same component
-                same_component = (component_i == component_j and component_i != -1)
+                # Check if they're in the same component (using union-find)
+                same_component = ds.connected(endpoint_idx, j)
                 
-                # Check directionality: is j in the direction this endpoint is pointing?
+                # Check directionality
                 to_target = pos_j - pos_i
                 to_target_normalized = to_target / (np.linalg.norm(to_target) + 1e-10)
                 direction_dot = np.dot(direction_i, to_target_normalized)
                 
                 # Compute edge features
-                edge_feat = self.compute_edge_features(
-                    feat_i,
-                    feat_j,
-                    skeleton
-                )
+                edge_feat = self.compute_edge_features(feat_i, feat_j, skeleton)
                 
                 # Decide based on component membership
                 should_connect = False
@@ -731,20 +716,16 @@ class VesselDenoiser:
                 if same_component:
                     should_connect = True
                 else:
-                    # Different components = merging separate segments
-                    # Require STRONG evidence
+                    # Different components - require STRONG evidence
                     if edge_feat['path_support'] > 0.5:
-                        # Strong skeleton path exists
                         should_connect = True
-                    elif direction_dot > 0.3 and edge_feat['radius_ratio'] > 0.5: # Moderate radius evidence, some directional evidence
-                        # Well aligned forward, similar radius
-                        #if is_endpoint_j:  # Both endpoints
+                    elif direction_dot > 0.3 and edge_feat['radius_ratio'] > 0.5:
                         score = self.score_connection(edge_feat)
-                        if score > self.score_thresh:  # High threshold for merging
+                        if score > self.score_thresh:
                             should_connect = True
-                    elif edge_feat['radius_ratio'] > 0.7: #stronger radius evidence
+                    elif edge_feat['radius_ratio'] > 0.7:
                         score = self.score_connection(edge_feat)
-                        if score > self.score_thresh:  # High threshold for merging
+                        if score > self.score_thresh:
                             should_connect = True
                 
                 # Special check: if j is internal node, require alignment
@@ -754,6 +735,8 @@ class VesselDenoiser:
                 
                 if should_connect:
                     G.add_edge(endpoint_idx, j, **edge_feat)
+                    # Update union-find structure immediately
+                    ds.merge(endpoint_idx, j)
         
         return G
     
@@ -807,7 +790,7 @@ class VesselDenoiser:
             degrees = [G.degree(n) for n in component]
             
             # Component statistics
-            size = len(component)
+            size = len(component) * self.kernel_spacing
             mean_radius = np.mean(radii)
             max_radius = np.max(radii)
             avg_degree = np.mean(degrees)
@@ -824,13 +807,16 @@ class VesselDenoiser:
             
             # Measure elongation (max distance / mean deviation from center)
             if len(positions) > 1:
-                pairwise_dists = np.linalg.norm(
-                    positions[:, None] - positions[None, :], axis=2
-                )
-                max_dist = np.max(pairwise_dists)
                 mean_pos = positions.mean(axis=0)
                 deviations = np.linalg.norm(positions - mean_pos, axis=1)
                 mean_deviation = np.mean(deviations)
+                
+                # FAST APPROXIMATION: Use bounding box diagonal
+                # This is O(n) instead of O(n²) and uses minimal memory
+                bbox_min = positions.min(axis=0)
+                bbox_max = positions.max(axis=0)
+                max_dist = np.linalg.norm(bbox_max - bbox_min)
+                
                 elongation = max_dist / (mean_deviation + 1) if mean_deviation > 0 else max_dist
             else:
                 elongation = 0

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/src/nettracer3d/nettracer.py

@@ -781,7 +781,7 @@ def get_surface_areas(labeled, xy_scale=1, z_scale=1):
         
     return result
 
-def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None, compute = True, xy_scale = 1, z_scale = 1):
+def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None, compute = True, unify = False, xy_scale = 1, z_scale = 1):
     """Internal method to break open a skeleton at its branchpoints and label the remaining components, for an 8bit binary array"""
 
     if type(skeleton) == str:
@@ -829,11 +829,16 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
         tifffile.imwrite(filename, labeled_image, photometric='minisblack')
         print(f"Broken skeleton saved to {filename}")
 
+    if not unify:
+        verts = None
+    else:
+        verts = invert_array(verts)
+
     if compute:
 
-        return labeled_image, None, skeleton, None
+        return labeled_image, verts, skeleton, None
 
-    return labeled_image, None, None, None
+    return labeled_image, verts, None, None
 
 def compute_optional_branchstats(verts, labeled_array, endpoints, xy_scale = 1, z_scale = 1):
 
@@ -2371,7 +2376,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, xy_scale = 1, z_scale = 1):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, unify = False, union_val = 10, xy_scale = 1, z_scale = 1):
     """
     Can be used to label branches a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -2401,13 +2406,20 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
         other_array = skeletonize(array)
 
-        other_array, verts, skele, endpoints = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, xy_scale = xy_scale, z_scale = z_scale)
+        other_array, verts, skele, endpoints = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, unify = unify, xy_scale = xy_scale, z_scale = z_scale)
 
     else:
-        array, verts, skele, endpoints = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, xy_scale = xy_scale, z_scale = z_scale)
+        if down_factor is not None:
+            bonus_array = downsample(bonus_array, down_factor)
+        array, verts, skele, endpoints = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, unify = unify, xy_scale = xy_scale, z_scale = z_scale)
+
+    if unify is True and nodes is not None:
+        from . import branch_stitcher
+        verts = dilate_3D_old(verts, 3, 3, 3,)
+        verts, _ = label_objects(verts)
+        array = branch_stitcher.trace(bonus_array, array, verts, score_thresh = union_val)
+        verts = None
 
-    if nodes is not None and down_factor is not None:
-        array = upsample_with_padding(array, down_factor, arrayshape)
 
     if nodes is None:
 
@@ -2441,6 +2453,9 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
     else:
         print("Branches labelled")
 
+    if nodes is not None and down_factor is not None:
+        array = upsample_with_padding(array, down_factor, arrayshape)
+
 
     return array, verts, skele, endpoints
 
@@ -3349,8 +3364,11 @@ class Network_3D:
                         try:
                             tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                         except:
-                            self._nodes = binarize(self._nodes)
-                            tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                            try:
+                                tifffile.imwrite(f"{filename}", self._nodes)
+                            except:
+                                self._nodes = binarize(self._nodes)
+                                tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     else:
                         tifffile.imwrite(f"{filename}", self._nodes)
                     print(f"Nodes saved to {filename}")
@@ -3362,8 +3380,11 @@ class Network_3D:
                         try:
                             tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                         except:
-                            self._nodes = binarize(self._nodes)
-                            tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                            try:
+                                tifffile.imwrite(f"{directory}/{filename}", self._nodes)
+                            except:
+                                self._nodes = binarize(self._nodes)
+                                tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     else:
                         tifffile.imwrite(f"{directory}/{filename}", self._nodes)
                     print(f"Nodes saved to {directory}/{filename}")
@@ -3398,16 +3419,22 @@ class Network_3D:
                 try:
                     tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 except:
-                    self._edges = binarize(self._edges)
-                    tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    try:
+                        tifffile.imwrite(f"{filename}", self._edges)
+                    except:
+                        self._edges = binarize(self._edges)
+                        tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 print(f"Edges saved to {filename}")
 
             if directory is not None:
                 try:
                     tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 except:
-                    self._edges = binarize(self._edges)
-                    tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    try:
+                        tifffile.imwrite(f"{directory}/{filename}", self._edges)
+                    except:
+                        self._edges = binarize(self._edges)
+                        tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 print(f"Edges saved to {directory}/{filename}")
 
         if self._edges is None:
@@ -3583,8 +3610,11 @@ class Network_3D:
                     try:
                         tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     except:
-                        self._network_overlay = binarize(self._network_overlay)
-                        tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        try:
+                            tifffile.imwrite(f"{filename}", self._network_overlay)
+                        except:
+                            self._network_overlay = binarize(self._network_overlay)
+                            tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{filename}", self._network_overlay)
                 print(f"Network overlay saved to {filename}")
@@ -3594,8 +3624,11 @@ class Network_3D:
                     try:
                         tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     except:
-                        self._network_overlay = binarize(self._network_overlay)
-                        tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        try:
+                            tifffile.imwrite(f"{directory}/{filename}", self._network_overlay)
+                        except:
+                            self._network_overlay = binarize(self._network_overlay)
+                            tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{directory}/{filename}", self._network_overlay)
                 print(f"Network overlay saved to {directory}/{filename}")
@@ -3622,8 +3655,11 @@ class Network_3D:
                     try:
                         tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     except:
-                        self._id_overlay = binarize(self._id_overlay)
-                        tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        try:
+                            tifffile.imwrite(f"{filename}", self._id_overlay)
+                        except:                            
+                            self._id_overlay = binarize(self._id_overlay)
+                            tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True)
                 print(f"Network overlay saved to {filename}")
@@ -3633,8 +3669,11 @@ class Network_3D:
                     try:
                         tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     except:
-                        self._id_overlay = binarize(self._id_overlay)
-                        tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        try:
+                            tifffile.imwrite(f"{directory}/{filename}", self._id_overlay)
+                        except:
+                            self._id_overlay = binarize(self._id_overlay)
+                            tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{directory}/{filename}", self._id_overlay)
                 print(f"ID overlay saved to {directory}/{filename}")

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/src/nettracer3d/nettracer_gui.py

@@ -4887,7 +4887,7 @@ class ImageViewerWindow(QMainWindow):
         gennodes_action.triggered.connect(self.show_gennodes_dialog)
         branch_action = generate_menu.addAction("Label Branches")
         branch_action.triggered.connect(lambda: self.show_branch_dialog())
-        filament_action = generate_menu.addAction("Trace Filaments")
+        filament_action = generate_menu.addAction("Trace Filaments (For Segmented Data)")
         filament_action.triggered.connect(self.show_filament_dialog)
         genvor_action = generate_menu.addAction("Generate Voronoi Diagram - goes in Overlay2")
         genvor_action.triggered.connect(self.voronoi)
@@ -6358,11 +6358,13 @@ class ImageViewerWindow(QMainWindow):
             if 'YResolution' in tags:
                 y_res = tags['YResolution'].value
                 y_scale = y_res[1] / y_res[0] if isinstance(y_res, tuple) else 1.0 / y_res
-        
-        if x_scale is None:
+
+        if x_scale == None:
             x_scale = 1
-        if z_scale is None:
+        if z_scale == None:
             z_scale = 1
+        if x_scale == 1 and z_scale == 1:
+            return
 
         return x_scale, z_scale
 
@@ -7337,6 +7339,10 @@ class ImageViewerWindow(QMainWindow):
 
         try:
 
+            if self.shape[0] == 1:
+                print("The image is 2D and therefore does not have surface areas")
+                return
+
             surface_areas = n3d.get_surface_areas(self.channel_data[self.active_channel], xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
 
             if self.active_channel == 0:
@@ -7357,6 +7363,10 @@ class ImageViewerWindow(QMainWindow):
 
         try:
 
+            if self.shape[0] == 1:
+                print("The image is 2D and therefore does not have sphericities")
+                return
+
             self.volumes()
             self.handle_sa()
             volumes = self.volume_dict[self.active_channel]
@@ -12627,8 +12637,7 @@ class MachineWindow(QMainWindow):
                 self.num_chunks = 0
                 self.parent().update_display()
             except:
-                import traceback
-                traceback.print_exc()
+
                 pass            
 
         except:
@@ -13216,22 +13225,28 @@ class ThresholdWindow(QMainWindow):
             data = self.parent().channel_data[self.parent().active_channel]
             nonzero_data = data[data != 0]
 
-            if nonzero_data.size > 578009537:
-                # For large arrays, use numpy histogram directly
-                # Store min/max separately if needed elsewhere
-                self.data_min = np.min(nonzero_data)
-                self.data_max = np.max(nonzero_data)
-                self.histo_list = [self.data_min, self.data_max]
-                nonzero_data = n3d.downsample(nonzero_data, 5)
-                print('start')
-                counts, bin_edges = np.histogram(nonzero_data, bins= min(int(np.sqrt(nonzero_data.size)), 500), density=False)
-                print('start')
+            MAX_SAMPLES_FOR_HISTOGRAM = 10_000_000  # Downsample data above this size
+            MAX_HISTOGRAM_BINS = 512  # Maximum bins for smooth matplotlib interaction
+            MIN_HISTOGRAM_BINS = 128  # Minimum bins for decent resolution
+
+            # Always compute min/max first (before any downsampling)
+            self.data_min = np.min(nonzero_data)
+            self.data_max = np.max(nonzero_data)
+            self.histo_list = [self.data_min, self.data_max]
+
+            # Downsample data if too large
+            if nonzero_data.size > MAX_SAMPLES_FOR_HISTOGRAM:
+                downsample_factor = int(np.ceil(nonzero_data.size / MAX_SAMPLES_FOR_HISTOGRAM))
+                nonzero_data_sampled = n3d.downsample(nonzero_data, downsample_factor)
             else:
-                # For smaller arrays, can still use histogram method for consistency
-                counts, bin_edges = np.histogram(nonzero_data, bins='auto', density=False)
-                self.data_min = np.min(nonzero_data)
-                self.data_max = np.max(nonzero_data)
-                self.histo_list = [self.data_min, self.data_max]
+                nonzero_data_sampled = nonzero_data
+
+            # Calculate optimal bin count (capped for matplotlib performance)
+            # Using Sturges' rule but capped to reasonable limits
+            n_bins = int(np.ceil(np.log2(nonzero_data_sampled.size)) + 1)
+            n_bins = np.clip(n_bins, MIN_HISTOGRAM_BINS, MAX_HISTOGRAM_BINS)
+
+            counts, bin_edges = np.histogram(nonzero_data_sampled, bins=n_bins, density=False)
             
             self.bounds = True
             self.parent().bounds = True
@@ -13936,10 +13951,10 @@ class FilamentDialog(QDialog):
         # Speedup Group
         speedup_group = QGroupBox("Speedup")
         speedup_layout = QFormLayout()
-        self.kernel_spacing = QLineEdit("1")
+        self.kernel_spacing = QLineEdit("3")
         speedup_layout.addRow("Kernel Spacing (1 is most accurate, can increase to speed up):", self.kernel_spacing)
         self.downsample_factor = QLineEdit("1")
-        speedup_layout.addRow("Temporary Downsample Factor (Note that the above distances are not adjusted for this):", self.downsample_factor)
+        speedup_layout.addRow("Temporary Downsample Factor (Note that the below distances are not adjusted for this):", self.downsample_factor)
         speedup_group.setLayout(speedup_layout)
         main_layout.addWidget(speedup_group)
         
@@ -13959,7 +13974,7 @@ class FilamentDialog(QDialog):
         artifact_group = QGroupBox("Artifact Removal")
         artifact_layout = QFormLayout()
         self.min_component = QLineEdit("20")
-        artifact_layout.addRow("Minimum Component Size to Include (Filters out noise before connecting, calculate unscaled volumes if unsure):", self.min_component)
+        artifact_layout.addRow("Minimum Component Size to Include:", self.min_component)
         self.blob_sphericity = QLineEdit("1.0")
         artifact_layout.addRow("Spherical Objects in the Output can Represent Noise. Enter a val 0 < x < 1 to consider removing spheroids. Larger vals are more spherical. 1.0 = a perfect sphere. 0.3 is usually the lower bound of a spheroid:", self.blob_sphericity)
         self.blob_volume = QLineEdit("200")
@@ -13968,7 +13983,8 @@ class FilamentDialog(QDialog):
         artifact_layout.addRow("Remove Branch Spines Below this Length?", self.spine_removal)
         artifact_group.setLayout(artifact_layout)
         main_layout.addWidget(artifact_group)
-        
+
+    
         # Run Button
         run_button = QPushButton("Run Filament Tracer (Output Goes in Overlay 2)")
         run_button.clicked.connect(self.run)
@@ -13981,6 +13997,7 @@ class FilamentDialog(QDialog):
 
             from . import filaments
 
+
             kernel_spacing = int(self.kernel_spacing.text()) if self.kernel_spacing.text().strip() else 1
             max_distance = float(self.max_distance.text()) if self.max_distance.text().strip() else 20
             min_component = int(self.min_component.text()) if self.min_component.text().strip() else 20
@@ -13995,7 +14012,6 @@ class FilamentDialog(QDialog):
             if downsample_factor and downsample_factor > 1:
                 data = n3d.downsample(data, downsample_factor)
 
-
             result = filaments.trace(data, kernel_spacing, max_distance, min_component, gap_tolerance, blob_sphericity, blob_volume, spine_removal, score_threshold)
 
             if downsample_factor and downsample_factor > 1:
@@ -14008,9 +14024,49 @@ class FilamentDialog(QDialog):
             self.accept()
 
         except Exception as e:
-
+            import traceback
+            print(traceback.format_exc())
             print(f"Error: {e}")
 
+    def wait_for_threshold_processing(self):
+        """
+        Opens ThresholdWindow and waits for user to process the image.
+        Returns True if completed, False if cancelled.
+        The thresholded image will be available in the main window after completion.
+        """
+        # Create event loop to wait for user
+        loop = QEventLoop()
+        result = {'completed': False}
+        
+        # Create the threshold window
+        thresh_window = ThresholdWindow(self.parent(), 0)
+
+        
+        # Connect signals
+        def on_processing_complete():
+            result['completed'] = True
+            loop.quit()
+            
+        def on_processing_cancelled():
+            result['completed'] = False
+            loop.quit()
+        
+        thresh_window.processing_complete.connect(on_processing_complete)
+        thresh_window.processing_cancelled.connect(on_processing_cancelled)
+        
+        # Show window and wait
+        thresh_window.show()
+        thresh_window.raise_()
+        thresh_window.activateWindow()
+        
+        # Block until user clicks "Apply Threshold & Continue" or "Cancel"
+        loop.exec()
+        
+        # Clean up
+        thresh_window.deleteLater()
+        
+        return result['completed']
+
 
 
 class MaskDialog(QDialog):
@@ -15139,30 +15195,40 @@ class BranchDialog(QDialog):
         self.fix = QPushButton("Auto-Correct 1")
         self.fix.setCheckable(True)
         self.fix.setChecked(False)
-        correction_layout.addWidget(QLabel("Auto-Correct Branches by Collapsing Busy Neighbors: "), 0, 0)
-        correction_layout.addWidget(self.fix, 0, 1)
+        #correction_layout.addWidget(QLabel("Auto-Correct Branches by Collapsing Busy Neighbors: "), 0, 0)
+        #correction_layout.addWidget(self.fix, 0, 1)
         
         # Fix value
         self.fix_val = QLineEdit('4')
-        correction_layout.addWidget(QLabel("Avg Degree of Nearby Branch Communities to Merge (4-6 recommended):"), 1, 0)
-        correction_layout.addWidget(self.fix_val, 1, 1)
+        #correction_layout.addWidget(QLabel("(For Auto-Correct 1) Avg Degree of Nearby Branch Communities to Merge (4-6 recommended):"), 1, 0)
+        #correction_layout.addWidget(self.fix_val, 1, 1)
         
         # Seed
         self.seed = QLineEdit('')
-        correction_layout.addWidget(QLabel("Random seed for auto correction (int - optional):"), 2, 0)
-        correction_layout.addWidget(self.seed, 2, 1)
+        #correction_layout.addWidget(QLabel("Random seed for auto correction (int - optional):"), 2, 0)
+        #correction_layout.addWidget(self.seed, 2, 1)
 
-        self.fix2 = QPushButton("Auto-Correct 2")
+        self.fix2 = QPushButton("Auto-Correct Internal Branches")
         self.fix2.setCheckable(True)
         self.fix2.setChecked(True)
         correction_layout.addWidget(QLabel("Auto-Correct Branches by Collapsing Internal Labels: "), 3, 0)
         correction_layout.addWidget(self.fix2, 3, 1)
 
-        self.fix3 = QPushButton("Correct Nontouching Branches?")
+        self.fix3 = QPushButton("Auto-Correct Nontouching Branches")
         self.fix3.setCheckable(True)
         self.fix3.setChecked(True)
-        correction_layout.addWidget(QLabel("Correct Nontouching Branches?: "), 4, 0)
+        correction_layout.addWidget(QLabel("Auto-Correct Nontouching Branches?: "), 4, 0)
         correction_layout.addWidget(self.fix3, 4, 1)
+
+        self.fix4 = QPushButton("Auto-Attempt to Reunify Main Branches?")
+        self.fix4.setCheckable(True)
+        self.fix4.setChecked(False)
+        correction_layout.addWidget(QLabel("Reunify Main Branches: "), 5, 0)
+        correction_layout.addWidget(self.fix4, 5, 1)
+
+        self.fix4_val = QLineEdit('10')
+        correction_layout.addWidget(QLabel("(For Reunify) Minimum Score to Merge? (Lower vals = More mergers, can be negative):"), 6, 0)
+        correction_layout.addWidget(self.fix4_val, 6, 1)
         
         correction_group.setLayout(correction_layout)
         main_layout.addWidget(correction_group)
@@ -15241,7 +15307,9 @@ class BranchDialog(QDialog):
             fix = self.fix.isChecked()
             fix2 = self.fix2.isChecked()
             fix3 = self.fix3.isChecked()
+            fix4 = self.fix4.isChecked()
             fix_val = float(self.fix_val.text()) if self.fix_val.text() else None
+            fix4_val = float(self.fix4_val.text()) if self.fix4_val.text() else 10
             seed = int(self.seed.text()) if self.seed.text() else None
             compute = self.compute.isChecked()
 
@@ -15260,7 +15328,12 @@ class BranchDialog(QDialog):
 
             if my_network.edges is not None and my_network.nodes is not None and my_network.id_overlay is not None:
 
-                output, verts, skeleton, endpoints = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape, compute = compute, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
+                if fix4:
+                    unify = True
+                else:
+                    unify = False
+
+                output, verts, skeleton, endpoints = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape, compute = compute, unify = unify, union_val = fix4_val, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
 
                 if fix2:
 

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/src/nettracer3d/tutorial.py

@@ -1765,6 +1765,7 @@ def setup_branch_tutorial(window):
         pre_action=open_dialog
     )
 
+    """
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix'),
         "This first auto-correction option is designed if you feel like the branch labels are generally too busy. Selecting this will have the program attempt to collapse overly-dense regions of branches into a single label. Note that this behavior is somewhat tricky to predict so I generally don't use it but feel free to give it a shot and see how it looks.",
@@ -1792,6 +1793,8 @@ def setup_branch_tutorial(window):
         action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'seed', 'setText("")')
     )
 
+    """
+
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix2'),
         "The second auto-correction option will automatically merge any internal labels that arise with their outer-neighbors. This is something that can occasionally happen with fat, trunk-like branches that are tricky to algorithmically decipher. I have found that this merge handles these issues quite well, so this option is enabled by default.",
@@ -1802,12 +1805,30 @@ def setup_branch_tutorial(window):
 
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix3'),
-        "This final auto-correction step will automatically correct any branches that aren't contiguous in space. Rarely (Depending on the segmentation, really) a branch can initially be labeled non-contiguously, which is usually not correct. This is because the 'meat' of any branch is at first labeled based on which internal filament it's closest to. So if you have a very wide branch it may rarely aquire labels of nearby smaller branches across gaps. Enabling this will split those labels into seperate regions as to not confound the connectivity graph. The largest component is considered the 'correct one' and keeps its label, while smaller components inherit the label of the largest shared border of a 'real' branch they are bordering. It is enabled here by default to mitigate any potential errors, although note this does not apply to the branchpoint networks since they don't actually utilize the branches themselves.",
+        "This auto-correction step will automatically correct any branches that aren't contiguous in space. Rarely (Depending on the segmentation, really) a branch can initially be labeled non-contiguously, which is usually not correct. This is because the 'meat' of any branch is at first labeled based on which internal filament it's closest to. So if you have a very wide branch it may rarely aquire labels of nearby smaller branches across gaps. Enabling this will split those labels into seperate regions as to not confound the connectivity graph. The largest component is considered the 'correct one' and keeps its label, while smaller components inherit the label of the largest shared border of a 'real' branch they are bordering. It is enabled here by default to mitigate any potential errors, although note this does not apply to the branchpoint networks since they don't actually utilize the branches themselves.",
         highlight_type=None,
         message_position="beside",
         pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix3', 'click()')
         )
 
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix4'),
+        "This final auto-correction step will try to automatically merge any similarly sized branches moving in the same direction, instead of just letting a larger branch with many sub-branches get chopped up. It is off by default because of its less predictable behavior, although its good if you want your branches to be more continuous. Just note each of these fixes does add extra processing time.",
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix4', 'click()'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix4', 'toggle()')
+        )
+
+    tutorial.add_step(
+        MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'fix4_val'),
+        "This threshold values controls how likely a junction is to merge any pair of its nearby branches. Regardless of what you enter here, only two branches at a time can merge at a junction. Values between 20-40 are more meaningful, while those lower tend to merge everything and those higher usually emrge nothing.",
+        highlight_type=None,
+        message_position="beside",
+        pre_action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix4_val', 'setText("FLOAT!")'),
+        action=MenuHelper.create_widget_interaction(tutorial, 'branch_dialog', 'fix4_val', 'setText("")')
+        )
+
     tutorial.add_step(
         MenuHelper.create_widget_getter(tutorial, 'branch_dialog', 'down_factor'),
         "This integer value can be used to temporarily downsample the image while creating branches. Aside from speeding up the process, this may actually improve branch-labeling behavior with thick branches but will lose labeling for smaller branches (instead merging them with nearby thicker branches they arise from). It is disabled by default. Larger values will downsample more aggressively.",

{nettracer3d-1.1.9 → nettracer3d-1.2.3/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.1.9
+Version: 1.2.3
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,12 +110,8 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.1.9 Updates --
+-- Version 1.2.3 Updates --
 
-	* Fixed saving of Boolean True/False arrays.
-	* Fixed branch functions not working correctly when a temporary downsample was being applied
-	* Added the 'filaments tracer' which can be used to improve vessel based segmentations
-	* Removed options for 'cubic' downsampling during processing as this option actually made outputs worse.
-	* Rearranged the 'Analyze -> Stats' menu
+	* Tweaked the 'branch unification params' - now hard rejects any sharp forks in the branches so branches will mostly be straight.
 	
 	

{nettracer3d-1.1.9 → nettracer3d-1.2.3}/src/nettracer3d.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/nettracer3d/__init__.py
+src/nettracer3d/branch_stitcher.py
 src/nettracer3d/cellpose_manager.py
 src/nettracer3d/community_extractor.py
 src/nettracer3d/excelotron.py