nettracer3d 1.0.1__tar.gz → 1.0.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.1
+Version: 1.0.2
 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,7 @@ 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.2 Updates --
 
-	* Bug fixes, mainly
+	* Minor fixes
+	* Added ability to generate violin plots using the table generated from merging node identities, showing the relative expression of markers for multiple channels for the nodes belonging to some channel or community/neighborhood

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

@@ -65,6 +65,7 @@ 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.2 Updates --
 
-	* Bug fixes, mainly
+	* Minor fixes
+	* Added ability to generate violin plots using the table generated from merging node identities, showing the relative expression of markers for multiple channels for the nodes belonging to some channel or community/neighborhood

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

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

{nettracer3d-1.0.1 → nettracer3d-1.0.2}/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.2}/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.
 
 
@@ -6120,14 +6121,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.2}/src/nettracer3d/nettracer_gui.py

@@ -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
 
@@ -6068,7 +6064,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 +6822,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 +8356,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 +8364,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 +9143,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 +9277,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 +9900,266 @@ 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 run(self):
+
+        def df_to_dict_by_rows(df, row_indices):
+            """
+            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()
+            
+            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 == item:
+                        iden_list.append(item)
+
+            violin_dict = df_to_dict_by_rows(self.df, iden_list)
+
+            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)  # Fixed: should be communities
+
+            com_list = com_dict[int(com)]
+
+            violin_dict = df_to_dict_by_rows(self.df, com_list)
+
+            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 +13199,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.2/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.0.1
+Version: 1.0.2
 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,7 @@ 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.2 Updates --
 
-	* Bug fixes, mainly
+	* Minor fixes
+	* Added ability to generate violin plots using the table generated from merging node identities, showing the relative expression of markers for multiple channels for the nodes belonging to some channel or community/neighborhood