canns 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

canns/pipeline/asa_gui/analysis_modes/pathcompare_mode.py

@@ -0,0 +1,199 @@
+"""PathCompare analysis mode."""
+
+from __future__ import annotations
+
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QSpinBox,
+    QWidget,
+)
+
+from ..views.widgets.popup_combo import PopupComboBox
+from .base import AbstractAnalysisMode, configure_form_layout
+
+
+class PathCompareMode(AbstractAnalysisMode):
+    name = "pathcompare"
+    display_name = "Path Compare (CohoMap required)"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("PathCompare Parameters")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.angle_scale = PopupComboBox()
+        self.angle_scale.addItems(["auto", "rad", "deg", "unit"])
+        self.angle_scale.setCurrentText("auto")
+
+        self.dim_mode = PopupComboBox()
+        self.dim_mode.addItem("2D", userData="2d")
+        self.dim_mode.addItem("1D", userData="1d")
+        self.dim_mode.setCurrentIndex(0)
+
+        self.dim = QSpinBox()
+        self.dim.setRange(1, 10)
+        self.dim.setValue(1)
+
+        self.dim1 = QSpinBox()
+        self.dim1.setRange(1, 10)
+        self.dim1.setValue(1)
+
+        self.dim2 = QSpinBox()
+        self.dim2.setRange(1, 10)
+        self.dim2.setValue(2)
+
+        self.use_box = QCheckBox("Use coordsbox / times_box")
+        self.use_box.setChecked(False)
+
+        self.interp_full = QCheckBox("Interpolate to full trajectory")
+        self.interp_full.setChecked(True)
+        self.interp_full.setEnabled(False)
+
+        self.coords_key = QLineEdit()
+        self.coords_key.setPlaceholderText("coords / coordsbox (optional)")
+        self.times_key = QLineEdit()
+        self.times_key.setPlaceholderText("times_box (optional)")
+
+        self.slice_mode = PopupComboBox()
+        self.slice_mode.addItem("Time (tmin/tmax)", userData="time")
+        self.slice_mode.addItem("Index (imin/imax)", userData="index")
+        self.slice_mode.setCurrentIndex(0)
+
+        self.tmin = QDoubleSpinBox()
+        self.tmin.setRange(-1e9, 1e9)
+        self.tmin.setDecimals(4)
+        self.tmin.setValue(-1.0)
+
+        self.tmax = QDoubleSpinBox()
+        self.tmax.setRange(-1e9, 1e9)
+        self.tmax.setDecimals(4)
+        self.tmax.setValue(-1.0)
+
+        self.imin = QSpinBox()
+        self.imin.setRange(-1, 1_000_000_000)
+        self.imin.setValue(-1)
+
+        self.imax = QSpinBox()
+        self.imax.setRange(-1, 1_000_000_000)
+        self.imax.setValue(-1)
+
+        self.stride = QSpinBox()
+        self.stride.setRange(1, 100000)
+        self.stride.setValue(1)
+
+        self.tail = QSpinBox()
+        self.tail.setRange(0, 100000)
+        self.tail.setValue(200)
+
+        self.fps = QSpinBox()
+        self.fps.setRange(1, 240)
+        self.fps.setValue(30)
+
+        self.no_wrap = QCheckBox("Disable angle wrap")
+        self.no_wrap.setChecked(False)
+
+        self.save_gif = QCheckBox("Save GIF")
+        self.save_gif.setChecked(False)
+
+        form.addRow("Dim mode", self.dim_mode)
+
+        self._dims1d_label = QLabel("Dim")
+        dims_1d = QWidget()
+        dims_1d_layout = QHBoxLayout(dims_1d)
+        dims_1d_layout.setContentsMargins(0, 0, 0, 0)
+        dims_1d_layout.addWidget(self.dim)
+        dims_1d_layout.addStretch(1)
+
+        self._dims2d_label = QLabel("Dim X / Dim Y")
+        dims_2d = QWidget()
+        dims_2d_layout = QHBoxLayout(dims_2d)
+        dims_2d_layout.setContentsMargins(0, 0, 0, 0)
+        dims_2d_layout.addWidget(QLabel("dim1"))
+        dims_2d_layout.addWidget(self.dim1)
+        dims_2d_layout.addSpacing(8)
+        dims_2d_layout.addWidget(QLabel("dim2"))
+        dims_2d_layout.addWidget(self.dim2)
+        dims_2d_layout.addStretch(1)
+
+        form.addRow(self._dims1d_label, dims_1d)
+        form.addRow(self._dims2d_label, dims_2d)
+        form.addRow(self.use_box)
+        form.addRow(self.interp_full)
+        form.addRow("coords key", self.coords_key)
+        form.addRow("times key", self.times_key)
+        form.addRow("Slice mode", self.slice_mode)
+        form.addRow("tmin (sec, -1=auto)", self.tmin)
+        form.addRow("tmax (sec, -1=auto)", self.tmax)
+        form.addRow("imin (-1=auto)", self.imin)
+        form.addRow("imax (-1=auto)", self.imax)
+        form.addRow("stride", self.stride)
+        form.addRow("tail (frames)", self.tail)
+        form.addRow("fps", self.fps)
+        form.addRow("theta scale", self.angle_scale)
+        form.addRow(self.no_wrap)
+        form.addRow(self.save_gif)
+
+        def _refresh_dim_mode() -> None:
+            mode = str(self.dim_mode.currentData() or "2d")
+            is_1d = mode == "1d"
+            self._dims1d_label.setVisible(is_1d)
+            dims_1d.setVisible(is_1d)
+            self._dims2d_label.setVisible(not is_1d)
+            dims_2d.setVisible(not is_1d)
+
+        def _refresh_enabled() -> None:
+            use_box = bool(self.use_box.isChecked())
+            self.interp_full.setEnabled(use_box)
+
+        def _refresh_slice_mode() -> None:
+            is_time = self.slice_mode.currentData() == "time"
+            self.tmin.setEnabled(is_time)
+            self.tmax.setEnabled(is_time)
+            self.imin.setEnabled(not is_time)
+            self.imax.setEnabled(not is_time)
+
+        self.dim_mode.currentIndexChanged.connect(_refresh_dim_mode)
+        self.use_box.toggled.connect(_refresh_enabled)
+        self.slice_mode.currentIndexChanged.connect(_refresh_slice_mode)
+        _refresh_dim_mode()
+        _refresh_enabled()
+        _refresh_slice_mode()
+
+        return box
+
+    def collect_params(self) -> dict:
+        tmin = float(self.tmin.value())
+        tmax = float(self.tmax.value())
+        imin = int(self.imin.value())
+        imax = int(self.imax.value())
+        tmin = None if tmin < 0 else tmin
+        tmax = None if tmax < 0 else tmax
+        imin = None if imin < 0 else imin
+        imax = None if imax < 0 else imax
+        return {
+            "angle_scale": str(self.angle_scale.currentText()),
+            "dim_mode": str(self.dim_mode.currentData() or "2d"),
+            "dim": int(self.dim.value()),
+            "dim1": int(self.dim1.value()),
+            "dim2": int(self.dim2.value()),
+            "use_box": bool(self.use_box.isChecked()),
+            "interp_full": bool(self.interp_full.isChecked()),
+            "coords_key": self.coords_key.text().strip() or None,
+            "times_key": self.times_key.text().strip() or None,
+            "slice_mode": str(self.slice_mode.currentData() or "time"),
+            "tmin": tmin,
+            "tmax": tmax,
+            "imin": imin,
+            "imax": imax,
+            "stride": int(self.stride.value()),
+            "tail": int(self.tail.value()),
+            "fps": int(self.fps.value()),
+            "no_wrap": bool(self.no_wrap.isChecked()),
+            "animation_format": "gif" if self.save_gif.isChecked() else "none",
+        }

