class TestWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.setWindowTitle("Signal filtering 2 (guiqwt)") self.setWindowIcon(get_icon('guiqwt.svg')) hlayout = QHBoxLayout() central_widget = QWidget(self) central_widget.setLayout(hlayout) self.setCentralWidget(central_widget) #---guiqwt plot manager self.manager = PlotManager(self) #--- def add_plot(self, x, y, func, title): widget = FilterTestWidget(self, x, y, func) widget.setup_widget(title) self.centralWidget().layout().addWidget(widget) #---Register plot to manager self.manager.add_plot(widget.plot) #--- def setup_window(self): #---Add toolbar and register manager tools toolbar = self.addToolBar("tools") self.manager.add_toolbar(toolbar, id(toolbar)) self.manager.register_all_curve_tools()
class CentralWidget(QWidget): def __init__(self, parent): QWidget.__init__(self, parent) layout = QGridLayout() self.setLayout(layout) self.plot1 = ImagePlot(self) layout.addWidget(self.plot1, 0, 0, 1, 1) self.plot2 = ImagePlot(self) layout.addWidget(self.plot2, 1, 0, 1, 1) self.contrast = ContrastAdjustment(self) layout.addWidget(self.contrast, 2, 0, 1, 2) self.itemlist = PlotItemList(self) layout.addWidget(self.itemlist, 0, 1, 2, 1) self.manager = PlotManager(self) for plot in (self.plot1, self.plot2): self.manager.add_plot(plot) for panel in (self.itemlist, self.contrast): self.manager.add_panel(panel) def register_tools(self): self.manager.register_all_image_tools()
class iScope(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.setWindowTitle("iScope (TM)") hlayout = QHBoxLayout() central_widget = QWidget(self) central_widget.setLayout(hlayout) self.setCentralWidget(central_widget) # ---guiqwt plot manager self.manager = PlotManager(self) # --- def add_plot(self, x, y): widget = iScopeWidget(self, x, y) widget.setup_widget() self.centralWidget().layout().addWidget(widget) # ---Register plot to manager self.manager.add_plot(widget.plot) # --- def setup_window(self): # ---Add toolbar and register manager tools toolbar = self.addToolBar("tools") self.manager.add_toolbar(toolbar, id(toolbar)) self.manager.register_standard_tools() self.manager.tools[0].activate()
def configure_plot(self): self.marker = add_marker(self.plot) self.line = MeasurementLine() self.line.setVisible(0) self.label = make_label(self.marker, self.line) setupCommonStyle(self.line, self.marker) manager = PlotManager(self.widget) manager.add_plot(self.plot) tool = manager.add_tool(MzSelectionTool) tool.activate() manager.set_default_tool(tool) self.plot.add_item(self.marker) self.plot.add_item(self.label) self.plot.add_item(self.line) self.plot.startMeasuring.connect(self.line.start_measuring) self.plot.moveMeasuring.connect(self.line.move_measuring) self.plot.stopMeasuring.connect(self.line.stop_measuring) self.plot.moveMarker.connect(self.marker.move_local_point_to) self.line.updated.connect(self.plot.replot)
class GuiqwtScreen(QWidget): """ Hum hum hum """ def __init__(self, parent=None, x=[], y=[], data=[]): QWidget.__init__(self, parent) if len(x) < 2: x = np.linspace(0, 1392, 1392) y = np.linspace(0, 1040, 1040) data = np.zeros((1040, 1392)) self.x = x self.y = y self.data = data sx = 600 sy = int(sx / 1.338) stretch_x = 3 stretch_y = 3 #self.setGeometry(QRect(0,0,sx,sy)) layout = QGridLayout(self) layout.setMargin(0) self.screen = ImageScreen(self, x, y, data) self.cutX = CutScreen(self) self.cutY = CutScreen(self) layout.addWidget(self.screen, 1, 0) layout.addWidget(self.cutX, 0, 0) layout.addWidget(self.cutY, 1, 1) layout.setColumnStretch(0, stretch_x) layout.setColumnStretch(1, 1) layout.setRowStretch(0, 1) layout.setRowStretch(1, stretch_y) self.setLayout(layout) self.updateGeometry() self.manager = PlotManager(self) self.manager.add_plot(self.screen.plot) self.manager.add_plot(self.cutX.plot) self.manager.add_plot(self.cutY.plot) #roi = ROISelectTool #bkgnd = BKGNDSelectTool self.tools = [tools.SelectTool, tools.RectZoomTool, tools.ColormapTool] self.manager.register_all_curve_tools()
class GuiqwtScreen(QWidget): """ Hum hum hum """ def __init__(self, parent=None, x=[], y=[], data=[]): QWidget.__init__(self, parent) if len(x) < 2: x = np.linspace(0, 1392, 1392) y = np.linspace(0, 1040, 1040) data = np.zeros((1040, 1392)) self.x = x self.y = y self.data = data layout = QGridLayout(self) ''' self.screen = ImageScreen(self,x,y,data,int(self.sizex*5.0/6.0),int(self.sizey*5.0/6.0)) self.cutX = CutScreen(self,sizex=int(self.sizex*5.0/6.0),sizey=int(self.sizey*1.0/6.0)) self.cutY = CutScreen(self,sizex=int(self.sizex*1.0/6.0),sizey=int(self.sizey*5.0/6.0)) ''' sx = 500 sy = int(sx / 1.338) a = 0.2 self.screen = ImageScreen(self, x, y, data, sizex=sx, sizey=sy) self.cutX = CutScreen(self, sizex=sx, sizey=int(a * sy)) self.cutY = CutScreen(self, sizex=int(a * sx), sizey=sy) layout.addWidget(self.screen, 1, 0) layout.addWidget(self.cutX, 0, 0) layout.addWidget(self.cutY, 1, 1) self.setLayout(layout) self.updateGeometry() self.manager = PlotManager(self) self.manager.add_plot(self.screen.plot) self.manager.add_plot(self.cutX.plot) self.manager.add_plot(self.cutY.plot) roi = RegionSelectTool self.tools = [ tools.SelectTool, tools.RectZoomTool, roi, tools.ColormapTool ] self.manager.register_all_curve_tools()
def configure_plot(self): set_x_axis_scale_draw(self.widget) manager = PlotManager(self.widget) manager.add_plot(self.plot) tool = manager.add_tool(RtSelectionTool) tool.activate() manager.set_default_tool(tool) self.marker = add_marker(self.plot) setupStyleRtMarker(self.marker) self.marker.rts = (0, ) self.plot.moveMarker.connect(self.marker.move_local_point_to) self.plot.moveMarker.connect(self.move_rt_cursor)
def Plot_Start_New(widget,PLOT_DEFINE,COLORS,x1,x2,y1,y2): newmanager = PlotManager(widget) newplots = [] newcurves = {} for name in PLOT_DEFINE: plot = CurvePlot() #设置图表颜色 plot.setStyleSheet('''QWidget{ border: 1px solid #32435E; border-radius: 3px; font-size:11pt; color:white; font-family:"Microsoft YaHei UI"; /* padding: 0 8px; */ background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #080B10, stop: 1.0 #212C3F); selection-background-color: #0A246A; } ''' ) plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(20) newplots.append(plot) newmanager.add_plot(plot) plot.plot_id = id(plot) for curve_color, curve_name in map(None,COLORS,name): if u"状态" in curve_name or u"打角/100" in curve_name : newcurves[curve_name] = guiqwt_make.curve([0], [0],markerfacecolor = 'black', markeredgecolor=curve_color, title=curve_name,marker = 'Diamond',linestyle = 'NoPen',markersize = 6) else: newcurves[curve_name] = guiqwt_make.curve([0], [0], color=curve_color, title=curve_name) plot.add_item(newcurves[curve_name]) #设置X轴y轴 plot.set_axis_limits(newcurves[curve_name].yAxis(),y1,y2) plot.set_axis_limits(newcurves[curve_name].xAxis(),x1,x2) plot.add_item(guiqwt_make.legend("BL")) newmanager.register_standard_tools() newmanager.get_default_tool().activate() return (newmanager,newplots,newcurves)
class TestDialog(QDialog): def __init__(self): QDialog.__init__(self) vlayout = QVBoxLayout() self.setLayout(vlayout) self.widget = CurveWidget() self.curve_item = make.curve([], [], color='r') self.widget.plot.add_item(self.curve_item) self.pm = PlotManager(self.widget) self.pm.add_plot(self.widget.plot) t = self.pm.add_tool(MyTool) t.curve_item = self.curve_item self.pm.set_default_tool(t) t.activate() self.layout().addWidget(self.widget) self.update_curve() def update_curve(self): x = np.arange(0,10,.1) y = np.sin(np.sin(x)) self.curve_item.set_data(x, y) self.curve_item.plot().replot()
class EicPlottingWidget(CurveWidget): SELECTED_RANGE_CHANGED = pyqtSignal(float, float) def __init__(self, parent=None, with_range=True): super(EicPlottingWidget, self).__init__(parent, ylabel="I") patch_inner_plot_object(self, EicPlot) self._with_range = with_range self._setup_plot() def enable_range(self, flag): self._with_range = flag self._setup_range_selector() def _setup_plot(self): self.pm = PlotManager(self) self.pm.add_plot(self.plot) t = self.pm.add_tool(RtSelectionTool) t.activate() self.pm.set_default_tool(t) self._setup_cursor() self._setup_range_selector() self._setup_label() self._setup_axes() def _setup_cursor(self): marker = Marker(label_cb=self.plot.label_info, constraint_cb=self.plot.on_plot) marker.rts = [0] setup_marker_param( marker, { "symbol.size": 0, "symbol.alpha": 0.0, "sel_symbol.size": 0, "sel_symbol.alpha": 0.0, "line.color": "#909090", "line.width": 1.0, "line.style": "SolidLine", "sel_line.color": "#909090", "sel_line.width": 1.0, "sel_line.style": "SolidLine", "markerstyle": "VLine" }) marker.attach(self.plot) self.marker = marker self._setup_cursor_info(marker) def _setup_cursor_info(self, marker): self.cursor_info = RtCursorInfo(marker) def _setup_range_selector(self): if not self._with_range: self.range_ = None return self.range_ = SnappingRangeSelection(0, 0) # you have to register item to plot before you can register the # rtSelectionHandler: self.plot.add_item(self.range_) self.range_.SELECTED_RANGE_CHANGED.connect( self._range_selection_handler) cc = make.info_label("TR", [RangeSelectionInfo(self.range_)], title=None) setup_label_param(cc, {"label": "", "font.size": 12}) self.plot.add_item(cc) def _setup_label(self): label = make.info_label("T", [self.cursor_info], title=None) setup_label_param(label, { "label": "", "font.size": 12, "border.color": "#ffffff" }) self.label = label def _setup_axes(self): # render tic labels in modfied format: set_rt_formatting_on_x_axis(self.plot) self.plot.set_axis_title("bottom", "RT") def plot_(self, eics): self.add_eics(eics) def set_cursor_pos(self, rt): self.plot.set_rt(rt) def set_overall_range(self, rtmin, rtmax): self.plot.overall_x_min = rtmin self.plot.overall_x_max = rtmax def add_eics(self, data, labels=None, configs=None): """ do not forget to call replot() after calling this function ! """ allrts = list() if configs is None: configs = [{"color": getColor(i)} for i in range(len(data))] if labels is None: labels = [""] * len(data) unique_labels = set() # items_with_label = [] seen = set() for i, (rts, chromatogram) in enumerate(data): # we do not plot duplicates, which might happen if multiple lines in the # table explorer are sellected ! if (id(rts), id(chromatogram)) in seen: continue seen.add((id(rts), id(chromatogram))) config = configs[i] label = "<pre>%s</pre>" % labels[i] unique_labels.add(label) curve = make_unselectable_curve(rts, chromatogram, title=label, **config) allrts.extend(rts) self.plot.add_item(curve) self.plot.add_item(self.label) self.plot.set_x_values(sorted(set(allrts))) # no idea why guiqwt needs double registration here: self.marker.attach(self.plot) self.plot.add_item(self.marker) # self._add_legend(unique_labels, items_with_label) if self.range_ is not None: self.plot.add_item(self.range_) def _add_legend(self, unique_labels, items_with_label): # überbleibsel von zeitreihen plott unique_labels -= set((None, )) unique_labels -= set(("", )) if unique_labels: legend = make.legend("TL", restrict_items=items_with_label) setup_label_param(legend, {"font.size": 12}) self.plot.add_item(legend) def add_eic_filled(self, rts, iis, baseline, color): shape = create_closed_shape(rts, iis, baseline, color) if shape is not None: self.plot.add_item(shape) def set_visible(self, visible): self.plot.setVisible(visible) def get_range_selection_limits(self): if self.range_ is None: return None, None return sorted((self.range_._min, self.range_._max)) def set_range_selection_limits(self, xleft, xright): if self.range_ is None: return self.range_.move_point_to(0, (xleft, 0)) self.range_.move_point_to(1, (xright, 0)) def reset_intensity_limits(self, imin=None, imax=None, fac=1.1, rtmin=None, rtmax=None): self.plot.reset_y_limits(imin, imax, fac, rtmin, rtmax) @protect_signal_handler def _range_selection_handler(self, left, right): min_, max_ = sorted((left, right)) self.SELECTED_RANGE_CHANGED.emit(min_, max_) def set_rt_axis_limits(self, xmin, xmax): self.plot.update_plot_xlimits(xmin, xmax) def get_limits(self): return self.plot.get_plot_limits() def updateAxes(self): self.plot.updateAxes() def set_intensity_axis_limits(self, ymin, ymax): self.plot.update_plot_ylimits(ymin, ymax) def reset_rt_limits(self, rt_min=None, rt_max=None, fac=1.1): self.plot.reset_x_limits(rt_min, rt_max, fac) def reset_intensitiy_limits(self, i_min=None, i_max=None, fac=1.1, rt_min=None, rt_max=None): self.plot.reset_y_limits(i_min, i_max, fac, rt_min, rt_max) def set_limit(self, ix, value): self.plot.set_limit(ix, value) def getLimits(self): return self.plot.get_plot_limits() def replot(self): self.plot.replot() def del_all_items(self): self.plot.del_all_items() def reset(self): """empties plot""" self.del_all_items() self.replot() def shrink_and_replot(self, rtmin, rtmax): self.reset_rt_limits(rtmin, rtmax) self.plot.reset_y_limits() self.plot.replot()
class SyncXAxis(QtGui.QWidget): def __init__(self): super(SyncXAxis, self).__init__() self.data = {u"t":array("d")} for name in sum(PLOT_DEFINE, []): self.data[name] = array("d") self.i = 0 self.x = [] self.curves = {} self.t = 0 self.sint = [] self.get_Roll = [] self.get_Pitch = [] self.get_Yaw = [] self.get_Angle1 = [] self.get_Angle2 =[] self.get_Angle3 = [] vbox = QtGui.QGridLayout() #工具栏 vbox.addLayout(self.setup_toolbar(),0,0) self.manager = PlotManager(self) self.plots = [] #生成竖直排列图形窗口 for i, define in enumerate(PLOT_DEFINE): plot = CurvePlot() plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60) self.manager.add_plot(plot) self.plots.append(plot) plot.plot_id = id(plot) for j, curve_name in enumerate(define): curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name) plot.add_item(curve) plot.add_item(make.legend("BL")) #vbox.addWidget(plot) vbox.addWidget(self.plots[0],1,0) vbox.addWidget(self.plots[1],1,1) vbox.addWidget(self.plots[2],2,0) vbox.addWidget(self.plots[3],2,1) self.manager.register_standard_tools() self.manager.get_default_tool().activate() self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys()) self.setLayout(vbox) self.startTimer(20) def setup_toolbar(self): toolbar = QtGui.QGridLayout() self.auto_xrange_checkbox = QtGui.QCheckBox(u"X轴自动调节") self.xrange_box = QtGui.QSpinBox() self.xrange_box.setMinimum(5) self.xrange_box.setMaximum(100) self.xrange_box.setValue(50) self.auto_xrange_checkbox.setChecked(True) self.Roll_label = QtGui.QLabel("PID KP:") self.lineEdit1 = QtGui.QLineEdit() self.lineEdit1.setText("1") self.lineEdit1.returnPressed.connect(self.PID_Roll) self.Roll_label.setBuddy(self.lineEdit1) self.Pitch_label = QtGui.QLabel("PID KI:") self.lineEdit2 = QtGui.QLineEdit() self.Pitch_label.setBuddy(self.lineEdit2) self.lineEdit2.setText("1") self.lineEdit2.returnPressed.connect(self.PID_Pitch) self.Yaw_label = QtGui.QLabel("PID KD:") self.lineEdit3 = QtGui.QLineEdit() self.Yaw_label.setBuddy(self.lineEdit3) self.lineEdit3.setText("1") self.lineEdit3.returnPressed.connect(self.PID_Yaw) toolbar.addWidget(self.auto_xrange_checkbox,0,0) toolbar.addWidget(self.xrange_box,0,1) toolbar.addWidget(self.Roll_label,1,0) toolbar.addWidget(self.lineEdit1,1,1) toolbar.addWidget(self.Pitch_label,2,0) toolbar.addWidget(self.lineEdit2,2,1) toolbar.addWidget(self.Yaw_label,3,0) toolbar.addWidget(self.lineEdit3,3,1) return toolbar def PID_Roll(self): global RPY_Array try: #print str(int(self.lineEdit1.text())) RPY_Array[0] = int(self.lineEdit1.text()) except: pass def PID_Pitch(self): global RPY_Array try: #print str(self.lineEdit1.text()) RPY_Array[1] = int(self.lineEdit2.text()) except: pass def PID_Yaw(self): global RPY_Array try: #print str(self.lineEdit1.text()) RPY_Array[2] = int(self.lineEdit3.text()) except: pass def timerEvent(self, event): global RPY_Array,Roll,Pitch,Yaw,Angle1,Angle2,Angle3 global xSlider,ySlider,zSlider self.x.append(self.t) self.t += DT self.sint.append(np.sin(self.t)) self.get_Roll.append(Roll) self.get_Pitch.append(Pitch) self.get_Yaw.append(Yaw) self.get_Angle1.append(Angle1) self.get_Angle2.append(Angle2) self.get_Angle3.append(Angle3) xSlider.setValue(Angle1 * 16)#初始值 ySlider.setValue(Angle3 * 16) zSlider.setValue(Angle2 * 16) #x轴的移动 if self.auto_xrange_checkbox.isChecked(): xmax = self.x[-1] xmin = self.xrange_box.value() if len(self.x) > xmin: self.x = self.x[-xmin:-1] self.get_Roll = self.get_Roll[-xmin:-1] self.get_Pitch = self.get_Pitch[-xmin:-1] self.get_Yaw = self.get_Yaw[-xmin:-1] self.get_Angle1 = self.get_Angle1[-xmin:-1] self.get_Angle2 = self.get_Angle2[-xmin:-1] self.get_Angle3 = self.get_Angle3[-xmin:-1] else : pass self.y_array = [[],[],[],[],[],[]] #3 最后一个 #0 三 #2 二 self.y_array[2] = self.get_Roll self.y_array[0] = self.get_Pitch self.y_array[3] = self.get_Yaw self.y_array[1] = self.get_Angle1 self.y_array[4] = self.get_Angle2 self.y_array[5] = self.get_Angle3 #print "\n", #print Roll,Pitch,Yaw,Angle1,Angle2,Angle3 #发送PID参数 global RPY_Array #serial_send(str("%04d" %RPY_Array[0]) + str("%04d" %RPY_Array[1]) + str("%04d" %RPY_Array[2]) + "111111") #更新数据 刷新图像 self.i = 0 for key, curve in self.curves.iteritems(): #self.sint = self.sint + 1 #self.sint = [x + 0.1 for x in self.sint] #print type(self.x),type(self.t) try: curve.set_data(self.x,self.y_array[self.i]) except: pass #print self.i #print key self.i += 1 for plot in self.plots: if self.auto_xrange_checkbox.isChecked(): plot.do_autoscale() elif self.auto_xrange_checkbox.isChecked(): plot.set_axis_limits("bottom", xmin, xmax) plot.replot() else: plot.replot()
class Ui_PlotWidget_Feature_Set(QtGui.QWidget): """""" def __init__(self, parent=None): """Constructor for Ui_PlotWidget""" QtGui.QWidget.__init__(self, parent) self.setupUi() def setupUi(self): """loads numpy array Args: self Returns: nothing """ # self.plot = CurvePlot(self) self.dialog = CurveDialog(edit=False, toolbar=True, parent=self) self.plot = self.dialog.get_plot() self.plot.set_antialiasing(True) # x = np.linspace(-10,10,200) # dy = x/100. # y = np.sin(np.sin(np.sin(x))) # self.plot.add_item(make.curve(x,y)) self.loadButton = QtGui.QPushButton("Load") self.trainButton = QtGui.QPushButton("Train Model") ly = QtGui.QVBoxLayout() ly.addWidget(self.plot) # ly.addWidget(self.loadButton) # ly.addWidget(self.trainButton) self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, "Time") self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, "Value") self.manager = PlotManager(self) self.manager.add_plot(self.plot) # self.manager. legend = make.legend("TL") self.plot.add_item(legend) self.setLayout(ly) self.move(300, 200) self.show() self.dataController = DataController.DataController() def loadData(self): self.trainingData = self.dataController.loadSampleData() import logic.dimreduce.paa as PAA p = PAA.paa() data = p.process(self.trainingData["PIR"][:], 100) r = np.array(range(len(data))).reshape(len(data), 1) s = np.array(data).reshape(len(data), 1) rs = np.hstack((s, s)) print rs import logic.featurex.kmeans as km k = km.kmeans() labels = k.process(rs, 2) print labels self.plot.add_item(make.curve(range(0, len(data)), data)) from guiqwt.styles import AnnotationParam i = 0 i_beg = 0 i_end = 0 while i < len(labels): cur = labels[i_end] if i < len(labels) - 1: if labels[i_end + 1] != cur: i_end = i from guiqwt.annotations import AnnotatedRectangle param = AnnotationParam() param.title = str(labels[int(i_beg)]) param.show_computations = False anno = AnnotatedRectangle(r[int(i_beg)], 0.5, r[int(i_end)], 0.2, param) # TODO: y axis scaling self.plot.add_item(anno) i_beg = i_end print "s1" else: i_end = i print "s2" print "s3" print "s4", i_end, len(labels) i += 1 # param = AnnotationParam() # param.title = "alright" # param.show_computations = False ##anno = AnnotatedRectangle(0., 1., 1.5, 0.5, param) # anno.set_style("plot", "shape/drag") # anno.set_style("shape/drag/fill/color", "white") # self.plot.add_item(anno) # self.rangeSelection = make.range(-2, 2) # disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm", # title="Range infos") # self.plot.add_item(self.rangeSelection) # self.plot.add_item(disp0) self.plot.replot() def trainData(self, string_length, vocab, window_length, clusterN): a, b = self.rangeSelection.get_range() if a > b: a, b = b, a print a, b print "in widget", int(string_length), int(vocab), int(window_length), int(clusterN) self.dataController.trainData(a, b, int(string_length), int(vocab), int(window_length), int(clusterN))
class Window(QMainWindow): def __init__(self, wintitle): super(Window, self).__init__() self.default_tool = None self.plots = [] self.itemlist = PlotItemList(None) self.contrast = ContrastAdjustment(None) self.xcsw = XCrossSection(None) self.ycsw = YCrossSection(None) self.manager = PlotManager(self) self.toolbar = QToolBar(_("Tools"), self) self.manager.add_toolbar(self.toolbar, "default") self.toolbar.setMovable(True) self.toolbar.setFloatable(True) self.addToolBar(Qt.TopToolBarArea, self.toolbar) frame = QFrame(self) self.setCentralWidget(frame) self.layout = QGridLayout() layout = QVBoxLayout(frame) frame.setLayout(layout) layout.addLayout(self.layout) self.frame = frame self.setWindowTitle(wintitle) self.setWindowIcon(get_icon('guiqwt.svg')) def closeEvent(self, event): global _figures, _current_fig, _current_axes figure_title = to_text_string(self.windowTitle()) if _figures.pop(figure_title) == _current_fig: _current_fig = None _current_axes = None self.itemlist.close() self.contrast.close() self.xcsw.close() self.ycsw.close() event.accept() def add_plot(self, i, j, plot): self.layout.addWidget(plot, i, j) self.manager.add_plot(plot) self.plots.append(plot) def replot(self): for plot in self.plots: plot.replot() item = plot.get_default_item() if item is not None: plot.set_active_item(item) item.unselect() def add_panels(self, images=False): self.manager.add_panel(self.itemlist) if images: for panel in (self.ycsw, self.xcsw, self.contrast): panel.hide() self.manager.add_panel(panel) def register_tools(self, images=False): if images: self.manager.register_all_image_tools() else: self.manager.register_all_curve_tools() def display(self): self.show() self.replot() self.manager.get_default_tool().activate() self.manager.update_tools_status()
class MzPlottingWidget(CurveWidget): def __init__(self, parent=None): super(MzPlottingWidget, self).__init__(parent, xlabel="mz", ylabel="I") patch_inner_plot_object(self, MzPlot) self.plot.centralMz = None def label(self, x): # label with full precision: return QwtText(str(x)) a = QwtScaleDraw() a.label = new.instancemethod(label, self.plot, QwtScaleDraw) self.plot.setAxisScaleDraw(self.plot.xBottom, a) self.pm = PlotManager(self) self.pm.add_plot(self.plot) self.curve = make_unselectable_curve([], [], color="b", curvestyle="Sticks") self.plot.add_item(self.curve) t = self.pm.add_tool(MzSelectionTool) self.pm.set_default_tool(t) t.activate() marker = Marker(label_cb=self.plot.label_info, constraint_cb=self.plot.on_plot) marker.attach(self.plot) line = make_measurement_line() line.setVisible(0) setupCommonStyle(line, marker) line.shapeparam.line.color = "#555555" line.shapeparam.update_shape(line) label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None) label.labelparam.label = "" label.labelparam.font.size = 12 label.labelparam.update_label(label) self.marker = marker self.label = label self.line = line def plot_spectra(self, all_peaks, labels): self.plot.del_all_items() self.plot.add_item(self.marker) self.plot.add_item(make.legend("TL")) self.plot.add_item(self.label) for i, (peaks, label) in enumerate(zip(all_peaks, labels)): config = dict(color=getColor(i)) curve = make_unselectable_curve([], [], title=label, curvestyle="Sticks", **config) curve.set_data(peaks[:, 0], peaks[:, 1]) self.plot.add_item(curve) self.plot.resample_config = [] self.plot.add_item(self.line) if len(all_peaks): self.plot.all_peaks = np.vstack(all_peaks) else: self.plot.all_peaks = np.zeros((0, 2)) def _setup_configs_and_titles(self, configs, titles, n): configs = configs if configs is not None else [None] * n titles = titles if titles is not None else [""] * n def default(i): return dict(color=getColor(i)) configs = [ci if ci is not None else default(i) for (i, ci) in enumerate(configs)] return configs, titles def set_overall_range(self, mzmin, mzmax): self.plot.overall_x_min = mzmin self.plot.overall_x_max = mzmax def plot_peakmaps(self, peakmap_ranges, configs=None, titles=None): has_titles = titles is not None configs, titles = self._setup_configs_and_titles(configs, titles, len(peakmap_ranges)) self.plot.del_all_items() self.plot.add_item(self.marker) if has_titles: self.plot.add_item(make.legend("TL")) self.plot.add_item(self.label) self.plot.plot_peakmap_ranges(peakmap_ranges, configs, titles) self.plot.add_item(self.line) def set_cursor_pos(self, mz): self.plot.set_mz(mz) def resetAxes(self): self.plot.reset_x_limits() def reset_mz_limits(self, xmin=None, xmax=None, fac=1.1): self.plot.reset_x_limits(xmin, xmax, fac) def reset(self): self.plot.del_all_items() self.replot() def replot(self): self.plot.replot() def set_visible(self, visible): self.plot.setVisible(visible) def updateAxes(self): self.plot.updateAxes() def shrink_and_replot(self, mzmin, mzmax): self.reset_mz_limits(mzmin, mzmax) self.plot.reset_y_limits() self.plot.replot()
class RtPlotter(PlotterBase): def __init__(self, parent=None, rangeSelectionCallback=None): PlotterBase.__init__(self, "RT", "I") self.rangeSelectionCallback = rangeSelectionCallback widget = self.widget widget.plot.__class__ = RtPlot self.pm = PlotManager(widget) self.pm.add_plot(widget.plot) t = self.pm.add_tool(RtSelectionTool) t.activate() self.pm.set_default_tool(t) marker = Marker(label_cb=self.widget.plot.label_info, constraint_cb=self.widget.plot.on_plot) marker.rts = [0] setupStyleRtMarker(marker) marker.attach(self.widget.plot) self.marker = marker self.cursor_info = RtCursorInfo(marker) label = make.info_label("T", [self.cursor_info], title=None) label.labelparam.label = "" label.labelparam.font.size = 12 label.labelparam.border.color = "#ffffff" label.labelparam.update_label(label) self.label = label self.minRTRangeSelected = None self.maxRTRangeSelected = None def _set_rt_x_axis_labels(self): # todo: refactor as helper a = QwtScaleDraw() # render tic labels in modfied format: label = lambda self, v: QwtText(formatSeconds(v)) a.label = new.instancemethod(label, self.widget.plot, QwtScaleDraw) self.widget.plot.setAxisScaleDraw(self.widget.plot.xBottom, a) def _set_ts_x_axis_labels(self, data): # todo: refactor as helper all_ts = [tsi for ts in data for tsi in ts.x] pos = find_datetime_split_pos(all_ts) a = QwtScaleDraw() # render tic labels in modfied format: label = lambda self, v, pos=pos: QwtText(format_datetime_value(pos, v)) # QwtText(str(v)) a.label = new.instancemethod(label, self.widget.plot, QwtScaleDraw) self.widget.plot.setAxisScaleDraw(self.widget.plot.xBottom, a) def reset(self): """empties plot""" self.plot([]) self.marker.rts = [0] self.replot() def plot(self, data, is_time_series=False, titles=None, configs=None, withmarker=False): """ do not forget to call replot() after calling this function ! """ allrts = [] self.widget.plot.del_all_items() if is_time_series: self._set_ts_x_axis_labels(data) self.widget.plot.set_axis_title("bottom", "time") else: self._set_rt_x_axis_labels() self.widget.plot.set_axis_title("bottom", "RT") labels = set() legend_items = [] if is_time_series: seen = set() for i, ts in enumerate(data): # we do not plot duplicates, which might happen if multiple lines in the # table explorer are sellected ! if id(ts) in seen: continue seen.add(id(ts)) config = None if configs is not None: config = configs[i] if config is None: config = dict(color=getColor(i)) title = ts.label labels.add(title) for j, (x, y) in enumerate(ts.for_plotting()): x = [xi.toordinal() if isinstance(xi, datetime) else xi for xi in x] allrts.extend(x) curve = make.curve(x, y, title="<pre>%s</pre>" % title, **config) curve.__class__ = ModifiedCurveItem self.widget.plot.add_item(curve) self.cursor_info.is_time_series = True if j == 0: legend_items.append(curve) else: seen = set() for i, (rts, chromatogram) in enumerate(data): # we do not plot duplicates, which might happen if multiple lines in the # table explorer are sellected ! if (id(rts), id(chromatogram)) in seen: continue seen.add((id(rts), id(chromatogram))) config = None if configs is not None: config = configs[i] if config is None: config = dict(color=getColor(i)) if titles: title = "<pre>%s</pre>" % titles[i] else: title = "" labels.add(title) curve = make.curve(rts, chromatogram, title=title, **config) curve.__class__ = ModifiedCurveItem allrts.extend(rts) self.widget.plot.add_item(curve) self.cursor_info.is_time_series = False if withmarker: self.widget.plot.add_item(self.label) allrts = sorted(set(allrts)) self.marker.rts = allrts self.marker.attach(self.widget.plot) self.widget.plot.add_item(self.marker) labels -= set((None,)) labels -= set(("",)) if labels: legend = make.legend("TL", restrict_items=legend_items) legend.labelparam.font.size = 12 legend.labelparam.update_label(legend) self.widget.plot.add_item(legend) if not is_time_series: self._add_range_selector(allrts) def setEnabled(self, enabled): self.widget.plot.setVisible(enabled) def _add_range_selector(self, rtvalues): self.rtvalues = rtvalues self.minRTRangeSelected = 0 self.maxRTRangeSelected = 0 range_ = SnappingRangeSelection(self.minRTRangeSelected, self.maxRTRangeSelected, self.rtvalues) setupStyleRangeMarker(range_) self.range_ = range_ # you have to register item to plot before you can register the # rtSelectionHandler: self.widget.plot.add_item(range_) range_.SIG_RANGE_CHANGED.connect(self._range_selection_handler) #self.widget.disconnect(range_.plot(), SIG_RANGE_CHANGED, #self._range_selection_handler) #self.widget.connect(range_.plot(), SIG_RANGE_CHANGED, #self._range_selection_handler) cc = make.info_label("TR", [RtRangeSelectionInfo(range_)], title=None) cc.labelparam.label = "" cc.labelparam.font.size = 12 cc.labelparam.update_label(cc) self.widget.plot.add_item(cc) def getRangeSelectionLimits(self): return sorted((self.range_._min, self.range_._max)) def setRangeSelectionLimits(self, xleft, xright): saved = self.rangeSelectionCallback self.rangeSelectionCallback = None self.minRTRangeSelected = xleft self.maxRTRangeSelected = xright # left and right bar of range marker self.range_.move_point_to(0, (xleft, 0)) self.range_.move_point_to(1, (xright, 0)) self.rangeSelectionCallback = saved @protect_signal_handler def _range_selection_handler(self, obj, left, right): min_, max_ = sorted((left, right)) self.minRTRangeSelected = min_ self.maxRTRangeSelected = max_ if self.rangeSelectionCallback is not None: self.rangeSelectionCallback() reset_rt_limits = PlotterBase.reset_x_limits reset_intensity_limits = PlotterBase.reset_y_limits
class RealtimeDemo(QWidget): def __init__(self): super(RealtimeDemo, self).__init__() self.setWindowTitle(u"Realtime Demo") self.data = {u"t":array("d")} for name in sum(PLOT_DEFINE, []): self.data[name] = array("d") self.curves = {} self.t = 0 vbox = QVBoxLayout() vbox.addWidget(self.setup_toolbar()) self.manager = PlotManager(self) self.plots = [] for i, define in enumerate(PLOT_DEFINE): plot = CurvePlot() plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60) self.manager.add_plot(plot) self.plots.append(plot) plot.plot_id = id(plot) for j, curve_name in enumerate(define): curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name) plot.add_item(curve) plot.add_item(make.legend("BL")) vbox.addWidget(plot) self.manager.register_standard_tools() self.manager.get_default_tool().activate() self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys()) self.setLayout(vbox) self.startTimer(100) def setup_toolbar(self): toolbar = QToolBar() self.auto_yrange_checkbox = QCheckBox(u"Y轴自动调节") self.auto_xrange_checkbox = QCheckBox(u"X轴自动调节") self.xrange_box = QSpinBox() self.xrange_box.setMinimum(1) self.xrange_box.setMaximum(50) self.xrange_box.setValue(1) self.auto_xrange_checkbox.setChecked(True) self.auto_yrange_checkbox.setChecked(True) toolbar.addWidget(self.auto_yrange_checkbox) toolbar.addWidget(self.auto_xrange_checkbox) toolbar.addWidget(self.xrange_box) return toolbar def timerEvent(self, event): global bin_ori # writecache = [] drawcache = [] MAXRANGE = 65535 AMPL = 6 for i in range(n_channel): # writecache.append([]) drawcache.append([]) for i in range(collecttime): n = ser.inWaiting() # print(n) ori = ser.read(n) bin_ori += str(binascii.b2a_hex(ori))[2:-1] ffff_list = bin_ori.split('fffffffe') bin_ori = ffff_list[-1] wrong_no = 0 # print(len(ffff_list)) for i in range(1, len(ffff_list)): if len(ffff_list[i]) != 4 * n_channel: # print(i) # print('receive wrong') wrong_no += 1 # print(ffff_list[i]) continue for j in range(n_channel): temp = int(ffff_list[i][4 * j:4 * (j + 1)], 16) drawcache[j].append((temp))# - MAXRANGE / 2) / (MAXRANGE / 2) * AMPL) # writecache[j].append(str(temp)) # print(wrong_no) # print(wrong_no / len(ffff_list)) for i in xrange(len(drawcache[0])): t = self.t self.data[u"t"].append(t) # for j in xrange(n_channel): # self.data[u"signal_"+str(j)].append(drawcache[j][i]) # self.data[u"signal_0"].append(drawcache[0][i]) self.data[u"signal_1"].append(drawcache[1][i]) # self.data[u"signal_2"].append(drawcache[2][i]) # self.data[u"signal_3"].append(drawcache[3][i]) self.data[u"signal_4"].append(drawcache[4][i]) # self.data[u"signal_5"].append(drawcache[5][i]) # self.data[u"signal_6"].append(drawcache[6][i]) self.data[u"signal_7"].append(drawcache[7][i]) # self.data[u"signal_8"].append(drawcache[8][i]) # self.data[u"signal_9"].append(drawcache[9][i]) self.t += DT # for i in xrange(100): # t = self.t # self.data[u"t"].append(t) # self.data[u"sin1f"].append(sin(t)) # self.data[u"cos1f"].append(cos(t)) # self.data[u"sin3f"].append(sin(3*t)/6) # self.data[u"cos3f"].append(cos(3*t)/6) # self.data[u"sin合成"].append(sin(t)+sin(3*t)/6) # self.data[u"cos合成"].append(cos(t)+cos(3*t)/6) # self.t += DT if self.auto_xrange_checkbox.isChecked(): xmax = self.data["t"][-1] xmin = max(xmax - self.xrange_box.value(), 0) else: xmin, xmax = self.plots[0].get_axis_limits('bottom') for key, curve in self.curves.iteritems(): xdata = self.data["t"] ydata = self.data[key] x, y = get_peak_data(xdata, ydata, xmin, xmax, 600, 1/DT) curve.set_data(x, y) for plot in self.plots: if self.auto_yrange_checkbox.isChecked() and self.auto_xrange_checkbox.isChecked(): plot.do_autoscale() elif self.auto_xrange_checkbox.isChecked(): plot.set_axis_limits("bottom", xmin, xmax) plot.replot() else: plot.replot()
class RtPlotter(PlotterBase): def __init__(self, rangeSelectionCallback = None): super(RtPlotter, self).__init__("RT", "I") self.rangeSelectionCallback = rangeSelectionCallback widget = self.widget widget.plot.__class__ = RtPlot # todo: refactor as helper a = QwtScaleDraw() # render tic labels in modfied format: label = lambda self, v: QwtText(formatSeconds(v)) a.label = new.instancemethod(label, widget.plot, QwtScaleDraw) widget.plot.setAxisScaleDraw(widget.plot.xBottom, a) #a.label = new.instancemethod(label, widget.plot, QwtScaleDraw) self.pm = PlotManager(widget) self.pm.add_plot(widget.plot) t = self.pm.add_tool(RtSelectionTool) self.addTool(RtSelectionTool) self.pm.set_default_tool(t) marker = Marker(label_cb=self.widget.plot.label_info,\ constraint_cb=self.widget.plot.on_plot) marker.rts = [0] setupStyleRtMarker(marker) marker.attach(self.widget.plot) self.marker = marker label = make.info_label("T", [RtCursorInfo(marker)], title=None) label.labelparam.label = "" self.label=label self.minRTRangeSelected = None self.maxRTRangeSelected = None def addTool(self, tool): t = self.pm.add_tool(tool) t.activate() def reset(self): self.plot([]) self.marker.rts = [0] self.replot() def plot(self, chromatograms, titles=None, configs=None,\ withmarker=False): """ do not forget to call replot() after calling this function ! """ allrts = set() self.widget.plot.del_all_items() #self.widget.plot.set_antialiasing(True) for i in range(len(chromatograms)): rts, chromatogram = chromatograms[i] config = None if configs is not None: config = configs[i] if config is None: config = dict(color = getColor(i)) if titles: title = titles[i] else: title = "" curve = make.curve(rts, chromatogram, title=title, **config) curve.__class__ = ModifiedCurveItem allrts.update(rts) self.widget.plot.add_item(curve) if withmarker: self.widget.plot.add_item(self.label) allrts = sorted(allrts) self.marker.rts = allrts self.marker.attach(self.widget.plot) self.widget.plot.add_item(self.marker) if titles is not None: self.widget.plot.add_item(make.legend("TL")) self.addRangeSelector(allrts) def setEnabled(self, enabled): self.widget.plot.setVisible(enabled) def addRangeSelector(self, rtvalues): self.rtvalues = rtvalues self.minRTRangeSelected = 0 self.maxRTRangeSelected = 0 range_ = SnappingRangeSelection(self.minRTRangeSelected,\ self.maxRTRangeSelected, self.rtvalues) setupStyleRangeMarker(range_) self.range_ = range_ # you have to register item to plot before you can register the # rtSelectionHandler: self.widget.plot.add_item(range_) self.widget.disconnect(range_.plot(), SIG_RANGE_CHANGED,\ self.rangeSelectionHandler) self.widget.connect(range_.plot(), SIG_RANGE_CHANGED,\ self.rangeSelectionHandler) cc = make.info_label("TR", [RtRangeSelectionInfo(range_)], title=None) cc.labelparam.label = "" self.widget.plot.add_item(cc) def getRangeSelectionLimits(self): return sorted( (self.range_._min, self.range_._max) ) def setRangeSelectionLimits(self, xleft, xright): saved = self.rangeSelectionCallback self.rangeSelectionCallback = None self.minRTRangeSelected = xleft self.maxRTRangeSelected = xright # left and right bar of range marker self.range_.move_point_to(0, (xleft,0), emitsignal=False) self.range_.move_point_to(1, (xright,0)) # calls self.rangeSelectionHandler ! self.rangeSelectionCallback = saved @protect_signal_handler def rangeSelectionHandler(self, obj, left, right): min_, max_ = sorted((left, right)) self.minRTRangeSelected = min_ self.maxRTRangeSelected = max_ if self.rangeSelectionCallback is not None: self.rangeSelectionCallback()
class ContrastAdjustment(PanelWidget): """Contrast adjustment tool""" __implements__ = (IPanel,) PANEL_ID = ID_CONTRAST PANEL_TITLE = _("Contrast adjustment tool") PANEL_ICON = "contrast.png" def __init__(self, parent=None): super(ContrastAdjustment, self).__init__(parent) self.local_manager = None # local manager for the histogram plot self.manager = None # manager for the associated image plot # Storing min/max markers for each active image self.min_markers = {} self.max_markers = {} # Select point tools self.min_select_tool = None self.max_select_tool = None style = "<span style=\'color: #444444\'><b>%s</b></span>" layout, _label = get_image_layout(self.PANEL_ICON, style % self.PANEL_TITLE, alignment=Qt.AlignCenter) layout.setAlignment(Qt.AlignCenter) vlayout = QVBoxLayout() vlayout.addLayout(layout) self.local_manager = PlotManager(self) self.histogram = LevelsHistogram(parent) vlayout.addWidget(self.histogram) self.local_manager.add_plot(self.histogram) hlayout = QHBoxLayout() self.setLayout(hlayout) hlayout.addLayout(vlayout) self.toolbar = toolbar = QToolBar(self) toolbar.setOrientation(Qt.Vertical) # toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) hlayout.addWidget(toolbar) # Add standard plot-related tools to the local manager lman = self.local_manager lman.add_tool(SelectTool) lman.add_tool(BasePlotMenuTool, "item") lman.add_tool(BasePlotMenuTool, "axes") lman.add_tool(BasePlotMenuTool, "grid") lman.add_tool(AntiAliasingTool) lman.get_default_tool().activate() self.outliers_param = EliminateOutliersParam(self.PANEL_TITLE) def register_panel(self, manager): """Register panel to plot manager""" self.manager = manager default_toolbar = self.manager.get_default_toolbar() self.manager.add_toolbar(self.toolbar, "contrast") self.manager.set_default_toolbar(default_toolbar) self.setup_actions() for plot in manager.get_plots(): self.histogram.connect_plot(plot) def configure_panel(self): """Configure panel""" self.min_select_tool = self.manager.add_tool(SelectPointTool, title=_("Minimum level"), on_active_item=True, mode="create", tip=_("Select minimum level on image"), toolbar_id="contrast", end_callback=self.apply_min_selection) self.max_select_tool = self.manager.add_tool(SelectPointTool, title=_("Maximum level"), on_active_item=True, mode="create", tip=_("Select maximum level on image"), toolbar_id="contrast", end_callback=self.apply_max_selection) def get_plot(self): return self.manager.get_active_plot() def closeEvent(self, event): self.hide() event.ignore() def setup_actions(self): fullrange_ac = create_action(self, _("Full range"), icon=get_icon("full_range.png"), triggered=self.histogram.set_full_range, tip=_("Scale the image's display range " "according to data range") ) autorange_ac = create_action(self, _("Eliminate outliers"), icon=get_icon("eliminate_outliers.png"), triggered=self.eliminate_outliers, tip=_("Eliminate levels histogram " "outliers and scale the image's " "display range accordingly") ) add_actions(self.toolbar, [fullrange_ac, autorange_ac]) def eliminate_outliers(self): def apply(param): self.histogram.eliminate_outliers(param.percent) if self.outliers_param.edit(self, apply=apply): apply(self.outliers_param) def apply_min_selection(self, tool): item = self.get_plot().get_last_active_item(IVoiImageItemType) point = self.min_select_tool.get_coordinates() z = item.get_data(*point) self.histogram.set_min(z) def apply_max_selection(self, tool): item = self.get_plot().get_last_active_item(IVoiImageItemType) point = self.max_select_tool.get_coordinates() z = item.get_data(*point) self.histogram.set_max(z) def set_range(self, _min, _max): """Set contrast panel's histogram range""" self.histogram.set_range(_min, _max) # Update the levels histogram in case active item data has changed: self.histogram.selection_changed(self.get_plot())
class MzPlotter(PlotterBase): def __init__(self, c_callback=None): super(MzPlotter, self).__init__("m/z", "I") self.c_callback = c_callback widget = self.widget # inject mofified behaviour of wigets plot attribute: widget.plot.__class__ = MzPlot widget.plot.register_c_callback(self.handle_c_pressed) self.setHalfWindowWidth(0.05) self.centralMz = None # todo: refactor as helper a = QwtScaleDraw() label = lambda self, x : QwtText("%s" % x) a.label = new.instancemethod(label, widget.plot, QwtScaleDraw) widget.plot.setAxisScaleDraw(widget.plot.xBottom, a) self.pm = PlotManager(widget) self.pm.add_plot(widget.plot) self.curve = make.curve([], [], color='b', curvestyle="Sticks") # inject modified behaviour: self.curve.__class__ = ModifiedCurveItem self.widget.plot.add_item(self.curve) t = self.pm.add_tool(MzSelectionTool) self.pm.set_default_tool(t) t.activate() marker = Marker(label_cb=widget.plot.label_info,\ constraint_cb=widget.plot.on_plot) marker.attach(self.widget.plot) line = make.segment(0, 0, 0, 0) line.__class__ = ModifiedSegment line.setVisible(0) setupCommonStyle(line, marker) label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None) label.labelparam.label = "" self.marker = marker self.label = label self.line = line def setHalfWindowWidth(self, w2): self.widget.plot.set_half_window_width(w2) def setCentralMz(self, mz): self.widget.plot.set_central_mz(mz) def handle_c_pressed(self, p): if self.c_callback: self.c_callback(p) def plot(self, spectra, configs=None, titles=None): """ do not forget to call replot() after calling this function ! """ self.widget.plot.del_all_items() self.widget.plot.add_item(self.marker) if titles is not None: self.widget.plot.add_item(make.legend("TL")) self.widget.plot.add_item(self.label) allpeaks = [] for i in range(len(spectra)): peaks = spectra[i] allpeaks.append(peaks) config = configs[i] if configs is not None else None if config is None: config = dict(color = getColor(i)) if titles is not None: title = titles[i] else: title = u"" curve = make.curve([], [], title=title,\ curvestyle="Sticks", **config) curve.set_data(peaks[:, 0], peaks[:, 1]) curve.__class__ = ModifiedCurveItem self.widget.plot.add_item(curve) self.widget.plot.add_item(self.line) if len(allpeaks): self.widget.plot.all_peaks = np.vstack(allpeaks) else: self.widget.plot.all_peaks = np.zeros((0,2)) def resetAxes(self): self.widget.plot.reset_x_limits() def reset(self): self.plot(np.ndarray((0,2))) self.replot()
class MainWindow(qg.QMainWindow): """This one generates the main window and orchestrates all other widgets """ def __init__(self): qg.QMainWindow.__init__(self) self.setWindowTitle("Neuron Database") self.setWindowIcon(get_icon('guiqwt.png')) self.setAttribute(qc.Qt.WA_DeleteOnClose,True) hlayout = qg.QHBoxLayout() central_widget = qg.QWidget(self) central_widget.setLayout(hlayout) self.setCentralWidget(central_widget) #---guiqwt plot manager self.manager = PlotManager(self) #--- self.add_plot("1") self._constructFileMenu() self._constructEditMenu() self._constructConsoleWidget(central_widget) def _constructFileMenu(self): """ """ file_menu = self.menuBar().addMenu("File") quit_action = create_action(self, "Quit", shortcut="Ctrl+Q", icon=get_std_icon("DialogCloseButton"), tip="Quit application", triggered=self.close) openDB_action = create_action(self, "Open database", shortcut ="Ctrl+D", tip ="Open an existing database into scroll area", triggered=self.open_Database) createDB_action = create_action(self,"New database", shortcut ="Ctrl+N", tip ="Create a new database", triggered=self.create_Database) closeDB_action = create_action(self,"Close database", shortcut ="Ctrl+W", tip = "Close an open database", triggered=self.close_Database) add_actions(file_menu, (quit_action, openDB_action, createDB_action, closeDB_action)) def _constructEditMenu(self): """ """ edit_menu = self.menuBar().addMenu("Edit") editparam1_action = create_action(self, "Import dataset", shortcut ="Ctrl+A", tip ="Import data from matlab structure", triggered=self.add_newData) deleteNode_action = create_action(self, "Delete neuron", tip ="Delete neuron from database", triggered=self.delete_Neuron) add_actions(edit_menu, (editparam1_action, deleteNode_action)) def _constructConsoleWidget(self, central_widget): """ """ font = qg.QFont("Courier new") font.setPointSize(12) ns = {'win': self, 'widget': central_widget} msg = "Try for example: widget.set_text('foobar') or win.close()" # Note: by default, the internal shell is multithreaded which is safer # but not compatible with graphical user interface creation. # For example, if you need to plot data with Matplotlib, you will need # to pass the option: multithreaded=False self.console = cons = InternalShell(self, namespace=ns, message=msg) # Setup the console widget cons.set_font(font) cons.set_codecompletion_auto(True) cons.set_calltips(True) cons.setup_calltips(size=600, font=font) cons.setup_completion(size=(300, 100), font=font) console_dock = qg.QDockWidget("Console", self) console_dock.setWidget(cons) # Add the console widget to window as a dockwidget self.addDockWidget(qc.Qt.BottomDockWidgetArea, console_dock) def add_plot(self, title): """ """ self.widget = PlotWidget(self) self.widget.setup_widget(title) self.centralWidget().layout().addWidget(self.widget) #---Register plot to manager self.manager.add_plot(self.widget.plot) def setup_window(self): """Add toolbar and register manager tools """ toolbar = self.addToolBar("tools") self.manager.add_toolbar(toolbar, id(toolbar)) self.manager.register_all_curve_tools() def closeEvent(self, event): """ """ self.console.exit_interpreter() event.accept() def findOpenDBases(self): """ """ return self.widget.databaseScroll.DataBasesOpen ### popup actions: def add_newData(self): """ """ DBname = Popup(self.findOpenDBases(), textMessage = "add data to a database:", style = 4) if DBname.selection != None and DBname.selection != []: name = DBname.selection[1] neuronName = DBname.selection[2] if self.widget.databaseScroll.isOpen(name): addData = Dbase(DBaseName = name) if not addData.Data.Exists(neuronName): addData.AddData(neuronName, Directory = DBname.selection[0]) self.widget.databaseScroll.refreshTree() print 'data import complete.' else : print ' ' print 'database already has Neuron named {0}'.format(neuronName) else: print 'database not open.' def open_Database(self): """ """ DBname = Popup(self.findOpenDBases(), textMessage = "select database to open", style = 3) if DBname.selection != None and len(DBname.selection) > 1: print DBname.selection loadedDBname = DBname.selection self.widget.databaseScroll.AppendDatabasesOpen(loadedDBname) self.widget.databaseScroll.OpenDatabases(loadedDBname) #self.widget.databaseScroll.refreshTree() #print '{0} database opened.'.format(loadedDBname) else: pass def create_Database(self): """ """ DBname = Popup(self.findOpenDBases(), textMessage = "enter name of new database", style = 2) if DBname.selection != None : newDBname = DBname.selection if newDBname[-3:] != '.h5': newDBname = newDBname + '.h5' self.widget.databaseScroll.AppendDatabasesOpen(newDBname) self.widget.databaseScroll.refreshTree() #print '{0} database created.'.format(newDBname) else: pass def delete_Neuron(self): """ """ DBname = Popup(self.findOpenDBases(), textMessage = "enter name of neuron to delete", style = 1) if DBname.selection != None : try: name = DBname.selection[0] if self.widget.databaseScroll.isOpen(name): rmData = Dbase(DBaseName = name) neuron = DBname.selection[1] rmData.Data.RemoveNeuron(neuron, option = 1) rmData.Data.CloseDatabase() self.widget.databaseScroll.refreshTree() print 'successfully deleted', neuron else: print 'database not open.' except (ValueError, TypeError): print 'sorry, could not delete. please make sure data exists.' else: pass def close_Database(self): """ """ DBname = Popup(self.findOpenDBases(), textMessage = "select database to close", style = 0) if DBname.selection != None : self.widget.databaseScroll.CloseDatabase(DBname.selection) self.widget.databaseScroll.refreshTree() print '{0} closed.'.format(DBname.selection) else: pass
class Ui_Form(object): def __init__(self, type): self.dc = DataController() self.fec = FeatureExtractionControl() self.flowData = self.dc.dimrecprocData pos = self.fec.getAvailableAlgorithms().keys().index(type) self.fec.selectAlgorithm(pos) def setupUi(self, Form): Form.setObjectName(_fromUtf8("Form")) Form.resize(536, 384) self.Form=Form self.tableWidget = QtGui.QTableWidget(Form) self.tableWidget.setGeometry(QtCore.QRect(90, 261, 221, 121)) self.tableWidget.setObjectName(_fromUtf8("tableWidget")) self.tableWidget.setColumnCount(2) self.tableWidget.setRowCount(len(self.fec.getRequiredParameters())) item = QtGui.QTableWidgetItem() self.tableWidget.setVerticalHeaderItem(0, item) item = QtGui.QTableWidgetItem() self.tableWidget.setHorizontalHeaderItem(0, item) item = QtGui.QTableWidgetItem() self.tableWidget.setHorizontalHeaderItem(1, item) item = QtGui.QTableWidgetItem() self.tableWidget.setItem(0, 0, item) item = QtGui.QTableWidgetItem() self.tableWidget.setItem(0, 1, item) self.pushButton = QtGui.QPushButton(Form) self.pushButton.setGeometry(QtCore.QRect(0, 300, 75, 23)) self.pushButton.setObjectName(_fromUtf8("pushButton")) self.widget = QtGui.QWidget(Form) self.widget.setGeometry(QtCore.QRect(10, 10, 521, 211)) self.widget.setObjectName(_fromUtf8("widget")) self.pushButton_3 = QtGui.QPushButton(Form) self.pushButton_3.setGeometry(QtCore.QRect(0, 360, 75, 23)) self.pushButton_3.setObjectName(_fromUtf8("pushButton_3")) self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget) self.plot = self.dialog.get_plot() self.plot.set_antialiasing(True) self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time') self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value') self.manager = PlotManager(self) self.manager.add_plot(self.plot) legend = make.legend('TL') self.plot.add_item(legend) ly = QtGui.QVBoxLayout() ly.addWidget(self.plot) self.widget.setLayout(ly) # item = QtGui.QTableWidgetItem() # self.tableWidget.setHorizontalHeaderItem(0, item) # item = QtGui.QTableWidgetItem() # self.tableWidget.setItem(0, 0, item) # item = QtGui.QTableWidgetItem() # self.tableWidget.setItem(0, 1, item) # item = self.tableWidget.horizontalHeaderItem(0) # item.setText(_translate("Form", "Attribute", None)) c = 0 for it in self.fec.getRequiredParameters(): # item = QtGui.QTableWidgetItem() # item.setText(_translate("Form", "Id" + str(c), None)) # self.tableWidget.setVerticalHeaderItem(c, item) item = QtGui.QTableWidgetItem() item.setText(it) self.tableWidget.setItem(c, 0, item) print it, self.fec.getRequiredParameters()[it] item = QtGui.QTableWidgetItem() item.setText(str(self.fec.getRequiredParameters()[it])) self.tableWidget.setItem(c, 1, item) print c c += 1 self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) def retranslateUi(self, Form): Form.setWindowTitle(_translate("Form", "Form", None)) __sortingEnabled = self.tableWidget.isSortingEnabled() self.tableWidget.setSortingEnabled(False) self.tableWidget.setSortingEnabled(__sortingEnabled) self.pushButton.setText(_translate("Form", "Process", None)) Form.connect(self.pushButton, QtCore.SIGNAL('clicked()'), self.process) self.pushButton_3.setText(_translate("Form", "Save", None)) Form.connect(self.pushButton_3, QtCore.SIGNAL('clicked()'),self.saveDialog) def process(self): params = {} for i in range(self.tableWidget.rowCount()): a = self.tableWidget.item(i, 0) b = self.tableWidget.item(i, 1) params[str(a.text())] = int(b.text()) print "params", params outpN = self.tableWidget.item(0, 0) #params = {"none": "none", "output_length": outpN} r = np.array(range(len(self.dc.dimrecprocData))).reshape(len(self.dc.dimrecprocData), 1) s = np.array(self.dc.dimrecprocData).reshape(len(self.dc.dimrecprocData), 1) rs = np.hstack((s, s)) labels = self.fec.extractFeature(rs, params) print labels self.plot.del_all_items() self.plot.replot() self.plot.add_item( make.curve(range(0, len(self.dc.dimrecprocData)), self.dc.dimrecprocData)) from guiqwt.styles import AnnotationParam i = 0 i_beg = 0 i_end = 0 while i < len(labels): cur = labels[i_end] if i < len(labels) - 1: if labels[i_end + 1] != cur: i_end = i from guiqwt.annotations import AnnotatedRectangle param = AnnotationParam() param.title = str(labels[int(i_beg)]) param.show_computations = False anno = AnnotatedRectangle(r[int(i_beg)], self.dc.dimrecprocData[int(i_beg)], int(i_end), self.dc.dimrecprocData[r[int(i_end)]], param) #TODO: y axis scaling self.plot.add_item(anno) i_beg = i_end print "s1" else: i_end = i print "s2" print "s3" print "s4", i_end, len(labels) i += 1 self.rangeSelection = make.range(-2, 2) disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm", title="Range infos") #self.plot.add_item(self.rangeSelection) #self.plot.add_item(disp0) #self.dc.setCurrentDataFlowObject(self.flowData) self.dc.featureexData = self.flowData self.dc.setCurrentLabels(labels) print(self.dc.setCurrentLabels) #ToDo: Check that following line, make property in data controller self.dc.dimrecprocData = rs self.plot.replot() self.currentdata = np.reshape(labels, (-1, 1)) def saveDialog(self): path = QtGui.QFileDialog.getSaveFileName(self.Form, 'Save File', '', 'CSV(*.csv)') if not path.isEmpty(): with open(unicode(path), 'wb') as stream: writer = csv.writer(stream) [a,b]=self.currentdata.shape print(a) print(b) for row in range(a): rowdata = [] for column in range(b): item = self.currentdata.item(row, column) if item is not None: rowdata.append(item) else: rowdata.append('') writer.writerow(rowdata)
class RealtimeDemo(QWidget): def __init__(self): super(RealtimeDemo, self).__init__() self.setWindowTitle(u"Realtime Demo") self.data = {u"t": array("d")} for name in sum(PLOT_DEFINE, []): self.data[name] = array("d") self.curves = {} self.t = 0 vbox = QVBoxLayout() vbox.addWidget(self.setup_toolbar()) self.manager = PlotManager(self) self.plots = [] for i, define in enumerate(PLOT_DEFINE): plot = CurvePlot() plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60) self.manager.add_plot(plot) self.plots.append(plot) plot.plot_id = id(plot) for j, curve_name in enumerate(define): curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name) plot.add_item(curve) plot.add_item(make.legend("BL")) vbox.addWidget(plot) self.manager.register_standard_tools() self.manager.get_default_tool().activate() self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys()) self.setLayout(vbox) self.startTimer(100) def setup_toolbar(self): toolbar = QToolBar() self.auto_yrange_checkbox = QCheckBox(u"Y轴自动调节") self.auto_xrange_checkbox = QCheckBox(u"X轴自动调节") self.xrange_box = QSpinBox() self.xrange_box.setMinimum(5) self.xrange_box.setMaximum(50) self.xrange_box.setValue(10) self.auto_xrange_checkbox.setChecked(True) self.auto_yrange_checkbox.setChecked(True) toolbar.addWidget(self.auto_yrange_checkbox) toolbar.addWidget(self.auto_xrange_checkbox) toolbar.addWidget(self.xrange_box) return toolbar def timerEvent(self, event): for i in xrange(100): t = self.t self.data[u"t"].append(t) self.data[u"sin1f"].append(sin(t)) self.data[u"cos1f"].append(cos(t)) self.data[u"sin3f"].append(sin(3*t)/6) self.data[u"cos3f"].append(cos(3*t)/6) self.data[u"sin合成"].append(sin(t)+sin(3*t)/6) self.data[u"cos合成"].append(cos(t)+cos(3*t)/6) self.t += DT if self.auto_xrange_checkbox.isChecked(): xmax = self.data["t"][-1] xmin = max(xmax - self.xrange_box.value(), 0) else: xmin, xmax = self.plots[0].get_axis_limits('bottom') for key, curve in self.curves.iteritems(): xdata = self.data["t"] ydata = self.data[key] x, y = get_peak_data(xdata, ydata, xmin, xmax, 600, 1/DT) curve.set_data(x, y) for plot in self.plots: if self.auto_yrange_checkbox.isChecked() and self.auto_xrange_checkbox.isChecked(): plot.do_autoscale() elif self.auto_xrange_checkbox.isChecked(): plot.set_axis_limits("bottom", xmin, xmax) plot.replot() else: plot.replot()
class PlottingHelper(object): '''This is the class implementing the plotting work.''' def __init__(self, parent, signal_names, sample_rate): '''Do the initialization work. A PlottingHelper object helps plotting a group of signals all of which has the same number of points to plot at one time. signal_names: a dictionary {'list_name':['list of signal names']} sample_rate: the sample_rate of the signals ''' self.sample_rate = sample_rate self.signal_names = signal_names self.curve_items = {} self.curve_plots = {} self.plot_manager = PlotManager(parent) for list_name, sig_name_list in self.signal_names.items(): # One CurvePlot object for every sig_name_list curve_plot = CurvePlot() curve_plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(10) self.curve_plots[list_name] = curve_plot curve_plot.plot_id = id(curve_plot) for i, sig_name in enumerate(sig_name_list): # One CurveItem object for every signal_name print sig_name, colors[i] self.curve_items[sig_name] = make.curve([0], [0], \ color=colors[i], title=sig_name) curve_plot.add_item(self.curve_items[sig_name]) # add the curve_plot object to plot_manager self.plot_manager.add_plot(curve_plot) # register and activate the tools self.plot_manager.register_standard_tools() self.plot_manager.get_default_tool().activate() self.plot_manager.synchronize_axis(CurvePlot.X_BOTTOM, \ self.plot_manager.plots.keys()) def update_curves(self, time, signals, interval_in_second): '''update the curves everytime the signals change time: the time sequence, which is also the x_axis data signal: a dictionary of signals to plot, the keys of which is recorded in self.signal_names. and in fact these are the y_axis data ''' xmax = time[-1] xmin = max(xmax - interval_in_second, 0) xdata = time for list_name, sig_name_list in self.signal_names.items(): # for i, sig_name in enumerate(sig_name_list): # ydata = signals[sig_name] idxmn = int(xmin*self.sample_rate) idxmx = int(xmax*self.sample_rate) self.curve_items[sig_name].set_data(xdata[idxmn:idxmx], \ ydata[idxmn:idxmx]) self.curve_plots[list_name].do_autoscale()
class Ui_Form(object): def setupUi(self, Form): Form.setObjectName(_fromUtf8("Form")) Form.resize(750, 453) self.Form = Form self.pushButton = QtGui.QPushButton(Form) self.pushButton.setGeometry(QtCore.QRect(30, 0, 75, 23)) self.pushButton.setObjectName(_fromUtf8("pushButton")) '''self.checkBox = QtGui.QCheckBox(Form) self.checkBox.setGeometry(QtCore.QRect(20, 70, 70, 17)) self.checkBox.setObjectName(_fromUtf8("checkBox")) self.checkBox_2 = QtGui.QCheckBox(Form) self.checkBox_2.setGeometry(QtCore.QRect(100, 70, 70, 17)) self.checkBox_2.setObjectName(_fromUtf8("checkBox_2")) self.checkBox_3 = QtGui.QCheckBox(Form) self.checkBox_3.setGeometry(QtCore.QRect(180, 70, 70, 17)) self.checkBox_3.setObjectName(_fromUtf8("checkBox_3"))''' self.widget = QtGui.QWidget(Form) self.widget.setGeometry(QtCore.QRect(10, 110, 581, 251)) self.widget.setObjectName(_fromUtf8("widget")) self.startD = QtGui.QLineEdit(Form) self.startD.setGeometry(QtCore.QRect(120, 0, 81, 20)) self.startD.setObjectName(_fromUtf8("startD")) self.endD = QtGui.QLineEdit(Form) self.endD.setGeometry(QtCore.QRect(240, 0, 71, 20)) self.endD.setObjectName(_fromUtf8("endD")) self.label = QtGui.QLabel(Form) self.label.setGeometry(QtCore.QRect(290, 20, 46, 13)) self.label.setObjectName(_fromUtf8("label")) self.label_2 = QtGui.QLabel(Form) self.label_2.setGeometry(QtCore.QRect(170, 20, 46, 13)) self.label_2.setObjectName(_fromUtf8("label_2")) self.Hint = QtGui.QLabel(Form) self.Hint.setGeometry(QtCore.QRect(330, 10, 281, 16)) self.Hint.setObjectName(_fromUtf8("Hint")) self.pushButton_2 = QtGui.QPushButton(Form) self.pushButton_2.setGeometry(QtCore.QRect(30, 30, 75, 23)) self.pushButton_2.setObjectName(_fromUtf8("pushButton_2")) self.pushButton.clicked.connect(self.loadDialog) self.pushButton_2.clicked.connect(self.saveDialog) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) def retranslateUi(self, Form): Form.setWindowTitle(_translate("Form", "Form", None)) self.pushButton.setText(_translate("Form", "Load Data", None)) self.label.setText(_translate("Form", "End", None)) self.label_2.setText(_translate("Form", "Begin", None)) self.Hint.setText(_translate("Form", "Enter before loading. To load whole dataset, leave blank", None)) self.pushButton_2.setText(_translate("Form", "Save", None)) def loadDialog(self): filename = QtGui.QFileDialog.getOpenFileName(self.Form, 'Open File', '.') fname = open(filename) data = fname.read() #self.le.setText(filename) do = pandas.read_csv(str(filename), delimiter=",") #data = pd.read_csv('C:/Users/se00075/PycharmProjects/Test2/src' + '/' + 'data.csv') if (self.startD.text().isEmpty()) & (self.endD.text().isEmpty()): d=do else: do['time_stamp'] = do['time_stamp'].astype('datetime64[ns]') st = int(self.startD.text()) en = int(self.endD.text()) select = (do['time_stamp'] >= do.time_stamp[0]+datetime.timedelta(days=st-1)) & (do['time_stamp'] < do.time_stamp[0]+datetime.timedelta(days=en)) d = do[select] #d = pandas.read_csv(str(filename), delimiter=",") #print d ##Lets add clean missing data here space = 0 self.checkboxes = [] for i in d.columns: c = QtGui.QCheckBox(self.Form) #print space c.setGeometry(QtCore.QRect(10 + space, 50, 70, 17)) c.setText(_fromUtf8(i)) c.show() c.clicked.connect(self.selected) self.checkboxes.append(c) space += 68 self.original_data = d #self.original_data=(self.original_data-self.original_data.mean()) / self.original_data.std() self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget) self.plot = self.dialog.get_plot() self.plot.set_antialiasing(True) self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time') self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value') self.manager = PlotManager(self) self.manager.add_plot(self.plot) legend = make.legend('TL') self.plot.add_item(legend) ly = QtGui.QVBoxLayout() ly.addWidget(self.plot) self.widget.setLayout(ly) self.widget.show() self.Form.update() self.Form.repaint() def selected(self, state): dc = logic.DataFlowControl.DataController() from itertools import cycle colors = cycle(["r", "g", "b", "y"]) self.plot.del_all_items() selItems = [] for c in self.checkboxes: c.isChecked() c.text() if c.isChecked(): selItems.append(str(c.text())) self.selected_data = np.array(self.original_data[selItems]) print "fileLoader self.selected_data.shape", self.selected_data.shape x = range(self.selected_data.shape[0]) for g in selItems: k = make.curve(x, np.array(self.original_data[g]), color=colors.next()) self.plot.add_item(k) print "fileLoader current data flow object",self.selected_data #dc.setCurrentDataFlowObject(self.selected_data) dc.originalData = self.selected_data self.Form.repaint() self.Form.repaint() self.plot.update() def saveDialog(self): path = QtGui.QFileDialog.getSaveFileName(self.Form, 'Save File', '', 'CSV(*.csv)') if not path.isEmpty(): with open(unicode(path), 'wb') as stream: writer = csv.writer(stream) [a,b]=self.selected_data.shape print(a) print(b) for row in range(a): rowdata = [] for column in range(b): item = self.selected_data.item(row, column) if item is not None: rowdata.append(item) else: rowdata.append('') writer.writerow(rowdata)
class MzPlotter(PlotterBase): def __init__(self, c_callback=None, image_plot=None): super(MzPlotter, self).__init__("m/z", "I") self.c_callback = c_callback widget = self.widget # inject mofified behaviour of wigets plot attribute: widget.plot.__class__ = MzPlot widget.plot.register_c_callback(self.handle_c_pressed) widget.plot.image_plot = image_plot self.setHalfWindowWidth(0.05) self.centralMz = None # todo: refactor as helper a = QwtScaleDraw() label = lambda self, x: QwtText("%s" % x) a.label = new.instancemethod(label, widget.plot, QwtScaleDraw) widget.plot.setAxisScaleDraw(widget.plot.xBottom, a) self.pm = PlotManager(widget) self.pm.add_plot(widget.plot) self.curve = make.curve([], [], color='b', curvestyle="Sticks") # inject modified behaviour: self.curve.__class__ = ModifiedCurveItem self.widget.plot.add_item(self.curve) t = self.pm.add_tool(MzSelectionTool) self.pm.set_default_tool(t) t.activate() marker = Marker(label_cb=widget.plot.label_info, constraint_cb=widget.plot.on_plot) marker.attach(self.widget.plot) line = make.segment(0, 0, 0, 0) line.__class__ = ModifiedSegment line.setVisible(0) setupCommonStyle(line, marker) label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None) label.labelparam.label = "" self.marker = marker self.label = label self.line = line def setHalfWindowWidth(self, w2): self.widget.plot.set_half_window_width(w2) def setCentralMz(self, mz): self.widget.plot.set_central_mz(mz) def handle_c_pressed(self, p): if self.c_callback: self.c_callback(p) def plot(self, data, configs=None, titles=None): """ do not forget to call replot() after calling this function ! """ self.widget.plot.del_all_items() self.widget.plot.add_item(self.marker) if titles is not None: self.widget.plot.add_item(make.legend("TL")) self.widget.plot.add_item(self.label) all_peaks = [] self.widget.plot.data = [] self.widget.plot.curves = [] for i, (pm, rtmin, rtmax, mzmin, mzmax, npeaks) in enumerate(data): if rtmin is None and rtmax is None: rtmin, rtmax = pm.rtRange() elif rtmin is None: rtmin, __ = pm.rtRange() elif rtmax is None: __, rtmax = pm.rtRange() if mzmin is None and mzmax is None: mzmin, mzmax = pm.mzRange() elif mzmin is None: mzmin, __ = pm.mzRange() elif mzmax is None: __, mzmax = pm.mzRange() if npeaks is None: npeaks = 3000 peaks = sample_peaks(pm, rtmin, rtmax, mzmin, mzmax, npeaks) all_peaks.append(peaks) config = configs[i] if configs is not None else None if config is None: config = dict(color=getColor(i)) if titles is not None: title = titles[i] else: title = u"" curve = make.curve([], [], title=title, curvestyle="Sticks", **config) curve.set_data(peaks[:, 0], peaks[:, 1]) curve.__class__ = ModifiedCurveItem self.widget.plot.add_item(curve) self.widget.plot.curves.append(curve) self.widget.plot.data.append((pm, rtmin, rtmax, mzmin, mzmax, npeaks)) self.widget.plot.add_item(self.line) if len(all_peaks): self.widget.plot.all_peaks = np.vstack(all_peaks) else: self.widget.plot.all_peaks = np.zeros((0, 2)) def resetAxes(self): self.widget.plot.reset_x_limits() def reset(self): self.plot(np.ndarray((0, 2))) self.replot()
class plotWindow(QMainWindow): def __init__(self, *args, **kwargs): QMainWindow.__init__(self, *args, **kwargs) self.__initVars() # init self geo = self.geometry() geo.setWidth(800) geo.setHeight(600) geo.setX(100) geo.setY(100) self.setGeometry(geo) self.setWindowTitle("plot window") self.__initLayout() # end __init__ def __del__(self): if (self.__p_manager): del self.__p_manager # end if self.__initVars() # end __del__ def __initVars(self): self.__p_manager = False self.__p_toolbar = False self.__p_resizeButton = False self.__l_layoutChilds = [] self.__v_wasInitialized = False # end __initVars def __initLayout(self): # layout layout = QGridLayout() central_widget = QWidget(self) central_widget.setLayout(layout) self.setCentralWidget(central_widget) # create plot manager self.__p_manager = PlotManager(self) # toolbar if (self.__p_toolbar): self.__p_toolbar.clear() else: self.__p_toolbar = self.addToolBar("tools") # end if # resize button icon = QIcon("icons/center.png") button = QToolButton() button.setIcon(icon) button.setToolTip("Resize") self.connect(button, SIGNAL("clicked()"), self.__onAutoScale) self.__p_manager.add_toolbar(self.__p_toolbar, id(self.__p_toolbar)) self.__p_toolbar.addWidget(button) self.__v_wasInitialized = True # end __initManager def reInit(self): for plot in self.__l_layoutChilds: self.centralWidget().layout().removeWidget(plot) del plot # end if self.__l_layoutChilds = [] # layout oldLayout = self.centralWidget().layout() del oldLayout if (self.__p_manager): del self.__p_manager self.__p_manager = False # end if self.__initLayout() # end reInit def addCurvePlot(self, curves, *args, **kwargs): return self.__addPlot(curves, noneBugCurvePlot, *args, **kwargs) # end addCurvePlot def addImagePlot(self, images, *args, **kwargs): return self.__addPlot(images, ImagePlot, *args, **kwargs) # end addImagePlot def addImageWidget(self, images, *args, **kwargs): widget = ImageWidget(self, *args, **kwargs) plot = widget.get_plot() if (images.__class__ is not list): plot.add_item(images) else: for image in images: plot.add_item(image) # end for # end if self.centralWidget().layout().addWidget(widget) self.__l_layoutChilds.append(widget) return widget # end addImageWidget def getManager(self): return self.__p_manager # end getManager def __addPlot(self, dataList, plotClass, *args, **kwargs): """ pos[0]: row pos[1]: column pos[2]: rowspan pos[3]: columnspan """ pos = [] if ('position' in kwargs): pos = kwargs.pop('position') # end if if ('pos' in kwargs): pos = kwargs.pop('pos') # end if plot = plotClass(self, *args, **kwargs) if (dataList.__class__ is not list): plot.add_item(dataList) else: for data in dataList: plot.add_item(data) # end for # end if self.__registerPlot(plot, pos) return plot # end __addPlot def __registerPlot(self, plot, pos): # check for position if (pos != []): if (len(pos) == 2): pos.append(1) # rowspan pos.append(1) # columnspan # end if self.centralWidget().layout().addWidget(plot, pos[0], pos[1], pos[2], pos[3]) else: self.centralWidget().layout().addWidget(plot) # end if self.__l_layoutChilds.append(plot) self.__p_manager.add_plot(plot) # end __registerPLot def show(self, *args, **kwargs): if (self.__v_wasInitialized): self.__p_manager.register_all_curve_tools() self.__v_wasInitialized = False # end if QMainWindow.show(self, *args, **kwargs) # end show def showEvent(self, event): # emit signal self.emit(SIGNAL("onShow()")) # execute not overloaded showEvent QMainWindow.showEvent(self, event) # end showEvent def closeEvent(self, event): # emit signal self.emit(SIGNAL("onClose()")) # execute not overloaded closeEvent QMainWindow.closeEvent(self, event) # end closeEvent def __onAutoScale(self): plot = self.__p_manager.get_active_plot() plot.do_autoscale(True)
class Ui_Form(object): def __init__(self, type): self.dc = DataController() self.drc = RepresentationControl() self.flowData = self.dc.abstractionData pos = self.drc.getAvailableAlgorithms().keys().index(type) self.drc.selectAlgorithm(pos) def setupUi(self, Form): Form.setObjectName(_fromUtf8("Form")) Form.resize(536, 384) self.tableWidget = QtGui.QTableWidget(Form) self.tableWidget.setGeometry(QtCore.QRect(90, 261, 221, 121)) if self.dc.getCurrentLabels() is None: QtGui.QMessageBox.warning(Form, "No Features Found", "Please select Feature Extraction Method first", QtGui.QMessageBox.Ok) self.tableWidget.setObjectName(_fromUtf8("tableWidget")) self.tableWidget.setColumnCount(2) self.tableWidget.setRowCount(len(list(set(self.dc.getCurrentLabels())))) self.pushButton = QtGui.QPushButton(Form) self.pushButton.setGeometry(QtCore.QRect(0, 360, 75, 23)) self.pushButton.setObjectName(_fromUtf8("pushButton")) self.label = QtGui.QLabel(Form) self.label.setGeometry(QtCore.QRect(10, 10, 521, 211)) self.label.setText("The state figure will be saved") self.widget = QtGui.QWidget() self.widget.setGeometry(QtCore.QRect(10, 10, 521, 211)) self.widget.setObjectName(_fromUtf8("widget")) self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget) self.plot = self.dialog.get_plot() self.plot.set_antialiasing(True) self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time') self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value') self.manager = PlotManager(self) self.manager.add_plot(self.plot) ly = QtGui.QVBoxLayout() ly.addWidget(QtGui.QLabel(self.widget)) ly.addWidget(QtGui.QLabel(self.plot)) self.widget.setLayout(ly) # item = QtGui.QTableWidgetItem() # self.tableWidget.setHorizontalHeaderItem(0, item) # item = QtGui.QTableWidgetItem() # self.tableWidget.setItem(0, 0, item) # item = QtGui.QTableWidgetItem() # self.tableWidget.setItem(0, 1, item) # item = self.tableWidget.horizontalHeaderItem(0) # item.setText(_translate("Form", "Attribute", None)) c = 0 for it in list(set(self.dc.getCurrentLabels())): # item = QtGui.QTableWidgetItem() # item.setText(_translate("Form", "Id" + str(c), None)) # self.tableWidget.setVerticalHeaderItem(c, item) item = QtGui.QTableWidgetItem() item.setText(str(it)) self.tableWidget.setItem(c, 0, item) #print "jgaboo timeig", it #print it, self.drc.getRequiredParameters()[it] item = QtGui.QTableWidgetItem() item.setText("States!") self.tableWidget.setItem(c, 1, item) #print c c += 1 self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) def retranslateUi(self, Form): Form.setWindowTitle(_translate("Form", "Form", None)) __sortingEnabled = self.tableWidget.isSortingEnabled() self.tableWidget.setSortingEnabled(False) self.tableWidget.setSortingEnabled(__sortingEnabled) self.pushButton.setText(_translate("Form", "Picture It!", None)) Form.connect(self.pushButton, QtCore.SIGNAL('clicked()'), self.processor) def processor(self): print "in process" params = {} for i in range(self.tableWidget.rowCount()): a = self.tableWidget.item(i, 0) b = self.tableWidget.item(i, 1) params[str(a.text())] = str(b.text()) #print "paramsjo", params #print "paramsjo2", self.dc.params self.drc.represent(None,{"states":self.dc.params})
class ContrastAdjustment(PanelWidget): """Contrast adjustment tool""" __implements__ = (IPanel, ) PANEL_ID = ID_CONTRAST PANEL_TITLE = _("Contrast adjustment tool") PANEL_ICON = "contrast.png" def __init__(self, parent=None): super(ContrastAdjustment, self).__init__(parent) self.local_manager = None # local manager for the histogram plot self.manager = None # manager for the associated image plot # Storing min/max markers for each active image self.min_markers = {} self.max_markers = {} # Select point tools self.min_select_tool = None self.max_select_tool = None style = "<span style='color: #444444'><b>%s</b></span>" layout, _label = get_image_layout(self.PANEL_ICON, style % self.PANEL_TITLE, alignment=Qt.AlignCenter) layout.setAlignment(Qt.AlignCenter) vlayout = QVBoxLayout() vlayout.addLayout(layout) self.local_manager = PlotManager(self) self.histogram = LevelsHistogram(parent) vlayout.addWidget(self.histogram) self.local_manager.add_plot(self.histogram) hlayout = QHBoxLayout() self.setLayout(hlayout) hlayout.addLayout(vlayout) self.toolbar = toolbar = QToolBar(self) toolbar.setOrientation(Qt.Vertical) # toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) hlayout.addWidget(toolbar) # Add standard plot-related tools to the local manager lman = self.local_manager lman.add_tool(SelectTool) lman.add_tool(BasePlotMenuTool, "item") lman.add_tool(BasePlotMenuTool, "axes") lman.add_tool(BasePlotMenuTool, "grid") lman.add_tool(AntiAliasingTool) lman.get_default_tool().activate() self.outliers_param = EliminateOutliersParam(self.PANEL_TITLE) def register_panel(self, manager): """Register panel to plot manager""" self.manager = manager default_toolbar = self.manager.get_default_toolbar() self.manager.add_toolbar(self.toolbar, "contrast") self.manager.set_default_toolbar(default_toolbar) self.setup_actions() for plot in manager.get_plots(): self.histogram.connect_plot(plot) def configure_panel(self): """Configure panel""" self.min_select_tool = self.manager.add_tool( SelectPointTool, title=_("Minimum level"), on_active_item=True, mode="create", tip=_("Select minimum level on image"), toolbar_id="contrast", end_callback=self.apply_min_selection, ) self.max_select_tool = self.manager.add_tool( SelectPointTool, title=_("Maximum level"), on_active_item=True, mode="create", tip=_("Select maximum level on image"), toolbar_id="contrast", end_callback=self.apply_max_selection, ) def get_plot(self): return self.manager.get_active_plot() def closeEvent(self, event): self.hide() event.ignore() def setup_actions(self): fullrange_ac = create_action( self, _("Full range"), icon=get_icon("full_range.png"), triggered=self.histogram.set_full_range, tip=_("Scale the image's display range " "according to data range"), ) autorange_ac = create_action( self, _("Eliminate outliers"), icon=get_icon("eliminate_outliers.png"), triggered=self.eliminate_outliers, tip=_("Eliminate levels histogram " "outliers and scale the image's " "display range accordingly"), ) add_actions(self.toolbar, [fullrange_ac, autorange_ac]) def eliminate_outliers(self): def apply(param): self.histogram.eliminate_outliers(param.percent) if self.outliers_param.edit(self, apply=apply): apply(self.outliers_param) def apply_min_selection(self, tool): item = self.get_plot().get_last_active_item(IVoiImageItemType) point = self.min_select_tool.get_coordinates() z = item.get_data(*point) self.histogram.set_min(z) def apply_max_selection(self, tool): item = self.get_plot().get_last_active_item(IVoiImageItemType) point = self.max_select_tool.get_coordinates() z = item.get_data(*point) self.histogram.set_max(z) def set_range(self, _min, _max): """Set contrast panel's histogram range""" self.histogram.set_range(_min, _max) # Update the levels histogram in case active item data has changed: self.histogram.selection_changed(self.get_plot())
class EicPlottingWidget(CurveWidget): SELECTED_RANGE_CHANGED = pyqtSignal(float, float) def __init__(self, parent=None, with_range=True): super(EicPlottingWidget, self).__init__(parent, ylabel="I") patch_inner_plot_object(self, EicPlot) self._with_range = with_range self._setup_plot() def enable_range(self, flag): self._with_range = flag self._setup_range_selector() def _setup_plot(self): self.pm = PlotManager(self) self.pm.add_plot(self.plot) t = self.pm.add_tool(RtSelectionTool) t.activate() self.pm.set_default_tool(t) self._setup_cursor() self._setup_range_selector() self._setup_label() self._setup_axes() def _setup_cursor(self): marker = Marker(label_cb=self.plot.label_info, constraint_cb=self.plot.on_plot) marker.rts = [0] setup_marker_param(marker, {"symbol.size": 0, "symbol.alpha": 0.0, "sel_symbol.size": 0, "sel_symbol.alpha": 0.0, "line.color": "#909090", "line.width": 1.0, "line.style": "SolidLine", "sel_line.color": "#909090", "sel_line.width": 1.0, "sel_line.style": "SolidLine", "markerstyle": "VLine"}) marker.attach(self.plot) self.marker = marker self._setup_cursor_info(marker) def _setup_cursor_info(self, marker): self.cursor_info = RtCursorInfo(marker) def _setup_range_selector(self): if not self._with_range: self.range_ = None return self.range_ = SnappingRangeSelection(0, 0) # you have to register item to plot before you can register the # rtSelectionHandler: self.plot.add_item(self.range_) self.range_.SELECTED_RANGE_CHANGED.connect(self._range_selection_handler) cc = make.info_label("TR", [RangeSelectionInfo(self.range_)], title=None) setup_label_param(cc, {"label": "", "font.size": 12}) self.plot.add_item(cc) def _setup_label(self): label = make.info_label("T", [self.cursor_info], title=None) setup_label_param(label, {"label": "", "font.size": 12, "border.color": "#ffffff"}) self.label = label def _setup_axes(self): # render tic labels in modfied format: set_rt_formatting_on_x_axis(self.plot) self.plot.set_axis_title("bottom", "RT") def plot_(self, eics): self.add_eics(eics) def set_cursor_pos(self, rt): self.plot.set_rt(rt) def set_overall_range(self, rtmin, rtmax): self.plot.overall_x_min = rtmin self.plot.overall_x_max = rtmax def add_eics(self, data, labels=None, configs=None): """ do not forget to call replot() after calling this function ! """ allrts = list() if configs is None: configs = [{"color": getColor(i)} for i in range(len(data))] if labels is None: labels = [""] * len(data) unique_labels = set() # items_with_label = [] seen = set() for i, (rts, chromatogram) in enumerate(data): # we do not plot duplicates, which might happen if multiple lines in the # table explorer are sellected ! if (id(rts), id(chromatogram)) in seen: continue seen.add((id(rts), id(chromatogram))) config = configs[i] label = "<pre>%s</pre>" % labels[i] unique_labels.add(label) curve = make_unselectable_curve(rts, chromatogram, title=label, **config) allrts.extend(rts) self.plot.add_item(curve) self.plot.add_item(self.label) self.plot.set_x_values(sorted(set(allrts))) # no idea why guiqwt needs double registration here: self.marker.attach(self.plot) self.plot.add_item(self.marker) # self._add_legend(unique_labels, items_with_label) if self.range_ is not None: self.plot.add_item(self.range_) def _add_legend(self, unique_labels, items_with_label): # überbleibsel von zeitreihen plott unique_labels -= set((None,)) unique_labels -= set(("",)) if unique_labels: legend = make.legend("TL", restrict_items=items_with_label) setup_label_param(legend, {"font.size": 12}) self.plot.add_item(legend) def add_eic_filled(self, rts, iis, baseline, color): shape = create_closed_shape(rts, iis, baseline, color) if shape is not None: self.plot.add_item(shape) def set_visible(self, visible): self.plot.setVisible(visible) def get_range_selection_limits(self): if self.range_ is None: return None, None return sorted((self.range_._min, self.range_._max)) def set_range_selection_limits(self, xleft, xright): if self.range_ is None: return self.range_.move_point_to(0, (xleft, 0)) self.range_.move_point_to(1, (xright, 0)) def reset_intensity_limits(self, imin=None, imax=None, fac=1.1, rtmin=None, rtmax=None): self.plot.reset_y_limits(imin, imax, fac, rtmin, rtmax) @protect_signal_handler def _range_selection_handler(self, left, right): min_, max_ = sorted((left, right)) self.SELECTED_RANGE_CHANGED.emit(min_, max_) def set_rt_axis_limits(self, xmin, xmax): self.plot.update_plot_xlimits(xmin, xmax) def get_limits(self): return self.plot.get_plot_limits() def updateAxes(self): self.plot.updateAxes() def set_intensity_axis_limits(self, ymin, ymax): self.plot.update_plot_ylimits(ymin, ymax) def reset_rt_limits(self, rt_min=None, rt_max=None, fac=1.1): self.plot.reset_x_limits(rt_min, rt_max, fac) def reset_intensitiy_limits(self, i_min=None, i_max=None, fac=1.1, rt_min=None, rt_max=None): self.plot.reset_y_limits(i_min, i_max, fac, rt_min, rt_max) def set_limit(self, ix, value): self.plot.set_limit(ix, value) def getLimits(self): return self.plot.get_plot_limits() def replot(self): self.plot.replot() def del_all_items(self): self.plot.del_all_items() def reset(self): """empties plot""" self.del_all_items() self.replot() def shrink_and_replot(self, rtmin, rtmax): self.reset_rt_limits(rtmin, rtmax) self.plot.reset_y_limits() self.plot.replot()
class Ui_Form(object): def __init__(self, type): self.dc = DataController() self.prc = PreProcessingControl() self.flowData = self.dc.originalData pos = self.prc.getAvailableAlgorithms().keys().index(type) self.prc.selectAlgorithm(pos) def setupUi(self, Form): Form.setObjectName(_fromUtf8("Form")) Form.resize(536, 384) self.Form=Form self.tableWidget = QtGui.QTableWidget(Form) self.tableWidget.setGeometry(QtCore.QRect(90, 261, 221, 121)) self.tableWidget.setObjectName(_fromUtf8("tableWidget")) self.tableWidget.setColumnCount(2) self.tableWidget.setRowCount(1) item = QtGui.QTableWidgetItem() self.tableWidget.setVerticalHeaderItem(0, item) item = QtGui.QTableWidgetItem() self.tableWidget.setHorizontalHeaderItem(0, item) item = QtGui.QTableWidgetItem() self.tableWidget.setHorizontalHeaderItem(1, item) item = QtGui.QTableWidgetItem() self.tableWidget.setItem(0, 0, item) item = QtGui.QTableWidgetItem() self.tableWidget.setItem(0, 1, item) self.pushButton = QtGui.QPushButton(Form) self.pushButton.setGeometry(QtCore.QRect(0, 300, 75, 23)) self.pushButton.setObjectName(_fromUtf8("pushButton")) self.widget = QtGui.QWidget(Form) self.widget.setGeometry(QtCore.QRect(10, 10, 521, 211)) self.widget.setObjectName(_fromUtf8("widget")) #self.pushButton_2 = QtGui.QPushButton(Form) #self.pushButton_2.setGeometry(QtCore.QRect(0, 330, 75, 23)) #self.pushButton_2.setObjectName(_fromUtf8("pushButton_2")) self.pushButton_3 = QtGui.QPushButton(Form) self.pushButton_3.setGeometry(QtCore.QRect(0, 360, 75, 23)) self.pushButton_3.setObjectName(_fromUtf8("pushButton_3")) #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% self.dialog = CurveDialog(edit=False, toolbar=False, parent=self.widget) self.plot = self.dialog.get_plot() self.plot.set_antialiasing(True) self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time') self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value') self.manager = PlotManager(self) self.manager.add_plot(self.plot) legend = make.legend('TL') self.plot.add_item(legend) ly = QtGui.QVBoxLayout() ly.addWidget(self.plot) self.widget.setLayout(ly) # item = QtGui.QTableWidgetItem() # self.tableWidget.setHorizontalHeaderItem(0, item) # item = QtGui.QTableWidgetItem() # self.tableWidget.setItem(0, 0, item) # item = QtGui.QTableWidgetItem() # self.tableWidget.setItem(0, 1, item) # item = self.tableWidget.horizontalHeaderItem(0) # item.setText(_translate("Form", "Attribute", None)) c = 0 for it in self.prc.getRequiredParameters(): # item = QtGui.QTableWidgetItem() # item.setText(_translate("Form", "Id" + str(c), None)) # self.tableWidget.setVerticalHeaderItem(c, item) item = QtGui.QTableWidgetItem() item.setText(it) self.tableWidget.setItem(c, 0, item) #print it, self.prc.getRequiredParameters()[it] item = QtGui.QTableWidgetItem() item.setText(str(self.prc.getRequiredParameters()[it])) self.tableWidget.setItem(c, 1, item) # print c c += 1 ####%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) self.currentdata=[] def retranslateUi(self, Form): Form.setWindowTitle(_translate("Form", "Form", None)) __sortingEnabled = self.tableWidget.isSortingEnabled() self.tableWidget.setSortingEnabled(False) self.tableWidget.setSortingEnabled(__sortingEnabled) self.pushButton.setText(_translate("Form", "Process", None)) #self.pushButton_2.setText(_translate("Form", "Load", None)) self.pushButton_3.setText(_translate("Form", "Save", None)) Form.connect(self.pushButton, QtCore.SIGNAL('clicked()'),self.process) #Form.connect(self.pushButton_2, QtCore.SIGNAL('clicked()'),self.loadDialog) Form.connect(self.pushButton_3, QtCore.SIGNAL('clicked()'),self.saveDialog) def process(self): params = {} print(self.tableWidget.rowCount()) for i in range(self.tableWidget.rowCount()): a = self.tableWidget.item(i, 0) b = self.tableWidget.item(i, 1) params[str(a.text())] = int(b.text()) # print "params",params outpN = self.tableWidget.item(0, 0) #params = {"none": "none", "output_length": outpN} ''' if self.currentdata==[]: data = self.prc.preprocData(self.flowData, params) else: data = self.prc.preprocData(self.currentdata, params) ''' #self.dc.setCurrentDataFlowObject(data) #print data if params==[]: data = self.prc.preprocData(self.flowData, params) elif params!=[]: data = self.prc.preprocData(self.flowData, params) self.plot.del_all_items() print data print type(data) self.plot.add_item(make.curve(range(0, len(data)), data)) self.rangeSelection = make.range(-2, 2) disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm", title="Range infos") #self.plot.add_item(self.rangeSelection) #self.plot.add_item(disp0) self.plot.replot() #self.dc.setCurrentDataFlowObject(data) self.dc.preprocData = data self.currentdata = np.reshape(data, (-1, 1)) #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% '''def loadDialog(self): params = {} for i in range(self.tableWidget.rowCount()): a = self.tableWidget.item(i, 0) b = self.tableWidget.item(i, 1) params[str(a.text())] = int(b.text()) # print "params",params outpN = self.tableWidget.item(0, 0) #params = {"none": "none", "output_length": outpN} filename = QtGui.QFileDialog.getOpenFileName(self.Form, 'Open File', '.') fname = open(filename) self.original_data = pandas.read_csv(str(filename), delimiter=",") self.plot.del_all_items() self.currentdata = np.array(self.original_data) #print "fileLoader self.currentdata.shape", self.currentdata.shape print type(self.currentdata) print(self.currentdata.shape) ''' def saveDialog(self): path = QtGui.QFileDialog.getSaveFileName(self.Form, 'Save File', '', 'CSV(*.csv)') if not path.isEmpty(): with open(unicode(path), 'wb') as stream: writer = csv.writer(stream) [a,b]=self.currentdata.shape print(a) print(b) for row in range(a): rowdata = [] for column in range(b): item = self.currentdata.item(row, column) if item is not None: rowdata.append(item) else: rowdata.append('') writer.writerow(rowdata)
class RealtimeDemo(QWidget): def __init__(self): super(RealtimeDemo, self).__init__() self.setWindowTitle(u"Realtime Demo") self.data = {u"t":array("d")} for name in sum(PLOT_DEFINE, []): self.data[name] = array("d") self.curves = {} self.t = 0 vbox = QVBoxLayout() vbox.addWidget(self.setup_toolbar()) self.manager = PlotManager(self) self.plots = [] for i, define in enumerate(PLOT_DEFINE): plot = CurvePlot() plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(60) self.manager.add_plot(plot) self.plots.append(plot) plot.plot_id = id(plot) for j, curve_name in enumerate(define): curve = self.curves[curve_name] = make.curve([0], [0], color=COLORS[j], title=curve_name) plot.add_item(curve) plot.add_item(make.legend("BL")) vbox.addWidget(plot) self.manager.register_standard_tools() self.manager.get_default_tool().activate() self.manager.synchronize_axis(CurvePlot.X_BOTTOM, self.manager.plots.keys()) self.setLayout(vbox) self.startTimer(100) def setup_toolbar(self): toolbar = QToolBar() self.auto_yrange_checkbox = QCheckBox(u"Y-axis auto-adjust") self.auto_xrange_checkbox = QCheckBox(u"X-axis auto-adjust") self.xrange_box = QSpinBox() self.xrange_box.setMinimum(5) self.xrange_box.setMaximum(50) self.xrange_box.setValue(10) self.auto_xrange_checkbox.setChecked(True) self.auto_yrange_checkbox.setChecked(True) toolbar.addWidget(self.auto_yrange_checkbox) toolbar.addWidget(self.auto_xrange_checkbox) toolbar.addWidget(self.xrange_box) return toolbar def timerEvent(self, event): for i in range(100): t = self.t self.data[u"t"].append(t) self.data[u"sin1f"].append(sin(t)) self.data[u"sin3f"].append(sin(3*t)/6) self.t += DT if self.auto_xrange_checkbox.isChecked(): xmax = self.data["t"][-1] xmin = max(xmax - self.xrange_box.value(), 0) else: xmin, xmax = self.plots[0].get_axis_limits('bottom') for key, curve in self.curves.items(): xdata = self.data["t"] ydata = self.data[key] x, y = get_peak_data(xdata, ydata, xmin, xmax, 600, 1/DT) curve.set_data(x, y) for plot in self.plots: if self.auto_yrange_checkbox.isChecked() and self.auto_xrange_checkbox.isChecked(): plot.do_autoscale() elif self.auto_xrange_checkbox.isChecked(): plot.set_axis_limits("bottom", xmin, xmax) plot.replot() else: plot.replot()
class Ui_PlotWidget_Reduce_Set(QtGui.QWidget): """""" def __init__(self, parent=None): """Constructor for Ui_PlotWidget""" QtGui.QWidget.__init__(self, parent) self.setupUi() def setupUi(self): """loads numpy array Args: self Returns: nothing """ #self.plot = CurvePlot(self) self.dialog = CurveDialog(edit=False, toolbar=True, parent=self) self.plot = self.dialog.get_plot() self.plot.set_antialiasing(True) #x = np.linspace(-10,10,200) #dy = x/100. #y = np.sin(np.sin(np.sin(x))) #self.plot.add_item(make.curve(x,y)) self.loadButton = QtGui.QPushButton("Load") self.trainButton = QtGui.QPushButton("Train Model") ly = QtGui.QVBoxLayout() ly.addWidget(self.plot) #ly.addWidget(self.loadButton) #ly.addWidget(self.trainButton) self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.xBottom, 'Time') self.plot.setAxisTitle(Qwt5.Qwt.QwtPlot.yLeft, 'Value') self.manager = PlotManager(self) self.manager.add_plot(self.plot) #self.manager. legend = make.legend('TL') self.plot.add_item(legend) self.setLayout(ly) self.move(300, 200) self.show() self.dataController = DataController.DataController() def loadData(self): self.trainingData = self.dataController.loadSampleData() import logic.DimensionalityReduceControl as controller c = controller.DimensionalityReduceControl() c.selectAlgorithm(2) outpN = 100 params = {"none": "none", "output_length": outpN} data = c.reduceData(self.trainingData["PIR"][:],params) print data self.plot.add_item(make.curve(range(0, len(data)), data)) self.rangeSelection = make.range(-2, 2) disp0 = make.range_info_label(self.rangeSelection, 'BR', u"x = %.1f +- %.1f cm", title="Range infos") self.plot.add_item(self.rangeSelection) self.plot.add_item(disp0) self.plot.replot() def trainData(self,string_length, vocab, window_length, clusterN): a, b = self.rangeSelection.get_range() if a > b: a, b = b, a print a, b print "in widget", int(string_length), int(vocab), int(window_length), int(clusterN) self.dataController.trainData(a,b,int(string_length), int(vocab), int(window_length), int(clusterN))
class GuiQwtPlot( QtGui.QMainWindow ): def __init__( self ): QtGui.QMainWindow.__init__( self ) self.__create_layout() self.__setup_layout() def __create_layout( self ): self.setWindowTitle( "Live *.Chi plotter, v. 2.1.0 (April 2013)" ) self.plot = CurvePlot( self ) self.plot.set_antialiasing( True ) self.plot2 = CurvePlot( self ) self.plot2.set_antialiasing( True ) self.button = QtGui.QPushButton( "Search for files" ) self.button2 = QtGui.QPushButton( "Plot selected files" ) self.button3 = QtGui.QPushButton( "Select all" ) self.button4 = QtGui.QPushButton( "Select none" ) self.button5 = QtGui.QPushButton( "Integrate" ) self.button6 = QtGui.QPushButton( "Integral over ROI (defined by the two vertical cursors)" ) left_hbox0 = QtGui.QVBoxLayout() right_hbox0 = QtGui.QVBoxLayout() # Main graph left_vbox = QtGui.QVBoxLayout() left_vbox.addWidget( self.plot, 3) # Smaller graph left_vbox.addWidget( self.plot2, 1 ) self.tick_axis_reset = QtGui.QCheckBox("Reset axis when replotting data") self.tick_axis_reset.setCheckState(Qt.Checked) left_hbox0.addWidget( self.tick_axis_reset ) # Static text field right_hbox0.addWidget( QtGui.QLabel('Directory'), 0, QtCore.Qt.AlignRight ) hbox0 = QtGui.QHBoxLayout() hbox0.addLayout( left_hbox0 ) hbox0.addLayout( right_hbox0 ) left_vbox.addLayout( hbox0 ) # Add buttons to the left side left_vbox.addWidget( self.button ) left_vbox.addWidget( self.button2 ) left_vbox.addWidget( self.button6 ) # Data series list view log_label = QtGui.QLabel("Data series:") self.series_list_model = QtGui.QStandardItemModel() self.series_list_view = QtGui.QListView() self.series_list_view.setModel(self.series_list_model) right_vbox = QtGui.QVBoxLayout() right_vbox.addWidget( log_label ) right_vbox.addWidget( self.series_list_view ) # Create editable text box for inputting directory self.text1 = QtGui.QTextEdit() self.text1.setFixedHeight(22) # Put current directory to the text box self.text1.setText(os.getcwd()) right_vbox.addWidget( self.text1 ) # Add buttons right_vbox.addWidget( self.button3 ) right_vbox.addWidget( self.button4 ) right_vbox.addWidget( self.button5 ) # Combine left and right box hbox = QtGui.QHBoxLayout() hbox.addLayout( left_vbox, 2 ) # Second parameter is the stretch factor hbox.addLayout( right_vbox, 1 ) # of the widget, letting the figure to stretch more w = QtGui.QWidget() w.setLayout( hbox ) self.setCentralWidget( w ) def __setup_layout( self ): self.connect( self.button, QtCore.SIGNAL( 'clicked()' ), self.button_Click ) self.connect( self.button2, QtCore.SIGNAL( 'clicked()' ), self.button_Click2 ) self.connect( self.button3, QtCore.SIGNAL( 'clicked()' ), self.button_Click3 ) self.connect( self.button4, QtCore.SIGNAL( 'clicked()' ), self.button_Click4 ) self.connect( self.button5, QtCore.SIGNAL( 'clicked()' ), self.button_Click5 ) self.connect( self.button6, QtCore.SIGNAL( 'clicked()' ), self.button_Click6 ) # Vertical cursor self.cursorposition = 0.8 self.cursorposition2 = 1.2 self.vcursor1 = make.vcursor(self.cursorposition, label='x = %.2f') self.plot.add_item( self.vcursor1 ) self.vcursor2 = make.vcursor(self.cursorposition2, label='x = %.2f') self.plot.add_item( self.vcursor2 ) # Define the y label, x might change depending on user definition CurvePlot.set_axis_title(self.plot,CurvePlot.Y_LEFT,"Intensity (counts)") # Crate the PlotManager self.manager = PlotManager( self ) self.manager.add_plot( self.plot ) self.manager.add_plot( self.plot2 ) # Create Toolbar toolbar = self.addToolBar( 'tools' ) self.manager.add_toolbar( toolbar, id( toolbar ) ) # Register the ToolBar's type self.manager.register_all_curve_tools( ) # self.manager.register_other_tools() # Register a custom tool self.manager.add_tool( SelectPointTool, title = 'Position', on_active_item = True, mode = 'create' ) def fill_series_list(self, names): self.series_list_model.clear() counterlist = 0 for name in reversed(names): item = QtGui.QStandardItem(name) # if counterlist == 0: # Check only the first one # item.setCheckState(Qt.Checked) # else: item.setCheckState(Qt.Unchecked) item.setCheckable(True) self.series_list_model.appendRow(item) counterlist = counterlist + 1 # Load data to the list def button_Click( self ): # Find the newest files in the directory and subdirectories # and populate the list of files self.y = {} self.x = {} self.timestamp = {} self.names = [] self.fullfilename = {} # Clear the list in case used another directory before self.series_list_model.clear() # Go to the directory specified in the field or if none, give error message curdir = str(self.text1.toPlainText()) if os.path.isdir(curdir): os.chdir(curdir) else: print curdir+" is not a valid directory!" # Find the files in the directory counterfiles = 0 for dirpath, dirnames, filenames in os.walk(os.getcwd()): filenames.sort(key=lambda x: os.path.getmtime(dirpath+'/'+x)) for file1 in filenames: prefix,postfix = os.path.splitext(file1) # Only *.chi files ending with a number are accepted if len(re.findall("[\d]"+".chi",file1))>0: fullfilename1 = dirpath+'/'+file1 time1 = os.path.getmtime(fullfilename1) tmp,subpath = os.path.split(dirpath) tmp,subpath2 = os.path.split(tmp) seriesname1 = os.path.basename(str(subpath2+'_'+subpath+'_'+file1)) self.names.append(seriesname1) # Load data tmp = np.genfromtxt(str(fullfilename1),dtype=None,skip_header=4) self.y[seriesname1] = map(float, np.transpose(tmp[:,1])) self.x[seriesname1] = map(float, np.transpose(tmp[:,0])) self.datalen = len(self.x[seriesname1]) self.timestamp[seriesname1] = time1 self.fullfilename[seriesname1] = fullfilename1 counterfiles = counterfiles + 1 # Populate the checkbox list self.fill_series_list(self.names) #Refresh the figure def button_Click2( self ): # has_series = False # Seed for random generator of colors, so that they are always in the same order random.seed(654321) colorlistred = [220, 255, 155, 24, 0, 0, 48, 205, 255, 255, 0, 142] colorlistgreen = [20, 105, 48, 116, 229, 238, 128, 205, 193, 97, 0, 142] colorlistblue = [60, 180, 255, 205, 238, 118, 20, 0, 37, 3, 0, 142] # Clear the plot first self.plot.del_all_items() # Add back the vertical cursor to the plot in the same position as before self.plot.add_item( self.vcursor1 ) self.plot.add_item( self.vcursor2 ) # For axes take max of 2theta and max of intensity maxtth = 0 maxintensity = 0 mintth = 100 minintensity = 100 # Use first predefined colours, then random colorcounter = 0 # Two simple markers to test if mixed x ranges exist foundq = 0 foundtth = 0 for row in range(self.series_list_model.rowCount()): model_index = self.series_list_model.index(row, 0) checked = self.series_list_model.data(model_index, Qt.CheckStateRole) == QVariant(Qt.Checked) name = str(self.series_list_model.data(model_index).toString()) if checked: # has_series = True self.curveAlabel = name if len(colorlistred) > colorcounter: self.curveA = make.curve( [ ], [ ], self.curveAlabel, QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ), linewidth=3.0) colorcounter = colorcounter + 1 else: self.curveA = make.curve( [ ], [ ], self.curveAlabel, QtGui.QColor( random.randint(0,255), random.randint(0,255), random.randint(0,255) ), linewidth=3.0) self.plot.add_item( self.curveA ) self.curveA.set_data( self.x[name], self.y[name]) if max(self.x[name])>maxtth: maxtth = max(self.x[name]) if max(self.y[name])>maxintensity: maxintensity = max(self.y[name]) if min(self.x[name])<mintth: mintth = min(self.x[name]) if min(self.y[name])<minintensity and min(self.y[name]) > 0: minintensity = min(self.y[name]) # Check if TTH or Q range, redefine x label if Q f = open(str(self.fullfilename[name])) text1 = f.read() f.close() if 'Azimuth (Degrees)' in text1: foundtth = 1 CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"Azimuth angle (degrees)") elif 'Q' in text1: foundq = 1 CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"q (1/nm)") elif '2-Theta Angle (Degrees)' in text1: foundtth = 1 CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"2-theta (degrees)") if foundq == 1 and foundtth == 1: CurvePlot.set_axis_title(self.plot,CurvePlot.X_BOTTOM,"Mixed! q (1/nm) and 2-theta (degrees)") self.legend = make.legend( 'TR' ) # Top Right self.plot.add_item( self.legend ) # Reset axis if checkbox is checked, otherwise ignore if self.tick_axis_reset.isChecked()==True: CurvePlot.set_axis_limits(self.plot,CurvePlot.X_BOTTOM,mintth*0.9,maxtth*1.1) CurvePlot.set_axis_limits(self.plot,CurvePlot.Y_LEFT,minintensity*0.9,maxintensity*1.1) # Plot everything self.plot.replot( ) # Refresh also the integral plot self.button_Click6( ) # Select all def button_Click3( self ): for k in range(0,len(self.names)): self.series_list_model.item(k).setCheckState( Qt.Checked ) # Select none def button_Click4( self ): for k in range(0,len(self.names)): self.series_list_model.item(k).setCheckState( Qt.Unchecked ) # Download and integrate button def button_Click5( self ): curdir = str(self.text1.toPlainText()) execfile(curdir+"/setup/pipeline.py") # Update file list after integrating self.button_Click( ) # Sum over ROI and update the lower graph def button_Click6( self ): # Clear the plot first self.plot2.del_all_items() # Seed for random generator of colors, so that they are always in the same order random.seed(654321) colorlistred = [220, 255, 155, 24, 0, 0, 48, 205, 255, 255, 0, 142] colorlistgreen = [20, 105, 48, 116, 229, 238, 128, 205, 193, 97, 0, 142] colorlistblue = [60, 180, 255, 205, 238, 118, 20, 0, 37, 3, 0, 142] markerlist = ['Rect','Diamond', 'UTriangle', 'DTriangle', 'RTriangle','Cross', 'Ellipse', 'Star1', 'XCross', 'LTriangle', 'Star2'] # Get cursor positions to define ROI x1 = guiqwt.shapes.Marker.xValue(self.vcursor1) x2 = guiqwt.shapes.Marker.xValue(self.vcursor2) if x2 < x1: x3 = copy.deepcopy(x1) x1 = copy.deepcopy(x2) x2 = x3 indices = [] self.sumy = {} self.sumx = {} # Use first predefined colours, then random colorcounter = 0 maxsumx = 0 minsumx = 10000 maxsumy = 0 minsumy = 10000000 self.sumxall = {} self.sumyall = {} seriesnames = [] for row in range(self.series_list_model.rowCount()): model_index = self.series_list_model.index(row, 0) checked = self.series_list_model.data(model_index, Qt.CheckStateRole) == QVariant(Qt.Checked) name = str(self.series_list_model.data(model_index).toString()) if checked: # Find x values over which to sum indices = [] for index,value in enumerate(self.x[name]): if value > x1 and value < x2: indices.append(index) xx = np.array(self.x[name]) yy = np.array(self.y[name]) sumy1 = np.trapz(yy[indices],xx[indices]) self.sumy[name] = [float(sumy1)] number1 = re.findall("(?<=_|-)[\d]*(?=.chi)",name) sumx1 = int(number1[0]) self.sumx[name] = [float(sumx1)] if max(self.sumx[name])>maxsumx: maxsumx = max(self.sumx[name]) if max(self.sumy[name])>maxsumy: maxsumy = max(self.sumy[name]) if min(self.sumx[name])<minsumx: minsumx = min(self.sumx[name]) if min(self.sumy[name])<minsumy and min(self.sumy[name]) > 0: minsumy = min(self.sumy[name]) # Check which series names we have name1 = re.findall("[\W\S\d]*(?=-[\d]{5}.chi)",name) # Try different versions of writing the names if first one does not succeed if name1 == []: name1 = re.findall("[\W\S\d]*(?=_[\d]{4}.chi)",name) if name1 == []: name1 = re.findall("[\W\S\d]*(?=_[\d]{5}.chi)",name) seriesname1 = str(name1[0]) if seriesname1 not in seriesnames: seriesnames.append(seriesname1) self.sumxall[seriesname1] = [] self.sumyall[seriesname1] = [] self.sumxall[seriesname1].append(sumx1) self.sumyall[seriesname1].append(sumy1) # Make lines and legends to separate different sample series colorcounter = 0 random.seed(654321) markercounter = 0 for seriesname1 in seriesnames: if len(colorlistred) > colorcounter: self.curveB = make.curve( [ ], [ ], seriesname1, QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ), linewidth=3.0, marker=markerlist[markercounter], markerfacecolor = QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] ), markeredgecolor= QtGui.QColor( colorlistred[colorcounter], colorlistgreen[colorcounter], colorlistblue[colorcounter] )) colorcounter = colorcounter + 1 markercounter = markercounter + 1 else: newcolor = QtGui.QColor( random.randint(0,255), random.randint(0,255), random.randint(0,255)) self.curveB = make.curve( [ ], [ ], seriesname1, newcolor, linewidth=3.0, marker=markerlist[markercounter], markerfacecolor = newcolor, markeredgecolor = newcolor ) markercounter = markercounter + 1 if markercounter > len(markerlist): markercounter = 0 self.plot2.add_item( self.curveB ) self.curveB.set_data( self.sumxall[seriesname1],self.sumyall[seriesname1] ) CurvePlot.set_axis_title(self.plot2,CurvePlot.X_BOTTOM,"File number") CurvePlot.set_axis_title(self.plot2,CurvePlot.Y_LEFT,"ROI sum") self.legend2 = make.legend( 'TR' ) # Top Right self.plot2.add_item( self.legend2 ) # Reset axis if ticked if self.tick_axis_reset.isChecked()==True: CurvePlot.set_axis_limits(self.plot2,CurvePlot.X_BOTTOM,minsumx*0.9,maxsumx*1.1) CurvePlot.set_axis_limits(self.plot2,CurvePlot.Y_LEFT,minsumy*0.9,maxsumy*1.1) # Plot everything self.plot2.replot( )
class MzPlottingWidget(CurveWidget): def __init__(self, parent=None): super(MzPlottingWidget, self).__init__(parent, xlabel="mz", ylabel="I") patch_inner_plot_object(self, MzPlot) self.plot.centralMz = None def label(self, x): # label with full precision: return QwtText(str(x)) a = QwtScaleDraw() a.label = new.instancemethod(label, self.plot, QwtScaleDraw) self.plot.setAxisScaleDraw(self.plot.xBottom, a) self.pm = PlotManager(self) self.pm.add_plot(self.plot) self.curve = make_unselectable_curve([], [], color="b", curvestyle="Sticks") self.plot.add_item(self.curve) t = self.pm.add_tool(MzSelectionTool) self.pm.set_default_tool(t) t.activate() marker = Marker(label_cb=self.plot.label_info, constraint_cb=self.plot.on_plot) marker.attach(self.plot) line = make_measurement_line() line.setVisible(0) setupCommonStyle(line, marker) line.shapeparam.line.color = "#555555" line.shapeparam.update_shape(line) label = make.info_label("TR", [MzCursorInfo(marker, line)], title=None) label.labelparam.label = "" label.labelparam.font.size = 12 label.labelparam.update_label(label) self.marker = marker self.label = label self.line = line def plot_spectra(self, all_peaks, labels): self.plot.del_all_items() self.plot.add_item(self.marker) self.plot.add_item(make.legend("TL")) self.plot.add_item(self.label) for i, (peaks, label) in enumerate(zip(all_peaks, labels)): config = dict(color=getColor(i)) curve = make_unselectable_curve([], [], title=label, curvestyle="Sticks", **config) curve.set_data(peaks[:, 0], peaks[:, 1]) self.plot.add_item(curve) self.plot.resample_config = [] self.plot.add_item(self.line) if len(all_peaks): self.plot.all_peaks = np.vstack(all_peaks) else: self.plot.all_peaks = np.zeros((0, 2)) def _setup_configs_and_titles(self, configs, titles, n): configs = configs if configs is not None else [None] * n titles = titles if titles is not None else [""] * n def default(i): return dict(color=getColor(i)) configs = [ ci if ci is not None else default(i) for (i, ci) in enumerate(configs) ] return configs, titles def set_overall_range(self, mzmin, mzmax): self.plot.overall_x_min = mzmin self.plot.overall_x_max = mzmax def plot_peakmaps(self, peakmap_ranges, configs=None, titles=None): has_titles = titles is not None configs, titles = self._setup_configs_and_titles( configs, titles, len(peakmap_ranges)) self.plot.del_all_items() self.plot.add_item(self.marker) if has_titles: self.plot.add_item(make.legend("TL")) self.plot.add_item(self.label) self.plot.plot_peakmap_ranges(peakmap_ranges, configs, titles) self.plot.add_item(self.line) def set_cursor_pos(self, mz): self.plot.set_mz(mz) def resetAxes(self): self.plot.reset_x_limits() def reset_mz_limits(self, xmin=None, xmax=None, fac=1.1): self.plot.reset_x_limits(xmin, xmax, fac) def reset(self): self.plot.del_all_items() self.replot() def replot(self): self.plot.replot() def set_visible(self, visible): self.plot.setVisible(visible) def updateAxes(self): self.plot.updateAxes() def shrink_and_replot(self, mzmin, mzmax): self.reset_mz_limits(mzmin, mzmax) self.plot.reset_y_limits() self.plot.replot()
class UI(QtGui.QMainWindow): def __init__(self, parent=None): super(UI, self).__init__(parent) self.ui_obj = None self.y_position = 0 self.slider_pos = 0 self.image_temp = None self.image_w = 0 self.image_h = 0 self.image_path = None self.ui_init() self.init_connect() self.plot_init() def ui_init(self): self.ui_obj = Ui_MainWindow() self.ui_obj.setupUi(self) def init_connect(self): self.connect(self.ui_obj.y_verticalSlider, QtCore.SIGNAL('valueChanged(int)'), self.plot_line_gray) self.ui_obj.open_image_button.clicked.connect(self.open_image) self.ui_obj.save_plot_button.clicked.connect(self.save_image) def open_image(self): self.file_name = QtGui.QFileDialog.getOpenFileName( self, "open file dialog", "C:\Users\Administrator\Desktop", "*.jpg *.png") print self.file_name if self.file_name != "": # if self.ui_obj.image_path_lineEdit.text() != "": # self.image_path = self.ui_obj.image_path_lineEdit.text() self.image_path = self.file_name if os.path.exists(self.image_path): self.display_image() else: # self.image_clean() print "path is not exists!!\n" else: # self.image_clean() print "pls fill imagepath\n" def save_image(self): pass def image_clean(self): self.image_temp = None self.image_w = 0 self.image_h = 0 def display_image(self): # print "cv2 imread path :"+str(self.image_path) self.image_temp = cv2.imread(str(self.image_path)) self.image_h = len(self.image_temp) self.image_w = len(self.image_temp[0]) # #print image.shape[1],image.shape[0] # #print self.ui_obj.picture_display.width(),self.ui_obj.picture_display.height() # qimage = QtGui.QImage(image, image.shape[1], image.shape[0], QtGui.QImage.Format_RGB888) # qimage_resize = qimage.scaled(self.ui_obj.picture_display.width(), self.ui_obj.picture_display.height(), 0, 0) # self.ui_obj.picture_display.setPixmap(QtGui.QPixmap.fromImage(qimage_resize)) # self.ui_obj.picture_display.show() pixmap = QtGui.QPixmap() pixmap.load(str(self.image_path)) newpixmap = pixmap.scaled(self.ui_obj.picture_display.width(), self.ui_obj.picture_display.height(), 0, 0) self.ui_obj.picture_display.setPixmap(newpixmap) self.ui_obj.picture_display.setAlignment(QtCore.Qt.AlignCenter) self.ui_obj.picture_display.show() def plot_init(self): self.manager = PlotManager(self) self.plots = [] self.plot = CurvePlot(xlabel="", ylabel="") # self.plot.axisScaleDraw(CurvePlot.Y_LEFT).setMinimumExtent(10) self.manager.add_plot(self.plot) self.plots.append(self.plot) self.plot.plot_id = id(self.plot) self.curve = make.curve([0], [0], color="blue", title="gray value") self.plot.add_item(self.curve) self.plot.add_item(make.legend("TR")) self.ui_obj.line_info_display.addWidget(self.plot) def plot_line_gray(self): self.slider_pos = self.ui_obj.y_verticalSlider.value() # print"print line ",self.slider_pos # print type(self.slider_pos), len(self.image_temp) self.y_position = (100 - self.slider_pos) * (int(self.image_h) / 100) print "y_position:", self.y_position line = [ self.image_temp[self.y_position][i][1] for i in range(len(self.image_temp[self.y_position])) ] print len(line), [i for i in range(len(line))] self.plot.set_axis_limits('left', 0, 255) self.plot.set_axis_limits('bottom', 0, self.image_w) self.curve.set_data([i for i in range(len(line))], line) self.plot.replot() # print "image :", self.image_temp[3] def blur(self, kernel): pass def nosie(self, method): pass
class RtPlotter(PlotterBase): def __init__(self, rangeSelectionCallback=None): super(RtPlotter, self).__init__("RT", "I") self.rangeSelectionCallback = rangeSelectionCallback widget = self.widget widget.plot.__class__ = RtPlot # todo: refactor as helper a = QwtScaleDraw() # render tic labels in modfied format: label = lambda self, v: QwtText(formatSeconds(v)) a.label = new.instancemethod(label, widget.plot, QwtScaleDraw) widget.plot.setAxisScaleDraw(widget.plot.xBottom, a) self.pm = PlotManager(widget) self.pm.add_plot(widget.plot) t = self.pm.add_tool(RtSelectionTool) self.addTool(RtSelectionTool) self.pm.set_default_tool(t) marker = Marker(label_cb=self.widget.plot.label_info, constraint_cb=self.widget.plot.on_plot) marker.rts = [0] setupStyleRtMarker(marker) marker.attach(self.widget.plot) self.marker = marker label = make.info_label("T", [RtCursorInfo(marker)], title=None) label.labelparam.label = "" self.label = label self.minRTRangeSelected = None self.maxRTRangeSelected = None def addTool(self, tool): t = self.pm.add_tool(tool) t.activate() def reset(self): self.plot([]) self.marker.rts = [0] self.replot() def plot(self, chromatograms, titles=None, configs=None, withmarker=False): """ do not forget to call replot() after calling this function ! """ allrts = set() self.widget.plot.del_all_items() # self.widget.plot.set_antialiasing(True) for i in range(len(chromatograms)): rts, chromatogram = chromatograms[i] config = None if configs is not None: config = configs[i] if config is None: config = dict(color=getColor(i)) if titles: title = titles[i] else: title = "" curve = make.curve(rts, chromatogram, title=title, **config) curve.__class__ = ModifiedCurveItem allrts.update(rts) self.widget.plot.add_item(curve) if withmarker: self.widget.plot.add_item(self.label) allrts = sorted(allrts) self.marker.rts = allrts self.marker.attach(self.widget.plot) self.widget.plot.add_item(self.marker) if titles is not None: self.widget.plot.add_item(make.legend("TL")) self.addRangeSelector(allrts) def setEnabled(self, enabled): self.widget.plot.setVisible(enabled) def addRangeSelector(self, rtvalues): self.rtvalues = rtvalues self.minRTRangeSelected = 0 self.maxRTRangeSelected = 0 range_ = SnappingRangeSelection(self.minRTRangeSelected, self.maxRTRangeSelected, self.rtvalues) setupStyleRangeMarker(range_) self.range_ = range_ # you have to register item to plot before you can register the # rtSelectionHandler: self.widget.plot.add_item(range_) self.widget.disconnect(range_.plot(), SIG_RANGE_CHANGED, self.rangeSelectionHandler) self.widget.connect(range_.plot(), SIG_RANGE_CHANGED, self.rangeSelectionHandler) cc = make.info_label("TR", [RtRangeSelectionInfo(range_)], title=None) cc.labelparam.label = "" self.widget.plot.add_item(cc) def getRangeSelectionLimits(self): return sorted((self.range_._min, self.range_._max)) def setRangeSelectionLimits(self, xleft, xright): saved = self.rangeSelectionCallback self.rangeSelectionCallback = None self.minRTRangeSelected = xleft self.maxRTRangeSelected = xright # left and right bar of range marker self.range_.move_point_to(0, (xleft, 0), emitsignal=False) self.range_.move_point_to(1, (xright, 0)) # calls self.rangeSelectionHandler ! self.rangeSelectionCallback = saved @protect_signal_handler def rangeSelectionHandler(self, obj, left, right): min_, max_ = sorted((left, right)) self.minRTRangeSelected = min_ self.maxRTRangeSelected = max_ if self.rangeSelectionCallback is not None: self.rangeSelectionCallback()