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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phasor-handler
-Version: 2.2.3
+Version: 2.2.4
 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.3 → phasor_handler-2.2.4}/phasor_handler/app.py

@@ -244,7 +244,7 @@ class MainWindow(QMainWindow):
 def main():
     app = QApplication(sys.argv)
     try:
-        qdarktheme.setup_theme("auto")  # or your own apply_dark_theme()
+        qdarktheme.setup_theme()  # or your own apply_dark_theme()
     except Exception:
         pass  # fall back to default if theme package missing
     window = MainWindow()

{phasor_handler-2.2.3 → phasor_handler-2.2.4}/phasor_handler/scripts/meta_reader.py

@@ -1,5 +1,3 @@
-# TODO read from .txt files of CHA and CHB channels if available
-
 #!/usr/bin/env python3
 """
 meta_reader.py
@@ -32,6 +30,42 @@ class DataFrameDict(dict):
         self[key] = value
 
 # ------------- FUNCTIONS -------------
+
+# Mini2P text file parser
+_SPLIT = re.compile(r"\s{4,}")  # split key/value on 4+ spaces
+
+def read_mini2p_meta(path):
+    """
+    Read Mini2P metadata from Information-CHA.txt or Information-CHB.txt files.
+    
+    Args:
+        path: Path to the text file
+        
+    Returns:
+        dict: Nested dictionary with sections as keys
+    """
+    from pathlib import Path
+    from typing import Dict, Any
+    
+    path = Path(path)
+    data: Dict[str, Dict[str, Any]] = {}
+    section = None
+    with path.open(encoding="utf-8-sig") as f:  # utf-8 with BOM safe; handles 'μ'
+        for raw in f:
+            line = raw.strip()
+            if not line or line.startswith(("#", ";")):
+                continue
+            if line.startswith("[") and line.endswith("]"):
+                section = line[1:-1].strip()
+                data.setdefault(section, {})
+                continue
+            if section is None: 
+                section = "_root_"
+                data.setdefault(section, {})
+            parts = _SPLIT.split(line, maxsplit=1) 
+            key, val = (parts[0].strip(), parts[1].strip()) if len(parts) == 2 else (parts[0], "")
+            data[section][key] = val
+    return data
 def open_overwrite(path, *args, **kwargs):
     path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -358,7 +392,7 @@ def process_i3_folder(folder_path: str):
 
     # Output a json file 
     with open_overwrite(Path(folder_path) / 'experiment_summary.json', 'w', encoding='utf-8') as f:
-        json.dump(variables, f, indent=4)
+        json.dump(variables, f, indent=4, ensure_ascii=False)
 
     print(f"JSON file and Pickle file saved to {folder_path}")
 
@@ -399,6 +433,8 @@ def process_mini2p_folder(folder_path: str):
     # Collect all subdirectories and TDMS files
     folders = {}
     path_df = {}
+    txt_meta = {}  # Store parsed txt metadata
+    
     for subdir in os.listdir(folder_path):
         subdir_path = os.path.join(folder_path, subdir)
         if os.path.isdir(subdir_path):
@@ -406,6 +442,16 @@ def process_mini2p_folder(folder_path: str):
             tdms_files = [os.path.join(subdir_path, f) for f in os.listdir(subdir_path) if f.endswith('.tdms')]
             txt_files = [os.path.join(subdir_path, f) for f in os.listdir(subdir_path) if f.endswith('.txt')]
 
+            # Parse txt files for channel information
+            for txt_file in txt_files:
+                txt_filename = os.path.basename(txt_file)
+                if 'Information-CHA.txt' in txt_filename or 'Information-CHB.txt' in txt_filename:
+                    try:
+                        txt_meta[txt_filename] = read_mini2p_meta(txt_file)
+                        print(f"[INFO] Parsed metadata from {txt_filename}")
+                    except Exception as e:
+                        print(f"[WARN] Failed to parse {txt_filename}: {e}")
+
             if txt_files:
                 path_df[subdir] = (tdms_files, txt_files)
             elif tdms_files:
@@ -449,20 +495,41 @@ def process_mini2p_folder(folder_path: str):
         for _, row in info_df.iterrows():
             image_info[row['Item']] = row['Value']
     
-    # Parse timestamp from image info
+    # Override/supplement with txt file metadata if available
+    txt_cha = next((txt_meta[k] for k in txt_meta if 'CHA' in k), None)
+    txt_chb = next((txt_meta[k] for k in txt_meta if 'CHB' in k), None)
+    
+    # Use the first available txt metadata (prefer CHA)
+    primary_txt = txt_cha if txt_cha else txt_chb
+    
+    # Parse timestamp from txt file or image info
     import datetime
-    timestamp_str = safe_extract(lambda: image_info.get('Image time', 'NA'))
+    
+    timestamp_str = "NA"
+    if primary_txt and 'Basic Information' in primary_txt:
+        timestamp_str = safe_extract(lambda: primary_txt['Basic Information'].get('Time', 'NA'))
+    if timestamp_str == "NA":
+        timestamp_str = safe_extract(lambda: image_info.get('Image time', 'NA'))
+    
     if timestamp_str != 'NA':
         try:
-            # Parse format like "10/16/2025 11:19:54 PM"
-            dt = datetime.datetime.strptime(timestamp_str, "%m/%d/%Y %I:%M:%S %p")
+            # Try Mini2P format first: "2025-10-16_23-14-26.286"
+            if '_' in timestamp_str and '-' in timestamp_str:
+                # Format: YYYY-MM-DD_HH-MM-SS.mmm
+                timestamp_str = timestamp_str.split('.')[0]  # Remove milliseconds
+                dt = datetime.datetime.strptime(timestamp_str, "%Y-%m-%d_%H-%M-%S")
+            else:
+                # Try format like "10/16/2025 11:19:54 PM"
+                dt = datetime.datetime.strptime(timestamp_str, "%m/%d/%Y %I:%M:%S %p")
+            
             day = dt.day
             month = dt.month
             year = dt.year
             hour = dt.hour
             minute = dt.minute
             second = dt.second
-        except:
+        except Exception as e:
+            print(f"[WARN] Could not parse timestamp '{timestamp_str}': {e}")
             day = month = year = hour = minute = second = "NA"
     else:
         day = month = year = hour = minute = second = "NA"
@@ -519,7 +586,7 @@ def process_mini2p_folder(folder_path: str):
         "pixel_size": safe_extract(lambda: image_info.get('Image size_Pixel', 'NA')),
         "height": safe_extract(lambda: int(image_info.get('Image size_Line', 'NA'))),
         "width": safe_extract(lambda: int(image_info.get('Image size_Pixel', 'NA'))),
-        "FOV_size": "NA",  # Mini2P doesn't provide micron measurements in TDMS
+        "FOV_size": "NA",  # Will be updated from txt if available
         "zoom": safe_extract(lambda: image_info.get('Zoom', 'NA')),
         "laser_voltage": safe_extract(lambda: image_info.get('Laser(V)', 'NA')),
         "pmt_voltage": safe_extract(lambda: image_info.get('PMT(V)', 'NA')),
@@ -553,12 +620,93 @@ def process_mini2p_folder(folder_path: str):
         "data_folders": list(tdms_data.keys())
     }
     
+    # Enhance with txt file metadata if available
+    if primary_txt:
+        # Basic Information
+        if 'Basic Information' in primary_txt:
+            basic = primary_txt['Basic Information']
+            variables["system_config"] = safe_extract(lambda: basic.get('SystemConfig', 'NA'))
+            variables["probe"] = safe_extract(lambda: basic.get('Probe', 'NA'))
+            variables["imaging_mode"] = safe_extract(lambda: basic.get('ImagingMode', 'NA'))
+            variables["supergin_version"] = safe_extract(lambda: basic.get('SUPERGIN_Version', 'NA'))
+            variables["probe_type"] = safe_extract(lambda: basic.get('Probe_Type', 'NA'))
+            variables["pmt_gain"] = safe_extract(lambda: basic.get('PMT_Gain', 'NA'))
+        
+        # Power Regulation
+        if 'PowerRegulation' in primary_txt:
+            power = primary_txt['PowerRegulation']
+            variables["power_regulation_mode"] = safe_extract(lambda: power.get('PowerRegulationMode', 'NA'))
+            variables["power_voltage"] = safe_extract(lambda: power.get('Power', 'NA'))
+            variables["power_percentage"] = safe_extract(lambda: power.get('PowerPercentage', 'NA'))
+        
+        # Scan Information
+        if 'Scan' in primary_txt:
+            scan = primary_txt['Scan']
+            variables["scan_direction"] = safe_extract(lambda: scan.get('Scan_Direction', 'NA'))
+            variables["pixel_dwell"] = safe_extract(lambda: scan.get('Pixel_Dwell', 'NA'))
+            variables["frame_rate"] = safe_extract(lambda: scan.get('Frame_Rate', 'NA'))
+            variables["scan_frequency"] = safe_extract(lambda: scan.get('Frequency', 'NA'))
+            variables["fps_division"] = safe_extract(lambda: scan.get('FPS_Division', 'NA'))
+            
+            # Update dimensions from txt if available
+            pixel_x = safe_extract(lambda: int(scan.get('Pixel_X', 'NA')))
+            pixel_y = safe_extract(lambda: int(scan.get('Pixel_Y', 'NA')))
+            if pixel_x != "NA":
+                variables["width"] = pixel_x
+            if pixel_y != "NA":
+                variables["height"] = pixel_y
+        
+        # Zoom Information
+        if 'Zoom' in primary_txt:
+            zoom_info = primary_txt['Zoom']
+            variables["zoom"] = safe_extract(lambda: zoom_info.get('Zoom', 'NA'))
+            variables["amplitude_x"] = safe_extract(lambda: zoom_info.get('Amplitude_X', 'NA'))
+            variables["amplitude_y"] = safe_extract(lambda: zoom_info.get('Amplitude_Y', 'NA'))
+            variables["pixel_size"] = safe_extract(lambda: zoom_info.get('Pixel_Size', 'NA'))
+            variables["fov_x"] = safe_extract(lambda: zoom_info.get('Fov_X', 'NA'))
+            variables["fov_y"] = safe_extract(lambda: zoom_info.get('Fov_Y', 'NA'))
+            variables["FOV_size"] = safe_extract(lambda: f"{zoom_info.get('Fov_X', 'NA')} x {zoom_info.get('Fov_Y', 'NA')}")
+            variables["save_frames"] = safe_extract(lambda: zoom_info.get('Save Frames', 'NA'))
+        
+        # Stage Position
+        if 'Stage' in primary_txt:
+            stage = primary_txt['Stage']
+            variables["X_start_position"] = safe_extract(lambda: stage.get('Displacement_X', 'NA'))
+            variables["Y_start_position"] = safe_extract(lambda: stage.get('Displacement_Y', 'NA'))
+            variables["Z_start_position"] = safe_extract(lambda: stage.get('Displacement_Z', 'NA'))
+        
+        # ETL Information
+        if 'ETL' in primary_txt:
+            etl = primary_txt['ETL']
+            variables["etl_voltage"] = safe_extract(lambda: etl.get('Voltage', 'NA'))
+            variables["etl_distance"] = safe_extract(lambda: etl.get('Distance', 'NA'))
+        
+        # Behavioral Setting
+        if 'Behavioral Setting' in primary_txt:
+            behavioral = primary_txt['Behavioral Setting']
+            variables["camera_framerate"] = safe_extract(lambda: behavioral.get('Camera FrameRate', 'NA'))
+        
+        # Time Division Mode
+        if 'TimeDivisionMode' in primary_txt:
+            tdm = primary_txt['TimeDivisionMode']
+            variables["time_division_power"] = safe_extract(lambda: tdm.get('TimeDivisionModePower', 'NA'))
+            variables["channel_framerate"] = safe_extract(lambda: tdm.get('Channel FrameRate', 'NA'))
+    
+    # Add channel-specific metadata if both channels are available
+    if txt_cha and txt_chb:
+        variables["cha_metadata"] = txt_cha
+        variables["chb_metadata"] = txt_chb
+    elif txt_cha:
+        variables["cha_metadata"] = txt_cha
+    elif txt_chb:
+        variables["chb_metadata"] = txt_chb
+    
     # Save metadata
     with open(Path(folder_path) / 'experiment_summary.pkl', 'wb') as f:
         pickle.dump(variables, f)
     
     with open_overwrite(Path(folder_path) / 'experiment_summary.json', 'w', encoding='utf-8') as f:
-        json.dump(variables, f, indent=4)
+        json.dump(variables, f, indent=4, ensure_ascii=False)
     
     print(f"[OK] Mini2P metadata saved to {folder_path}")
     print("\n[OK] Files saved successfully.")

{phasor_handler-2.2.3 → phasor_handler-2.2.4}/phasor_handler/widgets/analysis/components/image_view.py

@@ -817,9 +817,10 @@ class ImageViewWidget(QWidget):
             if isinstance(metadata, dict):
                 # Check direct key
                 if 'pixel_size' in metadata:
-                    return float(metadata['pixel_size'])
+                    pixel_size_str = str(metadata['pixel_size'])
+                    return self._parse_pixel_size_string(pixel_size_str)
                 
-                # Check nested structure from ImageRecord.yaml
+                # Check nested structure from ImageRecord.yaml (3i format)
                 if ('ImageRecord.yaml' in metadata and 
                     'CLensDef70' in metadata['ImageRecord.yaml'] and
                     'mMicronPerPixel' in metadata['ImageRecord.yaml']['CLensDef70']):
@@ -827,11 +828,44 @@ class ImageViewWidget(QWidget):
                     
             # Try as object with attributes
             elif hasattr(metadata, 'pixel_size'):
-                return float(metadata.pixel_size)
+                pixel_size_str = str(metadata.pixel_size)
+                return self._parse_pixel_size_string(pixel_size_str)
             elif hasattr(metadata, 'mMicronPerPixel'):
                 return float(metadata.mMicronPerPixel)
                 
         except (KeyError, TypeError, ValueError, AttributeError) as e:
             print(f"DEBUG: Could not extract pixel size from metadata: {e}")
         
-        return None
+        return None
+    
+    def _parse_pixel_size_string(self, pixel_size_str):
+        """
+        Parse pixel size string to extract numeric value in microns.
+        Handles formats like:
+        - '0.201μm/pixel'
+        - '0.201'
+        - 0.201
+        
+        Args:
+            pixel_size_str: String or number containing pixel size
+            
+        Returns:
+            float: Pixel size in microns per pixel
+        """
+        import re
+        
+        # If already a number, return it
+        if isinstance(pixel_size_str, (int, float)):
+            return float(pixel_size_str)
+        
+        # Convert to string and extract numeric part
+        pixel_size_str = str(pixel_size_str)
+        
+        # Try to extract the first number from the string
+        # Handles formats like "0.201μm/pixel" or "0.598μm/pixel"
+        match = re.search(r'(\d+\.?\d*)', pixel_size_str)
+        if match:
+            return float(match.group(1))
+        
+        # If no match, try direct float conversion as last resort
+        return float(pixel_size_str)

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

@@ -1,3 +1,5 @@
+# TODO Implement behavioural and sync information to metadata.
+
 """
 Metadata Information Viewer Component
 
