Pulled SVN into GIT.

INSTALL.txt

+Akvo is a surface NMR (sNMR) processing utility. Currently preprocessing is supported, but we are adding inversion capabilities. 
+
+Installation is done in the typical python fashion
+
+python setup.py build 
+python setup.py build_ui   # OPTIONAL, see below
+python setup.py install    # requires sudo on most installations 
+
+# If you are going to be editing the source code, you may prefer to run 
+# the develop option which will not require rerunning the install option 
+# for each edit. This is entirely optional 
+python setup.py develop    # requires sudo on most installations 
+
+## Building the user interface 
+Akvo ships with a
+
+## On some platforms you may receive an error regarding PyQt5, it should be possible to manually 
+## install this via 
+pip install PyQt5 
+## Or 
+pip3 install PyQt5 

LICENSE.txt

+Akvo, a surface NMR workbench
+Copyright (C) 2014-2017 Trevor P. Irons  
+Copyright (C) 2017 M. Andrew Kass  
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

akvo/__init__.py

+#import akvo.tressel.decay

akvo/gui/__init__.py

+#import mainui.py 

akvo/gui/main2ui.py

+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'main.ui'
+#
+# Created: Fri Jan 11 23:28:48 2013
+#      by: PyQt4 UI code generator 4.9.6
+#
+# WARNING! All changes made in this file will be lost!
+

akvo/gui/mainui2.py

