major update:

- directory structure reorganized
- process_ecog signal_processing module included as a module of ecogvis
- lowercase package name
- Added MANIFEST.in to include .ui files on installation

Author: root

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include ecogvis/ui *

ecogvis/__init__.py

@@ -0,0 +1,4 @@
+#from .functions import *
+#from .signal_processing import *
+#from .ui import *
+from ecogvis import *

ecog_vis.py ecogvis/ecogvis.py

@@ -12,8 +12,8 @@
     QAction, QStackedLayout)
 import pyqtgraph as pg
 from pyqtgraph.widgets.MatplotlibWidget import MatplotlibWidget
-from Function.subFunctions import ecogVIS
-from Function.subDialogs import (CustomIntervalDialog, SelectChannelsDialog,
+from ecogvis.functions.subFunctions import ecogVIS
+from ecogvis.functions.subDialogs import (CustomIntervalDialog, SelectChannelsDialog,
     SpectralChoiceDialog, PeriodogramDialog, NoHighGammaDialog, NoPreprocessedDialog,
     NoTrialsDialog, ExitDialog, ERPDialog, CalcHighGammaDialog, GroupPeriodogramDialog)
 
@@ -839,11 +839,12 @@ def main(filename):
     sys.exit(app.exec_())
 
 # If called from a command line, e.g.: $ python ecog_ts_gui.py
-if __name__ == '__main__':
-    app = QApplication(sys.argv)  #instantiate a QtGui (holder for the app)
-    if len(sys.argv)==1:
-        fname = ''
-    else:
-        fname = sys.argv[1]
-    ex = Application(filename=fname)
-    sys.exit(app.exec_())
+# NOT WORKING ANYMORE
+# if __name__ == '__main__':
+#     app = QApplication(sys.argv)  #instantiate a QtGui (holder for the app)
+#     if len(sys.argv)==1:
+#         fname = ''
+#     else:
+#         fname = sys.argv[1]
+#     ex = Application(filename=fname)
+#     sys.exit(app.exec_())

Function/FS_colorLUT.py ecogvis/functions/FS_colorLUT.py

@@ -4,19 +4,19 @@
 import pyqtgraph as pg
 import pyqtgraph.opengl as gl
 import pyqtgraph.exporters as pgexp
-from ecog.utils import bands as default_bands
-from ecog.signal_processing.preprocess_data import preprocess_data
+from ecogvis.signal_processing import bands as default_bands
+from ecogvis.signal_processing.preprocess_data import preprocess_data
 from .FS_colorLUT import get_lut
 from threading import Event, Thread
 import numpy as np
 from scipy import signal
 import os
 import time
 
-path = os.path.dirname(__file__)
+ui_path = os.path.join(os.path.dirname(__file__), '..', 'ui')
 
 # Creates custom interval type -------------------------------------------------
-Ui_CustomInterval, _ = uic.loadUiType(os.path.join(path,"intervals_gui.ui"))
+Ui_CustomInterval, _ = uic.loadUiType(os.path.join(ui_path,"intervals_gui.ui"))
 class CustomIntervalDialog(QtGui.QDialog, Ui_CustomInterval):
     def __init__(self):
         super().__init__()
@@ -143,7 +143,7 @@ def cancel(self):
 
 
 # Exit confirmation ------------------------------------------------------------
-Ui_Exit, _ = uic.loadUiType(os.path.join(path,"exit_gui.ui"))
+Ui_Exit, _ = uic.loadUiType(os.path.join(ui_path,"exit_gui.ui"))
 class ExitDialog(QtGui.QDialog, Ui_Exit):
     def __init__(self, parent):
         super().__init__()
@@ -241,7 +241,7 @@ def unselect_all(self):
 
 
 # Creates Spectral Analysis choice dialog --------------------------------------
-Ui_SpectralChoice, _ = uic.loadUiType(os.path.join(path,"spectral_choice_gui.ui"))
+Ui_SpectralChoice, _ = uic.loadUiType(os.path.join(ui_path,"spectral_choice_gui.ui"))
 class SpectralChoiceDialog(QtGui.QDialog, Ui_SpectralChoice):
     def __init__(self, nwb, fpath, fname):
         super().__init__()
@@ -252,7 +252,7 @@ def __init__(self, nwb, fpath, fname):
 
         self.data_exists = False    #Indicates if data already exists or will be created
         self.decomp_type = None     #Indicates the chosen decomposition type
-        self.custom_bands = None    #Values for custom filter bands (user input)
+        self.chosen_bands = None    #Values for custom filter bands (user input)
         self.value = -1             #Reference value for user pressed exit button
 
         self.radioButton_1.clicked.connect(self.choice_default)
@@ -269,7 +269,6 @@ def __init__(self, nwb, fpath, fname):
 
     def choice_default(self):  # default chosen
         self.decomp_type = 'default'
-        self.custom_bands = None
         self.pushButton_1.setEnabled(False)
         self.pushButton_2.setEnabled(False)
         self.tableWidget.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
@@ -306,25 +305,15 @@ def choice_default(self):  # default chosen
 
     def choice_highgamma(self):  # default chosen
         self.decomp_type = 'high_gamma'
-        self.custom_bands = None
         self.pushButton_1.setEnabled(False)
         self.pushButton_2.setEnabled(False)
         self.tableWidget.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
         try:    # if data already exists in file
             decomp = self.nwb.modules['ecephys'].data_interfaces['high_gamma']
-            text = "'High gamma' frequency decomposition data already exists in current file.\n" \
-                   "It corresponds to the averaged power of the bands shown in the table."
+            text = "'High gamma' frequency decomposition data already exists in current file."
             self.label_1.setText(text)
             self.data_exists = True
             self.runButton.setEnabled(False)
-            # Populate table with values
-            self.tableWidget.setHorizontalHeaderLabels(['center [Hz]','sigma [Hz]'])
-            p0 = default_bands.chang_lab['cfs'][29:37]
-            p1 = default_bands.chang_lab['sds'][29:37]
-            self.tableWidget.setRowCount(len(p0))
-            for i in np.arange(len(p0)):
-                self.tableWidget.setItem(i, 0, QTableWidgetItem(str(round(p0[i],1))))
-                self.tableWidget.setItem(i, 1, QTableWidgetItem(str(round(p1[i],1))))
         except:   # if data does not exist in file
             text = "'High gamma' frequency decomposition data does not exist in current file.\n" \
                    "It can be created from the averaged power of the bands shown in the table. "\
@@ -340,11 +329,14 @@ def choice_highgamma(self):  # default chosen
             for i in np.arange(len(p0)):
                 self.tableWidget.setItem(i, 0, QTableWidgetItem(str(round(p0[i],1))))
                 self.tableWidget.setItem(i, 1, QTableWidgetItem(str(round(p1[i],1))))
+            # Allows user to populate table with values
+            self.tableWidget.setEditTriggers(QtGui.QAbstractItemView.DoubleClicked)
+            self.pushButton_1.setEnabled(True)
+            self.pushButton_2.setEnabled(True)
 
 
     def choice_custom(self):  # default chosen
         self.decomp_type = 'custom'
-        self.custom_bands = None
         try:    # if data already exists in file
             decomp = self.nwb.modules['ecephys'].data_interfaces['Bandpower_custom']
             text = "'Custom' frequency decomposition data already exists in current file.\n" \
@@ -357,12 +349,9 @@ def choice_custom(self):  # default chosen
             p0 = decomp.bands['filter_param_0']
             p1 = decomp.bands['filter_param_1']
             self.tableWidget.setRowCount(len(p0))
-            self.custom_bands = np.zeros((2,len(p0)))
             for i in np.arange(len(p0)):
                 self.tableWidget.setItem(i, 0, QTableWidgetItem(str(round(p0[i],1))))
                 self.tableWidget.setItem(i, 1, QTableWidgetItem(str(round(p1[i],1))))
-                self.custom_bands[i,0] = round(p0[i],1)
-                self.custom_bands[i,1] = round(p1[i],1)
         except:  # if data does not exist in file
             text = "'Custom' frequency decomposition data does not exist in current file.\n" \
                    "To create it, add the bands of interest to the table. "\
@@ -390,12 +379,12 @@ def del_band(self):
         self.tableWidget.removeRow(nRows-1)
 
     def run_decomposition(self):
-        if self.decomp_type=='custom':
+        if self.decomp_type!='default':
             nRows = self.tableWidget.rowCount()
-            self.custom_bands = np.zeros((2,nRows))
+            self.chosen_bands = np.zeros((2,nRows))
             for i in np.arange(nRows):
-                self.custom_bands[0,i] = float(self.tableWidget.item(i, 0).text())
-                self.custom_bands[1,i] = float(self.tableWidget.item(i, 1).text())
+                self.chosen_bands[0,i] = float(self.tableWidget.item(i, 0).text())
+                self.chosen_bands[1,i] = float(self.tableWidget.item(i, 1).text())
         # If Decomposition data does not exist in NWB file and user decides to create it
         self.label_2.setText('Processing spectral decomposition. Please wait...')
         self.pushButton_1.setEnabled(False)
@@ -409,7 +398,7 @@ def run_decomposition(self):
             block = [ aux.split('.')[0][1:] ]
             self.thread = ChildProgram(path=self.fpath, subject=subj,
                                        blocks=block, filter=self.decomp_type,
-                                       bands_vals=self.custom_bands)
+                                       bands_vals=self.chosen_bands)
             self.thread.finished.connect(self.out_close)
             self.thread.start()
 