@@ -13,6 +15,7 @@ from PyQt6.QtWidgets import (
 from PyQt6.QtCore import Qt, QSize
 from PyQt6.QtGui import QFont
 import json
+import re
 
 
 class MetadataViewer(QDialog):
@@ -104,7 +107,7 @@ class MetadataViewer(QDialog):
         self.timing_group.setLayout(self.timing_layout)
         layout.addWidget(self.timing_group)
         
-        # Stimulation Information Group
+        # Stimulation/Behavioral Information Group (will be renamed based on device)
         self.stim_group = QGroupBox("Stimulation Information")
         self.stim_layout = QGridLayout()
         self.stim_group.setLayout(self.stim_layout)
@@ -216,6 +219,16 @@ class MetadataViewer(QDialog):
             
     def update_overview_from_dict(self):
         """Update overview from dictionary metadata."""
+        # Determine device type
+        device_name = self.metadata.get('device_name', '').lower() if isinstance(self.metadata.get('device_name'), str) else ''
+        is_mini2p = 'mini' in device_name
+        
+        # Update group title based on device
+        if is_mini2p:
+            self.stim_group.setTitle("Behavioral Information")
+        else:
+            self.stim_group.setTitle("Stimulation Information")
+        
         # Experiment Summary
         row = 0
         for key in ['device_name', 'n_frames']:
@@ -270,37 +283,43 @@ class MetadataViewer(QDialog):
                                 display_value) if key != "Date (DDMMYYYY)" else self.add_info_row(self.timing_layout, row, key, display_value)
                 row += 1
         