+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'main.ui'
+#
+# Created: Fri Jan 11 23:34:58 2013
+#      by: PyQt4 UI code generator 4.9.6
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_MainWindow(object):
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName(_fromUtf8("MainWindow"))
+        MainWindow.resize(1000, 980)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(MainWindow.sizePolicy().hasHeightForWidth())
+        MainWindow.setSizePolicy(sizePolicy)
+        MainWindow.setMinimumSize(QtCore.QSize(60, 60))
+        MainWindow.setMaximumSize(QtCore.QSize(1000, 16777215))
+        MainWindow.setWindowOpacity(1.0)
+        MainWindow.setAutoFillBackground(True)
+        self.centralwidget = QtGui.QWidget(MainWindow)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.centralwidget.sizePolicy().hasHeightForWidth())
+        self.centralwidget.setSizePolicy(sizePolicy)
+        self.centralwidget.setMinimumSize(QtCore.QSize(0, 0))
+        self.centralwidget.setMaximumSize(QtCore.QSize(1000, 16777215))
+        self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
+        self.horizontalLayout = QtGui.QHBoxLayout(self.centralwidget)
+        self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
+        self.scrollArea = QtGui.QScrollArea(self.centralwidget)
+        self.scrollArea.setWidgetResizable(True)
+        self.scrollArea.setObjectName(_fromUtf8("scrollArea"))
+        self.scrollAreaWidgetContents = QtGui.QWidget()
+        self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 986, 927))
+        self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
+        self.horizontalLayout_2 = QtGui.QHBoxLayout(self.scrollAreaWidgetContents)
+        self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
+        self.tabWidget = QtGui.QTabWidget(self.scrollAreaWidgetContents)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.tabWidget.sizePolicy().hasHeightForWidth())
+        self.tabWidget.setSizePolicy(sizePolicy)
+        self.tabWidget.setMinimumSize(QtCore.QSize(940, 0))
+        self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
+        self.tab = QtGui.QWidget()
+        self.tab.setObjectName(_fromUtf8("tab"))
+        self.gridLayout = QtGui.QGridLayout(self.tab)
+        self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
+        self.groupBox_4 = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox_4.sizePolicy().hasHeightForWidth())
+        self.groupBox_4.setSizePolicy(sizePolicy)
+        self.groupBox_4.setMinimumSize(QtCore.QSize(480, 150))
+        self.groupBox_4.setFlat(False)
+        self.groupBox_4.setCheckable(True)
+        self.groupBox_4.setObjectName(_fromUtf8("groupBox_4"))
+        self.gridLayout.addWidget(self.groupBox_4, 4, 1, 1, 1)
+        self.groupBox = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox.sizePolicy().hasHeightForWidth())
+        self.groupBox.setSizePolicy(sizePolicy)
+        self.groupBox.setMinimumSize(QtCore.QSize(460, 230))
+        self.groupBox.setAutoFillBackground(False)
+        self.groupBox.setFlat(False)
+        self.groupBox.setObjectName(_fromUtf8("groupBox"))
+        self.headerFileTextBrowser = QtGui.QTextBrowser(self.groupBox)
+        self.headerFileTextBrowser.setGeometry(QtCore.QRect(10, 30, 441, 31))
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.headerFileTextBrowser.sizePolicy().hasHeightForWidth())
+        self.headerFileTextBrowser.setSizePolicy(sizePolicy)
+        font = QtGui.QFont()
+        font.setPointSize(8)
+        font.setItalic(True)
+        self.headerFileTextBrowser.setFont(font)
+        self.headerFileTextBrowser.setObjectName(_fromUtf8("headerFileTextBrowser"))
+        self.label_4 = QtGui.QLabel(self.groupBox)
+        self.label_4.setGeometry(QtCore.QRect(10, 70, 81, 21))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.pulseTypeTextBrowser = QtGui.QTextBrowser(self.groupBox)
+        self.pulseTypeTextBrowser.setGeometry(QtCore.QRect(90, 70, 361, 21))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.pulseTypeTextBrowser.setFont(font)
+        self.pulseTypeTextBrowser.setAcceptDrops(True)
+        self.pulseTypeTextBrowser.setObjectName(_fromUtf8("pulseTypeTextBrowser"))
+        self.lcdNumberNuTx = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberNuTx.setGeometry(QtCore.QRect(160, 100, 64, 23))
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Minimum)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.lcdNumberNuTx.sizePolicy().hasHeightForWidth())
+        self.lcdNumberNuTx.setSizePolicy(sizePolicy)
+        font = QtGui.QFont()
+        font.setPointSize(8)
+        self.lcdNumberNuTx.setFont(font)
+        self.lcdNumberNuTx.setWhatsThis(_fromUtf8(""))
+        self.lcdNumberNuTx.setAutoFillBackground(False)
+        self.lcdNumberNuTx.setStyleSheet(_fromUtf8("#lcdNumberNuTx {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberNuTx:disabled {\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberNuTx.setFrameShadow(QtGui.QFrame.Raised)
+        self.lcdNumberNuTx.setLineWidth(1)
+        self.lcdNumberNuTx.setMidLineWidth(0)
+        self.lcdNumberNuTx.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberNuTx.setProperty("value", 0.0)
+        self.lcdNumberNuTx.setObjectName(_fromUtf8("lcdNumberNuTx"))
+        self.lcdNumberTuneuF = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberTuneuF.setGeometry(QtCore.QRect(370, 100, 64, 23))
+        self.lcdNumberTuneuF.setStyleSheet(_fromUtf8("#lcdNumberTuneuF {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberTuneuF:disabled {\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberTuneuF.setLineWidth(1)
+        self.lcdNumberTuneuF.setMidLineWidth(0)
+        self.lcdNumberTuneuF.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberTuneuF.setObjectName(_fromUtf8("lcdNumberTuneuF"))
+        self.lcdNumberTauPulse1 = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberTauPulse1.setGeometry(QtCore.QRect(160, 130, 64, 23))
+        self.lcdNumberTauPulse1.setStyleSheet(_fromUtf8("#lcdNumberTauPulse1 {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberTauPulse1:disabled {\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberTauPulse1.setFrameShadow(QtGui.QFrame.Raised)
+        self.lcdNumberTauPulse1.setLineWidth(1)
+        self.lcdNumberTauPulse1.setMidLineWidth(0)
+        self.lcdNumberTauPulse1.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberTauPulse1.setObjectName(_fromUtf8("lcdNumberTauPulse1"))
+        self.label_6 = QtGui.QLabel(self.groupBox)
+        self.label_6.setGeometry(QtCore.QRect(10, 100, 91, 21))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.label_7 = QtGui.QLabel(self.groupBox)
+        self.label_7.setGeometry(QtCore.QRect(10, 130, 141, 21))
+        self.label_7.setObjectName(_fromUtf8("label_7"))
+        self.label_13 = QtGui.QLabel(self.groupBox)
+        self.label_13.setGeometry(QtCore.QRect(260, 160, 91, 21))
+        self.label_13.setObjectName(_fromUtf8("label_13"))
+        self.lcdNumberTauPulse2 = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberTauPulse2.setGeometry(QtCore.QRect(160, 160, 64, 23))
+        self.lcdNumberTauPulse2.setStyleSheet(_fromUtf8("#lcdNumberTauPulse2 {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberTauPulse2:disabled{\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberTauPulse2.setLineWidth(1)
+        self.lcdNumberTauPulse2.setMidLineWidth(0)
+        self.lcdNumberTauPulse2.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberTauPulse2.setObjectName(_fromUtf8("lcdNumberTauPulse2"))
+        self.label_14 = QtGui.QLabel(self.groupBox)
+        self.label_14.setGeometry(QtCore.QRect(260, 100, 111, 21))
+        self.label_14.setObjectName(_fromUtf8("label_14"))
+        self.label_15 = QtGui.QLabel(self.groupBox)
+        self.label_15.setGeometry(QtCore.QRect(260, 130, 111, 21))
+        self.label_15.setObjectName(_fromUtf8("label_15"))
+        self.lcdNumberSampFreq = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberSampFreq.setEnabled(True)
+        self.lcdNumberSampFreq.setGeometry(QtCore.QRect(370, 130, 64, 23))
+        self.lcdNumberSampFreq.setStyleSheet(_fromUtf8("#lcdNumberSampFreq {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberSampFreq:disabled{\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberSampFreq.setLineWidth(1)
+        self.lcdNumberSampFreq.setMidLineWidth(0)
+        self.lcdNumberSampFreq.setDigitCount(5)
+        self.lcdNumberSampFreq.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberSampFreq.setObjectName(_fromUtf8("lcdNumberSampFreq"))
+        self.lcdNumberTauDelay = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberTauDelay.setEnabled(True)
+        self.lcdNumberTauDelay.setGeometry(QtCore.QRect(370, 160, 64, 23))
+        self.lcdNumberTauDelay.setStyleSheet(_fromUtf8("#lcdNumberTauDelay {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberTauDelay:disabled {\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberTauDelay.setLineWidth(1)
+        self.lcdNumberTauDelay.setMidLineWidth(0)
+        self.lcdNumberTauDelay.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberTauDelay.setObjectName(_fromUtf8("lcdNumberTauDelay"))
+        self.label_16 = QtGui.QLabel(self.groupBox)
+        self.label_16.setGeometry(QtCore.QRect(10, 160, 131, 21))
+        self.label_16.setObjectName(_fromUtf8("label_16"))
+        self.lcdNumberNQ = QtGui.QLCDNumber(self.groupBox)
+        self.lcdNumberNQ.setGeometry(QtCore.QRect(160, 190, 64, 23))
+        self.lcdNumberNQ.setStyleSheet(_fromUtf8("#lcdNumberNQ {\n"
+"color: green;\n"
+"background: black;\n"
+"}\n"
+"\n"
+"#lcdNumberNQ:disabled{\n"
+"color: grey;\n"
+"background: black;\n"
+"}"))
+        self.lcdNumberNQ.setSegmentStyle(QtGui.QLCDNumber.Flat)
+        self.lcdNumberNQ.setObjectName(_fromUtf8("lcdNumberNQ"))
+        self.label_9 = QtGui.QLabel(self.groupBox)
+        self.label_9.setGeometry(QtCore.QRect(10, 190, 141, 21))
+        self.label_9.setObjectName(_fromUtf8("label_9"))
+        self.gridLayout.addWidget(self.groupBox, 4, 0, 1, 1)
+        self.groupBox_10 = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox_10.sizePolicy().hasHeightForWidth())
+        self.groupBox_10.setSizePolicy(sizePolicy)
+        self.groupBox_10.setMinimumSize(QtCore.QSize(460, 160))
+        self.groupBox_10.setObjectName(_fromUtf8("groupBox_10"))
+        self.stacksLineEdit = QtGui.QLineEdit(self.groupBox_10)
+        self.stacksLineEdit.setGeometry(QtCore.QRect(110, 30, 91, 21))
+        self.stacksLineEdit.setToolTip(_fromUtf8("<html><head/><body><p>Set the stacks that you would like processed.</p><p>This must be a valid set of numpy array indices. Remember that Python uses non end-inclusive indexing. </p><p>So things like [1:24] will include stacks 1-23</p><p>Furthermore [1:8,12:24] will include stacks 1-7 and 12:23. Any list of valid indices will be accepted, but they must be comma seperated. </p></body></html>"))
+        self.stacksLineEdit.setObjectName(_fromUtf8("stacksLineEdit"))
+        self.label = QtGui.QLabel(self.groupBox_10)
+        self.label.setGeometry(QtCore.QRect(10, 30, 51, 20))
+        self.label.setToolTip(_fromUtf8(""))
+        self.label.setStatusTip(_fromUtf8(""))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.label_23 = QtGui.QLabel(self.groupBox_10)
+        self.label_23.setGeometry(QtCore.QRect(10, 65, 101, 16))
+        self.label_23.setObjectName(_fromUtf8("label_23"))
+        self.dataChanLineEdit = QtGui.QLineEdit(self.groupBox_10)
+        self.dataChanLineEdit.setGeometry(QtCore.QRect(110, 60, 91, 21))
+        self.dataChanLineEdit.setObjectName(_fromUtf8("dataChanLineEdit"))
+        self.label_24 = QtGui.QLabel(self.groupBox_10)
+        self.label_24.setGeometry(QtCore.QRect(220, 36, 101, 16))
+        self.label_24.setObjectName(_fromUtf8("label_24"))
+        self.DeadTimeSpinBox = QtGui.QDoubleSpinBox(self.groupBox_10)
+        self.DeadTimeSpinBox.setGeometry(QtCore.QRect(360, 30, 91, 25))
+        self.DeadTimeSpinBox.setMinimum(5.0)
+        self.DeadTimeSpinBox.setSingleStep(0.5)
+        self.DeadTimeSpinBox.setProperty("value", 5.0)
+        self.DeadTimeSpinBox.setObjectName(_fromUtf8("DeadTimeSpinBox"))
+        self.label_28 = QtGui.QLabel(self.groupBox_10)
+        self.label_28.setGeometry(QtCore.QRect(220, 64, 131, 16))
+        self.label_28.setObjectName(_fromUtf8("label_28"))
+        self.refChanLineEdit = QtGui.QLineEdit(self.groupBox_10)
+        self.refChanLineEdit.setGeometry(QtCore.QRect(360, 60, 91, 21))
+        self.refChanLineEdit.setObjectName(_fromUtf8("refChanLineEdit"))
+        self.label_30 = QtGui.QLabel(self.groupBox_10)
+        self.label_30.setGeometry(QtCore.QRect(12, 96, 91, 16))
+        self.label_30.setObjectName(_fromUtf8("label_30"))
+        self.CentralVSpinBox = QtGui.QDoubleSpinBox(self.groupBox_10)
+        self.CentralVSpinBox.setGeometry(QtCore.QRect(110, 90, 91, 25))
+        self.CentralVSpinBox.setMinimum(100.0)
+        self.CentralVSpinBox.setMaximum(5000.99)
+        self.CentralVSpinBox.setSingleStep(1.0)
+        self.CentralVSpinBox.setObjectName(_fromUtf8("CentralVSpinBox"))
+        self.label_29 = QtGui.QLabel(self.groupBox_10)
+        self.label_29.setGeometry(QtCore.QRect(220, 95, 111, 16))
+        self.label_29.setObjectName(_fromUtf8("label_29"))
+        self.FIDProcComboBox = QtGui.QComboBox(self.groupBox_10)
+        self.FIDProcComboBox.setGeometry(QtCore.QRect(360, 90, 91, 25))
+        self.FIDProcComboBox.setObjectName(_fromUtf8("FIDProcComboBox"))
+        self.fullWorkflowPushButton = QtGui.QPushButton(self.groupBox_10)
+        self.fullWorkflowPushButton.setGeometry(QtCore.QRect(280, 130, 131, 31))
+        self.fullWorkflowPushButton.setAutoFillBackground(False)
+        self.fullWorkflowPushButton.setStyleSheet(_fromUtf8("#fullWorkflowPushButton {\n"
+"background: green;\n"
+"}"))
+        self.fullWorkflowPushButton.setAutoDefault(False)
+        self.fullWorkflowPushButton.setDefault(False)
+        self.fullWorkflowPushButton.setFlat(False)
+        self.fullWorkflowPushButton.setObjectName(_fromUtf8("fullWorkflowPushButton"))
+        self.loadDataPushButton = QtGui.QPushButton(self.groupBox_10)
+        self.loadDataPushButton.setGeometry(QtCore.QRect(90, 130, 91, 31))
+        self.loadDataPushButton.setObjectName(_fromUtf8("loadDataPushButton"))
+        self.gridLayout.addWidget(self.groupBox_10, 5, 0, 1, 1)
+        self.groupBox_9 = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox_9.sizePolicy().hasHeightForWidth())
+        self.groupBox_9.setSizePolicy(sizePolicy)
+        self.groupBox_9.setMinimumSize(QtCore.QSize(480, 100))
+        self.groupBox_9.setCheckable(True)
+        self.groupBox_9.setObjectName(_fromUtf8("groupBox_9"))
+        self.checkBox = QtGui.QCheckBox(self.groupBox_9)
+        self.checkBox.setGeometry(QtCore.QRect(30, 30, 171, 20))
+        self.checkBox.setObjectName(_fromUtf8("checkBox"))
+        self.comboBox_2 = QtGui.QComboBox(self.groupBox_9)
+        self.comboBox_2.setGeometry(QtCore.QRect(130, 50, 78, 25))
+        self.comboBox_2.setObjectName(_fromUtf8("comboBox_2"))
+        self.label_5 = QtGui.QLabel(self.groupBox_9)
+        self.label_5.setGeometry(QtCore.QRect(40, 60, 71, 16))
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.doubleSpinBox = QtGui.QDoubleSpinBox(self.groupBox_9)
+        self.doubleSpinBox.setGeometry(QtCore.QRect(390, 20, 62, 25))
+        self.doubleSpinBox.setObjectName(_fromUtf8("doubleSpinBox"))
+        self.label_8 = QtGui.QLabel(self.groupBox_9)
+        self.label_8.setGeometry(QtCore.QRect(220, 20, 161, 20))
+        self.label_8.setObjectName(_fromUtf8("label_8"))
+        self.gridLayout.addWidget(self.groupBox_9, 5, 1, 1, 1)
+        self.groupBox_7 = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox_7.sizePolicy().hasHeightForWidth())
+        self.groupBox_7.setSizePolicy(sizePolicy)
+        self.groupBox_7.setMinimumSize(QtCore.QSize(480, 100))
+        self.groupBox_7.setCheckable(True)
+        self.groupBox_7.setObjectName(_fromUtf8("groupBox_7"))
+        self.comboBox = QtGui.QComboBox(self.groupBox_7)
+        self.comboBox.setGeometry(QtCore.QRect(40, 30, 141, 22))
+        self.comboBox.setMouseTracking(True)
+        self.comboBox.setToolTip(_fromUtf8(""))
+        self.comboBox.setStatusTip(_fromUtf8(""))
+        self.comboBox.setWhatsThis(_fromUtf8(""))
+        self.comboBox.setObjectName(_fromUtf8("comboBox"))
+        self.comboBox.addItem(_fromUtf8(""))
+        self.comboBox.addItem(_fromUtf8(""))
+        self.gridLayout.addWidget(self.groupBox_7, 2, 1, 1, 1)
+        self.label_2 = QtGui.QLabel(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.label_2.sizePolicy().hasHeightForWidth())
+        self.label_2.setSizePolicy(sizePolicy)
+        font = QtGui.QFont()
+        font.setPointSize(20)
+        font.setBold(True)
+        font.setWeight(75)
+        self.label_2.setFont(font)
+        self.label_2.setLayoutDirection(QtCore.Qt.LeftToRight)
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.gridLayout.addWidget(self.label_2, 0, 1, 1, 1)
+        self.groupBox_8 = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox_8.sizePolicy().hasHeightForWidth())
+        self.groupBox_8.setSizePolicy(sizePolicy)
+        self.groupBox_8.setMinimumSize(QtCore.QSize(480, 150))
+        self.groupBox_8.setCheckable(True)
+        self.groupBox_8.setObjectName(_fromUtf8("groupBox_8"))
+        self.label_3 = QtGui.QLabel(self.groupBox_8)
+        self.label_3.setGeometry(QtCore.QRect(30, 60, 111, 16))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.spinBox = QtGui.QSpinBox(self.groupBox_8)
+        self.spinBox.setGeometry(QtCore.QRect(140, 60, 101, 25))
+        self.spinBox.setMaximum(1000)
+        self.spinBox.setProperty("value", 300)
+        self.spinBox.setObjectName(_fromUtf8("spinBox"))
+        self.gridLayout.addWidget(self.groupBox_8, 3, 1, 1, 1)
+        self.groupBox_5 = QtGui.QGroupBox(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.groupBox_5.sizePolicy().hasHeightForWidth())
+        self.groupBox_5.setSizePolicy(sizePolicy)
+        self.groupBox_5.setMinimumSize(QtCore.QSize(480, 150))
+        self.groupBox_5.setCheckable(True)
+        self.groupBox_5.setObjectName(_fromUtf8("groupBox_5"))
+        self.gridLayout.addWidget(self.groupBox_5, 1, 1, 1, 1)
+        self.mplwidget = MyDynamicMplCanvas(self.tab)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.mplwidget.sizePolicy().hasHeightForWidth())
+        self.mplwidget.setSizePolicy(sizePolicy)
+        self.mplwidget.setMinimumSize(QtCore.QSize(460, 460))
+        self.mplwidget.setObjectName(_fromUtf8("mplwidget"))
+        self.gridLayout.addWidget(self.mplwidget, 0, 0, 4, 1)
+        self.tabWidget.addTab(self.tab, _fromUtf8(""))
+        self.tab_3 = QtGui.QWidget()
+        self.tab_3.setObjectName(_fromUtf8("tab_3"))
+        self.treeWidget = QtGui.QTreeWidget(self.tab_3)
+        self.treeWidget.setGeometry(QtCore.QRect(70, 50, 256, 192))
+        self.treeWidget.setObjectName(_fromUtf8("treeWidget"))
+        self.treeWidget.headerItem().setText(0, _fromUtf8("1"))
+        self.toolBox = QtGui.QToolBox(self.tab_3)
+        self.toolBox.setGeometry(QtCore.QRect(320, 460, 79, 137))
+        self.toolBox.setObjectName(_fromUtf8("toolBox"))
+        self.page = QtGui.QWidget()
+        self.page.setGeometry(QtCore.QRect(0, 0, 94, 24))
+        self.page.setObjectName(_fromUtf8("page"))
+        self.toolBox.addItem(self.page, _fromUtf8(""))
+        self.page_2 = QtGui.QWidget()
+        self.page_2.setGeometry(QtCore.QRect(0, 0, 94, 24))
+        self.page_2.setObjectName(_fromUtf8("page_2"))
+        self.toolBox.addItem(self.page_2, _fromUtf8(""))
+        self.dateEdit = QtGui.QDateEdit(self.tab_3)
+        self.dateEdit.setGeometry(QtCore.QRect(400, 280, 110, 25))
+        self.dateEdit.setObjectName(_fromUtf8("dateEdit"))
+        self.tabWidget.addTab(self.tab_3, _fromUtf8(""))
+        self.tab_2 = QtGui.QWidget()
+        self.tab_2.setObjectName(_fromUtf8("tab_2"))
+        self.dateEdit_2 = QtGui.QDateEdit(self.tab_2)
+        self.dateEdit_2.setGeometry(QtCore.QRect(50, 100, 110, 25))
+        self.dateEdit_2.setObjectName(_fromUtf8("dateEdit_2"))
+        self.tabWidget.addTab(self.tab_2, _fromUtf8(""))
+        self.tab_6 = QtGui.QWidget()
+        self.tab_6.setObjectName(_fromUtf8("tab_6"))
+        self.tabWidget.addTab(self.tab_6, _fromUtf8(""))
+        self.tab_4 = QtGui.QWidget()
+        self.tab_4.setObjectName(_fromUtf8("tab_4"))
+        self.invertButton = QtGui.QPushButton(self.tab_4)
+        self.invertButton.setGeometry(QtCore.QRect(290, 140, 311, 141))
+        self.invertButton.setStyleSheet(_fromUtf8("#invertButton {\n"
+"font-size:29pt;\n"
+"font-weight: bold;\n"
+"color: white;\n"
+"background: red;\n"
+"}"))
+        self.invertButton.setObjectName(_fromUtf8("invertButton"))
+        self.tabWidget.addTab(self.tab_4, _fromUtf8(""))
+        self.tab_5 = QtGui.QWidget()
+        self.tab_5.setObjectName(_fromUtf8("tab_5"))
+        self.tabWidget.addTab(self.tab_5, _fromUtf8(""))
+        self.horizontalLayout_2.addWidget(self.tabWidget)
+        self.scrollArea.setWidget(self.scrollAreaWidgetContents)
+        self.horizontalLayout.addWidget(self.scrollArea)
+        MainWindow.setCentralWidget(self.centralwidget)
+        self.menubar = QtGui.QMenuBar(MainWindow)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 1000, 20))
+        self.menubar.setObjectName(_fromUtf8("menubar"))
+        self.menuFile = QtGui.QMenu(self.menubar)
+        self.menuFile.setObjectName(_fromUtf8("menuFile"))
+        self.menuAbout = QtGui.QMenu(self.menubar)
+        self.menuAbout.setObjectName(_fromUtf8("menuAbout"))
+        MainWindow.setMenuBar(self.menubar)
+        self.statusbar = QtGui.QStatusBar(MainWindow)
+        self.statusbar.setObjectName(_fromUtf8("statusbar"))
+        MainWindow.setStatusBar(self.statusbar)
+        self.actionClose = QtGui.QAction(MainWindow)
+        self.actionClose.setObjectName(_fromUtf8("actionClose"))
+        self.actionAboutBrewCentral = QtGui.QAction(MainWindow)
+        self.actionAboutBrewCentral.setObjectName(_fromUtf8("actionAboutBrewCentral"))
+        self.actionNothing = QtGui.QAction(MainWindow)
+        self.actionNothing.setObjectName(_fromUtf8("actionNothing"))
+        self.actionTemperature = QtGui.QAction(MainWindow)
+        self.actionTemperature.setObjectName(_fromUtf8("actionTemperature"))
+        self.actionOpen_GMR = QtGui.QAction(MainWindow)
+        self.actionOpen_GMR.setCheckable(False)
+        self.actionOpen_GMR.setObjectName(_fromUtf8("actionOpen_GMR"))
+        self.actionProcess = QtGui.QAction(MainWindow)
+        self.actionProcess.setCheckable(True)
+        self.actionProcess.setObjectName(_fromUtf8("actionProcess"))
+        self.actionOpen_Preprocessed_dataset = QtGui.QAction(MainWindow)
+        self.actionOpen_Preprocessed_dataset.setEnabled(False)
+        self.actionOpen_Preprocessed_dataset.setObjectName(_fromUtf8("actionOpen_Preprocessed_dataset"))
+        self.actionOpen_VC_Preprocessed_dataset = QtGui.QAction(MainWindow)
+        self.actionOpen_VC_Preprocessed_dataset.setEnabled(False)
+        self.actionOpen_VC_Preprocessed_dataset.setObjectName(_fromUtf8("actionOpen_VC_Preprocessed_dataset"))
+        self.actionSave_Preprocesssed_Dataset = QtGui.QAction(MainWindow)
+        self.actionSave_Preprocesssed_Dataset.setEnabled(False)
+        self.actionSave_Preprocesssed_Dataset.setObjectName(_fromUtf8("actionSave_Preprocesssed_Dataset"))
+        self.menuFile.addAction(self.actionOpen_GMR)
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.actionOpen_Preprocessed_dataset)
+        self.menuFile.addAction(self.actionOpen_VC_Preprocessed_dataset)
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.actionSave_Preprocesssed_Dataset)
+        self.menuFile.addSeparator()
+        self.menuFile.addAction(self.actionClose)
+        self.menuAbout.addAction(self.actionAboutBrewCentral)
+        self.menubar.addAction(self.menuFile.menuAction())
+        self.menubar.addAction(self.menuAbout.menuAction())
+
+        self.retranslateUi(MainWindow)
+        self.tabWidget.setCurrentIndex(0)
+        self.toolBox.setCurrentIndex(0)
+        QtCore.QObject.connect(self.actionClose, QtCore.SIGNAL(_fromUtf8("activated()")), MainWindow.close)
+        QtCore.QObject.connect(self.actionAboutBrewCentral, QtCore.SIGNAL(_fromUtf8("activated()")), MainWindow.show)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+    def retranslateUi(self, MainWindow):
+        MainWindow.setWindowTitle(_translate("MainWindow", "Avko - sNMR Workbench", None))
+        self.groupBox_4.setTitle(_translate("MainWindow", "Adaptive Noise Suppresion", None))
+        self.groupBox.setTitle(_translate("MainWindow", "Header file info", None))
+        self.headerFileTextBrowser.setHtml(_translate("MainWindow", "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
+"<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
+"p, li { white-space: pre-wrap; }\n"
+"</style></head><body style=\" font-family:\'Sans Serif\'; font-size:8pt; font-weight:400; font-style:italic;\">\n"
+"<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-family:\'DejaVu Serif\'; font-size:9pt;\">Load supported RAW Dataset header from file menu</span></p></body></html>", None))
+        self.label_4.setText(_translate("MainWindow", "Pulse Type", None))
+        self.pulseTypeTextBrowser.setHtml(_translate("MainWindow", "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
+"<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
+"p, li { white-space: pre-wrap; }\n"
+"</style></head><body style=\" font-family:\'Sans Serif\'; font-size:9pt; font-weight:400; font-style:italic;\">\n"
+"<p style=\"-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:\'DejaVu Serif\'; font-size:10pt;\"><br /></p></body></html>", None))
+        self.label_6.setText(_translate("MainWindow", "ν Tx  [Hz]", None))
+        self.label_7.setText(_translate("MainWindow", "τ Pulse 1 [ms]", None))
+        self.label_13.setText(_translate("MainWindow", "τ Delay [ms]", None))
+        self.label_14.setText(_translate("MainWindow", "Tx tuning [μF]", None))
+        self.label_15.setText(_translate("MainWindow", "ν Sampling [Hz]", None))
+        self.label_16.setText(_translate("MainWindow", "τ Pulse 2 [ms]", None))
+        self.label_9.setText(_translate("MainWindow", "Num. pulse moments", None))
+        self.groupBox_10.setTitle(_translate("MainWindow", "Input parameters", None))
+        self.label.setText(_translate("MainWindow", "Stacks", None))
+        self.label_23.setText(_translate("MainWindow", "Data Channels", None))
+        self.label_24.setText(_translate("MainWindow", "Dead time [ms]", None))
+        self.label_28.setText(_translate("MainWindow", "Reference Channels", None))
+        self.label_30.setText(_translate("MainWindow", "Central ν Hz", None))
+        self.CentralVSpinBox.setToolTip(_translate("MainWindow", "<html><head/><body><p>In case of off-resonant transmitter pulse, you can set the central frequency that will be used for all processing. This has the biggest impact on the band-pass filter, and the frequencies used in inversion. </p></body></html>", None))
+        self.label_29.setText(_translate("MainWindow", "Process FID #", None))
+        self.FIDProcComboBox.setToolTip(_translate("MainWindow", "<html><head/><body><p>For T1 or CPMG pulses, which pulse(s) would you like to process. Note that for very short delay T1 pulses, the first pulse may be disabled. </p></body></html>", None))
+        self.fullWorkflowPushButton.setText(_translate("MainWindow", "Full Workflow", None))
+        self.loadDataPushButton.setText(_translate("MainWindow", "Load Data", None))
+        self.groupBox_9.setTitle(_translate("MainWindow", "SmartStack^TM", None))
+        self.checkBox.setText(_translate("MainWindow", "Correct phase jitter", None))
+        self.label_5.setText(_translate("MainWindow", "Outlier test", None))
+        self.label_8.setText(_translate("MainWindow", "Instrument phase delay", None))
+        self.groupBox_7.setTitle(_translate("MainWindow", "Band-Pass Filter", None))
+        self.comboBox.setAccessibleDescription(_translate("MainWindow", "Hello", None))
+        self.comboBox.setItemText(0, _translate("MainWindow", "Butterworth", None))
+        self.comboBox.setItemText(1, _translate("MainWindow", "Chebychev Type II", None))
+        self.label_2.setText(_translate("MainWindow", "         Preprocessing Workflow", None))
+        self.groupBox_8.setTitle(_translate("MainWindow", "Downsample and truncate", None))
+        self.label_3.setText(_translate("MainWindow", "Truncate [ms]", None))
+        self.groupBox_5.setTitle(_translate("MainWindow", "Despike Filter", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Preprocess RAW", None))
+        self.toolBox.setItemText(self.toolBox.indexOf(self.page), _translate("MainWindow", "Page 1", None))
+        self.toolBox.setItemText(self.toolBox.indexOf(self.page_2), _translate("MainWindow", "Page 2", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_3), _translate("MainWindow", "Data QC", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate("MainWindow", "Model Parameters", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_6), _translate("MainWindow", "Forward modelling", None))
+        self.invertButton.setText(_translate("MainWindow", "Invert", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_4), _translate("MainWindow", "Inversion", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_5), _translate("MainWindow", "Analysis", None))
+        self.menuFile.setTitle(_translate("MainWindow", "&File", None))
+        self.menuAbout.setTitle(_translate("MainWindow", "About", None))
+        self.actionClose.setText(_translate("MainWindow", "&Close", None))
+        self.actionAboutBrewCentral.setText(_translate("MainWindow", "Brew Central", None))
+        self.actionNothing.setText(_translate("MainWindow", "Nothing", None))
+        self.actionTemperature.setText(_translate("MainWindow", "Temperature", None))
+        self.actionOpen_GMR.setText(_translate("MainWindow", "Open GMR RAW header", None))
+        self.actionOpen_GMR.setIconText(_translate("MainWindow", "Open GMR RAW dataset(s)", None))
+        self.actionProcess.setText(_translate("MainWindow", "Process", None))
+        self.actionOpen_Preprocessed_dataset.setText(_translate("MainWindow", "Open Avko Preprocessed dataset", None))
+        self.actionOpen_VC_Preprocessed_dataset.setText(_translate("MainWindow", "Open VC Preprocessed dataset", None))
+        self.actionSave_Preprocesssed_Dataset.setText(_translate("MainWindow", "Save Preprocesssed Dataset", None))
+
+from mydynamicmplcanvas import MyDynamicMplCanvas

akvo/gui/mydynamicmplcanvas.py

+from __future__ import unicode_literals
+import sys
+import os
+import random
+import matplotlib
+# Make sure that we are using QT5
+matplotlib.use('Qt5Agg')
+from PyQt5 import QtCore, QtWidgets
+
+from numpy import arange, sin, pi
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+import numpy as np
+
+class MyMplCanvas(FigureCanvas):
+    
+    """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
+    def __init__(self, parent=None, width=3, height=4, dpi=100):
+        
+        self.fig = Figure(figsize=(width, height), dpi=dpi)
+        FigureCanvas.__init__(self, self.fig)
+
+        self.setParent(parent)
+        FigureCanvas.updateGeometry(self)
+
+    def compute_initial_figure(self):
+        pass
+
+    def clicked(self):
+        print ("Clicked")
+
+class MyDynamicMplCanvas(MyMplCanvas):
+
+    """A canvas that updates itself every second with a new plot."""
+    def __init__(self, *args, **kwargs):
+        
+        MyMplCanvas.__init__(self, *args, **kwargs)
+        self.ax1 = self.fig.add_axes([.125,.1,.725,.8])
+        self.ax2 = self.ax1.twinx() # fig.add_axes([.125,.1,.725,.8])
+        self.compute_initial_figure()
+
+    def reAxH(self, num, shx=True, shy=True):
+        try:
+            self.fig.clear()
+        except:
+            pass
+        for n in range(num):
+            if n == 0:
+                self.ax1 = self.fig.add_subplot( 1, num, 1 )
+                self.ax1.tick_params(axis='both', which='major', labelsize=8)
+                self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax1.yaxis.get_offset_text().set_size(8) 
+            if n == 1:
+                self.ax2 = self.fig.add_subplot( 1, num, 2 )
+                self.ax2.tick_params(axis='both', which='major', labelsize=8)
+                self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax2.yaxis.get_offset_text().set_size(8) 
+            if n == 2:
+                self.ax3 = self.fig.add_subplot( 1, num, 3 )
+                self.ax3.tick_params(axis='both', which='major', labelsize=8)
+                self.ax3.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax3.yaxis.get_offset_text().set_size(8) 
+            if n == 3:
+                self.ax4 = self.fig.add_subplot( 1, num, 4 )
+                self.ax4.tick_params(axis='both', which='major', labelsize=8)
+                self.ax4.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax4.yaxis.get_offset_text().set_size(8) 
+    
+    def reAxH2(self, num, shx=True, shy=True):
+        try:
+            for ax in fig.axes:
+                self.fig.delaxes(ax)
+        except:
+            pass
+
+        try:
+            self.fig.clear()
+        except:
+            pass
+        
+        for n in range(num):
+            if n == 0:
+                self.ax1 = self.fig.add_subplot( 2, num, 1 )
+                self.ax1.tick_params(axis='both', which='major', labelsize=8)
+                self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax1.yaxis.get_offset_text().set_size(8) 
+                self.ax21 = self.fig.add_subplot( 2, num, num+1 )
+                self.ax21.tick_params(axis='both', which='major', labelsize=8)
+                self.ax21.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax21.yaxis.get_offset_text().set_size(8) 
+            if n == 1:
+                self.ax2 = self.fig.add_subplot( 2, num, 2, sharex=self.ax1, sharey=self.ax1 )
+                self.ax2.tick_params(axis='both', which='major', labelsize=8)
+                self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax2.yaxis.get_offset_text().set_size(8) 
+                self.ax22 = self.fig.add_subplot( 2, num, num+2, sharex=self.ax21, sharey=self.ax21 )
+                self.ax22.tick_params(axis='both', which='major', labelsize=8)
+                self.ax22.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax22.yaxis.get_offset_text().set_size(8) 
+            if n == 2:
+                self.ax3 = self.fig.add_subplot( 2, num, 3, sharex=self.ax1, sharey=self.ax1 )
+                self.ax3.tick_params(axis='both', which='major', labelsize=8)
+                self.ax3.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax3.yaxis.get_offset_text().set_size(8) 
+                self.ax23 = self.fig.add_subplot( 2, num, num+3, sharex=self.ax21, sharey=self.ax21 )
+                self.ax23.tick_params(axis='both', which='major', labelsize=8)
+                self.ax23.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax23.yaxis.get_offset_text().set_size(8) 
+            if n == 3:
+                self.ax4 = self.fig.add_subplot( 2, num, 4, sharex=self.ax1, sharey=self.ax1 )
+                self.ax4.tick_params(axis='both', which='major', labelsize=8)
+                self.ax4.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax4.yaxis.get_offset_text().set_size(8) 
+                self.ax24 = self.fig.add_subplot( 2, num, num+4, sharex=self.ax21, sharey=self.ax21 )
+                self.ax24.tick_params(axis='both', which='major', labelsize=8)
+                self.ax24.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax24.yaxis.get_offset_text().set_size(8) 
+            if n == 4:
+                self.ax5 = self.fig.add_subplot( 2, num, 5, sharex=self.ax1, sharey=self.ax1 )
+                self.ax5.tick_params(axis='both', which='major', labelsize=8)
+                self.ax5.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax5.yaxis.get_offset_text().set_size(8) 
+                self.ax25 = self.fig.add_subplot( 2, num, num+5, sharex=self.ax21, sharey=self.ax21 )
+                self.ax25.tick_params(axis='both', which='major', labelsize=8)
+                self.ax25.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax25.yaxis.get_offset_text().set_size(8) 
+            if n == 5:
+                self.ax6 = self.fig.add_subplot( 2, num, 6, sharex=self.ax1, sharey=self.ax1 )
+                self.ax6.tick_params(axis='both', which='major', labelsize=8)
+                self.ax6.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax6.yaxis.get_offset_text().set_size(8) 
+                self.ax26 = self.fig.add_subplot( 2, num, num+6, sharex=self.ax21, sharey=self.ax21 )
+                self.ax26.tick_params(axis='both', which='major', labelsize=8)
+                self.ax26.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax26.yaxis.get_offset_text().set_size(8) 
+            if n == 6:
+                self.ax7 = self.fig.add_subplot( 2, num, 7, sharex=self.ax1, sharey=self.ax1 )
+                self.ax7.tick_params(axis='both', which='major', labelsize=8)
+                self.ax7.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax7.yaxis.get_offset_text().set_size(8) 
+                self.ax27 = self.fig.add_subplot( 2, num, num+7, sharex=self.ax21, sharey=self.ax21 )
+                self.ax27.tick_params(axis='both', which='major', labelsize=8)
+                self.ax27.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax27.yaxis.get_offset_text().set_size(8) 
+            if n == 7:
+                self.ax8 = self.fig.add_subplot( 2, num, 8, sharex=self.ax1, sharey=self.ax1 )
+                self.ax8.tick_params(axis='both', which='major', labelsize=8)
+                self.ax8.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax8.yaxis.get_offset_text().set_size(8) 
+                self.ax28 = self.fig.add_subplot( 2, num, num+8, sharex=self.ax21, sharey=self.ax21 )
+                self.ax28.tick_params(axis='both', which='major', labelsize=8)
+                self.ax28.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+                self.ax28.yaxis.get_offset_text().set_size(8) 
+
+    def reAx2(self, shx=True, shy=True):
+
+        try:
+            self.fig.clear()
+        except:
+            pass
+
+        try:
+            self.ax1.clear() 
+            self.delaxes(self.ax1) #.clear()
+        except:
+            pass
+        
+        try:    
+            self.delaxes(self.ax3) #.clear()
+        except:
+            pass
+        
+        try:
+            self.ax2.clear() 
+            self.delaxes(self.ax2) #.clear()
+        except:
+            pass
+
+        self.ax1 = self.fig.add_subplot(211)
+        if shx and shy:
+            self.ax2 = self.fig.add_subplot(212, sharex=self.ax1, sharey=self.ax1)
+        elif shx == True:
+            self.ax2 = self.fig.add_subplot(212, sharex=self.ax1) 
+        elif shy == True:
+            self.ax2 = self.fig.add_subplot(212, sharey=self.ax1) 
+        else:
+            self.ax2 = self.fig.add_subplot(212)
+
+        self.ax1.tick_params(axis='both', which='major', labelsize=8)
+        self.ax2.tick_params(axis='both', which='major', labelsize=8)
+
+        self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.ax1.yaxis.get_offset_text().set_size(8) 
+        self.ax2.yaxis.get_offset_text().set_size(8) 
+
+    def reAx3(self, shx=True, shy=True):
+
+        try:
+            self.fig.clear()
+        except:
+            pass
+
+        try:
+            self.ax1.clear() 
+            self.delaxes(self.ax1) #.clear()
+        except:
+            pass
+            
+        try:
+            self.ax2.clear() 
+            self.delaxes(self.ax2) #.clear()
+        except:
+            pass
+        
+        try:    
+            self.ax3.clear() 
+            self.delaxes(self.ax3) #.clear()
+        except:
+            pass
+
+        self.ax1 = self.fig.add_subplot(211)
+        if shx and shy:
+            self.ax2 = self.fig.add_subplot(212, sharex=self.ax1, sharey=self.ax1)
+        elif shx:
+            self.ax2 = self.fig.add_subplot(212, sharex=self.ax1) 
+        elif shy:
+            self.ax2 = self.fig.add_subplot(212, sharey=self.ax1) 
+        else:
+            self.ax2 = self.fig.add_subplot(212) 
+
+        self.ax3 = self.ax1.twinx()
+
+        self.ax1.tick_params(axis='both', which='major', labelsize=8)
+        self.ax2.tick_params(axis='both', which='major', labelsize=8)
+        self.ax3.tick_params(axis='both', which='major', labelsize=8)
+
+        self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.ax3.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.ax1.yaxis.get_offset_text().set_size(8) 
+        self.ax2.yaxis.get_offset_text().set_size(8)    
+        self.ax3.yaxis.get_offset_text().set_size(8)    
+ 
+    def reAx4(self):
+
+        try:
+            self.fig.clear()
+        except:
+            pass
+
+        # two main axes
+        self.ax1 = self.fig.add_axes([0.15, 0.55,   0.625, 0.3672])
+        self.ax2 = self.fig.add_axes([0.15, 0.135,  0.625, 0.3672])
+        
+        # for colourbars
+        self.cax1 = self.fig.add_axes([0.8, 0.55,   0.025, 0.3672])
+        self.cax2 = self.fig.add_axes([0.8, 0.135,  0.025, 0.3672])
+        
+        self.ax1.tick_params(axis='both', which='major', labelsize=8)
+        self.ax2.tick_params(axis='both', which='major', labelsize=8)
+
+        self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.ax1.yaxis.get_offset_text().set_size(8) 
+        self.ax2.yaxis.get_offset_text().set_size(8) 
+
+        self.cax1.tick_params(axis='both', which='major', labelsize=8)
+        self.cax2.tick_params(axis='both', which='major', labelsize=8)
+
+        self.cax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.cax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.cax1.yaxis.get_offset_text().set_size(8) #.get_text()
+        self.cax2.yaxis.get_offset_text().set_size(8) #.get_text()
+
+        self.cax1.tick_params(labelsize=8) 
+        self.cax2.tick_params(labelsize=8)
+
+
+    def compute_initial_figure(self):
+        
+        t = np.arange(0,.3,1e-4)
+        x = np.cos(t*2000.*np.pi*2)*np.exp(-t/.07)
+        x2 = np.exp(-t/.07)
+        dp = self.ax1.plot(t, x, 'r',label='test function')
+        dp2 = self.ax2.plot(t, x2, 'r',label='test function2')
+        self.ax1.set_xlabel("Time [s]", fontsize=8)
+        self.ax1.set_ylabel("Signal [nV]", fontsize=8)
+
+        self.ax1.tick_params(axis='both', which='major', labelsize=8)
+        self.ax1.tick_params(axis='both', which='minor', labelsize=6)
+
+        self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y') 
+        self.ax1.legend(prop={'size':6})
+

akvo/gui/mydynamicmplcanvasnavigator.py

+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
+from matplotlib.figure import Figure
+import numpy as np
+
+import sys
+from PyQt5 import QtCore, QtGui
+
+#from mydynamicmplcanvas import MyMplCanvas
+
+class MyMplCanvasN(FigureCanvas):
+    
+    """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
+    def __init__(self, parent=None, width=3, height=.2, dpi=100):
+        
+        self.fig = Figure(figsize=(width, height), dpi=dpi)
+        FigureCanvas.__init__(self, self.fig)
+
+        self.setParent(parent)
+        FigureCanvas.updateGeometry(self)
+
+    def compute_initial_figure(self):
+        pass
+
+    def clicked(self):
+        print ("Clicked")
+
+class MyDynamicMplCanvasNavigator(MyMplCanvasN):
+    
+    def __init__(self, *args, **kwargs):
+        
+        MyMplCanvasN.__init__(self, *args, **kwargs)
+
+    def setCanvas(self, canvas):
+        NavigationToolbar(canvas, self)

akvo/gui/quad.r

+
+# Define 
+Xc <- function(E0, df, tt, phi, T2) {
+	E0 * -sin(2*pi*df*tt + phi) * exp(-tt/T2)
+}
+
+Yc <- function(E0, df, tt, phi, T2) {
+	E0 * cos(2*pi*df*tt + phi) * exp(-tt/T2)
+}
+
+#QI <- function(E0, df, tt, phi, T2, X, Y) {
+#	(X-Xc(E0, df, tt, phi, T2))  + (Y-Yc(E0, df, tt, phi, T2))
+#}

akvo/gui/replace.sh

+#!/bin/bash
+python2-pyuic4 main.ui > mainui.py
+sed 's/QtGui.KLed/KLed/g' mainui.py > mainui2.py

akvo/gui/temp.py

+"""
+This demo demonstrates how to embed a matplotlib (mpl) plot 
+into a PyQt4 GUI application, including:
+
+* Using the navigation toolbar
+* Adding data to the plot
+* Dynamically modifying the plot's properties
+* Processing mpl events
+* Saving the plot to a file from a menu
+
+The main goal is to serve as a basis for developing rich PyQt GUI
+applications featuring mpl plots (using the mpl OO API).
+
+Eli Bendersky (eliben@gmail.com)
+License: this code is in the public domain
+Last modified: 19.01.2009
+"""
+import sys, os, random
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+import matplotlib
+from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.backends.backend_qt4agg import NavigationToolbar2QTAgg as NavigationToolbar
+from matplotlib.figure import Figure
+
+
+class AppForm(QMainWindow):
+    def __init__(self, parent=None):
+        QMainWindow.__init__(self, parent)
+        self.setWindowTitle('Demo: PyQt with matplotlib')
+
+        self.create_menu()
+        self.create_main_frame()
+        self.create_status_bar()
+
+        self.textbox.setText('1 2 3 4')
+        self.on_draw()
+
+    def save_plot(self):
+        file_choices = "PNG (*.png)|*.png"
+        
+        path = unicode(QFileDialog.getSaveFileName(self, 
+                        'Save file', '', 
+                        file_choices))
+        if path:
+            self.canvas.print_figure(path, dpi=self.dpi)
+            self.statusBar().showMessage('Saved to %s' % path, 2000)
+    
+    def on_about(self):
+        msg = """ A demo of using PyQt with matplotlib:
+        
+         * Use the matplotlib navigation bar
+         * Add values to the text box and press Enter (or click "Draw")
+         * Show or hide the grid
+         * Drag the slider to modify the width of the bars
+         * Save the plot to a file using the File menu
+         * Click on a bar to receive an informative message
+        """
+        QMessageBox.about(self, "About the demo", msg.strip())
+    
+    def on_pick(self, event):
+        # The event received here is of the type
+        # matplotlib.backend_bases.PickEvent
+        #
+        # It carries lots of information, of which we're using
+        # only a small amount here.
+        # 
+        box_points = event.artist.get_bbox().get_points()
+        msg = "You've clicked on a bar with coords:\n %s" % box_points
+        
+        QMessageBox.information(self, "Click!", msg)
+    
+    def on_draw(self):
+        """ Redraws the figure
+        """
+        str = unicode(self.textbox.text())
+        self.data = map(int, str.split())
+        
+        x = range(len(self.data))
+
+        # clear the axes and redraw the plot anew
+        #
+        self.axes.clear()        
+        self.axes.grid(self.grid_cb.isChecked())
+        
+        self.axes.bar(
+            left=x, 
+            height=self.data, 
+            width=self.slider.value() / 100.0, 
+            align='center', 
+            alpha=0.44,
+            picker=5)
+        
+        self.canvas.draw()
+    
+    def create_main_frame(self):
+        self.main_frame = QWidget()
+        
+        # Create the mpl Figure and FigCanvas objects. 
+        # 5x4 inches, 100 dots-per-inch
+        #
+        self.dpi = 100
+        self.fig = Figure((5.0, 4.0), dpi=self.dpi)
+        self.canvas = FigureCanvas(self.fig)
+        self.canvas.setParent(self.main_frame)
+        
+        # Since we have only one plot, we can use add_axes 
+        # instead of add_subplot, but then the subplot
+        # configuration tool in the navigation toolbar wouldn't
+        # work.
+        #
+        self.axes = self.fig.add_subplot(111)
+        
+        # Bind the 'pick' event for clicking on one of the bars
+        #
+        self.canvas.mpl_connect('pick_event', self.on_pick)
+        
+        # Create the navigation toolbar, tied to the canvas
+        #
+        self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
+        
+        # Other GUI controls
+        # 
+        self.textbox = QLineEdit()
+        self.textbox.setMinimumWidth(200)
+        self.connect(self.textbox, SIGNAL('editingFinished ()'), self.on_draw)
+        
+        self.draw_button = QPushButton("&Draw")
+        self.connect(self.draw_button, SIGNAL('clicked()'), self.on_draw)
+        
+        self.grid_cb = QCheckBox("Show &Grid")
+        self.grid_cb.setChecked(False)
+        self.connect(self.grid_cb, SIGNAL('stateChanged(int)'), self.on_draw)
+        
+        slider_label = QLabel('Bar width (%):')
+        self.slider = QSlider(Qt.Horizontal)
+        self.slider.setRange(1, 100)
+        self.slider.setValue(20)
+        self.slider.setTracking(True)
+        self.slider.setTickPosition(QSlider.TicksBothSides)
+        self.connect(self.slider, SIGNAL('valueChanged(int)'), self.on_draw)
+        
+        #
+        # Layout with box sizers
+        # 
+        hbox = QHBoxLayout()
+        
+        for w in [  self.textbox, self.draw_button, self.grid_cb,
+                    slider_label, self.slider]:
+            hbox.addWidget(w)
+            hbox.setAlignment(w, Qt.AlignVCenter)
+        
+        vbox = QVBoxLayout()
+        vbox.addWidget(self.canvas)
+        vbox.addWidget(self.mpl_toolbar)
+        vbox.addLayout(hbox)
+        
+        self.main_frame.setLayout(vbox)
+        self.setCentralWidget(self.main_frame)
+    
+    def create_status_bar(self):
+        self.status_text = QLabel("This is a demo")
+        self.statusBar().addWidget(self.status_text, 1)
+        
+    def create_menu(self):        
+        self.file_menu = self.menuBar().addMenu("&File")
+        
+        load_file_action = self.create_action("&Save plot",
+            shortcut="Ctrl+S", slot=self.save_plot, 
+            tip="Save the plot")
+        quit_action = self.create_action("&Quit", slot=self.close, 
+            shortcut="Ctrl+Q", tip="Close the application")
+        
+        self.add_actions(self.file_menu, 
+            (load_file_action, None, quit_action))
+        
+        self.help_menu = self.menuBar().addMenu("&Help")
+        about_action = self.create_action("&About", 
+            shortcut='F1', slot=self.on_about, 
+            tip='About the demo')
+        
+        self.add_actions(self.help_menu, (about_action,))
+
+    def add_actions(self, target, actions):
+        for action in actions:
+            if action is None:
+                target.addSeparator()
+            else:
+                target.addAction(action)
+
+    def create_action(  self, text, slot=None, shortcut=None, 
+                        icon=None, tip=None, checkable=False, 
+                        signal="triggered()"):
+        action = QAction(text, self)
+        if icon is not None:
+            action.setIcon(QIcon(":/%s.png" % icon))
+        if shortcut is not None:
+            action.setShortcut(shortcut)
+        if tip is not None:
+            action.setToolTip(tip)
+            action.setStatusTip(tip)
+        if slot is not None:
+            self.connect(action, SIGNAL(signal), slot)
+        if checkable:
+            action.setCheckable(True)
+        return action
+
+
+def main():
+    app = QApplication(sys.argv)
+    form = AppForm()
+    form.show()
+    app.exec_()
+
+
+if __name__ == "__main__":
+    main()
+

akvo/terminal/SEGPlot.py

+#################################################################################
+# GJI final pub specs                                                           #
+import matplotlib                                                               #
+from matplotlib import rc                                                       #
+#matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{amsmath,amssymb}"]    #
+matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath,amssymb}"]  #
+rc('font',**{'family':'serif','serif':['timet']})                                   #
+rc('font',**{'size':8})                                                             #
+rc('text', usetex=True)                                                             #
+# converts pc that GJI is defined in to inches                                      # 
+# In GEOPHYSICS \textwidth = 42pc                                               #
+#        \columnwidth = 20pc                                                    #
+#        one column widthe figures are 20 picas                                 #
+#        one and one third column figures are 26 picas                          #
+def pc2in(pc):                                                                  #
+    return pc*12/72.27                                                          #
+#################################################################################
+import numpy as np
+light_grey = np.array([float(248)/float(255)]*3)
+
+def fixLeg(legend):
+    rect = legend.get_frame()
+    #rect.set_color('None')
+    rect.set_facecolor(light_grey)
+    rect.set_linewidth(0.0)
+    rect.set_alpha(0.5)
+
+def deSpine(ax1):
+    spines_to_remove = ['top', 'right']
+    for spine in spines_to_remove:
+        ax1.spines[spine].set_visible(False)
+    #ax1.xaxis.set_ticks_position('none')
+    #ax1.yaxis.set_ticks_position('none')
+    ax1.get_xaxis().tick_bottom()
+    ax1.get_yaxis().tick_left()

akvo/terminal/USGSPlots.py

+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+import plotyaml
+
+__author__ = "M. Andy Kass"
+__version__ = "$Revision 0.1"
+__date__ = "$Date: 2017-05-25"
+
+
+class USGSPlots:
+
+    def getData(self,fname,chan):
+            
+        self.channels = []
+        for part in chan.split(','):
+            if ':' in part:
+                a,b = part.split(':')
+                a,b = int(a), int(b)
+                self.channels.extend(range(a,b))
+            else:
+                a = int(part)
+                self.channels.append(a)
+        #print self.channels
+
+        self.data = []
+        for c in self.channels:
+            nm = "Chan. " + str(c)
+            self.data.append(plotyaml.loadAkvoData(fname,nm))
+
+
+        return 0
+
+    def plotSingleDecay(self,pm,chan=1):
+       
+
+        return 42
+
+
+    def plotAllDecays(self,chan=1):
+
+        return 42
+
+    def plotAverageFID(self,chan=1):
+
+        return 42
+
+    def plotSpectrum(self,chan=1):
+
+        return 42
+ 

akvo/terminal/epsPlots.py

+from SEGPlot import *
+
+import sys
+sys.path.append( '../tressel' )
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker
+import scipy.io as sio
+import scipy.signal as signal
+import numpy as np
+
+import mrsurvey
+import pickle
+import decay
+import cmaps
+plt.register_cmap(name='viridis', cmap=cmaps.viridis)
+plt.register_cmap(name='inferno', cmap=cmaps.inferno)
+plt.register_cmap(name='inferno_r', cmap=cmaps.inferno_r)
+
+plt.register_cmap(name='magma', cmap=cmaps.magma)
+plt.register_cmap(name='magma_r', cmap=cmaps.magma_r)
+
+
+class canvas():
+    
+    def __init__(self):
+        self.fig = plt.figure( figsize=(pc2in(20),pc2in(20) ) )
+        self.ax1 = self.fig.add_subplot((211))
+        self.ax2 = self.fig.add_subplot((212), sharex=self.ax1)
+   
+    def draw(self):
+        plt.draw() 
+
+    def reAx2(self):
+        try:
+            self.fig.clear()
+        except:
+            pass
+
+        try:
+            self.ax1.clear() 
+            self.delaxes(self.ax1) #.clear()
+        except:
+            pass
+            
+        try:
+            self.ax2.clear() 
+            self.delaxes(self.ax2) #.clear()
+        except:
+            pass
+
+        self.ax1 = self.fig.add_subplot(211)
+        self.ax2 = self.fig.add_subplot(212)
+
+        self.ax1.tick_params(axis='both', which='major', labelsize=8)
+        self.ax2.tick_params(axis='both', which='major', labelsize=8)
+
+        self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.ax1.yaxis.get_offset_text().set_size(8) 
+        self.ax2.yaxis.get_offset_text().set_size(8) 
+
+    def reAx4(self):
+        try:
+            self.fig.clear()
+        except:
+            pass
+
+        # two main axes
+        self.ax1 = self.fig.add_axes([0.15, 0.55,   0.625, 0.3672])
+        self.ax2 = self.fig.add_axes([0.15, 0.135 , 0.625, 0.3672])
+        
+        # for colourbars
+        self.cax1 = self.fig.add_axes([0.8, 0.55 ,  0.025, 0.3672])
+        self.cax2 = self.fig.add_axes([0.8, 0.135,  0.025, 0.3672])
+        
+        self.ax1.tick_params(axis='both', which='major', labelsize=8)
+        self.ax2.tick_params(axis='both', which='major', labelsize=8)
+
+        self.ax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.ax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.ax1.yaxis.get_offset_text().set_size(8) 
+        self.ax2.yaxis.get_offset_text().set_size(8) 
+
+        self.cax1.tick_params(axis='both', which='major', labelsize=8)
+        self.cax2.tick_params(axis='both', which='major', labelsize=8)
+
+        self.cax1.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+        self.cax2.ticklabel_format(style='sci', scilimits=(0,0), axis='y')  
+
+        self.cax1.yaxis.get_offset_text().set_size(8) #.get_text()
+        self.cax2.yaxis.get_offset_text().set_size(8) #.get_text()
+
+        self.cax1.tick_params(labelsize=8) 
+        self.cax2.tick_params(labelsize=8)
+        
+        #self.ax1.yaxis.minorticks_off()
+        #self.ax2.yaxis.minorticks_off()
+        
+        plt.tick_params(
+            axis='y',          # changes apply to the x-axis
+            which='minor',      # both major and minor ticks are affected
+            bottom='off',      # ticks along the bottom edge are off
+            top='off',         # ticks along the top edge are off
+            labelbottom='off') 
+
+if __name__ == "__main__":
+   
+    first = True
+    for ffile in sys.argv[1::]: 
+        Canvas = canvas()
+        pfile = file(ffile)
+        unpickle = pickle.Unpickler(pfile)
+        MRS = mrsurvey.GMRDataProcessor()
+        MRS.DATADICT = unpickle.load()
+        MRS.pulseType = MRS.DATADICT["INFO"]["pulseType"]
+        MRS.transFreq = MRS.DATADICT["INFO"]["transFreq"]
+        MRS.pulseLength = MRS.DATADICT["INFO"]["pulseLength"]
+        MRS.TuneCapacitance = MRS.DATADICT["INFO"]["TuneCapacitance"]
+        MRS.samp = MRS.DATADICT["INFO"]["samp"]
+        MRS.nPulseMoments = MRS.DATADICT["INFO"]["nPulseMoments"]
+        MRS.deadTime = MRS.DATADICT["INFO"]["deadTime"]
+
+        MRS.quadDet(1, True, Canvas)
+        MRS.gateIntegrate(14, 1, Canvas )
+
+        #Canvas.fig.suptitle(r"\textbf{Experiment 0, channel 4}",  fontsize=8) #, fontweight='bold')
+        Canvas.ax1.set_title(r"Experiment 0, channel 4",  fontsize=8) 
+        #Canvas.ax1.set_title("Channel 4")
+
+
+
+        plt.savefig("test.eps", dpi=2200)
+
+        if first:
+            mat = MRS.DATADICT["CA"]
+            pmat = MRS.DATADICT["CP"]
+            first = False
+        else:
+            mat += MRS.DATADICT["CA"]
+            pmat += MRS.DATADICT["CP"]
+
+    quadSum = True
+    if quadSum:
+    
+        Canvas.ax1.clear() 
+        Canvas.ax2.clear() 
+        Canvas.cax1.clear() 
+        Canvas.cax2.clear() 
+        pulse = "Pulse 1"
+        clip = 1
+        QQ = np.average(MRS.DATADICT[pulse]["Q"], axis=1 )
+        im1 = Canvas.ax1.pcolormesh( 1e3*MRS.DATADICT[pulse]["TIMES"][clip-1:-clip], QQ, mat,  cmap='coolwarm_r', rasterized=True, vmin=-np.max(np.abs(mat)), vmax=np.max(np.abs(mat)))
+        im2 = Canvas.ax2.pcolormesh( 1e3*MRS.DATADICT[pulse]["TIMES"][clip-1:-clip], QQ, pmat, cmap='coolwarm_r', rasterized=True, vmin=-np.max(np.abs(pmat)), vmax=np.max(np.abs(pmat)))
+
+        cb2 = Canvas.fig.colorbar(im2, cax=Canvas.cax2)
+        cb2.set_label("Noise residual (nV)", fontsize=8)
+
+
+        #canvas.ax2.yaxis.set_ticks( QQ[0,9::7] )       
+        
+        Canvas.ax1.set_yscale('log')
+        Canvas.ax2.set_yscale('log')
+        
+        qlabs = np.append(np.concatenate( (QQ[0:1],QQ[9::10] )), QQ[-1] ) 
+        Canvas.ax1.yaxis.set_ticks( qlabs ) # np.append(np.concatenate( (QQ[0:1],QQ[9::10] )), QQ[-1] ) )
+        Canvas.ax2.yaxis.set_ticks( qlabs ) #np.append(np.concatenate( (QQ[0:1],QQ[9::10] )), QQ[-1] ) )
+        #formatter = matplotlib.ticker.LogFormatter(10, labelOnlyBase=False)
+        formatter = matplotlib.ticker.FuncFormatter(lambda x, pos: str((round(x,1)))) 
+        Canvas.ax1.yaxis.set_major_formatter(formatter)#matplotlib.ticker.FormatStrFormatter('%d.1'))
+        Canvas.ax2.yaxis.set_major_formatter(formatter)#matplotlib.ticker.FormatStrFormatter('%d.1')) 
+
+        plt.setp(Canvas.ax1.get_xticklabels(), visible=False)
+ 
+        t = 1e3*MRS.DATADICT[pulse]["TIMES"][clip-1:-clip],
+        Canvas.ax1.set_ylim( np.min(QQ), np.max(QQ) )
+        Canvas.ax2.set_ylim( np.min(QQ), np.max(QQ) )
+        Canvas.ax1.set_xlim( np.min(t), np.max(t) )
+        Canvas.ax2.set_xlim( np.min(t), np.max(t) )
+
+        cb1 = Canvas.fig.colorbar(im1, cax=Canvas.cax1)
+        cb1.set_label("Phased amplitude (nV)", fontsize=8)
+
+        Canvas.ax2.set_xlabel(r"Time (ms)", fontsize=8)
+        Canvas.ax1.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
+        Canvas.ax2.set_ylabel(r"$q$ ( $\mathrm{A}\cdot\mathrm{s}$)", fontsize=8)
+
+        plt.savefig("quadSum.eps")
+
+    plt.show()

akvo/terminal/plotyaml.py

+import yaml
+import os, sys
+import numpy as np
+
+def slicedict(d, s):
+    return {k:v for k,v in d.items() if k.startswith(s)}
+
+# Converts Lemma/Merlin/Akvo serialized Eigen arrays into numpy ones for use by Python 
+class VectorXr(yaml.YAMLObject):
+    """
+    Converts Lemma/Merlin/Akvo serialized Eigen arrays into numpy ones for use by Python 
+    """
+    yaml_tag = u'VectorXr'
+    def __init__(self, array):
+        self.size = np.shape(array)[0]
+        self.data = array.tolist()
+    def __repr__(self):
+        # Converts to numpy array on import 
+        return "np.array(%r)" % (self.data)
+
+class AkvoData(yaml.YAMLObject):
+    """
+    Reads an Akvo serialized dataset into a standard python dictionary 
+    """
+    yaml_tag = u'AkvoData'
+    def __init__(self, array):
+        pass
+        #self.size = np.shape(array)[0]
+        #self.Imp = array.tolist()
+    def __repr__(self):
+        # Converts to a dictionary with Eigen vectors represented as Numpy arrays 
+        return self
+
+def loadAkvoData(fnamein, chan):
+    """ Loads data from an Akvo YAML file. The 0.02 is hard coded as the pulse length. This needs to be 
+        corrected in future kernel calculations. The current was reported but not the pulse length. 
+    """
+    fname = (os.path.splitext(fnamein)[0])
+    with open(fnamein, 'r') as stream:
+        try:
+            AKVO = (yaml.load(stream))
+        except yaml.YAMLError as exc:
+            print(exc)
+    return AKVO 
+
+def plotQt( akvo ):
+    import matplotlib.pyplot as plt
+    plt.style.use('ggplot')
+    for pulse in akvo.Gated:
+        if pulse[0:5] == "Pulse":
+            #print(akvo.GATED[pulse].keys())
+            nq = akvo.Pulses[pulse]["current"].size
+            for chan in slicedict(akvo.Gated[pulse], "Chan."):
+                # accumulate pulse moments
+                X = np.zeros( (nq, len( akvo.Gated[pulse]["abscissa"].data )) )
+                for q in range(nq):
+                    plt.plot(  akvo.Gated[pulse]["abscissa"].data,  akvo.Gated[pulse][chan]["Q-" + str(q)+" CA"].data ) 
+                    X[q] = akvo.Gated[pulse][chan]["Q-" + str(q)+" CA"].data
+    plt.matshow(X)
+
+    plt.show()
+if __name__ == "__main__":
+    akvo = loadAkvoData( sys.argv[1] , "Chan. 1")
+    plotQt(akvo)

akvo/terminal/tempPlots.py

+from USGSPlots import USGSPlots
+import plotyaml
+import sys
+
+
+if len(sys.argv) != 4 and len(sys.argv) != 2:
+    print('Usage:')
+    print('whatever.py filename channel option')
+    print('Use whatever.py -h for detailed help')
+    sys.exit()
+
+if len(sys.argv) == 2:
+    print('help!')
+    sys.exit()
+
+
+fname = str(sys.argv[1])
+chan = sys.argv[2]
+
+myplot = USGSPlots()
+
+myplot.getData(fname,chan)
+
+

akvo/tressel/__init__.py

+#import decay
+#import rotate
+#import mrsurvey 

akvo/tressel/adapt.py

+import numpy as np
+from numpy.linalg import lstsq
+from numpy.linalg import norm
+from numpy import fft 
+
+import pylab
+
+from scipy.signal import correlate
+
+def autocorr(x):
+    #result = np.correlate(x, x, mode='full')
+    result = correlate(x, x, mode='full')
+    return result[result.size/2:]
+
+class AdaptiveFilter:
+
+    def __init__(self, mu):
+        self.mu = mu
+
+    def adapt_filt_Ref(self, x, R, M, mu, PCA, lambda2=0.95, H0=0):
+        """ Taken from .m file
+        This function is written to allow the user to filter a input signal   
+        with an adaptive filter that utilizes 2 reference signals instead of  
+        the standard method which allows for only 1 reference signal.         
+        Author: Rob Clemens              Date: 3/16/06                       
+        Modified and ported to Python, now takes arbitray number of reference points  
+        """
+        #from akvo.tressel import pca 
+        import akvo.tressel.pca as pca 
+
+        if np.shape(x) != np.shape(R[0]): # or np.shape(x) != np.shape(rx1):
+            print ("Error, non aligned")
+            exit(1)
+        
+        if PCA == "Yes":
+            # PCA decomposition on ref channels so signals are less related
+            R, K, means = pca.pca( R )
+        
+        if all(H0) == 0:
+            H = np.zeros( (len(R)*M))
+            #print ("resetting filter")
+        else:
+            H = H0
+        Rn = np.ones(len(R)*M) / mu 
+        
+        r_ = np.zeros( (len(R), M) ) 
+        e = np.zeros(len(x)) # error, desired output
+        ilambda = lambda2**-1
+
+        for z in range(0, len(x)):
+            # Only look forwards, to avoid distorting the lates times 
+            # (run backwards, if opposite and you don't care about distorting very late time.)
+            for ir in range(len(R)):
+                if z < M:
+                    r_[ir,0:z] = R[ir][0:z]
+                    r_[ir,z:M] = 0 
+                else:
+                    # TODO, use np.delete and np.append to speed this up
+                    r_[ir,:] = R[ir][z-M:z]
+            # reshape            
+            r_n = np.reshape(r_, -1) #concatenate((r_v, r_h ))
+
+            #K      = np.dot( np.diag(Rn,0), r_n) / (lambda2 + np.dot(r_n*Rn, r_n))  # Create/update K
+            K      = (Rn* r_n) / (lambda2 + np.dot(r_n*Rn, r_n))  # Create/update K
+            e[z]   = x[z] - np.dot(r_n.T, H)             # e is the filtered signal, input - r(n) * Filter Coefs
+            H     += K*e[z];                             # Update Filter Coefficients
+            Rn     = ilambda*Rn - ilambda*np.dot(np.dot(K, r_n.T), Rn)     # Update R(n)
+        return e, H
+
+    def transferFunctionFFT(self, D, R, reg=1e-2):
+        from akvo.tressel import pca
+        """
+            Computes the transfer function (H) between a Data channel and 
+            a number of Reference channels. The Matrices D and R are 
+            expected to be in the frequency domain on input.
+            | R1'R1 R1'R2 R1'R3|   |h1|   |R1'D|
+            | R2'R1 R2'R2 R2'R3| * |h2| = |R2'D|
+            | R3'R1 R3'R2 R3'R3|   |h3|   |R3'D|
+
+            Returns the corrected array 
+        """
+
+        # PCA decomposition on ref channels so signals are less related
+        #transMatrix, K, means = pca.pca( np.array([rx0, rx1]))   
+        #RR = np.zeros(( np.shape(R[0])[0]*np.shape(R[0])[1], len(R)))
+#         RR = np.zeros(( len(R), np.shape(R[0])[0]*np.shape(R[0])[1] ))
+#         for ir in range(len(R)):
+#             RR[ir,:] = np.reshape(R[ir], -1)
+#         transMatrix, K, means = pca.pca(RR)    
+#         #R rx0 = transMatrix[0,:]
+#         # rx1 = transMatrix[1,:]
+#         for ir in range(len(R)):
+#             R[ir] = transMatrix[ir,0]
+
+        import scipy.linalg 
+        import akvo.tressel.pca as pca 
+        # Compute as many transfer functions as len(R)
+        # A*H = B
+        nref = len(R)
+        H = np.zeros( (np.shape(D)[1], len(R)), dtype=complex )
+        for iw in range(np.shape(D)[1]):
+            A = np.zeros( (nref, nref), dtype=complex )
+            B = np.zeros( (nref) , dtype=complex)
+            for ii in range(nref):
+                for jj in range(nref):
+                    # build A
+                    A[ii,jj] = np.dot(R[ii][:,iw], R[jj][:,iw])                 
+
+                # build B
+                B[ii] = np.dot( R[ii][:,iw], D[:,iw] )
+
+            # compute H(iw)
+            #linalg.solve(a,b) if a is square
+            #print "A", A
+            #print "B", B
+            # TODO, regularise this solve step? So as to not fit the spurious noise
+            #print np.shape(B), np.shape(A) 
+            #H[iw, :] = scipy.linalg.solve(A,B)
+            H[iw, :] = scipy.linalg.lstsq(A,B,cond=reg)[0]
+            #print "lstqt", np.shape(scipy.linalg.lstsq(A,B))
+            #print "solve", scipy.linalg.solve(A,B)
+            #H[iw,:]  = scipy.linalg.lstsq(A,B) # otherwise 
+                #H = np.zeros( (np.shape(D)[1], )   )
+        #print H #A, B
+        Error = np.zeros(np.shape(D), dtype=complex)
+        for ir in range(nref):
+            for q in range( np.shape(D)[0] ):
+                #print "dimcheck", np.shape(H[:,ir]), np.shape(R[ir][q,:] )
+                Error[q,:] += H[:,ir]*R[ir][q,:]
+        return D - Error
+
+    def adapt_filt_tworefFreq(self, x, rx0, rx1, M, lambda2=0.95):
+        """ Frequency domain version of above
+        """
+        from akvo.tressel import pca 
+
+        pylab.figure()
+        pylab.plot(rx0)
+        pylab.plot(rx1)
+
+        # PCA decomposition on ref channels so signals are less related
+        transMatrix, K, means = pca.pca( np.array([rx0, rx1]))    
+        rx0 = transMatrix[:,0]
+        rx1 = transMatrix[:,1]
+        
+        pylab.plot(rx0)
+        pylab.plot(rx1)
+        pylab.show()
+        exit()
+
+        if np.shape(x) != np.shape(rx0) or np.shape(x) != np.shape(rx1):
+            print ("Error, non aligned")
+            exit(1)
+
+        wx = fft.rfft(x)
+        wr0 = fft.rfft(rx0)
+        wr1 = fft.rfft(rx1)
+ 
+        H = np.zeros( (2*M), dtype=complex ) 
+        ident_mat = np.eye((2*M))
+        Rn = ident_mat / 0.1
+        r_v = np.zeros( (M), dtype=complex ) 
+        r_h = np.zeros( (M), dtype=complex ) 
+        e = np.zeros(len(x), dtype=complex )
+        ilambda = lambda2**-1
+
+        for z in range(0, len(wx)):
+            # TODO Padd with Zeros or truncate if M >,< arrays 
+            r_v = wr0[::-1][:M] 
+            r_h = wr1[::-1][:M] 
+            r_n = np.concatenate((r_v, r_h ))
+            K      = np.dot(Rn, r_n) / (lambda2 + np.dot(np.dot(r_n.T, Rn), r_n))  # Create/update K
+            e[z]   = wx[z] - np.dot(r_n,H)        # e is the filtered signal, input - r(n) * Filter Coefs
+            H     += K * e[z];                    # Update Filter Coefficients
+            Rn     = ilambda*Rn - ilambda*K*r_n.T*Rn  # Update R(n)
+        
+        return fft.irfft(e)
+
+    def iter_filt_refFreq(self, x, rx0, Ahat=.05, Bhat=.5, k=0.05):
+
+        X = np.fft.rfft(x)
+        X0 = np.copy(X)
+        RX0 = np.fft.rfft(rx0)
+
+        # step 0
+        Abs2HW = []
+        alphai =  k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) 
+        betai  =  k * (1. / (np.abs(Bhat)**2) ) 
+        Hw     =  ((1.+alphai) * np.abs(X)**2 ) / (np.abs(X)**2 + betai*(np.abs(RX0)**2))
+        H      =  np.abs(Hw)**2
+        pylab.ion()
+        pylab.figure()
+        for i in range(10):
+            #print "alphai", alphai
+            #print "betai", betai
+            #print "Hw", Hw
+            alphai = k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) * np.product(H, axis=0)
+            betai  = k * (1. / np.abs(Bhat)**2) * np.product(H, axis=0)
+            # update signal
+            Hw   =  ((1.+alphai) * np.abs(X)**2) / (np.abs(X)**2 + betai*np.abs(RX0)**2)
+            Hw = np.nan_to_num(Hw)
+            X *= Hw
+            H = np.vstack( (H, np.abs(Hw)**2) )
+            #print "Hw", Hw
+            pylab.cla()
+            pylab.plot(Hw)
+            #pylab.plot(np.abs(X))
+            #pylab.plot(np.abs(RX0))
+            pylab.draw()
+            raw_input("wait")
+
+        pylab.cla()
+        pylab.ioff()
+        #return np.fft.irfft(X0-X)
+        return np.fft.irfft(X)
+
+    def iter_filt_refFreq(self, x, rx0, rx1, Ahat=.1, Bhat=1., k=0.001):
+
+        X = np.fft.rfft(x)
+        X0 = np.copy(X)
+        RX0 = np.fft.rfft(rx0)
+        RX1 = np.fft.rfft(rx1)
+
+        # step 0
+        alphai =  k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) 
+        betai  =  k * (1. / (np.abs(Bhat)**2) ) 
+        #Hw     =  ((1.+alphai) * np.abs(X)**2 ) / (np.abs(X)**2 + betai*(np.abs(RX0)**2))
+        H      =  np.ones(len(X)) # abs(Hw)**2
+        #pylab.ion()
+        #pylab.figure(334)
+        for i in range(1000):
+            #print "alphai", alphai
+            #print "betai", betai
+            #print "Hw", Hw
+            alphai = k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) * np.product(H, axis=0)
+            betai  = k * (1. / np.abs(Bhat)**2) * np.product(H, axis=0)
+            # update signal
+            Hw   =  ((1.+alphai) * np.abs(X)**2) / (np.abs(X)**2 + betai*np.abs(RX0)**2)
+            Hw = np.nan_to_num(Hw)
+            X *= Hw #.conjugate
+            #H = np.vstack((H, np.abs(Hw)**2) )
+            H = np.vstack((H, np.abs(Hw)) )
+            #print "Hw", Hw
+            #pylab.cla()
+            #pylab.plot(Hw)
+            #pylab.plot(np.abs(X))
+            #pylab.plot(np.abs(RX0))
+            #pylab.draw()
+            #raw_input("wait")
+
+        #pylab.cla()
+        #pylab.ioff()
+        return np.fft.irfft(X0-X)
+        #return np.fft.irfft(X)
+
+    def Tdomain_DFT(self, desired, input, S):
+        """ Lifted from Adaptive filtering toolbox. Modefied to accept more than one input 
+            vector
+        """
+        
+        # Initialisation Procedure
+        nCoefficients =   S["filterOrderNo"]/2+1
+        nIterations   =   len(desired)
+
+        # Pre Allocations
+        errorVector  = np.zeros(nIterations, dtype='complex')
+        outputVector = np.zeros(nIterations, dtype='complex')
+        
+        # Initial State
+        coefficientVectorDFT =   np.fft.rfft(S["initialCoefficients"])/np.sqrt(float(nCoefficients))
+        desiredDFT           =   np.fft.rfft(desired)
+        powerVector          =   S["initialPower"]*np.ones(nCoefficients)
+
+        # Improve source code regularity, pad with zeros
+        # TODO, confirm zeros(nCoeffics) not nCoeffics-1
+        prefixedInput  =   np.concatenate([np.zeros(nCoefficients-1), np.array(input)])
+
+        # Body
+        pylab.ion()
+        pylab.figure(11)
+        for it in range(nIterations): # = 1:nIterations,
+            
+            regressorDFT = np.fft.rfft(prefixedInput[it:it+nCoefficients][::-1]) /\
+                           np.sqrt(float(nCoefficients))
+
+            # Summing two column vectors
+            powerVector = S["alpha"] * (regressorDFT*np.conjugate(regressorDFT)) + \
+                                  (1.-S["alpha"])*(powerVector)
+
+            pylab.cla()
+            #pylab.plot(prefixedInput[::-1], 'b')
+            #pylab.plot(prefixedInput[it:it+nCoefficients][::-1], 'g', linewidth=3)
+            #pylab.plot(regressorDFT.real)
+            #pylab.plot(regressorDFT.imag)
+            pylab.plot(powerVector.real)
+            pylab.plot(powerVector.imag)
+            #pylab.plot(outputVector)
+            #pylab.plot(errorVector.real)
+            #pylab.plot(errorVector.imag)
+            pylab.draw()
+            #raw_input("wait")
+
+            outputVector[it] = np.dot(coefficientVectorDFT.T, regressorDFT)
+
+            #errorVector[it] = desired[it] - outputVector[it]
+            errorVector[it] = desiredDFT[it] - outputVector[it]
+
+            #print errorVector[it], desired[it], outputVector[it]
+
+            # Vectorized
+            coefficientVectorDFT += (S["step"]*np.conjugate(errorVector[it])*regressorDFT) /\
+                                    (S['gamma']+powerVector)
+
+        return np.real(np.fft.irfft(errorVector))
+        #coefficientVector = ifft(coefficientVectorDFT)*sqrt(nCoefficients);
+
+    def Tdomain_DCT(self, desired, input, S):
+        """ Lifted from Adaptive filtering toolbox. Modefied to accept more than one input 
+            vector. Uses cosine transform
+        """
+        from scipy.fftpack import dct
+ 
+        # Initialisation Procedure
+        nCoefficients =   S["filterOrderNo"]+1
+        nIterations   =   len(desired)
+
+        # Pre Allocations
+        errorVector  = np.zeros(nIterations)
+        outputVector = np.zeros(nIterations)
+        
+        # Initial State
+        coefficientVectorDCT =   dct(S["initialCoefficients"]) #/np.sqrt(float(nCoefficients))
+        desiredDCT           =   dct(desired)
+        powerVector          =   S["initialPower"]*np.ones(nCoefficients)
+
+        # Improve source code regularity, pad with zeros
+        prefixedInput  =   np.concatenate([np.zeros(nCoefficients-1), np.array(input)])
+        
+        # Body
+        #pylab.figure(11)
+        #pylab.ion()
+        for it in range(0, nIterations): # = 1:nIterations,
+            
+            regressorDCT = dct(prefixedInput[it:it+nCoefficients][::-1], type=2) 
+            #regressorDCT = dct(prefixedInput[it+nCoefficients:it+nCoefficients*2+1])#[::-1]) 
+
+            # Summing two column vectors
+            powerVector = S["alpha"]*(regressorDCT) + (1.-S["alpha"])*(powerVector)
+            #pylab.cla()
+            #pylab.plot(powerVector)
+            #pylab.draw()
+
+            outputVector[it] = np.dot(coefficientVectorDCT.T, regressorDCT)
+            #errorVector[it] = desired[it] - outputVector[it]
+            errorVector[it] = desiredDCT[it] - outputVector[it]
+
+            # Vectorized
+            coefficientVectorDCT += (S["step"]*errorVector[it]*regressorDCT) #/\
+                                    #(S['gamma']+powerVector)
+
+        #pylab.plot(errorVector)
+        #pylab.show()
+        return dct(errorVector, type=3)
+        #coefficientVector = ifft(coefficientVectorDCT)*sqrt(nCoefficients);
+
+
+
+    def Tdomain_CORR(self, desired, input, S):
+
+        from scipy.linalg import toeplitz
+        from scipy.signal import correlate
+
+        # Autocorrelation
+        ac = np.correlate(input, input, mode='full')
+        ac = ac[ac.size/2:]
+        R = toeplitz(ac)
+        
+        # cross correllation
+        r = np.correlate(desired, input, mode='full')
+        r = r[r.size/2:]
+        
+        #r = np.correlate(desired, input, mode='valid')
+        print ("R", np.shape(R))
+        print ("r", np.shape(r))
+        print ("solving")
+        #H = np.linalg.solve(R,r)
+        H = np.linalg.lstsq(R,r,rcond=.01)[0]
+        #return desired - np.dot(H,input)
+        print ("done solving")
+        pylab.figure()
+        pylab.plot(H)
+        pylab.title("H")
+        #return desired - np.convolve(H, input, mode='valid')
+        #return desired - np.convolve(H, input, mode='same')
+        #return np.convolve(H, input, mode='same')
+        return desired - np.dot(toeplitz(H), input)
+        #return np.dot(R, H)
+
+#         T = toeplitz(input)
+#         print "shapes", np.shape(T), np.shape(desired)
+#         h = np.linalg.lstsq(T, desired)[0]
+#         print "shapes", np.shape(h), np.shape(input)
+#         #return np.convolve(h, input, mode='same')
+#         return desired - np.dot(T,h)
+ 
+    def Fdomain_CORR(self, desired, input, dt, freq):
+        
+        from scipy.linalg import toeplitz
+        
+        # Fourier domain
+        Input = np.fft.rfft(input)
+        Desired = np.fft.rfft(desired)
+
+        T = toeplitz(Input)
+        #H = np.linalg.solve(T, Desired)
+        H = np.linalg.lstsq(T, Desired)[0]
+#         ac = np.correlate(Input, Input, mode='full')
+#         ac = ac[ac.size/2:]
+#         R = toeplitz(ac)
+#         
+#         r = np.correlate(Desired, Input, mode='full')
+#         r = r[r.size/2:]
+#         
+#         #r = np.correlate(desired, input, mode='valid')
+#         print "R", np.shape(R)
+#         print "r", np.shape(r)
+#         print "solving"
+#         H = np.linalg.solve(R,r)
+#         #H = np.linalg.lstsq(R,r)
+#         #return desired - np.dot(H,input)
+#         print "done solving"
+        pylab.figure()
+        pylab.plot(H.real)
+        pylab.plot(H.imag)
+        pylab.plot(Input.real)
+        pylab.plot(Input.imag)
+        pylab.plot(Desired.real)
+        pylab.plot(Desired.imag)
+        pylab.legend(["hr","hi","ir","ii","dr","di"])
+        pylab.title("H")
+        #return desired - np.fft.irfft(Input*H)
+        return np.fft.irfft(H*Input)
+
+    def Tdomain_RLS(self, desired, input, S):
+        """
+            A DFT is first performed on the data. Than a RLS algorithm is carried out 
+            for noise cancellation. Related to the RLS_Alt Algoritm 5.3 in  Diniz book.
+            The desired and input signals are assummed to be real time series data.
+        """
+
+        # Transform data into frequency domain
+        Input = np.fft.rfft(input)
+        Desired = np.fft.rfft(desired)
+
+        # Initialisation Procedure
+        nCoefficients = S["filterOrderNo"]+1
+        nIterations   = len(Desired)
+
+        # Pre Allocations
+        errorVector  = np.zeros(nIterations, dtype="complex")
+        outputVector = np.zeros(nIterations, dtype="complex")
+        errorVectorPost  = np.zeros(nIterations, dtype="complex")
+        outputVectorPost = np.zeros(nIterations, dtype="complex")
+        coefficientVector = np.zeros( (nCoefficients, nIterations+1), dtype="complex" )        
+
+        # Initial State
+        coefficientVector[:,1] = S["initialCoefficients"]  
+        S_d                    = S["delta"]*np.eye(nCoefficients)
+
+        # Improve source code regularity, pad with zeros
+        prefixedInput = np.concatenate([np.zeros(nCoefficients-1, dtype="complex"), 
+                                np.array(Input)])
+        invLambda = 1./S["lambda"]
+        
+        # Body
+        pylab.ion()
+        pylab.figure(11)
+
+        for it in range(nIterations):
+            
+            regressor = prefixedInput[it:it+nCoefficients][::-1]
+
+            # a priori estimated output
+            outputVector[it] = np.dot(coefficientVector[:,it].T, regressor)
+       
+            # a priori error
+            errorVector[it] = Desired[it] - outputVector[it]
+
+            psi             = np.dot(S_d, regressor)
+            if np.isnan(psi).any():
+                print ("psi", psi)
+                exit(1)
+            
+            pylab.cla()
+            #pylab.plot(psi)
+            pylab.plot(regressor.real)
+            pylab.plot(regressor.imag)
+            pylab.plot(coefficientVector[:,it].real)
+            pylab.plot(coefficientVector[:,it].imag)
+            pylab.legend(["rr","ri", "cr", "ci"])
+            pylab.draw()
+            raw_input("paws")
+
+            S_d             = invLambda * (S_d - np.dot(psi, psi.T)  /\
+                                S["lambda"] + np.dot(psi.T, regressor))
+
+            coefficientVector[:,it+1] = coefficientVector[:,it] + \
+                                        np.conjugate(errorVector[it])*np.dot(S_d, regressor)
+            # A posteriori estimated output
+            outputVectorPost[it]  =  np.dot(coefficientVector[:,it+1].T, regressor)
+
+            # A posteriori error
+            errorVectorPost[it] = Desired[it] - outputVectorPost[it]
+ 
+        errorVectorPost = np.nan_to_num(errorVectorPost)
+
+        pylab.figure(11)
+        print (np.shape(errorVectorPost))
+        pylab.plot(errorVectorPost.real)
+        pylab.plot(errorVectorPost.imag)
+        pylab.show()
+        print(errorVectorPost)
+        #return np.fft.irfft(Desired)
+        return np.fft.irfft(errorVectorPost)
+
+if __name__ == "__main__":
+
+    def noise(nu, t, phi):
+        return np.sin(nu*2.*np.pi*t + phi)
+
+    import matplotlib.pyplot as plt
+    print("Test driver for adaptive filtering")
+    Filt = AdaptiveFilter(.1)
+    t = np.arange(0, .5, 1e-4)
+    omega = 2000 * 2.*np.pi
+    T2 = .100
+    n1 = noise(60, t, .2   )
+    n2 = noise(61, t, .514 )
+    x = np.sin(omega*t)* np.exp(-t/T2) + 2.3*noise(60, t, .34) + 1.783*noise(31, t, 2.1)
+    e = Filt.adapt_filt_tworef(x, n1, n2, 200, .98)
+    plt.plot(t,  x)
+    plt.plot(t, n1)
+    plt.plot(t, n2)
+    plt.plot(t,  e)
+    plt.show()

akvo/tressel/cadapt.pyx

+import numpy as np
+from numpy.linalg import lstsq
+from numpy.linalg import norm
+from numpy import fft 
+
+import pylab
+
+from scipy.signal import correlate
+
+def autocorr(x):
+    #result = np.correlate(x, x, mode='full')
+    result = correlate(x, x, mode='full')
+    return result[result.size/2:]
+
+class AdaptiveFilter:
+
+    def __init__(self, mu):
+        self.mu = mu
+
+    def adapt_filt_Ref(self, x, R, M, mu, PCA, lambda2=0.95, H0=0):
+        """ Taken from .m file
+        This function is written to allow the user to filter a input signal   
+        with an adaptive filter that utilizes 2 reference signals instead of  
+        the standard method which allows for only 1 reference signal.         
+        Author: Rob Clemens              Date: 3/16/06                       
+        Modified and ported to Python, now takes arbitray number of reference points  
+        """
+        #from akvo.tressel import pca 
+        import akvo.tressel.cpca as pca 
+
+        if np.shape(x) != np.shape(R[0]): # or np.shape(x) != np.shape(rx1):
+            print ("Error, non aligned")
+            exit(1)
+        
+        if PCA == "Yes":
+            # PCA decomposition on ref channels so signals are less related
+            R, K, means = pca.pca( R )
+        
+        if all(H0) == 0:
+            H = np.zeros( (len(R)*M))
+            #print ("resetting filter")
+        else:
+            H = H0
+        Rn = np.ones(len(R)*M) / mu 
+        
+        r_ = np.zeros( (len(R), M) ) 
+        e = np.zeros(len(x)) # error, desired output
+        ilambda = lambda2**-1
+        cdef int z
+        cdef int ir
+        for z in range(0, len(x)):
+            # Only look forwards, to avoid distorting the lates times 
+            # (run backwards, if opposite and you don't care about distorting very late time.)
+            for ir in range(len(R)):
+                if z < M:
+                    r_[ir,0:z] = R[ir][0:z]
+                    r_[ir,z:M] = 0 
+                else:
+                    # TODO, use np.delete and np.append to speed this up
+                    r_[ir,:] = R[ir][z-M:z]
+            # reshape            
+            r_n = np.reshape(r_, -1) #concatenate((r_v, r_h ))
+
+            #K      = np.dot( np.diag(Rn,0), r_n) / (lambda2 + np.dot(r_n*Rn, r_n))  # Create/update K
+            K      = (Rn* r_n) / (lambda2 + np.dot(r_n*Rn, r_n))  # Create/update K
+            e[z]   = x[z] - np.dot(r_n.T, H)             # e is the filtered signal, input - r(n) * Filter Coefs
+            H     += K*e[z];                             # Update Filter Coefficients
+            Rn     = ilambda*Rn - ilambda*np.dot(np.dot(K, r_n.T), Rn)     # Update R(n)
+        return e, H
+
+    def transferFunctionFFT(self, D, R, reg=1e-2):
+        from akvo.tressel import pca
+        """
+            Computes the transfer function (H) between a Data channel and 
+            a number of Reference channels. The Matrices D and R are 
+            expected to be in the frequency domain on input.
+            | R1'R1 R1'R2 R1'R3|   |h1|   |R1'D|
+            | R2'R1 R2'R2 R2'R3| * |h2| = |R2'D|
+            | R3'R1 R3'R2 R3'R3|   |h3|   |R3'D|
+
+            Returns the corrected array 
+        """
+
+        # PCA decomposition on ref channels so signals are less related
+        #transMatrix, K, means = pca.pca( np.array([rx0, rx1]))   
+        #RR = np.zeros(( np.shape(R[0])[0]*np.shape(R[0])[1], len(R)))
+#         RR = np.zeros(( len(R), np.shape(R[0])[0]*np.shape(R[0])[1] ))
+#         for ir in range(len(R)):
+#             RR[ir,:] = np.reshape(R[ir], -1)
+#         transMatrix, K, means = pca.pca(RR)    
+#         #R rx0 = transMatrix[0,:]
+#         # rx1 = transMatrix[1,:]
+#         for ir in range(len(R)):
+#             R[ir] = transMatrix[ir,0]
+
+        import scipy.linalg 
+        import akvo.tressel.pca as pca 
+        # Compute as many transfer functions as len(R)
+        # A*H = B
+        nref = len(R)
+        H = np.zeros( (np.shape(D)[1], len(R)), dtype=complex )
+        for iw in range(np.shape(D)[1]):
+            A = np.zeros( (nref, nref), dtype=complex )
+            B = np.zeros( (nref) , dtype=complex)
+            for ii in range(nref):
+                for jj in range(nref):
+                    # build A
+                    A[ii,jj] = np.dot(R[ii][:,iw], R[jj][:,iw])                 
+
+                # build B
+                B[ii] = np.dot( R[ii][:,iw], D[:,iw] )
+
+            # compute H(iw)
+            #linalg.solve(a,b) if a is square
+            #print "A", A
+            #print "B", B
+            # TODO, regularise this solve step? So as to not fit the spurious noise
+            #print np.shape(B), np.shape(A) 
+            #H[iw, :] = scipy.linalg.solve(A,B)
+            H[iw, :] = scipy.linalg.lstsq(A,B,cond=reg)[0]
+            #print "lstqt", np.shape(scipy.linalg.lstsq(A,B))
+            #print "solve", scipy.linalg.solve(A,B)
+            #H[iw,:]  = scipy.linalg.lstsq(A,B) # otherwise 
+                #H = np.zeros( (np.shape(D)[1], )   )
+        #print H #A, B
+        Error = np.zeros(np.shape(D), dtype=complex)
+        for ir in range(nref):
+            for q in range( np.shape(D)[0] ):
+                #print "dimcheck", np.shape(H[:,ir]), np.shape(R[ir][q,:] )
+                Error[q,:] += H[:,ir]*R[ir][q,:]
+        return D - Error
+
+    def adapt_filt_tworefFreq(self, x, rx0, rx1, M, lambda2=0.95):
+        """ Frequency domain version of above
+        """
+        from akvo.tressel import pca 
+
+        pylab.figure()
+        pylab.plot(rx0)
+        pylab.plot(rx1)
+
+        # PCA decomposition on ref channels so signals are less related
+        transMatrix, K, means = pca.pca( np.array([rx0, rx1]))    
+        rx0 = transMatrix[:,0]
+        rx1 = transMatrix[:,1]
+        
+        pylab.plot(rx0)
+        pylab.plot(rx1)
+        pylab.show()
+        exit()
+
+        if np.shape(x) != np.shape(rx0) or np.shape(x) != np.shape(rx1):
+            print ("Error, non aligned")
+            exit(1)
+
+        wx = fft.rfft(x)
+        wr0 = fft.rfft(rx0)
+        wr1 = fft.rfft(rx1)
+ 
+        H = np.zeros( (2*M), dtype=complex ) 
+        ident_mat = np.eye((2*M))
+        Rn = ident_mat / 0.1
+        r_v = np.zeros( (M), dtype=complex ) 
+        r_h = np.zeros( (M), dtype=complex ) 
+        e = np.zeros(len(x), dtype=complex )
+        ilambda = lambda2**-1
+
+        for z in range(0, len(wx)):
+            # TODO Padd with Zeros or truncate if M >,< arrays 
+            r_v = wr0[::-1][:M] 
+            r_h = wr1[::-1][:M] 
+            r_n = np.concatenate((r_v, r_h ))
+            K      = np.dot(Rn, r_n) / (lambda2 + np.dot(np.dot(r_n.T, Rn), r_n))  # Create/update K
+            e[z]   = wx[z] - np.dot(r_n,H)        # e is the filtered signal, input - r(n) * Filter Coefs
+            H     += K * e[z];                    # Update Filter Coefficients
+            Rn     = ilambda*Rn - ilambda*K*r_n.T*Rn  # Update R(n)
+        
+        return fft.irfft(e)
+
+    def iter_filt_refFreq(self, x, rx0, Ahat=.05, Bhat=.5, k=0.05):
+
+        X = np.fft.rfft(x)
+        X0 = np.copy(X)
+        RX0 = np.fft.rfft(rx0)
+
+        # step 0
+        Abs2HW = []
+        alphai =  k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) 
+        betai  =  k * (1. / (np.abs(Bhat)**2) ) 
+        Hw     =  ((1.+alphai) * np.abs(X)**2 ) / (np.abs(X)**2 + betai*(np.abs(RX0)**2))
+        H      =  np.abs(Hw)**2
+        pylab.ion()
+        pylab.figure()
+        for i in range(10):
+            #print "alphai", alphai
+            #print "betai", betai
+            #print "Hw", Hw
+            alphai = k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) * np.product(H, axis=0)
+            betai  = k * (1. / np.abs(Bhat)**2) * np.product(H, axis=0)
+            # update signal
+            Hw   =  ((1.+alphai) * np.abs(X)**2) / (np.abs(X)**2 + betai*np.abs(RX0)**2)
+            Hw = np.nan_to_num(Hw)
+            X *= Hw
+            H = np.vstack( (H, np.abs(Hw)**2) )
+            #print "Hw", Hw
+            pylab.cla()
+            pylab.plot(Hw)
+            #pylab.plot(np.abs(X))
+            #pylab.plot(np.abs(RX0))
+            pylab.draw()
+            raw_input("wait")
+
+        pylab.cla()
+        pylab.ioff()
+        #return np.fft.irfft(X0-X)
+        return np.fft.irfft(X)
+
+    def iter_filt_refFreq(self, x, rx0, rx1, Ahat=.1, Bhat=1., k=0.001):
+
+        X = np.fft.rfft(x)
+        X0 = np.copy(X)
+        RX0 = np.fft.rfft(rx0)
+        RX1 = np.fft.rfft(rx1)
+
+        # step 0
+        alphai =  k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) 
+        betai  =  k * (1. / (np.abs(Bhat)**2) ) 
+        #Hw     =  ((1.+alphai) * np.abs(X)**2 ) / (np.abs(X)**2 + betai*(np.abs(RX0)**2))
+        H      =  np.ones(len(X)) # abs(Hw)**2
+        #pylab.ion()
+        #pylab.figure(334)
+        for i in range(1000):
+            #print "alphai", alphai
+            #print "betai", betai
+            #print "Hw", Hw
+            alphai = k * (np.abs(Ahat)**2 / np.abs(Bhat)**2) * np.product(H, axis=0)
+            betai  = k * (1. / np.abs(Bhat)**2) * np.product(H, axis=0)
+            # update signal
+            Hw   =  ((1.+alphai) * np.abs(X)**2) / (np.abs(X)**2 + betai*np.abs(RX0)**2)
+            Hw = np.nan_to_num(Hw)
+            X *= Hw #.conjugate
+            #H = np.vstack((H, np.abs(Hw)**2) )
+            H = np.vstack((H, np.abs(Hw)) )
+            #print "Hw", Hw
+            #pylab.cla()
+            #pylab.plot(Hw)
+            #pylab.plot(np.abs(X))
+            #pylab.plot(np.abs(RX0))
+            #pylab.draw()
+            #raw_input("wait")
+
+        #pylab.cla()
+        #pylab.ioff()
+        return np.fft.irfft(X0-X)
+        #return np.fft.irfft(X)
+
+    def Tdomain_DFT(self, desired, input, S):
+        """ Lifted from Adaptive filtering toolbox. Modefied to accept more than one input 
+            vector
+        """
+        
+        # Initialisation Procedure
+        nCoefficients =   S["filterOrderNo"]/2+1
+        nIterations   =   len(desired)
+
+        # Pre Allocations
+        errorVector  = np.zeros(nIterations, dtype='complex')
+        outputVector = np.zeros(nIterations, dtype='complex')
+        
+        # Initial State
+        coefficientVectorDFT =   np.fft.rfft(S["initialCoefficients"])/np.sqrt(float(nCoefficients))
+        desiredDFT           =   np.fft.rfft(desired)
+        powerVector          =   S["initialPower"]*np.ones(nCoefficients)
+
+        # Improve source code regularity, pad with zeros
+        # TODO, confirm zeros(nCoeffics) not nCoeffics-1
+        prefixedInput  =   np.concatenate([np.zeros(nCoefficients-1), np.array(input)])
+
+        # Body
+        pylab.ion()
+        pylab.figure(11)
+        for it in range(nIterations): # = 1:nIterations,
+            
+            regressorDFT = np.fft.rfft(prefixedInput[it:it+nCoefficients][::-1]) /\
+                           np.sqrt(float(nCoefficients))
+
+            # Summing two column vectors
+            powerVector = S["alpha"] * (regressorDFT*np.conjugate(regressorDFT)) + \
+                                  (1.-S["alpha"])*(powerVector)
+
+            pylab.cla()
+            #pylab.plot(prefixedInput[::-1], 'b')
+            #pylab.plot(prefixedInput[it:it+nCoefficients][::-1], 'g', linewidth=3)
+            #pylab.plot(regressorDFT.real)
+            #pylab.plot(regressorDFT.imag)
+            pylab.plot(powerVector.real)
+            pylab.plot(powerVector.imag)
+            #pylab.plot(outputVector)
+            #pylab.plot(errorVector.real)
+            #pylab.plot(errorVector.imag)
+            pylab.draw()
+            #raw_input("wait")
+
+            outputVector[it] = np.dot(coefficientVectorDFT.T, regressorDFT)
+
+            #errorVector[it] = desired[it] - outputVector[it]
+            errorVector[it] = desiredDFT[it] - outputVector[it]
+
+            #print errorVector[it], desired[it], outputVector[it]
+
+            # Vectorized
+            coefficientVectorDFT += (S["step"]*np.conjugate(errorVector[it])*regressorDFT) /\
+                                    (S['gamma']+powerVector)
+
+        return np.real(np.fft.irfft(errorVector))
+        #coefficientVector = ifft(coefficientVectorDFT)*sqrt(nCoefficients);
+
+    def Tdomain_DCT(self, desired, input, S):
+        """ Lifted from Adaptive filtering toolbox. Modefied to accept more than one input 
+            vector. Uses cosine transform
+        """
+        from scipy.fftpack import dct
+ 
+        # Initialisation Procedure
+        nCoefficients =   S["filterOrderNo"]+1
+        nIterations   =   len(desired)
+
+        # Pre Allocations
+        errorVector  = np.zeros(nIterations)
+        outputVector = np.zeros(nIterations)
+        
+        # Initial State
+        coefficientVectorDCT =   dct(S["initialCoefficients"]) #/np.sqrt(float(nCoefficients))
+        desiredDCT           =   dct(desired)
+        powerVector          =   S["initialPower"]*np.ones(nCoefficients)
+
+        # Improve source code regularity, pad with zeros
+        prefixedInput  =   np.concatenate([np.zeros(nCoefficients-1), np.array(input)])
+        
+        # Body
+        #pylab.figure(11)
+        #pylab.ion()
+        for it in range(0, nIterations): # = 1:nIterations,
+            
+            regressorDCT = dct(prefixedInput[it:it+nCoefficients][::-1], type=2) 
+            #regressorDCT = dct(prefixedInput[it+nCoefficients:it+nCoefficients*2+1])#[::-1]) 
+
+            # Summing two column vectors
+            powerVector = S["alpha"]*(regressorDCT) + (1.-S["alpha"])*(powerVector)
+            #pylab.cla()
+            #pylab.plot(powerVector)
+            #pylab.draw()
+
+            outputVector[it] = np.dot(coefficientVectorDCT.T, regressorDCT)
+            #errorVector[it] = desired[it] - outputVector[it]
+            errorVector[it] = desiredDCT[it] - outputVector[it]
+
+            # Vectorized
+            coefficientVectorDCT += (S["step"]*errorVector[it]*regressorDCT) #/\
+                                    #(S['gamma']+powerVector)
+
+        #pylab.plot(errorVector)
+        #pylab.show()
+        return dct(errorVector, type=3)
+        #coefficientVector = ifft(coefficientVectorDCT)*sqrt(nCoefficients);
+
+
+
+    def Tdomain_CORR(self, desired, input, S):
+
+        from scipy.linalg import toeplitz
+        from scipy.signal import correlate
+
+        # Autocorrelation
+        ac = np.correlate(input, input, mode='full')
+        ac = ac[ac.size/2:]
+        R = toeplitz(ac)
+        
+        # cross correllation
+        r = np.correlate(desired, input, mode='full')
+        r = r[r.size/2:]
+        
+        #r = np.correlate(desired, input, mode='valid')
+        print ("R", np.shape(R))
+        print ("r", np.shape(r))
+        print ("solving")
+        #H = np.linalg.solve(R,r)
+        H = np.linalg.lstsq(R,r,rcond=.01)[0]
+        #return desired - np.dot(H,input)
+        print ("done solving")
+        pylab.figure()
+        pylab.plot(H)
+        pylab.title("H")
+        #return desired - np.convolve(H, input, mode='valid')
+        #return desired - np.convolve(H, input, mode='same')
+        #return np.convolve(H, input, mode='same')
+        return desired - np.dot(toeplitz(H), input)
+        #return np.dot(R, H)
+
+#         T = toeplitz(input)
+#         print "shapes", np.shape(T), np.shape(desired)
+#         h = np.linalg.lstsq(T, desired)[0]
+#         print "shapes", np.shape(h), np.shape(input)
+#         #return np.convolve(h, input, mode='same')
+#         return desired - np.dot(T,h)
+ 
+    def Fdomain_CORR(self, desired, input, dt, freq):
+        
+        from scipy.linalg import toeplitz
+        
+        # Fourier domain
+        Input = np.fft.rfft(input)
+        Desired = np.fft.rfft(desired)
+
+        T = toeplitz(Input)
+        #H = np.linalg.solve(T, Desired)
+        H = np.linalg.lstsq(T, Desired)[0]
+#         ac = np.correlate(Input, Input, mode='full')
+#         ac = ac[ac.size/2:]
+#         R = toeplitz(ac)
+#         
+#         r = np.correlate(Desired, Input, mode='full')
+#         r = r[r.size/2:]
+#         
+#         #r = np.correlate(desired, input, mode='valid')
+#         print "R", np.shape(R)
+#         print "r", np.shape(r)
+#         print "solving"
+#         H = np.linalg.solve(R,r)
+#         #H = np.linalg.lstsq(R,r)
+#         #return desired - np.dot(H,input)
+#         print "done solving"
+        pylab.figure()
+        pylab.plot(H.real)
+        pylab.plot(H.imag)
+        pylab.plot(Input.real)
+        pylab.plot(Input.imag)
+        pylab.plot(Desired.real)
+        pylab.plot(Desired.imag)
+        pylab.legend(["hr","hi","ir","ii","dr","di"])
+        pylab.title("H")
+        #return desired - np.fft.irfft(Input*H)
+        return np.fft.irfft(H*Input)
+
+    def Tdomain_RLS(self, desired, input, S):
+        """
+            A DFT is first performed on the data. Than a RLS algorithm is carried out 
+            for noise cancellation. Related to the RLS_Alt Algoritm 5.3 in  Diniz book.
+            The desired and input signals are assummed to be real time series data.
+        """
+
+        # Transform data into frequency domain
+        Input = np.fft.rfft(input)
+        Desired = np.fft.rfft(desired)
+
+        # Initialisation Procedure
+        nCoefficients = S["filterOrderNo"]+1
+        nIterations   = len(Desired)
+
+        # Pre Allocations
+        errorVector  = np.zeros(nIterations, dtype="complex")
+        outputVector = np.zeros(nIterations, dtype="complex")
+        errorVectorPost  = np.zeros(nIterations, dtype="complex")
+        outputVectorPost = np.zeros(nIterations, dtype="complex")
+        coefficientVector = np.zeros( (nCoefficients, nIterations+1), dtype="complex" )        
+
+        # Initial State
+        coefficientVector[:,1] = S["initialCoefficients"]  
+        S_d                    = S["delta"]*np.eye(nCoefficients)
+
+        # Improve source code regularity, pad with zeros
+        prefixedInput = np.concatenate([np.zeros(nCoefficients-1, dtype="complex"), 
+                                np.array(Input)])
+        invLambda = 1./S["lambda"]
+        
+        # Body
+        pylab.ion()
+        pylab.figure(11)
+
+        for it in range(nIterations):
+            
+            regressor = prefixedInput[it:it+nCoefficients][::-1]
+
+            # a priori estimated output
+            outputVector[it] = np.dot(coefficientVector[:,it].T, regressor)
+       
+            # a priori error
+            errorVector[it] = Desired[it] - outputVector[it]
+
+            psi             = np.dot(S_d, regressor)
+            if np.isnan(psi).any():
+                print ("psi", psi)
+                exit(1)
+            
+            pylab.cla()
+            #pylab.plot(psi)
+            pylab.plot(regressor.real)
+            pylab.plot(regressor.imag)
+            pylab.plot(coefficientVector[:,it].real)
+            pylab.plot(coefficientVector[:,it].imag)
+            pylab.legend(["rr","ri", "cr", "ci"])
+            pylab.draw()
+            raw_input("paws")
+
+            S_d             = invLambda * (S_d - np.dot(psi, psi.T)  /\
+                                S["lambda"] + np.dot(psi.T, regressor))
+
+            coefficientVector[:,it+1] = coefficientVector[:,it] + \
+                                        np.conjugate(errorVector[it])*np.dot(S_d, regressor)
+            # A posteriori estimated output
+            outputVectorPost[it]  =  np.dot(coefficientVector[:,it+1].T, regressor)
+
+            # A posteriori error
+            errorVectorPost[it] = Desired[it] - outputVectorPost[it]
+ 
+        errorVectorPost = np.nan_to_num(errorVectorPost)
+
+        pylab.figure(11)
+        print (np.shape(errorVectorPost))
+        pylab.plot(errorVectorPost.real)
+        pylab.plot(errorVectorPost.imag)
+        pylab.show()
+        print(errorVectorPost)
+        #return np.fft.irfft(Desired)
+        return np.fft.irfft(errorVectorPost)
+
+if __name__ == "__main__":
+
+    def noise(nu, t, phi):
+        return np.sin(nu*2.*np.pi*t + phi)
+
+    import matplotlib.pyplot as plt
+    print("Test driver for adaptive filtering")
+    Filt = AdaptiveFilter(.1)
+    t = np.arange(0, .5, 1e-4)
+    omega = 2000 * 2.*np.pi
+    T2 = .100
+    n1 = noise(60, t, .2   )
+    n2 = noise(61, t, .514 )
+    x = np.sin(omega*t)* np.exp(-t/T2) + 2.3*noise(60, t, .34) + 1.783*noise(31, t, 2.1)
+    e = Filt.adapt_filt_tworef(x, n1, n2, 200, .98)
+    plt.plot(t,  x)
+    plt.plot(t, n1)
+    plt.plot(t, n2)
+    plt.plot(t,  e)
+    plt.show()