ecogvis/functions/__init__.py

@@ -0,0 +1,6 @@
+from .hilbert_transform import *
+from .resample import *
+from .linenoise_notch import *
+#from .zscore import *
+from .common_referencing import *
+from .preprocess_data import *

Function/read_HTK.py ecogvis/functions/read_HTK.py

@@ -0,0 +1,28 @@
+"""
+Frequency band information for different types of data processing.
+"""
+import numpy as np
+
+# Chang lab frequencies
+fq_min = 4.0749286538265
+fq_max = 200.
+scale = 7.
+cfs = 2 ** (np.arange(np.log2(fq_min) * scale, np.log2(fq_max) * scale) / scale)
+cfs = np.array(cfs)
+sds = 10 ** ( np.log10(.39) + .5 * (np.log10(cfs)))
+sds = np.array(sds) * np.sqrt(2.)
+chang_lab = {'fq_min': fq_min,
+             'fq_max': fq_max,
+             'scale': scale,
+             'cfs': cfs,
+             'sds': sds}
+
+# Standard neuro bands
+bands = ['theta', 'alpha', 'beta', 'gamma', 'high gamma']
+min_freqs = [4., 8., 15., 30., 70.]
+max_freqs = [7., 14., 29., 59., 150.]
+HG_freq = 200.
+neuro = {'bands': bands,
+         'min_freqs': min_freqs,
+         'max_freqs': max_freqs,
+         'HG_freq': HG_freq}

