nettracer3d 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

nettracer3d/network_analysis.py

@@ -136,7 +136,6 @@ def open_network(excel_file_path):
         G.add_edge(nodes_a[i], nodes_b[i])
 
     return G
-
 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):
@@ -157,6 +156,61 @@ def read_excel_to_lists(file_path, sheet_name=0):
                 converted_data[k] = v
         
         return converted_data
+        
+    if type(file_path) == str:
+        # Check file extension
+        if file_path.lower().endswith('.xlsx'):
+            # Read the Excel file with headers (since your new save method includes them)
+            df = pd.read_excel(file_path, sheet_name=sheet_name)
+        elif file_path.lower().endswith('.csv'):
+            # Read the CSV file with headers and specify dtype to avoid the warning
+            df = pd.read_csv(file_path, dtype=str, low_memory=False)
+        elif file_path.lower().endswith('.json'):
+            df = load_json_to_list(file_path)
+            return df
+        else:
+            raise ValueError("File must be either .xlsx, .csv, or .json format")
+    else:
+        df = file_path
+        
+    # Initialize an empty list to store the lists of values
+    data_lists = []
+    # Iterate over each column in the DataFrame
+    for column_name, column_data in df.items():
+        # Convert the column values to a list and append to the data_lists
+        data_lists.append(column_data.tolist())
+        
+    master_list = [[], [], []]
+    for i in range(0, len(data_lists), 3):
+        master_list[0].extend([int(x) for x in data_lists[i]])
+        master_list[1].extend([int(x) for x in data_lists[i+1]])
+        try:
+            master_list[2].extend([int(x) for x in data_lists[i+2]])
+        except IndexError:
+            master_list[2].extend([0])  # Note: Changed to list with single int 0
+            
+    return master_list
+
+def read_excel_to_lists_old(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
@@ -545,42 +599,51 @@ def _find_centroids_old(nodes, node_list = None, down_factor = None):
 
     return centroid_dict
 
+
 def _find_centroids(nodes, node_list=None, down_factor=None):
     """Internal use version to get centroids without saving"""
-    def get_label_indices(binary_stack, label, y_offset):
-        """
-        Finds indices of labelled object in array and adjusts for the Y-offset.
-        """
-        indices = np.argwhere(binary_stack == label)
-        # Adjust the Y coordinate by the y_offset
-        indices[:, 1] += y_offset
-        return indices
+    
     
     def compute_indices_in_chunk(chunk, y_offset):
         """
-        Get indices for all labels in a given chunk of the 3D array.
-        Adjust Y-coordinate based on the y_offset for each chunk.
+        Alternative approach using np.where for even better performance on sparse arrays.
         """
         indices_dict_chunk = {}
-        label_list = np.unique(chunk)
-        try:
-            if label_list[0] == 0:
-                label_list = np.delete(label_list, 0)
-        except:
-            pass
         
-        for label in label_list:
-            indices = get_label_indices(chunk, label, y_offset)
-            indices_dict_chunk[label] = indices
+        # Get all coordinates where chunk is non-zero
+        z_coords, y_coords, x_coords = np.where(chunk != 0)
+        
+        if len(z_coords) == 0:
+            return indices_dict_chunk
+        
+        # Adjust Y coordinates
+        y_coords_adjusted = y_coords + y_offset
+        
+        # Get labels at these coordinates
+        labels = chunk[z_coords, y_coords, x_coords]
+        
+        # Group by unique labels
+        unique_labels = np.unique(labels)
+        
+        for label in unique_labels:
+            if label == 0:  # Skip background
+                continue
+            mask = (labels == label)
+            # Stack coordinates into the expected format [z, y, x]
+            indices_dict_chunk[label] = np.column_stack((
+                z_coords[mask], 
+                y_coords_adjusted[mask], 
+                x_coords[mask]
+            ))
+        
         return indices_dict_chunk
     
     def chunk_3d_array(array, num_chunks):
-        """
-        Split the 3D array into smaller chunks along the y-axis.
-        """
+        """Split the 3D array into smaller chunks along the y-axis."""
         y_slices = np.array_split(array, num_chunks, axis=1)
         return y_slices
     
+    # Handle input processing
     if isinstance(nodes, str):  # Open into numpy array if filepath
         nodes = tifffile.imread(nodes)
         if len(np.unique(nodes)) == 2:  # Label if binary
@@ -595,14 +658,14 @@ def _find_centroids(nodes, node_list=None, down_factor=None):
     indices_dict = {}
     num_cpus = mp.cpu_count()
     
-    # Chunk the 3D array along the y-axis into smaller subarrays
+    # Chunk the 3D array along the y-axis
     node_chunks = chunk_3d_array(nodes, num_cpus)
     
     # Calculate Y offset for each chunk
     chunk_sizes = [chunk.shape[1] for chunk in node_chunks]
     y_offsets = np.cumsum([0] + chunk_sizes[:-1])
     
-    # Parallel computation of indices across chunks
+    # Parallel computation using the optimized single-pass approach
     with ThreadPoolExecutor(max_workers=num_cpus) as executor:
         futures = {executor.submit(compute_indices_in_chunk, chunk, y_offset): chunk_id
                   for chunk_id, (chunk, y_offset) in enumerate(zip(node_chunks, y_offsets))}
@@ -622,10 +685,8 @@ def _find_centroids(nodes, node_list=None, down_factor=None):
         centroid = np.round(np.mean(indices, axis=0)).astype(int)
         centroid_dict[label] = centroid
     
-    try:
-        del centroid_dict[0]
-    except:
-        pass
+    # Remove background label if it exists
+    centroid_dict.pop(0, None)
     
     return centroid_dict
 

nettracer3d/node_draw.py

@@ -200,8 +200,12 @@ def degree_draw(degree_dict, centroid_dict, nodes):
 
     return draw_array
 
-def degree_infect(degree_dict, nodes):
-    return_nodes = np.zeros_like(nodes)  # Start with all zeros
+def degree_infect(degree_dict, nodes, make_floats = False):
+
+    if not make_floats:
+        return_nodes = np.zeros_like(nodes)  # Start with all zeros
+    else:
+        return_nodes = np.zeros(nodes.shape, dtype=np.float32)
     
     if not degree_dict:  # Handle empty dict
         return return_nodes

nettracer3d/painting.py

@@ -0,0 +1,373 @@
+from PyQt6.QtWidgets import QApplication, QMainWindow
+import matplotlib.pyplot as plt
+import copy
+import numpy as np
+
+
+class PaintManager(QMainWindow):
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+    def get_line_points(self, x0, y0, x1, y1):
+        """Get all points in a line between (x0,y0) and (x1,y1) using Bresenham's algorithm."""
+        points = []
+        dx = abs(x1 - x0)
+        dy = abs(y1 - y0)
+        x, y = x0, y0
+        sx = 1 if x0 < x1 else -1
+        sy = 1 if y0 < y1 else -1
+        
+        if dx > dy:
+            err = dx / 2.0
+            while x != x1:
+                points.append((x, y))
+                err -= dy
+                if err < 0:
+                    y += sy
+                    err += dx
+                x += sx
+        else:
+            err = dy / 2.0
+            while y != y1:
+                points.append((x, y))
+                err -= dx
+                if err < 0:
+                    x += sx
+                    err += dy
+                y += sy
+                
+        points.append((x, y))
+        return points
+
+    def initiate_paint_session(self, channel, current_xlim, current_ylim):
+        # Create static background (same as selection rectangle)
+
+        if self.parent().machine_window is not None:
+            if self.parent().machine_window.segmentation_worker is not None:
+                # Instead of just pausing, completely stop and clean up the worker
+                self.parent().machine_window.segmentation_worker.pause()
+
+
+        if not self.parent().channel_visible[channel]:
+            self.parent().channel_visible[channel] = True
+            
+        # Capture the background once
+        self.parent().static_background = self.parent().canvas.copy_from_bbox(self.parent().ax.bbox)
+
+        if self.parent().machine_window is not None:
+            if self.parent().machine_window.segmentation_worker is not None:
+                # Instead of just pausing, completely stop and clean up the worker
+                self.parent().machine_window.segmentation_worker.resume()
+
+
+
+    def start_virtual_paint_session(self, channel, current_xlim, current_ylim):
+        """Start a virtual paint session that doesn't modify arrays until the end."""
+        self.parent().painting = True
+        self.parent().paint_channel = channel
+        
+        # Store original state
+        if not self.parent().channel_visible[channel]:
+            self.parent().channel_visible[channel] = True
+            
+        # Initialize virtual paint storage - separate draw and erase operations
+        self.parent().virtual_draw_operations = []  # Stores drawing operations
+        self.parent().virtual_erase_operations = []  # Stores erase operations
+        self.parent().current_operation = []
+        self.parent().current_operation_type = None  # 'draw' or 'erase'
+
+    def add_virtual_paint_point(self, x, y, brush_size, erase=False, foreground=True):
+        """Add a single paint point to the virtual layer."""
+        
+        # Determine operation type and visual properties
+        if erase:
+            paint_color = 'black'  # Visual indicator for erase
+            alpha = 0.5
+            operation_type = 'erase'
+        else:
+            if self.parent().machine_window is not None:
+                if foreground:
+                    paint_color = 'green'  # Visual for foreground (value 1)
+                    alpha = 0.7
+                else:
+                    paint_color = 'red'  # Visual for background (value 2)
+                    alpha = 0.7
+            else:
+                paint_color = 'white'  # Normal paint
+                alpha = 0.7
+            operation_type = 'draw'
+                
+        # Store the operation data (for later conversion to real paint)
+        operation_data = {
+            'x': x,
+            'y': y,
+            'brush_size': brush_size,
+            'erase': erase,
+            'foreground': foreground,
+            'channel': self.parent().paint_channel,
+            'threed': getattr(self.parent(), 'threed', False),
+            'threedthresh': getattr(self.parent(), 'threedthresh', 1)
+        }
+        
+        # Create visual circle
+        circle = plt.Circle((x, y), brush_size/2, 
+                           color=paint_color, alpha=alpha, animated=True)
+        
+        # Add to current operation
+        if self.parent().current_operation_type != operation_type:
+            # Finish previous operation if switching between draw/erase
+            self.finish_current_virtual_operation()
+            self.parent().current_operation_type = operation_type
+        
+        self.parent().current_operation.append({
+            'circle': circle,
+            'data': operation_data
+        })
+        
+        self.parent().ax.add_patch(circle)
+
+    def add_virtual_paint_stroke(self, x, y, brush_size, erase=False, foreground=True):
+        """Add a paint stroke - simple visual, interpolation happens during data conversion."""
+        # Just add the current point for visual display (no interpolation yet)
+        self.add_virtual_paint_point(x, y, brush_size, erase, foreground)
+        
+        # Store the last position for data conversion later
+        self.parent().last_virtual_pos = (x, y)
+
+    def finish_current_virtual_operation(self):
+        """Finish the current operation (draw or erase) and add it to the appropriate list."""
+        
+        if not self.parent().current_operation:
+            return
+            
+        if self.parent().current_operation_type == 'draw':
+            self.parent().virtual_draw_operations.append(self.parent().current_operation)
+        elif self.parent().current_operation_type == 'erase':
+            self.parent().virtual_erase_operations.append(self.parent().current_operation)
+        
+        self.parent().current_operation = []
+        self.parent().current_operation_type = None
+
+    def update_virtual_paint_display(self):
+        """Update display with virtual paint strokes - super fast like selection rectangle."""
+        if not hasattr(self.parent(), 'static_background') or self.parent().static_background is None:
+            return
+        
+        # Restore the clean background
+        self.parent().canvas.restore_region(self.parent().static_background)
+        
+        # Draw all completed operations
+        for operation_list in [self.parent().virtual_draw_operations, self.parent().virtual_erase_operations]:
+            for operation in operation_list:
+                for item in operation:
+                    self.parent().ax.draw_artist(item['circle'])
+        
+        # Draw current operation being painted
+        if hasattr(self.parent(), 'current_operation'):
+            for item in self.parent().current_operation:
+                self.parent().ax.draw_artist(item['circle'])
+        
+        # Blit everything at once
+        self.parent().canvas.blit(self.parent().ax.bbox)
+
+    def convert_virtual_strokes_to_data(self):
+        """Convert virtual paint strokes to actual array data with interpolation applied here."""
+        
+        # First, apply all drawing operations with interpolation
+        for operation in self.parent().virtual_draw_operations:
+            last_pos = None
+            for item in operation:
+                data = item['data']
+                current_pos = (data['x'], data['y'])
+                
+                if last_pos is not None:
+                    points = self.get_line_points(last_pos[0], last_pos[1], current_pos[0], current_pos[1])
+                    for px, py in points:
+                        self.paint_at_position_vectorized(
+                            px, py,
+                            erase=False,
+                            channel=data['channel'],
+                            brush_size=data['brush_size'],
+                            threed=data['threed'],  # Add this
+                            threedthresh=data['threedthresh'],  # Add this
+                            foreground=data['foreground'],
+                            machine_window=self.parent().machine_window
+                        )
+                else:
+                    self.paint_at_position_vectorized(
+                        data['x'], data['y'],
+                        erase=False,
+                        channel=data['channel'],
+                        brush_size=data['brush_size'],
+                        threed=data['threed'],  # Add this
+                        threedthresh=data['threedthresh'],  # Add this
+                        foreground=data['foreground'],
+                        machine_window=self.parent().machine_window
+                    )
+                
+                last_pos = current_pos
+                try:
+                    item['circle'].remove()
+                except:
+                    pass
+        
+        # Then, apply all erase operations with interpolation (same changes)
+        for operation in self.parent().virtual_erase_operations:
+            last_pos = None
+            for item in operation:
+                data = item['data']
+                current_pos = (data['x'], data['y'])
+                
+                if last_pos is not None:
+                    points = self.get_line_points(last_pos[0], last_pos[1], current_pos[0], current_pos[1])
+                    for px, py in points:
+                        self.paint_at_position_vectorized(
+                            px, py,
+                            erase=True,
+                            channel=data['channel'],
+                            brush_size=data['brush_size'],
+                            threed=data['threed'],  # Add this
+                            threedthresh=data['threedthresh'],  # Add this
+                            foreground=data['foreground'],
+                            machine_window=self.parent().machine_window
+                        )
+                else:
+                    self.paint_at_position_vectorized(
+                        data['x'], data['y'],
+                        erase=True,
+                        channel=data['channel'],
+                        brush_size=data['brush_size'],
+                        threed=data['threed'],  # Add this
+                        threedthresh=data['threedthresh'],  # Add this
+                        foreground=data['foreground'],
+                        machine_window=self.parent().machine_window
+                    )
+                
+                last_pos = current_pos
+                try:
+                    item['circle'].remove()
+                except:
+                    pass
+        
+        # Clean up
+        self.parent().virtual_draw_operations = []
+        self.parent().virtual_erase_operations = []
+        if hasattr(self.parent(), 'current_operation'):
+            for item in self.parent().current_operation:
+                try:
+                    item['circle'].remove()
+                except:
+                    pass
+            self.parent().current_operation = []
+        self.parent().current_operation_type = None
+
+
+    def end_virtual_paint_session(self):
+        """Convert virtual paint to actual array modifications when exiting paint mode."""
+        if not hasattr(self.parent(), 'virtual_paint_strokes'):
+            return
+        
+        # Now apply all the virtual strokes to the actual arrays
+        for stroke in self.parent().virtual_paint_strokes:
+            for circle in stroke:
+                center = circle.center
+                radius = circle.radius
+                is_erase = circle.get_facecolor()[0] == 0  # Black = erase
+                
+                # Apply to actual array
+                self.paint_at_position_vectorized(
+                    int(center[0]), int(center[1]), 
+                    erase=is_erase, 
+                    channel=self.paint_channel,
+                    brush_size=int(radius * 2)
+                )
+                
+                # Remove the virtual circle
+                circle.remove()
+        
+        # Clean up virtual paint data
+        self.virtual_paint_strokes = []
+        self.current_stroke = []
+        
+        # Reset background
+        self.static_background = None
+        self.painting = False
+        
+        # Full refresh to show final result
+        self.update_display()
+
+    def paint_at_position_vectorized(self, center_x, center_y, erase=False, channel=2, 
+                                   slice_idx=None, brush_size=None, threed=None, 
+                                   threedthresh=None, foreground=True, machine_window=None):
+        """Vectorized paint operation for better performance."""
+        if self.parent().channel_data[channel] is None:
+            return
+        
+        # Use provided parameters or fall back to instance variables
+        slice_idx = slice_idx if slice_idx is not None else self.parent().current_slice
+        brush_size = brush_size if brush_size is not None else getattr(self.parent(), 'brush_size', 5)
+        threed = threed if threed is not None else getattr(self.parent(), 'threed', False)
+        threedthresh = threedthresh if threedthresh is not None else getattr(self.parent(), 'threedthresh', 1)
+        
+        # Handle 3D painting by recursively calling for each slice
+        if threed and threedthresh > 1:
+            half_range = (threedthresh - 1) // 2
+            low = max(0, slice_idx - half_range)
+            high = min(self.parent().channel_data[channel].shape[0] - 1, slice_idx + half_range)
+            
+            
+            for i in range(low, high + 1):
+                
+                # Recursive call for each slice, but with threed=False to avoid infinite recursion
+                self.paint_at_position_vectorized(
+                    center_x, center_y, 
+                    erase=erase, 
+                    channel=channel,
+                    slice_idx=i,  # Paint on slice i
+                    brush_size=brush_size,
+                    threed=False,  # Important: turn off 3D for recursive calls
+                    threedthresh=1,
+                    foreground=foreground,
+                    machine_window=machine_window
+                )
+                
+                
+            return  # Exit early, recursive calls handle everything
+        
+        # Regular 2D painting (single slice)
+        
+        # Determine paint value
+        if erase:
+            val = 0
+        elif machine_window is None:
+            try:
+                val = self.parent().min_max[channel][1]
+            except:
+                val = 255
+        elif foreground:
+            val = 1
+        else:
+            val = 2
+        
+        height, width = self.parent().channel_data[channel][slice_idx].shape
+        radius = brush_size // 2
+        
+        # Calculate affected region bounds
+        y_min = max(0, center_y - radius)
+        y_max = min(height, center_y + radius + 1)
+        x_min = max(0, center_x - radius)
+        x_max = min(width, center_x + radius + 1)
+        
+        if y_min >= y_max or x_min >= x_max:
+            return  # No valid region to paint
+        
+        # Create coordinate grids for the affected region
+        y_coords, x_coords = np.mgrid[y_min:y_max, x_min:x_max]
+        
+        # Calculate distances squared (avoid sqrt for performance)
+        distances_sq = (x_coords - center_x) ** 2 + (y_coords - center_y) ** 2
+        mask = distances_sq <= radius ** 2
+        
+        # Paint on this single slice
+        
+        self.parent().channel_data[channel][slice_idx][y_min:y_max, x_min:x_max][mask] = val