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)
def plot_raw_dataset_um( points_um, savedir='', title='images', grid=(3, 3), figsize=(8, 8), size=0.1, dpi=300, invert_yaxis=True, ): ''' Plot the mRNA spots for each gene. ''' print('Plotting mRNA spots of selected genes...') if not os.path.exists(savedir): os.makedirs(savedir) genes_per_plot = grid[0] * grid[1] num_plots, remain = divmod(len(points_um), genes_per_plot) if remain != 0: num_plots += 1 gene_list = list(points_um.keys()) gene_idx = 0 for plot_num in range(num_plots): fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) for gridpos in range(genes_per_plot): if gene_idx == len(points_um): break ax = fig.add_subplot(grid[0], grid[1], gridpos + 1) ax.scatter( points_um[gene_list[gene_idx]][:, 1], points_um[gene_list[gene_idx]][:, 0], s=size, ) ax.set_aspect('equal') ax.set_title(gene_list[gene_idx]) if invert_yaxis: ax.invert_yaxis() gene_idx += 1 fig.suptitle(title + f'\n {plot_num + 1} of {num_plots}') fig.tight_layout(rect=(0, 0, 1, .94)) savename = ( f'raw_image_{plot_num+1}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.png' ) fig.savefig(os.path.join(savedir, savename), dpi=dpi) canvas.close() fig.clear() plt.close()
class Main(Ui_MainWindow, QMainWindow): def __init__(self, ): super(Main, self).__init__() self.setupUi(self) self.fig_dict = {} self.L1.itemClicked.connect(self.changefig) # self.chk1.setVisible(False) # self.chk1.setChecked(True) self.setWindowIcon(QtGui.QIcon('ipco-logo.png')) def changefig(self, item): text = item.text() self.rmmpl() self.addmpl(self.fig_dict[text]) def addmpl(self, fig): self.canvas = FigureCanvas(fig) self.mplvl.addWidget(self.canvas) self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True) self.mplvl.addWidget(self.toolbar) self.rmmpl() def rmmpl(self, ): self.mplvl.removeWidget(self.canvas) self.canvas.close() self.mplvl.removeWidget(self.toolbar) self.toolbar.close() def addfig(self, name, fig): self.fig_dict[name] = fig self.L1.addItem(name)
class EDXmain(QtWidgets.QWidget): ''' Interface to get a list of points from an existing plot ''' # http://blog.rcnelson.com/building-a-matplotlib-gui-with-qt-designer-part-1/ def __init__(self, ): super(EDXmain, self).__init__() # gets inherited methods of this class self.initUI() self.fig_dict = {} # list of active figures # click on item in Qlistwidget triggers change of figures self.mplfigs.itemClicked.connect(self.changefig) # add select data subset button here def initUI(self): self.setGeometry(600, 300, 400, 200) self.setWindowTitle('EDX main window') self.show() def addmpl(self, fig): ''' adds matplotlib plot to qt container''' self.canvas = FigureCanvas(fig) # fig canvas widget # mplvl is a QVBoxLayout instance with addWidget method self.mplvl.addWidget( self.canvas) # mplvl is layout name within container in .ui window # could also be directly added to mplwindow container but then scales differently self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mplwindow, coordinates=True) self.mplvl.addWidget(self.toolbar) # toolbar added below passed plot self.canvas.mpl_connect('key_press_event', self.on_key_press) def rmmpl(self, ): ''' remove existing plots ''' self.mplvl.removeWidget(self.canvas) self.canvas.close() self.mplvl.removeWidget(self.toolbar) self.toolbar.close() def addfig(self, name, fig): ''' Adds name, underlying fig to dictionary and displays in window ''' self.fig_dict[name] = fig self.mplfigs.addItem(name) # adds name to QlistWidget def changefig(self, item): text = item.text() self.rmmpl() # removes existing self.addmpl(self.fig_dict[text]) def on_key_press(self, event): ''' get coords on plot ''' ix, iy = event.xdata, event.ydata print('Coords are: ', str(ix), str(iy))
class Main(QtWidgets.QMainWindow, Ui_MainWindow): def __init__(self): QtWidgets.QMainWindow.__init__(self) Ui_MainWindow.__init__(self) self.setupUi(self) self.plotField.clicked.connect(self.plotfield) #Notice that an empty figure instance was added to our plotting window in the initialization method. #This is necessary because our first call to changefig will try to remove a previously displayed figure, #which will throw an error if one is not displayed. #The empty figure serves as a placeholder so the changefig method functions properly. fig = Figure() self.addmpl(fig) def plotfield(self): wavelen = float(self.wavelen.toPlainText()) modenum = int(self.modeNum.toPlainText()) Zin = float(self.z.toPlainText()) x, ET = genAM.doubleSlit(wavelen, modenum, Zin) figx = Figure() ax1f1 = figx.add_subplot(111) ax1f1.set_title('Beam Pattern') ax1f1.plot(x, np.abs(ET)**2, label='Beam Pattern at %s m' % Zin) ax1f1.set_xlabel('x [m]') ax1f1.set_ylabel('Intensity') ax1f1.legend(loc='best') ax1f1.grid() self.rmmpl() self.addmpl(figx) def addmpl(self, fig): self.canvas = FigureCanvas(fig) self.mplvl_0.addWidget(self.canvas) self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mplwindow, coordinates=True) self.mplvl_0.addWidget(self.toolbar) def rmmpl(self): self.mplvl_0.removeWidget(self.canvas) self.canvas.close() self.mplvl_0.removeWidget(self.toolbar) self.toolbar.close()
class Main(QMainWindow, Ui_MainWindow): def __init__(self, ): super(Main, self).__init__() self.setupUi(self) 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 MplWidget(QWidget): ''' This class creates figures in the UI ''' def __init__(self, parent=None): QWidget.__init__(self, parent) self.canvas = FigureCanvas(Figure()) self.vertical_layout = QVBoxLayout() self.vertical_layout.addWidget(self.canvas) self.toolbar = NavigationToolbar(self.canvas, self) self.vertical_layout.addWidget(self.toolbar) self.setLayout(self.vertical_layout) self.canvas.draw() def removePlot(self, ): self.vertical_layout.removeWidget(self.canvas) self.canvas.close() self.vertical_layout.removeWidget(self.toolbar) self.toolbar.close() self.setLayout(self.vertical_layout) def addPlot(self, fig): self.canvas = FigureCanvas(fig) self.vertical_layout.addWidget(self.canvas) self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True) self.vertical_layout.addWidget(self.toolbar) self.canvas.draw() self.setLayout(self.vertical_layout) def addDynamicPlot(self, fig): self.canvas = FigureCanvas(fig) self.vertical_layout.addWidget(self.canvas) self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True) self.vertical_layout.addWidget(self.toolbar) self.setLayout(self.vertical_layout) self.cursor = SnaptoCursor(fig) self.cid = self.canvas.mpl_connect('motion_notify_event', self.cursor.mouse_move) def selectPointPlot(self, fig, QListWidget): self.cursor = SnaptoCursor(fig, QListWidget) self.canvas.mpl_connect('button_press_event', self.cursor.onclick) self.canvas.mpl_connect('motion_notify_event', self.cursor.mouse_move)
class MplCanvas(object): """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.).""" def __init__(self, parent, width, height, dpi): from PyQt5 import QtWidgets from matplotlib.figure import Figure from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg self.fig = Figure(figsize=(width, height), dpi=dpi) self.canvas = FigureCanvasQTAgg(self.fig) self.axes = self.fig.add_subplot(111) self.axes.set(xlabel='Time (sec)', ylabel='Activation (AU)') self.canvas.setParent(parent) FigureCanvasQTAgg.setSizePolicy(self.canvas, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) FigureCanvasQTAgg.updateGeometry(self.canvas) # XXX eventually this should be called in the window resize callback tight_layout(fig=self.axes.figure) def plot(self, x, y, label, **kwargs): """Plot a curve.""" line, = self.axes.plot(x, y, label=label, **kwargs) self.update_plot() return line def update_plot(self): """Update the plot.""" self.axes.legend(prop={ 'family': 'monospace', 'size': 'small' }, framealpha=0.5, handlelength=1.) self.canvas.draw() def show(self): """Show the canvas.""" self.canvas.show() def close(self): """Close the canvas.""" self.canvas.close()
class MainWindow(QMainWindow, Ui_MainWindow): def __init__(self, ): super(MainWindow, self).__init__() self.setupUi(self) self.cboxCultura.clear() self.cboxEstado.clear() root, dirs, files = next(os.walk(dirculturassimuladas)) self.cboxCultura.addItems(dirs) self.cboxCultura.currentIndexChanged.connect(self.carregaEstados) self.cboxEstado.currentIndexChanged.connect(self.carregaShape) def carregaShape(self): subprocess.call( ('/home/daniel/Desktop/tcc/shapeSP/recorteSP.R', self.cboxEstado.currentText(), self.cboxCultura.currentText())) MainWindow.rmmpl() drawstates() MainWindow.addmpl(fig1) def carregaEstados(self): self.cboxEstado.clear() direstado = dirculturassimuladas + "/" + self.cboxCultura.currentText() root, dirs, files = os.walk(direstado).next() self.cboxEstado.addItems(dirs) def addmpl(self, fig): self.canvas = FigureCanvas(fig) self.mplvl.addWidget(self.canvas) self.canvas.draw() self.show() #self.toolbar = NavigationToolbar(self.canvas)#, self.mplwindow #self.mplvl.addWidget(self.toolbar) #self.canvas.mpl_connect('pick_event', self.on_pick) def rmmpl(self): self.mplvl.removeWidget(self.canvas) self.canvas.close() fig1.clf()
class Main(QMainWindow, Ui_MainWindow): """The class's docstring""" def __init__(self, ): super(Main, self).__init__() self.setupUi(self) self.menubar = self.menuBar() self.menubar.setNativeMenuBar(False) # define some callback functions here from classes.pytecpiv_dialog_conf_class import dialog_conf self.actionConfiguration.triggered.connect(self.show_conf_fn) # menu settings self.dialog_conf = dialog_conf(self) from classes.pytecpiv_dialog_fig_class import dialog_img self.dialog_img = dialog_img(self) self.new_project_menu.triggered.connect(self.create_new_project) # menu new project self.import_calib_menu.triggered.connect(self.import_calib_img) # menu data import calib image self.Dataset_comboBox.currentIndexChanged.connect(self.dataset_combobox_fn) self.Img_pushButton.clicked.connect(self.show_dialog_img) def show_dialog_img(self): self.dialog_img.show() def addmpl(self, fig): """The method's docstring""" self.canvas = FigureCanvas(fig) self.mplvl.addWidget(self.canvas) self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mplfig, coordinates=True) self.mplvl.addWidget(self.toolbar) def rmmpl(self, ): """The method's docstring""" self.mplvl.removeWidget(self.canvas) self.canvas.close() self.mplvl.removeWidget(self.toolbar) self.toolbar.close() def show_conf_fn(self): """This function makes visible the dialogue box for the configuration""" import os from pytecpiv_conf import pytecpiv_get_pref current_directory = os.getcwd() (file_exist, sources_path, projects_path) = pytecpiv_get_pref() self.dialog_conf.code_label.setText(current_directory) self.dialog_conf.sources_label.setText(sources_path) self.dialog_conf.projects_label.setText(projects_path) self.dialog_conf.show() def create_new_project(self): from PyQt5.QtWidgets import QFileDialog from pytecpiv_conf import pytecpiv_get_pref from datetime import datetime from pytecpiv_util import dprint import json file_exist, sources_path, projects_path = pytecpiv_get_pref() this_project_path = QFileDialog.getExistingDirectory(self, 'Open directory', projects_path) drive, path_and_file = os.path.splitdrive(this_project_path) path_project, project_name = os.path.split(path_and_file) # create new project project_create_time = str(datetime.now()) dprint(' ') dprint(project_create_time) dprint('creating new project') # create new project_metadata file t = os.path.isfile('project_metadata.json') if t: os.remove('project_metadata.json') metadata = {'project': []} metadata['project'].append({'project_path': this_project_path}) metadata['project'].append({'path': path_project}) metadata['project'].append({'name': project_name}) metadata['project'].append({'create_date': project_create_time}) with open('project_metadata.json', 'w') as outfile: json.dump(metadata, outfile) def import_calib_img(self): from PyQt5.QtWidgets import QFileDialog from pytecpiv_conf import pytecpiv_get_pref, pytecpiv_set_cores from pytecpiv_util import dprint from pytecpiv_import import import_img import json import os global dataset_index, current_dataset, time_step # get the preferences for where sources are located file_exist, sources_path, projects_path = pytecpiv_get_pref() # pick the directory with the raw calib images; open the sources directory source_path_calib_img = QFileDialog.getExistingDirectory(self, 'Open directory', sources_path) # get the fraction core for parallel processing from conf dialog fraction_cores = self.dialog_conf.SliderCores.value() fraction_cores = fraction_cores / 100 n_cores, use_cores = pytecpiv_set_cores(fraction_cores) dprint(str(n_cores) + ' cores available') dprint('using ' + str(use_cores) + ' cores when parallel') # open the project_metadata to get the name and path of the new project with open('project_metadata.json') as f: project_data = json.load(f) project = project_data["project"] project = project[0] project_path = project["project_path"] # create a directory named CALIB inside the new project directory to store the imported calibration images project_path_calib_img = os.path.join(project_path, 'CALIB') t = os.path.exists(project_path_calib_img) if t: dprint('saving in directory: ' + project_path_calib_img) else: os.mkdir(project_path_calib_img) dprint('saving in directory: ' + project_path_calib_img) n_img = import_img(source_path_calib_img, project_path_calib_img, use_cores) project_data['project'].append({'source_calibration': source_path_calib_img, 'number_calibration_images': n_img}) # save metadata with open('project_metadata.json', 'w') as outfile: json.dump(project_data, outfile) # create new dataset entry and select dataset_index = dataset_index + 1 current_dataset[0] = 'calibration' current_dataset[1] = 1 current_dataset[2] = 1 current_dataset[3] = 0 current_dataset[4] = 0 current_dataset[5] = project_path_calib_img current_dataset[6] = 0 current_dataset[7] = 1 current_dataset[8] = 'Greys' # change the frame number and time in gui self.frame_text.setText(str(1)) self.time_text.setText(str((1 - 1) * time_step)) # change status of chow image checkbox self.Img_checkBox.setCheckState(2) # save dataset in json file table_dataset = {dataset_index: []} table_dataset[dataset_index].append({ 'name': 'calibration', 'frame': 1, 'plot_image': 1, 'plot_vector': 0, 'plot_scalar': 0, 'image_path': project_path_calib_img, 'img_value_min': 0, 'img_value_max': 1, 'img_colormap': 'Greys' }) # save data in json file in sources with open('table_dataset.json', 'w') as outfile: json.dump(table_dataset, outfile) # change the selected combobox self.Dataset_comboBox.insertItem(int(dataset_index), 'calibration images') self.Dataset_comboBox.setCurrentIndex(int(dataset_index)) def dataset_combobox_fn(self): """ :param self: :return: """ import json from pytecpiv_util import create_fig global current_dataset, fig1 index = self.Dataset_comboBox.currentIndex() self.rmmpl() # clear the mpl for a replot if index == 0: # this is a special index with the credits & license fig1 = Figure() ax1f1 = fig1.add_subplot(111) s1 = 'pyTecPIV v0.1-alpha' s2 = 'build on Python 3.7 with the following packages:' s3 = 'numpy, scikit-image, rawpy, json, hdf5, matplotlib' s4 = 'GUI build with Qt5' s5 = 'D. Boutelier, 2020' ax1f1.margins(0, 0, tight=True) ax1f1.set_ylim([0, 1]) ax1f1.set_xlim([0, 1]) ax1f1.text(0.01, 0.95, s1, fontsize=12) ax1f1.text(0.01, 0.9, s2, fontsize=10) ax1f1.text(0.01, 0.85, s3, fontsize=10) ax1f1.text(0.01, 0.775, s4, fontsize=10) ax1f1.text(0.01, 0.675, s5, fontsize=8) ax1f1.set_aspect('equal') ax1f1.set_axis_off() else: # open the table_dataset file with open('table_dataset.json') as f: table_dataset = json.load(f) selected_dataset = table_dataset[str(index)] selected_dataset = selected_dataset[0] current_dataset[0] = selected_dataset['name'] current_dataset[1] = selected_dataset['frame'] current_dataset[2] = selected_dataset['plot_image'] current_dataset[3] = selected_dataset['plot_vector'] current_dataset[4] = selected_dataset['plot_scalar'] current_dataset[5] = selected_dataset['image_path'] current_dataset[6] = selected_dataset['img_value_min'] current_dataset[7] = selected_dataset['img_value_max'] current_dataset[8] = selected_dataset['img_colormap'] fig1 = Figure() create_fig(fig1, current_dataset) self.addmpl(fig1)
class univariategroupDlg(QtWidgets.QDialog, Ui_univariategroup): def __init__(self, parent=None): super(univariategroupDlg, self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) self.YcomboBox.addItems(DS.Lc[DS.Ic]) self.YcomboBox.setCurrentIndex(0) self.TcheckBox.setChecked(False) self.XGcheckBox.setChecked(True) self.YGcheckBox.setChecked(True) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig = Figure() ax = fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0, 1]) ax.set_ylim([0, 1]) self.addmpl(fig) def redraw(self): groups = pd.Series(DS.Gr[DS.Ir], dtype='int') gr_type = [isinstance(e, (int, np.integer)) for e in groups] if sum(gr_type) != len(groups): QtWidgets.QMessageBox.critical(self,'Error',"Groups must be all present \n and must be integers",\ QtWidgets.QMessageBox.Ok) return () data = DS.Raw[DS.Ir] data = data[self.YcomboBox.currentText()] if data.shape[1] != 1: QtWidgets.QMessageBox.critical(self,'Error',"More columns have the same name",\ QtWidgets.QMessageBox.Ok) return () YG = pd.DataFrame({ 'G': groups.values, 'Y': data.values, 'Cr': DS.Cr[DS.Ir], 'Lr': DS.Lr[DS.Ir] }) YG = YG[~data.isnull().values] YGg = YG.groupby(['G']) ngr = len(YGg) color = 'blue' fig = Figure() ax = fig.add_subplot(111) if self.CcheckBox.isChecked(): color = DS.Cc[self.YcomboBox.currentIndex() - 1] if (self.BoxradioButton.isChecked()): plt.hold = True boxes = [] nbox = [] medianprops = dict(marker='D', markeredgecolor='black', markerfacecolor=color) for key, grp in YGg: nbox.append(key) boxes.append(grp['Y']) ax.boxplot(boxes, vert=1, medianprops=medianprops) ax.set_xticklabels(nbox, rotation='vertical') if self.YcheckBox.isChecked(): if self.YlineEdit.text(): ax.set_ylabel(self.YlineEdit.text()) if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.YlineEdit.text()) if (self.ConditioningradioButton.isChecked()): for key, grp in YGg: if self.CcheckBox.isChecked(): vcol = grp['Cr'] else: vcol = cm.magma.colors[int( (len(cm.magma.colors) - 1) / ngr * key)] ax.scatter(range(1, len(grp['Y']) + 1), grp['Y'], color=vcol, marker='o', label=key) ax.legend(loc='best') elif (self.histogramradioButton.isChecked()): iqr = np.percentile(YG['Y'], [75, 25]) iqr = iqr[0] - iqr[1] n = YG['Y'].shape[0] dy = abs(float(YG['Y'].max()) - float(YG['Y'].min())) nbins = np.floor(dy / (2 * iqr) * n**(1 / 3)) + 1 nbins = 2 * nbins bins = np.linspace(float(YG['Y'].min()), float(YG['Y'].max()), nbins) for key, grp in YGg: if self.CcheckBox.isChecked(): vcol = grp['Cr'] vcol = np.unique(vcol)[0] else: vcol = cm.magma.colors[int( (len(cm.magma.colors) - 1) / ngr * key)] ax.hist(grp['Y'], bins=bins, histtype='bar', color=vcol, alpha=0.5, orientation='vertical', label=str(key)) ax.legend(loc='best') if self.TcheckBox.isChecked(): if self.TlineEdit.text(): ax.set_title(self.TlineEdit.text()) else: ax.set_title('') if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) else: ax.xaxis.grid(False) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) else: ax.yaxis.grid(False) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') self.rmmpl() self.addmpl(fig) def reset(self): self.YcomboBox.setCurrentIndex(0) self.XGcheckBox.setChecked(True) self.YGcheckBox.setChecked(True) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.TlineEdit.setText('') self.update() 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 doeplotDlg(QtWidgets.QDialog,Ui_doeplotDialog): def __init__(self,parent=None): super(doeplotDlg,self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window |QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) Lc=DS.Lc[DS.Ic] Gc=DS.Gc[DS.Ic] Lcx=Lc[-Gc] Lcy=Lc[Gc] for x in Lcy: self.responcecomboBox.addItem(str(x)) for x in Lcx: self.factorcomboBox.addItem(str(x)) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig=Figure() ax=fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0,1]) ax.set_ylim([0,1]) self.addmpl(fig) def redraw(self): if DOE.lfac is None: doemodel(self) fig=Figure() ny=self.responcecomboBox.currentIndex() nf=self.factorcomboBox.currentIndex() Lc=DS.Lc[DS.Ic] Gc=DS.Gc[DS.Ic] Lcy=Lc[Gc] Lcx=Lc[-Gc] nX=len(Lcx) data=DS.Raw.loc[DS.Ir,DS.Ic] Y=data[Lcy] X=data[Lcx] nr=X.shape[0] w_text='' if nr>2**nX: Xu=X[-X.duplicated().values] Yu=[] for i in range(Xu.shape[0]): Yu.append(Y[(X==Xu.ix[i,:]).product(axis=1).astype('bool').values].mean().values) nr=2**nX X=Xu Y=pd.DataFrame(Yu,index=X.index,columns=Y.columns) w_text='Duplicated tests are averaged' ncx=len(Lcx) Y=Y.values.astype('float') X=X.values.astype('float') if self.orderedradioButton.isChecked(): ax=fig.add_subplot(111) Y=Y[:,ny] order=Y.argsort() ind=np.arange(nr) X=X[order,:] if((X.max()==1)&(X.min()==-1)): X=X.astype('str') X[X=='-1.0']='-' X[X=='1.0']='+' X[X=='0.0']='O' else: X=X.astype('str') label=nr*[''] for i in range(nr): label[i]=' '.join(X[i,:].tolist()) ax.scatter(ind,Y[order],color='red',alpha=0.3,marker='o') ax.set_xticks(ind) ax.set_xticklabels(ind[order]+1, rotation='vertical') ax.set_xlabel('Experiment Sequence') ax.set_ylabel('Responce') ax.xaxis.grid() ax.yaxis.grid() ax.set_title('Ordered Plot for '+self.responcecomboBox.currentText()) for i in range(nr): ax.annotate(label[i],(ind[i],Y[order][i]),rotation=-90,size=14) elif self.meanradioButton.isChecked(): ax=fig.add_subplot(111) Y=Y[:,ny] vmain=np.zeros(2*ncx) Ym=np.mean(Y) labels=[] for i in range(ncx): labels=labels+['-']+[Lcx[i]]+['+']+[' '] vmain[2*i]=np.mean(Y[X[:,i]==-1]) vmain[2*i+1]=np.mean(Y[X[:,i]==1]) ind=np.arange(2*ncx) ax.scatter(ind,vmain,color='red',alpha=0.3,marker='o') ax.set_xlabel('Factors') ax.set_ylabel('Responce') ax.set_xticks(np.arange(0,2*ncx,0.5)) ax.set_xticklabels(labels,rotation='vertical') ax.set_title('Main Effects Plot for Responce: '+self.responcecomboBox.currentText()) ax.add_line(Line2D([-1,2*ncx],[Ym,Ym],color='green')) for i in range(ncx): ax.add_line(Line2D([ind[2*i],ind[2*i+1]],[vmain[2*i],vmain[2*i+1]],color='red')) elif self.mainradioButton.isChecked(): ax=fig.add_subplot(111) Y=Y[:,ny] Ym=np.mean(Y) labels=[] ind=[] vy=[] for i in range(ncx): labels=labels+['-']+[Lcx[i]]+['+']+[' '] vy=vy+[Y[X[:,i]==-1].T.tolist()]+[Y[X[:,i]==1].T.tolist()] ind=ind+len(Y[X[:,i]==-1])*[2*i]+len(Y[X[:,i]==1])*[2*i+1] ax.scatter(ind,vy,color='red',alpha=0.3,marker='o') ax.set_xlabel('Factors') ax.set_ylabel('Responce') ax.set_xticks(np.arange(0,2*ncx,0.5)) ax.set_xticklabels(labels, rotation='vertical') ax.set_title('Scatter Plot for Responce :'+self.responcecomboBox.currentText()) ax.add_line(Line2D([-1,2*ncx],[Ym,Ym],color='green')) for i in range(2*ncx): ax.add_line(Line2D([i,i],[min(vy[i]),max(vy[i])],color='red')) elif self.interactionradioButton.isChecked(): def int_plot(ax,X,Y,Ym,i,j): x=X[:,i] if(i!=j): x=x*X[:,j] y_m=np.mean(Y[x==-1]) y_p=np.mean(Y[x==+1]) ax.set_ylim([min(Y),max(Y)]) ax.scatter([0,1],[y_m,y_p],color='red',alpha=0.3,marker='o') ax.add_line(Line2D([-1,2],[Ym,Ym],color='green')) ax.add_line(Line2D([0,1],[y_m,y_p],color='red')) Y=Y[:,ny] Ym=np.mean(Y) gs=GridSpec(ncx,ncx) for i in range(ncx): for j in range(ncx): if(j>=i): ax=fig.add_subplot(gs[i,j]) int_plot(ax,X,Y,Ym,i,j) if(i==j): ax.set_ylabel('Responce') ax.set_xticks([0,1], minor=False) ax.set_xticklabels(['-','+'],minor=False) ax.set_xlabel(Lcx[i]) else: ax.xaxis.set_visible(False) elif self.blockradioButton.isChecked(): ax=fig.add_subplot(111) for i in range(nr): for j in range(ncx): if((X[i,j]!=1)&(X[i,j]!=-1)): QtWidgets.QMessageBox.critical(self,'Output Limit', 'There are more then 2 levels\n I am not able to plot',QtWidgets.QMessageBox.Ok) return() labels=np.array(range(1,ncx+1)) labels=np.delete(labels,nf) x=X[:,nf] X=np.delete(X,nf,1) Y=Y[:,ny] if(min(Y)>0): ymin=0.99*min(Y) else: ymin=1.01*min(Y) if(max(Y)>0): ymax=1.01*max(Y) else: ymax=0.99*max(Y) n_factor=math.factorial(ncx)/math.factorial(ncx-2)/2 if(n_factor>10): QtWidgets.QMessageBox.critical(self,'Output Limit', 'There are more then 10 interactions. \n Too many to be plotted!',QtWidgets.QMessageBox.Ok) return() if(n_factor==1): QtWidgets.QMessageBox.critical(self,'Output Limit', 'There are no interaction left. \n Block Plot does not apply',QtWidgets.QMessageBox.Ok) return() for i in range(ncx-1): for j in range(i,(ncx-1)): if(j>i): vm=np.zeros(4) vp=np.zeros(4) vm[0]=np.mean(Y[(x==-1)&(X[:,j]==-1)&(X[:,i]==-1)]) vm[1]=np.mean(Y[(x==-1)&(X[:,j]==-1)&(X[:,i]==+1)]) vm[2]=np.mean(Y[(x==-1)&(X[:,j]==+1)&(X[:,i]==-1)]) vm[3]=np.mean(Y[(x==-1)&(X[:,j]==+1)&(X[:,i]==+1)]) vp[0]=np.mean(Y[(x==+1)&(X[:,j]==-1)&(X[:,i]==-1)]) vp[1]=np.mean(Y[(x==+1)&(X[:,j]==-1)&(X[:,i]==+1)]) vp[2]=np.mean(Y[(x==+1)&(X[:,j]==+1)&(X[:,i]==-1)]) vp[3]=np.mean(Y[(x==+1)&(X[:,j]==+1)&(X[:,i]==+1)]) ind=[0,1,2,3] ax.set_xlabel('Factors Combinations') ax.set_ylabel('Responce') ax.set_title('Block Plot: Responce '+self.responcecomboBox.currentText()+', Factor '+ self.factorcomboBox.currentText()+', interaction '+Lcx[labels[i]-1]+'-'+Lcx[labels[j]-1]) ax.plot(ind,vm,'_',ind,vp,'+') ax.set_xticks(ind) ax.set_xticklabels(['(- -)','(-,+)','(+,-)','(+,+)'], rotation='horizontal') ax.set_xlim([-1,4]) ax.set_ylim([ymin,ymax]) currentAxis = plt.gca() for k in range(4): someX=k someY=np.mean([vm[k],vp[k]]) d=abs(vm[k]-vp[k])*1.1 currentAxis.add_patch(Rectangle((someX-.1,someY-d/2),0.2,d,fill=False)) elif self.vsfactoradioButton.isChecked(): ax=fig.add_subplot(111) for i in range(nr): for j in range(ncx): if((X[i,j]!=1)&(X[i,j]!=-1)): QtWidgets.QMessageBox.critical(self,'Output Limit', 'There are more then 2 levels\n I am not able to plot',QtWidgets.QMessageBox.Ok) return() x=X[:,nf] Y=Y[:,ny] ym=Y[x==-1] yp=Y[x==+1] ind=range(1,3) ax.set_ylabel('Responce') ax.set_title('Block Plot: Responce '+self.responcecomboBox.currentText() +' vs. Factor '+self.factorcomboBox.currentText()) ax.boxplot([ym,yp]) ax.set_xticks(ind) ax.set_xticklabels(['(-)','(+)'], rotation='horizontal') elif self.youdenradioButton.isChecked(): ax=fig.add_subplot(111) Y=Y[:,ny] nfac=len(DOE.lfac) sfac=np.array([str(i) for i in DOE.lfac]) x=np.zeros(nfac) y=np.zeros(nfac) for i in range(nfac): Xp=X[:,(DOE.lfac[i][0]-1)] for j in range(1,len(DOE.lfac[i])): Xp=Xp*X[:,(DOE.lfac[i][j]-1)] x[i]=Y[Xp==-1].mean() y[i]=Y[Xp==+1].mean() ax.set_ylabel('Average Responce for +1') ax.set_xlabel('Average Responce for -1') ax.set_title('Youden Plot: Responce :'+self.responcecomboBox.currentText()) ax.scatter(x,y,color='red',alpha=0.3,marker='o') ax.scatter(Y.mean(),Y.mean(),color='blue',s=60,marker='+') ax.axhline(y=Y.mean(),color='red',linewidth=1.5,zorder=0) ax.axvline(x=Y.mean(),color='red',linewidth=1.5,zorder=0) for i in range(nfac): ax.annotate(sfac[i],(x[i],y[i]),rotation=0,size=12) elif self.effectradioButton.isChecked(): ax=fig.add_subplot(111) Y=Y[:,ny] nfac=len(DOE.lfac) sfac=np.array([str(i) for i in DOE.lfac]) x=np.zeros(nfac) y=np.zeros(nfac) for i in range(nfac): Xp=X[:,(DOE.lfac[i][0]-1)] for j in range(1,len(DOE.lfac[i])): Xp=Xp*X[:,(DOE.lfac[i][j]-1)] x[i]=Y[Xp==-1].mean() y[i]=Y[Xp==+1].mean() eff=abs(x-y) order=eff.argsort() width=0.35 ind=np.arange(1,nfac+1) ax.bar(ind,eff[order],width,color='blue') ax.set_xticks(ind+width/2) ax.set_xticklabels(sfac[order], rotation='vertical') ax.set_xlabel('Factors') ax.set_ylabel('|Effects|') ax.set_title('Effect Plot for '+self.responcecomboBox.currentText()) elif self.halfradioButton.isChecked(): ax=fig.add_subplot(111) Y=Y[:,ny] nfac=len(DOE.lfac) sfac=np.array([str(i) for i in DOE.lfac]) x=np.zeros(nfac) y=np.zeros(nfac) for i in range(nfac): Xp=X[:,(DOE.lfac[i][0]-1)] for j in range(1,len(DOE.lfac[i])): Xp=Xp*X[:,(DOE.lfac[i][j]-1)] x[i]=Y[Xp==-1].mean() y[i]=Y[Xp==+1].mean() eff=abs(x-y) order=eff.argsort() ind=[sp.stats.halfnorm.ppf(i/(nfac+1)) for i in range(1,nfac+1)] ax.scatter(ind,eff[order],color='blue',s=60,marker='+') for i in range(nfac): ax.annotate(sfac[order][i],(ind[i],eff[order][i]),rotation=-90,size=12) ax.set_xlabel('Half Normal Distribution Order') ax.set_ylabel('Ordered |Effects|') ax.set_title('Half Normal Distribution Plot for '+self.responcecomboBox.currentText()) if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): if self.YlineEdit.text(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) else: ax.xaxis.grid(False) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) else: ax.yaxis.grid(False) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x',which='both',bottom='off',top='off',labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y',which='both',left='off',right='off',labelleft='off') ax.annotate(w_text,xy=(0.75,0.95),xycoords='figure fraction',fontsize=8) self.rmmpl() self.addmpl(fig) def reset(self): self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(False) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.update() 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 VisualizerDialog(QtWidgets.QWidget): """ Defines a QDialog that is used to visualize the data in the main data preview area. It connects the dataChanged signal of the abstract data table and the sectionMoved signal of the header of the table view to the update_plot() method so that the method is called whenever either the content of the results table changes, or the columns are moved. The visualizer dialog has a 'Freeze visualization' checkbox. If the box is checked, the visualization is not updated on changes. FIXME: Live updates are currently disabled. """ def __init__(self, parent=None): super(VisualizerDialog, self).__init__(parent) self.ui = Ui_Visualizer() self.ui.setupUi(self) self.ui.progress_bar.setRange(0, 0) self.ui.box_visualize.hide() self.ui.progress_bar.hide() self.ui.label.hide() self.setWindowIcon(options.cfg.icon) self.margin_dialoglog_stack = [] self.frozen = False self.spinner = QtWidgets.QSpinBox() self.spinner.setFrame(True) self.spinner.setButtonSymbols(QtWidgets.QAbstractSpinBox.UpDownArrows) self.spinner.setMaximum(10) self.spinner.setMinimum(1) self.spinner.setSuffix(" year(s)") self.spinner_label = QtWidgets.QLabel("Bandwidth: ") self.spinner.valueChanged.connect(self.update_plot) self.combo_x_function = QtWidgets.QComboBox() self.label_x_function = QtWidgets.QLabel("Variable on &X axis:") self.label_x_function.setBuddy(self.combo_x_function) self.combo_y_function = QtWidgets.QComboBox() self.label_y_function = QtWidgets.QLabel("Variable on &Y axis:") self.label_y_function.setBuddy(self.combo_y_function) self.toolbar = None self.canvas = None try: self.resize(options.settings.value("visualizer_size")) except TypeError: pass def closeEvent(self, event): options.settings.setValue("visualizer_size", self.size()) self.close() def update_plot(self): """ Update the plot. During the update, the canvas and the navigation toolbar are replaced by new instances, as is the figure used by the visualizer. Finally, the draw() method of the visualizer is called to plot the visualization again. """ if hasattr(self.toolbar, "margin_dialog"): self.toolbar.margin_dialog.hide() self.toolbar.margin_dialog.close() get_toplevel_window().widget_list.remove(self.toolbar.margin_dialog) del self.toolbar.margin_dialog if self.smooth: self.spinner.setEnabled(False) self.visualizer.update_data(bandwidth=self.spinner.value()) else: self.visualizer.update_data() kwargs = {} if self.visualizer.numerical_axes == 2: try: kwargs["func_y"] = self._function_list[self.combo_y_function.currentIndex()] kwargs["column_y"] = None except IndexError: kwargs["func_y"] = None kwargs["column_y"] = utf8(self.combo_y_function.currentText()) if self.visualizer.numerical_axes == 1: try: kwargs["func_x"] = self._function_list[self.combo_x_function.currentIndex()] kwargs["column_x"] = None except IndexError: kwargs["func_x"] = None kwargs["column_x"] = utf8(self.combo_x_function.currentText()) self.visualizer.setup_figure() self.remove_matplot() self.add_matplot() self.visualizer.draw(**kwargs) self.visualizer.g.fig.tight_layout() self.visualizer.adjust_axes() self.visualizer.adjust_fonts() if self.smooth: self.spinner.setEnabled(True) self.visualizer.g.fig.tight_layout() if hasattr(self.toolbar, "margin_dialog"): self.toolbar.configure_subplots() def add_matplot(self): """ Add a matplotlib canvas and a navigation bar to the dialog. """ if not self.canvas: self.canvas = FigureCanvas(self.visualizer.g.fig) self.ui.verticalLayout.addWidget(self.canvas) self.canvas.setParent(self.ui.box_visualize) self.canvas.setFocusPolicy(QtCore.Qt.ClickFocus) self.canvas.setFocus() if not self.toolbar: self.toolbar = CoqNavigationToolbar(self.canvas, self, True) if (self.visualizer.numerical_axes == 2 and self.visualizer.function_list): self.toolbar.addWidget(self.label_y_function) self.toolbar.addWidget(self.combo_y_function) if (self.visualizer.numerical_axes == 1 and self.visualizer.function_list): self.toolbar.addWidget(self.label_x_function) self.toolbar.addWidget(self.combo_x_function) if options.cfg.experimental: self.toolbar.check_freeze.stateChanged.connect(self.toggle_freeze) if self.smooth: self.toolbar.addWidget(self.spinner_label) self.toolbar.addWidget(self.spinner) self.ui.navigation_layout.addWidget(self.toolbar) else: self.toolbar.canvas = self.canvas self.canvas.mpl_connect('key_press_event', self.keyPressEvent) self.canvas.mpl_connect('button_press_event', self.onclick) def onclick(self, event): """ Pass any click event onward to the visualizer, unless the dialog is in panning or zooming mode. """ if not self.toolbar.isPanning() and not self.toolbar.isZooming(): self.visualizer.onclick(event) def remove_matplot(self): """ Remove the matplotlib canvas and the navigation bar from the dialog. """ if self.canvas: self.canvas.close() self.ui.verticalLayout.removeWidget(self.canvas) self.canvas = None def close(self, *args): """ Close the visualizer widget, disconnect the signals, and remove the visualizer from the list of visualizers when closing.""" try: self.disconnect_signals() except TypeError: # TypeErrors can be raised if there is no connected object. This # can be ignored: pass self.remove_matplot() super(VisualizerDialog, self).close() try: get_toplevel_window().widget_list.remove(self) except ValueError: pass try: del self.visualizer except AttributeError: pass def keyPressEvent(self, event): """ Catch key events so that they can be passed on to the matplotlib toolbar. """ try: key_press_handler(event, self.canvas, self.toolbar) except AttributeError: # Attribute errors seem to occur when a key is pressed while the # mouse is outside of the figure area: # # AttributeError: 'QKeyEvent' object has no attribute 'inaxes' # # This exception may be safely ignored. pass except Exception as e: print(e) raise e def connect_signals(self): """ Connect the dataChanged signal of the abstract data table and the sectionMoved signal of the header of the table view to the update_plot() method so that the method is called whenever either the content of the results table changes, or the columns are moved.""" if not options.cfg.experimental: return get_toplevel_window().table_model.dataChanged.connect(self.update_plot) get_toplevel_window().table_model.layoutChanged.connect(self.update_plot) self.visualizer._view.horizontalHeader().sectionMoved.connect(self.update_plot) def disconnect_signals(self): """ Disconnect the dataChanged signal of the abstract data table and the sectionMoved signal of the header of the table view so that the update_plot() method is not called anymore when the content of the results table changes or the columns are moved.""" if not options.cfg.experimental: return get_toplevel_window().table_model.dataChanged.disconnect(self.update_plot) get_toplevel_window().table_model.layoutChanged.disconnect(self.update_plot) self.visualizer._view.horizontalHeader().sectionMoved.disconnect(self.update_plot) def toggle_freeze(self): """ Toggle the 'frozen' state of the visualization. This method is called whenever the 'Freeze visualization' box is checked or unchecked. If the box is checked, the visualization is frozen, and the plot is not updated if the content of the results table changes or if the columns of the table view are moved. If the box is unchecked (the default), the visualization is not frozen, and the plot is updated on changes to the results table. """ if not options.cfg.experimental: return self.frozen = not self.frozen if self.frozen: self.disconnect_signals() else: self.connect_signals() def Plot(self, model, view, visualizer_class, parent=None, **kwargs): """ Use the visualization type given as 'visualizer_class' to display the data given in the abstract data table 'model', using the table view given in 'view'. """ self.smooth = kwargs.get("smooth", False) self.visualizer = visualizer_class(model, view, parent=None, **kwargs) self._function_list = self.visualizer.function_list try: self.combo_x_function.addItems([fnc.get_name() for fnc in self._function_list]) for x in self.visualizer._number_columns: if x not in [fnc(columns=self.visualizer._group_by, session=get_toplevel_window().Session).get_id() for fnc in self._function_list]: self.combo_x_function.addItem(x) self.combo_x_function.currentIndexChanged.connect(self.update_plot) except AttributeError: pass try: self.combo_y_function.addItems([fnc.get_name() for fnc in self._function_list] + self.visualizer._number_columns) self.combo_y_function.currentIndexChanged.connect(self.update_plot) except AttributeError: pass if not self.visualizer._table.empty: self.setVisible(True) self.connect_signals() get_toplevel_window().widget_list.append(self) self.add_matplot() self.thread = classes.CoqThread(self.visualizer.draw, parent=self) self.thread.taskStarted.connect(self.startplot) self.thread.taskFinished.connect(self.finishplot) self.thread.taskException.connect(self.plotexception) self.visualizer.moveToThread(self.thread) self.thread.start() def plotexception(self, e): print(e) QtWidgets.QMessageBox.critical(self, "Error while plotting – Coquery", msg_visualization_error.format(self.exception), QtWidgets.QMessageBox.Ok, QtWidgets.QMessageBox.Ok) def startplot(self): self.ui.box_visualize.hide() self.ui.frame.setDisabled(True) self.ui.frame_placeholder.show() self.ui.progress_bar.show() self.ui.label.show() self.repaint() def finishplot(self): self.ui.frame_placeholder.hide() self.ui.progress_bar.hide() self.ui.label.hide() self.ui.box_visualize.show() self.ui.frame.setDisabled(False) self.repaint() self.visualizer.g.fig.canvas.draw() self.visualizer.g.fig.tight_layout() self.visualizer.adjust_axes() self.visualizer.adjust_fonts() self.visualizer.set_hover() self.visualizer.g.fig.tight_layout() self.show() # Create an alert in the system taskbar to indicate that the # visualization has completed: options.cfg.app.alert(self, 0)
def close(self, *args, **kwargs): for widget in [self.toolbar, self.smartScale, self.VCursor]: widget.close() widget.deleteLater() FigureCanvas.close(self, *args, **kwargs)
class Application(Ui_QtBaseClass, Ui_MainWindow): def __init__(self, parent=None): Ui_QtBaseClass.__init__(self, parent) self._figure = None self.setupUi(self) self.update_parameters(self.static_default_parameters()) self.show() self.on_click_submit() # load graph based on default values # (figure_width, figure_height) = tuple(self._figure.figure.get_size_inches) # self.update_parameters(figure_size_width = figure_width, figure_size_height = figure_height, figure_size_scale = 1.0) # connect button to function on_click self.pushButton_submit.clicked.connect(self.on_click_submit) self.pushButton_quit.clicked.connect(self.on_click_quit) self.pushButton_update.clicked.connect(self.on_click_update) self.pushButton_save.clicked.connect(self.on_click_save) def on_click_submit(self): p = self.get_parameters() print("PARSED PARAMETERS ARE:") for i in p: print(i + ': ' + str(p[i])) time.sleep(0.1) self._figure = main_function( p['time_step'], p['time_cap'], p['gas_emissivity'], p['vent_mass_flow_rate'], p['specimen_exposed_area'], p['specimen_volume'], p['specimen_heat_of_combustion'], p['specimen_burning_rate'], p['specimen_density'], p['lining_surface_emissivity'], p['lining_surface_area'], p['lining_thickness'], p['lining_thermal_conductivity'], p['lining_density'], p['lining_specific_heat'] ) self.add_mpl(self._figure.figure) self.on_click_save() return self.get_parameters() def on_click_update(self): self.remove_mpl() self.on_click_submit() self.on_click_save() def on_click_quit(self): self.close() def on_click_save(self): old_size = self._figure.figure.get_size_inches().tolist() p = self.get_parameters() new_size = [p['figure_size_width']*p['figure_size_scale'], p['figure_size_height']*p['figure_size_scale']] self._figure.figure.set_size_inches(new_size) self._figure.save_figure("output") print("Figure saved at: " + os.getcwd()) self._figure.figure.set_size_inches(old_size) self.canvas.draw() def add_mpl(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 remove_mpl(self): self.mplvl.removeWidget(self.canvas) self.canvas.close() self.mplvl.removeWidget(self.toolbar) self.toolbar.close() def update_parameters(self, parameters): for key in parameters: parameters[key] = str(parameters[key]) self.lineEdit_timeStep.setText(parameters['time_step']) self.lineEdit_timeCap.setText(parameters['time_cap']) self.lineEdit_gasEmissivity.setText(parameters['gas_emissivity']) self.lineEdit_ventMassFlowRate.setText(parameters['vent_mass_flow_rate']) self.lineEdit_specimenExposedArea.setText(parameters['specimen_exposed_area']) self.lineEdit_specimenVolume.setText(parameters['specimen_volume']) self.lineEdit_specimenHeatOfCombustion.setText(parameters['specimen_heat_of_combustion']) self.lineEdit_specimenBurningRate.setText(parameters['specimen_burning_rate']) self.lineEdit_specimenDensity.setText(parameters['specimen_density']) self.lineEdit_liningSurfaceEmissivity.setText(parameters['lining_surface_emissivity']) self.lineEdit_liningSurfaceArea.setText(parameters['lining_surface_area']) self.lineEdit_liningThickness.setText(parameters['lining_thickness']) self.lineEdit_liningThermalConductivity.setText(parameters['lining_thermal_conductivity']) self.lineEdit_liningDensity.setText(parameters['lining_density']) self.lineEdit_liningSpecificHeat.setText(parameters['lining_specific_heat']) self.lineEdit_figure_size_width.setText(parameters['figure_size_width']) self.lineEdit_figure_size_height.setText(parameters['figure_size_height']) self.lineEdit_figure_size_scale.setText(parameters['figure_size_scale']) pass def get_parameters(self): # self.lineEdit_timeStep.text() # self.lineEdit_timeCap.text() # self.lineEdit_gasEmissivity.text() # self.lineEdit_ventMassFlowRate.text() # # self.lineEdit_specimenExposedArea.text() # self.lineEdit_specimenVolume.text() # self.lineEdit_specimenHeatOfCombustion.text() # self.lineEdit_specimenBurningRate.text() # self.lineEdit_specimenDensity.text() # # self.lineEdit_liningSurfaceEmissivity.text() # self.lineEdit_liningSurfaceArea.text() # self.lineEdit_liningThickness.text() # self.lineEdit_liningThermalConductivity.text() # self.lineEdit_liningDensity.text() # self.lineEdit_liningSpecificHeat.text() parameters={ "time_step": self.lineEdit_timeStep.text(), "time_cap": self.lineEdit_timeCap.text(), 'gas_emissivity': self.lineEdit_gasEmissivity.text(), 'vent_mass_flow_rate': self.lineEdit_ventMassFlowRate.text(), 'specimen_exposed_area': self.lineEdit_specimenExposedArea.text(), 'specimen_volume': self.lineEdit_specimenVolume.text(), 'specimen_heat_of_combustion': self.lineEdit_specimenHeatOfCombustion.text(), 'specimen_burning_rate': self.lineEdit_specimenBurningRate.text(), 'specimen_density': self.lineEdit_specimenDensity.text(), 'lining_surface_emissivity': self.lineEdit_liningSurfaceEmissivity.text(), 'lining_surface_area': self.lineEdit_liningSurfaceArea.text(), 'lining_thickness': self.lineEdit_liningThickness.text(), 'lining_thermal_conductivity': self.lineEdit_liningThermalConductivity.text(), 'lining_density': self.lineEdit_liningDensity.text(), 'lining_specific_heat': self.lineEdit_liningSpecificHeat.text(), 'figure_size_width': self.lineEdit_figure_size_width.text(), 'figure_size_height': self.lineEdit_figure_size_height.text(), 'figure_size_scale': self.lineEdit_figure_size_scale.text(), } for item in parameters: parameters[item] = float(eval(parameters[item])) return parameters def run_simulation(self): d=1 @staticmethod def static_default_parameters(): parameters = { 'time_step': 0.5, 'time_cap': '60*60*2', 'gas_emissivity': 0.7, 'vent_mass_flow_rate': 0.0735, 'specimen_exposed_area': 1, 'specimen_volume': 0.4, 'specimen_heat_of_combustion': '19e6', 'specimen_burning_rate': '0.7/1000./60.', 'specimen_density': 640, 'lining_surface_emissivity': 0.7, 'lining_surface_area': '(4*3+3*1.5+1.5*4)*2', 'lining_thickness': .05, 'lining_thermal_conductivity': 1.08997, 'lining_density': 1700, 'lining_specific_heat': 820, 'figure_size_width': 10, 'figure_size_height': 7.5, 'figure_size_scale': 0.6, } return parameters
class plsplotDlg(QtWidgets.QDialog,Ui_plsplotDialog): def __init__(self,parent=None): super(plsplotDlg,self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window |QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) for x in range(PLS.ncp): self.XcomboBox.addItem(str(x+1)) self.YcomboBox.addItem(str(x+1)) Lc=DS.Lc[DS.Ic] Gc=DS.Gc[DS.Ic] Lcy=Lc[Gc] for x in Lcy: self.responcecomboBox.addItem(str(x)) self.XcomboBox.setCurrentIndex(0) self.YcomboBox.setCurrentIndex(1) self.VcheckBox.setChecked(False) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig=Figure() ax=fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0,1]) ax.set_ylim([0,1]) self.addmpl(fig) def redraw(self): fig=Figure() ax=fig.add_subplot(111) c1=self.XcomboBox.currentIndex() c2=self.YcomboBox.currentIndex() ny=self.responcecomboBox.currentIndex() Yname=self.responcecomboBox.currentText() Ts=DS.Ts[DS.Ir] Gc=DS.Gc[DS.Ic] Cr=DS.Cr[DS.Ir] Cr=Cr[-Ts] Lr=DS.Lr[DS.Ir] Lr=Lr[-Ts] Lc=DS.Lc[DS.Ic] Lcx=Lc[-Gc] Lcy=Lc[Gc] Cc=DS.Cc[DS.Ic] Ccx=Cc[-Gc] ncx=len(Lcx) ncy=len(Lcy) nr=len(Lr) Y=DS.Raw.loc[DS.Ir,DS.Ic][Lcy] Y=Y[-Ts] if(self.fittedradioButton.isChecked()): Y=Y.values ax.scatter(Y[:,ny],PLS.Ys[:,ny],color=Cr,alpha=0.3,marker='o') xmin,xmax=ax.get_xlim() ax.set_ylim([xmin,xmax]) ax.set_xlabel(Yname+' measured') ax.set_ylabel(Yname+' fitted') ax.set_title('Fitted vs. Measured Plot for '+Yname+ ' : Model '+str(PLS.ncp)+' components') ax.add_line(Line2D([xmin,xmax],[xmin,xmax],color='red')) if self.VcheckBox.isChecked(): for i in range(nr): ax.annotate(Lr[i],(Y[:,c1][i],PLS.Ys[:,c1][i])) elif(self.allfittedradioButton.isChecked()): Yc=pd.melt(pd.DataFrame(PLS.Yc)) Ysc=pd.melt(pd.DataFrame(PLS.Ysc)) df=pd.DataFrame(dict(X=Yc['value'],Y=Ysc['value'],point=Yc['variable'])) np.random.seed(nr) groups=df.groupby('point') colors=pd.tools.plotting._get_standard_colors(len(groups),color_type='random') ax.set_prop_cycle(cycler('color',colors)) ax.margins(0.05) for group in groups: ax.plot(group[1].X,group[1].Y, marker='o',linestyle='',ms=5,label=Lcy[group[0]]) ax.set_xlabel('Measured Data') ax.set_ylabel('Fitted Data') Dmin=min([Yc.value.min(),Ysc.value.min()]) Dmax=max([Yc.value.max(),Ysc.value.max()]) ax.set_xlim([Dmin,Dmax]) ax.set_ylim([Dmin,Dmax]) ax.set_title('Measured vs. Fitted Data') ax.add_line(Line2D([Dmin,Dmax],[Dmin,Dmax],color='red')) ax.legend(loc='best') elif(self.coefficientradioButton.isChecked()): B=PLS.B[:,ny] ind=np.array(range(1,ncx+1)) if(ncx>30): itick=np.linspace(0,ncx-1,20).astype(int) ltick=Lcx[itick] else: itick=ind ltick=Lcx if self.CcheckBox.isChecked(): vcol=Ccx else: vcol='blue' ax.bar(ind,B,align='center',color=vcol) ax.set_xticks(itick) ax.set_xticklabels(ltick,rotation='vertical') ax.set_xlim([0,ncx+1]) ax.set_xlabel('Variables') ax.set_ylabel('Coefficients') ax.set_title('Coefficients for '+Yname+' : Model '+str(PLS.ncp)+' components') elif self.wiradioButton.isChecked(): WS=np.dot(PLS.WS,np.linalg.inv(PLS.C)) txt=range(1,ncx+1) if self.VcheckBox.isChecked(): txt=Lcx vcol=ncx*['blue'] if self.CcheckBox.isChecked(): vcol=Ccx ax.scatter(WS[:,c1],WS[:,c2],alpha=0.3,color=vcol,s=30,marker='o') ax.scatter(0,0,color='red',s=60,marker='+') for i in range(ncx): ax.annotate(txt[i],(WS[:,c1][i],WS[:,c2][i])) lim=[WS.min(),0, WS.max()] vlim=max(abs(np.array(lim)))*1.2 ax.set_xlim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_ylim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_title('Weight Plot: Model with '+str(PLS.ncp)+' components') ax.set_xlabel('W*'+str(c1+1)) ax.set_ylabel('W*'+str(c2+1)) elif(self.qiradioButton.isChecked()): txt=range(1,ncy+1) if self.VcheckBox.isChecked(): txt=Lcx vcol=ncy*['blue'] if self.CcheckBox.isChecked(): vcol=Ccx ax.scatter(PLS.Q[:,c1],PLS.Q[:,c2],alpha=0.3,color=vcol,s=30,marker='o') ax.scatter(0,0,color='red',s=60,marker='+') for i in range(ncy): ax.annotate(txt[i],(PLS.Q[:,c1][i],PLS.Q[:,c2][i])) lim=[PLS.Q.min(),0,PLS.Q.max()] vlim=max(abs(np.array(lim)))*1.2 ax.set_xlim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_ylim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_title('Loading Plot: Model with '+str(PLS.ncp)+' components') ax.set_xlabel('C'+str(c1+1)) ax.set_ylabel('C'+str(c2+1)) elif(self.wqiradioButton.isChecked()): WS=np.dot(PLS.WS,np.linalg.inv(PLS.C)) txtc=range(1,ncy+1) txtw=range(1,ncx+1) if self.VcheckBox.isChecked(): txt=DS.Lc[DS.Ic] txtc=txt[DS.Gc[DS.Ic]] txtw=txt[-DS.Gc[DS.Ic]] vcolc=ncy*['red'] vcolw=ncx*['blue'] if self.CcheckBox.isChecked(): vcol=DS.Cc[DS.Ic] vcolc=vcol[DS.Gc[DS.Ic]] vcolw=vcol[-DS.Gc[DS.Ic]] ax.scatter(PLS.Q[:,c1],PLS.Q[:,c2],alpha=0.3,color=vcolc,s=30,marker='o') ax.scatter(WS[:,c1],WS[:,c2],alpha=0.3,color=vcolw,s=30,marker='o') ax.scatter(0,0,color='red',s=60,marker='+') for i in range(ncy): ax.annotate(txtc[i],(PLS.Q[:,c1][i],PLS.Q[:,c2][i])) for i in range(ncx): ax.annotate(txtw[i],(WS[:,c1][i],WS[:,c2][i])) lim=[PLS.Q.min(),0,PLS.Q.max(),WS.max(),WS.min()] vlim=max(abs(np.array(lim)))*1.2 ax.set_xlim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_ylim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_title('Loading Plot: Model with '+str(PLS.ncp)+' components') ax.set_xlabel('W* Q'+str(c1+1)) ax.set_ylabel('W* Q'+str(c2+1)) elif(self.ht2radioButton.isChecked()): ind=np.array(range(1,nr+1)) colors=[] for i in range(nr): colors.append('blue') if(PLS.HT2[i]>PLS.T95): colors[i]='red' if(nr>30): itick=np.linspace(0,nr-1,20).astype(int) ltick=Lr[itick] else: itick=ind ltick=Lr ax.bar(ind,PLS.HT2,align='center',color=colors) ax.set_xticks(itick) ax.set_xticklabels(ltick,rotation='vertical') ax.set_xlabel('Object') ax.set_title('Hoteling T2 for '+str(PLS.ncp)+' components model') ax.axhline(y=PLS.T95,color='red',linewidth=1.5,zorder=0) ax.annotate('95%',xy=(0,PLS.T95),color='red') ax.axhline(y=PLS.T99,color='red',linewidth=1.5,zorder=0) ax.annotate('99%',xy=(0,PLS.T99),color='red') ax.set_ylim([0,1.2*max([PLS.T99,max(PLS.HT2)])]) ax.set_xlim([0,nr+1]) elif(self.scoreradioButton.isChecked()): st2=PLS.T.var(axis=0) alpha=(100-self.alphaspinBox.value())/100 fn=np.array(range(1,(PLS.ncp+1))) fd=(nr+1)-fn fn =tuple(fn) fd =tuple(fd) falpha=sp.stats.f.ppf(alpha,fn,fd) colors=[] txt=[] for i in range(nr): txt.append('') colors.append('blue') rp=(PLS.T[:,c1][i])**2/st2[c1]+(PLS.T[:,c2][i])**2/st2[c2] if(rp>falpha[PLS.ncp-1]): colors[i]='red' txt[i]=Lr[i] ax.scatter(PLS.T[:,c1],PLS.T[:,c2],alpha=0.3,color=colors,s=30,marker='o') ax.scatter(0,0,color='red',s=60,marker='+') for i in range(nr): ax.annotate(txt[i],(PLS.T[:,c1][i],PLS.T[:,c2][i])) lim=[PLS.T.min(),0,PLS.T.max()] vlim=max(abs(np.array(lim)))*1.2 ax.set_xlim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_ylim([np.copysign(vlim,lim[0]),np.copysign(vlim,lim[2])]) ax.set_title('Score Plot: Model with '+str(PLS.ncp)+' components') ax.set_xlabel('Comp.'+str(c1+1)+' ('+str(round(st2[c1]/PLS.ncp*100,2))+'%)') ax.set_ylabel('Comp.'+str(c2+1)+' ('+str(round(st2[c2]/PLS.ncp*100,2))+'%)') ella=Ellipse(xy=(0,0),width=2*math.sqrt(falpha[PLS.ncp-1]*st2[c1]),height=2*math.sqrt(falpha[PLS.ncp-1]*st2[c2]),color='red') ella.set_facecolor('none') ax.add_artist(ella) alpha=alpha*100 ax.annotate(str(round(alpha,0))+'%',xy=(0,-math.sqrt(falpha[PLS.ncp-1]*st2[c2])),color='red') elif(self.spexradioButton.isChecked()): T95=sp.stats.chi2.ppf(0.95,nr)/(nr-PLS.ncp) T99=sp.stats.chi2.ppf(0.99,nr)/(nr-PLS.ncp) ind=np.array(range(1,nr+1)) if(nr>30): itick=np.linspace(0,nr-1,20).astype(int) ltick=Lr[itick] else: itick=ind ltick=Lr ax.bar(ind,PLS.SPEX,color='blue') ax.set_xticks(itick) ax.set_xticklabels(ltick,rotation='vertical') ax.set_xlabel('X Variables') ax.set_ylabel('SPE X') ax.set_title('SPE X for '+str(PLS.ncp)+' components model') ax.set_ylim([0,1.2*max([max(PLS.SPEX),T99])]) ax.set_xlim([0,max(itick)]) ax.axhline(y=T95,color='red',linewidth=1.5) ax.annotate('95%',xy=(0,T95),color='red') ax.axhline(y=T99,color='red',linewidth=1.5) ax.annotate('99%',xy=(0,T99),color='red') elif self.speyradioButton.isChecked(): T95=sp.stats.chi2.ppf(0.95,nr)/(nr-PLS.ncp) T99=sp.stats.chi2.ppf(0.99,nr)/(nr-PLS.ncp) ind=np.array(range(1,nr+1)) if(nr>30): itick=np.linspace(0,nr-1,20).astype(int) ltick=Lr[itick] else: itick=ind ltick=Lr ax.bar(ind,PLS.SPEY,color='blue') ax.set_xticks(itick) ax.set_xticklabels(ltick,rotation='vertical') ax.set_xlabel('Y Variables') ax.set_ylabel('SPE Y') ax.set_title('SPE Y for '+str(PLS.ncp)+' components model') ax.set_ylim([0,1.2*max([max(PLS.SPEY),T99])]) ax.set_xlim([0,max(itick)]) ax.axhline(y=T95,color='red',linewidth=1.5) ax.annotate('95%',xy=(0,T95),color='red') ax.axhline(y=T99,color='red',linewidth=1.5) ax.annotate('99%',xy=(0,T99),color='red') elif self.cvradioButton.isChecked(): X0=pd.DataFrame(PLS.Xc) Y0=pd.DataFrame(PLS.Yc) np.random.seed(nr) kf=sk.model_selection.KFold(n_splits=self.segmentspinBox.value(),shuffle=True) Ycv=pd.DataFrame(0,index=range(nr),columns=range(ncy)) for train, test in kf.split(X0): X=X0.iloc[train,:] Y=Y0.iloc[train,:] Xm,Ym,Sx,Sy,Xc,Yc,SSX,SSY,P,C,U,T,Q,W,WS,B,Ysc,Ys,R2,SPEX,SPEY,HT2,VIP,T95,T99=pls_model(X,Y,PLS.ncp,False,False,False) X_test=X0.iloc[test,:] Ycv.iloc[test,:]=np.dot(X_test,B) Y0=Y0.values PLS.Ycv=Ycv.values Ycvs=PLS.Ym+PLS.Sy*Ycv.T PLS.Ycvs=Ycvs.T.values Y=PLS.Ym+PLS.Sy*Y0.T Y=Y.T if self.CcheckBox.isChecked(): vcol=Cr else: vcol='red' ax.scatter(Y[:,ny],PLS.Ycvs.iloc[:,ny],color=vcol,alpha=0.3,marker='o') if self.VcheckBox.isChecked(): for i in range(nr): ax.annotate(Lr[i],(Y[:,ny][i],PLS.Ycvs.iloc[:,ny][i])) ax.set_xlabel(Yname+' measured') ax.set_ylabel(Yname+' CV predicted') xmin,xmax=ax.get_xlim() ax.set_ylim([xmin,xmax]) ax.set_title('CV Predicted vs. Measured Plot for '+Yname+' : Model '+str(PLS.ncp)+' components') ax.add_line(Line2D([xmin,xmax],[xmin,xmax],color='red')) elif self.turadioButton.isChecked(): if self.CcheckBox.isChecked(): vcol=Cr else: vcol='red' ax.scatter(PLS.T[:,c1],PLS.U[:,c1],color=vcol,alpha=0.3,marker='o') if self.VcheckBox.isChecked(): for i in range(nr): ax.annotate(Lr[i],(PLS.T[:,c1][i],PLS.U[:,c1][i])) ax.set_xlabel('T('+str(c1+1)+')') ax.set_ylabel('U('+str(c1+1)+')') ax.set_title('T vs. U Plot') elif self.vipradioButton.isChecked(): ind=np.array(range(1,ncx+1)) if(ncx>30): itick=np.linspace(0,ncx-1,20).astype(int) ltick=Lcx[itick] else: itick=ind ltick=Lcx colors=[] for i in range(ncx): colors.append('blue') if(PLS.VIP[i]>1): colors[i]='red' ax.bar(ind,PLS.VIP,align='center',color=colors) ax.set_xticks(itick) ax.set_xticklabels(ltick,rotation='vertical') ax.set_xlim([0,max(itick)+1]) ax.set_xlabel('Variables') ax.yaxis.grid() ax.set_title('Variable Importance Plot (VIP): Model '+str(PLS.ncp)+' components') if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): if self.YlineEdit.text(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) else: ax.xaxis.grid(False) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) else: ax.yaxis.grid(False) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x',which='both',bottom='off',top='off',labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y',which='both',left='off',right='off',labelleft='off') self.rmmpl() self.addmpl(fig) def reset(self): self.XcomboBox.setCurrentIndex(0) self.YcomboBox.setCurrentIndex(1) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(False) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.update() 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 regplotDlg(QtWidgets.QDialog, Ui_regplot): def __init__(self, parent=None): super(regplotDlg, self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) self.TcheckBox.setChecked(True) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig = Figure() ax = fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0, 1]) ax.set_ylim([0, 1]) self.addmpl(fig) def redraw(self): fig = Figure() ax = fig.add_subplot(111) data = DS.Raw.loc[DS.Ir, DS.Ic] Gc = DS.Gc[DS.Ic] Ts = DS.Ts[DS.Ir] X = data.loc[:, -Gc] Y = data.loc[:, Gc] Yname = Y.columns[0] X = X[-Ts] Y = Y[-Ts] Lr = DS.Lr[DS.Ir] Cr = DS.Cr[DS.Ir] Lr = Lr[-Ts] Cr = Cr[-Ts] nr = len(Lr) Lc = DS.Lc[DS.Ic] Lcx = Lc[-Gc] ncx = len(Lcx) Lcy = Lc[Gc] scoretr = REG.lr.score(X, Y) np.random.seed(REG.seed) if self.coeffradioButton.isChecked(): B = REG.lr.coef_ ind = np.array(range(1, ncx + 1)) if (ncx > 30): itick = np.linspace(0, ncx - 1, 20).astype(int) ltick = Lcx[itick] else: itick = ind ltick = Lcx vcol = [] for i in ind: if (REG.pS[i] < 0.05): vcol.append('red') else: vcol.append('blue') ax.bar(ind, B, align='center', color=vcol, label='Score: {:04.2f}'.format(scoretr)) ax.errorbar(ind, B, yerr=REG.dB[1:], fmt='o', ecolor='green') ax.set_xticks(itick) ax.set_xticklabels(ltick, rotation='vertical') ax.set_xlim([0, ncx + 1]) ax.set_xlabel('Variables') ax.set_ylabel('Coefficients') ax.set_title('Regression for ' + Lcy[0] + ' Intercept: {:10.4f}-{:10.4f}-{:10.4f}'.format( REG.lr.intercept_ - REG.dB[0], REG.lr.intercept_, REG.lr.intercept_ + REG.dB[0])) ax.set_ylabel('Coefficients') ax.legend(loc='upper left') elif self.resradioButton.isChecked(): Yfit = REG.lr.predict(X) Q = np.squeeze(Y.values) - Yfit ind = range(1, nr + 1) vcol = nr * ['blue'] if self.CcheckBox.isChecked(): vcol = Cr ax.scatter(ind, Q, alpha=0.3, color=vcol, s=30, marker='o') if self.VcheckBox.isChecked(): for i in range(nr): ax.annotate(Lr[i], (ind[i], Q[i])) lim = [Q.min(), 0, Q.max()] vlim = max(abs(np.array(lim))) * 1.1 ax.set_xlim([0, nr + 2]) ax.set_ylim([np.copysign(vlim, lim[0]), np.copysign(vlim, lim[2])]) ax.set_title('Residual Plot: Model with for ' + Lcy[0]) ax.set_xlabel('Point Index') ax.set_ylabel('Residuals') elif self.cvradioButton.isChecked(): scores = sk.model_selection.cross_val_score( REG.lr, X, Y, cv=self.segmentspinBox.value()) REG.Ycv = sk.model_selection.cross_val_predict( REG.lr, X, Y, cv=self.segmentspinBox.value()) if self.CcheckBox.isChecked(): vcol = Cr else: vcol = 'red' ax.scatter(Y, REG.Ycv, color=vcol, alpha=0.3, marker='o') if self.VcheckBox.isChecked(): for i in range(nr): ax.annotate(Lr[i], (Y.values[i], REG.Ycv[i])) ax.set_xlabel(Yname + ' measured') ax.set_ylabel(Yname + ' CV predicted') xmin, xmax = ax.get_xlim() ax.set_ylim([xmin, xmax]) ax.set_title('CV Predicted Plot for ' + Lcy[0] + ' : Score {:04.2f}'.format(scores.mean())) ax.add_line(Line2D([xmin, xmax], [xmin, xmax], color='red')) elif self.dispersionradioButton.isChecked(): fig = plt.figure() ax = fig.add_subplot(111) cax = ax.matshow(REG.dism) fig.colorbar(cax, format='%.2E') ax.set_title('Trace = {:10.4E}'.format(np.trace(REG.dism))) elif self.leverageradioButton.isChecked(): Ftable = surtabDlg.launch(None) if len(np.shape(Ftable)) == 0: return () if np.argmax(Ftable['X axis'].values) == np.argmax( Ftable['Y axis'].values): QtWidgets.QMessageBox.critical( self, 'Error', "Two variables on the same axis", QtWidgets.QMessageBox.Ok) return () fig = plt.figure() ax = fig.add_subplot(111) npts = 20 xname = Ftable[(Ftable['X axis'] == True).values].index[0] yname = Ftable[(Ftable['Y axis'] == True).values].index[0] cname = Ftable[(Ftable['Constant'] == True).values].index.tolist() cvalue = Ftable.loc[(Ftable['Constant'] == True).values, 'value'] x = np.linspace(float(Ftable['min'][xname]), float(Ftable['max'][xname]), npts) y = np.linspace(float(Ftable['min'][yname]), float(Ftable['max'][yname]), npts) px = [] py = [] for i in range(npts): for j in range(npts): px.append(x[i]) py.append(y[j]) mx = pd.DataFrame({xname: px, yname: py}) xtitle = '' for i in range(len(cname)): xtitle = xtitle + cname[i] + ' = ' + str( cvalue.values.tolist()[i]) mx[cname[i]] = np.ones(npts**2) * float(cvalue[i]) mx = mx[Lcx] pz = np.diag(np.dot(np.dot(mx, REG.dism), mx.T)) px = np.array(px) py = np.array(py) pz = np.array(pz) z = plt.mlab.griddata(px, py, pz, x, y, interp='linear') plt.contour(x, y, z, 15, linewidths=0.5, colors='k') plt.contourf(x, y, z, 15, cmap=plt.cm.rainbow) plt.colorbar() ax.set_xlabel(xname) ax.set_ylabel(yname) ax.set_title(xtitle) ax.set_xlim([px.min(), px.max()]) ax.set_ylim([py.min(), py.max()]) elif self.surfaceradioButton.isChecked(): Ftable = surtabDlg.launch(None) if len(np.shape(Ftable)) == 0: return () if np.argmax(Ftable['X axis'].values) == np.argmax( Ftable['Y axis'].values): QtWidgets.QMessageBox.critical( self, 'Error', "Two variables on the same axis", QtWidgets.QMessageBox.Ok) return () fig = plt.figure() ax = fig.add_subplot(111) npts = 100 xname = Ftable[(Ftable['X axis'] == True).values].index[0] yname = Ftable[(Ftable['Y axis'] == True).values].index[0] cname = Ftable[(Ftable['Constant'] == True).values].index.tolist() cvalue = Ftable.loc[(Ftable['Constant'] == True).values, 'value'] x = np.linspace(float(Ftable['min'][xname]), float(Ftable['max'][xname]), npts) y = np.linspace(float(Ftable['min'][yname]), float(Ftable['max'][yname]), npts) px = [] py = [] for i in range(npts): for j in range(npts): px.append(x[i]) py.append(y[j]) mx = pd.DataFrame({xname: px, yname: py}) xtitle = '' for i in range(len(cname)): xtitle = xtitle + cname[i] + ' = ' + str( cvalue.values.tolist()[i]) mx[cname[i]] = np.ones(npts**2) * float(cvalue[i]) mx = mx[Lcx] pz = REG.lr.predict(mx) px = np.array(px) py = np.array(py) pz = np.array(pz) z = plt.mlab.griddata(px, py, pz, x, y, interp='linear') plt.contour(x, y, z, 15, linewidths=0.5, colors='k') plt.contourf(x, y, z, 15, cmap=plt.cm.rainbow) plt.colorbar() ax.set_xlabel(xname) ax.set_ylabel(yname) ax.set_title(xtitle) ax.set_xlim([px.min(), px.max()]) ax.set_ylim([py.min(), py.max()]) if self.TcheckBox.isChecked(): if self.TlineEdit.text(): ax.set_title(self.TlineEdit.text()) else: ax.set_title('') if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): if self.YlineEdit.text(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) else: ax.xaxis.grid(False) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) else: ax.yaxis.grid(False) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') try: self.rmmpl() except: pass self.addmpl(fig) def reset(self): self.TcheckBox.setChecked(True) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.update() 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 plsweightDlg(QtWidgets.QDialog, Ui_plsweightDialog): def __init__(self, parent=None): super(plsweightDlg, self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) for x in range(PLS.ncp): self.componentcomboBox.addItem(str(x + 1)) Lr = DS.Lr[DS.Ir] Ts = DS.Ts[DS.Ir] for x in Lr[-Ts]: self.firstpointcomboBox.addItem(str(x)) self.secondpointcomboBox.addItem(str(x)) self.firstpointcomboBox.setCurrentIndex(0) self.secondpointcomboBox.setCurrentIndex(1) Gr = DS.Gr[DS.Ir] Gr = Gr[-Ts] Gr = pd.Series(Gr) for x in Gr.groupby(Gr).groups.keys(): self.firstgroupcomboBox.addItem(str(x)) self.secondgroupcomboBox.addItem(str(x)) self.VcheckBox.setChecked(False) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig = Figure() ax = fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0, 1]) ax.set_ylim([0, 1]) self.addmpl(fig) def redraw(self): nw = self.componentcomboBox.currentIndex() fig = Figure() ax = fig.add_subplot(111) Gc = DS.Gc[DS.Ic] Lc = DS.Lc[DS.Ic] Lcx = Lc[-Gc] Ccx = DS.Cc[DS.Ic] Ccx = Ccx[-Gc] ncx = len(Lcx) WS = np.dot(PLS.WS, np.linalg.inv(PLS.C)) ind = np.array(range(1, ncx + 1)) if (ncx > 30): itick = np.linspace(0, ncx - 1, 20).astype(int) ltick = Lcx[itick] else: itick = ind ltick = Lcx ax.set_xticks(itick) ax.set_xticklabels(ltick, rotation='vertical') ax.set_xlabel('Variable') if self.CcheckBox.isChecked(): cl = Ccx else: cl = ncx * ['blue'] ax.set_ylabel('Variable Contributon on Weight ' + str(nw + 1)) ax.set_xlim([0, ncx + 1]) if self.pointradioButton.isChecked(): p1 = self.firstpointcomboBox.currentIndex() p2 = self.secondpointcomboBox.currentIndex() x1 = np.array(PLS.Xc[p1, :]) x2 = np.array(PLS.Xc[p2, :]) lx = WS[:, nw] * (x1 - x2) ax.bar(ind, lx, align='center', width=0.8, color=cl) ax.set_title('Contribution of object ' + self.firstpointcomboBox.currentText() + ' vs. object ' + self.secondpointcomboBox.currentText() + ' to Weight ' + str(nw + 1)) elif self.averageradioButton.isChecked(): p1 = self.firstpointcomboBox.currentIndex() x1 = np.array(PLS.Xc[p1, :]) lx = WS[:, nw] * x1 ax.bar(ind, lx, align='center', width=0.8, color=cl) ax.set_title('Contribution of object ' + self.firstpointcomboBox.currentText() + ' to Weight ' + str(nw + 1)) elif self.groupradioButton.isChecked(): g1 = self.firstgroupcomboBox.currentIndex() g2 = self.secondgroupcomboBox.currentIndex() Gr = DS.Gr[DS.Ir] Gr = Gr[-DS.Ts[DS.Ir]] df = pd.DataFrame(PLS.Xc).groupby(Gr).mean() Xa = df.values x1 = np.array(Xa[g1, :]) x2 = np.array(Xa[g2, :]) lx = WS[:, nw] * (x1 - x2) ax.bar(ind, lx, align='center', width=0.8, color=cl) ax.set_title('Contribution of Group ' + self.firstgroupcomboBox.currentText() + ' vs. Group ' + self.secondgroupcomboBox.currentText() + ' to Weight ' + str(nw + 1)) if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): if self.YlineEdit.text(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) else: ax.xaxis.grid(False) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) else: ax.yaxis.grid(False) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') self.rmmpl() self.addmpl(fig) def reset(self): self.firstpointcomboBox.setCurrentIndex(0) self.secondpointcomboBox.setCurrentIndex(1) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(False) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.update() 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 bivariategroupDlg(QtWidgets.QDialog, Ui_bivariategroup): def __init__(self, parent=None): super(bivariategroupDlg, self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) self.XcomboBox.addItem('Auto') self.Y2comboBox.addItem('None') self.XcomboBox.addItems(DS.Lc[DS.Ic]) self.Y1comboBox.addItems(DS.Lc[DS.Ic]) self.Y2comboBox.addItems(DS.Lc[DS.Ic]) self.XcomboBox.setCurrentIndex(0) self.Y1comboBox.setCurrentIndex(0) self.Y2comboBox.setCurrentIndex(0) self.PcheckBox.setChecked(True) self.XGcheckBox.setChecked(True) self.YGcheckBox.setChecked(True) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) self.farwardButton.clicked.connect(self.farward) self.backwardButton.clicked.connect(self.backward) fig = Figure() ax = fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0, 1]) ax.set_ylim([0, 1]) self.addmpl(fig) self.id_group = 0 def redraw(self): if self.XcomboBox.currentText()==self.Y1comboBox.currentText() or \ self.XcomboBox.currentText()==self.Y2comboBox.currentText() : QtWidgets.QMessageBox.critical(self, 'Error', "Variables \n must be different !", QtWidgets.QMessageBox.Ok) return () groups = pd.Series(DS.Gr) if groups.isnull().all(): QtWidgets.QMessageBox.critical(self, 'Error', "Not all groups are defined !", QtWidgets.QMessageBox.Ok) return () groups = groups.astype('int') gr_type = [isinstance(e, (int, np.integer)) for e in groups] if sum(gr_type) != len(groups): QtWidgets.QMessageBox.critical( self, 'Error', "Groups must be all present \n and must be integers", QtWidgets.QMessageBox.Ok) return () data = DS.Raw.iloc[DS.Ir, DS.Ic] Lr = DS.Lr[DS.Ir] Cr = DS.Cr[DS.Ir] fig = Figure() color = 'blue' color1 = 'blue' Y1 = data[self.Y1comboBox.currentText()] if self.CcheckBox.isChecked(): color = DS.Cc[self.Y1comboBox.currentIndex() - 1] if self.Y2comboBox.currentText() == "None": dual = False Y2 = Y1 else: dual = True Y2 = data[self.Y2comboBox.currentText()] if self.CcheckBox.isChecked(): color1 = DS.Cc[self.Y2comboBox.currentIndex() - 2] if self.XcomboBox.currentText() == 'Auto': auto = True X = Y1 else: auto = False X = data[self.XcomboBox.currentText()] df = pd.DataFrame({ 'G': groups.values, 'X': X, 'Y1': Y1, 'Y2': Y2, 'C': Cr, 'L': Lr }) dfg = df.groupby(['G']) ngr = len(dfg) if (ngr == 1): QtWidgets.QMessageBox.critical( self, 'Error', 'Your data have just one group.\n Slide Show needs more than a single group.', QtWidgets.QMessageBox.Ok) return () groups = df.G.unique() if (auto): X = [] for gr in groups: grp = dfg.get_group(gr) X = X + list(range(len(grp['X']))) df['X'] = X if (self.slideradioButton.isChecked()): if dual: ax = fig.add_subplot(1, 2, 1) else: ax = fig.add_subplot(1, 1, 1) if (self.id_group > ngr - 1): QtWidgets.QMessageBox.critical( self, 'Error', 'Highest element of list is reached', QtWidgets.QMessageBox.Ok) self.id_group = ngr - 1 return () if (self.id_group < 0): QtWidgets.QMessageBox.critical( self, 'Error', 'Lowest element of list is reached', QtWidgets.QMessageBox.Ok) self.id_group = 0 return () min_X = df['X'].min() max_X = df['X'].max() min_Y1 = df['Y1'].min() max_Y1 = df['Y1'].max() min_Y2 = df['Y2'].min() max_Y2 = df['Y2'].max() M = dfg.get_group(groups[self.id_group]) ax.set_xlim([min_X, max_X]) ax.set_ylim([min_Y1, max_Y1]) if self.PcheckBox.isChecked(): ax.scatter(M['X'], M['Y1'], marker='o', color=color) if self.LcheckBox.isChecked(): ax.plot(M['X'], M['Y1'], linestyle='-', color=color) ax.xaxis.grid() ax.yaxis.grid() ax.set_ylabel(self.Y1comboBox.currentText()) ax.set_xlabel(self.XcomboBox.currentText()) ax.set_title('Group: ' + str(groups[self.id_group])) if dual: ax1 = fig.add_subplot(1, 2, 2) ax1.set_xlim([min_X, max_X]) ax1.set_ylim([min_Y2, max_Y2]) if self.PcheckBox.isChecked(): ax1.scatter(M['X'], M['Y2'], marker='o', color=color1) if self.LcheckBox.isChecked(): ax1.plot(M['X'], M['Y2'], linestyle='-', color=color1) ax1.xaxis.grid() ax1.yaxis.grid() ax1.set_title('Group:' + str(groups[self.id_group])) ax1.set_xlabel(self.XcomboBox.currentText()) ax1.set_ylabel(self.Y2comboBox.currentText()) if (self.conditioningradioButton.isChecked()): if dual: ax = fig.add_subplot(1, 2, 1) else: ax = fig.add_subplot(1, 1, 1) for key, grp in df.groupby(['G']): if self.CcheckBox.isChecked(): vcol = grp['C'] else: vcol = cm.viridis.colors[int( len(cm.viridis.colors) / ngr * key)] if self.PcheckBox.isChecked(): ax.scatter(grp['X'], grp['Y1'], color=vcol, marker='o', label=key) if self.LcheckBox.isChecked(): ax.plot(grp['X'], grp['Y1'], linestyle='-', color=vcol, label=key) ax.xaxis.grid() ax.yaxis.grid() ax.set_xlabel(self.XcomboBox.currentText()) ax.set_ylabel(self.Y1comboBox.currentText()) ax.legend(loc='best') if dual: ax1 = fig.add_subplot(1, 2, 2) for key, grp in df.groupby(['G']): if self.CcheckBox.isChecked(): vcol = grp['C'] else: vcol = cm.viridis.colors[int( len(cm.viridis.colors) / ngr * key)] if self.PcheckBox.isChecked(): ax1.scatter(grp['X'], grp['Y2'], color=vcol, marker='o', label=key) if self.LcheckBox.isChecked(): ax1.plot(grp['X'], grp['Y2'], linestyle='-', color=vcol, label=key) ax1.xaxis.grid() ax1.yaxis.grid() ax1.set_xlabel(self.XcomboBox.currentText()) ax1.set_ylabel(self.Y2comboBox.currentText()) ax1.legend(loc='best') if (self.scatteradioButton.isChecked()): ax = fig.add_subplot(1, 1, 1) if dual: ax1 = ax.twinx() for key, grp in df.groupby(['G']): if self.CcheckBox.isChecked(): vcol = grp['C'] else: vcol = cm.viridis.colors[int( len(cm.viridis.colors) / ngr * key)] if self.PcheckBox.isChecked(): ax.scatter(grp['X'], grp['Y1'], color=vcol, marker='o', label=key) if dual: ax1.scatter(grp['X'], grp['Y2'], color=vcol, marker='*', label=key) if self.LcheckBox.isChecked(): ax.plot(grp['X'], grp['Y1'], linestyle='-', color=vcol, label=key) if dual: ax1.plot(grp['X'], grp['Y2'], linestyle='-', color=vcol, label=key) ax.set_xlabel(self.XcomboBox.currentText()) ax.set_ylabel(self.Y1comboBox.currentText()) if dual: ax1.set_ylabel(self.Y2comboBox.currentText()) ax.legend(loc='best') if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) if dual: ax1.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if dual: ax1.set_xlabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) if dual: ax1.xaxis.grid(True) else: ax.xaxis.grid(False) if dual: ax1.xaxis.grid(False) if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) if dual: ax1.yaxis.grid(True) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if dual: ax1.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') if dual: ax1.tick_params(axis='y', which='both', bottom='off', top='off', labelbottom='off') self.rmmpl() self.addmpl(fig) def farward(self): self.id_group += 1 self.redraw() def backward(self): self.id_group -= 1 self.redraw() def reset(self): self.XcomboBox.setCurrentIndex(0) self.Y1comboBox.setCurrentIndex(0) self.Y2comboBox.setCurrentIndex(0) self.PcheckBox.setChecked(True) self.LcheckBox.setChecked(False) self.XGcheckBox.setChecked(True) self.YGcheckBox.setChecked(True) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.TlineEdit.setText('') self.update() 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 bivariaterowDlg(QtWidgets.QDialog, Ui_bivariaterow): def __init__(self, parent=None): super(bivariaterowDlg, self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) self.XcomboBox.addItem('Auto') self.YcomboBox.addItem('All') self.XcomboBox.addItems(DS.Lr[DS.Ir]) self.YcomboBox.addItems(DS.Lr[DS.Ir]) self.GcomboBox.addItem('All') groups = pd.Series(DS.Gr[DS.Ir]) groups = groups.dropna() groups = groups.values groups = groups.astype('str') groups = np.unique(groups) groups = np.sort(groups) self.GcomboBox.addItems(groups) self.XcomboBox.setCurrentIndex(0) self.YcomboBox.setCurrentIndex(0) self.XcomboBox.setCurrentIndex(0) self.YcomboBox.setCurrentIndex(0) self.PcheckBox.setChecked(True) self.XGcheckBox.setChecked(True) self.YGcheckBox.setChecked(True) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig = Figure() ax = fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0, 1]) ax.set_ylim([0, 1]) self.addmpl(fig) def redraw(self): if self.XcomboBox.currentText() == self.YcomboBox.currentText(): QtWidgets.QMessageBox.critical(self, 'Error', 'Variables \n must be different !', QtWidgets.QMessageBox.Ok) return () if (self.XcomboBox.currentText() == 'Auto') and ( self.YcomboBox.currentText() == 'All') and not self.scatterradioButton.isChecked(): QtWidgets.QMessageBox.critical( self, 'Error', "You have to select two rows \n for this kind of plot!", QtWidgets.QMessageBox.Ok) return () data = DS.Raw.iloc[DS.Ir, DS.Ic] data = data.assign(Lr=DS.Lr[DS.Ir]) data = data.assign(Cr=DS.Cr[DS.Ir]) data = data.assign(Gr=DS.Gr[DS.Ir]) if (self.XcomboBox.currentText() != 'Auto') and (self.YcomboBox.currentText() != 'All'): data = data.loc[[ self.XcomboBox.currentText(), self.YcomboBox.currentText() ]] elif (self.XcomboBox.currentText() != 'Auto') and (self.YcomboBox.currentText() == 'All'): QtWidgets.QMessageBox.critical(self, 'Error', "Select two rows!", QtWidgets.QMessageBox.Ok) return () elif (self.XcomboBox.currentText() == 'Auto') and (self.YcomboBox.currentText() != 'All'): QtWidgets.QMessageBox.critical(self, 'Error', "Use Univariate plot!", QtWidgets.QMessageBox.Ok) return () Nnan = data.isnull().isnull().all().all() data = data.T.dropna() data = data.T Lr = data['Lr'].values Cr = data['Cr'].values Gr = data['Gr'].values data = data.drop('Lr', axis=1) data = data.drop('Cr', axis=1) data = data.drop('Gr', axis=1) if data.dtypes.all() == 'float' and data.dtypes.all() == 'int': QtWidgets.QMessageBox.critical(self,'Error',"Some values are not numbers!",\ QtWidgets.QMessageBox.Ok) return () if (self.XcomboBox.currentText() != 'Auto') and (self.YcomboBox.currentText() != 'All'): if data.shape[0] != 2: QtWidgets.QMessageBox.critical(self,'Error',"Raw labels must be different",\ QtWidgets.QMessageBox.Ok) return () x = data.loc[self.XcomboBox.currentText()].values y = data.loc[self.YcomboBox.currentText()].values fig = Figure() ax = fig.add_subplot(111) color = 'blue' if self.scatterradioButton.isChecked(): if (self.XcomboBox.currentText() != 'Auto') and (self.YcomboBox.currentText() != 'All'): if self.PcheckBox.isChecked(): ax.scatter(x, y, marker='o', color=Cr) if self.LcheckBox.isChecked(): ax.plot(x, y, color='blue') if self.VcheckBox.isChecked(): for i, txt in enumerate(Lr): ax.annotate(txt, (x[i], y[i])) ax.set_xlabel(self.XcomboBox.currentText()) ax.set_ylabel(self.YcomboBox.currentText()) else: nr, nc = data.shape Lc = DS.Lc[DS.Ic] x = range(1, nc + 1) color = Cr if self.GcheckBox.isChecked(): groups = Gr ngr = len(np.unique(groups)) color = [] for key in groups: color.append(cm.viridis.colors[int( (len(cm.viridis.colors) - 1) / ngr * key)]) for i in range(nr): y = data.iloc[i, :] col = color[i] if self.GcomboBox.currentText() == 'All': if self.PcheckBox.isChecked(): ax.scatter(x, y, marker='o', color=col) if self.LcheckBox.isChecked(): ax.plot(x, y, color=col) else: if int(self.GcomboBox.currentText()) == groups[i]: if self.PcheckBox.isChecked(): ax.scatter(x, y, marker='o', color=col) if self.LcheckBox.isChecked(): ax.plot(x, y, color=col) if (nc > 30): itick = np.linspace(0, nc - 1, 20).astype(int) ltick = Lc[itick] else: itick = x ltick = Lc ax.set_xlim([0, nc + 2]) ax.set_xticks(itick) ax.set_xticklabels(ltick, rotation='vertical') if self.ellipseradioButton.isChecked(): def plot_ellipse(x, y, nstd=2, ax=None, **kwargs): def eigsorted(cov): vals, vecs = np.linalg.eigh(cov) order = vals.argsort()[::-1] return vals[order], vecs[:, order] pos = (x.mean(), y.mean()) cov = np.cov(x, y).tolist() vals, vecs = eigsorted(cov) theta = np.degrees(np.arctan2(*vecs[:, 0][::-1])) width, height = 2 * nstd * np.sqrt(vals) ellip = Ellipse(xy=pos, width=width, height=height, angle=theta, fill=False, **kwargs) ax.add_artist(ellip) return ellip for j in range(1, 4): plot_ellipse(x, y, j, ax) ax.scatter(x, y) ax.set_xlabel(self.XcomboBox.currentText()) ax.set_ylabel(self.YcomboBox.currentText()) ax.set_title('Ellipse for 1,2,3 times the Standard Deviation') if self.boxcoxradioButton.isChecked(): if (not (x > 0).all()) and (not (y > 0).all()): QtWidgets.QMessageBox.critical(self,'Error',"Values must be strictly positive",\ QtWidgets.QMessageBox.Ok) return () CBC = np.zeros(50) vlambda = np.linspace(-2, 2, 50) for i in range(50): trans_x = stats.boxcox(x, vlambda[i]) CBC[i] = np.corrcoef(trans_x, y)[0, 1] if self.PcheckBox.isChecked(): ax.scatter(vlambda, CBC, marker='o', color=color) if self.LcheckBox.isChecked(): ax.plot(vlambda, CBC, color=color) ax.set_xlabel('Lambda') ax.set_ylabel('Correlation Coefficient') if self.histogramradioButton.isChecked(): cx = 'blue' cy = 'red' xm = x.mean() ym = y.mean() xstd = x.std() ystd = y.std() dy = (ym - 3 * ystd) - (xm + 3 * xstd) dx = (xm - 3 * xstd) - (ym + 3 * ystd) if (dy > 0) | (dx > 0): x = sk.preprocessing.normalize(x.reshape(1, -1), norm='l2', axis=1, copy=True, return_norm=False) y = sk.preprocessing.normalize(y.reshape(1, -1), norm='l2', axis=1, copy=True, return_norm=False) x = x.ravel() y = y.ravel() ax.set_xlabel('Normalized Quantities') iqr = np.percentile(x, [75, 25]) iqr = iqr[0] - iqr[1] n = x.size dx = abs(max((x.max(), y.max())) - min((x.min(), y.min()))) nbins = int(np.floor(dx / (2 * iqr) * n**(1 / 3))) + 1 if nbins > self.spinBox.value(): self.spinBox.setValue(nbins) else: nbins = self.spinBox.value() bins = np.linspace(min((x.min(), y.min())), max( (x.max(), y.max())), nbins) ax.hist(x, bins=bins, histtype='bar', color=cx, alpha=0.5, orientation='vertical', label=str(self.XcomboBox.currentText())) ax.hist(y, bins=bins, histtype='bar', color=cy, alpha=0.5, orientation='vertical', label=str(self.YcomboBox.currentText())) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) ax.legend(bbox_to_anchor=(1, 1), loc='upper left', borderaxespad=0.2) if Nnan: ax.annotate('{:04.2f} NaN'.format(Nnan), xy=(0.80, 0.95), xycoords='figure fraction') if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): if self.YlineEdit.text(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) if self.TlineEdit.text(): ax.set_title(self.TlineEdit.text()) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') self.rmmpl() self.addmpl(fig) def reset(self): self.XcomboBox.setCurrentIndex(0) self.YcomboBox.setCurrentIndex(0) self.YcomboBox.setCurrentIndex(0) self.PcheckBox.setChecked(True) self.LcheckBox.setChecked(False) self.XGcheckBox.setChecked(True) self.YGcheckBox.setChecked(True) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.TlineEdit.setText('') self.update() 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 WidgetMatplot( QWidget, ): def __init__(self, ): super().__init__() self.layout = QVBoxLayout() self.setLayout(self.layout) # defualt figure self.figure_default = Figure() ax = self.figure_default.add_subplot(111) x = np.arange(0., 2 * np.pi, 0.1) ax.plot(x, np.sin(x)) ax.text(0.5, 0.0, 'This is a plot area') # setup Widgets self.add_plot(self.figure_default) #self.canvas = FigureCanvas(self.figure_default) #self.layout.addWidget(self.canvas) #self.toolbar = NavigationToolbar(self.canvas, # self, coordinates =True) #self.layout.addWidget(self.toolbar) self.axes = None #this is defined when figure/plot is added def draw_axes(self, x, y, label=None, fmt=None): """ Instead of replace whole figure, add a line in existing axes Seems to be not working !! """ if fmt: self.axes.plot(x, y, fmt, label=label) else: self.axes.plot(x, y, label=label) def reset_plot(self, ): # show default figure self.rm_plot() self.add_plot(self.figure_default) def add_plot(self, fig): # add a figure in the canvas. # figure is external # add canvas and toolbar to layout # To replace it one have to remove previous one first. self.axes = fig.get_axes()[0] # suppose only one axes.. self.canvas = FigureCanvas(fig) self.layout.addWidget(self.canvas) # add a canvas widget into layout self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self, coordinates=True) self.layout.addWidget(self.toolbar) def rm_plot(self, ): # remove canvas and toolbar self.layout.removeWidget(self.canvas) self.canvas.close() #self.canvas.setParent(None) self.layout.removeWidget(self.toolbar) self.toolbar.close() #self.toolbar.setParent(None) def add_plot_by_data(self, list_of_data_to_plot, show_grid=False, yscale='linear', xlabel='c.m. angle[deg]', ylabel='mb'): """ Parameters ---------- list_of_data_to_plot : list of dictionary to plot [plot1={'x': array ,'y':array,'yerr': array, 'label' : legend txt, 'fmt': matplotlib fmt}, plot2={},..] show_grid : TYPE, optional DESCRIPTION. The default is False. yscale : TYPE, optional DESCRIPTION. The default is 'linear'. xlabel : TYPE, optional DESCRIPTION. The default is 'c.m. angle[deg]'. ylabel : TYPE, optional DESCRIPTION. The default is 'mb'. Returns ------- None. """ # remove previous plot self.rm_plot() fig = Figure() ax = fig.add_subplot(111) for p in list_of_data_to_plot: try: # check whether a yerr exits in data yerr = p['yerr'] plot_err = True except: plot_err = False if plot_err: #error exist ax.errorbar(p['x'], p['y'], yerr=yerr, fmt=p['fmt'], label=p['label']) else: ax.plot(p['x'], p['y'], p['fmt'], label=p['label']) ax.legend() ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.set_yscale(yscale) if show_grid: ax.grid() self.add_plot(fig) return
def plotALot( self, gene_list, # list of genes to plot savedir="", title="images", grid=(4, 8), # grid to plot for each figure figsize=(16, 9), dpi=300, ): """ plot a lot of intensity maps from a list of genes """ genes_per_plot = grid[0] * grid[1] num_plots, remainder = divmod(len(gene_list), (genes_per_plot)) # add an extra plot if # number of genes is not perfectly divisible by number of plots if remainder != 0: num_plots += 1 for img_num in range(len(self.img_arrays)): # set up index for number of genes already plotted # ------------------------------------------------ reordered_idx = 0 for plot_num in range(num_plots): # set up figure canvas # -------------------- fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) for gridpos in range(genes_per_plot): # check if we have reached end of gene list # ----------------------------------------- if reordered_idx == len(gene_list) - 1: break # create temporary axes reference # ------------------------------- ax = fig.add_subplot(grid[0], grid[1], gridpos + 1) # plot the current gene # --------------------- array_idx = self.gene_index_dict[gene_list[reordered_idx]] ax.imshow(self.img_arrays[img_num][array_idx, ...], cmap="hot") ax.set_title(gene_list[reordered_idx]) # increment gene index # -------------------- reordered_idx += 1 fig.suptitle(title + f"\n{self.hdf5_file_list[img_num]}" f"\n({plot_num + 1} of {num_plots})") fig.tight_layout(rect=(0, 0, 1, .94)) # save the plot # ------------- savename = ( f"image_{img_num + 1}_{title.replace(' ','_')}" f"_{plot_num + 1}of{num_plots}_{self.time_str}.png") if not os.path.exists(savedir): os.mkdir(savedir) fig.savefig(os.path.join(savedir, savename), dpi=dpi) # close the canvas # ---------------- canvas.close() fig.clear()
class Main(QMainWindow, Ui_MainWindow): def __init__(self, ): #provide values for attributes at runtime super(Main, self).__init__() self.setupUi(self) self.pushBrowse.clicked.connect(self.selectFile) self.pushBrowse_2.clicked.connect(self.selectmlFile) self.pushApply.clicked.connect(self.apply) self.pushRun.clicked.connect(self.run) self.HomeDirectory = os.getcwd() #saves the primary working directory self.directory = os.listdir(self.HomeDirectory) self.saveBttn.clicked.connect(self.file_save) self.actionOpen.triggered.connect(self.file_open) self.actionReset.triggered.connect(self.plots_close) self.message = 0 #self.UI = [] self.reset = 0 #check User input for correct .csv file self.inputFile.setValidator(validator) self.inputFile.textChanged.connect(self.check_state) self.inputFile.textChanged.emit(self.inputFile.text()) #check User input for correct .csv file for ml self.mlData.setValidator(validator) self.mlData.textChanged.connect(self.check_state) self.mlData.textChanged.emit(self.mlData.text()) #shaft speed self.shaftSpeed.setValidator(regexp_checkdouble) self.shaftSpeed.textChanged.connect(self.check_state) self.shaftSpeed.textChanged.emit(self.shaftSpeed.text()) #Num of rolling elements self.numberofElements.setValidator(regexp_checkint) self.numberofElements.textChanged.connect(self.check_state) self.numberofElements.textChanged.emit(self.numberofElements.text()) #diameter of rolling elements self.diameterofElements.setValidator(regexp_checkdouble) self.diameterofElements.textChanged.connect(self.check_state) self.diameterofElements.textChanged.emit( self.diameterofElements.text()) #pitch diameter self.pitchDiameter.setValidator(regexp_checkdouble) self.pitchDiameter.textChanged.connect(self.check_state) self.pitchDiameter.textChanged.emit(self.pitchDiameter.text()) #Contact angle self.contactAngle.setValidator(regexp_checkdouble) self.contactAngle.textChanged.connect(self.check_state) self.contactAngle.textChanged.emit(self.contactAngle.text()) #Frequency Acoustic self.samFreqAcst.setValidator(regexp_checkdouble) self.samFreqAcst.textChanged.connect(self.check_state) self.samFreqAcst.textChanged.emit(self.samFreqAcst.text()) #Frequency Accelerometer """self.samFreqac.setValidator(regexp_checkdouble) self.samFreqac.textChanged.connect(self.check_state) self.samFreqac.textChanged.emit(self.samFreqac.text())""" def check_state(self, *args, **kwargs): #this function is changes the color of the lineedit fields depending on state sender = self.sender() validator = sender.validator() state = validator.validate(sender.text(), 0)[0] if state == QValidator.Acceptable: color = '#c4df9b' # green elif state == QtGui.QValidator.Intermediate: color = '#fff79a' # yellow else: color = '#f6989d' # red sender.setStyleSheet('QLineEdit { background-color: %s }' % color) #creates a dictionary from the saved CSV def file_open(self): #function called when the open file action in triggered. Creates a dictionary from a CSV file. filename = QFileDialog.getOpenFileName()[0] reader = csv.reader(open(filename, 'r')) d = {} for row in reader: k, v = row d[k] = v print(d) self.setTextInfile(d) return True #used the dicitonary created above to assign saved variables to input parameters def setTextInfile(self, d): self.inputName.setText(d['inputName']) self.inputApplication.setText(d['inputApplication']) self.inputModelnum.setText(d['inputModelnum']) self.inputSavingalias.setText(d['inputSavingalias']) self.inputFile.setText(d['inputFile']) self.mlData.setText(d['mlData']) self.horsepower.setText(d['horsepower']) self.voltage.setText(d['voltage']) self.phase.setText(d['phase']) self.shaftnum.setText(d['shaftnum']) self.shaftSpeed.setText(d['shaftSpeed']) self.numberofElements.setText(d['numberofElements']) self.diameterofElements.setText(d['diameterofElements']) self.pitchDiameter.setText(d['pitchDiameter']) self.contactAngle.setText(d['contactAngle']) self.samFreqAcst.setText(d['samFreq']) """ Hmm i wonder if this is used to save the file? """ def file_save(self, ): #called when the save btn is clicked. converts user input to dictionary #then to dataframe then to csv file. dict = CreateSaveDictionary(self.inputName.text(),\ self.inputApplication.text(),\ self.inputModelnum.text(),\ self.inputSavingalias.text(),\ self.inputFile.text(),\ self.mlData.text(), \ self.horsepower.text(), \ self.voltage.text(), \ self.phase.text(), \ self.shaftnum.text(),\ self.shaftSpeed.text(),\ self.numberofElements.text(), \ self.diameterofElements.text(), \ self.pitchDiameter.text(), \ self.contactAngle.text(), \ self.samFreqAcst.text()) CreateCSVfromDict(dict) """ These functions create the figure widgets and toolbars """ #Accelerometer def addmpl(self, fig): self.canvas = FigureCanvas(fig) #self.canvas.setParent(None) self.graph01UI.addWidget(self.canvas) #self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mainspectrum, coordinates=True) #self.toolbar.setParent(None) self.graph01UI.addWidget(self.toolbar) def addmpl02(self, fig): self.canvas = FigureCanvas(fig) #self.canvas.setParent(None) self.graph02UI.addWidget(self.canvas) #self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mainspectrum, coordinates=True) #self.toolbar.setParent(None) self.graph02UI.addWidget(self.toolbar) def addgraph11(self, fig): self.canvas1 = FigureCanvas(fig) self.graph11UI.addWidget(self.canvas1) #self.canvas1.draw() self.toolbar1 = NavigationToolbar(self.canvas1, self.graph11, coordinates=True) self.graph11UI.addWidget(self.toolbar1) def addgraph12(self, fig): self.canvas2 = FigureCanvas(fig) self.graph12UI.addWidget(self.canvas2) #self.canvas2.draw() self.toolbar2 = NavigationToolbar(self.canvas2, self.graph12, coordinates=True) self.graph12UI.addWidget(self.toolbar2) def addgraph21(self, fig): self.canvas3 = FigureCanvas(fig) self.graph21UI.addWidget(self.canvas3) #self.canvas3.draw() self.toolbar3 = NavigationToolbar(self.canvas3, self.graph21, coordinates=True) self.graph21UI.addWidget(self.toolbar3) def addgraph22(self, fig): self.canvas4 = FigureCanvas(fig) self.graph22UI.addWidget(self.canvas4) #self.canvas4.draw() self.toolbar4 = NavigationToolbar(self.canvas4, self.graph22, coordinates=True) self.graph22UI.addWidget(self.toolbar4) #ACOUSTIC def addmpl_2(self, fig): self.canvas = FigureCanvas(fig) #self.canvas.setParent(None) self.graph01UI_2.addWidget(self.canvas) #self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mainspectrum_2, coordinates=True) #self.toolbar.setParent(None) self.graph01UI_2.addWidget(self.toolbar) def addmpl02_2(self, fig): self.canvas = FigureCanvas(fig) #self.canvas.setParent(None) self.graph02UI_2.addWidget(self.canvas) #self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mainspectrum_2, coordinates=True) #self.toolbar.setParent(None) self.graph02UI_2.addWidget(self.toolbar) def addgraph11_2(self, fig): self.canvas1 = FigureCanvas(fig) self.graph11UI_2.addWidget(self.canvas1) #self.canvas1.draw() self.toolbar1 = NavigationToolbar(self.canvas1, self.graph11_2, coordinates=True) self.graph11UI_2.addWidget(self.toolbar1) def addgraph12_2(self, fig): self.canvas2 = FigureCanvas(fig) self.graph12UI_2.addWidget(self.canvas2) #self.canvas2.draw() self.toolbar2 = NavigationToolbar(self.canvas2, self.graph12_2, coordinates=True) self.graph12UI_2.addWidget(self.toolbar2) def addgraph21_2(self, fig): self.canvas3 = FigureCanvas(fig) self.graph21UI_2.addWidget(self.canvas3) #self.canvas3.draw() self.toolbar3 = NavigationToolbar(self.canvas3, self.graph21_2, coordinates=True) self.graph21UI_2.addWidget(self.toolbar3) def addgraph22_2(self, fig): self.canvas4 = FigureCanvas(fig) self.graph22UI_2.addWidget(self.canvas4) #self.canvas4.draw() self.toolbar4 = NavigationToolbar(self.canvas4, self.graph22_2, coordinates=True) self.graph22UI_2.addWidget(self.toolbar4) #clearly selects file def selectFile(self, ): self.inputFile.setText(QFileDialog.getOpenFileName()[0]) self.inputfile = self.inputFile.text() #selects file but for a ml data def selectmlFile(self, ): self.mlData.setText(QFileDialog.getOpenFileName()[0]) """ Apply checks user inputs and then assigns them to function parameter variables In case the user doesn't supply input for a specific field, default inputs will be inserted. """ def apply(self, ): if self.inputSavingalias.text() != "": self.savingalias = self.inputSavingalias.text() + ".csv" self.inputSavingalias.setText(self.savingalias) if self.inputFile.text() != "": try: temp = self.inputFile.text() self.FileOfInterest = self.inputFile.text() except: print("pu") else: print("no input file selected, using demo file.") self.FileOfInterest = "AccelerometerActualDataEdited.csv" self.inputFile.setText("/AccelerometerActualDataEdited.csv") if self.mlData.text() != "": self.TrainingDataFile = self.mlData.text() print(self.TrainingDataFile) else: print("no ML data selected") self.TrainingDataFile = "MLSynthesizedData.csv" #default file location self.mlData.setText("/MLSynthesizedData.csv") if self.shaftSpeed.text() != "": self.n = float(self.shaftSpeed.text()) print("type n =", type(self.n)) else: print("no shaft speed selected") self.n = 2000 / 60 self.shaftSpeed.setText(str(self.n)) if self.numberofElements.text() != "": self.N = int(self.numberofElements.text()) else: print("Number of elements not specified") self.N = 16 self.numberofElements.setText(str(self.N)) if self.diameterofElements.text() != "": self.Bd = float(self.diameterofElements.text()) else: print("Diameter of elements not specified") self.Bd = 0.331 * 254 self.diameterofElements.setText(str(self.Bd)) if self.pitchDiameter.text() != "": self.Pd = float(self.pitchDiameter.text()) else: print("no pitch diameter specified") self.Pd = Pd = 2.815 * 254 self.pitchDiameter.setText(str(self.Pd)) if self.contactAngle.text() != "": self.phi = float(self.contactAngle.text()) else: print("Contact angle not specified") self.phi = (15.17 * 3.14159) / 180 self.contactAngle.setText(str(self.phi)) if self.samFreqAcst.text() != "": self.SampleFrequency = float(self.samFreqAcst.text()) else: print("no sample frequency specified") self.SampleFrequency = 20000 self.samFreqAcst.setText(str(self.SampleFrequency)) self.popup = MyPopup("Applied") self.popup.setGeometry(QtCore.QRect(100, 100, 400, 200)) self.popup.show() ############################################## def getPlot(self, WhichPlot, plotinfo): X = plotinfo[0] Y = plotinfo[1] xlabel = plotinfo[2] ylabel = plotinfo[3] Title = plotinfo[4] if self.reset != 0: WhichPlot.cla() WhichPlot.plot(X, Y, c=np.random.rand(3, )) WhichPlot.set_xlabel(xlabel, fontsize=12) WhichPlot.set_ylabel(ylabel, fontsize=12) WhichPlot.set_title(Title) WhichPlot.grid(True) if self.reset != 0: self.canvas.draw() return None def run(self, ): #called when run is clicked if self.reset == 0: #instantiate the figures self.fig0 = plt.figure() self.sub0 = self.fig0.subplots() self.fig1 = plt.figure() self.sub1 = self.fig1.subplots() self.fig2 = plt.figure() self.sub2 = self.fig2.subplots() self.fig3 = plt.figure() self.sub3 = self.fig3.subplots() self.fig4 = plt.figure() self.sub4 = self.fig4.subplots() self.fig5 = plt.figure() self.sub5 = self.fig5.subplots() self.fig6 = plt.figure() self.sub6 = self.fig6.subplots() self.fig7 = plt.figure() self.sub7 = self.fig7.subplots() self.fig8 = plt.figure() self.sub8 = self.fig8.subplots() self.fig9 = plt.figure() self.sub9 = self.fig9.subplots() ############################################################################### #begin calling ml functions for processing #General Name_ID = "1" Application = "2" ModelNumber = "3" SavingAlias = "4" AccelerometerDataFilename = 'AccelerometerActualDataEdited.csv' #filename #main file AcousticDataFilename = 'DataOutputMic2Col.csv' #Wave File Name MLDataFilename = "MLSynthesizedData.csv" #Motor Characteristics Horsepower = "6" RatedVoltage = "7" ACorDC = "DC" NumberOfPolePairs = "9" NumberofShafts = "10" #Bearing Information ShaftSpeed = 300 #Also Used for Motor Characteristics NumberOfRollingElements = 3 DiameterOfRollingElements = 3 PitchDiameter = .2 ContactAngle = .2 #Processing Information AccelerometerSamplingFrequency = 14000 #must be an non-zero int or float AcousticSamplingFrequency = 30000 #must be an non-zero int or float #Microcontroller Information #Receive Required Information A2DResolution = 16 VoltageMax = 5 VoltageMin = 0 #System/Sensor Known Constants AccelerationMax = 50 AccelerationMin = -50 #Convert User Inputs into a condensed form OnlyUserInput = Inputs2CondensedForm(Name_ID, Application, ModelNumber, SavingAlias,\ AccelerometerDataFilename, AcousticDataFilename, \ MLDataFilename, Horsepower, RatedVoltage, ACorDC, \ NumberOfPolePairs, NumberofShafts, \ ShaftSpeed, NumberOfRollingElements, \ DiameterOfRollingElements,PitchDiameter, ContactAngle, \ AccelerometerSamplingFrequency, AcousticSamplingFrequency) SystemInputs = System2CondensedForm(A2DResolution, VoltageMax, VoltageMin, AccelerationMax, AccelerationMin) #Acquire Accelerometer Actual Data time, amp, Voltage, Acceleration = ExtractAccelerometerData( OnlyUserInput, SystemInputs) #Acquire Acoustic Actual Data Channel1Time, Channel1Value, Channe21Time, Channe2Value = ExtractAcousticData( OnlyUserInput, SystemInputs) #Put All Data into Working Form trial = 2 #Select the instance of the data ************needs future work AllData = AllData2WorkingForm(OnlyUserInput,SystemInputs,time[trial], \ amp[trial], Voltage[trial], Acceleration[trial],\ Channel1Time,Channel1Value,Channe21Time,Channe2Value) #Machine Learning TestDF = getTESTDataFrame(AllData) TestMatrix = getTESTMatrix(TestDF) Xall_train, Yall_train, dataset = GetTrainingData(AllData) FinalClassifier = TrainModel(Xall_train, Yall_train) #Predict prediction, prediction_string = PredictModel(FinalClassifier, TestMatrix) prediction_proba = PredictProbModel(FinalClassifier, TestMatrix) plt.close('all') plot0info,plot1info,plot2info,plot3info,plot4info,\ plot5info,plot6info,plot7info,plot8info,plot9info = getGraphs(AllData) #ACCELEROMETER PLOTTING self.getPlot(self.sub0, plot0info) #Raw Data self.getPlot(self.sub1, plot1info) #Raw Data w DC removed self.getPlot(self.sub2, plot2info) #Normalized self.getPlot(self.sub3, plot3info) #FFT self.getPlot(self.sub4, plot4info) #PSD #ACOUSTIC PLOTTING self.getPlot(self.sub5, plot5info) self.getPlot(self.sub6, plot6info) self.getPlot(self.sub7, plot7info) self.getPlot(self.sub8, plot8info) self.getPlot(self.sub9, plot9info) ############################################################################### if self.reset == 0: self.addmpl(self.fig0) self.addmpl02(self.fig2) self.addgraph11(self.fig1) self.addgraph12(self.fig3) self.addgraph21(self.fig4) #self.addgraph22(self.fig4) self.addmpl_2(self.fig5) #Raw Data self.addmpl02_2(self.fig7) #normalized self.addgraph11_2(self.fig6) #Raw Data w DC removed self.addgraph12_2(self.fig8) #FFT self.addgraph21_2(self.fig9) #PSD self.BSF.setText(str(truncate(TestDF["BSF"].values[0], 2))) self.BPFI.setText(str(truncate(TestDF["BPFI"].values[0], 2))) self.BPFO.setText(str(truncate(TestDF["BPFO"].values[0], 2))) self.FTF.setText(str(truncate(TestDF["FTF"].values[0], 2))) self.earlyEdit.setText(str(truncate(prediction_proba[0, 0], 2))) self.suspectEdit.setText(str(truncate(prediction_proba[0, 1], 2))) self.normalEdit.setText(str(truncate(prediction_proba[0, 2], 2))) """ self.immEdit.setText(str(Prediction[0,3])) self.innerEdit.setText(str(Prediction[0,4])) self.rollingEdit.setText(str(Prediction[0,5])) self.stageEdit.setText(str(Prediction[0,6])) """ self.reset = 1 def close_application(self, ): #self explanitory sys.exit() ############################################################################### def updategraphs(self, fig): print("made it to update graphs") sip.delete(self.canvas) sip.delete(self.canvas1) sip.delete(self.canvas2) sip.delete(self.canvas3) sip.delete(self.canvas4) #self.spectrumUI.removeWidget(self.canvas) self.canvas = FigureCanvas(fig[0]) self.canvas1 = FigureCanvas(fig[1]) self.canvas2 = FigureCanvas(fig[2]) self.canvas3 = FigureCanvas(fig[3]) self.canvas4 = FigureCanvas(fig[4]) def rmmpl(self, ): print("in rmmpl") self.spectrumUI.removeWidget(self.canvas) self.canvas.close() self.spectrumUI.removeWidget(self.toolbar) self.toolbar.close() self.graph11UI.removeWidget(self.canvas) self.canvas.close() self.graph11UI.removeWidget(self.toolbar) self.toolbar.close() self.graph12UI.removeWidget(self.canvas) self.canvas.close() self.graph12UI.removeWidget(self.toolbar) self.toolbar.close() self.graph21UI.removeWidget(self.canvas) self.canvas.close() self.graph21UI.removeWidget(self.toolbar) self.toolbar.close() self.graph22UI.removeWidget(self.canvas) self.canvas.close() self.graph22UI.removeWidget(self.toolbar) self.toolbar.close() def plots_close(self, ): print("made it to plots_close") self.spectrumUI.removeWidget(self.canvas) sip.delete(self.canvas) self.canvas = None self.spectrumUI.removeWidget(self.toolbar) sip.delete(self.toolbar) self.toolbar = None self.graph11UI.removeWidget(self.canvas1) self.canvas1.close() self.graph11UI.removeWidget(self.toolbar1) self.toolbar1.close() self.graph12UI.removeWidget(self.canvas2) self.canvas2.close() self.graph12UI.removeWidget(self.toolbar2) self.toolbar2.close() self.graph21UI.removeWidget(self.canvas3) self.canvas3.close() self.graph21UI.removeWidget(self.toolbar3) self.toolbar3.close() self.graph22UI.removeWidget(self.canvas4) self.canvas4.close() self.graph22UI.removeWidget(self.toolbar4) self.toolbar4.close()
class Main(QtWidgets.QMainWindow, Ui_MainWindow): def __init__(self): QtWidgets.QMainWindow.__init__(self) Ui_MainWindow.__init__(self) self.setupUi(self) self.simpleData.clicked.connect(self.simpleModel) self.realData.clicked.connect(self.realModel) self.BBdata.clicked.connect(self.BBspec) #Notice that an empty figure instance was added to our plotting window in the initialization method. #This is necessary because our first call to changefig will try to remove a previously displayed figure, #which will throw an error if one is not displayed. #The empty figure serves as a placeholder so the changefig method functions properly. fig = Figure() fig2 = Figure() fig3 = Figure() fig4 = Figure() fig5 = Figure() self.addmpl(fig) self.addmpl_2(fig2) self.addmpl_3(fig3) self.addmpl_4(fig4) self.addmpl_5(fig5) def BBspec(self): wavelen = np.linspace(float(self.min.toPlainText()), float(self.max.toPlainText()), float(self.samples.toPlainText())) * 1e-6 path = 'C:/Users/Joe/Documents/Python Scripts/Scatter Pixel Code/Consolidated_Filter.txt' BBT = float(self.BBtemp.toPlainText()) specIr = BBS.blackBodySpec(wavelen, BBT) FilterCoeff = FT.filterTransmission(path, wavelen) figx = Figure() ax1f1 = figx.add_subplot(111) ax1f1.set_title('BBspec Irradiance') ax1f1.plot(wavelen, baseUnits(specIr), label='Simple Model') ax1f1.plot(wavelen, baseUnits(specIr) * FilterCoeff, label='After Filter') ax1f1.set_xlabel('Wavelength (m)') ax1f1.set_ylabel('Amp (%s)' % (specIr.units)) ax1f1.ticklabel_format(style='sci', axis='x', scilimits=(0, 0)) ax1f1.legend(loc='best') ax1f1.grid() #print('okay') self.rmmpl_3() self.addmpl_3(figx) def realModel(self): ##Load and Store data wavelen = np.linspace(float(self.min.toPlainText()), float(self.max.toPlainText()), float(self.samples.toPlainText())) absEff0pol, absEff90pol = np.empty(len(wavelen)), np.empty( len(wavelen)) apertureData0pol, apertureData90pol = [], [] print(wavelen) step = 100 / (2 * len(wavelen)) i = 0 self.progressBar.setValue(i) for wnIdx, wn in enumerate(wavelen): absEff0pol[wnIdx], apertureData0poln = SPI.scatterPixelIntegrator( wn, 0, 0.65e-3, 0.65e-3) apertureData0pol.append(apertureData0poln) i = i + step self.progressBar.setValue(i) for wnIdx, wn in enumerate(wavelen): absEff90pol[ wnIdx], apertureData90poln = SPI.scatterPixelIntegrator( wn, 90, 0.65e-3, 0.65e-3) apertureData90pol.append(apertureData90poln) i = i + step self.progressBar.setValue(i) apertureData0pol, apertureData90pol = np.asarray( apertureData0pol), np.asarray(apertureData90pol) ##Plot 0 deg results averaged## PW = np.linspace(0, 10, 41) azimuthalSum0pol = [] for wnIdx, _ in enumerate(wavelen): azimuthalSum0pol.append(np.sum(apertureData0pol[wnIdx], axis=0)) azimuthalSum0pol = np.asarray(azimuthalSum0pol) fig0 = Figure() ax1f1 = fig0.add_subplot(211) ax1f1.set_title('Averaged Aperture Efficenty for each PW angle') for azimuthalSum0polN, wn in zip(azimuthalSum0pol, wavelen): ax1f1.plot(PW, azimuthalSum0polN / 37, label='%d 0pol' % (wn)) ax1f1.set_xlabel('PW inclination angle (deg)') ax1f1.set_ylabel('Efficientcy') ax1f1.legend(loc='best') ##Plot 90 deg results azimuthally averaged## azimuthalSum90pol = [] for wnIdx, _ in enumerate(wavelen): azimuthalSum90pol.append(np.sum(apertureData90pol[wnIdx], axis=0)) azimuthalSum90pol = np.asarray(azimuthalSum90pol) ax1f2 = fig0.add_subplot(212) for azimuthalSum90polN, wn in zip(azimuthalSum90pol, wavelen): ax1f2.plot(PW, azimuthalSum90polN / 37, label='%d 90pol' % (wn)) ax1f2.set_xlabel('PW inclination angle (deg)') ax1f2.set_ylabel('Efficientcy') ax1f2.legend(loc='best') ##Plot Absolute eff for 0/90deg results fig1 = Figure() ax1f3 = fig1.add_subplot(211) ax1f3.set_title('Aperture Efficenty for each wavelength') ax1f3.plot(wavelen, absEff0pol, marker='o', linestyle='--', label='Aperture Efficientcy 0pol') ax1f3.set_xlabel('Wavelenght (um)') ax1f3.set_ylabel('Aperture (%s)' % (ureg.steradian * ureg.meter**2)) ax1f3.legend(loc='best') ax1f4 = fig1.add_subplot(212) ax1f4.plot(wavelen, absEff90pol, marker='o', linestyle='--', c='r', label='Aperture Efficientcy 90pol') ax1f4.set_xlabel('Wavelenght (um)') ax1f4.set_ylabel('Aperture (%s)' % (ureg.steradian * ureg.meter**2)) ax1f4.legend(loc='best') path = 'C:/Users/Joe/Documents/Python Scripts/Scatter Pixel Code/Consolidated_Filter.txt' FilterCoeff = FT.filterTransmission(path, wavelen * 1e-6) BBT = float(self.BBtemp.toPlainText()) specIr = BBS.blackBodySpec(wavelen * 1e-6, BBT) specPowerAbsorbed0 = FilterCoeff * specIr * absEff0pol * ureg.steradian * ureg.mm**2 specPowerAbsorbed90 = FilterCoeff * specIr * absEff90pol * ureg.steradian * ureg.mm**2 fig3 = Figure() ax1f5 = fig3.add_subplot(211) ax1f5.set_title('Spectral Power Absorbed for each wavelength') ax1f5.plot(wavelen, baseUnits(specPowerAbsorbed0), marker='o', linestyle='--', label='Aperture Efficientcy 0pol') ax1f5.set_xlabel('Wavelenght (um)') #ax1f5.set_ylabel('Amplitude (%s)'%(specPowerAbsorbed0.units)) ax1f5.legend(loc='best') ax1f6 = fig3.add_subplot(212) ax1f6.plot(wavelen, baseUnits(specPowerAbsorbed90), marker='o', linestyle='--', label='Aperture Efficientcy 90pol') ax1f6.set_xlabel('Wavelenght (um)') ax1f6.set_ylabel('Amplitude \n(%s)' % (specPowerAbsorbed90.to_base_units().units)) ax1f6.legend(loc='best') totalPowerAbsorbed0pol = simps(baseUnits(specPowerAbsorbed0), wavelen * 1e-6) #(watts) totalPowerAbsorbed90pol = simps(baseUnits(specPowerAbsorbed90), wavelen * 1e-6) #(watts) self.totalPowerAbsorbed0.setText( str(totalPowerAbsorbed0pol * ureg.watt)) self.totalPowerAbsorbed90.setText( str(totalPowerAbsorbed90pol * ureg.watt)) self.rmmpl_2() self.addmpl_2(fig0) self.rmmpl_4() self.addmpl_4(fig1) self.rmmpl_5() self.addmpl_5(fig3) def simpleModel(self): PW = np.linspace(0, 10, 41) wavelen = np.linspace(float(self.min.toPlainText()), float(self.max.toPlainText()), float(self.samples.toPlainText())) AppEff = SEAF.simulateEffectiveApertureEfficiency( wavelen, float(self.EOAX.toPlainText()), float(self.EOAM.toPlainText()), float(self.PAEX.toPlainText()), float(self.PAEM.toPlainText()), PW) figx = Figure() ax1f1 = figx.add_subplot(111) ax1f1.set_title('Simulated Effective Aperture Eff') for an, wn in zip(AppEff, wavelen): ax1f1.plot(PW, an, label='wavelength %dum' % wn) ax1f1.set_xlabel('Inclination angle') ax1f1.set_ylabel('Efficiency') ax1f1.legend(loc='best') ax1f1.grid() self.rmmpl() self.addmpl(figx) def addmpl(self, fig): self.canvas = FigureCanvas(fig) self.mplvl_0.addWidget(self.canvas) self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mplwindow, coordinates=True) self.mplvl_0.addWidget(self.toolbar) def addmpl_2(self, fig): self.canvas2 = FigureCanvas(fig) self.mplvl_2.addWidget(self.canvas2) self.canvas2.draw() self.toolbar2 = NavigationToolbar(self.canvas2, self.mplwindow_2, coordinates=True) self.mplvl_2.addWidget(self.toolbar2) def addmpl_3(self, fig): self.canvas3 = FigureCanvas(fig) self.mplvl_3.addWidget(self.canvas3) self.canvas3.draw() self.toolbar3 = NavigationToolbar(self.canvas3, self.mplwindow_3, coordinates=True) self.mplvl_3.addWidget(self.toolbar3) def addmpl_4(self, fig): self.canvas4 = FigureCanvas(fig) self.mplvl_4.addWidget(self.canvas4) self.canvas4.draw() self.toolbar4 = NavigationToolbar(self.canvas4, self.mplwindow_4, coordinates=True) self.mplvl_4.addWidget(self.toolbar4) def addmpl_5(self, fig): self.canvas5 = FigureCanvas(fig) self.mplvl_5.addWidget(self.canvas5) self.canvas5.draw() self.toolbar5 = NavigationToolbar(self.canvas5, self.mplwindow_5, coordinates=True) self.mplvl_5.addWidget(self.toolbar5) def rmmpl(self): self.mplvl_0.removeWidget(self.canvas) self.canvas.close() self.mplvl_0.removeWidget(self.toolbar) self.toolbar.close() def rmmpl_2(self): self.mplvl_2.removeWidget(self.canvas2) self.canvas2.close() self.mplvl_2.removeWidget(self.toolbar2) self.toolbar2.close() def rmmpl_3(self): self.mplvl_3.removeWidget(self.canvas3) self.canvas3.close() self.mplvl_3.removeWidget(self.toolbar3) self.toolbar3.close() def rmmpl_4(self): self.mplvl_4.removeWidget(self.canvas4) self.canvas4.close() self.mplvl_4.removeWidget(self.toolbar4) self.toolbar4.close() def rmmpl_5(self): self.mplvl_5.removeWidget(self.canvas5) self.canvas5.close() self.mplvl_5.removeWidget(self.toolbar5) self.toolbar5.close() def scatterPixelIntegrator(self, wavelen, pol, width, height): fileMI = 'mode amplitude vs angle %dp0 um %dp0 deg.dat' % (wavelen, pol) fileMS = 'mode coefficients %dp0 um %dp0 deg-%d.dat' folderM = 'C:\\Users\\Joe\\Documents\\Python Scripts\\Scatter Pixel Code\\mode coefficients %dp0 um %dp0 deg' % ( wavelen, pol) fileS = 'sron_rect_gap%dum_s11_abso400_%s.dat' folderS = 'C:\\Users\\Joe\\Documents\\Python Scripts\\Scatter Pixel Code\\Scatter Data' ApertureArea = width * height ##WORKING Amps, modelist, PW, Azi = LMD.loadModalData(fileMI, fileMS, folderM, wavelen, pol) print('Modal Data Loaded') ##WORKING S11 = LSD.loadScatterData(fileS, folderS, wavelen) print('Scatter Data Loaded') ##WORKING AbosrbtionChannels = FAM.findAbsorptionModes(S11) # return PW,Azi,ApertureArea,modelist,Amps,AbosrbtionChannels print('AbsorbtionChannels got') absEff, RRR = IPP.integratePixelPerformance(PW, Azi, ApertureArea, modelist, Amps, AbosrbtionChannels) print('done') return absEff, RRR
class MplCanvas(object): """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.).""" def __init__(self, brain, width, height, dpi): from PyQt5 import QtWidgets from matplotlib import rc_context from matplotlib.figure import Figure from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg if brain.separate_canvas: parent = None else: parent = brain.window # prefer constrained layout here but live with tight_layout otherwise context = nullcontext extra_events = ('resize', ) try: context = rc_context({'figure.constrained_layout.use': True}) extra_events = () except KeyError: pass with context: self.fig = Figure(figsize=(width, height), dpi=dpi) self.canvas = FigureCanvasQTAgg(self.fig) self.axes = self.fig.add_subplot(111) self.axes.set(xlabel='Time (sec)', ylabel='Activation (AU)') self.canvas.setParent(parent) FigureCanvasQTAgg.setSizePolicy(self.canvas, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) FigureCanvasQTAgg.updateGeometry(self.canvas) self.brain = brain self.time_func = brain.callbacks["time"] for event in ('button_press', 'motion_notify') + extra_events: self.canvas.mpl_connect(event + '_event', getattr(self, 'on_' + event)) def plot(self, x, y, label, **kwargs): """Plot a curve.""" line, = self.axes.plot(x, y, label=label, **kwargs) self.update_plot() return line def plot_time_line(self, x, label, **kwargs): """Plot the vertical line.""" line = self.axes.axvline(x, label=label, **kwargs) self.update_plot() return line def update_plot(self): """Update the plot.""" leg = self.axes.legend(prop={ 'family': 'monospace', 'size': 'small' }, framealpha=0.5, handlelength=1., facecolor=self.brain._bg_color) for text in leg.get_texts(): text.set_color(self.brain._fg_color) with warnings.catch_warnings(record=True): warnings.filterwarnings('ignore', 'constrained_layout') self.canvas.draw() def set_color(self, bg_color, fg_color): """Set the widget colors.""" self.axes.set_facecolor(bg_color) self.axes.xaxis.label.set_color(fg_color) self.axes.yaxis.label.set_color(fg_color) self.axes.spines['top'].set_color(fg_color) self.axes.spines['bottom'].set_color(fg_color) self.axes.spines['left'].set_color(fg_color) self.axes.spines['right'].set_color(fg_color) self.axes.tick_params(axis='x', colors=fg_color) self.axes.tick_params(axis='y', colors=fg_color) self.fig.patch.set_facecolor(bg_color) def show(self): """Show the canvas.""" self.canvas.show() def close(self): """Close the canvas.""" self.canvas.close() def on_button_press(self, event): """Handle button presses.""" # left click (and maybe drag) in progress in axes if (event.inaxes != self.axes or event.button != 1): return self.time_func(event.xdata, update_widget=True, time_as_index=False) def clear(self): """Clear internal variables.""" self.close() self.axes.clear() self.fig.clear() self.brain = None self.canvas = None on_motion_notify = on_button_press # for now they can be the same def on_resize(self, event): """Handle resize events.""" tight_layout(fig=self.axes.figure)
class SigmaSwiperProgram(QtWidgets.QMainWindow,Ui_sigmaSwiper): guest_list = {"ID":[], "NAME":[]} has_guest = False has_graph = False data = {"TIME":[], "ID":[], "NAME":[]} graph_x = [] graph_y = [] today=datetime.datetime.now().strftime("%m-%d-%y") count = 0 settings = {} settings_file=".settings.ini" config = configparser.ConfigParser() fig = plt.Figure() def __init__(self): Ui_sigmaSwiper.__init__(self) QtWidgets.QMainWindow.__init__(self) self.setupUi(self) self.submit_button.clicked.connect(self.read_ID) self.action_export_list.triggered.connect(self.export_data) self.action_load_guest_list.triggered.connect(self.input_guest_list) self.action_exit.triggered.connect(qApp.quit) self.config.read(self.settings_file) self.settings = self.config['settings'] self.guest_list_check_label.setStyleSheet('color: black') self.guest_list_check_label.setText("Load a guest list") self.id_input.returnPressed.connect(self.read_ID) self.graph_layout = QtWidgets.QVBoxLayout() self.graph_widget.setLayout(self.graph_layout) def input_guest_list(self): fname = QFileDialog.getOpenFileName(None, 'Open Guestlist' , os.path.expanduser('~')+"/Desktop/", "Excel Files (*.xlsx)") if fname[0] == '': pass else: excel_file = pd.ExcelFile(fname[0]) df = excel_file.parse("Sheet1") self.guest_list["ID"] = df["ID"].tolist() self.guest_list["NAME"] = df["NAME"].tolist() self.has_guest = True self.guest_list_check_label.setStyleSheet('color: black') self.guest_list_check_label.setText("Guest List Loaded") def read_ID(self): inp = self.id_input.text() if len(inp) == 6: if self.has_guest: if int(inp) not in self.guest_list["ID"]: self.guest_list_check_label.setText("Not On List") self.guest_list_check_label.setStyleSheet('color: red') self.id_input.clear() else: self.count +=1 self.graph_y.append(self.count) self.data["ID"].append(inp) self.data["TIME"].append(datetime.datetime.now().strftime("%H:%M")) self.graph_x.append(datetime.datetime.now().strftime("%H:%M:%S")) name =self.guest_list["NAME"][self.guest_list["ID"].index(int(inp))] self.data["NAME"].append(name) self.guest_list_check_label.setText("On List") self.guest_list_check_label.setStyleSheet('color: green') self.lcdNumber.display(self.count) self.list_preview.addItem(name+" - "+inp) self.plot_data() #if self.count % 10 == 0: # export = pd.DataFrame(self.data) # export.index += 1 # fname = os.path.expanduser('~')+'/Desktop/temp/.xlsx' #export.to_excel(fname[0]) else: self.guest_list_check_label.setText("No Guest List Loaded") self.guest_list_check_label.setStyleSheet('color: yellow') self.id_input.clear() elif len(inp) == 13: inp = inp[4:10] if self.has_guest: if int(inp) not in self.guest_list["ID"]: self.guest_list_check_label.setText("Not On List") self.guest_list_check_label.setStyleSheet('color: red') self.id_input.clear() else: self.count +=1 self.graph_y.append(self.count) self.data["ID"].append(inp) self.data["TIME"].append(datetime.datetime.now().strftime("%H:%M")) self.graph_x.append(datetime.datetime.now().strftime("%H:%M:%S")) name =self.guest_list["NAME"][self.guest_list["ID"].index(int(inp))] self.data["NAME"].append(name) self.guest_list_check_label.setText("On List") self.guest_list_check_label.setStyleSheet('color: green') self.lcdNumber.display(self.count) self.list_preview.addItem(name+" - "+inp) self.plot_data() #if self.count % 10 == 0: # export = pd.DataFrame(self.data) # export.index += 1 # fname = os.path.expanduser('~')+"/Desktop/temp.xlsx" #export.to_excel(fname[0]) else: self.guest_list_check_label.setText("No Guest List Loaded") self.guest_list_check_label.setStyleSheet('color: yellow') self.id_input.clear() else: self.guest_list_check_label.setText("Invalid Input") self.guest_list_check_label.setStyleSheet('color: yellow') self.id_input.clear() def email_list(self,file_path): if self.settings["send_email"] == "yes": for x in self.settings["to_email"].strip().split(','): try: toaddr = x.strip() fromaddr = self.settings["from_email"] msg = MIMEMultipart() msg['From'] = fromaddr msg['To'] = toaddr msg['Subject'] = "Party List for "+self.today body = "Hello,\n Attached is the attendance sheet for our social event on "+self.today+". If any additional information is needed, please contact <insert responsible person here>" msg.attach(MIMEText(body, 'plain')) filename = file_path.split("/")[-1] attachment = open(file_path, "rb") part = MIMEBase('application', 'octet-stream') part.set_payload((attachment).read()) encoders.encode_base64(part) part.add_header('Content-Disposition', "attachment; filename= %s" % filename) msg.attach(part) server = smtplib.SMTP('smtp.gmail.com', 587) server.starttls() server.login(fromaddr, self.settings["email_password"]) text = msg.as_string() server.sendmail(fromaddr, toaddr, text) server.quit() except: print("email error") pass else: pass def export_data(self): export = pd.DataFrame(self.data) export.index += 1 fname = QFileDialog.getSaveFileName(None, 'Save Guest Log' , os.path.expanduser('~')+"/Desktop/"+self.today+"-"+self.settings["default_filename"]+".xlsx","Excel Files (*.xlsx)" ) if fname[0] == '': pass else: export.to_excel(fname[0]) self.email_list(fname[0]) def plot_data(self): if not self.has_graph: new_x = [mdates.datestr2num(x) for x in self.graph_x] plt.xlabel('Time') plt.ylabel('Count') ax = self.fig.add_subplot(111) ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M')) ax.plot(new_x, self.graph_y, 'r-') ax.get_xaxis().set_ticks([]) #ax.get_yaxis().set_ticks([]) self.canvas = FigureCanvas(self.fig) self.graph_layout.addWidget(self.canvas) self.canvas.draw() self.has_graph = True else: self.graph_layout.removeWidget(self.canvas) self.canvas.close() self.fig.clf() plt.xlabel('Time') plt.ylabel('Count') ax = self.fig.add_subplot(111) ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M')) new_x = [mdates.datestr2num(x) for x in self.graph_x] ax.plot(new_x, self.graph_y, 'r-') ax.get_xaxis().set_ticks([]) #ax.get_yaxis().set_ticks([]) self.canvas = FigureCanvas(self.fig) self.graph_layout.addWidget(self.canvas) self.canvas.draw()
class Main(QMainWindow, Ui_MainWindow): def __init__(self, ): super(Main, self).__init__() self.setupUi(self) self.showMaximized() self.ave = np.array([]) # empty array for average bore self.auto_flag = False # autoscale flag self.spinBoxval = 0 # defualt 4D data_cube dimension self.spinBox.hide() # hide option unless 4D self.colourmap = 'viridis' # default colourmap self.interpMethod = 'nearest' # default interp method self.cmapmin = None # default colourbar range, i.e let matplotlib decide self.cmapmax = None self.hres = 1 # default res, i.e jut voxel numbers on axis self.vres = 1 self.Normx = None # normalisation method. default set to None self.Normy = None self.Normz = None self.XView.setChecked(True) self.fig = Figure() self.ax1 = self.fig.add_subplot(111) self.X = datacube() self.AveBoreView = 'X' # change view of cube self.XView.toggled.connect(lambda: self.btnstate(self.XView)) self.YView.toggled.connect(lambda: self.btnstate(self.YView)) self.ZView.toggled.connect(lambda: self.btnstate(self.ZView)) self.Bore.toggled.connect(lambda: self.btnstate(self.Bore)) self.AverageBore.toggled.connect( lambda: self.btnstate(self.AverageBore)) # update data when slider moved self.Scroll_Horz.valueChanged[int].connect(self.sliderval) self.Scroll_Vert.valueChanged[int].connect(self.sliderval) self.file_open(args) self.Open.triggered.connect(self.file_open) self.Save_Avg_Bore.triggered.connect(self.saveBore) self.Reset.triggered.connect(self.reset_plot) self.AutoScale.triggered.connect(self.Auto_Scale_plot) # self.Bore_View.triggered.connect(self.ViewBore) self.action_Save_Gif.triggered.connect(self.saveGif) self.action_Colour_Map.triggered.connect(self.changeColourMap) self.action_Interpolation_Method.triggered.connect(self.changeInterpolationMethod) self.action_Colour_Bar_Clip.triggered.connect(self.changeclipColourBarRange) self.action_Save_Image.triggered.connect(self.saveImage) self.action_Normalisation_Method.triggered.connect(self.changeNormMethod) self.action_Bore_Location.triggered.connect(self.setBoreLocation) self.spinBox.valueChanged.connect(self.changeSpinbox) def setBoreLocation(self, ): xloc, ok = QtWidgets.QInputDialog.getInt( self, 'Input location', 'Enter X location:') yloc, ok = QtWidgets.QInputDialog.getInt( self, 'Input location', 'Enter Y location:') self.Scroll_Horz.setValue(xloc) self.Scroll_Vert.setValue(yloc) if self.Bore.isChecked(): if self.BoreView == 'X': self.im.set_ydata(self.X.data[:, xloc, yloc][::]) elif self.BoreView == 'Y': self.im.set_ydata(self.X.data[xloc, :, yloc][::]) elif self.BoreView == 'Z': self.im.set_ydata(self.X.data[yloc, xloc, :][::]) # try and redraw try: self.im.axes.figure.canvas.draw() if self.auto_flag: self.im.autoscale() except AttributeError: pass def changeNormMethod(self, ): # func to change Normalisation method of matshow method = self.getNormDialog() if(method == 'Log'): self.Normx = colors.LogNorm(vmin=0.1, vmax=self.X.data[self.ind, :, :].max()) self.Normy = colors.LogNorm(vmin=0.1, vmax=self.X.data[:, self.ind, :].max()) self.Normz = colors.LogNorm(vmin=0.1, vmax=self.X.data[:, :, self.ind].max()) elif(method == 'Symmetric Log'): self.Normx = colors.SymLogNorm(linthresh=1., vmin=self.X.data[self.ind, :, :].min(), vmax=self.X.data[self.ind, :, :].max()) self.Normy = colors.SymLogNorm(linthresh=1., vmin=self.X.data[:, self.ind, :].min(), vmax=self.X.data[:, self.ind, :].max()) self.Normz = colors.SymLogNorm(linthresh=1., vmin=self.X.data[:, :, self.ind].max(), vmax=self.X.data[:, :, self.ind].max()) elif(method == 'Linear'): self.Normx = None self.Normy = None self.Normz = None self.reset_plot(False) self.init_plot() def saveImage(self, ): # saves data and image of current view name = self.showGifDialog() if self.XView.isChecked(): np.savetxt(name + '.dat', self.X.data[self.Scroll_Vert.value(), :, :], delimiter=' ') elif self.YView.isChecked(): np.savetxt(name + '.dat', self.X.data[:, self.Scroll_Vert.value(), :], delimiter=' ') elif self.ZView.isChecked(): np.savetxt(name + '.dat', self.X.data[:, :, self.Scroll_Vert.value()], delimiter=' ') self.hres, self.vres = self.showextentDialog() # scale x, y ticks to actual scale based upon user definition # thanks https://stackoverflow.com/a/17816809/6106938 # change so that it uses extent=[xmin, xmax, ymin, ymax] # set default as None # then change here. extent added to matshow(*args, extent=[...]) ticks = ticker.FuncFormatter(lambda x, pos: '{0:g}'.format(x * self.hres)) self.ax1.xaxis.set_major_formatter(ticks) ticks = ticker.FuncFormatter(lambda y, pos: '{0:g}'.format(y * self.vres)) self.ax1.yaxis.set_major_formatter(ticks) self.fig.savefig(name + '.png') def changeColourMap(self, ): # change cmap self.colourmap = self.showColourmapsDialog() self.reset_plot(False) self.init_plot() def changeclipColourBarRange(self, ): # change vmin, vmax for cbar self.cmapmin, self.cmapmax = self.showclipColourBarDialog() self.reset_plot(False) self.init_plot() def changeInterpolationMethod(self, ): # change interpolation method for image self.interpMethod = str(self.showInterpolationDialog()) self.reset_plot(False) self.init_plot() def saveGif(self): rang = self.showGifframesDialog() # get range of frames step = self.showGifstepDialog() # get number of images name = self.showGifDialog() # name of file tight = self.showGifExtent() # tight or not # loop over range and make images tmpplace = self.Scroll_Vert.value() if rang * step > tmpplace: rang = tmpplace for i in range(rang): self.Scroll_Horz.setValue(self.ind) self.Scroll_Vert.setValue(tmpplace - (i * step)) self.sliderval() if tight: extent = self.ax1.get_window_extent().transformed(fig.dpi_scale_trans.inverted()) self.fig.savefig(str(i).zfill(3) + 'pic.png', bbox_inches=extent) else: self.fig.savefig(str(i).zfill(3) + 'pic.png') # use ffmpeg to create gif if tight: os.system("mogrify -trim *pic.png") os.system("ffmpeg -framerate 10 -pattern_type glob -i '*pic.png' -c:v libx264 -r 24 -pix_fmt yuv420p -vf 'pad=ceil(iw/2)*2:ceil(ih/2)*2' " + name + ".mp4") os.system('rm *pic.png') print('done') def changeSpinbox(self): # for 4d data cubes self.spinBoxval = int(self.spinBox.value()) fd = open(self.name, 'rb') self.readslice(fd, self.ndim, np.float64, self.cubeorder) self.reset_plot() self.init_plot() def Auto_Scale_plot(self): # autoscale cbar on plot and reset clipping if any self.cmapmin = None self.cmapmax = None if not self.auto_flag: self.auto_flag = True else: self.auto_flag = False def sliderval(self): # move slider and update data if self.XView.isChecked(): # fd = open(self.name, 'rb') self.X.readslice(self.Scroll_Horz.value()) self.im.set_data(self.X.data[self.Scroll_Vert.value(), :, :]) # self.Scroll_Horz.setValue(0) # pin unsed slider elif self.YView.isChecked(): self.X.readslice(self.Scroll_Horz.value()) self.im.set_data(self.X.data[:, self.Scroll_Vert.value(), :]) # self.Scroll_Horz.setValue(0) # pin unsed slider elif self.ZView.isChecked(): self.X.readslice(self.Scroll_Horz.value()) self.im.set_data(self.X.data[:, :, self.Scroll_Vert.value()]) # self.Scroll_Horz.setValue(0) # pin unsed slider elif self.Bore.isChecked(): if self.BoreView == 'X': self.im.set_ydata(self.X.data[:, self.Scroll_Horz.value(), self.Scroll_Vert.value()][::]) if self.auto_flag: self.ax1.relim() self.ax1.autoscale_view(True, True, True) elif self.BoreView == 'Y': self.im.set_ydata(self.X.data[self.Scroll_Horz.value(), :, self.Scroll_Vert.value()][::]) if self.auto_flag: self.ax1.relim() self.ax1.autoscale_view(True, True, True) elif self.BoreView == 'Z': self.im.set_ydata(self.X.data[self.Scroll_Vert.value(), self.Scroll_Horz.value(), :][::]) if self.auto_flag: self.ax1.relim() self.ax1.autoscale_view(True, True, True) elif self.AverageBore.isChecked(): self.Scroll_Horz.setValue(self.ind) self.Scroll_Vert.setValue(self.ind) # try and redraw try: self.im.axes.figure.canvas.draw() if self.auto_flag: self.im.autoscale() except AttributeError: pass def addmpl(self): # add plot to anvas self.rmmpl() self.canvas = FigureCanvas(self.fig) self.mplvl.addWidget(self.canvas) self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas, self.mplwindow) self.mplvl.addWidget(self.toolbar) def rmmpl(self): # delete plot from canvas try: self.canvas.close() self.canvas.deleteLater() self.toolbar.close() self.toolbar.deleteLater() gc.collect() except: pass def saveBore(self,): # save bore as a list of points name = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File') f = open(name, 'w') if len(self.ave) > 1: for i in range(len(self.ave)): f.write(str(self.ave[i]) + '\n') f.close() else: if self.BoreView == "X": tmp = self.X[:, self.Scroll_Horz.value(), self.Scroll_Vert.value()] elif self.BoreView == "Y": tmp = self.X[self.Scroll_Horz.value(), :, self.Scroll_Vert.value()] elif self.BoreView == "Z": tmp = self.X[self.Scroll_Horz.value(), self.Scroll_Vert.value(), :] for i in range(len(tmp)): f.write(str(tmp[i]) + '\n') def file_open(self, args): self.reset_plot() while True: try: # get file name if args.file is None: self.X.name = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File')[0] else: self.X.name = args.file # get precision of data cube self.X.dtype, self.X.cubeorder, item = self.getPrec(args) # get dimensions of data cube. can be guessed bool4d = False if self.X.cubeorder == 4: bool4d = True self.X.ndim = self.getSize(args, item, bool4d) try: fd = open(self.X.name, 'rb') except FileNotFoundError: self.ErrorDialog("File not Found!") self.X.name = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File')[0] self.X.readslice(0) self.init_plot() break except ValueError: size = os.path.getsize(self.X.name) if "Real*8" in item: size /= 8 elif "Real*4" in item: size /= 4 mssg = "Value of Ndim or precision is incorrect for this data cube.\n On disk size is: {:010d}.\n".format(int(size)) val2 = self.X.is_perfect_n(size, 2.) val3 = self.X.is_perfect_n(size, 3.) if (val2 and val3) != 0: mssg += " Try x=y={:04d}, z=1\n or x=y=z={:04d}.".format(int(val2), int(val3)) elif val2 != 0: mssg += "Try x=y={:04d}, z=1.".format(int(val2)) elif val3 != 0: mssg += "Try x=y=z={:04d}.".format(int(val3)) self.ErrorDialog(mssg) args.ndim = None args.fpprec = None except UnboundLocalError: pass break def getSize(self, args, item, bool4d): if args.ndim is None and item: size = os.path.getsize(self.X.name) if "Real*8" in item: size /= 8 elif "Real*4" in item: size /= 4 if self.X.is_perfect_n(size, 3.) != 0: size = self.X.is_perfect_n(size, 3.) ndim = (size, size, size) else: ndim = self.showNdimDialog(bool4d) else: ndim = (args.ndim, args.ndim, args.ndim) return ndim def getPrec(self, args): # get precision of data cube item = None if args.fpprec is None: item = str(self.showDtDialog()) if "Real*8" in item: dt = np.float64 elif "Real*4" in item: dt = np.float32 if "4 dim" in item: dim = 4 elif "3 dim" in item: dim = 3 else: if args.fpprec == 1: dt = np.float32 dim = 4 elif args.fpprec == 2: dt = np.float64 dim = 4 elif args.fpprec == 3: dt = np.float32 dim = 3 elif args.fpprec == 4: dt = np.float64 dim = 3 return dt, dim, item def btnstate(self, b): if b.text() == "X View": if b.isChecked() is True: self.reset_plot(False) self.Scroll_Vert.setMaximum(self.rows - 1) self.im = self.ax1.matshow(self.X.data[self.ind, :, :], vmin=self.cmapmin, vmax=self.cmapmax, cmap=str(self.colourmap), interpolation=self.interpMethod, norm=self.Normx) self.fig.colorbar(self.im) self.fig.set_tight_layout(True) self.ax1.set_aspect('auto') self.addmpl() if b.text() == "Y View": if b.isChecked() is True: self.reset_plot(False) self.Scroll_Vert.setMaximum(self.cols - 1) self.im = self.ax1.matshow(self.X.data[:, self.ind, :], vmin=self.cmapmin, vmax=self.cmapmax, cmap=str(self.colourmap), interpolation=self.interpMethod, norm=self.Normy) self.fig.colorbar(self.im) self.fig.set_tight_layout(True) self.ax1.set_aspect('auto') self.addmpl() if b.text() == "Z View": if b.isChecked() is True: self.reset_plot(False) self.Scroll_Vert.setMaximum(self.slices - 1) self.im = self.ax1.matshow(self.X.data[:, :, self.ind], vmin=self.cmapmin, vmax=self.cmapmax, cmap=str(self.colourmap), interpolation=self.interpMethod, norm=self.Normz) try: self.fig.colorbar(self.im) except ZeroDivisionError: self.ErrorDialog("Divison by zero, try another range") self.Normz = None self.Normy = None self.Normz = None self.cmapmin = None self.cmapmax = None self.btnstate(b) self.fig.set_tight_layout(True) self.ax1.set_aspect('auto') self.addmpl() if b.text() == "Draw Bore": if b.isChecked() is True: self.ViewBore() self.reset_plot(False) if self.BoreView == 'X': self.im, = self.ax1.plot(self.X.data[:, self.ind, self.ind]) elif self.BoreView == 'Y': self.im, = self.ax1.plot(self.X.data[self.ind, :, self.ind]) elif self.BoreView == 'Z': self.im, = self.ax1.plot(self.X.data[self.ind, self.ind, :]) self.fig.set_tight_layout(True) self.addmpl() if b.text() == "Avg. Bore": if b.isChecked() is True: self.AveBoreChecked() def ViewBore(self): self.BoreView = self.showBoreViewDialog() if self.BoreView == 'X': self.view = (1, 2) elif self.BoreView == 'Y': self.view = (0, 2) elif self.BoreView == 'Z': self.view = (0, 1) def AveBoreChecked(self): self.ViewBore() self.reset_plot(False) if len(self.ave) == 0: self.ave = np.array([]) self.ave = np.sum(self.X.data, self.view) self.ave /= (len(self.X.data[self.view[0]]) * len(self.X.data[self.view[1]])) self.im = self.ax1.plot(self.ave[::]) self.fig.set_tight_layout(True) self.addmpl() def reset_plot(self, *args): self.ave = np.array([]) self.fig.clf() self.ax1.clear() gc.collect() # fixes most of memory leak self.fig = Figure() self.ax1 = self.fig.add_subplot(111) self.rmmpl() def init_plot(self, ): self.rmmpl() if self.X.cubeorder == 4: self.rows, self.cols, self.slices, self.depth = self.X.ndim else: self.rows, self.cols, self.slices = self.X.ndim self.depth = 0 self.ind = 0 # int(rows / 2) if self.XView.isChecked(): view = self.XView self.Scroll_Vert.setMaximum(self.rows) self.Scroll_Horz.setMaximum(self.depth) elif self.YView.isChecked(): view = self.YView self.Scroll_Vert.setMaximum(self.cols) self.Scroll_Horz.setMaximum(self.depth) elif self.ZView.isChecked(): view = self.ZView self.Scroll_Vert.setMaximum(self.slices) self.Scroll_Horz.setMaximum(self.cols) elif self.AverageBore.isChecked(): view = self.AverageBore self.Scroll_Vert.setMaximum(self.rows) elif self.Bore_View.isChecked(): view = self.ViewBore self.Scroll_Vert.setMaximum(self.cols) self.Scroll_Horz.setMaximum(self.rows) self.btnstate(view) self.Scroll_Horz.setValue(self.ind) self.Scroll_Vert.setValue(self.ind) def showGifframesDialog(self, ): text, ok = QtWidgets.QInputDialog.getInt( self, '# of frames', 'Enter # of frames:') if ok: return(text) def showGifstepDialog(self, ): text, ok = QtWidgets.QInputDialog.getInt( self, 'Step size', 'Enter value of step:') if ok: return(text) def showGifExtent(self, ): items = ("Colour Bar", "No Colour Bar") text, ok = QtWidgets.QInputDialog.getItem( self, "Colour Bar on GIF?", " ", items, 0, False) if ok and text: if items == "Colour Bar": text = False else: text = True return text def showNdimDialog(self, bool4d): text1, ok1 = QtWidgets.QInputDialog.getInt( self, 'Input Ndim', 'Enter X Ndim:') if ok1: text2, ok2 = QtWidgets.QInputDialog.getInt( self, 'Input Ndim', 'Enter Y Ndim:') if ok2: text3, ok3 = QtWidgets.QInputDialog.getInt( self, 'Input Ndim', 'Enter Z Ndim:') if ok3 and bool4d: text4, ok4 = QtWidgets.QInputDialog.getInt( self, 'Input Ndim', 'Enter T Ndim:') return (text1, text2, text3, text4) else: return (text1, text2, text3) def showDtDialog(self, ): items = ("4 dim Real*4", "4 dim Real*8", "3 dim Real*4", "3 dim Real*8") item, ok = QtWidgets.QInputDialog.getItem(self, "Select Fortran Precision", "Precisions", items, 0, False) if ok and item: return item def showBoreViewDialog(self, ): items = ("X", "Y", "Z") item, ok = QtWidgets.QInputDialog.getItem(self, "Select Average Bore Direction", "Views", items, 0, False) if ok and item: return item def showGifDialog(self, ): text, ok = QtWidgets.QInputDialog.getText( self, 'Filename Dialog', 'Enter filename:') if ok: return str(text) def showextentDialog(self, ): hres, ok = QtWidgets.QInputDialog.getDouble( self, 'Data Extent', 'Enter horizontal resolution:', 0, -100, 100, 9,) if ok: vres, ok = QtWidgets.QInputDialog.getDouble( self, 'Data Extent', 'Enter vertical resolution:', 0, -100, 100, 9,) if ok: return (hres, vres) def getNormDialog(self, ): items = ("Log", "Linear", "Symmetric Log") item, ok = QtWidgets.QInputDialog.getItem(self, "Select cbar normalisation method", "Method:", items, 0, False) if ok and item: return item def showColourmapsDialog(self, ): items = ('viridis', 'inferno', 'plasma', 'magma', 'Blues', 'BuGn', 'BuPu', 'GnBu', 'Greens', 'Greys', 'Oranges', 'OrRd', 'PuBu', 'PuBuGn', 'PuRd', 'Purples', 'RdPu', 'Reds', 'YlGn', 'YlGnBu', 'YlOrBr', 'YlOrRd', 'afmhot', 'autumn', 'bone', 'cool', 'copper', 'gist_heat', 'gray', 'hot', 'pink', 'spring', 'summer', 'winter', 'BrBG', 'bwr', 'coolwarm', 'PiYG', 'PRGn', 'PuOr', 'RdBu', 'RdGy', 'RdYlBu', 'RdYlGn', 'Spectral', 'seismic', 'Accent', 'Dark2', 'Paired', 'Pastel1', 'Pastel2', 'Set1', 'Set2', 'Set3', 'Vega10', 'Vega20', 'Vega20b', 'Vega20c', 'gist_earth', 'terrain', 'ocean', 'gist_stern', 'brg', 'CMRmap', 'cubehelix', 'gnuplot', 'gnuplot2', 'gist_ncar', 'nipy_spectral', 'jet', 'rainbow', 'gist_rainbow', 'hsv', 'flag', 'prism') item, ok = QtWidgets.QInputDialog.getItem(self, "Select Colour Map", "Cmaps", items, 0, False) if ok and item: return item def showInterpolationDialog(self, ): items = ('none', 'nearest', 'bilinear', 'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos') item, ok = QtWidgets.QInputDialog.getItem(self, "Select Interpolation Method", "Methods", items, 0, False) if ok and item: return item def showclipColourBarDialog(self, ): text1, ok1 = QtWidgets.QInputDialog.getDouble( self, 'Input cbar min', 'Enter min:', 0., np.finfo("d").min, np.finfo("d").max, 10) if ok1: text2, ok2 = QtWidgets.QInputDialog.getDouble( self, 'Input cbar max', 'Enter max:', 0., np.finfo("d").min, np.finfo("d").max, 10) if ok2: return (float(text1), float(text2)) def ErrorDialog(self, ErrMsg): QtWidgets.QMessageBox.warning(self, "Error", ErrMsg)
class Main(QMainWindow, Ui_MainWindow): def __init__(self,specfilename,parfilename=None,wave1=None,wave2=None,numchunks=8,parent=None): QtWidgets.QMainWindow.__init__(self, parent) #super(Main,self).__init__() self.setupUi(self) ### Initialize stuff self.line_dict = {} self.fitpars = None self.parinfo = None self.linecmts = None self.wave1 = wave1 self.wave2 = wave2 self.numchunks = numchunks self.spls = [] self.labeltog = 1 self.pixtog = 0 self.restog = 1 self.fitconvtog = 0 self.lastclick=1334. ### Read in spectrum and list of lines to fit self.specfilename=specfilename self.spectrum = readspec(specfilename) self.wave=self.spectrum.wavelength.value self.normflux=self.spectrum.flux/self.spectrum.co self.normsig=self.spectrum.sig/self.spectrum.co cfg.spectrum = self.spectrum cfg.wave=self.wave cfg.normflux=self.normflux cfg.filename=self.specfilename if not parfilename==None: self.initialpars(parfilename) ### Connect signals to slots self.fitButton.clicked.connect(self.fitlines) self.fitConvBox.clicked.connect(self.togfitconv) self.boxLineLabel.clicked.connect(self.toglabels) self.boxFitpix.clicked.connect(self.togfitpix) self.boxResiduals.clicked.connect(self.togresiduals) self.loadParsButton.clicked.connect(self.openParFileDialog) self.addLineButton.clicked.connect(self.addLineDialog) self.writeParsButton.clicked.connect(self.writeParFileDialog) self.writeModelButton.clicked.connect(self.writeModelFileDialog) self.writeModelCompButton.clicked.connect(self.writeModelCompFileDialog) self.quitButton.clicked.connect(self.quitGui) ### Initialize spectral plots fig=Figure() self.fig=fig self.initplot(fig) ### Initialize side plot sidefig=Figure(figsize=(5.25,2)) self.sidefig = sidefig self.addsidempl(self.sidefig) self.sideplot(self.lastclick) #Dummy initial cenwave setting def initplot(self,fig,numchunks=8): wlen=len(self.spectrum.wavelength)/numchunks self.spls=[] if self.wave1==None: waveidx1=0 # Default to plotting entire spectrum for now else: waveidx1=jbg.closest(self.wave,self.wave1) if self.fitpars!=None: model=joebvpfit.voigtfunc(self.wave,self.datamodel.fitpars) sg=jbg.subplotgrid(numchunks) for i in range(numchunks): self.spls.append(fig.add_subplot(sg[i][0],sg[i][1],sg[i][2])) pixs=range(waveidx1+i*wlen,waveidx1+(i+1)*wlen) self.spls[i].plot(self.wave[pixs],self.normflux[pixs],linestyle='steps-mid') if self.fitpars!=None: self.spls[i].plot(self.wave,model,'r') self.spls[i].set_xlim(self.wave[pixs[0]],self.wave[pixs[-1]]) self.spls[i].set_ylim(cfg.ylim) self.spls[i].set_xlabel('wavelength',labelpad=0) self.spls[i].set_ylabel('relative flux',labelpad=-5) self.spls[i].get_xaxis().get_major_formatter().set_scientific(False) fig.subplots_adjust(top=0.98,bottom=0.05,left=0.08,right=0.97,wspace=0.15,hspace=0.25) self.addmpl(fig) def initialpars(self,parfilename): ### Deal with initial parameters from line input file self.fitpars,self.fiterrors,self.parinfo,self.linecmts = joebvpfit.readpars(parfilename) cfg.fitidx=joebvpfit.fitpix(self.wave, self.fitpars) #Set pixels for fit cfg.wavegroups=[] self.datamodel = LineParTableModel(self.fitpars,self.fiterrors,self.parinfo,linecmts=self.linecmts) self.tableView.setModel(self.datamodel) self.datamodel.updatedata(self.fitpars,self.fitpars,self.parinfo,self.linecmts) def sideplot(self,cenwave,wavebuf=3): if len(self.sidefig.axes)==0: self.sideax=self.sidefig.add_subplot(111) self.sideax.clear() self.sideax.plot(self.wave, self.normflux, linestyle='steps-mid') if self.pixtog == 1: self.sideax.plot(self.wave[cfg.fitidx], self.normflux[cfg.fitidx], 'gs', markersize=4, mec='green') model = joebvpfit.voigtfunc(self.wave, self.fitpars) res = self.normflux - model self.sideax.plot(self.wave, model, 'r') if self.restog == 1: self.sideax.plot(self.wave, -res, '.', color='black', ms=2) self.sideax.plot(self.wave, [0] * len(self.wave), color='gray') ### label lines we are trying to fit if self.labeltog == 1: for j in range(len(self.fitpars[0])): labelloc = self.fitpars[0][j] * (1. + self.fitpars[3][j]) + self.fitpars[4][j] / c * \ self.fitpars[0][j] * ( 1. + self.fitpars[3][j]) label = ' {:.1f}_\nz{:.4f}'.format(self.fitpars[0][j], self.fitpars[3][j]) self.sideax.text(labelloc, cfg.label_ypos, label, rotation=90, withdash=True, ha='center', va='bottom', clip_on=True, fontsize=cfg.label_fontsize) self.sideax.plot(self.wave, self.normsig, linestyle='steps-mid', color='red', lw=0.5) self.sideax.plot(self.wave, -self.normsig, linestyle='steps-mid', color='red', lw=0.5) self.sideax.get_xaxis().get_major_formatter().set_scientific(False) self.sideax.get_xaxis().get_major_formatter().set_useOffset(False) try: self.sideax.set_xlim(cenwave-wavebuf,cenwave+wavebuf) self.sideax.set_ylim(cfg.ylim) self.changesidefig(self.sidefig) except TypeError: pass def fitlines(self): print('VPmeasure: Fitting line profile(s)...') print(len(self.fitpars[0]),'lines loaded for fitting.') if self.fitconvtog: self.fitpars, self.fiterrors = joebvpfit.fit_to_convergence(self.wave, self.normflux, self.normsig, self.datamodel.fitpars, self.datamodel.parinfo) else: self.fitpars, self.fiterrors = joebvpfit.joebvpfit(self.wave, self.normflux,self.normsig, self.datamodel.fitpars,self.datamodel.parinfo) self.datamodel.updatedata(self.fitpars,self.fiterrors,self.parinfo,self.linecmts) self.tableView.resizeColumnsToContents() self.updateplot() self.sideplot(self.lastclick) def togfitconv(self): if self.fitconvtog==1: self.fitconvtog=0 else: self.fitconvtog=1 def quitGui(self): self.deleteLater() self.close() def toglabels(self): if self.labeltog==1: self.labeltog=0 else: self.labeltog=1 self.updateplot() def togfitpix(self): if self.pixtog == 1: self.pixtog = 0 else: self.pixtog = 1 self.updateplot() def togresiduals(self): if self.restog == 1: self.restog = 0 else: self.restog = 1 self.updateplot() def openParFileDialog(self): fname = QtWidgets.QFileDialog.getOpenFileName(self, 'Open line parameter file','.') fname = str(fname[0]) if fname != '': self.initialpars(fname) self.updateplot() def writeParFileDialog(self): fname = QtWidgets.QFileDialog.getSaveFileName(self, 'Save line parameter file', cfg.VPparoutfile) fname = str(fname[0]) if fname != '': joebvpfit.writelinepars(self.datamodel.fitpars, self.datamodel.fiterrors, self.datamodel.parinfo, self.specfilename, fname, self.datamodel.linecmts) def writeModelFileDialog(self): fname = QtWidgets.QFileDialog.getSaveFileName(self, 'Save model to file', cfg.VPmodeloutfile) fname = str(fname[0]) if fname != '': joebvpfit.writeVPmodel(fname, self.wave, self.fitpars, self.normflux, self.normsig) def writeModelCompFileDialog(self): dirDialog = QtWidgets.QFileDialog(self) dirDialog.setFileMode(dirDialog.Directory) dirDialog.setOption(dirDialog.ShowDirsOnly, True) defDirName = cfg.VPmodeloutfile[:-5] dname = dirDialog.getSaveFileName(self, 'Save model to files split by components',defDirName) dname = str(dname[0]) if dname != '': joebvpfit.writeVPmodelByComp(dname, self.spectrum,self.fitpars) def addLineDialog(self): dlgOutput=newLineDialog.get_newline() if (dlgOutput != 0): if '' not in dlgOutput: newlam,newz,newcol,newb,newvel,newvel1,newvel2 = dlgOutput self.datamodel.addLine(self.wave,float(newlam), float(newz), float(newcol), float(newb), float(newvel), float(newvel1), float(newvel2)) #dialog=newLineDialog(parent=None) self.fitpars = self.datamodel.fitpars self.fiterrors = self.datamodel.fiterrors self.parinfo = self.datamodel.parinfo self.tableView.setModel(self.datamodel) def updateplot(self): if self.wave1==None: waveidx1=0 # Default to plotting entire spectrum for now else: waveidx1=jbg.closest(self.wave,self.wave1) wlen=len(self.spectrum.wavelength)/self.numchunks for i,sp in enumerate(self.spls): sp.clear() prange=range(waveidx1+i*wlen,waveidx1+(i+1)*wlen) if ((len(self.fitpars[0])>0)): sp.plot(self.wave,self.normflux,linestyle='steps-mid') if self.pixtog==1: sp.plot(self.wave[cfg.fitidx], self.normflux[cfg.fitidx], 'gs', markersize=4, mec='green') model=joebvpfit.voigtfunc(self.wave,self.fitpars) res=self.normflux-model sp.plot(self.wave,model,'r') if self.restog==1: sp.plot(self.wave,-res,'.',color='black', ms=2) sp.plot(self.wave,[0]*len(self.wave),color='gray') ### label lines we are trying to fit if self.labeltog==1: for j in range(len(self.fitpars[0])): labelloc=self.fitpars[0][j]*(1.+self.fitpars[3][j])+self.fitpars[4][j]/c*self.fitpars[0][j]*(1.+self.fitpars[3][j]) label = ' {:.1f}_\nz{:.4f}'.format(self.fitpars[0][j], self.fitpars[3][j]) sp.text(labelloc, cfg.label_ypos, label, rotation=90, withdash=True, ha='center', va='bottom', clip_on=True, fontsize=cfg.label_fontsize) sp.plot(self.wave,self.normsig,linestyle='steps-mid',color='red', lw=0.5) sp.plot(self.wave,-self.normsig,linestyle='steps-mid',color='red', lw=0.5) sp.set_ylim(cfg.ylim) sp.set_xlim(self.wave[prange[0]],self.wave[prange[-1]]) sp.set_xlabel('wavelength (A)', fontsize=cfg.xy_fontsize, labelpad=cfg.x_labelpad) sp.set_ylabel('normalized flux', fontsize=cfg.xy_fontsize, labelpad=cfg.y_labelpad) sp.get_xaxis().get_major_formatter().set_scientific(False) sp.get_xaxis().get_major_formatter().set_useOffset(False) self.changefig(self.fig) def changefig(self, item): #text = str(item.text()) self.rmmpl() self.addmpl(self.fig) def changesidefig(self, item): #text = str(item.text()) self.rmsidempl() self.addsidempl(self.sidefig) def on_click(self, event): self.lastclick=event.xdata self.sideplot(self.lastclick) def addmpl(self, fig): self.canvas = FigureCanvas(fig) self.canvas.mpl_connect('button_press_event',self.on_click) self.mplvl.addWidget(self.canvas) self.canvas.draw() self.toolbar = NavigationToolbar(self.canvas,self.mplwindow,coordinates=True) self.mplvl.addWidget(self.toolbar) def addsidempl(self, sidefig): self.sidecanvas = FigureCanvas(sidefig) self.sidecanvas.setParent(self.sideMplWindow) if len(self.sidefig.axes) == 0: self.sidemplvl = QVBoxLayout() if len(self.sidefig.axes) != 0: self.sidemplvl.addWidget(self.sidecanvas) if len(self.sidefig.axes) == 0: self.sideMplWindow.setLayout(self.sidemplvl) self.sidecanvas.draw() def rmmpl(self,): self.mplvl.removeWidget(self.canvas) self.canvas.close() self.mplvl.removeWidget(self.toolbar) self.toolbar.close() def rmsidempl(self, ): self.sidemplvl.removeWidget(self.sidecanvas) self.sidecanvas.close()
class MplCanvas(object): """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.).""" def __init__(self, time_viewer, width, height, dpi): from PyQt5 import QtWidgets from matplotlib.figure import Figure from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg if time_viewer.separate_canvas: parent = None else: parent = time_viewer.window self.fig = Figure(figsize=(width, height), dpi=dpi) self.canvas = FigureCanvasQTAgg(self.fig) self.axes = self.fig.add_subplot(111) self.axes.set(xlabel='Time (sec)', ylabel='Activation (AU)') self.canvas.setParent(parent) FigureCanvasQTAgg.setSizePolicy( self.canvas, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding ) FigureCanvasQTAgg.updateGeometry(self.canvas) # XXX eventually this should be called in the window resize callback tight_layout(fig=self.axes.figure) self.time_viewer = time_viewer for event in ('button_press', 'motion_notify'): self.canvas.mpl_connect( event + '_event', getattr(self, 'on_' + event)) def plot(self, x, y, label, **kwargs): """Plot a curve.""" line, = self.axes.plot( x, y, label=label, **kwargs) self.update_plot() return line def plot_time_line(self, x, label, **kwargs): """Plot the vertical line.""" line = self.axes.axvline(x, label=label, **kwargs) self.update_plot() return line def update_plot(self): """Update the plot.""" self.axes.legend(prop={'family': 'monospace', 'size': 'small'}, framealpha=0.5, handlelength=1.) self.canvas.draw() def show(self): """Show the canvas.""" self.canvas.show() def close(self): """Close the canvas.""" self.canvas.close() def on_button_press(self, event): """Handle button presses.""" # left click (and maybe drag) in progress in axes if (event.inaxes != self.axes or event.button != 1): return self.time_viewer.time_call( event.xdata, update_widget=True, time_as_index=False) on_motion_notify = on_button_press # for now they can be the same
class Main(QMainWindow, Ui_MainWindow): def __init__(self, ): #provide values for attributes at runtime super(Main, self).__init__() self.setupUi(self) self.pushBrowse.clicked.connect(self.selectFile) self.pushBrowse_2.clicked.connect(self.selectmlFile) self.pushApply.clicked.connect(self.apply) self.pushRun.clicked.connect(self.run) self.HomeDirectory = os.getcwd() #saves the primary working directory self.directory = os.listdir(self.HomeDirectory) self.saveBttn.clicked.connect(self.file_save) self.actionOpen.triggered.connect(self.file_open) self.actionReset.triggered.connect(self.plots_close) self.message = 0 self.UI = [] self.reset = 0 self.plotinfo = [] self.plot2info = [] self.plot3info = [] self.plot4info = [] self.plot5info = [] self.plot6info = [] #check User input for correct .csv file self.inputFile.setValidator(validator) self.inputFile.textChanged.connect(self.check_state) self.inputFile.textChanged.emit(self.inputFile.text()) #check User input for correct .csv file for ml self.mlData.setValidator(validator) self.mlData.textChanged.connect(self.check_state) self.mlData.textChanged.emit(self.mlData.text()) #shaft speed self.shaftSpeed.setValidator(regexp_checkdouble) self.shaftSpeed.textChanged.connect(self.check_state) self.shaftSpeed.textChanged.emit(self.shaftSpeed.text()) #Num of rolling elements self.numberofElements.setValidator(regexp_checkint) self.numberofElements.textChanged.connect(self.check_state) self.numberofElements.textChanged.emit(self.numberofElements.text()) #diameter of rolling elements self.diameterofElements.setValidator(regexp_checkdouble) self.diameterofElements.textChanged.connect(self.check_state) self.diameterofElements.textChanged.emit( self.diameterofElements.text()) #pitch diameter self.pitchDiameter.setValidator(regexp_checkdouble) self.pitchDiameter.textChanged.connect(self.check_state) self.pitchDiameter.textChanged.emit(self.pitchDiameter.text()) #Contact angle self.contactAngle.setValidator(regexp_checkdouble) self.contactAngle.textChanged.connect(self.check_state) self.contactAngle.textChanged.emit(self.contactAngle.text()) #Frequency self.samFreq.setValidator(regexp_checkdouble) self.samFreq.textChanged.connect(self.check_state) self.samFreq.textChanged.emit(self.samFreq.text()) def check_state( self, *args, **kwargs ): #this function is changes the color of the lineedit fields depending on state sender = self.sender() validator = sender.validator() state = validator.validate(sender.text(), 0)[0] if state == QValidator.Acceptable: color = '#c4df9b' # green elif state == QtGui.QValidator.Intermediate: color = '#fff79a' # yellow else: color = '#f6989d' # red sender.setStyleSheet('QLineEdit { background-color: %s }' % color) #creates a dictionary from the saved CSV def file_open( self ): #function called when the open file action in triggered. Creates a dictionary from a CSV file. filename = QFileDialog.getOpenFileName()[0] reader = csv.reader(open(filename, 'r')) d = {} for row in reader: k, v = row d[k] = v print(d) self.setTextInfile(d) return True #used the dicitonary created above to assign saved variables to input parameters def setTextInfile(self, d): self.inputName.setText(d['inputName']) self.inputApplication.setText(d['inputApplication']) self.inputModelnum.setText(d['inputModelnum']) self.inputSavingalias.setText(d['inputSavingalias']) self.inputFile.setText(d['inputFile']) self.mlData.setText(d['mlData']) self.horsepower.setText(d['horsepower']) self.voltage.setText(d['voltage']) self.phase.setText(d['phase']) self.shaftnum.setText(d['shaftnum']) self.shaftSpeed.setText(d['shaftSpeed']) self.numberofElements.setText(d['numberofElements']) self.diameterofElements.setText(d['diameterofElements']) self.pitchDiameter.setText(d['pitchDiameter']) self.contactAngle.setText(d['contactAngle']) self.samFreq.setText(d['samFreq']) """ Hmm i wonder if this is used to save the file? """ def file_save( self, ): #called when the save btn is clicked. converts user input to dictionary then to dataframe then to csv file. dict = CreateSaveDictionary(self.inputName.text(), self.inputApplication.text(), self.inputModelnum.text(), self.inputSavingalias.text(), self.inputFile.text(), self.mlData.text(), self.horsepower.text(), self.voltage.text(), self.phase.text(), self.shaftnum.text(), self.shaftSpeed.text(), self.numberofElements.text(), self.diameterofElements.text(), self.pitchDiameter.text(), self.contactAngle.text(), self.samFreq.text()) CreateCSVfromDict(dict) """ These functions create the figure widgets and toolbars """ def addmpl(self, fig): self.canvas = FigureCanvas(fig) #self.canvas.setParent(None) self.spectrumUI.addWidget(self.canvas) #self.canvas.draw() #self.toolbar = NavigationToolbar(self.canvas,self.mainspectrum, coordinates=True) #self.toolbar.setParent(None) #self.spectrumUI.addWidget(self.toolbar) def addgraph11(self, fig): self.canvas1 = FigureCanvas(fig) self.graph11UI.addWidget(self.canvas1) #self.canvas1.draw() self.toolbar1 = NavigationToolbar(self.canvas1, self.graph11, coordinates=True) self.graph11UI.addWidget(self.toolbar1) def addgraph12(self, fig): self.canvas2 = FigureCanvas(fig) self.graph12UI.addWidget(self.canvas2) #self.canvas2.draw() self.toolbar2 = NavigationToolbar(self.canvas2, self.graph12, coordinates=True) self.graph12UI.addWidget(self.toolbar2) def addgraph13(self, fig): self.canvas5 = FigureCanvas(fig) self.graph13UI.addWidget(self.canvas5) #self.canvas2.draw() self.toolbar5 = NavigationToolbar(self.canvas5, self.graph13, coordinates=True) self.graph13UI.addWidget(self.toolbar5) def addgraph21(self, fig): self.canvas3 = FigureCanvas(fig) self.graph21UI.addWidget(self.canvas3) #self.canvas3.draw() self.toolbar3 = NavigationToolbar(self.canvas3, self.graph21, coordinates=True) self.graph21UI.addWidget(self.toolbar3) def addgraph22(self, fig): self.canvas4 = FigureCanvas(fig) self.graph22UI.addWidget(self.canvas4) #self.canvas4.draw() self.toolbar4 = NavigationToolbar(self.canvas4, self.graph22, coordinates=True) self.graph22UI.addWidget(self.toolbar4) #clearly selects file def selectFile(self, ): self.inputFile.setText(QFileDialog.getOpenFileName()[0]) self.inputfile = self.inputFile.text() #selects file but for a ml data def selectmlFile(self, ): self.mlData.setText(QFileDialog.getOpenFileName()[0]) """ Apply checks user inputs and then assigns them to function parameter variables In case the user doesn't supply input for a specific field, default inputs will be inserted. """ def apply(self, ): if self.inputSavingalias.text() != "": self.savingalias = self.inputSavingalias.text() + ".csv" self.inputSavingalias.setText(self.savingalias) if self.inputFile.text() != "": try: temp = self.inputFile.text() self.FileOfInterest = self.inputFile.text() except: print("pu") else: print("no input file selected, using demo file.") self.FileOfInterest = "AccelerometerActualData.csv" self.inputFile.setText("/AccelerometerActualData.csv") if self.mlData.text() != "": self.TrainingDataFile = self.mlData.text() print(self.TrainingDataFile) else: print("no ML data selected") self.TrainingDataFile = "NoNegatives.csv" #default file location self.mlData.setText("/NoNegatives.csv") if self.shaftSpeed.text() != "": self.n = float(self.shaftSpeed.text()) print("type n =", type(self.n)) else: print("no shaft speed selected") self.n = 2000 / 60 self.shaftSpeed.setText(str(self.n)) if self.numberofElements.text() != "": self.N = int(self.numberofElements.text()) else: print("Number of elements not specified") self.N = 16 self.numberofElements.setText(str(self.N)) if self.diameterofElements.text() != "": self.Bd = float(self.diameterofElements.text()) else: print("Diameter of elements not specified") self.Bd = 0.331 * 254 self.diameterofElements.setText(str(self.Bd)) if self.pitchDiameter.text() != "": self.Pd = float(self.pitchDiameter.text()) else: print("no pitch diameter specified") self.Pd = Pd = 2.815 * 254 self.pitchDiameter.setText(str(self.Pd)) if self.contactAngle.text() != "": self.phi = float(self.contactAngle.text()) else: print("Contact angle not specified") self.phi = (15.17 * 3.14159) / 180 self.contactAngle.setText(str(self.phi)) if self.samFreq.text() != "": self.SampleFrequency = float(self.samFreq.text()) else: print("no sample frequency specified") self.SampleFrequency = 20000 self.samFreq.setText(str(self.SampleFrequency)) self.popup = MyPopup("Applied") self.popup.setGeometry(QtCore.QRect(100, 100, 400, 200)) self.popup.show() ############################################## def getPlot(self, X, Y, xlabel, ylabel, Title): if self.reset != 0: self.sub0.cla() self.sub0.plot(X, Y, c=np.random.rand(3, )) self.sub0.set_xlabel(xlabel, fontsize=12) self.sub0.set_ylabel(ylabel, fontsize=12) self.sub0.set_title(Title) self.sub0.grid(True) if self.reset != 0: self.canvas.draw() return True def getPlot1(self, X, Y, xlabel, ylabel, Title): if self.reset != 0: self.sub1.cla() self.sub1.plot(X, Y, c=np.random.rand(3, )) self.sub1.set_xlabel(xlabel, fontsize=12) self.sub1.set_ylabel(ylabel, fontsize=12) self.sub1.set_title(Title) self.sub1.grid(True) if self.reset != 0: self.canvas1.draw() return True def getPlot2(self, X, Y, xlabel, ylabel, Title): if self.reset != 0: self.sub2.cla() self.sub2.plot(X, Y, c=np.random.rand(3, )) self.sub2.set_xlabel(xlabel, fontsize=12) self.sub2.set_ylabel(ylabel, fontsize=12) self.sub2.set_title(Title) self.sub2.grid(True) if self.reset != 0: self.canvas2.draw() return True def getPlot3(self, X, Y, xlabel, ylabel, Title): if self.reset != 0: self.sub3.cla() self.sub3.plot(X, Y, c=np.random.rand(3, )) self.sub3.set_xlabel(xlabel, fontsize=12) self.sub3.set_ylabel(ylabel, fontsize=12) self.sub3.set_title(Title) self.sub3.grid(True) if self.reset != 0: self.canvas3.draw() return True def getPlot4(self, X, Y, xlabel, ylabel, Title): if self.reset != 0: self.sub4.cla() self.sub4.plot(X, Y, c=np.random.rand(3, )) self.sub4.set_xlabel(xlabel, fontsize=12) self.sub4.set_ylabel(ylabel, fontsize=12) self.sub4.set_title(Title) self.sub4.grid(True) if self.reset != 0: self.canvas4.draw() return True def getPlot5(self, X, Y, xlabel, ylabel, Title): if self.reset != 0: self.sub4.cla() self.sub5.plot(X, Y, c=np.random.rand(3, )) self.sub5.set_xlabel(xlabel, fontsize=12) self.sub5.set_ylabel(ylabel, fontsize=12) self.sub5.set_title(Title) self.sub5.grid(True) if self.reset != 0: self.canvas5.draw() return True def run(self, ): #called when run is clicked if self.reset == 0: #instantiate the figures self.fig0 = plt.figure() self.sub0 = self.fig0.add_subplot() self.fig1 = plt.figure() self.sub1 = self.fig1.add_subplot() self.fig2 = plt.figure() self.sub2 = self.fig2.add_subplot() self.fig3 = plt.figure() self.sub3 = self.fig3.add_subplot() self.fig4 = plt.figure() self.sub4 = self.fig4.add_subplot() self.fig5 = plt.figure() self.sub5 = self.fig5.add_subplot() #begin calling ml functions for processing Data = getValuesFromRawData(self.FileOfInterest) UserInput = UserInputs2WorkingForm( self.n, self.N, self.Bd, self.Pd, self.phi, self.SampleFrequency, Data, self.HomeDirectory, self.directory, self.TrainingDataFile, self.inputSavingalias, self.inputName, self.inputModelnum) self.UI = UserInput BearingInfo = BearingInfomation(UserInput) X_train, X_test, Y_train, Y_test = GetSplitTrainingData(UserInput) classifier = TrainModel(X_train, Y_train) Y_test_pred = PredictModel(classifier, X_test) ## #Create time series array t = np.arange(0, UserInput['Time of Sampling'], 1 / UserInput['Sampling Frequency']) #Perform FFT, PSD, Correlation, DC Offset UserInput1 = RemoveDCOffset(UserInput) x1 = FourierTransform(UserInput1) x2 = get_psd_values(UserInput1) x3 = get_autocorr_values(UserInput1) TEST = getTESTDataFrame(UserInput) TEST1 = TEST.values[:, 0:(TEST.shape[1] - 1)] OUTCOME = PredictModel(classifier, TEST1) plt.close('all') figs = [] #figs = getGraphs(UserInput) self.plotinfo, self.plot2info, self.plot3info, self.plot4info, self.plot5info, self.plot6info = getGraphs( UserInput) self.getPlot(self.plotinfo[0], self.plotinfo[1], self.plotinfo[2], self.plotinfo[3], self.plotinfo[4]) self.getPlot1(self.plot2info[0], self.plot2info[1], self.plot2info[2], self.plot2info[3], self.plot2info[4]) self.getPlot2(self.plot3info[0], self.plot3info[1], self.plot3info[2], self.plot3info[3], self.plot3info[4]) self.getPlot3(self.plot4info[0], self.plot4info[1], self.plot4info[2], self.plot4info[3], self.plot4info[4]) self.getPlot4(self.plot5info[0], self.plot5info[1], self.plot5info[2], self.plot5info[3], self.plot5info[4]) self.getPlot5(self.plot6info[0], self.plot6info[1], self.plot6info[2], self.plot6info[3], self.plot6info[4]) Prediction = PredictProbModel(classifier, X_test) print("outcome:") print(OUTCOME) print("Accuracy on training set is : {}".format( classifier.score(X_train, Y_train))) print("Accuracy on test set is : {}".format( classifier.score(X_test, Y_test))) if self.reset == 0: self.addmpl(self.fig0) self.addgraph11(self.fig1) self.addgraph12(self.fig2) self.addgraph21(self.fig3) self.addgraph22(self.fig4) self.BSF.setText(str(truncate(BearingInfo['BSF'], 3))) self.BPFI.setText(str(truncate(BearingInfo['BPFI'], 3))) self.BPFO.setText(str(truncate(BearingInfo['BPFO'], 3))) self.FTF.setText(str(truncate(BearingInfo['FTF'], 3))) self.earlyEdit.setText(str(Prediction[0, 0])) self.suspectEdit.setText(str(Prediction[0, 1])) self.normalEdit.setText(str(Prediction[0, 2])) self.immEdit.setText(str(Prediction[0, 3])) self.innerEdit.setText(str(Prediction[0, 4])) self.rollingEdit.setText(str(Prediction[0, 5])) self.stageEdit.setText(str(Prediction[0, 6])) self.reset = 1 def close_application(self, ): #self explanitory sys.exit() ############################################################################### def updategraphs(self, fig): print("made it to update graphs") sip.delete(self.canvas) sip.delete(self.canvas1) sip.delete(self.canvas2) sip.delete(self.canvas3) sip.delete(self.canvas4) #self.spectrumUI.removeWidget(self.canvas) self.canvas = FigureCanvas(fig[0]) self.canvas1 = FigureCanvas(fig[1]) self.canvas2 = FigureCanvas(fig[2]) self.canvas3 = FigureCanvas(fig[3]) self.canvas4 = FigureCanvas(fig[4]) def rmmpl(self, ): print("in rmmpl") self.spectrumUI.removeWidget(self.canvas) self.canvas.close() self.spectrumUI.removeWidget(self.toolbar) self.toolbar.close() self.graph11UI.removeWidget(self.canvas) self.canvas.close() self.graph11UI.removeWidget(self.toolbar) self.toolbar.close() self.graph12UI.removeWidget(self.canvas) self.canvas.close() self.graph12UI.removeWidget(self.toolbar) self.toolbar.close() self.graph21UI.removeWidget(self.canvas) self.canvas.close() self.graph21UI.removeWidget(self.toolbar) self.toolbar.close() self.graph22UI.removeWidget(self.canvas) self.canvas.close() self.graph22UI.removeWidget(self.toolbar) self.toolbar.close() def plots_close(self, ): print("made it to plots_close") self.spectrumUI.removeWidget(self.canvas) sip.delete(self.canvas) self.canvas = None self.spectrumUI.removeWidget(self.toolbar) sip.delete(self.toolbar) self.toolbar = None self.graph11UI.removeWidget(self.canvas1) self.canvas1.close() self.graph11UI.removeWidget(self.toolbar1) self.toolbar1.close() self.graph12UI.removeWidget(self.canvas2) self.canvas2.close() self.graph12UI.removeWidget(self.toolbar2) self.toolbar2.close() self.graph21UI.removeWidget(self.canvas3) self.canvas3.close() self.graph21UI.removeWidget(self.toolbar3) self.toolbar3.close() self.graph22UI.removeWidget(self.canvas4) self.canvas4.close() self.graph22UI.removeWidget(self.toolbar4) self.toolbar4.close()
class MainWindow(QtWidgets.QMainWindow, form_class): def __init__(self, parent=None): QtWidgets.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, QtWidgets.QTableWidgetItem(layer)) self.table.setItem(num, 1, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 2, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 3, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 4, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 5, QtWidgets.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 = QtWidgets.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, QtWidgets.QTableWidgetItem(layer)) self.table.setItem(num, 1, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 2, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 3, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 4, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 5, QtWidgets.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 = QtWidgets.QFileDialog.getOpenFileName( self, 'Single File', '~/Desktop/', "Image files (*.jpg *.png *.tif)") self.figname = str(name[0]) image = imageio.imread(self.figname) #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.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) 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), int(event.xdata), 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] - [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] - [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, QtWidgets.QTableWidgetItem(layer)) self.table.setItem(num, 1, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 2, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 3, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 4, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 5, QtWidgets.QTableWidgetItem("0")) squaresize = self.cropsize image_gray = self.BLUEimage self.BLUEblobs = blob_log(self.BLUEimage, 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()), exclude_border=squaresize) self.table.setItem( int(self.numLayers.text()) + 1, 4, QtWidgets.QTableWidgetItem(str(len(self.BLUEblobs)))) if str(self.fMarker.currentText()) == 'RFP': blobs = blob_log(self.REDimage, 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()), exclude_border=squaresize) self.table.setItem( int(self.numLayers.text()) + 1, 4, QtWidgets.QTableWidgetItem(str(len(self.BLUEblobs)))) if str(self.fMarker.currentText()) == 'GFP': blobs = blob_log(self.GREENimage, 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()), exclude_border=squaresize) self.table.setItem( int(self.numLayers.text()) + 1, 4, QtWidgets.QTableWidgetItem(str(len(self.BLUEblobs)))) if str(self.fMarker.currentText()) == 'GFP or RFP': blobs = blob_log(self.REDimage + self.GREENimage, 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()), exclude_border=squaresize) self.table.setItem( int(self.numLayers.text()) + 1, 4, QtWidgets.QTableWidgetItem(str(len(self.BLUEblobs)))) #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, QtWidgets.QTableWidgetItem(str(len(blobs)))) #self.table.setItem(9 , 2, QtWidgets.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, QtWidgets.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, QtWidgets.QTableWidgetItem(layer)) self.table.setItem(num, 1, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 2, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 3, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 4, QtWidgets.QTableWidgetItem("0")) self.table.setItem(num, 5, QtWidgets.QTableWidgetItem("0")) self.table.setItem( int(self.numLayers.text()) + 1, 1, QtWidgets.QTableWidgetItem(str(len(self.THEblobs)))) self.table.setItem( int(self.numLayers.text()) + 1, 4, QtWidgets.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, QtWidgets.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, x) 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) c = Circle((x, y), r + 10 if r + 10 < squaresize else squaresize, color=colors[whichpolygon.index(1)], linewidth=.5, alpha=0.3) ax.add_patch(c) ax.text(x, y, polygonListCount[whichpolygon.index(1)], color='white', fontsize=10) self.nMarkedCells.setText(str(ctr)) self.table.setItem( int(self.numLayers.text()) + 1, 2, QtWidgets.QTableWidgetItem( str(self.imgPolygon.area / self.bigpoligon.area)[:4])) self.table.setItem( int(self.numLayers.text()), 2, QtWidgets.QTableWidgetItem( str(int(self.bigpoligon.area / self.bigpoligon.area)))) self.table.setItem(int(self.numLayers.text()), 1, QtWidgets.QTableWidgetItem(str(ctr))) self.table.setItem(int(self.numLayers.text()), 3, QtWidgets.QTableWidgetItem(str(ctr))) self.table.setItem( int(self.numLayers.text()) + 1, 3, QtWidgets.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, QtWidgets.QTableWidgetItem( str(pol.area / self.bigpoligon.area)[:4])) self.table.setItem( n, 3, QtWidgets.QTableWidgetItem( str(polygonListCount[n] / (pol.area / self.bigpoligon.area))[:6])) self.table.setItem( n, 1, QtWidgets.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, x) 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, QtWidgets.QTableWidgetItem(str(ctrDAPI))) if float(self.table.item(int(self.numLayers.text()), 4).text()) > 0: self.table.setItem( int(self.numLayers.text()), 5, QtWidgets.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, QtWidgets.QTableWidgetItem( str(polygonListCount[n] / polygonListCountDAPI[n])[:6])) self.table.setItem( n, 4, QtWidgets.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) c = Circle((x, y), r + 10 if r + 10 < squaresize else squaresize, color='gray', linewidth=.5, alpha=0.3) ax.add_patch(c) ax.text(x, y, str(number), color='white', fontsize=6) 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' ])
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}{1}'.format(locale.format_string('%.2F', 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}{1}'.format(locale.format_string('%.2F', 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)
def plotALot( img_array, gene_index_dict, # list of genes to plot reordered_genes=None, savedir="", title="images", grid=(3, 6), # grid to plot for each figure figsize=(16, 9), dpi=300, ): """ plot a lot of images from a list of genes """ genes_per_plot = grid[0] * grid[1] num_plots, remainder = divmod(len(gene_index_dict), (genes_per_plot)) # add an extra plot if # number of genes is not perfectly divisible by number of plots if remainder != 0: num_plots += 1 if reordered_genes is None: reordered_genes = [ None, ] * len(gene_index_dict) for gene in gene_index_dict: reordered_genes[gene_index_dict[gene]["index"]] = gene # set up index for number of genes already plotted # ------------------------------------------------ array_idx = 0 for plot_num in range(num_plots): # set up figure canvas # -------------------- fig = Figure(figsize=figsize, dpi=dpi) canvas = FigCanvas(fig) fig.set_canvas(canvas) for gridpos in range(genes_per_plot): # check if we have reached end of gene list # ----------------------------------------- if array_idx == len(gene_index_dict): break # create temporary axes reference # ------------------------------- ax = fig.add_subplot(grid[0], grid[1], gridpos + 1) # plot the current gene (array_idx) # --------------------- gene = reordered_genes[array_idx] ax.imshow(img_array[gene_index_dict[gene]["index"], ...], cmap="hot") ax.set_title(gene) ax.grid(False) # increment gene index # -------------------- array_idx += 1 fig.suptitle(title + f" ({plot_num + 1} of {num_plots})") fig.tight_layout(rect=(0, 0, 1, .94)) # save the plot # time_now = datetime.datetime.now().strftime("%Y%m%d_%H%M") savename = (f"{title.replace(' ','_')}" f"_{plot_num + 1}of{num_plots}.png") if not os.path.exists(savedir): os.mkdir(savedir) fig.savefig(os.path.join(savedir, savename), dpi=dpi) canvas.close() fig.clear()
class timeseriesplotDlg(QtWidgets.QDialog, Ui_timeseriesplotDialog): def __init__(self, parent=None): super(timeseriesplotDlg, self).__init__(parent) self.setupUi(self) self.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowMaximizeButtonHint) self.YcomboBox.addItems(DS.Lc) self.autocorrelationadioButton.setChecked(True) self.TcheckBox.setChecked(True) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(True) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.ApplyButton.clicked.connect(self.redraw) self.ResetButton.clicked.connect(self.reset) fig = Figure() ax = fig.add_subplot(111) ax.plot(np.array(0)) ax.set_xlim([0, 1]) ax.set_ylim([0, 1]) self.addmpl(fig) def redraw(self): if self.YcomboBox.currentText() == 'None': QtWidgets.QMessageBox.critical(self, 'Error', "No Variable \n Selected !", QtWidgets.QMessageBox.Ok) return () data = DS.Raw.iloc[DS.Ir, DS.Ic] data = data.assign(Lr=DS.Lr[DS.Ir]) data = data.assign(Cr=DS.Cr[DS.Ir]) data = data[[self.YcomboBox.currentText(), 'Lr', 'Cr']] Nnan = data[self.YcomboBox.currentText()].isnull().all() data = data.dropna() #Lr=data['Lr'].values data = data.drop('Lr', axis=1) data = data.drop('Cr', axis=1) Y = data.values.ravel() if Y.dtype == 'float' and Y.dtype == 'int': QtWidgets.QMessageBox.critical(self,'Error',"Some values are not numbers!",\ QtWidgets.QMessageBox.Ok) return () color = 'blue' fig = Figure() ax = fig.add_subplot(111) if self.CcheckBox.isChecked(): color = DS.Cc[self.YcomboBox.currentIndex() - 1] if (self.autocorrelationadioButton.isChecked()): plot_acf(Y, ax=ax, color=color, alpha=int(self.alfaspinBox.value()) / 100) ax.set_title('Autocorrelation Plot of ' + self.YcomboBox.currentText()) elif (self.spectrumradioButton.isChecked()): ps = abs(np.fft.fft(Y))**2 time_step = 1 / int(self.freqSpinBox.value()) freqs = np.fft.fftfreq(Y.size, time_step) idx = np.argsort(freqs) freqs = freqs[idx] ps = ps[idx] red = freqs > 0 ax.plot(freqs[red], ps[red]) ax.set_title('Spectral Plot of ' + self.YcomboBox.currentText()) ax.set_xlabel('Frequency') ax.set_ylabel('Spectrum') if Nnan: ax.annotate('NaN present', xy=(0.05, 0.95), xycoords='axes fraction') if self.TcheckBox.isChecked(): if self.TlineEdit.text(): ax.set_title(self.TlineEdit.text()) else: ax.set_title('') if self.XcheckBox.isChecked(): if self.XlineEdit.text(): ax.set_xlabel(self.XlineEdit.text()) else: ax.set_xlabel('') if self.YcheckBox.isChecked(): ax.set_ylabel(self.YlineEdit.text()) else: ax.set_ylabel('') if self.XGcheckBox.isChecked(): ax.xaxis.grid(True) else: ax.xaxis.grid(False) if self.YGcheckBox.isChecked(): ax.yaxis.grid(True) else: ax.yaxis.grid(False) if not self.XMcheckBox.isChecked(): ax.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off') if not self.YMcheckBox.isChecked(): ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') self.rmmpl() self.addmpl(fig) def reset(self): self.YcomboBox.setCurrentIndex(0) self.XGcheckBox.setChecked(False) self.YGcheckBox.setChecked(False) self.XMcheckBox.setChecked(False) self.YMcheckBox.setChecked(True) self.XcheckBox.setChecked(True) self.YcheckBox.setChecked(True) self.XlineEdit.setText('') self.YlineEdit.setText('') self.TlineEdit.setText('') self.update() 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()