akvo/tressel/cpca.pyx

+##########################################################
+#
+#
+#
+#
+#
+#from scipy import mean
+import numpy
+
+def pca(A, remove=[]):
+    ''' The input matrix A should be a 2D numpy array in column-major 
+        order. Each column is a dataset and PCA will be applied across
+        columns
+    '''
+    #nrow = len(A[:,0])
+    #ncol = len(A[0,:])
+    nrow,ncol = numpy.shape(A)
+
+    # Cast into matrix type for easier math
+    A = numpy.matrix(A)
+
+    # Allocate Covariance Matrix
+    covMatrix = numpy.matrix(numpy.zeros((nrow, nrow)))
+    
+    # Compute Means of each row. Each column must be normalised
+    meanArray = []
+    for i in range(nrow):
+        meanArray.append(numpy.mean(A[i].tolist()[0]) ) 
+        A[i] -= meanArray[i]
+    meanArray = numpy.array(meanArray) 
+    
+    # Generate Covariance Matrix
+    covMatrix = numpy.cov(A)
+
+    # Compute Eigen Values, Eigen Vectors     
+    eigs = numpy.linalg.eig(covMatrix)
+    K = eigs[1].T
+    
+    #print K
+    #print "Eigen Values"
+    #print eigs[0]
+    
+    # Zero requested components
+    for i in remove:
+        K[i] = numpy.zeros(len(K))        
+
+    # Make Transform Matrices
+    transMatrix = K*A
+    
+    # Return Necssary Stuff
+    return numpy.array(transMatrix), K, meanArray
+    #return K, A, meanArray 
+
+#def invpca(K, A, means):
+def invpca(transMatrix, K, means):
+    '''Converts a PCA rotated dataset back to normal. Input parameters
+    are the components to discard in re-creation.
+    '''
+    K = numpy.matrix(K)
+    # Transform and Untransform the data
+    #transMatrix = K*A
+    untransMatrix = K.T*transMatrix
+    
+    # Correct for normalisation
+    for i in range(len(transMatrix)):
+        untransMatrix[i] += means[i]
+
+    return untransMatrix    

