nettracer3d 1.0.1__tar.gz → 1.0.3__tar.gz

{nettracer3d-1.0.1/src/nettracer3d.egg-info → nettracer3d-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.1
+Version: 1.0.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,6 +110,6 @@ 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.0.1 Updates --
+-- Version 1.0.3 Updates --
 
-	* Bug fixes, mainly
+	* Some small bug fixes and adjustments

{nettracer3d-1.0.1 → nettracer3d-1.0.3}/README.md

@@ -65,6 +65,6 @@ 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.0.1 Updates --
+-- Version 1.0.3 Updates --
 
-	* Bug fixes, mainly
+	* Some small bug fixes and adjustments

{nettracer3d-1.0.1 → nettracer3d-1.0.3}/pyproject.toml

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

{nettracer3d-1.0.1 → nettracer3d-1.0.3}/src/nettracer3d/neighborhoods.py

@@ -8,7 +8,8 @@ from matplotlib.colors import LinearSegmentedColormap
 from sklearn.cluster import DBSCAN
 from sklearn.neighbors import NearestNeighbors
 import matplotlib.colors as mcolors
-
+from collections import Counter
+from . import community_extractor
 
 
 import os
@@ -992,60 +993,63 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
                 node_to_intensity[node_id] = node_intensity_clean[node_id]
         
         # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
-        def intensity_to_rgb(intensity, min_val, max_val):
-            """Convert intensity value to RGB using RdBu_r colormap logic, centered at 0"""
+        def intensity_to_rgba(intensity, min_val, max_val):
+            """Convert intensity value to RGBA using RdBu_r colormap logic, centered at 0"""
             
             # Handle edge case where all values are the same
             if max_val == min_val:
                 if intensity == 0:
-                    return np.array([255, 255, 255], dtype=np.uint8)  # White for 0
+                    return np.array([255, 255, 255, 0], dtype=np.uint8)  # Transparent white for 0
                 elif intensity > 0:
-                    return np.array([255, 200, 200], dtype=np.uint8)  # Light red for positive
+                    return np.array([255, 200, 200, 255], dtype=np.uint8)  # Opaque light red for positive
                 else:
-                    return np.array([200, 200, 255], dtype=np.uint8)  # Light blue for negative
+                    return np.array([200, 200, 255, 255], dtype=np.uint8)  # Opaque light blue for negative
             
             # Find the maximum absolute value for symmetric scaling around 0
             max_abs = max(abs(min_val), abs(max_val))
             
-            # If max_abs is 0, everything is 0, so return white
+            # If max_abs is 0, everything is 0, so return transparent
             if max_abs == 0:
-                return np.array([255, 255, 255], dtype=np.uint8)  # White
+                return np.array([255, 255, 255, 0], dtype=np.uint8)  # Transparent white
             
             # Normalize intensity to -1 to 1 range, centered at 0
             normalized = intensity / max_abs
             normalized = np.clip(normalized, -1, 1)
             
             if normalized > 0:
-                # Positive values: white to red (intensity 0 = white, max positive = red)
+                # Positive values: white to red (intensity 0 = transparent, max positive = red)
                 r = 255
                 g = int(255 * (1 - normalized))
                 b = int(255 * (1 - normalized))
+                alpha = 255  # Fully opaque for all non-zero values
             elif normalized < 0:
-                # Negative values: white to blue (intensity 0 = white, max negative = blue)  
+                # Negative values: white to blue (intensity 0 = transparent, max negative = blue)  
                 r = int(255 * (1 + normalized))
                 g = int(255 * (1 + normalized))
                 b = 255
+                alpha = 255  # Fully opaque for all non-zero values
             else:
-                # Exactly 0: white
-                r, g, b = 255, 255, 255
+                # Exactly 0: transparent
+                r, g, b, alpha = 255, 255, 255, 0
             
-            return np.array([r, g, b], dtype=np.uint8)
-        
-        # Create lookup table for RGB colors
+            return np.array([r, g, b, alpha], dtype=np.uint8)
+
+        # Modified usage in your main function:
+        # Create lookup table for RGBA colors (note the 4 channels now)
         max_label = max(max(labeled_array.flat), max(node_to_intensity.keys()) if node_to_intensity else 0)
-        color_lut = np.zeros((max_label + 1, 3), dtype=np.uint8)  # Default to black (0,0,0)
-        
-        # Fill lookup table with RGB colors based on intensity
+        color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)  # Default to transparent (0,0,0,0)
+
+        # Fill lookup table with RGBA colors based on intensity
         for node_id, intensity in node_to_intensity.items():
-            rgb_color = intensity_to_rgb(intensity, min_intensity, max_intensity)
-            color_lut[int(node_id)] = rgb_color
-        
+            rgba_color = intensity_to_rgba(intensity, min_intensity, max_intensity)
+            color_lut[int(node_id)] = rgba_color
+
         # Apply lookup table to labeled array - single vectorized operation
         if is_3d:
-            # Return full 3D RGB array [Z, Y, X, 3]
+            # Return full 3D RGBA array [Z, Y, X, 4]
             heatmap_array = color_lut[labeled_array]
         else:
-            # Return 2D RGB array
+            # Return 2D RGBA array
             if labeled_array.ndim == 3:
                 # Take middle slice for 2D representation
                 middle_slice = labeled_array.shape[0] // 2
@@ -1053,7 +1057,7 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
             else:
                 # Already 2D
                 heatmap_array = color_lut[labeled_array]
-        
+
         return heatmap_array
     
     else:
@@ -1122,19 +1126,124 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
         plt.tight_layout()
         plt.show()
 
-# Example usage:
-if __name__ == "__main__":
-    # Sample data for demonstration
-    sample_dict = {
-        'category_A': np.array([0.1, 0.5, 0.8, 0.3, 0.9]),
-        'category_B': np.array([0.7, 0.2, 0.6, 0.4, 0.1]),
-        'category_C': np.array([0.9, 0.8, 0.2, 0.7, 0.5])
-    }
+def create_violin_plots(data_dict, graph_title="Violin Plots"):
+    """
+    Create violin plots from dictionary data with distinct colors.
     
-    sample_id_set = ['feature_1', 'feature_2', 'feature_3', 'feature_4', 'feature_5']
+    Parameters:
+    data_dict (dict): Dictionary where keys are column headers (strings) and 
+                     values are lists of floats
+    graph_title (str): Title for the overall plot
+    """
+    if not data_dict:
+        print("No data to plot")
+        return
     
-    # Create the heatmap
-    fig, ax = plot_dict_heatmap(sample_dict, sample_id_set, 
-                               title="Sample Heatmap Visualization")
+    # Prepare data
+    labels = list(data_dict.keys())
+    data_lists = list(data_dict.values())
     
+    # Generate colors using the community color strategy
+    try:
+        # Create a mock community dict for color generation
+        mock_community_dict = {i: i+1 for i in range(len(labels))}  # No outliers for simplicity
+        
+        # Get distinct colors
+        n_colors = len(labels)
+        colors_rgb = community_extractor.generate_distinct_colors(n_colors)
+        
+        # Sort by data size for consistent color assignment (like community sizes)
+        data_sizes = [(i, len(data_lists[i])) for i in range(len(data_lists))]
+        sorted_indices = sorted(data_sizes, key=lambda x: (-x[1], x[0]))
+        
+        # Create color mapping
+        colors = []
+        for i, _ in sorted_indices:
+            color_idx = sorted_indices.index((i, _))
+            if color_idx < len(colors_rgb):
+                # Convert RGB (0-255) to matplotlib format (0-1)
+                rgb_normalized = tuple(c/255.0 for c in colors_rgb[color_idx])
+                colors.append(rgb_normalized)
+            else:
+                colors.append('gray')  # Fallback color
+        
+        # Reorder colors to match original label order
+        final_colors = ['gray'] * len(labels)
+        for idx, (original_idx, _) in enumerate(sorted_indices):
+            final_colors[original_idx] = colors[idx]
+            
+    except Exception as e:
+        print(f"Color generation failed, using default colors: {e}")
+        # Fallback to default matplotlib colors
+        final_colors = plt.cm.Set3(np.linspace(0, 1, len(labels)))
+    
+    # Create the plot
+    fig, ax = plt.subplots(figsize=(max(8, len(labels) * 1.5), 6))
+    
+    # Create violin plots
+    violin_parts = ax.violinplot(data_lists, positions=range(len(labels)), 
+                                showmeans=False, showmedians=True, showextrema=True)
+    
+    # Color the violins
+    for i, pc in enumerate(violin_parts['bodies']):
+        if i < len(final_colors):
+            pc.set_facecolor(final_colors[i])
+            pc.set_alpha(0.7)
+    
+    # Color the other violin elements
+    for partname in ('cbars', 'cmins', 'cmaxes', 'cmedians'):
+        if partname in violin_parts:
+            violin_parts[partname].set_edgecolor('black')
+            violin_parts[partname].set_linewidth(1)
+            
+    # Add data points as scatter plot overlay with much lower transparency
+    """
+    for i, data in enumerate(data_lists):
+        y = data
+        # Add some jitter to x positions for better visibility
+        x = np.random.normal(i, 0.04, size=len(y))
+        ax.scatter(x, y, alpha=0.2, s=15, color='black', edgecolors='none', zorder=3)  # No borders, more transparent
+    """
+    
+    # Calculate reasonable y-axis limits to focus on the bulk of the data
+    all_data = [val for sublist in data_lists for val in sublist]
+    if all_data:
+        # Use percentiles to exclude extreme outliers from the view
+        y_min = np.percentile(all_data, 5)   # 5th percentile
+        y_max = np.percentile(all_data, 95)  # 95th percentile
+        
+        # Add some padding
+        y_range = y_max - y_min
+        y_padding = y_range * 0.15
+        ax.set_ylim(y_min - y_padding, y_max + y_padding)
+    
+    # Add IQR and median text annotations BELOW the violins
+    for i, data in enumerate(data_lists):
+        if len(data) > 0:
+            q1, median, q3 = np.percentile(data, [25, 50, 75])
+            iqr = q3 - q1
+            
+            # Position text below the violin (using current y-axis limits)
+            y_min_current = ax.get_ylim()[0]
+            y_text = y_min_current - (ax.get_ylim()[1] - ax.get_ylim()[0]) * 0.15
+            
+            ax.text(i, y_text, f'Median: {median:.2f}\nIQR: {iqr:.2f}', 
+                   horizontalalignment='center', fontsize=8, 
+                   bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.8))
+    
+    # Customize the plot
+    ax.set_xticks(range(len(labels)))
+    ax.set_xticklabels(labels, rotation=45, ha='right')
+    ax.set_title(graph_title, fontsize=14, fontweight='bold')
+    ax.set_ylabel('Normalized Values (Z-score-like)', fontsize=12)
+    ax.grid(True, alpha=0.3)
+    
+    # Add a horizontal line at y=0 (the identity centerpoint)
+    ax.axhline(y=0, color='red', linestyle='--', alpha=0.5, linewidth=1, 
+               label='Identity Centerpoint')
+    ax.legend(loc='upper right')
+    
+    # Adjust layout to prevent label cutoff and accommodate bottom text
+    plt.subplots_adjust(bottom=0.2)  # Extra space for bottom text
+    plt.tight_layout()
     plt.show()

