nettracer3d 0.2.7__tar.gz → 0.2.8__tar.gz

{nettracer3d-0.2.7/src/nettracer3d.egg-info → nettracer3d-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.7
+Version: 0.2.8
 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

{nettracer3d-0.2.7 → nettracer3d-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.2.7"
+version = "0.2.8"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]

{nettracer3d-0.2.7 → nettracer3d-0.2.8}/src/nettracer3d/community_extractor.py

@@ -2,7 +2,7 @@ import pandas as pd
 import networkx as nx
 import tifffile
 import numpy as np
-from typing import List, Dict, Tuple
+from typing import List, Dict, Tuple, Union, Any
 from collections import defaultdict, Counter
 from networkx.algorithms import community
 from scipy import ndimage
@@ -648,7 +648,69 @@ def find_hub_nodes(G: nx.Graph, proportion: float = 0.1) -> List:
     
     return hub_nodes
 
+def get_color_name_mapping():
+    """Return a dictionary of common colors and their RGB values."""
+    return {
+        'red': (255, 0, 0),
+        'green': (0, 255, 0),
+        'blue': (0, 0, 255),
+        'yellow': (255, 255, 0),
+        'cyan': (0, 255, 255),
+        'magenta': (255, 0, 255),
+        'purple': (128, 0, 128),
+        'orange': (255, 165, 0),
+        'brown': (165, 42, 42),
+        'pink': (255, 192, 203),
+        'navy': (0, 0, 128),
+        'teal': (0, 128, 128),
+        'olive': (128, 128, 0),
+        'maroon': (128, 0, 0),
+        'lime': (50, 205, 50),
+        'indigo': (75, 0, 130),
+        'violet': (238, 130, 238),
+        'coral': (255, 127, 80),
+        'turquoise': (64, 224, 208),
+        'gold': (255, 215, 0)
+    }
+
+def rgb_to_color_name(rgb: Tuple[int, int, int]) -> str:
+    """
+    Convert an RGB tuple to its nearest color name.
+    
+    Args:
+        rgb: Tuple of (r, g, b) values
+        
+    Returns:
+        str: Name of the closest matching color
+    """
+    color_map = get_color_name_mapping()
+    
+    # Convert input RGB to numpy array
+    rgb_array = np.array(rgb)
+    
+    # Calculate Euclidean distance to all known colors
+    min_distance = float('inf')
+    closest_color = None
+    
+    for color_name, color_rgb in color_map.items():
+        distance = np.sqrt(np.sum((rgb_array - np.array(color_rgb)) ** 2))
+        if distance < min_distance:
+            min_distance = distance
+            closest_color = color_name
+            
+    return closest_color
 
+def convert_node_colors_to_names(node_to_color: Dict[int, Tuple[int, int, int]]) -> Dict[int, str]:
+    """
+    Convert a dictionary of node-to-RGB mappings to node-to-color-name mappings.
+    
+    Args:
+        node_to_color: Dictionary mapping node IDs to RGB tuples
+        
+    Returns:
+        Dictionary mapping node IDs to color names
+    """
+    return {node: rgb_to_color_name(color) for node, color in node_to_color.items()}
 
 def generate_distinct_colors(n_colors: int) -> List[Tuple[int, int, int]]:
     """
@@ -721,33 +783,55 @@ def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.nd
             mask = labeled_array == label
             for i in range(3):  # RGB channels
                 rgb_array[mask, i] = node_to_color[label][i]
+
+    node_to_color_names = convert_node_colors_to_names(community_to_color)
+
     
-    return rgb_array
+    return rgb_array, node_to_color_names
 
-def assign_community_grays(community_dict: Dict[int, int], labeled_array: np.ndarray) -> np.ndarray:
+def assign_community_grays(community_dict: Dict[int, Union[int, str, Any]], labeled_array: np.ndarray) -> np.ndarray:
     """
-    Assign distinct grayscale values to communities.
+    Assign grayscale values to communities. For numeric communities, uses the community
+    number directly. For string/other communities, assigns sequential values.
     
     Args:
-        community_dict: Dictionary mapping node IDs to community numbers
+        community_dict: Dictionary mapping node IDs to community identifiers (numbers or strings)
         labeled_array: 3D numpy array with labels corresponding to node IDs
     
     Returns:
-        grayscale numpy array
+        tuple: (grayscale numpy array, mapping of node IDs to assigned values)
     """
-    # Get unique communities
-    communities = set(community_dict.values())
-    n_communities = len(communities)
+    # Determine if we're dealing with numeric or string communities
+    sample_value = next(iter(community_dict.values()))
+    is_numeric = isinstance(sample_value, (int, float))
     
-    # Generate evenly spaced grayscale values (excluding pure black for background)
-    gray_values = np.linspace(1, 255, n_communities, dtype=np.uint8)
+    if is_numeric:
+        # For numeric communities, use values directly
+        node_to_gray = community_dict
+        max_val = max(community_dict.values())
+    else:
+        # For string/other communities, assign sequential values
+        unique_communities = sorted(set(community_dict.values()))
+        community_to_value = {comm: i+1 for i, comm in enumerate(unique_communities)}
+        node_to_gray = {node: community_to_value[comm] for node, comm in community_dict.items()}
+        max_val = len(unique_communities)
     
-    # Create direct mapping from node ID to grayscale value
-    node_to_gray = {node: gray_values[list(communities).index(comm)] 
-                   for node, comm in community_dict.items()}
+    # Choose appropriate dtype based on maximum value
+    if max_val <= 255:
+        dtype = np.uint8
+    elif max_val <= 65535:
+        dtype = np.uint16
+    else:
+        dtype = np.uint32
     
     # Create output array
-    gray_array = np.zeros_like(labeled_array, dtype=np.uint8)
+    gray_array = np.zeros_like(labeled_array, dtype=dtype)
+    
+    # Create mapping of unique communities to their grayscale values
+    if is_numeric:
+        community_to_gray = {comm: comm for comm in set(community_dict.values())}
+    else:
+        community_to_gray = {comm: i+1 for i, comm in enumerate(sorted(set(community_dict.values())))}
     
     # Use numpy's vectorized operations for faster assignment
     unique_labels = np.unique(labeled_array)
@@ -755,7 +839,7 @@ def assign_community_grays(community_dict: Dict[int, int], labeled_array: np.nda
         if label in node_to_gray:
             gray_array[labeled_array == label] = node_to_gray[label]
     
-    return gray_array
+    return gray_array, community_to_gray
 
 
 if __name__ == "__main__":

{nettracer3d-0.2.7 → nettracer3d-0.2.8}/src/nettracer3d/morphology.py

@@ -270,51 +270,56 @@ def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     return volumes
 
 
-def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale):
+def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root):
 
-    
+    if 0 in targets:
+        targets.remove(0)
     targets = np.isin(nodes, targets)
     targets = nettracer.binarize(targets)
     
     dilate_xy, dilate_z = nettracer.dilation_length_to_pixels(xy_scale, z_scale, search, search)
-    print(f"Dilation parameters - xy: {dilate_xy}, z: {dilate_z}")
     
-    targets = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
-    targets = targets != 0
-    print(f"After dilation - targets shape: {targets.shape}, sum: {np.sum(targets)}")
+    dilated = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
+    dilated = dilated - targets #technically we dont need the cores
+    search_vol = np.count_nonzero(dilated) * xy_scale * xy_scale * z_scale #need this for density
+    targets = dilated != 0
+    del dilated
+
     
     targets = targets * nodes
-    print(f"After multiplication with nodes - unique values in targets: {np.unique(targets)}")
     
     unique, counts = np.unique(targets, return_counts=True)
     count_dict = dict(zip(unique, counts))
-    print(f"Initial count_dict: {count_dict}")
+    print(count_dict)
     
     del count_dict[0]
-    print(f"count_dict after removing zeros: {count_dict}")
     
     unique, counts = np.unique(nodes, return_counts=True)
     total_dict = dict(zip(unique, counts))
-    print(f"Initial total_dict: {total_dict}")
-    
+    print(total_dict)
+
     del total_dict[0]
-    print(f"total_dict after removing zeros: {total_dict}")
     
-    print(f"id_dict keys: {list(id_dict.keys())}")
-    print(f"Initial neighborhood_dict: {neighborhood_dict}")
-    print(f"Initial totals: {totals}")
     
     for label in total_dict:
         if label in id_dict:
             if label in count_dict:
                 neighborhood_dict[id_dict[label]] += count_dict[label]
-                print(f"Updated neighborhood_dict[{id_dict[label]}] with count {count_dict[label]}")
             totals[id_dict[label]] += total_dict[label]
-            print(f"Updated totals[{id_dict[label]}] with total {total_dict[label]}")
+
+
+    try:
+        del neighborhood_dict[root]  #no good way to get this
+        del totals[root] #no good way to get this
+    except:
+        pass
     
-    print(f"Final neighborhood_dict: {neighborhood_dict}")
-    print(f"Final totals: {totals}")
-    return neighborhood_dict, totals
+    volume = nodes.shape[0] * nodes.shape[1] * nodes.shape[2] * xy_scale * xy_scale * z_scale
+    densities = {}
+    for nodeid, amount in totals.items():
+        densities[nodeid] = (neighborhood_dict[nodeid]/search_vol)/(amount/volume)
+
+    return neighborhood_dict, totals, densities
 
 
 

{nettracer3d-0.2.7 → nettracer3d-0.2.8}/src/nettracer3d/nettracer.py

@@ -1383,7 +1383,7 @@ def binarize(arrayimage, directory = None):
 
     return arrayimage
 
-def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False):
+def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False):
     """
     Can be used to dilate a binary image in 3D. Dilated output will be saved to the active directory if none is specified. Note that dilation is done with single-instance kernels and not iterations, and therefore
     objects will lose their shape somewhat and become cube-ish if the 'amount' param is ever significantly larger than the objects in quesiton.
@@ -1408,13 +1408,15 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
     if len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
 
-    if not fast_dil:
+    if not fast_dil and not recursive:
         arrayimage = (dilate_3D(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
         if np.max(arrayimage) == 1:
             arrayimage = arrayimage * 255
-
-    else:
+    elif not recursive:
         arrayimage = (dilate_3D_old(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+    else:
+        arrayimage = (dilate_3D_recursive(arrayimage, dilate_xy, dilate_xy, dilate_z)) * 255
+
 
 
     if type(image) == str:
@@ -1935,6 +1937,9 @@ def encapsulate(parent_dir = None, name = None):
     
     return new_folder_path
 
+
+
+
 #THE 3D NETWORK CLASS
 
 class Network_3D:
@@ -3906,25 +3911,37 @@ class Network_3D:
         return hubs, hub_img
 
 
-    def extract_communities(self, color_code = True, down_factor = None):
+    def extract_communities(self, color_code = True, down_factor = None, identities = False):
 
         if down_factor is not None:
             original_shape = self._nodes.shape
             temp = downsample(self._nodes, down_factor)
             if color_code:
-                image = community_extractor.assign_community_colors(self.communities, temp)
+                if not identities:
+                    image, output = community_extractor.assign_community_colors(self.communities, temp)
+                else:
+                    image, output = community_extractor.assign_community_colors(self.node_identities, temp)
             else:
-                image = community_extractor.assign_community_grays(self.communities, temp)
+                if not identities:
+                    image, output = community_extractor.assign_community_grays(self.communities, temp)
+                else:
+                    image, output = community_extractor.assign_community_grays(self.node_identities, temp)
             image = upsample_with_padding(image, down_factor, original_shape)
         else:
 
             if color_code:
-                image = community_extractor.assign_community_colors(self.communities, self._nodes)
+                if not identities:
+                    image, output = community_extractor.assign_community_colors(self.communities, self._nodes)
+                else:
+                    image, output = community_extractor.assign_community_colors(self.node_identities, self._nodes)
             else:
-                image = community_extractor.assign_community_grays(self.communities, self._nodes)
+                if not identities:
+                    image, output = community_extractor.assign_community_grays(self.communities, self._nodes)
+                else:
+                    image, output = community_extractor.assign_community_grays(self.node_identities, self._nodes)
 
 
-        return image
+        return image, output
         
 
 
@@ -4072,6 +4089,14 @@ class Network_3D:
         except:
             stats['degree_assortativity'] = "Failed to compute"
 
+        try:
+            nodes = np.unique(self._nodes)
+            if nodes[0] == 0:
+                nodes = np.delete(nodes, 0)
+            stats['Unconnected nodes (left out from node image)'] = (len(nodes) - len(G.nodes()))
+        except:
+            stats['Unconnected nodes (left out from node image)'] = "Failed to compute"
+
         
         return stats
 
@@ -4114,9 +4139,9 @@ class Network_3D:
 
 
         elif mode == 1: #Search neighborhoods morphologically, obtain densities
-            neighborhood_dict, total_dict = morphology.search_neighbor_ids(self._nodes, targets, node_identities, neighborhood_dict, total_dict, search, self._xy_scale, self._z_scale)
-            title1 = f'Volumetric Neighborhood Distribution of Nodes in image from Nodes: {root}'
-            title2 = f'Density Distribution of Nodes in image from Nodes {root} as a proportion of total node volume of that ID'
+            neighborhood_dict, total_dict, densities = morphology.search_neighbor_ids(self._nodes, targets, node_identities, neighborhood_dict, total_dict, search, self._xy_scale, self._z_scale, root)
+            title1 = f'Volumetric Neighborhood Distribution of Nodes in image that are {search} from nodes: {root}'
+            title2 = f'Density Distribution of Nodes in image that are {search} from Nodes {root} as a proportion of total node volume of that ID'
 
 
         for identity in neighborhood_dict:
@@ -4126,11 +4151,13 @@ class Network_3D:
 
         network_analysis.create_bar_graph(proportion_dict, title2, "Node Identity", "Proportion", directory=directory)
 
+        try:
+            network_analysis.create_bar_graph(densities, f'Clustering Factor of Node Identities with {search} from nodes {root}', "Node Identity", "Density Search/Density Total", directory=directory)
+        except:
+            densities = None
 
 
-
-
-        return neighborhood_dict, proportion_dict, title1, title2
+        return neighborhood_dict, proportion_dict, title1, title2, densities
 
 
 

{nettracer3d-0.2.7 → nettracer3d-0.2.8}/src/nettracer3d/nettracer_gui.py

@@ -555,6 +555,8 @@ class ImageViewerWindow(QMainWindow):
                     if len(self.clicked_values['nodes']) > 1 or len(self.clicked_values['edges']) > 1:
                         combine_obj = highlight_menu.addAction("Combine Object Labels")
                         combine_obj.triggered.connect(self.handle_combine)
+                    split_obj = highlight_menu.addAction("Split Non-Touching Labels")
+                    split_obj.triggered.connect(self.handle_seperate)
                     delete_obj = highlight_menu.addAction("Delete Selection")
                     delete_obj.triggered.connect(self.handle_delete)
                     if len(self.clicked_values['nodes']) > 1:
@@ -991,6 +993,58 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"Error: {e}")
 
+    def handle_info(self, sort = 'node'):
+
+        try:
+
+            info_dict = {}
+
+            if sort == 'node':
+
+                label = self.clicked_values['nodes'][-1]
+
+                info_dict['Label'] = label
+
+                info_dict['Object Class'] = 'Node'
+
+                if my_network.node_identities is not None:
+                    info_dict['ID'] = my_network.node_identities[label]
+
+                if my_network.network is not None:
+                    info_dict['Degree'] = my_network.network.degree(label)
+
+                if my_network.communities is not None:
+                    info_dict['Community'] = my_network.communities[label]
+
+                if my_network.node_centroids is not None:
+                    info_dict['Centroid'] = my_network.node_centroids[label]
+
+                if self.volume_dict[0] is not None:
+                    info_dict['Volume'] = self.volume_dict[0][label]
+
+
+            elif sort == 'edge':
+
+                label = self.clicked_values['edges'][-1]
+
+                info_dict['Label'] = label
+
+                info_dict['Object Class'] = 'Edge'
+
+                if my_network.edge_centroids is not None:
+                    info_dict['Centroid'] = my_network.edge_centroids[label]
+
+                if self.volume_dict[1] is not None:
+                    info_dict['Volume'] = self.volume_dict[1][label]
+
+            self.format_for_upperright_table(info_dict, title = f'Info on Object')
+
+        except:
+            pass
+
+
+
+
     def handle_combine(self):
 
         try:
@@ -1040,12 +1094,73 @@ class ImageViewerWindow(QMainWindow):
                     for column in range(model.columnCount(None)):
                         self.network_table.resizeColumnToContents(column)
 
+                self.highlight_overlay = None
+                self.update_display()
+
+                self.show_centroid_dialog()
+
             except Exception as e:
                 print(f"Error, could not update network: {e}")
 
+
         except Exception as e:
             print(f"An error has occured: {e}")
 
+    def handle_seperate(self):
+
+        try:
+
+            if len(self.clicked_values['nodes']) > 0:
+                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'])
+                max_val = np.max(my_network.nodes)
+                self.highlight_overlay, num = n3d.label_objects(self.highlight_overlay)
+
+                node_bools = self.highlight_overlay != 0
+                new_max = num + max_val
+                self.highlight_overlay = self.highlight_overlay + max_val
+                self.highlight_overlay = self.highlight_overlay * node_bools
+                if new_max < 256:
+                    dtype = np.uint8
+                elif new_max < 65536:
+                    dtype = np.uint16
+                else:
+                    dtype = np.uint32
+
+                self.highlight_overlay = self.highlight_overlay.astype(dtype)
+                my_network.nodes = my_network.nodes + self.highlight_overlay
+                self.load_channel(0, my_network.nodes, True)
+
+            if len(self.clicked_values['edges']) > 0:
+                self.create_highlight_overlay(edge_indices = self.clicked_values['edges'])
+                max_val = np.max(my_network.edges)
+                self.highlight_overlay, num = n3d.label_objects(self.highlight_overlay)
+                node_bools = self.highlight_overlay != 0
+                new_max = num + max_val
+
+                self.highlight_overlay = self.highlight_overlay + max_val
+                self.highlight_overlay = self.highlight_overlay * node_bools
+                if new_max < 256:
+                    dtype = np.uint8
+                elif new_max < 65536:
+                    dtype = np.uint16
+                else:
+                    dtype = np.uint32
+
+                self.highlight_overlay = self.highlight_overlay.astype(dtype)
+                my_network.edges = my_network.edges + self.highlight_overlay
+                self.load_channel(1, my_network.edges, True)
+            self.highlight_overlay = None
+            self.update_display()
+            print("Network is not updated automatically, please recompute if necesarry. Identities are not automatically updated.")
+            self.show_centroid_dialog()
+
+        except Exception as e:
+            print(f"Error seperating: {e}")
+
+
+
+
+
     def handle_delete(self):
 
         try:
@@ -1399,6 +1514,7 @@ class ImageViewerWindow(QMainWindow):
                         # Try to highlight the last selected value in tables
                         if self.clicked_values['edges']:
                             self.highlight_value_in_tables(self.clicked_values['edges'][-1])
+
             
             elif not self.selecting and self.selection_start:  # If we had a click but never started selection
                 # Handle as a normal click
@@ -1564,6 +1680,7 @@ class ImageViewerWindow(QMainWindow):
                             self.clicked_values = {'nodes': [clicked_value], 'edges': []}
                         # Get latest value (or the last remaining one if we just removed an item)
                         latest_value = self.clicked_values['nodes'][-1] if self.clicked_values['nodes'] else None
+                        self.handle_info('node')
                     elif self.active_channel == 1:
                         if ctrl_pressed:
                             if clicked_value in self.clicked_values['edges']:
@@ -1577,6 +1694,8 @@ class ImageViewerWindow(QMainWindow):
                             self.clicked_values = {'nodes': [], 'edges': [clicked_value]}
                         # Get latest value (or the last remaining one if we just removed an item)
                         latest_value = self.clicked_values['edges'][-1] if self.clicked_values['edges'] else None
+                        self.handle_info('edge')
+
                     
                     # Try to find and highlight the latest value in the current table
                     try:
@@ -1689,7 +1808,9 @@ class ImageViewerWindow(QMainWindow):
         mother_action = overlay_menu.addAction("Get Mother Nodes")
         mother_action.triggered.connect(self.show_mother_dialog)
         community_code_action = overlay_menu.addAction("Code Communities")
-        community_code_action.triggered.connect(self.show_code_dialog)
+        community_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Community'))
+        id_code_action = overlay_menu.addAction("Code Identities")
+        id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
 
 
         # Process menu
@@ -2050,6 +2171,37 @@ class ImageViewerWindow(QMainWindow):
     def load_misc(self, sort):
         """Loads various things"""
 
+        def uncork(my_dict, trumper = None):
+
+            if trumper is None:
+                for thing in my_dict:
+                    val = my_dict[thing]
+                    new_val = val[0]
+                    for i in range(1, len(val)):
+                        try:
+                            new_val += f" AND {val[i]}"
+                        except:
+                            break
+                    my_dict[thing] = new_val
+            elif trumper == '-':
+                for key, value in my_dict.items():
+                    my_dict[key] = value[0]
+            else:
+                for thing in my_dict:
+                    val = my_dict[thing]
+                    if trumper in val:
+                        my_dict[thing] = trumper
+                    else:
+                        new_val = val[0]
+                        for i in range(1, len(val)):
+                            try:
+                                new_val += f" AND {val[i]}"
+                            except:
+                                break
+                        my_dict[thing] = new_val
+
+            return my_dict
+
         if sort != 'Merge Nodes':
 
             try:
@@ -2058,13 +2210,32 @@ class ImageViewerWindow(QMainWindow):
                     self,
                     f"Load {sort}",
                     "",
-                    "Spreadsheets (*.xlsx *.csv)"
+                    "Spreadsheets (*.xlsx *.csv *.json)"
                 )
 
                 try:
                     if sort == 'Node Identities':
                         my_network.load_node_identities(file_path = filename)
 
+                        first_value = list(my_network.node_identities.values())[0]  # Check that there are not multiple IDs
+                        if isinstance(first_value, (list, tuple)):
+                            trump_value, ok = QInputDialog.getText(
+                                self,
+                                'Multiple IDs Detected',
+                                'The node identities appear to contain multiple ids per node in a list.\n'
+                                'If you desire one node ID to trump all others, enter it here.\n'
+                                '(Enter "-" to have the first IDs trump all others or press x to skip)'
+                            )
+                            if not ok or trump_value.strip() == '':
+                                trump_value = None
+                            elif trump_value.upper() == '-':
+                                trump_value = '-'
+                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
+                        else:
+                            trump_value = None
+                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
+
+
                         if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
                             try:
                                 self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
@@ -2091,9 +2262,13 @@ class ImageViewerWindow(QMainWindow):
 
 
                 except Exception as e:
+                    import traceback
+                    print(traceback.format_exc())
                     print(f"An error has occured: {e}")
 
             except Exception as e:
+                import traceback
+                print(traceback.format_exc())
                 QMessageBox.critical(
                     self,
                     "Error Loading",
@@ -2245,7 +2420,7 @@ class ImageViewerWindow(QMainWindow):
                 self,
                 f"Load Network",
                 "",
-                "Spreadsheets (*.xlsx *.csv)"
+                "Spreadsheets (*.xlsx *.csv *.json)"
             )
 
             my_network.load_network(file_path = filename)
@@ -2294,7 +2469,6 @@ class ImageViewerWindow(QMainWindow):
                     "TIFF Files (*.tif *.tiff)"
                 )
                 self.channel_data[channel_index] = tifffile.imread(filename)
-                print(self.channel_data[channel_index].shape)
                 if len(self.channel_data[channel_index].shape) == 2:
                     #self.channel_data[channel_index] = np.stack((self.channel_data[channel_index], self.channel_data[channel_index]), axis = 0) #currently handle 2d arrays by just making them 3d
                     self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
@@ -2746,8 +2920,8 @@ class ImageViewerWindow(QMainWindow):
         dialog = MotherDialog(self)
         dialog.exec()
 
-    def show_code_dialog(self):
-        dialog = CodeDialog(self)
+    def show_code_dialog(self, sort = 'Community'):
+        dialog = CodeDialog(self, sort = sort)
         dialog.exec()
 
 
@@ -4134,16 +4308,19 @@ class NeighborIdentityDialog(QDialog):
 
         layout = QFormLayout(self)
 
-        self.root = QComboBox()
-        self.root.addItems(list(set(my_network.node_identities.values())))  
-        self.root.setCurrentIndex(0)
-        layout.addRow("Root Identity to Search for Neighbor's IDs (search uses nodes of this ID, finds what IDs they connect to", self.root)
+        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 Neighbor's IDs (search uses nodes of this ID, finds what IDs they connect to", self.root)
+        else:
+            self.root = None
 
         self.directory = QLineEdit("")
         layout.addRow("Output Directory:", self.directory)
 
         self.mode = QComboBox()
-        self.mode.addItems(["From Network - Based on Absolute Connectivity", "Use Labeled Nodes - Based on Neighborhood Densities"])
+        self.mode.addItems(["From Network - Based on Absolute Connectivity", "Use Labeled Nodes - Based on Morphological Neighborhood Densities"])
         self.mode.setCurrentIndex(0)
         layout.addRow("Mode", self.mode)
 
@@ -4157,21 +4334,33 @@ class NeighborIdentityDialog(QDialog):
 
     def neighborids(self):
 
-        root = self.root.currentText()
+        try:
 
-        directory = self.directory.text() if self.directory.text().strip() else None
+            try:
+                root = self.root.currentText()
+            except:
+                pass
 
-        mode = self.mode.currentIndex()
+            directory = self.directory.text() if self.directory.text().strip() else None
 
-        search = float(self.search.text()) if self.search.text().strip() else 0
+            mode = self.mode.currentIndex()
 
+            search = float(self.search.text()) if self.search.text().strip() else 0
 
-        result, result2, title1, title2 = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search)
 
-        self.parent().format_for_upperright_table(result, 'Node Identity', 'Amount', title = title1)
-        self.parent().format_for_upperright_table(result2, 'Node Identity', 'Proportion', title = title2)
+            result, result2, title1, title2, densities = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search)
+
+            self.parent().format_for_upperright_table(result, 'Node Identity', 'Amount', title = title1)
+            self.parent().format_for_upperright_table(result2, 'Node Identity', 'Proportion', title = title2)
+
+            if mode == 1:
+
+                self.parent().format_for_upperright_table(densities, 'Node Identity', 'Density in search/density total', title = f'Clustering Factor of Node Identities with {search} from nodes {root}')
 
