microlive 1.0.14__py3-none-any.whl → 1.0.16__py3-none-any.whl

microlive/__init__.py

@@ -23,7 +23,7 @@ Authors:
     Nathan L. Nowling, Brian Munsky, Ning Zhao
 """
 
-__version__ = "1.0.14"
+__version__ = "1.0.16"
 __author__ = "Luis U. Aguilera, William S. Raymond, Rhiannon M. Sears, Nathan L. Nowling, Brian Munsky, Ning Zhao"
 
 # Package name (for backward compatibility)

microlive/gui/app.py

@@ -101,6 +101,7 @@ from matplotlib.backends.backend_qt5agg import (
     FigureCanvasQTAgg as FigureCanvas,
     NavigationToolbar2QT as NavigationToolbar,)
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+from mpl_toolkits.mplot3d import Axes3D  # For 3D intensity profile visualization
 from functools import partial
 from scipy.optimize import curve_fit
 from scipy.ndimage import gaussian_filter, label, center_of_mass, distance_transform_edt
@@ -2841,12 +2842,21 @@ class GUI(QMainWindow):
             if hasattr(self, 'time_slider_display'):
                 self.time_slider_display.setEnabled(False)
                 self.time_slider_display.setValue(0)
+                self.time_slider_display.setMaximum(0)
+            if hasattr(self, 'frame_label_display'):
+                self.frame_label_display.setText("0/0")
             if hasattr(self, 'play_button_display'):
                 self.play_button_display.setEnabled(False)
             if hasattr(self, 'time_slider_tracking'):
                 self.time_slider_tracking.setValue(0)
+                self.time_slider_tracking.setMaximum(0)
+            if hasattr(self, 'frame_label_tracking'):
+                self.frame_label_tracking.setText("0/0")
             if hasattr(self, 'time_slider_tracking_vis'):
                 self.time_slider_tracking_vis.setValue(0)
+                self.time_slider_tracking_vis.setMaximum(0)
+            if hasattr(self, 'frame_label_tracking_vis'):
+                self.frame_label_tracking_vis.setText("0/0")
             
             # Stop any playing timers
             self.stop_all_playback()
@@ -2937,12 +2947,21 @@ class GUI(QMainWindow):
         if hasattr(self, 'time_slider_display'):
             self.time_slider_display.setEnabled(False)
             self.time_slider_display.setValue(0)
+            self.time_slider_display.setMaximum(0)
+        if hasattr(self, 'frame_label_display'):
+            self.frame_label_display.setText("0/0")
         if hasattr(self, 'play_button_display'):
             self.play_button_display.setEnabled(False)
         if hasattr(self, 'time_slider_tracking'):
             self.time_slider_tracking.setValue(0)
+            self.time_slider_tracking.setMaximum(0)
+        if hasattr(self, 'frame_label_tracking'):
+            self.frame_label_tracking.setText("0/0")
         if hasattr(self, 'time_slider_tracking_vis'):
             self.time_slider_tracking_vis.setValue(0)
+            self.time_slider_tracking_vis.setMaximum(0)
+        if hasattr(self, 'frame_label_tracking_vis'):
+            self.frame_label_tracking_vis.setText("0/0")
         
         # Stop any playing timers
         self.stop_all_playback()
@@ -9054,7 +9073,7 @@ class GUI(QMainWindow):
         # Cluster radius
         self.cluster_radius_input = QSpinBox()
         self.cluster_radius_input.setMinimum(100)
-        self.cluster_radius_input.setMaximum(2000)
+        self.cluster_radius_input.setMaximum(6000)
         self.cluster_radius_input.setValue(self.cluster_radius_nm)
         self.cluster_radius_input.valueChanged.connect(self.update_cluster_radius)
         params_layout.addRow("Cluster radius (nm):", self.cluster_radius_input)
@@ -11701,9 +11720,13 @@ class GUI(QMainWindow):
         layout = QVBoxLayout(self.coloc_verify_distance_widget)
         layout.setContentsMargins(10, 5, 10, 5)
         
-        # Info label
-        info_label = QLabel("Review and correct Distance-based colocalization results:")
+        # Info label explaining what is displayed
+        info_label = QLabel(
+            "Review unique particle tracks. Each row shows a time-averaged crop. "
+            "A track is marked colocalized (✓) if ANY frame is within the distance threshold."
+        )
         info_label.setStyleSheet("font-style: italic; color: #999;")
+        info_label.setWordWrap(True)
         layout.addWidget(info_label)
         
         # Top bar with stats and buttons
@@ -12553,6 +12576,9 @@ class GUI(QMainWindow):
             channels=(ch1, ch2)
         )
         
+        # Reset sorted flag so Sort button can be used
+        self._verify_visual_sorted = False
+        
         # Update stats label
         self._update_verify_visual_stats()
     
@@ -12570,20 +12596,76 @@ class GUI(QMainWindow):
         )
     
     def sort_verify_visual(self):
-        """Sort Verify Visual results by prediction value (lowest to highest)."""
+        """Sort Verify Visual results by prediction value (lowest to highest for review)."""
         if not hasattr(self, 'verify_visual_checkboxes') or len(self.verify_visual_checkboxes) == 0:
+            QMessageBox.information(self, "No Data", "No spots to sort. Please click Populate first.")
+            return
+        
+        if not hasattr(self, 'colocalization_results') or not self.colocalization_results:
+            QMessageBox.warning(self, "No Results", "No colocalization results available.")
             return
         
-        values = self.colocalization_results.get('prediction_values_vector') if hasattr(self, 'colocalization_results') else None
+        results = self.colocalization_results
+        values = results.get('prediction_values_vector')
+        mean_crop = results.get('mean_crop_filtered')
+        crop_size = results.get('crop_size', 15)
+        flag_vector = results.get('flag_vector')
+        ch1 = results.get('ch1_index', 0)
+        ch2 = results.get('ch2_index', 1)
+        
         if values is None or len(values) == 0:
             QMessageBox.information(self, "Cannot Sort", "No prediction values available for sorting.")
             return
         
-        # Re-populate with sorted order would require rebuilding crops
-        # For now, show a message that sorting is based on visual arrangement
-        QMessageBox.information(self, "Sort", 
-            "Spots are already displayed in their original detection order. "
-            "Lower prediction values indicate uncertain colocalization.")
+        if mean_crop is None:
+            QMessageBox.warning(self, "No Data", "Crop data not available for sorting.")
+            return
+        
+        # Check if already sorted (compare to original order)
+        if hasattr(self, '_verify_visual_sorted') and self._verify_visual_sorted:
+            QMessageBox.information(self, "Already Sorted", "Spots are already sorted by prediction value.")
+            return
+        
+        # Get current checkbox states before sorting
+        current_states = [chk.isChecked() for chk in self.verify_visual_checkboxes]
+        
+        # Create sorted indices (ascending by prediction value - uncertain first)
+        num_spots = len(values)
+        sorted_indices = np.argsort(values)
+        
+        # Re-order checkbox states to match new sort order
+        sorted_states = [current_states[i] if i < len(current_states) else False for i in sorted_indices]
+        
+        # Re-order crops - each spot is crop_size rows in the mean_crop array
+        num_crop_spots = mean_crop.shape[0] // crop_size
+        if num_crop_spots < num_spots:
+            num_spots = num_crop_spots
+            sorted_indices = sorted_indices[:num_spots]
+        
+        sorted_crop = np.zeros_like(mean_crop[:num_spots*crop_size])
+        for new_idx, old_idx in enumerate(sorted_indices[:num_spots]):
+            if old_idx < num_crop_spots:
+                sorted_crop[new_idx*crop_size:(new_idx+1)*crop_size] = \
+                    mean_crop[old_idx*crop_size:(old_idx+1)*crop_size]
+        
+        # Re-create verification crops with sorted data
+        self._create_verification_crops(
+            scroll_area=self.verify_visual_scroll_area,
+            checkboxes_list_attr='verify_visual_checkboxes',
+            mean_crop=sorted_crop,
+            crop_size=crop_size,
+            flag_vector=sorted_states,  # Use previously checked states after reorder
+            stats_label=self.verify_visual_stats_label,
+            num_channels=2,
+            channels=(ch1, ch2)
+        )
+        
+        # Mark as sorted
+        self._verify_visual_sorted = True
+        self._verify_visual_sort_indices = sorted_indices
+        
+        # Update stats
+        self._update_verify_visual_stats()
     
     def cleanup_verify_visual(self):
         """Clear all checkboxes in Verify Visual subtab."""
@@ -12630,7 +12712,11 @@ class GUI(QMainWindow):
     # === Verify Distance Subtab Methods ===
     
     def populate_verify_distance(self):
-        """Populate the Verify Distance subtab with Distance colocalization results."""
+        """Populate the Verify Distance subtab with Distance colocalization results.
+        
+        Calculates and stores the minimum distance from each reference channel spot
+        to its nearest partner in the target channel for sorting purposes.
+        """
         if not hasattr(self, 'distance_coloc_results') or not self.distance_coloc_results:
             QMessageBox.warning(self, "No Results", 
                 "Please run Distance colocalization first.")
@@ -12641,8 +12727,10 @@ class GUI(QMainWindow):
         ch0 = results.get('channel_0', 0)
         ch1 = results.get('channel_1', 1)
         df_coloc = results.get('df_colocalized', pd.DataFrame())
+        df_ch1_all = results.get('df_ch1_all', pd.DataFrame())
         threshold_px = results.get('threshold_distance_px', 2.0)
         threshold_nm = results.get('threshold_distance_nm', 130.0)
+        use_3d = results.get('use_3d', False)
         
         # We need to create crops from tracking data
         if not hasattr(self, 'df_tracking') or self.df_tracking.empty:
@@ -12684,28 +12772,129 @@ class GUI(QMainWindow):
         
         num_spots = mean_crop.shape[0] // crop_size
         
-        # Create flag vector based on distance colocalization
-        # Mark spots as colocalized if their coordinates match
-        coloc_coords = set()
+        # Build set of colocalized coordinates for matching
+        # Use a tolerance-based approach instead of exact coordinate matching
+        coloc_coords_array = np.empty((0, 4))  # z, y, x, cell_id
         if not df_coloc.empty:
-            for _, row in df_coloc.iterrows():
-                coord = (round(row.get('x', 0), 1), round(row.get('y', 0), 1))
-                coloc_coords.add(coord)
-        
+            if 'z' in df_coloc.columns and use_3d:
+                coloc_coords_array = df_coloc[['z', 'y', 'x', 'cell_id']].values
+            else:
+                # Add dummy z=0 for 2D matching
+                coloc_coords_array = np.column_stack([
+                    np.zeros(len(df_coloc)),
+                    df_coloc['y'].values,
+                    df_coloc['x'].values,
+                    df_coloc['cell_id'].values
+                ])
+        
+        # Calculate minimum distances for each spot in ch0 to nearest spot in ch1
+        # This will be used for sorting (ascending = closest to threshold = most uncertain)
+        distance_values = []
         flag_vector = []
-        for i, (_, row) in enumerate(df_ch0.drop_duplicates(subset=['particle']).iterrows()):
+        
+        # Get ch1 coordinates for distance calculation
+        ch1_coords = None
+        if not df_ch1_all.empty and 'x' in df_ch1_all.columns and 'y' in df_ch1_all.columns:
+            if use_3d and 'z' in df_ch1_all.columns:
+                ch1_coords = df_ch1_all[['z', 'y', 'x']].values
+            else:
+                ch1_coords = df_ch1_all[['y', 'x']].values
+        
+        # Get anisotropic scaling for 3D
+        voxel_z_nm = results.get('voxel_z_nm', 300.0)
+        voxel_xy_nm = results.get('voxel_xy_nm', 130.0)
+        z_scale = voxel_z_nm / voxel_xy_nm if use_3d and voxel_xy_nm > 0 else 1.0
+        
+        # Use the same particle column identification as CropArray
+        # This ensures our iteration matches the crop order
+        df_ch0_copy = df_ch0.copy()
+        if 'unique_particle' in df_ch0_copy.columns:
+            particle_col = 'unique_particle'
+        elif 'cell_id' in df_ch0_copy.columns:
+            if 'spot_type' in df_ch0_copy.columns:
+                df_ch0_copy['unique_particle'] = (
+                    df_ch0_copy['cell_id'].astype(str) + '_' +
+                    df_ch0_copy['spot_type'].astype(str) + '_' +
+                    df_ch0_copy['particle'].astype(str)
+                )
+            else:
+                df_ch0_copy['unique_particle'] = (
+                    df_ch0_copy['cell_id'].astype(str) + '_' +
+                    df_ch0_copy['particle'].astype(str)
+                )
+            particle_col = 'unique_particle'
+        else:
+            particle_col = 'particle'
+        
+        # Helper function to check if a spot coordinate is in the colocalized set
+        def is_coord_colocalized(z, y, x, cell_id, coloc_arr, tolerance=1.0):
+            """Check if a spot is in the colocalized set using coordinate tolerance."""
+            if len(coloc_arr) == 0:
+                return False
+            # Filter by cell_id first for efficiency
+            cell_mask = coloc_arr[:, 3].astype(int) == int(cell_id)
+            cell_coloc = coloc_arr[cell_mask]
+            if len(cell_coloc) == 0:
+                return False
+            # Check distance to each colocalized spot
+            for cz, cy, cx, _ in cell_coloc:
+                dist_xy = np.sqrt((x - cx)**2 + (y - cy)**2)
+                dist_z = abs(z - cz) if use_3d else 0
+                if dist_xy <= tolerance and dist_z <= tolerance:
+                    return True
+            return False
+        
+        # Iterate unique particles in the same order as CropArray
+        unique_particles = df_ch0_copy[particle_col].unique()
+        
+        for i, particle_id in enumerate(unique_particles):
             if i >= num_spots:
                 break
-            coord = (round(row.get('x', 0), 1), round(row.get('y', 0), 1))
-            flag_vector.append(coord in coloc_coords)
+            
+            df_particle = df_ch0_copy[df_ch0_copy[particle_col] == particle_id]
+            
+            # Check if ANY observation of this particle is colocalized
+            is_coloc = False
+            min_dist_all = threshold_px * 10.0  # Large default
+            
+            for _, row in df_particle.iterrows():
+                x_val, y_val = row['x'], row['y']
+                z_val = row.get('z', 0)
+                cell_id = row.get('cell_id', 0)
+                
+                # Check if this observation is in the colocalized set
+                if len(coloc_coords_array) > 0:
+                    if is_coord_colocalized(z_val, y_val, x_val, cell_id, coloc_coords_array, tolerance=1.0):
+                        is_coloc = True
+                
+                # Calculate minimum distance to any ch1 spot for this observation
+                if ch1_coords is not None and len(ch1_coords) > 0:
+                    if use_3d and ch1_coords.shape[1] == 3:
+                        spot_coord = np.array([[z_val * z_scale, y_val, x_val]])
+                        ch1_scaled = ch1_coords.copy().astype(float)
+                        ch1_scaled[:, 0] = ch1_scaled[:, 0] * z_scale  # Scale Z
+                    else:
+                        spot_coord = np.array([[y_val, x_val]])
+                        ch1_scaled = ch1_coords
+                    
+                    from scipy.spatial.distance import cdist
+                    distances = cdist(spot_coord, ch1_scaled, metric='euclidean')
+                    obs_min_dist = float(np.min(distances))
+                    if obs_min_dist < min_dist_all:
+                        min_dist_all = obs_min_dist
+            
+            flag_vector.append(is_coloc)
+            distance_values.append(min_dist_all)
         
-        # Pad flag_vector if needed
+        # Pad vectors if needed (shouldn't happen, but just in case)
         while len(flag_vector) < num_spots:
             flag_vector.append(False)
+            distance_values.append(threshold_px * 10.0)
         
-        # Store for later use
+        # Store for later use (sorting, etc.)
         self.verify_distance_mean_crop = mean_crop
         self.verify_distance_crop_size = crop_size
+        self.verify_distance_values = np.array(distance_values)  # For sorting by distance
         
         # Create spot crops with checkboxes
         self._create_verification_crops(
@@ -12719,6 +12908,9 @@ class GUI(QMainWindow):
             channels=(ch0, ch1)
         )
         
+        # Reset sorted flag so Sort button can be used
+        self._verify_distance_sorted = False
+        
         # Update stats label
         self._update_verify_distance_stats()
     
@@ -12743,9 +12935,88 @@ class GUI(QMainWindow):
             )
     
     def sort_verify_distance(self):
-        """Sort Verify Distance results (by cell ID or coordinate)."""
-        QMessageBox.information(self, "Sort", 
-            "Distance colocalization spots are displayed in detection order.")
+        """Sort Verify Distance results by distance value (ascending - closest to threshold first).
+        
+        Similar to Visual method's certainty-based sorting, but uses the measured
+        distance to nearest partner. Spots with distances closest to the colocalization
+        threshold are shown first as they represent the most uncertain classifications.
+        """
+        if not hasattr(self, 'verify_distance_checkboxes') or len(self.verify_distance_checkboxes) == 0:
+            QMessageBox.information(self, "No Data", "No spots to sort. Please click Populate first.")
+            return
+        
+        if not hasattr(self, 'verify_distance_mean_crop') or self.verify_distance_mean_crop is None:
+            QMessageBox.warning(self, "No Data", "Crop data not available for sorting.")
+            return
+        
+        # Check if distance values are available
+        if not hasattr(self, 'verify_distance_values') or self.verify_distance_values is None:
+            QMessageBox.warning(self, "No Distance Data", 
+                "Distance values not available. Please re-run Populate.")
+            return
+        
+        # Check if already sorted
+        if hasattr(self, '_verify_distance_sorted') and self._verify_distance_sorted:
+            QMessageBox.information(self, "Already Sorted", "Spots are already sorted by distance value.")
+            return
+        
+        mean_crop = self.verify_distance_mean_crop
+        crop_size = self.verify_distance_crop_size
+        distance_values = self.verify_distance_values
+        
+        # Get current checkbox states before sorting
+        current_states = [chk.isChecked() for chk in self.verify_distance_checkboxes]
+        num_spots = len(current_states)
+        
+        # Sort ascending by distance (closest to threshold = most uncertain first)
+        # This matches the Visual method's approach of showing uncertain cases first
+        sorted_indices = np.argsort(distance_values)
+        
+        # Re-order states and distances
+        sorted_states = [current_states[i] if i < len(current_states) else False for i in sorted_indices]
+        sorted_distances = distance_values[sorted_indices]
+        
+        # Re-order crops
+        num_crop_spots = mean_crop.shape[0] // crop_size
+        if num_crop_spots < num_spots:
+            num_spots = num_crop_spots
+            sorted_indices = sorted_indices[:num_spots]
+        
+        sorted_crop = np.zeros_like(mean_crop[:num_spots*crop_size])
+        for new_idx, old_idx in enumerate(sorted_indices[:num_spots]):
+            if old_idx < num_crop_spots:
+                sorted_crop[new_idx*crop_size:(new_idx+1)*crop_size] = \
+                    mean_crop[old_idx*crop_size:(old_idx+1)*crop_size]
+        
+        # Get channels from distance results
+        results = self.distance_coloc_results if hasattr(self, 'distance_coloc_results') else {}
+        ch0 = results.get('channel_0', 0)
+        ch1 = results.get('channel_1', 1)
+        image = self.corrected_image if self.corrected_image is not None else self.image_stack
+        num_channels = image.shape[-1] if image is not None and image.ndim == 5 else 1
+        
+        # Re-create verification crops with sorted data
+        self._create_verification_crops(
+            scroll_area=self.verify_distance_scroll_area,
+            checkboxes_list_attr='verify_distance_checkboxes',
+            mean_crop=sorted_crop,
+            crop_size=crop_size,
+            flag_vector=sorted_states,
+            stats_label=self.verify_distance_stats_label,
+            num_channels=num_channels,
+            channels=(ch0, ch1)
+        )
+        
+        # Update stored data after sorting for consistency
+        self.verify_distance_mean_crop = sorted_crop
+        self.verify_distance_values = sorted_distances
+        self._verify_distance_sort_indices = sorted_indices  # Store for reference
+        
+        # Mark as sorted
+        self._verify_distance_sorted = True
+        
+        # Update stats
+        self._update_verify_distance_stats()
     
     def cleanup_verify_distance(self):
         """Clear all checkboxes in Verify Distance subtab."""
@@ -12833,7 +13104,12 @@ class GUI(QMainWindow):
             
             # Checkbox
             chk = QCheckBox(f"Spot {i+1}")
-            chk.setChecked(bool(flag_vector[i]) if i < len(flag_vector) else False)
+            # Safely get the flag value (handle numpy arrays, lists, etc.)
+            try:
+                flag_val = bool(flag_vector[i]) if i < len(flag_vector) else False
+            except (TypeError, IndexError):
+                flag_val = False
+            chk.setChecked(flag_val)
             chk.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
             
             # Connect to stats update
@@ -12897,7 +13173,18 @@ class GUI(QMainWindow):
                     spot_coord = (int(dfm.iloc[0]['y']), int(dfm.iloc[0]['x']))
                     found_spot = True
                 else:
-                    spot_coord = (0, 0)
+                    # Particle not in current frame - jump to first valid frame for this particle
+                    df_particle = self.df_tracking[self.df_tracking[particle_col] == pid]
+                    if not df_particle.empty:
+                        first_frame = int(df_particle['frame'].min())
+                        self.current_frame = first_frame
+                        if hasattr(self, 'time_slider_tracking_vis'):
+                            self.time_slider_tracking_vis.setValue(first_frame)
+                        dfm = df_particle[df_particle['frame'] == first_frame]
+                        spot_coord = (int(dfm.iloc[0]['y']), int(dfm.iloc[0]['x']))
+                        found_spot = True
+                    else:
+                        spot_coord = (0, 0)
             else:
                 spot_coord = (0, 0)
         else:
@@ -12956,7 +13243,12 @@ class GUI(QMainWindow):
         else:
             main_img = norm_stack[selected_channelIndex]
             main_cmap = cmap_list_imagej[selected_channelIndex % len(cmap_list_imagej)]
-        gs = fig.add_gridspec(1, 2, width_ratios=[3, 2], hspace=0.1, wspace=0.1)
+        
+        # Always show 3D intensity profile for spot quality assessment
+        show_3d_profile = True
+        
+        # 3-column layout: main image + 2D crops + 3D surfaces
+        gs = fig.add_gridspec(1, 3, width_ratios=[3, 1, 1.5], hspace=0.1, wspace=0.15)
         ax_main = fig.add_subplot(gs[0, 0])
         
         # Store main axes reference and recreate RectangleSelector
@@ -12972,8 +13264,15 @@ class GUI(QMainWindow):
             props=dict(facecolor='cyan', edgecolor='white', alpha=0.3, linewidth=2)
         )
         
+        # 2D crop subgrid
         gs2 = gs[0, 1].subgridspec(C, 1, hspace=0.1)
-        axes_zoom = [fig.add_subplot(gs2[i, 0]) for i in range(C)]        
+        axes_zoom = [fig.add_subplot(gs2[i, 0]) for i in range(C)]
+        
+        # 3D profile subgrid (only create if enabled)
+        axes_3d = []
+        if show_3d_profile:
+            gs3 = gs[0, 2].subgridspec(C, 1, hspace=0.15)
+            axes_3d = [fig.add_subplot(gs3[i, 0], projection='3d') for i in range(C)]        
         # remove background if requested
         if hasattr(self, 'checkbox_remove_bg') and self.checkbox_remove_bg.isChecked():
             seg_mask = getattr(self, 'segmentation_mask', None)
@@ -13027,6 +13326,15 @@ class GUI(QMainWindow):
             rect = patches.Rectangle((x0, y0), crop_sz, crop_sz, edgecolor='white', facecolor='none', linewidth=2)
             ax_main.add_patch(rect)
         ax_main.axis('off')
+        
+        # Add thin border to show image boundaries (matching Tracking tab style)
+        # Use -0.5 origin and full size to place border outside the image
+        if self.image_stack is not None:
+            img_H, img_W = main_img.shape[:2]
+            img_border = patches.Rectangle((-0.5, -0.5), img_W, img_H, linewidth=0.8, 
+                                            edgecolor='#555555', facecolor='none', linestyle='-')
+            ax_main.add_patch(img_border)
+        
         for ci, ax in enumerate(axes_zoom):
             if found_spot:
                 crop = norm_stack[ci, y0:y1, x0:x1]
@@ -13034,6 +13342,59 @@ class GUI(QMainWindow):
                 crop = np.zeros((crop_sz, crop_sz))
             ax.imshow(crop, cmap=cmap_list_imagej[ci % len(cmap_list_imagej)], interpolation='nearest', vmin=0, vmax=1)
             ax.axis('off')
+            # Add gray frame border to 2D crops using Rectangle (spines hidden by axis('off'))
+            # Use -0.5 origin and full size to place border outside the image (matplotlib centers pixels at integers)
+            crop_h, crop_w = crop.shape[:2]
+            crop_border = patches.Rectangle((-0.5, -0.5), crop_w, crop_h, linewidth=0.8, 
+                                              edgecolor='#555555', facecolor='none', linestyle='-')
+            ax.add_patch(crop_border)
+        
+        # Render 3D intensity profiles if enabled
+        if show_3d_profile and axes_3d:
+            # Create meshgrid for surface plot (only once, using crop dimensions)
+            crop_example = norm_stack[0, y0:y1, x0:x1] if found_spot else np.zeros((crop_sz, crop_sz))
+            Y_grid, X_grid = np.meshgrid(np.arange(crop_example.shape[0]), 
+                                          np.arange(crop_example.shape[1]), indexing='ij')
+            
+            for ci, ax3d in enumerate(axes_3d):
+                if found_spot:
+                    crop = norm_stack[ci, y0:y1, x0:x1]
+                else:
+                    crop = np.zeros((crop_sz, crop_sz))
+                
+                # Get channel colormap
+                cmap = cmap_list_imagej[ci % len(cmap_list_imagej)]
+                
+                # Plot surface with matching colormap
+                ax3d.plot_surface(X_grid, Y_grid, crop, cmap=cmap, 
+                                   edgecolor='none', alpha=0.9, antialiased=True)
+                
+                # Style the 3D axes for dark theme
+                ax3d.set_facecolor('black')
+                ax3d.set_xlabel('X', fontsize=7, color='white', labelpad=-2)
+                ax3d.set_ylabel('Y', fontsize=7, color='white', labelpad=-2)
+                ax3d.set_zlabel('I', fontsize=7, color='white', labelpad=-2)
+                ax3d.tick_params(axis='both', which='major', labelsize=5, colors='white', pad=0)
+                ax3d.tick_params(axis='z', which='major', labelsize=5, colors='white', pad=0)
+                
+                # Set consistent Z limits for comparison across channels
+                ax3d.set_zlim(0, 1)
+                
+                # Make pane and grid styling match dark theme
+                ax3d.xaxis.pane.fill = False
+                ax3d.yaxis.pane.fill = False
+                ax3d.zaxis.pane.fill = False
+                ax3d.xaxis.pane.set_edgecolor('gray')
+                ax3d.yaxis.pane.set_edgecolor('gray')
+                ax3d.zaxis.pane.set_edgecolor('gray')
+                ax3d.grid(True, alpha=0.3, color='gray')
+                
+                # Add channel label
+                ax3d.set_title(f'Ch{ci}', fontsize=8, color='white', pad=-5)
+                
+                # Set viewing angle for nice perspective
+                ax3d.view_init(elev=25, azim=-45)
+        
         fig.tight_layout()
         
         # Add thin white frame border to main image
@@ -15475,6 +15836,7 @@ class GUI(QMainWindow):
             self.verify_visual_checkboxes = []
         if hasattr(self, 'verify_visual_stats_label'):
             self.verify_visual_stats_label.setText("Run Visual colocalization first, then click Populate")
+        self._verify_visual_sorted = False
         
         # Reset Verify Distance
         if hasattr(self, 'verify_distance_scroll_area'):
@@ -15483,6 +15845,11 @@ class GUI(QMainWindow):
             self.verify_distance_checkboxes = []
         if hasattr(self, 'verify_distance_stats_label'):
             self.verify_distance_stats_label.setText("Run Distance colocalization first, then click Populate")
+        # Reset stored distance data for sorting
+        self.verify_distance_mean_crop = None
+        self.verify_distance_crop_size = None
+        self.verify_distance_values = None
+        self._verify_distance_sorted = False
 
     def reset_cellpose_tab(self):
         """Reset Cellpose tab state, masks, and UI controls to defaults."""

microlive/microscopy.py

@@ -3948,7 +3948,8 @@ class BigFISH():
         
         # Select isolated spots (cluster_id < 0) and set cluster_size to 1
         spots_no_clusters = clusters_and_spots_big_fish[clusters_and_spots_big_fish[:,-1] < 0].copy()
-        spots_no_clusters[:,-1] = 1  # Replace cluster_id with cluster_size=1
+        if len(spots_no_clusters) > 0:
+            spots_no_clusters[:,-1] = 1  # Replace cluster_id with cluster_size=1
         
         # Select cluster centroids with cluster_size > 1
         clusters_no_spots = clusters[clusters[:,-2] > 1]
@@ -5012,6 +5013,7 @@ class DataProcessing():
         self.fast_gaussian_fit = fast_gaussian_fit
         # This number represent the number of columns that doesnt change with the number of color channels in the image
         self.NUMBER_OF_CONSTANT_COLUMNS_IN_DATAFRAME = 18
+        
     def get_dataframe(self):
         '''
         This method extracts data from the class SpotDetection and returns the data as a dataframe.
@@ -5162,7 +5164,7 @@ class DataProcessing():
                     array_spots_nuc[:,10:13] = spots_nuc[:,:3]   # populating coord 
                     array_spots_nuc[:,13] = 1                   # is_nuc
                     array_spots_nuc[:,14] = 0                   # is_cluster
-                    array_spots_nuc[:,15] = 0                   # cluster_size
+                    array_spots_nuc[:,15] = spots_nuc[:,3]      # cluster_size (use actual detected value)
                     array_spots_nuc[:,16] =  spot_type          # spot_type
                     array_spots_nuc[:,17] =  is_cell_in_border  # is_cell_fragmented
             
@@ -5171,7 +5173,7 @@ class DataProcessing():
                     array_spots_cytosol_only[:,10:13] = spots_cytosol_only[:,:3]    # populating coord 
                     array_spots_cytosol_only[:,13] = 0                             # is_nuc
                     array_spots_cytosol_only[:,14] = 0                             # is_cluster
-                    array_spots_cytosol_only[:,15] = 1                            # cluster_size
+                    array_spots_cytosol_only[:,15] = spots_cytosol_only[:,3]       # cluster_size (use actual detected value)
                     array_spots_cytosol_only[:,16] =  spot_type                    # spot_type
                     array_spots_cytosol_only[:,17] =  is_cell_in_border            # is_cell_fragmented
                 if (detected_cyto_clusters == True): #(detected_cyto == True) and 

{microlive-1.0.14.dist-info → microlive-1.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microlive
-Version: 1.0.14
+Version: 1.0.16
 Summary: Live-cell microscopy image analysis and single-molecule measurements
 Project-URL: Homepage, https://github.com/ningzhaoAnschutz/microlive
 Project-URL: Documentation, https://github.com/ningzhaoAnschutz/microlive/blob/main/docs/user_guide.md

{microlive-1.0.14.dist-info → microlive-1.0.16.dist-info}/RECORD

@@ -1,14 +1,13 @@
-microlive/__init__.py,sha256=ZAui2VsXaQAYA4fnc1FhYO1v3lfGGEFrmTJyZeBAY9E,1385
+microlive/__init__.py,sha256=p_eGEVyBH_4sOqlUkHXgU0D7B2P-B79xdox8lMW2cbY,1385
 microlive/imports.py,sha256=VAAMavSLIKO0LooadTXfCdZiv8LQbV_wITeIv8IHwxM,7531
-microlive/microscopy.py,sha256=97T9tEOVwBhEbAZujlDSeC3jt5xSQSCGJ8kboI6ucho,710732
+microlive/microscopy.py,sha256=OFqf0JXJW4-2cLHvXnwwp_SfMFsUXwp5lDKbkCRR4ok,710841
 microlive/ml_spot_detection.py,sha256=pVbOSGNJ0WWMuPRML42rFwvjKVZ0B1fJux1179OIbAg,10603
 microlive/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 microlive/data/icons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 microlive/data/icons/icon_micro.png,sha256=b5tFv4E6vUmLwYmYeM4PJuxLV_XqEzN14ueolekTFW0,370236
 microlive/data/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-microlive/data/models/spot_detection_cnn.pth,sha256=Np7vpPJIbKQmuKY0Hx-4IkeEDsnks_QEgs7TqaYgZmI,8468580
 microlive/gui/__init__.py,sha256=tB-CdDC7x5OwYFAQxLOUvfVnUThaXKXVRsB68YP0Y6Q,28
-microlive/gui/app.py,sha256=GTl2Iwe5uG603Ja6ykwfSG2kB7YaZJYQukLpC0DOurw,787890
+microlive/gui/app.py,sha256=sUz8MBQ4bpiNsZAhyZ7lhneY_hF45KORgepXShCCFYE,805899
 microlive/gui/main.py,sha256=b66W_2V-pclGKOozfs75pwrCGbL_jkVU3kFt8RFMZIc,2520
 microlive/gui/micro_mac.command,sha256=TkxYOO_5A2AiNJMz3_--1geBYfl77THpOLFZnV4J2ac,444
 microlive/gui/micro_windows.bat,sha256=DJUKPhDbCO4HToLwSMT-QTYRe9Kr1wn5A2Ijy2klIrw,773
@@ -21,8 +20,9 @@ microlive/utils/__init__.py,sha256=metAf2zPS8w23d8dyM7-ld1ovrOKBdx3y3zu5IVrzIg,5
 microlive/utils/device.py,sha256=tcPMU8UiXL-DuGwhudUgrbjW1lgIK_EUKIOeOn0U6q4,2533
 microlive/utils/model_downloader.py,sha256=EruviTEh75YBekpznn1RZ1Nj8lnDmeC4TKEnFLOow6Y,9448
 microlive/utils/resources.py,sha256=Jz7kPI75xMLCBJMyX7Y_3ixKi_UgydfQkF0BlFtLCKs,1753
-microlive-1.0.14.dist-info/METADATA,sha256=mxn3h5atEOVG_u04F48N-H2ORlMJLC0c4aJQ9bGbB5c,12434
-microlive-1.0.14.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-microlive-1.0.14.dist-info/entry_points.txt,sha256=Zqp2vixyD8lngcfEmOi8fkCj7vPhesz5xlGBI-EubRw,54
-microlive-1.0.14.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-microlive-1.0.14.dist-info/RECORD,,
+microlive/data/models/spot_detection_cnn.pth,sha256=Np7vpPJIbKQmuKY0Hx-4IkeEDsnks_QEgs7TqaYgZmI,8468580
+microlive-1.0.16.dist-info/METADATA,sha256=fscI8jQ0VT1fs9gUE9HtKXtlkhdH39hQiMGPV5VRx_I,12434
+microlive-1.0.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+microlive-1.0.16.dist-info/entry_points.txt,sha256=Zqp2vixyD8lngcfEmOi8fkCj7vPhesz5xlGBI-EubRw,54
+microlive-1.0.16.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+microlive-1.0.16.dist-info/RECORD,,