phasor-handler 2.2.0__py3-none-any.whl

phasor_handler/__init__.py

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

phasor_handler/app.py

@@ -0,0 +1,249 @@
+import sys
+import subprocess
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QPushButton, QFileDialog, QMessageBox, 
+    QListView, QTreeView, QAbstractItemView, QTabWidget
+)
+from PyQt6.QtGui import QFileSystemModel, QIcon
+from PyQt6.QtCore import Qt
+from PyQt6.QtCore import QThread
+
+from .widgets import ConversionWidget, RegistrationWidget, AnalysisWidget
+from .tools import misc
+from .workers import RegistrationWorker
+from .models.dir_manager import DirManager
+from .themes import apply_dark_theme
+import qdarktheme
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Phasor Handler v2.0")
+        self.setWindowIcon(QIcon('img/logo.ico'))
+        # self.setMinimumSize(1400, 1000)
+        # central directory manager (shared with widgets)
+        self.dir_manager = DirManager()
+        # expose legacy attribute for compatibility
+        self.selected_dirs = self.dir_manager.list()
+        # keep the local list synced when dir_manager changes
+        self.dir_manager.directoriesChanged.connect(lambda lst: setattr(self, 'selected_dirs', list(lst)))
+
+        # Create tab widget and add sub-widgets
+        self.tabs = QTabWidget()
+        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.currentChanged.connect(self.on_tab_changed)
+        self.setCentralWidget(self.tabs)
+
+    def _init_roi_state(self):
+        """Initialize ROI and CNB (contrast/brightness) state on the window instance."""
+        self._roi_center = None
+        self._roi_radius = None
+        self._roi_overlay_pixmap = None
+
+        # CNB (contrast & brightness) state
+        self._current_qimage = None
+        self._current_image_np = None
+        self._cnb_window = None
+        
+        # ImageJ-like: min/max intensity (applied before contrast)
+        self._cnb_min = None
+        self._cnb_max = None
+
+        # contrast multiplier around midpoint (1.0 = no change)
+        self._cnb_contrast = 1.0
+
+        # Master switch to disable/enable CNB functionality (default: disabled)
+        self._cnb_active = False
+
+
+    def add_dirs_dialog(self, tab):
+        dialog = QFileDialog(self)
+        dialog.setWindowTitle('Select One or More Directories')
+        dialog.setFileMode(QFileDialog.FileMode.Directory)
+        dialog.setOption(QFileDialog.Option.DontUseNativeDialog, True)
+        for view in dialog.findChildren((QListView, QTreeView)):
+            if isinstance(view.model(), QFileSystemModel):
+                view.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        if dialog.exec():
+            selected_paths = dialog.selectedFiles()
+            # delegate to the manager
+            self.dir_manager.add(selected_paths)
+            # refresh views (manager emits signal which can call refresh_dir_lists)
+            self.refresh_dir_lists()
+        dialog.deleteLater()
+
+    def remove_selected_dirs(self, tab):
+        widget = self.conv_list_widget if tab == 'conversion' else self.reg_list_widget if tab == "registration" else self.analysis_list_widget
+        selected_items = widget.selectedItems()
+        if not selected_items:
+            return
+        to_remove = []
+        for item in selected_items:
+            # Get the full path from UserRole, fallback to text for compatibility
+            full_path = item.data(Qt.ItemDataRole.UserRole)
+            if full_path is None:
+                full_path = item.text()
+            to_remove.append(full_path)
+        # update model; UI will refresh on signal
+        self.dir_manager.remove(to_remove)
+        self.refresh_dir_lists()
+
+    def refresh_dir_lists(self):
+        # Clear only if the widgets exist and are valid
+        if hasattr(self, 'conv_list_widget'):
+            self.conv_list_widget.clear()
+        if hasattr(self, 'reg_list_widget'):
+            try:
+                self.reg_list_widget.clear()
+            except RuntimeError:
+                # Widget was deleted; recreate the Registration tab if needed
+                pass
+        if hasattr(self, 'analysis_list_widget'):
+            self.analysis_list_widget.clear()
+
+        from PyQt6.QtWidgets import QListWidgetItem
+        for full_path, display_name in self.dir_manager.get_display_names():
+            if hasattr(self, 'conv_list_widget'):
+                item = QListWidgetItem(display_name)
+                item.setToolTip(full_path)
+                item.setData(Qt.ItemDataRole.UserRole, full_path)
+                self.conv_list_widget.addItem(item)
+            if hasattr(self, 'reg_list_widget'):
+                try:
+                    item = QListWidgetItem(display_name)
+                    item.setToolTip(full_path)
+                    item.setData(Qt.ItemDataRole.UserRole, full_path)
+                    self.reg_list_widget.addItem(item)
+                except RuntimeError:
+                    pass
+            if hasattr(self, 'analysis_list_widget'):
+                item = QListWidgetItem(display_name)
+                item.setToolTip(full_path)
+                item.setData(Qt.ItemDataRole.UserRole, full_path)
+                self.analysis_list_widget.addItem(item)
+
+    def on_tab_changed(self, idx):
+        # When switching to analysis tab, refresh its directory list
+        tab_text = self.tabs.tabText(idx)
+        if tab_text == "Analysis":
+            if hasattr(self, 'analysis_list_widget'):
+                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)
+
+    def run_conversion_script(self):
+        if not self.selected_dirs:
+            QMessageBox.warning(self, "No Directories", "Please add at least one directory to the list before running.")
+            return
+
+        mode = self.mode_combo.currentText().lower()
+        self.conv_log.clear()
+        self.conv_log.append(f"--- Starting Batch Conversion in '{mode}' mode ---\n")
+        for i, conv_dir in enumerate(self.selected_dirs):
+            self.conv_log.append(f"Processing ({i+1}/{len(self.selected_dirs)}): {conv_dir}")
+            # 1. Run convert.py
+            cmd = [sys.executable, "scripts/convert.py", str(conv_dir), "--mode", mode]
+            try:
+                proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0)
+                for line in proc.stdout:
+                    self.conv_log.append(line.rstrip())
+                    QApplication.processEvents()
+                retcode = proc.wait()
+                if retcode != 0:
+                    self.conv_log.append(f"FAILED to convert: {conv_dir}\n")
+                else:
+                    self.conv_log.append("--- Conversion done ---\n")
+            except Exception as e:
+                self.conv_log.append(f"FAILED to convert: {conv_dir} (Error: {e})\n")
+                continue
+
+            # 2. Run meta_reader.py
+            meta_cmd = [sys.executable, "scripts/meta_reader.py", "-f", str(conv_dir)]
+            self.conv_log.append(f"\n[meta_reader] Reading metadata for: {conv_dir}")
+            try:
+                meta_proc = subprocess.Popen(meta_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0)
+                for line in meta_proc.stdout:
+                    self.conv_log.append(line.rstrip())
+                    QApplication.processEvents()
+                meta_retcode = meta_proc.wait()
+                if meta_retcode != 0:
+                    self.conv_log.append(f"FAILED to read metadata: {conv_dir}\n")
+                else:
+                    self.conv_log.append("--- Metadata read done ---\n")
+            except Exception as e:
+                self.conv_log.append(f"FAILED to read metadata: {conv_dir} (Error: {e})\n")
+                continue
+        self.conv_log.append("--- Batch Conversion Finished ---")
+
+    def run_registration_script(self):
+        # Gather inputs and start a background worker so the GUI doesn't block
+        selected_dirs = []
+        for i in range(self.reg_list_widget.count()):
+            item = self.reg_list_widget.item(i)
+            if item is not None:
+                # Get full path from UserRole, fallback to text for compatibility
+                full_path = item.data(Qt.ItemDataRole.UserRole)
+                if full_path is None:
+                    full_path = item.text()
+                selected_dirs.append(full_path)
+        if not selected_dirs:
+            QMessageBox.warning(self, "No Directories", "Please add at least one directory to the list before running registration.")
+            return
+
+        params = {}
+        for name, edit in zip(self.param_names, self.param_edits):
+            value = edit.text().strip()
+            if value:
+                params[name] = value
+
+        # Disable UI controls while running
+        # Find the run button by text (safe because we created it nearby)
+        run_btn = None
+        for w in self.findChildren(QPushButton):
+            if w.text().startswith("Run Registration"):
+                run_btn = w
+                break
+        if run_btn:
+            run_btn.setEnabled(False)
+
+        self.reg_log.clear()
+
+        # Create thread and worker
+        self._reg_thread = QThread()
+        self._reg_worker = RegistrationWorker(selected_dirs, params, self.combine_checkbox.isChecked())
+        self._reg_worker.moveToThread(self._reg_thread)
+        # Connect signals
+        self._reg_thread.started.connect(self._reg_worker.run)
+        self._reg_worker.log.connect(lambda s: (self.reg_log.append(s), QApplication.processEvents()))
+        def _on_finished():
+            if run_btn:
+                run_btn.setEnabled(True)
+            self._reg_thread.quit()
+            self._reg_thread.wait()
+            self._reg_worker.deleteLater()
+            del self._reg_worker
+            del self._reg_thread
+
+        self._reg_worker.finished.connect(_on_finished)
+        self._reg_worker.error.connect(lambda e: self.reg_log.append(f"ERROR: {e}"))
+        self._reg_thread.start()
+
+def main():
+    app = QApplication(sys.argv)
+    try:
+        qdarktheme.setup_theme("auto")  # or your own apply_dark_theme()
+    except Exception:
+        pass  # fall back to default if theme package missing
+    window = MainWindow()
+    window.showMaximized()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

