diff --git a/exploratory/array-masking.ipynb b/exploratory/array-masking.ipynb new file mode 100644 index 0000000..964a50f --- /dev/null +++ b/exploratory/array-masking.ipynb @@ -0,0 +1,1216 @@ +{ + "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", + "from mesoscopy.process import region\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\")\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, + "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)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l_aba" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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": 5, + "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": 6, + "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": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotations = get_atlas_annotations()\n", + "annotations" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9ed0211d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(1214)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotations.loc[annotations[\"acronym\"] == \"VISli1\", \"id\"].values[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b7e9f585", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "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": 9, + "id": "8b19388f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 9, + "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": 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\"][1000:3000])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d85dd3a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'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.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.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=[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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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=[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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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, + "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": 14, + "id": "b0fedbcd", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d26da73a", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(region_activity)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "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": [ + " 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": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.unstack().reset_index().rename(columns={\"level_0\": \"region\", \"level_1\": \"time_idx\", 0: \"F\"})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff1f8641", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "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": [] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} 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 8110796..2028e96 100644 --- a/src/mesoscopy/process/__init__.py +++ b/src/mesoscopy/process/__init__.py @@ -22,16 +22,17 @@ """Processing submodule.""" import os +from pathlib import Path + import click -import numpy as np -import dask.array as da +import pandas as pd from pynwb.image import ImageSeries -import mesoscopy.timer as timer - -import mesoscopy.io as io +import mesoscopy.process.region as pr import mesoscopy.process.smooth as psm import mesoscopy.process.zscore as pzs +from mesoscopy import io +from mesoscopy import timer @click.group("process") @@ -61,12 +62,12 @@ 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 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" @@ -97,14 +98,14 @@ 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 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"): @@ -145,25 +146,37 @@ def zscore_cmd(path: str, out_dir: str) -> None: io.write_nwb(path, nwbfile, io=nwbio) -def load_deltaf(path: str, nwb: bool = False) -> tuple[str, np.ndarray, np.ndarray]: - """Load preprocessed deltaf from an HDF5 or NWB file. +@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.""" + 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) - Args: - path (str): Path to the preprocessed file. - nwb (bool, optional): Whether the file is an NWB file. Defaults to False. + outpath = out_dir + os.sep + session_id + "_regions.csv" - 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) + with timer.Timer(message="Extracting region activity"): + region_activity = pd.DataFrame(pr.extract_all_regions(deltaf_series, as_dataframe=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}") diff --git a/src/mesoscopy/process/region.py b/src/mesoscopy/process/region.py new file mode 100644 index 0000000..c81be0f --- /dev/null +++ b/src/mesoscopy/process/region.py @@ -0,0 +1,136 @@ +# 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. + +from typing import Literal + +import numpy as np +import numpy.typing as npt +import pandas as pd + +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: + """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] + + 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: 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() + + if exclude is None: + exclude = [] + + 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 excluded_regions] + + region_ids = {region: annotations.loc[annotations["acronym"] == region, "id"].values[0] for region in regions} + + 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 = {} + 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) + return df.unstack().reset_index().rename(columns={"level_0": "region", "level_1": "time_idx", 0: "F"}) + + return region_activity 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/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" ) 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_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) 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) diff --git a/uv.lock b/uv.lock index 7bc87a7..280c94c 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 3 +revision = 2 requires-python = ">=3.12" [[package]]