akvo/tressel/decay.py

+import numpy, pylab,array #,rpy2
+
+from rpy2.robjects.packages import importr
+
+import rpy2.robjects as robjects
+import rpy2.robjects.numpy2ri
+
+#import notch
+from numpy.fft import fft, fftfreq
+
+# We know/can calculate frequency peak, use this to guess where picks will be.
+# maybe have a sliding window that reports peak values.
+def peakPicker(data, omega, dt):
+
+    # compute window based on omega and dt
+    # make sure you are not aliased, grab every other peak
+    window = (2*numpy.pi) / (omega*dt)
+
+    data = numpy.array(data) 
+    peaks = []
+    troughs = []
+    times = []
+    times2 = []
+    indices = []
+    ws = 0
+    we = window
+    ii = 0
+    for i in range((int)(len(data)/window)):
+        
+        # initially was just returning this I think avg is better
+        #times.append( (ws + numpy.abs(data[ws:we]).argmax()) * dt )
+    
+        peaks.append(numpy.max(data[ws:we]))
+        times.append( (ws + data[ws:we].argmax()) * dt )
+        indices.append( ii + data[ws:we].argmax() )        
+
+        troughs.append(numpy.min(data[ws:we]))
+        times2.append( (ws + (data[ws:we]).argmin()) * dt )
+        indices.append( ii + data[ws:we].argmin() )        
+
+        ws += window
+        we += window
+        ii += (int)(we-ws)
+    
+    #return numpy.array(peaks), numpy.array(times)
+    
+    # Averaging peaks does a good job of removing bias in noise
+    return (numpy.array(peaks)-numpy.array(troughs))/2., \
+        (numpy.array(times)+numpy.array(times2))/2., \
+        indices           
+
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressCurve(peaks,times,sigma2=None  ,intercept=True):
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    b1  = 0                  # Bias
+    b2  = 0                  # Linear 
+    rT2 = 0.3                # T2 regressed
+    r   = robjects.r         
+
+    # Variable shared between R and Python
+    robjects.globalenv['b1'] = b1
+    robjects.globalenv['b2'] = b2
+    robjects.globalenv['rT2'] = rT2
+    #robjects.globalenv['sigma2'] = sigma2
+    value = robjects.FloatVector(peaks)
+    times = robjects.FloatVector(numpy.array(times))
+    
+#    my_weights = robjects.RVector(value/sigma2)
+#    robjects.globalenv['my_weigts'] = my_weights
+
+    if sigma2 != None:
+        # print ("weighting")
+        #tw = numpy.array(peaks)/sigma2 
+        my_weights = robjects.FloatVector( sigma2 )
+    #else:
+    #    my_weights = robjects.FloatVector(numpy.ones(len(peaks))) 
+
+        robjects.globalenv['my_weights'] = my_weights
+        #print (my_weights)
+        #print (len(peaks))
+    
+    if (intercept):
+        my_list = robjects.r('list(b1=50, b2=1e2, rT2=0.03)')
+        my_lower = robjects.r('list(b1=0, b2=0, rT2=.005)')
+        my_upper = robjects.r('list(b1=20000, b2=2000, rT2=.700)')
+    else:
+        my_list = robjects.r('list(b2=1e2, rT2=0.3)')
+        my_lower = robjects.r('list(b2=0, rT2=.005)')
+        my_upper = robjects.r('list(b2=2000, rT2=.700)')
+
+    my_cont = robjects.r('nls.control(maxiter=1000, warnOnly=TRUE, printEval=FALSE)')
+
+    
+    if (intercept):
+        #fmla = robjects.RFormula('value ~ b1 + exp(-times/rT2)')
+        fmla = robjects.Formula('value ~ b1 + b2*exp(-times/rT2)')
+        #fmla = robjects.RFormula('value ~ b1 + b2*times + exp(-times/rT2)')
+    else:
+        fmla = robjects.Formula('value ~ b2*exp(-times/rT2)')
+
+    env = fmla.getenvironment()
+    env['value'] = value
+    env['times'] = times
+    
+    # ugly, but I get errors with everything else I've tried
+    #my_weights = robjects.r('rep(1,length(value))')
+    #for ii in range(len(my_weights)):
+    #    my_weights[ii] *= peaks[ii]/sigma2
+
+
+    Error = False
+    #fit = robjects.r.nls(fmla,start=my_list,control=my_cont,weights=my_weights)
+    if (sigma2 != None):
+        #print("SIGMA 2")
+        #fit = robjects.r.tryCatch(robjects.r.suppressWarnings(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm="port", \
+        #                     weights=my_weights)), 'silent=TRUE')
+        try:
+            fit = robjects.r.tryCatch(    robjects.r.nls(fmla, start=my_list, control=my_cont, weights=my_weights, algorithm="port" , \
+                lower=my_lower,upper=my_upper))
+        except:
+            print("regression issue pass")
+            Error = True
+                            # weights=my_weights))
+    else:
+        try:
+            fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list,control=my_cont,algorithm="port",lower=my_lower,upper=my_upper))
+        except:
+            print("regression issue pass")
+            Error = True
+    # If failure fall back on zero regression values   
+    if not Error:
+        #Error = fit[3][0]
+        report =  r.summary(fit)
+    b1 = 0
+    b2 = 0 
+    rT2 = 1
+    if (intercept):
+        if not Error:
+            b1  =  r['$'](report,'par')[0]
+            b2  =  r['$'](report,'par')[1]
+            rT2 =  r['$'](report,'par')[2]
+            #print  report
+            #print  r['$'](report,'convergence')
+            #print  r['convergence'] #(report,'convergence')
+            #print  r['$'](report,'par')[13]
+            #print  r['$'](report,'par')[14]
+        else:
+            print("ERROR DETECTED, regressed values set to default")
+            b1 = 1e1
+            b2 = 1e-2
+            rT2 = 1e-2
+            #print r['$'](report,'par')[0]
+            #print r['$'](report,'par')[1]
+            #print r['$'](report,'par')[2]
+        return [b1,b2,rT2] 
+    else:
+        if not Error:
+            rT2 =  r['$'](report,'par')[1]
+            b2  =  r['$'](report,'par')[0]
+        else:
+            print("ERROR DETECTED, regressed values set to default")
+        return [b2, rT2] 
+
+def quadratureDetect(X, Y, tt):
+    
+    r   = robjects.r         
+
+    robjects.r(''' 
+         Xc <- function(E0, df, tt, phi, T2) {
+	            E0 * -sin(2*pi*df*tt + phi) * exp(-tt/T2)
+                }
+
+         Yc <- function(E0, df, tt, phi, T2) {
+	            E0 * cos(2*pi*df*tt + phi) * exp(-tt/T2)
+                } 
+         ''')  
+
+    # Make 0 vector 
+    Zero = robjects.FloatVector(numpy.zeros(len(X)))
+    
+    # Fitted Parameters
+    E0 = 0.
+    df = 0.
+    phi = 0.
+    T2 = 0.
+    robjects.globalenv['E0'] = E0
+    robjects.globalenv['df'] = df
+    robjects.globalenv['phi'] = phi
+    robjects.globalenv['T2'] = T2
+    XY = robjects.FloatVector(numpy.concatenate((X,Y)))
+    
+    # Arrays
+    tt = robjects.FloatVector(numpy.array(tt))
+    X = robjects.FloatVector(numpy.array(X))
+    Y = robjects.FloatVector(numpy.array(Y))
+    Zero = robjects.FloatVector(numpy.array(Zero))
+
+    #fmla = robjects.Formula('Zero ~ QI( E0, df, tt, phi, T2, X, Y )')
+    #fmla = robjects.Formula('X ~ Xc( E0, df, tt, phi, T2 )')
+    #fmla = robjects.Formula('Y ~ Yc( E0, df, tt, phi, T2 )')
+    fmla = robjects.Formula('XY ~ c(Xc( E0, df, tt, phi, T2 ), Yc( E0, df, tt, phi, T2 ))')
+
+    env = fmla.getenvironment()
+    env['Zero'] = Zero
+    env['X'] = X
+    env['Y'] = Y
+    env['XY'] = XY 
+    env['tt'] = tt
+    
+    # Bounds and control    
+    start = robjects.r('list(E0=100,   df= 0   , phi=   0.00,  T2=.100)')
+    lower = robjects.r('list(E0=1,     df=-13.0, phi=  -3.14,  T2=.005)')
+    upper = robjects.r('list(E0=1000,  df= 13.0, phi=   3.14,  T2=.800)')
+
+    cont = robjects.r('nls.control(maxiter=10000, warnOnly=TRUE, printEval=FALSE)')
+    
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=start, control=cont, lower=lower, upper=upper, algorithm='port')) #, \
+    report =  r.summary(fit)
+    #print (report)
+    
+    E0  =  r['$'](report,'par')[0]
+    df  =  r['$'](report,'par')[1]
+    phi =  r['$'](report,'par')[2]
+    T2  =  r['$'](report,'par')[3]
+    #print ( E0,df,phi,T2 )
+    return E0,df,phi,T2
+    
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressSpec(w, wL, X): #,sigma2=1,intercept=True):
+
+    # compute s
+    s = -1j*w
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    a   = 0                  # Linear 
+    rT2 = 0.1                # T2 regressed
+    r   = robjects.r         
+
+    # Variable shared between R and Python
+    robjects.globalenv['a'] = a
+    #robjects.globalenv['w'] = w
+    robjects.globalenv['rT2'] = rT2
+    robjects.globalenv['wL'] = wL
+    robjects.globalenv['nb'] = 0
+
+    #s = robjects.ComplexVector(numpy.array(s))
+    w = robjects.FloatVector(numpy.array(w))
+    XX = robjects.FloatVector(X)
+    #Xr = robjects.FloatVector(numpy.real(X))
+    #Xi = robjects.FloatVector(numpy.imag(X))
+    #Xa = robjects.FloatVector(numpy.abs(X))
+    #Xri = robjects.FloatVector(numpy.concatenate((Xr,Xi)))
+    
+    #my_lower = robjects.r('list(a=.001, rT2=.001, nb=.0001)')
+    my_lower = robjects.r('list(a=.001, rT2=.001)')
+    #my_upper = robjects.r('list(a=1.5, rT2=.300, nb =100.)')
+    my_upper = robjects.r('list(a=1.5, rT2=.300)')
+     
+    #my_list = robjects.r('list(a=.2, rT2=0.03, nb=.1)')
+    my_list = robjects.r('list(a=.2, rT2=0.03)')
+    my_cont = robjects.r('nls.control(maxiter=5000, warnOnly=TRUE, printEval=FALSE)')
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    ##fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('XX ~ a*(wL) / (wL^2 + (s+1/rT2)^2 )') # complex
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 )) + nb') # complex
+    #fmla = robjects.Formula('XX ~ Re(a*( s + 1./rT2 )  / (wL^2 + (s+1/rT2)^2 ))') # complex
+    fmla = robjects.Formula('XX ~ a*(.5/rT2)  / ((1./rT2)^2 + (w-wL)^2 )')
+    #fmla = robjects.Formula('Xa ~ (s + 1./T2) / ( wL**2 + (1/T2 + 1j*w)**2 ) ')
+ 
+    env = fmla.getenvironment()
+    #env['s'] = s
+    env['w'] = w
+    #env['Xr'] = Xr
+    #env['Xa'] = Xa
+    #env['Xi'] = Xi
+    #env['Xri'] = Xri
+    env['XX'] = XX
+     
+    #fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list, control=my_cont)) #, lower=my_lower, algorithm='port')) #, \
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    report =  r.summary(fit)
+    #print report 
+    #print(r.warnings())
+ 
+    a  =  r['$'](report,'par')[0]
+    rT2 =  r['$'](report,'par')[1]
+    nb =  r['$'](report,'par')[2]
+    
+    return a, rT2, nb
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressModulus(w, wL, X): #,sigma2=1,intercept=True):
+
+    # compute s
+    s = -1j*w
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    a   = 0                  # Linear 
+    rT2 = 0.1                # T2 regressed
+    r   = robjects.r         
+
+    # Variable shared between R and Python
+    robjects.globalenv['a'] = a
+    robjects.globalenv['rT2'] = rT2
+    robjects.globalenv['wL'] = wL
+    robjects.globalenv['nb'] = 0
+
+    s = robjects.ComplexVector(numpy.array(s))
+    XX = robjects.ComplexVector(X)
+    Xr = robjects.FloatVector(numpy.real(X))
+    Xi = robjects.FloatVector(numpy.imag(X))
+    Xa = robjects.FloatVector(numpy.abs(X))
+    Xri = robjects.FloatVector(numpy.concatenate((Xr,Xi)))
+    
+    #my_lower = robjects.r('list(a=.001, rT2=.001, nb=.0001)')
+    my_lower = robjects.r('list(a=.001, rT2=.001)')
+    #my_upper = robjects.r('list(a=1.5, rT2=.300, nb =100.)')
+    my_upper = robjects.r('list(a=1.5, rT2=.300)')
+     
+    #my_list = robjects.r('list(a=.2, rT2=0.03, nb=.1)')
+    my_list = robjects.r('list(a=.2, rT2=0.03)')
+    my_cont = robjects.r('nls.control(maxiter=5000, warnOnly=TRUE, printEval=FALSE)')
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    ##fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('XX ~ a*(wL) / (wL^2 + (s+1/rT2)^2 )') # complex
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 )) + nb') # complex
+    fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 ))') # complex
+ 
+    env = fmla.getenvironment()
+    env['s'] = s
+    env['Xr'] = Xr
+    env['Xa'] = Xa
+    env['Xi'] = Xi
+    env['Xri'] = Xri
+    env['XX'] = XX
+     
+    #fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list, control=my_cont)) #, lower=my_lower, algorithm='port')) #, \
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    report =  r.summary(fit)
+    #print report 
+    #print  r.warnings()
+ 
+    a  =  r['$'](report,'par')[0]
+    rT2 =  r['$'](report,'par')[1]
+    nb =  r['$'](report,'par')[2]
+    
+    return a, rT2
+
+#################################################
+# Regress for T2 using rpy2 interface
+def regressSpecComplex(w, wL, X, known=True, win=None): #,sigma2=1,intercept=True):
+
+    # compute s
+    s = -1j*w
+
+    # TODO, if regression fails, it might be because there is no exponential
+    # term, maybe do a second regression then on a linear model. 
+    a   = 1                  # Linear 
+    rT2 = 0.1                # T2 regressed
+    r   = robjects.r         
+    phi2 = 0                 # phase
+    wL2 = wL
+
+    # Variable shared between R and Python
+    robjects.globalenv['a'] = a
+    robjects.globalenv['rT2'] = rT2
+    robjects.globalenv['wL'] = wL
+    robjects.globalenv['wL2'] = 0
+    robjects.globalenv['nb'] = 0
+    robjects.globalenv['phi2'] = phi2
+
+    s = robjects.ComplexVector(numpy.array(s))
+    XX = robjects.ComplexVector(X)
+    Xr = robjects.FloatVector(numpy.real(X))
+    Xi = robjects.FloatVector(numpy.imag(X))
+    Xa = robjects.FloatVector(numpy.abs(X))
+    Xri = robjects.FloatVector(numpy.concatenate((X.real,X.imag)))
+
+    robjects.r(''' 
+        source('kernel.r')
+    ''')   
+    #Kw = robjects.globalenv['Kwri']
+     
+    #print (numpy.shape(X))
+    
+    #######################################################################
+
+    if known:
+        # known Frequency
+        my_lower = robjects.r('list(a=.001, rT2=.001, phi2=-3.14)')
+        my_upper = robjects.r('list(a=3.5, rT2=.300, phi2=3.14)')
+        my_list = robjects.r('list(a=.2, rT2=0.03, phi2=0)')
+    else:
+        # Unknown Frequency
+        my_lower = robjects.r('list(a=.001, rT2=.001, phi2=-3.14, wL2=wL-5)')
+        my_upper = robjects.r('list(a=3.5, rT2=.300, phi2=3.14, wL2=wL+5)')
+        my_list = robjects.r('list(a=.2, rT2=0.03, phi2=0, wL2=wL)')
+    
+    my_cont = robjects.r('nls.control(maxiter=5000, warnOnly=TRUE, printEval=FALSE)')
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('Xi   ~   Im(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 ))') # envelope
+    #fmla = robjects.Formula('Xri ~ c(Re(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 )), Im(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 )))') # envelope
+    
+    #fmlar = robjects.Formula('Xr ~ (Kwr(a, phi2, s, rT2, wL)) ') # envelope
+    #fmlai = robjects.Formula('Xi ~ (Kwi(a, phi2, s, rT2, wL)) ') # envelope
+    
+
+    
+    if known:
+        ###########################################3
+        # KNOWN freq 
+        fmla = robjects.Formula('Xri ~ c(Kwr(a, phi2, s, rT2, wL), Kwi(a, phi2, s, rT2, wL) ) ') # envelope
+    else:
+        ####################################################################################################3
+        # unknown frequency
+        fmla = robjects.Formula('Xri ~ c(Kwr(a, phi2, s, rT2, wL2), Kwi(a, phi2, s, rT2, wL2) ) ') # envelope
+
+    #fmla = robjects.Formula('Xri ~ (Kwri(a, phi2, s, rT2, wL)) ') # envelope
+    
+    #fmla = robjects.Formula('Xa ~ (abs(a*(sin(phi2)*s + ((1/rT2)*sin(phi2)) + wL*cos(phi2)) / (wL^2+(s+1/rT2)^2 )))') # envelope
+    #fmla = robjects.Formula('XX ~ a*(wL) / (wL^2 + (s+1/rT2)^2 )') # complex
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 )) + nb') # complex
+    
+    #fmla = robjects.Formula('Xri ~ c(a*Re((wL) / (wL^2+(s+1/rT2)^2 )), a*Im((wL)/(wL^2 + (s+1/rT2)^2 )))') # envelope
+    
+    #        self.Gw[iw, iT2] = ((np.sin(phi2) *  (alpha + 1j*self.w[iw]) + self.wL*np.cos(phi2)) / \
+    #                               (self.wL**2 + (alpha+1.j*self.w[iw])**2 ))
+    #        self.Gw[iw, iT2] = ds * self.sc*((np.sin(phi2)*( alpha + 1j*self.w[iw]) + self.wL*np.cos(phi2)) / \
+    #                               (self.wL**2 + (alpha+1.j*self.w[iw])**2 ))
+    
+    # Works Amplitude Only!
+    #fmla = robjects.Formula('Xa ~ abs(a*(wL) / (wL^2 + (s+1/rT2)^2 ))') # complex
+ 
+    env = fmla.getenvironment()
+    env['s'] = s
+    env['Xr'] = Xr
+    env['Xa'] = Xa
+    env['Xi'] = Xi
+    env['Xri'] = Xri
+    env['XX'] = XX
+     
+    #fit = robjects.r.tryCatch(robjects.r.nls(fmla,start=my_list, control=my_cont)) #, lower=my_lower, algorithm='port')) #, \
+    #fit = robjects.r.tryCatch(robjects.r.nls(fmlar, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    fit = robjects.r.tryCatch(robjects.r.nls(fmla, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    
+    #env = fmlai.getenvironment()
+    #fiti = robjects.r.tryCatch(robjects.r.nls(fmlai, start=my_list, control=my_cont, lower=my_lower, upper=my_upper, algorithm='port')) #, \
+    
+    #reportr =  r.summary(fitr)
+    #reporti =  r.summary(fiti)
+    report =  r.summary(fit)
+    #print( report )
+    #exit()
+    #print( reportr )
+    #print( reporti  )
+    #exit()
+    #print ( r.warnings())
+ 
+    #a   =  (r['$'](reportr,'par')[0] + r['$'](reporti,'par')[0]) / 2.
+    #rT2 =  (r['$'](reportr,'par')[1] + r['$'](reporti,'par')[1]) / 2.
+    #nb  =  (r['$'](reportr,'par')[2] + r['$'](reporti,'par')[2]) / 2.
+    a   =  r['$'](report,'par')[0] 
+    rT2 =  r['$'](report,'par')[1] 
+    nb  =  r['$'](report,'par')[2] #phi2 
+
+    #print ("Python wL2", r['$'](report,'par')[3] )   
+    #print ("Python zeta", r['$'](report,'par')[2] )   
+ 
+    return a, rT2, nb
+
+
+
+###################################################################
+###################################################################
+###################################################################
+if __name__ == "__main__":
+
+    dt    = .0001
+    T2    = .1
+    omega = 2000.*2*numpy.pi
+    phi   = .0
+    T     = 8.*T2
+    
+    t = numpy.arange(0, T, dt)
+
+    # Synthetic data, simple single decaying sinusoid 
+    # with a single decay parameter and gaussian noise added 
+    data = numpy.exp(-t/T2) * numpy.sin(omega * t + phi) + numpy.random.normal(0,.05,len(t)) \
+                         + numpy.random.randint(-1,2,len(t))*numpy.random.exponential(.2,len(t)) 
+    cdata = numpy.exp(-t/T2) * numpy.sin(omega * t + phi) #+ numpy.random.normal(0,.25,len(t))
+    #data = numpy.random.normal(0,.25,len(t))
+
+    sigma2 = numpy.std(data[::-len(data)/4])
+    #sigma2 = numpy.var(data[::-len(data)/4])
+    print("sigma2", sigma2)    
+    
+    [peaks,times,indices] = peakPicker(data, omega, dt)
+    
+    [b1,b2,rT2] = regressCurve(peaks,times)
+    print("rT2 nonweighted", rT2)
+    
+    [b1,b2,rT2] = regressCurve(peaks,times,sigma2)
+    print("rT2 weighted", rT2)
+
+    envelope   =  numpy.exp(-t/T2)
+    renvelope  =  numpy.exp(-t/rT2)
+
+    outf = file('regress.txt','w')
+    for i in range(len(times)):
+        outf.write(str(times[i]) + "   " +  str(peaks[i]) + "\n")  
+    outf.close()
+
+    pylab.plot(t,data, 'b')
+    pylab.plot(t,cdata, 'g', linewidth=1)
+    pylab.plot(t,envelope, color='violet', linewidth=4)
+    pylab.plot(t,renvelope, 'r', linewidth=4)
+    pylab.plot(times, numpy.array(peaks), 'bo', markersize=8, alpha=.25)
+    pylab.legend(['noisy data','clean data','real envelope','regressed env','picks'])
+    pylab.savefig("regression.pdf")
+
+
+    # FFT check
+    fourier = fft(data)
+    pylab.figure()
+    freq = fftfreq(len(data), d=dt)
+    pylab.plot(freq, (fourier.real))
+    
+    pylab.show()
+
+    # TODO do a bunch in batch mode to see if T2 estimate is better with or without 
+    # weighting and which model is best.
+
+    # TODO try with real data
+
+    # TODO test filters (median, FFT, notch)
+
+    # It looks like weighting is good for relatively low sigma, but for noisy data
+    # it hurts us. Check

