NeuroDOT-py 1.0.0__tar.gz

neurodot_py-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 ythackerCS
+
+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.

neurodot_py-1.0.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: NeuroDOT_py
+Version: 1.0.0
+Summary: An extensible Python toolbox for efficient optical brain mapping
+Author-email: "Adam T. Eggebrecht" <aeggebre@wustl.edu>, Emma Speh <espeh@wustl.edu>, Ari Segel <ari@wustl.edu>, Yash Thacker <ythacker@wustl.edu>
+Project-URL: Homepage, https://github.com/WUSTL-ORL/NeuroDOT_py
+Project-URL: Issues, https://github.com/WUSTL-ORL/NeuroDOT_py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+NeuroDOT_py README
+
+
+1. Installation:
+
+	1. First, download Python. NeuroDOT_py is optimized for Python version 3.8.8: https://www.python.org/downloads/
+	
+	2. Download VSCode: https://code.visualstudio.com
+	
+	3. Download the Jupyter notebook extension for VSCode: launch your VS Code and type “jupyter notebook” in the extension search box. Select the first result (Jupyter) and click 'Install'.
+	
+	4. Install NeuroDOT_py using Pip: pip install neuro_dot
+
+
+2. Geting Started
+		
+	1. The toolbox contains 4 folders: Data, neuro_dot, Support Files, and outputfiles/output_Images.
+	
+		1. The Data folder contains 10 data samples including both retinotopic mapping of visual cortex and mapping of hierarchical language processing with HD-DOT. There are also two example parameter files, 'params.txt,' and 'params2.txt' to be used with 'getting_started' (the NeuroDOT Preprocessing script).
+             
+		2. The neuro_dot folder contains the library, consisting of modules for each category of function involved in NeuroDOT_py (Analysis, File_IO, Light Modeling, Matlab   Equivalent Functions, Reconstruction, Spatial Transforms, Temporal Transforms, and Visualizations). There is also a function named DynamicFilter, which is used in 'getting_started.ipynb' to simplify visualizations for data pre-processing. There is also 'requirements.txt' which contains all of the necessary libraries to be installed to use NeuroDOT_py.	
+		
+		3. The Support Files folder contains necessary files for running NeuroDOT pipelines.
+			- The A matrix file required for Reconstruction is too large to be posted on GitHub, so it can be downloaded from: https://www.nitrc.org/projects/neurodot/. Other A matrices will be added in the future.
+	     
+		4. The 'outputfiles' folder is created after running 'getting_started' and is where all of the images (.png) generated will be saved to.
+	     
+	2. 'getting_started.ipynb' is the Jupyter notebook for getting acquainted with NeuroDOT_Py. This is the file that you will open in VSCode/Jupter Notebook to run and manipulate the code. 
+ 
+

neurodot_py-1.0.0/README.md

@@ -0,0 +1,30 @@
+NeuroDOT_py README
+
+
+1. Installation:
+
+	1. First, download Python. NeuroDOT_py is optimized for Python version 3.8.8: https://www.python.org/downloads/
+	
+	2. Download VSCode: https://code.visualstudio.com
+	
+	3. Download the Jupyter notebook extension for VSCode: launch your VS Code and type “jupyter notebook” in the extension search box. Select the first result (Jupyter) and click 'Install'.
+	
+	4. Install NeuroDOT_py using Pip: pip install neuro_dot
+
+
+2. Geting Started
+		
+	1. The toolbox contains 4 folders: Data, neuro_dot, Support Files, and outputfiles/output_Images.
+	
+		1. The Data folder contains 10 data samples including both retinotopic mapping of visual cortex and mapping of hierarchical language processing with HD-DOT. There are also two example parameter files, 'params.txt,' and 'params2.txt' to be used with 'getting_started' (the NeuroDOT Preprocessing script).
+             
+		2. The neuro_dot folder contains the library, consisting of modules for each category of function involved in NeuroDOT_py (Analysis, File_IO, Light Modeling, Matlab   Equivalent Functions, Reconstruction, Spatial Transforms, Temporal Transforms, and Visualizations). There is also a function named DynamicFilter, which is used in 'getting_started.ipynb' to simplify visualizations for data pre-processing. There is also 'requirements.txt' which contains all of the necessary libraries to be installed to use NeuroDOT_py.	
+		
+		3. The Support Files folder contains necessary files for running NeuroDOT pipelines.
+			- The A matrix file required for Reconstruction is too large to be posted on GitHub, so it can be downloaded from: https://www.nitrc.org/projects/neurodot/. Other A matrices will be added in the future.
+	     
+		4. The 'outputfiles' folder is created after running 'getting_started' and is where all of the images (.png) generated will be saved to.
+	     
+	2. 'getting_started.ipynb' is the Jupyter notebook for getting acquainted with NeuroDOT_Py. This is the file that you will open in VSCode/Jupter Notebook to run and manipulate the code. 
+ 
+

