vneumodpy 0.1.6__tar.gz

vneumodpy-0.1.6/LICENSE.md

@@ -0,0 +1,23 @@
+
+
+MIT License
+
+Copyright (c) 2022-present T.Okuno, RIKEN CBS
+
+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.

vneumodpy-0.1.6/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: vneumodpy
+Version: 0.1.6
+Summary: The Virtual Neuromodulation Toolbox for Python.
+Home-page: https://github.com/takuto-okuno-riken/vneumodpy
+Author: takuto okuno
+License: MIT
+Keywords: vneumod vneumodpy virtual neuromodulation
+Description-Content-Type: text/plain
+License-File: LICENSE.md
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: h5py
+Requires-Dist: hdf5storage
+Requires-Dist: nibabel
+Requires-Dist: statsmodels
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+Please visit https://github.com/takuto-okuno-riken/vneumodpy in detail description

vneumodpy-0.1.6/README.md

@@ -0,0 +1,273 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-success.svg)](https://opensource.org/licenses/MIT)
+
+# Virtual Neuromodulation Toolbox for Python
+The Virtual Neuromodulation Toolbox for Python (MATLAB version is [here](https://github.com/takuto-okuno-riken/vneumod)).
+
+
+## Introduction
+To realize the digital brain, various approaches have been taken at multiple levels.
+We proposed [Group Surrogate Data Generating Model (GSDGM)](https://github.com/takuto-okuno-riken/gsdgmpy), which does not incorporate structural connectivity and focuses on reproducing resting-state functional MRI dynamics (BOLD signal). 
+This model can learn multivariate time-series data (BOLD signal) of a group and generate a centroidal and representative multivariate time-series of the group.
+The group surrogate model preserves the statistics of multivariate time-series well, so this allows for the generation of whole-brain dynamics with extremely high accuracy. 
+
+Whole-brain data-driven model (group surrogate model) assumes no specific brain tissue structure, one voxel of 4 × 4 × 4 mm gray matter, and 25445 voxels based on the Allen human brain atlas. 
+All voxels are fully connected, and vector auto-regression (VAR) surrogate is used to learn group data and generate group surrogate data.
+
+<div align="center">
+<img src="data/img/fig1.jpg" width="70%">
+</div>
+<br>
+
+Then, we extended output of VAR surrogate for virtual neuromodulation.
+<div align="center">
+<img src="data/img/fig2.jpg" width="30%">
+</div>
+
+
+where x<sub>i</sub>(t) is output of voxel i, y<sub>i</sub>(t) is VAR surrogate output of voxel i, z<sub>i</sub>(t),u<sub>i</sub>(t) are modulation terms of voxel i, and c<sub>i</sub>,σ<sub>X</sub>∈R. 
+σ<sub>X</sub> is calculated as the standard deviation from the entire voxel time-series.
+z<sub>i</sub>(t) is constructed by convolution of the canonical Hemodynamic Response Function (HRF) and the Box-car task design.
+u<sub>i</sub>(t) performs direct adjustment to the output of VAR surrogate.
+In other words, if there is a virtual neuromodulation stimulus, it adjusts to prioritize neuromodulation stimulus, such as u<sub>i</sub>(t)=1-0.5∙z<sub>i</sub>(t).
+Using the above-mentioned virtual neuromodulation, BOLD signal addition, i.e., DBS treatment, can be virtually performed for specific voxels. 
+
+
+<b>Command line tools</b>
+
+| name | description |
+|:---|:---|
+| gsdgm | Generate a whole-brain data-driven model based on the group surrogate model (VAR surrogate).|
+| vneumod | Generate virtual neuromodulation time-series surrogate data based on the group surrogate model.|
+| mtess | Calculate and plot MTESS for a group of multivariate time-series data. |
+
+
+## Requirements: software
+* Python 3.11.14
+* matplotlib 3.10.8
+* scikit_learn 1.8.0
+* h5py 3.15.1
+* pandas 2.3.3
+* statsmodels 0.14.6
+
+
+## Installation
+1. Download this [Toolbox](https://github.com/takuto-okuno-riken/vneumodpy/archive/refs/heads/main.zip) zip files.
+2. Extract zip file under your working directory <work_path>/vneumodpy-main.
+3. This is not required, but we recommend using the conda virtual environment.
+~~~
+(base) work_path>cd vneumodpy-main
+(base) vneumodpy-main>conda create -n vneumod python=3.11.14
+...
+(base) vneumodpy-main>conda activate vneumod
+(vneumod) vneumodpy-main>
+~~~
+4. Install several packages.
+~~~
+(vneumod) vneumodpy-main>pip install -r requirements.txt
+...
+~~~
+5. Run the following demos.
+
+
+## Command Line Tools Demos
+<b>Demo 1</b><br>
+First demo uses a PD group surrogate model to apply sweet spot stimulus of the virtual STN-DBS, performs GLM analysis, and then outputs an NIfTI file.
+Pre-processed subject data and group surrogate model files should be downloaded from [zenodo](https://zenodo.org/records/19312573), and extracted a zip file to overwrite 'results' directory in <work_path>/vneumod-main before running this code.<br/>
+(Please confirm to update results directory.)
+
+~~~
+(vneumod) vneumodpy-main>python vneumod.py --cx results/ppmi81CXAllenCube2s34gmacomp.mat --model results/ppmi81CXAllenCube2s34gmacomp_gsm_var.mat --targatl data/allenCube2atlasStn3.nii.gz --atlas data/allenCube2atlas.nii.gz --out 1 --roi 4525 --glm --nocache
+set savename=ppmi81CXAllenCube2s34gmacomp
+load subject time-series file: results/ppmi81CXAllenCube2s34gmacomp.mat
+load model file: results/ppmi81CXAllenCube2s34gmacomp_gsm_var.mat
+loading subject permutation : results/perm1_ppmi81CXAllenCube2s34gmacomp.mat
+generate modulation (add & mul) time-series, target roi=4525, srframes=160, dbsoffsec=28, dbsonsec=22, dbspw=0.15
+convolution params tr=1.0, res=16, sp=8
+calc virtual neuromodulation surrogate. roi=4525, surrnum=40
+surrogate sample : 1
+done t=9.170302391052246 sec
+surrogate sample : 1
+done t=7.329235553741455 sec
+...
+
+process GLM with Tukey-Taper(8) estimation ...
+done t=22.902510166168213 sec
+calc 2nd-level GLM...
+process GLM with Tukey-Taper(8) estimation ...
+done t=17.72597575187683 sec
+save nifti file : results/ppmi81CXAllenCube2s34gmacomp_4525sr40pr1_2nd-Tukey8.nii.gz
+~~~
+
+When you view the outputted NIfTI file with ITK-SNAP, you can confirm activation of STN sweet spot and deactivation of A4.<br/>
+
+<div align="center">
+<img src="data/img/demo1.jpg" width="70%"></div>
+
+
+##
+<b>Demo 2</b><br>
+This demo shows creation of a group surrogate model from (pre-processed) rs-fMRI time-series data (25445 ROIs). <br>
+(Caution: model calculation will take like one day.)
+~~~
+(vneumod) vneumodpy-main>python gsdgm.py --var results/ppmi81CXAllenCube2s34gmacomp.mat
+load subject time-series file: results/ppmi81CXAllenCube2s34gmacomp.mat
+output group surrogate model file : results/ppmi81CXAllenCube2s34gmacomp_gsm_var.mat
+~~~
+
+The group surrogate data is the representative centroid of the group of original time-series data.
+
+
+## Command Line Tools Reference
+<b>gsdgm command</b><br>
+~~~
+(vneumod) vneumodpy-main>python gsdgm.py -h
+usage: gsdgm.py [-h] [--var] [--lag LAG] [--noise NOISE] [--outpath OUTPATH] [--transopt TRANSOPT]
+                [--format FORMAT] [--surrnum SURRNUM] [--siglen SIGLEN] [--range RANGE] [--cache]
+                [--njobs NJOBS] [--showinsig] [--showinras] [--showsig] [--showras]
+                filename [filename ...]
+
+positional arguments:
+  filename             filename of node status time-series (node x frames)
+
+options:
+  -h, --help           show this help message and exit
+  --var                output Vector Auto-Regression (VAR) group surrogate model
+                       (<filename>_gsm_var.mat)
+  --lag LAG            time lag <num> for VAR (default:1)
+  --noise NOISE        noise type for VAR surrogate model (default:"gaussian" or "residuals")
+  --outpath OUTPATH    output files path (default:"results")
+  --transopt TRANSOPT  signal transform option (for type 1:centroid value)
+  --format FORMAT      save file format <type> 0:csv, 1:mat(each), 2:mat(all) (default:2)
+  --surrnum SURRNUM    output surrogate sample number <num> (default:0)
+  --siglen SIGLEN      output time-series length <num> (default:same as input time-series)
+  --range RANGE        output surrogate value range (default:"auto", sigma:<num>, full:<num>,
+                       <min>:<max> or "none")
+  --cache              save cache file at model calculation
+  --njobs NJOBS        number of jobs (multiprocessing) for model calculation (default:-1)
+  --showinsig          show input time-series data of <filename>.csv
+  --showinras          show raster plot of input time-series data of <filename>.csv
+  --showsig            show output surrogate time-series data
+  --showras            show raster plot of output surrogate time-series data
+~~~
+The input .mat file should include input cell data described as follows. The node count must be the same within the group, whereas the time-series length does not have to be the same.
+| name | cell | description |
+|:---|:---|:---|
+|CX |{&lt;nodes&gt; x &lt;length&gt;} x &lt;cell number&gt; |group of multivariate time-series|
+|names |{'data name string'} x &lt;cell number&gt; |names of each time-series data|
+
+The output (group surrogate model) .mat file includes the following struct data:
+
+| name | type | description |
+|:---|:---|:---|
+|net | struct |struct of group surrogate model|
+|gRange | struct |struct of group range information|
+|name | string |name of group surrogate model|
+
+The output (group surrogate data) .mat file includes the following cell data:
+
+| name | cell | description |
+|:---|:---|:---|
+|CX |{&lt;nodes&gt; x &lt;length&gt;} x &lt;cell number&gt; |group of multivariate time-series|
+|names |{'data name string'} x &lt;cell number&gt; |names of each time-series data|
+
+
+##
+<b>vneumod command</b><br>
+~~~
+(vneumod) vneumodpy-main>python vneumod.py -h
+usage: vneumod.py [-h] [--cx CX] [--pymodel PYMODEL] [--model MODEL] [--atlas ATLAS]
+                  [--targatl TARGATL] [--roi ROI] [--out OUT] [--outfrom OUTFROM]
+                  [--surrnum SURRNUM] [--srframes SRFRAMES] [--vnparam VNPARAM] [--tr TR]
+                  [--hrfparam HRFPARAM] [--glm] [--njobs NJOBS] [--outpath OUTPATH] [--nocache]
+                  [filename ...]
+
+positional arguments:
+  filename             filename of subject permutation (1 x length)
+
+options:
+  -h, --help           show this help message and exit
+  --cx CX              set cells of subject time-series (<filename>.mat)
+  --pymodel PYMODEL    set (VAR) group surrogate model <path> by vneumodpy
+  --model MODEL        set (VAR) group surrogate model (<filename>_gsm_var.mat)
+  --atlas ATLAS        set cube atlas nifti file (<filename>.nii.gz)
+  --targatl TARGATL    set modulation target atlas nifti file (<filename>.nii.gz)
+  --roi ROI            set modulation target ROI <num> or <range text>
+  --out OUT            set output trials (perm & surrogate files) number <num> (default:1)
+  --outfrom OUTFROM    set surrogate output from <num> (default:1)
+  --surrnum SURRNUM    output surrogate sessions per one file <num> (default:40)
+  --srframes SRFRAMES  output surrogate frames <num> (default:160)
+  --vnparam VNPARAM    set virtual neuromodulation params <num,num,num> (default:28,22,0.15)
+  --tr TR              set TR (second) of fMRI time-series <num> (default:1)
+  --hrfparam HRFPARAM  set HRF (for convolution) params <num,num> (default:16,8)
+  --glm                output GLM result nifti file
+  --njobs NJOBS        number of jobs (multiprocessing) for glm calculation (default:8)
+  --outpath OUTPATH    output files path (default:"results")
+  --nocache            do not output surrogate file
+~~~
+The input .mat files are optional. It should include subject permutation data for surrogate data generation:
+| name | matrix | description |
+|:---|:---|:---|
+|perm |&lt;1&gt; x &lt;length&gt; | time-series permutation order|
+
+The output will be T-value 3D matrix nifti file (GLM result) aligned with cube atlas nifti file.
+
+##
+<b>mtess command</b><br>
+~~~
+(vneumod) vneumodpy-main>python mtess.py -h
+usage: mtess.py [-h] [--range RANGE] [--aclag ACLAG] [--paclag PACLAG] [--cclag CCLAG]
+                [--pcclag PCCLAG] [--outpath OUTPATH] [--format FORMAT] [--transform TRANSFORM]
+                [--transopt TRANSOPT] [--showinsig] [--showinras] [--showmat] [--showsig]
+                [--showprop] [--shownode] [--showdend SHOWDEND] [--cache] [--cachepath CACHEPATH]
+                filename [filename ...]
+
+positional arguments:
+  filename              filename of node status time-series (node x frames)
+
+options:
+  -h, --help            show this help message and exit
+  --range RANGE         input group value range (default:"auto", sigma:<num>, full:<num> or
+                        <min>:<max>)
+  --aclag ACLAG         time lag <num> for Auto Correlation (default:5)
+  --paclag PACLAG       time lag <num> for Partial Auto Correlation (default:13)
+  --cclag CCLAG         time lag <num> for Cross Correlation (default:2)
+  --pcclag PCCLAG       time lag <num> for Partial Cross Correlation (default:4)
+  --outpath OUTPATH     output files path (default:"results")
+  --format FORMAT       save file format <type> 0:csv, 1:mat (default:1)
+  --transform TRANSFORM
+                        input signal transform 0:raw, 1:sigmoid (default:0)
+  --transopt TRANSOPT   signal transform option (for type 1:centroid value)
+  --showinsig           show input time-series data of <filename>.csv
+  --showinras           show raster plot of input time-series data of <filename>.csv
+  --showmat             show result MTESS matrix
+  --showsig             show 1 vs. others node signals
+  --showprop            show result polar chart of 1 vs. others MTESS statistical properties
+  --shownode            show result line plot of 1 vs. others node MTESS
+  --showdend SHOWDEND   show dendrogram of <algo> hierarchical clustering based on MTESS matrix.
+  --cache               use cache file for MTESS calculation
+  --cachepath CACHEPATH
+                        cache files <path> (default:"results/cache")
+~~~
+The input .mat file should include input cell data. The node count must be the same within the group, whereas time-series length does not have to be the same.
+| name | cell | description |
+|:---|:---|:---|
+|CX |{&lt;nodes&gt; x &lt;length&gt;} x &lt;cell number&gt; |group of multivariate time-series|
+|names |{'data name string'} x &lt;cell number&gt; |names of each time-series data|
+
+The output .mat file includes the following matrix data:
+
+| name | matrix | description |
+|:---|:---|:---|
+|MTS |&lt;cell number&gt; x &lt;cell number&gt; | MTESS matrix (2D)|
+|MTSp |&lt;cell number&gt; x &lt;cell number&gt; x 8| MTESS statistical property matrix (3D)|
+|nMTS |&lt;cell number&gt; x &lt;cell number&gt; x &lt;nodes&gt;| Node MTESS matrix (3D)|
+|nMTSp |&lt;cell number&gt; x &lt;cell number&gt; x &lt;nodes&gt; x 8| Node MTESS statistical property matrix (4D)|
+
+Similarities are generated for the following 8 statistical properties: mean, standard deviation, DFT amplitude, correlation, partial correlation, cross-correlation and partial cross-correlation.
+
+
+## Citing Virtual Neuromodulation Toolbox
+If you find Virtual Neuromodulation Toolbox useful in your research, please cite it as follows: 
+
+Takuto Okuno, Alexander Woodward, Hideyuki Okano, Junichi Hata (submitted)
+["Do distinct DBS targets converge on a common associative circuit? A digital brain study"](https://www.google.com/), ,

vneumodpy-0.1.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vneumodpy-0.1.6/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="vneumodpy",
+    version="0.1.6",
+    license='MIT',
+    packages=find_packages(where='src'),
+    package_dir={"vneumodpy": "src/vneumodpy",
+                 "vneumodpy.glm": "src/vneumodpy/glm",
+                 "vneumodpy.measures": "src/vneumodpy/measures",
+                 "vneumodpy.models": "src/vneumodpy/models",
+                 "vneumodpy.nuisance": "src/vneumodpy/nuisance",
+                 "vneumodpy.surrogate": "src/vneumodpy/surrogate",
+                 },
+    install_requires=[
+        "matplotlib", "scikit-learn", "numpy", "pandas", "scipy", "h5py", "hdf5storage", "nibabel", "statsmodels"
+    ],
+    author='takuto okuno', # パッケージ作者の名前
+    url='https://github.com/takuto-okuno-riken/vneumodpy',
+
+    description='The Virtual Neuromodulation Toolbox for Python.',
+    long_description='Please visit https://github.com/takuto-okuno-riken/vneumodpy in detail description',
+    long_description_content_type='text/plain',
+    keywords = 'vneumod vneumodpy virtual neuromodulation',
+)

vneumodpy-0.1.6/src/vneumodpy/__init__.py

@@ -0,0 +1,38 @@
+
+from .models.multivaliate_var_network import MultivariateVARNetwork
+from .models.mvar_init_with_cell_mth import call_executor as mvar_init_with_cell_mth
+from .models.regress import linear
+from .models.regress import prepare
+from .models.regress import inv_qr
+from .models import group_range
+
+from .glm.canonical_hrf import get as canonical_hrf
+from .glm.hrf_design_matrix import get as hrf_design_matrix
+from .glm.tukey import calc as tukey
+from .glm.tukey_mp import calc as tukey_mp  # multi processing version
+from .glm.contrast_image import calc as contrast_image
+from .glm.roi_ts_to4dimage import get as roi_ts_to4dimage
+from .glm.roi_ts_from4dimage import get as roi_ts_from4dimage
+from .glm.adjust_volume_dir import adjust_volume_dir
+from .glm.resampling_nifti_volume import resampling_nifti_volume
+
+from .surrogate.multivariate_var import calc as multivariate_var
+from .surrogate.dbs_multivariate_var import calc as dbs_multivariate_var
+from .surrogate.vnm_addmul_signals import get as vnm_addmul_signals
+from .surrogate.vnm_var_surrogate import calc as vnm_var_surrogate
+from .surrogate.vnm_subject_perm import get as vnm_subject_perm
+
+from .measures import ac
+from .measures import pac
+from .measures import cm
+from .measures import ccm
+from .measures import pcm
+from .measures import pccm
+from .measures import pccm_
+from .measures import mtess
+from .measures import mskewkurt
+from .measures.cos_sim import calc as cos_sim
+
+from .nuisance.mean_time_series import get as nuisance_mean_time_series
+from .nuisance.acompcor import get as nuisance_acompcor
+from .nuisance.regression_out import get as nuisance_regression_out

vneumodpy-0.1.6/src/vneumodpy/glm/adjust_volume_dir.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+##
+# Adjust NIfTI volume direction based on NIfTI info Transpose matrix
+# returns adjusted NIfTI volume
+# input:
+#  V            nifti 4D volume (X x Y x Z x frames)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+
+
+def adjust_volume_dir(V, info):
+    A = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])
+    if np.sum(np.abs(A * info.affine[:3, :3])) > 0:
+        print('nifti volume transformation is not supported.')
+        return V
+    if info.affine[0, 0] < 0:  # check flip X axis
+        V = np.flipud(V).copy()
+    if info.affine[1, 1] < 0:  # check flip Y axis
+        V = np.fliplr(V).copy()
+    if info.affine[2, 2] < 0:  # check flip Z axis
+        V = np.flip(V, axis=2).copy()
+    return V

vneumodpy-0.1.6/src/vneumodpy/glm/canonical_hrf.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+##
+# get GLM Canonical hemodynamic response function
+# returns time range (t), HRF time-series (hrf)
+# input:
+#  dt                 time resolution (sec) (default:0.045)
+#  responseDelay      delay of response (gamma a)(sec) (default:6)
+#  underShootDelay    delay of undershoot (gamma a)(sec) (default:16)
+#  kernelSec          kernel time length (sec) (default: 32)
+#  underShootRatio    ratio of underShoot (default: 0.167)
+#  hrfScale           HRF scale (gamma b) (default: 0.9)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from scipy.stats import gamma
+
+def get(dt=0.045, response_delay=6, under_shoot_delay=16, kernel_sec=32, under_shoot_ratio=0.167, hrf_scale=0.9):
+
+    t = np.arange(0, kernel_sec+dt, dt)
+    hrf = gamma.pdf(t,response_delay,scale=hrf_scale) - gamma.pdf(t,under_shoot_delay,scale=hrf_scale) * under_shoot_ratio
+    hrf = hrf.T / np.sum(hrf)
+    return t, hrf

vneumodpy-0.1.6/src/vneumodpy/glm/contrast_image.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+##
+# Calculate GLM Contrast Image with prewhitening.
+# based on K.J.Friston et al. (2000), M.W.Woolrich et al. (2001), K.J.Worsley (2001)
+# returns cells of T-value matrix (Ts)
+# input:
+#  Cs           cells of contrast vectors (contrasts (predictor size) x 1)
+#  B            predictor variables (node x predictor variables)
+#  RSS          Residual Sum of Squares (node x 1)
+#  X2is         Vector or single value of inv(X' * X) for contrast
+#  tRs          Vector or single value of trace(R) for contrast
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from math import sqrt
+
+def calc(Cs, B, RSS, X2is, tRs):
+    # GLM contrast image
+    # T = (c' * B) / sqrt(c' * X' * inv(V) * X * c * (RSS / trace(R)))
+    Ts = []
+    roiNum = RSS.shape[0]
+    T2 = np.zeros((roiNum,1), dtype=np.float32)
+
+    for c in Cs:
+        for i in range(roiNum):
+            if X2is.shape[0] == roiNum:
+                X2i = X2is[i, :, :]
+                d = sqrt(c.T @ X2i @ c)
+            else:
+                d = sqrt(c.T @ X2is @ c)
+
+            if tRs.shape[0] == roiNum:
+                se2 = sqrt(RSS[i].item() / tRs[i].item()) # to scalar
+            else:
+                se2 = sqrt(RSS[i].item() / tRs) # to scalar
+
+            T2[i] = (c.T @ B[i, :].T) / (d * se2)
+        Ts.append(T2.copy())
+    return Ts

vneumodpy-0.1.6/src/vneumodpy/glm/hrf_design_matrix.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# get GLM HRF (hemodynamic response function) design matrix
+# input:
+#  onsets       cells of task set start time
+#  durations    cells of task set duration
+#  frames       fMRI time frames
+#  TR           fMRI TR
+#  res          sampling resolution of HRF
+#  sp           sampling starting point (in resolution)
+#  hrf          Canonical hemodynamic response function (optional)
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+
+from ..glm.canonical_hrf import get as canonical_hrf    # for command mode
+
+def get(onsets, durations, frames, TR, res, sp, hrf=[]):
+
+    # get Canonical hemodynamic response function
+    if len(hrf) == 0:
+        dt = TR / res
+        t, hrf = canonical_hrf(dt)
+
+    tasknum = len(onsets)
+    X = np.zeros((frames * res, tasknum), float)
+    U = np.zeros((frames * res, tasknum), float)
+    for k in range(tasknum):
+        onset = onsets[k]
+        duration = durations[k]
+        for i in range(len(onset)):
+            t1 = int(np.ceil(onset[i] / TR * res))
+            t2 = int(np.ceil(t1 + duration[i] / TR * res))
+            U[t1-1:t2,k] = 1
+        # get design matrix
+        C = np.convolve(U[:,k], hrf)
+        X[:,k] = C[0:frames * res]
+
+    # final sampling
+    X = X[np.arange((sp-1),X.shape[0],res),:]
+    U = U[np.arange((sp-1),U.shape[0],res),:]
+    return X, U

vneumodpy-0.1.6/src/vneumodpy/glm/resampling_nifti_volume.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# resampling NIfTI volume.
+# returns re-sampled volume (outV)
+# input:
+#  V            nifti 3D volume (X x Y x Z)
+#  stepXY       XY axes resampling rate
+#  stepZ        Z axes resampling rate
+#  operation    operation for each plane ('mode'(default),'max','min','mean','median')
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from scipy.stats import mode
+
+def resampling_nifti_volume(V, stepXY, stepZ, operation='mode'):
+    xs = int(np.floor(V.shape[0] / stepXY))
+    ys = int(np.floor(V.shape[1] / stepXY))
+    zs = int(np.floor(V.shape[2] / stepZ))
+    outV = np.zeros((xs, ys, zs), dtype=np.float32)
+
+    if stepXY >= 1 and stepZ >= 1:
+        # scale down
+        for z in range(1,zs+1):
+            for y in range(1,ys+1):
+                for x in range(1,xs+1):
+                    x_start = int(round(x * stepXY - (stepXY - 1))) - 1
+                    x_end = int(round(x * stepXY))
+                    y_start = int(round(y * stepXY - (stepXY - 1))) - 1
+                    y_end = int(round(y * stepXY))
+                    z_start = int(round(z * stepZ - (stepZ - 1))) - 1
+                    z_end = int(round(z * stepZ))
+                    A = V[x_start:x_end, y_start:y_end, z_start:z_end]
+
+                    if operation == 'mode':
+                        A_flat = A[~np.isnan(A)]
+                        if A_flat.size == 0:
+                            m = np.nan
+                        else:
+                            m = mode(A_flat, axis=None).mode[0]
+                    elif operation == 'min':
+                        m = np.nanmin(A)
+                    elif operation == 'max':
+                        m = np.nanmax(A)
+                    elif operation == 'mean':
+                        m = np.nanmean(A)
+                    elif operation == 'median':
+                        m = np.nanmedian(A)
+                    else:
+                        raise ValueError(f"Unsupported operation: {operation}")
+
+                    outV[x-1, y-1, z-1] = m
+    else:
+        # scale up
+        out_shape = (
+            int(np.ceil(V.shape[0] / stepXY)),
+            int(np.ceil(V.shape[1] / stepXY)),
+            int(np.ceil(V.shape[2] / stepZ))
+        )
+        outV = np.zeros(out_shape, dtype=np.float32)
+
+        for z in range(1,V.shape[2]+1):
+            for y in range(1,V.shape[1]+1):
+                for x in range(1,V.shape[0]+1):
+                    m = V[x-1, y-1, z-1]
+                    xx_start = int(round((x-1) / stepXY))
+                    xx_end = int(round(x / stepXY))
+                    yy_start = int(round((y-1) / stepXY))
+                    yy_end = int(round(y / stepXY))
+                    zz_start = int(round((z-1) / stepZ))
+                    zz_end = int(round(z / stepZ))
+                    outV[xx_start:xx_end, yy_start:yy_end, zz_start:zz_end] = m
+
+    return outV

vneumodpy-0.1.6/src/vneumodpy/glm/roi_ts_from4dimage.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+##
+# get ROI time-series (matrix) from NIfTI 4D volume.
+# returns ROI time-series (X)
+# input:
+#  V            nifti 4D volume (X x Y x Z x frames)
+#  atlasV       nifti 3D atlas (X x Y x Z)
+#  operation    calc operation for each plane ('mode'(default),'max','min','mean','median','sum')
+
+from __future__ import print_function, division   # for Python 2 compatible
+
+import numpy as np
+from scipy.stats import mode
+
+def get(V, atlasV, operation='mode'):
+    roiIdx = np.unique(atlasV)
+    roiIdx = roiIdx[roiIdx != 0]  # remove 0
+
+    X = np.zeros((len(roiIdx), V.shape[3]), dtype=np.float32)
+    A = V.reshape(-1, V.shape[3])
+    for i in range(len(roiIdx)):
+        j = roiIdx[i]
+        B = A[atlasV.flatten() == j, :]
+        if operation == 'mode':
+            m = mode(B, axis=0, nan_policy='omit').mode[0]
+        elif operation == 'min':
+            m = np.nanmin(B, axis=0)
+        elif operation == 'max':
+            m = np.nanmax(B, axis=0)
+        elif operation == 'mean':
+            m = np.nanmean(B, axis=0)
+        elif operation == 'median':
+            m = np.nanmedian(B, axis=0)
+        elif operation == 'sum':
+            m = np.nansum(B, axis=0)
+        else:
+            raise ValueError(f"Unsupported operation: {operation}")
+        X[i, :] = m
+    return X