akvo/tressel/filtfilt.py

+from numpy import vstack, hstack, eye, ones, zeros, linalg, \
+newaxis, r_, flipud, convolve, matrix, array
+from scipy.signal import lfilter
+
+def lfilter_zi(b,a):
+    #compute the zi state from the filter parameters. see [Gust96].
+
+    #Based on:
+    # [Gust96] Fredrik Gustafsson, Determining the initial states in forward-backward 
+    # filtering, IEEE Transactions on Signal Processing, pp. 988--992, April 1996, 
+    # Volume 44, Issue 4
+
+    n=max(len(a),len(b))
+
+    zin = (  eye(n-1) - hstack( (-a[1:n,newaxis],
+                                 vstack((eye(n-2), zeros(n-2))))))
+
+    zid=  b[1:n] - a[1:n]*b[0]
+
+    zi_matrix=linalg.inv(zin)*(matrix(zid).transpose())
+    zi_return=[]
+
+    #convert the result into a regular array (not a matrix)
+    for i in range(len(zi_matrix)):
+      zi_return.append(float(zi_matrix[i][0]))
+
+    return array(zi_return)
+
+
+
+
+def filtfilt(b,a,x):
+    #For now only accepting 1d arrays
+    ntaps=max(len(a),len(b))
+    edge=ntaps*3
+
+    if x.ndim != 1:
+        raise ValueError, "Filiflit is only accepting 1 dimension arrays."
+
+    #x must be bigger than edge
+    if x.size < edge:
+        raise ValueError, "Input vector needs to be bigger than 3 * max(len(a),len(b)."
+
+    if len(a) < ntaps:
+        a=r_[a,zeros(len(b)-len(a))]
+
+    if len(b) < ntaps:
+        b=r_[b,zeros(len(a)-len(b))]
+
+    zi=lfilter_zi(b,a)
+
+    #Grow the signal to have edges for stabilizing 
+    #the filter with inverted replicas of the signal
+    s=r_[2*x[0]-x[edge:1:-1],x,2*x[-1]-x[-1:-edge:-1]]
+    #in the case of one go we only need one of the extrems 
+    # both are needed for filtfilt
+
+    (y,zf)=lfilter(b,a,s,-1,zi*s[0])
+
+    (y,zf)=lfilter(b,a,flipud(y),-1,zi*y[-1])
+
+    return flipud(y[edge-1:-edge+1])
+
+
+if __name__=='__main__':
+
+    from scipy.signal import butter
+    from scipy import sin, arange, pi, randn
+
+    from pylab import plot, legend, show, hold
+
+    t=arange(-1,1,.01)
+    x=sin(2*pi*t*.5+2)
+    #xn=x + sin(2*pi*t*10)*.1
+    xn=x+randn(len(t))*0.05
+
+    [b,a]=butter(3,0.05)
+
+    z=lfilter(b,a,xn)
+    y=filtfilt(b,a,xn)
+
+    plot(x,'c')
+    hold(True)
+    plot(xn,'k')
+    plot(z,'r')
+    plot(y,'g')
+
+    legend(('original','noisy signal','lfilter - butter 3 order','filtfilt - butter 3 order'))
+    hold(False)
+    show()
+