-        # Stimulation Information
+        # Stimulation/Behavioral Information (device-specific)
         row = 0
-        stim_keys = ['stimulation_timeframes', 'stimulation_ms', 'duty_cycle', 'stimulated_roi_location', 'stimulated_rois']
-        for key in stim_keys:
-            if key in self.metadata:
-                value = self.metadata[key]
-                if isinstance(value, list):
-                    if key == 'stimulation_timeframes':
-                        display_value = ', '.join(map(str, value))
-                        key = "Stimulation Timeframes"
-                    elif key == 'stimulation_ms':
-                        display_value = ', '.join(map(str, [int(v/1000) for v in value]))
-                        key = "Stimulation Time (s)"
-                    elif key == 'duty_cycle':
-                        duty_cycle_counts = {val: value.count(val) for val in set(value)}
-                        display_value = ' | '.join([f'{val}: {count}X' for val, count in duty_cycle_counts.items()])
-                        key = "Duty Cycle"
-                    elif key == 'stimulated_roi_location':
-                        display_value = ', '.join(map(str, [len(x) for x in value]))
-                        key = "Number of stimulated ROIs"
-                    elif key == 'stimulated_rois':
-                        if not value or all(not sublist for sublist in value):
-                            display_value = "NA"
-                        else:
-                            display_value = ', '.join([', '.join(map(str, x)) for x in value])
-                        key = "Stimulated ROIs"
-                else:
-                    display_value = str(value)
-                self.add_info_row(self.stim_layout, row, key.replace('_', ' '), 
-                                display_value)
-                row += 1
+        if is_mini2p:
+            # Mini2P: Show only camera frame rate for behavioral information
+            camera_framerate = self.metadata.get('camera_framerate', 'NA')
+            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']
+            for key in stim_keys:
+                if key in self.metadata:
+                    value = self.metadata[key]
+                    if isinstance(value, list):
+                        if key == 'stimulation_timeframes':
+                            display_value = ', '.join(map(str, value))
+                            key = "Stimulation Timeframes"
+                        elif key == 'stimulation_ms':
+                            display_value = ', '.join(map(str, [int(v/1000) for v in value]))
+                            key = "Stimulation Time (s)"
+                        elif key == 'duty_cycle':
+                            duty_cycle_counts = {val: value.count(val) for val in set(value)}
+                            display_value = ' | '.join([f'{val}: {count}X' for val, count in duty_cycle_counts.items()])
+                            key = "Duty Cycle"
+                        elif key == 'stimulated_roi_location':
+                            display_value = ', '.join(map(str, [len(x) for x in value]))
+                            key = "Number of stimulated ROIs"
+                        elif key == 'stimulated_rois':
+                            if not value or all(not sublist for sublist in value):
+                                display_value = "NA"
+                            else:
+                                display_value = ', '.join([', '.join(map(str, x)) for x in value])
+                            key = "Stimulated ROIs"
+                    else:
+                        display_value = str(value)
+                    self.add_info_row(self.stim_layout, row, key.replace('_', ' '), 
+                                    display_value)
+                    row += 1
         
         # Image Information
         row = 0
