def onZipfPlot(self): before = time.time() pg.setConfigOptions(antialias=True) dialog= QtGui.QDialog(self) plotWidget = pg.PlotWidget(name='Zipf\'s Law Plot') logx = self.model.getLogX() ab = self.model.getPolyFit() s = ScatterPlotItem(logx, self.model.getLogfreqDist(), size=4, pen=None, brush=pg.mkBrush(255, 255, 255)) s.addPoints(logx, self.model.getLogfreqDist()) plot = plotWidget.plot(logx, [self.model.getPoly(x) for x in logx], pen=(0,255,255), size=4) legend = LegendItem((130,60), offset=(500,30)) legend.setParentItem(plotWidget.getPlotItem()) legend.addItem(s, 'Corpus data') legend.addItem(plot, str(round(ab[0], 3)) + 'x + ' +str(round(ab[1], 3))) plotWidget.addItem(s) lay = QtGui.QVBoxLayout() lay.addWidget(plotWidget) dialog.setLayout(lay) dialog.show() self.fillTimeData("creating Zipf plot", time.time() - before)
def __init__(self, cluster, plot, pen=None, brush=None): self.__cluster=cluster; if(pen is None): self.__pen=pg.mkPen(QColor("#DFDFDF")); else: self.__pen=pen; if(brush is None): self.__brush=QBrush(QColor("#DFDFDF")); else: self.__brush=brush; # self.__plotData=pg.ScatterPlotItem(x=[0, 1], y=[0, 1], # symbol="s", __pen=pg.mkPen("w"), # size=1); self.__plotData=FastScatterPlotItem(x=[0], y=[0], symbol="s", pen=self.__pen, size=1, pointMode=True); # self.__plotData=ScatterPlotItem(x=[0], y=[0], symbol="s", # pen=self.__pen, brush=self.__brush, size=1); self.__plotDataBigP=ScatterPlotItem(x=[0], y=[0], symbol="s", pen=self.__pen, brush=self.__brush, size=2); self.__plotBoundaryData=pg.PlotDataItem(x=[0], y=[0], pen=self.__pen); self.__plot=plot; self.__waveStartInd=0; self.__selPtsSequence=None; self.__calcSelPtsSequence(); self.__selDispWaves=np.zeros(self.__cluster.getSelectArray().shape, dtype="bool");
def __init__(self, name): CtrlNode.__init__(self, name, terminals={ 'input': { 'io': 'in' }, 'plot': { 'io': 'out' } }) self.item = ScatterPlotItem() self.keys = []
def __init__(self, name, num_data, color, ix, max_actors, actor_height): self.name = name self.num_data = num_data self.color = color self.ix = ix self.max_actors = max_actors self.actor_height = actor_height self.offset = ix * actor_height self.data = np.array([self.offset + 30] * num_data) self.head = 0 self.pre_head = 0 self.plotItem = PlotCurveItem(pen=pg.mkPen(color, width=3), width=4, name=name) self.plotPoint = ScatterPlotItem(pen=pg.mkPen("w", width=5), brush=pg.mkBrush(color), size=5) self.render()
def _update_anchors_scatter_item(self, points): if self.anchors_scatter_item is not None: self.plot_widget.removeItem(self.anchors_scatter_item) self.anchors_scatter_item = None self.anchors_scatter_item = ScatterPlotItem(x=points[:, 0], y=points[:, 1]) self.plot_widget.addItem(self.anchors_scatter_item)
def __init__(self, name): CtrlNode.__init__(self, name, terminals={ 'input': {'io': 'in'}, 'plot': {'io': 'out'} }) self.item = ScatterPlotItem() self.keys = []
def __init__(self, scatter_widget, parent=None, name="None", view_box=None): super().__init__(scatter_widget, parent=parent, _=name, view_box=view_box) self._tooltip_delegate = EventDelegate(self.help_event, self._show_arc) self.plot_widget.scene().installEventFilter(self._tooltip_delegate) self.scatterplot_points = ScatterPlotItem(x=[], y=[])
class Actor(object): def __init__(self, name, num_data, color, ix, max_actors, actor_height): self.name = name self.num_data = num_data self.color = color self.ix = ix self.max_actors = max_actors self.actor_height = actor_height self.offset = ix * actor_height self.data = np.array([self.offset + 30] * num_data) self.head = 0 self.pre_head = 0 self.plotItem = PlotCurveItem(pen=pg.mkPen(color, width=3), width=4, name=name) self.plotPoint = ScatterPlotItem(pen=pg.mkPen("w", width=5), brush=pg.mkBrush(color), size=5) self.render() def __str__(self): return "<Actor name:%r, position=%r>" % (self.name, self.head) def __repr__(self): return "Actor(%r, %r, %r, %r, %r, %r)" % (self.name, self.num_data, self.color, self.ix, self.max_actors, self.actor_height) def add_value(self, value): self.pre_head = self.head self.data[self.pre_head] = value / self.max_actors + self.offset self.head = (self.pre_head + 1) % self.num_data def fill_missing(self, count): dp = self.head for i in range(count): self.data[dp] = self.offset dp = (dp + 1) % self.num_data self.pre_head = (dp - 1) % self.num_data self.head = dp def render(self): self.plotItem.setData(y=self.data, clear=True) self.plotPoint.setData(x=[self.pre_head], y=[self.data[self.pre_head]])
def manual_move(self): self.__replot_requested = False if self.plotdata.rand is not None: rand = self.plotdata.rand valid_mask = self.plotdata.valid_mask data = self.data[valid_mask] selection = self._selection[valid_mask] selection = selection[rand] ec, _, valid_mask = radviz( data, list(self.model_selected), self.plotdata.points ) assert sum(valid_mask) == len(data) data = data[rand] ec = ec[rand] data_x = data.X data_y = data.Y data_metas = data.metas else: self.prepare_radviz_data(list(self.model_selected)) ec = self.plotdata.embedding_coords valid_mask = self.plotdata.valid_mask data_x = self.data.X[valid_mask] data_y = self.data.Y[valid_mask] data_metas = self.data.metas[valid_mask] selection = self._selection[valid_mask] attributes = (self.variable_x, self.variable_y) + self.data.domain.attributes domain = Domain( attributes=attributes, class_vars=self.data.domain.class_vars, metas=self.data.domain.metas, ) data = Table.from_numpy( domain, X=np.hstack((ec, data_x)), Y=data_y, metas=data_metas ) self.graph.new_data(data, None) self.graph.selection = selection self.graph.update_data(self.variable_x, self.variable_y, reset_view=True) self.graph.plot_widget.addItem(self._circle) self.graph.scatterplot_points = ScatterPlotItem( x=self.plotdata.points[:, 0], y=self.plotdata.points[:, 1] ) self._update_points_labels() self.graph.plot_widget.addItem(self.graph.scatterplot_points)
def setup_plot(self, reset_view=True): if self.data is None: return self.graph.jitter_continuous = True self.__replot_requested = False variables = list(self.model_selected) if len(variables) < 2: self.Warning.no_features() self.graph.new_data(None) return self.Warning.clear() self.prepare_radviz_data(variables) if self.plotdata.embedding_coords is None: return domain = self.data.domain new_metas = domain.metas + (self.variable_x, self.variable_y) domain = Domain( attributes=domain.attributes, class_vars=domain.class_vars, metas=new_metas ) mask = self.plotdata.valid_mask array = np.zeros((len(self.data), 2), dtype=np.float) array[mask] = self.plotdata.embedding_coords data = self.data.transform(domain) data[:, self.variable_x] = array[:, 0].reshape(-1, 1) data[:, self.variable_y] = array[:, 1].reshape(-1, 1) subset_data = ( data[self._subset_mask & mask] if self._subset_mask is not None and len(self._subset_mask) else None ) self.plotdata.data = data self.graph.new_data(data[mask], subset_data) if self._selection is not None: self.graph.selection = self._selection[self.plotdata.valid_mask] self.graph.update_data(self.variable_x, self.variable_y, reset_view=reset_view) self.graph.plot_widget.addItem(self._circle) self.graph.scatterplot_points = ScatterPlotItem( x=self.plotdata.points[:, 0], y=self.plotdata.points[:, 1] ) self._update_points_labels() self.graph.plot_widget.addItem(self.graph.scatterplot_points)
class ScatterPlot(CtrlNode): """Generates a scatter plot from a record array or nested dicts""" nodeName = 'ScatterPlot' uiTemplate = [ ('x', 'combo', {'values': [], 'index': 0}), ('y', 'combo', {'values': [], 'index': 0}), ('sizeEnabled', 'check', {'value': False}), ('size', 'combo', {'values': [], 'index': 0}), ('absoluteSize', 'check', {'value': False}), ('colorEnabled', 'check', {'value': False}), ('color', 'colormap', {}), ('borderEnabled', 'check', {'value': False}), ('border', 'colormap', {}), ] def __init__(self, name): CtrlNode.__init__(self, name, terminals={ 'input': {'io': 'in'}, 'plot': {'io': 'out'} }) self.item = ScatterPlotItem() self.keys = [] #self.ui = QtGui.QWidget() #self.layout = QtGui.QGridLayout() #self.ui.setLayout(self.layout) #self.xCombo = QtGui.QComboBox() #self.yCombo = QtGui.QComboBox() def process(self, input, display=True): #print "scatterplot process" if not display: return {'plot': None} self.updateKeys(input[0]) x = str(self.ctrls['x'].currentText()) y = str(self.ctrls['y'].currentText()) size = str(self.ctrls['size'].currentText()) pen = QtGui.QPen(QtGui.QColor(0,0,0,0)) points = [] for i in input: pt = {'pos': (i[x], i[y])} if self.ctrls['sizeEnabled'].isChecked(): pt['size'] = i[size] if self.ctrls['borderEnabled'].isChecked(): pt['pen'] = QtGui.QPen(self.ctrls['border'].getColor(i)) else: pt['pen'] = pen if self.ctrls['colorEnabled'].isChecked(): pt['brush'] = QtGui.QBrush(self.ctrls['color'].getColor(i)) points.append(pt) self.item.setPxMode(not self.ctrls['absoluteSize'].isChecked()) self.item.setPoints(points) return {'plot': self.item} def updateKeys(self, data): if isinstance(data, dict): keys = list(data.keys()) elif isinstance(data, list) or isinstance(data, tuple): keys = data elif isinstance(data, np.ndarray) or isinstance(data, np.void): keys = data.dtype.names else: print("Unknown data type:", type(data), data) return for c in self.ctrls.values(): c.blockSignals(True) for c in [self.ctrls['x'], self.ctrls['y'], self.ctrls['size']]: cur = str(c.currentText()) c.clear() for k in keys: c.addItem(k) if k == cur: c.setCurrentIndex(c.count()-1) for c in [self.ctrls['color'], self.ctrls['border']]: c.setArgList(keys) for c in self.ctrls.values(): c.blockSignals(False) self.keys = keys def saveState(self): state = CtrlNode.saveState(self) return {'keys': self.keys, 'ctrls': state} def restoreState(self, state): self.updateKeys(state['keys']) CtrlNode.restoreState(self, state['ctrls']) #class ImageItem(Node): #"""Creates an ImageItem for display in a canvas from a file handle.""" #nodeName = 'Image' #def __init__(self, name): #Node.__init__(self, name, terminals={ #'file': {'io': 'in'}, #'image': {'io': 'out'} #}) #self.imageItem = graphicsItems.ImageItem() #self.handle = None #def process(self, file, display=True): #if not display: #return {'image': None} #if file != self.handle: #self.handle = file #data = file.read() #self.imageItem.updateImage(data) #pos = file.
def _add_point_items(self): if self._points is None: return x, y = self._points[:, 0], self._points[:, 1] self._point_items = ScatterPlotItem(x=x, y=y) self.plot_widget.addItem(self._point_items)
def __init__(self, name): CtrlNode.__init__(self, name, terminals={"input": {"io": "in"}, "plot": {"io": "out"}}) self.item = ScatterPlotItem() self.keys = []
class ScatterPlot(CtrlNode): """Generates a scatter plot from a record array or nested dicts""" nodeName = "ScatterPlot" uiTemplate = [ ("x", "combo", {"values": [], "index": 0}), ("y", "combo", {"values": [], "index": 0}), ("sizeEnabled", "check", {"value": False}), ("size", "combo", {"values": [], "index": 0}), ("absoluteSize", "check", {"value": False}), ("colorEnabled", "check", {"value": False}), ("color", "colormap", {}), ("borderEnabled", "check", {"value": False}), ("border", "colormap", {}), ] def __init__(self, name): CtrlNode.__init__(self, name, terminals={"input": {"io": "in"}, "plot": {"io": "out"}}) self.item = ScatterPlotItem() self.keys = [] # self.ui = QtGui.QWidget() # self.layout = QtGui.QGridLayout() # self.ui.setLayout(self.layout) # self.xCombo = QtGui.QComboBox() # self.yCombo = QtGui.QComboBox() def process(self, input, display=True): # print "scatterplot process" if not display: return {"plot": None} self.updateKeys(input[0]) x = str(self.ctrls["x"].currentText()) y = str(self.ctrls["y"].currentText()) size = str(self.ctrls["size"].currentText()) pen = QtGui.QPen(QtGui.QColor(0, 0, 0, 0)) points = [] for i in input: pt = {"pos": (i[x], i[y])} if self.ctrls["sizeEnabled"].isChecked(): pt["size"] = i[size] if self.ctrls["borderEnabled"].isChecked(): pt["pen"] = QtGui.QPen(self.ctrls["border"].getColor(i)) else: pt["pen"] = pen if self.ctrls["colorEnabled"].isChecked(): pt["brush"] = QtGui.QBrush(self.ctrls["color"].getColor(i)) points.append(pt) self.item.setPxMode(not self.ctrls["absoluteSize"].isChecked()) self.item.setPoints(points) return {"plot": self.item} def updateKeys(self, data): if isinstance(data, dict): keys = data.keys() elif isinstance(data, list) or isinstance(data, tuple): keys = data elif isinstance(data, np.ndarray) or isinstance(data, np.void): keys = data.dtype.names else: print "Unknown data type:", type(data), data return for c in self.ctrls.itervalues(): c.blockSignals(True) for c in [self.ctrls["x"], self.ctrls["y"], self.ctrls["size"]]: cur = str(c.currentText()) c.clear() for k in keys: c.addItem(k) if k == cur: c.setCurrentIndex(c.count() - 1) for c in [self.ctrls["color"], self.ctrls["border"]]: c.setArgList(keys) for c in self.ctrls.itervalues(): c.blockSignals(False) self.keys = keys def saveState(self): state = CtrlNode.saveState(self) return {"keys": self.keys, "ctrls": state} def restoreState(self, state): self.updateKeys(state["keys"]) CtrlNode.restoreState(self, state["ctrls"])
class ScatterPlot(CtrlNode): """Generates a scatter plot from a record array or nested dicts""" nodeName = 'ScatterPlot' uiTemplate = [ ('x', 'combo', { 'values': [], 'index': 0 }), ('y', 'combo', { 'values': [], 'index': 0 }), ('sizeEnabled', 'check', { 'value': False }), ('size', 'combo', { 'values': [], 'index': 0 }), ('absoluteSize', 'check', { 'value': False }), ('colorEnabled', 'check', { 'value': False }), ('color', 'colormap', {}), ('borderEnabled', 'check', { 'value': False }), ('border', 'colormap', {}), ] def __init__(self, name): CtrlNode.__init__(self, name, terminals={ 'input': { 'io': 'in' }, 'plot': { 'io': 'out' } }) self.item = ScatterPlotItem() self.keys = [] #self.ui = QtGui.QWidget() #self.layout = QtGui.QGridLayout() #self.ui.setLayout(self.layout) #self.xCombo = QtGui.QComboBox() #self.yCombo = QtGui.QComboBox() def process(self, input, display=True): #print "scatterplot process" if not display: return {'plot': None} self.updateKeys(input[0]) x = str(self.ctrls['x'].currentText()) y = str(self.ctrls['y'].currentText()) size = str(self.ctrls['size'].currentText()) pen = QtGui.QPen(QtGui.QColor(0, 0, 0, 0)) points = [] for i in input: pt = {'pos': (i[x], i[y])} if self.ctrls['sizeEnabled'].isChecked(): pt['size'] = i[size] if self.ctrls['borderEnabled'].isChecked(): pt['pen'] = QtGui.QPen(self.ctrls['border'].getColor(i)) else: pt['pen'] = pen if self.ctrls['colorEnabled'].isChecked(): pt['brush'] = QtGui.QBrush(self.ctrls['color'].getColor(i)) points.append(pt) self.item.setPxMode(not self.ctrls['absoluteSize'].isChecked()) self.item.setPoints(points) return {'plot': self.item} def updateKeys(self, data): if isinstance(data, dict): keys = list(data.keys()) elif isinstance(data, list) or isinstance(data, tuple): keys = data elif isinstance(data, np.ndarray) or isinstance(data, np.void): keys = data.dtype.names else: print("Unknown data type:", type(data), data) return for c in self.ctrls.values(): c.blockSignals(True) for c in [self.ctrls['x'], self.ctrls['y'], self.ctrls['size']]: cur = str(c.currentText()) c.clear() for k in keys: c.addItem(k) if k == cur: c.setCurrentIndex(c.count() - 1) for c in [self.ctrls['color'], self.ctrls['border']]: c.setArgList(keys) for c in self.ctrls.values(): c.blockSignals(False) self.keys = keys def saveState(self): state = CtrlNode.saveState(self) return {'keys': self.keys, 'ctrls': state} def restoreState(self, state): self.updateKeys(state['keys']) CtrlNode.restoreState(self, state['ctrls'])
class ClusterPlotItem(object): def __init__(self, cluster, plot, pen=None, brush=None): self.__cluster=cluster; if(pen is None): self.__pen=pg.mkPen(QColor("#DFDFDF")); else: self.__pen=pen; if(brush is None): self.__brush=QBrush(QColor("#DFDFDF")); else: self.__brush=brush; # self.__plotData=pg.ScatterPlotItem(x=[0, 1], y=[0, 1], # symbol="s", __pen=pg.mkPen("w"), # size=1); self.__plotData=FastScatterPlotItem(x=[0], y=[0], symbol="s", pen=self.__pen, size=1, pointMode=True); # self.__plotData=ScatterPlotItem(x=[0], y=[0], symbol="s", # pen=self.__pen, brush=self.__brush, size=1); self.__plotDataBigP=ScatterPlotItem(x=[0], y=[0], symbol="s", pen=self.__pen, brush=self.__brush, size=2); self.__plotBoundaryData=pg.PlotDataItem(x=[0], y=[0], pen=self.__pen); self.__plot=plot; self.__waveStartInd=0; self.__selPtsSequence=None; self.__calcSelPtsSequence(); self.__selDispWaves=np.zeros(self.__cluster.getSelectArray().shape, dtype="bool"); def setPlotData(self, xChN, yChN, xChParamT, yChParamT, drawType=0): if(drawType==0): self.__plotData.setData(x=self.__cluster.getParam(xChN, xChParamT), y=self.__cluster.getParam(yChN, yChParamT), symbol="s", pen=self.__pen, size=1, pointMode=True); # self.__plotData.setData(x=self.__cluster.getParam(xChN, xChParamT), # y=self.__cluster.getParam(yChN, yChParamT), # symbol="s", pen=self.__pen, brush=self.__brush, # size=1); else: self.__plotDataBigP.setData(x=self.__cluster.getParam(xChN, xChParamT), y=self.__cluster.getParam(yChN, yChParamT), symbol="s", pen=self.__pen, brush=self.__brush, size=2); boundaries=self.__cluster.getBoundaries([xChN, yChN], [xChParamT, yChParamT]); if(len(boundaries)>0): points=np.zeros((2, 0)); connArr=np.zeros(0, dtype="bool"); for i in boundaries: curPoints=i.getPoints(); points=np.hstack((points, curPoints)); curCon=np.zeros(curPoints.shape[1], dtype="bool"); curCon[:-1]=True; connArr=np.hstack((connArr, curCon)); self.__plotBoundaryData.setData(x=points[0, :], y=points[1, :], connect=connArr); else: self.__plotBoundaryData.setData(x=[0], y=[0], connect="all"); def addToPlot(self, drawType=0): if(drawType==0): self.__plot.addItem(self.__plotData); else: self.__plot.addItem(self.__plotDataBigP); self.__plot.addItem(self.__plotBoundaryData); def removeFromPlot(self, plotType=0): if(plotType==0): self.__plot.removeItem(self.__plotData); else: self.__plot.RemoveItem(self.__plotDataBigP); self.__plot.removeItem(self.__plotBoundaryData); def getCurPen(self): return self.__pen; def __calcSelPtsSequence(self): sBA=self.__cluster.getSelectArray(); self.__selPtsSequence=np.cumsum(sBA); def getPrevWaves(self, indIncSize, trigChOnly): self.__calcSelPtsSequence(); if(self.__waveStartInd<=0): return (None, None, None, None, None); self.__waveStartInd=self.__waveStartInd-indIncSize; if(self.__waveStartInd+indIncSize>=self.__getNumSelPts()): self.__waveStartInd=self.__getNumSelPts()-indIncSize; # self.__waveStartInd=self.__waveStartInd%self.__getNumSelPts(); if(self.__waveStartInd<=0): self.__waveStartInd=0; sBA=self.__getSelPointsByRange(self.__waveStartInd, self.__waveStartInd+indIncSize); self.__selDispWaves=self.__selDispWaves | sBA; (nptsPerCh, waves, xvals, connArrs)=self.__cluster.getWaveforms(sBA, None, trigChOnly); return (self.__cluster.getNumChannels(), nptsPerCh, waves, xvals, connArrs); def getNextWaves(self, indIncSize, trigChOnly): self.__calcSelPtsSequence(); if(self.__waveStartInd>=self.__getNumSelPts()): return (None, None, None, None, None); sBA=self.__getSelPointsByRange(self.__waveStartInd, self.__waveStartInd+indIncSize); self.__selDispWaves=self.__selDispWaves | sBA; self.__waveStartInd=self.__waveStartInd+indIncSize; (nptsPerCh, waves, xvals, connArrs)=self.__cluster.getWaveforms(sBA, None, trigChOnly); return (self.__cluster.getNumChannels(), nptsPerCh, waves, xvals, connArrs); def resetWaveInd(self): self.__waveStartInd=0; def clearSelDispWaves(self): self.__selDispWaves[:]=False; def resetViewWaves(self): self.__calcSelPtsSequence(); def getSelDispWaves(self): (wAvg, wSEM, w25P, wMed, w75P)=self.__cluster.calcWaveStats(); (nptsPerCh, waves, xvals, conArrs)=self.__cluster.getWaveforms(self.__selDispWaves, None, False) return (waves, wAvg, wSEM, w25P, wMed, w75P); def __getSelPointsByRange(self, startInd, endInd): sBA=self.__cluster.getSelectArray(); return sBA & ((self.__selPtsSequence>=startInd) & (self.__selPtsSequence<endInd)); def __getNumSelPts(self): return self.__selPtsSequence[-1];