neurodot_py-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "NeuroDOT_py"
+version = "1.0.0"
+authors = [
+  { name = "Adam T. Eggebrecht", email = "aeggebre@wustl.edu"},
+  { name="Emma Speh", email="espeh@wustl.edu" },
+  { name ="Ari Segel", email = "ari@wustl.edu"},
+  { name = "Yash Thacker", email = "ythacker@wustl.edu"},
+
+]
+description =  "An extensible Python toolbox for efficient optical brain mapping"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+
+[project.urls]
+Homepage = "https://github.com/WUSTL-ORL/NeuroDOT_py"
+Issues = "https://github.com/WUSTL-ORL/NeuroDOT_py/issues"
+

neurodot_py-1.0.0/setup.cfg

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

neurodot_py-1.0.0/src/NeuroDOT_py.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: NeuroDOT_py
+Version: 1.0.0
+Summary: An extensible Python toolbox for efficient optical brain mapping
+Author-email: "Adam T. Eggebrecht" <aeggebre@wustl.edu>, Emma Speh <espeh@wustl.edu>, Ari Segel <ari@wustl.edu>, Yash Thacker <ythacker@wustl.edu>
+Project-URL: Homepage, https://github.com/WUSTL-ORL/NeuroDOT_py
+Project-URL: Issues, https://github.com/WUSTL-ORL/NeuroDOT_py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+NeuroDOT_py README
+
+
+1. Installation:
+
+	1. First, download Python. NeuroDOT_py is optimized for Python version 3.8.8: https://www.python.org/downloads/
+	
+	2. Download VSCode: https://code.visualstudio.com
+	
+	3. Download the Jupyter notebook extension for VSCode: launch your VS Code and type “jupyter notebook” in the extension search box. Select the first result (Jupyter) and click 'Install'.
+	
+	4. Install NeuroDOT_py using Pip: pip install neuro_dot
+
+
+2. Geting Started
+		
+	1. The toolbox contains 4 folders: Data, neuro_dot, Support Files, and outputfiles/output_Images.
+	
+		1. The Data folder contains 10 data samples including both retinotopic mapping of visual cortex and mapping of hierarchical language processing with HD-DOT. There are also two example parameter files, 'params.txt,' and 'params2.txt' to be used with 'getting_started' (the NeuroDOT Preprocessing script).
+             
+		2. The neuro_dot folder contains the library, consisting of modules for each category of function involved in NeuroDOT_py (Analysis, File_IO, Light Modeling, Matlab   Equivalent Functions, Reconstruction, Spatial Transforms, Temporal Transforms, and Visualizations). There is also a function named DynamicFilter, which is used in 'getting_started.ipynb' to simplify visualizations for data pre-processing. There is also 'requirements.txt' which contains all of the necessary libraries to be installed to use NeuroDOT_py.	
+		
+		3. The Support Files folder contains necessary files for running NeuroDOT pipelines.
+			- The A matrix file required for Reconstruction is too large to be posted on GitHub, so it can be downloaded from: https://www.nitrc.org/projects/neurodot/. Other A matrices will be added in the future.
+	     
+		4. The 'outputfiles' folder is created after running 'getting_started' and is where all of the images (.png) generated will be saved to.
+	     
+	2. 'getting_started.ipynb' is the Jupyter notebook for getting acquainted with NeuroDOT_Py. This is the file that you will open in VSCode/Jupter Notebook to run and manipulate the code. 
+ 
+

