class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
fig = Figure()
self.addmpl(fig)
self.rdBtn.clicked.connect(self.read)
self.df = {}
def read(self):
try:
self.df[str(self.inp.text()).split('.')[0]]=pd.read_csv(str(self.inp.text()))
except IOError:
print 'No such file'
def clear(self):
self.mplfigs.clear()
self.rmmpl()
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self,):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
class GraphPage(QtGui.QMainWindow):
def __init__(self, parent=None):
super(GraphPage, self).__init__()
uic.loadUi("graphPage.ui", self)
self.fig_dict = {}
self.listWidget.itemClicked.connect(self.changeFig)
fig = Figure()
self.addplot(fig)
def addplot(self, fig):
self.canvas = FigureCanvas(fig)
self.verticalLayout.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.verticalLayout.addWidget(self.toolbar)
def rmPlot(self):
self.verticalLayout.removeWidget(self.canvas)
self.canvas.close()
self.verticalLayout.removeWidget(self.toolbar)
self.toolbar.close()
def addfig(self, name, fig):
self.fig_dict[name] = fig
self.listWidget.addItem(name)
def changeFig(self, item):
text = item.text()
self.rmPlot()
self.addplot(self.fig_dict[text])
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.mplfigs.itemClicked.connect(self.change_fig)
def change_fig(self, item):
text = item.text()
self.rm_mpl()
self.add_mpl(self.fig_dict[text])
def add_mpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
self.addToolBar(self.toolbar)
def rm_mpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def add_fig(self, name, fig):
self.fig_dict[name] = fig
self.mplfigs.addItem(name)
class Mpl(QtGui.QWidget, Ui_Form):
def __init__(self, fig_dict, name_list):
super(Mpl, self).__init__()
self.setupUi(self)
self.fig_dict = fig_dict
self.name_list = name_list
self.index = 0
self.btnBack.clicked.connect(self.back)
self.btnForward.clicked.connect(self.forward)
self.comboBoxSelect.addItems(self.name_list)
self.comboBoxSelect.setCurrentIndex(self.index)
self.comboBoxSelect.activated.connect(self.select)
if self.fig_dict and self.name_list:
fig = self.fig_dict[self.name_list[self.index]]
else:
fig = Figure()
self.addmpl(fig)
def changefig(self, ):
self.comboBoxSelect.setCurrentIndex(self.index)
fig = self.fig_dict[self.name_list[self.index]]
self.rmmpl()
self.addmpl(fig)
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
# self.canvas.setSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
self.ltMPL.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.wgtToolbox,
coordinates=True)
self.ltToolbox.addWidget(self.toolbar)
def rmmpl(self, ):
self.ltMPL.removeWidget(self.canvas)
self.canvas.close()
self.ltToolbox.removeWidget(self.toolbar)
self.toolbar.close()
def back(self):
self.index = self.index - 1 if self.index != 0 else len(
self.name_list) - 1
self.changefig()
def forward(self):
self.index = self.index + 1 if self.index != len(
self.name_list) - 1 else 0
self.changefig()
def select(self):
self.index = self.comboBoxSelect.currentIndex()
self.changefig()
class Mpl(QtGui.QWidget, Ui_Form):
def __init__(self, fig_dict, name_list):
super(Mpl, self).__init__()
self.setupUi(self)
self.fig_dict = fig_dict
self.name_list = name_list
self.index = 0
self.btnBack.clicked.connect(self.back)
self.btnForward.clicked.connect(self.forward)
self.comboBoxSelect.addItems(self.name_list)
self.comboBoxSelect.setCurrentIndex(self.index)
self.comboBoxSelect.activated.connect(self.select)
if self.fig_dict and self.name_list:
fig = self.fig_dict[self.name_list[self.index]]
else:
fig = Figure()
self.addmpl(fig)
def changefig(self,):
self.comboBoxSelect.setCurrentIndex(self.index)
fig = self.fig_dict[self.name_list[self.index]]
self.rmmpl()
self.addmpl(fig)
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
# self.canvas.setSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
self.ltMPL.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.wgtToolbox, coordinates=True)
self.ltToolbox.addWidget(self.toolbar)
def rmmpl(self,):
self.ltMPL.removeWidget(self.canvas)
self.canvas.close()
self.ltToolbox.removeWidget(self.toolbar)
self.toolbar.close()
def back(self):
self.index = self.index-1 if self.index!=0 else len(self.name_list)-1
self.changefig()
def forward(self):
self.index = self.index+1 if self.index!=len(self.name_list)-1 else 0
self.changefig()
def select(self):
self.index = self.comboBoxSelect.currentIndex()
self.changefig()
class Main(QMainWindow,Ui_MainWindow):
def __init__(self):
super(Main,self).__init__()
self.setupUi(self)
self.cosPlot.clicked.connect(self.cosPlotFunc)
self.sinPlot.clicked.connect(self.sinPlotFunc)
self.loadData.clicked.connect(self.loadDataFunc)
self.shotData = pd.DataFrame()
fig = Figure()
self.addmpl(fig)
def addmpl(self,fig):
self.canvas = FigureCanvas(fig)
self.livePlotLay.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,self,coordinates=True)
self.livePlotLay.addWidget(self.toolbar)
def rmmpl(self):
self.livePlotLay.removeWidget(self.canvas)
self.canvas.close()
self.livePlotLay.removeWidget(self.toolbar)
self.toolbar.close()
def cosPlotFunc(self):
self.rmmpl()
fig = Figure()
axes = fig.add_subplot(111)
x = np.linspace(0,2*np.pi,1000)
axes.plot(x,np.cos(x))
self.addmpl(fig)
def sinPlotFunc(self):
self.rmmpl()
fig = Figure()
axes = fig.add_subplot(111)
x = np.linspace(0,2*np.pi,1000)
axes.plot(x,np.sin(x))
self.addmpl(fig)
def loadDataFunc(self):
fileDialog = QtGui.QFileDialog(self)
fileDialog.setFilters('*.h5')
fileDialog.setFileMode(QtGui.QFileDialog.ExistingFiles)
fileDialog.exec_()
for fileName in fileDialog.selectedFiles():
print fileName
self.shotData = self.shotData.append(shotProcessor(str(fileName), 'absGaussFit'), ignore_index=True)
print self.shotData
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.mplfigs.itemClicked.connect(self.changefig)
fig = Figure()
self.addmpl(fig)
def changefig(
self, item
): #signal for changing the figure, itemclicked is connected to this
text = item.text() #to get info and text of the item
self.rmmpl() #remove the old fig
self.addmpl(self.fig_dict[text]
) #add new fig based on the list item that was clicked
def addfig(self, name, fig):
self.fig_dict[name] = fig
self.mplfigs.addItem(name) #add fig to fig dictionary?
def addmpl(self, fig): #add plot
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas) #create the figure canvas widget
self.canvas.draw() #draw canvas on app window
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow,
coordinates=True) #set toolbar
self.mplvl.addWidget(self.toolbar) #add toolbar to layout
# This is the alternate toolbar placement. Susbstitute the three lines above
# for these lines to see the different look.
# self.toolbar = NavigationToolbar(self.canvas,
# self, coordinates=True)
# self.addToolBar(self.toolbar)
def rmmpl(self, ): #changing plots- removes plot
self.mplvl.removeWidget(
self.canvas) #remove canvas and toolbar from vertical layout
self.canvas.close() #removes their display from the application window
self.mplvl.removeWidget(self.toolbar) #remove the toolbar
self.toolbar.close() #remove toolbar from window
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.mplfigs.itemClicked.connect(self.changefig)
fig = Figure()
self.addmpl(fig)
def changefig(self, item):
text = item.text()
self.rmmpl()
self.addmpl(self.fig_dict[text])
def addfig(self, name, fig):
self.fig_dict[name] = fig
self.mplfigs.addItem(name)
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
# This is the alternate toolbar placement. Susbstitute the three lines above
# for these lines to see the different look.
# self.toolbar = NavigationToolbar(self.canvas,
# self, coordinates=True)
# self.addToolBar(self.toolbar)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.mplfigs.itemClicked.connect(self.changefig)
fig = Figure()
self.addmpl(fig)
def changefig(self, item):
text = item.text()
self.rmmpl()
self.addmpl(self.fig_dict[text])
def addfig(self, name, fig):
self.fig_dict[name] = fig
self.mplfigs.addItem(name)
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
# This is the alternate toolbar placement. Susbstitute the three lines above
# for these lines to see the different look.
# self.toolbar = NavigationToolbar(self.canvas,
# self, coordinates=True)
# self.addToolBar(self.toolbar)
def rmmpl(self,):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
class MainWindow(QtGui.QMainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
# Load of main window GUI
# The GUI was developed in QT Designer
self.ui = uic.loadUi("src/gui/main.ui")
# Full Screen
self.ui.showMaximized()
screen = QtGui.QDesktopWidget().screenGeometry()
# Screen dimensions
self.size_x = screen.width()
self.size_y = screen.height()
self.ui.setWindowFlags(self.ui.windowFlags()
| QtCore.Qt.CustomizeWindowHint)
self.ui.setWindowFlags(self.ui.windowFlags()
& ~QtCore.Qt.WindowMaximizeButtonHint)
self.ui.ctrlFrame.resize(280, self.size_y - 120)
self.ui.tabPlots.resize(self.size_x - 600, self.size_y - 150)
self.ui.plotFrame.resize(self.size_x - 620, self.size_y - 210)
self.ui.plotFrame.setLayout(self.ui.MainPlot)
self.ui.plotFrame_2.resize(self.size_x - 620, self.size_y - 210)
self.ui.plotFrame_2.setLayout(self.ui.MainPlot_2)
self.ui.Terminal.move(self.size_x - 290, self.size_y / 2 - 100)
self.ui.Terminal.resize(self.size_x - 1085, self.size_y / 2 - 30)
self.ui.Terminal.setLayout(self.ui.TermVBox)
self.ui.loggsFrame.move(self.size_x - 290, 10)
self.ui.loggsFrame.resize(self.size_x - 1085, self.size_y / 2 - 120)
self.ui.loggsFrame.setLayout(self.ui.loggsText)
# Logging
logTextBox = QTextEditLogger(self)
# You can format what is printed to text box
logTextBox.setFormatter(
logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
logging.getLogger().addHandler(logTextBox)
# You can control the logging level
logging.getLogger().setLevel(logging.INFO)
self.ui.loggsText.addWidget(logTextBox.widget)
# Initial settings
# Loading General Configuration file
# Load general settings
self.gc = {}
with open("./config/general_config") as f:
for line in f:
if line[0] != "#" and line[0] != "\n":
(key, val) = line.split()
self.gc[key] = val
logging.info('Loading configuration parameters ...')
# Load list of firmware registers (note: must manually update for different versions)
self.regs = {}
with open("./config/firmware_registers") as f:
for line in f:
if line[0] != "#" and line[0] != "\n":
(key, val) = line.split()
self.regs[key] = val
logging.info('Loading firmware registers ...')
# Paths of firmware and directories to save data
self.firmware = self.gc['FIRMWARE_FILE']
self.ui.firmEdit.setText(self.firmware)
self.vna_savepath = self.gc['VNA_SAVEPATH']
self.targ_savepath = self.gc['TARG_SAVEPATH']
self.dirfile_savepath = self.gc['DIRFILE_SAVEPATH']
self.ui.vnaEdit.setText(self.vna_savepath)
self.ui.tarEdit.setText(self.targ_savepath)
self.ui.streamEdit.setText(self.dirfile_savepath)
# UDP packet
self.buf_size = int(self.gc['buf_size'])
self.header_len = int(self.gc['header_len'])
# Ethernet port
self.eth_port = self.gc['udp_dest_device']
self.ui.ethEdit.setText(self.eth_port)
os.system("sudo ip link set " + self.eth_port + " mtu 9000")
# Source (V6) Data for V6
self.udp_src_ip = self.gc['udp_src_ip']
self.udp_src_mac = self.gc['udp_src_mac']
self.udp_src_port = self.gc['udp_src_port']
self.ui.ipSrcEdit.setText(self.udp_src_ip)
self.ui.macSrcEdit.setText(self.udp_src_mac)
self.ui.portSrcEdit.setText(self.udp_src_port)
self.dds_shift = self.gc['dds_shift']
self.udp_dst_ip = self.gc['udp_dest_ip']
self.udp_dst_mac = self.gc['udp_dest_mac']
self.udp_dst_port = self.gc['udp_dst_port']
self.ui.ipDstEdit.setText(self.udp_dst_ip)
self.ui.macDstEdit.setText(self.udp_dst_mac)
self.ui.portDstEdit.setText(self.udp_dst_port)
# About the ROACH
self.roach_ip = self.gc['roach_ppc_ip']
self.ui.roachIPEdit.setText(self.roach_ip)
# Windfreak Synthesizer params
self.synthID = self.gc['synthID']
self.clkFreq = np.float(self.gc['clkFreq'])
self.clkPow = np.float(self.gc['clkPow'])
self.LOFreq = np.float(self.gc['LOFreq'])
self.LOPow = np.float(self.gc['LOPow'])
self.center_freq = np.float(self.gc['center_freq'])
self.lo_step = np.float(self.gc['lo_step'])
self.ui.freqClk.setText(str(self.clkFreq))
self.ui.powClk.setText(str(self.clkPow))
self.ui.loFreq.setText(str(self.LOFreq))
self.ui.loPow.setText(str(self.LOPow))
# Limits of test comb
self.min_pos_freq = np.float(self.gc['min_pos_freq'])
self.max_pos_freq = np.float(self.gc['max_pos_freq'])
self.min_neg_freq = np.float(self.gc['min_neg_freq'])
self.max_neg_freq = np.float(self.gc['max_neg_freq'])
self.symm_offset = np.float(self.gc['symm_offset'])
self.Nfreq = int(self.gc['Nfreq'])
self.ui.minPosEdit.setText(str(self.min_pos_freq / 1.0e6))
self.ui.maxPosEdit.setText(str(self.max_pos_freq / 1.0e6))
self.ui.minNegEdit.setText(str(self.min_neg_freq / 1.0e6))
self.ui.maxNegEdit.setText(str(self.max_neg_freq / 1.0e6))
self.ui.offsetEdit.setText(str(self.symm_offset / 1.0e6))
self.ui.nFreqsEdit.setText(str(self.Nfreq))
# Attenuation
att_ID_1 = int(self.gc['att_ID_1'])
att_ID_2 = int(self.gc['att_ID_2'])
self.attenID = [att_ID_1, att_ID_2]
self.ui.attInIDEdit.setText(str(att_ID_1))
self.ui.attOutIDEdit.setText(str(att_ID_2))
self.att_In = int(self.gc['attIn'])
self.att_Out = int(self.gc['attOut'])
self.target_rms = np.float(self.gc['target_rms_mv'])
self.ui.attInEdit.setText(str(self.att_In))
self.ui.attOutEdit.setText(str(self.att_Out))
self.ui.tarLevelEdit.setText(str(self.target_rms))
# Optional test frequencies
self.test_freq = np.float(self.gc['test_freq'])
self.test_freq = np.array([self.test_freq])
self.freq_list = self.gc['freq_list']
# Parameters for resonator search
self.smoothing_scale = np.float(self.gc['smoothing_scale'])
self.peak_threshold = np.float(self.gc['peak_threshold'])
self.spacing_threshold = np.float(self.gc['spacing_threshold'])
# VNA Sweep
self.startVNA = -255.5e6
self.stopVNA = 255.5e6
self.ui.centralEdit.setText(str(self.center_freq))
self.ui.startEdit.setText(str(self.startVNA / 1.0e6))
self.ui.stopEdit.setText(str(self.stopVNA / 1.0e6))
self.ui.stepEdit.setText(str(self.lo_step / 1.0e6))
self.ui.nTonesEdit.setText(str(self.Nfreq))
# Tool bar
# ROACH status
self.ui.actionRoach.triggered.connect(self.roach_connection)
# ROACH network
self.ui.actionNetwork.triggered.connect(self.roach_network)
# Synthesizer
self.ui.actionSynthesizer.triggered.connect(self.roach_synth)
# Attenuattors
self.ui.actionRF_Calibration.triggered.connect(self.roach_atten)
# QDR Calibration
self.ui.actionQDR_Calibration.triggered.connect(self.qdr_cal)
# Buttons
# Roach
# Roach Settings
self.ui.firmDir.mousePressEvent = self.chooseFirmPath
self.ui.vnaDir.mousePressEvent = self.chooseVNAPath
self.ui.targDir.mousePressEvent = self.chooseTargPath
self.ui.streamDir.mousePressEvent = self.chooseStreamPath
self.ui.upFirmBtn.mousePressEvent = self.upload_firmware
self.ui.synthBtn.mousePressEvent = self.roach_synth
self.ui.udpConfBtn.mousePressEvent = self.roach_network
self.ui.udpTestBtn.mousePressEvent = self.test_udp
self.ui.attBtn.mousePressEvent = self.roach_atten
self.ui.writeTestBtn.mousePressEvent = self.write_test_comb
self.ui.plotSweepBtn.mousePressEvent = self.start_plot_VNA
self.ui.startSweepBtn.mousePressEvent = self.start_VNA_sweep
# Iniatialising
self.statusConn = 0
self.statusFirm = 0
self.statusSynth = 0
self.statusAtt = 0
self.statusNet = 0
self.s = None
self.fpga = None
try:
self.fpga = casperfpga.CasperFpga(self.roach_ip, timeout=100.)
icon.addPixmap(QPixmap('./src/icon/ok_icon.png'))
self.ui.actionRoach_Status.setIcon(icon)
logging.info("Connected to: " + self.roach_ip)
except:
self.fpga = None
self.statusConn = 1
logging.info("Roach link is down")
# Check firmware
if self.fpga:
logging.info('Firmware is uploaded')
if self.fpga.is_running():
self.ui.upFirmBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
else:
self.statusFirm = 1
else:
self.statusFirm = 1
# UDP socket
# Run with root permissions
try:
self.s = socket(AF_PACKET, SOCK_RAW, htons(3))
logging.info('Socket is initialised.')
except:
logging.error(
'Socket is not initialised. Permissions are required')
# Roach interface
self.ri = roachInterface(self.fpga, self.gc, self.regs, None)
# GbE interface
try:
self.udp = roachDownlink(self.ri, self.fpga, self.gc, self.regs,
self.s, self.ri.accum_freq)
self.udp.configSocket()
logging.info('UDP configuration done.')
except:
logging.error("UDP connection couldn't be initialised.")
# Creation of Plot
self.fig1 = Figure()
self.addmpl_homodyne(self.fig1)
# Creation of Plot
self.fig1 = Figure()
self.addmpl_vna(self.fig1)
# To use LATEX in plots
matplotlib.rc('text', usetex=True)
matplotlib.rcParams['text.latex.preamble'] = [r"\usepackage{amsmath}"]
# IPython console
self.console = EmbedIPython()
self.console.kernel.shell.run_cell('%pylab qt')
self.console.execute("cd ./")
self.ui.TermVBox.addWidget(self.console)
self.ui.show()
def choosePath(self, flag):
w = QWidget()
w.resize(320, 240)
w.setWindowTitle("Select directory where KID files are ")
if flag == "firm":
self.firmware = QFileDialog.getOpenFileName(
self, "Select Directory")
self.ui.firmEdit.setText(self.firmware)
self.gc['FIRMWARE_FILE'] = self.firmware
elif flag == "vnaPath":
self.vna_savepath = QFileDialog.getOpenFileName(
self, "Select Directory")
self.ui.vnaEdit.setText(self.vna_savepath)
self.gc['VNA_SAVEPATH'] = self.vna_savepath
elif flag == "tarPath":
self.targ_savepath = QFileDialog.getOpenFileName(
self, "Select Directory")
self.ui.tarEdit.setText(self.targ_savepath)
self.gc['TARG_SAVEPATH'] = self.targ_savepath
elif flag == "streamPath":
self.dirfile_savepath = QFileDialog.getOpenFileName(
self, "Select Directory")
self.ui.streamEdit.setText(self.dirfile_savepath)
self.gc['DIRFILE_SAVEPATH'] = self.dirfile_savepath
def chooseFirmPath(self, event):
self.choosePath("firm")
def chooseVNAPath(self, event):
self.choosePath("vnaPath")
def chooseTargPath(self, event):
self.choosePath("tarPath")
def chooseStreamPath(self, event):
self.choosePath("streamPath")
def testConn(self, fpga):
"""Tests the link to Roach2 PPC, using return from getFPGA()
inputs:
casperfpga object fpga: The fpga object
outputs: the fpga object"""
if not fpga:
try:
fpga = casperfpga.CasperFpga(self.roach_ip, timeout=3.)
# Roach interface
self.ri = roachInterface(self.fpga, self.gc, self.regs, None)
except RuntimeError:
logging.warning(
"No connection to ROACH. If booting, wait 30 seconds and retry. Otherwise, check gc config."
)
return fpga
def roach_connection(self, event):
"""Check the connection with ROACH, if it is connected turn green the status icon"""
self.roach_ip = self.ui.roachIPEdit.toPlainText()
w = QWidget()
self.ui.setEnabled(False)
self.ui.statusbar.showMessage(u'Waiting for roach connection...')
QMessageBox.information(w, "ROACH Connection",
"Starting with ROACH comunication ...")
try:
result = self.testConn(self.fpga)
except:
result = None
icon = QIcon()
if not result:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionRoach_Status.setIcon(icon)
self.statusConn = 1
self.ui.statusbar.showMessage(u'ROACH connection failed!')
logging.warning('ROACH connection failed.')
QMessageBox.information(
w, "ROACH Connection",
"No connection to ROACH. If booting, wait 30 seconds and retry. Otherwise, check gc config."
)
else:
self.fpga = result
icon.addPixmap(QPixmap('./src/icon/ok_icon.png'))
self.ui.actionRoach_Status.setIcon(icon)
self.statusConn = 0
self.ui.statusbar.showMessage(u'ROACH connection is successful!')
logging.info('ROACH connection is successful!')
QMessageBox.information(w, "ROACH Connection",
"Successful communication!")
self.ui.setEnabled(True)
def roach_synth(self, event):
"""Synthesizer connection. Check if the synthesizer is connected and set it
the initial parameters"""
self.clkFreq = np.float(self.ui.freqClk.toPlainText())
self.clkPow = np.float(self.ui.powClk.toPlainText())
self.LOFreq = np.float(self.ui.loFreq.toPlainText())
self.LOPow = np.float(self.ui.loPow.toPlainText())
self.synthID = self.ui.comboBox.currentText().upper()
w = QMessageBox()
icon = QIcon()
self.ui.setEnabled(False)
self.ui.statusbar.showMessage(
u'Waiting for synthesizer connection ...')
QMessageBox.information(w, "Synthesizer Connection",
"Starting Synthesizer configuration ...")
try:
# Initializing Synthesizer Windfreak
self.synthRF = synthclass.Synthesizer(self.synthID)
icon.addPixmap(QPixmap('./src/icon/ok_icon.png'))
self.ui.actionSynthesizer_status.setIcon(icon)
self.ui.synthBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
self.statusSynth = 0
logging.info('Synthesizer connection is successful')
self.ui.statusbar.showMessage(
u'Synthesizer connection is successful')
# CLK
self.synthRF.setControlChannel(0)
self.synthRF.setPower(True)
self.synthRF.setRFMute(1)
self.synthRF.setRFAmp(1)
self.synthRF.setFrequency(self.clkFreq)
self.synthRF.setPower(self.clkPow)
# LO
self.synthRF.setControlChannel(1)
self.synthRF.setPower(True)
self.synthRF.setRFMute(1)
self.synthRF.setRFAmp(1)
self.synthRF.setFrequency(self.LOFreq)
self.synthRF.setPower(self.LOPow)
QMessageBox.information(w, "Synthesizer connection",
"Synthesizer connected and working!")
except:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionSynthesizer_status.setIcon(icon)
self.ui.synthBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusSynth = 1
logging.warning('Synthesizer failed!')
self.ui.statusbar.showMessage(u'Synthesizer failed!')
QMessageBox.warning(w, "Synthesizer connection",
"Synthesizer connection failed!")
self.ui.setEnabled(True)
def qdr_cal(self, event):
w = QMessageBox()
icon = QIcon()
self.ui.setEnabled(False)
self.ui.statusbar.showMessage(u'Waiting for QDR Calibration ...')
QMessageBox.information(w, "QDR Calibration",
"Starting QDR calibration ...")
if not self.fpga == None:
self.fpga.write_int(self.regs['accum_len_reg'],
self.ri.accum_len - 1)
time.sleep(0.1)
self.fpga.write_int(self.regs['dds_shift_reg'],
int(self.gc['dds_shift']))
time.sleep(0.1)
# QDR Calibration
if (self.ri.qdrCal() < 0):
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionQDR_Status.setIcon(icon)
self.ui.statusbar.showMessage(u'QDR Calibration failed!')
logging.info('QDR Calibration failed!')
QMessageBox.information(
w, "QDR Calibration",
"QDR calibration failed... Check FPGA clock source")
else:
icon.addPixmap(QPixmap('./src/icon/ok_icon.png'))
self.ui.actionQDR_Status.setIcon(icon)
self.fpga.write_int(self.regs['write_qdr_status_reg'], 1)
self.ui.statusbar.showMessage(u'QDR Calibration completed!')
logging.info('QDR Calibration completed!')
QMessageBox.information(w, "QDR Calibration",
"QDR calibration completed!")
else:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionQDR_Status.setIcon(icon)
logging.info('QDR calibration failed... Check ROACH connection')
QMessageBox.information(
w, "QDR Calibration",
"QDR calibration failed... Check ROACH connection")
self.ui.setEnabled(True)
def roach_atten(self, event):
"""Attenuators connection. Check if the attenuators are connected and calibrate them"""
att_ID_1 = int(self.ui.attInIDEdit.toPlainText())
att_ID_2 = int(self.ui.attOutIDEdit.toPlainText())
self.attenID = [att_ID_1, att_ID_2]
self.att_In = int(self.ui.attInEdit.toPlainText())
self.att_Out = int(self.ui.attOutEdit.toPlainText())
self.target_rms = np.float(self.ui.tarLevelEdit.toPlainText())
w = QMessageBox()
icon = QIcon()
self.ui.setEnabled(False)
self.ui.statusbar.showMessage(
u'Waiting for attenuators calibration ... ')
QMessageBox.information(
w, "Attenuation Connection",
"Starting input/output attenuators configuration ...")
try:
# Attenuation calibration
att = attCalibration.CalibrationATT(self.attenID)
if self.fpga:
att.calibrateADC(self.fpga, self.target_rms, self.att_Out,
self.att_In) # ADC level calibration
icon.addPixmap(QPixmap('./src/icon/ok_icon.png'))
self.ui.actionRF_Status.setIcon(icon)
self.ui.attBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
self.statusAtt = 0
self.ui.statusbar.showMessage(
u'Attenuators connection is succesful')
logging.info('Attenuators connection is succesful')
QMessageBox.information(w, "Attenuators connection",
"Attenuators connected and working!")
else:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionRF_Status.setIcon(icon)
self.ui.attBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusAtt = 0
self.ui.statusbar.showMessage(
u'Attenuators connection failed!')
logging.warning('Attenuators connection failed!')
QMessageBox.information(
w, "Attenuators connection",
"Attenuators calibration failed! Roach is not connected.")
except:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionRF_Status.setIcon(icon)
self.ui.attBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusAtt = 1
self.ui.statusbar.showMessage(u'Attenuators connection failed!')
logging.warning(
'Attenuators connection failed! Check attenuators connection.')
QMessageBox.warning(
w, "Attenuators connection",
"Attenuators connection failed! Check attenuators connection.")
self.ui.setEnabled(True)
def roach_network(self, event):
self.gc['udp_dest_ip'] = self.ui.ipDstEdit.toPlainText()
self.gc['udp_dst_port'] = self.ui.portDstEdit.toPlainText()
self.gc['udp_dest_mac'] = self.ui.macDstEdit.toPlainText()
self.gc['udp_src_ip'] = self.ui.ipSrcEdit.toPlainText()
self.gc['udp_src_port'] = self.ui.portSrcEdit.toPlainText()
self.gc['udp_src_mac'] = self.ui.macSrcEdit.toPlainText()
self.gc['udp_dest_device'] = self.ui.ethEdit.toPlainText()
# Update the UDP parameters
self.eth_port = self.gc['udp_dest_device']
os.system("sudo ip link set " + self.eth_port + " mtu 9000")
self.udp_src_ip = self.gc['udp_src_ip']
self.udp_src_mac = self.gc['udp_src_mac']
self.udp_src_port = self.gc['udp_src_port']
self.udp_dst_ip = self.gc['udp_dest_ip']
self.udp_dst_mac = self.gc['udp_dest_mac']
self.udp_dst_port = self.gc['udp_dst_port']
w = QMessageBox()
icon = QIcon()
self.ui.setEnabled(False)
self.ui.statusbar.showMessage(u'UDP configuration ... ')
QMessageBox.information(w, "UDP Configuration",
"Starting UDP configuration ...")
try:
# GbE interface
self.udp = roachDownlink(self.ri, self.fpga, self.gc, self.regs,
self.s, self.ri.accum_freq)
self.udp.configSocket()
# UDP Configuration
try:
self.udp.configDownlink()
# Register set
self.fpga.write_int(self.regs['accum_len_reg'],
self.ri.accum_len - 1)
time.sleep(0.1)
self.fpga.write_int(self.regs['dds_shift_reg'],
int(self.gc['dds_shift']))
time.sleep(0.1)
icon.addPixmap(QPixmap('./src/icon/ok_icon.png'))
self.ui.actionNetwork_status.setIcon(icon)
self.ui.udpConfBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
self.statusNet = 0
self.ui.statusbar.showMessage(u'UDP Downlink configured.')
logging.info('UDP Downlink configured.')
QMessageBox.information(w, "UDP Downlink",
"UDP Network configuraton id done.")
except AttributeError:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionNetwork_status.setIcon(icon)
self.ui.udpConfBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(
u'UDP Downlink configuration failed!')
logging.warning(
"UDP Downlink could not be configured. Check ROACH connection."
)
QMessageBox.information(
w, "UDP Downlink",
"UDP Downlink could not be configured. Check ROACH connection."
)
except:
icon.addPixmap(QPixmap('./src/icon/wrong_icon.png'))
self.ui.actionNetwork_status.setIcon(icon)
self.ui.udpConfBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(u'UDP Network configuraton failed!')
logging.warning('UDP Network configuraton failed!')
QMessageBox.information(
w, "UDP error",
"UDP Network configuraton failed! Check ROACH connection.")
self.ui.setEnabled(True)
def write_test_comb(self, event):
self.min_pos_freq = np.float(self.ui.minPosEdit.toPlainText()) * 1.0e6
self.max_pos_freq = np.float(self.ui.maxPosEdit.toPlainText()) * 1.0e6
self.min_neg_freq = np.float(self.ui.minNegEdit.toPlainText()) * 1.0e6
self.max_neg_freq = np.float(self.ui.maxNegEdit.toPlainText()) * 1.0e6
self.symm_offset = np.float(self.ui.offsetEdit.toPlainText()) * 1.0e6
self.Nfreq = int(self.ui.nFreqsEdit.toPlainText())
#w = QMessageBox()
self.ui.statusbar.showMessage(u'Writting test comb ... ')
try:
if self.fpga:
self.ri.makeFreqComb(self.min_neg_freq, self.max_neg_freq,
self.min_pos_freq, self.max_pos_freq,
self.symm_offset, self.Nfreq)
if (len(self.ri.freq_comb) > 400):
self.fpga.write_int(self.regs['fft_shift_reg'], 2**5 - 1)
time.sleep(0.1)
else:
self.fpga.write_int(self.regs['fft_shift_reg'], 2**9 - 1)
time.sleep(0.1)
self.ri.upconvert = np.sort(
((self.ri.freq_comb + (self.center_freq) * 1.0e6)) / 1.0e6)
logging.info("RF tones =", self.ri.upconvert)
self.ri.writeQDR(self.ri.freq_comb, transfunc=False)
np.save("last_freq_comb.npy", self.ri.freq_comb)
if not (self.fpga.read_int(self.regs['dds_shift_reg'])):
if self.regs['DDC_mixerout_bram_reg'] in self.fpga.listdev(
):
shift = self.ri.return_shift(0)
if (shift < 0):
self.ui.writeTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(
"Error finding dds shift: Try writing full frequency comb (N = 1000), or single test frequency. Then try again"
)
logging.warning(
"Error finding dds shift: Try writing full frequency comb (N = 1000), or single test frequency. Then try again"
)
else:
self.fpga.write_int(self.regs['dds_shift_reg'],
shift)
self.ui.writeTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
self.statusNet = 0
self.ui.statusbar.showMessage("Wrote DDS shift (" +
str(shift) + ")")
logging.info("Wrote DDS shift (" + str(shift) +
")")
else:
self.fpga.write_int(self.regs['dds_shift_reg'],
self.ri.dds_shift)
else:
self.ui.writeTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(u'Error writting test comb')
logging.warning('Error writting test comb')
except KeyboardInterrupt:
self.ui.writeTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(u'Error writting test comb')
logging.warning('Error writting test comb')
def test_udp(self, event):
w = QMessageBox()
self.ui.setEnabled(False)
self.ui.statusbar.showMessage(u'Starting UDP test ... ')
QMessageBox.information(w, "UDP test", "Starting UDP test ...")
if self.fpga:
if (self.udp.testDownlink(5) < 0):
self.ui.udpTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(u'Error receiving data.')
logging.warning(
"Error receiving data. Check ethernet configuration.")
else:
self.ui.udpTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
self.statusNet = 0
self.ui.statusbar.showMessage(u'Test successful!')
logging.warning("Test successful. Connections are working.")
self.fpga.write_int(self.regs['write_stream_status_reg'], 1)
else:
self.ui.udpTestBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusNet = 1
self.ui.statusbar.showMessage(u'Error receiving data.')
logging.warning("Error receiving data. Check ROACH connection.")
self.ui.setEnabled(True)
def start_plot_VNA(self, event):
self.plotVNASweep(str(np.load("last_vna_dir.npy")))
def start_VNA_sweep(self, event):
self.vnaSweep(self.ri, self.udp, None)
def vna_sweep_dirfile(self,
center_freq=None,
save_path='./vna_sweeps',
write=None,
sweep_dir=None,
randomiser=0,
samples_per_point=10,
num_tones=256,
sweep_step=2.5e3,
adjust_sideband_leakage=True,
auto_fullscale=False,
remove_cryostat_input_s21=True,
remove_electronics_input_response=True,
plot=True,
gains=None,
step_sleep=0.1):
write = self.ui.writeTones.isChecked()
startVNA = np.float(self.ui.startEdit.toPlainText()) * 1.0e6
stopVNA = np.float(self.ui.stopEdit.toPlainText()) * 1.0e6
center_freq = np.float(self.ui.centralEdit.toPlainText()) * 1.0e6
sweep_step = np.float(self.ui.stepEdit.toPlainText()) * 1.0e6
num_tones = int(self.ui.nTonesEdit.toPlainText())
save_path = os.path.join(save_path, sweep_dir)
bb_freqs, delta_f = np.linspace(startVNA,
stopVNA,
num_tones,
retstep=True)
if randomiser is not None:
bb_freqs += randomiser
for ch in range(len(bb_freqs) - 1):
#if np.round(abs(bb_freqs[ch]),-3) in np.around(bb_freqs[ch+1:],-3):
# AQUI VAMOS *******************************************************************
if (np.around(abs(bb_freqs[ch]) / self.dac_freq_res)
) * self.dac_freq_res in np.around(
bb_freqs[ch + 1:] / self.dac_freq_res) * self.dac_freq_res:
#print '*****FOUND******'
bb_freqs[ch] += 2 * self.dac_freq_res
bb_freqs = np.roll(bb_freqs, -np.argmin(np.abs(bb_freqs)) - 1)
np.save('./last_bb_freqs.npy', bb_freqs)
rf_freqs = bb_freqs + center_freq
np.save('./last_rf_freqs.npy', rf_freqs)
channels = np.arange(len(rf_freqs))
np.save('./last_channels.npy', channels)
#self.v.setFrequencyFast(0,center_freq , 0.01) # LO
#self.vLO.frequency = center_freq
self.v.setFrequencyFast(center_freq)
print '\nVNA baseband freqs (MHz) =', bb_freqs / 1.0e6
print '\nVNA RF freqs (MHz) =', rf_freqs / 1.0e6
if write == 'y' or write is True:
self.writeQDR(bb_freqs,
adjust_sideband_leakage=adjust_sideband_leakage,
auto_fullscale=auto_fullscale,
remove_cryostat_input_s21=remove_cryostat_input_s21,
remove_electronics_input_response=
remove_electronics_input_response,
lo_frequency=center_freq,
gains=gains)
self.fpga.write_int('sync_accum_reset', 0)
self.fpga.write_int('sync_accum_reset', 1)
f, i, q = self.sweep_lo_dirfile(Npackets_per=samples_per_point,
channels=channels,
center_freq=center_freq,
span=delta_f,
save_path=save_path,
bb_freqs=bb_freqs,
step=sweep_step,
sleep=step_sleep)
last_vna_dir = save_path
np.save('./last_vna_dir.npy', np.array([last_vna_dir]))
np.save('./last_vna_sweep.npy', np.array([f, i, q]))
#self.plot_kids(save_path = last_vna_dir, bb_freqs = bb_freqs, channels = channels)
if plot:
plt.figure('vna-sweep-dirfile')
for ch in channels:
plt.plot(f[ch], 10 * np.log10(i[ch]**2 + q[ch]**2))
plt.show()
return f, i, q
def vnaSweep(self, ri, udp, valon):
"""Does a wideband sweep of the RF band, saves data in vna_savepath
as .npy files
inputs:
roachInterface object ri
gbeConfig object udp
valon synth object valon
bool write: Write test comb before sweeping?
Navg = Number of data points to average at each sweep step"""
#Navg = np.int(gc[np.where(gc == 'Navg')[0][0]][1])
Navg = 10
if not os.path.exists(self.vna_savepath):
os.makedirs(self.vna_savepath)
sweep_dir = self.vna_savepath + '/' + \
str(int(time.time())) + '-' + time.strftime('%b-%d-%Y-%H-%M-%S') + '.dir'
os.mkdir(sweep_dir)
np.save("./last_vna_dir.npy", sweep_dir)
print sweep_dir
# *** Synthesizer ***
self.synthRF.setControlChannel(1)
self.synthRF.setFrequencyFast(self.center_freq)
span = self.ri.pos_delta
print "Sweep Span =", 2 * np.round(self.ri.pos_delta, 2), "Hz"
start = self.center_freq * 1.0e6 - (span)
stop = self.center_freq * 1.0e6 + (span)
sweep_freqs = np.arange(start, stop, self.lo_step)
sweep_freqs = np.round(sweep_freqs / self.lo_step) * self.lo_step
if not np.size(self.ri.freq_comb):
self.ri.makeFreqComb()
np.save(sweep_dir + '/bb_freqs.npy', self.ri.freq_comb)
np.save(sweep_dir + '/sweep_freqs.npy', sweep_freqs)
Nchan = len(self.ri.freq_comb)
if not Nchan:
Nchan = fpga.read_int(
self.regs[np.where(self.regs == 'read_comb_len_reg')[0][0]][1])
for freq in sweep_freqs:
print 'LO freq =', freq / 1.0e6
self.synthRF.setFrequencyFast(freq)
self.udp.saveSweepData(Navg,
sweep_dir,
freq,
Nchan,
skip_packets=10)
time.sleep(0.001)
self.synthRF.setFrequencyFast(self.center_freq)
return
def openStoredSweep(self, savepath):
"""Opens sweep data
inputs:
char savepath: The absolute path where sweep data is saved
ouputs:
numpy array Is: The I values
numpy array Qs: The Q values"""
files = sorted(os.listdir(savepath))
I_list, Q_list = [], []
for filename in files:
if filename.startswith('I'):
I_list.append(os.path.join(savepath, filename))
if filename.startswith('Q'):
Q_list.append(os.path.join(savepath, filename))
Is = np.array([np.load(filename) for filename in I_list])
Qs = np.array([np.load(filename) for filename in Q_list])
return Is, Qs
def plotVNASweep(self, path):
plt.figure()
Is, Qs = self.openStoredSweep(path)
sweep_freqs = np.load(path + '/sweep_freqs.npy')
bb_freqs = np.load(path + '/bb_freqs.npy')
rf_freqs = np.zeros((len(bb_freqs), len(sweep_freqs)))
for chan in range(len(bb_freqs)):
rf_freqs[chan] = (sweep_freqs + bb_freqs[chan]) / 1.0e6
Q = np.reshape(np.transpose(Qs), (len(Qs[0]) * (len(sweep_freqs))))
I = np.reshape(np.transpose(Is), (len(Is[0]) * (len(sweep_freqs))))
mag = np.sqrt(I**2 + Q**2)
mag = 20 * np.log10(mag / np.max(mag))
mag = np.concatenate((mag[len(mag) / 2:], mag[:len(mag) / 2]))
rf_freqs = np.hstack(rf_freqs)
rf_freqs = np.concatenate(
(rf_freqs[len(rf_freqs) / 2:], rf_freqs[:len(rf_freqs) / 2]))
plt.plot(rf_freqs, mag)
#plt.plot(mag)
plt.title(path, size=16)
plt.xlabel('frequency (MHz)', size=16)
plt.ylabel('dB', size=16)
plt.grid()
plt.tight_layout()
plt.savefig(os.path.join(path, 'vna_sweep.png'),
dpi=100,
bbox_inches='tight')
plt.show()
return
def upload_firmware(self, event):
w = QWidget()
self.ui.setEnabled(False)
QMessageBox.information(w, "ROACH Connection",
"Uploading firmware ...")
try:
if (self.ri.uploadfpg() < 0):
self.ui.upFirmBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusFirm = 1
QMessageBox.information(w, "ROACH Firmware",
"Firmware upload failed! :(")
else:
self.ui.upFirmBtn.setStyleSheet("""QWidget {
color: white;
background-color: green
}""")
self.statusFirm = 0
QMessageBox.information(w, "ROACH Firmware",
"Firmware uploaded successfuly! :)")
except:
QMessageBox.information(w, "ROACH Firmware",
"Firmware upload failed! :(")
self.ui.upFirmBtn.setStyleSheet("""QWidget {
color: white;
background-color: red
}""")
self.statusFirm = 1
self.ui.setEnabled(True)
def addmpl_homodyne(self, fig):
self.canvas_H = FigureCanvas(fig)
self.ui.MainPlot_2.addWidget(self.canvas_H)
self.canvas_H.draw()
self.toolbar_H = NavigationToolbar(self.canvas_H,
self,
coordinates=True)
self.ui.MainPlot_2.addWidget(self.toolbar_H)
def rmmpl_homodyne(self):
self.ui.MainPlot_2.removeWidget(self.canvas_H)
self.canvas_H.close()
self.ui.MainPlot_2.removeWidget(self.toolbar_H)
self.toolbar_H.close()
def addmpl_vna(self, fig):
self.canvas_V = FigureCanvas(fig)
self.ui.MainPlot.addWidget(self.canvas_V)
self.canvas_V.draw()
self.toolbar_V = NavigationToolbar(self.canvas_V,
self,
coordinates=True)
self.ui.MainPlot.addWidget(self.toolbar_V)
def rmmpl_vna(self):
self.ui.MainPlot.removeWidget(self.canvas_V)
self.canvas_V.close()
self.ui.MainPlot.removeWidget(self.toolbar_V)
self.toolbar_V.close()
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
QtCore.QObject.connect(self.scanButton,QtCore.SIGNAL('clicked()'), self.dispInstru)
QtCore.QObject.connect(self.connectButton,QtCore.SIGNAL('clicked()'), self.connectInstru)
QtCore.QObject.connect(self.configButton, QtCore.SIGNAL('clicked()'), self.loadConfigFile)
QtCore.QObject.connect(self.saveButton, QtCore.SIGNAL('clicked()'), self.handleSave)
QtCore.QObject.connect(self.modeComboBox, QtCore.SIGNAL('currentIndexChanged(const QString&)'), self.changeMode)
QtCore.QObject.connect(self.sweepButton, QtCore.SIGNAL('clicked()'), self.startSweep)
self.canvas = MyMplCanvas(self, width=5, height=4, dpi=100)
self.p = 0
self.mplvl.addWidget(self.canvas) #self.canvas.setParent(self.mplwindow)
self.toolbar = NavigationToolbar(self.canvas, self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
def dispInstru(self):
self.rm = visa.ResourceManager()
self.instrusList = self.rm.list_resources()
print self.instrusList
for i in range(len(self.instrusList)):
exec("self.instruCheckBox%s = QtGui.QCheckBox(self.verticalLayoutWidget)" % i)
exec("self.instruCheckBox%s.setText(self.instrusList[%s])" % (i,i))
exec("self.instruLayout.addWidget(self.instruCheckBox%s)" % i)
def loadConfigFile(self):
self.listWidget.addItem('Assign success')
f = open('configure','r')
lines = f.readlines()
self.configMap = {}
for line in lines:
line = line.strip()
IDN, instruName= line.split(' ')
self.configMap[IDN] = instruName
def connectInstru(self):
self.listWidget.addItem('Connect success')
self.instruMap = {}
self.instruObj = []
for i in range(len(self.instrusList)):
exec("a = self.instruCheckBox%s.isChecked()" % i)
if a:
instruName = self.configMap[self.instrusList[i]]
self.instruMap[i] = instruName
self.instruObj.append(self.rm.open_resource(self.instrusList[i]))
for i in range(len(self.instruObj)):
if self.instruMap[i] == '2400':
self.instruObj[i].write("*RST")
self.instruObj[i].write("*CLS")
self.instruObj[i].write("*RCL 0")
if self.instruMap[i] == '2636' or self.instruMap[i] == '2635A':
self.instruObj[i].write("reset()")
self.instruObj[i].write("*CLS")
def handleSave(self):
path = QtGui.QFileDialog.getSaveFileName(self, 'Save File', '', 'CSV(*.csv)')
if not path.isEmpty():
with open(unicode(path), 'wb') as stream:
writer = csv.writer(stream)
for row in range(self.tableWidget.rowCount()):
rowdata = []
for column in range(self.tableWidget.columnCount()):
item = self.tableWidget.item(row, column)
if item is not None:
rowdata.append(unicode(item.text()).encode('utf8'))
else:
rowdata.append('')
print rowdata
writer.writerow(rowdata)
def changeMode(self):
if self.modeComboBox.currentText() == 'Voltage Sweep':
self.startLabel = QtGui.QLabel('')
self.startLabel.setText('Start')
self.startLabel.setStyleSheet("font: 18pt \"Helvetica\";\n""border-color: rgb(0, 0, 0);")
self.startLineEdit = QtGui.QLineEdit()
self.paraLayout.addRow(self.startLabel,self.startLineEdit)
self.stepLabel = QtGui.QLabel('')
self.stepLabel.setText('Step')
self.stepLabel.setStyleSheet("font: 18pt \"Helvetica\";\n""border-color: rgb(0, 0, 0);")
self.stepLineEdit = QtGui.QLineEdit()
self.paraLayout.addRow(self.stepLabel,self.stepLineEdit)
self.stopLabel = QtGui.QLabel('')
self.stopLabel.setText('Stop')
self.stopLabel.setStyleSheet("font: 18pt \"Helvetica\";\n""border-color: rgb(0, 0, 0);")
self.stopLineEdit = QtGui.QLineEdit()
self.paraLayout.addRow(self.stopLabel,self.stopLineEdit)
self.complianceLabel = QtGui.QLabel('')
self.complianceLabel.setText('Compliance')
self.complianceLabel.setStyleSheet("font: 18pt \"Helvetica\";\n""border-color: rgb(0, 0, 0);")
self.complianceLineEdit = QtGui.QLineEdit()
self.paraLayout.addRow(self.complianceLabel,self.complianceLineEdit)
self.delayLabel = QtGui.QLabel('')
self.delayLabel.setText('Delay')
self.delayLabel.setStyleSheet("font: 18pt \"Helvetica\";\n""border-color: rgb(0, 0, 0);")
self.delayLineEdit = QtGui.QLineEdit()
self.paraLayout.addRow(self.delayLabel,self.delayLineEdit)
def startSweep(self):
self.onStart()
# if self.modeComboBox.currentText == 'Voltage Sweep':
# compliance = int(self.complianceLineEdit.getText())
# start = int(self.startLineEdit.getText())
# stop = int(self.stopLineEdit.getText())
# step = int(self.stepLineEdit.getText())
# pointsNum = (stop-start)/step + 1
# i = self.instruMap.keys()[self.instruMap.values().index('2400')]
# self.instruObj[i].write("*RST") #restore GPIB default conditions
# self.instruObj[i].write(":SOUR:FUNC VOLT") #source is voltage
# self.instruObj[i].write(":SENS:FUNC 'CURR:DC") #sense is Current
# self.instruObj[i].write(":SENS:CURR:PROT %d" % compliance) #voltage protection
# self.instruObj[i].write(":SOUR:VOLT:START %f" % start)
# self.instruObj[i].write(":SOUR:VOLT:STOP %f" % stop)
# self.instruObj[i].write(":SOUR:VOLT:STEP %f" % step)
# self.instruObj[i].write(":SOUR:VOLT:MODE SWE") # sweep mode
# self.instruObj[i].write(":SOUR:SWE:RANGE AUTO") #auto source ranging
# self.instruObj[i].write(":SOUR:SWE:SPAC LIN") #select linear staricase sweep
# self.instruObj[i].write(":TRIG:COUNT %d" % pointsNum)
# self.instruObj[i].write(":SOUR:DEL 0.1")
# self.instruObj[i].write(":FORM:ELEM CURR") #current reading only
# self.instruObj[i].write(":OUTP ON")
# self.instruObj[i].write(":READ?")
# aa = self.instruObj[i].read()
def onStart(self):
self.x = []
self.y = []
self.canvas.axes.set_autoscalex_on(True)
self.line, = self.canvas.axes.plot(self.x,self.y)
timer = QtCore.QTimer(self)
timer.timeout.connect(self.run)
timer.start(10)
#self.line, = self.canvas.axes.plot(self.x, self.y, animated=True, lw=2)
#self.ani = animation.FuncAnimation(self.canvas.figure,self.run,self.data_gen, blit=True, interval = 100)
# def data_gen(self):
# while True:
# self.p = -1*self.p
# t = max(self.x) + 1
# y = np.sin(t)
# yield t,y
def run(self):
newx = max(self.x) + 1
self.x.append(newx)
self.y = np.sin(self.x)
self.line.set_data(self.x, self.y)
xmin,xmax = self.canvas.axes.get_xlim()
ymin,ymax = self.canvas.axes.get_ylim()
self.canvas.axes.figure.canvas.draw()
if newx >= xmax:
xmax = 2*xmax
self.canvas.axes.set_xlim(0,xmax)
self.canvas.axes.figure.canvas.draw()
QtGui.qApp.processEvents() #update the window to see the new x scale !important canvas.draw() must go before this line
self.tableWidget.insertRow(self.p)
self.tableWidget.setItem(self.p,0,QtGui.QTableWidgetItem(datetime.now().strftime("%H:%M:%S.%f")))
self.tableWidget.setItem(self.p,1,QtGui.QTableWidgetItem(str(newx)))
self.tableWidget.setItem(self.p,2,QtGui.QTableWidgetItem(str(self.y[-1])))
self.p += 1
# newx, newy = data
# self.x.append(newx)
# self.y = np.sin(self.x)
# self.line.set_data(self.x, self.y)
# xmin,xmax = self.canvas.axes.get_xlim()
# ymin,ymax = self.canvas.axes.get_ylim()
# if newx >= xmax:
# xmax = 2*xmax
# self.canvas.axes.set_xlim(0,xmax)
# self.canvas.axes.figure.canvas.draw()
# QtGui.qApp.processEvents() #update the window to see the new x scale !important canvas.draw() must go before this line
# return self.line,
# self.fig_dict = {}
# self.mplfigs.itemClicked.connect(self.addNumber)
# def addNumber(self, item):
# text = str(item.text())
# self.rmmpl()
# self.addmpl(self.fig_dict[text])
# def addfig(self, name, fig):
# self.fig_dict[name] = fig
# self.mplfigs.addItem(name)
def init(self):
self.x.append(1)
self.x.append(2)
self.y.append(4)
self.y.append(-5)
self.line.set_data(self.x, self.y)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
class MainWindow(QtGui.QMainWindow, form_class):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.cellpoints = np.array([])
self.FindCells.clicked.connect(self.Id_cells)
self.Classify.clicked.connect(self.start_clicked)
self.AddClassified.clicked.connect(self.create_csv)
self.validatebutton.clicked.connect(self.validateAutoClass)
self.imageviewbutton.clicked.connect(self.openMainFig)
self.autoClassButton.clicked.connect(self.AutoClassification)
self.Boxsize.setText("101")
self.fig = Figure()
self.THEimage = np.array([])
self.BLUEimage = 0
self.THEblobs = np.array([])
self.DatabaseSize.setText(str(len(glob.glob('singleCells/*.png'))))
self.table.setColumnCount(3)
self.layout.addWidget(self.table, 1, 0)
self.table.setHorizontalHeaderLabels(
['index', 'auto class', 'gold class'])
self.dirButton.clicked.connect(self.chooseDirectory)
self.directory = 'singleCells/'
self.saveDir.setText('singleCells/')
self.dirWindow.clicked.connect(self.openDIRwindow)
def openDIRwindow(self):
dirwindow = allDirectoriesWindow(self)
dirwindow.exec_()
def removeCell(self, cellnumber):
self.THEblobs[cellnumber:-1] = self.THEblobs[cellnumber + 1:]
self.THEblobs = self.THEblobs[:-1]
self.nMarkedCells.setText(str(int(self.nMarkedCells.text()) - 1))
self.table.removeRow(cellnumber)
for i in range(len(self.THEblobs)):
self.table.setItem(i, 0, QtGui.QTableWidgetItem(str(i)))
self.ImgAddPatches()
def chooseDirectory(self):
directory = QtGui.QFileDialog.getExistingDirectory(self)
self.saveDir.setText(str(directory) + '/')
self.DatabaseSize.setText(
str(len(glob.glob(str(self.saveDir.text()) + '*.png'))))
def create_csv(self):
savename = str(self.saveNames.text())
filenames = np.array([
savename + str(self.table.item(i, 0).text()) + '.png'
for i in range(int(self.nMarkedCells.text()))
])
#filenamesList = filenames.tolist()
classnames = np.array([
str(self.table.item(i, 2).text())
for i in range(int(self.nMarkedCells.text()))
])
classtable = pd.DataFrame(
np.transpose(np.vstack(
(filenames,
classnames)))) #, index=dates, columns=[nome , classe])
print(classtable)
saveclassification = classtable.to_csv(str(self.saveDir.text()) +
savename + 'class.csv',
index=False,
header=['file', 'class'])
self.DatabaseSize.setText(
str(len(glob.glob(str(self.saveDir.text()) + '*.png'))))
def save_crops(self):
squaresize = int(str(self.Boxsize.text()))
savename = str(self.saveNames.text())
blobs = self.THEblobs
for number, blob in enumerate(blobs):
y, x, r = blob
y = y + squaresize #adjusting centers
x = x + squaresize #DONT ASK ME WHY
crop = self.THEimage[int(y) - int(squaresize / 2):int(y) +
int(squaresize / 2),
int(x) - int(squaresize / 2):int(x) +
int(squaresize / 2)]
io.imsave(
str(self.saveDir.text()) + savename + str(number) + '.png',
crop)
def onclick(self, event):
print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' %
(event.button, event.x, event.y, event.xdata, event.ydata))
if event.button == 3:
squaresize = int(str(self.Boxsize.text()))
self.THEblobs = np.array(self.THEblobs.tolist() + [[
int(event.ydata - squaresize),
int(event.xdata - squaresize),
int(str(self.Boxsize.text()))
]])
print(self.THEblobs)
self.table.setHorizontalHeaderLabels(
['index', 'auto class', 'gold class'])
rowPosition = self.table.rowCount()
self.table.insertRow(rowPosition)
self.table.setItem(rowPosition, 0,
QtGui.QTableWidgetItem(str(rowPosition)))
self.table.setItem(rowPosition, 1, QtGui.QTableWidgetItem("-"))
self.table.setItem(rowPosition, 2, QtGui.QTableWidgetItem("-"))
self.nMarkedCells.setText(str(int(self.nMarkedCells.text()) + 1))
self.ImgAddPatches()
elif event.button == 2:
print(self.THEblobs[:, 0:2])
dist = np.sum(
(self.THEblobs[:, 0:2] + 101 - [event.ydata, event.xdata])**2,
1)
if min(dist) < 800:
line = dist.tolist().index(min(dist))
print(line)
self.removeCell(line)
def Id_cells(self):
squaresize = int(str(self.Boxsize.text()))
image_gray = self.BLUEimage
blobs = blob_dog(image_gray[squaresize:-squaresize,
squaresize:-squaresize],
min_sigma=10,
max_sigma=30,
threshold=.8)
self.THEblobs = blobs
self.nMarkedCells.setText(str(len(blobs)))
self.table.setRowCount(len(blobs))
self.table.setColumnCount(3)
self.layout.addWidget(self.table, 1, 0)
self.table.setHorizontalHeaderLabels(
['index', 'auto class', 'gold class'])
self.ImgAddPatches()
def ImgAddPatches(self):
squaresize = int(str(self.Boxsize.text()))
self.fig, ax = subplots(1, 1)
ax.imshow(self.THEimage)
ax.grid(False)
ax.axis('off')
for number, blob in enumerate(self.THEblobs):
y, x, r = blob
c = Rectangle((x + int(squaresize / 2), y + int(squaresize / 2)),
squaresize,
squaresize,
color='r',
linewidth=2,
alpha=0.3)
ax.add_patch(c)
ax.text(x + squaresize - 25,
y + squaresize + 25,
str(number),
color='white')
self.table.setItem(number, 0, QtGui.QTableWidgetItem(str(number)))
self.table.setItem(number, 1, QtGui.QTableWidgetItem('-'))
self.table.setItem(number, 2, QtGui.QTableWidgetItem('-'))
self.changeFIGURE(self.fig)
def openMainFig(self):
if self.THEimage.any() == True:
self.rmmpl()
self.THEimage = np.array([])
self.BLUEimage = 0
for i in range(len(self.THEblobs)):
self.table.removeRow(0)
self.nMarkedCells.setText(str(0))
self.THEblobs = np.array([])
name = QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)")
image = misc.imread(str(name))
self.saveNames.setText(str(name).split("/")[-1][:-4] + 'i')
self.THEimage = image
self.BLUEimage = image[:, :, 2]
baseimage = self.fig.add_subplot(111)
baseimage.axis('off')
baseimage.grid(False)
baseimage.imshow(image)
self.canvas = FigureCanvas(self.fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def changeFIGURE(self, newFIG):
self.rmmpl()
self.canvas = FigureCanvas(newFIG)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def start_clicked(self):
self.save_crops()
with open('bytemp', 'w') as f:
f.write(
str(self.saveNames.text()) + ',' +
str(self.nMarkedCells.text()) + ',' + str(self.saveDir.text()))
classwindow = ManualClassifyWindow(self)
classwindow.exec_()
with open('bytemp', 'r') as f:
classifiedCells = f.readline().split(',')[:-1]
self.MitoticIndex.setText(
str(classifiedCells.count('mitose')) + '/' + str(
classifiedCells.count('mitose') +
classifiedCells.count('interfase')))
for i, clasf in enumerate(classifiedCells):
self.table.setItem(i, 2, QtGui.QTableWidgetItem(clasf))
self.coloring_types(classifiedCells)
def coloring_types(self, cellClassList):
colors = ['b', 'g', 'r', 'c', 'm', 'y', 'w']
color_dict = dict(
zip([x[0] for x in Counter(cellClassList).most_common()], colors))
self.fig, ax = subplots(1, 1)
squaresize = int(str(self.Boxsize.text()))
ax.imshow(self.THEimage)
ax.grid(False)
ax.axis('off')
self.layout.addWidget(self.table, 1, 0)
for number, blob in enumerate(self.THEblobs):
y, x, r = blob
c = Rectangle((x + int(squaresize / 2), y + int(squaresize / 2)),
squaresize,
squaresize,
color=color_dict[cellClassList[number]],
linewidth=2,
alpha=0.3)
ax.add_patch(c)
ax.text(x + squaresize - 25,
y + squaresize + 25,
str(number),
color='white')
self.changeFIGURE(self.fig)
def validateAutoClass(self):
conta = 0
if str(
self.table.item(int(int(self.nMarkedCells.text()) / 2),
1).text()) != '-':
for i in range(int(self.nMarkedCells.text())):
if str(self.table.item(i, 1).text()) == str(
self.table.item(i, 2).text()):
conta += 1
print(conta / int(self.nMarkedCells.text()))
self.SucessRate.setText(
str(int(float(conta) / int(self.nMarkedCells.text()) * 100)) +
'%')
if str(
self.table.item(int(int(self.nMarkedCells.text()) / 2),
2).text()) == '-':
mitose = 0
interfase = 0
for i in range(int(self.nMarkedCells.text())):
self.table.setItem(
i, 2,
QtGui.QTableWidgetItem(str(self.table.item(i, 1).text())))
if str(self.table.item(i, 1).text()) == 'mitose': mitose += 1
elif str(self.table.item(i, 1).text()) == 'interfase':
interfase += 1
self.MitoticIndex.setText(
str(mitose) + '/' + str(mitose + interfase))
def AutoClassification(self):
self.save_crops()
#open images
training = pd.DataFrame()
testImg = pd.DataFrame()
list_ = []
allFiles = glob.glob(str(self.saveDir.text()) + "*.csv")
for file_ in allFiles:
df = pd.read_csv(file_, index_col=None, header=0)
list_.append(df)
training = pd.concat(list_)
training["photo"] = training.file.apply(
lambda x: misc.imread(str(self.saveDir.text()) + x))
training["photo"] = training.photo.apply(rgb2gray)
training["photo"] = training.photo.apply(exposure.equalize_adapthist)
testImg["files"] = glob.glob(
str(self.saveDir.text()) + str(self.saveNames.text()) + "*.png")
testImg["photo"] = [
misc.imread(x) for x in glob.glob(
str(self.saveDir.text()) + str(self.saveNames.text()) +
"*.png")
]
testImg["photo"] = testImg.photo.apply(rgb2gray)
testImg["photo"] = testImg.photo.apply(exposure.equalize_adapthist)
# Rotate training images
def rotate(df, degrees):
result = df.copy()
result.photo = result.photo.apply(
lambda x: transform.rotate(x, degrees))
return result
number_of_rotations = 20
orig_training = training.copy()
for i in [(360. / number_of_rotations) * (i + 1)
for i in range(number_of_rotations)]:
training = pd.concat((training, rotate(orig_training, i)))
# Initialize features with texture values
train_feats = np.array(
[x for x in training.photo.apply(texture).values])
print(train_feats)
Y_training = training["class"].values
testImg_feats = np.array(
[x for x in testImg.photo.apply(texture).values])
# Add dispersion ratios to features
training["dispersion"] = training.photo.apply(dispersionratio)
train_feats = np.hstack(
(train_feats, np.array([x for x in training["dispersion"].values
]).reshape(-1, 1)))
testImg["dispersion"] = testImg.photo.apply(dispersionratio)
testImg_feats = np.hstack(
(testImg_feats, np.array([x for x in testImg["dispersion"].values
]).reshape(-1, 1)))
# Apply FFT to photos (does NOT add to features yet)
training["FFT"] = training.photo.apply(fft.fft2)
training["FFT"] = training.FFT.apply(abs)
training["Phase"] = training.FFT.apply(np.angle)
testImg["FFT"] = testImg.photo.apply(fft.fft2)
testImg["FFT"] = testImg.FFT.apply(abs)
testImg["Phase"] = testImg.FFT.apply(np.angle)
# Dimensionality reduction on the FFTs
pca = PCA(n_components=15)
pcb = PCA(n_components=15)
fabsPCA = pca.fit(vectorize(training["FFT"]))
fphiPCA = pcb.fit(vectorize(training["Phase"]))
#Adding ffts to feature set
train_feats_final = np.hstack(
(train_feats, fphiPCA.transform(vectorize(training["Phase"])),
fabsPCA.transform(vectorize(training["FFT"]))))
testImg_feats_final = np.hstack(
(testImg_feats, fphiPCA.transform(vectorize(testImg["Phase"])),
fabsPCA.transform(vectorize(testImg["FFT"]))))
train_feats_final = normalize_columns(train_feats_final)
testImg_feats_final = normalize_columns(testImg_feats_final)
clf = RandomForestClassifier(n_estimators=9)
print(len(train_feats_final), len(Y_training))
clf.fit(np.nan_to_num(train_feats_final), np.nan_to_num(Y_training))
Y_predict = clf.predict(np.nan_to_num(testImg_feats_final))
for number, cellclass in enumerate(Y_predict):
self.table.setItem(number, 1,
QtGui.QTableWidgetItem(str(cellclass)))
self.coloring_types(Y_predict)
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
fig = Figure()
self.addmpl(fig)
self.rdBtn.clicked.connect(self.read)
self.df = {}
self.dfList.itemDoubleClicked.connect(self.df_selected)
self.colList.itemDoubleClicked.connect(self.addcol)
self.stgList.itemDoubleClicked.connect(self.rmvcol)
def read(self):
try:
self.df[str(self.inp.text()).split('.')[0]] = pd.read_csv(
str(self.inp.text()))
self.dfList.addItem(str(self.inp.text()).split('.')[0])
print('File read')
except IOError:
print('No such file')
def df_selected(self):
if self.colList.count() == 0:
self.colList.addItems(self.df[str(
self.dfList.currentItem().text())].columns)
else:
self.colList.clear()
self.stgList.clear()
self.colList.addItems(self.df[str(
self.dfList.currentItem().text())].columns)
def addcol(self):
items = [
self.stgList.item(i).text() for i in xrange(self.stgList.count())
]
print items
if str(self.colList.currentItem().text()) not in items:
self.stgList.addItem(str(self.colList.currentItem().text()))
def rmvcol(self):
self.stgList.takeItem(self.stgList.row(self.stgList.currentItem()))
def clear(self):
self.mplfigs.clear()
self.rmmpl()
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(
self.canvas,
self.mplwindow,
coordinates=True,
)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
class Main(QMainWindow, Ui_MainWindow):
# Define plate arrays as global variables to be able use them elsewhere in the program.
global w_plate
global mx_plate
global my_plate
global qx_plate
global qy_plate
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.btnPlot.setStyleSheet('color: red')
self.textEdit.setTextColor(QtGui.QColor("magenta"))
# Check deflections radio button by default
self.deflections_radio.setChecked(False)
# Creating a QButtonGroup and adding the plot options ratio buttons.
# This will be used to make sure new results are plotted every time the solve button is pressed.
# Otherwise, if the deflections radio button is already selected, new run won't plot results.
self.group = QtGui.QButtonGroup()
self.group.addButton(self.deflections_radio)
self.group.addButton(self.mx_radio)
self.group.addButton(self.my_radio)
self.group.addButton(self.qx_radio)
self.group.addButton(self.qy_radio)
self.plot_options_group.setEnabled(False)
self.infoLabel.setStyleSheet('color: blue')
self.infoLabel.setText(' Theory of Plates and Shells\n' +
' Süleyman Muti\n' +
' Spring 2016')
self.btnPlot.clicked.connect(lambda: self.fdm())
self.deflections_radio.toggled.connect(lambda: self.deflections_radio_checked())
self.mx_radio.toggled.connect(lambda: self.mx_radio_checked())
self.my_radio.toggled.connect(lambda: self.my_radio_checked())
self.qx_radio.toggled.connect(lambda: self.qx_radio_checked())
self.qy_radio.toggled.connect(lambda: self.qy_radio_checked())
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def get_grid_size(self):
if self.rBtn15x10.isChecked():
return 15, 1e-6
if self.rBtn30x20.isChecked():
return 30, 1e-6
elif self.rBtn180x120.isChecked():
return 180, 1e-7
elif self.rBtn540x360.isChecked():
return 540, 1e-9
def deflections_radio_checked(self):
if self.deflections_radio.isChecked():
self.rmmpl()
self.print_plot(w_plate, 'Plate Deflections', 'viridis')
def mx_radio_checked(self):
if self.mx_radio.isChecked():
self.rmmpl()
self.print_plot(mx_plate, 'Mx Bending Moment', 'plasma')
def my_radio_checked(self):
if self.my_radio.isChecked():
self.rmmpl()
self.print_plot(my_plate, 'My Bending Moment', 'plasma')
def qx_radio_checked(self):
if self.qx_radio.isChecked():
self.rmmpl()
self.print_plot(qx_plate, 'Qx Transverse Shear Force', 'inferno')
def qy_radio_checked(self):
if self.qy_radio.isChecked():
self.rmmpl()
self.print_plot(qy_plate, 'Qy Transverse Shear Force', 'inferno')
def print_plot(self, array_to_be_plotted, plot_title, colormap):
a = array_to_be_plotted
self.rmmpl()
fig = Figure()
self.addmpl(fig)
ax = fig.add_subplot(111)
cax = ax.imshow(a, cmap=colormap)
fig.colorbar(cax, shrink=0.6, aspect=5)
fig.tight_layout()
ax.set_title(plot_title, fontsize=20, y=1.01)
ax.axes.get_xaxis().set_ticks([])
ax.axes.get_yaxis().set_ticks([])
ax.format_coord = lambda x, y: ''
ax.set_xlabel('300 mm', fontsize=20, rotation=0)
ax.set_ylabel('200 mm', fontsize=20, rotation=90)
ax.autoscale(False)
plt.show()
def print_info(self, grid_size):
grid_string = 'Grid size: {:d} x {:d}'.format(grid_size, grid_size*2//3)
deflection_string = 'Maximum deflection of the plate: {0:.4f} mm'.format(np.max(w_plate))
moment_string = 'Max. Mx: {:.4f} Nmm/mm \t Max. My: {:.4f} Nmm/mm'.format(np.max(mx_plate), np.max(my_plate))
shear_string = 'Max. Qx: {:.4f} N/mm \t Max. Qy: {:.4f} N/mm'.format(np.max(qx_plate),
np.max(qy_plate))
self.textEdit.setText(grid_string + '\n' + deflection_string + '\n' + moment_string + '\n' + shear_string)
def fdm(self):
# Let the function fdm() know that the plate arrays are global variables and can be used outside its scope.
global w_plate
global mx_plate
global my_plate
global qx_plate
global qy_plate
# Enabling initially disabled plot options area which was disabled to prevent
# plot attempts without array creations.
self.plot_options_group.setEnabled(True)
# Deselecting the deflections radio button to make sure new results always get plotted.
self.group.setExclusive(False)
self.deflections_radio.setChecked(False)
self.group.setExclusive(True)
dim_x = 300 # Plate length in x-direction [mm]
# dim_y = 200 # Plate length in y-direction [mm]
# Use Python tuple to get the number of elements in the x-direction and corresponding convergence criterion.
(m, conv) = self.get_grid_size()
n = m * 2 // 3 # Number of elements in the y-direction.
# Element size
delta = dim_x / m
# Initialize matrices for iterative solution.
w_old = np.zeros((m + 3, n + 3)) # Initialize plate deflections to zero.
w = np.copy(w_old)
m1 = np.zeros((m + 3, n + 3))
m2 = np.zeros((m + 3, n + 3))
qx = np.zeros((m + 3, n + 3))
qy = np.zeros((m + 3, n + 3))
# Material properties, loading, and other properties
e = 70000 # Modulus of elasticity [N/mm2]
nu = 0.3 # Poisson's ratio
h = 2 # Plate thickness [mm]
po = 0.01 # Distributed load [N/mm2]
# Plate stiffness
d = (e * (h ** 3)) / (12 * (1.0 - (nu ** 2)))
# Distributed load
p = (po * (delta ** 4)) / d
# Set logical condition to check if convergence criterion is met.
cond = False # Set to false to initiate iteration loop.
# Loop to iterate plate deflections using Finite Difference Method
iteration_number = 0 # Keep an eye on the iteration number.
while not cond:
cond = True # set to true to check if criterion is met for all nodes.
# Apply boundary conditions. Simply supported on all edges.
w[:, 0] = -w_old[:, 2]
w[:, n + 2] = -w_old[:, n]
w[0, :] = -w_old[2, :]
w[m + 2, :] = -w_old[m, :]
# Calculate deflection of each node using neighbouring nodes
# (i.e., using FDM)
# Python range() statement is seemingly upper-bound exclusive. We need to add 1 to cover all range.
for i in range(2, m + 1):
# Check if the current index point has distributed load acting on it. If so apply the load, if not let it be zero.
if i <= (m / 2 + 1):
k = p
else:
k = 0
for j in range(2, n + 1):
# Finite Difference Method Formula: v4 = p/d
w[i, j] = (1 / 20) * (k + 8 * (w[i + 1, j] + w[i - 1, j] + w[i, j + 1] + w[i, j - 1]) - 2 * (
w[i + 1, j + 1] + w[i - 1, j + 1] + w[i + 1, j - 1] + w[i - 1, j - 1]) - w[i + 2, j] - w[
i - 2, j] - w[
i, j + 2] - w[i, j - 2])
# Check if convergence criterion is met for each node. Set logical condition
# to false even if a single node violates the the condition so that the
# iteration can continue until all nodes meet the criterion.
if abs(w[i, j] - w_old[i, j]) > conv:
cond = False
# Reset deflection matrices for next iteration.
w_old = np.copy(w)
# Keep an eye on the iteration number.
iteration_number += 1
# Calculate the bending moments and transverse shear forces based on the deflections.
for i in range(2, m + 1):
for j in range(2, n + 1):
# Common terms in bending moment equations.
m1[i, j] = -(w[i+1, j] - 2*w[i, j] + w[i-1, j])*d/delta**2
m2[i, j] = -(w[i, j+1] - 2*w[i, j] + w[i, j-1])*d/delta**2
# Transverse shear forces.
qx[i, j] = -((w[i+2, j] - 2*w[i+1, j] + 2*w[i-1, j] - w[i-2, j]) +
(w[i+1, j+1] - 2*w[i+1, j] + w[i+1, j-1] - w[i-1, j+1] +
2*w[i-1, j] - w[i-1, j-1])) * d / (2*delta ** 3)
qy[i, j] = -((w[i+1, j+1] - 2*w[i, j+1] + w[i-1, j+1] - w[i+1, j-1] + 2*w[i, j-1] - w[i-1, j-1]) +
(w[i, j+2] - 2*w[i, j+1] + 2*w[i, j-1] - w[i, j-2])) * d / (2*delta ** 3)
# Assemble bending moment arrays.
mx = m1 + nu*m2
my = m2 + nu*m1
# Exclude the ghost nodes that were necessary to apply boundary conditions,
# and obtain deflections for plate nodes only. Plate deflections will be plotted correcting the orientation.
w_plate = w[1:m + 2, 1:n + 2].transpose()
mx_plate = mx[1:m + 2, 1:n + 2].transpose()
my_plate = my[1:m + 2, 1:n + 2].transpose()
qx_plate = qx[1:m + 2, 1:n + 2].transpose()
qy_plate = qy[1:m + 2, 1:n + 2].transpose()
# Set deflections radio button to checked to display the new run's results.
self.deflections_radio.setChecked(True)
# Print information summarizing the solution
# Maximum deflection, maximum bending moments, and maximum shear forces
self.print_info(m)
class MainWindodw(QMainWindow, Ui_MainWindow):
"""main window of application"""
def __init__(self):
super(MainWindodw, self).__init__()
self.setupUi(self)
self.isTrigMode = False
self.isRunMode = False
self.button_list = [self.run_radio_button,
self.trig_radio_button,
self.run_push_button]
self.data = []
self.freq = []
self.res = []
# implement button's function
self.trig_radio_button.clicked.connect(self.trig_toggled)
self.run_radio_button.clicked.connect(self.run_toggled)
self.run_push_button.clicked.connect(self.run_pushed)
self.stop_push_button.clicked.connect(self.stop_pushed)
self.saveraw_push_button.clicked.connect(self.saveraw_pushed)
self.savefft_push_button.clicked.connect(self.savefft_pushed)
# add empty plot
fig1 = Figure()
axfig1 = fig1.add_subplot(111)
axfig1.plot()
self.add_rawmpl(fig1)
fig2 = Figure()
axfig2 = fig2.add_subplot(111)
axfig2.plot()
self.add_fftmpl(fig2)
thread = QtCore.QThread()
self.reader = SerialReader()
self.reader.moveToThread(thread)
self.reader.sig_status.connect(self.serial_plot)
self.reader.sig_termino.connect(self.enable_button)
def add_rawmpl(self, fig):
self.raw_canvas = FigureCanvas(fig)
self.vl_raw.addWidget(self.raw_canvas)
self.raw_canvas.draw()
self.raw_toolbar = NavigationToolbar(self.raw_canvas,
self, coordinates=True)
self.vl_raw.addWidget(self.raw_toolbar)
def add_fftmpl(self, fig):
self.fft_canvas = FigureCanvas(fig)
self.vl_fft.addWidget(self.fft_canvas)
self.fft_canvas.draw()
self.fft_toolbar = NavigationToolbar(self.fft_canvas,
self, coordinates=True)
self.vl_fft.addWidget(self.fft_toolbar)
def remove_rawmpl(self):
self.vl_raw.removeWidget(self.raw_canvas)
self.raw_canvas.close()
self.vl_raw.removeWidget(self.raw_toolbar)
self.fft_toolbar.close()
def remove_fftmpl(self):
self.vl_fft.removeWidget(self.fft_canvas)
self.fft_canvas.close()
self.vl_fft.removeWidget(self.fft_toolbar)
self.fft_toolbar.close()
def trig_toggled(self):
print('trig is toggled')
self.isTrigMode = True
self.isRunMode = False
def run_toggled(self):
print('run is toggled')
self.isTrigMode = False
self.isRunMode = True
def run_pushed(self):
if self.isTrigMode: self.reader.mode = b't'
elif self.isRunMode: self.reader.mode = b'r'
else:
self.errorDialog('Select Mode')
return
self.disable_button()
self.reader.run()
time.sleep(5)
def stop_pushed(self):
self.reader.stop()
self.reader.serial_close()
def saveraw_pushed(self):
if not self.data:
self.errorDialog('No measurement')
return
filepath = QtGui.QFileDialog.getSaveFileName(filter='*.dat')[0]
with open(filepath, 'w') as f:
for item in self.data:
f.write(str(item) + '\n')
def savefft_pushed(self):
if not self.freq:
self.errorDialog('No measurement')
return
filepath = QtGui.QFileDialog.getSaveFileName(filter='*.dat')[0]
with open(filepath, 'w') as f:
for fre, res in zip(self.freq, self.res):
f.write(str(fre) + ' ' + str(res) + '\n')
def serial_plot(self, data):
self.remove_rawmpl()
self.remove_fftmpl()
self.data = data
self.freq, self.res = sig_fft(data, 1.0/20000)
fig1 = Figure()
axfig1 = fig1.add_subplot(111)
axfig1.plot(self.data)
fig2 = Figure()
axfig2 = fig2.add_subplot(111)
axfig2.plot(self.freq, self.res)
self.add_rawmpl(fig1)
self.add_fftmpl(fig2)
def enable_button(self):
for btn in self.button_list:
btn.setEnabled(True)
def disable_button(self):
for btn in self.button_list:
btn.setEnabled(False)
def errorDialog(self, message):
e = QtGui.QErrorMessage()
e.showMessage(message)
e.exec_()
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
fig = Figure()
self.addmpl(fig)
self.rdBtn.clicked.connect(self.read)
self.pltBtn.clicked.connect(self.plot)
self.df = {}
self.dfList.itemDoubleClicked.connect(self.df_selected)
self.colList.itemDoubleClicked.connect(self.addcol)
self.stgList.itemDoubleClicked.connect(self.rmvcol)
self.plotList.itemDoubleClicked.connect(self.show_fig)
self.currentDF = None
self.current_name = None
self.plots = {}
self.plotBox.addItems(['histogram', 'plot', 'scatter'])
self.selection = "None"
self.aBtn.clicked.connect(self.spawn_child)
def spawn_child(self):
sec = Sec(self)
sec.show()
def read(self):
try:
lista = [
str(self.dfList.item(i).text())
for i in xrange(self.dfList.count())
]
if str(self.inp.text()).split('.')[0] not in lista:
self.df[str(self.inp.text()).split('.')[0]] = pd.read_csv(
str(self.inp.text()))
self.dfList.addItem(str(self.inp.text()).split('.')[0])
except IOError:
print('No such file')
def df_selected(self):
self.current_name = str(self.dfList.currentItem().text())
self.currentDF = self.df[self.current_name]
self.filterBox.clear()
self.filterBox.addItem("None")
self.plotList.clear()
self.rmmpl()
if self.current_name in self.plots.keys():
self.plotList.addItems(self.plots[self.current_name].keys())
self.filterBox.addItems(self.df[str(
self.dfList.currentItem().text())].columns)
if self.colList.count() == 0:
self.colList.addItems(self.df[str(
self.dfList.currentItem().text())].columns)
else:
self.colList.clear()
self.stgList.clear()
self.colList.addItems(self.df[str(
self.dfList.currentItem().text())].columns)
def addcol(self):
items = [
self.stgList.item(i).text() for i in xrange(self.stgList.count())
]
if str(self.colList.currentItem().text()) not in items:
self.stgList.addItem(str(self.colList.currentItem().text()))
def plot(self):
if self.currentDF is None:
return
items = [
str(self.stgList.item(i).text())
for i in xrange(self.stgList.count())
]
# here goes some logic to create different plots depending on the
# selection of plotBox
self.selection = str(self.filterBox.currentText())
if self.selection == "None":
if str(self.plotBox.currentText()) == 'scatter':
if self.stgList.count() != 2:
raise TypeError('Select just two columns')
else:
if self.current_name not in self.plots.keys():
generated_plot = {}
col1 = str(self.stgList.item(0).text())
col2 = str(self.stgList.item(1).text())
data1 = self.currentDF[col1].values
data2 = self.currentDF[col2].values
f, ax = plt.subplots()
ax.scatter(data1, data2, alpha=0.5)
ax.set(xlabel=col1, ylabel=col2)
ax.set_title(col1 + ' vs ' + col2)
generated_plot[col1 + ';' + col2 + ' ' +
str(self.plotBox.currentText())] = f
self.plots[self.current_name] = generated_plot
else:
col1 = str(self.stgList.item(0).text())
col2 = str(self.stgList.item(1).text())
data1 = self.currentDF[col1].values
data2 = self.currentDF[col2].values
f, ax = plt.subplots()
ax.scatter(data1, data2, alpha=0.5)
ax.set(xlabel=col1, ylabel=col2)
ax.set_title(col1 + ' vs ' + col2)
self.plots[self.current_name][
col1 + ';' + col2 + ' ' +
str(self.plotBox.currentText())] = f
elif str(self.plotBox.currentText()) == 'plot':
if self.current_name not in self.plots.keys():
generated_plots = {}
for col in items:
f, ax = plt.subplots()
self.currentDF[col].plot(ax=ax)
ax.set(ylabel=col, xlabel='index')
ax.set_title(col + ' Plot')
generated_plots[col + ' ' +
str(self.plotBox.currentText())] = f
self.plots[self.current_name] = generated_plots
else:
for col in items:
f, ax = plt.subplots()
self.currentDF[col].plot(ax=ax)
ax.set(ylabel=col, xlabel='index')
ax.set_title(col + ' Plot')
self.plots[self.current_name][col + ' ' + str(
self.plotBox.currentText())] = f
elif str(self.plotBox.currentText()) == 'histogram':
if self.current_name not in self.plots.keys():
generated_plots = {}
for col in items:
f, ax = plt.subplots()
self.currentDF[col].hist(ax=ax)
ax.set(xlabel=col, ylabel='count')
ax.set_title('Histogram of ' + col)
generated_plots[col + ' ' +
str(self.plotBox.currentText())] = f
self.plots[self.current_name] = generated_plots
else:
for col in items:
f, ax = plt.subplots()
self.currentDF[col].hist(ax=ax)
ax.set(xlabel=col, ylabel='count')
ax.set_title('Histogram of ' + col)
self.plots[self.current_name][col + ' ' + str(
self.plotBox.currentText())] = f
else:
if str(self.plotBox.currentText()) == 'scatter':
if self.stgList.count() != 2:
raise TypeError('Select just two columns')
else:
if self.current_name not in self.plots.keys():
f, ax = plt.subplots()
for value in self.currentDF[self.selection].unique():
filtered_df = self.currentDF[self.currentDF[
self.selection] == value]
generated_plot = {}
col1 = str(self.stgList.item(0).text())
col2 = str(self.stgList.item(1).text())
data1 = filtered_df[col1].values
data2 = filtered_df[col2].values
ax.scatter(data1,
data2,
label=str(value),
alpha=0.5)
ax.set(xlabel=col1, ylabel=col2)
f.legend()
generated_plot[col1 + ';' + col2 + '; fil= ' +
self.selection + ' ' +
str(self.plotBox.currentText())] = f
self.plots[self.current_name] = generated_plot
else:
f, ax = plt.subplots()
for value in self.currentDF[self.selection].unique():
filtered_DF = self.currentDF[self.currentDF[
self.selection] == value]
col1 = str(self.stgList.item(0).text())
col2 = str(self.stgList.item(1).text())
data1 = filtered_DF[col1].values
data2 = filtered_DF[col2].values
ax.scatter(data1,
data2,
label=str(value),
alpha=0.5)
ax.set(xlabel=col1, ylabel=col2)
f.legend()
self.plots[self.current_name][
col1 + ';' + col2 + '; fil= ' + self.selection +
' ' + str(self.plotBox.currentText())] = f
elif str(self.plotBox.currentText()) == 'histogram':
if self.current_name not in self.plots.keys():
generated_plots = {}
for col in items:
f, ax = plt.subplots()
for value in self.currentDF[self.selection].unique():
filtered_df = self.currentDF[self.currentDF[
self.selection] == value]
filtered_df[col].hist(ax=ax,
label=str(value),
alpha=0.5)
ax.set(xlabel=col, ylabel='count')
f.legend()
generated_plots[col + ';fil= ' + self.selection + ' ' +
str(self.plotBox.currentText())] = f
self.plots[self.current_name] = generated_plots
else:
for col in items:
f, ax = plt.subplots()
for value in self.currentDF[self.selection].unique():
filtered_df = self.currentDF[self.currentDF[
self.selection] == value]
filtered_df[col].hist(ax=ax,
alpha=0.5,
label=str(value))
ax.set(xlabel=col, ylabel='count')
f.legend()
self.plots[self.current_name][
col + ';fil= ' + self.selection + ' ' +
str(self.plotBox.currentText())] = f
else:
if self.current_name not in self.plots.keys():
generated_plots = {}
for col in items:
f, ax = plt.subplots()
for value in self.currentDF[self.selection].unique():
# .reset_index() intended to time series, uncomment otherwise
filtered_df = self.currentDF[self.currentDF[
self.selection] == value]
filtered_df[col].plot(ax=ax,
label=str(value),
alpha=0.5)
ax.set(xlabel='index', ylabel=col)
f.legend()
generated_plots[col + ';fil= ' + self.selection + ' ' +
str(self.plotBox.currentText())] = f
self.plots[self.current_name] = generated_plots
else:
for col in items:
f, ax = plt.subplots()
for value in self.currentDF[self.selection].unique():
# .reset_index() intended to time series uncomment otherwise
filtered_df = self.currentDF[self.currentDF[
self.selection] == value]
filtered_df[col].plot(ax=ax,
alpha=0.5,
label=str(value))
ax.set(xlabel='index', ylabel=col)
f.legend()
self.plots[self.current_name][
col + ';fil= ' + self.selection + ' ' +
str(self.plotBox.currentText())] = f
self.plotList.clear()
for plot_dict in self.plots[self.current_name].keys():
self.plotList.addItem(plot_dict)
def show_fig(self):
self.rmmpl()
fig_name = str(self.plotList.currentItem().text())
self.addmpl(self.plots[self.current_name][fig_name])
def rmvcol(self):
self.stgList.takeItem(self.stgList.row(self.stgList.currentItem()))
def clear(self):
self.mplfigs.clear()
self.rmmpl()
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(
self.canvas,
self.mplwindow,
coordinates=True,
)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
class SWATGraph(QObject):
"""Display SWAT result data as line graphs or bar chart."""
def __init__(self, csvFile):
"""Initialise class variables."""
QObject.__init__(self)
self._dlg = GraphDialog()
self._dlg.setWindowFlags(self._dlg.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
## csv file of results
self.csvFile = csvFile
## canvas for displaying matplotlib figure
self.canvas = None
## matplotlib tool bar
self.toolbar = None
## matplotlib axes
self.ax1 = None
def run(self):
"""Initialise form and run on initial csv file."""
self._dlg.lineOrBar.addItem('Line graph')
self._dlg.lineOrBar.addItem('Bar chart')
self._dlg.lineOrBar.setCurrentIndex(0)
self._dlg.newFile.clicked.connect(self.getCsv)
self._dlg.updateButton.clicked.connect(self.updateGraph)
self._dlg.closeForm.clicked.connect(self.closeFun)
self.setUbuntuFont()
self.readCsv()
self._dlg.exec_()
def addmpl(self, fig):
"""Add graph defined in fig."""
self.canvas = FigureCanvas(fig)
# graphvl is the QVBoxLayout instance added to the graph widget.
# Needed to make fig expand to fill graph widget.
self._dlg.graphvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self._dlg.graph,
coordinates=True)
self._dlg.graphvl.addWidget(self.toolbar)
def rmmpl(self):
"""Remove current graph if any."""
try:
self._dlg.graphvl.removeWidget(self.canvas)
self.canvas.close()
self._dlg.graphvl.removeWidget(self.toolbar)
self.toolbar.close()
self.ax1 = None
return
except Exception:
# no problem = may not have been a graph
return
@staticmethod
def trans(msg):
"""Translate message."""
return QApplication.translate("QSWATPlus", msg, None)
@staticmethod
def error(msg):
"""Report msg as an error."""
msgbox = QMessageBox()
msgbox.setWindowTitle('SWATGraph')
msgbox.setIcon(QMessageBox.Critical)
msgbox.setText(SWATGraph.trans(msg))
msgbox.exec_()
return
def getCsv(self):
"""Ask user for csv file."""
settings = QSettings()
if settings.contains('/QSWATPlus/LastInputPath'):
path = str(settings.value('/QSWATPlus/LastInputPath'))
else:
path = ''
filtr = self.trans('CSV files (*.csv)')
csvFile, _ = QFileDialog.getOpenFileName(None, 'Open csv file', path,
filtr)
if csvFile is not None and csvFile != '':
settings.setValue('/QSWATPlus/LastInputPath',
os.path.dirname(str(csvFile)))
self.csvFile = csvFile
self.readCsv()
def readCsv(self):
"""Read current csv file (if any)."""
# csvFile may be none if run from command line
if not self.csvFile or self.csvFile == '':
return
if not os.path.exists(self.csvFile):
self.error('Error: Cannot find csv file {0}'.format(self.csvFile))
return
"""Read csv file into table; create statistics (coefficients); draw graph."""
# clear graph
self.rmmpl()
# clear table
self._dlg.table.clear()
for i in range(self._dlg.table.columnCount() - 1, -1, -1):
self._dlg.table.removeColumn(i)
self._dlg.table.setColumnCount(0)
self._dlg.table.setRowCount(0)
row = 0
numCols = 0
with open(self.csvFile, 'r', newline='') as csvFil:
reader = csv.reader(csvFil)
for line in reader:
try:
# use headers in first line
if row == 0:
numCols = len(line)
for i in range(numCols):
self._dlg.table.insertColumn(i)
self._dlg.table.setHorizontalHeaderLabels(line)
else:
self._dlg.table.insertRow(row - 1)
for i in range(numCols):
try:
val = line[i].strip()
except Exception as e:
self.error(
'Error: could not read file {0} at line {1} column {2}: {3}'
.format(self.csvFile, row + 1, i + 1,
repr(e)))
return
item = QTableWidgetItem(val)
self._dlg.table.setItem(row - 1, i, item)
row = row + 1
except Exception as e:
self.error(
'Error: could not read file {0} at line {1}: {2}'.
format(self.csvFile, row + 1, repr(e)))
return
# columns are too narrow for headings
self._dlg.table.resizeColumnsToContents()
# rows are too widely spaced vertically
self._dlg.table.resizeRowsToContents()
self.writeStats()
self.updateGraph()
@staticmethod
def makeFloat(s):
"""Parse string s as float and return; return nan on failure."""
try:
return float(s)
except Exception:
return float('nan')
def updateGraph(self):
"""Redraw graph as line or bar chart according to lineOrBar setting."""
style = 'bar' if self._dlg.lineOrBar.currentText(
) == 'Bar chart' else 'line'
self.drawGraph(style)
@staticmethod
def shiftDates(dates, shift):
"""Add shift (number of days) to each date in dates."""
delta = timedelta(days=shift)
return [x + delta for x in dates]
@staticmethod
def getDateFormat(date):
"""
Return date strptime format string from example date, plus basic width for drawing bar charts.
Basic width is how matplotlib divides the date axis: number of days in the time unit
Assumes date has one of 3 formats:
yyyy: annual: return %Y and 12
yyyy/m or yyyy/mm: monthly: return %Y/%m and 30
yyyyddd: daily: return %Y%j and 24
"""
if date.find('/') > 0:
return '%Y/%m', 30
length = len(date)
if length == 4:
return '%Y', 365
if length == 7:
return '%Y%j', 1
SWATGraph.error('Cannot parse date {0}'.format(date))
return '', 1
def drawGraph(self, style):
"""Draw graph as line or bar chart according to style."""
# preserve title, labels and yscale if they exist
# in order to replace them when updating graph
try:
title = self.ax1.get_title()
except Exception:
title = ''
try:
xlbl = self.ax1.get_xlabel()
except Exception:
xlbl = ''
try:
ylbl = self.ax1.get_ylabel()
except Exception:
ylbl = ''
try:
yscl = self.ax1.get_yscale()
except Exception:
yscl = ''
self.rmmpl()
fig = Figure()
# left, bottom, width, height adjusted to leave space for legend below
self.ax1 = fig.add_axes([0.05, 0.22, 0.92, 0.68])
numPlots = self._dlg.table.columnCount() - 1
rng = range(self._dlg.table.rowCount())
fmt, widthBase = self.getDateFormat(
str(self._dlg.table.item(0, 0).text()).strip())
if fmt == '':
# could not parse
return
xVals = [
datetime.strptime(
str(self._dlg.table.item(i, 0).text()).strip(), fmt)
for i in rng
]
for col in range(1, numPlots + 1):
yVals = [
self.makeFloat(self._dlg.table.item(i, col).text())
for i in rng
]
h = self._dlg.table.horizontalHeaderItem(col).text()
if style == 'line':
self.ax1.plot(xVals, yVals, label=h)
# reinstate yscale (only relevant for line graphs)
if yscl == 'log':
self.ax1.set_yscale(yscl, nonposy='mask')
elif yscl != '':
self.ax1.set_yscale(yscl)
else:
# width of bars in days.
# adding 1 to divisor gives space of size width between each date's group
width = float(widthBase) / (numPlots + 1)
# can't imagine anyone wanting more than 7 colours
# but just in case we'll use shades of grey for 8 upwards
colours = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
colour = colours[col - 1] if col <= 7 else str(
float((col - 7) / (numPlots - 6)))
mid = numPlots / 2
shift = width * (col - 1 - mid)
xValsShifted = xVals if shift == 0 else self.shiftDates(
xVals, shift)
self.ax1.bar(xValsShifted,
yVals,
width,
color=colour,
linewidth=0,
label=h)
# reinstate title and labels
if title != '':
self.ax1.set_title(title)
if xlbl != '':
self.ax1.set_xlabel(xlbl)
else:
self.ax1.set_xlabel('Date')
if ylbl != '':
self.ax1.set_ylabel(ylbl)
self.ax1.grid(True)
legendCols = min(4, self._dlg.table.columnCount())
fontSize = 'x-small' if legendCols > 4 else 'small'
self.ax1.legend(bbox_to_anchor=(1.0, -0.15),
ncol=legendCols,
fontsize=fontSize)
self.addmpl(fig)
def closeFun(self):
"""Close dialog."""
self._dlg.close()
def writeStats(self):
"""Write Pearson and Nash coefficients."""
numCols = self._dlg.table.columnCount()
numRows = self._dlg.table.rowCount()
self._dlg.coeffs.clear()
for i in range(1, numCols):
for j in range(i + 1, numCols):
self.pearson(i, j, numRows)
for i in range(1, numCols):
for j in range(i + 1, numCols):
# only compute Nash-Sutcliffe Efficiency
# if one plot is observed,
# and use that as the first plot
if str(self._dlg.table.horizontalHeaderItem(i).text()).find(
'observed') == 0:
if not str(self._dlg.table.horizontalHeaderItem(
j).text()).find('observed') == 0:
self.nash(i, j, numRows)
elif str(self._dlg.table.horizontalHeaderItem(j).text()).find(
'observed') == 0:
self.nash(j, i, numRows)
def multiSums(self, idx1, idx2, N):
"""Return various sums for two series, only including points where both are numbers, plus count of such values."""
s1 = 0
s2 = 0
s11 = 0
s22 = 0
s12 = 0
count = 0
for i in range(N):
val1 = self.makeFloat(self._dlg.table.item(i, idx1).text())
val2 = self.makeFloat(self._dlg.table.item(i, idx2).text())
# ignore missing values
if not (math.isnan(val1) or math.isnan(val2)):
s1 += val1
s2 += val2
s11 += val1 * val1
s22 += val2 * val2
s12 += val1 * val2
count = count + 1
return (s1, s2, s11, s22, s12, count)
def sum1(self, idx1, idx2, N):
"""Return sum for series1, only including points where both are numbers, plus count of such values."""
s1 = 0
count = 0
for i in range(N):
val1 = self.makeFloat(self._dlg.table.item(i, idx1).text())
val2 = self.makeFloat(self._dlg.table.item(i, idx2).text())
# ignore missing values
if not (math.isnan(val1) or math.isnan(val2)):
s1 += val1
count = count + 1
return (s1, count)
def pearson(self, idx1, idx2, N):
"""Calculate and display Pearson correlation coefficients for each pair of plots."""
s1, s2, s11, s22, s12, count = self.multiSums(idx1, idx2, N)
if count == 0: return
sqx = (count * s11) - (s1 * s1)
sqy = (count * s22) - (s2 * s2)
sxy = (count * s12) - (s1 * s2)
deno = math.sqrt(sqx * sqy)
if deno == 0: return
rho = sxy / deno
if count < N:
extra = ' (using {0!s} of {1!s} values)'.format(count, N)
else:
extra = ''
msg = 'Series1: ' + self._dlg.table.horizontalHeaderItem(idx1).text() + \
' Series2: ' + self._dlg.table.horizontalHeaderItem(idx2).text() + ' Pearson Correlation Coefficient = {0:.2f}{1}'.format(rho, extra)
self._dlg.coeffs.append(SWATGraph.trans(msg))
def nash(self, idx1, idx2, N):
"""Calculate and display Nash-Sutcliffe efficiency coefficients for each pair of plots where one is observed."""
s1, count = self.sum1(idx1, idx2, N)
if count == 0: return
mean = s1 / count
num = 0
deno = 0
for i in range(N):
val1 = self.makeFloat(self._dlg.table.item(i, idx1).text())
val2 = self.makeFloat(self._dlg.table.item(i, idx2).text())
# ignore missing values
if not (math.isnan(val1) or math.isnan(val2)):
diff12 = val1 - val2
diff1m = val1 - mean
num += diff12 * diff12
deno += diff1m * diff1m
if deno == 0: return
result = 1 - (num / deno)
if count < N:
extra = ' (using {0!s} of {1!s} values)'.format(count, N)
else:
extra = ''
msg = 'Series1: ' + self._dlg.table.horizontalHeaderItem(idx1).text() + \
' Series2: ' + self._dlg.table.horizontalHeaderItem(idx2).text() + ' Nash-Sutcliffe Efficiency Coefficient = {0:.2f}{1}'.format(result, extra)
self._dlg.coeffs.append(SWATGraph.trans(msg))
def setUbuntuFont(self):
"""Set Ubuntu font size 10 as default."""
QFontDatabase.addApplicationFont(":/fonts/Ubuntu-R.ttf")
ufont = QFont("Ubuntu", 10, 1)
QApplication.setFont(ufont)
class MyWindowClass(QtGui.QMainWindow, form_class):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.start.clicked.connect(self.start_clicked)
self.regioncontourbutton.clicked.connect(self.openfile1)
self.twibutton.clicked.connect(self.openfile2)
self.cityregionbutton.clicked.connect(self.openfile3)
self.vegindexbutton.clicked.connect(self.openfile4)
self.imageviewbutton.clicked.connect(self.openMainFig)
self.rmvPointButton.clicked.connect(self.removeCell)
self.MutValue.setText("5000")
self.MutantQuantity.setText("0")
self.table.setColumnCount(2)
self.layout.addWidget(self.table, 1, 0)
self.table.setHorizontalHeaderLabels(['index', 'mutant size'])
self.MutantLIST = np.array([])
self.THEimage = np.array([])
self.fig = Figure()
def openfile1(self):
self.regioncontour.setText(
QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)"))
def openfile2(self):
self.twi.setText(
QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)"))
def openfile3(self):
self.cityregion.setText(
QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)"))
def openfile4(self):
self.vegindex.setText(
QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)"))
def removeCell(self):
pointNumber = int(self.rmvPointN.text())
self.MutantLIST[pointNumber:-1] = self.MutantLIST[pointNumber + 1:]
self.MutantLIST = self.MutantLIST[:-1]
self.MutantQuantity.setText(
str(
int(self.MutantQuantity.text()) -
int(self.table.item(pointNumber, 1).text())))
self.table.removeRow(pointNumber)
for i in range(len(self.MutantLIST)):
self.table.setItem(i, 0, QtGui.QTableWidgetItem(str(i)))
self.ImgAddPatches()
self.rmvPointN.setText('')
def onclick(self, event):
#print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' %(event.button, event.x, event.y, event.xdata, event.ydata))
if event.button == 3:
self.MutantLIST = np.array(self.MutantLIST.tolist() + [[
int(event.ydata),
int(event.xdata),
int(str(self.MutValue.text()))
]])
rowPosition = self.table.rowCount()
self.table.insertRow(rowPosition)
self.table.setItem(rowPosition, 0,
QtGui.QTableWidgetItem(str(rowPosition)))
self.table.setItem(
rowPosition, 1,
QtGui.QTableWidgetItem(str(self.MutValue.text())))
self.MutantQuantity.setText(
str(
int(self.MutantQuantity.text()) +
int(str(self.MutValue.text()))))
self.ImgAddPatches()
def openMainFig(self):
if self.THEimage.any() == True:
self.rmmpl()
for i in range(len(self.MutantLIST)):
self.table.removeRow(0)
self.MutantLIST = np.array([])
name = QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)")
image = misc.imread(str(name))
self.THEimage = image
baseimage = self.fig.add_subplot(111)
baseimage.axis('off')
baseimage.grid(False)
baseimage.imshow(image)
self.canvas = FigureCanvas(self.fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def ImgAddPatches(self):
self.fig, ax = subplots(1, 1)
ax.imshow(self.THEimage)
ax.grid(False)
ax.axis('off')
for number, blob in enumerate(self.MutantLIST):
y, x, r = blob
c = Circle((x, y),
self.THEimage.shape[0] * (log(r)**1.5) / 1000,
color='r',
linewidth=2,
alpha=0.5)
ax.add_patch(c)
ax.text(x, y, str(number), color='white')
self.changeFIGURE(self.fig)
def changeFIGURE(self, newFIG):
self.rmmpl()
self.canvas = FigureCanvas(newFIG)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def rmmpl(self, ):
#plt.close()
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def start_clicked(self):
self.start.setText("Running")
transgenic_type = 0
if self.genedrive.isChecked() == True: transgenic_type = 1
island_shape = misc.imread(str(self.regioncontour.text()))
island_shape_gray = rgb2gray(island_shape)
island_wet = ski.img_as_float(
rgb2gray(misc.imread(str(self.twi.text()))))
island_veg = adjust_gamma(
ski.img_as_float(rgb2gray(misc.imread(str(self.vegindex.text())))),
.2)
if str(self.cityregion.text()) == '': island_city = np.zeros(grid_size)
else: island_city = rgb2gray(misc.imread(str(self.cityregion.text())))
mosquitos = Grid(island_shape_gray, island_veg, island_wet,
island_city, float(self.pixelSize.text()),
int(str(self.populationLimit.text())),
transgenic_type, int(self.Neq_step.text()))
for single_point in self.MutantLIST:
y, x, quantity = single_point
mosquitos.GRID[y][x].amut = quantity
CURSOR_UP_ONE = '\x1b[1A'
ERASE_LINE = '\x1b[2K'
mosquitos.images()
for i in range(int(self.daysAfterRelease.text())):
print("loading: " +
str(i / int(self.daysAfterRelease.text()) * 100) + "% done")
mosquitos.updateall()
mosquitos.images()
print(CURSOR_UP_ONE + ERASE_LINE + CURSOR_UP_ONE)
mosquitos.graph()
system("convert timelapse/timelapse-*.png timelapse/dinamic.gif")
system("rm timelapse/timelapse-*.png")
print("End of simulation")
class dApp(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(dApp, self).__init__(parent)
self.setupUi(self)
self.init_defValues()
self.update_table()
self.update_data_disp()
self.init_UI()
self.update_data_disp()
self.widgetStyle = ("QWidget {background-color: #ffffff}," +
"QWidget::item {background: transparent," +
"QWidget::item:selected {background: #ffffff}}")
def init_defValues(self):
self.canvas_1 = False
self.canvas_2 = False
self.canvas_3 = False
self.canvas_4 = False
self.canvas_5 = False
self.canvas_6 = False
self.canvas_7 = False
self.dic_canvas = {}
self.dispData = {}
self.dicData = {}
self.dicData['res'] = empty_class() # class to store results
dD = self.dispData
dD['drift'] = False
dD['f1'] = 4.8e9
dD['f2'] = 4.1e9
dD['g1'] = 1.299e9 # 1.3051e9
dD['g2'] = 1.49e9 # 1486120350.0 # 1.4906e9
dD['cgain11 start'] = 1.8166e7
dD['cgain22 start'] = 1.0478e7
dD['cgain11 stop'] = 1.7251e7
dD['cgain22 stop'] = 1.4240e7
dD['B'] = 5e5
dD['select'] = 0
dD['mapdim'] = [200, 200]
dD['lags'] = 1000
dD['Phase correction'] = True
dD['Trigger correction'] = True
dD['FFT-Filter'] = False
dD['Power Averages'] = 1
dD['Averages'] = 1
dD['Low Pass'] = 0
dD['dim1 pt'] = 201
dD['dim1 start'] = 2.03
dD['dim1 stop'] = 0.03
dD['dim1 name'] = 'RF power'
dD['dim2 pt'] = 11
dD['dim2 start'] = 0
dD['dim2 stop'] = 1
dD['dim2 name'] = 'Magnet'
dD['dim3 pt'] = 1
dD['dim3 start'] = 0
dD['dim3 stop'] = 1
dD['dim3 name'] = 'Nothing'
dD['Process Num'] = 1
dD['Settings file'] = 'density_matrix.set'
self.dicData['dim1 lin'] = np.linspace(dD['dim1 start'], dD['dim1 stop'], dD['dim1 pt'])
self.dicData['dim2 lin'] = np.linspace(dD['dim2 start'], dD['dim2 stop'], dD['dim2 pt'])
self.dicData['dim3 lin'] = np.linspace(dD['dim3 start'], dD['dim3 stop'], dD['dim3 pt'])
def init_UI(self):
''' connect buttons to programs '''
self.open_hdf5_on.triggered.connect(lambda: self.add_hdf5data('hdf5_on'))
self.open_hdf5_off.triggered.connect(lambda: self.add_hdf5data('hdf5_off'))
self.action_Quit.triggered.connect(qApp.quit)
self.save_mtx_as.triggered.connect(self.browse_saveMtx)
self.save_mtx.triggered.connect(self.saveMtx)
self.makeHistogram.clicked.connect(self.make_Histogram)
self.Process_all.clicked.connect(self.process_all)
self.calc_hyb_digitizer_drift.clicked.connect(self.process_digitizer_drift)
self.calc_hyb_button.clicked.connect(self.process_hybrid)
self.calc_hyb_button2.clicked.connect(self.process_hybrid2)
self.calc_hyb_button_all.clicked.connect(self.process_hybrid_all)
# self.tableWidget.itemChanged.connect(self.read_table)
self.Update_table.clicked.connect(self.read_table)
self.actionLoadPrev.triggered.connect(self.load_settings)
self.actionSavePrev.triggered.connect(self.save_settings)
self.actionMtx_files.triggered.connect(self.open_mtx_spyview)
self.action11.triggered.connect(lambda: self.add_hdf5data('on11'))
self.action22.triggered.connect(lambda: self.add_hdf5data('on22'))
self.action12.triggered.connect(lambda: self.add_hdf5data('on12'))
self.action21.triggered.connect(lambda: self.add_hdf5data('on21'))
self.action12_OFF.triggered.connect(lambda: self.add_hdf5data('off12'))
self.action21_OFF.triggered.connect(lambda: self.add_hdf5data('off21'))
self.checkBox_drift.toggled.connect(self.checkbox_drift)
def checkbox_drift(self):
self.dispData['drift'] = not self.dispData['drift']
self.update_data_disp()
def save_settings(self):
savename = QFileDialog.getSaveFileName(self, "Save settingsfile as..")
if savename:
self.dispData['Settings file'] = str(savename)
json.dump(self.dispData, codecs.open(savename, 'w+', encoding='utf-8'),
separators=(',', ':'), sort_keys=True, indent=4)
# with open(savename, "w+") as myFile:
# cPickle.dump(self.dispData, myFile)
logging.debug('settings and files saved')
def load_settings(self):
openname = QFileDialog.getOpenFileName(self, "Open settingsfile")
if openname:
obj_text = codecs.open(openname, 'r', encoding='utf-8').read()
self.dispData = json.loads(obj_text)
# with open(openname, "r") as myFile:
# self.dispData = cPickle.load(myFile)
self.dispData['Settings file'] = str(openname)
if 'hdf5_on' in self.dispData:
functions.load_dataset(self.dispData, self.dicData, 'hdf5_on')
functions.load_dataset(self.dispData, self.dicData, 'hdf5_off')
logging.debug('Single Amp settings and files loaded')
elif 'on11' in self.dispData:
functions.load_dataset(self.dispData, self.dicData, 'on11')
functions.load_dataset(self.dispData, self.dicData, 'on22')
functions.load_dataset(self.dispData, self.dicData, 'on12')
functions.load_dataset(self.dispData, self.dicData, 'on21')
functions.load_dataset(self.dispData, self.dicData, 'off12')
functions.load_dataset(self.dispData, self.dicData, 'off21')
logging.debug('Double Amp settings and files loaded')
self.update_table()
self.update_data_disp()
def add_hdf5data(self, frequency_configuration):
dialog_txt = 'Pick a file for :' + str(frequency_configuration)
openname = QFileDialog.getOpenFileName(self, dialog_txt)
if openname:
logging.debug(str(frequency_configuration) + ':' + str(openname))
self.dispData[str(frequency_configuration)] = str(openname)
functions.load_dataset(self.dispData, self.dicData, frequency_configuration)
self.update_data_disp()
def browse_saveMtx(self):
savename = QFileDialog.getSaveFileName(self, "Select for 'base-name'+cII.mtx .. files")
if savename:
self.dispData['mtx '] = str(savename)
logging.debug('Save .mtx:' + str(savename))
self.saveMtx()
def saveMtx(self):
if self.dispData['mtx ']:
savename = self.dispData['mtx ']
res = self.dicData['res'] # this contains the calculation results
logging.debug('Save .mtx:' + str(savename))
on = self.dicData['hdf5_on']
savemtx(savename + 'cII.mtx', np.expand_dims(res.IQmapM_avg[0], axis=0), on.headerII)
savemtx(savename + 'cQQ.mtx', np.expand_dims(res.IQmapM_avg[1], axis=0), on.headerQQ)
savemtx(savename + 'cIQ.mtx', np.expand_dims(res.IQmapM_avg[2], axis=0), on.headerIQ)
savemtx(savename + 'cQI.mtx', np.expand_dims(res.IQmapM_avg[3], axis=0), on.headerQI)
self.update_data_disp()
def open_mtx_spyview(self):
if self.dispData['mtx ']:
d = threading.Thread(name='spyview', target=self._spyview)
d.setDaemon(True)
d.start()
def _spyview(self):
logging.debug('Spyview started')
basen = self.dispData['mtx ']
subprocess.call(['spyview', basen + 'cII.mtx', basen + 'cQQ.mtx',
basen + 'cIQ.mtx', basen + 'cQI.mtx'])
logging.debug('Spyview closed')
def read_table(self):
table = self.tableWidget
dD = self.dispData
dD['f1'] = float(table.item(0, 0).text())
dD['f2'] = float(table.item(1, 0).text())
dD['g1'] = float(table.item(2, 0).text())
dD['g2'] = float(table.item(3, 0).text())
dD['B'] = float(table.item(4, 0).text())
dD['select'] = int(eval(str(table.item(5, 0).text())))
dD['lags'] = int(eval(str(table.item(6, 0).text())))
dD['mapdim'][0] = int(table.item(7, 0).text())
dD['mapdim'][1] = int(table.item(8, 0).text())
dD['Phase correction'] = bool(eval(str(table.item(9, 0).text())))
dD['Trigger correction'] = bool(eval(str(table.item(10, 0).text())))
dD['FFT-Filter'] = bool(eval(str(table.item(11, 0).text())))
dD['Power Averages'] = int(eval(str(table.item(12, 0).text())))
dD['Low Pass'] = float(table.item(13, 0).text())
dD['Averages'] = int(table.item(14, 0).text())
dD['dim1 pt'] = int(table.item(15, 0).text())
dD['dim1 start'] = float(table.item(16, 0).text())
dD['dim1 stop'] = float(table.item(17, 0).text())
dD['dim1 name'] = str(table.item(18, 0).text())
dD['dim2 pt'] = int(table.item(19, 0).text())
dD['dim2 start'] = float(table.item(20, 0).text())
dD['dim2 stop'] = float(table.item(21, 0).text())
dD['dim2 name'] = str(table.item(22, 0).text())
dD['dim3 pt'] = int(table.item(23, 0).text())
dD['dim3 start'] = float(table.item(24, 0).text())
dD['dim3 stop'] = float(table.item(25, 0).text())
dD['dim3 name'] = str(table.item(26, 0).text())
dD['Process Num'] = int(table.item(27, 0).text())
dD['cgain11 start'] = float(table.item(28, 0).text())
dD['cgain22 start'] = float(table.item(29, 0).text())
dD['cgain11 stop'] = float(table.item(30, 0).text())
dD['cgain22 stop'] = float(table.item(31, 0).text())
aD = self.dicData
aD['dim1 lin'] = np.linspace(dD['dim1 start'], dD['dim1 stop'], dD['dim1 pt'])
aD['dim2 lin'] = np.linspace(dD['dim2 start'], dD['dim2 stop'], dD['dim2 pt'])
aD['dim3 lin'] = np.linspace(dD['dim3 start'], dD['dim3 stop'], dD['dim3 pt'])
table.resizeColumnsToContents()
table.resizeRowsToContents()
self.update_data_disp()
def update_table(self):
logging.debug('Update Table Widget')
table = self.tableWidget
d = self.dispData
table.setItem(0, 0, QTableWidgetItem(str(d['f1'])))
table.setItem(1, 0, QTableWidgetItem(str(d['f2'])))
table.setItem(2, 0, QTableWidgetItem(str(d['g1'])))
table.setItem(3, 0, QTableWidgetItem(str(d['g2'])))
table.setItem(4, 0, QTableWidgetItem(str(d['B'])))
table.setItem(5, 0, QTableWidgetItem(str(d['select'])))
table.setItem(6, 0, QTableWidgetItem(str(d['lags'])))
table.setItem(7, 0, QTableWidgetItem(str(d['mapdim'][0])))
table.setItem(8, 0, QTableWidgetItem(str(d['mapdim'][1])))
table.setItem(9, 0, QTableWidgetItem(str(d['Phase correction'])))
table.setItem(10, 0, QTableWidgetItem(str(d['Trigger correction'])))
table.setItem(11, 0, QTableWidgetItem(str(d['FFT-Filter'])))
table.setItem(12, 0, QTableWidgetItem(str(d['Power Averages'])))
table.setItem(13, 0, QTableWidgetItem(str(d['Low Pass'])))
table.setItem(14, 0, QTableWidgetItem(str(d['Averages'])))
table.setItem(15, 0, QTableWidgetItem(str(d['dim1 pt'])))
table.setItem(16, 0, QTableWidgetItem(str(d['dim1 start'])))
table.setItem(17, 0, QTableWidgetItem(str(d['dim1 stop'])))
table.setItem(18, 0, QTableWidgetItem(str(d['dim1 name'])))
table.setItem(19, 0, QTableWidgetItem(str(d['dim2 pt'])))
table.setItem(20, 0, QTableWidgetItem(str(d['dim2 start'])))
table.setItem(21, 0, QTableWidgetItem(str(d['dim2 stop'])))
table.setItem(22, 0, QTableWidgetItem(str(d['dim2 name'])))
table.setItem(23, 0, QTableWidgetItem(str(d['dim3 pt'])))
table.setItem(24, 0, QTableWidgetItem(str(d['dim3 start'])))
table.setItem(25, 0, QTableWidgetItem(str(d['dim3 stop'])))
table.setItem(26, 0, QTableWidgetItem(str(d['dim3 name'])))
table.setItem(27, 0, QTableWidgetItem(str(d['Process Num'])))
table.setItem(28, 0, QTableWidgetItem(str(d['cgain11 start'])))
table.setItem(29, 0, QTableWidgetItem(str(d['cgain22 start'])))
table.setItem(30, 0, QTableWidgetItem(str(d['cgain11 stop'])))
table.setItem(31, 0, QTableWidgetItem(str(d['cgain22 stop'])))
table.resizeColumnsToContents()
table.resizeRowsToContents()
table.show()
def update_data_disp(self):
xr = (np.array([-self.dispData['lags'], self.dispData['lags']]) / self.dispData['B'])
self.dicData['minmax lags (s)'] = xr
self.dicData['xaxis'] = np.linspace(xr[0], xr[1], self.dispData['lags'] * 2 + 1)
self.selectDat.clear()
for key in self.dispData:
newItem = key + ': ' + str(self.dispData[key])
self.selectDat.addItem(newItem)
def tab2array(self, table):
nT = np.zeros([table.rowCount(), table.columnCount()])
for i in range(table.rowCount()):
for j in range(table.columnCount()):
val = table.item(i, j)
if val:
nT[i, j] = np.float(val.text())
return nT
def update_page_1(self, fig):
self.clear_page_1()
logging.debug('Update Histogram Figures')
self.canvas_1 = FigureCanvas(fig)
self.HistLayout.addWidget(self.canvas_1)
self.canvas_1.draw()
self.toolbar_1 = NavigationToolbar(self.canvas_1, self.tab_2, coordinates=True)
self.HistLayout.addWidget(self.toolbar_1)
def update_page_2(self, fig):
self.clear_page_2()
logging.debug('Update Correlation Figures')
self.canvas_2 = FigureCanvas(fig)
self.CorrLayout.addWidget(self.canvas_2)
self.canvas_2.draw()
self.toolbar_2 = NavigationToolbar(self.canvas_2, self.cc_page, coordinates=True)
self.CorrLayout.addWidget(self.toolbar_2)
def update_page_3(self, fig):
self.clear_page_3()
logging.debug('Update TMS Figures')
self.canvas_3 = FigureCanvas(fig)
self.TMSLayout.addWidget(self.canvas_3)
self.canvas_3.draw()
self.toolbar_3 = NavigationToolbar(self.canvas_3, self.TMS_page, coordinates=True)
self.TMSLayout.addWidget(self.toolbar_3)
def update_page_5(self, fig):
self.clear_page_5()
logging.debug('Update page 5: phn1')
self.canvas_5 = FigureCanvas(fig)
self.phn1.addWidget(self.canvas_5)
self.canvas_5.draw()
self.toolbar_5 = NavigationToolbar(self.canvas_5, self.phn1_page, coordinates=True)
self.phn1.addWidget(self.toolbar_5)
def update_page_6(self, fig):
self.clear_page_6()
logging.debug('Update page 6: phn2')
self.canvas_6 = FigureCanvas(fig)
self.phn2.addWidget(self.canvas_6)
self.canvas_6.draw()
self.toolbar_6 = NavigationToolbar(self.canvas_6, self.phn2_page, coordinates=True)
self.phn2.addWidget(self.toolbar_6)
def update_page_7(self, fig):
self.clear_page_7()
logging.debug('Clear page 7: 3d-covmat')
self.canvas_7 = FigureCanvas(fig)
self.covmat_field.addWidget(self.canvas_7)
self.canvas_7.draw()
self.toolbar_7 = NavigationToolbar(self.canvas_7, self.tab_covmat, coordinates=True)
self.covmat_field.addWidget(self.toolbar_7)
def clear_page_1(self):
if self.canvas_1:
logging.debug('Clear Histogram Figures')
self.HistLayout.removeWidget(self.canvas_1)
self.canvas_1.close()
self.HistLayout.removeWidget(self.toolbar_1)
self.toolbar_1.close()
def clear_page_2(self):
if self.canvas_2:
logging.debug('Clear Correlation Figures')
self.CorrLayout.removeWidget(self.canvas_2)
self.canvas_2.close()
self.CorrLayout.removeWidget(self.toolbar_2)
self.toolbar_2.close()
def clear_page_3(self):
if self.canvas_3:
logging.debug('Clear TMS Figures')
self.TMSLayout.removeWidget(self.canvas_3)
self.canvas_3.close()
self.TMSLayout.removeWidget(self.toolbar_3)
self.toolbar_3.close()
def clear_page_5(self):
if self.canvas_5:
logging.debug('Clear page 5: phn1')
self.phn1.removeWidget(self.canvas_5)
self.canvas_5.close()
self.phn1.removeWidget(self.toolbar_5)
self.toolbar_5.close()
def clear_page_6(self):
if self.canvas_6:
logging.debug('Clear page 6: phn2')
self.phn2.removeWidget(self.canvas_6)
self.canvas_6.close()
self.phn2.removeWidget(self.toolbar_6)
self.toolbar_6.close()
def clear_page_7(self):
if self.canvas_7:
logging.debug('Clear page 7: 3d-covmat')
self.covmat_field.removeWidget(self.canvas_7)
self.canvas_7.close()
self.covmat_field.removeWidget(self.toolbar_7)
self.toolbar_7.close()
def process_all(self):
self.read_table()
logging.debug('start processing')
functions.process_all_points(self.dispData, self.dicData)
res = self.dicData['res']
fig1 = Figure(facecolor='white', edgecolor='white')
pl1 = fig1.add_subplot(1, 1, 1)
pl1.plot(res.ns[:, 0], label='f1')
pl1.plot(res.ns[:, 1], label='f2')
pl1.set_title('Photon numbers')
fig2 = Figure(facecolor='white', edgecolor='white')
pl3 = fig2.add_subplot(2, 1, 1)
pl4 = fig2.add_subplot(2, 1, 2)
pl3.plot(res.sqs, label='Sq Mag')
pl3.plot(res.ineqs, label='Ineq_req')
pl3.set_title('Squeezing Mag')
pl4.plot(res.sqphs)
pl4.set_title('Squeezing Phase')
self.update_page_5(fig1)
self.update_page_6(fig2)
self.read_table()
self.save_processed()
def save_processed(self):
if self.dispData['mtx ']:
savename = self.dispData['mtx ']
logging.debug('Save data as mtx files: ' + str(savename))
on = self.dicData['hdf5_on']
res = self.dicData['res'] # this contains the calculation results
savemtx(savename + 'IImaps.mtx', res.IQmapMs_avg[:, 0, :, :], on.headerII)
savemtx(savename + 'QQmaps.mtx', res.IQmapMs_avg[:, 1, :, :], on.headerQQ)
savemtx(savename + 'IQmaps.mtx', res.IQmapMs_avg[:, 2, :, :], on.headerIQ)
savemtx(savename + 'QImaps.mtx', res.IQmapMs_avg[:, 3, :, :], on.headerQI)
savemtx(savename + 'cs_avg_QI.mtx', res.cs_avg, on.headerQI)
savemtx(savename + 'cs_avg_QI_off.mtx', res.cs_avg_off, on.headerQI)
filename = savename + 'n1n2rawSq1InNoi1Sq2dn1offn2offphs.mtx'
dataset = np.array([res.ns[:, 0], res.ns[:, 1], res.sqs, res.ineqs, res.noises, res.sqs2-res.sqsn2, res.ns_off[:, 0], res.ns_off[:, 1], res.sqphs])
mtxdataset = np.expand_dims(dataset, 0)
savemtx(filename, mtxdataset)
# gp.s([res.ns[:, 0], res.ns[:, 1], res.sqs, res.ineqs, res.noises, res.sqs2-res.sqsn2, res.ns_off[:, 0], res.ns_off[:, 1]], filename=filename)
# gp.c('plot "' + filename + '" u 3 w lp t "Squeezing"')
# gp.c('replot "' + filename + '" u 4 w lp t "Ineq"')
self.update_data_disp()
def make_Histogram(self):
self.read_table()
functions.process(self.dispData, self.dicData)
self.make_CorrFigs()
self.make_TMSFig()
on = self.dicData['hdf5_on'] # this one contains all the histogram axis
res = self.dicData['res'] # this contains the calculation results
fig1 = Figure(facecolor='white', edgecolor='white')
ax1 = fig1.add_subplot(2, 2, 1)
ax2 = fig1.add_subplot(2, 2, 2)
ax3 = fig1.add_subplot(2, 2, 3)
ax4 = fig1.add_subplot(2, 2, 4)
ax1.imshow(res.IQmapM_avg[0], interpolation='nearest', origin='low',
extent=[on.xII[0], on.xII[-1], on.yII[0], on.yII[-1]], aspect='auto')
ax2.imshow(res.IQmapM_avg[1], interpolation='nearest', origin='low',
extent=[on.xQQ[0], on.xQQ[-1], on.yQQ[0], on.yQQ[-1]], aspect='auto')
ax3.imshow(res.IQmapM_avg[2], interpolation='nearest', origin='low',
extent=[on.xIQ[0], on.xIQ[-1], on.yIQ[0], on.yIQ[-1]], aspect='auto')
ax4.imshow(res.IQmapM_avg[3], interpolation='nearest', origin='low',
extent=[on.xQI[0], on.xQI[-1], on.yQI[0], on.yQI[-1]], aspect='auto')
fig1.tight_layout()
ax1.set_title('IIc')
ax2.set_title('QQc')
ax3.set_title('IQc')
ax4.set_title('QIc')
self.update_page_1(fig1) # send figure to the show_figure terminal
self.read_table()
def make_CorrFigs(self):
fig2 = Figure(facecolor='white', edgecolor='black')
res = self.dicData['res']
xCorr1 = fig2.add_subplot(2, 2, 1)
xCorr2 = fig2.add_subplot(2, 2, 2)
xCorr3 = fig2.add_subplot(2, 2, 3)
xCorr4 = fig2.add_subplot(2, 2, 4)
xCorr1.set_title('<IIc>')
xCorr2.set_title('<QQc>')
xCorr3.set_title('<IQc>')
xCorr4.set_title('<QIc>')
xCorr1.plot(self.dicData['xaxis'], res.c_avg[0])
xCorr2.plot(self.dicData['xaxis'], res.c_avg[1])
xCorr3.plot(self.dicData['xaxis'], res.c_avg[2])
xCorr4.plot(self.dicData['xaxis'], res.c_avg[3])
xCorr1.axis('tight')
xCorr2.axis('tight')
xCorr3.axis('tight')
xCorr4.axis('tight')
# fig2.tight_layout()
self.update_page_2(fig2)
def make_TMSFig(self):
fig3 = Figure(facecolor='white', edgecolor='black')
res = self.dicData['res']
xTMS1 = fig3.add_subplot(1, 2, 1)
xTMS2 = fig3.add_subplot(1, 2, 2)
xTMS1.set_title('Magnitude')
xTMS2.set_title('Phase')
xTMS1.plot(self.dicData['xaxis'], np.abs(res.psi_avg[0]))
xTMS2.plot(self.dicData['xaxis'], np.angle(res.psi_avg[0]))
xTMS1.axis('tight')
xTMS2.axis('tight')
# xTMS1.tight_layout(fig3)
# xTMS2.tight_layout(fig3)
self.update_page_3(fig3)
def process_hybrid(self):
self.read_table()
res = self.dicData['res']
lags = self.dispData['lags']
functions_hybrid.process_hyb(self.dispData, self.dicData)
fig7, ax = plot3dHist(res.cov_mat)
self.update_page_7(fig7)
ax.mouse_init()
def process_hybrid2(self):
self.read_table()
res = self.dicData['res']
lags = self.dispData['lags']
functions_hybrid.process_hyb2(self.dispData, self.dicData)
fig7, ax = plot3dHist2(res.cov_mat)
self.update_page_7(fig7)
ax.mouse_init()
def process_hybrid_all(self):
self.read_table()
res = self.dicData['res']
lags = self.dispData['lags']
functions_hybrid.process_hyb_all(self.dispData, self.dicData)
# fig7, ax = plot3dHist2(res.cov_mat)
fig6 = Figure(facecolor='white', edgecolor='black')
xpl1 = fig6.add_subplot(1, 2, 1)
xpl2 = fig6.add_subplot(1, 2, 2)
xpl1.set_title('N1')
xpl1.set_title('N2')
xpl1.plot(res.n1)
xpl2.plot(res.n2)
self.update_page_5(fig6)
# self.update_page_7(fig7)
# ax.mouse_init()
def process_digitizer_drift(self):
self.read_table()
functions_digitizer_drift.generate_drift_map(self.dispData, self.dicData)
class Main(QMainWindow,Ui_MainWindow):
def __init__(self,):
super(Main,self).__init__()
self.setupUi(self)
self.actionLoad.triggered.connect(self.loadCfg)
self.ReadButton.clicked.connect(self.readInData)
self.UpdateButton.clicked.connect(self.updatePlot)
self.TimeSlider.valueChanged.connect(self.updatePlot)
self.TimeSlider.sliderMoved.connect(self.updateSlider)
self.figs = []
self.axs = []
self.updating = False
self.addmpl(Figure())
def updateSlider(self):
self.TimeDisplay.setText(self.strlist[self.TimeSlider.value()])
def updatePlot(self):
if not self.updating:
self.updating = True
self.rmmpl()
self.addmpl(self.figs[self.TimeSlider.value()])
self.updating = False
def loadCfg(self):
dlg = QFileDialog()
dlg.setFilter("Config Files (*.ini)")
self.inifn = str(dlg.getOpenFileName(self,'Open File','.','Config Files (*.ini)'))
if(self.inifn):
text = open(self.inifn,'r')
self.ConfigBox.setText(text.read())
text.close()
#self.settings = QSettings(self.inifn, QSettings.IniFormat) #MAYBE USE QSETTINGS FOR INI READ/WRITE?!?!?
def addmpl(self,fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow,
coordinates=True)
self.addToolBar(self.toolbar)
def rmmpl(self,):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def readInData(self):
f = open(self.inifn,'w')
f.write(str(self.ConfigBox.toPlainText()))
f.close()
gpsloc = str(self.GPSBox.text())
isrloc = str(self.ISRBox.text())
asloc = str(self.AllSkyBox.text())
self.PC = PlotClass(self.inifn,GPSloc=gpsloc,ASloc=asloc,ISRloc=isrloc)
self.strlist = [insertinfo( str(j)+' $tmdy $thmsehms',posix=i[0],posixend=i[1]) for j, i in enumerate(self.PC.Regdict['Time'])]
self.TimeSlider.setMaximum(len(self.strlist)-1)
self.TimeSlider.setTracking(False)
self.TimeSlider.setTickPosition(1)
self.figs=[]
self.axs=[]
for t in range(len(self.strlist)):
print(self.strlist[t])
self.figs.append(Figure(figsize=(16,10)))
self.axs.append(self.figs[t].add_subplot(111))
m=self.PC.plotmap(self.figs[t],self.axs[t])
(allhands,cbarsax)=self.PC.plotsingle(m,self.axs[t],self.figs[t],timenum=t,icase=0)
self.rmmpl()
self.addmpl(self.figs[0])
class Main(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.PlotButton.clicked.connect(self.plot)
self.ClearButton.clicked.connect(self.clear)
self.SaveButton.clicked.connect(self.save)
self.QuitButton.clicked.connect(self.quit)
self.subjectNo = 0;
self.filter = 0;
self.param =0;
self.fig = plt.figure();
self.a1 = self.fig.add_subplot(121)
self.a2 = self.fig.add_subplot(122)
self.cnx = mysql.connector.connect(user='******',password='******',database='mohand');
self.cursor = self.cnx.cursor();
def addplot(self):
self.canvas = FigureCanvas(self.fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
self.addToolBar(self.toolbar)
def rmplot(self):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def filterstr(self,x):
return{
0: '_fil_',
1: '_raw_'
}.get(x)
def paramstr(self,x):
return{
0: 'indexVal',
1: 'meanReactionTime',
2: 'meanMovementTime',
3: 'meanResponseTime',
4: 'meanMaxVel',
5: 'meanMaxAcc',
6: 'meanEPD',
7: 'meanRealDist',
8: 'meanTraversedDist',
9: 'meanPerDev',
10: 'ovMaxReactionTime',
11: 'ovMaxMovementTime',
12: 'ovMaxEPD',
13: 'ovMaxSpeed',
14: 'ovMaxAcc'
}.get(x)
def daystr(self,x):
return{
0: 'baseline',
1: 'day1',
2: 'day2',
3: 'day3',
4: 'day4',
5: 'day5'
}.get(x,'performance')
def plot(self):
print "plotting graph";
self.subjectNo = int(self.text_subNo.text());
self.filter = self.combo_filter.currentIndex();
self.param = self.combo_param.currentIndex();
fstr = self.filterstr(self.filter);
pstr = self.paramstr(self.param);
rep_data = np.zeros(7);
ran_data = np.zeros(7);
for i in range(7):
s = "select count("+pstr+fstr+"rep) from "+self.daystr(i)+" where subNo="+str(self.subjectNo);
res=self.cursor.execute(s);
if(int(self.cursor.fetchone()[0])==1):
s = "select "+pstr+fstr+"rep from "+self.daystr(i)+" where subNo="+str(self.subjectNo);
res2 = self.cursor.execute(s);
rep_data[i] = float(self.cursor.fetchone()[0]);
s = "select count("+pstr+fstr+"ran) from "+self.daystr(i)+" where subNo="+str(self.subjectNo);
res=self.cursor.execute(s);
if(int(self.cursor.fetchone()[0])==1):
s = "select "+pstr+fstr+"ran from "+self.daystr(i)+" where subNo="+str(self.subjectNo);
res2 = self.cursor.execute(s);
ran_data[i] = float(self.cursor.fetchone()[0]);
self.rmplot();
labels = ['Baseline', 'Day 1', 'Day 2','Day 3','Day 4','Day 5','Performance'];
self.a1.set_xticklabels(labels);
self.a2.set_xticklabels(labels);
self.a1.set_title('Repeated Sequence');
self.a2.set_title('Random Sequence');
label_ax = 'Subject '+str(self.subjectNo)+' '+pstr;
self.a1.plot(rep_data, label=label_ax);
self.a2.plot(ran_data, label =label_ax);
leg1 = self.a1.legend(loc='best');
leg2 = self.a2.legend(loc='best');
leg1.draggable(state=True);
leg2.draggable(state=True);
self.addplot();
self.sub_info.setText("(Subject Number "+str(self.subjectNo)+")");
rep_d1_val = int((rep_data[1]-rep_data[0])*100/rep_data[0]);
self.rep_d1.setText(str(rep_d1_val));
ran_d1_val = int((ran_data[1]-ran_data[0])*100/ran_data[0]);
self.ran_d1.setText(str(ran_d1_val));
rep_d2_val = int((rep_data[2]-rep_data[0])*100/rep_data[0]);
self.rep_d2.setText(str(rep_d2_val));
ran_d2_val = int((ran_data[2]-ran_data[0])*100/ran_data[0]);
self.ran_d2.setText(str(ran_d2_val));
rep_d3_val = int((rep_data[3]-rep_data[0])*100/rep_data[0]);
self.rep_d3.setText(str(rep_d3_val));
ran_d3_val = int((ran_data[3]-ran_data[0])*100/ran_data[0]);
self.ran_d3.setText(str(ran_d3_val));
rep_d4_val = int((rep_data[4]-rep_data[0])*100/rep_data[0]);
self.rep_d4.setText(str(rep_d4_val));
ran_d4_val = int((ran_data[4]-ran_data[0])*100/ran_data[0]);
self.ran_d4.setText(str(ran_d4_val));
rep_d5_val = int((rep_data[5]-rep_data[0])*100/rep_data[0]);
self.rep_d5.setText(str(rep_d5_val));
ran_d5_val = int((ran_data[5]-ran_data[0])*100/ran_data[0]);
self.ran_d5.setText(str(ran_d5_val));
rep_p_val = int((rep_data[6]-rep_data[0])*100/rep_data[0]);
self.rep_p.setText(str(rep_p_val));
ran_p_val = int((ran_data[6]-ran_data[0])*100/ran_data[0]);
self.ran_p.setText(str(ran_p_val));
def clear(self):
self.a1.cla();
self.a2.cla();
self.rmplot();
self.addplot();
self.text_subNo.setText("");
self.combo_filter.setCurrentIndex(0);
self.combo_param.setCurrentIndex(0);
print "clear";
def save(self):
print "save"
#open a dialog box and input name of figure and then save.
#plt.savefig('common_labels_text.png', dpi=300)
def quit(self):
#self.cnx.commit();
#self.cnx.close();
exit()
class Main(QMainWindow, Ui_MainWindow):
# Define plate arrays as global variables to be able use them elsewhere in the program.
global w_plate
global mx_plate
global my_plate
global qx_plate
global qy_plate
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.btnPlot.setStyleSheet('color: red')
self.textEdit.setTextColor(QtGui.QColor("magenta"))
# Check deflections radio button by default
self.deflections_radio.setChecked(False)
# Creating a QButtonGroup and adding the plot options ratio buttons.
# This will be used to make sure new results are plotted every time the solve button is pressed.
# Otherwise, if the deflections radio button is already selected, new run won't plot results.
self.group = QtGui.QButtonGroup()
self.group.addButton(self.deflections_radio)
self.group.addButton(self.mx_radio)
self.group.addButton(self.my_radio)
self.group.addButton(self.qx_radio)
self.group.addButton(self.qy_radio)
self.plot_options_group.setEnabled(False)
self.infoLabel.setStyleSheet('color: blue')
self.infoLabel.setText(' Theory of Plates and Shells\n' +
' Süleyman Muti\n' + ' Spring 2016')
self.btnPlot.clicked.connect(lambda: self.fdm())
self.deflections_radio.toggled.connect(
lambda: self.deflections_radio_checked())
self.mx_radio.toggled.connect(lambda: self.mx_radio_checked())
self.my_radio.toggled.connect(lambda: self.my_radio_checked())
self.qx_radio.toggled.connect(lambda: self.qx_radio_checked())
self.qy_radio.toggled.connect(lambda: self.qy_radio_checked())
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def get_grid_size(self):
if self.rBtn15x10.isChecked():
return 15, 1e-6
if self.rBtn30x20.isChecked():
return 30, 1e-6
elif self.rBtn180x120.isChecked():
return 180, 1e-7
elif self.rBtn540x360.isChecked():
return 540, 1e-9
def deflections_radio_checked(self):
if self.deflections_radio.isChecked():
self.rmmpl()
self.print_plot(w_plate, 'Plate Deflections', 'viridis')
def mx_radio_checked(self):
if self.mx_radio.isChecked():
self.rmmpl()
self.print_plot(mx_plate, 'Mx Bending Moment', 'plasma')
def my_radio_checked(self):
if self.my_radio.isChecked():
self.rmmpl()
self.print_plot(my_plate, 'My Bending Moment', 'plasma')
def qx_radio_checked(self):
if self.qx_radio.isChecked():
self.rmmpl()
self.print_plot(qx_plate, 'Qx Transverse Shear Force', 'inferno')
def qy_radio_checked(self):
if self.qy_radio.isChecked():
self.rmmpl()
self.print_plot(qy_plate, 'Qy Transverse Shear Force', 'inferno')
def print_plot(self, array_to_be_plotted, plot_title, colormap):
a = array_to_be_plotted
self.rmmpl()
fig = Figure()
self.addmpl(fig)
ax = fig.add_subplot(111)
cax = ax.imshow(a, cmap=colormap)
fig.colorbar(cax, shrink=0.6, aspect=5)
fig.tight_layout()
ax.set_title(plot_title, fontsize=20, y=1.01)
ax.axes.get_xaxis().set_ticks([])
ax.axes.get_yaxis().set_ticks([])
ax.format_coord = lambda x, y: ''
ax.set_xlabel('300 mm', fontsize=20, rotation=0)
ax.set_ylabel('200 mm', fontsize=20, rotation=90)
ax.autoscale(False)
plt.show()
def print_info(self, grid_size):
grid_string = 'Grid size: {:d} x {:d}'.format(grid_size,
grid_size * 2 // 3)
deflection_string = 'Maximum deflection of the plate: {0:.4f} mm'.format(
np.max(w_plate))
moment_string = 'Max. Mx: {:.4f} Nmm/mm \t Max. My: {:.4f} Nmm/mm'.format(
np.max(mx_plate), np.max(my_plate))
shear_string = 'Max. Qx: {:.4f} N/mm \t Max. Qy: {:.4f} N/mm'.format(
np.max(qx_plate), np.max(qy_plate))
self.textEdit.setText(grid_string + '\n' + deflection_string + '\n' +
moment_string + '\n' + shear_string)
def fdm(self):
# Let the function fdm() know that the plate arrays are global variables and can be used outside its scope.
global w_plate
global mx_plate
global my_plate
global qx_plate
global qy_plate
# Enabling initially disabled plot options area which was disabled to prevent
# plot attempts without array creations.
self.plot_options_group.setEnabled(True)
# Deselecting the deflections radio button to make sure new results always get plotted.
self.group.setExclusive(False)
self.deflections_radio.setChecked(False)
self.group.setExclusive(True)
dim_x = 300 # Plate length in x-direction [mm]
# dim_y = 200 # Plate length in y-direction [mm]
# Use Python tuple to get the number of elements in the x-direction and corresponding convergence criterion.
(m, conv) = self.get_grid_size()
n = m * 2 // 3 # Number of elements in the y-direction.
# Element size
delta = dim_x / m
# Initialize matrices for iterative solution.
w_old = np.zeros(
(m + 3, n + 3)) # Initialize plate deflections to zero.
w = np.copy(w_old)
m1 = np.zeros((m + 3, n + 3))
m2 = np.zeros((m + 3, n + 3))
qx = np.zeros((m + 3, n + 3))
qy = np.zeros((m + 3, n + 3))
# Material properties, loading, and other properties
e = 70000 # Modulus of elasticity [N/mm2]
nu = 0.3 # Poisson's ratio
h = 2 # Plate thickness [mm]
po = 0.01 # Distributed load [N/mm2]
# Plate stiffness
d = (e * (h**3)) / (12 * (1.0 - (nu**2)))
# Distributed load
p = (po * (delta**4)) / d
# Set logical condition to check if convergence criterion is met.
cond = False # Set to false to initiate iteration loop.
# Loop to iterate plate deflections using Finite Difference Method
iteration_number = 0 # Keep an eye on the iteration number.
while not cond:
cond = True # set to true to check if criterion is met for all nodes.
# Apply boundary conditions. Simply supported on all edges.
w[:, 0] = -w_old[:, 2]
w[:, n + 2] = -w_old[:, n]
w[0, :] = -w_old[2, :]
w[m + 2, :] = -w_old[m, :]
# Calculate deflection of each node using neighbouring nodes
# (i.e., using FDM)
# Python range() statement is seemingly upper-bound exclusive. We need to add 1 to cover all range.
for i in range(2, m + 1):
# Check if the current index point has distributed load acting on it. If so apply the load, if not let it be zero.
if i <= (m / 2 + 1):
k = p
else:
k = 0
for j in range(2, n + 1):
# Finite Difference Method Formula: v4 = p/d
w[i, j] = (1 / 20) * (
k + 8 *
(w[i + 1, j] + w[i - 1, j] + w[i, j + 1] + w[i, j - 1])
- 2 * (w[i + 1, j + 1] + w[i - 1, j + 1] +
w[i + 1, j - 1] + w[i - 1, j - 1]) -
w[i + 2, j] - w[i - 2, j] - w[i, j + 2] - w[i, j - 2])
# Check if convergence criterion is met for each node. Set logical condition
# to false even if a single node violates the the condition so that the
# iteration can continue until all nodes meet the criterion.
if abs(w[i, j] - w_old[i, j]) > conv:
cond = False
# Reset deflection matrices for next iteration.
w_old = np.copy(w)
# Keep an eye on the iteration number.
iteration_number += 1
# Calculate the bending moments and transverse shear forces based on the deflections.
for i in range(2, m + 1):
for j in range(2, n + 1):
# Common terms in bending moment equations.
m1[i, j] = -(w[i + 1, j] - 2 * w[i, j] +
w[i - 1, j]) * d / delta**2
m2[i, j] = -(w[i, j + 1] - 2 * w[i, j] +
w[i, j - 1]) * d / delta**2
# Transverse shear forces.
qx[i, j] = -(
(w[i + 2, j] - 2 * w[i + 1, j] + 2 * w[i - 1, j] -
w[i - 2, j]) +
(w[i + 1, j + 1] - 2 * w[i + 1, j] + w[i + 1, j - 1] -
w[i - 1, j + 1] + 2 * w[i - 1, j] -
w[i - 1, j - 1])) * d / (2 * delta**3)
qy[i, j] = -(
(w[i + 1, j + 1] - 2 * w[i, j + 1] + w[i - 1, j + 1] -
w[i + 1, j - 1] + 2 * w[i, j - 1] - w[i - 1, j - 1]) +
(w[i, j + 2] - 2 * w[i, j + 1] + 2 * w[i, j - 1] -
w[i, j - 2])) * d / (2 * delta**3)
# Assemble bending moment arrays.
mx = m1 + nu * m2
my = m2 + nu * m1
# Exclude the ghost nodes that were necessary to apply boundary conditions,
# and obtain deflections for plate nodes only. Plate deflections will be plotted correcting the orientation.
w_plate = w[1:m + 2, 1:n + 2].transpose()
mx_plate = mx[1:m + 2, 1:n + 2].transpose()
my_plate = my[1:m + 2, 1:n + 2].transpose()
qx_plate = qx[1:m + 2, 1:n + 2].transpose()
qy_plate = qy[1:m + 2, 1:n + 2].transpose()
# Set deflections radio button to checked to display the new run's results.
self.deflections_radio.setChecked(True)
# Print information summarizing the solution
# Maximum deflection, maximum bending moments, and maximum shear forces
self.print_info(m)
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.fg_dict = {}
self.mplfigs.itemClicked.connect(self.changefig)
self.datacube.clicked.connect(self.selectFile)
self.polarization.clicked.connect(self.selectPol)
self.fetch.clicked.connect(self._fetch)
self.res.clicked.connect(self._res)
self.calc.clicked.connect(self._calc)
self.reset.clicked.connect(self._reset)
self.xst.valueChanged[str].connect(self.xchg)
self.yst.valueChanged[str].connect(self.ychg)
self.x_st, self.y_st = 0,0
fig = Figure()
self.fig = fig
self.addmpl(fig, np.ones((100,100)))
self.previous_point = []
self.tempxpt,self.tempypt = [],[]
self.allxpoints = []
self.allypoints = []
self.start_point = []
self.end_point = []
self.line = None
self.roicolor = 'r'
self.ax = plt.gca()
self.dcube_path = '/Users/Mipanox/Desktop/coding_temp/SF/wzError/L1455_rgd.fits'
self.poldt_path = '/Users/Mipanox/Desktop/coding_temp/SF/wzError/scupollegacy_l1455_cube.fits'
self.dc_nm.setText(self.dcube_path)
self.po_nm.setText(self.poldt_path)
self.dn = None
self.ds = None
self.__ID2 = self.fig.canvas.mpl_connect(
'button_press_event', self.__button_press_callback)
def selectFile(self):
self.dc_nm.setText(QFileDialog.getOpenFileName())
self.dcube_path = unicode(self.dc_nm.text())
def selectPol(self):
self.po_nm.setText(QFileDialog.getOpenFileName())
self.poldt_path = unicode(self.po_nm.text())
def xchg(self):
self.x_st = self.xst.value()
def ychg(self):
self.y_st = self.yst.value()
def _fetch(self):
if self.checkBox.isChecked() == True:
self.__fet()
else:
self.dn = sfn(ds=self.dcube_path,name='foo',od=2.,bn=1.,
pol=self.poldt_path,du=1.5e-5)
self.ds = sf(ds=self.dcube_path,name='foo',od=2.,bn=1.,
pol=self.poldt_path,du=1.5e-5)
m0 = self.dn.m0
m1 = self.dn.m1
i = 0
for n in [m0,m1]:
fig_ = Figure()
axf_ = fig_.add_subplot(111)
cax = axf_.imshow(n,origin='lower')
fig_.colorbar(cax)
name = 'moment %s' %i
self.fig_dict[name] = fig_
self.fg_dict[name] = n
self.mplfigs.addItem(name)
i += 1
def __fet(self):
from astropy.utils.data import get_readable_fileobj
from astropy.io import fits
with get_readable_fileobj(self.dcube_path, cache=True) as f:
fitsfile = fits.open(f)
gd = fitsfile[0].data[0][0]
dshd = fitsfile[0].header
with get_readable_fileobj(self.poldt_path, cache=True) as e:
fitsfile = fits.open(e)
po = fitsfile[0].data[0][0] + 90. # to B-field
pshd = fitsfile[0].header
tx = 'gd-pol'
fig = Figure()
self.fig_dict[tx] = fig
self.fg_dict[tx] = [gd,po]
self.mplfigs.addItem(tx)
axf = fig.add_subplot(111)
self.__quiver(gd,po,axf,tx)
def __quiver(self,gd,po,plt,tx):
lx,ly = gd.shape
y,x = np.mgrid[0:(lx-1):(lx)*1j, 0:(ly-1):(ly)*1j]
gx,gy = -np.sin(np.radians(gd)),np.cos(np.radians(gd))
px,py = -np.sin(np.radians(po)+90.),np.cos(np.radians(po)+90.)
quiveropts = dict(headlength=0, pivot='middle',
scale=5e1, headaxislength=0)
plt.axis('equal');
plt.quiver(x,y,gx,gy,color='r',**quiveropts)
plt.quiver(x,y,px,py,color='b',alpha=0.5,**quiveropts)
def _calc(self):
def avg_adj(ar,n): # reshaping even-indexed arrays
(M,N) = ar.shape
tt = np.zeros((M-n+1,N-n+1))
for (x,y),i in np.ndenumerate(ar):
if x > ar.shape[0]-n or y > ar.shape[1]-n: continue
else:
ap = ar[slice(x,x+n),slice(y,y+n)]
tt[x,y] = ap.mean()
return tt
pol = self.dn._grad(pol=1)[0]
grd = self.ds._grad()
for i in range(1,len(grd)):
if i % 2:
pt = avg_adj(pol,i+1)
else:
pt = pol[i/2:-i/2,i/2:-i/2]
gt = grd[i]
tx = '%s x %s' %(i+1,i+1)
fig = Figure()
self.fig_dict[tx] = fig
self.fg_dict[tx] = [gt,pt]
self.mplfigs.addItem(tx)
axf = fig.add_subplot(111)
self.__quiver(gt,pt,axf,tx)
def _res(self, item):
cg,cp = self.fg[0],self.fg[1]
if self.x_st >= 0 and self.y_st >= 0:
gd = np.pad(cg,((0,2*self.x_st),(0,2*self.y_st)),
mode='constant', constant_values=(np.nan))
po = np.pad(cp,((self.x_st,self.x_st),(self.y_st,self.y_st)),
mode='constant', constant_values=(np.nan))
elif self.x_st < 0 and self.y_st >= 0:
gd = np.pad(cg,((-self.x_st,-self.x_st),(0,2*self.y_st)),
mode='constant', constant_values=(np.nan))
po = np.pad(cp,((0,-2*self.x_st),(self.y_st,self.y_st)),
mode='constant', constant_values=(np.nan))
elif self.x_st >=0 and self.y_st < 0:
gd = np.pad(cg,((0,2*self.x_st),(-self.y_st,-self.y_st)),
mode='constant', constant_values=(np.nan))
po = np.pad(cp,((self.x_st,self.x_st),(0,-2*self.y_st)),
mode='constant', constant_values=(np.nan))
else:
gd = np.pad(cg,((-self.x_st,-self.x_st),(-self.y_st,-self.y_st)),
mode='constant', constant_values=(np.nan))
po = np.pad(cp,((0,-2*self.x_st),(0,-2*self.y_st)),
mode='constant', constant_values=(np.nan))
if self.x_st == 0 and self.y_st == 0: pass
else:
tx = '%s - (%s x %s) shifted' %(str(self.mplfigs.currentItem().text()),
self.x_st,self.y_st)
fig = Figure()
self.fig_dict[tx] = fig
self.fg_dict[tx] = [gd,po]
self.mplfigs.addItem(tx)
axf = fig.add_subplot(111)
self.__quiver(gd,po,axf,tx)
if len(self.allxpoints) > 0: # if roi selected
if self.checkBox.isChecked() == True:
tp = self.getMask(gd)
else:
self.tempxpt,self.tempypt = self.allxpoints,self.allypoints
old_xd,old_yd = self.dn.m0.shape
new_xd,new_yd = gd.shape
for i in range(len(self.allxpoints)):
self.allxpoints[i] *= float(new_xd) / float(old_xd)
self.allypoints[i] *= float(new_yd) / float(old_yd)
tp = self.getMask(gd)
gd[tp==False] = np.nan
po[tp==False] = np.nan
gx,gy = -np.sin(np.radians(gd)),np.cos(np.radians(gd))
px,py = -np.sin(np.radians(po)),np.cos(np.radians(po))
# +/- 90 doesn't matter
overlay = np.sum(~np.isnan(gd) * ~np.isnan(po) * 1.)
self.spsize.setText('%d' %(overlay))
v_c = vc(v1=np.array([gx,gy]),v2=np.array([px,py]))
self.rho_c.setText('%3e' %(v_c.corr_c()) )
self.rho_h.setText('%3e' %(v_c.corr_h()) )
self.allxpoints = self.tempxpt
self.allypoints = self.tempypt
def _reset(self):
self.previous_point = []
self.tempxpt,self.tempypt = [],[]
self.allxpoints = []
self.allypoints = []
self.start_point = []
self.end_point = []
self.line = None
## remember to right-click before reset if changed frame
self.ax.lines = []
self.changefig(self.mplfigs.currentItem())
self.xst.setValue(0)
self.yst.setValue(0)
def changefig(self, item):
text = str(item.text())
self.rmmpl()
self.addmpl(self.fig_dict[text], self.fg_dict[text])
def addmpl(self, fig, fg):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
self.fg = fg
self.ax = self.fig.add_subplot(111)
self.canvas.draw()
self.canvas.setFocusPolicy( Qt.ClickFocus )
self.canvas.setFocus()
self.canvas.mpl_connect('button_press_event', self.__button_press_callback)
def rmmpl(self,):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def __button_press_callback(self, event):
if event.inaxes:
x, y = event.xdata, event.ydata
self.ax = event.inaxes
if event.button == 1 and event.dblclick == False: # If you press the left button, single click
if self.line == None: # if there is no line, create a line
self.line = plt.Line2D([x, x],
[y, y],
marker='o',
color=self.roicolor)
self.start_point = [x,y]
self.previous_point = self.start_point
self.allxpoints=[x]
self.allypoints=[y]
self.ax.add_line(self.line)
self.canvas.draw()
# add a segment
else: # if there is a line, create a segment
self.line = plt.Line2D([self.previous_point[0], x],
[self.previous_point[1], y],
marker = 'o',color=self.roicolor)
self.previous_point = [x,y]
self.allxpoints.append(x)
self.allypoints.append(y)
event.inaxes.add_line(self.line)
self.canvas.draw()
elif ((event.button == 1 and event.dblclick==True) or
(event.button == 3 and event.dblclick==False)) and self.line != None: # close the loop and disconnect
self.canvas.mpl_disconnect(self.__ID2) #joerg
self.line.set_data([self.previous_point[0],
self.start_point[0]],
[self.previous_point[1],
self.start_point[1]])
self.ax.add_line(self.line)
self.canvas.draw()
self.line = None
def getMask(self, ci):
ny, nx = ci.shape
poly_verts = [(self.allxpoints[0], self.allypoints[0])]
for i in range(len(self.allxpoints)-1, -1, -1):
poly_verts.append((self.allxpoints[i], self.allypoints[i]))
x, y = np.meshgrid(np.arange(nx), np.arange(ny))
x, y = x.flatten(), y.flatten()
points = np.vstack((x,y)).T
ROIpath = mplPath.Path(poly_verts)
grid = ROIpath.contains_points(points).reshape((ny,nx))
return grid
class MyApp(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.SetFormInitialValues()
def AddPlot(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
def RemovePlot(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def SetFormInitialValues(self):
self.mplwindow.setStyleSheet("border: 1px solid black")
self.fig = 0
self.A_text.setText("1")
self.B_text.setText("0")
self.C_text.setText("-1")
self.f_text.setText("x")
self.from_Box.setValue(0)
self.to_Box.setValue(1)
self.phi_0_text.setText("2*x")
self.StringPolynomial_text.setText("(x**i)*(1-x)")
self.N_spinBox.setValue(3)
self.GoButton.clicked.connect(self.ProcessForm)
def ProcessForm(self):
StringResult = ""
# N is the number of partitions
N = int(self.N_spinBox.value())
# Define the variables
x = smp.symbols('x')
A = smp.sympify(str(self.A_text.toPlainText()))
B = smp.sympify(str(self.B_text.toPlainText()))
C = smp.sympify(str(self.C_text.toPlainText()))
f = smp.sympify(str(self.f_text.toPlainText()))
from_ = self.from_Box.value()
to_ = self.to_Box.value()
Coefficients_ = []
Equations_ = []
# Define phi_0
phi_0 = str(self.phi_0_text.toPlainText())
# Define function for phi in each partition node
StringPolynomial = str(self.StringPolynomial_text.toPlainText())
ExpressionString = []
CoefficientsString = ""
for i in xrange(1, N + 1):
CoefficientsString += "c_" + str(i) + " "
ExpressionString.append(
("c_i * " + StringPolynomial).replace("i", str(i)))
Coefficients_ = smp.S(CoefficientsString.strip().split())
# Join the string with a plus character
ExpressionString = " + ".join(map(str, ExpressionString))
# Append phi_0 to U(x)
U = smp.sympify(phi_0) + smp.sympify(ExpressionString)
U_first_derivative = smp.diff(U, x)
U_second_derivative = smp.diff(U_first_derivative, x)
# Define the Residual function R(x)
R = A * U_second_derivative + B * U_first_derivative + C * U - f
StringResult += "Residual function:\n" + str(R) + "\n\n"
self.console_text.setText(StringResult)
# Integrals
for i in xrange(1, N + 1):
# Set the power
f = StringPolynomial.replace("i", str(i))
f = smp.sympify(f)
Integral = smp.integrate(f * R, (x, from_, to_))
Equations_.append(smp.Eq(Integral, 0))
# Solve the system of equations
SolutionVector = smp.solve(Equations_, Coefficients_)
# Set the coefficients in the U function
for i in xrange(0, N):
U = U.subs(Coefficients_[i], SolutionVector[Coefficients_[i]])
StringResult += "U function:\n" + str(U) + "\n\n"
self.console_text.setText(StringResult)
# this converts thye sympy function into a numpy function
U = smp.lambdify((x), U, "numpy")
# Frome here the function U is callable as we are used
X = np.linspace(from_, to_, num=100)
Y = U(X)
self.console_text.setText(StringResult)
# Plot the result
#plt.plot(X, Y);
#plt.show();
if self.fig != 0:
self.RemovePlot()
self.fig = Figure()
ax1f1 = self.fig.add_subplot(111)
ax1f1.plot(X, Y)
self.AddPlot(self.fig)
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, data):
super(Main, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.perguntas_dict = {}
self.data = data
self.question_id = -1
# click Perguntas
self.mplfigs.itemClicked.connect(
self.update_pessoa) # when clicked, change plot
# click Pessoa
# on click function
self.mplfigs_2.cellClicked.connect(self.update_correlacao)
fig = Figure()
self.add_plot(fig)
# ----------------------
# PERGUNTA TABLE METHODS
def addpergunta(self, id, name): # add perguntas
name = name.decode('utf-8')
self.perguntas_dict[
name] = id # add item to perguntas dict, name as key and id as value
self.mplfigs.addItem(name) # add item to mplfigs
# ----------------------
# ----------------------
# PESSOA TABLE METHODS
def init_pessoa(self):
# set table
row_count = len(self.data.index)
self.mplfigs_2.setRowCount(row_count)
self.mplfigs_2.setColumnCount(2)
# set header
self.mplfigs_2.setHorizontalHeaderLabels(
QString("id;resposta;").split(";"))
def update_pessoa(self, question):
# access perguntas dict and get question_id based on click
try:
question = question.text()
question = unicode(question) # to text
except AttributeError:
question = question
question_id = str(self.perguntas_dict[question])
self.question_id = question_id
# add data inside table
data_column = self.data[question_id]
votos_dict = {'sim': [], 'nao': [], 'nulo': []}
for i, d in enumerate(data_column):
self.mplfigs_2.setItem(i, 0, QTableWidgetItem("{}".format(i)))
self.mplfigs_2.setItem(i, 1, QTableWidgetItem("{}".format(d)))
if d == 1:
votos_dict['sim'].append(i)
elif d == -1:
votos_dict['nao'].append(i)
elif d == 0:
votos_dict['nulo'].append(i)
self.changefig(self.data, votos_dict)
# ----------------------
# CORRELACAO TABLE
def init_correlacao(self, data):
# set table
row_count = len(data.index) - 1
self.mplfigs_3.setRowCount(row_count)
self.mplfigs_3.setColumnCount(3)
# set header
self.mplfigs_3.setHorizontalHeaderLabels(
QString("id; conc; disc;").split(";"))
def update_correlacao(self, row, col):
person_id = row
data_plot = PCA.get_oposition(self.data, self.question_id, person_id)
self.init_correlacao(data_plot)
self.changefig(data_plot, person_id)
self.person = self.data.loc[self.data['participant'] ==
person_id].drop('participant', axis=1)
self.person = map(list, self.person.values) # to list
ordered_data, name = self.treat_data(data_plot)
print ordered_data
self.others = data_plot['participant'].tolist()
self.size = len(self.data.index)
for i, o in enumerate(self.others):
other = self.data.loc[self.data['participant'] == o]
id = other['participant'].values
print id
other = other.drop('participant', axis=1)
other = map(list, other.values)
both_sim, both_nao, both_nulo = 0, 0, 0
for pair in itertools.izip(self.person[0], other[0]):
if pair == (1.0, 1.0):
both_sim += 1
elif pair == (0.0, 0.0):
both_nulo += 1
if pair == (-1.0, -1.0):
both_nao += 1
self.sim = both_sim + both_nao + both_nulo
self.nao = self.size - self.sim
print self.sim, self.nao
self.mplfigs_3.setItem(i, 0, QTableWidgetItem("{}".format(id[0])))
self.mplfigs_3.setItem(i, 1,
QTableWidgetItem("{}".format(self.sim)))
self.mplfigs_3.setItem(i, 2,
QTableWidgetItem("{}".format(self.nao)))
# ----------------------
# PLOT METHODS
def changefig(self, data_plot, person_id=-1): # change plot func
self.remove_plot() # clear plot
fig = self.PCA_plot(data_plot, person_id) # get plot info
self.add_plot(fig) # add plot
def add_plot(self, fig): # add plot
self.canvas = FigureCanvas(fig) # put matplot fig
self.mplvl.addWidget(self.canvas) # create widget mplvl space
self.canvas.draw() # draw canvas
self.toolbar = NavigationToolbar(
self.canvas, # create toolbar
self.mplwindow,
coordinates=True)
self.mplvl.addWidget(self.toolbar) # add toolbar
def remove_plot(self, ): # clear cnavas
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def treat_data(self, data):
data, name = data.drop(
['participant'], axis=1).as_matrix(), data['participant'].tolist()
data = PCA.PCA(data) # PCA it
return data, name
def PCA_plot(self, data_plot, evidence=-1):
# treat data
data, name = self.treat_data(data_plot)
# Plot init
self.fig = Figure()
self.ax1 = self.fig.add_subplot(111)
# data
blue, = self.ax1.plot(data[:, 0],
data[:, 1],
'o',
markersize=7,
color='blue',
alpha=0.5)
if evidence != -1: # evidence data
if isinstance(evidence, dict):
for e in evidence['nao']:
index = name.index(e)
red, = self.ax1.plot(data[index, 0],
data[index, 1],
'o',
markersize=7,
color='red',
alpha=0.5)
for e in evidence['nulo']:
index = name.index(e)
yellow, = self.ax1.plot(data[index, 0],
data[index, 1],
'o',
markersize=7,
color='y',
alpha=0.5)
if not (len(evidence['nao']) == 0
or len(evidence['nulo']) == 0):
self.ax1.legend([blue, red, yellow],
['sim', 'nao', 'nulo']) # legenda
else:
index = name.index(evidence)
self.ax1.plot(data[index, 0],
data[index, 1],
'o',
markersize=7,
color='red',
alpha=0.5)
# annotations
for i, txt in enumerate(name):
self.ax1.annotate(txt, (data[i, 0], data[i, 1]))
self.extra = Rectangle((0, 0),
1,
1,
fc="w",
fill=False,
edgecolor='none',
linewidth=0)
if evidence == -1 or isinstance(evidence, dict):
self.ax1.annotate("PCA Geral",
xy=(0.05, 0.95),
xycoords='axes fraction',
fontsize=14)
else:
self.ax1.annotate("Sujeito {}".format(evidence),
xy=(0.05, 0.95),
xycoords='axes fraction',
fontsize=14)
return self.fig
class GUIControl(QtGui.QMainWindow, design.Ui_controlMontura):
#Señal para actualizar el FOV de Stellarium
act_stell_pos = QtCore.pyqtSignal(str, str)
def __init__(self, parent=None):
super(GUIControl, self).__init__(parent)
self.setupUi(self)
self.RT = None
self.fig_dict = {}
self.m = 0
self.az = 0
self.el = 0
self.m_az = 0
self.m_el = 0
self.vel = 0
self.h = 0
self.newRA = 0
self.newDEC = 0
self.sra = 0
self.sdec = 0
self.lon = 0
self.lat = 0
self.find = False
self.track = False
self.sweep = False
self.i = 0
self.j = 0
self.g = 0
self.k = False
self.manualGPS = False
self.timeBarrido = 0.0
self.ori = 0
self.yaori = 0
#Variables de cuadro
self.pasox = 0
self.pasoy = 0
self.tamanox = 0
self.tamanoy = 0
self.timeBarrido = 0
self.totalx = 0
self.totaly = 0
self.adc = 0
self.paro = 0
self.vectGrap = [0] * 50
#Se inician caracteristicas de la tabla
self.mode.setCurrentIndex(0)
#Se bloquean algunos campos
self.textEdit_2.setDisabled(True)
self.textEdit_3.setDisabled(True)
self.textEdit.setDisabled(True)
self.textEdit_4.setDisabled(True)
#Conexion serie
self.connectSerial()
#Se declaran las conexiones de la GUI
self.mode.currentChanged.connect(self.modeEdit)
self.toolButton.clicked.connect(self.home)
self.toolButton_2.clicked.connect(self.editPos)
self.toolButton_3.clicked.connect(self.unlock)
self.menubar.setNativeMenuBar(False)
#Iniciamos la configuracion inicial
self.modeEdit()
#Conexiones del Modo Automatico
self.checkBox.clicked.connect(self.justFirst)
self.checkBox_2.clicked.connect(self.justSecond)
self.checkBox_3.clicked.connect(self.justThird)
self.frame.setDisabled(True)
self.mode.setTabEnabled(1, False)
#Conexion con Stellarium
self.textEdit_11.setDisabled(True)
self.textEdit_12.setDisabled(True)
self.Server = Telescope_Server(pos_signal=self.act_stell_pos)
self.Server.daemon = True
self.Server.start()
self.Server.stell_pos_recv.connect(self.stellariumRead)
#Menu Bar
#Archivo
#Abrir Stellaium
self.actionAbrir_Stellarium.triggered.connect(self.openSte)
#Salir
self.actionSalr.triggered.connect(self.closeApp)
#Posicionamiento
#Manual
self.actionManual.triggered.connect(self.getManualGPS)
#Acerca
self.actionAcerca.triggered.connect(self.mensaje)
#Boton Iniciar
self.pushButton.clicked.connect(self.start)
#Boton Stop
self.pushButton_3.clicked.connect(self.stop)
self.stopAuto = True
self.mg = 0
#Graficamos los valores
self.fig1 = Figure()
self.f1 = self.fig1.add_subplot(111)
self.f1.set_ylabel('Potencia')
self.addmpl(self.fig1)
#Boton compas
self.toolButton_4.clicked.connect(self.orientar)
def orientar(self):
self.mode.setDisabled(True)
self.actionAcerca.setDisabled(True)
self.actionManual.setDisabled(True)
self.actionAbrir_Stellarium.setDisabled(True)
self.statusbar.showMessage("Orientando la antena")
self.ori = 1
self.acumWord()
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.plotADC.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
self.plotADC.addWidget(self.toolbar)
def start(self):
self.pushButton.setDisabled(True)
os.system('./test')
self.mg = 0
if self.track == True or self.sweep == True:
if self.sweep == True:
self.timeBarrido = float(self.tiempoBarrido.toPlainText())
self.pasox = float(self.azPaso.toPlainText())
self.pasoy = float(self.elPaso.toPlainText())
self.tamanox = float(self.azVentana.toPlainText())
self.tamanoy = float(self.elVentana.toPlainText())
self.totalx = math.ceil(self.tamanox / self.pasox)
self.totaly = math.ceil(self.tamanoy / self.pasoy)
#Conexion modo track
self.Track = TrackMode(self.timeBarrido)
self.Track.lat_lon.connect(self.writeInfo)
self.Track.start()
def stop(self):
self.pushButton.setDisabled(False)
self.stopAuto = True
self.Track.cancel()
def updateData(self, az, el, lat, lon, adc, paro, yaori):
try:
self.az = float(az)
self.el = float(el)
self.adc = int(adc)
self.yaori = int(yaori)
self.paro = int(paro)
except:
print self.az
print self.el
print self.adc
print self.yaori
print self.paro
#aux = self.vectGrap[1:50]
#aux.insert(0,self.adc)
#self.vectGrap = aux
#self.newGrap
if self.manualGPS == False:
if float(lon) > 18000 and float(lat) > 9000:
self.textEdit_2.setText("Not Found")
self.textEdit_3.setText("Not Found")
else:
self.lon = float(lon)
self.lat = float(lat)
lon_ax = 100 * float(self.lon)
lat_ax = 100 * float(self.lat)
self.lon = int(abs(lon_ax / 10000)) + float(
(int(abs(lon_ax / 100)) %
100)) / 60 + (float(int(abs(lon_ax)) % 100) +
abs(lon_ax) - abs(int(lon_ax))) / 3600
self.lat = int(abs(lat_ax / 10000)) + float(
(int(abs(lat_ax / 100)) %
100)) / 60 + (float(int(abs(lat_ax)) % 100) +
abs(lat_ax) - abs(int(lat_ax))) / 3600
self.textEdit_2.setText('{0:5f}'.format(self.lat))
self.textEdit_3.setText('{0:5f}'.format(self.lon))
if lon_ax < 0:
self.lon = -1 * self.lon
self.label_4.setText('W')
else:
self.label_4.setText('E')
if lat_ax < 0:
self.lat = -1 * self.lat
self.label_3.setText('S')
else:
self.label_3.setText('N')
self.mode.setTabEnabled(1, True)
self.manualGPS = True
if self.paro == 1:
QtGui.QMessageBox.warning(self, 'Warning', "Motores inhabilitados")
try:
self.stop()
self.frame.setDisabled(True)
self.modoAuto.setDisabled(True)
self.actionManual.setDisabled(True)
except:
print "Fallo al finalizar los motores"
elif self.paro == 0:
self.frame.setDisabled(False)
self.modoAuto.setDisabled(False)
self.actionManual.setDisabled(False)
self.vel = 0
if self.yaori == 1:
self.writeLCD(0)
self.mode.setDisabled(False)
self.actionAcerca.setDisabled(False)
self.actionManual.setDisabled(False)
self.actionAbrir_Stellarium.setDisabled(False)
self.statusbar.showMessage("Orientacion finalizada")
elif self.yaori == 2:
self.writeLCD(0)
self.mode.setDisabled(False)
self.actionAcerca.setDisabled(False)
self.actionManual.setDisabled(False)
self.actionAbrir_Stellarium.setDisabled(False)
self.statusbar.showMessage(
"NO se pudo orientar satisfactoriamente la antena")
self.textEdit.setText(az)
self.textEdit_4.setText(el)
def mensaje(self):
QtGui.QMessageBox.information(self, 'Acerca', "Control RT V1.0")
def newGrap(self):
self.rmmpl()
self.f1.plot(self.vectGrap)
self.addmpl(self.fig1)
def rmmpl(self):
self.plotADC.removeWidget(self.canvas)
self.canvas.close()
self.plotADC.removeWidget(self.toolbar)
self.toolbar.close()
def getManualGPS(self):
self.manualGPS = True
self.textEdit_2.setDisabled(False)
self.textEdit_3.setDisabled(False)
self.mode.setTabEnabled(1, True)
def openSte(self):
os.system('stellarium &')
def closeApp(self):
self.Server.close_socket()
self.close()
def stellariumRead(self, ra, dec, mtime):
ra = float(ra)
dec = float(dec)
mtime = float(mtime)
(self.sra, self.sdec, stime) = coords.eCoords2str(ra, dec, mtime)
if self.find == True or self.mg < 1:
self.writeInfo()
def writeInfo(self):
self.mg = 1
self.newRA = 180 * coords.hourStr_2_rad(self.sra) / (math.pi * 15)
self.newDEC = 180 * coords.degStr_2_rad(self.sdec) / math.pi
self.ecuToalaz = EcuToHor(self.newRA, self.newDEC, self.lat, self.lon)
(self.az, self.el) = self.ecuToalaz.getHor()
if self.sweep == True:
self.az = self.az - (self.tamanox / 2) + self.g * self.pasox
self.el = self.el + (self.tamanoy / 2) - self.j * self.pasoy
if self.i >= self.totalx:
self.i = 0
self.j = self.j + 1
self.k = not self.k
if self.j > self.totaly:
self.j = 0
self.g = 0
self.stop()
else:
self.i = self.i + 1
if self.k == False:
self.g = self.g + 1
else:
self.g = self.g - 1
self.textEdit_11.setText('{0:.4f}'.format(self.az))
self.textEdit_12.setText('{0:.4f}'.format(self.el))
self.acumWord()
def justFirst(self):
self.stopAuto = True
self.frame.setEnabled(False)
self.find = True
self.track = False
self.sweep = False
self.checkBox.setChecked(True)
self.checkBox_2.setChecked(False)
self.checkBox_3.setChecked(False)
def justSecond(self):
self.timeBarrido = 1
self.stopAuto = False
self.frame.setEnabled(False)
self.find = False
self.track = True
self.sweep = False
self.checkBox.setChecked(False)
self.checkBox_2.setChecked(True)
self.checkBox_3.setChecked(False)
def justThird(self):
self.stopAuto = False
self.frame.setEnabled(True)
self.find = False
self.track = False
self.sweep = True
self.checkBox.setChecked(False)
self.checkBox_2.setChecked(False)
self.checkBox_3.setChecked(True)
def fromJS(self, vel, m_az, m_el):
self.vel = vel
self.m_az = m_az
self.m_el = m_el
self.acumWord()
def acumWord(self):
if self.RT != None:
if self.ori != 1:
self.RT.writeWord(self.az, self.el, self.m, self.vel,
self.m_az, self.m_el, self.h, self.ori)
elif self.ori == 1 and self.yaori == 1:
self.ori = 0
self.RT.writeWord(self.az, self.el, self.m, self.vel,
self.m_az, self.m_el, self.h, self.ori)
self.h = 0
def connectSerial(self):
portSerial = availablePorts()
for path_RT in portSerial:
print "Conexion exitosa con " + path_RT
self.connectRT(path_RT)
def connectRT(self, path_RT):
try:
if self.RT == None:
self.RT = comSerial(portSerial=path_RT)
#Recepcion de la cadena
self.RT.readAntena.connect(self.updateData)
self.RT.start()
except:
QtGui.QMessageBox.warning(self, 'Warning', "RT no conectado")
self.RT = None
def home(self):
self.textEdit_4.setText('0.0000000')
self.az = 0
self.h = 1
self.acumWord()
def unlock(self):
self.textEdit.setDisabled(False)
self.textEdit_4.setDisabled(False)
def editPos(self):
self.az = float(self.textEdit.toPlainText())
self.el = float(self.textEdit_4.toPlainText())
self.textEdit.setDisabled(True)
self.textEdit_4.setDisabled(True)
if self.az >= 360:
self.az = 0
self.textEdit.setText('0')
elif self.az < 0:
self.az = 0
self.textEdit.setText('0')
if self.el > 90:
self.el = 90
self.textEdit_4.setText('90')
elif self.el < 0:
self.el = 0
self.textEdit_4.setText('0')
self.statusbar.showMessage(
"La antena no puede alcanzar elevacion menor a 0")
self.acumWord()
def modeEdit(self):
if self.mode.currentIndex() == 0:
#Se inicia el joystick
self.JOY = joyStickControl(0.0001)
self.JOY.start()
#Conexion a la LCD
self.JOY.jSvel.connect(self.writeLCD)
#Conexion a la matriz de LED
self.JOY.jSmov.connect(self.writeMLED)
self.JOY.jMove.connect(self.fromJS)
#Funcion Modo Manual
self.confManualMode()
else:
self.lcdNumber.display('0')
#Finalizamos el joystick
self.JOY.cancel()
#Funcion Modo Automatico
self.confAutoMode()
def modifyPosSte(self, cmdText, lat, lon):
try:
if not os.path.exists(
'/home/marcial/.stellarium/data/user_locations.txt'):
archivo = open(
'/home/marcial/.stellarium/data/user_locations.txt', 'a')
archivo.write(cmdText)
archivo.close()
archivo = open(
'/home/marcial/.stellarium/data/user_locations.txt', 'r')
else:
archivo = open(
'/home/marcial/.stellarium/data/user_locations.txt', 'r')
lineas = list(archivo)
for i in range(len(lineas)):
if lineas[i][0:14] == cmdText:
lineas[i] = cmdText + '\t\tMexico\tX\t0\t' + str(
lat) + 'N\t' + str(lon) + 'E\t2144\t2\t\tEarth\n'
archivo.close()
fileNew = open('/home/marcial/.stellarium/data/user_locations.txt',
'w')
strToLine = ''.join(lineas)
fileNew.write(strToLine)
fileNew.close()
except IOError:
QtGui.QMessageBox.warning(self, 'Warning',
"Fallo al cargar parametros iniciales")
def confManualMode(self):
self.statusbar.showMessage("Bienvenido !!! Modo Manual")
self.toolButton.setDisabled(False)
self.toolButton_2.setDisabled(False)
self.toolButton_3.setDisabled(False)
self.toolButton_4.setDisabled(False)
self.m = 2
self.acumWord()
def confAutoMode(self):
self.statusbar.showMessage("Bienvenido !!! Modo Automatico")
self.lat = float(self.textEdit_2.toPlainText())
self.lon = float(self.textEdit_3.toPlainText())
self.textEdit_2.setDisabled(True)
self.textEdit_3.setDisabled(True)
self.toolButton.setDisabled(True)
self.toolButton_2.setDisabled(True)
self.toolButton_3.setDisabled(True)
self.toolButton_4.setDisabled(True)
self.textEdit_2.setText('{0:.5f}'.format(abs(self.lat)))
self.textEdit_3.setText('{0:.5f}'.format(abs(self.lon)))
if self.lat < 0:
self.label_3.setText('S')
else:
self.label_3.setText('N')
if self.lon < 0:
self.label_4.setText('W')
else:
self.label_4.setText('E')
if self.lat > 90:
self.lat = 90
self.textEdit_2.setText('90')
elif self.lat < -90:
self.lat = -90
self.textEdit_2.setText('-90')
if self.lon > 180:
self.lon = 180
self.textEdit_3.setText('180')
elif self.lon < -180:
self.lon = -180
self.textEdit_3.setText('-180')
#Abrir Stellarium
self.modifyPosSte('SkyExplorer RT', str(self.lat), str(self.lon))
os.system('./CheckStellarium')
self.m = 1
self.acumWord()
def writeLCD(self, vel):
stateVel = ""
if vel < 4:
stateVel = "Baja"
elif vel < 8:
stateVel = "Media"
else:
stateVel = "Alta"
self.statusbar.showMessage("Velocidad: " + stateVel)
self.lcdNumber.display(vel)
self.vel = vel
def writeMLED(self, m_az, m_el):
stateMov = ""
self.clearButton()
if m_az == 1 and m_el == 1:
self.right_downButton()
stateMov = "Abajo/Derecha"
elif m_az == 1 and m_el == -1:
self.right_upButton()
stateMov = "Arriba/Derecha"
elif m_az == -1 and m_el == 1:
self.left_downButton()
stateMov = "Abajo/Izquierda"
elif m_az == -1 and m_el == -1:
self.left_upButton()
stateMov = "Arriba/Izquierda"
elif m_az == 0 and m_el == 1:
self.downButton()
stateMov = "Abajo"
elif m_az == 0 and m_el == -1:
self.upButton()
stateMov = "Arriba"
elif m_az == 1 and m_el == 0:
self.rightButton()
stateMov = "Derecha"
elif m_az == -1 and m_el == 0:
self.leftButton()
stateMov = "Izquierda"
self.statusbar.showMessage("Movimiento: " + stateMov)
def rightButton(self):
self.qLed_1_4.setOffColour(QLed.Green)
self.qLed_2_4.setOffColour(QLed.Green)
self.qLed_2_5.setOffColour(QLed.Green)
self.qLed_3_1.setOffColour(QLed.Green)
self.qLed_3_2.setOffColour(QLed.Green)
self.qLed_3_3.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_5.setOffColour(QLed.Green)
self.qLed_3_6.setOffColour(QLed.Green)
self.qLed_4_1.setOffColour(QLed.Green)
self.qLed_4_2.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_4_6.setOffColour(QLed.Green)
self.qLed_4_7.setOffColour(QLed.Green)
self.qLed_7_4.setOffColour(QLed.Green)
self.qLed_6_4.setOffColour(QLed.Green)
self.qLed_6_5.setOffColour(QLed.Green)
self.qLed_5_1.setOffColour(QLed.Green)
self.qLed_5_2.setOffColour(QLed.Green)
self.qLed_5_3.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_6.setOffColour(QLed.Green)
self.qLed_5_7.setOffColour(QLed.Green)
def upButton(self):
self.qLed_1_4.setOffColour(QLed.Green)
self.qLed_2_3.setOffColour(QLed.Green)
self.qLed_2_4.setOffColour(QLed.Green)
self.qLed_2_5.setOffColour(QLed.Green)
self.qLed_3_2.setOffColour(QLed.Green)
self.qLed_3_3.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_5.setOffColour(QLed.Green)
self.qLed_3_6.setOffColour(QLed.Green)
self.qLed_4_1.setOffColour(QLed.Green)
self.qLed_4_2.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_4_6.setOffColour(QLed.Green)
self.qLed_4_7.setOffColour(QLed.Green)
self.qLed_5_3.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_6.setOffColour(QLed.Green)
self.qLed_6_3.setOffColour(QLed.Green)
self.qLed_6_4.setOffColour(QLed.Green)
self.qLed_6_5.setOffColour(QLed.Green)
self.qLed_7_3.setOffColour(QLed.Green)
self.qLed_7_4.setOffColour(QLed.Green)
self.qLed_7_5.setOffColour(QLed.Green)
def downButton(self):
self.qLed_7_4.setOffColour(QLed.Green)
self.qLed_6_3.setOffColour(QLed.Green)
self.qLed_6_4.setOffColour(QLed.Green)
self.qLed_6_5.setOffColour(QLed.Green)
self.qLed_5_2.setOffColour(QLed.Green)
self.qLed_5_3.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_6.setOffColour(QLed.Green)
self.qLed_5_7.setOffColour(QLed.Green)
self.qLed_4_1.setOffColour(QLed.Green)
self.qLed_4_2.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_4_6.setOffColour(QLed.Green)
self.qLed_4_7.setOffColour(QLed.Green)
self.qLed_3_3.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_5.setOffColour(QLed.Green)
self.qLed_2_3.setOffColour(QLed.Green)
self.qLed_2_4.setOffColour(QLed.Green)
self.qLed_2_5.setOffColour(QLed.Green)
self.qLed_1_3.setOffColour(QLed.Green)
self.qLed_1_4.setOffColour(QLed.Green)
self.qLed_1_5.setOffColour(QLed.Green)
def leftButton(self):
self.qLed_1_4.setOffColour(QLed.Green)
self.qLed_2_3.setOffColour(QLed.Green)
self.qLed_2_4.setOffColour(QLed.Green)
self.qLed_3_2.setOffColour(QLed.Green)
self.qLed_3_3.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_5.setOffColour(QLed.Green)
self.qLed_3_6.setOffColour(QLed.Green)
self.qLed_3_7.setOffColour(QLed.Green)
self.qLed_4_1.setOffColour(QLed.Green)
self.qLed_4_2.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_4_6.setOffColour(QLed.Green)
self.qLed_4_7.setOffColour(QLed.Green)
self.qLed_5_2.setOffColour(QLed.Green)
self.qLed_5_3.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_6.setOffColour(QLed.Green)
self.qLed_5_7.setOffColour(QLed.Green)
self.qLed_5_8.setOffColour(QLed.Green)
self.qLed_6_3.setOffColour(QLed.Green)
self.qLed_6_4.setOffColour(QLed.Green)
self.qLed_7_4.setOffColour(QLed.Green)
def right_upButton(self):
self.qLed_2_3.setOffColour(QLed.Green)
self.qLed_2_4.setOffColour(QLed.Green)
self.qLed_2_5.setOffColour(QLed.Green)
self.qLed_2_6.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_5.setOffColour(QLed.Green)
self.qLed_3_6.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_4_6.setOffColour(QLed.Green)
self.qLed_5_2.setOffColour(QLed.Green)
self.qLed_5_3.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_7.setOffColour(QLed.Green)
self.qLed_6_3.setOffColour(QLed.Green)
def left_upButton(self):
self.qLed_2_2.setOffColour(QLed.Green)
self.qLed_2_3.setOffColour(QLed.Green)
self.qLed_2_4.setOffColour(QLed.Green)
self.qLed_2_5.setOffColour(QLed.Green)
self.qLed_3_2.setOffColour(QLed.Green)
self.qLed_3_3.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_4_2.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_5_2.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_6.setOffColour(QLed.Green)
self.qLed_5_7.setOffColour(QLed.Green)
self.qLed_6_5.setOffColour(QLed.Green)
def left_downButton(self):
self.qLed_6_2.setOffColour(QLed.Green)
self.qLed_6_3.setOffColour(QLed.Green)
self.qLed_6_4.setOffColour(QLed.Green)
self.qLed_6_5.setOffColour(QLed.Green)
self.qLed_5_2.setOffColour(QLed.Green)
self.qLed_5_3.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_4_2.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_3_2.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_6.setOffColour(QLed.Green)
self.qLed_3_5.setOffColour(QLed.Green)
self.qLed_2_5.setOffColour(QLed.Green)
def right_downButton(self):
self.qLed_6_3.setOffColour(QLed.Green)
self.qLed_6_4.setOffColour(QLed.Green)
self.qLed_6_5.setOffColour(QLed.Green)
self.qLed_6_6.setOffColour(QLed.Green)
self.qLed_5_4.setOffColour(QLed.Green)
self.qLed_5_6.setOffColour(QLed.Green)
self.qLed_5_7.setOffColour(QLed.Green)
self.qLed_4_3.setOffColour(QLed.Green)
self.qLed_4_4.setOffColour(QLed.Green)
self.qLed_4_5.setOffColour(QLed.Green)
self.qLed_4_6.setOffColour(QLed.Green)
self.qLed_3_2.setOffColour(QLed.Green)
self.qLed_3_3.setOffColour(QLed.Green)
self.qLed_3_4.setOffColour(QLed.Green)
self.qLed_3_6.setOffColour(QLed.Green)
self.qLed_2_3.setOffColour(QLed.Green)
def clearButton(self):
self.qLed_1_1.setOffColour(QLed.Grey)
self.qLed_1_2.setOffColour(QLed.Grey)
self.qLed_1_3.setOffColour(QLed.Grey)
self.qLed_1_4.setOffColour(QLed.Grey)
self.qLed_1_5.setOffColour(QLed.Grey)
self.qLed_1_6.setOffColour(QLed.Grey)
self.qLed_1_7.setOffColour(QLed.Grey)
self.qLed_2_1.setOffColour(QLed.Grey)
self.qLed_2_2.setOffColour(QLed.Grey)
self.qLed_2_3.setOffColour(QLed.Grey)
self.qLed_2_4.setOffColour(QLed.Grey)
self.qLed_2_5.setOffColour(QLed.Grey)
self.qLed_2_6.setOffColour(QLed.Grey)
self.qLed_2_7.setOffColour(QLed.Grey)
self.qLed_3_1.setOffColour(QLed.Grey)
self.qLed_3_2.setOffColour(QLed.Grey)
self.qLed_3_3.setOffColour(QLed.Grey)
self.qLed_3_4.setOffColour(QLed.Grey)
self.qLed_3_5.setOffColour(QLed.Grey)
self.qLed_3_6.setOffColour(QLed.Grey)
self.qLed_3_7.setOffColour(QLed.Grey)
self.qLed_4_1.setOffColour(QLed.Grey)
self.qLed_4_2.setOffColour(QLed.Grey)
self.qLed_4_3.setOffColour(QLed.Grey)
self.qLed_4_4.setOffColour(QLed.Grey)
self.qLed_4_5.setOffColour(QLed.Grey)
self.qLed_4_6.setOffColour(QLed.Grey)
self.qLed_4_7.setOffColour(QLed.Grey)
self.qLed_5_1.setOffColour(QLed.Grey)
self.qLed_5_2.setOffColour(QLed.Grey)
self.qLed_5_3.setOffColour(QLed.Grey)
self.qLed_5_4.setOffColour(QLed.Grey)
self.qLed_5_6.setOffColour(QLed.Grey)
self.qLed_5_7.setOffColour(QLed.Grey)
self.qLed_5_8.setOffColour(QLed.Grey)
self.qLed_6_1.setOffColour(QLed.Grey)
self.qLed_6_2.setOffColour(QLed.Grey)
self.qLed_6_3.setOffColour(QLed.Grey)
self.qLed_6_4.setOffColour(QLed.Grey)
self.qLed_6_5.setOffColour(QLed.Grey)
self.qLed_6_6.setOffColour(QLed.Grey)
self.qLed_6_7.setOffColour(QLed.Grey)
self.qLed_7_1.setOffColour(QLed.Grey)
self.qLed_7_2.setOffColour(QLed.Grey)
self.qLed_7_3.setOffColour(QLed.Grey)
self.qLed_7_4.setOffColour(QLed.Grey)
self.qLed_7_5.setOffColour(QLed.Grey)
self.qLed_7_6.setOffColour(QLed.Grey)
self.qLed_7_7.setOffColour(QLed.Grey)
#Salir
def closeEvent(self, event):
try:
self.Server.close_socket()
self.RT.cancel()
event.accept()
except:
event.accept()
class Main(QtGui.QWidget):
def __init__(self, parent=None):
super(Main, self).__init__(parent)
self.setWindowTitle('Data Chest Image Browser')
# Add in Rabi plot.
self.setWindowIcon(QtGui.QIcon('rabi.jpg'))
self.root = os.environ["DATA_ROOT"]
if "\\" in self.root:
self.root = self.root.replace("\\", '/')
self.pathRoot = QtCore.QString(self.root)
self.filters = QtCore.QStringList()
self.filters.append("*.hdf5")
self.dataChest = dataChest("", self.root)
self.local_tz = tz.tzlocal()
self.utc = tz.gettz('UTC')
# Directory browser configuration.
self.model = QtGui.QFileSystemModel(self)
self.model.setRootPath(QtCore.QString(self.root))
self.model.setNameFilterDisables(False)
self.model.nameFilterDisables()
self.model.setNameFilters(self.filters)
self.indexRoot = self.model.index(self.model.rootPath())
self.directoryBrowserLabel = QtGui.QLabel(self)
self.directoryBrowserLabel.setText("Directory Browser:")
self.directoryTree = QtGui.QTreeView(self)
self.directoryTree.setModel(self.model)
self.directoryTree.setRootIndex(self.indexRoot)
self.directoryTree.header().setResizeMode(
QtGui.QHeaderView.ResizeToContents)
self.directoryTree.header().setStretchLastSection(False)
self.directoryTree.clicked.connect(self.dirTreeSelectionMade)
# Plot types drop down list configuration.
self.plotTypesComboBoxLabel = QtGui.QLabel(self)
self.plotTypesComboBoxLabel.setText("Available Plot Types:")
self.plotTypesComboBox = QtGui.QComboBox(self)
self.plotTypesComboBox.activated[str].connect(self.plotTypeSelected)
# Configure scrolling widget.
self.scrollWidget = QtGui.QWidget(self)
self.scrollLayout = QtGui.QHBoxLayout(self)
self.scrollWidget.setLayout(self.scrollLayout)
self.scrollArea = QtGui.QScrollArea(self)
self.scrollArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
self.scrollArea.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAsNeeded)
self.scrollArea.setWidget(self.scrollWidget)
self.scrollArea.setWidgetResizable(True) # What happens without?
vbox = QtGui.QVBoxLayout()
vbox.addWidget(self.directoryBrowserLabel)
vbox.addWidget(self.directoryTree)
vbox.addWidget(self.plotTypesComboBoxLabel)
vbox.addWidget(self.plotTypesComboBox)
vbox.addWidget(self.scrollArea)
self.mplwindow = QtGui.QWidget(self)
self.mplvl = QtGui.QVBoxLayout(self.mplwindow)
hbox = QtGui.QHBoxLayout()
hbox.addLayout(vbox)
hbox.addWidget(self.mplwindow)
self.setLayout(hbox)
self.currentFig = Figure()
self.addFigureToCanvas(self.currentFig)
self.filePath = None # redundant
self.fileName = None # redundant
self.plotType = None # redundant
self.varsToIgnore = []
def plotTypeSelected(self, plotType):
# Called when a plotType selection is made from drop down.
# self.plotTypesComboBox.adjustSize()
if plotType != self.plotType:
self.removeFigFromCanvas()
self.currentFig = self.figFromFileInfo(self.filePath,
self.fileName,
selectedPlotType=plotType)
self.addFigureToCanvas(self.currentFig)
self.updatePlotTypeOptions(plotType)
self.plotType = plotType
# When is best time to do this?
self.varsToIgnore = []
def updatePlotTypeOptions(self, plotType, depVarName=None):
# Update area below plotType, selection drop down (add/remove variables)
self.clearLayout(self.scrollLayout)
if plotType == "1D" or plotType == "Histogram":
headerList = ["Dep Var:", "Status:"]
widgetTypeList = ["QLabel", "QCheckBox"]
depVarList = [row[0] for row in self.dataChest.getVariables()[1]]
for ii in range(0, len(headerList)):
optionsSlice = QtGui.QVBoxLayout()
label = QtGui.QLabel(self) # widget to log
label.setText(headerList[ii])
optionsSlice.addWidget(label)
for depVar in depVarList:
if widgetTypeList[ii] == "QLabel":
label = QtGui.QLabel(self) # widget to log
label.setText(depVar)
optionsSlice.addWidget(label)
elif widgetTypeList[ii] == "QCheckBox":
checkBox = QtGui.QCheckBox('', self) # widget to log
checkBox.setCheckState(QtCore.Qt.Checked)
checkBox.stateChanged.connect(
partial(self.varStateChanged, depVar))
optionsSlice.addWidget(checkBox)
optionsSlice.addStretch(1)
self.scrollLayout.addLayout(optionsSlice)
self.scrollLayout.addStretch(1)
elif plotType == '2D Image':
headerList = ["Dep Var:", "Status:"]
widgetTypeList = ["QLabel", "QCheckBox"]
depVarList = [row[0] for row in self.dataChest.getVariables()[1]]
if depVarName is None:
depVarName = depVarList[0]
for ii in range(0, len(headerList)):
optionsSlice = QtGui.QVBoxLayout()
label = QtGui.QLabel(self) # widget to log
label.setText(headerList[ii])
optionsSlice.addWidget(label)
for depVar in depVarList:
if widgetTypeList[ii] == "QLabel":
label = QtGui.QLabel(self) # widget to log
label.setText(depVar)
optionsSlice.addWidget(label)
elif widgetTypeList[ii] == "QCheckBox":
checkBox = QtGui.QCheckBox('', self) # widget to log
print "depVarName=", depVarName
if depVar == depVarName:
checkBox.setCheckState(QtCore.Qt.Checked)
checkBox.stateChanged.connect(
partial(self.varStateChanged, depVar))
optionsSlice.addWidget(checkBox)
optionsSlice.addStretch(1)
self.scrollLayout.addLayout(optionsSlice)
self.scrollLayout.addStretch(1)
def clearLayout(self, layout):
# Clear the plotType options layout and all widgets therein.
for i in reversed(range(layout.count())):
item = layout.itemAt(i)
if isinstance(item, QtGui.QWidgetItem):
item.widget().close()
elif not isinstance(item, QtGui.QSpacerItem):
self.clearLayout(item.layout())
# remove the item from layout
layout.removeItem(item)
def varStateChanged(self, name, state):
# Add/remove variables from current displayed plot.
if state == QtCore.Qt.Checked:
self.varsToIgnore.remove(name)
# Remove old figure, needs garbage collection too.
self.removeFigFromCanvas()
self.currentFig = self.figFromFileInfo(
self.filePath,
self.fileName,
selectedPlotType=self.plotType,
varsToIgnore=self.varsToIgnore)
self.addFigureToCanvas(self.currentFig)
else: # unchecked
if name not in self.varsToIgnore:
self.varsToIgnore.append(name)
# Remove old figure, needs garbage collection too.
self.removeFigFromCanvas()
self.currentFig = self.figFromFileInfo(
self.filePath,
self.fileName,
selectedPlotType=self.plotType,
varsToIgnore=self.varsToIgnore)
self.updatePlotTypeOptions(self.plotType, '')
self.addFigureToCanvas(self.currentFig)
def convertPathToArray(self, path):
if self.root + "/" in path:
path = path.replace(self.root + "/", '')
elif self.root in path:
path = path.replace(self.root, '')
return path.split('/')
def addFigureToCanvas(self, fig):
# Addsmpl fig to the canvas.
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
def removeFigFromCanvas(self):
# Remove fig from the canvas.
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
self.currentFig.clf()
@QtCore.pyqtSlot(QtCore.QModelIndex) # logical flow could be improved
def dirTreeSelectionMade(self, index):
# Called when a directory tree selection is made.
indexItem = self.model.index(index.row(), 0, index.parent())
fileName = str(self.model.fileName(indexItem))
filePath = str(self.model.filePath(indexItem))
if ".hdf5" in filePath:
# Removes fileName from path if file is chosen.
filePath = filePath[:-(len(fileName) + 1)]
if self.fileName != fileName or self.filePath != filePath:
# If an actual change occurs update check what happens for
# just a folder.
self.filePath = filePath # Is there a point in storing this?
self.fileName = fileName
if ".hdf5" in fileName:
# fileName is not a directory, otherwise leave as is
# till a file is selected.
self.removeFigFromCanvas()
# Remove old figure, needs garbage collection too.
self.currentFig = self.figFromFileInfo(self.filePath,
self.fileName)
self.addFigureToCanvas(self.currentFig)
variables = self.dataChest.getVariables() # fine
dataCategory = self.categorizeDataset(variables) # fine
self.updatePlotTypesList(self.supportedPlotTypes(
dataCategory)) # fine: updates list
self.updatePlotTypeOptions(
self.supportedPlotTypes(dataCategory)[0])
self.plotType = self.supportedPlotTypes(dataCategory)[0]
self.varsToIgnore = [] # When is best time to do this?
else:
self.fileName = None
def updatePlotTypesList(self, plotTypes):
# Update plotTypes list based on selected dataset.
self.plotTypesComboBox.clear()
for element in plotTypes:
if ".dir" not in str(element) and ".ini" not in str(element):
self.plotTypesComboBox.addItem(str(element))
def categorizeDataset(self, variables):
# Categorizes dataset, this is now redundant.
indepVarsList = variables[0]
numIndepVars = len(indepVarsList)
if numIndepVars == 1:
return "1D"
elif numIndepVars == 2:
return "2D"
else:
return (str(numIndepVars) + "D")
def supportedPlotTypes(self, dimensionality):
# Provide list of plotTypes based on datasetType.
if dimensionality == "1D":
plotTypes = ["1D", "Histogram"]
elif dimensionality == "2D":
plotTypes = ["2D Image"]
else:
plotTypes = []
return plotTypes
# Some shape checking needs to go into this function to ensure
# 1D array inputs.
def plot1D(self, dataset, variables, plotType, dataClass, varsToIgnore=[]):
# Shorten this monstrosity!
# print "varsToIgnore=", varsToIgnore
if plotType == None:
plotType = self.supportedPlotTypes("1D")[0] # defaults
elif plotType not in self.supportedPlotTypes("1D"):
print "Unrecognized plot type was provided"
# Return bum fig with something cool, maybe a gif.
if plotType == "1D":
fig = self.basic1DPlot(dataset, variables, varsToIgnore)
elif plotType == "Histogram":
# Adjust bin size.
fig = self.basic1DHistogram(dataset, variables, varsToIgnore)
return fig
# Some shape checking needs to go into this function to ensure
# 2D array inputs.
def plot2D(self, dataset, variables, plotType, dataClass, varsToIgnore=[]):
# Shorten this monstrosity!
# print "varsToIgnore=", varsToIgnore
if plotType == None:
plotType = self.supportedPlotTypes("2D")[0] #defaults
elif plotType not in self.supportedPlotTypes("2D"):
print "Unrecognized plot type was provided"
# Return bum fig with something cool, maybe a gif.
if plotType == "2D Image":
fig = self.basic2DImage(dataset, variables, varsToIgnore)
#elif plotType == "Histogram": #adjust bin size
# fig = self.basic1DHistogram(dataset, variables, varsToIgnore)
return fig
def basic2DImage(self, dataset, variables, varsToIgnore):
fig = Figure(dpi=100)
ax = fig.add_subplot(111)
indepVars = variables[0]
depVars = variables[1]
if varsToIgnore == [depVars[ii][0] for ii in range(0, len(depVars))]:
return fig
# dataset = np.asarray(dataset)
xlabel = self.dataChest.getParameter("X Label", True)
if xlabel is None:
xlabel = indepVars[0][0]
ylabel = self.dataChest.getParameter("Y Label", True)
if ylabel is None:
# For data with more than one dep, recommend ylabel.
ylabel = depVars[0][0]
plotTitle = self.dataChest.getParameter("Plot Title", True)
if plotTitle is None:
plotTitle = self.dataChest.getDatasetName()
ax.set_title(plotTitle)
ax.set_xlabel(xlabel + " " + "(" + indepVars[0][3] + ")")
ax.set_ylabel(ylabel + " " + "(" + depVars[0][3] + ")")
# For multiple deps with different units this is ambiguous.
imageType = self.dataChest.getParameter("Image Type", True)
if imageType is None and self.dataChest.getDataCategory() == '2D Scan':
imageType = '2D Scan'
print "imageType=", imageType
if imageType is None:
dataset = np.asarray(dataset)
# Add or "scatter"
imageType = "Scatter"
print "Scatter"
for ii in range(0, len(depVars)):
x = dataset[::, 0]
y = dataset[::, 1]
z = dataset[::, 2]
im = ax.tricontourf(x,
y,
z,
100,
cmap=cm.gist_rainbow,
antialiased=True)
fig.colorbar(im, fraction=0.15)
break
elif imageType == "Pixel":
xGridRes = self.dataChest.getParameter("X Resolution", True)
xIncrement = self.dataChest.getParameter("X Increment", True)
yGridRes = self.dataChest.getParameter("Y Resolution", True)
yIncrement = self.dataChest.getParameter("Y Increment", True)
dataset = np.asarray(dataset)
x = dataset[::, 0].flatten()
y = dataset[::, 1].flatten()
z = dataset[::, 2].flatten()
if len(x) > 1:
if x[0] == x[1]:
sweepType = "Y"
else:
sweepType = "X"
print "sweepType=", sweepType
new = self.makeGrid(
x, xGridRes, xIncrement, y, yGridRes, yIncrement,
sweepType, z
) #makeGrid(self, x, xGridRes, dX, y, yGridRes, dY, sweepType, z)
X = new[0]
Y = new[1]
Z = new[2]
im = ax.imshow(Z,
extent=(X.min(), X.max(), Y.min(), Y.max()),
interpolation='nearest',
cmap=cm.gist_rainbow,
origin='lower')
fig.colorbar(im, fraction=0.15)
elif imageType == '2D Scan':
nx = len(dataset)
ny = len(dataset[0][2])
z = []
for ii in range(0, nx):
z.append(dataset[ii][2])
x = [dataset[0][0], dataset[-1][0]]
x = np.asarray(x)
y = np.linspace(dataset[0][1][0], dataset[0][1][1], ny)
z = np.asarray(z)
z = z.flatten()
z = z.reshape(nx, ny)
im = ax.imshow(z,
extent=(x.min(), x.max(), y.min(), y.max()),
aspect='auto',
interpolation='nearest',
cmap=cm.gist_rainbow,
origin='lower')
fig.colorbar(im, fraction=0.15)
elif imageType == "Buffered":
print "Buffered"
return fig
def _utc_to_local(self, utcDatetime):
localDatetime = utcDatetime.replace(tzinfo=self.utc)
return localDatetime.astimezone(self.local_tz)
def basic1DPlot(self, dataset, variables, varsToIgnore):
fig = Figure(dpi=100)
ax = fig.add_subplot(111)
indepVars = variables[0]
depVars = variables[1]
containsDatetime = False
for ii in range(0, len(indepVars)):
if 'utc_datetime' in indepVars[ii]:
containsDatetime = True
scanType = self.dataChest.getParameter("Scan Type", True)
xlabel = self.dataChest.getParameter("X Label", True)
if xlabel is None:
xlabel = indepVars[0][0]
ylabel = self.dataChest.getParameter("Y Label", True)
if ylabel is None:
# For data with more than one dep, recommend ylabel.
ylabel = depVars[0][0]
plotTitle = self.dataChest.getParameter("Plot Title", True)
if plotTitle is None:
plotTitle = self.dataChest.getDatasetName()
ax.set_title(plotTitle)
dataset = np.asarray(dataset)
ax.set_xlabel(xlabel + " " + "(" + indepVars[0][3] + ")")
ax.set_ylabel(ylabel + " " + "(" + depVars[0][3] + ")")
# For multiple deps with different units this is ambiguous.
for ii in range(0, len(depVars)):
if depVars[ii][0] not in varsToIgnore:
if scanType is None:
x = dataset[::, 0].flatten()
# Only works when all dims are same => perform checks.
y = dataset[::, 1 + ii].flatten()
if containsDatetime:
dStamp = dateStamp()
dates = []
for jj in range(0, len(y)):
dates.append(
self._utc_to_local(
datetime.strptime(
dStamp.floatToUtcDateStr(x[jj]),
'%Y-%m-%dT%H:%M:%S.%f')))
dates = np.asarray(dates)
print dates
dates = date2num(dates)
dateFmt = DateFormatter("%m/%d/%Y %H:%M:%S")
auto = AutoDateLocator()
ax.xaxis.set_major_locator(auto)
ax.xaxis.set_major_formatter(dateFmt)
ax.tick_params(axis='x', labelsize=9)
ax.grid(True)
ax.autoscale_view()
elif scanType == "Lin":
y = np.asarray(dataset[0][1 + ii])
# Only one row of data for this and log type supported.
x = np.linspace(dataset[0][0][0],
dataset[0][0][1],
num=len(y))
elif scanType == "Log":
y = dataset[0][1 + ii]
x = np.logspace(np.log10(dataset[0][0][0]),
np.log10(dataset[0][0][1]),
num=len(y))
ax.set_xscale('log')
#ax.plot(x, y, "o", label = depVars[ii][0])
if containsDatetime:
ax.plot_date(dates,
y,
tz=self.utc,
linestyle='-',
marker=',',
label=depVars[ii][0])
fig.autofmt_xdate()
fig.tight_layout()
else:
ax.plot(x, y, label=depVars[ii][0])
ax.legend(fontsize=10, loc="best")
return fig
def basic1DHistogram(self, dataset, variables, varsToIgnore):
fig = Figure(dpi=100)
ax = fig.add_subplot(111)
indepVars = variables[0]
depVars = variables[1]
scanType = self.dataChest.getParameter("Scan Type", True)
xlabel = self.dataChest.getParameter("X Label", True)
ylabel = self.dataChest.getParameter("Y Label", True)
if ylabel is None:
ylabel = depVars[0][0]
# For data with more than one dep, recommend ylabel.
plotTitle = self.dataChest.getParameter("Plot Title", True)
if plotTitle is None:
plotTitle = self.dataChest.getDatasetName()
ax.set_title(plotTitle)
dataset = np.asarray(dataset)
ax.set_xlabel(ylabel + " " + "(" + depVars[0][3] + ")")
# For multiple deps with different units this is ambiguous.
ax.set_ylabel("Statistical Frequency")
for ii in range(0, len(depVars)):
if depVars[ii][0] not in varsToIgnore:
if scanType is None:
y = dataset[::, 1 + ii].flatten()
elif scanType == "Lin":
y = dataset[0][1 + ii]
elif scanType == "Log":
y = dataset[0][1 + ii]
weights = np.ones_like(y) / float(len(y))
ax.hist(y,
100,
weights=weights,
alpha=0.5,
label=depVars[ii][0])
#ax.hist(y, 50, normed=1,weights =weights, alpha=0.5, label = depVars[ii][0])
ax.legend()
return fig
def figFromFileInfo(self,
filePath,
fileName,
selectedPlotType=None,
varsToIgnore=[]):
relPath = self.convertPathToArray(filePath)
self.dataChest.cd(relPath)
self.dataChest.openDataset(fileName)
variables = self.dataChest.getVariables()
dataCategory = self.categorizeDataset(variables)
#otherwise refer to dataset name needs to be implemented
dataset = self.dataChest.getData()
if dataCategory == "1D":
fig = self.plot1D(dataset,
variables,
selectedPlotType,
None,
varsToIgnore=varsToIgnore)
# plot1D(self, dataset, variables, plotType, dataClass, varsToIgnore = [])
elif dataCategory == "2D": #was "2D Sweep"
fig = self.plot2D(dataset,
variables,
selectedPlotType,
None,
varsToIgnore=varsToIgnore)
else:
print("1D data is the only type currently \r\n" +
"supported by this grapher.")
print("Attempted to plot " + dataCategory + " data.")
fig = Figure(dpi=100)
self.dataChest.cd("")
# yield self.cxn.data_vault.dump_existing_sessions()
return fig
def makeGrid(self, x, xGridRes, dX, y, yGridRes, dY, sweepType, z):
totalNumPts = len(x)
if sweepType == "Y":
# Y sweep type ==> fix x, sweep y, then go to x+dx and
# sweep y again...
divNmod = divmod(len(x), yGridRes)
numFullYslices = divNmod[0]
numPartiallyComplete = divNmod[1]
if numFullYslices < xGridRes:
npxRemainder = np.array([])
npyRemainder = np.array([])
# What kind of beast is the line below?
nanArray = np.zeros(shape=(yGridRes * xGridRes -
yGridRes * numFullYslices -
numPartiallyComplete, ))
nanArray[:] = np.NAN
# Is this pseudo-23 dimensional space definition?
npzRemainder = np.concatenate([
z[yGridRes * numFullYslices:yGridRes * numFullYslices +
numPartiallyComplete], nanArray
])
for ii in range(numFullYslices, xGridRes):
npxRemainder = np.concatenate([
npxRemainder,
np.linspace(dX * ii + x[0],
dX * ii + x[0],
num=yGridRes)
])
npyRemainder = np.concatenate([
npyRemainder,
np.linspace(y[0],
y[0] + (yGridRes - 1) * dY,
num=yGridRes)
])
else:
npxRemainder = np.array([])
npyRemainder = np.array([])
npzRemainder = np.array([])
npx = np.concatenate(
[x[0:yGridRes * numFullYslices], npxRemainder])
npy = np.concatenate(
[y[0:yGridRes * numFullYslices], npyRemainder])
npz = np.concatenate(
[z[0:yGridRes * numFullYslices], npzRemainder])
npx = npx.reshape(xGridRes, yGridRes).T
npy = npy.reshape(xGridRes, yGridRes).T
npz = npz.reshape(xGridRes, yGridRes).T
elif sweepType == "X":
# X sweep type ==> fix y, sweep x, then go to x+dy and
# sweep y again...
divNmod = divmod(len(x), xGridRes)
numFullXslices = divNmod[0]
numPartiallyComplete = divNmod[1]
if numFullXslices < yGridRes:
npxRemainder = np.array([])
npyRemainder = np.array([])
nanArray = np.zeros(shape=(yGridRes * xGridRes -
xGridRes * numFullXslices -
numPartiallyComplete, ))
nanArray[:] = np.NAN
npzRemainder = np.concatenate([
z[xGridRes * numFullXslices:xGridRes * numFullXslices +
numPartiallyComplete], nanArray
])
for ii in range(numFullXslices, yGridRes):
npyRemainder = np.concatenate([
npyRemainder,
np.linspace(dY * ii + y[0],
dY * ii + y[0],
num=xGridRes)
])
npxRemainder = np.concatenate([
npxRemainder,
np.linspace(x[0],
x[0] + (xGridRes - 1) * dX,
num=xGridRes)
])
else:
npxRemainder = np.array([])
npyRemainder = np.array([])
npzRemainder = np.array([])
npx = np.concatenate(
[x[0:xGridRes * numFullXslices], npxRemainder])
npy = np.concatenate(
[y[0:xGridRes * numFullXslices], npyRemainder])
npz = np.concatenate(
[z[0:xGridRes * numFullXslices], npzRemainder])
npx = npx.reshape(xGridRes, yGridRes)
npy = npy.reshape(xGridRes, yGridRes)
npz = npz.reshape(xGridRes, yGridRes)
return (npx, npy, npz)
class MainWindow(QtGui.QMainWindow, OnClick, OnMotion):
def __init__(self):
super(MainWindow, self).__init__()
uic.loadUi("PeakInspector_layout.ui", self)
self.setWindowTitle("PeakInspector (beta) (c) A.Salykin - Masaryk University - CC-BY-SA 4.0")
# main variable:
self.multiple_data_sets = pd.DataFrame() # Initialise the final dataframe to export to Excel
self.coordinates = []
self.area = []
self.amplitudes = []
self.amplitude_line_coordinates = []
self.left_peak_border = []
self.right_peak_border = []
self.pickable_artists_pts_AX2 = []
self.pickable_artists_pts_AX3 = []
self.pickable_artists_lns_AX3 = []
self.pickable_artists_fill_AX3 = []
self.pickable_artists_plb_AX3 = []
self.pickable_artists_prb_AX3 = []
self.pickable_artists_lnsP_AX3 = []
self.left_border = []
self.right_border = []
# Connect buttons to class methods:
self.BtnLoadFile.clicked.connect(self.load_file)
self.BtnReplot.clicked.connect(self.replot_graph)
self.chbxDotPickEnable.stateChanged.connect(self.dot_pick_enable)
self.BtnSaveCurrent.clicked.connect(self.coordinates_analysis)
self.BtnSaveFullDataset.clicked.connect(self.save_data)
self.BoxMplPlotStyle.currentIndexChanged.connect(self.mpl_style_change)
style.use(self.BoxMplPlotStyle.currentText())
self.BtnLoadFile.setStyleSheet("background-color: #7CF2BD")
self.BtnReplot.setStyleSheet("background-color: #FAF6F2")
self.BtnSaveCurrent.setStyleSheet("background-color: #FAF6F2")
self.BtnSaveFullDataset.setStyleSheet("background-color: #FAF6F2")
# Initialise figure instance
self.fig = plt.figure()
self.show()
def addmpl(self, ):
self.canvas = FigureCanvas(self.fig)
self.toolbar = NavigationToolbar(self.canvas, self.CanvasWidget, coordinates=True)
self.CanvasLayout.addWidget(self.toolbar)
self.CanvasLayout.addWidget(self.canvas)
if self.chbxDotPickEnable.isChecked():
self.cid_click = self.canvas.mpl_connect('button_press_event', self.on_click)
self.cid_motion = self.canvas.mpl_connect('motion_notify_event', self.on_motion)
self.canvas.draw()
def rmmpl(self, ): #
self.canvas.mpl_disconnect(self.cid_click)
self.canvas.mpl_disconnect(self.cid_motion)
self.CanvasLayout.removeWidget(self.canvas)
self.canvas.close()
self.CanvasLayout.removeWidget(self.toolbar)
self.toolbar.close()
def dot_pick_enable(self, ): # if checked, user can choose peaks
try: # if figure and canvas is initiated
if self.chbxDotPickEnable.isChecked():
self.cid_click = self.canvas.mpl_connect('button_press_event', self.on_click)
self.cid_motion = self.canvas.mpl_connect('motion_notify_event', self.on_motion)
else:
self.canvas.mpl_disconnect(self.cid_click)
self.canvas.mpl_disconnect(self.cid_motion)
except:
message = MessageBox()
message.about(self, 'Warning!', "File was not loaded! \n Please be sure that your file has \
\n 1) 1 or 2 columns; \n 2) check headers, footers and delimeter \n and try again.")
def load_file(self, ):
self.BtnLoadFile.setStyleSheet("background-color: #FAF6F2")
# Check if we already have some file loaded - then remove canvas
if hasattr(self, 'cid_click'):
self.rmmpl()
# Make sure that np data arrays and lists from previous dataset are empty
self.x = np.empty([])
self.y = np.empty([])
self.clear_data()
name = QtGui.QFileDialog.getOpenFileName(self, 'Open File')
if not name:
return self.import_error()
# get more readable file name for graph title
try:
slash_index = self.find_character(name, '/')
dot_index = self.find_character(name, '.')
self.graph_name = name[slash_index[-1] + 1:dot_index[-1]]
except:
self.graph_name = name[-10:]
skip_header_rows = self.BoxSkipHeader.value()
skip_footer_rows = self.BoxSkipFooter.value()
if self.BoxDelimeterChoice.currentText() == 'Tab':
delimiter = "\t"
elif self.BoxDelimeterChoice.currentText() == 'Space':
delimiter = " "
elif self.BoxDelimeterChoice.currentText() == 'Comma':
delimiter = ","
elif self.BoxDelimeterChoice.currentText() == 'Dot':
delimiter = "."
# unpack file
try: # if data file has 2 columns
self.x, self.y = np.genfromtxt(name,
delimiter = delimiter,
skip_header = skip_header_rows,
skip_footer = skip_footer_rows,
unpack = True)
if len(self.y) < 100:
return self.import_error()
return self.process_opened_file()
except: # if data file has 1 column
self.y = np.genfromtxt(name,
skip_header=skip_header_rows,
skip_footer=skip_footer_rows, unpack=True)
if len(self.y) < 100:
return self.import_error()
self.x = np.arange(0, len(self.y), 1)
return self.process_opened_file()
def import_error(self,):
message = MessageBox()
message.about(self, 'Warning!', "Data were not loaded. \n Please, be sure that:\n "
"1. Data have 1 or 2 columns.\n"
"2. Data are longer than 100 points.\n"
"3. Delimiter is correctly specified.\n"
"4. Rows in data contain only numeric values\n")
def process_opened_file(self, ):
self.x = tuple(self.x)
self.data_preprocessing(self.y)
self.baseline_calculation()
self.plot_data()
def data_preprocessing(self, data_to_preprocess):
try:
# Detrend dataset
if self.chbxDetrendData.isChecked():
self.data_detrended = sig.detrend(data_to_preprocess)
else:
self.data_detrended = data_to_preprocess
# Application of Savitzkyi-Golay filter for data smoothing
sg_window_frame = self.BoxSGwindowFrame.value()
sg_polynom_degree = self.BoxSGpolynomDegree.value()
self.data_after_filter = sig.savgol_filter(self.data_detrended, sg_window_frame, sg_polynom_degree)
except:
message = MessageBox()
message.about(self, 'Warning!',
"Not possible to detrend and/or smooth data! \n Please check your dataset and try again.")
def baseline_calculation(self, ):
'''
Calculate baseline of detrended data and add it to dataset for baseline to be equal 0
'''
databaseline = min(self.data_after_filter)
if self.chbxDetrendData.isChecked():
self.data_after_filter = [i + abs(databaseline) for i in self.data_after_filter]
self.data_detrended = [i + abs(databaseline) for i in self.data_detrended]
else:
self.data_after_filter = [i - abs(databaseline) for i in self.data_after_filter]
self.data_detrended = [i - abs(databaseline) for i in self.data_detrended]
def interpolation(self, p1, p2, left_index, right_index):
f = interpolate.interp1d([p1[0], p2[0]], [p1[1], p2[1]])
num = len(self.x[left_index:right_index])
xx = np.linspace(self.x[left_index], self.x[right_index], num)
return f(xx)
def plot_data(self, ):
if self.BoxPlotCustomStyle.currentText() == 'Line':
plot_style_custom = '-'
marker_size = 1
elif self.BoxPlotCustomStyle.currentText() == 'Line & small markers':
plot_style_custom = 'o-'
marker_size = 3
elif self.BoxPlotCustomStyle.currentText() == 'Line & big markers':
plot_style_custom = 'o-'
marker_size = 6
elif self.BoxPlotCustomStyle.currentText() == 'Small markers':
plot_style_custom = 'o'
marker_size = 3
elif self.BoxPlotCustomStyle.currentText() == 'Big markers':
plot_style_custom = 'o'
marker_size = 6
font_size = 14
self.ax1 = plt.subplot2grid((4, 1), (0, 0), rowspan=1, colspan=1)
plt.title(self.graph_name)
self.ax1.plot(self.x, self.y, plot_style_custom, ms=marker_size, linewidth=1) # plot raw data
plt.ylabel('Original raw data', fontsize=font_size)
self.ax2 = plt.subplot2grid((4, 1), (1, 0), rowspan=1, colspan=1)
self.ax2.plot(self.x, self.data_detrended, plot_style_custom, ms=marker_size, linewidth=1) # plot detrended data
plt.ylabel('Detrended data', fontsize=font_size)
self.ax3 = plt.subplot2grid((4, 1), (2, 0), rowspan=2, colspan=1, sharex=self.ax2, sharey=self.ax2)
self.ax3.plot(self.x, self.data_after_filter, plot_style_custom, ms=marker_size, linewidth=1) # plot filtered detrended data
self.baselinePlotArtist = self.ax3.plot([self.x[0], self.x[-1]], [0, 0], 'k', linewidth=1) # plot baseline
plt.ylabel('Savitzky-Golay filter \n for detrended data', fontsize=font_size)
self.ax3.set_xlim(0, self.x[-1])
plt.xlabel('Time, sec')
self.addmpl()
def replot_graph(self, ):
self.clear_data()
self.rmmpl()
self.data_preprocessing(self.y)
self.baseline_calculation()
self.plot_data()
def coordinates_analysis(self, ):
"""
Main function
"""
coord_x, coord_y = zip(*self.coordinates)
leftpb_x, leftpb_y = zip(*self.left_peak_border)
rightpb_x, rightpb_y= zip(*self.right_peak_border)
# absolute amplitude % and MAX
relative_amplitude = []
ampl_max = max(self.amplitudes)
relative_amplitude[:] = [(i / ampl_max) for i in self.amplitudes]
# create temporal Pandas DataFrame for sorting and calculation:
temp_dataset = list(
zip(coord_x, self.amplitudes, relative_amplitude, leftpb_x, leftpb_y, rightpb_x, rightpb_y, self.area))
df = pd.DataFrame(data=temp_dataset,
columns=['Peak Time',
'Amplitude',
'Relative Amplitude \n (F/Fmax)',
'Peak Start Time',
'Peak Start Ordinate',
'Peak Stop Time',
'Peak Stop Ordinate',
'Area'])
# Sort data in DataFrame according to the time of peak appearance
df_sorted = df.sort_values(['Peak Time'], ascending=True)
df_sorted.index = range(0, len(df_sorted)) # reset indexing
# calculate periods
periods = []
for i in range(1, len(df_sorted['Peak Time'])):
periods.append(df_sorted.at[i, 'Peak Time'] - df_sorted.at[i - 1, 'Peak Time'])
periods.insert(0, np.nan) # add placeholder because len(periods)=len(peaks)-1
# calculate frequencies based on calculated periods
frequencies = []
frequencies[:] = [(1 / i) for i in periods]
# Analise peak start - stop time (left and right peak borders)
peak_full_time = []
for i in range(0, len(df_sorted['Peak Time']), 1):
peak_full_time.append(df_sorted.at[i, 'Peak Stop Time'] - df_sorted.at[i, 'Peak Start Time'])
peak_up_time = []
for i in range(0, len(df_sorted['Peak Time']), 1):
peak_up_time.append(df_sorted.at[i, 'Peak Time'] - df_sorted.at[i, 'Peak Start Time'])
peak_down_time = []
for i in range(0, len(df_sorted['Peak Time']), 1):
peak_down_time.append(df_sorted.at[i, 'Peak Stop Time'] - df_sorted.at[i, 'Peak Time'])
# Compute area under the peak using the composite trapezoidal rule.
peak_area = []
for i in range(0, len(df_sorted['Peak Time']), 1):
peak_area.append(np.trapz(df_sorted.at[i, 'Area']))
# Analise the peak decay area
half_decay_time = []
half_decay_amplitude = []
for i in range(0, len(df_sorted['Peak Time']), 1):
half_decay_ampl = df_sorted.at[i, 'Amplitude'] / 2 # calculate the half of the amplitude
peak_index = self.x.index(df_sorted.at[i, 'Peak Time']) # find index of the peak time
stop_idx = self.x.index(df_sorted.at[i, 'Peak Stop Time']) # find index of the right peak border
data_decay_region = self.data_after_filter[peak_index:stop_idx] # determine the amplitude region where to search for halftime decay index
time_decay_region = self.x[peak_index:stop_idx]
half_decay_idx = (np.abs(data_decay_region - half_decay_ampl)).argmin() # find the closet value in data_decay_region that corresponds to the half amplitude
half_decay_amplitude.append(half_decay_ampl)
half_decay_time.append(time_decay_region[half_decay_idx] - df_sorted.at[i, 'Peak Time'])
# Compute amplitude normalised to the baseline
normalised_amplitude = []
sg_window_frame = self.BoxSGwindowFrame.value()
sg_polynom_degree = self.BoxSGpolynomDegree.value()
orig_data_filtered = sig.savgol_filter(self.y, sg_window_frame, sg_polynom_degree)
for i in range(0, len(df_sorted['Peak Time']), 1):
start_idx = self.x.index(df_sorted.at[i, 'Peak Start Time'])
F0 = orig_data_filtered[start_idx]
amplitude_normed_computation = df_sorted.at[i, 'Amplitude'] / F0
normalised_amplitude.append(amplitude_normed_computation)
# normalised amplitude %
relative_normalised_amplitude = []
maxATB = max(normalised_amplitude)
relative_normalised_amplitude[:] = [(i / maxATB) for i in normalised_amplitude]
# normalised amplitude MAX
normalised_amplitude_max = list(range(0, len(df_sorted['Peak Time']) - 1))
normalised_amplitude_max[:] = [np.nan for _ in normalised_amplitude_max]
normalised_amplitude_max.insert(0, maxATB)
# add file name as first column
file_name = list(range(0, len(df_sorted['Peak Time']) - 1))
file_name[:] = [np.nan for _ in file_name]
file_name.insert(0, self.graph_name)
# add maximum amplitude
absolute_amplitude_max = list(range(0, len(df_sorted['Peak Time']) - 1))
absolute_amplitude_max[:] = [np.nan for _ in absolute_amplitude_max]
absolute_amplitude_max.insert(0, max(df_sorted['Amplitude']))
# peak sorting
big_peaks_number = [p for p in self.amplitudes if (p > ampl_max * 0.66)]
medium_peaks_number = [p for p in self.amplitudes if (p > ampl_max * 0.33 and p <= ampl_max * 0.66)]
small_peaks_number = [p for p in self.amplitudes if (p > 0 and p <= ampl_max * 0.33)]
big_peaks_frequency = list(range(0, len(df_sorted['Peak Time']) - 1))
big_peaks_frequency[:] = [np.nan for _ in big_peaks_frequency]
big_peaks_frequency.insert(0, len(big_peaks_number) / (self.x[-1] - self.x[0]))
medium_peaks_frequency = list(range(0, len(df_sorted['Peak Time']) - 1))
medium_peaks_frequency[:] = [np.nan for _ in medium_peaks_frequency]
medium_peaks_frequency.insert(0, len(medium_peaks_number) / (self.x[-1] - self.x[0]))
small_peaks_frequency = list(range(0, len(df_sorted['Peak Time']) - 1))
small_peaks_frequency[:] = [np.nan for _ in small_peaks_frequency]
small_peaks_frequency.insert(0, len(small_peaks_number) / (self.x[-1] - self.x[0]))
final_dataset = list(zip(file_name,
df_sorted['Peak Time'],
df_sorted['Amplitude'],
df_sorted['Relative Amplitude \n (F/Fmax)'],
absolute_amplitude_max,
normalised_amplitude,
relative_normalised_amplitude,
normalised_amplitude_max,
periods,
frequencies,
half_decay_time,
half_decay_amplitude,
df_sorted['Peak Start Time'],
df_sorted['Peak Start Ordinate'],
df_sorted['Peak Stop Time'],
df_sorted['Peak Stop Ordinate'],
peak_up_time,
peak_down_time,
peak_full_time,
peak_area,
big_peaks_frequency,
medium_peaks_frequency,
small_peaks_frequency))
final_dataframe = pd.DataFrame(data=final_dataset,
columns=['File name',
'Peak time',
'Absolute amplitude',
'Absolute amplitude (%)',
'Absolute amplitude MAX',
'Normalised amplitude',
'Normalised amplitude (%)',
'Normalised amplitude MAX',
'Period',
'Frequency',
'Half-decay time',
'Half-decay amplitude',
'Start time',
'Start ordinate',
'Stop time',
'Stop ordinate',
'Ascending time',
'Decay time',
'Full peak time',
'AUC',
'Big peaks, Hz',
'Mid peaks, Hz',
'Small peaks, Hz'])
# specify data for export acording to the settings tab in GUI
# and append current analysed dataset to existing ones
try:
columns_to_delete_for_export = []
if not self.chbxFileName.isChecked(): columns_to_delete_for_export.append('File name')
if not self.chbxPeakTime.isChecked(): columns_to_delete_for_export.append('Peak time')
if not self.chbxAmplAbs.isChecked(): columns_to_delete_for_export.append('Absolute amplitude')
if not self.chbxAmplAbsRel.isChecked(): columns_to_delete_for_export.append('Absolute amplitude (%)')
if not self.chbxAmplAbsMax.isChecked(): columns_to_delete_for_export.append('Absolute amplitude MAX')
if not self.chbxAmplNorm.isChecked(): columns_to_delete_for_export.append('Normalised amplitude')
if not self.chbxAmplNormRel.isChecked(): columns_to_delete_for_export.append('Normalised amplitude (%)')
if not self.chbxAmplNormMax.isChecked(): columns_to_delete_for_export.append('Normalised amplitude MAX')
if not self.chbxPeriod.isChecked(): columns_to_delete_for_export.append('Period')
if not self.chbxFreq.isChecked(): columns_to_delete_for_export.append('Frequency')
if not self.chbxHalfDecayTime.isChecked(): columns_to_delete_for_export.append('Half-decay time')
if not self.chbxHalfDecayAmpl.isChecked(): columns_to_delete_for_export.append('Half-decay amplitude')
if not self.chbxLeftBorderTime.isChecked(): columns_to_delete_for_export.append('Start time')
if not self.chbxLeftBorder.isChecked(): columns_to_delete_for_export.append('Start ordinate')
if not self.chbxRightBorderTime.isChecked(): columns_to_delete_for_export.append('Stop time')
if not self.chbxRightBorder.isChecked(): columns_to_delete_for_export.append('Stop ordinate')
if not self.chbxTimeToPeak.isChecked(): columns_to_delete_for_export.append('Ascending time')
if not self.chbxDecayTime.isChecked(): columns_to_delete_for_export.append('Decay time')
if not self.chbxFullPeakTime.isChecked(): columns_to_delete_for_export.append('Full peak time')
if not self.chbxAUC.isChecked(): columns_to_delete_for_export.append('AUC')
if not self.chbxSmallPeaks.isChecked(): columns_to_delete_for_export.append('Big peaks, Hz')
if not self.chbxMidPeaks.isChecked(): columns_to_delete_for_export.append('Mid peaks, Hz')
if not self.chbxBigPeaks.isChecked(): columns_to_delete_for_export.append('Small peaks, Hz')
final_dataframe.drop(columns_to_delete_for_export, axis=1, inplace=True)
self.multiple_data_sets = self.multiple_data_sets.append(final_dataframe)
if self.chbxSaveFig.isChecked():
os.makedirs('_Figures', exist_ok=True)
dpi = self.BoxDPI.value()
plt.savefig(os.path.join('_Figures', 'Fig_{figName}.png'.format(figName=self.graph_name)), dpi=dpi)
del df
del df_sorted
del final_dataframe
dialog = MessageBox.question(self, '', "Current dataset was analysed \n and added to previous ones (if exist). \n Would you like to load next file? ",
QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if dialog == QtGui.QMessageBox.Yes:
self.load_file()
else:
self.rmmpl()
self.BtnSaveFullDataset.setStyleSheet("background-color: #7CF2BD")
self.BtnLoadFile.setStyleSheet("background-color: #7CF2BD")
except:
message = MessageBox()
message.about(self, 'Warning!', "Data were not added to existing dataset. \n Plese be sure that you did not change the output settings.")
def save_data(self, ):
try:
file_name = QtGui.QFileDialog.getSaveFileName(self, 'Save file')
writer = pd.ExcelWriter('{}.xlsx'.format(file_name))
self.multiple_data_sets.to_excel(writer, index=True, sheet_name='Results')
writer.sheets['Results'].set_zoom(80)
writer.sheets['Results'].set_column('A:A', 5)
writer.sheets['Results'].set_column('B:X', 23)
writer.save()
message = MessageBox()
message.about(self, 'Data saved', "Data were saved!")
self.multiple_data_sets = pd.DataFrame()
self.BtnSaveFullDataset.setStyleSheet("background-color: #FAF6F2")
self.BtnLoadFile.setStyleSheet("background-color: #7CF2BD")
except:
message = MessageBox()
message.about(self, 'Warning!', "Data were not exported to Excel! \n Please try again.")
def mpl_style_change(self, ):
style.use(self.BoxMplPlotStyle.currentText())
def clear_data(self):
self.coordinates = []
self.area = []
self.amplitudes = []
self.amplitude_line_coordinates = []
self.left_peak_border = []
self.right_peak_border = []
self.pickable_artists_pts_AX2 = []
self.pickable_artists_pts_AX3 = []
self.pickable_artists_lns_AX3 = []
self.pickable_artists_fill_AX3 = []
self.pickable_artists_plb_AX3 = []
self.pickable_artists_prb_AX3 = []
self.pickable_artists_lnsP_AX3 = []
def closeEvent(self, event):
"""Exchange default event to add a dialog"""
if self.multiple_data_sets.empty:
reply = MessageBox.question(self, 'Warning!',
"Are you sure to quit?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
else:
reply = MessageBox.question(self, 'Warning!',
"You have unsaved analysed data! \n Are you sure to quit?",
QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
event.accept()
else:
event.ignore()
@staticmethod
def find_character(s, ch): # for graph title
return [i for i, ltr in enumerate(s) if ltr == ch]
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
#data_dict stores all loaded data sets
self.data_dict = {}
self.mplfigs.itemSelectionChanged.connect(self.changefig)
self.folderSelect.clicked.connect(self.onSelectFolder)
self.saveFit.clicked.connect(self.onSaveFit)
self.cancelFit.clicked.connect(self.onCancelFit)
self.fitSelectedData.clicked.connect(self.onFit)
self.fitSelectedData.setEnabled(False)
self.selectPandasDB.clicked.connect(self.onSelectPandasDB)
self.QEntry.setValidator(QtGui.QIntValidator(1,1000000))
self.widthEdit.setValidator(QtGui.QIntValidator(1,10000))
self.widthEdit.setText(str(0))
self.powerType.setText(str(0))
self.powerValue.setText(str(0))
self.QEntry.setText(str(20000))
self.fNumber.setValue(1)
self.degeneracySelect.setCurrentIndex(0)
fig = Figure()
self.addmpl(fig)
self.activefig=None
self.activeDataSet=None
self.fittingWindow = None
self.df=pd.DataFrame()
self.testdf=pd.DataFrame()
self.onSelectPandasDB()
def onSelectPandasDB(self,):
"""Select a folder, the selected folder will be parsed for sub-folders.
Each of these subfolders will be turned into a xyData class which is
then stored in main with the adddata command"""
fileDialog=QtGui.QFileDialog(self)
fileName=fileDialog.getSaveFileName(self,
"Choose a pandasDB", homedir, filter ="csv (*.csv)")
self.pathtopandas=fileName
self.chipEdit.setText(self.pathtopandas)
print self.pathtopandas
def onSelectFolder(self,):
"""Select a folder, the selected folder will be parsed for sub-folders.
Each of these subfolders will be turned into a xyData class which is
then stored in main with the adddata command"""
self.fileDialog=QtGui.QFileDialog(self)
folderName=self.fileDialog.getExistingDirectory(self,
"Choose a folder", homedir, QtGui.QFileDialog.ShowDirsOnly)
for i in os.listdir(folderName):
if i[-4:] == ".txt":
self.adddata(i, xyData(os.path.join(folderName,i)))
def changefig(self, ):
item=self.mplfigs.currentItem()
if self.activefig==None:
pass
else:
self.activefig.canvas.mpl_disconnect(self.cid)
if self.fitSelectedData.isEnabled()==True:
pass
else:
self.fitSelectedData.setEnabled(True)
text = item.text()
self.rmmpl()
fig=self.data_dict[text].fig
self.addmpl(fig)
self.cid = fig.canvas.mpl_connect('button_press_event', self.onclick)
try:
self.widthEdit.setText(str(self.data_dict[text].deviceWid))
except ValueError:
pass
try:
self.rowEdit.setValue(int(self.data_dict[text].deviceRow))
except ValueError:
pass
try:
self.powerType.setText(str(self.data_dict[text].laserPowerType))
except ValueError:
pass
try:
self.powerValue.setText(str(self.data_dict[text].laserPower))
except ValueError:
pass
try:
self.columnEdit.setValue(int(self.data_dict[text].deviceCol))
except ValueError:
pass
try:
ind = self.deviceType.findText(str(self.data_dict[text].deviceType).strip())
self.deviceType.setCurrentIndex(ind)
except ValueError:
pass
self.activefig=fig
self.activeDataSet=self.data_dict[text]
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self,):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
# self.activefig.canvas.mpl_disconnect(self.cid)
#This has to be modified for data types other than a ZI data input
def adddata(self, name, xyDataClass):
self.data_dict[name] = xyDataClass
self.mplfigs.addItem(name)
#Clcik on active MPL window
def onclick(self, event):
# print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(event.button, event.x, event.y, event.xdata, event.ydata)
print self.activeDataSet.find_nearestx(event.xdata)
#gca can get limits of zoomed widow
def onFit(self,):
self.disableForFit()
def fitClick(self, event):
self.cancelFit.setEnabled(True)
print 'clicked'
self.activefig.canvas.mpl_disconnect(self.cid)
xi,xf = self.activeDataSet.fig.gca().get_xlim()
xi, xvi = self.activeDataSet.find_nearestx(xi)
xf, xvf = self.activeDataSet.find_nearestx(xf)
# General to this point, actual fit can vary below
x0 = event.xdata
y0 = event.ydata
Q = float(self.QEntry.text())
sigma=1/(2*Q)
print xi,xf, [x0,y0,sigma]
ip=[x0,y0,sigma]
print self.activeDataSet
out, params, outp, self.paramsp, dout = self.activeDataSet.fitDataSelection(xi,xf,ip)
self.outfit=out
self.currpars=params
self.fitfig=Figure()
ax=self.fitfig.add_subplot(1,1,1)
axt=ax.twinx()
ax.plot(self.activeDataSet.data.f[xi:xf+1], out.best_fit)
axt.plot(dout[0], outp.best_fit, 'g')
ax.plot(self.activeDataSet.data.f[xi:xf+1], self.activeDataSet.data.r[xi:xf+1], 'ro')
axt.plot(dout[0], dout[1], 'go')
idx=min(range(len(self.activeDataSet.data.f)), key=lambda x: abs(self.activeDataSet.data.f[x]-params[0]))
ax.annotate('Q = '+ str(params[3]) + '\n' + 'w_0 = '+ str(params[0]), xy=(params[0],self.activeDataSet.data.r[idx]), textcoords = 'data', xycoords='data')
self.rmmpl()
self.addmpl(self.fitfig)
self.activeFitParams = params
self.saveFit.setEnabled(True)
# plt.text(2, 0.65,'Q = '+ str(params[3]), fontdict=font)
def disableForFit(self,):
self.mplfigs.setEnabled(False)
self.fitSelectedData.setEnabled(False)
self.folderSelect.setEnabled(False)
self.activefig.canvas.mpl_disconnect(self.cid)
self.cid =self.activefig.canvas.mpl_connect('button_press_event', self.fitClick)
def enableAfterFit(self,):
self.toolbar.setEnabled(True)
self.mplfigs.setEnabled(True)
self.fitSelectedData.setEnabled(True)
self.folderSelect.setEnabled(True)
self.activefig.canvas.mpl_disconnect(self.cid)
self.rmmpl()
self.addmpl(self.activefig)
self.cid =self.activefig.canvas.mpl_connect('button_press_event', self.onclick)
def onSaveFit(self,):
self.w0=self.activeFitParams[0]
self.A=self.activeFitParams[1]
self.Q=self.activeFitParams[3]
self.lineInt=self.activeFitParams[4]
self.lineSlope=self.activeFitParams[5]
self.saveFit.setEnabled(False)
self.cancelFit.setEnabled(False)
curridx=self.mplfigs.currentItem().text()+'_'+str(self.fNumber.value())+'_' + self.degeneracySelect.currentText()
newrow=self.prepareDFRow(curridx)
try:
master=pd.read_csv(self.pathtopandas, index_col=0)
if curridx not in self.testdf.index:
newmaster=master.append(newrow)
print newmaster
newmaster.to_csv(self.pathtopandas[:-4]+'temp.csv')
os.remove(self.pathtopandas)
os.rename(self.pathtopandas[:-4]+'temp.csv',self.pathtopandas)
else:
print 'repeated fit'
except IOError:
newrow.to_csv(self.pathtopandas)
self.enableAfterFit()
def prepareDFRow(self, idx):
df = pd.DataFrame({'Run Name' : self.mplfigs.currentItem().text(), 'Device Name' : self.chipEdit.text(), 'Row Number' : \
self.rowEdit.value(), 'Column Number' : self.columnEdit.value(),\
'Device Type' : self.deviceType.currentText(), 'Device Width' : \
self.widthEdit.text(), 'Mode Order' : self.fNumber.value(), \
'Mode Type': self.degeneracySelect.currentText(), 'Frequency' : self.w0, 'Amplitude' : self.A, \
'Q' : self.Q, 'Bad Fit' : self.selectBadFit.checkState(), 'Power Measurement Type' : self.powerType.text(), 'Power (uW)' : self.powerValue.text(),\
'Fit Notes' : self.fitNotes.text(), 'Date' : self.activeDataSet.date, 'Intercept': self.lineInt, 'Slope':self.lineSlope, 'w0p': self.paramsp[0],'Qp': self.paramsp[1],'pm': self.paramsp[2],'pb': self.paramsp[3]}, index=[idx] )
return df
def onCancelFit(self,):
self.saveFit.setEnabled(False)
self.cancelFit.setEnabled(False)
self.enableAfterFit()
class Main(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.StartButton.clicked.connect(self.loadFile)
self.NextButton.clicked.connect(self.nextRecord)
self.DeleteButton.clicked.connect(self.deleteRecord)
self.GenerateButton.clicked.connect(self.generateRecord)
self.QuitButton.clicked.connect(self.quit)
self.horiz = GetSystemMetrics(0)
self.verti = GetSystemMetrics(1)
self.subjectNo = 0;
self.dayNo = 0;
self.blockNo = 0;
self.center_no = 0;
self.tr_no = 0;
self.old_x = 0
self.old_y = 0
self.old_t = 0
self.start=0;
self.vel_thresh = 500/4.25; #in pix/s
self.deleteThisRecord = 0;
self.generateAll = 0;
self.fileReadDone = 0;
self.AllStrings = []; #raw file.
self.AllGoodStrings = []; #filtered file
self.RandomStrings = [];
self.SequenceStrings = [];
self.RandomGoodStrings = [];
self.SequenceGoodStrings = [];
topics="tr_no Reaction_Time Movement_Time Response_Time Max_Vel Max_Acc End_Point_Dev Real_Distance Actual_Distance_Traversed Distance_Percent\n";
self.AllStrings.append(topics);
self.AllGoodStrings.append(topics);
self.RandomStrings.append(topics);
self.SequenceStrings.append(topics);
self.RandomGoodStrings.append(topics);
self.SequenceGoodStrings.append(topics);
self.cnx = mysql.connector.connect(user='******',password='******',database='mohand');
self.cursor = self.cnx.cursor();
self.smoothLevel = 20;
def addplot(self, fig):
#plt.savefig('common_labels_text.png', dpi=300)
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
self.addToolBar(self.toolbar)
def rmplot(self):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def loadFile(self):
print "load file"
self.X=[];
self.Y=[];
self.D=[];
self.V=[];
self.A=[];
self.T=[];
self.generateAll = 0;
self.fileReadDone = 0;
subNo = self.SubjectText.text()
d = self.DayCombo.currentIndex()
self.subjectNo = int(subNo);
self.dayNo = d+1;
self.blockNo = self.BlockCombo.currentIndex()+1
block = str(self.blockNo);
day = dayTitle(self.dayNo)
if self.dayNo<=5:
s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+subNo+"\\Subject" + subNo + day + "Block" + block + "_Data.txt";
else:
s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+subNo+"\\Subject" + subNo + day + "Data.txt";
center_file_s = "C:\\Users\\neuro\\Documents\\Visual Studio 2015\\Projects\\MohandTracker\\Mohands(4,6,5).txt";
print s
self.file = open(s, 'r');
self.center_file = open(center_file_s, 'r');
self.center_array = [[int(x) for x in line.split()] for line in self.center_file];
#print self.center_array
self.center_array_size = len(self.center_array[0]);
self.tr_no = 0;
self.start = 0;
self.smoothLevel = int(self.text_smooth.text());
self.getFig();
def getFig(self):
plt.close("all");
s1 = str(self.tr_no);
s2 = str(self.tr_no+1);
self.FromLabel.setText(s1);
self.ToLabel.setText(s2);
reac_time = 0;
react_time_set = 0;
response_time = 0;
if self.dayNo<=5 :
self.center_no = (5 * (self.dayNo-1) + self.blockNo-1) % self.center_array_size;
else :
self.center_no = (25 + self.dayNo % 2) % self.center_array_size;
if int(self.tr_no)<len(self.center_array):
present_target = (self.center_array[int(self.tr_no)][int(self.center_no)])%9;
#print self.tr_no, present_target;
iter_val = 0;
for line in self.file:
iter_val = iter_val+1;
tr_no, x , y , t = [float(i) for i in line.split()];
if iter_val%self.smoothLevel>0:
continue;
if self.start==0:
self.old_x = x;
self.old_y = y;
self.old_t = t;
self.X=[x];
self.Y=[y];
self.T=[t];
self.start=1;
continue
if tr_no == self.tr_no:
self.X.append(x);
self.Y.append(y);
self.T.append(t);
dist = math.sqrt((x-self.old_x)*(x-self.old_x) + (y-self.old_y)*(y-self.old_y));
if len(self.D)!=0:
self.D.append(dist+self.D[len(self.D)-1]);
else:
self.D.append(dist);
print t,self.old_t
vel = dist/(t-self.old_t);
if len(self.V)!=0 :
self.old_v = self.V[len(self.V)-1];
acc = (vel-self.old_v)/(t-self.old_t);
self.A.append(acc);
self.V.append(vel);
self.old_x = x
self.old_y = y
self.old_t = t
if (vel>self.vel_thresh) and (react_time_set==0):
reac_time = t;
react_time_set = 1;
if (vel>self.vel_thresh):
response_time = t;
movement_time = response_time - reac_time;
else:
print "len",len(self.T), len(self.D)
if self.T[len(self.T)-1]<=0.007 or self.T[len(self.T)-1]>=12: #filtering records based on the protocol.
self.deleteThisRecord = 1;
if self.generateAll==0:
fig = plt.figure()
a1 = fig.add_subplot(221)
a1.plot(self.X,self.Y);
a1.set_ylabel('Y');
a1.set_xlabel('X');
a1.plot(self.X[0],self.Y[0],'g+', mew=1.5, ms=15)
a1.plot(center_x(present_target),center_y(present_target),'ro', markerfacecolor='None', mew= 1, ms = 15)
a1.plot(center_x(present_target),center_y(present_target),'r.')
a1.axis([0,self.horiz/4.25,0,self.verti/4.25])
a2 = fig.add_subplot(222)
a2.plot(self.T[1:len(self.T)],self.D);
a2.set_ylabel('Distance from starting point');
a2.set_xlabel('Time');
a3 = fig.add_subplot(223)
a3.plot(self.T[1:len(self.T)],self.V);
a3.set_ylabel('Speed of cursor');
a3.set_xlabel('Time');
a4 = fig.add_subplot(224)
a4.plot(self.T[2:len(self.T)],self.A);
a4.set_ylabel('Acceleration of cursor');
a4.set_xlabel('Time');
self.rmplot()
self.addplot(fig)
max_vel = max(self.V);
max_acc = max(self.A);
end_point_dev = math.sqrt((self.X[len(self.X)-1]-center_x(present_target))*(self.X[len(self.X)-1]-center_x(present_target)) + (self.Y[len(self.Y)-1]-center_y(present_target))*(self.Y[len(self.Y)-1]-center_y(present_target)));
real_dist = math.sqrt((self.X[0]-self.X[len(self.X)-1])*(self.X[0]-self.X[len(self.X)-1]) + (self.Y[0]-self.Y[len(self.Y)-1])*(self.Y[0]-self.Y[len(self.Y)-1]));
actual_dist_traversed = self.D[len(self.D)-1];
dist_per = (actual_dist_traversed - real_dist)*100.0/real_dist ;
old_tr_no = self.tr_no;
self.old_x = x
self.old_y = y
self.old_t = t
self.tr_no = tr_no
self.D=[];
self.V=[];
self.A=[];
self.T=[t];
self.X=[x];
self.Y=[y];
break
else:
self.fileReadDone = 1;
if self.generateAll ==0:
s3 = "Reaction Time = " + str(reac_time);
s4 = "Movement Time = " + str(movement_time);
s5 = "Response Time = " + str(response_time);
s6 = "Max Velocity = " + str(max_vel);
s7 = "Max Acc = " + str(max_acc);
s8 = "End Point Deviation = " + str(end_point_dev);
s9 = "Real Distance = " + str(real_dist);
s10 = "Actual Distance Traversed = " + str(actual_dist_traversed);
s11 = "Distance Percent Deviation = " + str(dist_per);
self.Reaction_Time.setText(s3)
self.Movement_Time.setText(s4)
self.Response_Time.setText(s5)
self.Max_Velocity.setText(s6)
self.Max_Acc.setText(s7)
self.Deviation.setText(s8)
self.Real_Dist.setText(s9)
self.Actual_Dist.setText(s10)
self.Dist_Per.setText(s11)
if self.fileReadDone==0:
final_str = str(int(old_tr_no))+" "+str(reac_time)+" "+str(movement_time)+" "+str(response_time)+" "+str(max_vel)+" "+str(max_acc)+" "+str(end_point_dev)+" "+str(real_dist)+" "+str(actual_dist_traversed)+" "+str(dist_per)+"\n";
self.AllStrings.append(final_str);
if (old_tr_no%13)>=7 or (old_tr_no%13)==0:
self.SequenceStrings.append(final_str);
else:
self.RandomStrings.append(final_str);
def nextRecord(self):
self.writeToFilteredFile();
print "fetching next record"
#self.tr_no = self.tr_no+1;
self.getFig();
def writeToFilteredFile(self):
already_written_tr_no = -1;
if len(self.AllGoodStrings)>1:
filtered_data_list = [j for j in self.AllGoodStrings[len(self.AllGoodStrings)-1].split()]
already_written_tr_no = int(filtered_data_list[0]);
old_tr_no = int(self.AllStrings[len(self.AllStrings)-1].split()[0])
if (self.deleteThisRecord==0) and (int(old_tr_no)!=already_written_tr_no):
self.AllGoodStrings.append(self.AllStrings[len(self.AllStrings)-1]);
if (old_tr_no%13)>=7 or (old_tr_no%13)==0:
self.SequenceGoodStrings.append(self.AllStrings[len(self.AllStrings)-1]);
else:
self.RandomGoodStrings.append(self.AllStrings[len(self.AllStrings)-1]);
self.deleteThisRecord = 0;
def typeOfEntry(self,x):
return{
1: '_fil_rep',
2: '_fil_ran',
3: '_raw_rep',
4: '_raw_ran'
}.get(x)
def dayDatabase(self,x):
return{
1: 'day1',
2: 'day2',
3: 'day3',
4: 'day4'
}.get(x,'day5')
def deleteFromDatabase(self):
if self.dayNo==6:
day_str = "baseline";
elif self.dayNo<=5:
day_str = self.dayDatabase(self.dayNo);
else:
day_str = "performance";
s = "delete from "+day_str+" where subNo="+str(self.subjectNo);
self.cursor.execute(s);
def createDatabaseRecord(self):
if self.dayNo==6:
day_str = "baseline";
elif self.dayNo<=5:
day_str = self.dayDatabase(self.dayNo);
else:
day_str = "performance";
init_record = np.zeros(60);
s="insert into "+day_str+"(subNo) values("+str(self.subjectNo)+")";
self.cursor.execute(s);
def writeToDatabase(self,entryType,meanReactionTime,meanMovementTime,meanResponseTime,meanMaxVel,meanMaxAcc,meanEPD,meanRealDist,meanTraversedDist,meanPerDev,ovMaxReactionTime,ovMaxMovementTime,ovMaxEPD,ovMaxSpeed,ovMaxAcc,indexVal):
entry_str = self.typeOfEntry(entryType);
print entryType,entry_str
if self.dayNo>5:
if self.dayNo==6:
day_str = "baseline";
else :
day_str = "performance";
s ="update "+day_str+" set meanReactionTime"+entry_str+"="+str(meanReactionTime)+",meanMovementTime"+entry_str+"="+str(meanMovementTime)+",meanResponseTime"+entry_str+"="+str(meanResponseTime)+",meanMaxVel"+entry_str+"="+str(meanMaxVel)+",meanMaxAcc"+entry_str+"="+str(meanMaxAcc)+",meanEPD"+entry_str+"="+str(meanEPD)+",meanRealDist"+entry_str+"="+str(meanRealDist)+",meanTraversedDist"+entry_str+"="+str(meanTraversedDist)+",meanPerDev"+entry_str+"="+str(meanPerDev)+",ovMaxReactionTime"+entry_str+"="+str(ovMaxReactionTime)+",ovMaxMovementTime"+entry_str+"="+str(ovMaxMovementTime)+",ovMaxEPD"+entry_str+"="+str(ovMaxEPD)+",ovMaxSpeed"+entry_str+"="+str(ovMaxSpeed)+",ovMaxAcc"+entry_str+"="+str(ovMaxAcc)+",indexVal"+entry_str+"="+str(indexVal)+" where subNo="+str(self.subjectNo);
self.cursor.execute(s);
else:
day_str = self.dayDatabase(self.dayNo);
if self.blockNo==1: #query will return empty set or an old junk value. Generating block 1 data clears any old data already stored.
s ="update "+day_str+" set meanReactionTime"+entry_str+"="+str(meanReactionTime)+",meanMovementTime"+entry_str+"="+str(meanMovementTime)+",meanResponseTime"+entry_str+"="+str(meanResponseTime)+",meanMaxVel"+entry_str+"="+str(meanMaxVel)+",meanMaxAcc"+entry_str+"="+str(meanMaxAcc)+",meanEPD"+entry_str+"="+str(meanEPD)+",meanRealDist"+entry_str+"="+str(meanRealDist)+",meanTraversedDist"+entry_str+"="+str(meanTraversedDist)+",meanPerDev"+entry_str+"="+str(meanPerDev)+",ovMaxReactionTime"+entry_str+"="+str(ovMaxReactionTime)+",ovMaxMovementTime"+entry_str+"="+str(ovMaxMovementTime)+",ovMaxEPD"+entry_str+"="+str(ovMaxEPD)+",ovMaxSpeed"+entry_str+"="+str(ovMaxSpeed)+",ovMaxAcc"+entry_str+"="+str(ovMaxAcc)+",indexVal"+entry_str+"="+str(indexVal)+" where subNo="+str(self.subjectNo);
self.cursor.execute(s);
else:
s = "select meanReactionTime"+entry_str+",meanMovementTime"+entry_str+",meanResponseTime"+entry_str+",meanMaxVel"+entry_str+",meanMaxAcc"+entry_str+",meanEPD"+entry_str+",meanRealDist"+entry_str+",meanTraversedDist"+entry_str+",meanPerDev"+entry_str+",ovMaxReactionTime"+entry_str+",ovMaxMovementTime"+entry_str+",ovMaxEPD"+entry_str+",ovMaxSpeed"+entry_str+",ovMaxAcc"+entry_str+",indexVal"+entry_str+" from "+day_str+" where subNo="+str(self.subjectNo);
self.cursor.execute(s);
for (old_meanReactionTime,old_meanMovementTime,old_meanResponseTime,old_meanMaxVel,old_meanMaxAcc,old_meanEPD,old_meanRealDist,old_meanTraversedDist,old_meanPerDev,old_ovMaxReactionTime,old_ovMaxMovementTime,old_ovMaxEPD,old_ovMaxSpeed,old_ovMaxAcc,old_indexVal) in self.cursor:
meanReactionTime = (float(old_meanReactionTime)*(self.blockNo-1)+meanReactionTime)/self.blockNo;
meanMovementTime = (float(old_meanMovementTime)*(self.blockNo-1)+meanMovementTime)/self.blockNo;
meanResponseTime = (float(old_meanResponseTime)*(self.blockNo-1)+meanResponseTime)/self.blockNo;
meanMaxVel = (float(old_meanMaxVel)*(self.blockNo-1)+meanMaxVel)/self.blockNo;
meanMaxAcc = (float(old_meanMaxAcc)*(self.blockNo-1)+meanMaxAcc)/self.blockNo;
meanEPD = (float(old_meanEPD)*(self.blockNo-1)+meanEPD)/self.blockNo;
meanRealDist = (float(old_meanRealDist)*(self.blockNo-1)+meanRealDist)/self.blockNo;
meanTraversedDist = (float(old_meanTraversedDist)*(self.blockNo-1)+meanTraversedDist)/self.blockNo;
meanPerDev = (float(old_meanPerDev)*(self.blockNo-1)+meanPerDev)/self.blockNo;
ovMaxReactionTime = (float(old_ovMaxReactionTime)*(self.blockNo-1)+ovMaxReactionTime)/self.blockNo;
ovMaxMovementTime = (float(old_ovMaxMovementTime)*(self.blockNo-1)+ovMaxMovementTime)/self.blockNo;
ovMaxEPD = (float(old_ovMaxEPD*(self.blockNo-1))+ovMaxEPD)/self.blockNo;
ovMaxSpeed = (float(old_ovMaxSpeed*(self.blockNo-1))+ovMaxSpeed)/self.blockNo;
ovMaxAcc = (float(old_ovMaxAcc*(self.blockNo-1))+ovMaxAcc)/self.blockNo;
indexVal = (float(old_indexVal*(self.blockNo-1))+indexVal)/self.blockNo;
s ="update "+day_str+" set meanReactionTime"+entry_str+"="+str(meanReactionTime)+",meanMovementTime"+entry_str+"="+str(meanMovementTime)+",meanResponseTime"+entry_str+"="+str(meanResponseTime)+",meanMaxVel"+entry_str+"="+str(meanMaxVel)+",meanMaxAcc"+entry_str+"="+str(meanMaxAcc)+",meanEPD"+entry_str+"="+str(meanEPD)+",meanRealDist"+entry_str+"="+str(meanRealDist)+",meanTraversedDist"+entry_str+"="+str(meanTraversedDist)+",meanPerDev"+entry_str+"="+str(meanPerDev)+",ovMaxReactionTime"+entry_str+"="+str(ovMaxReactionTime)+",ovMaxMovementTime"+entry_str+"="+str(ovMaxMovementTime)+",ovMaxEPD"+entry_str+"="+str(ovMaxEPD)+",ovMaxSpeed"+entry_str+"="+str(ovMaxSpeed)+",ovMaxAcc"+entry_str+"="+str(ovMaxAcc)+",indexVal"+entry_str+"="+str(indexVal)+" where subNo="+str(self.subjectNo);
self.cursor.execute(s);
def ensure_dir(self,f):
d = os.path.dirname(f)
print os.path.exists(d)
if not os.path.exists(d):
os.makedirs(d)
def generateRecord(self):
self.writeToFilteredFile();
self.generateAll = 1;
while self.fileReadDone==0:
self.getFig();
self.writeToFilteredFile();
folder_s = "Data\\Subject "+str(self.subjectNo)+"\\Summary\\";
self.ensure_dir(folder_s);
raw_s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+str(self.subjectNo)+"\\Summary\\Subject" + str(self.subjectNo) + dayTitle(self.dayNo) + "Block" + str(self.blockNo) + "_RawFileAll.txt";
filter_s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+str(self.subjectNo)+"\\Summary\\Subject" + str(self.subjectNo) + dayTitle(self.dayNo) + "Block" + str(self.blockNo) + "_FilteredFileAll.txt";
rand_raw_s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+str(self.subjectNo)+"\\Summary\\Subject" + str(self.subjectNo) + dayTitle(self.dayNo) + "Block" + str(self.blockNo) + "_RawFileRandom.txt";
seq_raw_s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+str(self.subjectNo)+"\\Summary\\Subject" + str(self.subjectNo) + dayTitle(self.dayNo) + "Block" + str(self.blockNo) + "_RawFileRepeated.txt";
rand_filter_s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+str(self.subjectNo)+"\\Summary\\Subject" + str(self.subjectNo) + dayTitle(self.dayNo) + "Block" + str(self.blockNo) + "_FilteredFileRandom.txt";
seq_filter_s = "C:\\Users\\neuro\\Documents\\Arna\\Tracker\\Data\\Subject "+str(self.subjectNo)+"\\Summary\\Subject" + str(self.subjectNo) + dayTitle(self.dayNo) + "Block" + str(self.blockNo) + "_FilteredFileRepeated.txt";
rawFile = open(raw_s,'w');
rand_rawFile = open(rand_raw_s, 'w');
seq_rawFile = open(seq_raw_s, 'w');
filterFile = open(filter_s,'w');
rand_filterFile = open(rand_filter_s,'w');
seq_filterFile = open(seq_filter_s,'w');
s_meanReact = "\nMean Reaction Time = ";
s_meanMove = "\nMean Movement Time = ";
s_meanResponse = "\nMean Response Time = ";
s_meanMaxVel = "\nMean maximum Speed = ";
s_meanMaxAcc = "\nMean maximum acceleration = ";
s_meanEPD = "\nMean End Point Deviation = ";
s_meanRealDist = "\nMean Real Distance = ";
s_meanDistTraversed = "\nMean Traversed Distance = ";
s_meanDistPer = "\nMean Percentage deviation = ";
s_maxReact = "%\nOverall Maximum Reaction Time = ";
s_maxMove = "\nOverall Maximum Movement Time = ";
s_maxEPD = "\nOverall Maximum End Point Deviation = ";
s_maxMaxVel = "\nOverall Maximum Speed = ";
s_maxMaxAcc= "\nOverall Maximum Acceleration = ";
s_score = "\nIndex Value = ";
A = np.zeros(9);
max_react,max_move,max_epd,max_vel,max_acc = 0,0,0,0,0;
for i in range(len(self.AllStrings)):
rawFile.write(self.AllStrings[i])
if i==0:
continue;
temp_data = [float(j) for j in self.AllStrings[i].split()];
tdnp = np.array(temp_data[1:]);
if tdnp[0]>max_react:
max_react = tdnp[0];
if tdnp[1]>max_move:
max_move = tdnp[1];
if tdnp[5]>max_epd:
max_epd = tdnp[5];
if tdnp[3]>max_vel:
max_vel = tdnp[3];
if tdnp[4]>max_acc:
max_acc = tdnp[4];
A = A+tdnp;
A = A/(len(self.AllStrings));
##index_val = (A[3]/2330)+(A[4]/119289)+((2.389-A[1])/2.389)+((1.165-A[0])/1.165)+((100-A[8])/100)+((49.7-A[5])/49.7);
##index_val = index_val*10/6;
index_val = ((100-A[8])/100)+((49.7-A[5])/49.7)+((1.165-A[0])/1.165);
index_val = index_val*10/3;
res_str=s_meanReact+str(A[0])+s_meanMove+str(A[1])+s_meanResponse+str(A[2])+s_meanMaxVel+str(A[3])+s_meanMaxAcc+str(A[4])+s_meanEPD+str(A[5])+s_meanRealDist+str(A[6])+s_meanDistTraversed+str(A[7])+s_meanDistPer+str(A[8])+s_maxReact+str(max_react)+s_maxMove+str(max_move)+s_maxEPD+str(max_epd)+s_maxMaxVel+str(max_vel)+s_maxMaxAcc+str(max_acc)+s_score+str(index_val)+"\n";
rawFile.write(res_str);
A = np.zeros(9);
max_react,max_move,max_epd,max_vel,max_acc = 0,0,0,0,0;
for i in range(len(self.AllGoodStrings)):
filterFile.write(self.AllGoodStrings[i])
if i==0:
continue;
temp_data = [float(j) for j in self.AllGoodStrings[i].split()];
tdnp = np.array(temp_data[1:]);
if tdnp[0]>max_react:
max_react = tdnp[0];
if tdnp[1]>max_move:
max_move = tdnp[1];
if tdnp[5]>max_epd:
max_epd = tdnp[5];
if tdnp[3]>max_vel:
max_vel = tdnp[3];
if tdnp[4]>max_acc:
max_acc = tdnp[4];
A = A+tdnp;
A = A/(len(self.AllGoodStrings));
index_val = ((100-A[8])/100)+((49.7-A[5])/49.7)+((1.165-A[0])/1.165);
index_val = index_val*10/3;
res_str=s_meanReact+str(A[0])+s_meanMove+str(A[1])+s_meanResponse+str(A[2])+s_meanMaxVel+str(A[3])+s_meanMaxAcc+str(A[4])+s_meanEPD+str(A[5])+s_meanRealDist+str(A[6])+s_meanDistTraversed+str(A[7])+s_meanDistPer+str(A[8])+s_maxReact+str(max_react)+s_maxMove+str(max_move)+s_maxEPD+str(max_epd)+s_maxMaxVel+str(max_vel)+s_maxMaxAcc+str(max_acc)+s_score+str(index_val)+"\n";
filterFile.write(res_str);
if self.blockNo==1:
self.deleteFromDatabase();
self.createDatabaseRecord();
if self.dayNo>5:
self.deleteFromDatabase();
self.createDatabaseRecord();
A = np.zeros(9);
max_react,max_move,max_epd,max_vel,max_acc = 0,0,0,0,0;
for i in range(len(self.RandomStrings)):
rand_rawFile.write(self.RandomStrings[i])
if i==0:
continue;
temp_data = [float(j) for j in self.RandomStrings[i].split()];
tdnp = np.array(temp_data[1:]);
if tdnp[0]>max_react:
max_react = tdnp[0];
if tdnp[1]>max_move:
max_move = tdnp[1];
if tdnp[5]>max_epd:
max_epd = tdnp[5];
if tdnp[3]>max_vel:
max_vel = tdnp[3];
if tdnp[4]>max_acc:
max_acc = tdnp[4];
A = A+tdnp;
A = A/(len(self.RandomStrings));
index_val = ((100-A[8])/100)+((49.7-A[5])/49.7)+((1.165-A[0])/1.165);
index_val = index_val*10/3;
res_str=s_meanReact+str(A[0])+s_meanMove+str(A[1])+s_meanResponse+str(A[2])+s_meanMaxVel+str(A[3])+s_meanMaxAcc+str(A[4])+s_meanEPD+str(A[5])+s_meanRealDist+str(A[6])+s_meanDistTraversed+str(A[7])+s_meanDistPer+str(A[8])+s_maxReact+str(max_react)+s_maxMove+str(max_move)+s_maxEPD+str(max_epd)+s_maxMaxVel+str(max_vel)+s_maxMaxAcc+str(max_acc)+s_score+str(index_val)+"\n";
rand_rawFile.write(res_str);
self.writeToDatabase(4,A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7],A[8],max_react,max_move,max_epd,max_vel,max_acc,index_val);
A = np.zeros(9);
max_react,max_move,max_epd,max_vel,max_acc = 0,0,0,0,0;
for i in range(len(self.SequenceStrings)):
seq_rawFile.write(self.SequenceStrings[i])
if i==0:
continue;
temp_data = [float(j) for j in self.SequenceStrings[i].split()];
tdnp = np.array(temp_data[1:]);
if tdnp[0]>max_react:
max_react = tdnp[0];
if tdnp[1]>max_move:
max_move = tdnp[1];
if tdnp[5]>max_epd:
max_epd = tdnp[5];
if tdnp[3]>max_vel:
max_vel = tdnp[3];
if tdnp[4]>max_acc:
max_acc = tdnp[4];
A = A+tdnp;
A = A/(len(self.SequenceStrings));
index_val = ((100-A[8])/100)+((49.7-A[5])/49.7)+((1.165-A[0])/1.165);
index_val = index_val*10/3;
res_str=s_meanReact+str(A[0])+s_meanMove+str(A[1])+s_meanResponse+str(A[2])+s_meanMaxVel+str(A[3])+s_meanMaxAcc+str(A[4])+s_meanEPD+str(A[5])+s_meanRealDist+str(A[6])+s_meanDistTraversed+str(A[7])+s_meanDistPer+str(A[8])+s_maxReact+str(max_react)+s_maxMove+str(max_move)+s_maxEPD+str(max_epd)+s_maxMaxVel+str(max_vel)+s_maxMaxAcc+str(max_acc)+s_score+str(index_val)+"\n";
seq_rawFile.write(res_str);
self.writeToDatabase(3,A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7],A[8],max_react,max_move,max_epd,max_vel,max_acc,index_val);
A = np.zeros(9);
max_react,max_move,max_epd,max_vel,max_acc = 0,0,0,0,0;
for i in range(len(self.RandomGoodStrings)):
rand_filterFile.write(self.RandomGoodStrings[i])
if i==0:
continue;
temp_data = [float(j) for j in self.RandomGoodStrings[i].split()];
tdnp = np.array(temp_data[1:]);
if tdnp[0]>max_react:
max_react = tdnp[0];
if tdnp[1]>max_move:
max_move = tdnp[1];
if tdnp[5]>max_epd:
max_epd = tdnp[5];
if tdnp[3]>max_vel:
max_vel = tdnp[3];
if tdnp[4]>max_acc:
max_acc = tdnp[4];
A = A+tdnp;
A = A/(len(self.RandomGoodStrings));
index_val = ((100-A[8])/100)+((49.7-A[5])/49.7)+((1.165-A[0])/1.165);
index_val = index_val*10/3;
res_str=s_meanReact+str(A[0])+s_meanMove+str(A[1])+s_meanResponse+str(A[2])+s_meanMaxVel+str(A[3])+s_meanMaxAcc+str(A[4])+s_meanEPD+str(A[5])+s_meanRealDist+str(A[6])+s_meanDistTraversed+str(A[7])+s_meanDistPer+str(A[8])+s_maxReact+str(max_react)+s_maxMove+str(max_move)+s_maxEPD+str(max_epd)+s_maxMaxVel+str(max_vel)+s_maxMaxAcc+str(max_acc)+s_score+str(index_val)+"\n";
rand_filterFile.write(res_str);
self.writeToDatabase(2,A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7],A[8],max_react,max_move,max_epd,max_vel,max_acc,index_val);
A = np.zeros(9);
max_react,max_move,max_epd,max_vel,max_acc = 0,0,0,0,0;
for i in range(len(self.SequenceGoodStrings)):
seq_filterFile.write(self.SequenceGoodStrings[i])
if i==0:
continue;
temp_data = [float(j) for j in self.SequenceGoodStrings[i].split()];
tdnp = np.array(temp_data[1:]);
if tdnp[0]>max_react:
max_react = tdnp[0];
if tdnp[1]>max_move:
max_move = tdnp[1];
if tdnp[5]>max_epd:
max_epd = tdnp[5];
if tdnp[3]>max_vel:
max_vel = tdnp[3];
if tdnp[4]>max_acc:
max_acc = tdnp[4];
A = A+tdnp;
A = A/(len(self.SequenceGoodStrings));
index_val = ((100-A[8])/100)+((49.7-A[5])/49.7)+((1.165-A[0])/1.165);
index_val = index_val*10/3;
res_str=s_meanReact+str(A[0])+s_meanMove+str(A[1])+s_meanResponse+str(A[2])+s_meanMaxVel+str(A[3])+s_meanMaxAcc+str(A[4])+s_meanEPD+str(A[5])+s_meanRealDist+str(A[6])+s_meanDistTraversed+str(A[7])+s_meanDistPer+str(A[8])+s_maxReact+str(max_react)+s_maxMove+str(max_move)+s_maxEPD+str(max_epd)+s_maxMaxVel+str(max_vel)+s_maxMaxAcc+str(max_acc)+s_score+str(index_val)+"\n";
seq_filterFile.write(res_str);
self.writeToDatabase(1,A[0],A[1],A[2],A[3],A[4],A[5],A[6],A[7],A[8],max_react,max_move,max_epd,max_vel,max_acc,index_val);
print "written analysis files"
def deleteRecord(self):
print "delete this record"
self.deleteThisRecord = 1;
def quit(self):
self.cnx.commit();
self.cnx.close();
exit()
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
#data_dict stores all loaded data sets
self.data_dict = {}
self.mplfigs.itemSelectionChanged.connect(self.changefig)
self.folderSelect.clicked.connect(self.onSelectFolder)
self.saveFit.clicked.connect(self.onSaveFit)
self.cancelFit.clicked.connect(self.onCancelFit)
self.fitSelectedData.clicked.connect(self.onFit)
self.fitSelectedData.setEnabled(False)
self.selectPandasDB.clicked.connect(self.onSelectPandasDB)
self.QEntry.setValidator(QtGui.QIntValidator(1,1000000))
self.widthEdit.setValidator(QtGui.QIntValidator(1,10000))
self.widthEdit.setText(str(0))
self.powerType.setText(str(0))
self.powerValue.setText(str(0))
self.QEntry.setText(str(100))
self.fNumber.setValue(1)
self.degeneracySelect.setCurrentIndex(0)
fig = Figure()
self.addmpl(fig)
self.activefig=None
self.activeDataSet=None
self.fittingWindow = None
self.df=pd.DataFrame()
self.testdf=pd.DataFrame()
self.onSelectPandasDB()
def onSelectPandasDB(self,):
"""Select a folder, the selected folder will be parsed for sub-folders.
Each of these subfolders will be turned into a xyData class which is
then stored in main with the adddata command"""
fileDialog=QtGui.QFileDialog(self)
fileName=fileDialog.getSaveFileName(self,
"Choose a pandasDB", homedir, filter ="csv (*.csv)")
self.pathtopandas=fileName
self.chipEdit.setText(self.pathtopandas)
print self.pathtopandas
def onSelectFolder(self,):
"""Select a folder, the selected folder will be parsed for sub-folders.
Each of these subfolders will be turned into a xyData class which is
then stored in main with the adddata command"""
self.fileDialog=QtGui.QFileDialog(self)
folderName=self.fileDialog.getExistingDirectory(self,
"Choose a folder", homedir, QtGui.QFileDialog.ShowDirsOnly)
for i in os.listdir(folderName):
for ii in os.listdir(os.path.join(folderName,i)):
if ii[-4:] == ".csv":
self.adddata(i, xyData(os.path.join(folderName,i)))
def changefig(self, ):
item=self.mplfigs.currentItem()
if self.activefig==None:
pass
else:
self.activefig.canvas.mpl_disconnect(self.cid)
if self.fitSelectedData.isEnabled()==True:
pass
else:
self.fitSelectedData.setEnabled(True)
text = item.text()
self.rmmpl()
fig=self.data_dict[text].fig
self.addmpl(fig)
self.cid = fig.canvas.mpl_connect('button_press_event', self.onclick)
try:
self.widthEdit.setText(str(self.data_dict[text].deviceWid))
except ValueError:
pass
try:
self.rowEdit.setValue(int(self.data_dict[text].deviceRow))
except ValueError:
pass
try:
self.powerType.setText(str(self.data_dict[text].laserPowerType))
except ValueError:
pass
try:
self.powerValue.setText(str(self.data_dict[text].laserPower))
except ValueError:
pass
try:
self.columnEdit.setValue(int(self.data_dict[text].deviceCol))
except ValueError:
pass
try:
ind = self.deviceType.findText(str(self.data_dict[text].deviceType).strip())
self.deviceType.setCurrentIndex(ind)
except ValueError:
pass
self.activefig=fig
self.activeDataSet=self.data_dict[text]
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
def rmmpl(self,):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
# self.activefig.canvas.mpl_disconnect(self.cid)
#This has to be modified for data types other than a ZI data input
def adddata(self, name, xyDataClass):
self.data_dict[name] = xyDataClass
self.mplfigs.addItem(name)
#Clcik on active MPL window
def onclick(self, event):
# print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(event.button, event.x, event.y, event.xdata, event.ydata)
print self.activeDataSet.find_nearestx(event.xdata)
#gca can get limits of zoomed widow
def onFit(self,):
self.disableForFit()
def fitClick(self, event):
self.cancelFit.setEnabled(True)
print 'clicked'
self.activefig.canvas.mpl_disconnect(self.cid)
xi,xf = self.activeDataSet.fig.gca().get_xlim()
xi, xvi = self.activeDataSet.find_nearestx(xi)
xf, xvf = self.activeDataSet.find_nearestx(xf)
# General to this point, actual fit can vary below
x0 = event.xdata
y0 = event.ydata
Q = float(self.QEntry.text())
sigma=1/(2*Q)
print xi,xf, [x0,y0,sigma]
ip=[x0,y0,sigma]
print self.activeDataSet
out, params, outp, self.paramsp, dout = self.activeDataSet.fitDataSelection(xi,xf,ip)
self.outfit=out
self.currpars=params
self.fitfig=Figure()
ax=self.fitfig.add_subplot(1,1,1)
axt=ax.twinx()
ax.plot(self.activeDataSet.data.f[xi:xf+1], out.best_fit)
axt.plot(dout[0], outp.best_fit, 'g')
ax.plot(self.activeDataSet.data.f[xi:xf+1], self.activeDataSet.data.r[xi:xf+1], 'ro')
axt.plot(dout[0], dout[1], 'go')
idx=min(range(len(self.activeDataSet.data.f)), key=lambda x: abs(self.activeDataSet.data.f[x]-params[0]))
ax.annotate('Q = '+ str(params[3]) + '\n' + 'w_0 = '+ str(params[0]), xy=(params[0],self.activeDataSet.data.r[idx]), textcoords = 'data', xycoords='data')
self.rmmpl()
self.addmpl(self.fitfig)
self.activeFitParams = params
self.saveFit.setEnabled(True)
# plt.text(2, 0.65,'Q = '+ str(params[3]), fontdict=font)
def disableForFit(self,):
self.mplfigs.setEnabled(False)
self.fitSelectedData.setEnabled(False)
self.folderSelect.setEnabled(False)
self.activefig.canvas.mpl_disconnect(self.cid)
self.cid =self.activefig.canvas.mpl_connect('button_press_event', self.fitClick)
def enableAfterFit(self,):
self.toolbar.setEnabled(True)
self.mplfigs.setEnabled(True)
self.fitSelectedData.setEnabled(True)
self.folderSelect.setEnabled(True)
self.activefig.canvas.mpl_disconnect(self.cid)
self.rmmpl()
self.addmpl(self.activefig)
self.cid =self.activefig.canvas.mpl_connect('button_press_event', self.onclick)
def onSaveFit(self,):
self.w0=self.activeFitParams[0]
self.A=self.activeFitParams[1]
self.Q=self.activeFitParams[3]
self.lineInt=self.activeFitParams[4]
self.lineSlope=self.activeFitParams[5]
self.saveFit.setEnabled(False)
self.cancelFit.setEnabled(False)
curridx=self.mplfigs.currentItem().text()+'_'+str(self.fNumber.value())+'_' + self.degeneracySelect.currentText()
newrow=self.prepareDFRow(curridx)
try:
master=pd.read_csv(self.pathtopandas, index_col=0)
if curridx not in self.testdf.index:
newmaster=master.append(newrow)
print newmaster
newmaster.to_csv(self.pathtopandas[:-4]+'temp.csv')
os.remove(self.pathtopandas)
os.rename(self.pathtopandas[:-4]+'temp.csv',self.pathtopandas)
else:
print 'repeated fit'
except IOError:
newrow.to_csv(self.pathtopandas)
self.enableAfterFit()
def prepareDFRow(self, idx):
df = pd.DataFrame({'Run Name' : self.mplfigs.currentItem().text(), 'Device Name' : self.chipEdit.text(), 'Row Number' : \
self.rowEdit.value(), 'Column Number' : self.columnEdit.value(),\
'Device Type' : self.deviceType.currentText(), 'Device Width' : \
self.widthEdit.text(), 'Mode Order' : self.fNumber.value(), \
'Mode Type': self.degeneracySelect.currentText(), 'Frequency' : self.w0, 'Amplitude' : self.A, \
'Q' : self.Q, 'Bad Fit' : self.selectBadFit.checkState(), 'Power Measurement Type' : self.powerType.text(), 'Power (uW)' : self.powerValue.text(),\
'Fit Notes' : self.fitNotes.text(), 'Date' : self.activeDataSet.date, 'Intercept': self.lineInt, 'Slope':self.lineSlope, 'w0p': self.paramsp[0],'Qp': self.paramsp[1],'pm': self.paramsp[2],'pb': self.paramsp[3]}, index=[idx] )
return df
def onCancelFit(self,):
self.saveFit.setEnabled(False)
self.cancelFit.setEnabled(False)
self.enableAfterFit()
class Main(QtGui.QWidget):
def __init__(self, parent = None):
super(Main, self).__init__(parent)
self.setWindowTitle('Data Chest Image Browser')
# Add in Rabi plot.
self.setWindowIcon(QtGui.QIcon('rabi.jpg'))
self.root = os.environ["DATA_CHEST_ROOT"]
self.pathRoot=QtCore.QString(self.root)
self.filters =QtCore.QStringList()
self.filters.append("*.hdf5")
self.dataChest = dataChest(None, True)
# Directory browser configuration.
self.model = QtGui.QFileSystemModel(self)
self.model.setRootPath(self.pathRoot)
self.model.setNameFilterDisables(False)
self.model.nameFilterDisables()
self.model.setNameFilters(self.filters)
self.indexRoot = self.model.index(self.model.rootPath())
self.directoryBrowserLabel = QtGui.QLabel(self)
self.directoryBrowserLabel.setText("Directory Browser:")
self.directoryTree = QtGui.QTreeView(self)
self.directoryTree.setModel(self.model)
self.directoryTree.setRootIndex(self.indexRoot)
self.directoryTree.header().setResizeMode(QtGui.QHeaderView.ResizeToContents)
self.directoryTree.header().setStretchLastSection(False)
self.directoryTree.clicked.connect(self.dirTreeSelectionMade)
# Plot types drop down list configuration.
self.plotTypesComboBoxLabel = QtGui.QLabel(self)
self.plotTypesComboBoxLabel.setText("Available Plot Types:")
self.plotTypesComboBox = QtGui.QComboBox(self)
self.plotTypesComboBox.activated[str].connect(self.plotTypeSelected)
# Configure scrolling widget.
self.scrollWidget = QtGui.QWidget(self)
self.scrollLayout = QtGui.QHBoxLayout(self)
self.scrollWidget.setLayout(self.scrollLayout)
self.scrollArea = QtGui.QScrollArea(self)
self.scrollArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
self.scrollArea.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
self.scrollArea.setWidget(self.scrollWidget)
self.scrollArea.setWidgetResizable(True) # What happens without?
vbox = QtGui.QVBoxLayout()
vbox.addWidget(self.directoryBrowserLabel)
vbox.addWidget(self.directoryTree)
vbox.addWidget(self.plotTypesComboBoxLabel)
vbox.addWidget(self.plotTypesComboBox)
vbox.addWidget(self.scrollArea)
self.mplwindow =QtGui.QWidget(self)
self.mplvl = QtGui.QVBoxLayout(self.mplwindow)
hbox = QtGui.QHBoxLayout()
hbox.addLayout(vbox)
hbox.addWidget(self.mplwindow)
self.setLayout(hbox)
self.currentFig = Figure()
self.addFigureToCanvas(self.currentFig)
self.filePath = None # redundant
self.fileName = None # redundant
self.plotType = None # redundant
self.varsToIgnore = []
def plotTypeSelected(self, plotType):
# Called when a plotType selection is made from drop down.
# self.plotTypesComboBox.adjustSize()
if plotType != self.plotType:
self.removeFigFromCanvas()
self.currentFig = self.figFromFileInfo(self.filePath, self.fileName, selectedPlotType = plotType)
self.addFigureToCanvas(self.currentFig)
self.updatePlotTypeOptions(plotType)
self.plotType = plotType
# When is best time to do this?
self.varsToIgnore = []
def updatePlotTypeOptions(self, plotType, depVarName = None):
# Update area below plotType, selection drop down (add/remove variables)
self.clearLayout(self.scrollLayout)
if plotType == "1D" or plotType == "Histogram":
headerList = ["Dep Var:", "Status:"]
widgetTypeList = ["QLabel", "QCheckBox"]
depVarList = [row[0] for row in self.dataChest.getVariables()[1]]
for ii in range(0,len(headerList)):
optionsSlice = QtGui.QVBoxLayout()
label = QtGui.QLabel(self) # widget to log
label.setText(headerList[ii])
optionsSlice.addWidget(label)
for depVar in depVarList:
if widgetTypeList[ii] =="QLabel":
label = QtGui.QLabel(self) # widget to log
label.setText(depVar)
optionsSlice.addWidget(label)
elif widgetTypeList[ii] =="QCheckBox":
checkBox = QtGui.QCheckBox('', self) # widget to log
checkBox.setCheckState(QtCore.Qt.Checked)
checkBox.stateChanged.connect(partial(self.varStateChanged, depVar))
optionsSlice.addWidget(checkBox)
optionsSlice.addStretch(1)
self.scrollLayout.addLayout(optionsSlice)
self.scrollLayout.addStretch(1)
elif plotType == '2D Image':
headerList = ["Dep Var:", "Status:"]
widgetTypeList = ["QLabel", "QCheckBox"]
depVarList = [row[0] for row in self.dataChest.getVariables()[1]]
if depVarName is None:
depVarName = depVarList[0]
for ii in range(0,len(headerList)):
optionsSlice = QtGui.QVBoxLayout()
label = QtGui.QLabel(self) # widget to log
label.setText(headerList[ii])
optionsSlice.addWidget(label)
for depVar in depVarList:
if widgetTypeList[ii] =="QLabel":
label = QtGui.QLabel(self) # widget to log
label.setText(depVar)
optionsSlice.addWidget(label)
elif widgetTypeList[ii] =="QCheckBox":
checkBox = QtGui.QCheckBox('', self) # widget to log
print "depVarName=", depVarName
if depVar == depVarName:
checkBox.setCheckState(QtCore.Qt.Checked)
checkBox.stateChanged.connect(partial(self.varStateChanged, depVar))
optionsSlice.addWidget(checkBox)
optionsSlice.addStretch(1)
self.scrollLayout.addLayout(optionsSlice)
self.scrollLayout.addStretch(1)
def clearLayout(self, layout):
# Clear the plotType options layout and all widgets therein.
for i in reversed(range(layout.count())):
item = layout.itemAt(i)
if isinstance(item, QtGui.QWidgetItem):
item.widget().close()
elif not isinstance(item, QtGui.QSpacerItem):
self.clearLayout(item.layout())
# remove the item from layout
layout.removeItem(item)
def varStateChanged(self, name, state):
# Add/remove variables from current displayed plot.
if state == QtCore.Qt.Checked:
self.varsToIgnore.remove(name)
# Remove old figure, needs garbage collection too.
self.removeFigFromCanvas()
self.currentFig = self.figFromFileInfo(self.filePath,
self.fileName,
selectedPlotType=self.plotType,
varsToIgnore =self.varsToIgnore)
self.addFigureToCanvas(self.currentFig)
else: # unchecked
if name not in self.varsToIgnore:
self.varsToIgnore.append(name)
# Remove old figure, needs garbage collection too.
self.removeFigFromCanvas()
self.currentFig = self.figFromFileInfo(self.filePath,
self.fileName,
selectedPlotType=self.plotType,
varsToIgnore=self.varsToIgnore)
self.updatePlotTypeOptions(self.plotType, '')
self.addFigureToCanvas(self.currentFig)
def convertPathToArray(self, path):
if self.root + "/" in path:
path = path.replace(self.root+"/", '')
elif self.root in path:
path = path.replace(self.root, '')
return path.split('/')
def addFigureToCanvas(self, fig):
# Addsmpl fig to the canvas.
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.mplwindow, coordinates=True)
self.mplvl.addWidget(self.toolbar)
def removeFigFromCanvas(self):
# Remove fig from the canvas.
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
self.currentFig.clf()
@QtCore.pyqtSlot(QtCore.QModelIndex) # logical flow could be improved
def dirTreeSelectionMade(self, index):
# Called when a directory tree selection is made.
indexItem = self.model.index(index.row(), 0, index.parent())
fileName = str(self.model.fileName(indexItem))
filePath = str(self.model.filePath(indexItem))
if ".hdf5" in filePath:
# Removes fileName from path if file is chosen.
filePath = filePath[:-(len(fileName)+1)]
if self.fileName != fileName or self.filePath != filePath:
# If an actual change occurs update check what happens for
# just a folder.
self.filePath = filePath # Is there a point in storing this?
self.fileName = fileName
if ".hdf5" in fileName:
# fileName is not a directory, otherwise leave as is
# till a file is selected.
self.removeFigFromCanvas()
# Remove old figure, needs garbage collection too.
self.currentFig = self.figFromFileInfo(self.filePath, self.fileName)
self.addFigureToCanvas(self.currentFig)
variables = self.dataChest.getVariables() # fine
dataCategory = self.categorizeDataset(variables) # fine
self.updatePlotTypesList(self.supportedPlotTypes(dataCategory)) # fine: updates list
self.updatePlotTypeOptions(self.supportedPlotTypes(dataCategory)[0])
self.plotType = self.supportedPlotTypes(dataCategory)[0]
self.varsToIgnore = [] # When is best time to do this?
else:
self.fileName = None
def updatePlotTypesList(self, plotTypes):
# Update plotTypes list based on selected dataset.
self.plotTypesComboBox.clear()
for element in plotTypes:
if ".dir" not in str(element) and ".ini" not in str(element):
self.plotTypesComboBox.addItem(str(element))
def categorizeDataset(self, variables):
# Categorizes dataset, this is now redundant.
indepVarsList = variables[0]
numIndepVars = len(indepVarsList)
if numIndepVars == 1:
return "1D"
elif numIndepVars == 2:
return "2D"
else:
return (str(numIndepVars)+"D")
def supportedPlotTypes(self, dimensionality):
# Provide list of plotTypes based on datasetType.
if dimensionality == "1D":
plotTypes = ["1D", "Histogram"]
elif dimensionality == "2D":
plotTypes = ["2D Image"]
else:
plotTypes = []
return plotTypes
# Some shape checking needs to go into this function to ensure
# 1D array inputs.
def plot1D(self, dataset, variables, plotType, dataClass, varsToIgnore = []):
# Shorten this monstrosity!
# print "varsToIgnore=", varsToIgnore
if plotType == None:
plotType = self.supportedPlotTypes("1D")[0] # defaults
elif plotType not in self.supportedPlotTypes("1D"):
print "Unrecognized plot type was provided"
# Return bum fig with something cool, maybe a gif.
if plotType =="1D":
fig = self.basic1DPlot(dataset, variables, varsToIgnore)
elif plotType == "Histogram":
# Adjust bin size.
fig = self.basic1DHistogram(dataset, variables, varsToIgnore)
return fig
# Some shape checking needs to go into this function to ensure
# 2D array inputs.
def plot2D(self, dataset, variables, plotType, dataClass, varsToIgnore = []):
# Shorten this monstrosity!
# print "varsToIgnore=", varsToIgnore
if plotType == None:
plotType = self.supportedPlotTypes("2D")[0] #defaults
elif plotType not in self.supportedPlotTypes("2D"):
print "Unrecognized plot type was provided"
# Return bum fig with something cool, maybe a gif.
if plotType =="2D Image":
fig = self.basic2DImage(dataset, variables, varsToIgnore)
#elif plotType == "Histogram": #adjust bin size
# fig = self.basic1DHistogram(dataset, variables, varsToIgnore)
return fig
def basic2DImage(self, dataset, variables, varsToIgnore):
fig = Figure(dpi=100)
ax = fig.add_subplot(111)
indepVars = variables[0]
depVars = variables[1]
if varsToIgnore == [depVars[ii][0] for ii in range(0,len(depVars))]:
return fig
dataset = np.asarray(dataset)
print dataset[0]
xlabel = self.dataChest.getParameter("X Label", True)
if xlabel is None:
xlabel = indepVars[0][0]
ylabel = self.dataChest.getParameter("Y Label", True)
if ylabel is None:
# For data with more than one dep, recommend ylabel.
ylabel = depVars[0][0]
plotTitle = self.dataChest.getParameter("Plot Title", True)
if plotTitle is None:
plotTitle = self.dataChest.getDatasetName()
ax.set_title(plotTitle)
ax.set_xlabel(xlabel+" "+"("+indepVars[0][3]+")")
ax.set_ylabel(ylabel+" "+"("+depVars[0][3]+")")
# For multiple deps with different units this is ambiguous.
imageType = self.dataChest.getParameter("Image Type", True)
if imageType is None:
# Add or "scatter"
imageType = "Scatter"
print "Scatter"
for ii in range(0, len(depVars)):
x = dataset[::,0]
y = dataset[::,1]
z = dataset[::,2]
im = ax.tricontourf(x,y,z, 100, cmap=cm.gist_rainbow, antialiased=True)
fig.colorbar(im, fraction = 0.15)
break
elif imageType == "Pixel":
xGridRes = self.dataChest.getParameter("X Resolution", True)
xIncrement = self.dataChest.getParameter("X Increment", True)
yGridRes = self.dataChest.getParameter("Y Resolution", True)
yIncrement = self.dataChest.getParameter("Y Increment", True)
x = dataset[::,0].flatten()
y = dataset[::,1].flatten()
z = dataset[::,2].flatten()
if len(x)>1:
if x[0]==x[1]:
sweepType = "Y"
else:
sweepType = "X"
print "sweepType=", sweepType
new = self.makeGrid(x, xGridRes, xIncrement, y, yGridRes, yIncrement, sweepType, z) #makeGrid(self, x, xGridRes, dX, y, yGridRes, dY, sweepType, z)
X = new[0]
Y = new[1]
Z = new[2]
im = ax.imshow(Z, extent=(X.min(), X.max(), Y.min(), Y.max()), interpolation='nearest', cmap=cm.gist_rainbow, origin='lower')
fig.colorbar(im, fraction = 0.15)
else:
print "return jack shit"
elif imageType == "Buffered":
print "Buffered"
return fig
def basic1DPlot(self, dataset, variables, varsToIgnore):
fig = Figure(dpi=100)
ax = fig.add_subplot(111)
indepVars = variables[0]
depVars = variables[1]
containsDatetime = False
for ii in range(0, len(indepVars)):
if 'utc_datetime' in indepVars[ii]:
containsDatetime = True
scanType = self.dataChest.getParameter("Scan Type", True)
xlabel = self.dataChest.getParameter("X Label", True)
if xlabel is None:
xlabel = indepVars[0][0]
ylabel = self.dataChest.getParameter("Y Label", True)
if ylabel is None:
# For data with more than one dep, recommend ylabel.
ylabel = depVars[0][0]
plotTitle = self.dataChest.getParameter("Plot Title", True)
if plotTitle is None:
plotTitle = self.dataChest.getDatasetName()
ax.set_title(plotTitle)
dataset = np.asarray(dataset)
ax.set_xlabel(xlabel+" "+"("+indepVars[0][3]+")")
ax.set_ylabel(ylabel+" "+"("+depVars[0][3]+")")
# For multiple deps with different units this is ambiguous.
for ii in range(0, len(depVars)):
if depVars[ii][0] not in varsToIgnore:
if scanType is None:
x = dataset[::,0].flatten()
# Only works when all dims are same => perform checks.
y = dataset[::,1+ii].flatten()
if containsDatetime:
months = MonthLocator(range(1, 13), bymonthday=1, interval=3)
monthsFmt = DateFormatter("%b %d %Y %H:%M:%S")
mondays = WeekdayLocator(MONDAY)
ax.plot_date(x, y)
ax.xaxis.set_major_locator(months)
ax.xaxis.set_major_formatter(monthsFmt)
ax.grid(True)
ax.xaxis.set_minor_locator(mondays)
ax.autoscale_view()
fig.autofmt_xdate()
elif scanType == "Lin":
y = np.asarray(dataset[0][1+ii])
# Only one row of data for this and log type supported.
x = np.linspace(dataset[0][0][0], dataset[0][0][1], num = len(y))
elif scanType == "Log":
y = dataset[0][1+ii]
x = np.logspace(np.log10(dataset[0][0][0]), np.log10(dataset[0][0][1]), num = len(y))
ax.set_xscale('log')
ax.plot(x, y, "o", label = depVars[ii][0])
#ax.plot(x, y, label = depVars[ii][0])
ax.legend(fontsize = 10)
return fig
def basic1DHistogram(self, dataset, variables, varsToIgnore):
fig = Figure(dpi=100)
ax = fig.add_subplot(111)
indepVars = variables[0]
depVars = variables[1]
scanType = self.dataChest.getParameter("Scan Type", True)
xlabel = self.dataChest.getParameter("X Label", True)
ylabel = self.dataChest.getParameter("Y Label", True)
if ylabel is None:
ylabel = depVars[0][0]
# For data with more than one dep, recommend ylabel.
plotTitle = self.dataChest.getParameter("Plot Title", True)
if plotTitle is None:
plotTitle = self.dataChest.getDatasetName()
ax.set_title(plotTitle)
dataset = np.asarray(dataset)
ax.set_xlabel(ylabel+" "+"("+depVars[0][3]+")")
# For multiple deps with different units this is ambiguous.
ax.set_ylabel("Statistical Frequency")
for ii in range(0, len(depVars)):
if depVars[ii][0] not in varsToIgnore:
if scanType is None:
y = dataset[::,1+ii].flatten()
elif scanType == "Lin":
y = dataset[0][1+ii]
elif scanType == "Log":
y = dataset[0][1+ii]
weights = np.ones_like(y)/float(len(y))
ax.hist(y, 100, weights =weights, alpha=0.5, label = depVars[ii][0])
#ax.hist(y, 50, normed=1,weights =weights, alpha=0.5, label = depVars[ii][0])
ax.legend()
return fig
def figFromFileInfo(self, filePath, fileName, selectedPlotType = None, varsToIgnore =[]):
relPath = self.convertPathToArray(filePath)
self.dataChest.cd(relPath)
self.dataChest.openDataset(fileName)
variables = self.dataChest.getVariables()
dataCategory = self.categorizeDataset(variables)
#otherwise refer to dataset name needs to be implemented
dataset = self.dataChest.getData()
if dataCategory == "1D":
fig = self.plot1D(dataset, variables, selectedPlotType, None, varsToIgnore = varsToIgnore)
# plot1D(self, dataset, variables, plotType, dataClass, varsToIgnore = [])
elif dataCategory =="2D": #was "2D Sweep"
fig = self.plot2D(dataset, variables, selectedPlotType, None, varsToIgnore = varsToIgnore)
else:
print("1D data is the only type currently \r\n"+
"supported by this grapher.")
print("Attempted to plot "+dataCategory+" data.")
fig = Figure(dpi=100)
self.dataChest.cd("")
# yield self.cxn.data_vault.dump_existing_sessions()
return fig
def makeGrid(self, x, xGridRes, dX, y, yGridRes, dY, sweepType, z):
totalNumPts = len(x)
if sweepType =="Y":
# Y sweep type ==> fix x, sweep y, then go to x+dx and
# sweep y again...
divNmod = divmod(len(x), yGridRes)
numFullYslices = divNmod[0]
numPartiallyComplete = divNmod[1]
if numFullYslices < xGridRes:
npxRemainder = np.array([])
npyRemainder = np.array([])
# What kind of beast is the line below?
nanArray = np.zeros(shape = (yGridRes*xGridRes -yGridRes*numFullYslices-numPartiallyComplete,))
nanArray[:] = np.NAN
# Is this pseudo-23 dimensional space definition?
npzRemainder = np.concatenate([z[yGridRes*numFullYslices:yGridRes*numFullYslices+numPartiallyComplete], nanArray])
for ii in range(numFullYslices, xGridRes):
npxRemainder = np.concatenate([npxRemainder, np.linspace(dX*ii+x[0], dX*ii+x[0], num = yGridRes)])
npyRemainder = np.concatenate([npyRemainder, np.linspace(y[0], y[0]+(yGridRes-1)*dY, num = yGridRes)])
else:
npxRemainder = np.array([])
npyRemainder = np.array([])
npzRemainder = np.array([])
npx = np.concatenate([x[0:yGridRes*numFullYslices], npxRemainder])
npy = np.concatenate([y[0:yGridRes*numFullYslices], npyRemainder])
npz = np.concatenate([z[0:yGridRes*numFullYslices], npzRemainder])
npx = npx.reshape(xGridRes, yGridRes).T
npy = npy.reshape(xGridRes, yGridRes).T
npz = npz.reshape(xGridRes, yGridRes).T
elif sweepType =="X":
# X sweep type ==> fix y, sweep x, then go to x+dy and
# sweep y again...
divNmod = divmod(len(x), xGridRes)
numFullXslices = divNmod[0]
numPartiallyComplete = divNmod[1]
if numFullXslices < yGridRes:
npxRemainder = np.array([])
npyRemainder = np.array([])
nanArray = np.zeros(shape = (yGridRes*xGridRes -xGridRes*numFullXslices-numPartiallyComplete,))
nanArray[:] = np.NAN
npzRemainder = np.concatenate([z[xGridRes*numFullXslices:xGridRes*numFullXslices+numPartiallyComplete], nanArray])
for ii in range(numFullXslices, yGridRes):
npyRemainder = np.concatenate([npyRemainder, np.linspace(dY*ii+y[0], dY*ii+y[0], num = xGridRes)])
npxRemainder = np.concatenate([npxRemainder, np.linspace(x[0], x[0]+(xGridRes-1)*dX, num = xGridRes)])
else:
npxRemainder = np.array([])
npyRemainder = np.array([])
npzRemainder = np.array([])
npx = np.concatenate([x[0:xGridRes*numFullXslices], npxRemainder])
npy = np.concatenate([y[0:xGridRes*numFullXslices], npyRemainder])
npz = np.concatenate([z[0:xGridRes*numFullXslices], npzRemainder])
npx = npx.reshape(xGridRes, yGridRes)
npy = npy.reshape(xGridRes, yGridRes)
npz = npz.reshape(xGridRes, yGridRes)
return (npx,npy,npz)
class MainWindow(QtGui.QMainWindow, form_class):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
self.cellpoints = np.array([])
self.FindCells.clicked.connect(self.Id_cells)
self.AddClassified.clicked.connect(self.create_csv)
self.imageviewbutton.clicked.connect(self.openMainFig)
self.numLayers.valueChanged.connect(self.redrawLayers)
self.maxSigSpin.valueChanged.connect(self.Id_cells)
self.minSigSpin.valueChanged.connect(self.Id_cells)
self.log_overlap.valueChanged.connect(self.Id_cells)
self.thresholdSpin.valueChanged.connect(self.Id_cells)
self.cropsize = 25
self.fig = Figure()
self.THEimage = np.array([])
self.BLUEimage = 0
self.BLUEblobs = np.array([])
self.REDimage = 0
self.GREENimage = 0
self.THEblobs = np.array([])
self.table.setColumnCount(6)
self.layout.addWidget(self.table, 1, 0)
self.table.setHorizontalHeaderLabels([
'Layer', 'Fluorescent cell count', 'Area', 'Density',
'Nuclei count', 'Fluorescent fraction'
])
for num, layer in enumerate(
[str(x + 1) for x in range(int(self.numLayers.text()))] +
['Total selected reg', 'Total image']):
self.table.insertRow(num)
self.table.setItem(num, 0, QtGui.QTableWidgetItem(layer))
self.table.setItem(num, 1, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 2, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 3, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 4, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 5, QtGui.QTableWidgetItem("0"))
self.directory = 'singleCells/'
self.guidePoints = {'TR': 0, 'TL': 0, 'BL': 0, 'BR': 0}
self.innergridRight = [
(self.guidePoints['TR'] * i + self.guidePoints['BR'] *
(int(self.numLayers.text()) - i)) / int(self.numLayers.text())
for i in range(1,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(self.guidePoints['TL'] * i + self.guidePoints['BL'] *
(int(self.numLayers.text()) - i)) / int(self.numLayers.text())
for i in range(1,
int(self.numLayers.text()) + 1)
]
self.polygonList = []
self.bigpoligon = 0
self.figname = 0
self.imgPolygon = 0
#self.saveDir.setText('singleCells/')
def openDIRwindow(self):
dirwindow = allDirectoriesWindow(self)
dirwindow.exec_()
def removeCell(self, cellnumber):
self.THEblobs[cellnumber:-1] = self.THEblobs[cellnumber + 1:]
self.THEblobs = self.THEblobs[:-1]
self.ImgAddPatches()
def chooseDirectory(self):
directory = QtGui.QFileDialog.getExistingDirectory(self)
self.saveDir.setText(str(directory) + '/')
self.DatabaseSize.setText(
str(len(glob.glob(str(self.saveDir.text()) + '*.png'))))
def openMainFig(self):
if self.THEimage.any() == True:
self.rmmpl()
self.THEimage = np.array([])
self.BLUEimage = 0
while self.table.rowCount() < int(self.numLayers.text()) + 2:
self.table.insertRow(0)
while self.table.rowCount() > int(self.numLayers.text()) + 2:
self.table.removeRow(0)
for num, layer in enumerate(
[str(x + 1) for x in range(int(self.numLayers.text()))] +
['Total selected reg', 'Total image']):
self.table.setItem(num, 0, QtGui.QTableWidgetItem(layer))
self.table.setItem(num, 1, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 2, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 3, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 4, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 5, QtGui.QTableWidgetItem("0"))
self.directory = 'singleCells/'
self.guidePoints = {'TR': 0, 'TL': 0, 'BL': 0, 'BR': 0}
self.innergridRight = [
(self.guidePoints['TR'] * i + self.guidePoints['BR'] *
(int(self.numLayers.text()) - i)) / int(self.numLayers.text())
for i in range(1,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(self.guidePoints['TL'] * i + self.guidePoints['BL'] *
(int(self.numLayers.text()) - i)) / int(self.numLayers.text())
for i in range(1,
int(self.numLayers.text()) + 1)
]
self.polygonList = []
self.bigpoligon = 0
self.nMarkedCells.setText(str(0))
self.THEblobs = np.array([])
name = QtGui.QFileDialog.getOpenFileName(
self, 'Single File', '~/Desktop/',
"Image files (*.jpg *.png *.tif)")
self.figname = str(name)
image = misc.imread(str(name))
#self.saveNames.setText(str(name).split("/")[-1][:-4] + 'i')
self.THEimage = image
self.imgPolygon = Polygon([[0, 0], [0, image.shape[1]],
[image.shape[0], image.shape[1]],
[image.shape[0], 0]])
self.BLUEimage = image[:, :, 2]
#self.BLUEblobs = blob_log(self.BLUEimage[self.cropsize:-self.cropsize,self.cropsize:-self.cropsize], max_sigma=int(self.maxSigSpin.text()), num_sigma=10, min_sigma = int(self.minSigSpin.text()),overlap = float(self.log_overlap.text()) ,threshold=float(self.thresholdSpin.text()))
self.REDimage = image[:, :, 0]
self.GREENimage = image[:, :, 1]
baseimage = self.fig.add_subplot(111)
baseimage.axis('off', frameon=False)
baseimage.grid(False)
baseimage.imshow(image)
axis('off')
subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
self.canvas = FigureCanvas(self.fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def onclick(self, event):
print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' %
(event.button, event.x, event.y, event.xdata, event.ydata))
if event.button == 3:
if str(self.rClicktype.currentText()) == 'Add cell':
squaresize = self.cropsize
#print(len(self.THEblobs))
self.THEblobs = np.array(self.THEblobs.tolist() + [[
int(event.ydata - squaresize),
int(event.xdata - squaresize), self.cropsize
]])
#print(len(self.THEblobs))
#self.table.setHorizontalHeaderLabels(['index', 'auto class', 'manual class'])
#rowPosition = self.table.rowCount()
#self.table.insertRow(rowPosition)
self.nMarkedCells.setText(
str(int(self.nMarkedCells.text()) + 1))
self.ImgAddPatches()
if str(self.rClicktype.currentText()) == 'Add 1st box corner':
self.guidePoints['TR'] = [int(event.ydata), int(event.xdata)]
self.rClicktype.setCurrentIndex == 'Add 2nd box corner'
if 0 not in self.guidePoints.values():
self.polygonList = []
self.innergridRight = [
(array(self.guidePoints['TR']) * i +
array(self.guidePoints['BR']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(array(self.guidePoints['TL']) * i +
array(self.guidePoints['BL']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
#print(self.innergridLeft, self.innergridRight)
self.bigpoligon = Polygon([
self.guidePoints['TR'], self.guidePoints['TL'],
self.guidePoints['BL'], self.guidePoints['BR']
])
for i in range(len(self.innergridLeft) - 1):
self.polygonList += [
Polygon([
self.innergridRight[i], self.innergridLeft[i],
self.innergridLeft[i + 1],
self.innergridRight[i + 1]
])
]
self.ImgAddPatches()
if str(self.rClicktype.currentText()) == 'Add 2nd box corner':
self.guidePoints['TL'] = [int(event.ydata), int(event.xdata)]
self.rClicktype.setCurrentIndex == 'Add 3rd box corner'
if 0 not in self.guidePoints.values():
self.polygonList = []
self.innergridRight = [
(array(self.guidePoints['TR']) * i +
array(self.guidePoints['BR']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(array(self.guidePoints['TL']) * i +
array(self.guidePoints['BL']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
#print(self.innergridLeft, self.innergridRight)
self.bigpoligon = Polygon([
self.guidePoints['TR'], self.guidePoints['TL'],
self.guidePoints['BL'], self.guidePoints['BR']
])
for i in range(len(self.innergridLeft) - 1):
self.polygonList += [
Polygon([
self.innergridRight[i], self.innergridLeft[i],
self.innergridLeft[i + 1],
self.innergridRight[i + 1]
])
]
self.ImgAddPatches()
if str(self.rClicktype.currentText()) == 'Add 3rd box corner':
self.guidePoints['BL'] = [int(event.ydata), int(event.xdata)]
self.rClicktype.setCurrentIndex == 'Add 4th box corner'
if 0 not in self.guidePoints.values():
self.polygonList = []
self.innergridRight = [
(array(self.guidePoints['TR']) * i +
array(self.guidePoints['BR']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(array(self.guidePoints['TL']) * i +
array(self.guidePoints['BL']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
#print(self.innergridLeft, self.innergridRight)
self.bigpoligon = Polygon([
self.guidePoints['TR'], self.guidePoints['TL'],
self.guidePoints['BL'], self.guidePoints['BR']
])
for i in range(len(self.innergridLeft) - 1):
self.polygonList += [
Polygon([
self.innergridRight[i], self.innergridLeft[i],
self.innergridLeft[i + 1],
self.innergridRight[i + 1]
])
]
self.ImgAddPatches()
if str(self.rClicktype.currentText()) == 'Add 4th box corner':
self.guidePoints['BR'] = [int(event.ydata), int(event.xdata)]
if 0 not in self.guidePoints.values():
self.polygonList = []
self.innergridRight = [
(array(self.guidePoints['TR']) * i +
array(self.guidePoints['BR']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(array(self.guidePoints['TL']) * i +
array(self.guidePoints['BL']) *
(int(self.numLayers.text()) - i)) /
int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
#print(self.innergridLeft, self.innergridRight)
self.bigpoligon = Polygon([
self.guidePoints['TR'], self.guidePoints['TL'],
self.guidePoints['BL'], self.guidePoints['BR']
])
#print(self.bigpoligon)
for i in range(len(self.innergridLeft) - 1):
self.polygonList += [
Polygon([
self.innergridRight[i], self.innergridLeft[i],
self.innergridLeft[i + 1],
self.innergridRight[i + 1]
])
]
self.ImgAddPatches()
if str(self.rClicktype.currentText()) == 'Remove cell':
dist = np.sum((self.THEblobs[:, 0:2] + self.cropsize + 1 -
[event.ydata, event.xdata])**2, 1)
if min(dist) < 800:
line = dist.tolist().index(min(dist))
#print(line)
self.removeCell(line)
self.nMarkedCells.setText(
str(int(self.nMarkedCells.text()) - 1))
#self.ImgAddPatches()
elif event.button == 2:
#print(self.THEblobs[:,0:2])
dist = np.sum((self.THEblobs[:, 0:2] + self.cropsize + 1 -
[event.ydata, event.xdata])**2, 1)
if min(dist) < 800:
line = dist.tolist().index(min(dist))
#print(line)
self.removeCell(line)
self.nMarkedCells.setText(
str(int(self.nMarkedCells.text()) - 1))
#self.ImgAddPatches()
def redrawLayers(self):
if 0 not in self.guidePoints.values():
self.polygonList = []
self.innergridRight = [
(array(self.guidePoints['TR']) * i +
array(self.guidePoints['BR']) *
(int(self.numLayers.text()) - i)) / int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
self.innergridLeft = [
(array(self.guidePoints['TL']) * i +
array(self.guidePoints['BL']) *
(int(self.numLayers.text()) - i)) / int(self.numLayers.text())
for i in range(0,
int(self.numLayers.text()) + 1)
]
#print(self.innergridLeft, self.innergridRight)
self.bigpoligon = Polygon([
self.guidePoints['TR'], self.guidePoints['TL'],
self.guidePoints['BL'], self.guidePoints['BR']
])
#print(self.bigpoligon)
for i in range(len(self.innergridLeft) - 1):
self.polygonList += [
Polygon([
self.innergridRight[i], self.innergridLeft[i],
self.innergridLeft[i + 1], self.innergridRight[i + 1]
])
]
self.ImgAddPatches()
def changeFIGURE(self, newFIG):
self.rmmpl()
self.canvas = FigureCanvas(newFIG)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.widget,
coordinates=True)
self.mplvl.addWidget(self.toolbar)
cid = self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def rmmpl(self, ):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
def Id_cells(self):
if type(self.BLUEimage) == type(0): return
while self.table.rowCount() < int(self.numLayers.text()) + 2:
self.table.insertRow(0)
while self.table.rowCount() > int(self.numLayers.text()) + 2:
self.table.removeRow(0)
for num, layer in enumerate(
[str(x + 1) for x in range(int(self.numLayers.text()))] +
['Total selected reg', 'Total image']):
self.table.setItem(num, 0, QtGui.QTableWidgetItem(layer))
self.table.setItem(num, 1, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 2, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 3, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 4, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 5, QtGui.QTableWidgetItem("0"))
squaresize = self.cropsize
image_gray = self.BLUEimage
self.BLUEblobs = blob_log(self.BLUEimage[squaresize:-squaresize,
squaresize:-squaresize],
max_sigma=int(self.maxSigSpin.text()),
num_sigma=10,
min_sigma=int(self.minSigSpin.text()),
overlap=float(self.log_overlap.text()),
threshold=float(self.thresholdSpin.text()))
self.table.setItem(
int(self.numLayers.text()) + 1, 4,
QtGui.QTableWidgetItem(str(len(self.BLUEblobs))))
if str(self.fMarker.currentText()) == 'RFP':
blobs = blob_log(self.REDimage[squaresize:-squaresize,
squaresize:-squaresize],
max_sigma=int(self.maxSigSpin.text()),
num_sigma=10,
min_sigma=int(self.minSigSpin.text()),
overlap=float(self.log_overlap.text()),
threshold=float(self.thresholdSpin.text()))
if str(self.fMarker.currentText()) == 'GFP':
blobs = blob_log(self.GREENimage[squaresize:-squaresize,
squaresize:-squaresize],
max_sigma=int(self.maxSigSpin.text()),
num_sigma=10,
min_sigma=int(self.minSigSpin.text()),
overlap=float(self.log_overlap.text()),
threshold=float(self.thresholdSpin.text()))
if str(self.fMarker.currentText()) == 'GFP or RFP':
jointImage = self.REDimage + self.GREENimage
blobs = blob_log(jointImage[squaresize:-squaresize,
squaresize:-squaresize],
max_sigma=int(self.maxSigSpin.text()),
num_sigma=10,
min_sigma=int(self.minSigSpin.text()),
overlap=float(self.log_overlap.text()),
threshold=float(self.thresholdSpin.text()))
#blobsDAPI = blob_log(self.BLUEimage[squaresize:-squaresize,squaresize:-squaresize], max_sigma=10, num_sigma=10, min_sigma = 3, threshold=.1)
self.THEblobs = blobs
self.nMarkedCells.setText(str(len(blobs)))
self.table.setItem(
int(self.numLayers.text()) + 1, 1,
QtGui.QTableWidgetItem(str(len(blobs))))
#self.table.setItem(9 , 2, QtGui.QTableWidgetItem(str(len(blobsDAPI))))
if float(self.table.item(int(self.numLayers.text()) + 1,
2).text()) != 0:
self.table.setItem(
int(self.numLayers.text()) + 1, 3,
QtGui.QTableWidgetItem(
str(
float(
self.table.item(int(self.numLayers.text()) + 1,
1).text()) /
float(
self.table.item(int(self.numLayers.text()) + 1,
2).text()))))
self.ImgAddPatches()
def ImgAddPatches(self):
colors = ['w', 'r', 'g', 'y', 'w', 'r', 'g', 'y', 'orange', 'w', 'r'
] * 100
squaresize = self.cropsize
close(self.fig)
self.fig, ax = subplots(1, 1)
ax.imshow(self.THEimage)
ax.axis('off')
subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
while self.table.rowCount() < int(self.numLayers.text()) + 2:
self.table.insertRow(0)
while self.table.rowCount() > int(self.numLayers.text()) + 2:
self.table.removeRow(0)
for num, layer in enumerate(
[str(x + 1) for x in range(int(self.numLayers.text()))] +
['Total selected reg', 'Total image']):
self.table.setItem(num, 0, QtGui.QTableWidgetItem(layer))
self.table.setItem(num, 1, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 2, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 3, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 4, QtGui.QTableWidgetItem("0"))
self.table.setItem(num, 5, QtGui.QTableWidgetItem("0"))
self.table.setItem(
int(self.numLayers.text()) + 1, 1,
QtGui.QTableWidgetItem(str(len(self.THEblobs))))
self.table.setItem(
int(self.numLayers.text()) + 1, 4,
QtGui.QTableWidgetItem(str(len(self.BLUEblobs))))
if float(self.table.item(int(self.numLayers.text()) + 1,
4).text()) > 0:
self.table.setItem(
int(self.numLayers.text()) + 1, 5,
QtGui.QTableWidgetItem(
str(
float(
self.table.item(int(self.numLayers.text()) + 1,
1).text()) /
float(
self.table.item(int(self.numLayers.text()) + 1,
4).text()))[:10]))
if 0 not in self.guidePoints.values():
ctr = 0
polygonListCount = array([0 for i in self.polygonList])
#print('pollistcount before:'+str(polygonListCount))
for number, blob in enumerate(self.THEblobs):
y, x, r = blob
blobPoint = Point(y + int(squaresize), x + int(squaresize))
if self.bigpoligon.contains(blobPoint):
ctr += 1
whichpolygon = [
1 if x.contains(blobPoint) else 0
for x in self.polygonList
]
polygonListCount += array(whichpolygon)
#print('pollistcount:'+str(polygonListCount))
c = Rectangle(
(x + int(squaresize / 2), y + int(squaresize / 2)),
squaresize,
squaresize,
color=colors[whichpolygon.index(1)],
linewidth=.5,
alpha=0.3)
ax.add_patch(c)
ax.text(x + squaresize - self.cropsize / 2,
y + squaresize + self.cropsize / 2,
polygonListCount[whichpolygon.index(1)],
color='white',
fontsize=10)
self.nMarkedCells.setText(str(ctr))
self.table.setItem(
int(self.numLayers.text()) + 1, 2,
QtGui.QTableWidgetItem(
str(self.imgPolygon.area / self.bigpoligon.area)[:4]))
self.table.setItem(
int(self.numLayers.text()), 2,
QtGui.QTableWidgetItem(
str(int(self.bigpoligon.area / self.bigpoligon.area))))
self.table.setItem(int(self.numLayers.text()), 1,
QtGui.QTableWidgetItem(str(ctr)))
self.table.setItem(int(self.numLayers.text()), 3,
QtGui.QTableWidgetItem(str(ctr)))
self.table.setItem(
int(self.numLayers.text()) + 1, 3,
QtGui.QTableWidgetItem(
str(
float(
self.table.item(int(self.numLayers.text()) + 1,
1).text()) /
float(
self.table.item(int(self.numLayers.text()) + 1,
2).text()))[:6]))
for n, pol in enumerate(self.polygonList):
self.table.setItem(
n, 2,
QtGui.QTableWidgetItem(
str(pol.area / self.bigpoligon.area)[:4]))
self.table.setItem(
n, 3,
QtGui.QTableWidgetItem(
str(polygonListCount[n] /
(pol.area / self.bigpoligon.area))[:6]))
self.table.setItem(
n, 1, QtGui.QTableWidgetItem(str(polygonListCount[n])))
#### add blue cells to dapi count
ctrDAPI = 0
polygonListCountDAPI = array([0 for i in self.polygonList])
for number, blob in enumerate(self.BLUEblobs):
y, x, r = blob
blobPoint = Point(y + int(squaresize), x + int(squaresize))
if self.bigpoligon.contains(blobPoint):
ctrDAPI += 1
whichpolygonDAPI = [
1 if x.contains(blobPoint) else 0
for x in self.polygonList
]
polygonListCountDAPI += array(whichpolygonDAPI)
self.table.setItem(int(self.numLayers.text()), 4,
QtGui.QTableWidgetItem(str(ctrDAPI)))
if float(self.table.item(int(self.numLayers.text()),
4).text()) > 0:
self.table.setItem(
int(self.numLayers.text()), 5,
QtGui.QTableWidgetItem(
str(
float(
self.table.item(int(self.numLayers.text()),
1).text()) / ctrDAPI)))
for n, pol in enumerate(self.polygonList):
self.table.setItem(
n, 5,
QtGui.QTableWidgetItem(
str(polygonListCount[n] /
polygonListCountDAPI[n])[:6]))
self.table.setItem(
n, 4, QtGui.QTableWidgetItem(str(polygonListCountDAPI[n])))
if 0 in self.guidePoints.values():
for number, blob in enumerate(self.THEblobs):
y, x, r = blob
c = Rectangle(
(x + int(squaresize / 2), y + int(squaresize / 2)),
squaresize,
squaresize,
color='gray',
linewidth=.5,
alpha=0.3)
ax.add_patch(c)
ax.text(x + squaresize - self.cropsize / 2,
y + squaresize + self.cropsize / 2,
str(number),
color='white',
fontsize=4)
for number, key in enumerate(self.guidePoints):
if self.guidePoints[key] != 0:
ax.add_patch(
Circle(self.guidePoints[key][::-1],
int(self.numLayers.text()),
color='w',
linewidth=2,
fill=True))
if self.guidePoints['TR'] != 0 and self.guidePoints['TL'] != 0:
ax.plot([self.guidePoints['TR'][1], self.guidePoints['TL'][1]],
[self.guidePoints['TR'][0], self.guidePoints['TL'][0]],
'-',
color='w',
linewidth=2)
if self.guidePoints['TL'] != 0 and self.guidePoints['BL'] != 0:
ax.plot([self.guidePoints['TL'][1], self.guidePoints['BL'][1]],
[self.guidePoints['TL'][0], self.guidePoints['BL'][0]],
'-',
color='w',
linewidth=2)
if self.guidePoints['BR'] != 0 and self.guidePoints['BL'] != 0:
ax.plot([self.guidePoints['BR'][1], self.guidePoints['BL'][1]],
[self.guidePoints['BR'][0], self.guidePoints['BL'][0]],
'-',
color='w',
linewidth=2)
if self.guidePoints['TR'] != 0 and self.guidePoints['BR'] != 0:
ax.plot([self.guidePoints['TR'][1], self.guidePoints['BR'][1]],
[self.guidePoints['TR'][0], self.guidePoints['BR'][0]],
'-',
color='w',
linewidth=2)
if 0 not in self.guidePoints.values():
for i in range(len(self.innergridLeft)):
ax.plot([self.innergridRight[i][1], self.innergridLeft[i][1]],
[self.innergridRight[i][0], self.innergridLeft[i][0]],
'-',
color='w',
linewidth=1)
ax.axis('off')
subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
for item in [self.fig, ax]:
item.patch.set_visible(False)
self.changeFIGURE(self.fig)
def create_csv(self):
layer = np.array([
str(self.table.item(i, 0).text())
for i in range(self.table.rowCount())
])
fcells = np.array([
str(self.table.item(i, 1).text())
for i in range(self.table.rowCount())
])
area = np.array([
str(self.table.item(i, 2).text())
for i in range(self.table.rowCount())
])
density = np.array([
str(self.table.item(i, 3).text())
for i in range(self.table.rowCount())
])
nucleiCount = np.array([
str(self.table.item(i, 4).text())
for i in range(self.table.rowCount())
])
transfectedRatio = np.array([
str(self.table.item(i, 5).text())
for i in range(self.table.rowCount())
])
classtable = DataFrame(
np.transpose(
np.vstack((layer, fcells, area, density, nucleiCount,
transfectedRatio
)))) #, index=dates, columns=[nome , classe])
print(classtable)
saveclassification = classtable.to_csv(self.figname + '_count.csv',
index=False,
header=[
'layers',
'Fluorescent cells', 'Area',
'Density',
'DAPI cell count',
'Transfection efficiency'
])
