spatial-aim 1.3.0__tar.gz → 1.3.1__tar.gz

{spatial_aim-1.3.0 → spatial_aim-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatial-aim
-Version: 1.3.0
+Version: 1.3.1
 Summary: SpatialAIM — annotation-independent mapping of scRNA-seq references onto high-resolution spatial transcriptomics
 Author-email: Dominik Pysch <dominik.pysch@fau.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{spatial_aim-1.3.0 → spatial_aim-1.3.1}/src/spatial_aim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatial-aim
-Version: 1.3.0
+Version: 1.3.1
 Summary: SpatialAIM — annotation-independent mapping of scRNA-seq references onto high-resolution spatial transcriptomics
 Author-email: Dominik Pysch <dominik.pysch@fau.de>
 License:                     GNU GENERAL PUBLIC LICENSE

spatial_aim-1.3.1/src/spatial_aim.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.3.1",
+  "distance": 0,
+  "node": "ga41027f02b0a96f69bf54115cca3fbeeedd3640c",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-15"
+}

{spatial_aim-1.3.0 → spatial_aim-1.3.1}/src/spatialaim/gui/render/scatter.py

@@ -39,6 +39,13 @@ logger = logging.getLogger(__name__)
 # Grey (as a CSS rgba string) for spots drawn below the confidence threshold.
 _GREY_RGBA = "rgba(184,184,184,0.9)"
 
+# The spatial panel draws each state in up to _MAX_CHUNKS interleaved chunks (see
+# add_spatial_traces), capped at _MAX_STATE_TRACES traces in all: 20 chunks for a
+# handful of states is all but a random order, while a K of 50 still gets 4
+# without the panel turning into thousands of WebGL traces.
+_MAX_CHUNKS = 20
+_MAX_STATE_TRACES = 200
+
 # --- EXPERIMENTAL: per-state centroid markers on the UMAP panels --------------
 # Hand-set switch (see the question in the session that added this). When True,
 # each UMAP panel gets one diamond marker per state at the state's *expression
@@ -373,40 +380,54 @@ def add_spatial_traces(
             col=col,
         )
 