@@ -308,10 +327,14 @@ class MetadataViewer(QDialog):
         for key in image_keys:
             if key in self.metadata:
                 value = self.metadata[key]
-                if key == "pixel_size": key = "Pixel Size (µm)"
+                if key == "pixel_size": 
+                    key = "Pixel Size (µm)"
+                    value = re.sub(r'[^0-9.]+', '', str(value))
                 elif key == "FOV_size": 
                     key = "FOV Size (µm)"
-                    value = value[:-7]
+                    # Parse FOV_size to format as "206 x 176" (without μm on individual values)
+                    # Example input: "206μm x 176μm"
+                    value = str(value).replace('μm', '').replace('um', '').replace('microns', '').strip()
 
                 self.add_info_row(self.image_layout, row, key.replace('_', ' '), 
                                 str(value))

{phasor_handler-2.2.3 → phasor_handler-2.2.4}/phasor_handler/widgets/analysis/components/roi_list.py

@@ -74,20 +74,15 @@ class RoiListWidget(QWidget):
         roi_grid_layout.addWidget(self.save_roi_btn, 1, 0)
         roi_grid_layout.addWidget(self.load_roi_btn, 1, 1)
         roi_grid_layout.addWidget(self.export_trace_btn, 2, 0, 1, 2)
+
+        from PyQt6.QtWidgets import QCheckBox
+        self.hide_rois_checkbox = QCheckBox("Hide ROIs")
+        self.hide_rois_checkbox.stateChanged.connect(self._on_hide_rois_toggled)
+        roi_grid_layout.addWidget(self.hide_rois_checkbox, 3, 0)
         
