Pulled SVN into GIT.

INSTALL.txt

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1 @@
+#import akvo.tressel.decay

akvo/gui/__init__.py

@@ -0,0 +1 @@
+#import mainui.py 

akvo/gui/main2ui.py

@@ -0,0 +1,9 @@
+# -*- 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

@@ -0,0 +1,586 @@
+# -*- 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

@@ -0,0 +1,299 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,13 @@
+
+# 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

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

akvo/gui/temp.py

@@ -0,0 +1,219 @@
+"""
+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

@@ -0,0 +1,35 @@
+#################################################################################
+# 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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,192 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,3 @@
+#import decay
+#import rotate
+#import mrsurvey 

akvo/tressel/adapt.py

@@ -0,0 +1,545 @@
+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

@@ -0,0 +1,546 @@
+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)