Changeset 8601:c5afd932b8a7 in orange


Ignore:
Timestamp:
08/04/11 19:29:53 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
6aa2291daca924d33fdc0c80dc09a8f74d7308a4
Message:
 
Location:
orange/OrangeWidgets/Prototypes
Files:
2 edited

Legend:

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

    r8598 r8601  
    2929    def __init__(self, u=None, v=None, weight=1, links_index=0, label='', parent=None): 
    3030        orangeplot.EdgeItem.__init__(self, u, v, parent) 
    31         self.set_u(u) 
    32         self.set_v(v) 
    3331        self.set_weight(weight) 
    3432        self.set_links_index(links_index) 
     
    3836        orangeplot.NetworkCurve.__init__(self, parent) 
    3937        self.name = "Network Curve" 
    40         self.showEdgeLabels = 0 
     38         
     39    def fr(self, steps, weighted=False, smooth_cooling=False): 
     40        orangeplot.NetworkCurve.fr(self, steps, weighted, smooth_cooling) 
    4141       
    4242    def set_node_sizes(self, values={}, min_size=0, max_size=0): 
    4343        orangeplot.NetworkCurve.set_node_sizes(self, values, min_size, max_size) 
    4444       
    45     def move_selected_nodes(self, dx, dy): 
    46         selected = self.get_selected_nodes() 
    47          
    48         self.coors[selected][0] = self.coors[0][selected] + dx 
    49         self.coors[1][selected][1] = self.coors[1][selected] + dy 
    50            
    51         self.update_properties() 
    52         return selected 
    53    
    54 #    def get_selected_nodes(self): 
    55 #        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_selected()] 
    56  
    57     def get_unselected_nodes(self): 
    58         return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if not vertex.is_selected()] 
    59  
    60     def get_marked_nodes(self): 
    61         return [vertex.index() for vertex in self.nodes().itervalues() if vertex.is_marked()] 
    62    
    63     def set_marked_nodes(self, vertices): 
    64         n = self.nodes() 
    65         for vertex in n.itervalues(): 
    66           vertex.set_marked(False) 
    67         for index in vertices: 
    68           if index in n: 
    69             n[index].set_marked(True) 
    70          
    71     def mark_to_sel(self): 
    72         for vertex in self.nodes().itervalues(): 
    73           if vertex.is_marked(): 
    74               vertex.set_selected(True) 
    75            
    76     def sel_to_mark(self): 
    77         for vertex in self.nodes().itervalues(): 
    78           if vertex.is_selected(): 
    79               vertex.set_selected(False) 
    80               vertex.set_marked(True) 
    81    
    82     def unmark(self): 
    83         for vertex in self.nodes().itervalues(): 
    84           vertex.set_marked(False) 
    85        
    86     def unselect(self): 
    87         for vertex in self.nodes().itervalues(): 
    88             vertex.set_selected(False) 
    89          
    90     def set_hidden_nodes(self, nodes): 
    91         for vertex in self.nodes().itervalues(): 
    92             vertex.setVisible(vertex.index() in nodes) 
    93        
    94     def hide_selected_nodes(self): 
    95         for vertex in self.nodes().itervalues(): 
    96           if vertex.selected: 
    97             vertex.hide() 
    98    
    99     def hide_unselected_nodes(self): 
    100         for vertex in self.nodes().itervalues(): 
    101           if not vertex.selected: 
    102             vertex.hide() 
    103      
    104     def show_all_vertices(self): 
    105         for vertex in self.nodes().itervalues(): 
    106           vertex.show() 
    107      
    108     def changed(self): 
    109         self.itemChanged() 
    110          
    111     def closest_node(self, px, py): 
    112         ndx = min(self.coors, key=lambda x: abs(self.coors[x][0]-px) + abs(self.coors[x][1]-py)) 
    113         return ndx, math.sqrt((self.coors[ndx][0]-px)**2 + (self.coors[ndx][0]-px)**2) 
    114  
    115     def get_nodes_in_rect(self, x1, y1, x2, y2): 
    116         if x1 > x2: 
    117             x1, x2 = x2, x1 
    118         if y1 > y2: 
    119             y1, y2 = y2, y1 
    120         return [key for key in self.coors if x1 < self.coors[key][0] < x2 and y1 < self.coors[key][1] < y2] 
    121          
    122     def fr(self, steps, weighted=False, smooth_cooling=False): 
    123         orangeplot.NetworkCurve.fr(self, steps, weighted, smooth_cooling) 
     45#    def move_selected_nodes(self, dx, dy): 
     46#        selected = self.get_selected_nodes() 
     47#         
     48#        self.coors[selected][0] = self.coors[0][selected] + dx 
     49#        self.coors[1][selected][1] = self.coors[1][selected] + dy 
     50#           
     51#        self.update_properties() 
     52#        return selected 
     53#         
     54#    def set_hidden_nodes(self, nodes): 
     55#        for vertex in self.nodes().itervalues(): 
     56#            vertex.setVisible(vertex.index() in nodes) 
     57#       
     58#    def hide_selected_nodes(self): 
     59#        for vertex in self.nodes().itervalues(): 
     60#          if vertex.selected: 
     61#            vertex.hide() 
     62 
     63#    def hide_unselected_nodes(self): 
     64#        for vertex in self.nodes().itervalues(): 
     65#          if not vertex.selected: 
     66#            vertex.hide() 
     67#     
     68#    def show_all_vertices(self): 
     69#        for vertex in self.nodes().itervalues(): 
     70#          vertex.show() 
     71     
     72     
    12473         
    12574class OWNxCanvas(OWPlot): 
     
    12877        self.master = master 
    12978        self.parent = parent 
    130         #self.vertices_old = {}         # distionary of nodes (orngIndex: vertex_objekt) 
    131         #self.edges_old = {}            # distionary of edges (curveKey: edge_objekt) 
    132         #self.vertices = [] 
    133         #self.edges = [] 
    134         self.indexPairs = {}       # distionary of type CurveKey: orngIndex   (for nodes) 
    135         #self.selection = []        # list of selected nodes (indices) 
    136         self.markerKeys = {}       # dictionary of type NodeNdx : markerCurveKey 
    137         self.tooltipKeys = {}      # dictionary of type NodeNdx : tooltipCurveKey 
     79         
    13880        self.graph = None 
    139         self.layout = None 
    140         self.vertexDegree = []     # seznam vozlisc oblike (vozlisce, stevilo povezav), sortiran po stevilu povezav 
    141         self.edgesKey = -1 
    142         #self.vertexSize = 6 
    143         self.state = NOTHING  #default je rocno premikanje 
    144         self.hiddenNodes = [] 
    145         self.markedNodes = set() 
    146         self.markWithRed = False 
     81 
    14782        self.circles = [] 
    148         self.tooltipNeighbours = 2 
    149         self.selectionNeighbours = 2 
    15083        self.freezeNeighbours = False 
    15184        self.labelsOnMarkedOnly = 0 
    152         self.enableWheelZoom = 1 
    153         self.optimizing = 0 
    154         self.stopOptimizing = 0 
    155         self.insideview = 0 
    156         self.insideviewNeighbours = 2 
    157         self.enableGridXB(False) 
    158         self.enableGridYL(False) 
    159         self.renderAntialiased = 1 
    160         self.sendMarkedNodes = None 
    161         self.showEdgeLabels = 0 
    162         self.showDistances = 0 
    163         self.showMissingValues = 0 
    164         self.show_indices = True 
     85 
     86        self.show_indices = False 
    16587        self.showWeights = 0 
    166         self.minEdgeWeight = sys.maxint 
    167         self.maxEdgeWeight = 0 
    168         self.maxEdgeSize = 1 
    169          
    170         self.invertEdgeSize = 0 
     88         
    17189        self.showComponentAttribute = None 
    17290        self.forceVectors = None 
    173         self.appendToSelection = 1 
     91        #self.appendToSelection = 1 
    17492        self.fontSize = 12 
    17593              
    17694        self.networkCurve = NetworkCurve() 
    17795        self.add_custom_curve(self.networkCurve) 
    178         self.callbackMoveVertex = None 
    17996         
    18097        self.minComponentEdgeWidth = 0 
    18198        self.maxComponentEdgeWidth = 0 
    18299        self.items_matrix = None 
    183         self.controlPressed = False 
    184         self.altPressed = False 
     100         
    185101        self.items = None 
    186102        self.links = None 
    187103         
    188104        self.node_label_attributes = [] 
    189         self.edge_color_attribute = None 
    190105         
    191106        self.axis_margin = 0 
     
    194109        self._legend_margin = QRectF(0, 0, 0, 0) 
    195110         
    196         self.setFocusPolicy(Qt.StrongFocus) 
     111        #self.setFocusPolicy(Qt.StrongFocus) 
    197112         
    198113    def update_canvas(self): 
     
    217132      self.drawPlotItems() 
    218133       
    219 #    def optimize(self, frSteps): 
    220 #        qApp.processEvents() 
    221 #        tolerance = 5 
    222 #        initTemp = 100 
    223 #        breakpoints = 20 
    224 #        k = int(frSteps / breakpoints) 
    225 #        o = frSteps % breakpoints 
    226 #        iteration = 0 
    227 #        coolFactor = exp(log(10.0 / 10000.0) / frSteps) 
    228 #        #print coolFactor 
    229 #        if k > 0: 
    230 #            while iteration < breakpoints: 
    231 #                initTemp = self.layout.fruchtermanReingold(k, initTemp, coolFactor, self.hiddenNodes) 
    232 #                iteration += 1 
    233 #                qApp.processEvents() 
    234 #                self.updateCanvas() 
    235 #     
    236 #            initTemp = self.layout.fruchtermanReingold(o, initTemp, coolFactor, self.hiddenNodes) 
    237 #            qApp.processEvents() 
    238 #            self.updateCanvas() 
    239 #        else: 
    240 #            while iteration < o: 
    241 #                initTemp = self.layout.fruchtermanReingold(1, initTemp, coolFactor, self.hiddenNodes) 
    242 #                iteration += 1 
    243 #                qApp.processEvents() 
    244 #                self.updateCanvas() 
    245                  
    246134    def markedToSelection(self): 
    247135        self.networkCurve.mark_to_sel() 
     
    251139        self.networkCurve.sel_to_mark() 
    252140        self.drawPlotItems() 
    253          
    254         if self.sendMarkedNodes != None: 
    255             self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    256141         
    257142    def removeSelection(self, replot=True): 
     
    290175        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_selected()] 
    291176        #return [p.index() for p in self.selected_points()] 
    292      
    293     def getNeighboursUpTo(self, ndx, dist): 
     177         
     178    def marked_nodes(self): 
     179        return [vertex.index() for vertex in self.networkCurve.nodes().itervalues() if vertex.is_marked()] 
     180         
     181    def get_neighbors_upto(self, ndx, dist): 
    294182        newNeighbours = neighbours = set([ndx]) 
    295183        for d in range(dist): 
     
    300188            neighbours |= newNeighbours 
    301189        return neighbours 
    302       
    303     def markSelectionNeighbours(self): 
    304         if not self.freezeNeighbours and self.selectionNeighbours: 
    305             toMark = set() 
    306             for ndx in self.networkCurve.get_selected_nodes(): 
    307                 toMark |= self.getNeighboursUpTo(ndx, self.selectionNeighbours) 
    308              
    309             self.networkCurve.set_marked_nodes(toMark) 
    310             self.drawPlotItems() 
    311                  
    312         elif not self.freezeNeighbours and self.selectionNeighbours == 0: 
    313             self.networkCurve.set_marked_nodes(self.networkCurve.get_selected_nodes()) 
    314             self.drawPlotItems() 
    315              
    316         if self.sendMarkedNodes != None: 
    317             self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    318                  
    319     def unmark(self): 
    320       self.networkCurve.unmark() 
    321       self.drawPlotItems(replot=0) 
    322        
    323       if self.sendMarkedNodes != None: 
    324             self.sendMarkedNodes([]) 
    325              
    326     def set_marked_nodes(self, vertices): 
    327       self.networkCurve.set_marked_nodes(vertices) 
    328       self.drawPlotItems(replot=0) 
    329        
    330       if self.sendMarkedNodes != None: 
    331             self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    332      
    333     def updateData(self): 
    334         if self.graph is None: 
    335             return 
    336          
    337         self.clear() 
    338         self.tooltipData = [] 
     190     
     191    def mark_on_selection_changed(self): 
     192        toMark = set() 
     193        for ndx in self.selected_nodes(): 
     194            toMark |= self.get_neighbors_upto(ndx, self.mark_neighbors) 
     195         
     196        self.networkCurve.clear_node_marks() 
     197        self.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
     198         
     199#    def updateData(self): 
     200#        if self.graph is None: 
     201#            return 
    339202#         
    340 #        if self.items_matrix and self.minComponentEdgeWidth > 0 and self.maxComponentEdgeWidth > 0:           
    341 #            components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    342 #            matrix = self.items_matrix.avgLinkage(components) 
    343 #             
    344 #            edges = set() 
    345 #            for u in range(matrix.dim): 
    346 #                neighbours = matrix.getKNN(u, 2) 
    347 #                for v in neighbours: 
    348 #                    if v < u: 
    349 #                        edges.add((v, u)) 
    350 #                    else: 
    351 #                        edges.add((u, v)) 
    352 #            edges = list(edges) 
    353     # show 2n strongest edges 
    354     #          vals = matrix.getValues() 
    355     #          vals = zip(vals, range(len(vals))) 
    356     #          count = 0 
    357     #          add = 0 
    358     #          for i in range(matrix.dim): 
    359     #              add += i + 1 
    360     #              for j in range(i+1, matrix.dim): 
    361     #                  v, ind = vals[count] 
    362     #                  ind += add 
    363     #                  vals[count] = (v, ind) 
    364     #                  count += 1 
    365     #          vals.sort(reverse=0) 
    366     #          vals = vals[:2 * matrix.dim] 
    367     #          edges = [(ind / matrix.dim, ind % matrix.dim) for v, ind in vals] 
    368     #          print "number of component edges:", len(edges), "number of components:", len(components) 
    369 #            components_c = [(sum(self.networkCurve.coors[c][0]) / len(c), sum(self.networkCurve.coors[c][1]) / len(c)) for c in components] 
    370 #            weights = [1 - matrix[u,v] for u,v in edges] 
    371 #             
    372 #            max_weight = max(weights) 
    373 #            min_weight = min(weights) 
    374 #            span_weights = max_weight - min_weight 
    375 #           
    376 #        self.networkCurve.update_properties() 
    377          
    378         if self.insideview == 1: 
    379             selection = self.networkCurve.get_selected_nodes() 
    380             if len(selection) >= 1: 
    381                 visible = set() 
    382                 visible |= set(selection) 
    383                 visible |= self.getNeighboursUpTo(selection[0], self.insideviewNeighbours) 
    384                 self.networkCurve.set_hidden_nodes(set(range(self.graph.number_of_nodes())) - visible) 
    385      
    386         edgesCount = 0 
    387          
    388         if self.forceVectors != None: 
    389             for v in self.forceVectors: 
    390                 self.addCurve("force", Qt.white, Qt.green, 1, style=QwtPlotCurve.Lines, xData=v[0], yData=v[1], showFilledSymbols=False) 
    391          
    392         for r in self.circles: 
    393             step = 2 * pi / 64; 
    394             fi = 0 
    395             x = [] 
    396             y = [] 
    397             for i in range(65): 
    398                 x.append(r * cos(fi) + 5000) 
    399                 y.append(r * sin(fi) + 5000) 
    400                 fi += step 
    401                  
    402             self.addCurve("radius", Qt.white, Qt.green, 1, style=NetworkCurve.Lines, xData=x, yData=y, showFilledSymbols=False) 
    403          
    404         """ 
    405         if self.renderAntialiased: 
    406             self.networkCurve.setRenderHint(QwtPlotItem.RenderAntialiased) 
    407         else: 
    408             self.networkCurve.setRenderHint(QwtPlotItem.RenderAntialiased, False) 
    409         """ 
    410          
    411         self.networkCurve.showEdgeLabels = self.showEdgeLabels 
    412         self.networkCurve.attach(self) 
     203#        self.clear() 
     204#        self.tooltipData = [] 
     205#         
     206#        if self.forceVectors != None: 
     207#            for v in self.forceVectors: 
     208#                self.addCurve("force", Qt.white, Qt.green, 1, style=QwtPlotCurve.Lines, xData=v[0], yData=v[1], showFilledSymbols=False) 
     209#         
     210#        for r in self.circles: 
     211#            step = 2 * pi / 64; 
     212#            fi = 0 
     213#            x = [] 
     214#            y = [] 
     215#            for i in range(65): 
     216#                x.append(r * cos(fi) + 5000) 
     217#                y.append(r * sin(fi) + 5000) 
     218#                fi += step 
     219#                 
     220#            self.addCurve("radius", Qt.white, Qt.green, 1, style=NetworkCurve.Lines, xData=x, yData=y, showFilledSymbols=False) 
     221#       
     222#        #self.networkCurve.showEdgeLabels = self.showEdgeLabels 
     223#        self.networkCurve.attach(self) 
    413224             
    414225    def drawComponentKeywords(self): 
     
    416227            return 
    417228         
    418         if self.layout is None or self.graph is None or self.items is None: 
     229        if self.graph is None or self.items is None: 
    419230            return 
    420231         
     
    443254             
    444255            mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize) 
    445            
    446     def drawIndexes(self): 
    447         if self.showIndexes: 
    448             for vertex in self.networkCurve.vertices.itervalues(): 
    449                 if not vertex.show: 
    450                     continue 
    451                  
    452                 if self.labelsOnMarkedOnly and not (vertex.marked): 
    453                     continue 
    454                                    
    455                 x1 = self.networkCurve.coors[vertex.index][0] 
    456                 y1 = self.networkCurve.coors[vertex.index][1] 
    457      
    458                 lbl = str(vertex.index) 
    459                 mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignTop, size=self.fontSize) 
    460                 self.markerKeys['index ' + str(vertex.index)] = mkey          
    461      
    462     def drawWeights(self): 
    463         if self.showWeights: 
    464             for edge in self.edges: 
    465                 if not (edge.u.show and edge.v.show): 
    466                     continue 
    467                  
    468                 if self.labelsOnMarkedOnly and not (edge.u.marked and edge.v.marked): 
    469                     continue 
    470                                    
    471                 x1 = (self.networkCurve.coors[edge.u.index][0] + self.networkCurve.coors[edge.v.index][0]) / 2 
    472                 y1 = (self.networkCurve.coors[edge.u.index][1] + self.networkCurve.coors[edge.v.index][1]) / 2 
    473                  
    474                 if edge.weight == None: 
    475                     lbl = "None" 
    476                 else: 
    477                     lbl = "%.2f" % float(edge.weight) 
    478                  
    479                 mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize) 
    480                 self.markerKeys[(edge.u, edge.v)] = mkey 
    481256                             
    482257    def getColorIndeces(self, table, attribute, palette): 
     
    611386    def setEdgeLabelText(self, attributes): 
    612387        self.edgeLabelText = [] 
    613         if self.layout is None or self.graph is None or self.items is None: 
     388        if self.graph is None or self.items is None: 
    614389            return 
    615390         
     
    681456    def set_graph(self, graph, curve=None, items=None, links=None): 
    682457        self.clear() 
    683         self.vertexDegree = [] 
    684         self.minEdgeWeight = sys.maxint 
    685         self.maxEdgeWeight = 0 
    686458         
    687459        if graph is None: 
    688460            self.graph = None 
    689             #self.layout = None 
    690461            self.networkCurve = None 
    691462            self.items = None 
     
    696467            yMax = 1.0 
    697468            self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.fontSize) 
    698             self.tooltipNeighbours = 0 
    699469            self.replot() 
    700470            return 
    701471         
    702472        self.graph = graph 
    703         #self.layout = layout 
    704473        self.networkCurve = NetworkCurve() if curve is None else curve 
     474        self.add_custom_curve(self.networkCurve) 
     475         
    705476        self.items = items if items is not None else self.graph.items() 
    706477        self.links = links if links is not None else self.graph.links() 
  • orange/OrangeWidgets/Prototypes/OWNxExplorerQt.py

    r8598 r8601  
    3232    settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    3333    "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.use_antialiasing", "networkCanvas.use_animations", 
    34     "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices" 
     34    "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices", 
    3535    "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    3636    "showWeights", "showEdgeLabels", "colorSettings",  
     
    209209        OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i") 
    210210         
    211         ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setMarkMode) 
    212         OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.setMarkMode) 
    213         OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback = self.setMarkMode) 
     211        ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.set_mark_mode) 
     212        OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.set_mark_mode) 
     213        OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback = self.set_mark_mode) 
    214214        self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
    215215        self.searchStringTimer = QTimer(self) 
    216         self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode) 
    217          
    218         OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback = self.setMarkMode) 
    219         OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback = self.setMarkMode) 
     216        self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.set_mark_mode) 
     217         
     218        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback = self.set_mark_mode) 
     219        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback = self.set_mark_mode) 
    220220        ib = OWGUI.indentedBox(ribg, orientation = 0) 
    221         self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h))) 
     221        self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.set_mark_mode(h))) 
    222222        #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
    223223        OWGUI.widgetLabel(ribg, "Mark  vertices with ...") 
    224         OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.setMarkMode) 
    225         OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.setMarkMode) 
    226         self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h))) 
    227         OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.setMarkMode) 
    228         OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.setMarkMode) 
    229         OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.setMarkMode) 
     224        OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.set_mark_mode) 
     225        OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.set_mark_mode) 
     226        self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.set_mark_mode(h))) 
     227        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.set_mark_mode) 
     228        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.set_mark_mode) 
     229        OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.set_mark_mode) 
    230230        ib = OWGUI.indentedBox(ribg) 
    231         self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h))) 
     231        self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.set_mark_mode(h))) 
    232232        OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)") 
    233         self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback = self.setMarkMode) 
     233        self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback = self.set_mark_mode) 
    234234        ib = OWGUI.indentedBox(ribg) 
    235235        self.markInput = 0 
    236         self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h))) 
     236        self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.set_mark_mode(h))) 
    237237        self.markInputRadioButton.setEnabled(False) 
    238238         
    239239        ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
    240240        self.checkSendMarkedNodes = 0 
    241         OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback = self.setSendMarkedNodes, disabled=0) 
     241        OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback = self.send_marked_nodes, disabled=0) 
    242242         
    243243        G = self.networkCanvas.gui 
     
    324324         
    325325        self.icons = self.createAttributeIconDict() 
    326         self.setMarkMode() 
     326        self.set_mark_mode() 
    327327         
    328328        self.editAttribute = 0 
     
    575575        pass 
    576576     
    577     def setSendMarkedNodes(self): 
     577    def send_marked_nodes(self): 
    578578        if self.checkSendMarkedNodes: 
    579             self.networkCanvas.sendMarkedNodes = self.sendMarkedNodes 
    580             self.sendMarkedNodes(self.networkCanvas.getMarkedVertices()) 
     579            markedNodes = self.networkCanvas.marked_nodes() 
     580             
     581            if len(markedNodes) == 0: 
     582                self.send("Marked Items", None) 
     583                return 
     584             
     585            if self.graph is not None and self.graph_base.items() is not None: 
     586                items = self.graph_base.items().getitems(markedNodes) 
     587                self.send("Marked Items", items) 
     588                return 
     589             
     590            self.send("Marked Items", None) 
    581591        else: 
     592            self.networkCanvas.send_marked_nodes = None 
    582593            self.send("Marked Items", None) 
    583             self.networkCanvas.sendMarkedNodes = None 
    584          
    585     def sendMarkedNodes(self, markedNodes):         
    586         if len(markedNodes) == 0: 
    587             self.send("Marked Items", None) 
    588             return 
    589          
    590         if self.graph is not None and self.graph_base.items() is not None: 
    591             items = self.graph_base.items().getitems(markedNodes) 
    592             self.send("Marked Items", items) 
    593             return 
    594          
    595         self.send("Marked Items", None) 
    596594             
    597595    def showComponents(self): 
     
    969967        self.searchStringTimer.start(1000) 
    970968          
    971     def setMarkMode(self, i = None): 
     969    def set_mark_mode(self, i=None): 
    972970        self.searchStringTimer.stop() 
    973971        if not i is None: 
    974972            self.hubs = i 
    975973         
    976         #print self.hubs 
    977         self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0 
    978         self.networkCanvas.markWithRed = False 
    979  
     974        QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed) 
     975         
    980976        if self.graph is None: 
    981977            return 
    982978         
    983979        hubs = self.hubs 
    984         if hubs == 0: 
    985             self.networkCanvas.setMarkedVertices([]) 
    986             self.networkCanvas.replot() 
    987             return 
    988          
    989         elif hubs == 1: 
    990             #print "mark on given label" 
    991             txt = self.markSearchString 
    992             labelText = self.networkCanvas.labelText 
    993             self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
    994              
    995             toMark = [i for i, values in enumerate(self.graph_base.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(self.graph_base.items().domain)) + self.graph_base.items().domain.getmetas().keys()])] 
    996             self.networkCanvas.setMarkedVertices(toMark) 
    997             self.networkCanvas.replot() 
    998             return 
    999          
    1000         elif hubs == 2: 
    1001             #print "mark on focus" 
    1002             self.networkCanvas.unmark() 
    1003             self.networkCanvas.tooltipNeighbours = self.markDistance 
    1004             return 
    1005  
    1006         elif hubs == 3: 
    1007             #print "mark selected" 
    1008             self.networkCanvas.unmark() 
    1009             self.networkCanvas.selectionNeighbours = self.markDistance 
    1010             self.networkCanvas.markSelectionNeighbours() 
    1011             return 
    1012          
    1013         self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
    1014         powers = self.graph.degree() 
    1015         powers = [powers[key] for key in sorted(powers.keys())] 
    1016          
    1017         if hubs == 4: # at least N connections 
    1018             #print "mark at least N connections" 
    1019             N = self.markNConnections 
    1020             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power >= N]) 
    1021             self.networkCanvas.replot() 
    1022         elif hubs == 5: 
    1023             #print "mark at most N connections" 
    1024             N = self.markNConnections 
    1025             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power <= N]) 
    1026             self.networkCanvas.replot() 
    1027         elif hubs == 6: 
    1028             #print "mark more than any" 
    1029             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    1030             self.networkCanvas.replot() 
    1031         elif hubs == 7: 
    1032             #print "mark more than avg" 
    1033             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    1034             self.networkCanvas.replot() 
    1035         elif hubs == 8: 
    1036             #print "mark most" 
    1037             sortedIdx = range(len(powers)) 
    1038             sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y])) 
    1039             cutP = self.markNumber - 1 
    1040             cutPower = powers[sortedIdx[cutP]] 
    1041             while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower: 
    1042                 cutP += 1 
    1043             self.networkCanvas.setMarkedVertices(sortedIdx[:cutP]) 
    1044             self.networkCanvas.replot() 
    1045         elif hubs == 9: 
    1046             self.setMarkInput() 
     980         
     981        if hubs in [0,1,2,3]: 
     982            if hubs == 0: 
     983                self.networkCanvas.networkCurve.clear_node_marks() 
     984            elif hubs == 1: 
     985                #print "mark on given label" 
     986                txt = self.markSearchString 
     987                 
     988                toMark = set(i for i, values in enumerate(self.graph_base.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(self.graph_base.items().domain)) + self.graph_base.items().domain.getmetas().keys()])) 
     989                toMark = toMark.intersection(self.graph.nodes()) 
     990                self.networkCanvas.networkCurve.clear_node_marks() 
     991                self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
     992            elif hubs == 2: 
     993                #print "mark on focus" 
     994                self.networkCanvas.mark_neighbors = self.markDistance 
     995            elif hubs == 3: 
     996                #print "mark selected" 
     997                self.networkCanvas.mark_neighbors = self.markDistance 
     998                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed) 
     999                self.networkCanvas.mark_on_selection_changed() 
     1000                 
     1001        elif hubs in [4,5,6,7,8,9]: 
     1002             
     1003            powers = sorted(self.graph.degree_iter(), key=itemgetter(1), reverse=True) 
     1004             
     1005            if hubs == 4: 
     1006                #print "mark at least N connections" 
     1007                N = self.markNConnections 
     1008                self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     1009                    d >= N else (i, False) for i, d in powers)) 
     1010            elif hubs == 5: 
     1011                #print "mark at most N connections" 
     1012                N = self.markNConnections 
     1013                self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     1014                    d <= N else (i, False) for i, d in powers)) 
     1015            elif hubs == 6: 
     1016                #print "mark more than any" 
     1017                self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     1018                    d > max([0]+self.graph.degree(self.graph.neighbors(i)).values()) \ 
     1019                    else (i, False) for i,d in powers )) 
     1020            elif hubs == 7: 
     1021                #print "mark more than avg" 
     1022                self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     1023                    d > statc.mean([0]+self.graph.degree(self.graph.neighbors(i)).values()) \ 
     1024                    else (i, False) for i,d in powers )) 
     1025                self.networkCanvas.replot() 
     1026            elif hubs == 8: 
     1027                #print "mark most" 
     1028                self.networkCanvas.networkCurve.clear_node_marks() 
     1029                 
     1030                if self.markNumber < 1: 
     1031                    return 
     1032                 
     1033                cut = self.markNumber 
     1034                cutPower = powers[cut-1][1] 
     1035                while cut < len(powers) and powers[cut][1] == cutPower: 
     1036                    cut += 1 
     1037     
     1038                self.networkCanvas.networkCurve.clear_node_marks() 
     1039                self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for \ 
     1040                    i,d in powers[:cut])) 
     1041                 
     1042            elif hubs == 9: 
     1043                var = str(self.markInputCombo.currentText()) 
     1044                if self.markInputItems is not None and len(self.markInputItems) > 0: 
     1045                    values = [str(x[var]).strip().upper() for x in self.markInputItems] 
     1046                    tomark = dict((x, True) for x in self.graph.nodes() if str(self.graph_base.items()[x][var]).strip().upper() in values) 
     1047                    self.networkCanvas.networkCurve.clear_node_marks() 
     1048                    self.networkCanvas.networkCurve.set_node_marks(tomark) 
     1049                     
     1050                else: 
     1051                    self.networkCanvas.networkCurve.clear_node_marks()       
     1052         
     1053        self.nMarked = len(self.networkCanvas.marked_nodes()) 
     1054        self.send_marked_nodes() 
    10471055        
    10481056    def testRefresh(self): 
     
    13511359         
    13521360    def set_network_view(self, nxView): 
     1361        if self._network_view is not None: 
     1362            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
     1363             
    13531364        self._network_view = nxView 
    13541365         
     
    13781389        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    13791390        self.setCombos() 
    1380         self.networkCanvas.updateData() 
    1381          
    1382     def setMarkInput(self): 
    1383         var = str(self.markInputCombo.currentText()) 
    1384         #print 'combo:',self.markInputCombo.currentText() 
    1385         if self.markInputItems is not None and len(self.markInputItems) > 0: 
    1386             values = [str(x[var]).strip().upper() for x in self.markInputItems] 
    1387             toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
    1388             #print "mark:", toMark 
    1389             self.networkCanvas.setMarkedVertices(list(toMark)) 
    1390             self.networkCanvas.replot() 
    1391              
    1392         else: 
    1393             self.networkCanvas.setMarkedVertices([]) 
    1394             self.networkCanvas.replot()             
    1395      
     1391        #self.networkCanvas.updateData() 
     1392         
    13961393    def markItems(self, items): 
    13971394        self.markInputCombo.clear() 
     
    14161413                        self.markInputRadioButton.setEnabled(True) 
    14171414                 
    1418                         self.setMarkMode(9) 
     1415                        self.set_mark_mode(9) 
    14191416               
    14201417    def setExampleSubset(self, subset): 
     
    16751672        self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
    16761673        self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes) 
    1677         self.networkCanvas.updateData() 
     1674        #self.networkCanvas.updateData() 
    16781675        self.networkCanvas.replot() 
    16791676 
Note: See TracChangeset for help on using the changeset viewer.