Function/subDialogs.py ecogvis/functions/subDialogs.py

@@ -0,0 +1,49 @@
+from __future__ import division
+import numpy as np
+
+
+__all__ = ['subtract_CAR',
+           'subtract_common_median_reference']
+
+def subtract_CAR(X, b_size=16):
+    """
+    Compute and subtract common average reference in 16 channel blocks.
+    """
+
+    channels, time_points = X.shape
+    s = channels // b_size
+    r = channels % b_size
+
+    X_1 = X[:channels-r].copy()
+
+    X_1 = X_1.reshape((s, b_size, time_points))
+    X_1 -= np.nanmean(X_1, axis=1, keepdims=True)
+    if r > 0:
+        X_2 = X[channels-r:].copy()
+        X_2 -= np.nanmean(X_2, axis=0, keepdims=True)
+        X = np.vstack([X_1.reshape((s*b_size, time_points)), X_2])
+        return X
+    else:
+        return X_1.reshape((s*b_size, time_points))
+
+
+def subtract_common_median_reference(X, channel_axis=-2):
+    """
+    Compute and subtract common median reference
+    for the entire grid.
+
+    Parameters
+    ----------
+    X : ndarray (..., n_channels, n_time)
+        Data to common median reference.
+
+    Returns
+    -------
+    Xp : ndarray (..., n_channels, n_time)
+        Common median referenced data.
+    """
+
+    median = np.nanmedian(X, axis=channel_axis, keepdims=True)
+    Xp = X - median
+
+    return Xp

