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