From 8e1e42fb036a21c8cc3921afe98102e215f536af Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 22 Apr 2026 12:28:42 +0100 Subject: [PATCH 01/23] add ruff --- uv.lock | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/uv.lock b/uv.lock index 5ac5111..280c94c 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 3 +revision = 2 requires-python = ">=3.12" [[package]] @@ -1468,6 +1468,7 @@ docs = [ { name = "mkdocs-material" }, { name = "mkdocstrings-python" }, { name = "pymdown-extensions" }, + { name = "ruff" }, ] lint = [ { name = "ruff" }, @@ -1534,6 +1535,7 @@ docs = [ { name = "mkdocs-material" }, { name = "mkdocstrings-python" }, { name = "pymdown-extensions" }, + { name = "ruff" }, ] lint = [{ name = "ruff" }] test = [ From 8dff9d89ff80abdbddce54fa5e1e995b42c83edc Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 22 Apr 2026 12:28:53 +0100 Subject: [PATCH 02/23] organise imports --- src/mesoscopy/process/__init__.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/mesoscopy/process/__init__.py b/src/mesoscopy/process/__init__.py index 8110796..656e332 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -22,16 +22,15 @@ """Processing submodule.""" import os + import click import numpy as np -import dask.array as da from pynwb.image import ImageSeries -import mesoscopy.timer as timer - -import mesoscopy.io as io import mesoscopy.process.smooth as psm import mesoscopy.process.zscore as pzs +from mesoscopy import io +from mesoscopy import timer @click.group("process") From 1f62d33a0a761c2e95bb8838efc3c70b2271e224 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 22 Apr 2026 18:15:41 +0100 Subject: [PATCH 03/23] add functions to return ABA array and annotations --- src/mesoscopy/resources/__init__.py | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/src/mesoscopy/resources/__init__.py b/src/mesoscopy/resources/__init__.py index 2409fda..a9656bc 100644 --- a/src/mesoscopy/resources/__init__.py +++ b/src/mesoscopy/resources/__init__.py @@ -20,6 +20,10 @@ # SOFTWARE. from importlib import resources +import imageio +import numpy as np +import pandas as pd + import mesoscopy.resources from mesoscopy import io @@ -30,10 +34,18 @@ def get_default_landmarks() -> dict: Returns: dict: Default landmark coordinates. """ - return io.read_points( - str( - resources.files(mesoscopy.resources).joinpath( - "ccf_template_landmarks_140x142.csv" - ) - ) + return io.read_points(str(resources.files(mesoscopy.resources).joinpath("ccf_template_landmarks_140x142.csv"))) + + +def get_atlas(): + left_hemisphere_aba = imageio.imread( + str(resources.files(mesoscopy.resources).joinpath("ccf_template_top_140x142.tiff")) + ) + right_hemisphere_aba = np.flip(left_hemisphere_aba, axis=1) + return left_hemisphere_aba, right_hemisphere_aba + + +def get_atlas_annotations(): + return pd.read_csv( + str(resources.files(mesoscopy.resources).joinpath("ccf_annotations.csv")), delimiter=", ", engine="python" ) From 3c64618bd2ff6bd7de890448f2a5d4e49401b908 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 22 Apr 2026 18:16:01 +0100 Subject: [PATCH 04/23] add function to return delta f for a specified region acronym --- src/mesoscopy/process/region.py | 69 +++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 src/mesoscopy/process/region.py diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py new file mode 100644 index 0000000..d3c725b --- /dev/null +++ b/src/mesoscopy/process/region.py @@ -0,0 +1,69 @@ +# Copyright (c) 2026 Constantinos Eleftheriou . +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of this +# software and associated documentation files (the "Software"), to deal in the +# Software without restriction, including without limitation the rights to use, copy, +# modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, +# and to permit persons to whom the Software is furnished to do so, subject to the +# following conditions: +# +# The above copyright notice and this permission notice shall be included in all copies +# or substantial portions of the Software +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +# IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import numpy as np +import numpy.typing as npt +import pandas as pd +from typing import Literal +from mesoscopy import resources + + +DEFAULT_EXCLUDE = [ + "FRP1", + "VISpl1", + "VISpor1", + "VISli1", + "TEa1", + "AUDd1", + "AUDp1", + "AUDpo1", + "AUDv1", + "ORBm1", +] + + +def extract_region_activity( + deltaf_series: npt.NDArray, region_acronym: str, hemisphere: Literal["left", "right", "both"] +) -> npt.NDArray: + annotations = resources.get_atlas_annotations() + region_id = annotations.loc[annotations["acronym"] == region_acronym, "id"].values[0] + + if not region_id: + msg = f"Region acronym {region_acronym} not recognised." + raise ValueError(msg) + + left_aba, right_aba = resources.get_atlas() + + if hemisphere.lower() == "left": + region_mask = np.broadcast_to(left_aba == region_id, deltaf_series.shape) + elif hemisphere.lower() == "right": + region_mask = np.broadcast_to(right_aba == region_id, deltaf_series.shape) + elif hemisphere.lower() == "both": + aba = left_aba + right_aba + region_mask = np.broadcast_to(aba == region_id, deltaf_series.shape) + else: + msg = f"Could not recognise hemisphere option {hemisphere}, select left, right or both." + raise ValueError(msg) + + return np.ma.array(deltaf_series, mask=~region_mask).mean(axis=(1, 2)) + + +def extract_all_regions(deltaf_series): ... From 585402630ad12c7a0bb5062e47acb091a14ee09a Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 22 Apr 2026 18:16:09 +0100 Subject: [PATCH 05/23] array masking exploration --- exploratory/array-masking.ipynb | 588 ++++++++++++++++++++++++++++++++ 1 file changed, 588 insertions(+) create mode 100644 exploratory/array-masking.ipynb diff --git a/exploratory/array-masking.ipynb b/exploratory/array-masking.ipynb new file mode 100644 index 0000000..f9693cd --- /dev/null +++ b/exploratory/array-masking.ipynb @@ -0,0 +1,588 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "81105d50", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from mesoscopy.resources import get_atlas, get_atlas_annotations\n", + "import matplotlib.pyplot as plt\n", + "from mesoscopy import io\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "98430049", + "metadata": {}, + "outputs": [], + "source": [ + "f = io.read_h5(\"../scratch/sub-test_exp-testexp_meso_date-2025-05-20T14_42_39_preprocessed_registered.h5\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "17ba4891", + "metadata": {}, + "outputs": [], + "source": [ + "l_aba, r_aba = get_atlas()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9fc92035", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16),\n", + " array([[0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l_aba" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f54c9a78", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "masked_array(\n", + " data=[[[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --]],\n", + "\n", + " ...,\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --]],\n", + "\n", + " [[--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " ...,\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --],\n", + " [--, --, --, ..., --, --, --]]],\n", + " mask=[[[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True]],\n", + "\n", + " ...,\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True]],\n", + "\n", + " [[ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " ...,\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True],\n", + " [ True, True, True, ..., True, True, True]]],\n", + " fill_value=np.float64(1e+20),\n", + " dtype=float32)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mask = np.broadcast_to(l_aba == 578, f[\"F\"].shape)\n", + "\n", + "np.ma.array(f[\"F\"], mask=~mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "994f3a73", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idacronymname
011SSp-ulPrimary somatosensory area upper limb
197AUDd1Dorsal auditory area
2104AUDp1Primary auditory area
3111AUDpo1Posterior auditory area
4118AUDv1Ventral auditory area
5395FRP1Frontal pole
6578MOp1Primary motor area
7584MOsSecondary motor area
8665ORBm1Orbital area medial part
9753PL1Prelimbic area
10866RSPagl1Retrosplenial area lateral agranular part
11872RSPd1Retrosplenial area dorsal part
12879RSPv1Retrosplenial area ventral part
13970SSp-bfd1Primary somatosensory area barrel field
14977SSp-ll1Primary somatosensory area lower limb
15984SSp-m1Primary somatosensory area mouth
16991SSp-n1Primary somatosensory area nose
17998SSp-tr1Primary somatosensory area trunk
181005SSp-ul1Primary somatosensory area upper limb
191012SSp-un1Primary somatosensory area unassigned
201019SSs1Supplemental somatosensory area
211060TEa1Temporal association areas
221125VISal1Anterolateral visual area
231132VISam1Anteromedial visual area
241139VISC1Visceral area
251146VISl1Lateral visual area
261153VISpPrimary visual area
271160VISpl1Posterolateral visual area
281167VISpmPosteromedial visual area
291207VISa1Anterior area
301214VISli1Laterointermediate area
311221VISpor1Postrhinal area
321228VISrl1Rostrolateral area
\n", + "
" + ], + "text/plain": [ + " id acronym name\n", + "0 11 SSp-ul Primary somatosensory area upper limb\n", + "1 97 AUDd1 Dorsal auditory area\n", + "2 104 AUDp1 Primary auditory area\n", + "3 111 AUDpo1 Posterior auditory area\n", + "4 118 AUDv1 Ventral auditory area\n", + "5 395 FRP1 Frontal pole\n", + "6 578 MOp1 Primary motor area\n", + "7 584 MOs Secondary motor area\n", + "8 665 ORBm1 Orbital area medial part\n", + "9 753 PL1 Prelimbic area\n", + "10 866 RSPagl1 Retrosplenial area lateral agranular part\n", + "11 872 RSPd1 Retrosplenial area dorsal part\n", + "12 879 RSPv1 Retrosplenial area ventral part\n", + "13 970 SSp-bfd1 Primary somatosensory area barrel field\n", + "14 977 SSp-ll1 Primary somatosensory area lower limb\n", + "15 984 SSp-m1 Primary somatosensory area mouth\n", + "16 991 SSp-n1 Primary somatosensory area nose\n", + "17 998 SSp-tr1 Primary somatosensory area trunk\n", + "18 1005 SSp-ul1 Primary somatosensory area upper limb\n", + "19 1012 SSp-un1 Primary somatosensory area unassigned\n", + "20 1019 SSs1 Supplemental somatosensory area\n", + "21 1060 TEa1 Temporal association areas\n", + "22 1125 VISal1 Anterolateral visual area\n", + "23 1132 VISam1 Anteromedial visual area\n", + "24 1139 VISC1 Visceral area\n", + "25 1146 VISl1 Lateral visual area\n", + "26 1153 VISp Primary visual area\n", + "27 1160 VISpl1 Posterolateral visual area\n", + "28 1167 VISpm Posteromedial visual area\n", + "29 1207 VISa1 Anterior area\n", + "30 1214 VISli1 Laterointermediate area\n", + "31 1221 VISpor1 Postrhinal area\n", + "32 1228 VISrl1 Rostrolateral area" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotations = get_atlas_annotations()\n", + "annotations" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9ed0211d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(1214)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotations.loc[annotations[\"acronym\"] == \"VISli1\", \"id\"].values[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "b7e9f585", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(l_aba + r_aba)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "8b19388f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.ma.array(f[\"F\"], mask=~mask).mean(axis=(1, 2)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dbdd594", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 02b322238c90f0c4b1158e4f4645c6fc805db1fd Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Thu, 23 Apr 2026 10:44:52 +0100 Subject: [PATCH 06/23] add function to extract activity across all ABA regions --- src/mesoscopy/process/region.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py index d3c725b..1c6bc8b 100644 --- a/src/mesoscopy/process/region.py +++ b/src/mesoscopy/process/region.py @@ -66,4 +66,21 @@ def extract_region_activity( return np.ma.array(deltaf_series, mask=~region_mask).mean(axis=(1, 2)) -def extract_all_regions(deltaf_series): ... +def extract_all_regions(deltaf_series: npt.NDArray) -> dict: + annotations = resources.get_atlas_annotations() + regions = annotations.acronym.unique() + + region_activity = {} + + for region in regions: + region_left_hemisphere = f"L_{region}" + region_right_hemisphere = f"R_{region}" + + region_activity[region_left_hemisphere] = extract_region_activity( + deltaf_series=deltaf_series, region_acronym=region, hemisphere="left" + ) + region_activity[region_right_hemisphere] = extract_region_activity( + deltaf_series=deltaf_series, region_acronym=region, hemisphere="right" + ) + + return region_activity From 53d6fcac729ea08d514b58d7dc3f331f608fd9eb Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Thu, 23 Apr 2026 10:46:37 +0100 Subject: [PATCH 07/23] ignore regions specified in default preselected list --- src/mesoscopy/process/region.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py index 1c6bc8b..5621337 100644 --- a/src/mesoscopy/process/region.py +++ b/src/mesoscopy/process/region.py @@ -68,7 +68,7 @@ def extract_region_activity( def extract_all_regions(deltaf_series: npt.NDArray) -> dict: annotations = resources.get_atlas_annotations() - regions = annotations.acronym.unique() + regions = [region for region in annotations.acronym.unique() if region not in DEFAULT_EXCLUDE] region_activity = {} From 201d77f339b58f104cd973e520f296abe5300264 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Mon, 6 Jul 2026 16:59:35 +0100 Subject: [PATCH 08/23] wip --- exploratory/array-masking.ipynb | 609 ++++++++++++++++++++++++++++++-- src/mesoscopy/process/region.py | 10 +- 2 files changed, 589 insertions(+), 30 deletions(-) diff --git a/exploratory/array-masking.ipynb b/exploratory/array-masking.ipynb index f9693cd..c7659d8 100644 --- a/exploratory/array-masking.ipynb +++ b/exploratory/array-masking.ipynb @@ -10,7 +10,8 @@ "import numpy as np\n", "from mesoscopy.resources import get_atlas, get_atlas_annotations\n", "import matplotlib.pyplot as plt\n", - "from mesoscopy import io\n" + "from mesoscopy import io\n", + "from mesoscopy.process import region\n" ] }, { @@ -25,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 3, "id": "17ba4891", "metadata": {}, "outputs": [], @@ -42,20 +43,13 @@ { "data": { "text/plain": [ - "(array([[0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " ...,\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16),\n", - " array([[0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " ...,\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16))" + "array([[0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16)" ] }, "execution_count": 4, @@ -69,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 5, "id": "f54c9a78", "metadata": {}, "outputs": [ @@ -179,7 +173,7 @@ " dtype=float32)" ] }, - "execution_count": 32, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -192,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 6, "id": "994f3a73", "metadata": {}, "outputs": [ @@ -462,7 +456,7 @@ "32 1228 VISrl1 Rostrolateral area" ] }, - "execution_count": 33, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -474,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 7, "id": "9ed0211d", "metadata": {}, "outputs": [ @@ -484,7 +478,7 @@ "np.int64(1214)" ] }, - "execution_count": 34, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -495,17 +489,17 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 8, "id": "b7e9f585", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 35, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -526,17 +520,17 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 9, "id": "8b19388f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 36, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, @@ -557,9 +551,566 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "2dbdd594", "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['SSp-ul', 'AUDd1', 'AUDp1', 'AUDpo1', 'AUDv1', 'FRP1', 'MOp1',\n", + " 'MOs', 'ORBm1', 'PL1', 'RSPagl1', 'RSPd1', 'RSPv1', 'SSp-bfd1',\n", + " 'SSp-ll1', 'SSp-m1', 'SSp-n1', 'SSp-tr1', 'SSp-ul1', 'SSp-un1',\n", + " 'SSs1', 'TEa1', 'VISal1', 'VISam1', 'VISC1', 'VISl1', 'VISp',\n", + " 'VISpl1', 'VISpm', 'VISa1', 'VISli1', 'VISpor1', 'VISrl1'],\n", + " dtype=object)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_atlas_annotations().acronym.unique()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f8f15224", + "metadata": {}, + "outputs": [], + "source": [ + "region_activity = region.extract_all_regions(deltaf_series=f[\"F\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d85dd3a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'L_SSp-ul': masked_array(data=[-0.00604184390977025, -0.01060702744871378,\n", + " -0.008824565447866917, ..., -4.267902113497257e-05,\n", + " -0.006469919346272945, 0.0030176336877048016],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-ul': masked_array(data=[-0.009447815828025341, -0.001017036847770214,\n", + " -0.0046899644657969475, ..., -0.0026234539691358805,\n", + " 0.0009041279554367065, -0.000360634527169168],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_MOp1': masked_array(data=[0.0009656610160038389, 0.006643298028529376,\n", + " 0.004778639110112099, ..., -0.0031457458876101908,\n", + " -0.004371119641709602, -0.0018309765848620184],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_MOp1': masked_array(data=[-0.0013334494212578084, 0.0020117065458918897,\n", + " 0.0017263108286364325, ..., -0.0038147726278195434,\n", + " -0.007190017407881346, -0.004266427851271355],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_MOs': masked_array(data=[-0.009037716287962148, -0.002834144732362068,\n", + " -0.0062620778918506155, ..., 0.0001582152526863144,\n", + " -0.004033234037863657, -0.0010766992626535582],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_MOs': masked_array(data=[-0.006386714202297525, -0.00300759448851618,\n", + " -0.00808299235414931, ..., -0.0015163726250170702,\n", + " -0.004091616847385583, -0.001376669651545749],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_PL1': masked_array(data=[0.0010487591475248337, -0.0020986948907375336,\n", + " -0.004614616632461548, ..., 0.000793599858880043,\n", + " -0.002319606989622116, -0.006217010617256165],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_PL1': masked_array(data=[-0.01033807873725891, 0.0005004123225808144,\n", + " -0.0016392995417118072, ..., 0.0027645695209503173,\n", + " 0.005742197632789612, 0.006311099529266357],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_RSPagl1': masked_array(data=[-0.009015845065294955, -0.007273171947210161,\n", + " -0.005384721201979767, ..., 0.004451963911412662,\n", + " 0.004779362579598961, 0.004709274442364071],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_RSPagl1': masked_array(data=[-0.012615827109309153, -0.011487812422123192,\n", + " -0.012048130708116713, ..., 0.006241799884811971,\n", + " 0.005451742049569411, 0.006490237485323704],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_RSPd1': masked_array(data=[-0.013841560734507373, -0.00823518016454204,\n", + " -0.012388368396807814, ..., 0.007476706638970338,\n", + " 0.006294493784989847, 0.0075009808211070495],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_RSPd1': masked_array(data=[-0.018229066258501212, -0.013103347300263623,\n", + " -0.01926988469975074, ..., 0.007613780858266689,\n", + " 0.004571691498427135, 0.0059230071504402645],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_RSPv1': masked_array(data=[-0.021226562394036187, -0.014034542772505019,\n", + " -0.009148812294006348, ..., 0.008635014957851834,\n", + " -0.003311553266313341, 0.003544061713748508],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_RSPv1': masked_array(data=[-0.015522591272989909, -0.009300906790627374,\n", + " -0.0203101290596856, ..., 0.0013280303941832648,\n", + " 0.004169947240087721, 0.005740311410692003],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-bfd1': masked_array(data=[-0.00572699534742138, -0.003269220605681214,\n", + " -0.0043376014202455935, ..., 0.0018620700775822507,\n", + " -0.00035699673845798155, 0.0024940261357947243],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-bfd1': masked_array(data=[-0.0031862011438683617, 6.663154197644584e-05,\n", + " -0.003426971616624277, ..., -0.00031939771356461925,\n", + " -0.005514928359019605, -0.00282214321667635],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-ll1': masked_array(data=[-0.014608979965589061, -0.00969901366263443,\n", + " -0.00923007837733867, ..., 0.006031609470059413,\n", + " 0.004670979073329001, 0.007079750854776513],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-ll1': masked_array(data=[-0.01334157493543921, -0.005083014505990544,\n", + " -0.00930090868695182, ..., 0.0001292078067427096,\n", + " 0.0026628584224985255, 0.0025944232200243457],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-m1': masked_array(data=[0.0013131074833147454, 0.0030337587149456293,\n", + " 0.0035220757879392064, ..., -0.0009692458040786512,\n", + " -0.0013135317901168207, -0.00014096350794789766],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-m1': masked_array(data=[0.003623371473466507, 0.004707443593728422,\n", + " 0.0047442332060650145, ..., -0.006138358453307489,\n", + " -0.006893852744439636, 0.0004684298929542002],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-n1': masked_array(data=[-0.004989613186229359, -0.002081148326396942,\n", + " -0.0042797850840019455, ..., 0.00018116419739795452,\n", + " -0.002447577588485949, 0.0008060994247595469],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-n1': masked_array(data=[-0.0010937145262053518, 0.00041727902311267275,\n", + " -0.00034051140149434406, ..., -0.0014287556211153667,\n", + " -0.004031698812137951, -0.005224807244358641],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-tr1': masked_array(data=[-0.007144426822662354, -0.00414143705368042,\n", + " -0.004123128890991211, ..., 0.0016836571693420411,\n", + " 0.002865349054336548, -0.0013300751447677612],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-tr1': masked_array(data=[-0.007947922706604004, -0.008492201805114745,\n", + " -0.0057030472755432125, ..., 0.0013136659860610962,\n", + " -0.0005753974914550781, 0.0001477925479412079],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-ul1': masked_array(data=[-0.0034603279690409816, -0.006182103378828182,\n", + " -0.003910491632860761, ..., 0.00039217957230501397,\n", + " 0.0010704625484555268, 0.002289270800213481],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-ul1': masked_array(data=[-0.00796317277952682, -0.005539106213769247,\n", + " -0.005358056134955828, ..., -0.0015744612660518913,\n", + " -0.001880005625791328, 0.0028400734413501828],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-un1': masked_array(data=[-0.00691329558690389, -0.006869689623514811,\n", + " -0.004969422419865926, ..., 0.002697473367055257,\n", + " 0.0014967872699101765, 0.0032520618041356406],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-un1': masked_array(data=[-0.009521227677663167, -0.00810991366704305,\n", + " -0.004583989381790161, ..., -0.004747321605682373,\n", + " -0.0024636226892471315, -0.004120723406473795],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSs1': masked_array(data=[-0.0020808716118335723, 0.0016853314638137816,\n", + " 0.0008377104997634888, ..., 0.0007549292594194412,\n", + " 0.0020050959289073943, -0.0012848654389381409],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSs1': masked_array(data=[-0.0031159740686416628, 0.0018535219132900238,\n", + " -0.003206475377082825, ..., 0.0007928413152694702,\n", + " -0.00334791898727417, -0.0003820110484957695],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISal1': masked_array(data=[-0.014642531909639872, -0.012121035939171201,\n", + " -0.011610829640948584, ..., 0.003287895331307063,\n", + " -0.0015008423536542863, 0.0011990214624102154],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISal1': masked_array(data=[-0.013095187762426951, -0.012832369123186384,\n", + " -0.015425997120993478, ..., 0.0007386210537146009,\n", + " -0.0020929969965465486, -0.002822233097893851],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISam1': masked_array(data=[-0.0019687306135892867, -0.0033644527196884156,\n", + " -0.002365643344819546, ..., 0.0010324638336896897,\n", + " 0.002210439369082451, 0.0013426660560071468],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISam1': masked_array(data=[-0.002968633361160755, -0.008221364766359329,\n", + " -0.0014306535944342614, ..., 0.002752809040248394,\n", + " -0.00033529449719935653, -0.0003834850620478392],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISC1': masked_array(data=[-0.010995621482531229, 0.002410490531474352,\n", + " 0.007776329914728801, ..., -0.03961696972449621,\n", + " 0.07052432994047801, -0.006000289072593053],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISC1': masked_array(data=[0.005802556872367859, 0.0161961962779363,\n", + " 0.008047867566347122, ..., 0.0011808363099892933,\n", + " -0.0075661130249500275, 0.034777904550234474],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISl1': masked_array(data=[-0.005183381366205739, -0.0035750001341432005,\n", + " -0.006539326447706956, ..., 0.0022026380667319666,\n", + " 0.0017569523591261643, 0.0028211006096431185],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISl1': masked_array(data=[-0.010318101107419193, -0.008062783178392348,\n", + " -0.011112724031720842, ..., 0.0020746192434331874,\n", + " -0.0038890491475115766, 0.0009398657705757645],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISp': masked_array(data=[-0.009140242181926835, -0.005387905244448048,\n", + " -0.008444017795118913, ..., 0.004306336741384245,\n", + " 0.0019373033464569406, 0.002252275532931748],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISp': masked_array(data=[-0.014373933794923313, -0.009296484653658298,\n", + " -0.012602723224173589, ..., 0.002685312670004034,\n", + " 0.0004265118768885841, 0.0025036306900900838],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISpm': masked_array(data=[-0.002999004696597572, -0.004320388581572461,\n", + " -0.004592640059334891, ..., 0.0014224217719390612,\n", + " 0.0017411165377672982, 0.0037900021597116933],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISpm': masked_array(data=[-0.004239990430719712, -0.007129118222148479,\n", + " -0.0029783504349844797, ..., 0.0018593020298901725,\n", + " 0.0036174802720045844, 0.0037387995158924777],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISa1': masked_array(data=[-0.004028177761531376, -0.003158240885167689,\n", + " -0.0012227413537618998, ..., -0.00028606947068567876,\n", + " 0.0028403230480380827, 1.5769284088294824e-05],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISa1': masked_array(data=[-0.009420641652353994, -0.007112859845995069,\n", + " -0.010065487214735339, ..., 0.001219111722666067,\n", + " -0.0001933472817177539, 0.0018617012700834475],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISrl1': masked_array(data=[-0.009454312531844429, -0.007391774783963742,\n", + " -0.006714459994564886, ..., -0.002016820013523102,\n", + " -0.0014161608465339827, -0.0005654578056672345],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISrl1': masked_array(data=[-0.012947405162064926, -0.008426177112952522,\n", + " -0.011863628159398619, ..., 0.00203269736274429,\n", + " -0.0021209404196428218, -0.0013621010534141374],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20)}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "region_activity" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "dd0022b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(region_activity[\"L_MOs\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d26da73a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'L_SSp-ul': masked_array(data=[-0.00604184390977025, -0.01060702744871378,\n", + " -0.008824565447866917, ..., -4.267902113497257e-05,\n", + " -0.006469919346272945, 0.0030176336877048016],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-ul': masked_array(data=[-0.009447815828025341, -0.001017036847770214,\n", + " -0.0046899644657969475, ..., -0.0026234539691358805,\n", + " 0.0009041279554367065, -0.000360634527169168],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_MOp1': masked_array(data=[0.0009656610160038389, 0.006643298028529376,\n", + " 0.004778639110112099, ..., -0.0031457458876101908,\n", + " -0.004371119641709602, -0.0018309765848620184],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_MOp1': masked_array(data=[-0.0013334494212578084, 0.0020117065458918897,\n", + " 0.0017263108286364325, ..., -0.0038147726278195434,\n", + " -0.007190017407881346, -0.004266427851271355],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_MOs': masked_array(data=[-0.009037716287962148, -0.002834144732362068,\n", + " -0.0062620778918506155, ..., 0.0001582152526863144,\n", + " -0.004033234037863657, -0.0010766992626535582],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_MOs': masked_array(data=[-0.006386714202297525, -0.00300759448851618,\n", + " -0.00808299235414931, ..., -0.0015163726250170702,\n", + " -0.004091616847385583, -0.001376669651545749],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_PL1': masked_array(data=[0.0010487591475248337, -0.0020986948907375336,\n", + " -0.004614616632461548, ..., 0.000793599858880043,\n", + " -0.002319606989622116, -0.006217010617256165],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_PL1': masked_array(data=[-0.01033807873725891, 0.0005004123225808144,\n", + " -0.0016392995417118072, ..., 0.0027645695209503173,\n", + " 0.005742197632789612, 0.006311099529266357],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_RSPagl1': masked_array(data=[-0.009015845065294955, -0.007273171947210161,\n", + " -0.005384721201979767, ..., 0.004451963911412662,\n", + " 0.004779362579598961, 0.004709274442364071],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_RSPagl1': masked_array(data=[-0.012615827109309153, -0.011487812422123192,\n", + " -0.012048130708116713, ..., 0.006241799884811971,\n", + " 0.005451742049569411, 0.006490237485323704],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_RSPd1': masked_array(data=[-0.013841560734507373, -0.00823518016454204,\n", + " -0.012388368396807814, ..., 0.007476706638970338,\n", + " 0.006294493784989847, 0.0075009808211070495],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_RSPd1': masked_array(data=[-0.018229066258501212, -0.013103347300263623,\n", + " -0.01926988469975074, ..., 0.007613780858266689,\n", + " 0.004571691498427135, 0.0059230071504402645],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_RSPv1': masked_array(data=[-0.021226562394036187, -0.014034542772505019,\n", + " -0.009148812294006348, ..., 0.008635014957851834,\n", + " -0.003311553266313341, 0.003544061713748508],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_RSPv1': masked_array(data=[-0.015522591272989909, -0.009300906790627374,\n", + " -0.0203101290596856, ..., 0.0013280303941832648,\n", + " 0.004169947240087721, 0.005740311410692003],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-bfd1': masked_array(data=[-0.00572699534742138, -0.003269220605681214,\n", + " -0.0043376014202455935, ..., 0.0018620700775822507,\n", + " -0.00035699673845798155, 0.0024940261357947243],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-bfd1': masked_array(data=[-0.0031862011438683617, 6.663154197644584e-05,\n", + " -0.003426971616624277, ..., -0.00031939771356461925,\n", + " -0.005514928359019605, -0.00282214321667635],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-ll1': masked_array(data=[-0.014608979965589061, -0.00969901366263443,\n", + " -0.00923007837733867, ..., 0.006031609470059413,\n", + " 0.004670979073329001, 0.007079750854776513],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-ll1': masked_array(data=[-0.01334157493543921, -0.005083014505990544,\n", + " -0.00930090868695182, ..., 0.0001292078067427096,\n", + " 0.0026628584224985255, 0.0025944232200243457],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-m1': masked_array(data=[0.0013131074833147454, 0.0030337587149456293,\n", + " 0.0035220757879392064, ..., -0.0009692458040786512,\n", + " -0.0013135317901168207, -0.00014096350794789766],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-m1': masked_array(data=[0.003623371473466507, 0.004707443593728422,\n", + " 0.0047442332060650145, ..., -0.006138358453307489,\n", + " -0.006893852744439636, 0.0004684298929542002],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-n1': masked_array(data=[-0.004989613186229359, -0.002081148326396942,\n", + " -0.0042797850840019455, ..., 0.00018116419739795452,\n", + " -0.002447577588485949, 0.0008060994247595469],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-n1': masked_array(data=[-0.0010937145262053518, 0.00041727902311267275,\n", + " -0.00034051140149434406, ..., -0.0014287556211153667,\n", + " -0.004031698812137951, -0.005224807244358641],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-tr1': masked_array(data=[-0.007144426822662354, -0.00414143705368042,\n", + " -0.004123128890991211, ..., 0.0016836571693420411,\n", + " 0.002865349054336548, -0.0013300751447677612],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-tr1': masked_array(data=[-0.007947922706604004, -0.008492201805114745,\n", + " -0.0057030472755432125, ..., 0.0013136659860610962,\n", + " -0.0005753974914550781, 0.0001477925479412079],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-ul1': masked_array(data=[-0.0034603279690409816, -0.006182103378828182,\n", + " -0.003910491632860761, ..., 0.00039217957230501397,\n", + " 0.0010704625484555268, 0.002289270800213481],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-ul1': masked_array(data=[-0.00796317277952682, -0.005539106213769247,\n", + " -0.005358056134955828, ..., -0.0015744612660518913,\n", + " -0.001880005625791328, 0.0028400734413501828],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSp-un1': masked_array(data=[-0.00691329558690389, -0.006869689623514811,\n", + " -0.004969422419865926, ..., 0.002697473367055257,\n", + " 0.0014967872699101765, 0.0032520618041356406],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSp-un1': masked_array(data=[-0.009521227677663167, -0.00810991366704305,\n", + " -0.004583989381790161, ..., -0.004747321605682373,\n", + " -0.0024636226892471315, -0.004120723406473795],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_SSs1': masked_array(data=[-0.0020808716118335723, 0.0016853314638137816,\n", + " 0.0008377104997634888, ..., 0.0007549292594194412,\n", + " 0.0020050959289073943, -0.0012848654389381409],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_SSs1': masked_array(data=[-0.0031159740686416628, 0.0018535219132900238,\n", + " -0.003206475377082825, ..., 0.0007928413152694702,\n", + " -0.00334791898727417, -0.0003820110484957695],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISal1': masked_array(data=[-0.014642531909639872, -0.012121035939171201,\n", + " -0.011610829640948584, ..., 0.003287895331307063,\n", + " -0.0015008423536542863, 0.0011990214624102154],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISal1': masked_array(data=[-0.013095187762426951, -0.012832369123186384,\n", + " -0.015425997120993478, ..., 0.0007386210537146009,\n", + " -0.0020929969965465486, -0.002822233097893851],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISam1': masked_array(data=[-0.0019687306135892867, -0.0033644527196884156,\n", + " -0.002365643344819546, ..., 0.0010324638336896897,\n", + " 0.002210439369082451, 0.0013426660560071468],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISam1': masked_array(data=[-0.002968633361160755, -0.008221364766359329,\n", + " -0.0014306535944342614, ..., 0.002752809040248394,\n", + " -0.00033529449719935653, -0.0003834850620478392],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISC1': masked_array(data=[-0.010995621482531229, 0.002410490531474352,\n", + " 0.007776329914728801, ..., -0.03961696972449621,\n", + " 0.07052432994047801, -0.006000289072593053],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISC1': masked_array(data=[0.005802556872367859, 0.0161961962779363,\n", + " 0.008047867566347122, ..., 0.0011808363099892933,\n", + " -0.0075661130249500275, 0.034777904550234474],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISl1': masked_array(data=[-0.005183381366205739, -0.0035750001341432005,\n", + " -0.006539326447706956, ..., 0.0022026380667319666,\n", + " 0.0017569523591261643, 0.0028211006096431185],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISl1': masked_array(data=[-0.010318101107419193, -0.008062783178392348,\n", + " -0.011112724031720842, ..., 0.0020746192434331874,\n", + " -0.0038890491475115766, 0.0009398657705757645],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISp': masked_array(data=[-0.009140242181926835, -0.005387905244448048,\n", + " -0.008444017795118913, ..., 0.004306336741384245,\n", + " 0.0019373033464569406, 0.002252275532931748],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISp': masked_array(data=[-0.014373933794923313, -0.009296484653658298,\n", + " -0.012602723224173589, ..., 0.002685312670004034,\n", + " 0.0004265118768885841, 0.0025036306900900838],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISpm': masked_array(data=[-0.002999004696597572, -0.004320388581572461,\n", + " -0.004592640059334891, ..., 0.0014224217719390612,\n", + " 0.0017411165377672982, 0.0037900021597116933],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISpm': masked_array(data=[-0.004239990430719712, -0.007129118222148479,\n", + " -0.0029783504349844797, ..., 0.0018593020298901725,\n", + " 0.0036174802720045844, 0.0037387995158924777],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'L_VISa1': masked_array(data=[-0.004028177761531376, -0.003158240885167689,\n", + " -0.0012227413537618998, ..., -0.00028606947068567876,\n", + " 0.0028403230480380827, 1.5769284088294824e-05],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20),\n", + " 'R_VISa1': masked_array(data=[-0.009420641652353994, -0.007112859845995069,\n", + " -0.010065487214735339, ..., 0.001219111722666067,\n", + " -0.0001933472817177539, 0.0018617012700834475],\n", + " mask=[False, False, False, ..., False, False, False],\n", + " fill_value=1e+20)}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "region.extract_all_regions(deltaf_series=f[\"F\"], exclude=[\"VISrl1\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6d60f00", + "metadata": {}, "outputs": [], "source": [] } diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py index 5621337..33e905f 100644 --- a/src/mesoscopy/process/region.py +++ b/src/mesoscopy/process/region.py @@ -66,8 +66,16 @@ def extract_region_activity( return np.ma.array(deltaf_series, mask=~region_mask).mean(axis=(1, 2)) -def extract_all_regions(deltaf_series: npt.NDArray) -> dict: +def extract_all_regions( + deltaf_series: npt.NDArray, exclude: list | None = None, ignore_default_exclude: bool = False +) -> dict: annotations = resources.get_atlas_annotations() + + if exclude is None: + exclude = [] + + excluded_regions = DEFAULT_EXCLUDE if not ignore_default_exclude else [] + excluded_regions.extend(exclude) regions = [region for region in annotations.acronym.unique() if region not in DEFAULT_EXCLUDE] region_activity = {} From b7a4eac36a32f3a759326c2f36bc45f88f6d9db3 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Thu, 9 Jul 2026 17:19:06 +0100 Subject: [PATCH 09/23] cmd wip --- exploratory/array-masking.ipynb | 546 ++++++++++-------------------- src/mesoscopy/process/__init__.py | 22 ++ 2 files changed, 201 insertions(+), 367 deletions(-) diff --git a/exploratory/array-masking.ipynb b/exploratory/array-masking.ipynb index c7659d8..d253398 100644 --- a/exploratory/array-masking.ipynb +++ b/exploratory/array-masking.ipynb @@ -496,7 +496,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -527,7 +527,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 9, @@ -536,7 +536,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -594,234 +594,234 @@ { "data": { "text/plain": [ - "{'L_SSp-ul': masked_array(data=[-0.00604184390977025, -0.01060702744871378,\n", - " -0.008824565447866917, ..., -4.267902113497257e-05,\n", - " -0.006469919346272945, 0.0030176336877048016],\n", + "{'L_SSp-ul': masked_array(data=[-0.014033851213753223, -0.0023055514320731163,\n", + " -0.0046494812704622746, ..., -0.005773003213107586,\n", + " -0.006918411236256361, 0.003909487742930651],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-ul': masked_array(data=[-0.009447815828025341, -0.001017036847770214,\n", - " -0.0046899644657969475, ..., -0.0026234539691358805,\n", - " 0.0009041279554367065, -0.000360634527169168],\n", + " 'R_SSp-ul': masked_array(data=[0.0011805910617113113, -0.004940943326801062,\n", + " -0.004747333005070686, ..., 0.005206792615354061,\n", + " -0.003380958689376712, -0.002345480490475893],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_MOp1': masked_array(data=[0.0009656610160038389, 0.006643298028529376,\n", - " 0.004778639110112099, ..., -0.0031457458876101908,\n", - " -0.004371119641709602, -0.0018309765848620184],\n", + " 'L_MOp1': masked_array(data=[0.0012087095742938161, 0.006479873511069579,\n", + " 0.004268450755269135, ..., -0.002622898511046194,\n", + " -0.004218819497645587, -0.0018279879029226486],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_MOp1': masked_array(data=[-0.0013334494212578084, 0.0020117065458918897,\n", - " 0.0017263108286364325, ..., -0.0038147726278195434,\n", - " -0.007190017407881346, -0.004266427851271355],\n", + " 'R_MOp1': masked_array(data=[-1.5095275937369044e-07, 0.0031936260018768895,\n", + " 0.0022690168285735266, ..., -0.004278725591199151,\n", + " -0.008189782328989315, -0.0057176269333938075],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_MOs': masked_array(data=[-0.009037716287962148, -0.002834144732362068,\n", - " -0.0062620778918506155, ..., 0.0001582152526863144,\n", - " -0.004033234037863657, -0.0010766992626535582],\n", + " 'L_MOs': masked_array(data=[-0.00733040180244676, -0.001921274772352376,\n", + " -0.005639809238119144, ..., 0.0010045917940811372,\n", + " -0.00289904327699596, -0.001076304097050872],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_MOs': masked_array(data=[-0.006386714202297525, -0.00300759448851618,\n", - " -0.00808299235414931, ..., -0.0015163726250170702,\n", - " -0.004091616847385583, -0.001376669651545749],\n", + " 'R_MOs': masked_array(data=[-0.007620688655246911, -0.003428645776790872,\n", + " -0.008854721153765857, ..., -4.159120966491085e-05,\n", + " -0.0014319851604745661, 0.00013330740707980795],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_PL1': masked_array(data=[0.0010487591475248337, -0.0020986948907375336,\n", - " -0.004614616632461548, ..., 0.000793599858880043,\n", - " -0.002319606989622116, -0.006217010617256165],\n", + " 'L_PL1': masked_array(data=[-0.013283089399337769, -0.0026014751195907594,\n", + " -0.0014095172286033631, ..., 0.0026571032404899596,\n", + " -0.004158598184585571, -0.002931191623210907],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_PL1': masked_array(data=[-0.01033807873725891, 0.0005004123225808144,\n", - " -0.0016392995417118072, ..., 0.0027645695209503173,\n", - " 0.005742197632789612, 0.006311099529266357],\n", + " 'R_PL1': masked_array(data=[0.007158556580543518, -0.009701893329620362,\n", + " 0.002825324237346649, ..., 0.003142477571964264,\n", + " -0.003895668983459473, -0.0009304802119731903],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_RSPagl1': masked_array(data=[-0.009015845065294955, -0.007273171947210161,\n", - " -0.005384721201979767, ..., 0.004451963911412662,\n", - " 0.004779362579598961, 0.004709274442364071],\n", + " 'L_RSPagl1': masked_array(data=[-0.010232141898380771, -0.0069485798910940335,\n", + " -0.0089195912309702, ..., 0.007900469036023152,\n", + " 0.008165491072468738, 0.00837478993839248],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_RSPagl1': masked_array(data=[-0.012615827109309153, -0.011487812422123192,\n", - " -0.012048130708116713, ..., 0.006241799884811971,\n", - " 0.005451742049569411, 0.006490237485323704],\n", + " 'R_RSPagl1': masked_array(data=[-0.01352551567109294, -0.01164242142958265,\n", + " -0.01248257981296397, ..., 0.008677239239957817,\n", + " 0.008264492161541064, 0.007455593322817221],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_RSPd1': masked_array(data=[-0.013841560734507373, -0.00823518016454204,\n", - " -0.012388368396807814, ..., 0.007476706638970338,\n", - " 0.006294493784989847, 0.0075009808211070495],\n", + " 'L_RSPd1': masked_array(data=[-0.015534882655229105, -0.011418075512742142,\n", + " -0.013885254140400215, ..., 0.010264690574782584,\n", + " 0.00804251539127906, 0.00972024376130165],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_RSPd1': masked_array(data=[-0.018229066258501212, -0.013103347300263623,\n", - " -0.01926988469975074, ..., 0.007613780858266689,\n", - " 0.004571691498427135, 0.0059230071504402645],\n", + " 'R_RSPd1': masked_array(data=[-0.016762855412710047, -0.01376889855660441,\n", + " -0.01858871367276477, ..., 0.0088568221577598,\n", + " 0.005692363699988636, 0.0067583099960366174],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_RSPv1': masked_array(data=[-0.021226562394036187, -0.014034542772505019,\n", - " -0.009148812294006348, ..., 0.008635014957851834,\n", - " -0.003311553266313341, 0.003544061713748508],\n", + " 'L_RSPv1': masked_array(data=[-0.020429519812266032, -0.011243644025590685,\n", + " -0.01216142839855618, ..., 0.010765853855344985,\n", + " 0.0012375758753882513, 0.007058852248721653],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_RSPv1': masked_array(data=[-0.015522591272989909, -0.009300906790627374,\n", - " -0.0203101290596856, ..., 0.0013280303941832648,\n", - " 0.004169947240087721, 0.005740311410692003],\n", + " 'R_RSPv1': masked_array(data=[-0.016519489553239612, -0.012696713871426053,\n", + " -0.02089816199408637, ..., 0.004538283745447794,\n", + " 0.008982977602216932, 0.008620958195792304],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-bfd1': masked_array(data=[-0.00572699534742138, -0.003269220605681214,\n", - " -0.0043376014202455935, ..., 0.0018620700775822507,\n", - " -0.00035699673845798155, 0.0024940261357947243],\n", + " 'L_SSp-bfd1': masked_array(data=[-0.006667985795419428, -0.003577950634533846,\n", + " -0.005047343350663969, ..., 0.0013130245329458503,\n", + " -0.0005661271040952659, 0.002028020575076719],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-bfd1': masked_array(data=[-0.0031862011438683617, 6.663154197644584e-05,\n", - " -0.003426971616624277, ..., -0.00031939771356461925,\n", - " -0.005514928359019605, -0.00282214321667635],\n", + " 'R_SSp-bfd1': masked_array(data=[-0.00415083547181721, -0.0013469996331613276,\n", + " -0.004490166072604022, ..., 0.00036313839351074606,\n", + " -0.004657121247883084, -0.0026040873950040795],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-ll1': masked_array(data=[-0.014608979965589061, -0.00969901366263443,\n", - " -0.00923007837733867, ..., 0.006031609470059413,\n", - " 0.004670979073329001, 0.007079750854776513],\n", + " 'L_SSp-ll1': masked_array(data=[-0.012672511687189896, -0.009397166856327412,\n", + " -0.007719593018478488, ..., 0.005676626048473098,\n", + " 0.00489550014460309, 0.006683493993297126],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-ll1': masked_array(data=[-0.01334157493543921, -0.005083014505990544,\n", - " -0.00930090868695182, ..., 0.0001292078067427096,\n", - " 0.0026628584224985255, 0.0025944232200243457],\n", + " 'R_SSp-ll1': masked_array(data=[-0.011901273490479274, -0.00554644469148624,\n", + " -0.008366665484742348, ..., 0.00016224449095518693,\n", + " 0.0016499422721981262, 0.001873460800751396],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-m1': masked_array(data=[0.0013131074833147454, 0.0030337587149456293,\n", - " 0.0035220757879392064, ..., -0.0009692458040786512,\n", - " -0.0013135317901168207, -0.00014096350794789766],\n", + " 'L_SSp-m1': masked_array(data=[0.00047472450468275283, 0.0024304898700328787,\n", + " 0.002209042509396871, ..., -0.000509012829173695,\n", + " -0.0003187851698109598, -0.00020478108916619812],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-m1': masked_array(data=[0.003623371473466507, 0.004707443593728422,\n", - " 0.0047442332060650145, ..., -0.006138358453307489,\n", - " -0.006893852744439636, 0.0004684298929542002],\n", + " 'R_SSp-m1': masked_array(data=[0.0033452161634811247, 0.005282972196135858,\n", + " 0.005225563290143254, ..., -0.005994234422240594,\n", + " -0.006220980726107202, -0.0006650918812462778],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-n1': masked_array(data=[-0.004989613186229359, -0.002081148326396942,\n", - " -0.0042797850840019455, ..., 0.00018116419739795452,\n", - " -0.002447577588485949, 0.0008060994247595469],\n", + " 'L_SSp-n1': masked_array(data=[-0.005448756795940977, -0.0023389269005168567,\n", + " -0.003903671647563125, ..., 8.024592799219218e-05,\n", + " -0.003073453451647903, -0.0002346154528133797],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-n1': masked_array(data=[-0.0010937145262053518, 0.00041727902311267275,\n", - " -0.00034051140149434406, ..., -0.0014287556211153667,\n", - " -0.004031698812137951, -0.005224807244358641],\n", + " 'R_SSp-n1': masked_array(data=[-0.0010106705806472085, 0.0007491691433119051,\n", + " -0.0006256030138694879, ..., -0.0019599178975278683,\n", + " -0.004140827240365924, -0.004861467715465661],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-tr1': masked_array(data=[-0.007144426822662354, -0.00414143705368042,\n", - " -0.004123128890991211, ..., 0.0016836571693420411,\n", - " 0.002865349054336548, -0.0013300751447677612],\n", + " 'L_SSp-tr1': masked_array(data=[-0.004366690635681152, -0.00216253662109375,\n", + " -0.0014669373035430908, ..., -0.0010107845067977906,\n", + " 0.003070756673812866, -0.003410844087600708],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-tr1': masked_array(data=[-0.007947922706604004, -0.008492201805114745,\n", - " -0.0057030472755432125, ..., 0.0013136659860610962,\n", - " -0.0005753974914550781, 0.0001477925479412079],\n", + " 'R_SSp-tr1': masked_array(data=[-0.008656573295593262, -0.008858576774597168,\n", + " -0.007676359176635742, ..., 0.002116822004318237,\n", + " 0.0009880146980285644, 0.0019443566799163818],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-ul1': masked_array(data=[-0.0034603279690409816, -0.006182103378828182,\n", - " -0.003910491632860761, ..., 0.00039217957230501397,\n", - " 0.0010704625484555268, 0.002289270800213481],\n", + " 'L_SSp-ul1': masked_array(data=[-0.0037868186484935674, -0.004994455603666083,\n", + " -0.0037989181141520655, ..., -5.595767220785452e-05,\n", + " -0.00029643801755683364, 0.0012969826543053915],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-ul1': masked_array(data=[-0.00796317277952682, -0.005539106213769247,\n", - " -0.005358056134955828, ..., -0.0015744612660518913,\n", - " -0.001880005625791328, 0.0028400734413501828],\n", + " 'R_SSp-ul1': masked_array(data=[-0.006430195653161337, -0.00391713491705961,\n", + " -0.002780574421549952, ..., -0.002825222181719403,\n", + " -0.002140893076741418, 0.0025443961453992265],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-un1': masked_array(data=[-0.00691329558690389, -0.006869689623514811,\n", - " -0.004969422419865926, ..., 0.002697473367055257,\n", - " 0.0014967872699101765, 0.0032520618041356406],\n", + " 'L_SSp-un1': masked_array(data=[-0.00618749737739563, -0.008935513496398926,\n", + " -0.00472840428352356, ..., 0.004623570044835408,\n", + " 0.0038045565287272137, 0.003594652016957601],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-un1': masked_array(data=[-0.009521227677663167, -0.00810991366704305,\n", - " -0.004583989381790161, ..., -0.004747321605682373,\n", - " -0.0024636226892471315, -0.004120723406473795],\n", + " 'R_SSp-un1': masked_array(data=[-0.01187420129776001, -0.008354594707489013,\n", + " -0.0066703502337137855, ..., -0.002582803169886271,\n", + " -0.001995809078216553, -0.0013482200105985006],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSs1': masked_array(data=[-0.0020808716118335723, 0.0016853314638137816,\n", - " 0.0008377104997634888, ..., 0.0007549292594194412,\n", - " 0.0020050959289073943, -0.0012848654389381409],\n", + " 'L_SSs1': masked_array(data=[-0.0030905187129974367, 0.0006831234693527222,\n", + " -0.001949998289346695, ..., 0.0018264533579349519,\n", + " 0.0027165967226028443, -0.0007010949403047561],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSs1': masked_array(data=[-0.0031159740686416628, 0.0018535219132900238,\n", - " -0.003206475377082825, ..., 0.0007928413152694702,\n", - " -0.00334791898727417, -0.0003820110484957695],\n", + " 'R_SSs1': masked_array(data=[-0.0049105587601661685, 0.0010619950294494629,\n", + " -0.00260578989982605, ..., 0.0014483129978179932,\n", + " -0.003213001191616058, -9.74537618458271e-05],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISal1': masked_array(data=[-0.014642531909639872, -0.012121035939171201,\n", - " -0.011610829640948584, ..., 0.003287895331307063,\n", - " -0.0015008423536542863, 0.0011990214624102154],\n", + " 'L_VISal1': masked_array(data=[-0.005778278623308454, -0.003376559132621402,\n", + " -0.00968535930391342, ..., 0.0022552599982609825,\n", + " 0.0003062347098002358, 0.0014914984977434551],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISal1': masked_array(data=[-0.013095187762426951, -0.012832369123186384,\n", - " -0.015425997120993478, ..., 0.0007386210537146009,\n", - " -0.0020929969965465486, -0.002822233097893851],\n", + " 'R_VISal1': masked_array(data=[-0.008624708841717432, -0.007961061265733507,\n", + " -0.010375697461385575, ..., 0.005581533625012352,\n", + " -0.0046790071896144324, 0.0029413004716237388],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISam1': masked_array(data=[-0.0019687306135892867, -0.0033644527196884156,\n", - " -0.002365643344819546, ..., 0.0010324638336896897,\n", - " 0.002210439369082451, 0.0013426660560071468],\n", + " 'L_VISam1': masked_array(data=[-0.002600082941353321, -0.006421634554862976,\n", + " -0.005055435374379158, ..., 0.00020793676376342773,\n", + " 0.0006793882232159377, 6.797346286475658e-05],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISam1': masked_array(data=[-0.002968633361160755, -0.008221364766359329,\n", - " -0.0014306535944342614, ..., 0.002752809040248394,\n", - " -0.00033529449719935653, -0.0003834850620478392],\n", + " 'R_VISam1': masked_array(data=[-0.0020380256697535514, -0.007694423198699951,\n", + " -0.003579515591263771, ..., 0.00019545331597328185,\n", + " 0.0031532064080238343, 0.0023261621594429017],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISC1': masked_array(data=[-0.010995621482531229, 0.002410490531474352,\n", - " 0.007776329914728801, ..., -0.03961696972449621,\n", - " 0.07052432994047801, -0.006000289072593053],\n", + " 'L_VISC1': masked_array(data=[0.03378681341807047, -0.00606775904695193,\n", + " 0.06831075251102448, ..., -0.014019307990868887,\n", + " 0.02656376361846924, -0.007869244863589605],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISC1': masked_array(data=[0.005802556872367859, 0.0161961962779363,\n", - " 0.008047867566347122, ..., 0.0011808363099892933,\n", - " -0.0075661130249500275, 0.034777904550234474],\n", + " 'R_VISC1': masked_array(data=[-0.00929751805961132, 0.026456234355767567,\n", + " 0.007971870402495066, ..., -0.013542252282301584,\n", + " 0.008318687478701273, 0.015014130622148514],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISl1': masked_array(data=[-0.005183381366205739, -0.0035750001341432005,\n", - " -0.006539326447706956, ..., 0.0022026380667319666,\n", - " 0.0017569523591261643, 0.0028211006096431185],\n", + " 'L_VISl1': masked_array(data=[-0.0016103796251527556, 0.001556872994035155,\n", + " -0.0022002804082828565, ..., 0.0020433754383862674,\n", + " 0.0002804646616453653, 0.007566246357592908],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISl1': masked_array(data=[-0.010318101107419193, -0.008062783178392348,\n", - " -0.011112724031720842, ..., 0.0020746192434331874,\n", - " -0.0038890491475115766, 0.0009398657705757645],\n", + " 'R_VISl1': masked_array(data=[-0.025578341641268886, 0.005045478488062765,\n", + " 0.0034280203200958586, ..., -0.0009608538923682748,\n", + " -0.0030777077753465255, 0.0006799236103728578],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISp': masked_array(data=[-0.009140242181926835, -0.005387905244448048,\n", - " -0.008444017795118913, ..., 0.004306336741384245,\n", - " 0.0019373033464569406, 0.002252275532931748],\n", + " 'L_VISp': masked_array(data=[-0.008580011893091216, -0.0037662456242781852,\n", + " -0.00781555063419033, ..., 0.005344631745643222,\n", + " 0.00436337952761306, 0.002381208543398243],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISp': masked_array(data=[-0.014373933794923313, -0.009296484653658298,\n", - " -0.012602723224173589, ..., 0.002685312670004034,\n", - " 0.0004265118768885841, 0.0025036306900900838],\n", + " 'R_VISp': masked_array(data=[-0.013346634135857247, -0.00812952156797249,\n", + " -0.00990891772622739, ..., 0.0030202075553747974,\n", + " 0.0011493071189509576, 0.0031016087145798337],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISpm': masked_array(data=[-0.002999004696597572, -0.004320388581572461,\n", - " -0.004592640059334891, ..., 0.0014224217719390612,\n", - " 0.0017411165377672982, 0.0037900021597116933],\n", + " 'L_VISpm': masked_array(data=[-0.0095696389174261, -0.009143576902501723,\n", + " -0.005712877301608815, ..., 0.007447449099115965,\n", + " 0.0070947538904783105, 0.008626583243618492],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISpm': masked_array(data=[-0.004239990430719712, -0.007129118222148479,\n", - " -0.0029783504349844797, ..., 0.0018593020298901725,\n", - " 0.0036174802720045844, 0.0037387995158924777],\n", + " 'R_VISpm': masked_array(data=[-0.012210134698563264, -0.007568964938155743,\n", + " -0.009043914931161063, ..., 0.006802944576039034,\n", + " 0.005720874341596074, 0.005985271029111718],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISa1': masked_array(data=[-0.004028177761531376, -0.003158240885167689,\n", - " -0.0012227413537618998, ..., -0.00028606947068567876,\n", - " 0.0028403230480380827, 1.5769284088294824e-05],\n", + " 'L_VISa1': masked_array(data=[-0.002971118146722967, -0.0034021593474007988,\n", + " -0.00020881174327610255, ..., -0.00011427987080353957,\n", + " 0.0017314414669583728, 0.001749689345593219],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISa1': masked_array(data=[-0.009420641652353994, -0.007112859845995069,\n", - " -0.010065487214735339, ..., 0.001219111722666067,\n", - " -0.0001933472817177539, 0.0018617012700834475],\n", + " 'R_VISa1': masked_array(data=[-0.008313341574235395, -0.006312118960427238,\n", + " -0.005990090903702316, ..., 0.000465799513813499,\n", + " -0.0018320260764835598, -0.00019919387735686935],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISrl1': masked_array(data=[-0.009454312531844429, -0.007391774783963742,\n", - " -0.006714459994564886, ..., -0.002016820013523102,\n", - " -0.0014161608465339827, -0.0005654578056672345],\n", + " 'L_VISrl1': masked_array(data=[-0.010959998421047045, -0.008275526373282723,\n", + " -0.007561957058699235, ..., 0.0015957831688549209,\n", + " -0.0033778979078583097, 0.0002434327793510064],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISrl1': masked_array(data=[-0.012947405162064926, -0.008426177112952522,\n", - " -0.011863628159398619, ..., 0.00203269736274429,\n", - " -0.0021209404196428218, -0.0013621010534141374],\n", + " 'R_VISrl1': masked_array(data=[-0.014714967945347662, -0.008015477139016857,\n", + " -0.011097423408342444, ..., -0.0007558289267446684,\n", + " -0.0022647398645463195, -0.0023275242875451627],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20)}" ] @@ -844,7 +844,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 13, @@ -853,7 +853,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -868,248 +868,60 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, + "id": "b0fedbcd", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n" + ] + }, + { + "cell_type": "code", + "execution_count": 79, "id": "d26da73a", "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(region_activity)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "9d280c5e", + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'L_SSp-ul': masked_array(data=[-0.00604184390977025, -0.01060702744871378,\n", - " -0.008824565447866917, ..., -4.267902113497257e-05,\n", - " -0.006469919346272945, 0.0030176336877048016],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-ul': masked_array(data=[-0.009447815828025341, -0.001017036847770214,\n", - " -0.0046899644657969475, ..., -0.0026234539691358805,\n", - " 0.0009041279554367065, -0.000360634527169168],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_MOp1': masked_array(data=[0.0009656610160038389, 0.006643298028529376,\n", - " 0.004778639110112099, ..., -0.0031457458876101908,\n", - " -0.004371119641709602, -0.0018309765848620184],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_MOp1': masked_array(data=[-0.0013334494212578084, 0.0020117065458918897,\n", - " 0.0017263108286364325, ..., -0.0038147726278195434,\n", - " -0.007190017407881346, -0.004266427851271355],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_MOs': masked_array(data=[-0.009037716287962148, -0.002834144732362068,\n", - " -0.0062620778918506155, ..., 0.0001582152526863144,\n", - " -0.004033234037863657, -0.0010766992626535582],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_MOs': masked_array(data=[-0.006386714202297525, -0.00300759448851618,\n", - " -0.00808299235414931, ..., -0.0015163726250170702,\n", - " -0.004091616847385583, -0.001376669651545749],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_PL1': masked_array(data=[0.0010487591475248337, -0.0020986948907375336,\n", - " -0.004614616632461548, ..., 0.000793599858880043,\n", - " -0.002319606989622116, -0.006217010617256165],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_PL1': masked_array(data=[-0.01033807873725891, 0.0005004123225808144,\n", - " -0.0016392995417118072, ..., 0.0027645695209503173,\n", - " 0.005742197632789612, 0.006311099529266357],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_RSPagl1': masked_array(data=[-0.009015845065294955, -0.007273171947210161,\n", - " -0.005384721201979767, ..., 0.004451963911412662,\n", - " 0.004779362579598961, 0.004709274442364071],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_RSPagl1': masked_array(data=[-0.012615827109309153, -0.011487812422123192,\n", - " -0.012048130708116713, ..., 0.006241799884811971,\n", - " 0.005451742049569411, 0.006490237485323704],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_RSPd1': masked_array(data=[-0.013841560734507373, -0.00823518016454204,\n", - " -0.012388368396807814, ..., 0.007476706638970338,\n", - " 0.006294493784989847, 0.0075009808211070495],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_RSPd1': masked_array(data=[-0.018229066258501212, -0.013103347300263623,\n", - " -0.01926988469975074, ..., 0.007613780858266689,\n", - " 0.004571691498427135, 0.0059230071504402645],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_RSPv1': masked_array(data=[-0.021226562394036187, -0.014034542772505019,\n", - " -0.009148812294006348, ..., 0.008635014957851834,\n", - " -0.003311553266313341, 0.003544061713748508],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_RSPv1': masked_array(data=[-0.015522591272989909, -0.009300906790627374,\n", - " -0.0203101290596856, ..., 0.0013280303941832648,\n", - " 0.004169947240087721, 0.005740311410692003],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-bfd1': masked_array(data=[-0.00572699534742138, -0.003269220605681214,\n", - " -0.0043376014202455935, ..., 0.0018620700775822507,\n", - " -0.00035699673845798155, 0.0024940261357947243],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-bfd1': masked_array(data=[-0.0031862011438683617, 6.663154197644584e-05,\n", - " -0.003426971616624277, ..., -0.00031939771356461925,\n", - " -0.005514928359019605, -0.00282214321667635],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-ll1': masked_array(data=[-0.014608979965589061, -0.00969901366263443,\n", - " -0.00923007837733867, ..., 0.006031609470059413,\n", - " 0.004670979073329001, 0.007079750854776513],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-ll1': masked_array(data=[-0.01334157493543921, -0.005083014505990544,\n", - " -0.00930090868695182, ..., 0.0001292078067427096,\n", - " 0.0026628584224985255, 0.0025944232200243457],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-m1': masked_array(data=[0.0013131074833147454, 0.0030337587149456293,\n", - " 0.0035220757879392064, ..., -0.0009692458040786512,\n", - " -0.0013135317901168207, -0.00014096350794789766],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-m1': masked_array(data=[0.003623371473466507, 0.004707443593728422,\n", - " 0.0047442332060650145, ..., -0.006138358453307489,\n", - " -0.006893852744439636, 0.0004684298929542002],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-n1': masked_array(data=[-0.004989613186229359, -0.002081148326396942,\n", - " -0.0042797850840019455, ..., 0.00018116419739795452,\n", - " -0.002447577588485949, 0.0008060994247595469],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-n1': masked_array(data=[-0.0010937145262053518, 0.00041727902311267275,\n", - " -0.00034051140149434406, ..., -0.0014287556211153667,\n", - " -0.004031698812137951, -0.005224807244358641],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-tr1': masked_array(data=[-0.007144426822662354, -0.00414143705368042,\n", - " -0.004123128890991211, ..., 0.0016836571693420411,\n", - " 0.002865349054336548, -0.0013300751447677612],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-tr1': masked_array(data=[-0.007947922706604004, -0.008492201805114745,\n", - " -0.0057030472755432125, ..., 0.0013136659860610962,\n", - " -0.0005753974914550781, 0.0001477925479412079],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-ul1': masked_array(data=[-0.0034603279690409816, -0.006182103378828182,\n", - " -0.003910491632860761, ..., 0.00039217957230501397,\n", - " 0.0010704625484555268, 0.002289270800213481],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-ul1': masked_array(data=[-0.00796317277952682, -0.005539106213769247,\n", - " -0.005358056134955828, ..., -0.0015744612660518913,\n", - " -0.001880005625791328, 0.0028400734413501828],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSp-un1': masked_array(data=[-0.00691329558690389, -0.006869689623514811,\n", - " -0.004969422419865926, ..., 0.002697473367055257,\n", - " 0.0014967872699101765, 0.0032520618041356406],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSp-un1': masked_array(data=[-0.009521227677663167, -0.00810991366704305,\n", - " -0.004583989381790161, ..., -0.004747321605682373,\n", - " -0.0024636226892471315, -0.004120723406473795],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_SSs1': masked_array(data=[-0.0020808716118335723, 0.0016853314638137816,\n", - " 0.0008377104997634888, ..., 0.0007549292594194412,\n", - " 0.0020050959289073943, -0.0012848654389381409],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_SSs1': masked_array(data=[-0.0031159740686416628, 0.0018535219132900238,\n", - " -0.003206475377082825, ..., 0.0007928413152694702,\n", - " -0.00334791898727417, -0.0003820110484957695],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISal1': masked_array(data=[-0.014642531909639872, -0.012121035939171201,\n", - " -0.011610829640948584, ..., 0.003287895331307063,\n", - " -0.0015008423536542863, 0.0011990214624102154],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISal1': masked_array(data=[-0.013095187762426951, -0.012832369123186384,\n", - " -0.015425997120993478, ..., 0.0007386210537146009,\n", - " -0.0020929969965465486, -0.002822233097893851],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISam1': masked_array(data=[-0.0019687306135892867, -0.0033644527196884156,\n", - " -0.002365643344819546, ..., 0.0010324638336896897,\n", - " 0.002210439369082451, 0.0013426660560071468],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISam1': masked_array(data=[-0.002968633361160755, -0.008221364766359329,\n", - " -0.0014306535944342614, ..., 0.002752809040248394,\n", - " -0.00033529449719935653, -0.0003834850620478392],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISC1': masked_array(data=[-0.010995621482531229, 0.002410490531474352,\n", - " 0.007776329914728801, ..., -0.03961696972449621,\n", - " 0.07052432994047801, -0.006000289072593053],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISC1': masked_array(data=[0.005802556872367859, 0.0161961962779363,\n", - " 0.008047867566347122, ..., 0.0011808363099892933,\n", - " -0.0075661130249500275, 0.034777904550234474],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISl1': masked_array(data=[-0.005183381366205739, -0.0035750001341432005,\n", - " -0.006539326447706956, ..., 0.0022026380667319666,\n", - " 0.0017569523591261643, 0.0028211006096431185],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISl1': masked_array(data=[-0.010318101107419193, -0.008062783178392348,\n", - " -0.011112724031720842, ..., 0.0020746192434331874,\n", - " -0.0038890491475115766, 0.0009398657705757645],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISp': masked_array(data=[-0.009140242181926835, -0.005387905244448048,\n", - " -0.008444017795118913, ..., 0.004306336741384245,\n", - " 0.0019373033464569406, 0.002252275532931748],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISp': masked_array(data=[-0.014373933794923313, -0.009296484653658298,\n", - " -0.012602723224173589, ..., 0.002685312670004034,\n", - " 0.0004265118768885841, 0.0025036306900900838],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISpm': masked_array(data=[-0.002999004696597572, -0.004320388581572461,\n", - " -0.004592640059334891, ..., 0.0014224217719390612,\n", - " 0.0017411165377672982, 0.0037900021597116933],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISpm': masked_array(data=[-0.004239990430719712, -0.007129118222148479,\n", - " -0.0029783504349844797, ..., 0.0018593020298901725,\n", - " 0.0036174802720045844, 0.0037387995158924777],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'L_VISa1': masked_array(data=[-0.004028177761531376, -0.003158240885167689,\n", - " -0.0012227413537618998, ..., -0.00028606947068567876,\n", - " 0.0028403230480380827, 1.5769284088294824e-05],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20),\n", - " 'R_VISa1': masked_array(data=[-0.009420641652353994, -0.007112859845995069,\n", - " -0.010065487214735339, ..., 0.001219111722666067,\n", - " -0.0001933472817177539, 0.0018617012700834475],\n", - " mask=[False, False, False, ..., False, False, False],\n", - " fill_value=1e+20)}" + "L_SSp-ul 0 -0.014034\n", + " 1 -0.002306\n", + " 2 -0.004649\n", + " 3 -0.005122\n", + " 4 -0.013291\n", + " ... \n", + "R_VISrl1 7495 0.000298\n", + " 7496 -0.000169\n", + " 7497 -0.000756\n", + " 7498 -0.002265\n", + " 7499 -0.002328\n", + "Length: 345000, dtype: float64" ] }, - "execution_count": 15, + "execution_count": 101, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "region.extract_all_regions(deltaf_series=f[\"F\"], exclude=[\"VISrl1\"])" + "df.unstack()" ] }, { "cell_type": "code", "execution_count": null, - "id": "d6d60f00", + "id": "ff1f8641", "metadata": {}, "outputs": [], "source": [] diff --git a/src/mesoscopy/process/__init__.py b/src/mesoscopy/process/__init__.py index 656e332..913c43d 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -144,6 +144,28 @@ def zscore_cmd(path: str, out_dir: str) -> None: io.write_nwb(path, nwbfile, io=nwbio) +@process_cmd.command("regions") +@click.argument( + "path", + type=click.Path(exists=True), +) +@click.option( + "-o", + "--out_dir", + type=click.Path(dir_okay=True), + default="./", + help="Output directory for smoothed recording.", +) +def regions_cmd(path: str, out_dir: str) -> None: + """Extract ∆F signal averages from ABA-defined regions. + + Args: + path (str): Path to registered HDF5 recording or NWB file. + out_dir (str): Path to output directory. + """ + ... + + def load_deltaf(path: str, nwb: bool = False) -> tuple[str, np.ndarray, np.ndarray]: """Load preprocessed deltaf from an HDF5 or NWB file. From 537db744ce4cb26831b49aeffca3eaa1aeaa921b Mon Sep 17 00:00:00 2001 From: atejon123 <45932034+atejon123@users.noreply.github.com> Date: Tue, 30 Jun 2026 16:36:33 +0100 Subject: [PATCH 10/23] Fix warp transformation by using tform without inversion The tform is already inverted in a way that wrap function requires --- src/mesoscopy/register/transform.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/mesoscopy/register/transform.py b/src/mesoscopy/register/transform.py index 1c7a849..e3e2fa6 100644 --- a/src/mesoscopy/register/transform.py +++ b/src/mesoscopy/register/transform.py @@ -59,9 +59,9 @@ def landmarks_affine( with click.progressbar(range(deltaf_series.shape[0]), label="Registering recording to template...") as frame_ids: for idx in frame_ids: if crop_x > 0 or crop_y > 0: - warped_.append(trf.warp(deltaf_series[idx, :crop_y, :crop_x], tform.inverse, order=3)) + warped_.append(trf.warp(deltaf_series[idx, :crop_y, :crop_x], tform, order=3)) else: - warped_.append(trf.warp(deltaf_series[idx, :, :], tform.inverse, order=3)) + warped_.append(trf.warp(deltaf_series[idx, :, :], tform, order=3)) warped = np.array(warped_) return warped, tform From 5a7867a6cd5896a51ff13390d7b6c1eea5cb57d9 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Fri, 10 Jul 2026 12:43:23 +0100 Subject: [PATCH 11/23] Enhance landmarks_affine function with parallel processing and add comprehensive tests --- src/mesoscopy/register/transform.py | 28 +++++--- tests/test_registration.py | 107 +++++++++++++++++++++++++++- 2 files changed, 124 insertions(+), 11 deletions(-) diff --git a/src/mesoscopy/register/transform.py b/src/mesoscopy/register/transform.py index e3e2fa6..297f29b 100644 --- a/src/mesoscopy/register/transform.py +++ b/src/mesoscopy/register/transform.py @@ -18,7 +18,10 @@ # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR # IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +import os import time +from concurrent.futures import ThreadPoolExecutor +from concurrent.futures import as_completed import click import numpy as np @@ -55,13 +58,20 @@ def landmarks_affine( end = time.time() click.echo(f"Transform estimated in {end - start} s") - warped_ = [] - with click.progressbar(range(deltaf_series.shape[0]), label="Registering recording to template...") as frame_ids: - for idx in frame_ids: - if crop_x > 0 or crop_y > 0: - warped_.append(trf.warp(deltaf_series[idx, :crop_y, :crop_x], tform, order=3)) - else: - warped_.append(trf.warp(deltaf_series[idx, :, :], tform, order=3)) - warped = np.array(warped_) + n_frames = deltaf_series.shape[0] - return warped, tform + def _warp_frame(idx: int) -> np.ndarray: + if crop_x > 0 or crop_y > 0: + return trf.warp(deltaf_series[idx, :crop_y, :crop_x], tform, order=3) + return trf.warp(deltaf_series[idx], tform, order=3) + + results: list[np.ndarray | None] = [None] * n_frames + n_workers = os.cpu_count() or 1 + with click.progressbar(length=n_frames, label="Registering recording to template...") as bar: + with ThreadPoolExecutor(max_workers=n_workers) as executor: + futures = {executor.submit(_warp_frame, i): i for i in range(n_frames)} + for future in as_completed(futures): + results[futures[future]] = future.result() + bar.update(1) + + return np.stack(results), tform diff --git a/tests/test_registration.py b/tests/test_registration.py index e39581a..349d30b 100644 --- a/tests/test_registration.py +++ b/tests/test_registration.py @@ -1,15 +1,118 @@ from importlib import resources import numpy as np +import pytest from click.testing import CliRunner +from skimage import transform as trf import mesoscopy import mesoscopy.register as reg import mesoscopy.resources as res +from mesoscopy.register.transform import landmarks_affine -def test_landmarks_affine(): - """Test affine transform calculation for defined landmarks""" +# --------------------------------------------------------------------------- +# Fixtures +# --------------------------------------------------------------------------- + +@pytest.fixture +def small_series(): + """A small (10, 40, 40) float32 DeltaF/F series with a fixed seed.""" + rng = np.random.default_rng(0) + return rng.random((10, 40, 40), dtype=np.float32) + + +@pytest.fixture +def landmark_pair(): + """Matching recording / template landmark dicts (pure translation: +2 col, +3 row).""" + recording = {"bregma": (10.0, 10.0), "lambda": (30.0, 10.0), "midline": (10.0, 25.0)} + template = {"bregma": (12.0, 13.0), "lambda": (32.0, 13.0), "midline": (12.0, 28.0)} + return recording, template + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- + +def test_landmarks_affine_output_shape(small_series, landmark_pair): + """Warped series must have the same shape as the input.""" + recording_lm, template_lm = landmark_pair + warped, _ = landmarks_affine(small_series, recording_lm, template_lm) + assert warped.shape == small_series.shape + + +def test_landmarks_affine_returns_projective_transform(small_series, landmark_pair): + """Second return value must be a skimage ProjectiveTransform.""" + recording_lm, template_lm = landmark_pair + _, tform = landmarks_affine(small_series, recording_lm, template_lm) + assert isinstance(tform, trf.ProjectiveTransform) + + +def test_landmarks_affine_transform_params(small_series, landmark_pair): + """Returned transform must match the one computed directly from the landmarks.""" + recording_lm, template_lm = landmark_pair + _, tform = landmarks_affine(small_series, recording_lm, template_lm) + + template = np.array(list(template_lm.values()), dtype=np.float32) + recording = np.array(list(recording_lm.values()), dtype=np.float32) + expected_tform = trf.estimate_transform("affine", template, recording) + + np.testing.assert_allclose(tform.params, expected_tform.params, atol=1e-6) + + +def test_landmarks_affine_matches_sequential_reference(small_series, landmark_pair): + """Parallel output must be numerically identical to the sequential per-frame loop.""" + recording_lm, template_lm = landmark_pair + + template = np.array(list(template_lm.values()), dtype=np.float32) + recording = np.array(list(recording_lm.values()), dtype=np.float32) + ref_tform = trf.estimate_transform("affine", template, recording) + reference = np.array([trf.warp(small_series[i], ref_tform, order=3) for i in range(small_series.shape[0])]) + + warped, _ = landmarks_affine(small_series, recording_lm, template_lm) + + np.testing.assert_array_equal(warped, reference) + + +def test_landmarks_affine_crop(landmark_pair): + """With crop_x / crop_y the warped frames should be cropped to those dimensions.""" + rng = np.random.default_rng(1) + series = rng.random((5, 40, 40), dtype=np.float32) + recording_lm, template_lm = landmark_pair + crop_x, crop_y = 30, 25 + + warped, _ = landmarks_affine(series, recording_lm, template_lm, crop_x=crop_x, crop_y=crop_y) + + assert warped.shape == (5, crop_y, crop_x) + + +def test_landmarks_affine_crop_matches_sequential_reference(landmark_pair): + """Cropped parallel output must be identical to the sequential cropped loop.""" + rng = np.random.default_rng(2) + series = rng.random((5, 40, 40), dtype=np.float32) + recording_lm, template_lm = landmark_pair + crop_x, crop_y = 30, 25 + + template = np.array(list(template_lm.values()), dtype=np.float32) + recording = np.array(list(recording_lm.values()), dtype=np.float32) + ref_tform = trf.estimate_transform("affine", template, recording) + reference = np.array([trf.warp(series[i, :crop_y, :crop_x], ref_tform, order=3) for i in range(series.shape[0])]) + + warped, _ = landmarks_affine(series, recording_lm, template_lm, crop_x=crop_x, crop_y=crop_y) + + np.testing.assert_array_equal(warped, reference) + + +def test_landmarks_affine_identity_landmarks(small_series): + """When recording and template landmarks are identical the warp is a near-identity.""" + landmarks = {"A": (5.0, 5.0), "B": (35.0, 5.0), "C": (5.0, 35.0)} + warped, _ = landmarks_affine(small_series, landmarks, landmarks) + + # Interior pixels should be reproduced almost exactly (boundary pixels may differ + # due to the constant-zero padding convention of skimage warp). + interior = small_series[:, 5:-5, 5:-5] + warped_interior = warped[:, 5:-5, 5:-5] + np.testing.assert_allclose(warped_interior, interior, atol=1e-5) def test_load_preprocessed_h5(preproc_h5): From df889aef5569df7dcc20adbd36c79dfeb6ea692a Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Fri, 10 Jul 2026 14:19:19 +0100 Subject: [PATCH 12/23] perf: eagerly load deltaf series into RAM in load_deltaf MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Returning a lazy HDF5 dataset caused per-frame random I/O during parallel warping. With the real-world chunk layout (1407, 5, 9) each frame access required decompressing ~448 chunks from disk, resulting in ~53 min for a 45 000-frame recording. Changes: - load_deltaf: load /F and /timestamps eagerly with [:] and use a context manager so the file is closed immediately after loading - load_deltaf (NWB path): wrap lazy HDMF arrays with np.array() for the same reason - landmarks_affine: add a defensive np.asarray() guard so the function is safe even when a lazy array is passed in directly Measured on a 45 000 × 140 × 142 float32 recording (3.6 GB): before: ~3178 s (lazy I/O × 10 threads fighting HDF5 cache) after: ~14 s (10 s load + 4 s parallel warp) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/mesoscopy/register/__init__.py | 10 +++++----- src/mesoscopy/register/transform.py | 9 ++++++--- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/src/mesoscopy/register/__init__.py b/src/mesoscopy/register/__init__.py index b67d039..c2df169 100644 --- a/src/mesoscopy/register/__init__.py +++ b/src/mesoscopy/register/__init__.py @@ -237,13 +237,13 @@ def load_deltaf(path: str, nwb: bool = False) -> tuple[str, np.ndarray, np.ndarr if nwb: nwbfile = io.read_nwb(path) session_id = nwbfile.identifier - deltaf_series = nwbfile.processing["ophys"]["DeltaFSeries"].data - timestamps = nwbfile.processing["ophys"]["DeltaFSeries"].timestamps + deltaf_series = np.array(nwbfile.processing["ophys"]["DeltaFSeries"].data) + timestamps = np.array(nwbfile.processing["ophys"]["DeltaFSeries"].timestamps) else: session_id = path.split("/")[-1].replace(".h5", "") - f_preproc = h5py.File(path) - deltaf_series = f_preproc["/F"] - timestamps = f_preproc["/timestamps"] + with h5py.File(path, "r") as f_preproc: + deltaf_series = f_preproc["/F"][:] + timestamps = f_preproc["/timestamps"][:] return session_id, deltaf_series, timestamps diff --git a/src/mesoscopy/register/transform.py b/src/mesoscopy/register/transform.py index 297f29b..e1c9800 100644 --- a/src/mesoscopy/register/transform.py +++ b/src/mesoscopy/register/transform.py @@ -43,12 +43,15 @@ def landmarks_affine( template_landmarks (dict): Template landmarks. crop_x (int, optional): Crop x-axis. Defaults to 0. crop_y (int, optional): Crop y-axis. Defaults to 0. - qa_dir (str, optional): Directory to save QA plots. Defaults to "". - session_id (str, optional): Session ID. Defaults to "". Returns: - tuple[np.ndarray, np.ndarray]: Registered DeltaF/F series and affine transformation matrix. + tuple[np.ndarray, trf.ProjectiveTransform]: Registered DeltaF/F series and affine + transformation matrix. """ + if not isinstance(deltaf_series, np.ndarray): + click.echo("Loading imaging data into memory...") + deltaf_series = np.asarray(deltaf_series) + template = np.array(list(template_landmarks.values()), dtype=np.float32) recording = np.array(list(recording_landmarks.values()), dtype=np.float32) From 4a845cd9df856bb68616ea30aca4c12ae8fc298a Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Fri, 10 Jul 2026 14:23:25 +0100 Subject: [PATCH 13/23] merge with statements --- src/mesoscopy/register/transform.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/src/mesoscopy/register/transform.py b/src/mesoscopy/register/transform.py index e1c9800..4b853a5 100644 --- a/src/mesoscopy/register/transform.py +++ b/src/mesoscopy/register/transform.py @@ -68,13 +68,18 @@ def _warp_frame(idx: int) -> np.ndarray: return trf.warp(deltaf_series[idx, :crop_y, :crop_x], tform, order=3) return trf.warp(deltaf_series[idx], tform, order=3) + start = time.time() results: list[np.ndarray | None] = [None] * n_frames n_workers = os.cpu_count() or 1 - with click.progressbar(length=n_frames, label="Registering recording to template...") as bar: - with ThreadPoolExecutor(max_workers=n_workers) as executor: - futures = {executor.submit(_warp_frame, i): i for i in range(n_frames)} - for future in as_completed(futures): - results[futures[future]] = future.result() - bar.update(1) + with ( + click.progressbar(length=n_frames, label="Registering recording to template...") as bar, + ThreadPoolExecutor(max_workers=n_workers) as executor, + ): + futures = {executor.submit(_warp_frame, i): i for i in range(n_frames)} + for future in as_completed(futures): + results[futures[future]] = future.result() + bar.update(1) + end = time.time() + click.echo(f"Recording registered in {end - start} s") return np.stack(results), tform From 00aa21d07a350bb00490538ed87a3c4be997b8ff Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Fri, 10 Jul 2026 15:34:22 +0100 Subject: [PATCH 14/23] refactor: consolidate load_deltaf into io.py Duplicate load_deltaf implementations existed in both mesoscopy.process and mesoscopy.register, with a third caller in mesoscopy.export reaching across into mesoscopy.process. This made it difficult to optimise the loading path in one place and led to subtle behavioural differences between modules (e.g. the process version left the h5py file handle open and did not eagerly load arrays into RAM, while the register version used a context manager and sliced with [:]). Changes: - Add a single canonical load_deltaf(path, nwb=False) to io.py, using the register-style implementation (context manager + eager [:] load) - Remove local load_deltaf definitions from process/__init__.py and register/__init__.py; redirect all call sites to io.load_deltaf() - Update export/__init__.py to call io.load_deltaf() directly, removing the now-unused mesoscopy.process import - Move load_deltaf tests from test_registration.py to test_io.py where all other io function tests live Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/mesoscopy/export/__init__.py | 4 ++-- src/mesoscopy/io.py | 25 +++++++++++++++++++++++++ src/mesoscopy/process/__init__.py | 25 ++----------------------- src/mesoscopy/register/__init__.py | 26 +------------------------- tests/test_io.py | 14 ++++++++++++++ tests/test_registration.py | 14 -------------- 6 files changed, 44 insertions(+), 64 deletions(-) diff --git a/src/mesoscopy/export/__init__.py b/src/mesoscopy/export/__init__.py index 8e0c44e..b506906 100644 --- a/src/mesoscopy/export/__init__.py +++ b/src/mesoscopy/export/__init__.py @@ -28,8 +28,8 @@ import numpy as np import mesoscopy.export.nwb as exp_nwb -import mesoscopy.process as proc +from mesoscopy import io from tqdm import tqdm @@ -97,7 +97,7 @@ def export_deltaf(path: str, out_path: str) -> str: nwb = bool(path.endswith(".nwb")) click.echo("Loading delta F data...") - _, deltaf, _ = proc.load_deltaf(path, nwb) + _, deltaf, _ = io.load_deltaf(path, nwb) # Rescale deltaf to positive integer values between 0 and 255 click.echo("Rescaling delta F for export...") diff --git a/src/mesoscopy/io.py b/src/mesoscopy/io.py index 1449f92..da24476 100644 --- a/src/mesoscopy/io.py +++ b/src/mesoscopy/io.py @@ -23,6 +23,7 @@ from collections import OrderedDict import h5py +import numpy as np import numpy.typing as npt import xmltodict import zarr @@ -142,6 +143,30 @@ def store_interim( return zarr.load(interim_path) +def load_deltaf(path: str, nwb: bool = False) -> tuple[str, np.ndarray, np.ndarray]: + """Load preprocessed dF/F from an HDF5 or NWB file. + + Args: + path (str): Path to the preprocessed file. + nwb (bool, optional): Whether the file is an NWB file. Defaults to False. + + Returns: + tuple[str, np.ndarray, np.ndarray]: Session identifier, dF/F series, and timestamps. + """ + if nwb: + nwbfile = read_nwb(path) + session_id = nwbfile.identifier + deltaf_series = np.array(nwbfile.processing["ophys"]["DeltaFSeries"].data) + timestamps = np.array(nwbfile.processing["ophys"]["DeltaFSeries"].timestamps) + else: + session_id = path.split("/")[-1].replace(".h5", "") + with h5py.File(path, "r") as f: + deltaf_series = f["/F"][:] + timestamps = f["/timestamps"][:] + + return session_id, deltaf_series, timestamps + + def read_points(path: str) -> dict[str, tuple[float, float]]: """Read a landmark points file. diff --git a/src/mesoscopy/process/__init__.py b/src/mesoscopy/process/__init__.py index 913c43d..5378828 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -65,7 +65,7 @@ def smooth_cmd(path: str, out_dir: str, sigma: int = 2) -> None: click.echo(f"Loading preprocessed recording from {path}...") # Determine whether we're working with an NWB file nwb = bool(path.endswith(".nwb")) - session_id, deltaf_series, timestamps = load_deltaf(path, nwb=nwb) + session_id, deltaf_series, timestamps = io.load_deltaf(path, nwb=nwb) outpath = out_dir + os.sep + session_id + "_smoothed.h5" @@ -103,7 +103,7 @@ def zscore_cmd(path: str, out_dir: str) -> None: click.echo(f"Loading preprocessed recording from {path}...") # Determine whether we're working with an NWB file nwb = bool(path.endswith(".nwb")) - session_id, deltaf_series, timestamps = load_deltaf(path, nwb=nwb) + session_id, deltaf_series, timestamps = io.load_deltaf(path, nwb=nwb) h5_outpath = out_dir + os.sep + session_id + "_zscored.h5" with timer.Timer(message="Z-scoring DeltaF/F"): @@ -166,25 +166,4 @@ def regions_cmd(path: str, out_dir: str) -> None: ... -def load_deltaf(path: str, nwb: bool = False) -> tuple[str, np.ndarray, np.ndarray]: - """Load preprocessed deltaf from an HDF5 or NWB file. - Args: - path (str): Path to the preprocessed file. - nwb (bool, optional): Whether the file is an NWB file. Defaults to False. - - Returns: - tuple[str, np.ndarray, np.ndarray]: Session identifier, dF/F series, and timestamps. - """ - if nwb: - nwbfile = io.read_nwb(path) - session_id = nwbfile.identifier - deltaf_series = nwbfile.processing["ophys"]["DeltaFSeries"].data - timestamps = nwbfile.processing["ophys"]["DeltaFSeries"].timestamps - else: - session_id = path.split("/")[-1].replace(".h5", "") - f_preproc = io.read_h5(path) - deltaf_series = f_preproc["/F"] - timestamps = f_preproc["/timestamps"] - - return session_id, np.array(deltaf_series), np.array(timestamps) diff --git a/src/mesoscopy/register/__init__.py b/src/mesoscopy/register/__init__.py index c2df169..e68cbc8 100644 --- a/src/mesoscopy/register/__init__.py +++ b/src/mesoscopy/register/__init__.py @@ -176,7 +176,7 @@ def landmarks_cmd( # Determine whether we're working with an NWB file nwb = True if path.endswith(".nwb") else False - session_id, deltaf_series, timestamps = load_deltaf(path, nwb) + session_id, deltaf_series, timestamps = io.load_deltaf(path, nwb) click.echo("Loading landmarks...") template_landmarks = res.get_default_landmarks() @@ -224,30 +224,6 @@ def landmarks_cmd( return outpath -def load_deltaf(path: str, nwb: bool = False) -> tuple[str, np.ndarray, np.ndarray]: - """Load preprocessed deltaf from an HDF5 or NWB file. - - Args: - path (str): Path to the preprocessed file. - nwb (bool, optional): Whether the file is an NWB file. Defaults to False. - - Returns: - tuple[str, np.ndarray, np.ndarray]: Session identifier, dF/F series, and timestamps. - """ - if nwb: - nwbfile = io.read_nwb(path) - session_id = nwbfile.identifier - deltaf_series = np.array(nwbfile.processing["ophys"]["DeltaFSeries"].data) - timestamps = np.array(nwbfile.processing["ophys"]["DeltaFSeries"].timestamps) - else: - session_id = path.split("/")[-1].replace(".h5", "") - with h5py.File(path, "r") as f_preproc: - deltaf_series = f_preproc["/F"][:] - timestamps = f_preproc["/timestamps"][:] - - return session_id, deltaf_series, timestamps - - def load_maxips(path: str) -> tuple[np.ndarray, np.ndarray]: """Load maximum intensity projections from a preprocessed HDF5 file. diff --git a/tests/test_io.py b/tests/test_io.py index bb4e295..401c30a 100644 --- a/tests/test_io.py +++ b/tests/test_io.py @@ -92,6 +92,20 @@ def test_read_points_unsupported(): io.read_points("unsupported.file") +def test_load_preprocessed_h5(preproc_h5): + session_id, deltaf, ts = io.load_deltaf(preproc_h5) + assert session_id == "preproc" + assert deltaf.shape == (300, 40, 40) + assert ts.shape == (300,) + + +def test_load_preprocessed_nwb(preproc_nwb): + session_id, deltaf, ts = io.load_deltaf(preproc_nwb, nwb=True) + assert session_id == "session_1234" + assert deltaf.shape == (300, 40, 40) + assert ts.shape == (300,) + + def test_write_points_csv(tmp_path): path = tmp_path / "test_points" data = {"testArea": [0, 200], "anotherTestArea": [250, 20]} diff --git a/tests/test_registration.py b/tests/test_registration.py index 349d30b..dfd243a 100644 --- a/tests/test_registration.py +++ b/tests/test_registration.py @@ -115,20 +115,6 @@ def test_landmarks_affine_identity_landmarks(small_series): np.testing.assert_allclose(warped_interior, interior, atol=1e-5) -def test_load_preprocessed_h5(preproc_h5): - session_id, deltaf, ts = reg.load_deltaf(preproc_h5) - assert session_id == "preproc" - assert deltaf.shape == (300, 40, 40) - assert ts.shape == (300,) - - -def test_load_preprocessed_nwb(preproc_nwb): - session_id, deltaf, ts = reg.load_deltaf(preproc_nwb, nwb=True) - assert session_id == "session_1234" - assert deltaf.shape == (300, 40, 40) - assert ts.shape == (300,) - - def test_update_nwb(nwbfile, preproc_h5): tform_mock = np.array([[(1, 2, 3), (1, 2, 4)]]) nwb = reg.update_nwb(nwbfile, preproc_h5, tform_mock) From ef605757023593a26f4cfec25ab785f4c344c60d Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Fri, 10 Jul 2026 15:38:55 +0100 Subject: [PATCH 15/23] Parallelise extract_all_regions() with ThreadPoolExecutor - Load atlas and annotations once upfront instead of once per region call - Use ThreadPoolExecutor to process all regions concurrently; NumPy releases the GIL during masked-array operations so threads run in parallel without serialising the large deltaf_series array - Fix mutation of module-level DEFAULT_EXCLUDE list: copy it with list() before extending with caller-supplied excludes - Fix region filter to use the computed excluded_regions set instead of the hard-coded DEFAULT_EXCLUDE constant Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/mesoscopy/process/region.py | 38 ++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 15 deletions(-) diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py index 33e905f..decb0e8 100644 --- a/src/mesoscopy/process/region.py +++ b/src/mesoscopy/process/region.py @@ -19,12 +19,13 @@ # IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. +from concurrent.futures import ThreadPoolExecutor +from typing import Literal + import numpy as np import numpy.typing as npt -import pandas as pd -from typing import Literal -from mesoscopy import resources +from mesoscopy import resources DEFAULT_EXCLUDE = [ "FRP1", @@ -70,25 +71,32 @@ def extract_all_regions( deltaf_series: npt.NDArray, exclude: list | None = None, ignore_default_exclude: bool = False ) -> dict: annotations = resources.get_atlas_annotations() + left_aba, right_aba = resources.get_atlas() if exclude is None: exclude = [] - excluded_regions = DEFAULT_EXCLUDE if not ignore_default_exclude else [] + excluded_regions = list(DEFAULT_EXCLUDE) if not ignore_default_exclude else [] excluded_regions.extend(exclude) - regions = [region for region in annotations.acronym.unique() if region not in DEFAULT_EXCLUDE] + regions = [region for region in annotations.acronym.unique() if region not in excluded_regions] - region_activity = {} + region_ids = { + region: annotations.loc[annotations["acronym"] == region, "id"].values[0] + for region in regions + } - for region in regions: - region_left_hemisphere = f"L_{region}" - region_right_hemisphere = f"R_{region}" + def _process_region(region: str) -> tuple[str, npt.NDArray, str, npt.NDArray]: + region_id = region_ids[region] + left_mask = np.broadcast_to(left_aba == region_id, deltaf_series.shape) + right_mask = np.broadcast_to(right_aba == region_id, deltaf_series.shape) + left_activity = np.ma.array(deltaf_series, mask=~left_mask).mean(axis=(1, 2)) + right_activity = np.ma.array(deltaf_series, mask=~right_mask).mean(axis=(1, 2)) + return f"L_{region}", left_activity, f"R_{region}", right_activity - region_activity[region_left_hemisphere] = extract_region_activity( - deltaf_series=deltaf_series, region_acronym=region, hemisphere="left" - ) - region_activity[region_right_hemisphere] = extract_region_activity( - deltaf_series=deltaf_series, region_acronym=region, hemisphere="right" - ) + region_activity = {} + with ThreadPoolExecutor() as executor: + for l_key, l_activity, r_key, r_activity in executor.map(_process_region, regions): + region_activity[l_key] = l_activity + region_activity[r_key] = r_activity return region_activity From 0435daeef55a212161d5a00f106d93aa22fba3dc Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Fri, 10 Jul 2026 15:44:49 +0100 Subject: [PATCH 16/23] Add tests for process.region module MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 19 tests across two classes covering extract_region_activity and extract_all_regions. Resources are mocked with a minimal synthetic 6×6 atlas (three regions, including one from DEFAULT_EXCLUDE) so tests run without file I/O and stay deterministic. TestExtractRegionActivity: - Output shape for left / right / both hemispheres - Output values verified against manual mask means - Hemisphere argument is case-insensitive - Invalid hemisphere raises ValueError - Different regions yield different signals TestExtractAllRegions: - Returns dict with L_/R_-prefixed keys - Each value has shape (n_frames,) - DEFAULT_EXCLUDE regions absent by default - ignore_default_exclude=True re-includes them - Custom exclude list removes specified regions - Custom exclude is additive with DEFAULT_EXCLUDE - DEFAULT_EXCLUDE is not mutated by repeated calls - Results are numerically consistent with extract_region_activity Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- tests/test_region.py | 227 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 tests/test_region.py diff --git a/tests/test_region.py b/tests/test_region.py new file mode 100644 index 0000000..d06814d --- /dev/null +++ b/tests/test_region.py @@ -0,0 +1,227 @@ +from unittest.mock import patch + +import numpy as np +import pandas as pd +import pytest + +from mesoscopy.process.region import DEFAULT_EXCLUDE, extract_all_regions, extract_region_activity + +# --------------------------------------------------------------------------- +# Fixtures +# --------------------------------------------------------------------------- + +# Mock atlas layout (6×6): +# Columns 0-2 are the "left" hemisphere; columns 3-5 are zero. +# right_aba = np.flip(left_aba, axis=1), so regions appear in columns 3-5 +# of the right atlas, mirroring the left — no pixel is non-zero in both. +# +# left_aba rows: +# 0-1, col 0-2 → region id=1 (REG1) +# 2-3, col 0-2 → region id=2 (REG2) +# 4-5, col 0-2 → region id=3 (FRP1, present in DEFAULT_EXCLUDE) + +_ATLAS_H, _ATLAS_W = 6, 6 +_N_FRAMES = 10 + + +@pytest.fixture(scope="module") +def mock_left_aba(): + aba = np.zeros((_ATLAS_H, _ATLAS_W), dtype=np.uint16) + aba[0:2, 0:3] = 1 + aba[2:4, 0:3] = 2 + aba[4:6, 0:3] = 3 + return aba + + +@pytest.fixture(scope="module") +def mock_right_aba(mock_left_aba): + return np.flip(mock_left_aba, axis=1).copy() + + +@pytest.fixture(scope="module") +def mock_annotations(): + return pd.DataFrame({"id": [1, 2, 3], "acronym": ["REG1", "REG2", "FRP1"]}) + + +@pytest.fixture(scope="module") +def deltaf_series(): + rng = np.random.default_rng(0) + return rng.random((_N_FRAMES, _ATLAS_H, _ATLAS_W)) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def _patch_resources(left_aba, right_aba, annotations): + """Return a context manager that patches both resource loaders.""" + return ( + patch("mesoscopy.resources.get_atlas", return_value=(left_aba, right_aba)), + patch("mesoscopy.resources.get_atlas_annotations", return_value=annotations), + ) + + +# --------------------------------------------------------------------------- +# extract_region_activity +# --------------------------------------------------------------------------- + + +class TestExtractRegionActivity: + def test_left_hemisphere_shape(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_region_activity(deltaf_series, "REG1", "left") + assert result.shape == (_N_FRAMES,) + + def test_right_hemisphere_shape(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_region_activity(deltaf_series, "REG1", "right") + assert result.shape == (_N_FRAMES,) + + def test_both_hemispheres_shape(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_region_activity(deltaf_series, "REG1", "both") + assert result.shape == (_N_FRAMES,) + + def test_left_hemisphere_values(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + # Region 1 occupies rows 0-1, cols 0-2 in the left atlas. + expected = deltaf_series[:, 0:2, 0:3].mean(axis=(1, 2)) + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_region_activity(deltaf_series, "REG1", "left") + np.testing.assert_allclose(result, expected) + + def test_right_hemisphere_values(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + # right_aba = flip(left_aba): region 1 lands in rows 0-1, cols 3-5. + expected = deltaf_series[:, 0:2, 3:6].mean(axis=(1, 2)) + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_region_activity(deltaf_series, "REG1", "right") + np.testing.assert_allclose(result, expected) + + def test_both_hemispheres_values(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + # left + right: region 1 covers rows 0-1 across all 6 columns. + expected = deltaf_series[:, 0:2, :].mean(axis=(1, 2)) + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_region_activity(deltaf_series, "REG1", "both") + np.testing.assert_allclose(result, expected) + + def test_different_regions_produce_different_results( + self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series + ): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + reg1 = extract_region_activity(deltaf_series, "REG1", "left") + reg2 = extract_region_activity(deltaf_series, "REG2", "left") + assert not np.allclose(reg1, reg2), "Different regions should produce different activity signals" + + def test_invalid_hemisphere_raises(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + with pytest.raises(ValueError, match="hemisphere"): + extract_region_activity(deltaf_series, "REG1", "bilateral") + + def test_hemisphere_argument_case_insensitive( + self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series + ): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + lower = extract_region_activity(deltaf_series, "REG1", "left") + upper = extract_region_activity(deltaf_series, "REG1", "LEFT") + np.testing.assert_allclose(lower, upper) + + +# --------------------------------------------------------------------------- +# extract_all_regions +# --------------------------------------------------------------------------- + + +class TestExtractAllRegions: + def test_returns_dict(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series) + assert isinstance(result, dict) + + def test_keys_have_hemisphere_prefix(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series) + for key in result: + assert key.startswith("L_") or key.startswith("R_"), f"Unexpected key format: {key}" + + def test_both_hemispheres_present_for_each_region( + self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series + ): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series) + for region in ("REG1", "REG2"): + assert f"L_{region}" in result + assert f"R_{region}" in result + + def test_values_have_correct_shape(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series) + for key, value in result.items(): + assert value.shape == (_N_FRAMES,), f"Wrong shape for {key}: {value.shape}" + + def test_default_exclude_filters_regions(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + # FRP1 is in DEFAULT_EXCLUDE; it should be absent from the result. + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series) + assert "L_FRP1" not in result + assert "R_FRP1" not in result + + def test_ignore_default_exclude_includes_all_regions( + self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series + ): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series, ignore_default_exclude=True) + assert "L_FRP1" in result + assert "R_FRP1" in result + + def test_custom_exclude_removes_region(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series, exclude=["REG1"]) + assert "L_REG1" not in result + assert "R_REG1" not in result + assert "L_REG2" in result + assert "R_REG2" in result + + def test_custom_exclude_combined_with_default( + self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series + ): + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + result = extract_all_regions(deltaf_series, exclude=["REG1"]) + assert "L_FRP1" not in result + assert "L_REG1" not in result + assert "L_REG2" in result + + def test_does_not_mutate_default_exclude(self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series): + original = list(DEFAULT_EXCLUDE) + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + extract_all_regions(deltaf_series, exclude=["REG1"]) + assert DEFAULT_EXCLUDE == original, "extract_all_regions must not mutate DEFAULT_EXCLUDE" + + def test_values_match_extract_region_activity( + self, mock_left_aba, mock_right_aba, mock_annotations, deltaf_series + ): + """extract_all_regions results should match extract_region_activity for each region.""" + with patch("mesoscopy.resources.get_atlas", return_value=(mock_left_aba, mock_right_aba)), \ + patch("mesoscopy.resources.get_atlas_annotations", return_value=mock_annotations): + all_regions = extract_all_regions(deltaf_series, ignore_default_exclude=True) + single_left = extract_region_activity(deltaf_series, "REG2", "left") + single_right = extract_region_activity(deltaf_series, "REG2", "right") + np.testing.assert_allclose(all_regions["L_REG2"], single_left) + np.testing.assert_allclose(all_regions["R_REG2"], single_right) From 2171aaacf6f61c1cc6777177e3e4002a1ec6d279 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Sat, 11 Jul 2026 19:13:32 +0100 Subject: [PATCH 17/23] add option to return activity from all regions as df, add docstrings --- src/mesoscopy/process/region.py | 45 ++++++++++++++++++++++++++++----- 1 file changed, 39 insertions(+), 6 deletions(-) diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py index decb0e8..fc03192 100644 --- a/src/mesoscopy/process/region.py +++ b/src/mesoscopy/process/region.py @@ -24,6 +24,7 @@ import numpy as np import numpy.typing as npt +import pandas as pd from mesoscopy import resources @@ -44,6 +45,22 @@ def extract_region_activity( deltaf_series: npt.NDArray, region_acronym: str, hemisphere: Literal["left", "right", "both"] ) -> npt.NDArray: + """Extracts the mean ∆F/F signal of a specific cortical region in the Allen Brain Atlas from a registered recording. + + Args: + deltaf_series (npt.NDArray): A 3D array of shape (time, height, width) representing the DeltaF/F signal. + Should be registered to the Allen Brain Atlas. + region_acronym (str): The acronym of the cortical region to extract (e.g., 'VISp', 'MOp etc.). + hemisphere (Literal["left", "right", "both"]): The hemisphere to extract the activity from. + Options are 'left', 'right', or 'both'. + + Returns: + npt.NDArray: A 1D array of shape (time,) representing the mean ∆F/F signal of the specified cortical + region over time. + + Raises: + ValueError: If the specified region acronym is not recognized or if the hemisphere option is invalid. + """ annotations = resources.get_atlas_annotations() region_id = annotations.loc[annotations["acronym"] == region_acronym, "id"].values[0] @@ -68,8 +85,23 @@ def extract_region_activity( def extract_all_regions( - deltaf_series: npt.NDArray, exclude: list | None = None, ignore_default_exclude: bool = False -) -> dict: + deltaf_series: npt.NDArray, + exclude: list | None = None, + ignore_default_exclude: bool = False, + as_dataframe: bool = False, +) -> dict | pd.DataFrame: + """Extracts the mean ∆F/F signal of all cortical regions in the Allen Brain Atlas from a registered recording. + + Args: + deltaf_series (npt.NDArray): A 3D array of shape (time, height, width) representing the DeltaF/F signal. + exclude (list, optional): A list of region acronyms to exclude from the extraction. Defaults to None. + ignore_default_exclude (bool, optional): If True, ignores the default excluded regions. Defaults to False. + as_dataframe (bool, optional): If True, returns the result as a pandas DataFrame. Defaults to False. + + Returns: + dict | pd.DataFrame: A dictionary with region acronyms as keys and their mean activity as values, + or a DataFrame with columns 'region', 'time_idx', and 'F'. + """ annotations = resources.get_atlas_annotations() left_aba, right_aba = resources.get_atlas() @@ -80,10 +112,7 @@ def extract_all_regions( excluded_regions.extend(exclude) regions = [region for region in annotations.acronym.unique() if region not in excluded_regions] - region_ids = { - region: annotations.loc[annotations["acronym"] == region, "id"].values[0] - for region in regions - } + region_ids = {region: annotations.loc[annotations["acronym"] == region, "id"].values[0] for region in regions} def _process_region(region: str) -> tuple[str, npt.NDArray, str, npt.NDArray]: region_id = region_ids[region] @@ -99,4 +128,8 @@ def _process_region(region: str) -> tuple[str, npt.NDArray, str, npt.NDArray]: region_activity[l_key] = l_activity region_activity[r_key] = r_activity + if as_dataframe: + df = pd.DataFrame(region_activity) + return df.unstack().reset_index().rename(columns={"level_0": "region", "level_1": "time_idx", 0: "F"}) + return region_activity From b5248585a2bc8c5f17e705523721403a55e46d9e Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Sat, 11 Jul 2026 19:14:05 +0100 Subject: [PATCH 18/23] add regions command --- src/mesoscopy/process/__init__.py | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/src/mesoscopy/process/__init__.py b/src/mesoscopy/process/__init__.py index 5378828..b9e4720 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -22,11 +22,13 @@ """Processing submodule.""" import os +from pathlib import Path import click -import numpy as np +import pandas as pd from pynwb.image import ImageSeries +import mesoscopy.process.region as pr import mesoscopy.process.smooth as psm import mesoscopy.process.zscore as pzs from mesoscopy import io @@ -60,7 +62,7 @@ def smooth_cmd(path: str, out_dir: str, sigma: int = 2) -> None: """Generate a smoothed DeltaF/F recording using a Laplace of Gaussian filter.""" if not os.path.exists(out_dir): click.echo(f"Creating output directory {out_dir}...") - os.makedirs(out_dir) + Path(out_dir).mkdir(parents=True) click.echo(f"Loading preprocessed recording from {path}...") # Determine whether we're working with an NWB file @@ -96,9 +98,9 @@ def smooth_cmd(path: str, out_dir: str, sigma: int = 2) -> None: ) def zscore_cmd(path: str, out_dir: str) -> None: """Pixel-wise z-score ∆F/F signal.""" - if not os.path.exists(out_dir): + if not Path(out_dir).exists(): click.echo(f"Creating output directory {out_dir}...") - os.makedirs(out_dir) + Path(out_dir).mkdir(parents=True) click.echo(f"Loading preprocessed recording from {path}...") # Determine whether we're working with an NWB file @@ -163,7 +165,21 @@ def regions_cmd(path: str, out_dir: str) -> None: path (str): Path to registered HDF5 recording or NWB file. out_dir (str): Path to output directory. """ - ... + if not Path(out_dir).exists(): + click.echo(f"Creating output directory {out_dir}...") + Path(out_dir).mkdir(parents=True) + + click.echo(f"Loading preprocessed recording from {path}...") + # Determine whether we're working with an NWB file + nwb = bool(path.endswith(".nwb")) + session_id, deltaf_series, timestamps = io.load_deltaf(path, nwb=nwb) + outpath = out_dir + os.sep + session_id + "_regions.csv" + with timer.Timer(message="Extracting region activity"): + region_activity = pd.DataFrame(pr.extract_all_regions(deltaf_series, as_dataframe=True)) + region_activity["time_idx"] = timestamps[region_activity["time_idx"]] + region_activity.rename(columns={"time_idx": "timestamps"}, inplace=True) + region_activity.to_csv(outpath, index=False) + click.echo(f"Saved region activity at {outpath}") From c0ea1bd2e42fb96d6fcbc2e33c6a4f79746f25c1 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Sat, 11 Jul 2026 19:14:15 +0100 Subject: [PATCH 19/23] play around with dataframe return --- exploratory/array-masking.ipynb | 477 +++++++++++++++++++------------- 1 file changed, 292 insertions(+), 185 deletions(-) diff --git a/exploratory/array-masking.ipynb b/exploratory/array-masking.ipynb index d253398..5786102 100644 --- a/exploratory/array-masking.ipynb +++ b/exploratory/array-masking.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "81105d50", "metadata": {}, "outputs": [], @@ -16,17 +16,18 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "98430049", "metadata": {}, "outputs": [], "source": [ - "f = io.read_h5(\"../scratch/sub-test_exp-testexp_meso_date-2025-05-20T14_42_39_preprocessed_registered.h5\")" + "# f = io.read_h5(\"../scratch/sub-test_exp-testexp_meso_date-2025-05-20T14_42_39_preprocessed_registered.h5\")\n", + "f = io.read_h5(\"../scratch/sub-TT712_exp-10hrb25ce_meso_date-2025-05-15T16_29_37_preprocessed_registered.h5\")" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "17ba4891", "metadata": {}, "outputs": [], @@ -36,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "9fc92035", "metadata": {}, "outputs": [ @@ -52,7 +53,7 @@ " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16)" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -63,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "f54c9a78", "metadata": {}, "outputs": [ @@ -173,7 +174,7 @@ " dtype=float32)" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -186,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "994f3a73", "metadata": {}, "outputs": [ @@ -456,7 +457,7 @@ "32 1228 VISrl1 Rostrolateral area" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -468,7 +469,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "9ed0211d", "metadata": {}, "outputs": [ @@ -478,7 +479,7 @@ "np.int64(1214)" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -489,17 +490,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "b7e9f585", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, @@ -520,23 +521,23 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "8b19388f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -551,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "2dbdd594", "metadata": {}, "outputs": [ @@ -566,7 +567,7 @@ " dtype=object)" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -577,256 +578,256 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "f8f15224", "metadata": {}, "outputs": [], "source": [ - "region_activity = region.extract_all_regions(deltaf_series=f[\"F\"])" + "region_activity = region.extract_all_regions(deltaf_series=f[\"F\"][1000:3000])" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "d85dd3a5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'L_SSp-ul': masked_array(data=[-0.014033851213753223, -0.0023055514320731163,\n", - " -0.0046494812704622746, ..., -0.005773003213107586,\n", - " -0.006918411236256361, 0.003909487742930651],\n", + "{'L_SSp-ul': masked_array(data=[0.006696587894111872, 0.004767163656651974,\n", + " 0.000791934784501791, ..., -0.0030872286297380924,\n", + " -0.0025738729164004326, -0.008355200290679932],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-ul': masked_array(data=[0.0011805910617113113, -0.004940943326801062,\n", - " -0.004747333005070686, ..., 0.005206792615354061,\n", - " -0.003380958689376712, -0.002345480490475893],\n", + " 'R_SSp-ul': masked_array(data=[0.013162602670490742, 0.0022261962294578552,\n", + " 0.005490864161401987, ..., -0.004024984780699015,\n", + " 0.006603638641536236, -0.005593894515186548],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_MOp1': masked_array(data=[0.0012087095742938161, 0.006479873511069579,\n", - " 0.004268450755269135, ..., -0.002622898511046194,\n", - " -0.004218819497645587, -0.0018279879029226486],\n", + " 'L_MOp1': masked_array(data=[0.0050218402197534555, 0.001145734526645178,\n", + " 0.003507521874146443, ..., -0.01002270965283858,\n", + " -0.010019475016100654, -0.011747975002303434],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_MOp1': masked_array(data=[-1.5095275937369044e-07, 0.0031936260018768895,\n", - " 0.0022690168285735266, ..., -0.004278725591199151,\n", - " -0.008189782328989315, -0.0057176269333938075],\n", + " 'R_MOp1': masked_array(data=[0.0036452446860828617, -0.00014634127817848177,\n", + " 0.0036914677455507474, ..., -0.0029782239504700875,\n", + " -0.004199888514376235, -0.004142787721421983],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_MOs': masked_array(data=[-0.00733040180244676, -0.001921274772352376,\n", - " -0.005639809238119144, ..., 0.0010045917940811372,\n", - " -0.00289904327699596, -0.001076304097050872],\n", + " 'L_MOs': masked_array(data=[0.00786832928417674, 0.00461303300301074,\n", + " 0.0074767586690799095, ..., -0.006106210186687754,\n", + " -0.005086347130942393, -0.008034864421821455],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_MOs': masked_array(data=[-0.007620688655246911, -0.003428645776790872,\n", - " -0.008854721153765857, ..., -4.159120966491085e-05,\n", - " -0.0014319851604745661, 0.00013330740707980795],\n", + " 'R_MOs': masked_array(data=[0.007445970531440597, 0.0062615938589606485,\n", + " 0.005647438152934944, ..., -0.002440089910802707,\n", + " -0.00446843333407427, -0.0054458732336339815],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_PL1': masked_array(data=[-0.013283089399337769, -0.0026014751195907594,\n", - " -0.0014095172286033631, ..., 0.0026571032404899596,\n", - " -0.004158598184585571, -0.002931191623210907],\n", + " 'L_PL1': masked_array(data=[0.002847793996334076, 0.004953921735286713,\n", + " 0.002891952693462372, ..., -0.0028355053067207338,\n", + " -0.002338845282793045, -0.003907392621040344],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_PL1': masked_array(data=[0.007158556580543518, -0.009701893329620362,\n", - " 0.002825324237346649, ..., 0.003142477571964264,\n", - " -0.003895668983459473, -0.0009304802119731903],\n", + " 'R_PL1': masked_array(data=[0.00218205064535141, 0.005880986452102661,\n", + " 0.002079216241836548, ..., 0.0007182970643043518,\n", + " -0.0060173416137695316, 0.0027856674790382387],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_RSPagl1': masked_array(data=[-0.010232141898380771, -0.0069485798910940335,\n", - " -0.0089195912309702, ..., 0.007900469036023152,\n", - " 0.008165491072468738, 0.00837478993839248],\n", + " 'L_RSPagl1': masked_array(data=[0.0018613932043684963, 0.002880446396428025,\n", + " 0.00938245963258862, ..., 0.005628174765970697,\n", + " 0.0014170091676514178, 0.0039953032964492735],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_RSPagl1': masked_array(data=[-0.01352551567109294, -0.01164242142958265,\n", - " -0.01248257981296397, ..., 0.008677239239957817,\n", - " 0.008264492161541064, 0.007455593322817221],\n", + " 'R_RSPagl1': masked_array(data=[0.006866576760636326, 0.007833883970110249,\n", + " 0.010447004524009356, ..., 0.0038898641637746725,\n", + " -6.448658360979864e-05, 0.002557977106561305],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_RSPd1': masked_array(data=[-0.015534882655229105, -0.011418075512742142,\n", - " -0.013885254140400215, ..., 0.010264690574782584,\n", - " 0.00804251539127906, 0.00972024376130165],\n", + " 'L_RSPd1': masked_array(data=[0.013155848168960923, 0.008417858796961167,\n", + " 0.013607871501951876, ..., -0.00343281930060033,\n", + " -0.005107631463833782, -0.002966613720749955],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_RSPd1': masked_array(data=[-0.016762855412710047, -0.01376889855660441,\n", - " -0.01858871367276477, ..., 0.0088568221577598,\n", - " 0.005692363699988636, 0.0067583099960366174],\n", + " 'R_RSPd1': masked_array(data=[0.014070387691488046, 0.013722280712078904,\n", + " 0.012663175382882433, ..., -0.0022670754691219088,\n", + " -0.004134087306459236, -0.001927944400426372],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_RSPv1': masked_array(data=[-0.020429519812266032, -0.011243644025590685,\n", - " -0.01216142839855618, ..., 0.010765853855344985,\n", - " 0.0012375758753882513, 0.007058852248721653],\n", + " 'L_RSPv1': masked_array(data=[0.02674778832329644, 0.021112570497724744,\n", + " 0.019511765903896756, ..., -0.009468673335181341,\n", + " -0.004021110799577501, -0.010588402218288846],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_RSPv1': masked_array(data=[-0.016519489553239612, -0.012696713871426053,\n", - " -0.02089816199408637, ..., 0.004538283745447794,\n", - " 0.008982977602216932, 0.008620958195792304],\n", + " 'R_RSPv1': masked_array(data=[0.013735389709472657, 0.014315089914533827,\n", + " 0.012569371859232585, ..., -0.011222957240210638,\n", + " -0.004187974002626207, -0.0052236378192901615],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-bfd1': masked_array(data=[-0.006667985795419428, -0.003577950634533846,\n", - " -0.005047343350663969, ..., 0.0013130245329458503,\n", - " -0.0005661271040952659, 0.002028020575076719],\n", + " 'L_SSp-bfd1': masked_array(data=[0.0022085684764234326, -0.0007141919075688229,\n", + " 0.002894404870045336, ..., -0.003942482984518703,\n", + " -0.004735360266287116, -0.0034993090207063697],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-bfd1': masked_array(data=[-0.00415083547181721, -0.0013469996331613276,\n", - " -0.004490166072604022, ..., 0.00036313839351074606,\n", - " -0.004657121247883084, -0.0026040873950040795],\n", + " 'R_SSp-bfd1': masked_array(data=[0.0021063895165165766, 0.00010763793429241905,\n", + " 0.0028459473501277876, ..., -0.0037774955170064035,\n", + " -0.005944866470143765, -0.00546892987021917],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-ll1': masked_array(data=[-0.012672511687189896, -0.009397166856327412,\n", - " -0.007719593018478488, ..., 0.005676626048473098,\n", - " 0.00489550014460309, 0.006683493993297126],\n", + " 'L_SSp-ll1': masked_array(data=[0.010601229549194714, 0.006583635111032806,\n", + " 0.01323762295409019, ..., -0.0004464865934034312,\n", + " -0.005259468318512721, -0.003293601252277445],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-ll1': masked_array(data=[-0.011901273490479274, -0.00554644469148624,\n", - " -0.008366665484742348, ..., 0.00016224449095518693,\n", - " 0.0016499422721981262, 0.001873460800751396],\n", + " 'R_SSp-ll1': masked_array(data=[0.0031886811582198054, -0.0006305095016586114,\n", + " 0.006732764451400093, ..., 0.009348689399150588,\n", + " 0.006156361991574305, 0.005605281880183249],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-m1': masked_array(data=[0.00047472450468275283, 0.0024304898700328787,\n", - " 0.002209042509396871, ..., -0.000509012829173695,\n", - " -0.0003187851698109598, -0.00020478108916619812],\n", + " 'L_SSp-m1': masked_array(data=[0.0008323126369052463, -0.0016357721102358115,\n", + " 0.0004995562361948417, ..., -0.00041494631406032676,\n", + " 0.00021038232653430015, -0.0011241143249502085],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-m1': masked_array(data=[0.0033452161634811247, 0.005282972196135858,\n", - " 0.005225563290143254, ..., -0.005994234422240594,\n", - " -0.006220980726107202, -0.0006650918812462778],\n", + " 'R_SSp-m1': masked_array(data=[-0.002335519953207536, -0.0012704666816827023,\n", + " -0.0005465211591335258, ..., -0.0029362777266839536,\n", + " -0.005832238630814986, -0.004991739687293467],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-n1': masked_array(data=[-0.005448756795940977, -0.0023389269005168567,\n", - " -0.003903671647563125, ..., 8.024592799219218e-05,\n", - " -0.003073453451647903, -0.0002346154528133797],\n", + " 'L_SSp-n1': masked_array(data=[0.00048123898379730457, 0.0019097544930197976,\n", + " 0.0023650612794991694, ..., -0.0023159009940696487,\n", + " -0.00252583103649544, -0.0015271231532096863],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-n1': masked_array(data=[-0.0010106705806472085, 0.0007491691433119051,\n", - " -0.0006256030138694879, ..., -0.0019599178975278683,\n", - " -0.004140827240365924, -0.004861467715465661],\n", + " 'R_SSp-n1': masked_array(data=[4.428656150897344e-05, 0.0021907443350011654,\n", + " -0.0006019595558896209, ..., -0.004376297647302801,\n", + " -0.006044872782447122, -0.005067888534430302],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-tr1': masked_array(data=[-0.004366690635681152, -0.00216253662109375,\n", - " -0.0014669373035430908, ..., -0.0010107845067977906,\n", - " 0.003070756673812866, -0.003410844087600708],\n", + " 'L_SSp-tr1': masked_array(data=[-0.0006525291800498962, -0.004639388084411621,\n", + " 0.001452468752861023, ..., 0.015282602310180663,\n", + " 0.009521465301513671, 0.013134696006774903],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-tr1': masked_array(data=[-0.008656573295593262, -0.008858576774597168,\n", - " -0.007676359176635742, ..., 0.002116822004318237,\n", - " 0.0009880146980285644, 0.0019443566799163818],\n", + " 'R_SSp-tr1': masked_array(data=[-0.000349889874458313, 0.0018099465370178223,\n", + " 0.005910438537597656, ..., 0.010716154098510742,\n", + " 0.0062520489692687985, 0.009864056587219238],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-ul1': masked_array(data=[-0.0037868186484935674, -0.004994455603666083,\n", - " -0.0037989181141520655, ..., -5.595767220785452e-05,\n", - " -0.00029643801755683364, 0.0012969826543053915],\n", + " 'L_SSp-ul1': masked_array(data=[0.006061434191326763, 0.003059322334999262,\n", + " 0.006487583559612895, ..., 0.0005366382903830949,\n", + " -0.0013534360153730526, -0.0026617305223331895],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-ul1': masked_array(data=[-0.006430195653161337, -0.00391713491705961,\n", - " -0.002780574421549952, ..., -0.002825222181719403,\n", - " -0.002140893076741418, 0.0025443961453992265],\n", + " 'R_SSp-ul1': masked_array(data=[0.004018897788469182, 0.0009896233331325441,\n", + " 0.0035402669463046764, ..., 0.0026145632876906286,\n", + " -0.003010738173196482, -0.0011037923568903013],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSp-un1': masked_array(data=[-0.00618749737739563, -0.008935513496398926,\n", - " -0.00472840428352356, ..., 0.004623570044835408,\n", - " 0.0038045565287272137, 0.003594652016957601],\n", + " 'L_SSp-un1': masked_array(data=[0.004698699712753296, 0.0005391236146291097,\n", + " 0.008289636770884196, ..., 0.004381097157796224,\n", + " 0.0026112860441207886, 0.00046531428893407186],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSp-un1': masked_array(data=[-0.01187420129776001, -0.008354594707489013,\n", - " -0.0066703502337137855, ..., -0.002582803169886271,\n", - " -0.001995809078216553, -0.0013482200105985006],\n", + " 'R_SSp-un1': masked_array(data=[0.0029144752025604247, 0.0022106417020161945,\n", + " 0.005435750881830851, ..., -0.005554901758829753,\n", + " -0.006219976345698039, -0.0065692770481109615],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_SSs1': masked_array(data=[-0.0030905187129974367, 0.0006831234693527222,\n", - " -0.001949998289346695, ..., 0.0018264533579349519,\n", - " 0.0027165967226028443, -0.0007010949403047561],\n", + " 'L_SSs1': masked_array(data=[0.0004947913438081742, 0.005641902685165405,\n", + " 0.0024328891932964324, ..., -0.0012647943198680878,\n", + " -0.002842405438423157, -0.00038309238851070405],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_SSs1': masked_array(data=[-0.0049105587601661685, 0.0010619950294494629,\n", - " -0.00260578989982605, ..., 0.0014483129978179932,\n", - " -0.003213001191616058, -9.74537618458271e-05],\n", + " 'R_SSs1': masked_array(data=[-0.0006135556101799011, -0.0032475340366363526,\n", + " 0.0037855321168899538, ..., -0.002162401229143143,\n", + " -0.004407351911067963, -0.0068241870403289795],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISal1': masked_array(data=[-0.005778278623308454, -0.003376559132621402,\n", - " -0.00968535930391342, ..., 0.0022552599982609825,\n", - " 0.0003062347098002358, 0.0014914984977434551],\n", + " 'L_VISal1': masked_array(data=[0.01040828511828468, 0.00521157563678802,\n", + " 0.007247358087509397, ..., -0.00692363769289047,\n", + " -0.009088927791232155, -0.007418360975053575],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISal1': masked_array(data=[-0.008624708841717432, -0.007961061265733507,\n", - " -0.010375697461385575, ..., 0.005581533625012352,\n", - " -0.0046790071896144324, 0.0029413004716237388],\n", + " 'R_VISal1': masked_array(data=[0.004782114710126605, 0.0046408214266338045,\n", + " 0.0070985546187748985, ..., -0.005551789015058487,\n", + " -0.00809640922243633, -0.01037889245956663],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISam1': masked_array(data=[-0.002600082941353321, -0.006421634554862976,\n", - " -0.005055435374379158, ..., 0.00020793676376342773,\n", - " 0.0006793882232159377, 6.797346286475658e-05],\n", + " 'L_VISam1': masked_array(data=[-0.002230653166770935, -0.0026926979422569274,\n", + " 0.0023358769714832304, ..., 0.015594550967216491,\n", + " 0.011436781287193299, 0.01439841091632843],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISam1': masked_array(data=[-0.0020380256697535514, -0.007694423198699951,\n", - " -0.003579515591263771, ..., 0.00019545331597328185,\n", - " 0.0031532064080238343, 0.0023261621594429017],\n", + " 'R_VISam1': masked_array(data=[-0.00028857141733169557, -0.004304191842675209,\n", + " 2.927570603787899e-05, ..., 0.008126115798950196,\n", + " 0.006545652449131012, 0.006843777000904083],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISC1': masked_array(data=[0.03378681341807047, -0.00606775904695193,\n", - " 0.06831075251102448, ..., -0.014019307990868887,\n", - " 0.02656376361846924, -0.007869244863589605],\n", + " 'L_VISC1': masked_array(data=[0.001800412933031718, -0.026361880203088123,\n", + " 0.048531800508499146, ..., 0.0036931708455085754,\n", + " -0.025857210159301758, -0.016787593563397724],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISC1': masked_array(data=[-0.00929751805961132, 0.026456234355767567,\n", - " 0.007971870402495066, ..., -0.013542252282301584,\n", - " 0.008318687478701273, 0.015014130622148514],\n", + " 'R_VISC1': masked_array(data=[-0.011358295877774557, -0.008184257273872694,\n", + " 0.0009328878174225489, ..., -0.0036866882195075354,\n", + " 0.007234333703915278, -0.0019834997753302255],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISl1': masked_array(data=[-0.0016103796251527556, 0.001556872994035155,\n", - " -0.0022002804082828565, ..., 0.0020433754383862674,\n", - " 0.0002804646616453653, 0.007566246357592908],\n", + " 'L_VISl1': masked_array(data=[0.005264556669926906, 0.002475028673371116,\n", + " 0.004756286249055967, ..., -0.006180629625425234,\n", + " -0.012509357798230517, -0.013806012960580679],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISl1': masked_array(data=[-0.025578341641268886, 0.005045478488062765,\n", - " 0.0034280203200958586, ..., -0.0009608538923682748,\n", - " -0.0030777077753465255, 0.0006799236103728578],\n", + " 'R_VISl1': masked_array(data=[0.011594067563067426, 0.00012636577690040672,\n", + " 0.0021749214156643374, ..., -0.003703795291565277,\n", + " -0.0017778991342900874, -0.007304586552001618],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISp': masked_array(data=[-0.008580011893091216, -0.0037662456242781852,\n", - " -0.00781555063419033, ..., 0.005344631745643222,\n", - " 0.00436337952761306, 0.002381208543398243],\n", + " 'L_VISp': masked_array(data=[0.012036069327847421, 0.01112928657363195,\n", + " 0.012452031445959707, ..., -0.008480925974333234,\n", + " -0.013516817949657412, -0.013195863704091496],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISp': masked_array(data=[-0.013346634135857247, -0.00812952156797249,\n", - " -0.00990891772622739, ..., 0.0030202075553747974,\n", - " 0.0011493071189509576, 0.0031016087145798337],\n", + " 'R_VISp': masked_array(data=[0.012259355525380558, 0.009270186979043818,\n", + " 0.012501942742731153, ..., -0.006546849881426399,\n", + " -0.006850829707329684, -0.006574291543862254],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISpm': masked_array(data=[-0.0095696389174261, -0.009143576902501723,\n", - " -0.005712877301608815, ..., 0.007447449099115965,\n", - " 0.0070947538904783105, 0.008626583243618492],\n", + " 'L_VISpm': masked_array(data=[-0.002983574105911896, -0.0009330372099115067,\n", + " 0.0031444848585529487, ..., 0.011787168118132263,\n", + " 0.008039106841848678, 0.008375758383454395],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISpm': masked_array(data=[-0.012210134698563264, -0.007568964938155743,\n", - " -0.009043914931161063, ..., 0.006802944576039034,\n", - " 0.005720874341596074, 0.005985271029111718],\n", + " 'R_VISpm': masked_array(data=[0.004973979557261747, 0.003274506881457417,\n", + " 0.007423376836696593, ..., 0.006561113505804238,\n", + " 0.0027080934588648692, 0.004817058058346019],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISa1': masked_array(data=[-0.002971118146722967, -0.0034021593474007988,\n", - " -0.00020881174327610255, ..., -0.00011427987080353957,\n", - " 0.0017314414669583728, 0.001749689345593219],\n", + " 'L_VISa1': masked_array(data=[0.00026754136164705236, -0.00633612129238102,\n", + " 0.0012911226782765422, ..., 0.012365508746433924,\n", + " 0.01084028257356657, 0.009122079068964178],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISa1': masked_array(data=[-0.008313341574235395, -0.006312118960427238,\n", - " -0.005990090903702316, ..., 0.000465799513813499,\n", - " -0.0018320260764835598, -0.00019919387735686935],\n", + " 'R_VISa1': masked_array(data=[0.005789388726641248, 0.002048916541613065,\n", + " 0.006064626303586093, ..., 0.010501796549016779,\n", + " 0.005265292587813797, 0.0038943353232803878],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'L_VISrl1': masked_array(data=[-0.010959998421047045, -0.008275526373282723,\n", - " -0.007561957058699235, ..., 0.0015957831688549209,\n", - " -0.0033778979078583097, 0.0002434327793510064],\n", + " 'L_VISrl1': masked_array(data=[0.008240224874537924, 0.007215430555136308,\n", + " 0.00934809640697811, ..., -0.00241299815799879,\n", + " -0.00714692279048588, -0.0060456427543059636],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20),\n", - " 'R_VISrl1': masked_array(data=[-0.014714967945347662, -0.008015477139016857,\n", - " -0.011097423408342444, ..., -0.0007558289267446684,\n", - " -0.0022647398645463195, -0.0023275242875451627],\n", + " 'R_VISrl1': masked_array(data=[0.008774526093317114, 0.003841696226078531,\n", + " 0.0062790085440096646, ..., -0.007713707244914511,\n", + " -0.01078570666520492, -0.009134758425795513],\n", " mask=[False, False, False, ..., False, False, False],\n", " fill_value=1e+20)}" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -837,23 +838,23 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "dd0022b3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -868,7 +869,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "b0fedbcd", "metadata": {}, "outputs": [], @@ -878,7 +879,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 16, "id": "d26da73a", "metadata": {}, "outputs": [], @@ -888,34 +889,132 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 17, "id": "9d280c5e", "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
regiontime_idxF
0L_SSp-ul00.006697
1L_SSp-ul10.004767
2L_SSp-ul20.000792
3L_SSp-ul30.005402
4L_SSp-ul40.011726
............
91995R_VISrl11995-0.006175
91996R_VISrl11996-0.007681
91997R_VISrl11997-0.007714
91998R_VISrl11998-0.010786
91999R_VISrl11999-0.009135
\n", + "

92000 rows × 3 columns

\n", + "
" + ], "text/plain": [ - "L_SSp-ul 0 -0.014034\n", - " 1 -0.002306\n", - " 2 -0.004649\n", - " 3 -0.005122\n", - " 4 -0.013291\n", - " ... \n", - "R_VISrl1 7495 0.000298\n", - " 7496 -0.000169\n", - " 7497 -0.000756\n", - " 7498 -0.002265\n", - " 7499 -0.002328\n", - "Length: 345000, dtype: float64" + " region time_idx F\n", + "0 L_SSp-ul 0 0.006697\n", + "1 L_SSp-ul 1 0.004767\n", + "2 L_SSp-ul 2 0.000792\n", + "3 L_SSp-ul 3 0.005402\n", + "4 L_SSp-ul 4 0.011726\n", + "... ... ... ...\n", + "91995 R_VISrl1 1995 -0.006175\n", + "91996 R_VISrl1 1996 -0.007681\n", + "91997 R_VISrl1 1997 -0.007714\n", + "91998 R_VISrl1 1998 -0.010786\n", + "91999 R_VISrl1 1999 -0.009135\n", + "\n", + "[92000 rows x 3 columns]" ] }, - "execution_count": 101, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df.unstack()" + "df.unstack().reset_index().rename(columns={\"level_0\": \"region\", \"level_1\": \"time_idx\", 0: \"F\"})" ] }, { @@ -925,6 +1024,14 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e54eb7c6", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -943,7 +1050,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.12" + "version": "3.13.11" } }, "nbformat": 4, From a6f3b990681058f06cf7f9ce77f35b0fb5c2fb2f Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Sat, 11 Jul 2026 19:15:01 +0100 Subject: [PATCH 20/23] fix docstring format from cli --- src/mesoscopy/process/__init__.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/mesoscopy/process/__init__.py b/src/mesoscopy/process/__init__.py index b9e4720..04bc330 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -159,12 +159,7 @@ def zscore_cmd(path: str, out_dir: str) -> None: help="Output directory for smoothed recording.", ) def regions_cmd(path: str, out_dir: str) -> None: - """Extract ∆F signal averages from ABA-defined regions. - - Args: - path (str): Path to registered HDF5 recording or NWB file. - out_dir (str): Path to output directory. - """ + """Extract ∆F signal averages from ABA-defined regions.""" if not Path(out_dir).exists(): click.echo(f"Creating output directory {out_dir}...") Path(out_dir).mkdir(parents=True) From c930a092499bfc0532928a18708af563f588e3a4 Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 15 Jul 2026 14:31:22 +0100 Subject: [PATCH 21/23] speed up processing by precalculating boolean mask, remove threading which was useless --- src/mesoscopy/process/region.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py index fc03192..c81be0f 100644 --- a/src/mesoscopy/process/region.py +++ b/src/mesoscopy/process/region.py @@ -19,7 +19,6 @@ # IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. -from concurrent.futures import ThreadPoolExecutor from typing import Literal import numpy as np @@ -114,19 +113,21 @@ def extract_all_regions( region_ids = {region: annotations.loc[annotations["acronym"] == region, "id"].values[0] for region in regions} - def _process_region(region: str) -> tuple[str, npt.NDArray, str, npt.NDArray]: - region_id = region_ids[region] - left_mask = np.broadcast_to(left_aba == region_id, deltaf_series.shape) - right_mask = np.broadcast_to(right_aba == region_id, deltaf_series.shape) - left_activity = np.ma.array(deltaf_series, mask=~left_mask).mean(axis=(1, 2)) - right_activity = np.ma.array(deltaf_series, mask=~right_mask).mean(axis=(1, 2)) - return f"L_{region}", left_activity, f"R_{region}", right_activity + hw = left_aba.shape[0] * left_aba.shape[1] + left_masks = np.array([(left_aba == region_ids[r]).ravel() for r in regions]) # (n_regions, H*W) + right_masks = np.array([(right_aba == region_ids[r]).ravel() for r in regions]) + + left_counts = left_masks.sum(axis=1).astype(float) # (n_regions,) + right_counts = right_masks.sum(axis=1).astype(float) + + data_flat = deltaf_series.reshape(deltaf_series.shape[0], hw) # (T, H*W) + left_activities = (data_flat @ left_masks.T) / left_counts # (T, n_regions) + right_activities = (data_flat @ right_masks.T) / right_counts region_activity = {} - with ThreadPoolExecutor() as executor: - for l_key, l_activity, r_key, r_activity in executor.map(_process_region, regions): - region_activity[l_key] = l_activity - region_activity[r_key] = r_activity + for i, region in enumerate(regions): + region_activity[f"L_{region}"] = left_activities[:, i] + region_activity[f"R_{region}"] = right_activities[:, i] if as_dataframe: df = pd.DataFrame(region_activity) From 12564fe3359ff78f3424312cf3d818aa52cd64ec Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 15 Jul 2026 14:31:43 +0100 Subject: [PATCH 22/23] convert timestamps to str before saving --- src/mesoscopy/process/__init__.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/mesoscopy/process/__init__.py b/src/mesoscopy/process/__init__.py index 04bc330..2028e96 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -173,8 +173,10 @@ def regions_cmd(path: str, out_dir: str) -> None: with timer.Timer(message="Extracting region activity"): region_activity = pd.DataFrame(pr.extract_all_regions(deltaf_series, as_dataframe=True)) - region_activity["time_idx"] = timestamps[region_activity["time_idx"]] - region_activity.rename(columns={"time_idx": "timestamps"}, inplace=True) + region_activity["time_idx"] = [ + str(timestamp, encoding="utf-8") for timestamp in timestamps[region_activity["time_idx"]] + ] + region_activity.rename(columns={"time_idx": "timestamp"}, inplace=True) region_activity.to_csv(outpath, index=False) click.echo(f"Saved region activity at {outpath}") From d0944fcdd40221eec39462f503ebeaa6c7320c1a Mon Sep 17 00:00:00 2001 From: Constantinos Eleftheriou Date: Wed, 15 Jul 2026 14:32:14 +0100 Subject: [PATCH 23/23] test timing for new extract_all_regions implementation --- exploratory/array-masking.ipynb | 218 +++++++++++++++++++++++++++----- 1 file changed, 188 insertions(+), 30 deletions(-) diff --git a/exploratory/array-masking.ipynb b/exploratory/array-masking.ipynb index 5786102..964a50f 100644 --- a/exploratory/array-masking.ipynb +++ b/exploratory/array-masking.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "81105d50", "metadata": {}, "outputs": [], @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "98430049", "metadata": {}, "outputs": [], @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "17ba4891", "metadata": {}, "outputs": [], @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "9fc92035", "metadata": {}, "outputs": [ @@ -53,7 +53,7 @@ " [0, 0, 0, ..., 0, 0, 0]], shape=(140, 142), dtype=uint16)" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "f54c9a78", "metadata": {}, "outputs": [ @@ -174,7 +174,7 @@ " dtype=float32)" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -187,7 +187,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "994f3a73", "metadata": {}, "outputs": [ @@ -457,7 +457,7 @@ "32 1228 VISrl1 Rostrolateral area" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -469,7 +469,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "9ed0211d", "metadata": {}, "outputs": [ @@ -479,7 +479,7 @@ "np.int64(1214)" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -490,17 +490,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "b7e9f585", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -521,17 +521,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "8b19388f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, @@ -552,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "2dbdd594", "metadata": {}, "outputs": [ @@ -567,7 +567,7 @@ " dtype=object)" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -578,7 +578,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "f8f15224", "metadata": {}, "outputs": [], @@ -588,7 +588,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "d85dd3a5", "metadata": {}, "outputs": [ @@ -827,7 +827,7 @@ " fill_value=1e+20)}" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -838,17 +838,17 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "dd0022b3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, @@ -869,7 +869,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "b0fedbcd", "metadata": {}, "outputs": [], @@ -879,7 +879,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "d26da73a", "metadata": {}, "outputs": [], @@ -889,7 +889,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "id": "9d280c5e", "metadata": {}, "outputs": [ @@ -1008,7 +1008,7 @@ "[92000 rows x 3 columns]" ] }, - "execution_count": 17, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1027,9 +1027,167 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "e54eb7c6", "metadata": {}, + "outputs": [ + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mCannot execute code, session has been disposed. Please try restarting the Kernel." + ] + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mCannot execute code, session has been disposed. Please try restarting the Kernel. \n", + "\u001b[1;31mView Jupyter log for further details." + ] + } + ], + "source": [ + "df = region.extract_all_regions(deltaf_series=f[\"F\"][1000:30000], as_dataframe=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d350096", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
regiontime_idxF
0L_SSp-ul00.006697
1L_SSp-ul10.004767
2L_SSp-ul20.000792
3L_SSp-ul30.005402
4L_SSp-ul40.011726
............
91995R_VISrl11995-0.006175
91996R_VISrl11996-0.007681
91997R_VISrl11997-0.007714
91998R_VISrl11998-0.010786
91999R_VISrl11999-0.009135
\n", + "

92000 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " region time_idx F\n", + "0 L_SSp-ul 0 0.006697\n", + "1 L_SSp-ul 1 0.004767\n", + "2 L_SSp-ul 2 0.000792\n", + "3 L_SSp-ul 3 0.005402\n", + "4 L_SSp-ul 4 0.011726\n", + "... ... ... ...\n", + "91995 R_VISrl1 1995 -0.006175\n", + "91996 R_VISrl1 1996 -0.007681\n", + "91997 R_VISrl1 1997 -0.007714\n", + "91998 R_VISrl1 1998 -0.010786\n", + "91999 R_VISrl1 1999 -0.009135\n", + "\n", + "[92000 rows x 3 columns]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37903dbd", + "metadata": {}, "outputs": [], "source": [] }