-    for state in sorted(np.unique(hard[keep]).tolist()):
-        mask = keep & (hard == state)
-        show = state not in legend_shown
-        legend_shown.add(state)
-        genes = top_genes_suffix(top_genes, state)
-        head = f"{state_label(state, names)}{genes}"
-        if confidence is not None:
-            customdata = confidence[mask][:, None]
-            hovertemplate = (
-                f"{head}<br>"
-                "confidence %{customdata[0]:.3f}<br>"
-                "x %{x:.1f}  y %{y:.1f}<extra></extra>"
-            )
-        else:
-            customdata = None
-            hovertemplate = f"{head}<br>x %{{x:.1f}}  y %{{y:.1f}}<extra></extra>"
-        fig.add_trace(
-            go.Scattergl(
-                x=coords[mask, 0],
-                y=coords[mask, 1],
-                mode="markers",
-                marker=dict(
-                    size=dot_size, color=hex_color(palette.get(state)), opacity=1.0
+    # Draw order decides which colour wins where spots overlap: one trace per
+    # state, stacked by state id, lets the last states cover the others however
+    # rare they are. So each state is split into random chunks and the chunks are
+    # drawn round-robin (state 0 chunk 0, state 1 chunk 0, ..., state 0 chunk 1,
+    # ...), which comes close to a random order spot by spot. Every chunk is still
+    # a trace in its state's legendgroup, so the headline widget's toggling,
+    # clicks and hover work unchanged; only the first chunk carries the legend
+    # entry. The seed is fixed, so a rerun draws the same picture.
+    states = sorted(np.unique(hard[keep]).tolist())
+    n_chunks = max(1, min(_MAX_CHUNKS, _MAX_STATE_TRACES // max(1, len(states))))
+    chunk = np.random.default_rng(0).integers(n_chunks, size=len(hard))
+    for c in range(n_chunks):
+        for state in states:
+            mask = keep & (hard == state) & (chunk == c)
+            if not mask.any():
+                continue
+            show = state not in legend_shown
+            legend_shown.add(state)
+            genes = top_genes_suffix(top_genes, state)
+            head = f"{state_label(state, names)}{genes}"
+            if confidence is not None:
+                customdata = confidence[mask][:, None]
+                hovertemplate = (
+                    f"{head}<br>"
+                    "confidence %{customdata[0]:.3f}<br>"
+                    "x %{x:.1f}  y %{y:.1f}<extra></extra>"
+                )
+            else:
+                customdata = None
+                hovertemplate = f"{head}<br>x %{{x:.1f}}  y %{{y:.1f}}<extra></extra>"
+            fig.add_trace(
+                go.Scattergl(
+                    x=coords[mask, 0],
+                    y=coords[mask, 1],
+                    mode="markers",
+                    marker=dict(
+                        size=dot_size, color=hex_color(palette.get(state)), opacity=1.0
+                    ),
+                    name=state_label(state, names),
+                    legendgroup=f"state{state}",
+                    showlegend=show,
+                    meta="spatial",
+                    customdata=customdata,
+                    hovertemplate=hovertemplate,
                 ),
-                name=state_label(state, names),
-                legendgroup=f"state{state}",
-                showlegend=show,
-                meta="spatial",
-                customdata=customdata,
-                hovertemplate=hovertemplate,
-            ),
-            row=row,
-            col=col,
-        )
+                row=row,
+                col=col,
+            )
 
     _pin_spatial_axes(fig, coords, row=row, col=col, equal_aspect=equal_aspect)
 

{spatial_aim-1.3.0 → spatial_aim-1.3.1}/src/spatialaim/gui/state_names.py

@@ -9,7 +9,11 @@ the same population whichever mapper placed it there. The names live in
     {"7": {"0": "Astrocytes", "3": "L2/3 IT"}, "12": {...}}
 
 Only the names actually set are stored; ``label`` falls back to ``Cell type <n>``
-for every other state, so a partly-named K is the normal case.
+for every other state, so a partly-named K is the normal case. A run started
+from an annotation (``--start_from_annotation``) is the exception at K = T (T =
+the number of annotated types): there the tree cut is the identity, so every
+state *is* one annotated type and defaults to that type's name
+(``annotation_names``); a name set by hand still wins.
 
 This is the GUI's only write path onto disk. Nothing in the sweep or the analysis
 reads the file -- losing it costs the labels and nothing else. Because the key is
@@ -22,8 +26,15 @@ from __future__ import annotations
 
 import json
 import logging
+from functools import lru_cache
 from pathlib import Path
 
+import pandas as pd
+
+from spatialaim.io import START_CLUSTER_TO_STATE_FILENAME, START_CLUSTERING_FILENAME
+
+from . import data_access
+
 logger = logging.getLogger(__name__)
 
 FILENAME = "cell_type_names.json"
@@ -52,8 +63,48 @@ def load_all(output_dir: Path) -> dict[str, dict[str, str]]:
     return data if isinstance(data, dict) else {}
 
 
-def load(output_dir: Path, k: int) -> dict[int, str]:
-    """``{state: name}`` for one K, holding only the states that have a name.
+def annotation_names(output_dir: Path, k: int) -> dict[int, str]:
+    """``{state: annotated type}`` when this output dir's runs start from an
+    annotation and ``k`` is T, the number of annotated types -- the level where
+    the tree cut is the identity, so each state is exactly one annotated type.
+    Empty for every other K, for Leiden starts, and when no run root has the
+    files yet. All mappers cut the same tree, so any run root serves."""
+    if data_access.start_from_annotation_from_config(output_dir) is None:
+        return {}
+    for root in sorted(Path(output_dir).glob("*/")):
+        clustering = root / START_CLUSTERING_FILENAME
+        cut = data_access.k_dir(root, k) / START_CLUSTER_TO_STATE_FILENAME
+        if clustering.exists() and cut.exists():
+            # mtimes in the key: a rerun into the same dir invalidates the cache.
+            return dict(
+                _annotation_names(
+                    str(clustering),
+                    str(cut),
+                    clustering.stat().st_mtime,
+                    cut.stat().st_mtime,
+                )
+            )
+    return {}
+
+
+@lru_cache(maxsize=32)
+def _annotation_names(
+    clustering: str, cut: str, _m1: float, _m2: float
+) -> tuple[tuple[int, str], ...]:
+    """``annotation_names`` for one run root's files (cached per file version)."""
+    names = data_access.load_start_cluster_names(Path(clustering).parent)
+    states = pd.read_csv(cut)["state"].to_numpy(dtype=int)
+    if (
+        names is None
+        or len(states) != len(names)
+        or int(states.max()) + 1 != len(names)
+    ):
+        return ()  # not the identity level: K != T
+    return tuple((int(s), n) for s, n in zip(states, names) if n)
+
+
+def _stored(output_dir: Path, k: int) -> dict[int, str]:
+    """``{state: name}`` for the names set by hand at this K.
 
     Tolerates hand-edits: entries with a non-numeric state or a blank name are
     skipped rather than surfacing as broken labels.
@@ -72,19 +123,28 @@ def load(output_dir: Path, k: int) -> dict[int, str]:
     return out
 
 
+def load(output_dir: Path, k: int) -> dict[int, str]:
+    """``{state: name}`` for one K, holding only the states that have a name:
+    the annotated type names at K = T of an annotation start
+    (``annotation_names``), overridden by any name set by hand."""
+    return annotation_names(output_dir, k) | _stored(output_dir, k)
+
+
 def save(output_dir: Path, k: int, names: dict[int, str]) -> None:
     """Replace this K's names, leaving every other K in the file untouched.
 
-    A blank name drops that state back to its default label instead of storing an
-    empty string, and a K with nothing left set drops out of the file entirely.
+    A blank name -- or one equal to the state's annotated type (see
+    ``annotation_names``) -- drops that state back to its default label instead
+    of being stored, and a K with nothing left set drops out of the file entirely.
     The write goes through a temp file and an atomic replace, so an interrupted
     save cannot leave a half-written file that would read back as no names at all.
     """
     data = load_all(output_dir)
+    defaults = annotation_names(output_dir, k)
     cleaned = {
         str(int(s)): n.strip()
         for s, n in names.items()
-        if isinstance(n, str) and n.strip()
+        if isinstance(n, str) and n.strip() and n.strip() != defaults.get(int(s))
     }
     if cleaned:
         data[str(int(k))] = cleaned
@@ -103,7 +163,7 @@ def set_name(output_dir: Path, k: int, state: int, name: str) -> None:
     """Set (or, when blank, clear) one state's name at this K, keeping the
     others -- the cell-type modal's write, through the same ``save`` as the
     all-states naming dialog."""
-    names = load(output_dir, k)
+    names = _stored(output_dir, k)
     names[int(state)] = name
     save(output_dir, k, names)
 

spatial_aim-1.3.0/src/spatial_aim.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.3.0",
-  "distance": 0,
-  "node": "g3ff1552b03833c77cdbaada6b0efd4e446c91b6a",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-14"
-}