Function/subFunctions.py ecogvis/functions/subFunctions.py

@@ -0,0 +1,11 @@
+import numpy as np
+
+from numpy.fft import rfftfreq, fftfreq
+
+try:
+    from mkl_fft._numpy_fft import rfft, irfft, fft, ifft
+except ImportError:
+    try:
+        from pyfftw.interfaces.numpy_fft import rfft, irfft, fft, ifft
+    except ImportError:
+        from numpy.fft import rfft, irfft, fft, ifft

ecogvis/signal_processing/__init__.py

@@ -0,0 +1,92 @@
+from __future__ import division
+import numpy as np
+
+from .fft import fftfreq, fft, ifft
+try:
+    from accelerate.mkl.fftpack import fft, ifft
+except ImportError:
+    try:
+        from pyfftw.interfaces.numpy_fft import fft, ifft
+    except ImportError:
+        from numpy.fft import fft, ifft
+
+
+__authors__ = "Alex Bujan, Jesse Livezey"
+
+
+__all__ = ['gaussian', 'hamming', 'hilbert_transform']
+
+
+def gaussian(X, rate, center, sd):
+    time = X.shape[-1]
+    freq = fftfreq(time, 1./rate)
+
+    k = np.exp((-(np.abs(freq) - center)**2)/(2 * (sd**2)))
+    k /= np.linalg.norm(k)
+
+    return k
+
+
+def hamming(X, rate, min_freq, max_freq):
+    time = X.shape[-1]
+    freq = fftfreq(time, 1./rate)
+
+    pos_in_window = np.logical_and(freq >= min_freq, freq <= max_freq)
+    neg_in_window = np.logical_and(freq <= -min_freq, freq >= -max_freq)
+
+    k = np.zeros(len(freq))
+    window_size = np.count_nonzero(pos_in_window)
+    window = np.hamming(window_size)
+    k[pos_in_window] = window
+    window_size = np.count_nonzero(neg_in_window)
+    window = np.hamming(window_size)
+    k[neg_in_window] = window
+    k /= np.linalg.norm(k)
+
+    return k
+
+
+def hilbert_transform(X, rate, filters=None, phase=None, X_fft_h=None):
+    """
+    Apply bandpass filtering with Hilbert transform using
+    a prespecified set of filters.
+
+    Parameters
+    ----------
+    X : ndarray (n_channels, n_time)
+        Input data, dimensions
+    rate : float
+        Number of samples per second.
+    filters : filter or list of filters (optional)
+        One or more bandpass filters
+
+    Returns
+    -------
+    Xh : ndarray, complex
+        Bandpassed analytic signal
+    """
+    if not isinstance(filters, list):
+        filters = [filters]
+    time = X.shape[-1]
+    freq = fftfreq(time, 1. / rate)
+
+    Xh = np.zeros((len(filters),) + X.shape, dtype=np.complex)
+    if X_fft_h is None:
+        # Heavyside filter
+        h = np.zeros(len(freq))
+        h[freq > 0] = 2.
+        h[0] = 1.
+        h = h[np.newaxis, :]
+        X_fft_h = fft(X) * h
+        if phase is not None:
+            X_fft_h *= phase
+    for ii, f in enumerate(filters):
+        if f is None:
+            Xh[ii] = ifft(X_fft_h)
+        else:
+            f = f / np.linalg.norm(f)
+            Xh[ii] = ifft(X_fft_h * f)
+    if Xh.shape[0] == 1:
+        return Xh[0], X_fft_h
+
+    return Xh, X_fft_h