-        # Create checkboxes for ROI display options
-        try:
-            from PyQt6.QtWidgets import QCheckBox
-            self.hide_rois_checkbox = QCheckBox("Hide ROIs")
-            self.hide_rois_checkbox.stateChanged.connect(self._on_hide_rois_toggled)
-            roi_grid_layout.addWidget(self.hide_rois_checkbox, 3, 0, 1, 2)
-            
-            self.display_labels_checkbox = QCheckBox("Hide Labels")
-            self.display_labels_checkbox.stateChanged.connect(self._on_hide_labels_toggled)
-            roi_grid_layout.addWidget(self.display_labels_checkbox, 3, 1, 1, 2)
-        except Exception:
-            self.hide_rois_checkbox = None
-            self.display_labels_checkbox = None
+        self.display_labels_checkbox = QCheckBox("Hide Labels")
+        self.display_labels_checkbox.stateChanged.connect(self._on_hide_labels_toggled)
+        roi_grid_layout.addWidget(self.display_labels_checkbox, 3, 1)
         
         roi_vbox.addLayout(roi_grid_layout)
         roi_group.setLayout(roi_vbox)
@@ -202,18 +197,7 @@ class RoiListWidget(QWidget):
             except Exception:
                 pass
         else:
-            # Create new ROI - calculate next available ROI number
-            existing_numbers = []
-            for roi in self.main_window._saved_rois:
-                roi_name = roi.get('name', '')
-                if roi_name.startswith('ROI '):
-                    try:
-                        number = int(roi_name.split('ROI ')[1])
-                        existing_numbers.append(number)
-                    except (IndexError, ValueError):
-                        pass
-            
-            next_num = max(existing_numbers) + 1 if existing_numbers else 1
+            next_num = len(self.main_window._saved_rois) + 1
             name = f"ROI {next_num}"
             
             color = (

{phasor_handler-2.2.3 → phasor_handler-2.2.4}/phasor_handler/widgets/analysis/components/trace_plot.py

@@ -303,25 +303,58 @@ class TraceplotWidget(QWidget):
         self.trace_ax.cla()
 
         # Compute metric depending on available channels and selected formula
-        # If red channel missing, switch to (Fg - Fo)/Fo (index 1) and disable other choices
+        # If red channel missing, show only single-channel formulas
         if sig2 is None:
-            # Single-channel data: use (Fg - Fo)/Fo
-            try:
-                # set dropdown to index 1 (Fg - Fo / Fo) but do not allow changing it
-                if self.formula_dropdown.count() > 1:
-                    # If index argument was provided override, respect it, otherwise set selection
-                    if index is None:
-                        self.formula_dropdown.setCurrentIndex(1)
-                self.formula_dropdown.setEnabled(False)
-            except Exception:
-                pass
+            # Single-channel data: limit dropdown to (Fg - Fo)/Fo and raw Fg only
+            # Only modify dropdown if it currently has more than 2 items (switching from dual to single channel)
+            if self.formula_dropdown.count() > 2:
+                self.formula_dropdown.blockSignals(True)
+                current_index = self.formula_dropdown.currentIndex()
+                
+                # Clear and repopulate with single-channel options only
+                self.formula_dropdown.clear()
+                self.formula_dropdown.addItem("(Fg - Fog) / Fog")  # Index 0 for single channel
+                self.formula_dropdown.addItem("Fg only")            # Index 1 for single channel
+                
+                # Set appropriate default selection based on previous selection
+                if current_index == 2:  # Was "Fg only"
+                    self.formula_dropdown.setCurrentIndex(1)
+                else:  # Default to (Fg - Fog) / Fog
+                    self.formula_dropdown.setCurrentIndex(0)
+                
+                self.formula_dropdown.blockSignals(False)
+                print("DEBUG: Switched to single-channel formula dropdown")
 
-            # Safe denom: avoid division by zero
-            denom_val = Fog if (Fog is not None and Fog != 0) else 1e-6
-            metric = (sig1 - Fog) / denom_val
+            # Calculate metric based on selected formula
+            formula_index = self.formula_dropdown.currentIndex() if index is None else index
+            if formula_index == 1:  # Fg only (raw)
+                metric = sig1
+            else:  # (Fg - Fog) / Fog (default, index 0)
+                denom_val = Fog if (Fog is not None and Fog != 0) else 1e-6
+                metric = (sig1 - Fog) / denom_val
         else:
-            # Two-channel data: enable formula selection
-            self.formula_dropdown.setEnabled(True)
+            # Two-channel data: restore all formula options
+            # Only modify dropdown if it currently has 2 items (switching from single to dual channel)
+            if self.formula_dropdown.count() == 2:
+                self.formula_dropdown.blockSignals(True)
+                current_index = self.formula_dropdown.currentIndex()
+                
+                # Clear and repopulate with all formula options
+                self.formula_dropdown.clear()
+                self.formula_dropdown.addItem("Fg - Fog / Fr")      # Index 0
+                self.formula_dropdown.addItem("Fg - Fog / Fog")     # Index 1
+                self.formula_dropdown.addItem("Fg only")            # Index 2
+                self.formula_dropdown.addItem("Fr only")            # Index 3
+                
+                # Restore appropriate selection based on previous selection
+                if current_index == 1:  # Was "Fg only" in single-channel mode
+                    self.formula_dropdown.setCurrentIndex(2)  # Set to "Fg only" in two-channel mode
+                else:  # Was "(Fg - Fog) / Fog"
+                    self.formula_dropdown.setCurrentIndex(1)  # Keep as "(Fg - Fog) / Fog"
+                
+                self.formula_dropdown.blockSignals(False)
+                print("DEBUG: Switched to dual-channel formula dropdown")
+            
             formula_index = self.formula_dropdown.currentIndex() if index is None else index
             if formula_index == 0:
                 denom = sig2.copy().astype(np.float32)
@@ -377,16 +410,61 @@ class TraceplotWidget(QWidget):
                                     print(f"DEBUG: First few time stamps: {time_stamps[:min(5, len(time_stamps))]}")
                                 break
                 
-                if time_stamps is not None and len(time_stamps) >= len(metric):
-                    # Use time stamps as x-axis (convert from ms to seconds)
-                    x_values = np.array(time_stamps[:len(metric)]) / 1000.0
-                    x_label = "Time (s)"
-                    # Convert current frame position to time
-                    if current_frame < len(time_stamps):
-                        current_x_pos = time_stamps[current_frame] / 1000.0
+                # Check if we have valid time stamps (not empty and has enough data)
+                has_valid_timestamps = (time_stamps is not None and 
+                                       hasattr(time_stamps, '__len__') and 
+                                       len(time_stamps) > 0 and
+                                       len(time_stamps) >= len(metric))
+                
+                if has_valid_timestamps:
+                    # Parse time stamps - they could be numbers (ms or seconds) or datetime strings
+                    time_array = np.array(time_stamps[:len(metric)])
+                    
+                    # Check if timestamps are strings (datetime format) or numbers
+                    if isinstance(time_stamps[0], str):
+                        # Parse datetime strings and convert to relative seconds
+                        from datetime import datetime
+                        try:
+                            # Parse the datetime strings
+                            dt_objects = []
+                            for ts in time_stamps[:len(metric)]:
+                                # Handle format like '2025-10-26 19:08:38.626'
+                                dt = datetime.strptime(ts, '%Y-%m-%d %H:%M:%S.%f')
+                                dt_objects.append(dt)
+                            
+                            # Convert to seconds relative to first timestamp
+                            first_dt = dt_objects[0]
+                            x_values = np.array([(dt - first_dt).total_seconds() for dt in dt_objects])
+                            print(f"DEBUG: Parsed datetime timestamps, duration: {x_values[-1]:.2f}s")
+                        except Exception as e:
+                            print(f"DEBUG: Error parsing datetime strings: {e}")
+                            # Fall back to frame numbers
+                            show_time = False
+                            x_values = None
                     else:
-                        current_x_pos = time_stamps[-1] / 1000.0 if len(time_stamps) > 0 else current_frame
-                    print(f"DEBUG: Using time stamps for x-axis (converted from ms), current position: {current_x_pos}s")
+                        # Numeric timestamps - detect if milliseconds or seconds
+                        max_time = np.max(time_array) if len(time_array) > 0 else 0
+                        
+                        # Heuristic: if max time > 10000, assume milliseconds; otherwise seconds
+                        if max_time > 10000:
+                            # Data is in milliseconds, convert to seconds
+                            x_values = time_array / 1000.0
+                            print(f"DEBUG: Time stamps appear to be in milliseconds (max={max_time:.2f}), converting to seconds")
+                        else:
+                            # Data is already in seconds (or very short recording in ms)
+                            x_values = time_array
+                            print(f"DEBUG: Time stamps appear to be in seconds (max={max_time:.2f})")
+                    
+                    if x_values is not None:
+                        x_label = "Time (s)"
+                        
+                        # Convert current frame position to time
+                        if current_frame < len(x_values):
+                            current_x_pos = x_values[current_frame]
+                        else:
+                            current_x_pos = x_values[-1] if len(x_values) > 0 else current_frame
+                        
+                        print(f"DEBUG: Using time stamps for x-axis, current position: {current_x_pos}s")
                 else:
                     # Fallback: estimate time based on frame rate (if available)
                     frame_rate = getattr(ed, 'frame_rate', None) if ed else None
@@ -432,14 +510,38 @@ class TraceplotWidget(QWidget):
                 print(f"DEBUG: Found {len(stims)} stimulation timeframes: {stims}")
 
             # Convert stimulation timeframes to appropriate x-axis units
-            if show_time and x_values is not None:
-                # Convert stim frames to time positions (from ms to seconds)
-                for stim in stims:
-                    stim_frame = int(stim)
-                    if stim_frame < len(time_stamps):
-                        stim_x_pos = time_stamps[stim_frame] / 1000.0
-                        print(f"DEBUG: Adding stimulation vline at time {stim_x_pos:.2f}s (frame {stim_frame})")
-                        self.trace_ax.axvline(stim_x_pos, color='red', linestyle='--', zorder=15, linewidth=2)
+            if show_time and x_values is not None and time_stamps is not None:
+                # Handle both datetime strings and numeric timestamps
+                if isinstance(time_stamps[0], str):
+                    # Parse datetime strings for stimulation times
+                    from datetime import datetime
+                    try:
+                        first_dt = datetime.strptime(time_stamps[0], '%Y-%m-%d %H:%M:%S.%f')
+                        for stim in stims:
+                            stim_frame = int(stim)
+                            if stim_frame < len(time_stamps):
+                                stim_dt = datetime.strptime(time_stamps[stim_frame], '%Y-%m-%d %H:%M:%S.%f')
+                                stim_x_pos = (stim_dt - first_dt).total_seconds()
+                                print(f"DEBUG: Adding stimulation vline at time {stim_x_pos:.2f}s (frame {stim_frame})")
+                                self.trace_ax.axvline(stim_x_pos, color='red', linestyle='--', zorder=15, linewidth=2)
+                    except Exception as e:
+                        print(f"DEBUG: Error parsing datetime for stimulation: {e}")
+                else:
+                    # Numeric timestamps - detect format
+                    time_array = np.array(time_stamps)
+                    max_time = np.max(time_array) if len(time_array) > 0 else 0
+                    is_milliseconds = max_time > 10000
+                    
+                    # Convert stim frames to time positions
+                    for stim in stims:
+                        stim_frame = int(stim)
+                        if stim_frame < len(time_stamps):
+                            if is_milliseconds:
+                                stim_x_pos = time_stamps[stim_frame] / 1000.0
+                            else:
+                                stim_x_pos = time_stamps[stim_frame]
+                            print(f"DEBUG: Adding stimulation vline at time {stim_x_pos:.2f}s (frame {stim_frame})")
+                            self.trace_ax.axvline(stim_x_pos, color='red', linestyle='--', zorder=15, linewidth=2)
             else:
                 # Use frame numbers
                 for stim in stims:
@@ -538,8 +640,27 @@ class TraceplotWidget(QWidget):
                                 time_stamps = getattr(ed, attr_name)
                                 break
                 
-                if time_stamps is not None and current_frame < len(time_stamps):
-                    current_x_pos = time_stamps[current_frame] / 1000.0
+                if time_stamps is not None and len(time_stamps) > 0 and current_frame < len(time_stamps):
+                    # Handle both datetime strings and numeric timestamps
+                    if isinstance(time_stamps[0], str):
+                        # Parse datetime strings
+                        from datetime import datetime
+                        try:
+                            first_dt = datetime.strptime(time_stamps[0], '%Y-%m-%d %H:%M:%S.%f')
+                            current_dt = datetime.strptime(time_stamps[current_frame], '%Y-%m-%d %H:%M:%S.%f')
+                            current_x_pos = (current_dt - first_dt).total_seconds()
+                        except Exception:
+                            # Fall back to frame rate if parsing fails
+                            pass
+                    else:
+                        # Numeric timestamps - detect if milliseconds or seconds
+                        max_time = np.max(time_stamps) if len(time_stamps) > 0 else 0
+                        if max_time > 10000:
+                            # Data is in milliseconds, convert to seconds
+                            current_x_pos = time_stamps[current_frame] / 1000.0
+                        else:
+                            # Data is already in seconds
+                            current_x_pos = time_stamps[current_frame]
                 elif ed is not None:
                     # Fallback: estimate time based on frame rate
                     if isinstance(ed, dict):
@@ -575,7 +696,28 @@ class TraceplotWidget(QWidget):
                                     break
                         
                         if time_stamps is not None and len(time_stamps) > 0:
-                            xmax = max(np.array(time_stamps[:min(nframes, len(time_stamps))]) / 1000.0)
+                            # Handle both datetime strings and numeric timestamps
+                            if isinstance(time_stamps[0], str):
+                                # Parse datetime strings
+                                from datetime import datetime
+                                try:
+                                    first_dt = datetime.strptime(time_stamps[0], '%Y-%m-%d %H:%M:%S.%f')
+                                    last_idx = min(nframes, len(time_stamps)) - 1
+                                    last_dt = datetime.strptime(time_stamps[last_idx], '%Y-%m-%d %H:%M:%S.%f')
+                                    xmax = (last_dt - first_dt).total_seconds()
+                                except Exception:
+                                    xmax = max(1, nframes - 1)
+                            else:
+                                # Numeric timestamps - detect if milliseconds or seconds
+                                time_array = np.array(time_stamps[:min(nframes, len(time_stamps))])
+                                max_time = np.max(time_array) if len(time_array) > 0 else 0
+                                
+                                if max_time > 10000:
+                                    # Data is in milliseconds, convert to seconds
+                                    xmax = max(time_array / 1000.0)
+                                else:
+                                    # Data is already in seconds
+                                    xmax = max(time_array)
                         elif ed is not None:
                             frame_rate = getattr(ed, 'frame_rate', None)
                             if frame_rate and frame_rate > 0:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phasor-handler
-Version: 2.2.3
+Version: 2.2.4
 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.3 → phasor_handler-2.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phasor-handler"
-version = "2.2.3"
+version = "2.2.4"
 authors = [{ name = "Josia Shemuel", email = "joshemuel@users.noreply.github.com" }]
 description = "A PyQt6 GUI toolbox for processing two-photon phasor imaging data"
 readme = "README.md"