canns/pipeline/asa_gui/analysis_modes/tda_mode.py

@@ -0,0 +1,112 @@
+"""TDA analysis mode."""
+
+from __future__ import annotations
+
+from PySide6.QtWidgets import QCheckBox, QFormLayout, QGroupBox, QSpinBox
+
+from ..views.widgets.popup_combo import PopupComboBox
+from .base import AbstractAnalysisMode, configure_form_layout
+
+
+class TDAMode(AbstractAnalysisMode):
+    name = "tda"
+    display_name = "TDA"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("TDA parameters")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.dim = QSpinBox()
+        self.dim.setRange(1, 50)
+        self.dim.setValue(6)
+        self.dim.setToolTip("PCA 维度（常见起点 6–12）。")
+
+        self.num_times = QSpinBox()
+        self.num_times.setRange(1, 50)
+        self.num_times.setValue(5)
+        self.num_times.setToolTip("时间下采样步长；越大越快但可能丢细节。")
+
+        self.active_times = QSpinBox()
+        self.active_times.setRange(1, 10_000_000)
+        self.active_times.setValue(15000)
+        self.active_times.setToolTip("选取最活跃时间点数；过小不稳，过大更慢。")
+
+        self.k = QSpinBox()
+        self.k.setRange(1, 200_000)
+        self.k.setValue(1000)
+        self.k.setToolTip("采样/去噪相关参数，影响速度与稳定性。")
+
+        self.n_points = QSpinBox()
+        self.n_points.setRange(10, 500_000)
+        self.n_points.setValue(1200)
+        self.n_points.setToolTip("点云代表点数量，越大越慢。")
+
+        self.metric = PopupComboBox()
+        self.metric.addItems(["cosine", "euclidean", "manhattan"])
+        self.metric.setToolTip("距离度量；推荐 cosine。")
+
+        self.nbs = QSpinBox()
+        self.nbs.setRange(1, 200_000)
+        self.nbs.setValue(800)
+        self.nbs.setToolTip("邻域规模参数，影响稳定性与速度。")
+
+        self.maxdim = QSpinBox()
+        self.maxdim.setRange(0, 3)
+        self.maxdim.setValue(2)
+        self.maxdim.setToolTip("最大同调维度；先 1 再 2。")
+
+        self.coeff = QSpinBox()
+        self.coeff.setRange(2, 997)
+        self.coeff.setValue(47)
+        self.coeff.setToolTip("有限域系数（默认 47）。")
+
+        self.standardize = QCheckBox()
+        self.standardize.setChecked(True)
+
+        self.do_shuffle = QCheckBox()
+        self.do_shuffle.setChecked(False)
+        self.do_shuffle.setToolTip("显著性检验；代价高，建议少量。")
+
+        self.num_shuffles = QSpinBox()
+        self.num_shuffles.setRange(0, 5000)
+        self.num_shuffles.setValue(100)
+        self.num_shuffles.setEnabled(False)
+        self.do_shuffle.toggled.connect(self.num_shuffles.setEnabled)
+        self.num_shuffles.setToolTip("Shuffle 次数（越多越慢）。")
+
+        form.addRow("TDA dim", self.dim)
+        form.addRow("num_times", self.num_times)
+        form.addRow("active_times", self.active_times)
+        form.addRow("k (sampling)", self.k)
+        form.addRow("n_points", self.n_points)
+        form.addRow("metric", self.metric)
+        form.addRow("nbs", self.nbs)
+        form.addRow("maxdim", self.maxdim)
+        form.addRow("coeff", self.coeff)
+        form.addRow("Shuffle: Enable", self.do_shuffle)
+        form.addRow("num_shuffles", self.num_shuffles)
+
+        return box
+
+    def collect_params(self) -> dict:
+        return {
+            "dim": int(self.dim.value()),
+            "num_times": int(self.num_times.value()),
+            "active_times": int(self.active_times.value()),
+            "k": int(self.k.value()),
+            "n_points": int(self.n_points.value()),
+            "metric": str(self.metric.currentText()),
+            "nbs": int(self.nbs.value()),
+            "maxdim": int(self.maxdim.value()),
+            "coeff": int(self.coeff.value()),
+            "standardize": bool(self.standardize.isChecked()),
+            "do_shuffle": bool(self.do_shuffle.isChecked()),
+            "num_shuffles": int(self.num_shuffles.value()),
+        }
+
+    def apply_preset(self, preset: str) -> None:
+        if preset == "grid":
+            self.maxdim.setValue(2)
+        elif preset == "hd":
+            self.maxdim.setValue(1)