{nettracer3d-1.0.1 → nettracer3d-1.0.3}/src/nettracer3d/nettracer.py

@@ -35,6 +35,7 @@ from . import proximity
 from skimage.segmentation import watershed as water
 
 
+
 #These next several methods relate to searching with 3D objects by dilating each one in a subarray around their neighborhood although I don't explicitly use this anywhere... can call them deprecated although I may want to use them later again so I have them still written out here.
 
 
@@ -3932,7 +3933,7 @@ class Network_3D:
         """
         self._nodes, num_nodes = label_objects(nodes, structure_3d)
 
-    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False):
+    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False, down_factor = None):
 
         """Internal method to merge two labelled node arrays into one"""
 
@@ -3943,7 +3944,10 @@ class Network_3D:
             max_val = np.max(root_nodes)
             other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
         if centroids:
-            new_dict = network_analysis._find_centroids(other_nodes)
+            new_dict = network_analysis._find_centroids(other_nodes, down_factor = down_factor)
+            if down_factor is not None:
+                for item in new_dict:
+                    new_dict[item] = down_factor * new_dict[item]
             self.node_centroids.update(new_dict)
 
         if root_ID is not None:
@@ -3983,7 +3987,7 @@ class Network_3D:
 
         return nodes, identity_dict
 
-    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False):
+    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False, down_factor = None):
         """
         Merges the self._nodes attribute with alternate labelled node images. The alternate nodes can be inputted as a string for a filepath to a tif,
         or as a directory address containing only tif images, which will merge the _nodes attribute with all tifs in the folder. The _node_identities attribute
@@ -4004,19 +4008,21 @@ class Network_3D:
         identity_dict = {} #A dictionary to deliniate the node identities
 
         if centroids:
-            self.node_centroids = network_analysis._find_centroids(self._nodes)
-
+            self.node_centroids = network_analysis._find_centroids(self._nodes, down_factor = down_factor)
+            if down_factor is not None:
+                for item in self.node_centroids:
+                    self.node_centroids[item] = down_factor * self.node_centroids[item]
 
         try: #Try presumes the input is a tif
             addn_nodes = tifffile.imread(addn_nodes_name) #If not this will fail and activate the except block
 
             if label_nodes is True:
                 addn_nodes, num_nodes2 = label_objects(addn_nodes) # Label the node objects. Note this presumes no overlap between node masks.
-                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids) #This method stacks labelled arrays
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor) #This method stacks labelled arrays
                 num_nodes = np.max(node_labels)
 
             else: #If nodes already labelled
-                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids)
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                 num_nodes = int(np.max(node_labels))
 
         except: #Exception presumes the input is a directory containing multiple tifs, to allow multi-node stackage.
@@ -4034,15 +4040,15 @@ class Network_3D:
                     if label_nodes is True:
                         addn_nodes, num_nodes2 = label_objects(addn_nodes)  # Label the node objects. Note this presumes no overlap between node masks.
                         if i == 0:
-                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                         else:
-                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids, down_factor = down_factor)
 
                     else:
                         if i == 0:
-                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids, down_factor = down_factor)
                         else:
-                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids, down_factor = down_factor)
                 except Exception as e:
                     print("Could not open additional nodes, verify they are being inputted correctly...")
 
@@ -6120,14 +6126,25 @@ class Network_3D:
 
                 for node, iden in self.node_identities.items():
 
-                    if iden == root:
+                    if iden == root: # Standard behavior
 
                         root_set.append(node)
 
-                    elif (iden == targ) or (targ == 'All Others (Excluding Self)'):
+                    elif '[' in iden and root != "All (Excluding Targets)": # For multiple nodes
+                        if root in iden:
+                            root_set.append(node)
+
+                    elif (iden == targ) or (targ == 'All Others (Excluding Self)'): # The other group
 
                         compare_set.append(node)
 
+                    elif '[' in iden: # The other group, for multiple nodes
+                        if targ in iden:
+                            compare_set.append(node)
+
+                    elif root == "All (Excluding Targets)": # If not assigned to the other group but the comprehensive root option is used
+                        root_set.append(node)
+
             if root == targ:
 
                 compare_set = root_set

{nettracer3d-1.0.1 → nettracer3d-1.0.3}/src/nettracer3d/nettracer_gui.py

@@ -4,7 +4,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QG
                             QHBoxLayout, QSlider, QMenuBar, QMenu, QDialog, 
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
-                            QMenu, QTabWidget, QGroupBox)
+                            QMenu, QTabWidget, QGroupBox, QCheckBox)
 from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent, QEventLoop)
 import numpy as np
 import time
@@ -511,12 +511,8 @@ class ImageViewerWindow(QMainWindow):
                 data = df.iloc[:, 0].tolist()  # First column as list
                 value = None
                 
-                self.format_for_upperright_table(
-                    data=data,
-                    metric=metric,
-                    value=value,
-                    title=title
-                )
+                df = self.format_for_upperright_table(data=data, metric=metric, value=value, title=title)
+                return df
             else:
                 # Multiple columns: create dictionary as before
                 # First column header (for metric parameter)
@@ -542,12 +538,8 @@ class ImageViewerWindow(QMainWindow):
                     value = value[0]
                 
                 # Call the parent method