akvo/tressel/pca.py

+##########################################################
+#
+#
+#
+#
+#
+#from scipy import mean
+import numpy
+
+def pca(A, remove=[]):
+    ''' The input matrix A should be a 2D numpy array in column-major 
+        order. Each column is a dataset and PCA will be applied across
+        columns
+    '''
+    #nrow = len(A[:,0])
+    #ncol = len(A[0,:])
+    nrow,ncol = numpy.shape(A)
+
+    # Cast into matrix type for easier math
+    A = numpy.matrix(A)
+
+    # Allocate Covariance Matrix
+    covMatrix = numpy.matrix(numpy.zeros((nrow, nrow)))
+    
+    # Compute Means of each row. Each column must be normalised
+    meanArray = []
+    for i in range(nrow):
+        meanArray.append(numpy.mean(A[i].tolist()[0]) ) 
+        A[i] -= meanArray[i]
+    meanArray = numpy.array(meanArray) 
+    
+    # Generate Covariance Matrix
+    covMatrix = numpy.cov(A)
+
+    # Compute Eigen Values, Eigen Vectors     
+    eigs = numpy.linalg.eig(covMatrix)
+    K = eigs[1].T
+    
+    #print K
+    #print "Eigen Values"
+    #print eigs[0]
+    
+    # Zero requested components
+    for i in remove:
+        K[i] = numpy.zeros(len(K))        
+
+    # Make Transform Matrices
+    transMatrix = K*A
+    
+    # Return Necssary Stuff
+    return numpy.array(transMatrix), K, meanArray
+    #return K, A, meanArray 
+
+#def invpca(K, A, means):
+def invpca(transMatrix, K, means):
+    '''Converts a PCA rotated dataset back to normal. Input parameters
+    are the components to discard in re-creation.
+    '''
+    K = numpy.matrix(K)
+    # Transform and Untransform the data
+    #transMatrix = K*A
+    untransMatrix = K.T*transMatrix
+    
+    # Correct for normalisation
+    for i in range(len(transMatrix)):
+        untransMatrix[i] += means[i]
+
+    return untransMatrix    

