#/*########################################################################## # # The PyMca X-Ray Fluorescence Toolkit # # Copyright (c) 2004-2014 European Synchrotron Radiation Facility # # This file is part of the PyMca X-ray Fluorescence Toolkit developed at # the ESRF by the Software group. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # #############################################################################*/ __author__ = "V.A. Sole - ESRF Data Analysis" __contact__ = "sole@esrf.fr" __license__ = "MIT" __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France" __doc__ = """ This module implements a PyQtGraph plotting backend. """ import sys import time if ("pyqtgraph" not in sys.modules): import pyqtgraph as pg pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') pg.setConfigOption('leftButtonPan', False) else: import pyqtgraph as pg from pyqtgraph.Qt import QtCore, QtGui from .. import PlotBackend _USE_ORIGINAL = False DEBUG = 0 class CustomViewBox(pg.ViewBox): def __init__(self, *args, **kwds): pg.ViewBox.__init__(self, *args, **kwds) self.setMouseMode(self.RectMode) ## reimplement right-click to zoom out def mouseClickEvent(self, ev): if ev.button() == QtCore.Qt.RightButton: if len(self.axHistory) > 1: del self.axHistory[-1] self.setRange(self.axHistory[-1]) ev.accept() else: self.autoRange() def mouseDragEvent(self, ev): if ev.button() == QtCore.Qt.RightButton: ev.ignore() else: pg.ViewBox.mouseDragEvent(self, ev) def autoRange(self): """ Adjust scales and reset the zoom stack """ self.axHistory = [] pg.ViewBox.autoRange(self) class InfiniteLine(pg.InfiniteLine): def mouseClickEvent(self, ev): if ev.button() == QtCore.Qt.LeftButton: if hasattr(self, "_plot_options"): if "selectable" in self._plot_options: ev.accept() self.moving = False self.sigPositionChangeFinished.emit(self) return pg.InfiniteLine.mouseClickEvent(self, ev) def mouseDragEvent(self, ev): if hasattr(self, "_plot_options"): if "selectable" in self._plot_options: ev.ignore() return pg.InfiniteLine.mouseDragEvent(self, ev) def setMouseHover(self, hover): if hasattr(self, "_plot_options"): if "selectable" in self._plot_options: if hover != self.mouseHovering: if hover: self._oldCursorShape = self.cursor().shape() self.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor)) else: self.setCursor(QtGui.QCursor(self._oldCursorShape)) elif "draggable" in self._plot_options: oldShape = self.cursor().shape() if oldShape not in [QtCore.Qt.SizeHorCursor, QtCore.Qt.SizeVerCursor, QtCore.Qt.PointingHandCursor, QtCore.Qt.OpenHandCursor, QtCore.Qt.SizeAllCursor]: self._originalCursorShape = oldShape if hover: oldShape = self.cursor().shape() if 'xmarker' in self._plot_options: shape = QtCore.Qt.SizeHorCursor elif 'ymarker' in self._plot_options: shape = QtCore.Qt.SizeVerCursor else: shape = QtCore.Qt.OpenHandCursor if oldShape != shape: self.setCursor(QtGui.QCursor(shape)) else: self.setCursor(QtGui.QCursor(self._originalCursorShape)) pg.InfiniteLine.setMouseHover(self, hover) class PlotCurveItem(pg.PlotCurveItem): def mouseClickEvent(self, ev): if not self.clickable or ev.button() == QtCore.Qt.MiddleButton: return ev.accept() if ev.button() == QtCore.Qt.RightButton: button = "right" else: button = "left" ddict = {} if ev.double(): ddict["event"] = "curveDoubleClicked" else: ddict["event"] = "curveClicked" ddict["type"] = "curve" ddict["button"] = button #print dir(ev) pos = ev.pos() ddict["x"] = pos.x() ddict["y"] = pos.y() pos = ev.screenPos() #pos = ev.scenePos() ddict["xpixel"] = pos.x() ddict["ypixel"] = pos.y() ddict["item"] = self ev.accept() self.sigClicked.emit(ddict) def hoverEvent(self, ev): if not ev.isExit(): oldShape = self.cursor().shape() if oldShape not in [QtCore.Qt.SizeHorCursor, QtCore.Qt.SizeVerCursor, QtCore.Qt.PointingHandCursor, QtCore.Qt.OpenHandCursor, QtCore.Qt.SizeAllCursor]: self._originalCursorShape = oldShape self.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor)) else: if self._originalCursorShape in [QtCore.Qt.SizeHorCursor, QtCore.Qt.SizeVerCursor, QtCore.Qt.PointingHandCursor, QtCore.Qt.OpenHandCursor, QtCore.Qt.SizeAllCursor]: #arrow as default self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor)) else: self.setCursor(QtGui.QCursor(self._originalCursorShape)) class ScatterPlotItem(pg.ScatterPlotItem): def mouseClickEvent(self, ev): if ev.button() == QtCore.Qt.MiddleButton: ev.ignore() return if ev.button() == QtCore.Qt.RightButton: button = "right" else: button = "left" if ev.button() == QtCore.Qt.LeftButton: pts = self.pointsAt(ev.pos()) if len(pts) > 0: self.ptsClicked = pts ev.accept() ddict = {} if ev.double(): ddict["event"] = "curveDoubleClicked" else: ddict["event"] = "curveClicked" #ddict["type"] = "scatterCurve" ddict["type"] = "scatter" ddict["button"] = button pos = ev.pos() ddict["x"] = pos.x() ddict["y"] = pos.y() pos = ev.screenPos() #pos = ev.scenePos() ddict["xpixel"] = pos.x() ddict["ypixel"] = pos.y() ddict["item"] = self ddict["xdata"] = [a.pos().x() for a in self.ptsClicked] ddict["ydata"] = [a.pos().y() for a in self.ptsClicked] self.sigClicked.emit(self, ddict) else: # should one ignore the event or say the number of points is 0? if DEBUG: print("no spots") ev.ignore() else: ev.ignore() def hoverEvent(self, ev): if not ev.isExit(): oldShape = self.cursor().shape() if oldShape not in [QtCore.Qt.SizeHorCursor, QtCore.Qt.SizeVerCursor, QtCore.Qt.PointingHandCursor, QtCore.Qt.OpenHandCursor, QtCore.Qt.SizeAllCursor]: self._originalCursorShape = oldShape self.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor)) else: if self._originalCursorShape in [QtCore.Qt.SizeHorCursor, QtCore.Qt.SizeVerCursor, QtCore.Qt.PointingHandCursor, QtCore.Qt.OpenHandCursor, QtCore.Qt.SizeAllCursor]: #arrow as default self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor)) else: self.setCursor(QtGui.QCursor(self._originalCursorShape)) class PlotDataItem(pg.PlotDataItem): def __init__(self, *args, **kargs): pg.PlotDataItem.__init__(self, *args, **kargs) # this prevents hover events on the children #self.setFlag(self.ItemHasNoContents) self.curve.sigClicked.disconnect() self.scatter.sigClicked.disconnect() #self.removeItem(self.curve) #self.removeItem(self.scatter) self.clear() #this restores hover events but it does not work as well as expected #and leaves the mouse always changed #self.setFiltersChildEvents(True) self.curve = PlotCurveItem() self.scatter = ScatterPlotItem() self.curve.setParentItem(self) self.scatter.setParentItem(self) self.curve.sigClicked.connect(self.curveClicked) self.scatter.sigClicked.connect(self.scatterClicked) if len(args): self.setData(*args, **kargs) def curveClicked(self, ddict=None): if self._plot_info['linewidth'] > 0: ddict["item"] = self self.sigClicked.emit(ddict) elif DEBUG: print("Ignoring due to linewidth") def scatterClicked(self, curve, ddict): ddict["item"] = self self.sigClicked.emit(ddict) class PyQtGraphBackend(PlotBackend.PlotBackend, pg.PlotWidget): def __init__(self, parent=None, enableMenu=False, **kw): if 'viewBox' in kw: vb = kw['viewBox'] del kw['viewBox'] else: vb = CustomViewBox() pg.PlotWidget.__init__(self, parent, viewBox=vb, enableMenu=enableMenu, **kw) PlotBackend.PlotBackend.__init__(self, parent) self.setMouseTracking(True) #the default was 2 when first testing self.scene().setClickRadius(2) # this only sends the position in pixel coordenates self.scene().sigMouseMoved.connect(self._mouseMoved) # this sends a mouse event self.scene().sigMouseClicked.connect(self._mouseClicked) self.__lastMouseClick = ["middle", time.time()] self._oldActiveCurve = None self._oldActiveCurveLegend = None self._logX = False self._logY = False self._imageItem = None if 0: import numpy x = numpy.arange(10000*200.) x.shape = 200, 10000 self.invertY(True) self._imageItem = pg.ImageItem(image=x) self._imageItem.setZValue(0) #self._imageItem.setCompositionMode(QtGui.QPainter.CompositionMode_Multiply) self.addItem(self._imageItem) def _mouseMoved(self, pos): if self.sceneBoundingRect().contains(pos): mousePoint = self.getViewBox().mapSceneToView(pos) x = mousePoint.x() y = mousePoint.y() ddict = {} ddict["event"] = "mouseMoved" ddict['x'] = x ddict['y'] = y ddict["xpixel"] = pos.x() ddict["ypixel"] = pos.y() self._callback(ddict) def _mouseClicked(self, ev): if ev.button() == QtCore.Qt.RightButton: button = "right" elif ev.button() == QtCore.Qt.LeftButton: button = "left" else: return ddict = {} if (button == self.__lastMouseClick[0]) and\ ((time.time() - self.__lastMouseClick[1]) < 0.6): ddict['event'] = "mouseDoubleCliked" else: ddict['event'] = "mouseClicked" self.__lastMouseClick = [button, time.time()] ddict["type"] = "scene" ddict["button"] = button #print dir(ev) pos = ev.pos() ddict["x"] = pos.x() ddict["y"] = pos.y() pos = ev.screenPos() #pos = ev.scenePos() ddict["xpixel"] = pos.x() ddict["ypixel"] = pos.y() self._callback(ddict) def setCallback(self, ffunction): #self.getViewBox().setCallback(ffunction) PlotBackend.PlotBackend.setCallback(self, ffunction) def addCurve(self, x, y, legend=None, info=None, replace=False, replot=True, color=None, symbol=None, linestyle=None, xlabel=None, ylabel=None, yaxis=None, xerror=None, yerror=None, **kw): if legend is None: legend = "Unnamed curve" self.removeCurve(legend, replot=False) if color is None: color = '#000000' brush = color if linestyle is None: style = '-' else: style = linestyle linewidth = 1 if hasattr(x, "shape"): if len(x.shape) == 2: if x.shape[1] == 1: x = x.reshape(-1) if hasattr(y, "shape"): if len(y.shape) == 2: if y.shape[1] == 1: y = y.reshape(-1) """ Better control instantiating a curve item and a scatter item because mouse coordenates are not emitted and right click is not handled. """ if style in [None, " "]: #pen = QtCore.Qt.NoPen pen = QtGui.QPen(QtCore.Qt.NoPen) linewidth = 0 elif style == "--": pen = QtGui.QPen(QtCore.Qt.DashLine) pen.setColor(QtGui.QColor(color)) #pen.setWidth(linewidth) elif style in ["-.", ".-"]: pen = QtGui.QPen(QtCore.Qt.DashDotLine) pen.setColor(QtGui.QColor(color)) #pen.setWidth(linewidth) elif style in ["-..", "..-"]: pen = QtGui.QPen(QtCore.Qt.DashDotDotLine) pen.setColor(QtGui.QColor(color)) #pen.setWidth(linewidth) elif style in ["..", ":"]: pen = QtGui.QPen(QtCore.Qt.DotLine) pen.setColor(QtGui.QColor(color)) #pen.setWidth(linewidth) else: pen = QtGui.QPen(QtCore.Qt.SolidLine) pen.setColor(QtGui.QColor(color)) #pen.setWidth(linewidth) if symbol in [None, '']: actualSymbol = None else: actualSymbol = symbol if _USE_ORIGINAL: item = self.plot(x, y, title=legend, pen=pen, symbol=actualSymbol, #symbolPen=color, shadowPen=None, symbolBrush=color, clickable=True) else: item = PlotDataItem() item.setData(x, y, title=legend, pen=pen, symbol=actualSymbol, #symbolPen=color, shadowPen=None, symbolBrush=color, clickable=True) self.addItem(item) if style in [None, " "]: item.curve.clickable = False item.curve.setAcceptHoverEvents(False) else: item.curve.clickable = True item.curve.setAcceptHoverEvents(True) if symbol is None: item.scatter.setAcceptHoverEvents(False) else: item.scatter.setAcceptHoverEvents(True) item._plot_info = {'color':color, 'linewidth':linewidth, 'brush':brush, 'style':style, 'symbol':symbol, 'label':legend, 'type':'curve'} item.setZValue(10) item.sigClicked.connect(self._curveClicked) #both work, perhaps legend is safer? #return legend return item def addImage(self, data, legend=None, info=None, replace=True, replot=True, xScale=None, yScale=None, z=0, selectable=False, draggable=False, colormap=None, **kw): """ :param data: (nrows, ncolumns) data or (nrows, ncolumns, RGBA) ubyte array :type data: numpy.ndarray :param legend: The legend to be associated to the curve :type legend: string or None :param info: Dictionary of information associated to the image :type info: dict or None :param replace: Flag to indicate if already existing images are to be deleted :type replace: boolean default True :param replot: Flag to indicate plot is to be immediately updated :type replot: boolean default True :param xScale: Two floats defining the x scale :type xScale: list or numpy.ndarray :param yScale: Two floats defining the y scale :type yScale: list or numpy.ndarray :param z: level at which the image is to be located (to allow overlays). :type z: A number bigger than or equal to zero (default) :param selectable: Flag to indicate if the image can be selected :type selectable: boolean, default False :param draggable: Flag to indicate if the image can be moved :type draggable: boolean, default False :param colormap: Dictionary describing the colormap to use (or None) :type colormap: Dictionnary or None (default). Ignored if data is RGB(A) :returns: The legend/handle used by the backend to univocally access it. """ self.removeImage(legend, replot=False) item = pg.ImageItem(image=data.T) item.setZValue(z) #self._imageItem.setCompositionMode(QtGui.QPainter.CompositionMode_Multiply) if xScale is None: xScale = [0.0, 1.0] if yScale is None: yScale = [0.0, 1.0] item._plot_info = {'label':legend, 'type':'image', 'xScale':xScale, 'yScale':yScale, 'z':z} item._plot_options = [] if selectable or draggable: if draggable: item._plot_options.append('draggable') else: item._plot_options.append('selectable') # TODO: handle image selection self.addItem(item) if replot: self.replot() return item def removeCurve(self, handle, replot=True): if hasattr(handle, '_plot_info'): actualHandle = handle else: # we have received a legend legend = handle actualHandle = None a = self.items() for item in a: if hasattr(item, '_plot_info'): label = item._plot_info['label'] if label == legend: actualHandle = item break if actualHandle is not None: self.removeItem(actualHandle) if replot: self.replot() def setActiveCurve(self, legend, replot=True): if hasattr(legend, '_plot_info'): # we have received an actual item handle = legend else: # we have received a legend handle = None items = self.items() for item in items: if hasattr(item, '_plot_info'): label = item._plot_info['label'] if label == legend: handle = item #TODO: use setPen, setBrush, setSymbolPen, setSymbolBrush, setSymbol, ... if handle is not None: #print("handle found") color = '#000000' if handle._plot_info['linewidth'] > 0: handle.opts['pen'] = color handle.opts['symbolPen'] = color handle.opts['symbolBrush'] = color handle.updateItems() else: raise KeyError("Curve %s not found" % legend) if self._oldActiveCurve in self.items(): #print("old still present") if self._oldActiveCurve._plot_info['label'] != legend: color = self._oldActiveCurve._plot_info['color'] if self._oldActiveCurve._plot_info['linewidth'] > 0: self._oldActiveCurve.opts['pen'] = color self._oldActiveCurve.opts['symbolPen'] = color self._oldActiveCurve.opts['symbolBrush'] = color self._oldActiveCurve.updateItems() elif self._oldActiveCurveLegend is not None: #print("old legend", self._oldActiveCurveLegend) if self._oldActiveCurveLegend != handle._plot_info['label']: items = self.items() for item in items: if hasattr(item, '_plot_info'): label = item._plot_info['label'] if label == self._oldActiveCurveLegend: color = item._plot_info['color'] if item._plot_info['linewidth'] > 0: item.opts['pen'] = color item.opts['symbolPen'] = color item.opts['symbolBrush'] = color item.updateItems() break self._oldActiveCurve = handle self._oldActiveCurveLegend = handle._plot_info['label'] if replot: self.replot() def replot(self): """ Update plot """ pg.PlotWidget.update(self) return def clearCurves(self): """ Clear all curves from the plot """ #This removes also the markers #self.getPlotItem().clearPlots() itemList = self.items() for item in itemList: if hasattr(item, '_plot_info'): label = item._plot_info['label'] if not label.startswith("__MARKER__"): self.removeItem(item) def clear(self): """ Clear all items from the plot """ pg.PlotWidget.clearPlots() def resetZoom(self): """ It should autoscale any axis that is in autoscale mode """ xmin, xmax = self.getGraphXLimits() xAuto = self.isXAxisAutoScale() yAuto = self.isYAxisAutoScale() if xAuto and yAuto: self.plotItem.autoRange() elif yAuto: xmin, xmax = self.getGraphXLimits() self.plotItem.autoRange() self.setGraphXLimits(xmin, xmax) elif xAuto: ymin, ymax = self.getGraphYLimits() self.plotItem.autoRange() self.setGraphYLimits(ymin, ymax) else: if DEBUG: print("Nothing to autoscale") self.replot() return #Graph related functions def getGraphTitle(self): # there should be a function for this return self.plotItem.titleLabel.text def getGraphXLabel(self): # there should be a function for this return self.getAxis('bottom').labelText def getGraphYLabel(self): # there should be a function for this return self.getAxis('left').labelText def setGraphTitle(self, title=""): self.setTitle(title) def setGraphXLabel(self, label="X"): self.setLabel('bottom', label) def setGraphYLabel(self, label="Y"): self.setLabel('left', label) def getGraphXLimits(self): """ Get the graph X (bottom) limits. :return: Minimum and maximum values of the X axis """ rect = self.viewRect() return rect.left(), rect.right() def getGraphYLimits(self): """ Get the graph Y (left) limits. :return: Minimum and maximum values of the Y axis """ rect = self.viewRect() return rect.bottom(), rect.top() def setGraphXLimits(self, xmin, xmax): self.setXRange(xmin, xmax, padding=0, update=False) def setGraphYLimits(self, ymin, ymax): self.setYRange(ymin, ymax, padding=0, update=False) def isXAxisAutoScale(self): if self._xAutoScale: return True else: return False def isYAxisAutoScale(self): if self._yAutoScale: return True else: return False def setXAxisAutoScale(self, flag=True): if flag: self._xAutoScale = True else: self._xAutoScale = False def setYAxisAutoScale(self, flag=True): if flag: self._yAutoScale = True else: self._yAutoScale = False def setXAxisLogarithmic(self, flag): if flag: self._logX = True else: self._logX = False self.setLogMode(self._logX, self._logY) def setYAxisLogarithmic(self, flag): if flag: self._logY = True else: self._logY = False self.setLogMode(self._logX, self._logY) def setLimits(self, xmin, xmax, ymin, ymax): self.setGraphXLimits(xmin, xmax) self.setGraphYLimits(ymin, ymax) # Marker handling def insertXMarker(self, x, legend, text=None, color='k', selectable=False, draggable=False, **kw): """ :param x: Horizontal position of the marker in graph coordenates :type x: float :param legend: Legend associated to the marker :type legend: string :param label: Text associated to the marker :type label: string or None :param color: Color to be used for instance 'blue', 'b', '#FF0000' :type color: string, default 'k' (black) :param selectable: Flag to indicate if the marker can be selected :type selectable: boolean, default False :param draggable: Flag to indicate if the marker can be moved :type draggable: boolean, default False :return: Handle used by the backend to univocally access the marker """ self.removeMarker(legend, replot=False) legend = "__MARKER__" + legend if selectable or draggable: movable = True else: movable = False line = InfiniteLine(angle=90, movable=movable) line.setPos(x) line.setY(1.) line._plot_info = {'label':legend, 'text':text} line._plot_options = ["xmarker"] if selectable: line._plot_options.append('selectable') elif draggable: line._plot_options.append('draggable') if selectable or draggable: line.sigPositionChangeFinished.connect(self._xMarkerMoved) line.setZValue(10) self.addItem(line) return line def insertYMarker(self, y, legend, text=None, color='k', selectable=False, draggable=False, **kw): """ :param y: Vertical position of the marker in graph coordenates :type y: float :param legend: Legend associated to the marker :type legend: string :param label: Text associated to the marker :type label: string or None :param color: Color to be used for instance 'blue', 'b', '#FF0000' :type color: string, default 'k' (black) :param selectable: Flag to indicate if the marker can be selected :type selectable: boolean, default False :param draggable: Flag to indicate if the marker can be moved :type draggable: boolean, default False :return: Handle used by the backend to univocally access the marker """ label = "__MARKER__" + legend if selectable or draggable: movable = True else: movable = False line = InfiniteLine(angle=0, movable=movable) line.setPos(y) line.setX(1.) line._plot_info = {'label':legend, 'text':text} line._plot_options = ["ymarker"] if selectable: line._plot_options.append('selectable') elif draggable: line._plot_options.append('draggable') if selectable or draggable: line.sigPositionChangeFinished.connect(self._yMarkerMoved) line.setZValue(10) self.addItem(line) return line def insertMarker(self, x, y, legend, text=None, **kw): print("PlotBackend insertMarker not implemented") def invertYAxis(self, flag=True): if flag: self.invertY(True) else: self.invertY(False) def _xMarkerMoved(self, item): label = item._plot_info['label'] ddict = {} ddict['event'] = "markerMoved" ddict['label'] = item._plot_info['label'][10:] ddict['type'] = 'marker' if 'draggable' in item._plot_options: ddict['draggable'] = True else: ddict['draggable'] = False if 'selectable' in item._plot_options: ddict['selectable'] = True ddict['event'] = "markerSelected" else: ddict['selectable'] = False # use this and not the current mouse position because # it has to agree with the marker position ddict['x'] = item.getXPos() ddict['y'] = 1.0 #ddict['xdata'] = artist.get_xdata() #ddict['ydata'] = artist.get_ydata() self._callback(ddict) def _yMarkerMoved(self, item): label = item._plot_info['label'] ddict = {} ddict['event'] = "markerMoved" ddict['label'] = item._plot_info['label'][10:] ddict['type'] = 'marker' if 'draggable' in item._plot_options: ddict['draggable'] = True else: ddict['draggable'] = False if 'selectable' in item._plot_options: ddict['selectable'] = True ddict['event'] = "markerSelected" else: ddict['selectable'] = False # use this and not the current mouse position because # it has to agree with the marker position ddict['x'] = 1.0 ddict['y'] = item.getYPos() #ddict['xdata'] = artist.get_xdata() #ddict['ydata'] = artist.get_ydata() self._callback(ddict) def removeImage(self, handle, replot=True): if hasattr(handle, '_plot_info'): actualHandle = handle else: # we have received a legend legend = handle actualHandle = None a = self.items() for item in a: if hasattr(item, '_plot_info'): label = item._plot_info['label'] if label == legend: actualHandle = item break if actualHandle is not None: self.removeItem(actualHandle) if replot: self.replot() if _USE_ORIGINAL: def _curveClicked(self, item): label = item._plot_info['label'] ddict = {} ddict['event'] = "curveClicked" ddict['button'] = 'left' ddict['label'] = label ddict['type'] = 'curve' self._callback(ddict) else: def _curveClicked(self, ddict0): item = ddict0['item'] label = item._plot_info['label'] ddict = {} ddict['event'] = "curveClicked" ddict['button'] = 'left' ddict['label'] = label ddict['type'] = 'curve' self._callback(ddict) def main(): from .. import Plot x = numpy.arange(100.) y = x * x plot = Plot.Plot(backend=PyQtGraphBackend) plot.addCurve(x, y, "dummy") plot.addCurve(x + 100, -x * x, "To set Active") print("Active curve = ", plot.getActiveCurve()) print("X Limits) = ", plot.getGraphXLimits()) print("Y Limits = ", plot.getGraphYLimits()) print("All curves = ", plot.getAllCurves()) #plot.removeCurve("dummy") plot.setActiveCurve("To set Active") print("All curves = ", plot.getAllCurves()) plot.insertXMarker(50., draggable=True) #plot.resetZoom() return plot if __name__ == "__main__": import numpy app = QtGui.QApplication([]) w = main() w.getWidgetHandle().show() #w.invertYAxis(True) w.replot() #w.invertYAxis(True) data = numpy.arange(1000.*1000) data.shape = 10000,100 #plot.replot() #w.invertYAxis(True) #w.replot() #w.widget.show() w.addImage(data, legend="image 0", xScale=(25, 1.0) , yScale=(-1000, 1.0), selectable=True) #w.removeImage("image 0") #w.invertYAxis(True) w.replot() #w.addImage(data, legend="image 1", xScale=(25, 1.0) , yScale=(-1000, 1.0), # replot=False, selectable=True) #w.invertYAxis(True) app.exec_()