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

canns/pipeline/asa_gui/analysis_modes/cohomap_mode.py

@@ -0,0 +1,56 @@
+"""CohoMap 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 CohoMapMode(AbstractAnalysisMode):
+    name = "cohomap"
+    display_name = "CohoMap (TDA + decode)"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("CohoMap Parameters")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.decode_version = PopupComboBox()
+        self.decode_version.addItems(["v2", "v0"])
+
+        self.num_circ = QSpinBox()
+        self.num_circ.setRange(1, 50)
+        self.num_circ.setValue(2)
+
+        self.real_ground = QCheckBox()
+        self.real_ground.setChecked(True)
+
+        self.real_of = QCheckBox()
+        self.real_of.setChecked(True)
+
+        self.subsample = QSpinBox()
+        self.subsample.setRange(1, 5000)
+        self.subsample.setValue(10)
+
+        form.addRow("Decode version", self.decode_version)
+        form.addRow("Decode num_circ", self.num_circ)
+        form.addRow("CohoMap subsample", self.subsample)
+
+        return box
+
+    def collect_params(self) -> dict:
+        return {
+            "decode_version": str(self.decode_version.currentText()),
+            "num_circ": int(self.num_circ.value()),
+            "real_ground": bool(self.real_ground.isChecked()),
+            "real_of": bool(self.real_of.isChecked()),
+            "cohomap_subsample": int(self.subsample.value()),
+        }
+
+    def apply_preset(self, preset: str) -> None:
+        if preset == "grid":
+            self.num_circ.setValue(2)
+        elif preset == "hd":
+            self.num_circ.setValue(1)

canns/pipeline/asa_gui/analysis_modes/cohospace_mode.py

@@ -0,0 +1,194 @@
+"""CohoSpace analysis mode."""
+
+from __future__ import annotations
+
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QSpinBox,
+    QWidget,
+)
+
+from ..views.widgets.popup_combo import PopupComboBox
+from .base import AbstractAnalysisMode, configure_form_layout
+
+
+class CohoSpaceMode(AbstractAnalysisMode):
+    name = "cohospace"
+    display_name = "CohoSpace / CohoScore"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("CohoSpace / CohoScore")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        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.mode = PopupComboBox()
+        self.mode.addItems(["spike", "fr"])
+        self.mode.setCurrentText("spike")
+
+        self.top_percent = QDoubleSpinBox()
+        self.top_percent.setRange(0.1, 50.0)
+        self.top_percent.setSingleStep(0.5)
+        self.top_percent.setValue(2.0)
+
+        self.view = PopupComboBox()
+        self.view.addItem("single neuron", userData="single")
+        self.view.addItem("all neurons (aggregate)", userData="population")
+        self.view.setCurrentIndex(0)
+
+        self.subsample = QSpinBox()
+        self.subsample.setRange(1, 100)
+        self.subsample.setValue(2)
+
+        self.unfold = PopupComboBox()
+        self.unfold.addItems(["square", "skew"])
+
+        self.skew_show_grid = QCheckBox("Skew: show grid")
+        self.skew_show_grid.setChecked(True)
+
+        self.skew_tiles = QSpinBox()
+        self.skew_tiles.setRange(0, 10)
+        self.skew_tiles.setValue(0)
+
+        self.top_k = QSpinBox()
+        self.top_k.setRange(1, 10_000_000)
+        self.top_k.setValue(10)
+
+        self.neuron_id = QSpinBox()
+        self.neuron_id.setRange(0, 1_000_000)
+        self.neuron_id.setValue(0)
+
+        self.btn_prev = QPushButton("←")
+        self.btn_next = QPushButton("→")
+        self.btn_show = QPushButton("Show")
+        self._neuron_row = QWidget()
+        neuron_row_layout = QHBoxLayout(self._neuron_row)
+        neuron_row_layout.setContentsMargins(0, 0, 0, 0)
+        neuron_row_layout.addWidget(self.btn_prev)
+        neuron_row_layout.addWidget(self.neuron_id, 1)
+        neuron_row_layout.addWidget(self.btn_next)
+        neuron_row_layout.addSpacing(8)
+        neuron_row_layout.addWidget(self.btn_show)
+
+        self.enable_score = QCheckBox("Compute CohoScore & top-K")
+        self.enable_score.setChecked(True)
+
+        self.use_best = QCheckBox("Use best neuron by CohoScore")
+        self.use_best.setChecked(True)
+
+        form.addRow("Dim mode", self.dim_mode)
+
+        self._dims1d_label = QLabel("Dim")
+        self._dims1d_wrap = QWidget()
+        dims_1d_layout = QHBoxLayout(self._dims1d_wrap)
+        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")
+        self._dims2d_wrap = QWidget()
+        dims_2d_layout = QHBoxLayout(self._dims2d_wrap)
+        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, self._dims1d_wrap)
+        form.addRow(self._dims2d_label, self._dims2d_wrap)
+        form.addRow("Unfold", self.unfold)
+        form.addRow("", self.skew_show_grid)
+        form.addRow("Skew tiles", self.skew_tiles)
+        form.addRow("Mode (spike / fr)", self.mode)
+        form.addRow("Top % (threshold)", self.top_percent)
+        form.addRow(self.enable_score)
+        form.addRow("View", self.view)
+        form.addRow("Top-K neurons", self.top_k)
+        form.addRow("Neuron id", self._neuron_row)
+        form.addRow("", self.use_best)
+
+        self.dim_mode.currentIndexChanged.connect(self._refresh_dim_mode)
+        self.view.currentIndexChanged.connect(self._refresh_view)
+        self.enable_score.toggled.connect(self._refresh_view)
+        self.btn_prev.clicked.connect(lambda: self._shift(-1))
+        self.btn_next.clicked.connect(lambda: self._shift(+1))
+        self._refresh_dim_mode()
+        self._refresh_view()
+
+        return box
+
+    def collect_params(self) -> dict:
+        return {
+            "dim_mode": str(self.dim_mode.currentData() or "2d"),
+            "dim": int(self.dim.value()),
+            "dim1": int(self.dim1.value()),
+            "dim2": int(self.dim2.value()),
+            "mode": str(self.mode.currentText()),
+            "top_percent": float(self.top_percent.value()),
+            "view": str(self.view.currentData() or "single"),
+            "subsample": int(self.subsample.value()),
+            "unfold": str(self.unfold.currentText()),
+            "skew_show_grid": bool(self.skew_show_grid.isChecked()),
+            "skew_tiles": int(self.skew_tiles.value()),
+            "neuron_id": int(self.neuron_id.value()),
+            "enable_score": bool(self.enable_score.isChecked()),
+            "top_k": int(self.top_k.value()),
+            "use_best": bool(self.use_best.isChecked()),
+        }
+
+    def apply_ranges(self, neuron_count: int | None, total_steps: int | None) -> None:
+        if neuron_count is None:
+            return
+        self.neuron_id.setRange(0, max(0, neuron_count - 1))
+        self.top_k.setMaximum(max(1, neuron_count))
+        if self.top_k.value() <= 0:
+            self.top_k.setValue(min(10, neuron_count))
+
+    def _refresh_dim_mode(self) -> None:
+        mode = str(self.dim_mode.currentData() or "2d")
+        is_1d = mode == "1d"
+        self._dims1d_label.setVisible(is_1d)
+        self._dims1d_wrap.setVisible(is_1d)
+        self._dims2d_label.setVisible(not is_1d)
+        self._dims2d_wrap.setVisible(not is_1d)
+        self.unfold.setEnabled(not is_1d)
+        self.skew_show_grid.setEnabled(not is_1d)
+        self.skew_tiles.setEnabled(not is_1d)
+
+    def _refresh_view(self) -> None:
+        view_single = str(self.view.currentData() or "single") == "single"
+        self.neuron_id.setEnabled(view_single)
+        self.btn_prev.setEnabled(view_single)
+        self.btn_next.setEnabled(view_single)
+        self.btn_show.setEnabled(view_single)
+        self.use_best.setEnabled(bool(self.enable_score.isChecked()))
+        self.top_k.setEnabled(bool(self.enable_score.isChecked()))
+
+    def _shift(self, delta: int) -> None:
+        val = self.neuron_id.value() + int(delta)
+        val = max(self.neuron_id.minimum(), min(self.neuron_id.maximum(), val))
+        self.neuron_id.setValue(val)

canns/pipeline/asa_gui/analysis_modes/decode_mode.py

@@ -0,0 +1,52 @@
+"""Decode 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 DecodeMode(AbstractAnalysisMode):
+    name = "decode"
+    display_name = "Decode"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("Decode Parameters")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.decode_version = PopupComboBox()
+        self.decode_version.addItems(["v2", "v0"])
+
+        self.num_circ = QSpinBox()
+        self.num_circ.setRange(1, 10)
+        self.num_circ.setValue(2)
+
+        self.real_ground = QCheckBox()
+        self.real_ground.setChecked(True)
+
+        self.real_of = QCheckBox()
+        self.real_of.setChecked(True)
+
+        form.addRow("decode_version", self.decode_version)
+        form.addRow("num_circ", self.num_circ)
+        form.addRow("real_ground", self.real_ground)
+        form.addRow("real_of", self.real_of)
+
+        return box
+
+    def collect_params(self) -> dict:
+        return {
+            "decode_version": str(self.decode_version.currentText()),
+            "num_circ": int(self.num_circ.value()),
+            "real_ground": bool(self.real_ground.isChecked()),
+            "real_of": bool(self.real_of.isChecked()),
+        }
+
+    def apply_preset(self, preset: str) -> None:
+        if preset == "grid":
+            self.num_circ.setValue(2)
+        elif preset == "hd":
+            self.num_circ.setValue(1)

