source: orange/Orange/OrangeWidgets/Unsupervised/OWNxCanvasQt.py @ 10854:e1100b7b4761

Revision 10854:e1100b7b4761, 29.4 KB checked in by anze <anze.staric@…>, 2 years ago (diff)

Fixed imports of orangeqt

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 *
20from Orange import 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        # if only one component
157        if distances.dim == 1:
158            return 0
159
160        mds = Orange.projection.mds.MDS(distances)
161        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0)
162        rect = self.data_rect()
163        w_fr = rect.width()
164        h_fr = rect.height()
165        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2)
166
167        x_mds = [mds.points[u][0] for u in range(len(mds.points))]
168        y_mds = [mds.points[u][1] for u in range(len(mds.points))]
169        w_mds = max(x_mds) - min(x_mds)
170        h_mds = max(y_mds) - min(y_mds)
171        d_mds = math.sqrt(w_mds ** 2 + h_mds ** 2)
172
173        animate_points = p.animate_points
174        p.animate_points = False
175
176        # if only one component
177        if d_mds == 0 or d_fr == 0:
178            d_mds = 1
179            d_fr = 1
180
181        self.set_node_coordinates(dict(
182           (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes))
183
184        #self.update_properties()
185        p.replot()
186        qApp.processEvents()
187
188        if opt_from_curr:
189            if avgLinkage:
190                for u, c in enumerate(components):
191                    x = sum([nodes[n].x() for n in c]) / len(c)
192                    y = sum([nodes[n].y() for n in c]) / len(c)
193                    mds.points[u][0] = x
194                    mds.points[u][1] = y
195            else:
196                for i, u in enumerate(sorted(nodes.iterkeys())):
197                    mds.points[i][0] = nodes[u].x()
198                    mds.points[i][1] = nodes[u].y()
199        else:
200            mds.Torgerson()
201
202        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,
203                     progressCallback=
204                         lambda a,
205                                b=None,
206                                mds=mds,
207                                mdsRefresh=mdsRefresh,
208                                components=components,
209                                progress_callback=progress_callback:
210                                    self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback))
211
212        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback)
213
214        if progress_callback != None:
215            progress_callback(mds.avgStress, self.mdsStep)
216
217        p.animate_points = animate_points
218        return 0
219
220    def mds_callback(self, a, b, mds, mdsRefresh, progress_callback):
221        """Refresh the UI when running  MDS."""
222
223        if not self.mdsStep % mdsRefresh:
224
225            self.set_node_coordinates(dict((u, (mds.points[u][0], \
226                                                mds.points[u][1])) for u in \
227                                           range(len(mds.points))))
228            self.plot().replot()
229            qApp.processEvents()
230
231            if progress_callback is not None:
232                progress_callback(a, self.mdsStep)
233
234        self.mdsStep += 1
235        return 0 if self.stopMDS else 1
236
237    def layout_mds(self, steps, distances, progress_callback=None, opt_from_curr=False):
238        """Position the network components according to similarities among
239        them.
240       
241        """
242        nodes = self.nodes()
243
244        if distances == None or distances.dim != len(nodes):
245            self.information('invalid or no distance matrix')
246            return 1
247
248        p = self.plot()
249
250        minStressDelta = 0
251        mdsRefresh = int(steps / 20)
252
253        self.mdsStep = 1
254        self.stopMDS = False
255
256        distances.matrixType = Orange.core.SymMatrix.Symmetric
257        mds = Orange.projection.mds.MDS(distances)
258        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0)
259        rect = self.data_rect()
260        w_fr = rect.width()
261        h_fr = rect.height()
262        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2)
263
264        x_mds = [mds.points[u][0] for u in range(len(mds.points))]
265        y_mds = [mds.points[u][1] for u in range(len(mds.points))]
266        w_mds = max(x_mds) - min(x_mds)
267        h_mds = max(y_mds) - min(y_mds)
268        d_mds = math.sqrt(w_mds ** 2 + h_mds ** 2)
269
270        animate_points = p.animate_points
271        p.animate_points = False
272
273        self.set_node_coordinates(dict(
274           (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes))
275
276        p.replot()
277        qApp.processEvents()
278
279        if opt_from_curr:
280            for i, u in enumerate(sorted(nodes.iterkeys())):
281                mds.points[i][0] = nodes[u].x()
282                mds.points[i][1] = nodes[u].y()
283        else:
284            mds.Torgerson()
285
286        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,
287                     progressCallback=
288                         lambda a,
289                                b=None,
290                                mds=mds,
291                                mdsRefresh=mdsRefresh,
292                                progress_callback=progress_callback:
293                                    self.mds_callback(a, b, mds, mdsRefresh, progress_callback))
294
295        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback)
296
297        if progress_callback != None:
298            progress_callback(mds.avgStress, self.mdsStep)
299
300        p.animate_points = animate_points
301        return 0
302
303#    def move_selected_nodes(self, dx, dy):
304#        selected = self.get_selected_nodes()
305#       
306#        self.coors[selected][0] = self.coors[0][selected] + dx
307#        self.coors[1][selected][1] = self.coors[1][selected] + dy
308#         
309#        self.update_properties()
310#        return selected
311#       
312#    def set_hidden_nodes(self, nodes):
313#        for vertex in self.nodes().itervalues():
314#            vertex.setVisible(vertex.index() in nodes)
315#     
316#    def hide_selected_nodes(self):
317#        for vertex in self.nodes().itervalues():
318#          if vertex.selected:
319#            vertex.hide()
320
321#    def hide_unselected_nodes(self):
322#        for vertex in self.nodes().itervalues():
323#          if not vertex.selected:
324#            vertex.hide()
325#   
326#    def show_all_vertices(self):
327#        for vertex in self.nodes().itervalues():
328#          vertex.show()
329
330
331
332class OWNxCanvas(OWPlot):
333    def __init__(self, master, parent=None, name="None"):
334        OWPlot.__init__(self, parent, name, axes=[])
335        self.master = master
336        self.parent = parent
337        self.NodeItem = NodeItem
338        self.graph = None
339
340        self.circles = []
341        self.freezeNeighbours = False
342        self.labelsOnMarkedOnly = 0
343
344        self.show_indices = False
345        self.show_weights = False
346        self.trim_label_words = 0
347        self.show_component_distances = False
348
349        self.showComponentAttribute = None
350        self.forceVectors = None
351        #self.appendToSelection = 1
352        self.fontSize = 12
353
354        self.networkCurve = NetworkCurve()
355        self.add_custom_curve(self.networkCurve)
356
357        self.minComponentEdgeWidth = 0
358        self.maxComponentEdgeWidth = 0
359        self.items_matrix = None
360
361        self.items = None
362        self.links = None
363        self.edge_to_row = None
364        self.label_distances = None
365
366        self.node_label_attributes = []
367        self.edge_label_attributes = []
368
369        self.axis_margin = 0
370        self.title_margin = 0
371        self.graph_margin = 1
372        self._legend_margin = QRectF(0, 0, 0, 0)
373
374        #self.setFocusPolicy(Qt.StrongFocus)
375
376    def update_canvas(self):
377        self.networkCurve.update_properties()
378        self.drawComponentKeywords()
379        self.replot()
380
381    def set_hidden_nodes(self, nodes):
382        self.networkCurve.set_hidden_nodes(nodes)
383
384    def hide_selected_nodes(self):
385      self.networkCurve.hide_selected_nodes()
386      self.drawPlotItems()
387
388    def hide_unselected_nodes(self):
389      self.networkCurve.hide_unselected_nodes()
390      self.drawPlotItems()
391
392    def show_all_vertices(self):
393      self.networkCurve.show_all_vertices()
394      self.drawPlotItems()
395
396    def selected_nodes(self):
397        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_selected()]
398        #return [p.index() for p in self.selected_points()]
399
400    def not_selected_nodes(self):
401        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_selected()]
402
403    def marked_nodes(self):
404        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_marked()]
405        #return [p.index() for p in self.marked_points()]
406
407    def not_marked_nodes(self):
408        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_marked()]
409
410    def get_neighbors_upto(self, ndx, dist):
411        newNeighbours = neighbours = set([ndx])
412        for d in range(dist):
413            tNewNeighbours = set()
414            for v in newNeighbours:
415                tNewNeighbours |= set(self.graph.neighbors(v))
416            newNeighbours = tNewNeighbours - neighbours
417            neighbours |= newNeighbours
418        return neighbours
419
420    def mark_on_selection_changed(self):
421        toMark = set()
422        for ndx in self.selected_nodes():
423            toMark |= self.get_neighbors_upto(ndx, self.mark_neighbors)
424
425        self.networkCurve.clear_node_marks()
426        self.networkCurve.set_node_marks(dict((i, True) for i in toMark))
427
428    def mark_on_focus_changed(self, node):
429        self.networkCurve.clear_node_marks()
430
431        if node is not None:
432            toMark = set(self.get_neighbors_upto(node.index(), self.mark_neighbors))
433            self.networkCurve.set_node_marks(dict((i, True) for i in toMark))
434
435    def drawComponentKeywords(self):
436        self.clear_markers()
437        if self.showComponentAttribute == None or self.graph is None or self.items is None:
438            return
439
440        if str(self.showComponentAttribute) not in self.items.domain:
441            self.showComponentAttribute = None
442            return
443
444        components = Orange.network.nx.algorithms.components.connected_components(self.graph)
445        nodes = self.networkCurve.nodes()
446
447        for c in components:
448            if len(c) == 0:
449                continue
450
451            x1 = sum(nodes[n].x() for n in c) / len(c)
452            y1 = sum(nodes[n].y() for n in c) / len(c)
453            lbl = str(self.items[c[0]][str(self.showComponentAttribute)])
454
455            self.add_marker(lbl, x1, y1, alignment=Qt.AlignCenter, size=self.fontSize)
456
457    def getColorIndeces(self, table, attribute, palette):
458        colorIndices = {}
459        colorIndex = None
460        minValue = None
461        maxValue = None
462
463        if attribute[0] != "(" or attribute[ -1] != ")":
464            i = 0
465            for var in table.domain.variables:
466                if var.name == attribute:
467                    colorIndex = i
468                    if var.varType == orange.VarTypes.Discrete:
469                        colorIndices = getVariableValueIndices(var, colorIndex)
470
471                i += 1
472            metas = table.domain.getmetas()
473            for i, var in metas.iteritems():
474                if var.name == attribute:
475                    colorIndex = i
476                    if var.varType == orange.VarTypes.Discrete:
477                        colorIndices = getVariableValueIndices(var, colorIndex)
478
479        colorIndices['?'] = len(colorIndices)
480        palette.setNumberOfColors(len(colorIndices))
481
482        if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous:
483            minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0]))
484            maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0]))
485
486        return colorIndices, colorIndex, minValue, maxValue
487
488    def set_node_colors(self, attribute, nodes=None):
489        if self.graph is None:
490            return
491
492        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette)
493        colors = {}
494
495        if nodes is None:
496            nodes = self.graph.nodes()
497
498        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue:
499            colors.update((node, self.discPalette[0]) for node in nodes)
500
501        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous:
502            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)])
503                          if str(self.items[v][colorIndex].value) != '?' else
504                          (v, self.discPalette[0]) for v in nodes)
505
506        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete:
507            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes)
508
509        else:
510            colors.update((node, self.discPalette[0]) for node in nodes)
511
512        self.networkCurve.set_node_colors(colors)
513        self.replot()
514
515    def set_node_labels(self, attributes=None):
516        if self.graph is None:
517            return
518
519        nodes = self.graph.nodes()
520
521        if attributes is not None:
522            self.node_label_attributes = attributes
523
524        label_attributes = []
525        if self.items is not None and isinstance(self.items, orange.ExampleTable):
526            label_attributes = [self.items.domain[att] for att in \
527                self.node_label_attributes if att in self.items.domain]
528
529        indices = [[] for u in nodes]
530        if self.show_indices:
531            indices = [[str(u)] for u in nodes]
532
533        distances = [[] for u in nodes]
534        show_distances = False
535        if self.label_distances is not None and type(self.label_distances) == \
536                           type([]) and len(self.label_distances) == len(nodes):
537            distances = self.label_distances
538            show_distances = True
539
540        if len(label_attributes) == 0 and \
541                        not self.show_indices and not show_distances:
542            self.networkCurve.set_node_labels({})
543
544        elif self.trim_label_words > 0:
545            self.networkCurve.set_node_labels(dict((node,
546                ', '.join(distances[i] + indices[i] +
547                          [' '.join(str(self.items[node][att]).split(' ')[:min(self.trim_label_words, len(str(self.items[node][att]).split(' ')))])
548                for att in label_attributes])) for i, node in enumerate(nodes)))
549        else:
550            self.networkCurve.set_node_labels(dict((node, ', '.join(\
551                        distances[i] + indices[i] + \
552                           [str(self.items[node][att]) for att in \
553                           label_attributes])) for i, node in enumerate(nodes)))
554
555        self.replot()
556
557
558    def set_edge_colors(self, attribute):
559        if self.graph is None:
560            return
561
562        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discPalette)
563        colors = []
564
565        if colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue:
566            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()]
567
568        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous:
569            colors = [self.contPalette[(float(self.links[edge.links_index()][colorIndex].value) - minValue) / (maxValue - minValue)]
570                          if str(self.links[edge.links_index()][colorIndex].value) != '?' else
571                          self.discPalette[0] for edge in self.networkCurve.edges()]
572
573        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Discrete:
574            colors = [self.discEdgePalette[colorIndices[self.links[edge.links_index()][colorIndex].value]] for edge in self.networkCurve.edges()]
575
576        else:
577            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()]
578
579        self.networkCurve.set_edge_colors(colors)
580        self.replot()
581
582    def set_edge_labels(self, attributes=None):
583        if self.graph is None:
584            return
585
586        edges = self.networkCurve.edge_indices()
587
588        if attributes is not None:
589            self.edge_label_attributes = attributes
590
591        label_attributes = []
592        if self.links is not None and isinstance(self.links, orange.ExampleTable):
593            label_attributes = [self.links.domain[att] for att in \
594                self.edge_label_attributes if att in self.links.domain]
595
596        weights = [[] for ex in edges]
597        if self.show_weights:
598            weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u, v in edges]
599
600        self.networkCurve.set_edge_labels([', '.join(weights[i] + \
601                           [str(self.links[i][att]) for att in \
602                           label_attributes]) for i, edge in enumerate(edges)])
603
604        self.replot()
605
606    def set_tooltip_attributes(self, attributes):
607        if self.graph is None or self.items is None or \
608           not isinstance(self.items, orange.ExampleTable):
609            return
610
611        tooltip_attributes = [self.items.domain[att] for att in \
612                                 attributes if att in self.items.domain]
613        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str(\
614                   self.items[node][att]) for att in tooltip_attributes)) \
615                                                        for node in self.graph))
616
617    def change_graph(self, newgraph):
618        old_nodes = set(self.graph.nodes_iter())
619        new_nodes = set(newgraph.nodes_iter())
620        inter_nodes = old_nodes.intersection(new_nodes)
621        remove_nodes = list(old_nodes.difference(inter_nodes))
622        add_nodes = list(new_nodes.difference(inter_nodes))
623
624        self.graph = newgraph
625
626        if len(remove_nodes) == 0 and len(add_nodes) == 0:
627            return False
628
629        current_nodes = self.networkCurve.nodes()
630
631        center_x = numpy.average([node.x() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0
632        center_y = numpy.average([node.y() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0
633
634        def closest_nodes_with_pos(nodes):
635
636            neighbors = set()
637            for n in nodes:
638                neighbors |= set(self.graph.neighbors(n))
639
640            # checked all, none found           
641            if len(neighbors - nodes) == 0:
642                return []
643
644            inter = old_nodes.intersection(neighbors)
645            if len(inter) > 0:
646                return inter
647            else:
648                return closest_nodes_with_pos(neighbors | nodes)
649
650        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)
651
652        self.networkCurve.remove_nodes(list(remove_nodes))
653
654        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)
655        self.networkCurve.add_nodes(nodes)
656        nodes = self.networkCurve.nodes()
657
658        #add edges
659        new_edges = self.graph.edges(add_nodes)
660
661        if self.links is not None and len(self.links) > 0:
662            links = self.links
663            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in new_edges)
664
665            if self.graph.is_directed():
666                edges = [EdgeItem(nodes[i], nodes[j],
667                    self.graph[i][j].get('weight', 1), links_index, arrows=EdgeItem.ArrowV, \
668                    parent=self.networkCurve) for ((i, j), links_index) in \
669                         zip(new_edges, links_indices)]
670            else:
671                edges = [EdgeItem(nodes[i], nodes[j],
672                    self.graph[i][j].get('weight', 1), links_index) for \
673                    ((i, j), links_index) in zip(new_edges, \
674                                        links_indices, parent=self.networkCurve)]
675        elif self.graph.is_directed():
676            edges = [EdgeItem(nodes[i], nodes[j], self.graph[i][j].get('weight', 1), \
677                    arrows=EdgeItem.ArrowV, parent=self.networkCurve) for (i, j) in new_edges]
678        else:
679            edges = [EdgeItem(nodes[i], nodes[j], self.graph[i][j].get('weight', 1), \
680                    parent=self.networkCurve) for (i, j) in new_edges]
681
682        self.networkCurve.add_edges(edges)
683
684        if len(current_nodes) < 3:
685            self.networkCurve.random()
686
687        return True
688
689    def set_graph(self, graph, curve=None, items=None, links=None):
690        self.clear()
691
692        if graph is None:
693            self.graph = None
694            self.networkCurve = None
695            self.items = None
696            self.links = None
697            xMin = -1.0
698            xMax = 1.0
699            yMin = -1.0
700            yMax = 1.0
701            self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.fontSize)
702            self.replot()
703            return
704
705        self.graph = graph
706        self.networkCurve = NetworkCurve() if curve is None else curve()
707        self.add_custom_curve(self.networkCurve)
708
709        self.items = items if items is not None else self.graph.items()
710        self.links = links if links is not None else self.graph.links()
711
712        #add nodes
713        #self.vertices_old = [(None, []) for v in self.graph]
714        vertices = dict((v, self.NodeItem(v, parent=self.networkCurve)) for v in self.graph)
715        self.networkCurve.set_nodes(vertices)
716
717        #build edge to row index
718        self.edge_to_row = {}
719        if self.links is not None and len(self.links) > 0:
720            for i, r in enumerate(self.links):
721                u = int(r['u'].value)
722                v = int(r['v'].value)
723                if u - 1 in self.graph and v - 1 in self.graph:
724                    u_dict = self.edge_to_row.get(u, {})
725                    v_dict = self.edge_to_row.get(v, {})
726                    u_dict[v] = i
727                    v_dict[u] = i
728                    self.edge_to_row[u] = u_dict
729                    self.edge_to_row[v] = v_dict
730                else:
731                    print 'could not find edge', u, v
732
733        #add edges
734        if self.links is not None and len(self.links) > 0:
735            links = self.links
736            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in self.graph.edges())
737
738            if self.graph.is_directed():
739                edges = [EdgeItem(vertices[i], vertices[j],
740                    graph[i][j].get('weight', 1), links_index, arrows=EdgeItem.ArrowV, \
741                    parent=self.networkCurve) for ((i, j), links_index) in \
742                         zip(self.graph.edges(), links_indices)]
743            else:
744                edges = [EdgeItem(vertices[i], vertices[j],
745                    graph[i][j].get('weight', 1), links_index, \
746                    parent=self.networkCurve) for ((i, j), links_index) in \
747                         zip(self.graph.edges(), links_indices)]
748
749        elif self.graph.is_directed():
750            edges = [EdgeItem(vertices[i], vertices[j],
751                                      graph[i][j].get('weight', 1), arrows=EdgeItem.ArrowV, parent=self.networkCurve) for (i, j) in self.graph.edges()]
752        else:
753            edges = [EdgeItem(vertices[i], vertices[j],
754                                      graph[i][j].get('weight', 1), parent=self.networkCurve) for (i, j) in self.graph.edges()]
755
756        self.networkCurve.set_edges(edges)
757        self.networkCurve.update_properties()
758        self.replot()
759
760    def update_animations(self, use_animations=None):
761        OWPlot.update_animations(self, use_animations)
762        self.networkCurve.set_use_animations(self.use_animations)
763
764    def set_labels_on_marked(self, labelsOnMarkedOnly):
765        self.networkCurve.set_labels_on_marked(labelsOnMarkedOnly)
766        self.set_node_labels()
767        self.replot()
768
769    def set_show_component_distances(self):
770        self.networkCurve.set_show_component_distances(self.show_component_distances)
771        self.replot()
772
773    def replot(self):
774        self.set_dirty()
775        OWPlot.replot(self)
776        if hasattr(self, 'networkCurve') and self.networkCurve is not None:
777            self.networkCurve.update()
778
Note: See TracBrowser for help on using the repository browser.