-                self.format_for_upperright_table(
-                    data=data_dict,
-                    metric=metric,
-                    value=value,
-                    title=title
-                )
+                df = self.format_for_upperright_table(data=data_dict, metric=metric, value=value, title=title)
+                return df
             
             QMessageBox.information(
                 self,
@@ -4592,6 +4584,8 @@ class ImageViewerWindow(QMainWindow):
         rad_action.triggered.connect(self.show_rad_dialog)
         inter_action = stats_menu.addAction("Calculate Node < > Edge Interaction")
         inter_action.triggered.connect(self.show_interaction_dialog)
+        violin_action = stats_menu.addAction("Show Identity Violins/UMAP")
+        violin_action.triggered.connect(self.show_violin_dialog)
         overlay_menu = analysis_menu.addMenu("Data/Overlays")
         degree_action = overlay_menu.addAction("Get Degree Information")
         degree_action.triggered.connect(self.show_degree_dialog)
@@ -5047,6 +5041,8 @@ class ImageViewerWindow(QMainWindow):
            for column in range(table.model().columnCount(None)):
                table.resizeColumnToContents(column)
 
+           return df
+
        except:
             pass
 
@@ -5475,7 +5471,6 @@ class ImageViewerWindow(QMainWindow):
 
         elif sort == 'Merge Nodes':
             try:
-
                 if my_network.nodes is None:
                     QMessageBox.critical(
                         self,
@@ -5483,72 +5478,118 @@ class ImageViewerWindow(QMainWindow):
                         "Please load your first set of nodes into the 'Nodes' channel first"
                     )
                     return
-
                 if len(np.unique(my_network.nodes)) < 3:
                     self.show_label_dialog()
-
-                # First ask user what they want to select
-                msg = QMessageBox()
-                msg.setWindowTitle("Selection Type")
-                msg.setText("Would you like to select a TIFF file or a directory?")
-                tiff_button = msg.addButton("TIFF File", QMessageBox.ButtonRole.AcceptRole)
-                dir_button = msg.addButton("Directory", QMessageBox.ButtonRole.AcceptRole)
-                msg.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
-
-                msg.exec()
-
-                # Also if they want centroids:
-                msg2 = QMessageBox()
-                msg2.setWindowTitle("Selection Type")
-                msg2.setText("Would you like to compute node centroids for each image prior to merging?")
-                yes_button = msg2.addButton("Yes", QMessageBox.ButtonRole.AcceptRole)
-                no_button = msg2.addButton("No", QMessageBox.ButtonRole.AcceptRole)
-                msg2.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
-
-                msg2.exec()
-
-                if msg2.clickedButton() == yes_button:
-                    centroids = True
-                else:
-                    centroids = False
-
-                if msg.clickedButton() == tiff_button:
-                    # Code for selecting TIFF files
-                    filename, _ = QFileDialog.getOpenFileName(
-                        self,
-                        "Select TIFF file",
-                        "",
-                        "TIFF files (*.tiff *.tif)"
-                    )
-                    if filename:
-                        selected_path = filename
-
-                elif msg.clickedButton() == dir_button:
-                    # Code for selecting directories
-                    dialog = QFileDialog(self)
-                    dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
-                    dialog.setOption(QFileDialog.Option.ReadOnly)
-                    dialog.setFileMode(QFileDialog.FileMode.Directory)
-                    dialog.setViewMode(QFileDialog.ViewMode.Detail)
-
-                    if dialog.exec() == QFileDialog.DialogCode.Accepted:
-                        selected_path = dialog.directory().absolutePath()
-
-                my_network.merge_nodes(selected_path, root_id = self.node_name, centroids = centroids)
-                self.load_channel(0, my_network.nodes, True)
-
-
-                if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                
+                # Create custom dialog
+                dialog = QDialog(self)
+                dialog.setWindowTitle("Merge Nodes Configuration")
+                dialog.setModal(True)
+                dialog.resize(400, 200)
+                
+                layout = QVBoxLayout(dialog)
+                
+                # Selection type
+                type_layout = QHBoxLayout()
+                type_label = QLabel("Selection Type:")
+                type_combo = QComboBox()
+                type_combo.addItems(["TIFF File", "Directory"])
+                type_layout.addWidget(type_label)
+                type_layout.addWidget(type_combo)
+                layout.addLayout(type_layout)
+                
+                # Centroids checkbox
+                centroids_layout = QHBoxLayout()
+                centroids_check = QCheckBox("Compute node centroids for each image prior to merging")
+                centroids_layout.addWidget(centroids_check)
+                layout.addLayout(centroids_layout)
+                
+                # Down factor for centroid calculation
+                down_factor_layout = QHBoxLayout()
+                down_factor_label = QLabel("Down Factor (for centroid calculation downsampling):")
+                down_factor_edit = QLineEdit()
+                down_factor_edit.setText("1")  # Default value
+                down_factor_edit.setPlaceholderText("Enter down factor (e.g., 1, 2, 4)")
+                down_factor_layout.addWidget(down_factor_label)
+                down_factor_layout.addWidget(down_factor_edit)
+                layout.addLayout(down_factor_layout)
+                
+                # Buttons
+                button_layout = QHBoxLayout()
+                accept_button = QPushButton("Accept")
+                cancel_button = QPushButton("Cancel")
+                button_layout.addWidget(accept_button)
+                button_layout.addWidget(cancel_button)
+                layout.addLayout(button_layout)
+                
+                # Connect buttons
+                accept_button.clicked.connect(dialog.accept)
+                cancel_button.clicked.connect(dialog.reject)
+                
+                # Execute dialog
+                if dialog.exec() == QDialog.DialogCode.Accepted:
+                    # Get values from dialog
+                    selection_type = type_combo.currentText()
+                    centroids = centroids_check.isChecked()
+                    
+                    # Validate and get down_factor
                     try:
-                        self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
-                    except Exception as e:
-                        print(f"Error loading node identity table: {e}")
-                if centroids:
-                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
-
-
+                        down_factor = int(down_factor_edit.text())
+                        if down_factor <= 0:
+                            raise ValueError("Down factor must be positive")
+                    except ValueError as e:
+                        QMessageBox.critical(
+                            self,
+                            "Invalid Input",
+                            f"Invalid down factor: {str(e)}"
+                        )
+                        return
+                    
+                    # Handle file/directory selection based on combo box choice
+                    if selection_type == "TIFF File":
+                        filename, _ = QFileDialog.getOpenFileName(
+                            self,
+                            "Select TIFF file",
+                            "",
+                            "TIFF files (*.tiff *.tif)"
+                        )
+                        if filename:
+                            selected_path = filename
+                        else:
+                            return  # User cancelled file selection
+                    else:  # Directory
+                        file_dialog = QFileDialog(self)
+                        file_dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
+                        file_dialog.setOption(QFileDialog.Option.ReadOnly)
+                        file_dialog.setFileMode(QFileDialog.FileMode.Directory)
+                        file_dialog.setViewMode(QFileDialog.ViewMode.Detail)
+                        if file_dialog.exec() == QFileDialog.DialogCode.Accepted:
+                            selected_path = file_dialog.directory().absolutePath()
+                        else:
+                            return  # User cancelled directory selection
+                    
+                    if down_factor == 1:
+                        down_factor = None
+                    # Call merge_nodes with all parameters
+                    my_network.merge_nodes(
+                        selected_path, 
+                        root_id=self.node_name, 
+                        centroids=centroids,
+                        down_factor=down_factor
+                    )
+                    
+                    self.load_channel(0, my_network.nodes, True)
+                    
+                    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')
+                        except Exception as e:
+                            print(f"Error loading node identity table: {e}")
+                    
+                    if centroids:
+                        self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                
             except Exception as e:
-
                 QMessageBox.critical(
                     self,
                     "Error Merging",
@@ -6068,7 +6109,7 @@ class ImageViewerWindow(QMainWindow):
 
             if self.shape == self.channel_data[channel_index].shape:
                 preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim())
-            self.shape = self.channel_data[channel_index].shape
+            self.shape = (self.channel_data[channel_index].shape[0], self.channel_data[channel_index].shape[1], self.channel_data[channel_index].shape[2])
             if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
                 self.throttle = True
             else:
@@ -6826,6 +6867,10 @@ class ImageViewerWindow(QMainWindow):
         dialog = InteractionDialog(self)
         dialog.exec()
 
+    def show_violin_dialog(self):
+        dialog = ViolinDialog(self)
+        dialog.show()
+
     def show_degree_dialog(self):
         dialog = DegreeDialog(self)
         dialog.exec()
@@ -8356,7 +8401,7 @@ class MergeNodeIdDialog(QDialog):
                 result = {key: np.array([d[key] for d in id_dicts]) for key in all_keys}
 
 
-                self.parent().format_for_upperright_table(result, 'NodeID', good_list, 'Mean Intensity')
+                self.parent().format_for_upperright_table(result, 'NodeID', good_list, 'Mean Intensity (Save this Table for "Analyze -> Stats -> Show Violins")')
                 if umap:
                     my_network.identity_umap(result)
 
@@ -8364,7 +8409,7 @@ class MergeNodeIdDialog(QDialog):
                 QMessageBox.information(
                     self,
                     "Success",
-                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
+                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. If desired, please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. If desired, please save the outputted mean intensity table to use with 'Analyze -> Stats -> Show Violins'. (Press Help [above] for more info)"
                 )
 
                 self.accept()
@@ -9143,12 +9188,16 @@ class NearNeighDialog(QDialog):
         if my_network.node_identities is not None:
 
             self.root = QComboBox()
-            self.root.addItems(list(set(my_network.node_identities.values())))  
+            roots = list(set(my_network.node_identities.values()))
+            roots.sort()
+            roots.append("All (Excluding Targets)")
+            self.root.addItems(roots)  
             self.root.setCurrentIndex(0)
             identities_layout.addRow("Root Identity to Search for Neighbor's IDs?", self.root)
             
             self.targ = QComboBox()
             neighs = list(set(my_network.node_identities.values()))
+            neighs.sort()
             neighs.append("All Others (Excluding Self)")
             self.targ.addItems(neighs)  
             self.targ.setCurrentIndex(0)
@@ -9273,6 +9322,10 @@ class NearNeighDialog(QDialog):
             except:
                 targ = None
 
+            if root == "All (Excluding Targets)" and targ == 'All Others (Excluding Self)':
+                root = None
+                targ = None
+
             heatmap = self.map.isChecked()
             threed = self.threed.isChecked()
             numpy = self.numpy.isChecked()
@@ -9892,6 +9945,294 @@ class InteractionDialog(QDialog):
             print(f"Error finding interactions: {e}")
 
 
+class ViolinDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+
+        QMessageBox.critical(
+            self,
+            "Notice",
+            "Please select spreadsheet (Should be table output of 'File -> Images -> Node Identities -> Assign Node Identities from Overlap with Other Images'. Make sure to save that table as .csv/.xlsx and then load it here to use this.)"
+        )
+
+        try:
+            try:
+                self.df = self.parent().load_file()
+            except:
+                return
+
+            self.backup_df = copy.deepcopy(self.df)
+            # Get all identity lists and normalize the dataframe
+            identity_lists = self.get_all_identity_lists()
+            self.df = self.normalize_df_with_identity_centerpoints(self.df, identity_lists)
+
+            self.setWindowTitle("Violin Parameters")
+            self.setModal(False)
+
+            layout = QFormLayout(self)
+
+            if my_network.node_identities is not None:
+
+                self.idens = QComboBox()
+                all_idens = list(set(my_network.node_identities.values()))
+                idens = []
+                for iden in all_idens:
+                    if '[' not in iden:
+                        idens.append(iden)
+                idens.sort()
+                idens.insert(0, "None")
+                self.idens.addItems(idens)  
+                self.idens.setCurrentIndex(0)
+                layout.addRow("Return Identity Violin Plots?", self.idens)
+            
+            if my_network.communities is not None:
+                self.coms = QComboBox()
+                coms = list(set(my_network.communities.values()))
+                coms.sort()
+                coms.insert(0, "None")
+                coms = [str(x) for x in coms]
+                self.coms.addItems(coms)  
+                self.coms.setCurrentIndex(0)
+                layout.addRow("Return Neighborhood/Community Violin Plots?", self.coms)
+
+            # Add Run button
+            run_button = QPushButton("Show Z-score-like Violin")
+            run_button.clicked.connect(self.run)
+            layout.addWidget(run_button)
+
+            run_button2 = QPushButton("Show Z-score UMAP")
+            run_button2.clicked.connect(self.run2)
+            layout.addWidget(run_button2)
+        except:
+            QTimer.singleShot(0, self.close)
+
+    def get_all_identity_lists(self):
+        """
+        Get all identity lists for normalization purposes.
+        
+        Returns:
+        dict: Dictionary where keys are identity names and values are lists of node IDs
+        """
+        identity_lists = {}
+        
+        # Get all unique identities
+        all_identities = set()
+        import ast
+        for item in my_network.node_identities:
+            try:
+                parse = ast.literal_eval(my_network.node_identities[item])
+                if isinstance(parse, (list, tuple, set)):
+                    all_identities.update(parse)
+                else:
+                    all_identities.add(str(parse))
+            except:
+                all_identities.add(str(my_network.node_identities[item]))
+        
+        # For each identity, get the list of nodes that have it
+        for identity in all_identities:
+            iden_list = []
+            for item in my_network.node_identities:
+                try:
+                    parse = ast.literal_eval(my_network.node_identities[item])
+                    if identity in parse:
+                        iden_list.append(item)
+                except:
+                    if identity == str(my_network.node_identities[item]):
+                        iden_list.append(item)
+            
+            if iden_list:  # Only add if we found nodes
+                identity_lists[identity] = iden_list
+        
+        return identity_lists
+
+    def normalize_df_with_identity_centerpoints(self, df, identity_lists):
+        """
+        Normalize the entire dataframe using identity-specific centerpoints.
+        Uses Z-score-like normalization with identity centerpoint as the "mean".
+        
+        Parameters:
+        df (pd.DataFrame): Original dataframe
+        identity_lists (dict): Dictionary where keys are identity names and values are lists of node IDs
+        
+        Returns:
+        pd.DataFrame: Normalized dataframe
+        """
+        # Make a copy to avoid modifying the original dataframe
+        df_copy = df.copy()
+        
+        # Set the first column as the index (row headers)
+        df_copy = df_copy.set_index(df_copy.columns[0])
+        
+        # Convert all remaining columns to float type (batch conversion)
+        df_copy = df_copy.astype(float)
+        
+        # First, calculate the centerpoint for each column by finding the median across all identity groups
+        column_centerpoints = {}
+        
+        for column in df_copy.columns:
+            centerpoint = None
+            
+            for identity, node_list in identity_lists.items():
+                # Get nodes that exist in both the identity list and the dataframe
+                valid_nodes = [node for node in node_list if node in df_copy.index]
+                if valid_nodes and ((str(identity) == str(column)) or str(identity) == f'{str(column)}+'):
+                    # Get the median value for this identity in this column
+                    identity_min = df_copy.loc[valid_nodes, column].median()
+                    centerpoint = identity_min
+                    break  # Found the match, no need to continue
+            
+            if centerpoint is not None:
+                # Use the identity-specific centerpoint
+                column_centerpoints[column] = centerpoint
+            else:
+                # Fallback: if no matching identity, use column median
+                column_centerpoints[column] = df_copy[column].median()
+        
+        # Now normalize each column using Z-score-like calculation with identity centerpoint
+        df_normalized = df_copy.copy()
+        for column in df_copy.columns:
+            centerpoint = column_centerpoints[column]
+            # Calculate standard deviation of the column
+            std_dev = df_copy[column].std()
+            
+            if std_dev > 0:  # Avoid division by zero
+                # Z-score-like: (value - centerpoint) / std_dev
+                df_normalized[column] = (df_copy[column] - centerpoint) / std_dev
+            else:
+                # If std_dev is 0, just subtract centerpoint
+                df_normalized[column] = df_copy[column] - centerpoint
+        
+        # Convert back to original format with first column as regular column
+        df_normalized = df_normalized.reset_index()
+        
+        return df_normalized
+
+    def show_in_table(self, df, metric, title):
+
+        # Create new table
+        table = CustomTableView(self.parent())
+        table.setModel(PandasModel(df))
+
+        try:
+            first_column_name = table.model()._data.columns[0]
+            table.sort_table(first_column_name, ascending=True)
+        except:
+             pass
+        
+        # Add to tabbed widget
+        if title is None:
+            self.parent().tabbed_data.add_table(f"{metric} Analysis", table)
+        else:
+            self.parent().tabbed_data.add_table(f"{title}", table)
+        
+
+
+        # Adjust column widths to content
+        for column in range(table.model().columnCount(None)):
+            table.resizeColumnToContents(column)
+
+    def run(self):
+
+        def df_to_dict_by_rows(df, row_indices, title):
+            """
+            Convert a pandas DataFrame to a dictionary by selecting specific rows.
+            No normalization - dataframe is already normalized.
+            
+            Parameters:
+            df (pd.DataFrame): DataFrame with first column as row headers, remaining columns contain floats
+            row_indices (list): List of values from the first column representing rows to include
+            
+            Returns:
+            dict: Dictionary where keys are column headers and values are lists of column values (as floats)
+                  for the specified rows
+            """
+            # Make a copy to avoid modifying the original dataframe
+            df_copy = df.copy()
+            
+            # Set the first column as the index (row headers)
+            df_copy = df_copy.set_index(df_copy.columns[0])
+            
+            # Mask the dataframe to include only the specified rows
+            masked_df = df_copy.loc[row_indices]
+            
+            # Create empty dictionary
+            result_dict = {}
+            
+            # For each column, add the column header as key and column values as list
+            for column in masked_df.columns:
+                result_dict[column] = masked_df[column].tolist()
+            
+            masked_df.insert(0, "NodeIDs", row_indices)
+            self.show_in_table(masked_df, metric = "NodeID", title = title)
+
+
+            return result_dict
+
+        from . import neighborhoods
+
+        if self.idens.currentIndex() != 0:
+
+            iden = self.idens.currentText()
+            iden_list = []
+            import ast
+
+            for item in my_network.node_identities:
+
+                try:
+                    parse = ast.literal_eval(my_network.node_identities[item])
+                    if iden in parse:
+                        iden_list.append(item)
+                except:
+                    if (iden == my_network.node_identities[item]):
+                        iden_list.append(item)
+
+            violin_dict = df_to_dict_by_rows(self.df, iden_list, f"Z-Score-like Channel Intensities of Identity {iden}, {len(iden_list)} Nodes")
+
+            neighborhoods.create_violin_plots(violin_dict, graph_title=f"Z-Score-like Channel Intensities of Identity {iden}, {len(iden_list)} Nodes")
+
+
+        if self.coms.currentIndex() != 0:
+
+            com = self.coms.currentText()
+
+            com_dict = n3d.invert_dict(my_network.communities)
+
+            com_list = com_dict[int(com)]
+
+            violin_dict = df_to_dict_by_rows(self.df, com_list, f"Z-Score-like Channel Intensities of Community/Neighborhood {com}, {len(com_list)} Nodes")
+
+            neighborhoods.create_violin_plots(violin_dict, graph_title=f"Z-Score-like Channel Intensities of Community/Neighborhood {com}, {len(com_list)} Nodes")
+
+
+    def run2(self):
+        def df_to_dict(df):
+            # Make a copy to avoid modifying the original dataframe
+            df_copy = df.copy()
+            
+            # Set the first column as the index (row headers)
+            df_copy = df_copy.set_index(df_copy.columns[0])
+            
+            # Convert all remaining columns to float type (batch conversion)
+            df_copy = df_copy.astype(float)
+            
+            # Create the result dictionary
+            result_dict = {}
+            for row_idx in df_copy.index:
+                result_dict[row_idx] = df_copy.loc[row_idx].tolist()
+            
+            return result_dict
+        
+        try:
+            umap_dict = df_to_dict(self.backup_df)
+            my_network.identity_umap(umap_dict)
+        except:
+            pass
+
+
+
+
 class DegreeDialog(QDialog):
 
 
@@ -12931,16 +13272,58 @@ class GrayWaterDialog(QDialog):
         run_button.clicked.connect(self.run_watershed)
         layout.addRow(run_button)
 
+    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']
+
     def run_watershed(self):
 
         try:
 
+            self.accept()
+            print("Please threshold foreground, or press cancel/skip if not desired:")
+            self.wait_for_threshold_processing()
+            data = self.parent().channel_data[self.parent().active_channel]
+
             min_intensity = float(self.min_intensity.text()) if self.min_intensity.text().strip() else None
 
             min_peak_distance = int(self.min_peak_distance.text()) if self.min_peak_distance.text().strip() else 1
 
-            data = self.parent().channel_data[self.parent().active_channel]
-
             data = n3d.gray_watershed(data, min_peak_distance, min_intensity)
 
             self.parent().load_channel(self.parent().active_channel, data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))

{nettracer3d-1.0.1 → nettracer3d-1.0.3/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.1
+Version: 1.0.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,6 +110,6 @@ 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.0.1 Updates --
+-- Version 1.0.3 Updates --
 
-	* Bug fixes, mainly
+	* Some small bug fixes and adjustments