neurodot_py-1.0.0/src/NeuroDOT_py.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/NeuroDOT_py.egg-info/PKG-INFO
+src/NeuroDOT_py.egg-info/SOURCES.txt
+src/NeuroDOT_py.egg-info/dependency_links.txt
+src/NeuroDOT_py.egg-info/top_level.txt
+src/neuro_dot/Analysis.py
+src/neuro_dot/DynamicFilter.py
+src/neuro_dot/File_IO.py
+src/neuro_dot/Light_Modeling.py
+src/neuro_dot/Matlab_Equivalent_Functions.py
+src/neuro_dot/Reconstruction.py
+src/neuro_dot/Spatial_Transforms.py
+src/neuro_dot/Temporal_Transforms.py
+src/neuro_dot/Visualizations.py
+src/neuro_dot/__init__.py

neurodot_py-1.0.0/src/NeuroDOT_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

neurodot_py-1.0.0/src/NeuroDOT_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+neuro_dot

neurodot_py-1.0.0/src/neuro_dot/Analysis.py

@@ -0,0 +1,237 @@
+# General imports
+import numpy as np
+import numpy.linalg as lna
+
+import neuro_dot as ndot
+
+
+   
+def BlockAverage(data_in, pulse, dt, Tkeep = 0):
+    """ 
+    BLOCKAVERAGE Averages data by stimulus blocks.
+
+    data_out = BLOCKAVERAGE(data_in, pulse, dt) takes a data array "data_in" 
+    and uses the pulse and dt information to cut that data timewise into 
+    blocks of equal length (dt), which are then averaged together and 
+    output as "data_out".
+    
+    Tkeep is a temporal mask. Any time points with a zero in this vector is
+    set to NaN.
+    """
+    ## Parameters and Initialization.
+    dims = np.shape(data_in)
+    Nt = dims[-1]
+    NDtf = np.ndim(data_in) > 2
+    Nbl = len(pulse)
+
+    if Tkeep == 0:
+        Tkeep = np.ones(shape = (Nt, 1))==1 
+
+    # Check to make sure that the block after the last synch point for this
+    if (dt + pulse[-1] - 1) > Nt:
+        Nbl = Nbl - 1
+
+    ## N-D Input (for 3-D or N-D voxel spaces).
+    if NDtf:
+        data_in = np.reshape(data_in, [], Nt)
+
+    ## Incorporate Tkeep  
+    data_in[:, np.argwhere(Tkeep == False)] = np.NaN
+
+    ## Cut data into blocks.
+    Nm = np.shape(data_in)[0]
+    blocks = np.zeros((Nm, dt, Nbl))
+
+    for p in range(0,len(pulse)):
+        pulse[p] = pulse[p] +1
+
+    for k in range(0, Nbl):
+        pulse_k = int(pulse[k])
+
+        if (pulse[k] + dt -1) <= Nt:
+            blocks[:, :, k] = data_in[:, pulse_k-1:pulse_k + dt-1] #Need to subtract 1 from both indices to account for 0 indexing in python
+        else:
+            dtb = (pulse_k-1) + dt - 1 - Nt+1
+            nans = np.empty(shape = (np.shape(data_in)[0], dtb)) # need multiple lines to create an array of nans in python
+            nans[:] = np.NaN
+            blocks[:, :, k] = np.concatenate((data_in[:, (pulse_k-1):Nt], nans), axis = 1) # need to subtract 1 from start index: pulse[k] due to zero indexing, also need to use Nt as final index to get correct size
+
+    ## Average blocks and return.
+    BA_out = np.nanmean(blocks, axis = 2) 
+    BSTD_out = np.nanstd(blocks, axis = 2, ddof = 1) 
+    nanmean_cols = np.nanmean(BA_out, axis = 1)
+    nanmean_matrix = np.ones(np.shape(BA_out))
+    for x in range(0, dt): 
+        nanmean_matrix[:, x] = nanmean_cols
+    BA_out = BA_out - nanmean_matrix
+    BT_out = np.divide(BA_out, BSTD_out)
+    BT_out[np.argwhere(np.isinf(BT_out))] = 0
+
+    ## N-D Output.
+    if NDtf:
+        #create tuple containing the desired output shape for BA_out, BSTD_out and BT_out
+        #tuple contains first axis until second to last axis of data with dt appeneded to the end of it
+        newshape = tuple(np.append(np.array(dims[0:-1]), dt))
+        BA_out = np.reshape(BA_out, newshape)
+        BSTD_out = np.reshape(BSTD_out, newshape)
+        BT_out = np.reshape(BT_out, newshape)
+        newshape_blocks = tuple(np.append(np.array(dims[0:-1]), (dt, Nbl))) # create tuple for deisred output shape for blocks, different from previous newshape bc Nbl is also appended
+        blocks = np.reshape(blocks, newshape_blocks)
+
+
+    return BA_out, BSTD_out, BT_out, blocks
+
+
+def CalcGVTD(data):
+    """
+    CalcGVTD calculates the Root Mean Square across measurements (log-mean light levels or voxels) of the temporal derivative. 
+
+    The data is assumed to have measurements in the first and time in the last 
+    dimension. 
+    
+    Any selection of measurement type or voxel index must be done
+    outside of this function.
+    """
+    # Double check data has correct dimensions
+    # Dsizes=size(data);
+    Dsizes = np.shape(data)
+    Ndim = len(Dsizes)
+    if Ndim > 2:
+        data = np.reshape(data, [], Dsizes[-1])
+    
+    # 1st Temporal Derivative
+    Ddata = data - np.roll(data, np.array([0, -1]), np.array([0,-1])) 
+
+    # RMS across measurements
+    GVTD = np.concatenate(([0], ndot.rms_py(Ddata[:,0:-1])), axis = 0)
+
+    return GVTD
+
+
+def FindGoodMeas(data, info_in, bthresh = 0.075):
+
+    """ 
+    FINDGOODMEAS Performs "Good Measurements" analysis to return indices of measurements within a chosen threshold.
+
+    info_out = FINDGOODMEAS(data, info_in) takes a light-level array "data"
+    in the MEAS x TIME format, and calculates the std of each channel
+    as its noise level. 
+
+    These are then thresholded by the default value of
+    0.075 to create a logical array, and both are returned as MEAS x 1
+    columns of the "info.MEAS" table. 
+    
+    If pulse synch point information exists in "info.system.synchpts",
+    then FINDGOODMEAS will crop the data to the start and stop pulses.
+
+    info_out = FINDGOODMEAS(data, info_in, bthresh) allows the user to
+    specify a threshold value.
+    
+    See Also: PLOTCAPGOODMEAS, PLOTHISTOGRAMSTD.
+    """
+    ## Parameters and Initialization.
+    # look for required info, FGM will not run if these fields are nonexistant
+    try:
+        info1 = info_in['system']['framerate']
+    except KeyError:
+        print('info_in["system"]["framerate"] does not exist and is required')
+        print('exiting FindGoodMeas')
+        return()
+    try:
+        info1 = info_in['pairs']
+    except KeyError:
+        print('info_in["pairs"] does not exist and is required')
+        print('exiting FindGoodMeas')
+        return()
+    info_out = info_in.copy() # create info_out
+    try:
+        GVwin
+    except NameError:
+        GVwin = 600
+    if not 'paradigm' in info_out:
+        info_out['paradigm'] = {}
+    if not bthresh in locals():
+        bthresh = 0.075 # Empirically derived threshold value.
+    dims = data.shape
+    Nt = dims[-1]       # Assumes time is always the last dimension
+    NDtf = np.ndim(data) > 2
+    if GVwin > (Nt-1):
+        GVwin = (Nt-1)
+    
+    # N-D Input.
+    if NDtf:
+        data = np.reshape(data, [], Nt)
+    
+    # Crop data to synchpts if necessary. 
+    keep = np.logical_and(info_in['pairs']['r2d'] < 20, info_in['pairs']['WL'] == 2)
+    foo = np.squeeze(data[keep,:])
+    foo = ndot.highpass(foo, 0.02, info_in['system']['framerate']) # bandpass filter, omega_hp = 0.02
+    foo = ndot.lowpass(foo, 1, info_in['system']['framerate'])     # bandpass filter, omega_lp = 1
+    foo = foo - np.roll(foo, 1, 1)
+    foo[:,0] = 0
+    foob = ndot.rms_py(foo) # uses new rms that only takes one input, calculates rms for every column in rms_input and outputs row vector
+    NtGV = Nt - GVwin
+    NtGV_mat = np.ones((1,NtGV), dtype = np.int8)  
+
+    if NtGV > 1: # sliding window to grab a meaningful set for 'quiet'
+        GVTD_win_means = np.zeros(NtGV, order = 'F')
+        i = 0
+        while i <= (NtGV - 1):
+            GVTD_win_means[i] =  np.mean(foob[i:((i+1)+ GVwin - 1)])
+            i = i+1
+        t0 = np.where(GVTD_win_means == np.min(GVTD_win_means)) # find min and set t0 --> tF
+        tF = t0[0][0] + GVwin 
+        STD = np.std(data[:, t0[0][0]:tF], 1, ddof= 1)          # Calulate STD, make sure ddof param is set = 1 so that np.STD behaves the same as matlab STD
+    elif not 'synchpts' in info_out['paradigm']:
+        NsynchPts = len(info_out['paradigm']['synchpts'])
+        if NsynchPts > 2:
+            tF = info_out['paradigm']['synchpts'][-1]
+            t0 = info_out['paradigm']['synchpts'][0]
+        elif NsynchPts == 2:
+            tF = info_out['paradigm']['synchpts'][1]
+            t0 = info_out['paradigm']['synchpts'][0]
+        else:
+            tF = data.shape[1]
+        STD = np.std(data[:, t0:tF], 1, ddof=1)                 # Calculate STD.
+    else:
+        STD = np.std(data, 1, ddof=1)
+    
+    # Populate in table of on-the-fly calculated stuff.
+    info_out['GVTDparams'] = {}
+    info_out['GVTDparams']['t0'] = t0[0][0]
+    info_out['GVTDparams']['tF'] = tF
+    if not 'MEAS' in info_out:
+        info_out['MEAS'] = {}
+        info_out['MEAS']['STD'] = STD
+        info_out['MEAS']['GI'] = np.zeros(np.shape(STD), dtype = np.uint8)
+        info_out['MEAS']['GI'][np.where(STD <= bthresh)] = 1
+    else:
+        info_out['MEAS']['STD'] = STD
+        info_out['MEAS']['GI'] = np.zeros(np.shape(STD), dtype = np.uint8)
+        info_out['MEAS']['GI'][np.where(STD <= bthresh)] = 1
+    if 'Clipped' in info_out['MEAS']:
+        info_out['MEAS']['GI'] = np.zeros(np.shape(STD), dtype = np.uint8)
+        info_out['MEAS']['GI'][np.where(info_out['MEAS']['GI'] and not info_out['MEAS']['Clipped'])] = 1
+    
+    return info_out
+
+
+def normcND(data):
+    """ 
+    NORMCND returns a column-normed matrix. It is assumed that the matrix is 2D.
+    """
+    vecnorm = lna.norm(data, ord = 2, axis = 0)
+    data = data / vecnorm
+
+    return data
+
+
+def normrND(data):
+    """
+    NORMRND returns a row-normed matrix. It is assumed that the matrix is 2D. Updated for broader compatability.
+    """
+    dataNorm = np.sqrt(np.sum(data**2))
+    data = data / dataNorm
+    data[np.argwhere(np.isfinite(data) == False)] = 0
+
+    return data