source: orange/orange/OrangeWidgets/Unsupervised/OWNetworkCanvas.py @ 8042:ffcb93bc9028

Revision 8042:ffcb93bc9028, 47.4 KB checked in by markotoplak, 3 years ago (diff)

Hierarchical clustering: also catch RuntimeError when importing matplotlib (or the documentation could not be built on server).

Line 
1CIRCLE = 0
2SQUARE = 1
3ROUND_RECT = 2
4
5NOTHING = 0
6ZOOMING = 1
7SELECT_RECTANGLE = 2
8SELECT_POLYGON = 3
9MOVE_SELECTION = 100
10
11from OWGraph import *
12from numpy import *
13from orngNetwork import Network
14from orngScaleScatterPlotData import *
15
16class NetworkVertex():
17    def __init__(self):
18        self.index = -1
19        self.marked = False
20        self.show = True
21        self.highlight = False
22        self.selected = False
23        self.label = []
24        self.tooltip = []
25        self.uuid = None
26       
27        self.image = None
28        self.pen = QPen(Qt.blue, 1)
29        self.pen.setJoinStyle(Qt.RoundJoin)
30        self.nocolor = Qt.white
31        self.color = Qt.blue
32        self.size = 5
33        self.style = 1
34   
35class NetworkEdge():
36    def __init__(self):
37        self.u = None
38        self.v = None
39        self.links_index = None
40        self.arrowu = 0
41        self.arrowv = 0
42        self.weight = 0
43        self.label = []
44
45        self.pen = QPen(Qt.lightGray, 1)
46        self.pen.setCapStyle(Qt.RoundCap)
47
48class NetworkCurve(QwtPlotCurve):
49  def __init__(self, parent, pen=QPen(Qt.black), xData=None, yData=None):
50      QwtPlotCurve.__init__(self, "Network Curve")
51
52      self.coors = None
53      self.vertices = []
54      self.edges = []
55      self.setItemAttribute(QwtPlotItem.Legend, 0)
56      self.showEdgeLabels = 0
57
58  def moveSelectedVertices(self, dx, dy):
59    selected = self.getSelectedVertices()
60   
61    self.coors[0][selected] = self.coors[0][selected] + dx
62    self.coors[1][selected] = self.coors[1][selected] + dy
63     
64    self.setData(self.coors[0], self.coors[1])
65    return selected
66 
67  def setVertexColor(self, v, color):
68      pen = self.vertices[v].pen
69      self.vertices[v].color = color
70      self.vertices[v].pen = QPen(color, pen.width())
71     
72  def setEdgeColor(self, index, color, nocolor=0):
73      pen = self.edges[index].pen
74      if nocolor:
75        color.setAlpha(0)
76      self.edges[index].pen = QPen(color, pen.width())
77      self.edges[index].pen.setCapStyle(Qt.RoundCap)
78 
79  def getSelectedVertices(self):
80    return [vertex.index for vertex in self.vertices if vertex.selected]
81
82  def getUnselectedVertices(self):
83    return [vertex.index for vertex in self.vertices if not vertex.selected]
84
85  def getMarkedVertices(self):
86    return [vertex.index for vertex in self.vertices if vertex.marked]
87 
88  def setMarkedVertices(self, vertices):
89    for vertex in self.vertices:
90      if vertex.index in vertices:
91        vertex.marked = True
92      else:
93        vertex.marked = False
94       
95  def markToSel(self):
96    for vertex in self.vertices:
97      if vertex.marked == True:
98          vertex.selected = True
99         
100  def selToMark(self):
101    for vertex in self.vertices:
102      if vertex.selected == True:
103          vertex.selected = False
104          vertex.marked = True
105 
106  def unMark(self):
107    for vertex in self.vertices:
108      vertex.marked = False
109     
110  def unSelect(self):
111    for vertex in self.vertices:
112        vertex.selected = False
113       
114  def setHiddenVertices(self, nodes):
115    for vertex in self.vertices:
116      if vertex.index in nodes:
117        vertex.show = False
118      else:
119        vertex.show = True
120     
121  def hideSelectedVertices(self):
122    for vertex in self.vertices:
123      if vertex.selected:
124        vertex.show = False
125 
126  def hideUnSelectedVertices(self):
127    for vertex in self.vertices:
128      if not vertex.selected:
129        vertex.show = False
130   
131  def showAllVertices(self):
132    for vertex in self.vertices:
133      vertex.show = True
134   
135  def changed(self):
136      self.itemChanged()
137
138  def draw(self, painter, xMap, yMap, rect):
139    for edge in self.edges:
140      if edge.u.show and edge.v.show:
141        painter.setPen(edge.pen)
142
143        px1 = xMap.transform(self.coors[0][edge.u.index])   #ali pa tudi self.x1, itd
144        py1 = yMap.transform(self.coors[1][edge.u.index])
145        px2 = xMap.transform(self.coors[0][edge.v.index])
146        py2 = yMap.transform(self.coors[1][edge.v.index])
147       
148        painter.drawLine(px1, py1, px2, py2)
149       
150        d = 12
151        #painter.setPen(QPen(Qt.lightGray, 1))
152        painter.setBrush(Qt.lightGray)
153        if edge.arrowu:
154            x = px1 - px2
155            y = py1 - py2
156           
157            fi = math.atan2(y, x) * 180 * 16 / math.pi
158
159            if not fi is None:
160                # (180*16) - fi - (20*16), (40*16)
161                painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640)
162               
163        if edge.arrowv:
164            x = px1 - px2
165            y = py1 - py2
166           
167            fi = math.atan2(y, x) * 180 * 16 / math.pi
168            if not fi is None:
169                # (180*16) - fi - (20*16), (40*16)
170                painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640)
171               
172        if self.showEdgeLabels and len(edge.label) > 0:
173            lbl = ', '.join(edge.label)
174            x = (px1 + px2) / 2
175            y = (py1 + py2) / 2
176           
177            th = painter.fontMetrics().height()
178            tw = painter.fontMetrics().width(lbl)
179            r = QRect(x - tw / 2, y - th / 2, tw, th)
180            painter.fillRect(r, QBrush(Qt.white))
181            painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl)
182   
183    for vertex in self.vertices:
184      if vertex.show:
185        pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer)
186        pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa
187        if vertex.selected:   
188          painter.setPen(QPen(Qt.yellow, 3))
189          painter.setBrush(vertex.color)
190          painter.drawEllipse(pX - (vertex.size + 4) / 2, pY - (vertex.size + 4) / 2, vertex.size + 4, vertex.size + 4)
191        elif vertex.marked:
192          painter.setPen(vertex.pen)
193          painter.setBrush(vertex.color)
194          painter.drawEllipse(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size)
195        else:
196          painter.setPen(vertex.pen)
197          painter.setBrush(vertex.nocolor)
198          #print pX - vertex.size / 2, pY - vertex.size / 2, vertex.size
199          painter.drawEllipse(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size)
200       
201class OWNetworkCanvas(OWGraph):
202  def __init__(self, master, parent=None, name="None"):
203      OWGraph.__init__(self, parent, name)
204      self.master = master
205      self.parent = parent
206      self.labelText = []
207      self.tooltipText = []
208      self.vertices_old = {}         # distionary of nodes (orngIndex: vertex_objekt)
209      self.edges_old = {}            # distionary of edges (curveKey: edge_objekt)
210      self.vertices = []
211      self.edges = []
212      self.indexPairs = {}       # distionary of type CurveKey: orngIndex   (for nodes)
213      #self.selection = []        # list of selected nodes (indices)
214      self.markerKeys = {}       # dictionary of type NodeNdx : markerCurveKey
215      self.tooltipKeys = {}      # dictionary of type NodeNdx : tooltipCurveKey
216      self.visualizer = None
217      self.vertexDegree = []     # seznam vozlisc oblike (vozlisce, stevilo povezav), sortiran po stevilu povezav
218      self.edgesKey = -1
219      #self.vertexSize = 6
220      self.nVertices = 0
221      self.enableXaxis(0)
222      self.enableYLaxis(0)
223      self.state = NOTHING  #default je rocno premikanje
224      self.hiddenNodes = []
225      self.markedNodes = set()
226      self.markWithRed = False
227      self.circles = []
228      self.tooltipNeighbours = 2
229      self.selectionNeighbours = 2
230      self.freezeNeighbours = False
231      self.labelsOnMarkedOnly = 0
232      self.enableWheelZoom = 1
233      self.optimizing = 0
234      self.stopOptimizing = 0
235      self.insideview = 0
236      self.insideviewNeighbours = 2
237      self.enableGridXB(False)
238      self.enableGridYL(False)
239      self.renderAntialiased = 1
240      self.sendMarkedNodes = None
241      self.showEdgeLabels = 0
242      self.showDistances = 0
243      self.showMissingValues = 0
244     
245      self.showWeights = 0
246      self.showIndexes = 0
247      self.minEdgeWeight = sys.maxint
248      self.maxEdgeWeight = 0
249      self.maxEdgeSize = 1
250     
251      self.maxVertexSize = 5
252      self.minVertexSize = 5
253      self.invertEdgeSize = 0
254      self.showComponentAttribute = None
255      self.forceVectors = None
256      self.appendToSelection = 1
257      self.fontSize = 12
258           
259      self.setAxisAutoScale(self.xBottom)
260      self.setAxisAutoScale(self.yLeft)
261     
262      self.networkCurve = NetworkCurve(self)
263      self.callbackMoveVertex = None
264      self.callbackSelectVertex = None
265      self.minComponentEdgeWidth = 0
266      self.maxComponentEdgeWidth = 0
267      self.vertexDistance = None
268      self.controlPressed = False
269      self.altPressed = False
270     
271      self.setFocusPolicy(Qt.StrongFocus)
272     
273  def getSelection(self):
274    return self.networkCurve.getSelectedVertices()
275
276  def getMarkedVertices(self):
277    return self.networkCurve.getMarkedVertices()
278     
279  def getVertexSize(self, index):
280      return 6
281     
282  def setHiddenVertices(self, nodes):
283      self.networkCurve.setHiddenVertices(nodes)
284 
285  def hideSelectedVertices(self):
286    self.networkCurve.hideSelectedVertices()
287    self.drawPlotItems()
288   
289  def hideUnSelectedVertices(self):
290    self.networkCurve.hideUnSelectedVertices()
291    self.drawPlotItems()
292   
293  def showAllVertices(self):
294    self.networkCurve.showAllVertices()
295    self.drawPlotItems()
296   
297  def optimize(self, frSteps):
298      qApp.processEvents()
299      tolerance = 5
300      initTemp = 100
301      breakpoints = 20
302      k = int(frSteps / breakpoints)
303      o = frSteps % breakpoints
304      iteration = 0
305      coolFactor = exp(log(10.0 / 10000.0) / frSteps)
306      #print coolFactor
307      if k > 0:
308          while iteration < breakpoints:
309              initTemp = self.visualizer.fruchtermanReingold(k, initTemp, coolFactor, self.hiddenNodes)
310              iteration += 1
311              qApp.processEvents()
312              self.updateCanvas()
313
314          initTemp = self.visualizer.fruchtermanReingold(o, initTemp, coolFactor, self.hiddenNodes)
315          qApp.processEvents()
316          self.updateCanvas()
317      else:
318          while iteration < o:
319              initTemp = self.visualizer.fruchtermanReingold(1, initTemp, coolFactor, self.hiddenNodes)
320              iteration += 1
321              qApp.processEvents()
322              self.updateCanvas()
323             
324  def markedToSelection(self):
325      self.networkCurve.markToSel()
326      self.drawPlotItems()
327     
328  def selectionToMarked(self):
329      self.networkCurve.selToMark()
330      self.drawPlotItems()
331     
332      if self.sendMarkedNodes != None:
333          self.sendMarkedNodes(self.networkCurve.getMarkedVertices())
334     
335  def removeSelection(self, replot=True):
336      self.networkCurve.unSelect()
337     
338      if replot:
339        self.replot()
340 
341  def selectNeighbours(self, sel, nodes, depth, maxdepth):
342      #print "list: " + str(sel)
343      #print "nodes: " + str(nodes)
344      sel.update(nodes)
345      if depth < maxdepth:
346          for i in nodes:
347              neighbours = set(self.visualizer.graph.getNeighbours(i))
348              #print "neighbours: " + str(neighbours)
349              self.selectNeighbours(sel, neighbours - sel, depth + 1, maxdepth)
350     
351  def getSelectedExamples(self):
352      selection = self.networkCurve.getSelectedVertices()
353     
354      if len(selection) == 0:
355          return None
356     
357      if self.visualizer.graph.items != None:
358          return self.visualizer.graph.items.getitems(selection)
359      else:
360          return None
361     
362  def getUnselectedExamples(self):
363      unselection = self.networkCurve.getUnselectedVertices()
364     
365      if len(unselection) == 0:
366          return None
367     
368      if self.visualizer.graph.items != None:
369          return self.visualizer.graph.items.getitems(unselection)
370      else:
371          return None
372
373  def getSelectedGraph(self):
374    selection = self.networkCurve.getSelectedVertices()
375   
376    if len(selection) == 0:
377        return None
378   
379    print self.visualizer.graph
380    subgraph = self.visualizer.graph.getSubGraph(selection)
381    subnet = Network(subgraph)
382    return subnet
383 
384  def getSelectedVertices(self):
385    return self.networkCurve.getSelectedVertices()
386 
387  def getNeighboursUpTo(self, ndx, dist):
388      newNeighbours = neighbours = set([ndx])
389      for d in range(dist):
390          tNewNeighbours = set()
391          for v in newNeighbours:
392              tNewNeighbours |= set(self.visualizer.graph.getNeighbours(v))
393          newNeighbours = tNewNeighbours - neighbours
394          neighbours |= newNeighbours
395      return neighbours
396   
397  def markSelectionNeighbours(self):
398      if not self.freezeNeighbours and self.selectionNeighbours:
399          toMark = set()
400          for ndx in self.networkCurve.getSelectedVertices():
401              toMark |= self.getNeighboursUpTo(ndx, self.selectionNeighbours)
402         
403          self.networkCurve.setMarkedVertices(toMark)
404          self.drawPlotItems()
405             
406      elif not self.freezeNeighbours and self.selectionNeighbours == 0:
407          self.networkCurve.setMarkedVertices(self.networkCurve.getSelectedVertices())
408          self.drawPlotItems()
409         
410      if self.sendMarkedNodes != None:
411          self.sendMarkedNodes(self.networkCurve.getMarkedVertices())
412             
413  def unMark(self):
414    self.networkCurve.unMark()
415    self.drawPlotItems(replot=0)
416   
417    if self.sendMarkedNodes != None:
418          self.sendMarkedNodes([])
419         
420  def setMarkedVertices(self, vertices):
421    self.networkCurve.setMarkedVertices(vertices)
422    self.drawPlotItems(replot=0)
423   
424    if self.sendMarkedNodes != None:
425          self.sendMarkedNodes(self.networkCurve.getMarkedVertices())
426     
427  def activateMoveSelection(self):
428      self.state = MOVE_SELECTION
429
430  def mouseMoveEvent(self, event):
431      if not self.visualizer:
432        return
433       
434      if self.mouseCurrentlyPressed and self.state == MOVE_SELECTION and self.GMmouseMoveEvent != None:
435          newX = self.invTransform(2, event.pos().x())
436          newY = self.invTransform(0, event.pos().y())
437         
438          dx = newX - self.invTransform(2, self.GMmouseMoveEvent.x())
439          dy = newY - self.invTransform(0, self.GMmouseMoveEvent.y())
440          movedVertices = self.networkCurve.moveSelectedVertices(dx, dy)
441         
442          self.GMmouseMoveEvent.setX(event.pos().x())  #zacetni dogodek postane trenutni
443          self.GMmouseMoveEvent.setY(event.pos().y())
444         
445          self.drawPlotItems(replot=1, vertices=movedVertices)
446          if self.callbackMoveVertex:
447              self.callbackMoveVertex()
448      else:
449          OWGraph.mouseMoveEvent(self, event)
450             
451      if not self.freezeNeighbours and self.tooltipNeighbours:
452          px = self.invTransform(2, event.x())
453          py = self.invTransform(0, event.y())   
454          ndx, mind = self.visualizer.closestVertex(px, py)
455          dX = self.transform(QwtPlot.xBottom, self.visualizer.graph.coors[0][ndx]) - event.x()
456          dY = self.transform(QwtPlot.yLeft,   self.visualizer.graph.coors[1][ndx]) - event.y()
457          # transform to pixel distance
458          distance = math.sqrt(dX**2 + dY**2) 
459           
460          if ndx != -1 and distance <= self.vertices[ndx].size / 2:
461              toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours))
462              self.networkCurve.setMarkedVertices(toMark)
463              self.drawPlotItems()
464             
465              if self.sendMarkedNodes != None:
466                  self.sendMarkedNodes(self.networkCurve.getMarkedVertices())
467          else:
468              self.networkCurve.unMark()
469              self.drawPlotItems()
470             
471              if self.sendMarkedNodes != None:
472                  self.sendMarkedNodes([])
473     
474      if self.showDistances:
475          selection = self.networkCurve.getSelectedVertices()
476          if len(selection) > 0:
477              px = self.invTransform(2, event.x())
478              py = self.invTransform(0, event.y()) 
479               
480              v, mind = self.visualizer.closestVertex(px, py)
481              dX = self.transform(QwtPlot.xBottom, self.visualizer.graph.coors[0][v]) - event.x()
482              dY = self.transform(QwtPlot.yLeft,   self.visualizer.graph.coors[1][v]) - event.y()
483              # transform to pixel distance
484              distance = math.sqrt(dX**2 + dY**2)               
485              if v != -1 and distance <= self.vertices[v].size / 2:
486                  if self.visualizer.vertexDistance == None:
487                      dst = 'vertex distance signal not set'
488                  else:
489                      dst = 0
490                      for u in selection:
491                          dst += self.visualizer.vertexDistance[u, v]
492                      dst = dst / len(selection)
493                     
494                  self.showTip(event.pos().x(), event.pos().y(), str(dst))
495                  self.replot()
496
497  def mousePressEvent(self, event):
498    if not self.visualizer:
499        return
500       
501    #self.grabKeyboard()
502    self.mouseSelectedVertex = 0
503    self.GMmouseMoveEvent = None
504   
505    if self.state == MOVE_SELECTION:
506      self.mouseCurrentlyPressed = 1
507      #if self.isPointSelected(self.invTransform(self.xBottom, event.pos().x()), self.invTransform(self.yLeft, event.pos().y())) and self.selection != []:
508      #  self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y())
509      #else:
510        # button pressed outside selected area or there is no area
511      self.selectVertex(event.pos())
512      self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y())
513      self.replot()
514    elif self.state == SELECT_RECTANGLE:
515        self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y())
516       
517        if self.clickedSelectedOnVertex(event.pos()):
518            self.mouseSelectedVertex = 1
519            self.mouseCurrentlyPressed = 1
520            self.state = MOVE_SELECTION
521            self.GMmouseMoveEvent = QPoint(event.pos().x(), event.pos().y())
522        elif self.clickedOnVertex(event.pos()):
523            self.mouseSelectedVertex = 1
524            self.mouseCurrentlyPressed = 1
525        else:
526            OWGraph.mousePressEvent(self, event) 
527    else:
528        OWGraph.mousePressEvent(self, event)     
529
530  def mouseReleaseEvent(self, event): 
531      if not self.visualizer:
532        return
533       
534      #self.releaseKeyboard()
535      if self.state == MOVE_SELECTION:
536          self.state = SELECT_RECTANGLE
537          self.mouseCurrentlyPressed = 0
538         
539          self.moveGroup = False
540          #self.GMmouseStartEvent=None
541         
542      if self.state == SELECT_RECTANGLE:
543          x1 = self.invTransform(2, self.GMmouseStartEvent.x())
544          y1 = self.invTransform(0, self.GMmouseStartEvent.y())
545         
546          x2 = self.invTransform(2, event.pos().x())
547          y2 = self.invTransform(0, event.pos().y())
548         
549         
550          if self.mouseSelectedVertex == 1 and x1 == x2 and y1 == y2 and self.selectVertex(self.GMmouseStartEvent):
551              QwtPlot.mouseReleaseEvent(self, event)
552          elif self.mouseSelectedVertex == 0:
553               
554              selection = self.visualizer.getVerticesInRect(x1, y1, x2, y2)
555
556              def selectVertex(ndx):
557                  if self.vertices[ndx].show:
558                      self.vertices[ndx].selected = True
559                     
560              map(selectVertex, selection)
561             
562              if len(selection) == 0 and x1 == x2 and y1 == y2:
563                  self.removeSelection()
564                  self.unMark()
565         
566              self.markSelectionNeighbours()
567              OWGraph.mouseReleaseEvent(self, event)
568              self.removeAllSelections()
569
570      elif self.state == SELECT_POLYGON:
571              OWGraph.mouseReleaseEvent(self, event)
572              if self.tempSelectionCurve == None:   #if OWVisGraph closed polygon
573                  self.selectVertices()
574      else:
575          OWGraph.mouseReleaseEvent(self, event)
576         
577      self.mouseCurrentlyPressed = 0
578      self.moveGroup = False
579         
580      if self.callbackSelectVertex != None:
581          self.callbackSelectVertex()
582
583  def keyPressEvent(self, e):
584      if not self.visualizer:
585        return
586       
587      if e.key() == 87 or e.key() == 81:
588          selection = [v.index for v in self.vertices if v.selected]
589          if len(selection) > 0:
590              phi = [math.pi / -180 if e.key() == 87 else math.pi / 180]
591              self.visualizer.rotateVertices([selection], phi)
592              self.drawPlotItems(replot=1)
593         
594      if e.key() == Qt.Key_Control:
595          self.controlPressed = True
596     
597      elif e.key() == Qt.Key_Alt:
598          self.altPressed = True
599         
600      if e.text() == "f":
601          self.graph.freezeNeighbours = not self.graph.freezeNeighbours
602     
603      OWGraph.keyPressEvent(self, e)
604         
605  def keyReleaseEvent(self, e):
606      if e.key() == Qt.Key_Control:
607          self.controlPressed = False
608     
609      elif e.key() == Qt.Key_Alt:
610          self.altPressed = False
611     
612      OWGraph.keyReleaseEvent(self, e)
613     
614
615  def clickedSelectedOnVertex(self, pos):
616      min = 1000000
617      ndx = -1
618
619      px = self.invTransform(2, pos.x())
620      py = self.invTransform(0, pos.y())   
621
622      ndx, min = self.visualizer.closestVertex(px, py)
623      dX = self.transform(QwtPlot.xBottom, self.visualizer.graph.coors[0][ndx]) - pos.x()
624      dY = self.transform(QwtPlot.yLeft,   self.visualizer.graph.coors[1][ndx]) - pos.y()
625      # transform to pixel distance
626      distance = math.sqrt(dX**2 + dY**2)
627      if ndx != -1 and distance <= self.vertices[ndx].size / 2:
628          return self.vertices[ndx].selected
629      else:
630          return False
631     
632  def clickedOnVertex(self, pos):
633      min = 1000000
634      ndx = -1
635
636      px = self.invTransform(2, pos.x())
637      py = self.invTransform(0, pos.y())   
638
639      ndx, min = self.visualizer.closestVertex(px, py)
640      dX = self.transform(QwtPlot.xBottom, self.visualizer.graph.coors[0][ndx]) - pos.x()
641      dY = self.transform(QwtPlot.yLeft,   self.visualizer.graph.coors[1][ndx]) - pos.y()
642      # transform to pixel distance
643      distance = math.sqrt(dX**2 + dY**2)
644      if ndx != -1 and distance <= self.vertices[ndx].size / 2:
645          return True
646      else:
647          return False
648             
649  def selectVertex(self, pos):
650      min = 1000000
651      ndx = -1
652
653      px = self.invTransform(2, pos.x())
654      py = self.invTransform(0, pos.y())   
655
656      ndx, min = self.visualizer.closestVertex(px, py)
657     
658      dX = self.transform(QwtPlot.xBottom, self.visualizer.graph.coors[0][ndx]) - pos.x()
659      dY = self.transform(QwtPlot.yLeft,   self.visualizer.graph.coors[1][ndx]) - pos.y()
660      # transform to pixel distance
661      distance = math.sqrt(dX**2 + dY**2)
662      if ndx != -1 and distance <= self.vertices[ndx].size / 2:
663          if not self.appendToSelection and not self.controlPressed:
664              self.removeSelection()
665                   
666          if self.insideview:
667              self.networkCurve.unSelect()
668              self.vertices[ndx].selected = not self.vertices[ndx].selected
669              self.optimize(100)
670             
671              self.markSelectionNeighbours()
672          else:
673              self.vertices[ndx].selected = not self.vertices[ndx].selected
674              self.markSelectionNeighbours()
675         
676          return True 
677      else:
678          return False
679          self.removeSelection()
680          self.unMark()
681 
682  def updateData(self):
683      if self.visualizer == None:
684          return
685     
686      self.removeDrawingCurves(removeLegendItems=0)
687      self.tips.removeAll()
688     
689      if self.vertexDistance and self.minComponentEdgeWidth > 0 and self.maxComponentEdgeWidth > 0:         
690          components = self.visualizer.graph.getConnectedComponents()
691          matrix = self.vertexDistance.avgLinkage(components)
692         
693          edges = set()
694          for u in range(matrix.dim):
695              neighbours = matrix.getKNN(u, 2)
696              for v in neighbours:
697                  if v < u:
698                      edges.add((v, u))
699                  else:
700                      edges.add((u, v))
701          edges = list(edges)
702# show 2n strongest edges
703#          vals = matrix.getValues()
704#          vals = zip(vals, range(len(vals)))
705#          count = 0
706#          add = 0
707#          for i in range(matrix.dim):
708#              add += i + 1
709#              for j in range(i+1, matrix.dim):
710#                  v, ind = vals[count]
711#                  ind += add
712#                  vals[count] = (v, ind)
713#                  count += 1
714#          vals.sort(reverse=0)
715#          vals = vals[:2 * matrix.dim]
716#          edges = [(ind / matrix.dim, ind % matrix.dim) for v, ind in vals]
717#          print "number of component edges:", len(edges), "number of components:", len(components)
718          components_c = [(sum(self.visualizer.graph.coors[0][c]) / len(c), sum(self.visualizer.graph.coors[1][c]) / len(c)) for c in components]
719          weights = [1 - matrix[u,v] for u,v in edges]
720         
721          max_weight = max(weights)
722          min_weight = min(weights)
723          span_weights = max_weight - min_weight
724       
725          for u,v in edges:
726              x = [components_c[u][0], components_c[v][0]]
727              y = [components_c[u][1], components_c[v][1]]
728              w = ((1 - matrix[u,v]) - min_weight) / span_weights * (self.maxComponentEdgeWidth - self.minComponentEdgeWidth) + self.minComponentEdgeWidth
729             
730              pen = QPen()
731              pen.setWidth(w)
732              pen.setBrush(QColor(50,200,255,15))
733              pen.setCapStyle(Qt.FlatCap)
734              pen.setJoinStyle(Qt.RoundJoin)
735              self.addCurve("component_edges", Qt.green, Qt.green, 0, style=QwtPlotCurve.Lines, symbol = QwtSymbol.NoSymbol, xData=x, yData=y, pen=pen, showFilledSymbols=False)
736     
737     
738      self.networkCurve.setData(self.visualizer.network.coors[0], self.visualizer.network.coors[1])
739     
740      if self.insideview == 1:
741          selection = self.networkCurve.getSelectedVertices()
742          if len(selection) >= 1:
743              visible = set()
744              visible |= set(selection)
745              visible |= self.getNeighboursUpTo(selection[0], self.insideviewNeighbours)
746              self.networkCurve.setHiddenVertices(set(range(self.nVertices)) - visible)
747
748      edgesCount = 0
749     
750      if self.forceVectors != None:
751          for v in self.forceVectors:
752              self.addCurve("force", Qt.white, Qt.green, 1, style=QwtPlotCurve.Lines, xData=v[0], yData=v[1], showFilledSymbols=False)
753     
754      for r in self.circles:
755          step = 2 * pi / 64;
756          fi = 0
757          x = []
758          y = []
759          for i in range(65):
760              x.append(r * cos(fi) + 5000)
761              y.append(r * sin(fi) + 5000)
762              fi += step
763             
764          self.addCurve("radius", Qt.white, Qt.green, 1, style=QwtPlotCurve.Lines, xData=x, yData=y, showFilledSymbols=False)
765     
766      if self.renderAntialiased:
767          self.networkCurve.setRenderHint(QwtPlotItem.RenderAntialiased)
768      else:
769          self.networkCurve.setRenderHint(QwtPlotItem.RenderAntialiased, False)
770   
771      self.networkCurve.showEdgeLabels = self.showEdgeLabels
772      self.networkCurve.attach(self)
773      self.drawPlotItems(replot=0)
774     
775      #self.zoomExtent()
776     
777  def drawPlotItems(self, replot=1, vertices=[]):
778      if len(vertices) > 0:
779          for vertex in vertices:
780              x1 = float(self.visualizer.network.coors[0][vertex])
781              y1 = float(self.visualizer.network.coors[1][vertex])
782             
783              if vertex in self.markerKeys:
784                  mkey = self.markerKeys[vertex]
785                  mkey.setValue(x1, y1)
786           
787              if 'index ' + str(vertex) in self.markerKeys:
788                  mkey = self.markerKeys['index ' + str(vertex)]
789                  mkey.setValue(x1, y1)
790             
791              if vertex in self.tooltipKeys:
792                  tkey = self.tooltipKeys[vertex]
793                  self.tips.positions[tkey] = (x1, y1, 0, 0)
794      else:
795          self.markerKeys = {}
796          self.removeMarkers()
797          self.drawLabels()
798          self.drawToolTips()
799          self.drawWeights()
800          self.drawIndexes()
801          self.drawComponentKeywords()
802     
803      if replot:
804          self.replot()
805         
806  def drawComponentKeywords(self):
807      if self.showComponentAttribute == None:
808          return
809     
810      if self.visualizer == None or self.visualizer.graph == None or self.visualizer.graph.items == None:
811          return
812     
813      if str(self.showComponentAttribute) not in self.visualizer.graph.items.domain:
814          self.showComponentAttribute = None
815          return
816     
817      components = self.visualizer.graph.getConnectedComponents()
818     
819      for component in components:
820          if len(component) == 0:
821              continue
822         
823          vertices = [vertex for vertex in component if self.vertices[vertex].show]
824
825          if len(vertices) == 0:
826              continue
827         
828          xes = [self.visualizer.network.coors[0][vertex] for vertex in vertices] 
829          yes = [self.visualizer.network.coors[1][vertex] for vertex in vertices] 
830                               
831          x1 = sum(xes) / len(xes)
832          y1 = sum(yes) / len(yes)
833         
834          lbl = str(self.visualizer.graph.items[component[0]][str(self.showComponentAttribute)])
835         
836          mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize)
837 
838  def drawToolTips(self):
839    # add ToolTips
840    self.tooltipData = []
841    self.tooltipKeys = {}
842    self.tips.removeAll()
843    if len(self.tooltipText) > 0:
844      for vertex in self.vertices:
845        if not vertex.show:
846          continue
847       
848        x1 = self.visualizer.network.coors[0][vertex.index]
849        y1 = self.visualizer.network.coors[1][vertex.index]
850        lbl = ""
851        values = self.visualizer.graph.items[vertex.index]
852        for ndx in self.tooltipText:
853            if not ndx in self.visualizer.graph.items.domain:
854                continue
855           
856            value = str(values[ndx])
857            # wrap text
858            i = 0
859            while i < len(value) / 100:
860                value = value[:((i + 1) * 100) + i] + "\n" + value[((i + 1) * 100) + i:]
861                i += 1
862               
863            lbl = lbl + str(value) + "\n"
864 
865        if lbl != '':
866          lbl = lbl[:-1]
867          self.tips.addToolTip(x1, y1, lbl)
868          self.tooltipKeys[vertex.index] = len(self.tips.texts) - 1
869                 
870  def drawLabels(self):
871      if len(self.labelText) > 0:
872          for vertex in self.vertices:
873              if not vertex.show:
874                  continue
875             
876              if self.labelsOnMarkedOnly and not (vertex.marked):
877                  continue
878                               
879              x1 = self.visualizer.network.coors[0][vertex.index]
880              y1 = self.visualizer.network.coors[1][vertex.index]
881              lbl = ""
882              values = self.visualizer.graph.items[vertex.index]
883              if self.showMissingValues:
884                  lbl = ", ".join([str(values[ndx]) for ndx in self.labelText])
885              else:
886                  lbl = ", ".join([str(values[ndx]) for ndx in self.labelText if str(values[ndx]) != '?'])
887              #if not self.showMissingValues and lbl == '':
888              #    continue
889             
890              if lbl:
891                  vertex.label = lbl
892                  mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignBottom, size=self.fontSize)
893                  self.markerKeys[vertex.index] = mkey   
894                   
895  def drawIndexes(self):
896      if self.showIndexes:
897          for vertex in self.vertices:
898              if not vertex.show:
899                  continue
900             
901              if self.labelsOnMarkedOnly and not (vertex.marked):
902                  continue
903                               
904              x1 = self.visualizer.network.coors[0][vertex.index]
905              y1 = self.visualizer.network.coors[1][vertex.index]
906
907              lbl = str(vertex.index)
908              mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignTop, size=self.fontSize)
909              self.markerKeys['index ' + str(vertex.index)] = mkey         
910
911  def drawWeights(self):
912      if self.showWeights:
913          for edge in self.edges:
914              if not (edge.u.show and edge.v.show):
915                  continue
916             
917              if self.labelsOnMarkedOnly and not (edge.u.marked and edge.v.marked):
918                  continue
919                               
920              x1 = (self.visualizer.network.coors[0][edge.u.index] + self.visualizer.network.coors[0][edge.v.index]) / 2
921              y1 = (self.visualizer.network.coors[1][edge.u.index] + self.visualizer.network.coors[1][edge.v.index]) / 2
922             
923              if edge.weight == None:
924                  lbl = "None"
925              else:
926                  lbl = "%.2f" % float(edge.weight)
927             
928              mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize)
929              self.markerKeys[(edge.u, edge.v)] = mkey
930                         
931  def getColorIndeces(self, table, attribute, palette):
932      colorIndices = {}
933      colorIndex = None
934      minValue = None
935      maxValue = None
936     
937      if attribute[0] != "(" or attribute[ -1] != ")":
938          i = 0
939          for var in table.domain.variables:
940              if var.name == attribute:
941                  colorIndex = i
942                  if var.varType == orange.VarTypes.Discrete: 
943                      colorIndices = getVariableValueIndices(var, colorIndex)
944                     
945              i += 1
946          metas = table.domain.getmetas()
947          for i, var in metas.iteritems():
948              if var.name == attribute:
949                  colorIndex = i
950                  if var.varType == orange.VarTypes.Discrete: 
951                      colorIndices = getVariableValueIndices(var, colorIndex)
952
953      colorIndices['?'] = len(colorIndices)
954      palette.setNumberOfColors(len(colorIndices))
955     
956      if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous:
957          minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0]))
958          maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0]))
959         
960      return colorIndices, colorIndex, minValue, maxValue
961 
962  def setEdgeColor(self, attribute):
963      if self.visualizer == None:
964          return
965     
966      colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.visualizer.graph.links, attribute, self.discEdgePalette)
967
968      for index in range(self.nEdges):
969          if colorIndex != None:
970              links_index = self.networkCurve.edges[index].links_index
971              if links_index == None:
972                  continue
973             
974              if self.visualizer.graph.links.domain[colorIndex].varType == orange.VarTypes.Continuous:
975                  newColor = self.discEdgePalette[0]
976                  if str(self.visualizer.graph.links[links_index][colorIndex]) != "?":
977                      if maxValue == minValue:
978                          newColor = self.discEdgePalette[0]
979                      else:
980                          value = (float(self.visualizer.graph.links[links_index][colorIndex].value) - minValue) / (maxValue - minValue)
981                          newColor = self.contEdgePalette[value]
982                     
983                  self.networkCurve.setEdgeColor(index, newColor)
984                 
985              elif self.visualizer.graph.links.domain[colorIndex].varType == orange.VarTypes.Discrete:
986                  newColor = self.discEdgePalette[colorIndices[self.visualizer.graph.links[links_index][colorIndex].value]]
987                  if self.visualizer.graph.links[links_index][colorIndex].value == "0":
988                    self.networkCurve.setEdgeColor(index, newColor, nocolor=1)
989                  else:
990                    self.networkCurve.setEdgeColor(index, newColor)
991                 
992          else:
993              newColor = self.discEdgePalette[0]
994              self.networkCurve.setEdgeColor(index, newColor)
995     
996      self.replot()
997 
998  def setVertexColor(self, attribute):
999      if self.visualizer == None:
1000          return
1001     
1002      colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.visualizer.graph.items, attribute, self.discPalette)
1003
1004      for v in range(self.nVertices):
1005          if colorIndex != None:   
1006              if self.visualizer.graph.items.domain[colorIndex].varType == orange.VarTypes.Continuous:
1007                  newColor = self.discPalette[0]
1008                 
1009                  if str(self.visualizer.graph.items[v][colorIndex]) != "?":
1010                      if maxValue == minValue:
1011                          newColor = self.discPalette[0]
1012                      else:
1013                          value = (float(self.visualizer.graph.items[v][colorIndex].value) - minValue) / (maxValue - minValue)
1014                          newColor = self.contPalette[value]
1015                     
1016                  self.networkCurve.setVertexColor(v, newColor)
1017                 
1018              elif self.visualizer.graph.items.domain[colorIndex].varType == orange.VarTypes.Discrete:
1019                  newColor = self.discPalette[colorIndices[self.visualizer.graph.items[v][colorIndex].value]]
1020                  #print newColor
1021                  self.networkCurve.setVertexColor(v, newColor)
1022                 
1023          else:
1024              newColor = self.discPalette[0]
1025              self.networkCurve.setVertexColor(v, newColor)
1026     
1027      self.replot()
1028     
1029  def setLabelText(self, attributes):
1030      self.labelText = []
1031      if self.visualizer == None or self.visualizer.graph == None or self.visualizer.graph.items == None:
1032          return
1033     
1034      if isinstance(self.visualizer.graph.items, orange.ExampleTable):
1035          data = self.visualizer.graph.items
1036          for att in attributes:
1037              for i in range(len(data.domain)):
1038                  if data.domain[i].name == att:
1039                      self.labelText.append(i)
1040                     
1041              if self.visualizer.graph.items.domain.hasmeta(att):
1042                      self.labelText.append(self.visualizer.graph.items.domain.metaid(att))
1043 
1044  def setTooltipText(self, attributes):
1045      self.tooltipText = []
1046      if self.visualizer == None or self.visualizer.graph == None or self.visualizer.graph.items == None:
1047          return
1048     
1049      if isinstance(self.visualizer.graph.items, orange.ExampleTable):
1050          data = self.visualizer.graph.items
1051          for att in attributes:
1052              for i in range(len(data.domain)):
1053                  if data.domain[i].name == att:
1054                      self.tooltipText.append(i)
1055                     
1056              if self.visualizer.graph.items.domain.hasmeta(att):
1057                      self.tooltipText.append(self.visualizer.graph.items.domain.metaid(att))
1058                     
1059  def setEdgeLabelText(self, attributes):
1060      self.edgeLabelText = []
1061      if self.visualizer == None or self.visualizer.graph == None or self.visualizer.graph.items == None:
1062          return
1063     
1064  def edgesContainsEdge(self, i, j):
1065      for e in range(self.nEdges):
1066          (key, iTmp, jTmp) = self.edges_old[e]
1067         
1068          if (iTmp == i and jTmp == j) or (iTmp == j and jTmp == i):
1069              return True
1070      return False
1071     
1072  def addVisualizer(self, visualizer, curve=None):
1073      self.visualizer = visualizer
1074      self.clear()
1075     
1076      self.nVertices = 0
1077      self.nEdges = 0
1078      self.vertexDegree = []
1079      self.vertices_old = {}
1080      self.vertices = []
1081      self.edges_old = {}
1082      self.nEdges = 0
1083      if curve is None:
1084          self.networkCurve = NetworkCurve(self)
1085      else:
1086          self.networkCurve = curve
1087         
1088      self.edges = []
1089      self.minEdgeWeight = sys.maxint
1090      self.maxEdgeWeight = 0
1091     
1092      if visualizer == None:
1093          xMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()
1094          xMax = self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue()
1095          yMin = self.axisScaleDiv(QwtPlot.yLeft).interval().minValue()
1096          yMax = self.axisScaleDiv(QwtPlot.yLeft).interval().maxValue()
1097          self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.fontSize)
1098          self.tooltipNeighbours = 0
1099          self.replot()
1100          return
1101     
1102      self.nVertices = visualizer.graph.nVertices
1103      #add nodes
1104      for v in range(0, self.nVertices):
1105          self.vertices_old[v] = (None, [])
1106          vertex = NetworkVertex()
1107          vertex.index = v
1108          self.vertices.append(vertex)
1109     
1110      #build edge index
1111      row_ind = {}
1112      if visualizer.graph.links != None and len(visualizer.graph.links) > 0:
1113        for i, r in enumerate(visualizer.graph.links):
1114            u = int(r['u'].value)
1115            v = int(r['v'].value)
1116            u_dict = row_ind.get(u, {})
1117            v_dict = row_ind.get(v, {})
1118            u_dict[v] = i
1119            v_dict[u] = i
1120            row_ind[u] = u_dict
1121            row_ind[v] = v_dict
1122           
1123      #add edges
1124      for (i, j) in visualizer.graph.getEdges():
1125          self.edges_old[self.nEdges] = (None, i, j)
1126          edge = NetworkEdge()
1127          edge.u = self.vertices[i]
1128          edge.v = self.vertices[j]
1129         
1130          edge.weight = float(str(visualizer.graph[i, j][0])) 
1131             
1132          #print "weight:", edge.weight
1133         
1134          self.edges.append(edge)
1135          self.nEdges += 1
1136         
1137          if edge.weight != None and self.minEdgeWeight > edge.weight:
1138              self.minEdgeWeight = edge.weight
1139             
1140          elif edge.weight != None and self.maxEdgeWeight < edge.weight:
1141              self.maxEdgeWeight = edge.weight
1142           
1143          if visualizer.graph.directed:
1144              edge.arrowu = 0
1145              edge.arrowv = 1
1146         
1147          if not hasattr(visualizer.graph, 'links'):
1148            visualizer.graph.links = None
1149           
1150          if visualizer.graph.links != None and len(visualizer.graph.links) > 0:
1151              edge.links_index = row_ind[i + 1][j + 1]
1152              row = visualizer.graph.links[edge.links_index]
1153              edge.label = [str(row[r].value) for r in range(2, len(row))]
1154
1155              #indexes = [k for k, x in enumerate(visualizer.graph.links) if (str(int(x[0])) == str(j + 1) and str(int(x[1])) == str(int(i + 1)))]
1156              #for k in range(2, len(row[0])):
1157              #    edge.label.append(str(row[0][k]))
1158              #else:
1159              #    print i, j, "not found"
1160             
1161              #if len(indexes) == 1:
1162              #    edge.links_index = indexes[0]
1163                       
1164      if self.maxEdgeWeight < 10:
1165          self.maxEdgeSize = self.maxEdgeWeight
1166      else:
1167          self.maxEdgeSize = 10
1168         
1169      self.setEdgesSize()
1170      self.setVerticesSize()
1171     
1172      self.networkCurve.coors = visualizer.network.coors
1173      self.networkCurve.vertices = self.vertices
1174      self.networkCurve.edges = self.edges
1175      self.networkCurve.changed()
1176     
1177  def setEdgesSize(self):
1178      if self.maxEdgeWeight > self.minEdgeWeight:
1179          #print 'maxEdgeSize',self.maxEdgeSize
1180          #print 'maxEdgeWeight',self.maxEdgeWeight
1181          #print 'minEdgeWeight',self.minEdgeWeight
1182          k = (self.maxEdgeSize - 1) / (self.maxEdgeWeight - self.minEdgeWeight)
1183          for edge in self.edges:
1184              if edge.weight == None:
1185                  size = 1
1186                  edge.pen = QPen(edge.pen.color(), size)
1187                  edge.pen.setCapStyle(Qt.RoundCap)
1188              else:
1189                  if self.invertEdgeSize:
1190                      size = (self.maxEdgeWeight - edge.weight - self.minEdgeWeight) * k + 1
1191                  else:
1192                      size = (edge.weight - self.minEdgeWeight) * k + 1
1193                  edge.pen = QPen(edge.pen.color(), size)
1194                  edge.pen.setCapStyle(Qt.RoundCap)
1195      else:
1196          for edge in self.edges:
1197              edge.pen = QPen(edge.pen.color(), 1)
1198              edge.pen.setCapStyle(Qt.RoundCap)
1199             
1200  def setVerticesSize(self, column=None, inverted=0):
1201      if self.visualizer == None or self.visualizer.graph == None or self.visualizer.graph.items == None:
1202          return
1203     
1204      column = str(column)
1205     
1206      if column in self.visualizer.graph.items.domain or (column.startswith("num of ") and column.replace("num of ", "") in self.visualizer.graph.items.domain):
1207          values = []
1208         
1209          if column in self.visualizer.graph.items.domain:
1210              values = [x[column].value for x in self.visualizer.graph.items if not x[column].isSpecial()]
1211          else:
1212              values = [len(x[column.replace("num of ", "")].value.split(',')) for x in self.visualizer.graph.items]
1213       
1214          minVertexWeight = float(min(values or [0]))
1215          maxVertexWeight = float(max(values or [0]))
1216         
1217          if maxVertexWeight - minVertexWeight == 0:
1218              k = 1 #doesn't matter
1219          else:
1220              k = (self.maxVertexSize - self.minVertexSize) / (maxVertexWeight - minVertexWeight)
1221         
1222          def getValue(v):
1223              if v.isSpecial():
1224                  return minVertexWeight
1225              else:
1226                  return float(v)
1227               
1228          if inverted:
1229              for vertex in self.vertices:
1230                  if column in self.visualizer.graph.items.domain:
1231                      vertex.size = self.maxVertexSize - ((getValue(self.visualizer.graph.items[vertex.index][column]) - minVertexWeight) * k)
1232                  else:
1233                      vertex.size = self.maxVertexSize - ((len(self.visualizer.graph.items[vertex.index][column.replace("num of ", "")].value.split(',')) - minVertexWeight) * k)
1234                 
1235                 
1236                  vertex.pen.setWidthF(1 + float(vertex.size) / 20)
1237          else:
1238              for vertex in self.vertices:
1239                  if column in self.visualizer.graph.items.domain:
1240                      vertex.size = (getValue(self.visualizer.graph.items[vertex.index][column]) - minVertexWeight) * k + self.minVertexSize
1241                  else:
1242                      vertex.size = (float(len(self.visualizer.graph.items[vertex.index][column.replace("num of ", "")].value.split(','))) - minVertexWeight) * k + self.minVertexSize
1243                     
1244                  #print vertex.size
1245                  vertex.pen.setWidthF(1 + float(vertex.size) / 20)
1246      else:
1247          for vertex in self.vertices:
1248              vertex.size = self.maxVertexSize
1249              vertex.pen.setWidthF(1 + float(vertex.size) / 20)
1250   
1251  def updateCanvas(self):
1252      self.setAxisAutoScale(self.xBottom)
1253      self.setAxisAutoScale(self.yLeft)
1254      self.updateData()
1255      self.replot() 
1256 
1257  def zoomExtent(self):
1258      self.setAxisAutoScale(self.xBottom)
1259      self.setAxisAutoScale(self.yLeft)
1260      self.replot()
1261     
1262  def zoomSelection(self):
1263      selection = self.networkCurve.getSelectedVertices()
1264      if len(selection) > 0: 
1265          x = [self.visualizer.network.coors[0][v] for v in selection]
1266          y = [self.visualizer.network.coors[1][v] for v in selection]
1267
1268          oldXMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue()
1269          oldXMax = self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue()
1270          oldYMin = self.axisScaleDiv(QwtPlot.yLeft).interval().minValue()
1271          oldYMax = self.axisScaleDiv(QwtPlot.yLeft).interval().maxValue()
1272          newXMin = min(x)
1273          newXMax = max(x)
1274          newYMin = min(y)
1275          newYMax = max(y)
1276          self.zoomStack.append((oldXMin, oldXMax, oldYMin, oldYMax))
1277          self.setAxisScale(QwtPlot.xBottom, newXMin - 100, newXMax + 100)
1278          self.setAxisScale(QwtPlot.yLeft, newYMin - 100, newYMax + 100)
1279          self.replot()
1280                 
Note: See TracBrowser for help on using the repository browser.