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 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 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.thisDir = os.path.dirname(os.path.abspath(__file__))
self.btOpenImage.clicked.connect(self.openImage)
fig = Figure()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
return
def openImage(self) :
texto = 'Escolha uma imagem'
path = QtGui.QFileDialog.getOpenFileNameAndFilter(self,
texto,
self.thisDir,
"Images (*.png *.jpg)")
datafile = cbook.get_sample_data(str(path[0]))
img = imread(datafile)
self.updateCanvas(self.initializeCanvas(img))
return
def initializeCanvas(self, img) :
fig = Figure()
fig.clear()
Graph = fig.add_subplot(111)
Graph.imshow(img, zorder=0, extent=[0.0, 1.0, 0.0, 1.0])
return fig
def updateCanvas(self, fig) :
self.canvasGraph.removeWidget(self.canvas)
self.canvas.close()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
def onclick(event):
x, y = event.xdata, event.ydata
print x, y
self.canvas.mpl_connect('button_press_event', onclick)
return
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.thisDir = os.path.dirname(os.path.abspath(__file__))
self.btOpenImage.clicked.connect(self.openImage)
fig = Figure()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
return
def openImage(self):
texto = 'Escolha uma imagem'
path = QtGui.QFileDialog.getOpenFileNameAndFilter(
self, texto, self.thisDir, "Images (*.png *.jpg)")
datafile = cbook.get_sample_data(str(path[0]))
img = imread(datafile)
self.updateCanvas(self.initializeCanvas(img))
return
def initializeCanvas(self, img):
fig = Figure()
fig.clear()
Graph = fig.add_subplot(111)
Graph.imshow(img, zorder=0, extent=[0.0, 1.0, 0.0, 1.0])
return fig
def updateCanvas(self, fig):
self.canvasGraph.removeWidget(self.canvas)
self.canvas.close()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
def onclick(event):
x, y = event.xdata, event.ydata
print x, y
self.canvas.mpl_connect('button_press_event', onclick)
return
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 Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
######################### Get database info #########################
self.engine = '' # engine variable stores database information
self.wedit = db.DBInfo(self)
self.wedit.exec_()
self.plot2D = True
self.Echeck = True
self.Eplot = True
self.Ccheck = True
self.Cplot = True
self.plotall = False
super(Main, self).__init__()
self.setupUi(self)
# TODO: make queries for max year and min year
self.year = get_minyear(self.engine)
self.slyear.setMaximum(get_maxyear(self.engine))
self.slyear.setMinimum(self.year)
######################### Initialize text for selected year #########################
self.txtyear.setText(str(self.slyear.value()))
######################### Program events #########################
self.slyear.valueChanged.connect(self.updTxt)
self.slyear.sliderReleased.connect(self.updFig)
self.txtyear.returnPressed.connect(self.updSl)
self.actionDatabase_info.triggered.connect(self.edit)
self.btnglobe.clicked.connect(self.globebutton)
self.chkconflicts.stateChanged.connect(self.conflictCheck)
self.chkeclipses.stateChanged.connect(self.eclipseCheck)
self.actionGenerate_Globe.triggered.connect(self.globemovie)
self.actionPlot_all.triggered.connect(self.plot_all_datapoints)
fig = plotmap()
self.addmpl(fig)
self.chkconflicts.toggle()
self.chkeclipses.toggle()
######################### Plot all data #########################
def plot_all_datapoints(self):
self.plotall = True
self.updFig()
######################### Map button #########################
def globebutton(self):
if self.plot2D:
self.plot2D = False
self.btnglobe.setText('Map view')
self.slyear.setMaximum(0)
self.slyear.setMaximum(360)
self.updFig()
else:
self.plot2D = True
self.btnglobe.setText('Globe view')
self.year = get_minyear(self.engine)
self.slyear.setMaximum(get_maxyear(self.engine))
self.slyear.setMinimum(self.year)
self.updFig()
######################### Checkbox features #########################
def conflictCheck(self):
if self.Ccheck:
self.Cplot = True
self.Ccheck = False
self.updFig()
else:
self.Cplot = False
self.Ccheck = True
self.updFig()
def eclipseCheck(self):
if self.Echeck:
self.Eplot = True
self.Echeck = False
self.updFig()
else:
self.Eplot = False
self.Echeck = True
self.updFig()
######################### Edit textbox and slider #########################
def updTxt(self):
if self.plot2D:
self.plotall = False
self.txtyear.setText(str(self.slyear.value()))
def updSl(self):
if self.plot2D:
self.plotall = False
self.slyear.setValue(int(self.txtyear.text()))
self.updFig()
######################### Update figure #########################
def updFig(self):
try:
self.rmmpl()
except:
pass
failed = False
self.updYear()
try:
fig1 = get_conflicts(self.engine, self.year, self.Eplot, self.Cplot, self.plot2D, self.plotall, int(self.txtyear.text()))
self.addmpl(fig1)
except Exception as e:
print(e)
info = "Could not connect to database. Are you sure you're connected to one?"
failed = True
pass
if failed:
QtGui.QMessageBox.information(self, 'Error', info)
else:
self.updConflist()
self.updExplist()
def updYear(self):
if self.plot2D:
self.year = int(self.txtyear.text())
######################### Check if event is clicked #########################
def onpick(self, event):
ind = event.ind
artist = event.artist
xdata = artist.get_xdata()
ydata = artist.get_ydata()
if ind[0] in range(len(xdata)):
self.updTxtinfo(ind, artist)
return ind[0]
def updTxtinfo(self, ind, artist):
lat = artist.get_ydata()[ind[0]]
lon = artist.get_xdata()[ind[0]]
year = int(self.txtyear.text())
conflict = True
try:
self.txtconfinfo.setText(get_confinfo(self.engine, lat, lon, year))
except:
conflict = False
if not conflict:
try:
self.txteclipse.setText(get_eclipseinfo(self.engine, lat, lon, year))
except:
pass
######################### Create a movie #########################
def globemovie(self):
makethevideo(self.engine,int(self.txtyear.text()), self.Eplot,self.Cplot,self.plotall)
def updConflist(self):
self.txtconflist.setText(get_conflist(self.engine, int(self.txtyear.text())))
def updExplist(self):
self.txtexport.setText(get_exportlist(self.engine, int(self.txtyear.text())))
######################### Create Database #########################
def edit(self):
self.wedit = db.DBInfo(self)
self.wedit.show()
######################### Create figure #########################
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.canvas.mpl_connect('pick_event', self.onpick)
self.mplvlayout.addWidget(self.canvas)
self.canvas.draw()
######################### Remove figure #########################
def rmmpl(self,):
self.mplvlayout.removeWidget(self.canvas)
self.canvas.close()
self.mplvlayout.removeWidget(self.toolbar)
self.toolbar.close()
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 MyMain(QMainWindow, Ui_MyMainWindow):
"""This class defines the application logic for a GUI construction
This class defines the application logic based on the GUI defined as
the front end. The GUI is defined through the base classes Ui_MyMainWindow
and QMainwindow. The class QMainWindow is part of every QT application ( at
least one is need) and generates a window with the normal windows decorations,
i.e. zou you can drag it around and resize it like any normal window.
The class Ui_MyMainWindow is a subclass of QMainWindow customizing the
standard windows as created by an instance of QMainWindow. Ui_MyMainWindow
defines the overall GUI design while the class MyMain contains the necessary
application logic to display matplotlib data plots and a plot selection
list.
"""
def __init__(self, ):
"""
Initialises an empty dictionary to store Figure instances by name.
Clicks on list items are associated with the method changefig.
An empty figure instance is added to the plotting window during
initialisation, such that the method changefig can remove the current
figure.
"""
super(MyMain, self).__init__()
self.setupUi(self)
self.fig_dict = {}
self.mplfigslist.itemClicked.connect(self.changefig)
fig = Figure()
self.addmpl(fig)
def changefig(self, item):
"""
Removes the current plot and displays the new one associated with the
item clicked.
Parameters
----------
item : instance of class QListWidgetItem, which defines a method 'text',
which simply returns the text of the selectd item.
"""
text = item.text()
if text == 'Exit Application':
self.close()
else:
self.rmmpl()
self.addmpl(self.fig_dict[text])
def addfig(self, name, fig):
"""
The Figure fig is added to the dictionary under the 'name' key.
The name key is added to the list Widget 'mplfigslist' an instance of
QT class QListWidget.
Parameters
----------
name : string
denoting the name of Figure instance.
fig : Figure
Figure instance associated with keyword 'name' .
"""
self.fig_dict[name] = fig
self.mplfigslist.addItem(name)
def addmpl(self, fig):
"""
Displays the Figure instance fig in the matplotlib container, a
generic QT container widget. A vertical layout named 'mplvl' is
enforced for any encapsulated widgets in this container. This
instance of QT class QVBoxLayout has an 'addWidget' method for
adding new vertically alligned widgets into the matplolib container
widget. Thismethd is used to upload the FigureCanvas object 'canvas',
which contains the plot.
Parameters
----------
fig : Figure instance
"""
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self):
"""
Removes the container widget with the current plot from the
GUI window and closes the canvas containing that current plot.
The method 'removeWidget' of the 'mplv' QVBoxLayout is used.
"""
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
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 MyWindowClass(QtGui.QMainWindow,serm.Ui_MainWindow):
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = serm.Ui_MainWindow()
self.setupUi(self)
self.pushButton_predict_risk.clicked.connect(self.predict_risk)
self.pushButton_DA_showplot.clicked.connect(self.showplot)
self.pushButton_DA_pearson.clicked.connect(self.calc_consist)
self.pushButton_PM_H2Oinit.clicked.connect(self.h2oinitfunc)
self.pushButton_DA_data_consist.clicked.connect(self.data_integrity_check)
self.pushButton_PM_Predict.clicked.connect(self.model_predict)
self.pushButton_PM_FWI.clicked.connect(self.calc_FWI)
self.pushButton_PM_BuildModel.clicked.connect(self.H2OBuildModel)
self.pushButton_PM_LastWData.clicked.connect(self.h2ogetdata)
self.pushButton_PM_addRecord.clicked.connect(self.addrow)
self.pushButton_PM_addweatherRecord.clicked.connect(self.addweatherrow)
self.tabMenu.connect(self.tabMenu,SIGNAL("currentChanged(int)"),self,SLOT("tabChangedSlot(int)"))
self.dateTimeEdit.setDateTime(datetime.now())
client.on_connect = self.on_connect
client.on_message = self.on_message
client.on_subscribe = self.on_subscribe
#client.connect("broker.hivemq.com", 1883,keepalive=0)
#client.connect("test.mosquitto.org",1883,keepalive=0)
client.connect("localhost", 1883,keepalive=0)
self.dial.valueChanged.connect(self.lbl_dialnum.setNum)
self.fn_gphlr()
scheduler.add_job(self.readData, 'interval', seconds=1, misfire_grace_time=2, id='readdata')
scheduler.add_job(self.timed_job, 'interval', seconds=10, id='recmeans')
scheduler.add_job(self.wunderground, 'interval', minutes=5, misfire_grace_time=2, id='wunderground')
self.wunderground()
self.timed_job()
model = None
test = None
def show_predictions_table(self):
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
self.tableView_PM.setWindowTitle("Connect to QSQLITE Database Example")
db.setHostName("localhost")
db.setDatabaseName("serm.db")
db.setUserName("")
db.setPassword("")
if (db.open()==False):
message = "Database Error"
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Error at opening database")
msg.setInformativeText(message)
msg.setWindowTitle("Informative Message")
msg.setStandardButtons(QMessageBox.Close)
msg.exec_()
projectModel = QSqlQueryModel()
projectModel.setQuery("SELECT datetime,smoke,temperature,humidity,windspeed,fri,ffwi FROM predictions ORDER BY recid DESC",db)
self.tableView_PM.setModel(projectModel)
self.tableView_PM.adjustSize
self.tableView_PM.setColumnWidth(0,160)
self.tableView_PM.show()
def addrow(self):
conn = sqlite3.connect('serm.db')
with conn:
dtm = self.dateTimeEdit_PM_datetime.text()
smk = self.doubleSpinBox_PM_smoke.text()
tmp = self.doubleSpinBox_PM_temp.text()
hmd = self.doubleSpinBox_PM_humidity.text()
wndspd = self.doubleSpinBox_PM_WindSpeed.text()
ffwi = self.lineEdit_PM_calcFWI.text()
risk = self.lineEdit_PM_predictRiskVal.text()
conn.execute("INSERT INTO predictions(datetime,smoke,temperature,humidity,windspeed,fri,ffwi) VALUES (?,?,?,?,?,?,?)", (dtm,smk,tmp,hmd,wndspd,risk,ffwi))
conn.close()
self.show_predictions_table()
def addweatherrow(self):
conn = sqlite3.connect('serm.db')
with conn:
dt = self.dateTimeEdit_PM_datetime.dateTime()
dtm = datetime.strftime(dt.toPyDateTime(), '%Y-%m-%d %H:%M:%S')
smk = self.doubleSpinBox_PM_smoke.value()
print(smk)
tmp = self.doubleSpinBox_PM_temp.value()
hmd = self.doubleSpinBox_PM_humidity.value()
wndspd = self.doubleSpinBox_PM_WindSpeed.value()
ffwi = self.lineEdit_PM_calcFWI.text()
risk = self.lineEdit_PM_predictRiskVal.text()
ddate = self.dateTimeEdit_PM_datetime.dateTime()
date_var = ddate.toPyDateTime()
tstmp = time.mktime(date_var.timetuple())
conn.execute("INSERT INTO data_means(timestamp,datetime,smoke,co,lpg,temperature,humidity,windspeed,winddir,risk,ffwi) VALUES (?,?,?,?,?,?,?,?,?,?,?)", (tstmp,dtm,smk,0,0,tmp,hmd,wndspd,'X',risk,ffwi))
conn.close()
self.show_predictions_table()
def on_connect(self,client, userdata, flags, rc):
print("CONNACK received with code %d." % (rc))
client.subscribe("/SERM",0)
def on_message(self,client, userdata, msg):
if msg.payload:
self.dateTimeEdit.setDateTime(datetime.now())
data = str(msg.payload).strip("b,',\n,\\")
parsed_json = json.loads(data)
smk = str(parsed_json['smk'])
lpg = str(parsed_json['lpg'])
co = str(parsed_json['co'])
hum = str(parsed_json['hum'])
temp = str(parsed_json['temp'])
wndspd = str(parsed_json['wndspd'])
wnddir = (parsed_json['wnddir'])
datetimestamp = calendar.timegm(time.strptime(str(time.strftime('%Y-%m-%d %H:%M:%S')), '%Y-%m-%d %H:%M:%S'))
T = float(temp)
H = float(float(hum)/100)
W = 349 + (1.29*T)+(0.0135*(T**2))
K = 0.805 + 0.000736*T - 0.000000273*(T**2)
K1 = 6.27 + 0.000938*T - 0.0000303*(T**2)
K2 = 1.91 + 0.0407*T - 0.000293*(T**2)
M = 1800/W *(((K*H)/(1-(K*H)))+(((K1*K*H)+(2*K1*K2*(K**2)*(H**2)))/(1+(K1*K*H)+(K1*K2*(K**2)*(H**2)))))
WMPH = float(wndspd)
M30 = M/30
WSQR = WMPH*WMPH
fmdc = 1 - 2*M30 + 1.5*M30**2 - 0.5*M30**3
CMBE = (fmdc*sqrt(1+WSQR))/0.3002
conn = sqlite3.connect('serm.db')
with conn:
conn.execute("INSERT INTO data(datetime,smoke,lpg,co,humidity,temperature,windspeed,winddir,ffwi) VALUES (?,?,?,?,?,?,?,?,?)", (datetimestamp,smk,lpg,co,hum,temp,wndspd,wnddir,str(CMBE)))
conn.commit()
def on_subscribe(self,client, userdata, mid, granted_qos):
print("Subscribed: "+str(mid)+" "+str(granted_qos))
def on_log(self,client, obj, level, string):
print(string)
@pyqtSlot(int)
def tabChangedSlot(self,argTabIndex):
if argTabIndex==1:
db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
self.tableView.setWindowTitle("Connect to QSQLITE Database Example")
db.setHostName("localhost")
db.setDatabaseName("serm_shadow.db")
db.setUserName("")
db.setPassword("")
if (db.open()==False):
message = "Database Error"
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Error at opening database")
msg.setInformativeText(message)
msg.setWindowTitle("Informative Message")
msg.setStandardButtons(QMessageBox.Close)
msg.exec_()
projectModel = QSqlQueryModel()
projectModel.setQuery("SELECT datetime,temperature,humidity,smoke,lpg,co,windspeed,winddir,ffwi,risk FROM data_means ORDER BY recid DESC",db)
self.tableView.setModel(projectModel)
self.tableView.adjustSize
self.tableView.setColumnWidth(0,168)
self.tableView.show()
elif argTabIndex==3:
conn = sqlite3.connect('serm.db')
ds = pd.read_sql("SELECT timestamp,datetime,risk,smoke,temperature,humidity,windspeed,ffwi from data_means", conn);
conn.close()
ds.to_csv("serm.csv")
self.show_predictions_table()
def fn_gphlr(self):
conn = sqlite3.connect('serm.db')
ds = pd.read_sql("SELECT timestamp,recid,ffwi,risk,smoke from data_means", conn);
dx = ds.recid
dy = ds.risk
pl2 = sns.regplot(dx,dy,data=dy,order=2)
fig2 = pl2.figure
self.addmpl(fig2)
def showplot(self):
conn = sqlite3.connect('serm_shadow.db')
df = pd.read_sql("SELECT ffwi,temperature,smoke,humidity,windspeed from data_means", conn)
self.gridLayout_DA_plot.removeWidget(self.canvas)
if self.comboBox_DA_diag.currentText() == "Histogram":
g = sns.pairplot(df,dropna=True,diag_kind="hist",size=2.2)
fig = g.fig
self.canvas = FigureCanvas(fig)
self.gridLayout_DA_plot.addWidget(self.canvas)
self.canvas.draw()
def calc_FWI(self):
humidity = self.doubleSpinBox_PM_humidity.value()
temperature = self.doubleSpinBox_PM_temp.value()
windspeed = self.doubleSpinBox_PM_WindSpeed.value()
###############################################################################################
T = float(temperature)
H = float(float(humidity)/100)
W = 349 + (1.29*T)+(0.0135*(T**2))
K = 0.805 + 0.000736*T - 0.000000273*(T**2)
K1 = 6.27 + 0.000938*T - 0.0000303*(T**2)
K2 = 1.91 + 0.0407*T - 0.000293*(T**2)
M = 1800/W *(((K*H)/(1-(K*H)))+(((K1*K*H)+(2*K1*K2*(K**2)*(H**2)))/(1+(K1*K*H)+(K1*K2*(K**2)*(H**2)))))
WMPH = float(windspeed)
M30 = M/30
WSQR = WMPH*WMPH
fmdc = 1 - 2*M30 + 1.5*M30**2 - 0.5*M30**3
CMBE = (fmdc*sqrt(1+WSQR))/0.3002
###############################################################################################
ffwi = str(round(CMBE,3))
self.lineEdit_PM_calcFWI.setText(ffwi)
def model_predict(self):
global model
global test
datevar = self.dateTimeEdit_PM_datetime.dateTime().toString("yyyy-MM-dd HH:mm:ss")
ffwi = self.lineEdit_PM_calcFWI.text()
smoke = self.doubleSpinBox_PM_smoke.value()
humidity = self.doubleSpinBox_PM_humidity.value()
temperature = self.doubleSpinBox_PM_temp.value()
windspeed = self.doubleSpinBox_PM_WindSpeed.value()
d = [datevar, ffwi, smoke , temperature, humidity, windspeed]
f = h2o.H2OFrame(d)
f.set_names(["datetime","ffwi","smoke","temperature", "humidity", "windspeed"])
predict = model.predict(f)
fnum = re.findall("[-+]?[0-9]*\.?[0-9]+", str(predict))
self.lineEdit_PM_predictRiskVal.setText(fnum[0])
def data_integrity_check(self):
conn = sqlite3.connect('serm_shadow.db')
message = None
data = pd.read_sql("SELECT risk,temperature,smoke,humidity,windspeed from data_means", conn)
assert(0 < len(data))
for index, row in data.iterrows():
assert(row["smoke"] >= 0),message + "Undefined Smoke value(s)\n"
assert(row["windspeed"] >= 0),message +"Undefined Windspeed value(s)\n"
assert(row["risk"] >= 0),message + "Undefined Risk value(s)\n"
assert(row["humidity"] >= 0),message + "Undefined Humidity value(s)\n"
if message == None:
message = "No errors on data"
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Data consisteny completed successfully")
msg.setInformativeText(message)
msg.setWindowTitle("MessageBox")
msg.setStandardButtons(QMessageBox.Close)
msg.exec_()
def calc_consist(self):
var1 = "risk"
var2 = None
if self.radioButton_PM_FWI.isChecked()==True :
var2 = "ffwi"
if self.radioButton_PM_TMP.isChecked()==True :
var2 = "temperature"
if self.radioButton_PM_HM.isChecked()==True :
var2 = "humidity"
if self.radioButton_PM_WNSPD.isChecked()==True :
var2 = "windspeed"
if self.radioButton_PM_SMK.isChecked()==True :
var2 = "smoke"
conn = sqlite3.connect('serm_shadow.db')
data = pd.read_sql("SELECT risk,ffwi,temperature,smoke,humidity,windspeed from data_means", conn)
if self.radioButton_DA_pears.isChecked() == True:
r_row, p_value = scipy.stats.pearsonr(data[var1], data[var2])
elif self.radioButton_DA_spear.isChecked() == True:
r_row, p_value = scipy.stats.spearmanr(data[var1], data[var2])
self.lineEdit_DA_coefficient.setText(str(round(r_row,3)));
self.lineEdit_DA_pvalue.setText(str(round(p_value,3)));
def removeplot(self):
self.gridLayout_DA_plot.removeWidget(self.canvas)
self.canvas.close()
def H2OBuildModel(self):
weather = "serm.csv"
weather_df = h2o.import_file(path=weather)
global model
global test
train,test,valid = weather_df.split_frame(ratios=(.7, .15))
estimator_index = self.tabWidget_PM_Estimator.currentIndex()
if estimator_index == 0:
_distribution = self.comboBox_PM_distribution.currentText()
_activation = self.comboBox_PM_activation.currentText()
_hidden = self.comboBox_PM_hidden.currentText()
_epochs = self.spinBox_PM_epochs.value()
_sparse = self.comboBox_PM_sparse.currentText()
_shuffle = self.comboBox_PM_shuffle.currentText()
model = H2ODeepLearningEstimator(distribution=_distribution,activation=_activation,hidden=_hidden,shuffle = _shuffle,sparse=_sparse,epochs=_epochs)
self.completed = 0
while self.completed < 100:
self.completed += 0.0001
self.progressBar.setValue(self.completed)
model.train(y="risk", x=["datetime","ffwi","smoke","temperature", "humidity", "windspeed"], training_frame=train)
metrics = model.model_performance()
self.lineEdit_PM_MSE.setText(str(round(metrics['MSE'],5)))
self.lineEdit_PM_RMSE.setText(str(round(metrics['RMSE'],5)))
self.lineEdit_PM_MAE.setText(str(round(metrics['mae'],5)))
self.lineEdit_PM_MRD.setText(str(round(metrics['mean_residual_deviance'],5)))
def predict_risk(self):
selected_hours = int(self.lbl_dialnum.text())
conn = sqlite3.connect('serm.db')
with conn:
df = pd.read_sql("SELECT recid,risk from data_means", conn);
lm = smf.ols("risk ~ recid", data=df).fit()
cur = conn.cursor()
cur.execute('SELECT MAX(recid) from data_means')
data = cur.fetchone()
c_recid = data[0]
counts = int((selected_hours * 60)*60)
total = counts+c_recid
idx = []
riskarr = []
for x in range(c_recid, total):
riskarr.append(lm.predict({'recid': x}))
idx.append(x)
df = pd.DataFrame(riskarr, index=idx)
self.txt_mean.setText(str(round(df.mean()[0],3)))
self.txt_max.setText(str(round(df.max()[0],3)))
self.txt_min.setText(str(round(df.min()[0],3)))
palette = QtGui.QPalette()
risk = df.mean()[0]
if risk < 10:
palette.setColor(QtGui.QPalette.Foreground,QtCore.Qt.green)
self.txt_max_2.setPalette(palette)
self.txt_max_2.setText("LOW")
elif risk >= 10 and risk < 30:
palette.setColor(QtGui.QPalette.Foreground,QtCore.Qt.yellow)
self.txt_max_2.setPalette(palette)
self.txt_max_2.setText("AVERAGE")
else:
palette.setColor(QtGui.QPalette.Foreground,QtCore.Qt.red)
self.txt_max_2.setPalette(palette)
self.txt_max_2.setText("HIGH")
def readData(self):
client.loop()
def h2ogetdata(self):
weather = "serm.csv"
weather_df = h2o.import_file(path=weather)
self.doubleSpinBox_PM_temp.setValue(weather_df.tail(1)['temperature'])
self.doubleSpinBox_PM_humidity.setValue(weather_df.tail(1)['humidity'])
self.doubleSpinBox_PM_smoke.setValue(weather_df.tail(1)['smoke'])
self.doubleSpinBox_PM_WindSpeed.setValue(weather_df.tail(1)['windspeed'])
#strfwi = re.findall("[-+]?[0-9]*\.?[0-9]+", str(weather_df.tail(1)['ffwi']))
#self.lineEdit_PM_calcFWI.setText(strfwi[0])
dttmstamp = datetime.utcfromtimestamp(weather_df.tail(1)['timestamp'])
self.dateTimeEdit_PM_datetime.setDateTime(dttmstamp)
def h2oinitfunc(self):
h2o.init()
if str(h2o.connection())=="<H2OConnection to http://localhost:54321, no session>":
self.lineEdit_PM_h2o_response.setText("Connection to H2O cluster Successful")
else:
self.lineEdit_PM_h2o_response.setText("Connection to H2O cluster Failed")
def timed_job(self):
conn = sqlite3.connect('serm.db')
with conn:
df = pd.read_sql_query("SELECT * from data", conn);
df.humidity = np.array(df.humidity.astype(float))
df.temperature = np.array(df.temperature.astype(float))
df.smoke = np.array(df.smoke.astype(float))
df.co = np.array(df.co.astype(float))
df.lpg = np.array(df.lpg.astype(float))
df.windspeed = np.array(df.windspeed.astype(float))
df.ffwi = np.array(df.ffwi.astype(float))
datetm = calendar.timegm(time.strptime(str(time.strftime('%Y-%m-%d %H:%M:%S')), '%Y-%m-%d %H:%M:%S'))
datedt = time.strftime('%Y-%m-%d %H:%M:%S')
winddir = df.winddir.tail(1).iget(0)
predict_risk.input['FFWI'] = df.ffwi.mean()
predict_risk.input['SMOKE'] = df.smoke.mean()
predict_risk.compute()
risk = predict_risk.output['RISK']
conn.execute("INSERT INTO data_means(timestamp,datetime,smoke,lpg,co,temperature,humidity,windspeed,winddir,ffwi,risk) VALUES (?,?,?,?,?,?,?,?,?,?,?)", (datetm,datedt,round(df.smoke.mean(),3),round(df.lpg.mean(),3),round(df.co.mean(),3),round(df.temperature.mean(),3),round(df.humidity.mean(),3),round(df.windspeed.mean(),3),winddir,round(df.ffwi.mean(),3),round(risk,3)))
conn.commit()
sql = "DELETE FROM data WHERE recid <= ( SELECT recid FROM (SELECT recid FROM data ORDER BY recid DESC LIMIT 1 OFFSET 20)foo)"
conn.execute(sql)
conn.commit()
# self.lcdNumber_ffwi.display(str(round(df.ffwi.mean(),-1)))
self.lcdNumber_ffwi.display(str(df.ffwi.mean()))
self.lcdNumber_risk.display((risk))
palette = QtGui.QPalette()
if risk < 10:
palette.setColor(QtGui.QPalette.Foreground,QtCore.Qt.green)
self.lbl_RiskStateValue.setPalette(palette)
self.lbl_RiskStateValue.setText("LOW")
elif risk >= 10 and risk < 30:
palette.setColor(QtGui.QPalette.Foreground,QtCore.Qt.yellow)
self.lbl_RiskStateValue.setPalette(palette)
self.lbl_RiskStateValue.setText("AVERAGE")
else:
palette.setColor(QtGui.QPalette.Foreground,QtCore.Qt.red)
self.lbl_RiskStateValue.setPalette(palette)
self.lbl_RiskStateValue.setText("HIGH")
sound = QSound("smoke-detector-1.wav")
sound.play()
def setclock(self,):
self.dateTimeEdit.setDateTime(datetime.now())
def rmmpl(self,):
self.gridLayout.removeWidget(self.canvas)
self.canvas.close()
def addmpl(self,fig):
self.canvas = FigureCanvas(fig)
self.gridLayout.addWidget(self.canvas)
self.canvas.draw()
def wunderground(self):
webURL = urllib.request.urlopen('http://api.wunderground.com/api/3efe05c687cbcdcb/geolookup/conditions/q/GR/Tripolis.json')
json_string = webURL.read()
encoding = webURL.info().get_content_charset('utf-8')
parsed_json = json.loads(json_string.decode(encoding))
temp_f = parsed_json['current_observation']['temp_c']
relative_humidity = parsed_json['current_observation']['relative_humidity']
wind_dir = parsed_json['current_observation']['wind_dir']
wind_kph = parsed_json['current_observation']['wind_kph']
self.ln_ctmp.setText(str(temp_f))
self.ln_relh.setText(str(relative_humidity))
self.ln_wndsp.setText(str(wind_kph))
self.ln_wnd.setText(str(wind_dir))
webURL.close()
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(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, ):
QtGui.QMainWindow.__init__(self)
self.setupUi(self)
icon = QtGui.QIcon(':/Icon.png')
self.setWindowIcon(icon)
self.coeffWH = CAPTUREHEIGHT/CAPTUREWIDTH
self.objectName = self.objectLine.text()
self.path = PATH
self.directoryLine.setText(self.path)
self.camara = CAMARA
self.camaraLine.setText(self.camara)
self.status = False
self.cam = None
self.posSlider.valueChanged.connect(self.posChange)
self.sizeSlider.valueChanged.connect(self.sizeChange)
self.brightnessSlider.valueChanged.connect(self.brightnessChange)
self.contrastSlider.valueChanged.connect(self.contrastChange)
self.saturationSlider.valueChanged.connect(self.saturationChange)
self.hueSlider.valueChanged.connect(self.hueChange)
self.gainSlider.valueChanged.connect(self.gainChange)
self.exposureSlider.valueChanged.connect(self.exposureChange)
self.enable_camara_change.changed.connect(self.enableCamaraChangerAction)
self.actionSave_in.triggered.connect(self.saveFiles)
self.actionSave_in.setShortcut('Ctrl+S')
self.aboutAction.triggered.connect(self.about)
self.filesListWidget.currentRowChanged.connect(self.updateFileImage)
self.startstopButton.clicked.connect(self.startStop)
self.captureButton.clicked.connect(self.captureData)
self.cleanButton.clicked.connect(self.cleanPlot)
self.resetButton.clicked.connect(self.resetSettings)
self.getFilesButton.clicked.connect(self.getfiles)
self.analyzeButton.clicked.connect(self.analyzeImages)
self.saveButton.clicked.connect(self.saveFiles)
self.clearFilesButton.clicked.connect(self.clearFiles)
self.comboBox_2.addItem("680 x 480")
self.comboBox_2.addItem("1280 x 720")
# self.comboBox_2.addItem("1920 x 1080")
self.comboBox_2.activated[str].connect(self.resolutionBox)
self.canvas = None
self.filenames = []
self.imagesFig = None
self.namesOnly = []
self.plot = None
def enableCamaraChangerAction(self):
value = self.enable_camara_change.isChecked()
self.camaraLine.setEnabled(value)
def startStop(self):
self.camaraLine.setEnabled(False)
if self.status:
if self.cam != None:
self.cam.closeInput()
self.timer.stop()
self.cam = None
self.status = not self.status
self.statusLabel.setText("Stopped")
self.statusLabel.setStyleSheet('color: red')
else:
self.status = not self.status
self.videoStream()
self.update()
if self.cam != None:
self.statusLabel.setText("Streaming")
self.statusLabel.setStyleSheet('color: green')
else:
self.status = True
if self.enable_camara_change.isChecked():
self.enable_camara_change.setChecked(False)
def videoStream(self):
self.camara = self.camaraLine.text()
if self.camara.isdigit():
self.camara = int(self.camara)
try:
self.cam = specpy.GuiWindow("Stream", self.camara, self.objectName, STREAMWIDTH, STREAMHEIGHT, PATH,
POS, SIZE, BRIGHTNESS, CONTRAST, SATURATION, HUE,
GAIN, EXPOSURE, "canvas")
self.resolutionBox(self.comboBox_2.currentText())
self.posChange()
self.sizeChange()
self.brightnessChange()
self.contrastChange()
self.saturationChange()
self.hueChange()
self.gainChange()
self.exposureChange()
except:
w = QtGui.QWidget()
QtGui.QMessageBox.critical(w, "Error", "An error has occurred. Try another camara")
self.cam = None
if self.cam != None:
self.updateImage()
self.fig_num = 0
def qImage(self, width, height, bytesPerLine):
qImg = QtGui.QImage(self.cam.frame.data, width, height, bytesPerLine, QtGui.QImage.Format_RGB888)
pix = QtGui.QPixmap(qImg)
return pix
def keyPressEvent(self, event):
keyPressed = event.key()
if keyPressed == QtCore.Qt.Key_Alt + QtCore.Qt.Key_F4:
self.cam.closeInput()
self.close()
elif keyPressed == QtCore.Qt.Key_Enter - 1:
self.captureData()
elif keyPressed == QtCore.Qt.Key_C:
self.cleanPlot()
elif keyPressed == QtCore.Qt.Key_R:
self.resetSettings()
elif keyPressed == QtCore.Qt.Key_Space:
self.startStop()
def updateImage(self):
if self.cam == None:
return
width = self.CamaraStream.frameGeometry().width()
height = int(self.coeffWH*width)
realHeight = self.CamaraStream.frameGeometry().height()
if height > realHeight:
width = int(realHeight/self.coeffWH)
height = realHeight
self.cam.changeHeight(height)
self.cam.changeWidth(width)
bytesPerLine = 3*width
answer = self.cam.eachPhotogram()
if answer:
pix = self.qImage(width, height, bytesPerLine)
self.CamaraStream.setPixmap(pix)
def update(self):
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.updateImage)
self.timer.start(33)
# Creates first plot
self.updatePlot()
def updatePlot(self):
"""
Updates plot
"""
def create():
if self.cam == None:
figure = self.imagesFig
else:
figure = self.cam.figure
if figure != None:
self.canvas = FigureCanvas(figure)
self.figureFrame.addWidget(self.canvas)
self.canvas.draw()
else:
self.canvas == None
def removePlot():
self.figureFrame.removeWidget(self.canvas)
self.canvas.close()
if self.cam == None and self.imagesFig == None:
return
if self.canvas == None:
create()
else:
removePlot()
create()
def posSliderLimits(self):
self.posSlider.setMinimum(0)
temp = self.cam.analysisHeight
self.posSlider.setMaximum(temp)
self.posSlider.setValue(int(temp/2))
def sizeSliderLimits(self):
self.sizeSlider.setMinimum(0)
temp = self.cam.analysisHeight
self.sizeSlider.setMaximum(int(temp/2))
self.sizeSlider.setValue(int(temp/4))
def posChange(self):
size = self.posSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.posTrackBar(size)
def sizeChange(self):
size = self.sizeSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.rangeTrackBar(size)
def brightnessChange(self):
size = self.brightnessSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.brightnessTrackBar(size)
def contrastChange(self):
size = self.contrastSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.contrastTrackBar(size)
def saturationChange(self):
size = self.saturationSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.saturationTrackBar(size)
def hueChange(self):
size = self.hueSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.hueTrackBar(size)
def gainChange(self):
size = self.gainSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.gainTrackBar(size)
def exposureChange(self):
size = self.exposureSlider.value()
if not self.status:
self.camaraWarning()
return
self.cam.exposureTrackBar(size)
def captureData(self):
if not self.status:
self.camaraWarning()
return
self.objectNameChanger()
self.pathChanger()
self.fig_num = self.cam.captureData(self.cam.notSquaredAnalysisFrame, self.fig_num)
self.updatePlot()
def resetSettings(self):
if self.cam == None:
self.camaraWarning()
return
self.cam.resetSettings(POS, SIZE, BRIGHTNESS, CONTRAST, SATURATION, HUE, GAIN, EXPOSURE)
self.posSlider.setValue(POS)
self.sizeSlider.setValue(SIZE)
self.brightnessSlider.setValue(BRIGHTNESS)
self.contrastSlider.setValue(CONTRAST)
self.saturationSlider.setValue(SATURATION)
self.hueSlider.setValue(HUE)
self.gainSlider.setValue(GAIN)
self.exposureSlider.setValue(EXPOSURE)
# self.path = PATH
# self.directoryLine.setText(self.path)
self.objectName = ""
self.objectLine.setText(self.objectName)
self.comboBox_2.setCurrentIndex(0)
self.resolutionBox(self.comboBox_2.currentText())
def closeEvent(self, event):
if self.cam != None:
self.cam.closeInput()
self.timer.stop()
self.close()
def resolutionBox(self, text):
parted_line = text.rpartition('x')
width, _, height = parted_line
width = int(width)
height = int(height)
self.coeffWH = height/width
self.cam.setCaptureHeight(height)
self.cam.setCaptureWidth(width)
self.posSliderLimits()
self.sizeSliderLimits()
def objectNameChanger(self):
self.objectName = self.objectLine.text()
self.cam.objectName = self.objectName
# print(text)
def pathChanger(self):
self.path = self.directoryLine.text()
self.cam.path = self.path
self.pathCleaner(False)
#
def pathCleaner(self, delete):
import os, glob
if not os.path.exists(self.path):
os.makedirs(self.path)
if delete:
temp = glob.glob(self.path+'/*.jpg')
temp2 = glob.glob(self.path+'/*.csv')
temp += temp2
for item in temp:
os.remove(item)
def cleanPlot(self):
if self.plot != None:
self.plot.cleanLines()
self.updatePlot()
if self.status:
self.cam.cleanData()
self.updatePlot()
if self.plot == None and self.cam == None:
self.camaraWarning()
def about(self):
about = QtGui.QMessageBox()
about.setIcon(QtGui.QMessageBox.Question)
about.setWindowTitle("About")
about.setText(
"Using a simple USB webcamara SpecPy is capable of recording frames "
+ "as intensity data. With a Graphical User Interface based on Qt, "
+ "camara settings are simple to control. Recorded frames are stored "
+ "inside a dedicated folder, along with the generated data, thus "
+ "allowing further analysis. <br><br>"
+ "More in formation can be found at the <a href=https://github.com/jsbarbosa/SpecPy>repository</a>."
)
about.exec()
def camaraWarning(self):
warning = QtGui.QMessageBox()
warning.setIcon(QtGui.QMessageBox.Warning)
warning.setWindowTitle("Warning")
warning.setText("Please start streaming.")
warning.exec()
def getfiles(self):
dlg = QtGui.QFileDialog()
dlg.setFileMode(QtGui.QFileDialog.AnyFile)
fileFilter = "Images (*.jpg *.jpeg *.png)"
filenames = dlg.getOpenFileNames(self, filter = fileFilter)
for file in filenames:
self.filenames.append(file)
self.filesListWidget.clear()
self.updateFileList()
def saveFiles(self):
dlg = QtGui.QFileDialog()
file = dlg.getExistingDirectory(self)
while file == "":
w = QtGui.QWidget()
QtGui.QMessageBox.critical(w, "Error", "No path has been specified.")
file = dlg.getExistingDirectory(self)
self.path = file
self.directoryLine.setText(self.path)
def clearFiles(self):
self.filenames = []
self.filesListWidget.clear()
def updateFileList(self):
self.namesOnly = []
if PLATFORM == "Linux":
breaker = '/'
else:
breaker = '\\'
for file in self.filenames:
temp = file.rpartition(breaker)
self.namesOnly.append(temp[-1])
path = temp[:-1][0]
self.inputLineEdit.setText(path)
self.filesListWidget.addItems(self.namesOnly)
def updateFileImage(self, pos):
pix = QtGui.QPixmap(self.filenames[pos])
coeff = pix.height()/pix.width()
width = self.fileViewer.frameGeometry().width()
height = int(coeff*width)
realHeight = self.fileViewer.frameGeometry().height()
if height > realHeight:
width = int(realHeight/coeff)
height = realHeight
pix = pix.scaled(width, height, QtCore.Qt.KeepAspectRatio)
self.fileViewer.setPixmap(pix)
def analyzeImages(self):
if self.cam != None:
w = QtGui.QWidget()
QtGui.QMessageBox.critical(w, "Error", "SpecPy is streaming.")
return
if self.filenames == []:
w = QtGui.QWidget()
QtGui.QMessageBox.critical(w, "Error", "No files loaded.")
return
class WorkThread(QtCore.QThread, Main):
def __init__(self, plot, imagesFig, filenames, namesOnly, path):
QtCore.QThread.__init__(self)
self.plot = plot
self.imagesFig = imagesFig
self.filenames = filenames
self.namesOnly = namesOnly
self.path = path
def __del__(self):
self.wait()
def run(self):
self.plot = specpy.RealTimePlot(1,1)
i = 0
for (file, name) in zip(self.filenames, self.namesOnly):
capturedframe = specpy.CapturedFrame(file, name, "", None, None, self.path)
self.plot.width = capturedframe.width
self.plot.changeAxes()
self.plot.includeCapturedFrame(capturedframe)
self.imagesFig = self.plot.figureReturn()
if i <= 3:
self.plot.ax2.set_ylim(0, capturedframe.height*255)
i += 1
self.emit(QtCore.SIGNAL('update(QString)'), str(i))
self.terminate
self.pathCleaner(False)
number = len(self.filenames)
progressBar_unit = int(100/number)
def threadUpdate(pos):
pos = int(pos)
self.progressBar.setValue(pos*progressBar_unit)
self.currentFileLabel.setText(self.namesOnly[pos-1])
if pos == number:
self.progressBar.setValue(100)
self.plot = self.workThread.plot
self.imagesFig = self.workThread.imagesFig
self.updatePlot()
self.workThread = WorkThread(self.plot, self.imagesFig, self.filenames, self.namesOnly, self.path)
self.connect(self.workThread, QtCore.SIGNAL("update(QString)"), threadUpdate)
self.workThread.start()
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 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 CoLocation(QMainWindow, Ui_MainWindow):
flag = True
categories = {}
valid_images = ["jpg","png","tga", "pgm", "jpeg"]
valid_videos = ["mp4", "avi"]
edge_threshold = 100
to_disp = []
def __init__(self, ):
super(CoLocation, self).__init__() #initialise from the ui designed by Designer App
self.setupUi(self)
self.setupUi_custom()
def update_categories(self):
#update selected categories
for radiobox in self.findChildren(QtGui.QRadioButton):
self.categories[radiobox.text()] = radiobox.isChecked()
def setupUi_custom(self,):
self.scene = QGraphicsScene()
self.scene2 = QGraphicsScene()
#TODO [WEIRD PROBLEM] QPixmap needs to be called at least once with JPG image before tensorFlow, otherwise program crashes
self.scene.addPixmap(QPixmap(os.getcwd()+"/demo.jpg").scaled(self.graphicsView.size(), QtCore.Qt.KeepAspectRatio))
self.graphicsView.setScene(self.scene)
import Yolo_module as yolo
self.classifier = yolo.YOLO_TF()
#Create thread for heavy processing and tensorflow, pass the instance of itself to modify GUI
self.image_thread = ImageThread(self, self.classifier)
#add connect SIGNAL here
self.pushButton.clicked.connect(self.selectFile)
self.horizontalSlider.valueChanged.connect(self.updateLCD)
self.pushButton_2.clicked.connect(self.image_thread.disp_graph)
self.pushButton_3.clicked.connect(self.selectFile_from_folder)
#Add blank canvas initially
fig1 = Figure()
self.addmpl(fig1)
def updateLCD(self):
#update edge_threshold variable based on slider
self.edge_threshold = self.horizontalSlider.value()
self.lcdNumber.display(self.edge_threshold)
def selectFile(self):
#Clear previous image displays
self.scene.clear()
self.scene2.clear()
self.update_categories()
filename = QFileDialog.getOpenFileName(directory = '/home/yash/Downloads/Pascal VOC 2012/samples')
self.lineEdit.setText(filename)
if filename.split('.')[1] in self.valid_videos:
self.image_thread.temp = filename #disp_video(filename)
self.image_thread.start()
elif filename.split('.')[1] in self.valid_images:
self.image_thread.disp_img(filename = filename)
self.image_thread.disp_graph()
else:
print("Invalid file format")
def selectFile_from_folder(self):
#Read all the images in the folder
path = QFileDialog.getExistingDirectory(None, 'Select a folder:', '/home/yash/Downloads/Pascal VOC 2012', QtGui.QFileDialog.ShowDirsOnly)
self.lineEdit_2.setText(path)
for f in os.listdir(path): #list all the files in the folder
ext = f.split('.')[1] #get the file extension
if ext.lower() not in self.valid_images: #check if the extension is valid for the image
continue
filename = path+'/'+f #create the path of the image
print(filename)
self.image_thread.tag_image(filename, batch = True)
#clear the image regions during batch upload
self.scene.clear()
self.scene2.clear()
self.image_thread.disp_graph(batch = True)
def addmpl(self, fig):
#Add figure to canvas and widget
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self,):
#remove the canvas and widget
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
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 WD(QMainWindow,Ui_MainWindow):
def __init__(self,parent=None):
QtGui.QWidget.__init__(self,parent)
self.setupUi(self)
self.file=open('output.txt','a')
self.ButtonBack.clicked.connect(self.back1)
self.radioButton.setChecked(True)
self.sim=0
self.true1=0
self.ButtonOn.hide()
self.ButtonBack.hide()
self.ButtonPause.hide()
self.label_5.hide()
self.interact_game.hide()
self.game.hide()
self.start.clicked.connect(self.start1)
self.back.clicked.connect(self.close)
self.ButtonOn.clicked.connect(self.on)
self.ButtonPause.clicked.connect(self.pause)
self.fig_dict={}
self.slider_simulation.hide()
# self.horizontalSlider.valueChanged.connect(self.initial)
self.slider_simulation.valueChanged.connect(self.simulation)
self.fig_dict={}
self.mplfigs.itemClicked.connect(self.changefig)
self.fig=plt.figure()
self.addmpl(self.fig)
self.ButtonDemo_1.clicked.connect(self.demo1)
self.ButtonDemo_2.clicked.connect(self.demo2)
self.demo=0
self.horizontalSlider.valueChanged.connect(self.initial)
self.pushButton_game.clicked.connect(self.game_call)
self.pushButton_try.clicked.connect(self.graph_try)
self.pushButton_return.clicked.connect(self.game_return)
self.ButtonDiffu.clicked.connect(self.diffusion)
self.ButtonBackDiffu.clicked.connect(self.backdiffu)
self.mplwindow_2.hide()
self.mplwindow_3.hide()
self.textDiffu.hide()
self.ButtonBackDiffu.hide()
self.ButtonDiffu.hide()
showAction=QtGui.QAction('&Authors', self)
showAction.triggered.connect(self.showAuthors)
mainMenu=self.menuBar()
fileMenu=mainMenu.addMenu('&About')
fileMenu.addAction(showAction)
self.timer1=QtCore.QTimer(self)
self.timer2=QtCore.QTimer(self)
self.ani_co=0
file=open('position_02.txt','r')
lines=file.readlines()
file.close()
x=[]
x1=[]
x2=[]
for line in lines:
p=line.split()
x.append(float(p[0]))
x1.append(float(p[1]))
x2.append(float(p[5]))
xv=np.array(x)
xv1=np.array(x1)
xv2=np.array(x2)
self.rmmpl()
self.fig=plt.figure()
axf=self.fig.add_subplot(111)
axf.set_xlabel('$x/a_{ho}$',fontsize=17)
axf.set_ylabel('density $|\psi|^2 a_{ho}$',fontsize=14)
axf.fill_between(xv,0,xv1,label='$R-Space$',facecolor='blue',alpha=0.5)
axf.fill_between(xv,0,xv2,label='$K-Space$',facecolor='yellow',alpha=0.5)
axf.set_xlim([-20,20])
axf.set_title('Wave Packet')
axf.legend()
self.addmpl(self.fig)
def initial(self):
file=open('initial2.txt','r')
lines=file.readlines()
file.close()
for i in range(0,16):
globals()['x%s' %i]=[]
for line in lines:
p=line.split()
for i in range(0,16):
globals()['x%s' %i].append(float(p[i-1]))
for i in range(0,16):
globals()['xv%s' %i]=np.array(globals()['x%s' %i])
value=self.horizontalSlider.value()
for i in range(3,16):
if value==i-9:
if self.fig==None:
self.rmmpl()
self.fig=Figure()
self.addmpl(self.fig)
self.fig.clear()
ax1f2=self.fig.add_subplot(111)
ax1f2.set_xlabel('$x/a_{ho}$',fontsize=17)
ax1f2.set_ylabel('density $|\psi|^2 a_{ho}$',fontsize=14)
ax1f2.fill_between(xv1,0,globals()['xv%s' %i],label='$R-Space$',facecolor='blue',alpha=0.5)
ax1f2.fill_between(xv1,0,xv2,label='$K-Space$',facecolor='yellow',alpha=0.5)
ax1f2.set_ylim(0.,0.6)
ax1f2.set_xlim(-20.,20.)
ax1f2.set_title('initial state')
ax1f2.legend()
self.canvas.draw()
def start1(self):
self.demo=0
self.start2()
def start2(self):
self.rmmpl()
self.fig.clear()
self.timer1.stop()
self.timer2.stop()
dialog = QtGui.QDialog()
progressBar = Ui_porcessProgress()
progressBar.setupUi(dialog)
dialog.show()
self.file.write('...Nuevo proceso...\n')
diff = 0
self.sim=0
self.true1=0
prevdir = os.getcwd()
self.spinBox_value=self.spinBox.value()
self.slider_simulation.setValue(0)
try:
if self.demo==0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(os.path.expanduser('./Wavepackdisper/Demo%s' %(self.demo)))
if (not os.path.exists('./WfWd-end')):
zip_ref = zipfile.ZipFile('./Demo%s.zip' %(self.demo), 'r')
zip_ref.extractall('.')
zip_ref.close()
else:
pass
file=open('input.txt','w')
if (self.radioButton.isChecked()==True):
self.true1=1
if (self.radioButton_2.isChecked()==True):
self.true1=0
file.write ('%s\t%s\t%s\t%s' %(self.horizontalSlider.value(),self.true1,self.spinBox.value(),self.spinBox_2.value()))
file.close()
time1=int(self.spinBox_value*(10*np.pi*2.0))
start_sub=time.time()
if self.demo==0:
exclude=set(['Demo1','Demo2'])
for root, dirs, files in os.walk(os.getcwd(), topdown=True):
dirs[:] = [d for d in dirs if d not in exclude]
for file in files:
if file.startswith("WfWd"):
os.remove((os.path.join(root, file)))
subprocess.Popen('python gpe_fft_ts_WP_v1.py',shell=True)
progressBar.porcessProgressBar.setMaximum(time1+1)
diff=0
while diff<time1+2:
diff=0
for root, dirs, files in os.walk(os.getcwd()):
dirs[:] = [d for d in dirs if d not in exclude]
for file in files:
if file.startswith("WfWd"):
diff +=1
if (diff<10):
progressBar.label.setText('Initiation of the progress...')
if (diff<time1-10) and (diff>10):
progressBar.label.setText(u'Solving Schrödinger equation...')
if (diff<time1+1) and (diff>time1-10):
progressBar.label.setText('Writing results ...')
progressBar.porcessProgressBar.setValue(diff)
QApplication.processEvents()
if (self.true1==1):
self.file.write('Posición inicial del paquete de ondas=%s\nPotential armónico: YES\nExcitación del estado=%s\nNúmero de oscilaciones=%s\n\n' %(self.horizontalSlider.value(),self.spinBox_2.value(),self.spinBox.value()))
if (self.true1==0):
self.file.write('Posición inicial del paquete de ondas=%s\nPotential armónico: NO\nExcitación del estado=%s\nNúmero de oscilaciones=%s\n\n' %(self.horizontalSlider.value(),self.spinBox_2.value(),self.spinBox.value()))
end_sub=time.time()
print (os.getcwd())
print ("READY")
self.label_5.show()
self.ButtonOn.show()
self.ButtonBack.show()
self.ButtonPause.show()
self.label_5.show()
self.slider_simulation.show()
self.slider_simulation.setMinimum(0)
self.slider_simulation.setMaximum(self.spinBox_value*int((10*np.pi*2.0)))
self.slider_simulation.setSingleStep(1)
if (self.radioButton.isChecked()==True):
self.interact_game.show()
self.ButtonDiffu.hide()
self.radioButton_oscil.setChecked(True)
if (self.radioButton_2.isChecked()==True):
self.interact_game.hide()
self.ButtonDiffu.show()
# time.sleep(2)
file=open('output_sp.txt','r')
self.file.write('%s\n\n' %file.read())
self.file.write('Durada de la computación=%s\n\n' %(end_sub-start_sub))
file = open('energies.txt', 'r')
lines = file.readlines()
file.close()
file2 = open('mean_value.txt','r')
lines2 = file2.readlines()
file2.close()
file4=open('WfWd-%08d.txt'%(0),'r')
lines4=file4.readlines()
file4.close()
finally:
os.chdir(prevdir)
x1=[]
x2=[]
x3=[]
for line in lines4:
p=line.split()
x1.append(float(p[0]))
x2.append(float(p[1]))
x3.append(float(p[5]))
xv1=np.array(x1)
xv2=np.array(x2)
xv3=np.array(x3)
self.rmmpl()
self.fig=plt.figure()
axf=self.fig.add_subplot(111)
axf.set_xlabel('$x/a_{ho}$',fontsize=17)
axf.set_ylabel('density $|\psi|^2 a_{ho}$',fontsize=14)
axf.fill_between(xv1,0,xv2,label='$R-Space$',facecolor='blue',alpha=0.5)
axf.fill_between(xv1,0,xv3,label='$K-Space$',facecolor='yellow',alpha=0.5)
axf.set_xlim([-self.horizontalSlider.value()-8,self.horizontalSlider.value()+8])
if (self.true1==0):
axf.set_ylim(0,0.6)
axf.set_title('state at t=%s $T/t_{ho}$' %(0))
axf.legend()
self.addmpl(self.fig)
x1 = []
y1 = []
z1 = []
j1 = []
for line in lines:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
z1.append(float(p[3]))
j1.append(float(p[4]))
xv = np.array(x1)
yv = np.array(y1)
zv = np.array(z1)
jv=np.array(j1)
fig=Figure()
ax1f1=fig.add_subplot(111)
ax1f1.set_xlabel('$T/t_{ho}$',fontsize=17)
ax1f1.set_ylabel('$E/\hbar \omega$',fontsize=17)
ax1f1.plot(xv,yv,'r.-',label='$E_{tot}$')
ax1f1.plot(xv,zv,'y.-',label='Kinetic Energy')
ax1f1.plot(xv,jv,'b.-',label='Potential Energy')
ax1f1.legend()
ax1f1.set_title('Energies')
x1 = []
y1 = []
z1 = []
i1 = []
j1 = []
for line in lines2:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
z1.append(float(p[2]))
i1.append(float(p[3]))
j1.append(float(p[4]))
xv = np.array(x1)
yv = np.array(y1)
zv = np.array(z1)
iv = np.array(i1)
jv = np.array(j1)
self.fig2=Figure()
ax1f2=self.fig2.add_subplot(111)
ax1f2.set_xlabel('$T/t_{ho}$',fontsize=17)
ax1f2.set_ylabel('$x/a_{ho}$',fontsize=17)
ax1f2.plot(xv,yv, 'b.',label='$R-Space:<x> $')
ax1f2.plot(xv,iv, 'y--',label='$k-Space:<k>$')
ax1f2.plot(xv,zv, 'b--',label='$R-Space:dispersion$')
ax1f2.plot(xv,jv, 'y.',label='$k-Space:dispersion$')
ax1f2.legend(loc='best')
self.delfig()
self.delfig()
self.delfig()
self.addfig('ENERGY',fig)
self.addfig('MEAN VALUE X',self.fig2)
self.slider_simulation.setValue(0)
def simulation(self):
time1=int(self.spinBox_value*(10*np.pi*2.0))
value=self.slider_simulation.value()
self.sim=value
prevdir = os.getcwd()
try:
if self.demo==0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(os.path.expanduser('./Wavepackdisper/Demo%s' %(self.demo)))
for i in range(0,time1+1):
file=open('WfWd-%08d.txt'%(i),'r')
globals()['lines%s' %i]=file.readlines()
file.close()
#
#
if value==i:
x1=[]
x2=[]
x3=[]
for line in (globals()['lines%s' %i]):
p=line.split()
x1.append(float(p[0]))
x2.append(float(p[1]))
x3.append(float(p[5]))
xv1=np.array(x1)
xv2=np.array(x2)
xv3=np.array(x3)
if self.fig==None:
self.rmmpl()
self.fig=plt.figure()
self.addmpl(self.fig)
self.fig.clear()
axf=self.fig.add_subplot(111)
axf.set_xlabel('$x/a_{ho}$',fontsize=17)
axf.set_ylabel('density $|\psi|^2 a_{ho}$',fontsize=14)
axf.fill_between(xv1,0,xv2,label='$R-Space$',facecolor='blue',alpha=0.5)
axf.fill_between(xv1,0,xv3,label='$K-Space$',facecolor='yellow',alpha=0.5)
axf.set_xlim([-self.horizontalSlider.value()-8,self.horizontalSlider.value()+8])
if (self.true1==0):
axf.set_ylim(0,0.6)
axf.set_title('state at t=%s $T/t_{ho}$' %(i))
axf.legend()
self.canvas.draw()
finally:
os.chdir(prevdir)
def game_call(self):
self.timer1.stop()
self.timer2.stop()
if (self.radioButton.isChecked()==True):
if (self.radioButton_oscil.isChecked()==True):
self.rmmpl()
self.textBrowser.show()
self.rmmpl2()
self.mplwindow.hide()
self.textDiffu.hide()
self.mplwindow_3.hide()
self.widget_osci.show()
self.start.hide()
self.ButtonDemo_1.hide()
self.ButtonDemo_2.hide()
self.interact.setEnabled(False)
self.mplfigs.hide()
self.spin_amplitude.setValue(3.)
self.spin_frequency.setValue(0.5)
prevdir = os.getcwd()
try:
if self.demo==0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(os.path.expanduser('./Wavepackdisper/Demo%s' %(self.demo)))
file2 = open('mean_value.txt','r')
lines2 = file2.readlines()
file2.close()
x1 = []
y1 = []
for line in lines2:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
xv = np.array(x1)
yv = np.array(y1)
finally:
os.chdir(prevdir)
fig3=Figure()
ax1f3=fig3.add_subplot(111)
ax1f3.set_xlabel('$T/t_{ho}$',fontsize=17)
ax1f3.set_ylabel('$x/a_{ho}$',fontsize=17)
ax1f3.plot(xv,yv, 'r.-',label='$R-Space$')
ax1f3.set_title('Wave packet trajectory')
ax1f3.legend()
self.addmpl2(fig3)
self.game.show()
self.mplwindow_2.show()
def graph_try(self):
if (self.radioButton.isChecked()==True):
if (self.radioButton_oscil.isChecked()==True):
self.amplitude=self.spin_amplitude.value()
self.frequency=self.spin_frequency.value()
self.ani_co += 1
if self.ani_co>1:
self.ani.event_source.stop()
time1=int(self.spinBox_value*(10*np.pi*2.0))
self.rmmpl2()
prevdir = os.getcwd()
try:
if self.demo==0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(os.path.expanduser('./Wavepackdisper/Demo%s' %(self.demo)))
file2 = open('mean_value.txt','r')
lines2 = file2.readlines()
file2.close()
x1 = []
y1 = []
for line in lines2:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
xv = np.array(x1)
yv = np.array(y1)
finally:
os.chdir(prevdir)
# fig3=Figure()
# self.addmpl2(fig3)
# ax1f3=fig3.add_subplot(111)
# ax1f3.set_xlabel('$T/t_{ho}$',fontsize=17)
# ax1f3.set_ylabel('$x/a_{ho}$',fontsize=17)
#
# x=np.arange(0,time1+1)/10.
# y=self.spin_amplitude.value()*np.cos(self.spin_frequency.value()*x)
#
# ax1f3.plot(xv,yv, 'r.-',label='$R-Space$')
# ax1f3.plot(x,y)
# ax1f3.set_title('Mean value x')
# ax1f3.legend()
# self.canvas.draw()
tf_sim = time1/10.
def simData():
L=self.amplitude
t_max = time1/10.
dt = 0.05
w = self.frequency
y = 0.0
t = 0.0
while t <= t_max:
if on_spr and not back_spr and not pause_spr:
y = L*np.sin(w*t+np.pi/2.)
t = t + dt
if t<0:
y = L*np.sin(w*t+np.pi/2.)
t = t + dt
if back_spr and not on_spr and not pause_spr:
y = L*np.sin(w*t+np.pi/2.)
t = t - dt
yield y, t
def onClick(event):
global pause_spr, on_spr, back_spr
back_spr ^= True
on_spr ^= True
def init():
line.set_data([], [])
line2.set_data([], [])
line3.set_data([], [])
line4.set_data([], [])
for j in range (0,11):
globals() ['line_%s' %(j)].set_data([], [])
time_text.set_text('')
return line, time_text
def simPoints(simData):
y, t = simData[0], simData[1]
if self.amplitude>=0:
ori = -self.amplitude-1.
if self.amplitude<=0:
ori = self.amplitude-1.
time_text.set_text(time_template%(t))
thisy = [ori, y]
line.set_data(0,thisy)
for j in range (3,9):
globals() ['line_%s' %(j)].set_data([((-1)**(j-1))*0.5,((-1)**j)*0.5],[(j-1.)*((y-ori)/10.)+ori,((y-ori)/10.)*j+ori])
line_0.set_data([0.,0.5],[((((y-ori)/10.)*1.+ori)+(((y-ori)/10.)*2.+ori))/2.,((y-ori)/10.)*2.+ori])
line_1.set_data([0.5,0.],[((y-ori)/10.)*8.+ori,((((y-ori)/10.)*8.+ori)+(((y-ori)/10.)*9.+ori))/2.])
line2.set_data([1.,-1.],[ori,ori])
line3.set_data([t,y])
tf = np.arange(0.0, t, 0.05)
line4.set_data([tf,self.amplitude*np.cos(tf*self.frequency)])
time_text.set_text(time_template % (t))
return line, line2, line3, line_0, line_1, line_2, line_3, line_4, line_5, line_6, line_7, line_8, line_9, line4
# gs=0
ax=0
ax2=0
# import matplotlib.gridspec as gridspec
fig3 = plt.figure()
# rcParams.update({'figure.autolayout': True})
# gs = gridspec.GridSpec(10, 10)
# ax = fig3.add_subplot(gs[:,03], xlim=(-0.5, 0.5), ylim=(-self.spin_amplitude.value()-2., +self.spin_amplitude.value()+2.))
# ax2 = fig3.add_subplot(gs[:,4:])
ax = plt.subplot2grid((10,10), (0,0), rowspan=10, colspan=2, autoscale_on=False, xlim=(-0.5, 0.5), ylim=(-self.amplitude-2., +self.amplitude+2.))
ax2 = plt.subplot2grid((10,10), (0,3), rowspan=10, colspan=7, autoscale_on=False, xlim=(0., tf_sim), ylim=(-self.amplitude-2., +self.amplitude+2.))
# ax = fig3.add_subplot(121)
# ax2 = fig3.add_subplot(122)
ax.set_title('Spring')
ax.set_xticks(np.arange(-2., 3., 5.))
ax.set_xlim(-1,1)
ax.set_ylabel('x(m)',fontsize=13)
if self.amplitude>=0:
ax.set_ylim(-self.amplitude-2.,self.amplitude+2.)
if self.amplitude<=0:
ax.set_ylim(self.amplitude-2.,-self.amplitude+2.)
ax2.set_xlabel('t(s)',fontsize=13)
ax2.set_ylabel('x(m)',fontsize=13)
ax2.plot(xv,yv, 'r.-')
ax2.set_title('Wave packet trajectory')
self.addmpl2(fig3)
line, = ax.plot([], [], 'o-', lw=2)
line2, = ax.plot([], [], 'g-', lw=2)
line3, = ax2.plot([], [], 'o-', lw=2)
line4, = ax2.plot([], [], 'b-', lw=2)
for j in range (0,11):
globals() ['line_%s' %(j)], = ax.plot([], [], 'b-', lw=2)
time_template = 'time = %.1fs'
time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)
fig3.canvas.mpl_connect('button_press_event', onClick)
self.ani = animation.FuncAnimation(fig3, simPoints, simData,
interval=25, blit=True, init_func=init, repeat=False)
#ani.save('muelle.mp4', fps=15)
self.canvas.draw()
def game_return(self):
self.rmmpl2()
self.rmmpl2()
self.mplwindow_2.hide()
self.textDiffu.hide()
self.mplwindow_3.hide()
self.game.hide()
self.fig=plt.figure()
self.addmpl(self.fig)
self.mplwindow.show()
self.start.show()
self.ButtonDemo_1.show()
self.ButtonDemo_2.show()
self.interact.setEnabled(True)
self.mplfigs.show()
self.slider_simulation.setValue(self.sim+1)
self.slider_simulation.setValue(self.sim-1)
def plot(self):
self.sim +=1
self.slider_simulation.setValue(self.sim)
if (self.sim==self.spinBox_value*int((10*np.pi*(2.)))):
self.timer1.stop()
def plot2(self):
self.sim -=1
self.slider_simulation.setValue(self.sim)
if (self.sim==0):
self.timer2.stop()
def on(self):
self.timer1.stop()
self.timer2.stop()
if self.timer2==None:
self.timer1=QtCore.QTimer(self)
self.timer1.timeout.connect(self.plot)
self.timer1.start(75)
else:
self.timer1=QtCore.QTimer(self)
self.timer1.timeout.connect(self.plot)
self.timer2.stop()
self.timer1.start(75)
def pause(self):
self.timer1.stop()
self.timer2.stop()
def back1(self):
self.timer1.stop()
self.timer2.stop()
if self.timer1==None:
self.timer2=QtCore.QTimer(self)
self.timer2.timeout.connect(self.plot2)
self.timer2.start(75)
else:
self.timer2=QtCore.QTimer(self)
self.timer2.timeout.connect(self.plot2)
self.timer1.stop()
self.timer2.start(75)
def diffusion(self):
self.timer1.stop()
self.timer2.stop()
self.mplwindow.hide()
self.mplwindow_2.hide()
self.mplwindow_3.show()
self.game.hide()
self.ButtonDiffu.hide()
self.textDiffu.show()
self.start.hide()
self.ButtonDemo_1.hide()
self.ButtonDemo_2.hide()
self.interact.setEnabled(False)
self.mplfigs.hide()
self.ButtonBackDiffu.show()
self.movie = QMovie("dispersion.gif", QByteArray(), self)
self.movie_scr = QLabel()
self.mplvl_3.addWidget(self.movie_scr)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_scr.setMovie(self.movie)
self.movie.start()
def backdiffu(self):
self.movie.stop()
self.mplvl_3.removeWidget(self.movie_scr)
self.mplwindow_3.hide()
self.ButtonBackDiffu.hide()
self.textDiffu.hide()
self.ButtonDiffu.show()
self.mplwindow.show()
self.start.show()
self.ButtonDemo_1.show()
self.ButtonDemo_2.show()
self.interact.setEnabled(True)
self.mplfigs.show()
self.slider_simulation.setValue(self.sim+1)
self.slider_simulation.setValue(self.sim-1)
def demo1(self):
self.radioButton_2.setChecked(True)
self.horizontalSlider.setValue(0)
self.spinBox_2.setValue(0)
self.spinBox.setValue(2)
self.demo=1
self.start2()
def demo2(self):
self.radioButton.setChecked(True)
self.horizontalSlider.setValue(3)
self.spinBox_2.setValue(0)
self.spinBox.setValue(2)
self.demo=2
self.start2()
def changefig(self,item):
text=item.text()
self.rmmpl()
self.addmpl(self.fig_dict[str(text)])
self.fig=None
self.timer1.stop()
self.timer2.stop()
def addfig(self,name,fig):
self.fig_dict[name]=fig
self.mplfigs.addItem(name)
def delfig(self):
listItems=self.mplfigs.selectedItems()
if not listItems: return
for item in listItems:
self.mplfigs.takeItem(self.mplfigs.row(item))
def addmpl(self,fig):
self.canvas=FigureCanvas(fig)
self.toolbar=NavigationToolbar(self.canvas,self,coordinates=True)
self.mplvl.addWidget(self.toolbar)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self):
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
def addmpl2(self,fig):
self.canvas=FigureCanvas(fig)
self.toolbar=NavigationToolbar(self.canvas,self,coordinates=True)
self.mplvl_2.addWidget(self.toolbar)
self.mplvl_2.addWidget(self.canvas)
self.canvas.draw()
def rmmpl2(self):
self.mplvl_2.removeWidget(self.toolbar)
self.toolbar.close()
self.mplvl_2.removeWidget(self.canvas)
self.canvas.close()
def close(self):
self.timer1.stop()
self.timer2.stop()
self.hide()
self.file.close()
self.parent().show()
def showAuthors(self):
QtGui.QMessageBox.question(self, 'Authors',
"ULTRACOLDUB\n\nUniversitat de Barcelona")
def closeEvent(self, event):
reply = QtGui.QMessageBox.question(self, 'EXIT',
"Are you sure to quit?", QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
event.accept()
self.file.close()
else:
event.ignore()
class MatplotlibWidget(QtGui.QWidget):
'''Base class for matplotlib widgets
'''
def __init__(self, parent):
'''Inits matplotlib widget.
Args:
parent: A Parent class object.
'''
super().__init__()
self.main_frame = parent
self.dpi = 75
self.show_axis_ticks = True
self.__create_frame()
def __create_frame(self):
self.fig = Figure((5.0, 3.0), dpi=self.dpi)
self.fig.patch.set_facecolor("white")
self.canvas = FigureCanvas(self.fig)
self.canvas.manager = MockManager(self.main_frame)
self.canvas.setParent(self.main_frame)
self.axes = self.fig.add_subplot(111)
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
hbox = QtGui.QHBoxLayout()
self.main_frame.ui.matplotlib_layout.addWidget(self.canvas)
self.main_frame.ui.matplotlib_layout.addWidget(self.mpl_toolbar)
self.main_frame.ui.matplotlib_layout.addLayout(hbox)
def fork_toolbar_buttons(self):
'''Remove figure options & subplot config that might not work properly.
'''
try:
self.mpl_toolbar.removeAction(self.mpl_toolbar.children()[21])
self.mpl_toolbar.removeAction(self.mpl_toolbar.children()[17])
except:
pass # Already removed
def remove_axes_ticks(self):
'''Remove ticks from axes.
'''
if not self.show_axis_ticks:
for tick in self.axes.yaxis.get_major_ticks():
tick.label1On = False
tick.label2On = False
for tick in self.axes.xaxis.get_major_ticks():
tick.label1On = False
tick.label2On = False
def delete(self):
'''Delete matplotlib objects.
'''
self.axes.clear() # Might be useless with fig.clf()
self.canvas.close()
self.fig.clf()
self.close()
del self.fig
del self.canvas
del self.axes
import gc
gc.collect()
class Window(QtGui.QMainWindow):
r""" A mainwindow object for the GUI display. Inherits from QMainWindow."""
def __init__(self):
super(Window, self).__init__()
self.interface()
def interface(self):
r""" Contains the main window interface generation functionality. Commented where needed."""
# Get the screen width and height and set the main window to that size
screen = QtGui.QDesktopWidget().screenGeometry()
self.setGeometry(0, 0, 800, screen.height())
self.setMaximumSize(QtCore.QSize(800, 2000))
# Set the window title and icon
self.setWindowTitle("WAVE: Weather Analysis and Visualization Environment")
self.setWindowIcon(QtGui.QIcon('./img/wave_64px.png'))
# Import the stylesheet for this window and set it to the window
stylesheet = "css/MainWindow.css"
with open(stylesheet, "r") as ssh:
self.setStyleSheet(ssh.read())
self.setAutoFillBackground(True)
self.setBackgroundRole(QtGui.QPalette.Highlight)
# Create actions for menus and toolbar
exit_action = QtGui.QAction(QtGui.QIcon('./img/exit_64px.png'), 'Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(self.close)
clear_action = QtGui.QAction(QtGui.QIcon('./img/clear_64px.png'), 'Clear the display', self)
clear_action.setShortcut('Ctrl+C')
clear_action.setStatusTip('Clear the display')
clear_action.triggered.connect(self.clear_canvas)
skewt_action = QtGui.QAction(QtGui.QIcon('./img/skewt_64px.png'), 'Open the skew-T dialog', self)
skewt_action.setShortcut('Ctrl+S')
skewt_action.setStatusTip('Open the skew-T dialog')
skewt_action.triggered.connect(self.skewt_dialog)
radar_action = QtGui.QAction(QtGui.QIcon('./img/radar_64px.png'), 'Radar', self)
radar_action.setShortcut('Ctrl+R')
radar_action.setStatusTip('Open Radar Dialog Box')
radar_action.triggered.connect(self.radar_dialog)
# Create the top menubar, setting native to false (for OS) and add actions to the menus
menubar = self.menuBar()
menubar.setNativeMenuBar(False)
filemenu = menubar.addMenu('&File')
editmenu = menubar.addMenu('&Edit')
helpmenu = menubar.addMenu('&Help')
filemenu.addAction(exit_action)
# Create the toolbar, place it on the left of the GUI and add actions to toolbar
left_tb = QtGui.QToolBar()
self.addToolBar(QtCore.Qt.LeftToolBarArea, left_tb)
left_tb.setMovable(False)
left_tb.addAction(clear_action)
left_tb.addAction(skewt_action)
left_tb.addAction(radar_action)
self.setIconSize(QtCore.QSize(30, 30))
# Create the toolbar, place it on the left of the GUI and add actions to toolbar
right_tb = QtGui.QToolBar()
self.addToolBar(QtCore.Qt.RightToolBarArea, right_tb)
right_tb.setMovable(False)
right_tb.addAction(clear_action)
right_tb.addAction(skewt_action)
right_tb.addAction(radar_action)
# Create the status bar with a default display
self.statusBar().showMessage('Ready')
# Figure and canvas widgets that display the figure in the GUI
self.figure = plt.figure(facecolor='#2B2B2B')
self.canvas = FigureCanvas(self.figure)
# Add subclassed matplotlib navbar to GUI
# spacer widgets for left and right of buttons
left_spacer = QtGui.QWidget()
left_spacer.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
right_spacer = QtGui.QWidget()
right_spacer.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
self.mpltb = QtGui.QToolBar()
self.mpltb.addWidget(left_spacer)
self.mpltb.addWidget(MplToolbar(self.canvas, self))
self.mpltb.addWidget(right_spacer)
self.mpltb.setMovable(False)
self.addToolBar(QtCore.Qt.TopToolBarArea, self.mpltb)
# Set the figure as the central widget and show the GUI
self.setCentralWidget(self.canvas)
self.show()
def skewt_dialog(self):
r""" When the toolbar icon for the Skew-T dialog is clicked, this function is executed. Creates an instance of
the SkewTDialog object which is the dialog box. If the submit button on the dialog is clicked, get the user
inputted values and pass them into the sounding retrieval call (DataAccessor.get_sounding) to fetch the data.
Finally, plot the returned data via self.plot.
Args:
None.
Returns:
None.
Raises:
None.
"""
dialog = SkewTDialog()
if dialog.exec_():
source, lat, long = dialog.get_values()
t, td, p, u, v, lat, long, time = DataAccessor.get_sounding(source, lat, long)
self.plot(t, td, p, u, v, lat, long, time)
def plot(self, t, td, p, u, v, lat, long, time):
r"""Displays the Skew-T data on a matplotlib figure.
Args:
t (array-like): A list of temperature values.
td (array-like): A list of dewpoint values.
p (array-like): A list of pressure values.
u (array-like): A list of u-wind component values.
v (array-like): A list of v-wind component values.
lat (string): A string containing the requested latitude value.
long (string): A string containing the requested longitude value.
time (string): A string containing the UTC time requested with seconds truncated.
Returns:
None.
Raises:
None.
"""
# Create a new figure. The dimensions here give a good aspect ratio
self.skew = SkewT(self.figure, rotation=40)
# Plot the data using normal plotting functions, in this case using
# log scaling in Y, as dictated by the typical meteorological plot
self.skew.plot(p, t, 'r')
self.skew.plot(p, td, 'g')
self.skew.plot_barbs(p, u, v, barbcolor='#FF0000', flagcolor='#FF0000')
self.skew.ax.set_ylim(1000, 100)
self.skew.ax.set_xlim(-40, 60)
# Axis colors
self.skew.ax.tick_params(axis='x', colors='#A3A3A4')
self.skew.ax.tick_params(axis='y', colors='#A3A3A4')
# Calculate LCL height and plot as black dot
l = lcl(p[0], t[0], td[0])
lcl_temp = dry_lapse(concatenate((p[0], l)), t[0])[-1].to('degC')
self.skew.plot(l, lcl_temp, 'ko', markerfacecolor='black')
# Calculate full parcel profile and add to plot as black line
prof = parcel_profile(p, t[0], td[0]).to('degC')
self.skew.plot(p, prof, 'k', linewidth=2)
# Color shade areas between profiles
self.skew.ax.fill_betweenx(p, t, prof, where=t >= prof, facecolor='#5D8C53', alpha=0.7)
self.skew.ax.fill_betweenx(p, t, prof, where=t < prof, facecolor='#CD6659', alpha=0.7)
# Add the relevant special lines
self.skew.plot_dry_adiabats()
self.skew.plot_moist_adiabats()
self.skew.plot_mixing_lines()
# Set title
deg = u'\N{DEGREE SIGN}'
self.skew.ax.set_title('Sounding for ' + lat + deg + ', ' + long + deg + ' at ' + time + 'z', y=1.02,
color='#A3A3A4')
# Discards old graph, works poorly though
# skew.ax.hold(False)
# Figure and canvas widgets that display the figure in the GUI
# set canvas size to display Skew-T appropriately
self.canvas.setMaximumSize(QtCore.QSize(800, 2000))
# refresh canvas
self.canvas.draw()
def radar_dialog(self):
r""" When the toolbar icon for the Skew-T dialog is clicked, this function is executed. Creates an instance of
the SkewTDialog object which is the dialog box. If the submit button on the dialog is clicked, get the user
inputted values and pass them into the sounding retrieval call (DataAccessor.get_sounding) to fetch the data.
Finally, plot the returned data via self.plot.
Args:
None.
Returns:
None.
Raises:
None.
"""
radar_dialog = RadarDialog()
if radar_dialog.exec_():
station, product = radar_dialog.get_radarvals()
x, y, ref = DataAccessor.get_radar(station, product)
self.plot_radar(x, y, ref)
def plot_radar(self, x, y, ref):
r"""Displays the Skew-T data on a matplotlib figure.
Args:
t (array-like): A list of temperature values.
td (array-like): A list of dewpoint values.
p (array-like): A list of pressure values.
u (array-like): A list of u-wind component values.
v (array-like): A list of v-wind component values.
lat (string): A string containing the requested latitude value.
long (string): A string containing the requested longitude value.
time (string): A string containing the UTC time requested with seconds truncated.
Returns:
None.
Raises:
None.
"""
self.ax = self.figure.add_subplot(111)
self.ax.pcolormesh(x, y, ref)
self.ax.set_aspect('equal', 'datalim')
self.ax.set_xlim(-460, 460)
self.ax.set_ylim(-460, 460)
self.ax.tick_params(axis='x', colors='#A3A3A4')
self.ax.tick_params(axis='y', colors='#A3A3A4')
# set canvas size to display Skew-T appropriately
self.canvas.setMaximumSize(QtCore.QSize(800, 2000))
# refresh canvas
self.canvas.draw()
def clear_canvas(self):
self.canvas.close()
self.figure = plt.figure(facecolor='#2B2B2B')
self.canvas = FigureCanvas(self.figure)
self.setCentralWidget(self.canvas)
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):
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.QMainWindow, Ui_MainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.setupUi(self)
icon = QtGui.QIcon(':/Icon.png')
self.setWindowIcon(icon)
self.coeffWH = CAPTUREHEIGHT/CAPTUREWIDTH
self.objectLine.setText(OBJECTNAME)
self.objectName = self.objectLine.text()
self.path = PATH
self.directoryLine.setText(self.path)
self.pathCleaner(True)
self.videoStream()
self.posSlider.valueChanged.connect(self.posChange)
self.posSlider.setMinimum(0)
self.posSlider.setMaximum(CAPTUREHEIGHT)
self.posSlider.setValue(POS)
self.sizeSlider.valueChanged.connect(self.sizeChange)
self.sizeSlider.setMinimum(0)
self.sizeSlider.setMaximum(POS)
self.sizeSlider.setValue(SIZE)
self.brightnessSlider.valueChanged.connect(self.brightnessChange)
self.contrastSlider.valueChanged.connect(self.contrastChange)
self.saturationSlider.valueChanged.connect(self.saturationChange)
self.hueSlider.valueChanged.connect(self.hueChange)
self.gainSlider.valueChanged.connect(self.gainChange)
self.exposureSlider.valueChanged.connect(self.exposureChange)
self.captureButton.clicked.connect(self.captureData)
self.cleanButton.clicked.connect(self.cleanPlot)
self.resetButton.clicked.connect(self.resetSettings)
self.comboBox_2.addItem("680 x 480")
self.comboBox_2.addItem("1280 x 720")
# self.comboBox_2.addItem("1920 x 1080")
self.comboBox_2.activated[str].connect(self.resolutionBox)
self.canvas = None
def videoStream(self):
self.cam = specpy.GuiWindow("Stream", CAMARA, self.objectName, STREAMWIDTH, STREAMHEIGHT, PATH,
POS, SIZE, BRIGHTNESS, CONTRAST, SATURATION, HUE,
GAIN, EXPOSURE, "canvas")
self.updateImage()
self.fig_num = 0
def qImage(self, width, height, bytesPerLine):
qImg = QtGui.QImage(self.cam.frame.data, width, height, bytesPerLine, QtGui.QImage.Format_RGB888)
pix = QtGui.QPixmap(qImg)
return pix
def keyPressEvent(self, event):
keyPressed = event.key()
if keyPressed == QtCore.Qt.Key_Alt + QtCore.Qt.Key_F4:
self.cam.closeInput()
self.close()
elif keyPressed == QtCore.Qt.Key_Enter - 1:
self.captureData()
elif keyPressed == QtCore.Qt.Key_C:
self.cleanPlot()
elif keyPressed == QtCore.Qt.Key_R:
self.resetSettings()
def updateImage(self):
width = self.CamaraStream.frameGeometry().width()
height = int(self.coeffWH*width)
realHeight = self.CamaraStream.frameGeometry().height()
if height > realHeight:
width = int(realHeight/self.coeffWH)
height = realHeight
self.cam.changeHeight(height)
self.cam.changeWidth(width)
bytesPerLine = 3*width
answer = self.cam.eachPhotogram()
if answer:
pix = self.qImage(width, height, bytesPerLine)
self.CamaraStream.setPixmap(pix)
def update(self):
timer = QtCore.QTimer(self)
timer.timeout.connect(self.updateImage)
timer.start(33)
# Creates first plot
self.updatePlot()
def updatePlot(self):
def create():
figure = self.cam.figure
if figure != None:
self.canvas = FigureCanvas(figure)
self.figureFrame.addWidget(self.canvas)
self.canvas.draw()
else:
self.canvas == None
def removePlot():
self.figureFrame.removeWidget(self.canvas)
self.canvas.close()
if self.canvas == None:
create()
else:
removePlot()
create()
def posSliderLimits(self):
self.posSlider.setMinimum(0)
temp = self.cam.analysisHeight
self.posSlider.setMaximum(temp)#CAPTUREHEIGHT)
self.posSlider.setValue(int(temp/2))
def sizeSliderLimits(self):
self.sizeSlider.setMinimum(0)
temp = self.cam.analysisHeight
self.sizeSlider.setMaximum(int(temp/2))
self.sizeSlider.setValue(int(temp/4))
def posChange(self):
size = self.posSlider.value()
self.cam.posTrackBar(size)
def sizeChange(self):
size = self.sizeSlider.value()
self.cam.rangeTrackBar(size)
def brightnessChange(self):
size = self.brightnessSlider.value()
self.cam.brightnessTrackBar(size)
def contrastChange(self):
size = self.contrastSlider.value()
self.cam.contrastTrackBar(size)
def saturationChange(self):
size = self.saturationSlider.value()
self.cam.saturationTrackBar(size)
def hueChange(self):
size = self.hueSlider.value()
self.cam.hueTrackBar(size)
def gainChange(self):
size = self.gainSlider.value()
self.cam.gainTrackBar(size)
def exposureChange(self):
size = self.exposureSlider.value()
self.cam.exposureTrackBar(size)
def captureData(self):
self.objectNameChanger()
self.pathChanger()
self.fig_num = self.cam.captureData(self.cam.notSquaredAnalysisFrame, self.fig_num)
self.updatePlot()
def resetSettings(self):
self.cam.resetSettings(POS, SIZE, BRIGHTNESS, CONTRAST, SATURATION, HUE, GAIN, EXPOSURE)
self.posSlider.setValue(POS)
self.sizeSlider.setValue(SIZE)
self.brightnessSlider.setValue(BRIGHTNESS)
self.contrastSlider.setValue(CONTRAST)
self.saturationSlider.setValue(SATURATION)
self.hueSlider.setValue(HUE)
self.gainSlider.setValue(GAIN)
self.exposureSlider.setValue(EXPOSURE)
self.path = PATH
self.directoryLine.setText(self.path)
self.objectName = OBJECTNAME
self.objectLine.setText(self.objectName)
self.comboBox_2.setCurrentIndex(0)
self.resolutionBox(self.comboBox_2.currentText())
def closeEvent(self, event):
self.cam.closeInput()
self.close()
def resolutionBox(self, text):
parted_line = text.rpartition('x')
width, _, height = parted_line
width = int(width)
height = int(height)
self.coeffWH = height/width
self.cam.setCaptureHeight(height)
self.cam.setCaptureWidth(width)
self.posSliderLimits()
self.sizeSliderLimits()
def objectNameChanger(self):
self.objectName = self.objectLine.text()
self.cam.objectName = self.objectName
# print(text)
def pathChanger(self):
self.path = self.directoryLine.text()
self.cam.path = self.path
self.pathCleaner(False)
def pathCleaner(self, delete):
import os, glob
if not os.path.exists(self.path):
os.makedirs(self.path)
if delete:
temp = glob.glob(self.path+'/*.jpg')
temp2 = glob.glob(self.path+'/*.csv')
temp += temp2
for item in temp:
os.remove(item)
def cleanPlot(self):
self.cam.cleanData()
self.updatePlot()
class Main(QMainWindow,Ui_MainWindow):
def __init__(self,parent=None):
super(Main,self).__init__(parent)
self.setupUi(self)
self.connect(self.pushButton_9,SIGNAL("clicked()"),self,SLOT("start()"))
self.connect(self.pushButton,SIGNAL("clicked()"),self,SLOT("one()"))
self.connect(self.pushButton_2,SIGNAL("clicked()"),self,SLOT("two()"))
self.connect(self.pushButton_3,SIGNAL("clicked()"),self,SLOT("three()"))
self.connect(self.pushButton_4,SIGNAL("clicked()"),self,SLOT("four()"))
self.connect(self.pushButton_5,SIGNAL("clicked()"),self,SLOT("five()"))
self.connect(self.pushButton_6,SIGNAL("clicked()"),self,SLOT("six()"))
self.connect(self.pushButton_7,SIGNAL("clicked()"),self,SLOT("seven()"))
self.connect(self.pushButton_8,SIGNAL("clicked()"),self,SLOT("eight()"))
self.connect(self.pushButton_10,SIGNAL("clicked()"),self,SLOT("confirm_size()"))
self.textEdit.append("push getsure")
self.df=[]
self.sensor=[]
def addmpl(self,fig):
self.canvas=FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
#--------------------button-------
@pyqtSlot()
def start(self):
self.listen_for_gestures()
@pyqtSlot()
def confirm_size(self):
list=[]
list.append(file1)
list.append(file2)
list.append(file3)
list.append(file4)
list.append(file5)
list.append(file6)
list.append(file7)
list.append(file8)
for i in range(len(list)):
ans=[]
try:
df=pd.read_csv(list[i],header=None)
ans.append(str(list[i]))
ans.append(df.shape)
self.textEdit.append(str(ans))
except:
print "file none.."
def listen_for_gestures(self):
print"start"
ser=serial.Serial("COM5",9600,timeout=time_out)#optional COM port
for n in range(0,samples):
total=[]
try:
print "Listening for gesture"
# self.textEdit.append("Listening for gesture for "+str(time_out)+"seconds...")
for line in ser:
line=line.decode()
line=line.split(" ")
del line[-1]
values=list(map(int,line))
total=total+values
except serial.SerialException:
print"caught serial exception"
self.textEdit.append("measurement end ...")
print "end.."
sensor1=[]
sensor2=[]
sensor3=[]
sensor4=[]
for j in range(0,len(total),4):
sensor1.append(total[j+0])
sensor2.append(total[j+1])
sensor3.append(total[j+2])
sensor4.append(total[j+3])
time.sleep(2)
sensor3.extend(sensor4)
sensor2.extend(sensor3)
sensor1.extend(sensor2)
# print total
if len(sensor1)>0:
sensor1=map(float,sensor1)
sensor1=self.trim_data(sensor1)
print sensor1
#self.textEdit.append("wait......")
time.sleep(2)
self.sensor=sensor1
# self.df=pd.DataFrame(sensor1)
self.plot_four(sensor1)
ser.close()
def trim_data(self,d,n=128,m=255):
l=len(d)
histogram=[0]*n
s=int(l/n)
if s==0:
s=int(1./(float(l)/float(n)))
for i,x in enumerate(d):
histogram[i*s]=x/m
else:
for i in range(0,n):
histogram[i]=sum(d[i*s:(i+1)*s])/(m*s)
return histogram
#---------------------------------------
@pyqtSlot()
def one(self):
self.textEdit.append("one")
self.save_csv(file1)
self.textEdit.append("saved....["+str(file1)+"]")
@pyqtSlot()
def two(self):
self.textEdit.append("two")
self.save_csv(file2)
self.textEdit.append("saved....["+str(file2)+"]")
@pyqtSlot()
def three(self):
self.textEdit.append("three")
self.save_csv(file3)
self.textEdit.append("saved...["+str(file3)+"]")
@pyqtSlot()
def four(self):
self.textEdit.append("four")
self.save_csv(file4)
self.textEdit.append("saved....["+str(file4)+"]")
@pyqtSlot()
def five(self):
self.textEdit.append("five")
self.save_csv(file5)
self.textEdit.append("saved....[5]")
@pyqtSlot()
def six(self):
self.textEdit.append("six")
self.save_csv(file6)
self.textEdit.append("saved....[6]")
@pyqtSlot()
def seven(self):
self.textEdit.append("seven")
self.save_csv(file7)
self.textEdit.append("saved....[7]")
@pyqtSlot()
def eight(self):
self.textEdit.append("eight")
self.save_csv(file8)
self.textEdit.append("saved....[8]")
def save_csv(self,file_name):
f=open(file_name,"ab")
csvwriter=csv.writer(f)
csvwriter.writerow(self.sensor)
f.close()
def plot_four(self,sensor1):
fig1=Figure()
sensor1=np.array(sensor1)
print sensor1
sensor1=sensor1.reshape(4,32)
print sensor1.T
ax1=fig1.add_subplot(411)
ax1.set_title("UP")
ax1.plot(np.arange(32),sensor1[0,:])
ax2=fig1.add_subplot(412)
ax2.set_title("DOWN")
ax2.plot(np.arange(32),sensor1[1,:])
ax3=fig1.add_subplot(413)
ax3.set_title("LEFT")
ax3.plot(np.arange(32),sensor1[2,:])
ax4=fig1.add_subplot(414)
ax4.set_title("RIGHT")
ax4.plot(np.arange(32),sensor1[3,:])
self.rmmpl()
self.addmpl(fig1)
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.toolbar = None
# Fill the indicators table
n_rows = 0
# self.indicator_classes = {}
# for s in Indicator.get_subclasses():
# n = s.get_name()
# if (n != None):
# self.indicator_classes[n] = s
# n_rows += 1
# self.indicators.setRowCount(n_rows)
# item = QtGui.QTableWidgetItem()
# item.setCheckState(QtCore.Qt.Unchecked)
# item.setText(n)
# self.indicators.setItem(n_rows-1, 0, item)
# GUI event handlers
self.symbolsList.itemSelectionChanged.connect(self.changeSymbolHandler)
self.marketsCombo.currentIndexChanged.connect(self.changeMarketHandler)
self.actionSma30.triggered.connect(self.actionSma30Handler)
self.actionSma90.triggered.connect(self.actionSma90Handler)
self.actionSma200.triggered.connect(self.actionSma200Handler)
self.actionBollinger.triggered.connect(self.actionBollingerHandler)
# self.indicators.itemPressed.connect(self.changeIndicatorHandler)
# TODO: use new notation
# QtCore.QObject.connect(self.symbolsList, QtCore.SIGNAL('itemSelectionChanged()'), self.changeSymbolHandler)
self.figure = Figure()
self.addFig(self.figure)
pythonshell = internalshell.InternalShell(self.shellWidget, namespace=globals(), \
commands=[], multithreaded=False)
pythonshell.resize(self.shellWidget.size())
#pythonshell.resize(800, 300)
#shell.setWidget(pythonshell)
#shell.show()
self.chart = None
def on_button_press_event(self, event):
print "on_button_press_event: [" + str(event.x) + ", " + str(event.y) + "]"
def on_motion_notify_event(self, event):
if (self.chart != None):
self.chart.cursor(event)
def on_scroll_event(self, event):
if (event.button == 'up'):
mode = +1
elif (event.button == 'down'):
mode = -1
self.chart.zoom(mode)
self.canvas.draw()
def changeSymbolHandler(self):
s = str(self.symbolsList.currentItem().text())
self.quote = Quote(s).load("2015-01-01")
# Delete figure
self.plotLayout.removeWidget(self.canvas)
self.canvas.close()
# Add new figure
self.canvas = FigureCanvas(self.figure)
self.plotLayout.addWidget(self.canvas)
self.chart = Chart(self.quote, figure=self.figure)
self.chart.add_item(self.quote)
self.canvas.draw()
self.cid = self.figure.canvas.mpl_connect('scroll_event', self.on_scroll_event)
self.cid = self.figure.canvas.mpl_connect('button_press_event', self.on_button_press_event)
# self.cid = self.figure.canvas.mpl_connect('motion_notify_event', self.on_motion_notify_event)
self.chart.plot()
self.canvas.draw()
def changeIndicatorHandler(self):
item = self.indicators.currentItem()
indicator_name = str(item.text())
if (item.checkState() == QtCore.Qt.Unchecked):
item.setCheckState(QtCore.Qt.Checked)
indicator = self.indicator_classes[indicator_name](self.quote)
self.chart.add_item(indicator)
elif (item.checkState() == QtCore.Qt.Checked):
item.setCheckState(QtCore.Qt.Unchecked)
self.chart.remove_item(indicator_name)
else:
print "???????????????"
#self.chart.add_item(self.quote)
# Replace figure
self.figure = self.chart.get_fig()
self.delFig()
self.addFig(self.figure)
self.chart.zoom()
# # Replace figure
# self.figure = self.chart.get_fig()
# self.delFig()
# self.addFig(self.figure)
# self.chart.plot()
def changeMarketHandler(self, index):
market = MARKET_REFS[index]
# Replace symbols
self.symbolsList.clear()
for s in sorted(market.iterkeys()):
self.symbolsList.addItem(s)
def actionSma30Handler(self):
s = SMA(self.chart.quote, 30)
self.chart.add_item(s)
self.chart.plot()
self.canvas.draw()
def actionSma90Handler(self):
s = SMA(self.chart.quote, 90)
self.chart.add_item(s)
self.chart.plot()
self.canvas.draw()
def actionSma200Handler(self):
s = SMA(self.chart.quote, 200)
self.chart.add_item(s)
self.chart.plot()
self.canvas.draw()
def actionBollingerHandler(self):
s = Bollinger(self.chart.quote)
self.chart.add_item(s)
self.chart.plot()
self.canvas.draw()
def initMarkets(self):
for market in MARKET_NAMES:
self.marketsCombo.addItem(market)
def addFig(self, fig):
self.canvas = FigureCanvas(fig)
self.plotLayout.addWidget(self.canvas)
#self.canvas.draw()
self.cid = self.figure.canvas.mpl_connect('scroll_event', self.on_scroll_event)
self.cid = self.figure.canvas.mpl_connect('button_press_event', self.on_button_press_event)
# self.cid = self.figure.canvas.mpl_connect('motion_notify_event', self.on_motion_notify_event)
def delFig(self,):
self.plotLayout.removeWidget(self.canvas)
self.canvas.close()
class Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
super(Main, self).__init__()
self.setupUi(self)
self.thisDir = os.path.dirname(os.path.abspath(__file__))
self.btOpenImage.clicked.connect(self.openImage)
fig = Figure()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
self.message.setText('Escolha uma imagem')
self.status.setText('Sem imagem')
self.Xax.setText('Esperando calibracao')
self.Xay.setText('Esperando calibracao')
self.calibrateX.clicked.connect(partial(self.action, 'calX'))
self.XaxisX = []
self.XaxisY = []
return
def openImage(self):
texto = 'Escolha uma imagem'
path = QtGui.QFileDialog.getOpenFileNameAndFilter(
self, texto, self.thisDir, "Images (*.png *.jpg)")
datafile = cbook.get_sample_data(str(path[0]))
img = imread(datafile)
self.updateCanvas(self.initializeCanvas(img))
self.message.setText('Esperando a calibracao dos eixos')
self.status.setText('Em espera')
return
def initializeCanvas(self, img):
fig = Figure()
fig.clear()
Graph = fig.add_subplot(111)
Graph.imshow(img, zorder=0, extent=[0.0, 1.0, 0.0, 1.0])
return fig
def updateCanvas(self, fig):
self.canvasGraph.removeWidget(self.canvas)
self.canvas.close()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
def onclick(event):
x, y = event.xdata, event.ydata
if x != None and y != None:
if self.currentAction == 'calX':
if len(self.XaxisX) == 0:
self.XaxisX.append(x)
self.XaxisY.append(y)
self.Xax.setText(str(x))
self.Xay.setText(str(y))
self.message.setText('Clique e marque onde esta Xb')
return
self.canvas.mpl_connect('button_press_event', onclick)
return
def action(self, what):
self.currentAction = what
if what == 'calX':
self.message.setText('Clique e marque onde esta Xa')
self.status.setText('Calibrando Eixo X')
return
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):
# 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 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 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 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 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 WD(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setupUi(self)
self.file = open('output.txt', 'a')
self.ButtonBack.clicked.connect(self.back1)
self.radioButton.setChecked(True)
self.sim = 0
self.true1 = 0
self.ButtonOn.hide()
self.ButtonBack.hide()
self.ButtonPause.hide()
self.label_5.hide()
self.interact_game.hide()
self.game.hide()
self.start.clicked.connect(self.start1)
self.back.clicked.connect(self.close)
self.ButtonOn.clicked.connect(self.on)
self.ButtonPause.clicked.connect(self.pause)
self.fig_dict = {}
self.slider_simulation.hide()
# self.horizontalSlider.valueChanged.connect(self.initial)
self.slider_simulation.valueChanged.connect(self.simulation)
self.fig_dict = {}
self.mplfigs.itemClicked.connect(self.changefig)
self.fig = plt.figure()
self.addmpl(self.fig)
self.ButtonDemo_1.clicked.connect(self.demo1)
self.ButtonDemo_2.clicked.connect(self.demo2)
self.demo = 0
self.horizontalSlider.valueChanged.connect(self.initial)
self.pushButton_game.clicked.connect(self.game_call)
self.pushButton_try.clicked.connect(self.graph_try)
self.pushButton_return.clicked.connect(self.game_return)
self.ButtonDiffu.clicked.connect(self.diffusion)
self.ButtonBackDiffu.clicked.connect(self.backdiffu)
self.mplwindow_2.hide()
self.mplwindow_3.hide()
self.textDiffu.hide()
self.ButtonBackDiffu.hide()
self.ButtonDiffu.hide()
showAction = QtGui.QAction('&Authors', self)
showAction.triggered.connect(self.showAuthors)
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('&About')
fileMenu.addAction(showAction)
self.timer1 = QtCore.QTimer(self)
self.timer2 = QtCore.QTimer(self)
self.ani_co = 0
file = open('position_02.txt', 'r')
lines = file.readlines()
file.close()
x = []
x1 = []
x2 = []
for line in lines:
p = line.split()
x.append(float(p[0]))
x1.append(float(p[1]))
x2.append(float(p[5]))
xv = np.array(x)
xv1 = np.array(x1)
xv2 = np.array(x2)
self.rmmpl()
self.fig = plt.figure()
axf = self.fig.add_subplot(111)
axf.set_xlabel('$x/a_{ho}$', fontsize=17)
axf.set_ylabel('density $|\psi|^2 a_{ho}$', fontsize=14)
axf.fill_between(xv,
0,
xv1,
label='$R-Space$',
facecolor='blue',
alpha=0.5)
axf.fill_between(xv,
0,
xv2,
label='$K-Space$',
facecolor='yellow',
alpha=0.5)
axf.set_xlim([-20, 20])
axf.set_title('Wave Packet')
axf.legend()
self.addmpl(self.fig)
def initial(self):
file = open('initial2.txt', 'r')
lines = file.readlines()
file.close()
for i in range(0, 16):
globals()['x%s' % i] = []
for line in lines:
p = line.split()
for i in range(0, 16):
globals()['x%s' % i].append(float(p[i - 1]))
for i in range(0, 16):
globals()['xv%s' % i] = np.array(globals()['x%s' % i])
value = self.horizontalSlider.value()
for i in range(3, 16):
if value == i - 9:
if self.fig == None:
self.rmmpl()
self.fig = Figure()
self.addmpl(self.fig)
self.fig.clear()
ax1f2 = self.fig.add_subplot(111)
ax1f2.set_xlabel('$x/a_{ho}$', fontsize=17)
ax1f2.set_ylabel('density $|\psi|^2 a_{ho}$', fontsize=14)
ax1f2.fill_between(xv1,
0,
globals()['xv%s' % i],
label='$R-Space$',
facecolor='blue',
alpha=0.5)
ax1f2.fill_between(xv1,
0,
xv2,
label='$K-Space$',
facecolor='yellow',
alpha=0.5)
ax1f2.set_ylim(0., 0.6)
ax1f2.set_xlim(-20., 20.)
ax1f2.set_title('initial state')
ax1f2.legend()
self.canvas.draw()
def start1(self):
self.demo = 0
self.start2()
def start2(self):
self.timer1.stop()
self.timer2.stop()
dialog = QtGui.QDialog()
progressBar = Ui_porcessProgress()
progressBar.setupUi(dialog)
dialog.show()
self.file.write('...Nuevo proceso...\n')
diff = 0
self.sim = 0
self.true1 = 0
prevdir = os.getcwd()
self.spinBox_value = self.spinBox.value()
self.slider_simulation.setValue(0)
try:
if self.demo == 0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(
os.path.expanduser('./Wavepackdisper/Demo%s' %
(self.demo)))
if (not os.path.exists('./WfWd-end')):
zip_ref = zipfile.ZipFile('./Demo%s.zip' % (self.demo),
'r')
zip_ref.extractall('.')
zip_ref.close()
else:
pass
file = open('input.txt', 'w')
if (self.radioButton.isChecked() == True):
self.true1 = 1
if (self.radioButton_2.isChecked() == True):
self.true1 = 0
file.write('%s\t%s\t%s\t%s' %
(self.horizontalSlider.value(), self.true1,
self.spinBox.value(), self.spinBox_2.value()))
file.close()
time1 = int(self.spinBox_value * (10 * np.pi * 2.0))
start_sub = time.time()
if self.demo == 0:
exclude = set(['Demo1', 'Demo2'])
for root, dirs, files in os.walk(os.getcwd(), topdown=True):
dirs[:] = [d for d in dirs if d not in exclude]
for file in files:
if file.startswith("WfWd"):
os.remove((os.path.join(root, file)))
subprocess.Popen('python gpe_fft_ts_WP_v1.py', shell=True)
progressBar.porcessProgressBar.setMaximum(time1 + 1)
diff = 0
while diff < time1 + 2:
diff = 0
for root, dirs, files in os.walk(os.getcwd()):
dirs[:] = [d for d in dirs if d not in exclude]
for file in files:
if file.startswith("WfWd"):
diff += 1
if (diff < 10):
progressBar.label.setText(
'Initiation of the progress...')
if (diff < time1 - 10) and (diff > 10):
progressBar.label.setText(
u'Solving Schrödinger equation...')
if (diff < time1 + 1) and (diff > time1 - 10):
progressBar.label.setText('Writing results ...')
progressBar.porcessProgressBar.setValue(diff)
QApplication.processEvents()
if (self.true1 == 1):
self.file.write(
'Posición inicial del paquete de ondas=%s\nPotential armónico: YES\nExcitación del estado=%s\nNúmero de oscilaciones=%s\n\n'
% (self.horizontalSlider.value(), self.spinBox_2.value(),
self.spinBox.value()))
if (self.true1 == 0):
self.file.write(
'Posición inicial del paquete de ondas=%s\nPotential armónico: NO\nExcitación del estado=%s\nNúmero de oscilaciones=%s\n\n'
% (self.horizontalSlider.value(), self.spinBox_2.value(),
self.spinBox.value()))
end_sub = time.time()
print(os.getcwd())
print("READY")
self.label_5.show()
self.ButtonOn.show()
self.ButtonBack.show()
self.ButtonPause.show()
self.label_5.show()
self.slider_simulation.show()
self.slider_simulation.setMinimum(0)
self.slider_simulation.setMaximum(self.spinBox_value * int(
(10 * np.pi * 2.0)))
self.slider_simulation.setSingleStep(1)
if (self.radioButton.isChecked() == True):
self.interact_game.show()
self.ButtonDiffu.hide()
self.radioButton_oscil.setChecked(True)
if (self.radioButton_2.isChecked() == True):
self.interact_game.hide()
self.ButtonDiffu.show()
# time.sleep(2)
file = open('output_sp.txt', 'r')
self.file.write('%s\n\n' % file.read())
self.file.write('Durada de la computación=%s\n\n' %
(end_sub - start_sub))
file = open('energies.txt', 'r')
lines = file.readlines()
file.close()
file2 = open('mean_value.txt', 'r')
lines2 = file2.readlines()
file2.close()
file4 = open('WfWd-%08d.txt' % (0), 'r')
lines4 = file4.readlines()
file4.close()
finally:
os.chdir(prevdir)
x1 = []
x2 = []
x3 = []
for line in lines4:
p = line.split()
x1.append(float(p[0]))
x2.append(float(p[1]))
x3.append(float(p[5]))
xv1 = np.array(x1)
xv2 = np.array(x2)
xv3 = np.array(x3)
self.rmmpl()
self.fig = plt.figure()
axf = self.fig.add_subplot(111)
axf.set_xlabel('$x/a_{ho}$', fontsize=17)
axf.set_ylabel('density $|\psi|^2 a_{ho}$', fontsize=14)
axf.fill_between(xv1,
0,
xv2,
label='$R-Space$',
facecolor='blue',
alpha=0.5)
axf.fill_between(xv1,
0,
xv3,
label='$K-Space$',
facecolor='yellow',
alpha=0.5)
axf.set_xlim([
-self.horizontalSlider.value() - 8,
self.horizontalSlider.value() + 8
])
if (self.true1 == 0):
axf.set_ylim(0, 0.6)
axf.set_title('state at %s' % (0))
axf.legend()
self.addmpl(self.fig)
x1 = []
y1 = []
z1 = []
j1 = []
for line in lines:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
z1.append(float(p[3]))
j1.append(float(p[4]))
xv = np.array(x1)
yv = np.array(y1)
zv = np.array(z1)
jv = np.array(j1)
fig = Figure()
ax1f1 = fig.add_subplot(111)
ax1f1.set_xlabel('$T/t_{ho}$', fontsize=17)
ax1f1.set_ylabel('$E/hw$', fontsize=17)
ax1f1.plot(xv, yv, 'r.-', label='$E_{tot}$')
ax1f1.plot(xv, zv, 'y.-', label='Kinetic Energy')
ax1f1.plot(xv, jv, 'b.-', label='Potential Energy')
ax1f1.legend()
ax1f1.set_title('Energies')
x1 = []
y1 = []
z1 = []
i1 = []
j1 = []
for line in lines2:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
z1.append(float(p[2]))
i1.append(float(p[3]))
j1.append(float(p[4]))
xv = np.array(x1)
yv = np.array(y1)
zv = np.array(z1)
iv = np.array(i1)
jv = np.array(j1)
self.fig2 = Figure()
ax1f2 = self.fig2.add_subplot(111)
ax1f2.set_xlabel('$T/t_{ho}$', fontsize=17)
ax1f2.set_ylabel('$x/a_{ho}$', fontsize=17)
ax1f2.plot(xv, yv, 'b.', label='$R-Space:<x> $')
ax1f2.plot(xv, iv, 'y--', label='$k-Space:<k>$')
ax1f2.plot(xv, zv, 'b--', label='$R-Space:dispersion$')
ax1f2.plot(xv, jv, 'y.', label='$k-Space:dispersion$')
ax1f2.legend(loc='best')
self.delfig()
self.delfig()
self.delfig()
self.addfig('ENERGY', fig)
self.addfig('MEAN VALUE X', self.fig2)
self.slider_simulation.setValue(0)
def simulation(self):
time1 = int(self.spinBox_value * (10 * np.pi * 2.0))
value = self.slider_simulation.value()
self.sim = value
prevdir = os.getcwd()
try:
if self.demo == 0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(
os.path.expanduser('./Wavepackdisper/Demo%s' %
(self.demo)))
for i in range(0, time1 + 1):
file = open('WfWd-%08d.txt' % (i), 'r')
globals()['lines%s' % i] = file.readlines()
file.close()
#
#
if value == i:
x1 = []
x2 = []
x3 = []
for line in (globals()['lines%s' % i]):
p = line.split()
x1.append(float(p[0]))
x2.append(float(p[1]))
x3.append(float(p[5]))
xv1 = np.array(x1)
xv2 = np.array(x2)
xv3 = np.array(x3)
if self.fig == None:
self.rmmpl()
self.fig = plt.figure()
self.addmpl(self.fig)
self.fig.clear()
axf = self.fig.add_subplot(111)
axf.set_xlabel('$x/a_{ho}$', fontsize=17)
axf.set_ylabel('density $|\psi|^2 a_{ho}$', fontsize=14)
axf.fill_between(xv1,
0,
xv2,
label='$R-Space$',
facecolor='blue',
alpha=0.5)
axf.fill_between(xv1,
0,
xv3,
label='$K-Space$',
facecolor='yellow',
alpha=0.5)
axf.set_xlim([
-self.horizontalSlider.value() - 8,
self.horizontalSlider.value() + 8
])
if (self.true1 == 0):
axf.set_ylim(0, 0.6)
axf.set_title('state at %s' % (i))
axf.legend()
self.canvas.draw()
finally:
os.chdir(prevdir)
def game_call(self):
self.timer1.stop()
self.timer2.stop()
if (self.radioButton.isChecked() == True):
if (self.radioButton_oscil.isChecked() == True):
self.rmmpl()
self.textBrowser.show()
self.rmmpl2()
self.mplwindow.hide()
self.textDiffu.hide()
self.mplwindow_3.hide()
self.widget_osci.show()
self.start.hide()
self.ButtonDemo_1.hide()
self.ButtonDemo_2.hide()
self.interact.setEnabled(False)
self.mplfigs.hide()
self.spin_amplitude.setValue(3.)
self.spin_frequency.setValue(0.5)
prevdir = os.getcwd()
try:
if self.demo == 0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(
os.path.expanduser('./Wavepackdisper/Demo%s' %
(self.demo)))
file2 = open('mean_value.txt', 'r')
lines2 = file2.readlines()
file2.close()
x1 = []
y1 = []
for line in lines2:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
xv = np.array(x1)
yv = np.array(y1)
finally:
os.chdir(prevdir)
fig3 = Figure()
ax1f3 = fig3.add_subplot(111)
ax1f3.set_xlabel('$T/t_{ho}$', fontsize=17)
ax1f3.set_ylabel('$x/a_{ho}$', fontsize=17)
ax1f3.plot(xv, yv, 'r.-', label='$R-Space$')
ax1f3.set_title('Mean value x')
ax1f3.legend()
self.addmpl2(fig3)
self.game.show()
self.mplwindow_2.show()
def graph_try(self):
if (self.radioButton.isChecked() == True):
if (self.radioButton_oscil.isChecked() == True):
self.amplitude = self.spin_amplitude.value()
self.frequency = self.spin_frequency.value()
self.ani_co += 1
if self.ani_co > 1:
self.ani.event_source.stop()
time1 = int(self.spinBox_value * (10 * np.pi * 2.0))
self.rmmpl2()
prevdir = os.getcwd()
try:
if self.demo == 0:
os.chdir(os.path.expanduser('./Wavepackdisper'))
else:
os.chdir(
os.path.expanduser('./Wavepackdisper/Demo%s' %
(self.demo)))
file2 = open('mean_value.txt', 'r')
lines2 = file2.readlines()
file2.close()
x1 = []
y1 = []
for line in lines2:
p = line.split()
x1.append(float(p[0]))
y1.append(float(p[1]))
xv = np.array(x1)
yv = np.array(y1)
finally:
os.chdir(prevdir)
# fig3=Figure()
# self.addmpl2(fig3)
# ax1f3=fig3.add_subplot(111)
# ax1f3.set_xlabel('$T/t_{ho}$',fontsize=17)
# ax1f3.set_ylabel('$x/a_{ho}$',fontsize=17)
#
# x=np.arange(0,time1+1)/10.
# y=self.spin_amplitude.value()*np.cos(self.spin_frequency.value()*x)
#
# ax1f3.plot(xv,yv, 'r.-',label='$R-Space$')
# ax1f3.plot(x,y)
# ax1f3.set_title('Mean value x')
# ax1f3.legend()
# self.canvas.draw()
tf_sim = time1 / 10.
def simData():
L = self.amplitude
t_max = time1 / 10.
dt = 0.05
w = self.frequency
y = 0.0
t = 0.0
while t <= t_max:
if on_spr and not back_spr and not pause_spr:
y = L * np.sin(w * t + np.pi / 2.)
t = t + dt
if t < 0:
y = L * np.sin(w * t + np.pi / 2.)
t = t + dt
if back_spr and not on_spr and not pause_spr:
y = L * np.sin(w * t + np.pi / 2.)
t = t - dt
yield y, t
def onClick(event):
global pause_spr, on_spr, back_spr
back_spr ^= True
on_spr ^= True
def init():
line.set_data([], [])
line2.set_data([], [])
line3.set_data([], [])
line4.set_data([], [])
for j in range(0, 11):
globals()['line_%s' % (j)].set_data([], [])
time_text.set_text('')
return line, time_text
def simPoints(simData):
y, t = simData[0], simData[1]
if self.amplitude >= 0:
ori = -self.amplitude - 1.
if self.amplitude <= 0:
ori = self.amplitude - 1.
time_text.set_text(time_template % (t))
thisy = [ori, y]
line.set_data(0, thisy)
for j in range(3, 9):
globals()['line_%s' % (j)].set_data(
[((-1)**(j - 1)) * 0.5, ((-1)**j) * 0.5],
[(j - 1.) * ((y - ori) / 10.) + ori,
((y - ori) / 10.) * j + ori])
line_0.set_data([0., 0.5],
[((((y - ori) / 10.) * 1. + ori) +
(((y - ori) / 10.) * 2. + ori)) / 2.,
((y - ori) / 10.) * 2. + ori])
line_1.set_data([0.5, 0.],
[((y - ori) / 10.) * 8. + ori,
((((y - ori) / 10.) * 8. + ori) +
(((y - ori) / 10.) * 9. + ori)) / 2.])
line2.set_data([1., -1.], [ori, ori])
line3.set_data([t, y])
tf = np.arange(0.0, t, 0.05)
line4.set_data(
[tf, self.amplitude * np.cos(tf * self.frequency)])
time_text.set_text(time_template % (t))
return line, line2, line3, line_0, line_1, line_2, line_3, line_4, line_5, line_6, line_7, line_8, line_9, line4
# gs=0
ax = 0
ax2 = 0
# import matplotlib.gridspec as gridspec
fig3 = plt.figure()
# rcParams.update({'figure.autolayout': True})
# gs = gridspec.GridSpec(10, 10)
# ax = fig3.add_subplot(gs[:,03], xlim=(-0.5, 0.5), ylim=(-self.spin_amplitude.value()-2., +self.spin_amplitude.value()+2.))
# ax2 = fig3.add_subplot(gs[:,4:])
ax = plt.subplot2grid(
(10, 10), (0, 0),
rowspan=10,
colspan=2,
autoscale_on=False,
xlim=(-0.5, 0.5),
ylim=(-self.amplitude - 2., +self.amplitude + 2.))
ax2 = plt.subplot2grid(
(10, 10), (0, 3),
rowspan=10,
colspan=7,
autoscale_on=False,
xlim=(0., tf_sim),
ylim=(-self.amplitude - 2., +self.amplitude + 2.))
# ax = fig3.add_subplot(121)
# ax2 = fig3.add_subplot(122)
ax.set_title('Spring')
ax.set_xticks(np.arange(-1., 2., 1.))
ax.set_xlim(-1, 1)
ax.set_ylabel('x(m)', fontsize=13)
if self.amplitude >= 0:
ax.set_ylim(-self.amplitude - 2., self.amplitude + 2.)
if self.amplitude <= 0:
ax.set_ylim(self.amplitude - 2., -self.amplitude + 2.)
ax2.set_xlabel('t(s)', fontsize=13)
ax2.set_ylabel('x(m)', fontsize=13)
ax2.plot(xv, yv, 'r.-')
ax2.set_title('Mean value x')
self.addmpl2(fig3)
line, = ax.plot([], [], 'o-', lw=2)
line2, = ax.plot([], [], 'g-', lw=2)
line3, = ax2.plot([], [], 'o-', lw=2)
line4, = ax2.plot([], [], 'b-', lw=2)
for j in range(0, 11):
globals()['line_%s' % (j)], = ax.plot([], [], 'b-', lw=2)
time_template = 'time = %.1fs'
time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)
fig3.canvas.mpl_connect('button_press_event', onClick)
self.ani = animation.FuncAnimation(fig3,
simPoints,
simData,
interval=25,
blit=True,
init_func=init,
repeat=False)
#ani.save('muelle.mp4', fps=15)
self.canvas.draw()
def game_return(self):
self.rmmpl2()
self.rmmpl2()
self.mplwindow_2.hide()
self.textDiffu.hide()
self.mplwindow_3.hide()
self.game.hide()
self.fig = plt.figure()
self.addmpl(self.fig)
self.mplwindow.show()
self.start.show()
self.ButtonDemo_1.show()
self.ButtonDemo_2.show()
self.interact.setEnabled(True)
self.mplfigs.show()
self.slider_simulation.setValue(self.sim + 1)
self.slider_simulation.setValue(self.sim - 1)
def plot(self):
self.sim += 1
self.slider_simulation.setValue(self.sim)
if (self.sim == self.spinBox_value * int((10 * np.pi * (2.)))):
self.timer1.stop()
def plot2(self):
self.sim -= 1
self.slider_simulation.setValue(self.sim)
if (self.sim == 0):
self.timer2.stop()
def on(self):
self.timer1.stop()
self.timer2.stop()
if self.timer2 == None:
self.timer1 = QtCore.QTimer(self)
self.timer1.timeout.connect(self.plot)
self.timer1.start(75)
else:
self.timer1 = QtCore.QTimer(self)
self.timer1.timeout.connect(self.plot)
self.timer2.stop()
self.timer1.start(75)
def pause(self):
self.timer1.stop()
self.timer2.stop()
def back1(self):
self.timer1.stop()
self.timer2.stop()
if self.timer1 == None:
self.timer2 = QtCore.QTimer(self)
self.timer2.timeout.connect(self.plot2)
self.timer2.start(75)
else:
self.timer2 = QtCore.QTimer(self)
self.timer2.timeout.connect(self.plot2)
self.timer1.stop()
self.timer2.start(75)
def diffusion(self):
self.timer1.stop()
self.timer2.stop()
self.mplwindow.hide()
self.mplwindow_2.hide()
self.mplwindow_3.show()
self.game.hide()
self.ButtonDiffu.hide()
self.textDiffu.show()
self.start.hide()
self.ButtonDemo_1.hide()
self.ButtonDemo_2.hide()
self.interact.setEnabled(False)
self.mplfigs.hide()
self.ButtonBackDiffu.show()
self.movie = QMovie("dispersion.gif", QByteArray(), self)
self.movie_scr = QLabel()
self.mplvl_3.addWidget(self.movie_scr)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.movie_scr.setMovie(self.movie)
self.movie.start()
def backdiffu(self):
self.movie.stop()
self.mplvl_3.removeWidget(self.movie_scr)
self.mplwindow_3.hide()
self.ButtonBackDiffu.hide()
self.textDiffu.hide()
self.ButtonDiffu.show()
self.mplwindow.show()
self.start.show()
self.ButtonDemo_1.show()
self.ButtonDemo_2.show()
self.interact.setEnabled(True)
self.mplfigs.show()
self.slider_simulation.setValue(self.sim + 1)
self.slider_simulation.setValue(self.sim - 1)
def demo1(self):
self.radioButton_2.setChecked(True)
self.horizontalSlider.setValue(0)
self.spinBox_2.setValue(0)
self.spinBox.setValue(2)
self.demo = 1
self.start2()
def demo2(self):
self.radioButton.setChecked(True)
self.horizontalSlider.setValue(3)
self.spinBox_2.setValue(0)
self.spinBox.setValue(2)
self.demo = 2
self.start2()
def changefig(self, item):
text = item.text()
self.rmmpl()
self.addmpl(self.fig_dict[str(text)])
self.fig = None
self.timer1.stop()
self.timer2.stop()
def addfig(self, name, fig):
self.fig_dict[name] = fig
self.mplfigs.addItem(name)
def delfig(self):
listItems = self.mplfigs.selectedItems()
if not listItems: return
for item in listItems:
self.mplfigs.takeItem(self.mplfigs.row(item))
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
self.mplvl.addWidget(self.toolbar)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self):
self.mplvl.removeWidget(self.toolbar)
self.toolbar.close()
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
def addmpl2(self, fig):
self.canvas = FigureCanvas(fig)
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
self.mplvl_2.addWidget(self.toolbar)
self.mplvl_2.addWidget(self.canvas)
self.canvas.draw()
def rmmpl2(self):
self.mplvl_2.removeWidget(self.toolbar)
self.toolbar.close()
self.mplvl_2.removeWidget(self.canvas)
self.canvas.close()
def close(self):
self.timer1.stop()
self.timer2.stop()
self.hide()
self.file.close()
self.parent().show()
def showAuthors(self):
QtGui.QMessageBox.question(self, 'Authors',
"ULTRACOLDUB\n\nUniversitat de Barcelona")
def closeEvent(self, event):
reply = QtGui.QMessageBox.question(self, 'EXIT',
"Are you sure to quit?",
QtGui.QMessageBox.Yes,
QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
event.accept()
self.file.close()
else:
event.ignore()
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)
self.thisDir = os.path.dirname(os.path.abspath(__file__))
self.btOpenImage.clicked.connect(self.openImage)
fig = Figure()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
self.message.setText('Escolha uma imagem')
self.status.setText('Sem imagem')
self.Xax.setText('Esperando calibracao')
self.Xay.setText('Esperando calibracao')
self.calibrateX.clicked.connect(partial(self.action, 'calX'))
self.XaxisX = []
self.XaxisY = []
return
def openImage(self) :
texto = 'Escolha uma imagem'
path = QtGui.QFileDialog.getOpenFileNameAndFilter(self,
texto,
self.thisDir,
"Images (*.png *.jpg)")
datafile = cbook.get_sample_data(str(path[0]))
img = imread(datafile)
self.updateCanvas(self.initializeCanvas(img))
self.message.setText('Esperando a calibracao dos eixos')
self.status.setText('Em espera')
return
def initializeCanvas(self, img) :
fig = Figure()
fig.clear()
Graph = fig.add_subplot(111)
Graph.imshow(img, zorder=0, extent=[0.0, 1.0, 0.0, 1.0])
return fig
def updateCanvas(self, fig) :
self.canvasGraph.removeWidget(self.canvas)
self.canvas.close()
self.canvas = FigureCanvas(fig)
self.canvasGraph.addWidget(self.canvas)
self.canvas.draw()
def onclick(event):
x, y = event.xdata, event.ydata
if x != None and y != None :
if self.currentAction == 'calX' :
if len(self.XaxisX) == 0 :
self.XaxisX.append(x)
self.XaxisY.append(y)
self.Xax.setText(str(x))
self.Xay.setText(str(y))
self.message.setText('Clique e marque onde esta Xb')
return
self.canvas.mpl_connect('button_press_event', onclick)
return
def action(self, what) :
self.currentAction = what
if what == 'calX' :
self.message.setText('Clique e marque onde esta Xa')
self.status.setText('Calibrando Eixo X')
return
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 Ui_MainWindow(object):
def Search_String(self, tofind):
with open(self.path, encoding="utf8") as f:
data = json.load(f)
counttofindname1 = 0
counttofindname2 = 0
Name1 = self.Name1.text()
Name2 = self.Name2.text()
req = [Name1, Name2]
for item in data:
if item['participants'] == req:
for conv in item['conversation']:
if 'text' in conv.keys():
search = conv['text']
if search == None:
continue
numberfound = search.lower().count(tofind.lower())
if conv['sender'] == Name1:
counttofindname1 += numberfound
elif conv['sender'] == Name2:
counttofindname2 += numberfound
return counttofindname1, counttofindname2
def count_messages(self):
with open(self.path, encoding="utf8") as f:
data = json.load(f)
countmsgsname1 = 0
countmsgsname2 = 0
Name1 = self.Name1.text()
Name2 = self.Name2.text()
req = [Name1, Name2]
for item in data:
if item['participants'] == req:
for conv in item['conversation']:
if conv['sender'] == Name1:
countmsgsname1 += 1
elif conv['sender'] == Name2:
countmsgsname2 += 1
return countmsgsname1, countmsgsname2
def wordcount(self):
with open(self.path, encoding="utf8") as f:
data = json.load(f)
totalwordcount = 0
wordcount1 = 0
wordcount2 = 0
Name1 = self.Name1.text()
Name2 = self.Name2.text()
req = [Name1, Name2]
for item in data:
if item['participants'] == req:
for conv in item['conversation']:
if 'text' in conv.keys():
search = conv['text']
if search == None:
continue
wc = len(search.split())
totalwordcount += wc
if conv['sender'] == Name1:
wordcount1 += wc
elif conv['sender'] == Name2:
wordcount2 += wc
return wordcount1, wordcount2, totalwordcount
def errorboi(self):
self.msgbox = QMessageBox()
self.msgbox.setText(
"Error, The given username doesnt exist, Check it and try again")
self.msgbox.exec()
def addmpl2(self, fig):
self.canvas2 = FigureCanvas(fig)
self.mplvl2.addWidget(self.canvas2)
self.canvas2.draw()
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self):
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
def rmmpl2(self):
self.mplvl.removeWidget(self.canvas2)
self.canvas2.close()
def check(self):
with open(self.path, encoding="utf8") as f:
data = json.load(f)
Name1 = self.Name1.text()
Name2 = self.Name2.text()
req = [Name1, Name2]
lists = []
returnval = ""
for item in data:
if item['participants'] == req:
lists.append("yes")
if len(lists) != 0:
returnval = True
else:
returnval = False
return returnval
def gen_search_clicked(self):
Name1 = self.Name1.text()
Name2 = self.Name2.text()
if self.check():
countmsgsname1, countmsgsname2 = self.count_messages()
totalcountmsgs = countmsgsname1 + countmsgsname2
self.disp_msgs_total.setText(str(totalcountmsgs))
wordcount1, wordcount2, totalwordcount = self.wordcount()
self.disp_words_total.setText(str(totalwordcount))
emptystring = ""
numberofletters1, numberofletters2 = self.Search_String(
emptystring)
self.disp_chars_total.setText(
str(numberofletters1 + numberofletters2))
self.disp_avgwords.setText(str(totalwordcount / totalcountmsgs))
self.disp_avgchars.setText(
str((numberofletters1 + numberofletters2) / totalcountmsgs))
global timesrun
if timesrun > 0:
ui.rmmpl()
# TOTAL MESSAGES
fig1 = Figure()
onef1 = fig1.add_subplot(131)
fig1.set_facecolor('#172144')
labels = [Name1, Name2]
sizes1 = [countmsgsname1, countmsgsname2]
onef1.set_title("Number of Messages", color='white', fontsize='13')
patches, texts, autotexts = onef1.pie(sizes1,
labels=labels,
autopct='%1.1f%%',
colors=('#25a1ff',
'#0eebff'),
explode=(0.05, 0))
for text in texts:
text.set_color('#ff8419')
for autotext in autotexts:
autotext.set_color('black')
# TOTAL WORDS
twof1 = fig1.add_subplot(132)
sizes2 = [wordcount1, wordcount2]
twof1.set_title("Number of Words", color='white', fontsize='13')
patches2, texts2, autotexts2 = twof1.pie(sizes2,
labels=labels,
autopct='%1.1f%%',
colors=('#25a1ff',
'#0eebff'),
explode=(0.05, 0))
for text in texts2:
text.set_color('#ff8419')
for autotext in autotexts2:
autotext.set_color('black')
# TOTAL CHARACTERS
threef1 = fig1.add_subplot(133)
sizes3 = [numberofletters1, numberofletters2]
threef1.set_title("Number of Characters",
color='white',
fontsize='13')
patches3, texts3, autotexts3 = threef1.pie(sizes3,
labels=labels,
autopct='%1.1f%%',
colors=('#25a1ff',
'#0eebff'),
explode=(0.05, 0))
for text in texts3:
text.set_color('#ff8419')
for autotext in autotexts3:
autotext.set_color('black')
timesrun += 1
ui.addmpl(fig1)
else:
self.errorboi()
def search_clicked(self):
Name1 = self.Name1.text()
Name2 = self.Name2.text()
Inputword = self.Inputword.text()
req = [Name1, Name2]
numberofwords1, numberofwords2 = self.Search_String(Inputword)
self.display1.setText(Name1 + " said " + Inputword + " " +
str(numberofwords1) + " times")
self.display2.setText(Name2 + " said " + Inputword + " " +
str(numberofwords2) + " times")
global timesrun2
if timesrun2 > 0:
ui.rmmpl2()
fig2 = Figure()
onef2 = fig2.add_subplot(111)
labels = [Name1, Name2]
height = [numberofwords1, numberofwords2]
fig2.set_facecolor('#172144')
onef2.set_facecolor('#172144')
onef2.spines['bottom'].set_color('white')
onef2.spines['left'].set_color('white')
onef2.spines['top'].set_color('#172144')
onef2.spines['right'].set_color('#172144')
onef2.xaxis.label.set_color('white')
onef2.yaxis.label.set_color('white')
onef2.tick_params(axis='x', colors='white')
onef2.tick_params(axis='y', colors='white')
onef2.bar(labels,
height,
width=0.4,
align='center',
color=('#25a1ff', '#0eebff'))
ui.addmpl2(fig2)
timesrun2 += 1
def Nextpage_button_clicked(self):
self.stackedWidget.setCurrentWidget(self.homepage)
def Browse_button_clicked(self):
filter = "json Files (*.json)"
fileName = QFileDialog.getOpenFileName(None, 'Search image Path',
os.getcwd(), filter)
self.path = fileName[0]
self.file_path.setText(self.path)
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1578, 964)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
MainWindow.sizePolicy().hasHeightForWidth())
MainWindow.setSizePolicy(sizePolicy)
MainWindow.setStyleSheet("background-color: rgb(16, 23, 39)")
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.stackedWidget = QtWidgets.QStackedWidget(self.centralwidget)
self.stackedWidget.setGeometry(QtCore.QRect(-10, -50, 1602, 1031))
self.stackedWidget.setStyleSheet("")
self.stackedWidget.setObjectName("stackedWidget")
self.homepage = QtWidgets.QWidget()
self.homepage.setObjectName("homepage")
self.label_2 = QtWidgets.QLabel(self.homepage)
self.label_2.setGeometry(QtCore.QRect(30, 370, 151, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_2.setFont(font)
self.label_2.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68);")
self.label_2.setObjectName("label_2")
self.disp_avgchars = QtWidgets.QLabel(self.homepage)
self.disp_avgchars.setGeometry(QtCore.QRect(250, 640, 181, 31))
font = QtGui.QFont()
font.setFamily("Lucida Sans")
font.setPointSize(15)
font.setBold(False)
font.setItalic(False)
font.setWeight(50)
self.disp_avgchars.setFont(font)
self.disp_avgchars.setStyleSheet("color: rgb(248, 29, 244);\n"
"background-color: rgb(23, 33, 68);")
self.disp_avgchars.setText("")
self.disp_avgchars.setObjectName("disp_avgchars")
self.disp_words_total = QtWidgets.QLabel(self.homepage)
self.disp_words_total.setGeometry(QtCore.QRect(130, 400, 181, 31))
font = QtGui.QFont()
font.setFamily("Lucida Sans")
font.setPointSize(15)
font.setBold(False)
font.setItalic(False)
font.setWeight(50)
self.disp_words_total.setFont(font)
self.disp_words_total.setStyleSheet(
"color: rgb(248, 29, 244);\n"
"background-color: rgb(23, 33, 68);")
self.disp_words_total.setText("")
self.disp_words_total.setObjectName("disp_words_total")
self.label_12 = QtWidgets.QLabel(self.homepage)
self.label_12.setGeometry(QtCore.QRect(30, 730, 161, 21))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_12.setFont(font)
self.label_12.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68);")
self.label_12.setObjectName("label_12")
self.layoutWidget = QtWidgets.QWidget(self.homepage)
self.layoutWidget.setGeometry(QtCore.QRect(20, 850, 1081, 160))
self.layoutWidget.setObjectName("layoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.layoutWidget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setObjectName("verticalLayout")
self.display1 = QtWidgets.QLabel(self.layoutWidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.display1.sizePolicy().hasHeightForWidth())
self.display1.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(32)
font.setBold(True)
font.setWeight(75)
self.display1.setFont(font)
self.display1.setStyleSheet("color: rgb(37, 161, 255);\n" "")
self.display1.setLineWidth(1)
self.display1.setText("")
self.display1.setScaledContents(False)
self.display1.setObjectName("display1")
self.verticalLayout.addWidget(self.display1)
self.display2 = QtWidgets.QLabel(self.layoutWidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.display2.sizePolicy().hasHeightForWidth())
self.display2.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(32)
font.setBold(True)
font.setWeight(75)
self.display2.setFont(font)
self.display2.setStyleSheet("color : rgb(14, 235, 255);\n" "")
self.display2.setText("")
self.display2.setObjectName("display2")
self.verticalLayout.addWidget(self.display2)
self.label_4 = QtWidgets.QLabel(self.homepage)
self.label_4.setGeometry(QtCore.QRect(30, 530, 291, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_4.setFont(font)
self.label_4.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68);")
self.label_4.setObjectName("label_4")
self.Search = QtWidgets.QPushButton(self.homepage)
self.Search.setGeometry(QtCore.QRect(190, 780, 81, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.Search.setFont(font)
self.Search.setStyleSheet("background-color: rgb(248, 29, 244);\n"
"color: rgb(255, 255, 255);")
self.Search.setObjectName("Search")
self.mplwindow2 = QtWidgets.QWidget(self.homepage)
self.mplwindow2.setGeometry(QtCore.QRect(1120, 560, 381, 441))
self.mplwindow2.setObjectName("mplwindow2")
self.mplvl2 = QtWidgets.QVBoxLayout(self.mplwindow2)
self.mplvl2.setContentsMargins(0, 0, 0, 0)
self.mplvl2.setObjectName("mplvl2")
self.label_6 = QtWidgets.QLabel(self.mplwindow2)
self.label_6.setText("")
self.label_6.setObjectName("label_6")
self.mplvl2.addWidget(self.label_6)
self.label_5 = QtWidgets.QLabel(self.homepage)
self.label_5.setGeometry(QtCore.QRect(30, 610, 341, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_5.setFont(font)
self.label_5.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68);")
self.label_5.setObjectName("label_5")
self.Inputword = QtWidgets.QLineEdit(self.homepage)
self.Inputword.setGeometry(QtCore.QRect(190, 730, 261, 24))
font = QtGui.QFont()
font.setPointSize(12)
self.Inputword.setFont(font)
self.Inputword.setStyleSheet("color: rgb(255, 132, 25);\n"
"background-color: rgb(23, 33, 68);\n"
"border-radius: 20px\n"
"")
self.Inputword.setText("")
self.Inputword.setFrame(False)
self.Inputword.setObjectName("Inputword")
self.label_11 = QtWidgets.QLabel(self.homepage)
self.label_11.setGeometry(QtCore.QRect(20, 280, 441, 411))
self.label_11.setStyleSheet("background-color: rgb(23, 33, 68);\n"
"border-radius: 20px")
self.label_11.setFrameShape(QtWidgets.QFrame.NoFrame)
self.label_11.setFrameShadow(QtWidgets.QFrame.Plain)
self.label_11.setText("")
self.label_11.setObjectName("label_11")
self.label_7 = QtWidgets.QLabel(self.homepage)
self.label_7.setGeometry(QtCore.QRect(30, 50, 1531, 71))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(50)
font.setBold(True)
font.setWeight(75)
self.label_7.setFont(font)
self.label_7.setStyleSheet("color: rgb(234, 187, 13);")
self.label_7.setAlignment(QtCore.Qt.AlignCenter)
self.label_7.setObjectName("label_7")
self.label_3 = QtWidgets.QLabel(self.homepage)
self.label_3.setGeometry(QtCore.QRect(30, 450, 171, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_3.setFont(font)
self.label_3.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color : rgb(23, 33, 68)")
self.label_3.setObjectName("label_3")
self.disp_avgwords = QtWidgets.QLabel(self.homepage)
self.disp_avgwords.setGeometry(QtCore.QRect(250, 560, 181, 31))
font = QtGui.QFont()
font.setFamily("Lucida Sans")
font.setPointSize(15)
font.setBold(False)
font.setItalic(False)
font.setWeight(50)
self.disp_avgwords.setFont(font)
self.disp_avgwords.setStyleSheet("color: rgb(248, 29, 244);\n"
"background-color: rgb(23, 33, 68);")
self.disp_avgwords.setText("")
self.disp_avgwords.setObjectName("disp_avgwords")
self.label_13 = QtWidgets.QLabel(self.homepage)
self.label_13.setGeometry(QtCore.QRect(20, 720, 441, 111))
self.label_13.setStyleSheet("background-color: rgb(23, 33, 68);\n"
"border-radius: 20px")
self.label_13.setText("")
self.label_13.setObjectName("label_13")
self.disp_msgs_total = QtWidgets.QLabel(self.homepage)
self.disp_msgs_total.setGeometry(QtCore.QRect(130, 320, 181, 31))
font = QtGui.QFont()
font.setFamily("Lucida Sans")
font.setPointSize(15)
font.setBold(False)
font.setItalic(False)
font.setWeight(50)
self.disp_msgs_total.setFont(font)
self.disp_msgs_total.setStyleSheet(
"color: rgb(248, 29, 244);\n"
"background-color: rgb(23, 33, 68);")
self.disp_msgs_total.setText("")
self.disp_msgs_total.setObjectName("disp_msgs_total")
self.layoutWidget1 = QtWidgets.QWidget(self.homepage)
self.layoutWidget1.setGeometry(QtCore.QRect(20, 140, 671, 128))
self.layoutWidget1.setObjectName("layoutWidget1")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.layoutWidget1)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.Name1 = QtWidgets.QLineEdit(self.layoutWidget1)
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(22)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.Name1.setFont(font)
self.Name1.setAccessibleName("")
self.Name1.setAutoFillBackground(False)
self.Name1.setStyleSheet("background-color: rgb(16, 23, 39);\n"
"color: rgb(255, 132, 25);")
self.Name1.setInputMask("")
self.Name1.setText("")
self.Name1.setFrame(False)
self.Name1.setAlignment(QtCore.Qt.AlignLeading | QtCore.Qt.AlignLeft
| QtCore.Qt.AlignVCenter)
self.Name1.setObjectName("Name1")
self.verticalLayout_2.addWidget(self.Name1)
self.Name2 = QtWidgets.QLineEdit(self.layoutWidget1)
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(22)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.Name2.setFont(font)
self.Name2.setMouseTracking(True)
self.Name2.setStyleSheet("background-color: rgb(16, 23, 39);\n"
"color: rgb(255, 132, 25);")
self.Name2.setFrame(False)
self.Name2.setAlignment(QtCore.Qt.AlignLeading | QtCore.Qt.AlignLeft
| QtCore.Qt.AlignVCenter)
self.Name2.setObjectName("Name2")
self.verticalLayout_2.addWidget(self.Name2)
self.Name2.raise_()
self.Name1.raise_()
self.label = QtWidgets.QLabel(self.homepage)
self.label.setGeometry(QtCore.QRect(30, 290, 151, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label.setFont(font)
self.label.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68);")
self.label.setObjectName("label")
self.mplwindow = QtWidgets.QWidget(self.homepage)
self.mplwindow.setGeometry(QtCore.QRect(490, 280, 1071, 241))
self.mplwindow.setStyleSheet("border-radius: 20px")
self.mplwindow.setObjectName("mplwindow")
self.mplvl = QtWidgets.QVBoxLayout(self.mplwindow)
self.mplvl.setContentsMargins(0, 0, 0, 0)
self.mplvl.setObjectName("mplvl")
self.disp_chars_total = QtWidgets.QLabel(self.homepage)
self.disp_chars_total.setGeometry(QtCore.QRect(130, 480, 181, 31))
font = QtGui.QFont()
font.setFamily("Lucida Sans")
font.setPointSize(15)
font.setBold(False)
font.setItalic(False)
font.setWeight(50)
self.disp_chars_total.setFont(font)
self.disp_chars_total.setStyleSheet(
"color: rgb(248, 29, 244);\n"
"background-color: rgb(23, 33, 68);")
self.disp_chars_total.setText("")
self.disp_chars_total.setObjectName("disp_chars_total")
self.gen_search = QtWidgets.QPushButton(self.homepage)
self.gen_search.setGeometry(QtCore.QRect(710, 190, 81, 31))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.gen_search.setFont(font)
self.gen_search.setStatusTip("")
self.gen_search.setStyleSheet("background-color: rgb(248, 29, 244);\n"
"color: rgb(255, 255, 255);")
self.gen_search.setIconSize(QtCore.QSize(120, 60))
self.gen_search.setFlat(False)
self.gen_search.setObjectName("gen_search")
self.label_13.raise_()
self.label_11.raise_()
self.label_2.raise_()
self.disp_avgchars.raise_()
self.disp_words_total.raise_()
self.label_12.raise_()
self.layoutWidget.raise_()
self.label_4.raise_()
self.Search.raise_()
self.mplwindow2.raise_()
self.label_5.raise_()
self.Inputword.raise_()
self.label_7.raise_()
self.label_3.raise_()
self.disp_avgwords.raise_()
self.disp_msgs_total.raise_()
self.layoutWidget.raise_()
self.label.raise_()
self.disp_chars_total.raise_()
self.gen_search.raise_()
self.mplwindow.raise_()
self.stackedWidget.addWidget(self.homepage)
self.pathpage = QtWidgets.QWidget()
self.pathpage.setObjectName("pathpage")
self.label_9 = QtWidgets.QLabel(self.pathpage)
self.label_9.setGeometry(QtCore.QRect(360, 820, 901, 61))
self.label_9.setStyleSheet("background-color: rgb(23, 33, 68);\n"
"border-radius: 20px")
self.label_9.setText("")
self.label_9.setObjectName("label_9")
self.Nextpage = QtWidgets.QPushButton(self.pathpage)
self.Nextpage.setGeometry(QtCore.QRect(750, 930, 121, 41))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.Nextpage.setFont(font)
self.Nextpage.setStyleSheet("background-color: rgb(248, 29, 244);\n"
"color: rgb(255, 255, 255);")
self.Nextpage.setObjectName("Nextpage")
self.label_10 = QtWidgets.QLabel(self.pathpage)
self.label_10.setGeometry(QtCore.QRect(240, 70, 1091, 111))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(40)
font.setBold(True)
font.setWeight(75)
self.label_10.setFont(font)
self.label_10.setStyleSheet("color: rgb(234, 187, 13);")
self.label_10.setObjectName("label_10")
self.label_14 = QtWidgets.QLabel(self.pathpage)
self.label_14.setGeometry(QtCore.QRect(690, 230, 871, 561))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_14.setFont(font)
self.label_14.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68);\n"
"border-radius: 20px")
self.label_14.setTextFormat(QtCore.Qt.RichText)
self.label_14.setObjectName("label_14")
self.label_15 = QtWidgets.QLabel(self.pathpage)
self.label_15.setGeometry(QtCore.QRect(30, 230, 631, 351))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(14)
self.label_15.setFont(font)
self.label_15.setStyleSheet("background-color: rgb(23, 33, 68);\n"
"color: rgb(255, 255, 255);\n"
"border-radius : 20px\n"
"")
self.label_15.setTextFormat(QtCore.Qt.RichText)
self.label_15.setObjectName("label_15")
self.label_17 = QtWidgets.QLabel(self.pathpage)
self.label_17.setGeometry(QtCore.QRect(1230, 190, 251, 20))
font = QtGui.QFont()
font.setFamily("Lucida Console")
font.setPointSize(9)
self.label_17.setFont(font)
self.label_17.setStyleSheet("color: rgb(255, 255, 255);")
self.label_17.setObjectName("label_17")
self.label_16 = QtWidgets.QLabel(self.pathpage)
self.label_16.setGeometry(QtCore.QRect(1330, 150, 55, 16))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(10)
self.label_16.setFont(font)
self.label_16.setStyleSheet("color: rgb(234, 187, 13);")
self.label_16.setObjectName("label_16")
self.label_8 = QtWidgets.QLabel(self.pathpage)
self.label_8.setGeometry(QtCore.QRect(370, 830, 111, 41))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.label_8.sizePolicy().hasHeightForWidth())
self.label_8.setSizePolicy(sizePolicy)
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.label_8.setFont(font)
self.label_8.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68)")
self.label_8.setObjectName("label_8")
self.file_path = QtWidgets.QLineEdit(self.pathpage)
self.file_path.setGeometry(QtCore.QRect(495, 830, 641, 31))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.file_path.sizePolicy().hasHeightForWidth())
self.file_path.setSizePolicy(sizePolicy)
self.file_path.setStyleSheet("color: rgb(255, 255, 255);\n"
"background-color: rgb(23, 33, 68)")
self.file_path.setFrame(False)
self.file_path.setObjectName("file_path")
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.file_path.setFont(font)
self.Browse_button = QtWidgets.QPushButton(self.pathpage)
self.Browse_button.setGeometry(QtCore.QRect(1150, 830, 101, 41))
font = QtGui.QFont()
font.setFamily("Century Gothic")
font.setPointSize(12)
self.Browse_button.setFont(font)
self.Browse_button.setStyleSheet(
"background-color: rgb(248, 29, 244);\n"
"color: rgb(255, 255, 255);")
self.Browse_button.setObjectName("Browse_button")
self.label_9.raise_()
self.Nextpage.raise_()
self.label_10.raise_()
self.label_14.raise_()
self.label_15.raise_()
self.label_17.raise_()
self.label_16.raise_()
self.label_8.raise_()
self.file_path.raise_()
self.Browse_button.raise_()
self.stackedWidget.addWidget(self.pathpage)
MainWindow.setCentralWidget(self.centralwidget)
#
self.stackedWidget.setCurrentWidget(self.pathpage)
self.Nextpage.clicked.connect(self.Nextpage_button_clicked)
self.Browse_button.clicked.connect(self.Browse_button_clicked)
self.Search.clicked.connect(self.search_clicked)
self.gen_search.clicked.connect(self.gen_search_clicked)
#
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(
_translate("MainWindow", "InstaChat Analyser--beta"))
self.label_2.setText(_translate("MainWindow", "Words Total"))
self.label_12.setText(_translate("MainWindow", "Custom Search:"))
self.label_4.setText(
_translate("MainWindow", "Average words per message"))
self.Search.setText(_translate("MainWindow", "Find!"))
self.label_5.setText(
_translate("MainWindow", "Average Characters per message"))
self.Inputword.setPlaceholderText(
_translate("MainWindow", "Enter Word here"))
self.label_7.setText(_translate("MainWindow", "Your Insta Banter"))
self.label_3.setText(_translate("MainWindow", "Characters Total"))
self.Name1.setToolTip(_translate("MainWindow", "Enter name here:"))
self.Name1.setPlaceholderText(
_translate("MainWindow", "Enter your insta username here:"))
self.Name2.setPlaceholderText(
_translate("MainWindow", "Enter the other person\'s username:"******"MainWindow", "Messages Total"))
self.gen_search.setToolTip(_translate("MainWindow",
"click to proceed"))
self.gen_search.setText(_translate("MainWindow", "GO!"))
self.Nextpage.setText(_translate("MainWindow", "Next >>"))
self.label_10.setText(
_translate("MainWindow", "Instagram Conversation Analyser"))
self.label_14.setText(
_translate(
"MainWindow",
"<html><head/><body><p>Following are the steps to get "
"started:</p><p>1) Download the Data:</p><p>On the instagam "
"app, go to Settings >> Security >> Download "
"Data.</p><p>Enter your email address and request download. "
"You will receive</p><p>the link to download the data on "
"</p><p>your email within 48 hours. (Generally it takes less "
"than 20 mins)</p><p><br/>2) Once u get the link, download the "
"<span style=\" color:#eabb0d;\">"Part 1"</span> "
"data.</p><p><br/>3) Unzip the data :</p><p>Do this using any "
"Unzipping tool like RAR, 7zip, WinZip etc.<br/></p><p>4) "
"Voila! </p><p>You will get a file named <span style=\" "
"color:#eabb0d;\">"messages"</span> with a .json "
"extension. </p><p>Now select that file through the Browse "
"Button and Click Next to proceed.</p></body></html>"))
self.label_15.setText(
_translate(
"MainWindow",
"<html><head/><body><p>Hi there!</p><p>This is the Instagram "
"Conversation Analyser, </p><p>You can visualise your "
"conversation with</p><p>someone in terms of ratio of "
"messages, words</p><p>and more.<br/></p><p>You can search how "
"many emotes you used and </p><p>visualise it with a graph as "
"well!</p></body></html>"))
self.label_17.setText(
_translate("MainWindow", "Developed by: Soham Kulkarni"))
self.label_16.setText(_translate("MainWindow", "beta"))
self.label_8.setText(_translate("MainWindow", "Select File :"))
self.Browse_button.setText(_translate("MainWindow", "Browse"))
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, 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 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 Main(QMainWindow, Ui_MainWindow):
def __init__(self, ):
######################### Get database info #########################
self.engine = '' # engine variable stores database information
self.wedit = db.DBInfo(self)
self.wedit.exec_()
self.plot2D = True
self.Echeck = True
self.Eplot = True
self.Ccheck = True
self.Cplot = True
self.plotall = False
super(Main, self).__init__()
self.setupUi(self)
# TODO: make queries for max year and min year
self.year = get_minyear(self.engine)
self.slyear.setMaximum(get_maxyear(self.engine))
self.slyear.setMinimum(self.year)
######################### Initialize text for selected year #########################
self.txtyear.setText(str(self.slyear.value()))
######################### Program events #########################
self.slyear.valueChanged.connect(self.updTxt)
self.slyear.sliderReleased.connect(self.updFig)
self.txtyear.returnPressed.connect(self.updSl)
self.actionDatabase_info.triggered.connect(self.edit)
self.btnglobe.clicked.connect(self.globebutton)
self.chkconflicts.stateChanged.connect(self.conflictCheck)
self.chkeclipses.stateChanged.connect(self.eclipseCheck)
self.actionGenerate_Globe.triggered.connect(self.globemovie)
self.actionPlot_all.triggered.connect(self.plot_all_datapoints)
fig = plotmap()
self.addmpl(fig)
self.chkconflicts.toggle()
self.chkeclipses.toggle()
######################### Plot all data #########################
def plot_all_datapoints(self):
self.plotall = True
self.updFig()
######################### Map button #########################
def globebutton(self):
if self.plot2D:
self.plot2D = False
self.btnglobe.setText('Map view')
self.slyear.setMaximum(0)
self.slyear.setMaximum(360)
self.updFig()
else:
self.plot2D = True
self.btnglobe.setText('Globe view')
self.year = get_minyear(self.engine)
self.slyear.setMaximum(get_maxyear(self.engine))
self.slyear.setMinimum(self.year)
self.updFig()
######################### Checkbox features #########################
def conflictCheck(self):
if self.Ccheck:
self.Cplot = True
self.Ccheck = False
self.updFig()
else:
self.Cplot = False
self.Ccheck = True
self.updFig()
def eclipseCheck(self):
if self.Echeck:
self.Eplot = True
self.Echeck = False
self.updFig()
else:
self.Eplot = False
self.Echeck = True
self.updFig()
######################### Edit textbox and slider #########################
def updTxt(self):
if self.plot2D:
self.plotall = False
self.txtyear.setText(str(self.slyear.value()))
def updSl(self):
if self.plot2D:
self.plotall = False
self.slyear.setValue(int(self.txtyear.text()))
self.updFig()
######################### Update figure #########################
def updFig(self):
try:
self.rmmpl()
except:
pass
failed = False
self.updYear()
try:
fig1 = get_conflicts(self.engine, self.year, self.Eplot,
self.Cplot, self.plot2D, self.plotall,
int(self.txtyear.text()))
self.addmpl(fig1)
except Exception as e:
print(e)
info = "Could not connect to database. Are you sure you're connected to one?"
failed = True
pass
if failed:
QtGui.QMessageBox.information(self, 'Error', info)
else:
self.updConflist()
self.updExplist()
def updYear(self):
if self.plot2D:
self.year = int(self.txtyear.text())
######################### Check if event is clicked #########################
def onpick(self, event):
ind = event.ind
artist = event.artist
xdata = artist.get_xdata()
ydata = artist.get_ydata()
if ind[0] in range(len(xdata)):
self.updTxtinfo(ind, artist)
return ind[0]
def updTxtinfo(self, ind, artist):
lat = artist.get_ydata()[ind[0]]
lon = artist.get_xdata()[ind[0]]
year = int(self.txtyear.text())
conflict = True
try:
self.txtconfinfo.setText(get_confinfo(self.engine, lat, lon, year))
except:
conflict = False
if not conflict:
try:
self.txteclipse.setText(
get_eclipseinfo(self.engine, lat, lon, year))
except:
pass
######################### Create a movie #########################
def globemovie(self):
makethevideo(self.engine, int(self.txtyear.text()), self.Eplot,
self.Cplot, self.plotall)
def updConflist(self):
self.txtconflist.setText(
get_conflist(self.engine, int(self.txtyear.text())))
def updExplist(self):
self.txtexport.setText(
get_exportlist(self.engine, int(self.txtyear.text())))
######################### Create Database #########################
def edit(self):
self.wedit = db.DBInfo(self)
self.wedit.show()
######################### Create figure #########################
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.canvas.mpl_connect('pick_event', self.onpick)
self.mplvlayout.addWidget(self.canvas)
self.canvas.draw()
######################### Remove figure #########################
def rmmpl(self, ):
self.mplvlayout.removeWidget(self.canvas)
self.canvas.close()
self.mplvlayout.removeWidget(self.toolbar)
self.toolbar.close()
class ContourPlot(QtWidgets.QMainWindow, Ui_MainWindow, QtWidgets.QFileDialog,
QtWidgets.QMessageBox, QtWidgets.QInputDialog):
def __init__(self):
super(ContourPlot, self).__init__()
# super().__init__()
self.setupUi(self)
# self.thread=QThread()
self.loop1 = ''
self.saving_dir = r''
self.newdirect = ''
self.newname = ''
self.newtitle = 'x y1 y2 y3 y4'
self.file_list = []
self.directory = ''
self.File = []
self.basename = ''
self.dlist = []
self.header = []
self.dlength = 0
self.dwidth = 0
self.xdata = []
self.ydata = []
self.zdata = []
self.get_matrix_data()
# self.Clr.clicked.connect(self.get_matrix_data)
self.startPlot.clicked.connect(self.update)
self.OpenFile.clicked.connect(self.open_file)
self.cm = plt.colormaps()
self.Cmap.addItems(self.cm)
# self.baseName.textChanged.connect(self.get_matrix_data)
# self.Xlist.textChanged.connect(self.get_matrix_data)
self.yGain.returnPressed.connect(self.update_graph)
self.zGain.returnPressed.connect(self.update_graph)
self.Ycol.valueChanged.connect(self.update_graph)
self.Zcol.valueChanged.connect(self.update_graph)
self.skipRow.returnPressed.connect(self.update)
self.skipFoot.returnPressed.connect(self.update)
self.Xlabel.returnPressed.connect(self.update_graph)
self.Ylabel.returnPressed.connect(self.update_graph)
self.Zlabel.returnPressed.connect(self.update_graph)
self.Cmap.currentTextChanged.connect(self.update_graph)
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111)
self.fig.tight_layout()
self.canvas = FigureCanvas(self.fig)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,
self.plot_window,
coordinates=True)
self.mpl.addWidget(self.toolbar)
self.mpl.addWidget(self.canvas)
self.tabWidget.currentChanged.connect(self.change_tab)
################################################################################
self.OpenFile_2.clicked.connect(self.load_files)
self.file_dic = {}
self.Clr2.clicked.connect(self.FileList.clear)
self.startPlot_2.clicked.connect(self.lineplot)
self.FileList.itemDoubleClicked.connect(self.remove_item)
self.Xlist_2.returnPressed.connect(self.lineplot)
self.yGain_2.returnPressed.connect(self.lineplot)
self.zGain_2.returnPressed.connect(self.lineplot)
self.Ycol_2.valueChanged.connect(self.lineplot)
self.Zcol_2.valueChanged.connect(self.lineplot)
self.skipRow_2.returnPressed.connect(self.lineplot)
self.skipFoot_2.returnPressed.connect(self.lineplot)
self.Xlabel_2.returnPressed.connect(self.lineplot)
self.Ylabel_2.returnPressed.connect(self.lineplot)
# self.
######################################for contour
def open_file(self):
f = self.getOpenFileName()[0]
if os.path.exists(f):
self.baseName.setText(f)
df = pd.read_csv(f, sep=' ', header=0, index_col=False)
self.shape = df.shape
# print(df.shape)
self.dlength = df.shape[0]
self.dwidth = df.shape[1]
self.Ycol.setMaximum(int((self.shape[1]) - 1))
self.Zcol.setMaximum(int((self.shape[1]) - 1))
def get_dllist(self):
code = 'global dlist;dlist={}'.format(self.Xlist.text())
print(code)
exec(code)
global dlist
print(dlist)
return dlist
def get_file(self, basename, dlist):
basename = str(basename)
self.File = []
for i in dlist:
f = basename.format(i)
if f != basename and os.path.exists(f):
self.File.append(f)
return self.File
def rmmpl(self):
self.mpl.removeWidget(self.canvas)
self.mpl.removeWidget(self.toolbar)
self.canvas.close()
def admpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mpl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True)
# self.extend_toolbar()
self.mpl.addWidget(self.toolbar)
self.mpl.addWidget(self.canvas)
def newfig(self):
fignew = plt.figure()
return fignew
def get_header(self):
df = pd.read_csv(self.File[0],
sep=' ',
header=0,
index_col=False,
skiprows=int(self.skipRow.text()))
return list(df.columns)
def get_matrix_data(self):
# fulld=[]
self.dlength_new = self.dlength - int(self.skipRow.text())
self.ydata = []
self.zdata = []
basename = self.baseName.toPlainText()
# dlist_para=self.Xlist.text().split(',')
dlist = self.get_dllist()
File = self.get_file(basename, dlist)
# if len(File)!=oldFile:
for j in range(int(self.dwidth)):
try:
self.x = np.zeros((len(File), int(self.dlength_new)))
self.y = np.zeros((len(File), int(self.dlength_new)))
self.z = np.zeros((len(File), int(self.dlength_new)))
for i in range(len(File)):
df = pd.read_csv(File[i],
sep=' ',
header=0,
index_col=False,
skiprows=int(self.skipRow.text()))
I = df.values[:, j]
V = df.values[:, j]
self.x[i] = (np.repeat(dlist[i], len(I)))
self.y[i] = I
self.z[i] = V
except Exception as error:
print(error)
self.x = np.zeros((1, 1))
self.y = np.zeros((1, 1))
self.z = np.zeros((1, 1))
self.ydata.append(self.y)
self.zdata.append(self.z)
def pcolormesh(self):
try:
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111)
self.ax.clear()
self.rmmpl()
self.admpl(self.fig)
try:
# skiprow=int(self.skipRow.text())
# skipfoot=int(self.skipFoot.text())
ygain = float(self.yGain.text())
zgain = float(self.zGain.text())
cols = (int(self.Ycol.value()), int(self.Zcol.value()))
self.x1 = self.x
self.y1 = self.ydata[cols[0]] * ygain
self.z1 = self.zdata[cols[1]] * zgain
except Exception as error:
print(error)
self.x1 = self.x
self.y1 = self.y
self.z1 = self.z
# cm=cont.get_cmap()
cont = self.ax.pcolormesh(self.x1,
self.y1,
self.z1,
cmap=self.Cmap.currentText())
# plt.colorbar(cont,label='').remove()
plt.colorbar(cont, fraction=0.05, label=self.Zlabel.text())
self.ax.set_xlabel(self.Xlabel.text())
self.ax.set_ylabel(self.Ylabel.text())
self.canvas.draw()
self.fig.tight_layout()
except Exception as error:
print(error)
def update(self):
self.get_matrix_data()
self.pcolormesh()
def continuous_update(self):
if self.Cont.isChecked():
try:
self.get_matrix_data()
self.pcolormesh()
except:
pass
def update_graph(self):
self.pcolormesh()
################################################for lineplots
def load_files(self):
f = self.getOpenFileNames()[0]
print(f)
for i in range(len(f)):
print(f[i])
indx = os.path.split(f[i])[1]
self.FileList.addItem(str(indx))
self.file_dic[indx] = f[i]
def get_color(self):
num = int(self.FileList.count())
print(num)
if num % 2 == 0:
return num
else:
return num + 1
def lineplot(self):
colord = self.get_color()
colorlist = plt.cm.RdBu_r(np.linspace(0, 1, colord))
leg = self.leglist()
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111)
self.ax.clear()
self.rmmpl()
self.admpl(self.fig)
try:
skiprow = int(self.skipRow_2.text())
skipfoot = int(self.skipFoot_2.text())
ygain = float(self.yGain_2.text())
zgain = float(self.zGain_2.text())
cols = (int(self.Ycol_2.value()), int(self.Zcol_2.value()))
for i in range(self.FileList.count()):
df = pd.read_csv(self.file_dic[self.FileList.item(i).text()],
sep=' ',
header=0,
index_col=False,
skiprows=skiprow,
skipfooter=skipfoot)
I = df.values[:, cols[0]] * ygain
V = df.values[:, cols[1]] * zgain
self.ax.plot(I, V, color=colorlist[i], label=leg[i])
self.ax.set_xlabel(self.Xlabel_2.text())
self.ax.set_ylabel(self.Ylabel_2.text())
self.ax.tick_params(direction='in',
length=6,
width=1,
colors='k',
grid_color='r',
grid_alpha=0.5)
self.ax.legend(fontsize=15, ncol=1).set_draggable(True)
self.canvas.draw()
self.fig.tight_layout()
except Exception as error:
print(error)
# def get_labels(self):
# l=self.Xlist_2.text()
# l='global labels;labels={}'.format(self.Xlist_2.text())
def remove_item(self):
self.FileList.takeItem(self.FileList.currentRow())
self.lineplot()
def change_tab(self):
indx = self.tabWidget.currentIndex()
if indx == 0:
self.pcolormesh()
elif indx == 1:
self.lineplot()
def leglist(self):
code = 'global dlist;dlist={}'.format(self.Xlist_2.text())
print(code)
exec(code)
global dlist
print(dlist)
return dlist
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 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 FieldStatsDialog(QtGui.QDialog, FORM_CLASS):
SETTINGS_ROOT = 'fieldstats/'
SETTINGS_LAYER = 'layer'
SETTINGS_FIELD = 'field'
SETTINGS_NUM_DECIMALS = 'num_decimals'
SETTINGS_PERCENTILES = 'percentiles'
SETTINGS_CREATE_UNIQUE = 'create_unique'
SETTINGS_SELECTED_ONLY = 'selected_only'
SETTINGS_GRAPH_TYPE = 'graph_type'
SETTINGS_GRAPH_SORT = 'graph_sort'
SETTINGS_GRAPH_SCALE = 'graph_scale'
SETTINGS_GRAPH_COLOR = 'graph_color'
SETTING_ANTILOG_LABELS = 'antilog_labels'
MAX_PIE_SLICES = 5
NO_GRAPH_EMPTY_FIELD = 0
NO_GRAPH_UNIQUE_LIST_NOT_CHECKED = 1
TRANSFORM_NONE = 0
TRANSFORM_LOG10 = 1
def __init__(self, parent=None):
#---------------------------------------------------------------------------
"""
Constructor.
"""
super(FieldStatsDialog, self).__init__(parent)
self.setupUi(self)
self.data = None
self.reload_layers()
self.reload_fields()
self.comboLayer.currentIndexChanged.connect(self.reload_fields)
self.pushButtonClose.clicked.connect(self.close)
self.pushButtonRefresh.clicked.connect(self.refresh)
self.pushButtonNextField.clicked.connect(self.next_field)
self.pushButtonPreviousField.clicked.connect(self.previous_field)
self.pushButtonQuartiles.clicked.connect(self.quartiles)
self.pushButton10Percent.clicked.connect(self.percent10)
self.pushButton5Percent.clicked.connect(self.percent5)
self.pushButtonHighEnd.clicked.connect(self.high_end)
self.comboBoxGraphType.currentIndexChanged.connect(self.refreshPlot)
self.comboBoxGraphSort.currentIndexChanged.connect(self.refreshPlot)
self.comboBoxGraphScale.currentIndexChanged.connect(self.refreshPlot)
self.pushButtonGraphOptions.clicked.connect(self.changeGraphOptions)
icon_path = ':/plugins/FieldStats/copy16px.png'
copy_icon = QtGui.QPixmap(icon_path)
self.toolButtonCopyGraphToClipboard.setIcon(QtGui.QIcon(copy_icon))
self.toolButtonCopyGraphToClipboard.setToolTip('Copy graph to the clipboard.')
self.toolButtonCopyGraphToClipboard.clicked.connect(self.copyGraphToClipboard)
# self.progressBar.hide()
self.progressBar.reset()
style = "alternate-background-color:#F6F6F6;background-color:white;selection-background-color:#FFEB7A;selection-color:black;"
self.tableField.horizontalHeader().setStretchLastSection(True)
self.tableField.setColumnWidth(0, 200)
self.tableField.setStyleSheet(style)
self.tableStatistics.horizontalHeader().setStretchLastSection(True)
self.tableStatistics.setColumnWidth(0, 250)
self.tableStatistics.setStyleSheet(style)
self.tableUnique.horizontalHeader().setStretchLastSection(True)
self.tableUnique.setColumnWidth(0, 300)
self.tableUnique.setColumnWidth(1, 100)
self.tableUnique.setStyleSheet(style)
self.lineEditNumDecimals.setText('2')
self.checkUseSelected.setChecked(True)
self.checkBoxCreateUnique.setChecked(True)
self.quartiles()
#
# ----- graph default labels
#
self.title = None
self.field_label = None
self.graph_last_field = None
self.graph_colors = GraphOptionsDialog.COLOR_SET_DEFAULT
self.antilog_labels = True
#
# ----- add matplotlib figure to dialog
#
self.figure_area = Figure(facecolor='white')
self.plot = self.figure_area.add_subplot(111)
# # self.figure_area.subplots_adjust(left=0.125, right=0.9, bottom=0.1, top=0.9)
self.figure_area.subplots_adjust(left=0.13, right=0.91, bottom=0.15, top=0.88)
self.canvas = FigureCanvas(self.figure_area)
self.graphLayout.addWidget(self.canvas)
self.canvas.draw()
self.read_defaults()
def read_default_combo(self, setting, combo_box):
#---------------------------------------------------------------------------
"""
Read saved settings for a comboBox control and properly restore by
setting the current index and text values.
:param setting: The setting to restore, typically from a constant string.
:type setting: str
:param combo_box: The comboBox control to restore the settings to.
:type combo_box: QComboBox
"""
s = QSettings()
str = s.value(self.SETTINGS_ROOT + setting)
if str != None:
index = combo_box.findText(str, Qt.MatchFixedString)
if index >= 0:
combo_box.setEditText(str)
combo_box.setCurrentIndex(index)
def read_defaults(self):
#---------------------------------------------------------------------------
"""
Read and restore saved default settings.
"""
s = QSettings()
str = s.value(self.SETTINGS_ROOT + self.SETTINGS_NUM_DECIMALS)
if str != None: self.lineEditNumDecimals.setText(str)
str = s.value(self.SETTINGS_ROOT + self.SETTINGS_PERCENTILES)
if str != None: self.lineEditPercentiles.setText(str)
str = s.value(self.SETTINGS_ROOT + self.SETTINGS_GRAPH_COLOR)
if str != None: self.graph_colors = str
val = s.value(self.SETTINGS_ROOT + self.SETTINGS_CREATE_UNIQUE)
if val != None: self.checkBoxCreateUnique.setChecked(val)
val = s.value(self.SETTINGS_ROOT + self.SETTINGS_SELECTED_ONLY)
if val != None: self.checkUseSelected.setChecked(val)
val = s.value(self.SETTINGS_ROOT + self.SETTING_ANTILOG_LABELS)
if val != None: self.antilog_labels = val
self.read_default_combo(self.SETTINGS_LAYER, self.comboLayer)
self.read_default_combo(self.SETTINGS_FIELD, self.comboField)
self.read_default_combo(self.SETTINGS_GRAPH_TYPE, self.comboBoxGraphType)
self.read_default_combo(self.SETTINGS_GRAPH_SORT, self.comboBoxGraphSort)
self.read_default_combo(self.SETTINGS_GRAPH_SCALE, self.comboBoxGraphScale)
def save_defaults(self):
#---------------------------------------------------------------------------
"""
Save settings so they can be restored each time the plugin starts.
"""
s = QSettings()
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_NUM_DECIMALS, self.lineEditNumDecimals.text())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_PERCENTILES, self.lineEditPercentiles.text())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_CREATE_UNIQUE, self.checkBoxCreateUnique.isChecked())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_SELECTED_ONLY, self.checkUseSelected.isChecked())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_LAYER, self.comboLayer.currentText())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_FIELD, self.comboField.currentText())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_GRAPH_TYPE, self.comboBoxGraphType.currentText())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_GRAPH_SORT, self.comboBoxGraphSort.currentText())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_GRAPH_SCALE, self.comboBoxGraphScale.currentText())
s.setValue(self.SETTINGS_ROOT + self.SETTINGS_GRAPH_COLOR, self.graph_colors)
s.setValue(self.SETTINGS_ROOT + self.SETTING_ANTILOG_LABELS, self.antilog_labels)
def percentiles(self, step):
#---------------------------------------------------------------------------
"""
Setup a comma delimited list of percentile breakpoints.
:param step: Incremental step between percentile values.
For example 10 for values every 10%.
:type step: integer
:returns: A string, for example '25, 50, 75' for a step of 25.
:rtype: str
"""
delimiter = ''
str = ''
for i in range(step, 100, step):
str += "{}{}".format(delimiter, i)
delimiter = ', '
self.lineEditPercentiles.setText(str)
# self.lineEditPercentiles.setCursorPosition(0)
def quartiles(self):
#---------------------------------------------------------------------------
"""
Setup default quartiles.
"""
self.percentiles(25)
def percent10(self):
#---------------------------------------------------------------------------
"""
Setup default percentiles every 10%.
"""
self.percentiles(10)
def percent5(self):
#---------------------------------------------------------------------------
"""
Setup default percentiles every 5%.
"""
self.percentiles(5)
def high_end(self):
#---------------------------------------------------------------------------
"""
Setup selected high-end percentiles. These are tailored to create
four bins of geochemical data.
"""
self.lineEditPercentiles.setText('50, 80, 95')
def reload_layers(self):
#---------------------------------------------------------------------------
"""
Load the current list of layers into the layers comboBox control.
"""
self.comboLayer.clear()
self.comboLayer.addItems(FieldStatsHelper.get_vector_layer_names())
def reload_fields(self):
#---------------------------------------------------------------------------
"""
Load the current list of fields into the fields comboBox control.
"""
self.comboField.clear()
layer = FieldStatsHelper.get_vector_layer_by_name(self.comboLayer.currentText())
if layer != None:
self.comboField.addItems(FieldStatsHelper.get_field_names(layer, [QVariant.String, QVariant.Int, QVariant.Double]))
def goto_field(self, field):
#---------------------------------------------------------------------------
"""
Goto a specific field and calculate stats.
:param field: The name of the field to goto.
:type field: str
"""
if field != None:
index = self.comboField.findText(field, Qt.MatchFixedString)
if index >= 0:
self.comboField.setEditText(field)
self.comboField.setCurrentIndex(index)
self.title = None
self.refresh()
def next_field(self):
#---------------------------------------------------------------------------
"""
Goto the next field in the table and calculate stats. This is circular
so if you advance past the end go back to the beginning.
"""
field = FieldStatsHelper.get_next_field(FieldStatsHelper.get_vector_layer_by_name(self.comboLayer.currentText()),
self.comboField.currentText())
self.goto_field(field)
def previous_field(self):
#---------------------------------------------------------------------------
"""
Goto the previous field in the table and calculate stats. This is circular
so if you advance past the beginning go back to the end.
"""
field = FieldStatsHelper.get_previous_field(FieldStatsHelper.get_vector_layer_by_name(self.comboLayer.currentText()),
self.comboField.currentText())
self.goto_field(field)
def refresh(self):
#---------------------------------------------------------------------------
"""
"""
self.save_defaults()
# self.progressBar.show()
layer = FieldStatsHelper.get_vector_layer_by_name(self.comboLayer.currentText())
self.data = FieldStatsData(layer, self.comboField.currentText(), self.checkUseSelected.isChecked())
self.data.num_decimals = int(self.lineEditNumDecimals.text())
self.data.createUniqueList = self.checkBoxCreateUnique.isChecked()
self.data.rangeChanged.connect(self.setProgressRange)
self.data.updateProgress.connect(self.updateProgress)
self.data.processFinished.connect(self.processFinished)
self.data.processInterrupted.connect(self.processInterrupted)
plist = self.lineEditPercentiles.text().split(',')
if len(plist) > 0:
for i in xrange(len(plist)):
p = float(plist[i])
if p >= 0.0 and p <= 100.0:
self.data.percentilesArray.append(p)
# self.btnOk.setEnabled(False)
# self.btnClose.setText(self.tr("Cancel"))
# self.buttonBox.rejected.disconnect(self.reject)
# self.btnClose.clicked.connect(self.stopProcessing)
# self.pushButtonNextField.hide()
# self.pushButtonPreviousField.hide()
# QtGui.QMessageBox.information(None, "DEBUG:", 'Process about to start.')
self.data.start()
def setProgressRange(self, maxValue):
self.progressBar.setRange(0, maxValue)
def updateProgress(self):
self.progressBar.setValue(self.progressBar.value() + 1)
def processFinished(self):
#---------------------------------------------------------------------------
"""
"""
self.stopProcessing()
self.tableField.clearContents()
self.tableStatistics.clearContents()
self.tableUnique.clearContents()
self.tableField.setRowCount(0)
self.tableStatistics.setRowCount(0)
self.tableUnique.setRowCount(0)
#
# ----- put field metadata in the field table
#
if self.data != None and len(self.data.fieldArray) > 0:
rowCount = len(self.data.fieldArray)
self.tableField.setRowCount(rowCount)
for i in xrange(rowCount):
label = self.data.fieldArray[i][0]
if (i == 1): label += (', ' + FieldStatsHelper.get_field_index_desc(
FieldStatsHelper.get_vector_layer_by_name(self.comboLayer.currentText()),
self.comboField.currentText()))
item = QtGui.QTableWidgetItem(label)
self.tableField.setItem(i, 0, item)
item = QtGui.QTableWidgetItem(str(self.data.fieldArray[i][1]))
self.tableField.setItem(i, 1, item)
self.tableField.resizeRowsToContents()
#
# ----- put statistics in the stats table
#
if self.data != None and len(self.data.statsArray) > 0:
rowCount = len(self.data.statsArray)
self.tableStatistics.setRowCount(rowCount)
for i in xrange(rowCount):
label = self.data.statsArray[i][0]
item = QtGui.QTableWidgetItem(label)
self.tableStatistics.setItem(i, 0, item)
item = QtGui.QTableWidgetItem(str(self.data.statsArray[i][1]))
self.tableStatistics.setItem(i, 1, item)
# if (i == 0): self.tableStatistics.setSpan(i, 0, 1, 2)
self.tableStatistics.resizeRowsToContents()
#
# ----- header at the top of selected tables
#
header = self.comboField.currentText() + ', ' + FieldStatsHelper.get_field_index_desc(
FieldStatsHelper.get_vector_layer_by_name(self.comboLayer.currentText()),
self.comboField.currentText(), 'Field ')
self.labelStatisticsHeader.setText(header)
if self.data != None and len(self.data.uniqueArray) > 0:
header += ', {} Unique Item(s)'.format(len(self.data.uniqueArray))
self.labelUniqueHeader.setText(header)
#
# ----- put unique items list in the table if applicable
#
if self.data != None and len(self.data.uniqueArray) > 0:
self.tableUnique.setSortingEnabled(False)
rowCount = len(self.data.uniqueArray)
self.tableUnique.setRowCount(rowCount)
for i in xrange(rowCount):
if self.data.is_text_field:
item = QtGui.QTableWidgetItem(self.data.uniqueArray[i][0])
self.tableUnique.setItem(i, 0, item)
else:
item = FloatTableWidgetItem(self.data.uniqueArray[i][0])
self.tableUnique.setItem(i, 0, item)
item = QtGui.QTableWidgetItem()
item.setData(Qt.DisplayRole, self.data.uniqueArray[i][1])
self.tableUnique.setItem(i, 1, item)
item = QtGui.QTableWidgetItem()
item.setData(Qt.DisplayRole, self.data.uniqueArray[i][2])
self.tableUnique.setItem(i, 2, item)
self.tableUnique.setSortingEnabled(True)
self.tableUnique.resizeRowsToContents()
if self.tabWidget.currentIndex() == 0:
self.tabWidget.setCurrentIndex(2)
self.refreshPlot()
self.progressBar.reset()
# self.progressBar.hide()
# self.pushButtonNextField.show()
# self.pushButtonPreviousField.show()
def parseColors(self, colors_str):
#---------------------------------------------------------------------------
"""
Parse a string of colors into an array of colors.
"""
color_list = colors_str.split(',')
if len(color_list) == 0:
color_list = GraphOptionsDialog.COLOR_SET_DEFAULT.split(',')
color_array = []
for color in color_list:
color_array.append(color.strip(" '").strip('"'))
return color_array
@staticmethod
def log10ScaleFormatter(n, pos):
#---------------------------------------------------------------------------
"""
"""
v = pow(10, n)
# Find the number of decimal places required
decimalplaces = int(np.maximum(-np.log10(v),0)) # =0 for numbers >=1
# Insert that number into a format string
formatstring = '{{:.{:1d}f}}'.format(decimalplaces)
# Return the formatted tick label
return formatstring.format(v)
def setCommonPlotOptions(self, transform):
#---------------------------------------------------------------------------
"""
"""
self.plot.set_aspect('auto')
if transform == self.TRANSFORM_LOG10 and self.antilog_labels:
self.plot.xaxis.set_major_formatter(ticker.FuncFormatter(self.log10ScaleFormatter))
def refreshPlot(self):
#---------------------------------------------------------------------------
no_graph_reason = self.NO_GRAPH_EMPTY_FIELD
self.save_defaults()
#
# ----- set transform type if applicable
#
transform = self.TRANSFORM_NONE
if self.comboBoxGraphScale.currentText() == 'Log Transform':
transform = self.TRANSFORM_LOG10
#
# ----- completely clear previous plot
# seems like overkill, but only way I know to do this right now
#
if self.canvas != None:
self.graphLayout.removeWidget(self.canvas)
self.canvas.close()
#
# ----- setup new plot from scratch
#
self.figure_area = Figure(facecolor='white')
self.plot = self.figure_area.add_subplot(111)
# self.figure_area.subplots_adjust(left=0.125, right=0.9, bottom=0.1, top=0.9)
if self.comboBoxGraphType.currentText() == 'Pie Chart':
self.figure_area.subplots_adjust(left=0.1, right=0.9, bottom=0.1, top=0.8)
else:
self.figure_area.subplots_adjust(left=0.13, right=0.91, bottom=0.15, top=0.88)
self.canvas = FigureCanvas(self.figure_area)
self.graphLayout.addWidget(self.canvas)
# self.canvas.draw()
if not self.data:
self.plot.axis('off')
self.canvas.draw()
return
data = None
colorsArray = self.parseColors(self.graph_colors)
#
# ----- graph title
#
if self.title == None or self.graph_last_field != self.comboField.currentText():
self.title = self.comboField.currentText() + ' ' + \
self.tr("from") + ' ' + self.comboLayer.currentText()
self.plot.set_title(unicode(self.title))
title_obj = self.plot.title
title_obj.set_position([.5, 1.02])
#
# ----- field label
#
if self.field_label == None or self.graph_last_field != self.comboField.currentText():
self.field_label = self.comboField.currentText()
if self.data.is_text_field: self.field_label += ', ' + self.tr('Length')
self.graph_last_field = self.comboField.currentText()
#
# ----- data to graph
#
if self.comboBoxGraphType.currentText() == 'Pie Chart':
if self.checkBoxCreateUnique.isChecked() and len(self.data.uniqueArray) > 0:
data = []
labelArray = []
num_unique_items = len(self.data.uniqueArray)
for i in range(0, num_unique_items):
if i < self.MAX_PIE_SLICES:
data.append(self.data.uniqueArray[i][1])
labelArray.append(self.data.uniqueArray[i][0])
else:
if i == self.MAX_PIE_SLICES:
data.append(self.data.uniqueArray[i][1])
labelArray.append('Other')
else:
data[self.MAX_PIE_SLICES] += self.data.uniqueArray[i][1]
else:
if not self.checkBoxCreateUnique.isChecked():
no_graph_reason = self.NO_GRAPH_UNIQUE_LIST_NOT_CHECKED
else:
if transform == self.TRANSFORM_LOG10:
if self.data.min <= 0:
t1 = []
for i in xrange(len(self.data.dataArray)):
t1.append(self.data.dataArray[i] + (abs(self.data.min) + 1))
data = np.log10(t1)
else:
data = np.log10(self.data.dataArray)
else:
data = np.copy(self.data.dataArray)
#
#
#
if self.comboBoxGraphType.currentText() == 'Line Graph' or self.comboBoxGraphType.currentText() == 'Scatter Plot':
if self.comboBoxGraphSort.currentText() == 'Ascending':
data = sorted(data)
elif self.comboBoxGraphSort.currentText() == 'Descending':
data = sorted(data, reverse=True)
#
#
#
if data != None and len(data) > 0:
if self.comboBoxGraphType.currentText() == 'Line Graph':
self.plot.grid(True)
self.plot.plot(np.arange(1,len(data)+1), data, "-", color=colorsArray[0], alpha=1.0, linewidth=1.5) # alpha=0.70
self.plot.set_ylabel(unicode(self.field_label))
self.plot.set_xlabel('')
self.plot.set_xlim([1,len(data)+1])
self.plot.grid(b=True, which='major', color='lightgrey', linestyle='-')
self.plot.set_aspect('auto')
if transform == self.TRANSFORM_LOG10 and self.antilog_labels:
self.plot.yaxis.set_major_formatter(ticker.FuncFormatter(self.log10ScaleFormatter))
elif self.comboBoxGraphType.currentText() == 'Scatter Plot':
self.plot.grid(True)
self.plot.plot(np.arange(1,len(data)+1), data, "o", color=colorsArray[0], alpha=1.0) # alpha=0.70
self.plot.set_ylabel(unicode(self.field_label))
self.plot.set_xlabel('')
self.plot.set_xlim([1,len(data)+1])
self.plot.grid(b=True, which='major', color='lightgrey', linestyle='-')
self.plot.set_aspect('auto')
if transform == self.TRANSFORM_LOG10 and self.antilog_labels:
self.plot.yaxis.set_major_formatter(ticker.FuncFormatter(self.log10ScaleFormatter))
elif self.comboBoxGraphType.currentText() == 'Histogram':
self.plot.grid(False)
self.plot.hist(data, 35, facecolor=colorsArray[0], alpha=1.0) # alpha=0.50
self.plot.set_xlabel(unicode(self.field_label))
self.plot.set_ylabel(unicode(self.tr("Frequency")))
self.plot.set_aspect('auto')
if transform == self.TRANSFORM_LOG10 and self.antilog_labels:
self.plot.xaxis.set_major_formatter(ticker.FuncFormatter(self.log10ScaleFormatter))
elif self.comboBoxGraphType.currentText() == 'Pie Chart':
_, _, autotexts = self.plot.pie(data, labels=labelArray, colors=colorsArray, autopct='%1.1f%%')
wedges = [patch for patch in self.plot.patches if isinstance(patch, matplotlib.patches.Wedge)]
for pie_wedge in wedges:
pie_wedge.set_edgecolor('white')
# for autotext in autotexts:
# autotext.set_color('white')
for t in autotexts:
t.set_size('small')
self.plot.set_aspect('equal')
# self.plot.set_ylabel(unicode(self.comboField.currentText()))
# self.plot.set_xlabel(unicode(self.tr("Row")))
# self.figure_area.autofmt_xdate()
self.canvas.draw()
else:
self.plot.cla()
self.plot.axis('off')
if no_graph_reason == self.NO_GRAPH_EMPTY_FIELD:
message = self.comboField.currentText() + ' is empty.'
elif no_graph_reason == self.NO_GRAPH_UNIQUE_LIST_NOT_CHECKED:
message = 'Check option to create a unique list.'
else:
message = 'Unable to Create Graph'
self.plot.text(0.5, 0.5, unicode(message), ha='center', va='center', fontsize=20,
transform=self.plot.transAxes)
self.figure_area.subplots_adjust(left=0.1, right=0.9, bottom=0.25, top=0.75)
self.canvas.draw()
def changeGraphOptions(self):
#---------------------------------------------------------------------------
"""
Display the dialog to change graph options.
"""
dlg = GraphOptionsDialog(self)
dlg.lineEditTitle.setText(self.title)
dlg.lineEditFieldLabel.setText(self.field_label)
dlg.lineEditColor.setText(self.graph_colors)
dlg.checkBoxAntilogLabels.setChecked(self.antilog_labels)
#
# ----- show dialog and change graph is accepted
#
if dlg.exec_() == QtGui.QDialog.Accepted:
if dlg.lineEditFieldLabel.text() != self.field_label or \
dlg.lineEditColor.text() != self.graph_colors or \
dlg.checkBoxAntilogLabels.isChecked() != self.antilog_labels:
self.field_label = dlg.lineEditFieldLabel.text()
self.title = dlg.lineEditTitle.text()
self.graph_colors = dlg.lineEditColor.text()
self.antilog_labels = dlg.checkBoxAntilogLabels.isChecked()
self.refreshPlot()
elif dlg.lineEditTitle.text() != self.title:
self.title = dlg.lineEditTitle.text()
self.plot.set_title(unicode(self.title))
self.canvas.draw()
def copyGraphToClipboard(self):
#---------------------------------------------------------------------------
pixmap = QtGui.QPixmap.grabWidget(self.canvas)
QtGui.QApplication.instance().clipboard().setPixmap(pixmap)
def processInterrupted(self):
#---------------------------------------------------------------------------
self.restoreGui()
def stopProcessing(self):
#---------------------------------------------------------------------------
if self.data is not None:
self.data.stop()
# self.data = None
def restoreGui(self):
#---------------------------------------------------------------------------
#self.progressBar.setFormat("%p%")
#self.progressBar.setRange(0, 1)
#self.progressBar.setValue(0)
self.progressBar.reset()
class CoLocation(QMainWindow, Ui_MainWindow):
flag = True
categories = {}
valid_images = ["jpg", "png", "tga", "pgm", "jpeg"]
valid_videos = ["mp4", "avi"]
edge_threshold = 100
to_disp = []
stop = False
framerate = 20
export_name = ''
def __init__(self, ):
super(
CoLocation,
self).__init__() #initialise from the ui designed by Designer App
self.setupUi(self)
self.setupUi_custom()
Help = QtGui.QAction(QtGui.QIcon('images/info.png'), 'Help', self)
Help.triggered.connect(self.show_help)
Settings = QtGui.QAction(QtGui.QIcon('images/settings.png'),
'Settings', self)
Settings.triggered.connect(self.show_settings)
Export = QtGui.QAction(QtGui.QIcon('images/export.png'), 'Export',
self)
Export.triggered.connect(self.show_export)
##To set up the toolbar
self.toolbar = self.addToolBar('Help')
self.toolbar.addAction(Help)
self.toolbar = self.addToolBar('Settings')
self.toolbar.addAction(Settings)
self.toolbar = self.addToolBar('Export')
self.toolbar.addAction(Export)
def show_help(self):
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Co-Location Visualisation")
f = open('How-To/how-to-Co-Location.txt', 'r')
msg.setInformativeText(
"Developed by Yash Chandak, under supervision of Prof. Babiga Birregah, University of Technology, Troyes"
)
msg.setWindowTitle("About Us")
msg.setDetailedText(f.read())
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
def show_settings(self):
framerate, ok = QtGui.QInputDialog.getInt(
self, 'Settings', 'Enter Frame Rate for Videos:')
self.framerate = framerate
def show_export(self):
name, ok = QtGui.QInputDialog.getText(self, 'Export to Gephi format',
'Enter file name :')
self.export_name = name + '.gefx'
def update_categories(self):
#update selected categories
for radiobox in self.findChildren(QtGui.QRadioButton):
self.categories[radiobox.text()] = radiobox.isChecked()
def setupUi_custom(self, ):
self.scene = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.pushButton.clicked.connect(self.selectFile)
self.horizontalSlider.valueChanged.connect(self.updateLCD)
self.pushButton_2.clicked.connect(self.disp_graph)
self.pushButton_3.clicked.connect(self.selectFile_from_folder)
self.stop_button.clicked.connect(self.set_stop)
#TODO [WEIRD PROBLEM] QPixmap needs to be called at least once with JPG image before tensorFlow, otherwise program crashes
self.scene.addPixmap(
QPixmap(os.getcwd() + "/images/demo.jpg").scaled(
self.graphicsView.size(), QtCore.Qt.KeepAspectRatio))
self.graphicsView.setScene(self.scene)
#Add blank canvas initially
fig1 = Figure()
self.addmpl(fig1)
def set_stop(self):
self.stop = True
def updateLCD(self):
#update edge_threshold variable based on slider
self.edge_threshold = self.horizontalSlider.value()
self.lcdNumber.display(self.edge_threshold)
def tag_image(self, filename=None, batch=False, image=None):
#importing TensorFlow on top causes segmentation fault (official bug #2034)
#importing here helps in working around the problem
#Python modules could be con)sidered as singletons... so no matter how many times they are imported, they get initialized only once
import Yolo_module as yolo
if (self.flag):
#initialise the model, only once
self.classifier = yolo.YOLO_TF()
self.flag = False
self.classifier.batch = batch
if not image == None:
self.classifier.detect_from_cvmat(image)
else:
self.classifier.detect_from_file(
filename) #execute Yolo on the image
return self.classifier.tagged_image
def disp_img(self, filename=None, img=None):
if not img == None:
img_rgb = img.copy()
cv2.cvtColor(img, cv2.COLOR_BGR2RGB, img_rgb)
img_rgb = QtGui.QImage(img_rgb, img_rgb.shape[1], img_rgb.shape[0],
img_rgb.shape[1] * 3,
QtGui.QImage.Format_RGB888)
self.scene.addPixmap(
QPixmap(img_rgb).scaled(self.graphicsView.size(),
QtCore.Qt.KeepAspectRatio))
image = self.tag_image(image=img)
else:
#DO this step before calling tensorflow
self.scene.addPixmap(
QPixmap(filename).scaled(self.graphicsView.size(),
QtCore.Qt.KeepAspectRatio))
#Dislplay tagged image
image = self.tag_image(filename=filename)
image = QtGui.QImage(
image, image.shape[1], image.shape[0], image.shape[1] * 3,
QtGui.QImage.Format_RGB888) #convert to Qt image format
self.scene2.addPixmap(
QPixmap(image).scaled(self.graphicsView_3.size(),
QtCore.Qt.KeepAspectRatio))
self.graphicsView.setScene(self.scene)
self.graphicsView_3.setScene(self.scene2)
def disp_graph(self, result=[], graph_name=''):
import graph_module as gm
self.update_categories()
self.rmmpl() #remove previous graph
if result != [] and result != False:
self.to_disp = result
#Display graph
fig = Figure()
fig.set_facecolor('w')
axf = fig.add_subplot(111)
axf.set_axis_off()
gm.co_location(self.to_disp, axf, self.edge_threshold, self.categories,
graph_name) #get updated graph
self.addmpl(fig)
print("graph added")
def disp_video(self, filename, skip=20):
cap = cv2.VideoCapture(filename)
count = 0
self.stop = False
while True:
#TODO: Better method - https://nikolak.com/pyqt-threading-tutorial/
QtCore.QCoreApplication.processEvents()
ret, img = cap.read()
if (not ret) or self.stop:
print("Ending video...") #+ str(ret) + str(self.stop))
break
if count % skip == 0:
img = cv2.resize(img, (640, 480))
self.disp_img(img=img)
self.disp_graph([self.classifier.result
]) #list of 1 resultant list
count = 0
count += 1
def selectFile(self):
#Clear previous image displays
self.scene.clear()
self.scene2.clear()
self.update_categories()
filename = QFileDialog.getOpenFileName(
directory='/home/yash/Downloads/Pascal VOC 2012/samples')
self.lineEdit.setText(filename)
#check if file is valid video
if filename.split('.')[1] in self.valid_videos:
self.disp_video(filename, self.framerate)
#check if the file is valid
elif filename.split('.')[1] in self.valid_images:
self.disp_img(filename=filename)
self.disp_graph([self.classifier.result
]) #list of 1 resultant list
else:
print("Invalid file format")
def selectFile_from_folder(self):
#Read all the images in the folder
path = QFileDialog.getExistingDirectory(
None, 'Select a folder:', '/home/yash/Downloads/Pascal VOC 2012',
QtGui.QFileDialog.ShowDirsOnly)
self.lineEdit_2.setText(path)
self.batch_results = []
for f in os.listdir(path): #list all the files in the folder
ext = f.split('.')[1] #get the file extension
if ext.lower(
) not in self.valid_images: #check if the extension is valid for the image
continue
filename = path + '/' + f #create the path of the image
print(filename)
self.tag_image(filename, batch=True)
self.batch_results.append(
self.classifier.result) #list of all resultant lists
#clear the image regions during batch upload
self.scene.clear()
self.scene2.clear()
self.disp_graph(self.batch_results, self.export_name)
def addmpl(self, fig):
#Add figure to canvas and widget
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def rmmpl(self, ):
#remove the canvas and widget
self.mplvl.removeWidget(self.canvas)
self.canvas.close()
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()