-        self.accept()
+
+            self.accept()
+        except Exception as e:
+            print(f"Error: {e}")
 
 
 
@@ -4521,14 +4710,16 @@ class MotherDialog(QDialog):
 
 class CodeDialog(QDialog):
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, sort = 'Community'):
 
         super().__init__(parent)
-        self.setWindowTitle("Community Code Parameters (Will go to Overlay2)")
+        self.setWindowTitle(f"{sort} Code Parameters (Will go to Overlay2)")
         self.setModal(True)
 
         layout = QFormLayout(self)
 
+        self.sort = sort
+
         self.down_factor = QLineEdit("")
         layout.addRow("down_factor (for speeding up overlay generation - optional):", self.down_factor)
 
@@ -4540,7 +4731,7 @@ class CodeDialog(QDialog):
 
 
         # Add Run button
-        run_button = QPushButton("Community Code")
+        run_button = QPushButton(f"{sort} Code")
         run_button.clicked.connect(self.code)
         layout.addWidget(run_button)
 
@@ -4553,16 +4744,27 @@ class CodeDialog(QDialog):
             down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
 
 
-
-            if my_network.communities is None:
-                self.parent().show_partition_dialog()
+            if self.sort == 'Community':
                 if my_network.communities is None:
-                    return
+                    self.parent().show_partition_dialog()
+                    if my_network.communities is None:
+                        return
+            elif my_network.node_identities is None:
+                print("Node identities are not set")
+                return
 