akvo/tressel/rotate.py

+# #################################################################################
+# # GJI final pub specs                                                           #
+# import matplotlib                                                               #
+# from matplotlib import rc                                                       #
+# matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{timet,amsmath}"]      #
+# rc('font',**{'family':'serif','serif':['timet']})                               #
+# rc('font',**{'size':8})                                                         #
+# rc('text', usetex=True)                                                         #
+# # converts pc that GJI is defined in to inches                                  # 
+# # In GJI \textwidth = 42pc                                                      #
+# #        \columnwidth = 20pc                                                    #
+# def pc2in(pc):                                                                  #
+#     return pc*12/72.27                                                          #
+# #################################################################################
+
+#from GJIPlot import *
+
+import numpy as np
+import matplotlib.pyplot as plt
+#from invertColours import *
+from akvo.tressel.decay import *
+from scipy import signal
+
+def quadrature(T, vL, wL, dt, xn, DT, t):
+        # decimate
+    # blind decimation
+    # 1 instead of T 
+    irsamp = (T) * int(  (1./vL) / dt) # real 
+    iisamp =       int(  ((1./vL)/ dt) * ( .5*np.pi / (2.*np.pi) ) ) # imaginary
+   
+
+    dsamp =  int( DT / dt) # real 
+
+    iisamp += dsamp
+
+    ############################################################
+    # simple quadrature-detection via sampling
+    xr = xn[dsamp::irsamp]
+    xi = xn[iisamp::irsamp]
+    phase = np.angle( xr + 1j*xi )
+    abse = np.abs( xr + 1j*xi )
+
+    # times
+    #ta = np.arange(0, TT, dt)
+    #te = np.arange(DT, TT, TT/len(abse))
+
+    #############################################################
+    # hilbert transform
+    ht = signal.hilbert(xn) #, 100))
+    he = np.abs(ht)         #, 100))
+    hp = ((np.angle(ht[dsamp::irsamp]))) 
+
+    #############################################################
+    # Resample ht
+    #htd = signal.decimate(he, 100, ftype='fir') 
+    #td = signal.decimate(t, 100, ftype='fir')
+    #[htd, td] = signal.resample(he, 21, t) 
+    #toss first, and use every third 
+    #htd = htd[1::3]
+    #td = td[1::3]
+
+    #############################################################
+    # Pre-envelope
+    #gplus = xn + 1j*ht  
+
+    #############################################################
+    # Complex envelope
+    #gc = gplus / np.exp(1j*wL*t)    
+
+    #############################################################
+    ## Design a low-pass filter
+    FS = 1./dt                                           # sampling rate
+    FC = 10.05/(0.5*FS)                                 # cutoff frequency at 0.05 Hz
+    N = 11                                               # number of filter taps
+    a = [1]                                              # filter denominator
+    b = signal.firwin(N, cutoff=FC, window='hamming')    # filter numerator
+
+    #############################################################
+    ## In-phase 
+    #2*np.cos(wL*t)  
+    dw = -2.*np.pi*2
+    Q = signal.filtfilt(b, a, xn*2*np.cos((wL+dw)*t))  # X
+    I = signal.filtfilt(b, a, xn*2*np.sin((wL+dw)*t))  # Y
+
+    ###############################################
+    # Plots
+    #plt.plot(ht.real)
+    #plt.plot(ht.imag)
+    #plt.plot(np.abs(ht))
+    #plt.plot(gc.real)
+    #plt.plot(gc.imag)
+
+    #plt.plot(xn)
+    #plt.plot(xn)
+    #plt.plot(ta, xn)
+    #plt.plot(te, abse, '-.', linewidth=2, markersize=10)
+    #plt.plot(ta, he, '.', markersize=10 )
+    #plt.plot(td, htd, color='green', linewidth=2)
+    # Phase Plots
+    #ax2 = plt.twinx()
+    #ax2.plot(te, hp, '.', markersize=10, color='green' )
+    #ax2.plot(te, phase, '-.', linewidth=2, markersize=10, color='green')
+
+
+    return Q[N:-N], I[N:-N], t[N:-N]
+
+#     #####################################################################
+#     # regress raw signal
+#     
+#     #[peaks, times, ind] = peakPicker(xn, wL, dt)
+#     #[a0,b0,rt20] =  regressCurve(peaks,  times) #,sigma2=1,intercept=True):
+#     
+#     dsamp = int( DT / dt) # real 
+#     # regress analytic signal
+#     [a0,b0,rt20] =  regressCurve(he[dsamp::],  t[dsamp::], intercept=True) #,sigma2=1,intercept=True):
+#     #[b0,rt20] =  regressCurve(he[dsamp::],  t[dsamp::], intercept=False) #,sigma2=1,intercept=True):
+#     #[a0,b0,rt20] =  regressCurve(he,  t) #,sigma2=1,intercept=True):
+#    
+#     # regress downsampled 
+#     [a,b,rt2] =  regressCurve(abse,  t[dsamp::irsamp], intercept=True) #,sigma2=1,intercept=True):
+#     #[b,rt2] =  regressCurve(htd,  td, intercept=False) #,sigma2=1,intercept=True):
+#     
+#     return irsamp, iisamp, htd, b0, rt20, ta, b, rt2, phase, td, he, dsamp
+#     #return irsamp, iisamp, abse, a0, b0, rt20, times, a, b, rt2, phase
+
+def RotateAmplitude(X, Y, zeta, df, t):
+    V = X + 1j*Y
+    return np.abs(V) * np.exp( 1j * ( np.angle(V) - zeta - 2.*np.pi*df*t ) )
+    #return np.abs(V) * np.exp( 1j * ( np.angle(V) - zeta - df*t ) )
+
+#def Gate(x, t):
+#    pass
+
+def gateIntegrate(T2D, T2T, gpd, sigma, stackEfficiency=2.):
+    """ Gate integrate the signal to gpd, gates per decade
+    """
+    
+    # use artificial time gates so that early times are fully captured
+    T2T0 = T2T[0]
+    T2TD = T2T[0] - (T2T[1]-T2T[0])
+    T2T -= T2TD
+    
+    # calculate total number of decades
+    nd = np.log10(T2T[-1]/T2T[0]) #np.log10(self.T2T[-1]) -  np.log10(self.T2T[-1])
+    tdd = np.logspace( np.log10(T2T[0]), np.log10(T2T[-1]), (int)(gpd*nd)+1, base=10, endpoint=True) 
+    tdl = tdd[0:-1]     # these are left edges
+    tdr = tdd[1::]      # these are left edges
+    td = (tdl+tdr) / 2. # window centres
+
+    Vars = np.ones( len(td) ) * sigma**2 #* .15**2
+    htd = np.zeros( len(td), dtype=complex )
+    isum = np.zeros( len(td) )
+    ii = 0
+
+    SIGSTACK = {}
+    SIGSTACK[ii]= []
+    for itd in range(len(T2T)):
+        if ( T2T[itd] > tdr[ii] ):
+            if (ii < len(td)-1):
+                ii += 1
+                SIGSTACK[ii] = []
+            else:
+                #print "overshoot??", ii
+                break
+        isum[ii] += 1
+        htd[ii] += T2D[ itd ]
+        SIGSTACK[ii].append(T2D[itd])
+        Vars[ii] += sigma**2
+
+    sigma = np.sqrt( Vars  * (1/isum)**stackEfficiency ) 
+    for ii in range(len(td)):
+        if len(SIGSTACK[ii]) > 30:
+            sigma[ii] = np.var(SIGSTACK[ii]) / ((len(SIGSTACK[ii])-1)**(1/stackEfficiency))
+            #sigma[ii] = np.std(SIGSTACK[ii]) * ( 1./(len(SIGSTACK[ii]))**stackEfficiency)
+
+    # RESET times where isum == 1
+    ii = 0
+    while (isum[ii] == 1):
+        td[ii] = T2T[ii]
+        ii += 1
+
+    htd /= isum
+    T2T += T2TD  
+    return td+T2TD, htd, tdd+T2TD, sigma, isum  # centre abscissa, data, window edges, error  
+
+if __name__ == "__main__":
+
+    dt = 1e-4
+    TT = 1.5
+    t = np.arange(0, TT, dt)
+    vL = 2057.
+    wL =  2.*np.pi*vL
+    wL2 = 2.*np.pi*(vL-2.5) #-2) #-2.2) # 3 Hz off 
+    zeta = -np.pi/6. #4.234
+    t2 = .150
+
+    xs = np.exp(-t/t2) * np.cos(wL2*t + zeta) 
+    xe = np.exp(-t/t2)    
+    xn = xs + np.random.normal(0,.1,len(xs))# + (np.sign(xs) 
+            #    np.random.random_integers(-1,1,len(xs))*0.6*np.random.lognormal(0, .35, len(xs)) + \
+            #    np.random.random_integers(-1,1,len(xs))*.004*np.random.weibull(.25, len(xs)), 60)))
+
+    # quadrature detection downsampling
+    T = 50    # sampling period, grab every T'th oscilation
+    DT = .002 #85  # dead time ms
+    #[irsamp, iisamp, abse, b0, rt20, times, b, rt2, phase, tdec, he, dsamp] = quadDetect(T, vL, wL, dt, xn, DT)
+    
+    [Q, I, tt] = quadrature(T, vL, wL, dt, xn, DT, t)
+    [E0,df,phi,T2] = quadratureDetect(Q, I, tt)
+    print("df", df)
+    D = RotateAmplitude(I, Q, phi, df, tt)
+
+    fig = plt.figure(figsize=[pc2in(20), pc2in(14)]) #
+    ax1 = fig.add_axes([.125,.2,.8,.7])
+    #ax1.plot(tt*1e3, np.exp(-tt/t2), linewidth=2, color='black', label="actual")   
+    ax1.plot(tt*1e3, D.imag, label="CA", color='red')    
+    ax1.plot(t*1e3, xn, color='blue', alpha=.25)
+    ax1.plot(tt*1e3, I, label="inphase", color='blue')
+    ax1.plot(tt*1e3, Q, label="quadrature", color='green')
+    
+    #ax1.plot(tt*1e3, np.angle( Q + 1j*I), label="angle", color='purple')
+
+
+    GT, GD = gateIntegrate( D.imag, tt, 10  )
+    GT, GDR = gateIntegrate( D.real, tt, 10  )
+    GT, GQ = gateIntegrate( Q, tt, 10  )
+    GT, GI = gateIntegrate( I, tt, 10  )
+    #ax1.plot(tt*1e3, np.arctan( Q/I), label="angle", color='purple')
+    #ax1.plot(GT*1e3, np.real(GD), 'o', label="GATE", color='purple')
+    #ax1.plot(GT*1e3, np.real(GDR), 'o', label="GATE Real", color='red')
+    #ax1.plot(GT*1e3, np.arctan( np.real(GQ)/np.real(GI)), 'o',label="GATE ANGLE", color='magenta')
+    
+
+    ax1.set_xlabel(r"time [ms]") 
+    ax1.set_ylim( [-1.25,1.65] )
+    
+    #light_grey = np.array([float(248)/float(255)]*3)
+    legend = plt.legend( frameon=True, scatterpoints=1, numpoints=1, labelspacing=0.2  )
+    #rect = legend.get_frame()
+    fixLeg(legend)
+    #rect.set_color('None')
+    #rect.set_facecolor(light_grey)
+    #rect.set_linewidth(0.0)
+    #rect.set_alpha(0.5)
+
+    # Remove top and right axes lines ("spines")
+    spines_to_remove = ['top', 'right']
+    for spine in spines_to_remove:
+        ax1.spines[spine].set_visible(False)
+    #ax1.xaxis.set_ticks_position('none')
+    #ax1.yaxis.set_ticks_position('none')
+    ax1.get_xaxis().tick_bottom()
+    ax1.get_yaxis().tick_left()
+
+    plt.savefig('rotatetime.pdf',dpi=600)
+    plt.savefig('rotatetime.eps',dpi=600)
+
+    # phase part
+    plt.figure()
+    plt.plot( tt*1e3, D.real, label="CA", color='red' )
+
+    plt.show()
+    exit()

