Ignore:
Timestamp:
01/26/12 16:13:31 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Bug fixes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Unsupervised/OWNxCanvasQt.py

    r9424 r9577  
    1010 
    1111import Orange 
    12 import random  
     12import random 
    1313import numpy 
    1414 
    1515from plot.owplot import * 
    1616from plot.owpoint import * 
    17 from plot.owtools import *   
     17from plot.owtools import * 
    1818 
    1919from orngScaleScatterPlotData import * 
     
    2727        if y is not None: 
    2828            self.set_y(y) 
    29          
     29 
    3030class EdgeItem(orangeqt.EdgeItem): 
    3131    def __init__(self, u=None, v=None, weight=1, links_index=0, arrows=None, label='', parent=None): 
     
    4040        orangeqt.NetworkCurve.__init__(self, parent) 
    4141        self.name = "Network Curve" 
    42          
     42 
    4343    def layout_fr(self, steps, weighted=False, smooth_cooling=False): 
    4444        orangeqt.NetworkCurve.fr(self, steps, weighted, smooth_cooling) 
    45        
     45 
    4646    def set_node_sizes(self, values={}, min_size=0, max_size=0): 
    4747        orangeqt.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
    48      
     48 
    4949    def fragviz_callback(self, a, b, mds, mdsRefresh, components, progress_callback): 
    5050        """Refresh the UI when running  MDS on network components.""" 
    51          
     51 
    5252        if not self.mdsStep % mdsRefresh: 
    5353            rotationOnly = False 
     
    5757            phi = [None] * len(components) 
    5858            nodes = self.nodes() 
    59              
    60             for i, component in enumerate(components):     
    61                  
     59 
     60            for i, component in enumerate(components): 
     61 
    6262                if len(mds.points) == len(components):  # if average linkage before 
    6363                    x_avg_mds = mds.points[i][0] 
     
    6666                    x = [mds.points[u][0] for u in component] 
    6767                    y = [mds.points[u][1] for u in component] 
    68              
    69                     x_avg_mds = sum(x) / len(x)  
     68 
     69                    x_avg_mds = sum(x) / len(x) 
    7070                    y_avg_mds = sum(y) / len(y) 
    7171                    # compute rotation angle 
     
    7676#                                    [nodes[u].x(), nodes[u].y()]) for u in component] 
    7777#                    phi[i] = sum(c) / sum(n) 
    78                      
    79                  
     78 
     79 
    8080                x = [nodes[i].x() for i in component] 
    8181                y = [nodes[i].y() for i in component] 
    82                  
     82 
    8383                x_avg_graph = sum(x) / len(x) 
    8484                y_avg_graph = sum(y) / len(y) 
    85                  
    86                 x_mds.append(x_avg_mds)  
     85 
     86                x_mds.append(x_avg_mds) 
    8787                y_mds.append(y_avg_mds) 
    88      
     88 
    8989                component_props.append((x_avg_graph, y_avg_graph, \ 
    9090                                        x_avg_mds, y_avg_mds, phi)) 
     
    9393                x_avg_graph, y_avg_graph, x_avg_mds, \ 
    9494                y_avg_mds, phi = component_props[i] 
    95                  
     95 
    9696    #            if phi[i]:  # rotate vertices 
    9797    #                #print "rotate", i, phi[i] 
     
    101101    #                self.graph.coors[0][component] = [u[0] for u in v] 
    102102    #                self.graph.coors[1][component] = [u[1] for u in v] 
    103                      
     103 
    104104                # translate vertices 
    105105                if not rotationOnly: 
    106106                    self.set_node_coordinates(dict( 
    107                        (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds,   
     107                       (i, ((nodes[i].x() - x_avg_graph) + x_avg_mds, 
    108108                            (nodes[i].y() - y_avg_graph) + y_avg_mds)) \ 
    109109                                  for i in component)) 
    110                      
     110 
    111111            #if self.mdsType == MdsType.exactSimulation: 
    112112            #    self.mds.points = [[self.graph.coors[0][i], \ 
     
    114114            #                        for i in range(len(self.graph.coors))] 
    115115            #    self.mds.freshD = 0 
    116              
     116 
    117117            #self.update_properties() 
    118118            self.plot().replot() 
    119119            qApp.processEvents() 
    120              
     120 
    121121            if progress_callback is not None: 
    122                 progress_callback(a, self.mdsStep)  
    123              
     122                progress_callback(a, self.mdsStep) 
     123 
    124124        self.mdsStep += 1 
    125125        return 0 if self.stopMDS else 1 
    126              
     126 
    127127    def layout_fragviz(self, steps, distances, graph, progress_callback=None, opt_from_curr=False): 
    128128        """Position the network components according to similarities among  
     
    134134            self.information('invalid or no distance matrix') 
    135135            return 1 
    136          
     136 
    137137        p = self.plot() 
    138138        edges = self.edges() 
    139139        nodes = self.nodes() 
    140          
     140 
    141141        avgLinkage = True 
    142142        rotationOnly = False 
    143143        minStressDelta = 0 
    144144        mdsRefresh = int(steps / 20) 
    145          
     145 
    146146        self.mdsStep = 1 
    147147        self.stopMDS = False 
    148          
     148 
    149149        components = Orange.network.nx.algorithms.components.connected.connected_components(graph) 
    150150        distances.matrixType = Orange.core.SymMatrix.Symmetric 
    151          
     151 
    152152        # scale net coordinates 
    153153        if avgLinkage: 
    154154            distances = distances.avgLinkage(components) 
    155              
     155 
    156156        mds = Orange.projection.mds.MDS(distances) 
    157157        mds.optimize(10, Orange.projection.mds.SgnRelStress, 0) 
     
    159159        w_fr = rect.width() 
    160160        h_fr = rect.height() 
    161         d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    162        
     161        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
     162 
    163163        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    164164        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
    165165        w_mds = max(x_mds) - min(x_mds) 
    166166        h_mds = max(y_mds) - min(y_mds) 
    167         d_mds = math.sqrt(w_mds**2 + h_mds**2) 
    168          
     167        d_mds = math.sqrt(w_mds ** 2 + h_mds ** 2) 
     168 
    169169        animate_points = p.animate_points 
    170170        p.animate_points = False 
    171          
     171 
    172172        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          
     173           (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes)) 
     174 
    175175        #self.update_properties() 
    176176        p.replot() 
    177177        qApp.processEvents() 
    178                       
     178 
    179179        if opt_from_curr: 
    180180            if avgLinkage: 
     
    185185                    mds.points[u][1] = y 
    186186            else: 
    187                 for i,u in enumerate(sorted(nodes.iterkeys())): 
     187                for i, u in enumerate(sorted(nodes.iterkeys())): 
    188188                    mds.points[i][0] = nodes[u].x() 
    189189                    mds.points[i][1] = nodes[u].y() 
    190190        else: 
    191             mds.Torgerson()  
    192  
    193         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,  
     191            mds.Torgerson() 
     192 
     193        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
    194194                     progressCallback= 
    195                          lambda a,  
    196                                 b=None,  
     195                         lambda a, 
     196                                b=None, 
    197197                                mds=mds, 
    198198                                mdsRefresh=mdsRefresh, 
    199199                                components=components, 
    200                                 progress_callback=progress_callback:  
     200                                progress_callback=progress_callback: 
    201201                                    self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback)) 
    202          
     202 
    203203        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
    204          
     204 
    205205        if progress_callback != None: 
    206206            progress_callback(mds.avgStress, self.mdsStep) 
    207          
     207 
    208208        p.animate_points = animate_points 
    209209        return 0 
    210      
     210 
    211211    def mds_callback(self, a, b, mds, mdsRefresh, progress_callback): 
    212212        """Refresh the UI when running  MDS.""" 
    213          
     213 
    214214        if not self.mdsStep % mdsRefresh: 
    215              
     215 
    216216            self.set_node_coordinates(dict((u, (mds.points[u][0], \ 
    217217                                                mds.points[u][1])) for u in \ 
     
    219219            self.plot().replot() 
    220220            qApp.processEvents() 
    221              
     221 
    222222            if progress_callback is not None: 
    223                 progress_callback(a, self.mdsStep)  
    224              
     223                progress_callback(a, self.mdsStep) 
     224 
    225225        self.mdsStep += 1 
    226226        return 0 if self.stopMDS else 1 
    227      
     227 
    228228    def layout_mds(self, steps, distances, progress_callback=None, opt_from_curr=False): 
    229229        """Position the network components according to similarities among  
     
    232232        """ 
    233233        nodes = self.nodes() 
    234          
     234 
    235235        if distances == None or distances.dim != len(nodes): 
    236236            self.information('invalid or no distance matrix') 
    237237            return 1 
    238          
     238 
    239239        p = self.plot() 
    240          
     240 
    241241        minStressDelta = 0 
    242242        mdsRefresh = int(steps / 20) 
    243          
     243 
    244244        self.mdsStep = 1 
    245245        self.stopMDS = False 
    246          
     246 
    247247        distances.matrixType = Orange.core.SymMatrix.Symmetric 
    248248        mds = Orange.projection.mds.MDS(distances) 
     
    251251        w_fr = rect.width() 
    252252        h_fr = rect.height() 
    253         d_fr = math.sqrt(w_fr**2 + h_fr**2) 
    254        
     253        d_fr = math.sqrt(w_fr ** 2 + h_fr ** 2) 
     254 
    255255        x_mds = [mds.points[u][0] for u in range(len(mds.points))] 
    256256        y_mds = [mds.points[u][1] for u in range(len(mds.points))] 
    257257        w_mds = max(x_mds) - min(x_mds) 
    258258        h_mds = max(y_mds) - min(y_mds) 
    259         d_mds = math.sqrt(w_mds**2 + h_mds**2) 
    260          
     259        d_mds = math.sqrt(w_mds ** 2 + h_mds ** 2) 
     260 
    261261        animate_points = p.animate_points 
    262262        p.animate_points = False 
    263          
     263 
    264264        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          
     265           (n, (nodes[n].x() * d_mds / d_fr, nodes[n].y() * d_mds / d_fr)) for n in nodes)) 
     266 
    267267        p.replot() 
    268268        qApp.processEvents() 
    269                       
     269 
    270270        if opt_from_curr: 
    271             for i,u in enumerate(sorted(nodes.iterkeys())): 
     271            for i, u in enumerate(sorted(nodes.iterkeys())): 
    272272                mds.points[i][0] = nodes[u].x() 
    273273                mds.points[i][1] = nodes[u].y() 
    274274        else: 
    275             mds.Torgerson()  
    276  
    277         mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta,  
     275            mds.Torgerson() 
     276 
     277        mds.optimize(steps, Orange.projection.mds.SgnRelStress, minStressDelta, 
    278278                     progressCallback= 
    279                          lambda a,  
    280                                 b=None,  
     279                         lambda a, 
     280                                b=None, 
    281281                                mds=mds, 
    282282                                mdsRefresh=mdsRefresh, 
    283                                 progress_callback=progress_callback:  
     283                                progress_callback=progress_callback: 
    284284                                    self.mds_callback(a, b, mds, mdsRefresh, progress_callback)) 
    285          
     285 
    286286        self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, progress_callback) 
    287          
     287 
    288288        if progress_callback != None: 
    289289            progress_callback(mds.avgStress, self.mdsStep) 
    290          
     290 
    291291        p.animate_points = animate_points 
    292292        return 0 
    293      
     293 
    294294#    def move_selected_nodes(self, dx, dy): 
    295295#        selected = self.get_selected_nodes() 
     
    318318#        for vertex in self.nodes().itervalues(): 
    319319#          vertex.show() 
    320      
    321      
    322          
     320 
     321 
     322 
    323323class OWNxCanvas(OWPlot): 
    324324    def __init__(self, master, parent=None, name="None"): 
     
    328328        self.NodeItem = NodeItem 
    329329        self.graph = None 
    330          
     330 
    331331        self.circles = [] 
    332332        self.freezeNeighbours = False 
     
    336336        self.show_weights = False 
    337337        self.trim_label_words = 0 
    338         self.explore_distances = False 
    339338        self.show_component_distances = False 
    340          
     339 
    341340        self.showComponentAttribute = None 
    342341        self.forceVectors = None 
    343342        #self.appendToSelection = 1 
    344343        self.fontSize = 12 
    345               
     344 
    346345        self.networkCurve = NetworkCurve() 
    347346        self.add_custom_curve(self.networkCurve) 
    348          
     347 
    349348        self.minComponentEdgeWidth = 0 
    350349        self.maxComponentEdgeWidth = 0 
    351350        self.items_matrix = None 
    352           
     351 
    353352        self.items = None 
    354353        self.links = None 
    355354        self.edge_to_row = None 
    356          
     355        self.label_distances = None 
     356 
    357357        self.node_label_attributes = [] 
    358358        self.edge_label_attributes = [] 
    359          
     359 
    360360        self.axis_margin = 0 
    361361        self.title_margin = 0 
    362362        self.graph_margin = 1 
    363363        self._legend_margin = QRectF(0, 0, 0, 0) 
    364          
     364 
    365365        #self.setFocusPolicy(Qt.StrongFocus) 
    366          
     366 
    367367    def update_canvas(self): 
    368368        self.networkCurve.update_properties() 
    369369        self.drawComponentKeywords() 
    370370        self.replot() 
    371          
     371 
    372372    def set_hidden_nodes(self, nodes): 
    373373        self.networkCurve.set_hidden_nodes(nodes) 
    374      
     374 
    375375    def hide_selected_nodes(self): 
    376376      self.networkCurve.hide_selected_nodes() 
    377377      self.drawPlotItems() 
    378        
     378 
    379379    def hide_unselected_nodes(self): 
    380380      self.networkCurve.hide_unselected_nodes() 
    381381      self.drawPlotItems() 
    382        
     382 
    383383    def show_all_vertices(self): 
    384384      self.networkCurve.show_all_vertices() 
    385385      self.drawPlotItems() 
    386      
     386 
    387387    def selected_nodes(self): 
    388388        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_selected()] 
    389389        #return [p.index() for p in self.selected_points()] 
    390          
     390 
    391391    def not_selected_nodes(self): 
    392392        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_selected()] 
    393          
     393 
    394394    def marked_nodes(self): 
    395395        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_marked()] 
    396396        #return [p.index() for p in self.marked_points()] 
    397          
     397 
    398398    def not_marked_nodes(self): 
    399         return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_marked()]     
    400      
     399        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_marked()] 
     400 
    401401    def get_neighbors_upto(self, ndx, dist): 
    402402        newNeighbours = neighbours = set([ndx]) 
     
    408408            neighbours |= newNeighbours 
    409409        return neighbours 
    410      
     410             
    411411    def mark_on_selection_changed(self): 
    412412        toMark = set() 
    413413        for ndx in self.selected_nodes(): 
    414414            toMark |= self.get_neighbors_upto(ndx, self.mark_neighbors) 
    415          
     415 
    416416        self.networkCurve.clear_node_marks() 
    417417        self.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
    418      
     418 
    419419    def mark_on_focus_changed(self, node): 
    420420        self.networkCurve.clear_node_marks() 
    421          
     421 
    422422        if node is not None: 
    423423            toMark = set(self.get_neighbors_upto(node.index(), self.mark_neighbors)) 
    424424            self.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
    425          
     425 
    426426    def drawComponentKeywords(self): 
    427427        self.clear_markers() 
    428428        if self.showComponentAttribute == None or self.graph is None or self.items is None: 
    429429            return 
    430          
     430 
    431431        if str(self.showComponentAttribute) not in self.items.domain: 
    432432            self.showComponentAttribute = None 
    433433            return 
    434          
     434 
    435435        components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    436436        nodes = self.networkCurve.nodes() 
    437          
     437 
    438438        for c in components: 
    439439            if len(c) == 0: 
    440440                continue 
    441              
     441 
    442442            x1 = sum(nodes[n].x() for n in c) / len(c) 
    443443            y1 = sum(nodes[n].y() for n in c) / len(c) 
    444444            lbl = str(self.items[c[0]][str(self.showComponentAttribute)]) 
    445              
     445 
    446446            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                              
     447 
    450448    def getColorIndeces(self, table, attribute, palette): 
    451449        colorIndices = {} 
     
    453451        minValue = None 
    454452        maxValue = None 
    455          
     453 
    456454        if attribute[0] != "(" or attribute[ -1] != ")": 
    457455            i = 0 
     
    459457                if var.name == attribute: 
    460458                    colorIndex = i 
    461                     if var.varType == orange.VarTypes.Discrete:  
     459                    if var.varType == orange.VarTypes.Discrete: 
    462460                        colorIndices = getVariableValueIndices(var, colorIndex) 
    463                          
     461 
    464462                i += 1 
    465463            metas = table.domain.getmetas() 
     
    467465                if var.name == attribute: 
    468466                    colorIndex = i 
    469                     if var.varType == orange.VarTypes.Discrete:  
     467                    if var.varType == orange.VarTypes.Discrete: 
    470468                        colorIndices = getVariableValueIndices(var, colorIndex) 
    471      
     469 
    472470        colorIndices['?'] = len(colorIndices) 
    473471        palette.setNumberOfColors(len(colorIndices)) 
    474          
     472 
    475473        if colorIndex != None and table.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    476474            minValue = float(min([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
    477475            maxValue = float(max([x[colorIndex].value for x in table if x[colorIndex].value != "?"] or [0.0])) 
    478              
     476 
    479477        return colorIndices, colorIndex, minValue, maxValue 
    480      
     478 
    481479    def set_node_colors(self, attribute, nodes=None): 
    482480        if self.graph is None: 
     
    485483        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
    486484        colors = {} 
    487          
     485 
    488486        if nodes is None: 
    489487            nodes = self.graph.nodes() 
    490          
     488 
    491489        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
    492490            colors.update((node, self.discPalette[0]) for node in nodes) 
    493          
     491 
    494492        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  
     493            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)]) 
     494                          if str(self.items[v][colorIndex].value) != '?' else 
    497495                          (v, self.discPalette[0]) for v in nodes) 
    498496 
    499497        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    500498            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
    501              
     499 
    502500        else: 
    503501            colors.update((node, self.discPalette[0]) for node in nodes) 
    504          
     502 
    505503        self.networkCurve.set_node_colors(colors) 
    506504        self.replot() 
    507          
     505 
    508506    def set_node_labels(self, attributes=None): 
    509507        if self.graph is None: 
    510             return  
    511          
     508            return 
     509 
    512510        nodes = self.graph.nodes() 
    513          
     511 
    514512        if attributes is not None: 
    515513            self.node_label_attributes = attributes 
    516          
     514 
    517515        label_attributes = [] 
    518516        if self.items is not None and isinstance(self.items, orange.ExampleTable): 
    519517            label_attributes = [self.items.domain[att] for att in \ 
    520518                self.node_label_attributes if att in self.items.domain] 
    521              
     519 
    522520        indices = [[] for u in nodes] 
    523521        if self.show_indices: 
    524522            indices = [[str(u)] for u in nodes] 
    525523         
    526         if len(label_attributes) == 0 and not self.show_indices: 
     524        distances = [[] for u in nodes] 
     525        show_distances = False 
     526        if self.label_distances is not None and type(self.label_distances) == \ 
     527                           type([]) and len(self.label_distances) == len(nodes): 
     528            distances = self.label_distances 
     529            show_distances = True 
     530             
     531        if len(label_attributes) == 0 and \ 
     532                        not self.show_indices and not show_distances: 
    527533            self.networkCurve.set_node_labels({}) 
    528          
     534 
    529535        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(' ')))]) 
     536            self.networkCurve.set_node_labels(dict((node, 
     537                ', '.join(distances[i] + indices[i] + 
     538                          [' '.join(str(self.items[node][att]).split(' ')[:min(self.trim_label_words, len(str(self.items[node][att]).split(' ')))]) 
    533539                for att in label_attributes])) for i, node in enumerate(nodes))) 
    534540        else: 
    535             self.networkCurve.set_node_labels(dict((node, ', '.join(indices[i]+\ 
     541            self.networkCurve.set_node_labels(dict((node, ', '.join( \ 
     542                        distances[i] + indices[i] + \ 
    536543                           [str(self.items[node][att]) for att in \ 
    537544                           label_attributes])) for i, node in enumerate(nodes))) 
    538          
     545 
    539546        self.replot() 
    540          
    541      
     547 
     548 
    542549    def set_edge_colors(self, attribute): 
    543550        if self.graph is None: 
    544551            return 
    545          
     552 
    546553        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discPalette) 
    547554        colors = [] 
    548          
     555 
    549556        if colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
    550557            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
    551          
     558 
    552559        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    553560            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  
     561                          if str(self.links[edge.links_index()][colorIndex].value) != '?' else 
    555562                          self.discPalette[0] for edge in self.networkCurve.edges()] 
    556              
     563 
    557564        elif colorIndex is not None and self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    558565            colors = [self.discEdgePalette[colorIndices[self.links[edge.links_index()][colorIndex].value]] for edge in self.networkCurve.edges()] 
    559              
     566 
    560567        else: 
    561568            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
    562              
     569 
    563570        self.networkCurve.set_edge_colors(colors) 
    564571        self.replot() 
    565          
     572 
    566573    def set_edge_labels(self, attributes=None): 
    567574        if self.graph is None: 
    568             return  
    569          
     575            return 
     576 
    570577        edges = self.networkCurve.edge_indices() 
    571          
     578 
    572579        if attributes is not None: 
    573580            self.edge_label_attributes = attributes 
    574          
     581 
    575582        label_attributes = [] 
    576583        if self.links is not None and isinstance(self.links, orange.ExampleTable): 
    577584            label_attributes = [self.links.domain[att] for att in \ 
    578585                self.edge_label_attributes if att in self.links.domain] 
    579              
     586 
    580587        weights = [[] for ex in edges] 
    581588        if self.show_weights: 
    582             weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u,v in edges] 
    583              
     589            weights = [["%.2f" % self.graph[u][v].get('weight', 1)] for u, v in edges] 
     590 
    584591        self.networkCurve.set_edge_labels([', '.join(weights[i] + \ 
    585592                           [str(self.links[i][att]) for att in \ 
    586                            label_attributes]) for i,edge in enumerate(edges)]) 
    587          
     593                           label_attributes]) for i, edge in enumerate(edges)]) 
     594 
    588595        self.replot() 
    589          
     596 
    590597    def set_tooltip_attributes(self, attributes): 
    591598        if self.graph is None or self.items is None or \ 
    592599           not isinstance(self.items, orange.ExampleTable): 
    593600            return 
    594          
     601 
    595602        tooltip_attributes = [self.items.domain[att] for att in \ 
    596603                                 attributes if att in self.items.domain] 
    597         self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \ 
     604        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str(\ 
    598605                   self.items[node][att]) for att in tooltip_attributes)) \ 
    599606                                                        for node in self.graph)) 
    600                  
     607 
    601608    def change_graph(self, newgraph): 
    602609        old_nodes = set(self.graph.nodes_iter()) 
     
    605612        remove_nodes = list(old_nodes.difference(inter_nodes)) 
    606613        add_nodes = list(new_nodes.difference(inter_nodes)) 
    607          
     614 
    608615        self.graph = newgraph 
    609          
     616 
    610617        if len(remove_nodes) == 0 and len(add_nodes) == 0: 
    611618            return False 
    612          
     619 
    613620        current_nodes = self.networkCurve.nodes() 
    614          
     621 
    615622        center_x = numpy.average([node.x() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0 
    616623        center_y = numpy.average([node.y() for node in current_nodes.values()]) if len(current_nodes) > 0 else 0 
    617          
     624 
    618625        def closest_nodes_with_pos(nodes): 
    619              
     626 
    620627            neighbors = set() 
    621628            for n in nodes: 
     
    625632            if len(neighbors - nodes) == 0: 
    626633                return [] 
    627              
     634 
    628635            inter = old_nodes.intersection(neighbors) 
    629636            if len(inter) > 0: 
     
    631638            else: 
    632639                return closest_nodes_with_pos(neighbors | nodes) 
    633          
     640 
    634641        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          
     642 
    636643        self.networkCurve.remove_nodes(list(remove_nodes)) 
    637          
     644 
    638645        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) 
    639646        self.networkCurve.add_nodes(nodes) 
    640647        nodes = self.networkCurve.nodes() 
    641          
     648 
    642649        #add edges 
    643650        new_edges = self.graph.edges(add_nodes) 
    644          
     651 
    645652        if self.links is not None and len(self.links) > 0: 
    646653            links = self.links 
    647654            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in new_edges) 
    648              
     655 
    649656            if self.graph.is_directed(): 
    650657                edges = [EdgeItem(nodes[i], nodes[j], 
     
    663670            edges = [EdgeItem(nodes[i], nodes[j], self.graph[i][j].get('weight', 1), \ 
    664671                    parent=self.networkCurve) for (i, j) in new_edges] 
    665              
     672 
    666673        self.networkCurve.add_edges(edges) 
    667          
     674 
    668675        if len(current_nodes) < 3: 
    669676            self.networkCurve.random() 
    670          
     677 
    671678        return True 
    672          
     679 
    673680    def set_graph(self, graph, curve=None, items=None, links=None): 
    674681        self.clear() 
    675          
     682 
    676683        if graph is None: 
    677684            self.graph = None 
     
    686693            self.replot() 
    687694            return 
    688          
     695 
    689696        self.graph = graph 
    690697        self.networkCurve = NetworkCurve() if curve is None else curve() 
    691698        self.add_custom_curve(self.networkCurve) 
    692          
     699 
    693700        self.items = items if items is not None else self.graph.items() 
    694701        self.links = links if links is not None else self.graph.links() 
    695          
     702 
    696703        #add nodes 
    697704        #self.vertices_old = [(None, []) for v in self.graph] 
    698705        vertices = dict((v, self.NodeItem(v, parent=self.networkCurve)) for v in self.graph) 
    699706        self.networkCurve.set_nodes(vertices) 
    700                  
     707 
    701708        #build edge to row index 
    702709        self.edge_to_row = {} 
     
    714721                else: 
    715722                    print 'could not find edge', u, v 
    716                
     723 
    717724        #add edges 
    718725        if self.links is not None and len(self.links) > 0: 
    719726            links = self.links 
    720727            links_indices = (self.edge_to_row[i + 1][j + 1] for (i, j) in self.graph.edges()) 
    721              
     728 
    722729            if self.graph.is_directed(): 
    723730                edges = [EdgeItem(vertices[i], vertices[j], 
     
    730737                    parent=self.networkCurve) for ((i, j), links_index) in \ 
    731738                         zip(self.graph.edges(), links_indices)] 
    732                  
     739 
    733740        elif self.graph.is_directed(): 
    734741            edges = [EdgeItem(vertices[i], vertices[j], 
     
    737744            edges = [EdgeItem(vertices[i], vertices[j], 
    738745                                      graph[i][j].get('weight', 1), parent=self.networkCurve) for (i, j) in self.graph.edges()] 
    739              
     746 
    740747        self.networkCurve.set_edges(edges) 
    741748        self.networkCurve.update_properties() 
    742         self.replot()   
    743      
     749        self.replot() 
     750 
    744751    def update_animations(self, use_animations=None): 
    745752        OWPlot.update_animations(self, use_animations) 
     
    750757        self.set_node_labels() 
    751758        self.replot() 
    752      
     759 
    753760    def set_show_component_distances(self): 
    754761        self.networkCurve.set_show_component_distances(self.show_component_distances) 
    755762        self.replot() 
    756          
     763 
    757764    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): 
    760765        self.set_dirty() 
    761766        OWPlot.replot(self) 
    762767        if hasattr(self, 'networkCurve') and self.networkCurve is not None: 
    763768            self.networkCurve.update() 
    764              
     769 
Note: See TracChangeset for help on using the changeset viewer.