canns/pipeline/asa_gui/app.py

@@ -0,0 +1,29 @@
+"""Application bootstrap for ASA GUI."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QSettings
+from PySide6.QtWidgets import QApplication
+
+from .main_window import MainWindow
+from .resources import load_theme_qss
+
+
+class ASAGuiApp(MainWindow):
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self._apply_styles()
+
+    def _apply_styles(self) -> None:
+        try:
+            settings = QSettings("canns", "asa_gui")
+            theme = settings.value("theme", "Light")
+            qss = load_theme_qss(str(theme))
+            app = QApplication.instance()
+            app.setStyleSheet(qss)
+            font = app.font()
+            if font.pointSize() <= 0:
+                font.setPointSize(10)
+                app.setFont(font)
+        except Exception:
+            pass

canns/pipeline/asa_gui/controllers/__init__.py

@@ -0,0 +1,6 @@
+"""Controllers for ASA GUI."""
+
+from .analysis_controller import AnalysisController
+from .preprocess_controller import PreprocessController
+
+__all__ = ["AnalysisController", "PreprocessController"]

canns/pipeline/asa_gui/controllers/analysis_controller.py

@@ -0,0 +1,59 @@
+"""Controller for analysis workflow."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from PySide6.QtCore import QObject
+
+from ..core import PipelineRunner, StateManager
+
+
+class AnalysisController(QObject):
+    def __init__(self, state_manager: StateManager, runner: PipelineRunner, parent=None) -> None:
+        super().__init__(parent)
+        self._state_manager = state_manager
+        self._runner = runner
+
+    def update_analysis(self, *, analysis_mode: str, analysis_params: dict) -> None:
+        self._state_manager.batch_update(
+            analysis_mode=analysis_mode,
+            analysis_params=analysis_params,
+        )
+
+    def get_state(self):
+        return self._state_manager.state
+
+    def run_analysis(
+        self,
+        *,
+        worker_manager,
+        on_log: Callable[[str], None],
+        on_progress: Callable[[int], None],
+        on_finished: Callable[[object], None],
+        on_error: Callable[[str], None],
+        on_cleanup: Callable[[], None] | None = None,
+    ) -> None:
+        state = self._state_manager.state
+        self._state_manager.update(is_running=True, current_stage="analysis")
+
+        worker_manager.start(
+            self._runner.run_analysis,
+            state,
+            on_log=on_log,
+            on_progress=on_progress,
+            on_finished=on_finished,
+            on_error=on_error,
+            on_cleanup=on_cleanup,
+        )
+
+    def finalize_analysis(self, artifacts: dict) -> None:
+        self._state_manager.update(
+            artifacts=artifacts,
+            is_running=False,
+            current_stage="",
+            progress=0,
+        )
+
+    def mark_idle(self) -> None:
+        self._state_manager.update(is_running=False, current_stage="", progress=0)