akvo/tressel/smooth.py

+import numpy
+
+def smooth(x,window_len=11,window='hanning'):
+    """smooth the data using a window with requested size.
+    
+    This method is based on the convolution of a scaled window with the signal.
+    The signal is prepared by introducing reflected copies of the signal 
+    (with the window size) in both ends so that transient parts are minimized
+    in the begining and end part of the output signal.
+    
+    input:
+        x: the input signal 
+        window_len: the dimension of the smoothing window; should be an odd integer
+        window: the type of window from 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'
+            flat window will produce a moving average smoothing.
+
+    output:
+        the smoothed signal
+        
+    example:
+
+    t=linspace(-2,2,0.1)
+    x=sin(t)+randn(len(t))*0.1
+    y=smooth(x)
+    
+    see also: 
+    
+    numpy.hanning, numpy.hamming, numpy.bartlett, numpy.blackman, numpy.convolve
+    scipy.signal.lfilter
+ 
+    TODO: the window parameter could be the window itself if an array instead of a string   
+    """
+
+    if x.ndim != 1:
+        raise ValueError("smooth only accepts 1 dimension arrays.")
+
+    if x.size < window_len:
+        raise ValueError("Input vector needs to be bigger than window size.")
+
+
+    if window_len<3:
+        return x
+
+
+    if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']:
+        raise ValueError("Window is on of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'")
+
+
+    s=numpy.r_[2*x[0]-x[window_len:1:-1],x,2*x[-1]-x[-1:-window_len:-1]]
+    #print(len(s))
+    if window == 'flat': #moving average
+        w=ones(window_len,'d')
+    else:
+        w=eval('numpy.'+window+'(window_len)')
+
+    y=numpy.convolve(w/w.sum(),s,mode='same')
+    return y[window_len-1:-window_len+1]
+
+
+
+
+from numpy import *
+from pylab import *
+
+def smooth_demo():
+
+    t=linspace(-4,4,100)
+    x=sin(t)
+    xn=x+randn(len(t))*0.1
+    y=smooth(x)
+
+    ws=31
+
+    subplot(211)
+    plot(ones(ws))
+
+    windows=['flat', 'hanning', 'hamming', 'bartlett', 'blackman']
+
+    hold(True)
+    for w in windows[1:]:
+        eval('plot('+w+'(ws) )')
+
+    axis([0,30,0,1.1])
+
+    legend(windows)
+    title("The smoothing windows")
+    subplot(212)
+    plot(x)
+    plot(xn)
+    for w in windows:
+        plot(smooth(xn,10,w))
+    l=['original signal', 'signal with noise']
+    l.extend(windows)
+
+    legend(l)
+    title("Smoothing a noisy signal")
+    show()
+
+
+if __name__=='__main__':
+    smooth_demo()
+

akvo/xml/usgsXML.py

+# XML metadata writer suitable for USGS Sciencebase Data Release
+# M. Andy Kass
+# 2017-02-17
+
+
+class Akvo(sNMRdata):
+
+    def __init__(self):
+        return
+
+    def readProcessed(self,fname):
+        # Load in the saved pickle saved from Akvo
+
+        return 42
+
+    def readInverted(self,fname):
+        return 42
+
+    def readGenericInfo(self,gfname='basicinfo,yaml',sfname='sNMRinfo.yaml'):
+        super().readGenericInfo(gfname)
+        super().readsNMRinfo(sfname)
+
+    def importProcessed(self,fname):
+        # Load in the exported YAML data from Akvo
+
+        return 42
+
+class VCsurfProcessed(sNMRdata):
+
+    def __init__(self):
+        return
+
+class VCDartdata(bNMRdata):
+
+    def __init__(self):
+        print('VCDartdata')
+        return
+
+
+class VCJavelindata(bNMRdata):
+
+    def __init__(self):
+        return
+
+
+
+
+# ----------Should never call these directly-------------------
+
+class data():
+    
+    def __init__(self):
+        return
+
+    def readGenericInfo(self,fname):
+        # Read in the generic information common to all surveys.
+
+        return 42
+
+class NMRdata(data):
+
+    def __init__(self):
+        return
+
+class bNMRdata(NMRdata):
+
+    def __init__(self):
+        return
+
+class sNMRdata(NMRdata):
+
+    def __init__(self):
+        return
+
+    def readsNMRinfo(self,fname):
+        # Read in generic info common to all sNMR surveys
+
+        return 42
+
+

akvo/xml/utClasses.py

+from usgsXML import AkvoProcessed
+
+mydata = AkvoProcessed()
+mydata.loadProcessed('test.txt')

akvo/xml/utLoadAkvoProc.py

+from usgsXML import AkvoProcessed
+
+mydata = AkvoProcessed()
+mydata.loadProcessed('test.p')

akvologo.svg

+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="210mm"
+   height="297mm"
+   viewBox="0 0 744.09448819 1052.3622047"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.91 r13725"
+   sodipodi:docname="akvologo.svg"
+   inkscape:export-filename="/home/tirons/src/akvo/akvo/gui/akvo.png"
+   inkscape:export-xdpi="90"
+   inkscape:export-ydpi="90">
+  <defs
+     id="defs4" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="2.32"
+     inkscape:cx="276.59198"
+     inkscape:cy="822.71621"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1626"
+     inkscape:window-height="834"
+     inkscape:window-x="251"
+     inkscape:window-y="156"
+     inkscape:window-maximized="0" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     style="opacity:1">
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#780000;stroke-width:5;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4.1;stroke-dasharray:none"
+       d="m 108.51064,231.89412 c 0,0 27.65957,-218.085107 84.04255,0"
+       id="path4144"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 186.69616,140.69112 c 0,0 -27.65957,218.08512 -84.04255,0"
+       id="path4144-3"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 206.77958,229.8786 c 0,0 27.65957,-218.085111 84.04255,0"
+       id="path4144-6"
+       inkscape:connector-curvature="0" />
+    <a
+       id="a4195"
+       style="">
+      <path
+         inkscape:connector-curvature="0"
+         id="path4144-3-7"
+         d="m 284.9651,138.67559 c 0,0 -27.65957,218.08513 -84.04255,0"
+         style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+      <path
+         style="fill:none;fill-rule:evenodd;stroke:#600000;stroke-width:5;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+         d="m 247.88645,235.67934 c 0,0 -20.54347,9.09636 -46.9639,-97.00375"
+         id="path4235"
+         inkscape:connector-curvature="0"
+         sodipodi:nodetypes="cc" />
+    </a>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 300.86469,231.02753 c 0,0 27.65957,-218.085107 84.04255,0"
+       id="path4144-5"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#6b0000;stroke-width:5;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+       d="m 379.05021,139.82453 c 0,0 -27.65957,218.08512 -84.04255,0"
+       id="path4144-3-3"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 392.69447,234.04881 c 0,0 27.65957,-218.08511 84.04255,0"
+       id="path4144-56"
+       inkscape:connector-curvature="0" />
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 470.87999,136.84581 c 0,0 -27.65957,218.08512 -84.04255,0"
+       id="path4144-3-2"
+       inkscape:connector-curvature="0" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path4237"
+       d="m 206.77958,229.8786 c 0,0 12.30376,-94.86414 37.6006,-97.75281"
+       style="fill:none;fill-rule:evenodd;stroke:#670000;stroke-width:5;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+       sodipodi:nodetypes="cc" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path4260"
+       d="m 401.518,186.33639 c 0,0 22.7576,-107.300794 59.85954,-2.61438"
+       style="fill:none;fill-rule:evenodd;stroke:#5f0000;stroke-width:5;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+       sodipodi:nodetypes="cc" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path4262"
+       d="m 460.74927,183.90463 c 0,0 -20.79682,111.22238 -59.53275,1.96079"
+       style="fill:none;fill-rule:evenodd;stroke:#660000;stroke-width:5;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
+       sodipodi:nodetypes="cc" />
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       x="118.28571"
+       y="266.07648"
+       id="text4264"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan4266"
+         x="118.28571"
+         y="266.07648"></tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       x="100"
+       y="294.17255"
+       id="text4268"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan4270"
+         x="100"
+         y="294.17255" /></text>
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:27.5px;line-height:125%;font-family:'Asana Math';-inkscape-font-specification:'Asana Math, Normal';text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       x="137.8793"
+       y="274.6553"
+       id="text4272"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan4274"
+         x="137.8793"
+         y="274.6553">Surface NMR Workbench</tspan></text>
+    <path
+       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 138.63793,248.05186 c 306.89655,2.58621 306.89655,2.58621 306.89655,2.58621"
+       id="path4276"
+       inkscape:connector-curvature="0" />
+  </g>
+</svg>

bir.sh

+#!/bin/bash
+python3 setup.py build
+sudo python3 setup.py install
+akvo

pyuic.json

+{
+    "files": [
+        [
+            "akvo/gui/main.ui",
+            "akvo/gui"
+        ]
+    ],
+    "pyrcc": "pyrcc5",
+    "pyrcc_options": "",
+    "pyuic": "pyuic5",
+    "pyuic_options": "--from-imports"
+}

setup.py

+#!/usr/bin/env python
+import sys
+
+# optionally use qt4
+# if sys.argv[1] == "build_ui":
+#     try:
+#         from pyqt_distutils.build_ui import build_ui
+#         cmdclass = {'build_ui': build_ui}
+#     except ImportError:
+#         build_ui = None  # user won't have pyqt_distutils when deploying
+#         cmdclass = {}
+# else:
+#     build_ui = None  # user won't have pyqt_distutils when deploying
+#     cmdclass = {}
+
+# Require PyQt5 and compiltion of GUI files via pyuic 
+from setuptools import setup, Extension
+from setuptools.command.build_py import build_py
+from pyqt_distutils.build_ui import build_ui
+
+class custom_build_py(build_py):
+    def run(self):
+        self.run_command('build_ui')
+        build_py.run(self)
+
+try:
+    from Cython.Build import cythonize as cythonise
+except ImportError:
+    def cythonise(*args, **kwargs):
+        #from Cython.Build import cythonize
+        #return cythonize(*args, **kwargs)
+        return 
+
+#from distutils.core import setup
+
+setup(name='Akvo',
+      version='1.0.4',
+      description='Surface nuclear magnetic resonance workbench',
+      author='Trevor P. Irons',
+      author_email='Trevor.Irons@lemmasoftware.org',
+      url='https://svn.lemmasofware.org/akvo',
+      #setup_requires=['PyQt5'],
+      setup_requires=[
+        # Setuptools 18.0 properly handles Cython extensions.
+        'PyQt5','setuptools>=18.0',
+      ],
+#      ext_modules = cythonise("akvo/tressel/*.pyx"), 
+#      build_requires=['cython'],
+      install_requires=[
+#          'cython',
+          'rpy2',
+          'matplotlib',
+          'scipy',
+          'numpy',
+          'PyQt5',
+          'pyyaml',
+          'pyqt-distutils',
+          'cmocean'
+      ],
+      packages=['akvo', 'akvo.tressel', 'akvo.gui'],
+      license=['GPL 4.0'],
+      entry_points = {
+              'console_scripts': [
+                  'akvo = akvo.gui.akvoGUI:main',                  
+              ],              
+          },
+      # for forced build of pyuic
+      cmdclass={
+          'build_ui': build_ui,
+          'build_py': custom_build_py,
+      },
+      #cmdclass=cmdclass,
+      # Mechanism to include auxiliary files
+      include_package_data=True,
+      package_data={
+        'akvo.gui': ['*.png']  #All .r files 
+      },
+    )
+
+