canns/pipeline/asa_gui/analysis_modes/fr_mode.py

@@ -0,0 +1,81 @@
+"""FR analysis mode."""
+
+from __future__ import annotations
+
+from PySide6.QtWidgets import QFormLayout, QGroupBox, QSpinBox
+
+from ..views.widgets.popup_combo import PopupComboBox
+from .base import AbstractAnalysisMode, configure_form_layout
+
+
+class FRMode(AbstractAnalysisMode):
+    name = "fr"
+    display_name = "FR Heatmap"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("FR (population heatmap)")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.neuron_start = QSpinBox()
+        self.neuron_start.setRange(0, 1_000_000)
+        self.neuron_start.setValue(0)
+
+        self.neuron_end = QSpinBox()
+        self.neuron_end.setRange(0, 1_000_000)
+        self.neuron_end.setValue(0)
+
+        self.time_start = QSpinBox()
+        self.time_start.setRange(0, 10_000_000)
+        self.time_start.setValue(0)
+
+        self.time_end = QSpinBox()
+        self.time_end.setRange(0, 10_000_000)
+        self.time_end.setValue(0)
+
+        self.normalize = PopupComboBox()
+        self.normalize.addItems(["none", "zscore_per_neuron", "minmax_per_neuron"])
+        self.normalize.setCurrentText("none")
+
+        self.mode = PopupComboBox()
+        self.mode.addItems(["fr", "spike"])
+        self.mode.setToolTip("Use 'fr' for firing-rate matrix (requires preprocessing).")
+
+        form.addRow("FR neuron_start", self.neuron_start)
+        form.addRow("FR neuron_end", self.neuron_end)
+        form.addRow("FR t_start", self.time_start)
+        form.addRow("FR t_end", self.time_end)
+        form.addRow("FR mode", self.mode)
+        form.addRow("FR normalize", self.normalize)
+
+        return box
+
+    def collect_params(self) -> dict:
+        neuron_start = int(self.neuron_start.value())
+        neuron_end = int(self.neuron_end.value())
+        time_start = int(self.time_start.value())
+        time_end = int(self.time_end.value())
+        neuron_range = None
+        time_range = None
+        if neuron_end > neuron_start:
+            neuron_range = (neuron_start, neuron_end)
+        if time_end > time_start:
+            time_range = (time_start, time_end)
+        return {
+            "neuron_range": neuron_range,
+            "time_range": time_range,
+            "normalize": str(self.normalize.currentText()),
+            "mode": str(self.mode.currentText()),
+        }
+
+    def apply_ranges(self, neuron_count: int | None, total_steps: int | None) -> None:
+        if neuron_count is not None:
+            self.neuron_start.setRange(0, max(0, neuron_count - 1))
+            self.neuron_end.setRange(0, neuron_count)
+            if self.neuron_end.value() == 0:
+                self.neuron_end.setValue(neuron_count)
+        if total_steps is not None:
+            self.time_start.setRange(0, max(0, total_steps - 1))
+            self.time_end.setRange(0, total_steps)
+            if self.time_end.value() == 0:
+                self.time_end.setValue(total_steps)