phasor_handler/img/icons/chevron-down.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path fill="white" d="M7.41 8.59L12 13.17l4.59-4.58L18 10l-6 6-6-6z"/>
+</svg>

phasor_handler/img/icons/chevron-up.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+  <path fill="white" d="M7.41 15.41L12 10.83l4.59 4.58L18 14l-6-6-6 6z"/>
+</svg>

phasor_handler/models/dir_manager.py

@@ -0,0 +1,100 @@
+from PyQt6.QtCore import QObject, pyqtSignal
+from pathlib import Path
+
+
+class DirManager(QObject):
+    """Manage a shared list of directories and notify listeners on changes.
+
+    This keeps directory logic separate from GUI widgets. Listeners should
+    connect to `directoriesChanged` and call `list()` to get the current value.
+    """
+    directoriesChanged = pyqtSignal(list)
+
+    def __init__(self, dirs=None, parent=None):
+        super().__init__(parent)
+        self._dirs = list(dirs) if dirs else []
+
+    def add(self, paths):
+        changed = False
+        for p in paths:
+            if p not in self._dirs:
+                self._dirs.append(p)
+                changed = True
+        if changed:
+            self.directoriesChanged.emit(self.list())
+
+    def remove(self, paths):
+        changed = False
+        for p in paths:
+            if p in self._dirs:
+                self._dirs.remove(p)
+                changed = True
+        if changed:
+            self.directoriesChanged.emit(self.list())
+
+    def clear(self):
+        if self._dirs:
+            self._dirs = []
+            self.directoriesChanged.emit([])
+
+    def list(self):
+        return list(self._dirs)
+    
+    def get_display_names(self):
+        """Return a list of (full_path, display_name) tuples.
+        
+        Display names show just the folder stem unless there are duplicates,
+        in which case enough parent folders are included to distinguish them.
+        """
+        if not self._dirs:
+            return []
+        
+        # Convert paths to Path objects for easier manipulation
+        paths = [Path(d) for d in self._dirs]
+        
+        # Start with just stems
+        display_map = {}
+        for i, p in enumerate(paths):
+            stem = p.name
+            if stem not in display_map:
+                display_map[stem] = []
+            display_map[stem].append((i, p))
+        
+        # For duplicates, add parent folders until unique
+        result = {}
+        for stem, path_list in display_map.items():
+            if len(path_list) == 1:
+                # No duplicates, use just the stem
+                idx, path = path_list[0]
+                result[idx] = stem
+            else:
+                # Duplicates found, need to differentiate
+                # Start with 2 levels (parent/stem) and increase until unique
+                max_depth = max(len(p.parts) for _, p in path_list)
+                
+                for depth in range(2, max_depth + 1):
+                    temp_names = {}
+                    all_unique = True
+                    
+                    for idx, path in path_list:
+                        # Get the last 'depth' parts of the path
+                        parts = path.parts[-depth:] if len(path.parts) >= depth else path.parts
+                        display_name = str(Path(*parts))
+                        
+                        if display_name in temp_names:
+                            all_unique = False
+                            break
+                        temp_names[display_name] = idx
+                    
+                    if all_unique:
+                        # Found unique names at this depth
+                        for display_name, idx in temp_names.items():
+                            result[idx] = display_name
+                        break
+                else:
+                    # If we still have duplicates after max depth, use full paths
+                    for idx, path in path_list:
+                        result[idx] = str(path)
+        
+        # Return in original order
+        return [(self._dirs[i], result[i]) for i in range(len(self._dirs))]