canns/pipeline/asa_gui/controllers/preprocess_controller.py

@@ -0,0 +1,89 @@
+"""Controller for preprocessing workflow."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from PySide6.QtCore import QObject
+
+from ..core import PipelineRunner, StateManager
+from ..core.state import relative_path
+
+
+class PreprocessController(QObject):
+    def __init__(self, state_manager: StateManager, runner: PipelineRunner, parent=None) -> None:
+        super().__init__(parent)
+        self._state_manager = state_manager
+        self._runner = runner
+
+    def update_inputs(
+        self,
+        *,
+        input_mode: str,
+        preset: str,
+        asa_file: str | None,
+        neuron_file: str | None,
+        traj_file: str | None,
+        preprocess_method: str,
+        preprocess_params: dict,
+        preclass: str,
+        preclass_params: dict,
+    ) -> None:
+        state = self._state_manager.state
+        asa_path = self._to_path(asa_file)
+        neuron_path = self._to_path(neuron_file)
+        traj_path = self._to_path(traj_file)
+        self._state_manager.batch_update(
+            input_mode=input_mode,
+            preset=preset,
+            asa_file=relative_path(state, path=asa_path) if asa_path is not None else None,
+            neuron_file=relative_path(state, path=neuron_path) if neuron_path is not None else None,
+            traj_file=relative_path(state, path=traj_path) if traj_path is not None else None,
+            preprocess_method=preprocess_method,
+            preprocess_params=preprocess_params,
+            preclass=preclass,
+            preclass_params=preclass_params,
+        )
+
+    def run_preprocess(
+        self,
+        *,
+        worker_manager,
+        on_log: Callable[[str], None],
+        on_progress: Callable[[int], None],
+        on_finished: Callable[[object], None],
+        on_error: Callable[[str], None],
+        on_cleanup: Callable[[], None] | None = None,
+    ) -> None:
+        state = self._state_manager.state
+        self._state_manager.update(is_running=True, current_stage="preprocess")
+
+        worker_manager.start(
+            self._runner.run_preprocessing,
+            state,
+            on_log=on_log,
+            on_progress=on_progress,
+            on_finished=on_finished,
+            on_error=on_error,
+            on_cleanup=on_cleanup,
+        )
+
+    def finalize_preprocess(self) -> None:
+        self._state_manager.update(
+            embed_data=self._runner.embed_data,
+            aligned_pos=self._runner.aligned_pos,
+            is_running=False,
+            current_stage="",
+            progress=0,
+        )
+
+    def mark_idle(self) -> None:
+        self._state_manager.update(is_running=False, current_stage="", progress=0)
+
+    @staticmethod
+    def _to_path(path: str | None):
+        if path is None:
+            return None
+        from pathlib import Path
+
+        return Path(path)

canns/pipeline/asa_gui/core/__init__.py

@@ -0,0 +1,15 @@
+"""Core infrastructure for ASA GUI."""
+
+from .runner import PipelineResult, PipelineRunner, ProcessingError
+from .state import StateManager, WorkflowState
+from .worker import AnalysisWorker, WorkerManager
+
+__all__ = [
+    "PipelineResult",
+    "PipelineRunner",
+    "ProcessingError",
+    "StateManager",
+    "WorkflowState",
+    "AnalysisWorker",
+    "WorkerManager",
+]

canns/pipeline/asa_gui/core/cache.py

@@ -0,0 +1,14 @@
+"""Cache helpers for ASA GUI pipeline."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+
+def md5_file(path: Path) -> str:
+    md5 = hashlib.md5()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            md5.update(chunk)
+    return md5.hexdigest()