canns/pipeline/asa_gui/analysis_modes/frm_mode.py

@@ -0,0 +1,92 @@
+"""FRM analysis mode."""
+
+from __future__ import annotations
+
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QPushButton,
+    QSpinBox,
+    QWidget,
+)
+
+from ..views.widgets.popup_combo import PopupComboBox
+from .base import AbstractAnalysisMode, configure_form_layout
+
+
+class FRMMode(AbstractAnalysisMode):
+    name = "frm"
+    display_name = "FRM (single neuron)"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("FRM (single neuron)")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.neuron_id = QSpinBox()
+        self.neuron_id.setRange(0, 1_000_000)
+        self.neuron_id.setValue(0)
+
+        self.bin_size = QSpinBox()
+        self.bin_size.setRange(5, 500)
+        self.bin_size.setValue(50)
+
+        self.min_occupancy = QSpinBox()
+        self.min_occupancy.setRange(1, 10_000)
+        self.min_occupancy.setValue(1)
+
+        self.smoothing = QCheckBox()
+        self.smoothing.setChecked(False)
+
+        self.smooth_sigma = QDoubleSpinBox()
+        self.smooth_sigma.setRange(0.1, 50.0)
+        self.smooth_sigma.setSingleStep(0.1)
+        self.smooth_sigma.setValue(1.0)
+
+        self.mode = PopupComboBox()
+        self.mode.addItems(["fr", "spike"])
+        self.mode.setToolTip("Use 'fr' for firing-rate matrix (requires preprocessing).")
+
+        self.btn_prev = QPushButton("←")
+        self.btn_next = QPushButton("→")
+        neuron_row = QWidget()
+        neuron_row_layout = QHBoxLayout(neuron_row)
+        neuron_row_layout.setContentsMargins(0, 0, 0, 0)
+        neuron_row_layout.addWidget(self.btn_prev)
+        neuron_row_layout.addWidget(self.neuron_id, 1)
+        neuron_row_layout.addWidget(self.btn_next)
+
+        self.btn_prev.clicked.connect(lambda: self._shift(-1))
+        self.btn_next.clicked.connect(lambda: self._shift(+1))
+
+        form.addRow("FRM neuron_id", neuron_row)
+        form.addRow("FRM bins", self.bin_size)
+        form.addRow("FRM min_occupancy", self.min_occupancy)
+        form.addRow("FRM smoothing", self.smoothing)
+        form.addRow("FRM sigma", self.smooth_sigma)
+        form.addRow("FRM mode", self.mode)
+
+        return box
+
+    def collect_params(self) -> dict:
+        return {
+            "neuron_id": int(self.neuron_id.value()),
+            "bin_size": int(self.bin_size.value()),
+            "min_occupancy": int(self.min_occupancy.value()),
+            "smoothing": bool(self.smoothing.isChecked()),
+            "smooth_sigma": float(self.smooth_sigma.value()),
+            "mode": str(self.mode.currentText()),
+        }
+
+    def apply_ranges(self, neuron_count: int | None, total_steps: int | None) -> None:
+        if neuron_count is None:
+            return
+        self.neuron_id.setRange(0, max(0, neuron_count - 1))
+
+    def _shift(self, delta: int) -> None:
+        val = self.neuron_id.value() + int(delta)
+        val = max(self.neuron_id.minimum(), min(self.neuron_id.maximum(), val))
+        self.neuron_id.setValue(val)

