phasor-handler 2.2.4__tar.gz → 2.3.0__tar.gz

{phasor_handler-2.2.4/phasor_handler.egg-info → phasor_handler-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phasor-handler
-Version: 2.2.4
+Version: 2.3.0
 Summary: A PyQt6 GUI toolbox for processing two-photon phasor imaging data
 Author-email: Josia Shemuel <joshemuel@users.noreply.github.com>
 License: MIT License

{phasor_handler-2.2.4 → phasor_handler-2.3.0}/environment.yml

@@ -216,4 +216,3 @@ dependencies:
       - xarray==2024.7.0
       - xmltodict==0.14.2
       - xsdata==24.3.1
-prefix: C:\Users\user\anaconda3\envs\suite2p

{phasor_handler-2.2.4 → phasor_handler-2.3.0}/phasor_handler/__init__.py

@@ -4,6 +4,6 @@ Phasor Handler - Two-Photon Phasor Imaging Data Processor
 A PyQt6 GUI toolbox for processing two-photon phasor imaging data.
 """
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 __author__ = "Josia Shemuel"
 __all__ = ["app", "widgets", "workers", "models", "scripts", "tools", "themes"]

{phasor_handler-2.2.4 → phasor_handler-2.3.0}/phasor_handler/app.py

@@ -13,7 +13,7 @@ from PyQt6.QtGui import QFileSystemModel, QIcon
 from PyQt6.QtCore import Qt
 from PyQt6.QtCore import QThread
 
-from .widgets import ConversionWidget, RegistrationWidget, AnalysisWidget
+from .widgets import ConversionWidget, RegistrationWidget, AnalysisWidget, SecondLevelWidget
 from .workers import RegistrationWorker, ConversionWorker
 from .models.dir_manager import DirManager
 from .themes import apply_dark_theme
@@ -37,7 +37,8 @@ class MainWindow(QMainWindow):
         self.tabs.addTab(ConversionWidget(self), "Conversion")
         self.tabs.addTab(RegistrationWidget(self), "Registration")
         # AnalysisWidget exposes compatible attributes on the main window
-        self.tabs.addTab(AnalysisWidget(self), "Analysis")
+        self.tabs.addTab(AnalysisWidget(self), "First Level")
+        self.tabs.addTab(SecondLevelWidget(self), "Second Level")
         self.tabs.currentChanged.connect(self.on_tab_changed)
         self.setCentralWidget(self.tabs)
 
@@ -130,17 +131,37 @@ class MainWindow(QMainWindow):
                 self.analysis_list_widget.addItem(item)
 
     def on_tab_changed(self, idx):
-        # When switching to analysis tab, refresh its directory list
+        # When switching to first level tab, refresh its directory list
         tab_text = self.tabs.tabText(idx)
-        if tab_text == "Analysis":
+        if tab_text == "First Level":
             if hasattr(self, 'analysis_list_widget'):
+                # Capture current selection to persist it
+                current_path = None
+                selected_items = self.analysis_list_widget.selectedItems()
+                if selected_items:
+                    current_path = selected_items[0].data(Qt.ItemDataRole.UserRole)
+                
+                # Block signals to prevent unnecessary clearing/reloading of the image
+                self.analysis_list_widget.blockSignals(True)
                 self.analysis_list_widget.clear()
+                
                 from PyQt6.QtWidgets import QListWidgetItem
                 for full_path, display_name in self.dir_manager.get_display_names():
                     item = QListWidgetItem(display_name)
                     item.setToolTip(full_path)
                     item.setData(Qt.ItemDataRole.UserRole, full_path)
                     self.analysis_list_widget.addItem(item)
+                    
+                    # Restore selection if it matches
+                    if current_path is not None and full_path == current_path:
+                        item.setSelected(True)
+                        self.analysis_list_widget.setCurrentItem(item)
+                
+                self.analysis_list_widget.blockSignals(False)
+        elif tab_text == "Second Level":
+            # Trigger refresh of second level plots when tab is shown
+            if hasattr(self, 'second_level_widget'):
+                self.second_level_widget.refresh_plots()
 
     def run_conversion_script(self):
         if not self.selected_dirs:

{phasor_handler-2.2.4 → phasor_handler-2.3.0}/phasor_handler/widgets/__init__.py

@@ -1,5 +1,6 @@
 from .analysis.view import AnalysisWidget
 from .conversion.view import ConversionWidget
 from .registration.view import RegistrationWidget
+from .secondlevel.view import SecondLevelWidget
 
-__all__ = ["AnalysisWidget", "ConversionWidget", "RegistrationWidget"]
+__all__ = ["AnalysisWidget", "ConversionWidget", "RegistrationWidget", "SecondLevelWidget"]

{phasor_handler-2.2.4 → phasor_handler-2.3.0}/phasor_handler/widgets/analysis/components/circle_roi.py

@@ -21,6 +21,7 @@ class CircleRoiTool(QObject):
     roiChanged = pyqtSignal(tuple)   # (x0, y0, x1, y1) in image coords (during drag)
     roiFinalized = pyqtSignal(tuple) # (x0, y0, x1, y1) in image coords (on release)
     roiSelected = pyqtSignal(int)    # index of ROI selected by right-click
+    roiSelectionToggled = pyqtSignal(int) # index of ROI to toggle selection for (Shift+Click)
     roiDrawingStarted = pyqtSignal() # emitted when user starts drawing a new ROI
 
     def __init__(self, label: QLabel, parent=None):
@@ -77,6 +78,11 @@ class CircleRoiTool(QObject):
         self._freehand_points_origin = None  # List of original freehand points for transformations
         # whether to show the small mode text in the overlay (can be toggled by view)
         self._show_mode_text = True
+        
+        # Multi-selection support for moving multiple ROIs simultaneously
+        self._selected_roi_indices = []  # List of indices of selected ROIs
+        self._multi_roi_origins = None  # Dict storing original positions during multi-ROI drag
+        self._multi_roi_drag_offset = None # QPointF storing current drag offset
 
     def set_draw_rect(self, rect: QRect):
         """Rectangle where the scaled pixmap is drawn inside the label."""
@@ -146,6 +152,95 @@ class CircleRoiTool(QObject):
         if self._base_pixmap is not None:
             self._paint_overlay()
 
+    def finalize_multi_roi_movement(self):
+        """Finalize the multi-ROI movement by applying the offset to saved ROIs."""
+        if self._multi_roi_origins is not None and self._multi_roi_drag_offset is not None:
+            dx = self._multi_roi_drag_offset.x()
+            dy = self._multi_roi_drag_offset.y()
+            
+            # Apply changes to all selected ROIs
+            for idx, origin in self._multi_roi_origins.items():
+                if 0 <= idx < len(self._saved_rois):
+                    roi = self._saved_rois[idx]
+                    ox, oy, ow, oh = origin['bbox']
+                    new_left = ox + dx
+                    new_top = oy + dy
+                    
+                    # Convert back to image coordinates
+                    if self._draw_rect and self._img_w and self._img_h:
+                        scale_x = self._img_w / float(self._draw_rect.width())
+                        scale_y = self._img_h / float(self._draw_rect.height())
+                        
+                        img_x0 = (new_left - self._draw_rect.left()) * scale_x
+                        img_y0 = (new_top - self._draw_rect.top()) * scale_y
+                        img_x1 = img_x0 + (ow * scale_x)
+                        img_y1 = img_y0 + (oh * scale_y)
+                        
+                        # Update the ROI's xyxy coordinates
+                        roi['xyxy'] = (img_x0, img_y0, img_x1, img_y1)
+                        
+                        # If this ROI has freehand points, translate them too
+                        if origin.get('freehand_points'):
+                            original_points = origin['freehand_points']
+                            translated_points = []
+                            for pt in original_points:
+                                # Points are stored in image coordinates
+                                # Convert to label coordinates, translate, convert back
+                                label_x = self._draw_rect.left() + (pt[0] / scale_x)
+                                label_y = self._draw_rect.top() + (pt[1] / scale_y)
+                                new_label_x = label_x + dx
+                                new_label_y = label_y + dy
+                                new_img_x = (new_label_x - self._draw_rect.left()) * scale_x
+                                new_img_y = (new_label_y - self._draw_rect.top()) * scale_y
+                                translated_points.append((new_img_x, new_img_y))
+                            roi['points'] = translated_points
+
+            # Clear the origin state
+            self._multi_roi_origins = None
+            self._multi_roi_drag_offset = None
+            self._paint_overlay()
+            print(f"DEBUG: Multi-ROI movement finalized for {len(self._selected_roi_indices)} ROIs")
+            return True
+        return False
+
+    def revert_multi_roi_movement(self):
+        """Revert the multi-ROI movement back to original positions."""
+        if self._multi_roi_origins is not None and len(self._multi_roi_origins) > 0:
+            # Restore original positions for all moved ROIs
+            for idx, origin in self._multi_roi_origins.items():
+                if 0 <= idx < len(self._saved_rois):
+                    roi = self._saved_rois[idx]
+                    ox, oy, ow, oh = origin['bbox']
+                    
+                    # Convert original bbox back to image coordinates
+                    if self._draw_rect and self._img_w and self._img_h:
+                        scale_x = self._img_w / float(self._draw_rect.width())
+                        scale_y = self._img_h / float(self._draw_rect.height())
+                        
+                        img_x0 = (ox - self._draw_rect.left()) * scale_x
+                        img_y0 = (oy - self._draw_rect.top()) * scale_y
+                        img_x1 = img_x0 + (ow * scale_x)
+                        img_y1 = img_y0 + (oh * scale_y)
+                        
+                        # Restore original xyxy
+                        roi['xyxy'] = (img_x0, img_y0, img_x1, img_y1)
+                        
+                        # Restore original freehand points if they existed
+                        if origin.get('freehand_points'):
+                            roi['points'] = origin['freehand_points']
+            
+            # Clear the origin state
+            self._multi_roi_origins = None
+            self._multi_roi_drag_offset = None
+            self._paint_overlay()
+            print(f"DEBUG: Multi-ROI movement reverted for {len(self._selected_roi_indices)} ROIs")
+            return True
+        return False
+
+    def is_multi_roi_preview_active(self):
+        """Check if there's a pending multi-ROI movement preview."""
+        return self._multi_roi_origins is not None and len(self._multi_roi_origins) > 0
+
     def _get_bbox_center(self):
         """Get the center point of the current bbox."""
         if self._bbox is None:
@@ -272,8 +367,22 @@ class CircleRoiTool(QObject):
                 else:
                     print("Draw an ROI first before switching interaction modes")
                     return True
+            elif event.key() == Qt.Key.Key_R:
+                # Finalize multi-ROI movement if active
+                if self._multi_roi_drag_offset is not None and self._multi_roi_origins:
+                    self.finalize_multi_roi_movement()
+                    # End the drag operation
+                    self._dragging = False
+                    self._mode = None
+                    self._translate_anchor = None
+                    return True
 
         if et == event.Type.MouseButtonPress:
+            # Check for pending multi-ROI preview and cancel it if clicking elsewhere to start new drawing
+            if self._multi_roi_origins is not None:
+                 print("DEBUG: Cancelling multi-ROI preview due to new Left Click")
+                 self.revert_multi_roi_movement()
+            
             if event.button() == Qt.MouseButton.LeftButton and self._in_draw_rect(event.position()):
                 # Emit signal that ROI drawing has started
                 self.roiDrawingStarted.emit()
@@ -315,6 +424,51 @@ class CircleRoiTool(QObject):
             if event.button() == Qt.MouseButton.RightButton and self._mode != 'draw':
                 p = event.position()  # QPointF
                 
+                # Check if we clicked on an ROI
+                clicked_roi_index = self._find_roi_at_point(p)
+                
+                # Check for pending multi-ROI preview
+                if self._multi_roi_origins is not None:
+                    # If we click right button again, we might want to cancel the previous preview
+                    # UNLESS we are clicking on the ghost? But ghosts aren't clickable objects yet.
+                    # User said "reset translate from original", so cancel is appropriate.
+                    print("DEBUG: Cancelling multi-ROI preview due to new Right Click")
+                    self.revert_multi_roi_movement()
+                
+                # Check for Shift+Click (Multi-selection toggle or add)
+                # User Requirement: "The Shift button needs to be HOLD DOWN... It's not just a toggle"
+                # This implies explicit check for modifier. 
+                if clicked_roi_index is not None and (event.modifiers() & Qt.KeyboardModifier.ShiftModifier):
+                    print(f"DEBUG: Shift+RightClick on ROI {clicked_roi_index} - toggling selection")
+                    self.roiSelectionToggled.emit(clicked_roi_index)
+                    return True
+                
+                # Check if multiple ROIs are selected AND we clicked on one of them
+                if len(self._selected_roi_indices) > 1 and clicked_roi_index is not None and clicked_roi_index in self._selected_roi_indices:
+                    # Multi-selection mode - move all selected ROIs together
+                    print(f"DEBUG: Multi-ROI drag started - moving {len(self._selected_roi_indices)} ROIs")
+                    self._mode = 'translate'
+                    self._dragging = True
+                    self._translate_anchor = p
+                    self._multi_roi_drag_offset = QPointF(0, 0)
+                    
+                    # Store original positions of all selected ROIs
+                    self._multi_roi_origins = {}
+                    for idx in self._selected_roi_indices:
+                        if 0 <= idx < len(self._saved_rois):
+                            roi = self._saved_rois[idx]
+                            xyxy = roi.get('xyxy')
+                            if xyxy:
+                                lbbox = self._label_bbox_from_image_xyxy(xyxy)
+                                if lbbox:
+                                    self._multi_roi_origins[idx] = {
+                                        'bbox': lbbox,
+                                        'rotation': roi.get('rotation', 0.0),
+                                        'freehand_points': roi.get('points', None)
+                                    }
+                    return True
+                
+                # Single selection mode - original behavior
                 # First, check if we're clicking on any saved ROI
                 roi_index = self._find_roi_at_point(p)
                 if roi_index is not None:
@@ -425,31 +579,47 @@ class CircleRoiTool(QObject):
                     self.roiChanged.emit(xyxy)
                 return True
 
-            elif self._mode == 'translate' and self._bbox_origin is not None and self._translate_anchor is not None:
-                # compute delta and move bbox using float math to avoid size drift
-                anchor = self._translate_anchor
-                dx = pos.x() - anchor.x()
-                dy = pos.y() - anchor.y()
-                ox, oy, ow, oh = self._bbox_origin
-                new_left = ox + dx
-                new_top = oy + dy
-                
-                self._bbox = (new_left, new_top, ow, oh)
-                
-                # Also translate freehand points if they exist
-                if self._freehand_points_origin:
-                    self._freehand_points = []
-                    for pt in self._freehand_points_origin:
-                        new_pt = QPointF(pt.x() + dx, pt.y() + dy)
-                        self._freehand_points.append(new_pt)
+            elif self._mode == 'translate' and self._translate_anchor is not None:
+                # Check if we're in multi-ROI mode
+                if self._multi_roi_origins is not None and len(self._multi_roi_origins) > 0:
+                    # Multi-ROI translation mode - PREVIEW ONLY
+                    anchor = self._translate_anchor
+                    dx = pos.x() - anchor.x()
+                    dy = pos.y() - anchor.y()
                     
-                    # Recalculate bbox from translated points to ensure center alignment
-                    self._update_bbox_from_freehand_points()
+                    # Update offset
+                    self._multi_roi_drag_offset = QPointF(dx, dy)
+                    
+                    # Repaint to show preview
+                    self._paint_overlay()
+                    return True
                 
-                self._paint_overlay()
-                xyxy = self._current_roi_image_coords()
-                if xyxy is not None:
-                    self.roiChanged.emit(xyxy)
+                # Single ROI translation (original behavior)
+                if self._bbox_origin is not None:
+                    # compute delta and move bbox using float math to avoid size drift
+                    anchor = self._translate_anchor
+                    dx = pos.x() - anchor.x()
+                    dy = pos.y() - anchor.y()
+                    ox, oy, ow, oh = self._bbox_origin
+                    new_left = ox + dx
+                    new_top = oy + dy
+                    
+                    self._bbox = (new_left, new_top, ow, oh)
+                    
+                    # Also translate freehand points if they exist
+                    if self._freehand_points_origin:
+                        self._freehand_points = []
+                        for pt in self._freehand_points_origin:
+                            new_pt = QPointF(pt.x() + dx, pt.y() + dy)
+                            self._freehand_points.append(new_pt)
+                        
+                        # Recalculate bbox from translated points to ensure center alignment
+                        self._update_bbox_from_freehand_points()
+                    
+                    self._paint_overlay()
+                    xyxy = self._current_roi_image_coords()
+                    if xyxy is not None:
+                        self.roiChanged.emit(xyxy)
                 return True
 
             elif self._mode == 'rotate' and self._rotation_anchor is not None:
@@ -539,6 +709,21 @@ class CircleRoiTool(QObject):
 
             if self._mode == 'translate' and event.button() == Qt.MouseButton.RightButton:
                 self._dragging = False
+                
+                # Check if we're in multi-ROI mode
+                # Check if we're in multi-ROI mode
+                if self._multi_roi_origins is not None and len(self._multi_roi_origins) > 0:
+                    # Mouse released -> KEEP PREVIEW
+                    self._translate_anchor = None
+                    self._mode = None
+                    self._dragging = False # Stop dragging but keep state
+                    
+                    # Repaint to keep preview visible
+                    self._paint_overlay()
+                    print(f"DEBUG: Multi-ROI drag released - preview kept. Press 'R' to commit, click elsewhere to cancel.")
+                    return True
+                
+                # Single ROI translation finalization (original behavior)
                 # finalize translation
                 self._translate_anchor = None
                 self._bbox_origin = None
@@ -764,7 +949,11 @@ class CircleRoiTool(QObject):
                         lx0, ly0, lw, lh = lbbox
                         px0 = float(lx0) - offset_x
                         py0 = float(ly0) - offset_y
-                        # determine color
+                        
+                        # Check if this ROI is selected
+                        is_selected = idx in self._selected_roi_indices
+                        
+                        # determine color - use brighter/thicker pen for selected ROIs
                         col = saved.get('color')
                         if isinstance(col, QColor):
                             qcol = col
@@ -773,8 +962,16 @@ class CircleRoiTool(QObject):
                             qcol = QColor(int(col[0]), int(col[1]), int(col[2]), int(a))
                         else:
                             qcol = QColor(200, 100, 10, 200)
-                        spen = QPen(qcol)
-                        spen.setWidth(3)
+                        
+                        # Highlight selected ROIs with thicker, brighter border
+                        if is_selected:
+                            # Use a brighter version of the ROI's own color
+                            spen = QPen(qcol.lighter(150))
+                            spen.setColor(QColor(spen.color().red(), spen.color().green(), spen.color().blue(), 255)) # Ensure opaque
+                            spen.setWidth(5)
+                        else:
+                            spen = QPen(qcol)
+                            spen.setWidth(3)
                         painter.setPen(spen)
                         
                         # Check ROI type
@@ -874,6 +1071,75 @@ class CircleRoiTool(QObject):
             except Exception:
                 pass
 
+        # Draw Multi-ROI Drag Preview (Ghosts)
+        if self._multi_roi_origins is not None and self._multi_roi_drag_offset is not None:
+            try:
+                dx = self._multi_roi_drag_offset.x()
+                dy = self._multi_roi_drag_offset.y()
+                
+                # Use a distinct pen for ghosts
+                ghost_pen = QPen(QColor(255, 255, 0, 200)) # Yellow
+                ghost_pen.setWidth(2)
+                ghost_pen.setStyle(Qt.PenStyle.DashLine)
+                painter.setPen(ghost_pen)
+                
+                for idx, origin in self._multi_roi_origins.items():
+                    ox, oy, ow, oh = origin['bbox']
+                    
+                    # Apply offset
+                    ghost_left = ox + dx
+                    ghost_top = oy + dy
+                    
+                    # Draw ghost based on type
+                    if 0 <= idx < len(self._saved_rois):
+                        roi = self._saved_rois[idx]
+                        roi_type = roi.get('type', 'circular')
+                        rotation = roi.get('rotation', 0.0)
+                        
+                        if roi_type == 'freehand' and origin.get('freehand_points'):
+                            # Draw freehand ghost
+                            if self._draw_rect and self._img_w and self._img_h:
+                                polygon = QPolygonF()
+                                scale_x = self._img_w / float(self._draw_rect.width())
+                                scale_y = self._img_h / float(self._draw_rect.height())
+                                
+                                for pt in origin['freehand_points']:
+                                    # Image -> Label
+                                    lx = self._draw_rect.left() + (pt[0] / scale_x)
+                                    ly = self._draw_rect.top() + (pt[1] / scale_y)
+                                    # Apply drag offset
+                                    lx += dx
+                                    ly += dy
+                                    # Label -> Pixmap
+                                    px = lx - offset_x
+                                    py = ly - offset_y
+                                    polygon.append(QPointF(px, py))
+                                painter.drawPolygon(polygon)
+                        else:
+                            # Draw Rect/Ellipse ghost
+                            px = ghost_left - offset_x
+                            py = ghost_top - offset_y
+                            
+                            if rotation != 0.0:
+                                center_x = px + ow / 2.0
+                                center_y = py + oh / 2.0
+                                painter.save()
+                                painter.translate(center_x, center_y)
+                                painter.rotate(math.degrees(rotation))
+                                if roi_type == 'rectangular':
+                                    painter.drawRect(int(round(-ow/2)), int(round(-oh/2)), int(round(ow)), int(round(oh)))
+                                else:
+                                    painter.drawEllipse(int(round(-ow/2)), int(round(-oh/2)), int(round(ow)), int(round(oh)))
+                                painter.restore()
+                            else:
+                                if roi_type == 'rectangular':
+                                    painter.drawRect(int(round(px)), int(round(py)), int(round(ow)), int(round(oh)))
+                                else:
+                                    painter.drawEllipse(int(round(px)), int(round(py)), int(round(ow)), int(round(oh)))
+
+            except Exception as e:
+                print(f"Error drawing multi-ROI preview: {e}")
+
         # Draw stimulus ROIs with distinctive styling (if visible)
         if getattr(self, '_show_stim_rois', True):
             try:
@@ -937,6 +1203,21 @@ class CircleRoiTool(QObject):
             font.setBold(True)
             painter.setFont(font)
             painter.drawText(10, 25, mode_text)
+        
+        # Draw multi-selection indicator when multiple ROIs are selected
+        if len(self._selected_roi_indices) > 1 and getattr(self, '_show_mode_text', True):
+            # Check if we're in preview mode (after drag, before finalize)
+            if self._multi_roi_origins is not None and len(self._multi_roi_origins) > 0:
+                multi_text = f"Preview: {len(self._selected_roi_indices)} ROIs moved - Press 'R' to finalize, Escape to revert"
+                painter.setPen(QPen(QColor(255, 165, 0, 255)))  # Orange for preview
+            else:
+                multi_text = f"Selected: {len(self._selected_roi_indices)} ROIs (right-click drag to move all)"
+                painter.setPen(QPen(QColor(255, 255, 0, 255)))  # Bright yellow
+            font = QFont()
+            font.setPointSize(11)
+            font.setBold(True)
+            painter.setFont(font)
+            painter.drawText(10, 50, multi_text)
 
         painter.end()
         self._label.setPixmap(overlay)

{phasor_handler-2.2.4 → phasor_handler-2.3.0}/phasor_handler/widgets/analysis/components/meta_info.py

@@ -291,7 +291,7 @@ class MetadataViewer(QDialog):
             self.add_info_row(self.stim_layout, row, "Camera Frame Rate (Hz)", str(camera_framerate))
         else:
             # 3i: Show stimulation information
-            stim_keys = ['stimulation_timeframes', 'stimulation_ms', 'duty_cycle', 'stimulated_roi_location', 'stimulated_rois']
+            stim_keys = ['stimulation_timeframes', 'stimulation_ms', 'duty_cycle', 'stimulated_roi_location', 'stimulated_rois', 'stimulated_roi_powers']
             for key in stim_keys:
                 if key in self.metadata:
                     value = self.metadata[key]
@@ -315,6 +315,9 @@ class MetadataViewer(QDialog):
                             else:
                                 display_value = ', '.join([', '.join(map(str, x)) for x in value])
                             key = "Stimulated ROIs"
+                        elif key == 'stimulated_roi_powers':
+                            display_value = ', '.join(map(str, value))
+                            key = "Stimulated ROI Powers"
                     else:
                         display_value = str(value)
                     self.add_info_row(self.stim_layout, row, key.replace('_', ' '),