phasor_handler/scripts/contrast.py

@@ -0,0 +1,131 @@
+"""Contrast and brightness helpers (ImageJ-style).
+
+Public functions:
+- ij_auto_contrast(img, saturated=0.35) -> np.ndarray (float32 0..1)
+- compute_cnb_min_max(img) -> (min, max)
+- apply_cnb_to_uint8(img, lo, hi, contrast=1.0) -> np.ndarray (uint8)
+- qimage_from_uint8(img_u8) -> QImage
+
+Notes:
+- ImageJ’s “Auto” = clip ~saturated% at each tail, then linear map to [0..1].
+- For composites: call ij_auto_contrast() per channel, then compose RGB yourself.
+"""
+from typing import Tuple
+import numpy as np
+
+
+def _finite(a: np.ndarray) -> np.ndarray:
+    """Return a flattened view of finite values only (ignore NaN/inf)."""
+    a = np.asarray(a)
+    if not np.issubdtype(a.dtype, np.number):
+        a = a.astype(np.float32, copy=False)
+    a = a.ravel()
+    if np.issubdtype(a.dtype, np.floating):
+        a = a[np.isfinite(a)]
+    return a
+
+
+def ij_auto_contrast(img, saturated: float = 0.35) -> np.ndarray:
+    """ImageJ-like auto contrast for a SINGLE-channel image.
+    Returns a float32 array scaled to 0..1.
+
+    Implementation detail:
+    - Uses percentiles (saturated% low, saturated% high) to set lo/hi.
+    - Works for 8/16-bit integers and floats (NaN/inf ignored).
+    """
+    a = np.asarray(img)
+    if a.size == 0:
+        return a.astype(np.float32)
+
+    vals = _finite(a)
+    if vals.size == 0:
+        return np.zeros_like(a, dtype=np.float32)
+
+    # Symmetric tail clip (ImageJ “Auto” default ≈ 0.35% each tail)
+    low_p = float(saturated)
+    high_p = 100.0 - float(saturated)
+
+    lo, hi = np.percentile(vals, [low_p, high_p])
+    if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo:
+        # Degenerate data (flat image, NaNs, etc.)
+        out = np.zeros_like(a, dtype=np.float32)
+        return out
+
+    out = (a.astype(np.float32) - float(lo)) / (float(hi) - float(lo))
+    np.clip(out, 0.0, 1.0, out=out)
+    return out
+
+
+def compute_cnb_min_max(img: np.ndarray) -> Tuple[float, float]:
+    """Compute min/max display window from data (handles grayscale or RGB).
+    For RGB, uses luminance (like a typical preview), but in ImageJ you’d
+    normally calculate per channel. Use this mainly for a default guess.
+    """
+    if img is None:
+        return 0.0, 255.0
+    a = np.asarray(img)
+    if a.size == 0:
+        return 0.0, 0.0
+
+    if a.ndim == 3 and a.shape[2] >= 3:
+        # Perceived luminance (ITU-R BT.601)
+        lum = (0.299 * a[..., 0] + 0.587 * a[..., 1] + 0.114 * a[..., 2]).ravel()
+        vals = _finite(lum)
+    else:
+        vals = _finite(a)
+
+    if vals.size == 0:
+        return 0.0, 0.0
+
+    return float(vals.min()), float(vals.max())
+
+
+def apply_cnb_to_uint8(img: np.ndarray, lo: float, hi: float, contrast: float = 1.0) -> np.ndarray:
+    """Apply min/max (window) mapping and contrast around mid-gray; return uint8.
+
+    - img: input array (H,W) or (H,W,C). For ImageJ behavior, pass a SINGLE channel
+      (e.g., green or red) and compose RGB yourself afterwards.
+    - lo, hi: display window [lo..hi] in source units (like ImageJ’s min/max).
+    - contrast: multiplier around 0.5 after normalization (1.0 = no change).
+
+    Returns uint8 of same shape (alpha dropped if present).
+    """
+    a = np.asarray(img).astype(np.float32, copy=False)
+    if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo:
+        # fallback to trivial map
+        if a.size == 0:
+            return np.zeros_like(a, dtype=np.uint8)
+        vmin, vmax = float(np.nanmin(a)), float(np.nanmax(a))
+        if not np.isfinite(vmin) or not np.isfinite(vmax) or vmax <= vmin:
+            out = np.zeros_like(a, dtype=np.uint8)
+            return out
+        lo, hi = vmin, vmax
+
+    # Window/level mapping
+    out = (a - float(lo)) / (float(hi) - float(lo))
+    # Contrast around midpoint (display-domain, same feel as IJ slider)
+    out = 0.5 + (out - 0.5) * float(contrast)
+    np.clip(out, 0.0, 1.0, out=out)
+
+    img_u8 = (out * 255.0).astype(np.uint8)
+    if img_u8.ndim == 3 and img_u8.shape[2] >= 4:
+        img_u8 = img_u8[..., :3]  # drop alpha if any
+    return img_u8
+
+
+def qimage_from_uint8(img_u8):
+    """Build a PyQt6 QImage from a uint8 numpy array without channel swapping.
+    Accepts 2D (grayscale) or 3D (RGB) arrays. Caller owns array lifetime while QImage lives.
+    """
+    from PyQt6.QtGui import QImage
+
+    img_u8 = np.ascontiguousarray(img_u8)  # ensure row stride is compact/consistent
+    h, w = img_u8.shape[:2]
+
+    if img_u8.ndim == 2 or (img_u8.ndim == 3 and img_u8.shape[2] == 1):
+        fmt = QImage.Format.Format_Grayscale8
+        return QImage(img_u8.data, w, h, img_u8.strides[0], fmt)
+    else:
+        # Expect RGB order; no BGR swap!
+        fmt = QImage.Format.Format_RGB888
+        return QImage(img_u8.data, w, h, img_u8.strides[0], fmt)