-            if mode == 0:
-                image = my_network.extract_communities(down_factor = down_factor)
-            elif mode == 1:
-                image = my_network.extract_communities(color_code = False, down_factor = down_factor)
+            if self.sort == 'Community':
+                if mode == 0:
+                    image, output = my_network.extract_communities(down_factor = down_factor)
+                elif mode == 1:
+                    image, output = my_network.extract_communities(color_code = False, down_factor = down_factor)
+            else:
+                if mode == 0:
+                    image, output = my_network.extract_communities(down_factor = down_factor, identities = True)
+                elif mode == 1:
+                    image, output = my_network.extract_communities(color_code = False, down_factor = down_factor, identities = True)
+
+            self.parent().format_for_upperright_table(output, f'{self.sort} Id', f'Encoding Val: {self.sort}', 'Legend')
 
 
             self.parent().load_channel(3, image, True)
@@ -4570,6 +4772,8 @@ class CodeDialog(QDialog):
 
         except Exception as e:
             print(f"An error has occurred: {e}")
+            import traceback
+            print(traceback.format_exc())
 
 
 
@@ -5052,7 +5256,7 @@ class DilateDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Binary Dilation", "Preserve Labels (slower)"])
+        self.mode_selector.addItems(["Binary Dilation", "Preserve Labels (slower)", "Recursive Binary Dilation (Use if the dilation radius is much larger than your objects)"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -5093,12 +5297,18 @@ class DilateDialog(QDialog):
                 self.accept()
                 return
 
+            if accepted_mode == 2:
+                recursive = True
+            else:
+                recursive = False
+
             # Call dilate method with parameters
             result = n3d.dilate(
                 active_data,
                 amount,
                 xy_scale = xy_scale,
                 z_scale = z_scale,
+                recursive = recursive
             )
 
             # Update both the display data and the network object

{nettracer3d-0.2.7 → nettracer3d-0.2.8}/src/nettracer3d/network_analysis.py

@@ -1,5 +1,6 @@
 import pandas as pd
 import networkx as nx
+import json
 import tifffile
 import numpy as np
 from networkx.algorithms import community
@@ -105,6 +106,25 @@ def open_network(excel_file_path):
 
 def read_excel_to_lists(file_path, sheet_name=0):
     """Convert a pd dataframe to lists. Handles both .xlsx and .csv files"""
+    def load_json_to_list(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = [[],[],[]]
+        for i in data[0]:
+            try:
+                converted_data[0].append(int(data[0][i]))
+                converted_data[1].append(int(data[1][i]))
+                try:
+                    converted_data[2].append(int(data[2][i]))
+                except IndexError:
+                    converted_data[2].append(0)
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
+
     if type(file_path) == str:
         # Check file extension
         if file_path.lower().endswith('.xlsx'):
@@ -115,8 +135,11 @@ def read_excel_to_lists(file_path, sheet_name=0):
             # Read the CSV file into a DataFrame without headers
             df = pd.read_csv(file_path, header=None)
             df = df.drop(0)
+        elif file_path.lower().endswith('.json'):
+            df = load_json_to_list(file_path)
+            return df
         else:
-            raise ValueError("File must be either .xlsx or .csv format")
+            raise ValueError("File must be either .xlsx, .csv, or .json format")
     else:
         df = file_path
 
@@ -134,7 +157,7 @@ def read_excel_to_lists(file_path, sheet_name=0):
         try:
             master_list[2].extend(data_lists[i+2])
         except IndexError:
-            pass
+            master_list[2].extend(0)
             
     return master_list
 
@@ -402,13 +425,28 @@ def read_centroids_to_dict(file_path):
     Returns:
     dict: Dictionary with first column as keys and next three columns as numpy array values
     """
+    def load_json_to_dict(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = {}
+        for k, v in data.items():
+            try:
+                converted_data[int(k)] = v
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
     # Check file extension
     if file_path.lower().endswith('.xlsx'):
         df = pd.read_excel(file_path)
     elif file_path.lower().endswith('.csv'):
         df = pd.read_csv(file_path)
+    elif file_path.lower().endswith('.json'):
+        df = load_json_to_dict(file_path)
     else:
-        raise ValueError("Unsupported file format. Please provide either .xlsx or .csv file")
+        raise ValueError("Unsupported file format. Please provide either .xlsx, .csv, or .json file")
     
     # Initialize an empty dictionary
     data_dict = {}
@@ -434,13 +472,30 @@ def read_excel_to_singval_dict(file_path):
     Returns:
     dict: Dictionary with first column as keys and second column as values
     """
+    def load_json_to_dict(filename):
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        # Convert only numeric strings to integers, leave other strings as is
+        converted_data = {}
+        for k, v in data.items():
+            try:
+                converted_data[int(k)] = v
+            except ValueError:
+                converted_data[k] = v
+        
+        return converted_data
+
     # Check file extension and read accordingly
     if file_path.lower().endswith('.xlsx'):
         df = pd.read_excel(file_path)
     elif file_path.lower().endswith('.csv'):
         df = pd.read_csv(file_path)
+    elif file_path.lower().endswith('.json'):
+        df = load_json_to_dict(file_path)
+        return df
     else:
-        raise ValueError("Unsupported file format. Please provide either .xlsx or .csv file")
+        raise ValueError("Unsupported file format. Please provide either .xlsx, .csv, or .json file")
     
     # Convert the DataFrame to a dictionary
     data_dict = {}

{nettracer3d-0.2.7 → nettracer3d-0.2.8/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.2.7
+Version: 0.2.8
 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