source: orange/orange/OrangeWidgets/Unsupervised/OWNxCanvasQt.py @ 9424:9797fd77a215

Revision 9424:9797fd77a215, 30.5 KB checked in by miha <miha.stajdohar@…>, 2 years ago (diff)

Fixed a bug on remove all nodes.

Line 
1CIRCLE = 0
2SQUARE = 1
3ROUND_RECT = 2
4
5NOTHING = 0
6ZOOMING = 1
7SELECT_RECTANGLE = 2
8SELECT_POLYGON = 3
9MOVE_SELECTION = 100
10
11import Orange
12import random 
13import numpy
14
15from plot.owplot import *
16from plot.owpoint import *
17from plot.owtools import * 
18
19from orngScaleScatterPlotData import *
20import orangeqt
21
22class NodeItem(orangeqt.NodeItem):
23    def __init__(self, index, x=None, y=None, parent=None):
24        orangeqt.NodeItem.__init__(self, index, OWPoint.Ellipse, Qt.blue, 5, parent)
25        if x is not None:
26            self.set_x(x)
27        if y is not None:
28            self.set_y(y)
29       
30class EdgeItem(orangeqt.EdgeItem):
31    def __init__(self, u=None, v=None, weight=1, links_index=0, arrows=None, label='', parent=None):
32        orangeqt.EdgeItem.__init__(self, u, v, parent)
33        self.set_weight(weight)
34        self.set_links_index(links_index)
35        if arrows is not None:
36            self.set_arrows(arrows)
37
38class NetworkCurve(orangeqt.NetworkCurve):
39    def __init__(self, parent=None, pen=QPen(Qt.black), xData=None, yData=None):
40        orangeqt.NetworkCurve.__init__(self, parent)
41        self.name = "Network Curve"
42       
43    def layout_fr(self, steps, weighted=False, smooth_cooling=False):
44        orangeqt.NetworkCurve.fr(self, steps, weighted, smooth_cooling)
45     
46    def set_node_sizes(self, values={}, min_size=0, max_size=0):
47        orangeqt.NetworkCurve.set_node_sizes(self, values, min_size, max_size)
48   
49    def fragviz_callback(self, a, b, mds, mdsRefresh, components, progress_callback):
50        """Refresh the UI when running  MDS on network components."""
51       
52        if not self.mdsStep % mdsRefresh:
53            rotationOnly = False
54            component_props = []
55            x_mds = []
56            y_mds = []
57            phi = [None] * len(components)
58            nodes = self.nodes()
59           
60            for i, component in enumerate(components):   
61               
62                if len(mds.points) == len(components):  # if average linkage before
63                    x_avg_mds = mds.points[i][0]
64                    y_avg_mds = mds.points[i][1]
65                else:                                   # if not average linkage before
66                    x = [mds.points[u][0] for u in component]
67                    y = [mds.points[u][1] for u in component]
68           
69                    x_avg_mds = sum(x) / len(x) 
70                    y_avg_mds = sum(y) / len(y)
71                    # compute rotation angle
72#                    c = [numpy.linalg.norm(numpy.cross(mds.points[u], \
73#                                [nodes[u].x(), nodes[u].y()])) for u in component]
74#                   
75#                    n = [numpy.vdot([nodes[u].x(), nodes[u].y()], \
76#                                    [nodes[u].x(), nodes[u].y()]) for u in component]
77#                    phi[i] = sum(c) / sum(n)
78                   
79               
80                x = [nodes[i].x() for i in component]
81                y = [nodes[i].y() for i in component]
82               
83                x_avg_graph = sum(x) / len(x)
84                y_avg_graph = sum(y) / len(y)
85               
86                x_mds.append(x_avg_mds) 
87                y_mds.append(y_avg_mds)
88   
89                component_props.append((x_avg_graph, y_avg_graph, \
90                                        x_avg_mds, y_avg_mds, phi))
91
92            for i, component in enumerate(components):
93                x_avg_graph, y_avg_graph, x_avg_mds, \
94                y_avg_mds, phi = component_props[i]
95               
96    #            if phi[i]:  # rotate vertices
97    #                #print "rotate", i, phi[i]
98    #                r = numpy.array([[numpy.cos(phi[i]), -numpy.sin(phi[i])], [numpy.sin(phi[i]), numpy.cos(phi[i])]])  #rotation matrix
99    #                c = [x_avg_graph, y_avg_graph]  # center of mass in FR coordinate system
100    #                v = [numpy.dot(numpy.array([self.graph.coors[0][u], self.graph.coors[1][u]]) - c, r) + c for u in component]
101    #                self.graph.coors[0][component] = [u[0] for u in v]
102    #                self.graph.coors[1][component] = [u[1] for u in v]
103                   
104                # translate vertices
105                if not rotationOnly:
106                    self.set_node_coordinates(dict(
107                       (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds, 
108                            (nodes[i].y() - y_avg_graph) + y_avg_mds)) \
109                                  for i in component))
110                   
111            #if self.mdsType == MdsType.exactSimulation:
112            #    self.mds.points = [[self.graph.coors[0][i], \
113            #                        self.graph.coors[1][i]] \
114            #                        for i in range(len(self.graph.coors))]
115            #    self.mds.freshD = 0
116           
117            #self.update_properties()
118            self.plot().replot()
119            qApp.processEvents()
120           
121            if progress_callback is not None:
122                progress_callback(a, self.mdsStep) 
123           
124        self.mdsStep += 1
125        return 0 if self.stopMDS else 1
126           
127    def layout_fragviz(self, steps, distances, graph, progress_callback=None, opt_from_curr=False):
128        """Position the network components according to similarities among
129        them.
130       
131        """
132
133        if distances == None or graph == None or distances.dim != graph.number_of_nodes():
134            self.information('invalid or no distance matrix')
135            return 1
136       
137        p = self.plot()
138        edges = self.edges()
139        nodes = self.nodes()
140       
141        avgLinkage = True
142        rotationOnly = False
143        minStressDelta = 0
144        mdsRefresh = int(steps / 20)
145       
146        self.mdsStep = 1
147        self.stopMDS = False
148       
149        components = Orange.network.nx.algorithms.components.connected.connected_components(graph)
150        distances.matrixType = Orange.core.SymMatrix.Symmetric
151       
152        # scale net coordinates
153        if avgLinkage:
154            distances = distances.avgLinkage(components)
155           
156        mds = Orange.projection.mds.MDS(distances)
157        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0)
158        rect = self.data_rect()
159        w_fr = rect.width()
160        h_fr = rect.height()
161        d_fr = math.sqrt(w_fr**2 + h_fr**2)
162     
163        x_mds = [mds.points[u][0] for u in range(len(mds.points))]
164        y_mds = [mds.points[u][1] for u in range(len(mds.points))]
165        w_mds = max(x_mds) - min(x_mds)
166        h_mds = max(y_mds) - min(y_mds)
167        d_mds = math.sqrt(w_mds**2 + h_mds**2)
168       
169        animate_points = p.animate_points
170        p.animate_points = False
171       
172        self.set_node_coordinates(dict(
173           (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes))
174       
175        #self.update_properties()
176        p.replot()
177        qApp.processEvents()
178                     
179        if opt_from_curr:
180            if avgLinkage:
181                for u, c in enumerate(components):
182                    x = sum([nodes[n].x() for n in c]) / len(c)
183                    y = sum([nodes[n].y() for n in c]) / len(c)
184                    mds.points[u][0] = x
185                    mds.points[u][1] = y
186            else:
187                for i,u in enumerate(sorted(nodes.iterkeys())):
188                    mds.points[i][0] = nodes[u].x()
189                    mds.points[i][1] = nodes[u].y()
190        else:
191            mds.Torgerson() 
192
193        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
194                     progressCallback=
195                         lambda a, 
196                                b=None, 
197                                mds=mds,
198                                mdsRefresh=mdsRefresh,
199                                components=components,
200                                progress_callback=progress_callback: 
201                                    self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback))
202       
203        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback)
204       
205        if progress_callback != None:
206            progress_callback(mds.avgStress, self.mdsStep)
207       
208        p.animate_points = animate_points
209        return 0
210   
211    def mds_callback(self, a, b, mds, mdsRefresh, progress_callback):
212        """Refresh the UI when running  MDS."""
213       
214        if not self.mdsStep % mdsRefresh:
215           
216            self.set_node_coordinates(dict((u, (mds.points[u][0], \
217                                                mds.points[u][1])) for u in \
218                                           range(len(mds.points))))
219            self.plot().replot()
220            qApp.processEvents()
221           
222            if progress_callback is not None:
223                progress_callback(a, self.mdsStep) 
224           
225        self.mdsStep += 1
226        return 0 if self.stopMDS else 1
227   
228    def layout_mds(self, steps, distances, progress_callback=None, opt_from_curr=False):
229        """Position the network components according to similarities among
230        them.
231       
232        """
233        nodes = self.nodes()
234       
235        if distances == None or distances.dim != len(nodes):
236            self.information('invalid or no distance matrix')
237            return 1
238       
239        p = self.plot()
240       
241        minStressDelta = 0
242        mdsRefresh = int(steps / 20)
243       
244        self.mdsStep = 1
245        self.stopMDS = False
246       
247        distances.matrixType = Orange.core.SymMatrix.Symmetric
248        mds = Orange.projection.mds.MDS(distances)
249        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0)
250        rect = self.data_rect()
251        w_fr = rect.width()
252        h_fr = rect.height()
253        d_fr = math.sqrt(w_fr**2 + h_fr**2)
254     
255        x_mds = [mds.points[u][0] for u in range(len(mds.points))]
256        y_mds = [mds.points[u][1] for u in range(len(mds.points))]
257        w_mds = max(x_mds) - min(x_mds)
258        h_mds = max(y_mds) - min(y_mds)
259        d_mds = math.sqrt(w_mds**2 + h_mds**2)
260       
261        animate_points = p.animate_points
262        p.animate_points = False
263       
264        self.set_node_coordinates(dict(
265           (n, (nodes[n].x()*d_mds/d_fr, nodes[n].y()*d_mds/d_fr)) for n in nodes))
266       
267        p.replot()
268        qApp.processEvents()
269                     
270        if opt_from_curr:
271            for i,u in enumerate(sorted(nodes.iterkeys())):
272                mds.points[i][0] = nodes[u].x()
273                mds.points[i][1] = nodes[u].y()
274        else:
275            mds.Torgerson() 
276
277        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
278                     progressCallback=
279                         lambda a, 
280                                b=None, 
281                                mds=mds,
282                                mdsRefresh=mdsRefresh,
283                                progress_callback=progress_callback: 
284                                    self.mds_callback(a, b, mds, mdsRefresh, progress_callback))
285       
286        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback)
287       
288        if progress_callback != None:
289            progress_callback(mds.avgStress, self.mdsStep)
290       
291        p.animate_points = animate_points
292        return 0
293   
294#    def move_selected_nodes(self, dx, dy):
295#        selected = self.get_selected_nodes()
296#       
297#        self.coors[selected][0] = self.coors[0][selected] + dx
298#        self.coors[1][selected][1] = self.coors[1][selected] + dy
299#         
300#        self.update_properties()
301#        return selected
302#       
303#    def set_hidden_nodes(self, nodes):
304#        for vertex in self.nodes().itervalues():
305#            vertex.setVisible(vertex.index() in nodes)
306#     
307#    def hide_selected_nodes(self):
308#        for vertex in self.nodes().itervalues():
309#          if vertex.selected:
310#            vertex.hide()
311
312#    def hide_unselected_nodes(self):
313#        for vertex in self.nodes().itervalues():
314#          if not vertex.selected:
315#            vertex.hide()
316#   
317#    def show_all_vertices(self):
318#        for vertex in self.nodes().itervalues():
319#          vertex.show()
320   
321   
322       
323class OWNxCanvas(OWPlot):
324    def __init__(self, master, parent=None, name="None"):
325        OWPlot.__init__(self, parent, name, axes=[])
326        self.master = master
327        self.parent = parent
328        self.NodeItem = NodeItem
329        self.graph = None
330       
331        self.circles = []
332        self.freezeNeighbours = False
333        self.labelsOnMarkedOnly = 0
334
335        self.show_indices = False
336        self.show_weights = False
337        self.trim_label_words = 0
338        self.explore_distances = False
339        self.show_component_distances = False
340       
341        self.showComponentAttribute = None
342        self.forceVectors = None
343        #self.appendToSelection = 1
344        self.fontSize = 12
345             
346        self.networkCurve = NetworkCurve()
347        self.add_custom_curve(self.networkCurve)
348       
349        self.minComponentEdgeWidth = 0
350        self.maxComponentEdgeWidth = 0
351        self.items_matrix = None
352         
353        self.items = None
354        self.links = None
355        self.edge_to_row = None
356       
357        self.node_label_attributes = []
358        self.edge_label_attributes = []
359       
360        self.axis_margin = 0
361        self.title_margin = 0
362        self.graph_margin = 1
363        self._legend_margin = QRectF(0, 0, 0, 0)
364       
365        #self.setFocusPolicy(Qt.StrongFocus)
366       
367    def update_canvas(self):
368        self.networkCurve.update_properties()
369        self.drawComponentKeywords()
370        self.replot()
371       
372    def set_hidden_nodes(self, nodes):
373        self.networkCurve.set_hidden_nodes(nodes)
374   
375    def hide_selected_nodes(self):
376      self.networkCurve.hide_selected_nodes()
377      self.drawPlotItems()
378     
379    def hide_unselected_nodes(self):
380      self.networkCurve.hide_unselected_nodes()
381      self.drawPlotItems()
382     
383    def show_all_vertices(self):
384      self.networkCurve.show_all_vertices()
385      self.drawPlotItems()
386   
387    def selected_nodes(self):
388        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_selected()]
389        #return [p.index() for p in self.selected_points()]
390       
391    def not_selected_nodes(self):
392        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_selected()]
393       
394    def marked_nodes(self):
395        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_marked()]
396        #return [p.index() for p in self.marked_points()]
397       
398    def not_marked_nodes(self):
399        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_marked()]   
400   
401    def get_neighbors_upto(self, ndx, dist):
402        newNeighbours = neighbours = set([ndx])
403        for d in range(dist):
404            tNewNeighbours = set()
405            for v in newNeighbours:
406                tNewNeighbours |= set(self.graph.neighbors(v))
407            newNeighbours = tNewNeighbours - neighbours
408            neighbours |= newNeighbours
409        return neighbours
410   
411    def mark_on_selection_changed(self):
412        toMark = set()
413        for ndx in self.selected_nodes():
414            toMark |= self.get_neighbors_upto(ndx, self.mark_neighbors)
415       
416        self.networkCurve.clear_node_marks()
417        self.networkCurve.set_node_marks(dict((i, True) for i in toMark))
418   
419    def mark_on_focus_changed(self, node):
420        self.networkCurve.clear_node_marks()
421       
422        if node is not None:
423            toMark = set(self.get_neighbors_upto(node.index(), self.mark_neighbors))
424            self.networkCurve.set_node_marks(dict((i, True) for i in toMark))
425       
426    def drawComponentKeywords(self):
427        self.clear_markers()
428        if self.showComponentAttribute == None or self.graph is None or self.items is None:
429            return
430       
431        if str(self.showComponentAttribute) not in self.items.domain:
432            self.showComponentAttribute = None
433            return
434       
435        components = Orange.network.nx.algorithms.components.connected_components(self.graph)
436        nodes = self.networkCurve.nodes()
437       
438        for c in components:
439            if len(c) == 0:
440                continue
441           
442            x1 = sum(nodes[n].x() for n in c) / len(c)
443            y1 = sum(nodes[n].y() for n in c) / len(c)
444            lbl = str(self.items[c[0]][str(self.showComponentAttribute)])
445           
446            self.add_marker(lbl, x1, y1, alignment=Qt.AlignCenter, size=self.fontSize)
447           
448            #mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize)
449                           
450    def getColorIndeces(self, table, attribute, palette):
451        colorIndices = {}
452        colorIndex = None
453        minValue = None
454        maxValue = None
455       
456        if attribute[0] != "(" or attribute[ -1] != ")":
457            i = 0
458            for var in table.domain.variables:
459                if var.name == attribute:
460                    colorIndex = i
461                    if var.varType == orange.VarTypes.Discrete: 
462                        colorIndices = getVariableValueIndices(var, colorIndex)
463                       
464                i += 1
465            metas = table.domain.getmetas()
466            for i, var in metas.iteritems():
467                if var.name == attribute:
468                    colorIndex = i
469                    if var.varType == orange.VarTypes.Discrete: 
470                        colorIndices = getVariableValueIndices(var, colorIndex)
471   
472        colorIndices['?'] = len(colorIndices)
473        palette.setNumberOfColors(len(colorIndices))
474       
475        if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous:
476            minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0]))
477            maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0]))
478           
479        return colorIndices, colorIndex, minValue, maxValue
480   
481    def set_node_colors(self, attribute, nodes=None):
482        if self.graph is None:
483            return
484
485        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette)
486        colors = {}
487       
488        if nodes is None:
489            nodes = self.graph.nodes()
490       
491        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue:
492            colors.update((node, self.discPalette[0]) for node in nodes)
493       
494        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous:
495            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)]) 
496                          if str(self.items[v][colorIndex].value) != '?' else 
497                          (v, self.discPalette[0]) for v in nodes)
498
499        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete:
500            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes)
501           
502        else:
503            colors.update((node, self.discPalette[0]) for node in nodes)
504       
505        self.networkCurve.set_node_colors(colors)
506        self.replot()
507       
508    def set_node_labels(self, attributes=None):
509        if self.graph is None:
510            return 
511       
512        nodes = self.graph.nodes()
513       
514        if attributes is not None:
515            self.node_label_attributes = attributes
516       
517        label_attributes = []
518        if self.items is not None and isinstance(self.items, orange.ExampleTable):
519            label_attributes = [self.items.domain[att] for att in \
520                self.node_label_attributes if att in self.items.domain]
521           
522        indices = [[] for u in nodes]
523        if self.show_indices:
524            indices = [[str(u)] for u in nodes]
525       
526        if len(label_attributes) == 0 and not self.show_indices:
527            self.networkCurve.set_node_labels({})
528       
529        elif self.trim_label_words > 0:
530            self.networkCurve.set_node_labels(dict((node, 
531                ', '.join(indices[i] + 
532                          [' '.join(str(self.items[node][att]).split(' ')[:min(self.trim_label_words,len(str(self.items[node][att]).split(' ')))])
533                for att in label_attributes])) for i, node in enumerate(nodes)))
534        else:
535            self.networkCurve.set_node_labels(dict((node, ', '.join(indices[i]+\
536                           [str(self.items[node][att]) for att in \
537                           label_attributes])) for i, node in enumerate(nodes)))
538       
539        self.replot()
540       
541   
542    def set_edge_colors(self, attribute):
543        if self.graph is None:
544            return
545       
546        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discPalette)
547        colors = []
548       
549        if colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue:
550            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()]
551       
552        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous:
553            colors = [self.contPalette[(float(self.links[edge.links_index()][colorIndex].value) - minValue) / (maxValue - minValue)]
554                          if str(self.links[edge.links_index()][colorIndex].value) != '?' else 
555                          self.discPalette[0] for edge in self.networkCurve.edges()]
556           
557        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Discrete:
558            colors = [self.discEdgePalette[colorIndices[self.links[edge.links_index()][colorIndex].value]] for edge in self.networkCurve.edges()]
559           
560        else:
561            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()]
562           
563        self.networkCurve.set_edge_colors(colors)
564        self.replot()
565       
566    def set_edge_labels(self, attributes=None):
567        if self.graph is None:
568            return 
569       
570        edges = self.networkCurve.edge_indices()
571       
572        if attributes is not None:
573            self.edge_label_attributes = attributes
574       
575        label_attributes = []
576        if self.links is not None and isinstance(self.links, orange.ExampleTable):
577            label_attributes = [self.links.domain[att] for att in \
578                self.edge_label_attributes if att in self.links.domain]
579           
580        weights = [[] for ex in edges]
581        if self.show_weights:
582            weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u,v in edges]
583           
584        self.networkCurve.set_edge_labels([', '.join(weights[i] + \
585                           [str(self.links[i][att]) for att in \
586                           label_attributes]) for i,edge in enumerate(edges)])
587       
588        self.replot()
589       
590    def set_tooltip_attributes(self, attributes):
591        if self.graph is None or self.items is None or \
592           not isinstance(self.items, orange.ExampleTable):
593            return
594       
595        tooltip_attributes = [self.items.domain[att] for att in \
596                                 attributes if att in self.items.domain]
597        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \
598                   self.items[node][att]) for att in tooltip_attributes)) \
599                                                        for node in self.graph))
600               
601    def change_graph(self, newgraph):
602        old_nodes = set(self.graph.nodes_iter())
603        new_nodes = set(newgraph.nodes_iter())
604        inter_nodes = old_nodes.intersection(new_nodes)
605        remove_nodes = list(old_nodes.difference(inter_nodes))
606        add_nodes = list(new_nodes.difference(inter_nodes))
607       
608        self.graph = newgraph
609       
610        if len(remove_nodes) == 0 and len(add_nodes) == 0:
611            return False
612       
613        current_nodes = self.networkCurve.nodes()
614       
615        center_x = numpy.average([node.x() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0
616        center_y = numpy.average([node.y() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0
617       
618        def closest_nodes_with_pos(nodes):
619           
620            neighbors = set()
621            for n in nodes:
622                neighbors |= set(self.graph.neighbors(n))
623
624            # checked all, none found           
625            if len(neighbors - nodes) == 0:
626                return []
627           
628            inter = old_nodes.intersection(neighbors)
629            if len(inter) > 0:
630                return inter
631            else:
632                return closest_nodes_with_pos(neighbors | nodes)
633       
634        pos = dict((n, [numpy.average(c) for c in zip(*[(current_nodes[u].x(), current_nodes[u].y()) for u in closest_nodes_with_pos(set([n]))])]) for n in add_nodes)
635       
636        self.networkCurve.remove_nodes(list(remove_nodes))
637       
638        nodes = dict((v, self.NodeItem(v, x=pos[v][0] if len(pos[v]) == 2 else center_x, y=pos[v][1] if len(pos[v]) == 2 else center_y, parent=self.networkCurve)) for v in add_nodes)
639        self.networkCurve.add_nodes(nodes)
640        nodes = self.networkCurve.nodes()
641       
642        #add edges
643        new_edges = self.graph.edges(add_nodes)
644       
645        if self.links is not None and len(self.links) > 0:
646            links = self.links
647            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in new_edges)
648           
649            if self.graph.is_directed():
650                edges = [EdgeItem(nodes[i], nodes[j],
651                    self.graph[i][j].get('weight', 1), links_index, arrows=EdgeItem.ArrowV, \
652                    parent=self.networkCurve) for ((i, j), links_index) in \
653                         zip(new_edges, links_indices)]
654            else:
655                edges = [EdgeItem(nodes[i], nodes[j],
656                    self.graph[i][j].get('weight', 1), links_index) for \
657                    ((i, j), links_index) in zip(new_edges, \
658                                        links_indices, parent=self.networkCurve)]
659        elif self.graph.is_directed():
660            edges = [EdgeItem(nodes[i], nodes[j], self.graph[i][j].get('weight', 1), \
661                    arrows=EdgeItem.ArrowV, parent=self.networkCurve) for (i, j) in new_edges]
662        else:
663            edges = [EdgeItem(nodes[i], nodes[j], self.graph[i][j].get('weight', 1), \
664                    parent=self.networkCurve) for (i, j) in new_edges]
665           
666        self.networkCurve.add_edges(edges)
667       
668        if len(current_nodes) < 3:
669            self.networkCurve.random()
670       
671        return True
672       
673    def set_graph(self, graph, curve=None, items=None, links=None):
674        self.clear()
675       
676        if graph is None:
677            self.graph = None
678            self.networkCurve = None
679            self.items = None
680            self.links = None
681            xMin = -1.0
682            xMax = 1.0
683            yMin = -1.0
684            yMax = 1.0
685            self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.fontSize)
686            self.replot()
687            return
688       
689        self.graph = graph
690        self.networkCurve = NetworkCurve() if curve is None else curve()
691        self.add_custom_curve(self.networkCurve)
692       
693        self.items = items if items is not None else self.graph.items()
694        self.links = links if links is not None else self.graph.links()
695       
696        #add nodes
697        #self.vertices_old = [(None, []) for v in self.graph]
698        vertices = dict((v, self.NodeItem(v, parent=self.networkCurve)) for v in self.graph)
699        self.networkCurve.set_nodes(vertices)
700               
701        #build edge to row index
702        self.edge_to_row = {}
703        if self.links is not None and len(self.links) > 0:
704            for i, r in enumerate(self.links):
705                u = int(r['u'].value)
706                v = int(r['v'].value)
707                if u - 1 in self.graph and v - 1 in self.graph:
708                    u_dict = self.edge_to_row.get(u, {})
709                    v_dict = self.edge_to_row.get(v, {})
710                    u_dict[v] = i
711                    v_dict[u] = i
712                    self.edge_to_row[u] = u_dict
713                    self.edge_to_row[v] = v_dict
714                else:
715                    print 'could not find edge', u, v
716             
717        #add edges
718        if self.links is not None and len(self.links) > 0:
719            links = self.links
720            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in self.graph.edges())
721           
722            if self.graph.is_directed():
723                edges = [EdgeItem(vertices[i], vertices[j],
724                    graph[i][j].get('weight', 1), links_index, arrows=EdgeItem.ArrowV, \
725                    parent=self.networkCurve) for ((i, j), links_index) in \
726                         zip(self.graph.edges(), links_indices)]
727            else:
728                edges = [EdgeItem(vertices[i], vertices[j],
729                    graph[i][j].get('weight', 1), links_index, \
730                    parent=self.networkCurve) for ((i, j), links_index) in \
731                         zip(self.graph.edges(), links_indices)]
732               
733        elif self.graph.is_directed():
734            edges = [EdgeItem(vertices[i], vertices[j],
735                                      graph[i][j].get('weight', 1), arrows=EdgeItem.ArrowV, parent=self.networkCurve) for (i, j) in self.graph.edges()]
736        else:
737            edges = [EdgeItem(vertices[i], vertices[j],
738                                      graph[i][j].get('weight', 1), parent=self.networkCurve) for (i, j) in self.graph.edges()]
739           
740        self.networkCurve.set_edges(edges)
741        self.networkCurve.update_properties()
742        self.replot() 
743   
744    def update_animations(self, use_animations=None):
745        OWPlot.update_animations(self, use_animations)
746        self.networkCurve.set_use_animations(self.use_animations)
747
748    def set_labels_on_marked(self, labelsOnMarkedOnly):
749        self.networkCurve.set_labels_on_marked(labelsOnMarkedOnly)
750        self.set_node_labels()
751        self.replot()
752   
753    def set_show_component_distances(self):
754        self.networkCurve.set_show_component_distances(self.show_component_distances)
755        self.replot()
756       
757    def replot(self):
758       
759                #, alignment = -1, bold = 0, color = None, brushColor = None, size=None, antiAlias = None, x_axis_key = xBottom, y_axis_key = yLeft):
760        self.set_dirty()
761        OWPlot.replot(self)
762        if hasattr(self, 'networkCurve') and self.networkCurve is not None:
763            self.networkCurve.update()
764           
Note: See TracBrowser for help on using the repository browser.