phasor_handler/scripts/convert.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+convert.py
+
+Given a SINGLE directory (e.g., StreamingPhasorCapture-...), this script
+finds and concatenates .npy stacks for Ch0 and Ch1.
+
+It saves the output TIFF inside the INPUT directory.
+
+The default mode is 'interleaved': [Ch0[0], Ch1[0], Ch0[1], Ch1[1], ...]
+"""
+
+import argparse
+import os
+import re
+import sys
+from typing import List, Dict
+import numpy as np
+import tifffile
+
+
+def natural_key(s: str):
+    """Natural sort key: 'file10' after 'file2'."""
+    return [int(text) if text.isdigit() else text.lower()
+            for text in re.split(r'(\d+)', s)]
+
+
+def list_channel_files(folder_path: str, prefix: str, ext: str = ".npy") -> List[str]:
+    """Finds all files in a folder with a given prefix and extension."""
+    files = [fn for fn in os.listdir(folder_path)
+             if fn.startswith(prefix) and fn.endswith(ext)]
+    files.sort(key=natural_key)
+    return [os.path.join(folder_path, fn) for fn in files]
+
+
+def load_and_concat(files: List[str]) -> np.ndarray:
+    """Load .npy arrays and concatenate along axis=0 (time)."""
+    arrays = []
+    for fp in files:
+        try:
+            arr = np.load(fp, mmap_mode="r")
+            arrays.append(arr)
+        except Exception as e:
+            print(f"[WARN] Skipping '{fp}': {e}", file=sys.stderr)
+    if not arrays:
+        return None
+    # Verify all image stacks have the same XY dimensions
+    ref_shape = arrays[0].shape[1:]
+    for i, a in enumerate(arrays):
+        if a.shape[1:] != ref_shape:
+            raise ValueError(f"Shape mismatch in {files[i]}: {a.shape} vs {arrays[0].shape}")
+    return np.concatenate(arrays, axis=0)
+
+
+def subfolder_basename(folder_path: str) -> str:
+    """Generates a base filename from the folder path."""
+    folder_name = os.path.basename(os.path.normpath(folder_path))
+    parts = folder_name.split("-")
+    return "-".join(parts[:2]) if len(parts) >= 2 else folder_name
+
+
+def write_tiff(out_path: str, data: np.ndarray, force_dtype: str = "uint16"):
+    """Writes a NumPy array to a BigTIFF file."""
+    if data is None:
+        raise ValueError("No image data to write.")
+    if force_dtype:
+        data = data.astype(force_dtype, copy=False)
+    tifffile.imwrite(out_path, data, bigtiff=True)
+    print(f"[OK] Saved {out_path}  "
+          f"(frames={data.shape[0]}, shape={data.shape[1:]}, dtype={data.dtype})")
+
+
+def process_single_folder(folder_path: str,
+                           ch0_prefix: str = "ImageData_Ch0",
+                           ch1_prefix: str = "ImageData_Ch1",
+                           ext: str = ".npy",
+                           mode: str = "interleaved",
+                           dtype: str = "uint16"):
+    """Processes .npy files in a single directory."""
+    if not os.path.isdir(folder_path):
+        raise NotADirectoryError(f"Input path is not a valid directory: {folder_path}")
+
+    ch0_files = list_channel_files(folder_path, ch0_prefix, ext)
+    ch1_files = list_channel_files(folder_path, ch1_prefix, ext)
+
+    if not ch0_files and not ch1_files:
+        print(f"[INFO] No '{ch0_prefix}*' or '{ch1_prefix}*' files found in {folder_path}.")
+        return
+
+    ch_data: Dict[str, np.ndarray] = {}
+    if ch0_files:
+        ch0_result = load_and_concat(ch0_files)
+        if ch0_result is not None:
+            ch_data["Ch0"] = ch0_result
+    if ch1_files:
+        ch1_result = load_and_concat(ch1_files)
+        if ch1_result is not None:
+            ch_data["Ch1"] = ch1_result
+
+    if len(ch_data) == 0:
+        print(f"[WARN] No usable image data loaded from {folder_path}.")
+        return
+
+    # Verify that channel spatial dimensions match
+    shapes = {k: v.shape[1:] for k, v in ch_data.items() if v is not None}
+    if len(set(shapes.values())) > 1:
+        raise ValueError(f"Channel spatial shape mismatch in '{folder_path}': {shapes}")
+
+    save_array = None
+
+    if mode == "interleaved":
+        if "Ch0" in ch_data and "Ch1" in ch_data:
+            ch0, ch1 = ch_data["Ch0"], ch_data["Ch1"]
+            if ch0.shape[0] != ch1.shape[0]:
+                raise ValueError(f"Frame count mismatch: Ch0 has {ch0.shape[0]} frames, Ch1 has {ch1.shape[0]}")
+            n_frames = ch0.shape[0]
+            interleaved = np.empty((n_frames * 2, *ch0.shape[1:]), dtype=ch0.dtype)
+            interleaved[0::2] = ch0
+            interleaved[1::2] = ch1
+            save_array = interleaved
+        else:
+            save_array = ch_data.get("Ch0")
+            if save_array is None:
+                save_array = ch_data.get("Ch1")
+    elif mode == "block":
+        concat_list = [ch_data[k] for k in ("Ch0", "Ch1") if k in ch_data]
+        save_array = np.concatenate(concat_list, axis=0)
+    else:
+        raise ValueError(f"Unknown mode: {mode}")
+
+    base = subfolder_basename(folder_path)
+    # The output TIFF is saved directly inside the input directory
+    out_path = os.path.join(folder_path, f"{base}.tif")
+    write_tiff(out_path, save_array, force_dtype=dtype)
+
+
+def main():
+    p = argparse.ArgumentParser(description="Convert .npy stacks from a single Phasor directory to a TIFF.")
+    p.add_argument("directory", help="Path to the single 'StreamingPhasorCapture*' folder containing .npy files.")
+    p.add_argument("--mode", choices=["interleaved", "block"], default="interleaved",
+                   help="Channel arrangement. Default is 'interleaved'.")
+    args = p.parse_args()
+
+    try:
+        process_single_folder(
+            folder_path=os.path.abspath(args.directory),
+            mode=args.mode
+        )
+    except Exception as e:
+        print(f"[FATAL] {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()