canns/pipeline/asa_gui/analysis_modes/gridscore_mode.py

@@ -0,0 +1,123 @@
+"""GridScore analysis modes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from PySide6.QtWidgets import QCheckBox, QDoubleSpinBox, QFormLayout, QGroupBox, QSpinBox
+
+from ..views.widgets.popup_combo import PopupComboBox
+from .base import AbstractAnalysisMode, configure_form_layout
+
+
+class GridScoreMode(AbstractAnalysisMode):
+    name = "gridscore"
+    display_name = "Grid Score (classic)"
+
+    def create_params_widget(self) -> QGroupBox:
+        box = QGroupBox("Grid Score (classic)")
+        form = QFormLayout(box)
+        configure_form_layout(form)
+
+        self.neuron_start = QSpinBox()
+        self.neuron_start.setRange(0, 10_000_000)
+        self.neuron_start.setValue(0)
+
+        self.neuron_end = QSpinBox()
+        self.neuron_end.setRange(0, 10_000_000)
+        self.neuron_end.setValue(0)
+
+        self.bins = QSpinBox()
+        self.bins.setRange(5, 500)
+        self.bins.setValue(50)
+
+        self.min_occupancy = QSpinBox()
+        self.min_occupancy.setRange(1, 10_000)
+        self.min_occupancy.setValue(1)
+
+        self.smoothing = QCheckBox()
+        self.smoothing.setChecked(False)
+
+        self.sigma = QDoubleSpinBox()
+        self.sigma.setRange(0.1, 50.0)
+        self.sigma.setSingleStep(0.1)
+        self.sigma.setValue(1.0)
+
+        self.overlap = QDoubleSpinBox()
+        self.overlap.setRange(0.1, 1.0)
+        self.overlap.setSingleStep(0.05)
+        self.overlap.setValue(0.8)
+
+        self.mode = PopupComboBox()
+        self.mode.addItems(["fr", "spike"])
+        self.mode.setToolTip("Use 'fr' for firing-rate maps (requires preprocessing).")
+
+        self.score_thr = QDoubleSpinBox()
+        self.score_thr.setRange(-2.0, 2.0)
+        self.score_thr.setSingleStep(0.05)
+        self.score_thr.setValue(0.3)
+
+        self.neuron_id = QSpinBox()
+        self.neuron_id.setRange(0, 10_000_000)
+        self.neuron_id.setValue(0)
+
+        form.addRow("neuron_start", self.neuron_start)
+        form.addRow("neuron_end", self.neuron_end)
+        form.addRow("bins", self.bins)
+        form.addRow("min_occupancy", self.min_occupancy)
+        form.addRow("smoothing", self.smoothing)
+        form.addRow("sigma", self.sigma)
+        form.addRow("autocorr overlap", self.overlap)
+        form.addRow("mode", self.mode)
+        form.addRow("score threshold (viz)", self.score_thr)
+
+        return box
+
+    def collect_params(self) -> dict:
+        return {
+            "gridscore": {
+                "neuron_start": int(self.neuron_start.value()),
+                "neuron_end": int(self.neuron_end.value()),
+                "bins": int(self.bins.value()),
+                "min_occupancy": int(self.min_occupancy.value()),
+                "smoothing": bool(self.smoothing.isChecked()),
+                "sigma": float(self.sigma.value()),
+                "overlap": float(self.overlap.value()),
+                "mode": str(self.mode.currentText()),
+                "score_thr": float(self.score_thr.value()),
+                "neuron_id": int(self.neuron_id.value()),
+            }
+        }
+
+    def apply_ranges(self, neuron_count: int | None, total_steps: int | None) -> None:
+        if neuron_count is None:
+            return
+        max_neuron = max(0, neuron_count - 1)
+        self.neuron_start.setRange(0, max_neuron)
+        self.neuron_end.setRange(0, neuron_count)
+        if self.neuron_end.value() == 0:
+            self.neuron_end.setValue(neuron_count)
+        self.neuron_id.setRange(0, max_neuron)
+
+    def apply_meta(self, meta: dict[str, Any]) -> None:
+        if not isinstance(meta, dict):
+            return
+        if "bins" in meta:
+            self.bins.setValue(int(meta["bins"]))
+        if "min_occupancy" in meta:
+            self.min_occupancy.setValue(int(meta["min_occupancy"]))
+        if "smoothing" in meta:
+            self.smoothing.setChecked(bool(meta["smoothing"]))
+        if "sigma" in meta:
+            self.sigma.setValue(float(meta["sigma"]))
+        if "overlap" in meta:
+            self.overlap.setValue(float(meta["overlap"]))
+        if "mode" in meta:
+            self.mode.setCurrentText(str(meta["mode"]))
+        if "neuron_id" in meta:
+            self.neuron_id.setValue(int(meta["neuron_id"]))
+
+
+class GridScoreInspectMode(GridScoreMode):
+    name = "gridscore_inspect"
+    display_name = "GridScore Inspect"