Changeset 8081:922aa219574d in orange


Ignore:
Timestamp:
07/05/11 17:34:08 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
e685194341d7c07496b852f3cd5d63ead71c801d
Message:

new network visualization scheme

Location:
orange/OrangeWidgets/Unsupervised
Files:
2 edited

Legend:

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

    r8061 r8081  
    1515from orngScaleScatterPlotData import * 
    1616 
    17 class NetworkVertex(): 
     17class NodeItem(): 
    1818    def __init__(self, index=-1): 
    1919        self.index = index 
     
    3434        self.style = 1 
    3535     
    36 class NetworkEdge(): 
     36class EdgeItem(): 
    3737    def __init__(self, u=None, v=None, weight=0, arrowu=0, arrowv=0,  
    3838                 links_index=None, label=[]): 
     
    5252      QwtPlotCurve.__init__(self, "Network Curve") 
    5353 
    54       self.coors = None 
    55       self.vertices = [] 
     54      self.coors = {} 
     55      self.vertices = {} 
    5656      self.edges = [] 
    5757      self.setItemAttribute(QwtPlotItem.Legend, 0) 
    5858      self.showEdgeLabels = 0 
    5959 
    60   def moveSelectedVertices(self, dx, dy): 
    61     selected = self.getSelectedVertices() 
     60  def move_selected_nodes(self, dx, dy): 
     61    selected = self.get_selected_nodes() 
    6262     
    6363    self.coors[0][selected] = self.coors[0][selected] + dx 
     
    6767    return selected 
    6868   
    69   def setVertexColor(self, v, color): 
     69  def set_node_color(self, v, color): 
    7070      pen = self.vertices[v].pen 
    7171      self.vertices[v].color = color 
    7272      self.vertices[v].pen = QPen(color, pen.width()) 
    7373       
    74   def setEdgeColor(self, index, color, nocolor=0): 
     74  def set_edge_color(self, index, color, nocolor=0): 
    7575      pen = self.edges[index].pen 
    7676      if nocolor: 
     
    7979      self.edges[index].pen.setCapStyle(Qt.RoundCap) 
    8080   
    81   def getSelectedVertices(self): 
    82     return [vertex.index for vertex in self.vertices if vertex.selected] 
    83  
    84   def getUnselectedVertices(self): 
    85     return [vertex.index for vertex in self.vertices if not vertex.selected] 
    86  
    87   def getMarkedVertices(self): 
    88     return [vertex.index for vertex in self.vertices if vertex.marked] 
     81  def get_selected_nodes(self): 
     82    return [vertex.index for vertex in self.vertices.itervalues() if vertex.selected] 
     83 
     84  def get_unselected_nodes(self): 
     85    return [vertex.index for vertex in self.vertices.itervalues() if not vertex.selected] 
     86 
     87  def get_marked_nodes(self): 
     88    return [vertex.index for vertex in self.vertices.itervalues() if vertex.marked] 
    8989   
    90   def setMarkedVertices(self, vertices): 
    91     for vertex in self.vertices: 
     90  def set_marked_nodes(self, vertices): 
     91    for vertex in self.vertices.itervalues(): 
    9292      if vertex.index in vertices: 
    9393        vertex.marked = True 
     
    9595        vertex.marked = False 
    9696         
    97   def markToSel(self): 
    98     for vertex in self.vertices: 
     97  def mark_to_sel(self): 
     98    for vertex in self.vertices.itervalues(): 
    9999      if vertex.marked == True: 
    100100          vertex.selected = True 
    101101           
    102   def selToMark(self): 
    103     for vertex in self.vertices: 
     102  def sel_to_mark(self): 
     103    for vertex in self.vertices.itervalues(): 
    104104      if vertex.selected == True: 
    105105          vertex.selected = False 
    106106          vertex.marked = True 
    107107   
    108   def unMark(self): 
    109     for vertex in self.vertices: 
     108  def unmark(self): 
     109    for vertex in self.vertices.itervalues(): 
    110110      vertex.marked = False 
    111111       
    112   def unSelect(self): 
    113     for vertex in self.vertices: 
     112  def unselect(self): 
     113    for vertex in self.vertices.itervalues(): 
    114114        vertex.selected = False 
    115115         
    116   def setHiddenVertices(self, nodes): 
    117     for vertex in self.vertices: 
     116  def set_hidden_nodes(self, nodes): 
     117    for vertex in self.vertices.itervalues(): 
    118118      if vertex.index in nodes: 
    119119        vertex.show = False 
     
    121121        vertex.show = True 
    122122       
    123   def hideSelectedVertices(self): 
    124     for vertex in self.vertices: 
     123  def hide_selected_nodes(self): 
     124    for vertex in self.vertices.itervalues(): 
    125125      if vertex.selected: 
    126126        vertex.show = False 
    127127   
    128   def hideUnSelectedVertices(self): 
    129     for vertex in self.vertices: 
     128  def hide_unselected_nodes(self): 
     129    for vertex in self.vertices.itervalues(): 
    130130      if not vertex.selected: 
    131131        vertex.show = False 
    132132     
    133   def showAllVertices(self): 
    134     for vertex in self.vertices: 
     133  def show_all_vertices(self): 
     134    for vertex in self.vertices.itervalues(): 
    135135      vertex.show = True 
    136136     
     
    143143        painter.setPen(edge.pen) 
    144144 
    145         px1 = xMap.transform(self.coors[0][edge.u.index])   #ali pa tudi self.x1, itd 
    146         py1 = yMap.transform(self.coors[1][edge.u.index]) 
    147         px2 = xMap.transform(self.coors[0][edge.v.index]) 
    148         py2 = yMap.transform(self.coors[1][edge.v.index]) 
     145        px1 = xMap.transform(self.coors[edge.u.index][0])   #ali pa tudi self.x1, itd 
     146        py1 = yMap.transform(self.coors[edge.u.index][1]) 
     147        px2 = xMap.transform(self.coors[edge.v.index][0]) 
     148        py2 = yMap.transform(self.coors[edge.v.index][1]) 
    149149         
    150150        painter.drawLine(px1, py1, px2, py2) 
     
    185185            painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl) 
    186186     
    187     for vertex in self.vertices: 
     187    for key, vertex in self.vertices.iteritems(): 
    188188      if vertex.show: 
    189         pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer) 
    190         pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa 
     189        pX = xMap.transform(self.coors[vertex.index][0])   #dobimo koordinati v pikslih (tipa integer) 
     190        pY = yMap.transform(self.coors[vertex.index][1])   #ki se stejeta od zgornjega levega kota canvasa 
    191191        if vertex.selected:     
    192192          painter.setPen(QPen(Qt.yellow, 3)) 
     
    205205          painter.drawEllipse(rect) 
    206206         
     207 
     208  def closest_node(self, px, py): 
     209    ndx = min(self.coors, key=lambda x: abs(self.coors[x][0]-px) + abs(self.coors[x][1]-py)) 
     210    return ndx, math.sqrt((self.coors[ndx][0]-px)**2 + (self.coors[ndx][0]-px)**2) 
     211 
     212  def get_nodes_in_rect(self, x1, y1, x2, y2): 
     213      if x1 > x2: 
     214          x1, x2 = x2, x1 
     215      if y1 > y2: 
     216          y1, y2 = y2, y1 
     217      return [key for key in self.coors if x1 < self.coors[key][0] < x2 and y1 < self.coors[key][1] < y2] 
     218         
    207219class OWNxCanvas(OWGraph): 
    208220    def __init__(self, master, parent=None, name="None"): 
     
    212224        self.labelText = [] 
    213225        self.tooltipText = [] 
    214         self.vertices_old = {}         # distionary of nodes (orngIndex: vertex_objekt) 
    215         self.edges_old = {}            # distionary of edges (curveKey: edge_objekt) 
    216         self.vertices = [] 
    217         self.edges = [] 
     226        #self.vertices_old = {}         # distionary of nodes (orngIndex: vertex_objekt) 
     227        #self.edges_old = {}            # distionary of edges (curveKey: edge_objekt) 
     228        #self.vertices = [] 
     229        #self.edges = [] 
    218230        self.indexPairs = {}       # distionary of type CurveKey: orngIndex   (for nodes) 
    219231        #self.selection = []        # list of selected nodes (indices) 
     
    278290         
    279291    def getSelection(self): 
    280       return self.networkCurve.getSelectedVertices() 
    281      
    282     def getMarkedVertices(self): 
    283       return self.networkCurve.getMarkedVertices() 
     292      return self.networkCurve.get_selected_nodes() 
     293     
     294    def get_marked_nodes(self): 
     295      return self.networkCurve.get_marked_nodes() 
    284296         
    285297    def getVertexSize(self, index): 
    286298        return 6 
    287299         
    288     def setHiddenVertices(self, nodes): 
    289         self.networkCurve.setHiddenVertices(nodes) 
    290      
    291     def hideSelectedVertices(self): 
    292       self.networkCurve.hideSelectedVertices() 
     300    def set_hidden_nodes(self, nodes): 
     301        self.networkCurve.set_hidden_nodes(nodes) 
     302     
     303    def hide_selected_nodes(self): 
     304      self.networkCurve.hide_selected_nodes() 
    293305      self.drawPlotItems() 
    294306       
    295     def hideUnSelectedVertices(self): 
    296       self.networkCurve.hideUnSelectedVertices() 
     307    def hide_unselected_nodes(self): 
     308      self.networkCurve.hide_unselected_nodes() 
    297309      self.drawPlotItems() 
    298310       
    299     def showAllVertices(self): 
    300       self.networkCurve.showAllVertices() 
     311    def show_all_vertices(self): 
     312      self.networkCurve.show_all_vertices() 
    301313      self.drawPlotItems() 
    302314       
     
    329341                 
    330342    def markedToSelection(self): 
    331         self.networkCurve.markToSel() 
     343        self.networkCurve.mark_to_sel() 
    332344        self.drawPlotItems() 
    333345         
    334346    def selectionToMarked(self): 
    335         self.networkCurve.selToMark() 
     347        self.networkCurve.sel_to_mark() 
    336348        self.drawPlotItems() 
    337349         
    338350        if self.sendMarkedNodes != None: 
    339             self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
     351            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    340352         
    341353    def removeSelection(self, replot=True): 
    342         self.networkCurve.unSelect() 
     354        self.networkCurve.unselect() 
    343355         
    344356        if replot: 
     
    356368         
    357369    def getSelectedExamples(self): 
    358         selection = self.networkCurve.getSelectedVertices() 
     370        selection = self.networkCurve.get_selected_nodes() 
    359371         
    360372        if len(selection) == 0: 
     
    366378            return None 
    367379         
    368     def getUnselectedExamples(self): 
    369         unselection = self.networkCurve.getUnselectedVertices() 
     380    def getunselectedExamples(self): 
     381        unselection = self.networkCurve.get_unselected_nodes() 
    370382         
    371383        if len(unselection) == 0: 
     
    378390     
    379391    def getSelectedGraph(self): 
    380       selection = self.networkCurve.getSelectedVertices() 
     392      selection = self.networkCurve.get_selected_nodes() 
    381393       
    382394      if len(selection) == 0: 
     
    387399      return subnet 
    388400     
    389     def getSelectedVertices(self): 
    390       return self.networkCurve.getSelectedVertices() 
     401    def get_selected_nodes(self): 
     402      return self.networkCurve.get_selected_nodes() 
    391403     
    392404    def getNeighboursUpTo(self, ndx, dist): 
     
    403415        if not self.freezeNeighbours and self.selectionNeighbours: 
    404416            toMark = set() 
    405             for ndx in self.networkCurve.getSelectedVertices(): 
     417            for ndx in self.networkCurve.get_selected_nodes(): 
    406418                toMark |= self.getNeighboursUpTo(ndx, self.selectionNeighbours) 
    407419             
    408             self.networkCurve.setMarkedVertices(toMark) 
     420            self.networkCurve.set_marked_nodes(toMark) 
    409421            self.drawPlotItems() 
    410422                 
    411423        elif not self.freezeNeighbours and self.selectionNeighbours == 0: 
    412             self.networkCurve.setMarkedVertices(self.networkCurve.getSelectedVertices()) 
     424            self.networkCurve.set_marked_nodes(self.networkCurve.get_selected_nodes()) 
    413425            self.drawPlotItems() 
    414426             
    415427        if self.sendMarkedNodes != None: 
    416             self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
    417                  
    418     def unMark(self): 
    419       self.networkCurve.unMark() 
     428            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
     429                 
     430    def unmark(self): 
     431      self.networkCurve.unmark() 
    420432      self.drawPlotItems(replot=0) 
    421433       
     
    423435            self.sendMarkedNodes([]) 
    424436             
    425     def setMarkedVertices(self, vertices): 
    426       self.networkCurve.setMarkedVertices(vertices) 
     437    def set_marked_nodes(self, vertices): 
     438      self.networkCurve.set_marked_nodes(vertices) 
    427439      self.drawPlotItems(replot=0) 
    428440       
    429441      if self.sendMarkedNodes != None: 
    430             self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
     442            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    431443         
    432444    def activateMoveSelection(self): 
     
    443455            dx = newX - self.invTransform(2, self.GMmouseMoveEvent.x()) 
    444456            dy = newY - self.invTransform(0, self.GMmouseMoveEvent.y()) 
    445             movedVertices = self.networkCurve.moveSelectedVertices(dx, dy) 
     457            movedVertices = self.networkCurve.move_selected_nodes(dx, dy) 
    446458             
    447459            self.GMmouseMoveEvent.setX(event.pos().x())  #zacetni dogodek postane trenutni 
     
    457469            px = self.invTransform(2, event.x()) 
    458470            py = self.invTransform(0, event.y())    
    459             ndx, mind = self.layout.closest_vertex(px, py) 
    460             dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - event.x() 
    461             dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - event.y() 
     471            ndx, mind = self.networkCurve.closest_node(px, py) 
     472            dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - event.x() 
     473            dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - event.y() 
    462474            # transform to pixel distance 
    463475            distance = math.sqrt(dX**2 + dY**2)  
    464476               
    465             if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
     477            if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    466478                toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours)) 
    467                 self.networkCurve.setMarkedVertices(toMark) 
     479                self.networkCurve.set_marked_nodes(toMark) 
    468480                self.drawPlotItems() 
    469481                 
    470482                if self.sendMarkedNodes != None: 
    471                     self.sendMarkedNodes(self.networkCurve.getMarkedVertices()) 
     483                    self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    472484            else: 
    473                 self.networkCurve.unMark() 
     485                self.networkCurve.unmark() 
    474486                self.drawPlotItems() 
    475487                 
     
    478490         
    479491        if self.showDistances: 
    480             selection = self.networkCurve.getSelectedVertices() 
     492            selection = self.networkCurve.get_selected_nodes() 
    481493            if len(selection) > 0: 
    482494                px = self.invTransform(2, event.x()) 
    483495                py = self.invTransform(0, event.y())   
    484496                  
    485                 v, mind = self.layout.closest_vertex(px, py) 
    486                 dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][v]) - event.x() 
    487                 dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][v]) - event.y() 
     497                v, mind = self.networkCurve.closest_node(px, py) 
     498                dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[v][0]) - event.x() 
     499                dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[v][1]) - event.y() 
    488500                # transform to pixel distance 
    489501                distance = math.sqrt(dX**2 + dY**2)                
    490                 if v != -1 and distance <= self.vertices[v].size / 2: 
     502                if v != -1 and distance <= self.networkCurve.vertices[v].size: 
    491503                    if self.items_matrix == None: 
    492504                        dst = 'vertex distance signal not set' 
     
    557569            elif self.mouseSelectedVertex == 0: 
    558570                  
    559                 selection = self.layout.get_vertices_in_rect(x1, y1, x2, y2) 
     571                selection = self.networkCurve.get_nodes_in_rect(x1, y1, x2, y2) 
    560572     
    561573                def selectVertex(ndx): 
    562                     if self.vertices[ndx].show: 
    563                         self.vertices[ndx].selected = True 
     574                    if self.networkCurve.vertices[ndx].show: 
     575                        self.networkCurve.vertices[ndx].selected = True 
    564576                         
    565577                map(selectVertex, selection) 
     
    567579                if len(selection) == 0 and x1 == x2 and y1 == y2: 
    568580                    self.removeSelection() 
    569                     self.unMark() 
     581                    self.unmark() 
    570582             
    571583                self.markSelectionNeighbours() 
     
    591603           
    592604        if e.key() == 87 or e.key() == 81: 
    593             selection = [v.index for v in self.vertices if v.selected] 
     605            selection = [v.index for v in self.networkCurve.vertices.itervalues() if v.selected] 
    594606            if len(selection) > 0: 
    595607                phi = [math.pi / -180 if e.key() == 87 else math.pi / 180] 
     
    625637        py = self.invTransform(0, pos.y())    
    626638     
    627         ndx, min = self.layout.closest_vertex(px, py) 
    628         dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - pos.x() 
    629         dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - pos.y() 
     639        ndx, min = self.networkCurve.closest_node(px, py) 
     640        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     641        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    630642        # transform to pixel distance 
    631643        distance = math.sqrt(dX**2 + dY**2) 
    632         if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
    633             return self.vertices[ndx].selected 
     644         
     645        #self.networkCurve 
     646         
     647        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
     648            return self.networkCurve.vertices[ndx].selected 
    634649        else: 
    635650            return False 
     
    642657        py = self.invTransform(0, pos.y())    
    643658     
    644         ndx, min = self.layout.closest_vertex(px, py) 
    645         dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - pos.x() 
    646         dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - pos.y() 
     659        ndx, min = self.networkCurve.closest_node(px, py) 
     660        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     661        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    647662        # transform to pixel distance 
    648663        distance = math.sqrt(dX**2 + dY**2) 
    649         if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
     664        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    650665            return True 
    651666        else: 
     
    659674        py = self.invTransform(0, pos.y())    
    660675     
    661         ndx, min = self.layout.closest_vertex(px, py) 
    662          
    663         dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - pos.x() 
    664         dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - pos.y() 
     676        ndx, min = self.networkCurve.closest_node(px, py) 
     677         
     678        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     679        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    665680        # transform to pixel distance 
    666681        distance = math.sqrt(dX**2 + dY**2) 
    667         if ndx != -1 and distance <= self.vertices[ndx].size / 2: 
     682        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    668683            if not self.appendToSelection and not self.controlPressed: 
    669684                self.removeSelection() 
    670685                       
    671686            if self.insideview: 
    672                 self.networkCurve.unSelect() 
    673                 self.vertices[ndx].selected = not self.vertices[ndx].selected 
     687                self.networkCurve.unselect() 
     688                self.networkCurve.vertices[ndx].selected = not self.networkCurve.vertices[ndx].selected 
    674689                self.optimize(100) 
    675690                 
    676691                self.markSelectionNeighbours() 
    677692            else: 
    678                 self.vertices[ndx].selected = not self.vertices[ndx].selected 
     693                self.networkCurve.vertices[ndx].selected = not self.networkCurve.vertices[ndx].selected 
    679694                self.markSelectionNeighbours() 
    680695             
     
    683698            return False 
    684699            self.removeSelection() 
    685             self.unMark() 
     700            self.unmark() 
    686701     
    687702    def updateData(self): 
     
    721736    #          edges = [(ind / matrix.dim, ind % matrix.dim) for v, ind in vals] 
    722737    #          print "number of component edges:", len(edges), "number of components:", len(components) 
    723             components_c = [(sum(self.layout.coors[0][c]) / len(c), sum(self.layout.coors[1][c]) / len(c)) for c in components] 
     738            components_c = [(sum(self.networkCurve.coors[c][0]) / len(c), sum(self.networkCurve.coors[c][1]) / len(c)) for c in components] 
    724739            weights = [1 - matrix[u,v] for u,v in edges] 
    725740             
     
    744759         
    745760        if self.insideview == 1: 
    746             selection = self.networkCurve.getSelectedVertices() 
     761            selection = self.networkCurve.get_selected_nodes() 
    747762            if len(selection) >= 1: 
    748763                visible = set() 
    749764                visible |= set(selection) 
    750765                visible |= self.getNeighboursUpTo(selection[0], self.insideviewNeighbours) 
    751                 self.networkCurve.setHiddenVertices(set(range(self.graph.number_of_nodes())) - visible) 
     766                self.networkCurve.set_hidden_nodes(set(range(self.graph.number_of_nodes())) - visible) 
    752767     
    753768        edgesCount = 0 
     
    783798        if len(vertices) > 0: 
    784799            for vertex in vertices: 
    785                 x1 = float(self.layout.coors[0][vertex]) 
    786                 y1 = float(self.layout.coors[1][vertex]) 
     800                x1 = float(self.networkCurve.coors[vertex][0]) 
     801                y1 = float(self.networkCurve.coors[vertex][1]) 
    787802                 
    788803                if vertex in self.markerKeys: 
     
    826841                continue 
    827842             
    828             vertices = [vertex for vertex in component if self.vertices[vertex].show] 
     843            vertices = [vertex for vertex in component if self.networkCurve.vertices[vertex].show] 
    829844     
    830845            if len(vertices) == 0: 
    831846                continue 
    832847             
    833             xes = [self.layout.coors[0][vertex] for vertex in vertices]   
    834             yes = [self.layout.coors[1][vertex] for vertex in vertices]   
     848            xes = [self.networkCurve.coors[vertex][0] for vertex in vertices]   
     849            yes = [self.networkCurve.coors[vertex][1] for vertex in vertices]   
    835850                                   
    836851            x1 = sum(xes) / len(xes) 
     
    847862      self.tips.removeAll() 
    848863      if len(self.tooltipText) > 0: 
    849         for vertex in self.vertices: 
     864        for vertex in self.networkCurve.vertices.itervalues(): 
    850865          if not vertex.show: 
    851866            continue 
    852867           
    853           x1 = self.layout.coors[0][vertex.index] 
    854           y1 = self.layout.coors[1][vertex.index] 
     868          x1 = self.networkCurve.coors[vertex.index][0] 
     869          y1 = self.networkCurve.coors[vertex.index][1] 
    855870          lbl = "" 
    856871          values = self.graph.items()[vertex.index] 
     
    875890    def drawLabels(self): 
    876891        if len(self.labelText) > 0: 
    877             for vertex in self.vertices: 
     892            for vertex in self.networkCurve.vertices.itervalues(): 
    878893                if not vertex.show: 
    879894                    continue 
     
    882897                    continue 
    883898                                   
    884                 x1 = self.layout.coors[0][vertex.index] 
    885                 y1 = self.layout.coors[1][vertex.index] 
     899                x1 = self.networkCurve.coors[vertex.index][0] 
     900                y1 = self.networkCurve.coors[vertex.index][1] 
    886901                lbl = "" 
    887902                values = self.graph.items()[vertex.index] 
     
    900915    def drawIndexes(self): 
    901916        if self.showIndexes: 
    902             for vertex in self.vertices: 
     917            for vertex in self.networkCurve.vertices.itervalues(): 
    903918                if not vertex.show: 
    904919                    continue 
     
    907922                    continue 
    908923                                   
    909                 x1 = self.layout.coors[0][vertex.index] 
    910                 y1 = self.layout.coors[1][vertex.index] 
     924                x1 = self.networkCurve.coors[vertex.index][0] 
     925                y1 = self.networkCurve.coors[vertex.index][1] 
    911926     
    912927                lbl = str(vertex.index) 
     
    923938                    continue 
    924939                                   
    925                 x1 = (self.layout.coors[0][edge.u.index] + self.layout.coors[0][edge.v.index]) / 2 
    926                 y1 = (self.layout.coors[1][edge.u.index] + self.layout.coors[1][edge.v.index]) / 2 
     940                x1 = (self.networkCurve.coors[edge.u.index][0] + self.networkCurve.coors[edge.v.index][0]) / 2 
     941                y1 = (self.networkCurve.coors[edge.u.index][1] + self.networkCurve.coors[edge.v.index][1]) / 2 
    927942                 
    928943                if edge.weight == None: 
     
    965980        return colorIndices, colorIndex, minValue, maxValue 
    966981     
    967     def setEdgeColor(self, attribute): 
     982    def set_edge_color(self, attribute): 
    968983        if self.graph is None: 
    969984            return 
     
    9861001                            newColor = self.contEdgePalette[value] 
    9871002                         
    988                     self.networkCurve.setEdgeColor(index, newColor) 
     1003                    self.networkCurve.set_edge_color(index, newColor) 
    9891004                     
    9901005                elif self.graph.links().domain[colorIndex].varType == orange.VarTypes.Discrete: 
    9911006                    newColor = self.discEdgePalette[colorIndices[self.graph.links()[links_index][colorIndex].value]] 
    9921007                    if self.graph.links()[links_index][colorIndex].value == "0": 
    993                       self.networkCurve.setEdgeColor(index, newColor, nocolor=1) 
     1008                      self.networkCurve.set_edge_color(index, newColor, nocolor=1) 
    9941009                    else: 
    995                       self.networkCurve.setEdgeColor(index, newColor) 
     1010                      self.networkCurve.set_edge_color(index, newColor) 
    9961011                     
    9971012            else: 
    9981013                newColor = self.discEdgePalette[0] 
    999                 self.networkCurve.setEdgeColor(index, newColor) 
     1014                self.networkCurve.set_edge_color(index, newColor) 
    10001015         
    10011016        self.replot() 
    10021017     
    1003     def setVertexColor(self, attribute): 
     1018    def set_node_color(self, attribute): 
    10041019        if self.graph is None: 
    10051020            return 
     
    10071022        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.graph.items(), attribute, self.discPalette) 
    10081023     
    1009         for v in range(self.graph.number_of_nodes()): 
     1024        for key, vertex in self.networkCurve.vertices.iteritems(): 
     1025            v = vertex.index 
    10101026            if colorIndex != None:     
    10111027                if self.graph.items().domain[colorIndex].varType == orange.VarTypes.Continuous: 
     
    10191035                            newColor = self.contPalette[value] 
    10201036                         
    1021                     self.networkCurve.setVertexColor(v, newColor) 
     1037                    self.networkCurve.set_node_color(v, newColor) 
    10221038                     
    10231039                elif self.graph.items().domain[colorIndex].varType == orange.VarTypes.Discrete: 
    10241040                    newColor = self.discPalette[colorIndices[self.graph.items()[v][colorIndex].value]] 
    10251041                    #print newColor 
    1026                     self.networkCurve.setVertexColor(v, newColor) 
     1042                    self.networkCurve.set_node_color(v, newColor) 
    10271043                     
    10281044            else: 
    10291045                newColor = self.discPalette[0] 
    1030                 self.networkCurve.setVertexColor(v, newColor) 
     1046                self.networkCurve.set_node_color(v, newColor) 
    10311047         
    10321048        self.replot() 
     
    10701086        self.clear() 
    10711087        self.vertexDegree = [] 
    1072         self.vertices_old = {} 
    1073         self.vertices = [] 
    1074         self.edges_old = {} 
    1075         self.edges = [] 
     1088        #self.vertices_old = {} 
     1089        #self.vertices = [] 
     1090        #self.edges_old = {} 
     1091        #self.edges = [] 
    10761092        self.minEdgeWeight = sys.maxint 
    10771093        self.maxEdgeWeight = 0 
     
    10951111         
    10961112        #add nodes 
    1097         self.vertices_old = [(None, []) for v in self.graph] 
    1098         self.vertices = [NetworkVertex(v) for v in self.graph] 
     1113        #self.vertices_old = [(None, []) for v in self.graph] 
     1114        vertices = dict((v, NodeItem(v)) for v in self.graph) 
    10991115         
    11001116        #build edge index 
     
    11181134             
    11191135            if self.graph.is_directed(): 
    1120                 self.edges = [NetworkEdge(self.vertices[i], self.vertices[j], 
     1136                edges = [EdgeItem(vertices[i], vertices[j], 
    11211137                    graph[i][j].get('weight', 1), 0, 1, links_index, label) for \ 
    11221138                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
    11231139                                                        links_indices, labels)] 
    11241140            else: 
    1125                 self.edges = [NetworkEdge(self.vertices[i], self.vertices[j], 
     1141                edges = [EdgeItem(vertices[i], vertices[j], 
    11261142                    graph[i][j].get('weight', 1), links_index, label) for \ 
    11271143                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
    11281144                                                        links_indices, labels)] 
    11291145        elif self.graph.is_directed(): 
    1130             self.edges = [NetworkEdge(self.vertices[i], self.vertices[j], 
     1146            edges = [EdgeItem(vertices[i], vertices[j], 
    11311147                                      graph[i][j].get('weight', 1), 0, 1) for (i, j) in self.graph.edges()] 
    11321148        else: 
    1133             self.edges = [NetworkEdge(self.vertices[i], self.vertices[j],  
     1149            edges = [EdgeItem(vertices[i], vertices[j], 
    11341150                                      graph[i][j].get('weight', 1)) for (i, j) in self.graph.edges()] 
    11351151         
    1136         self.minEdgeWeight = min(edge.weight for edge in self.edges) if len(self.edges) > 0 else 0 
    1137         self.maxEdgeWeight = max(edge.weight for edge in self.edges) if len(self.edges) > 0 else 0 
     1152        self.minEdgeWeight = min(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1153        self.maxEdgeWeight = max(edge.weight for edge in edges) if len(edges) > 0 else 0 
    11381154         
    11391155        if self.minEdgeWeight is None:  
     
    11481164        self.setVerticesSize() 
    11491165         
    1150         self.networkCurve.coors = self.layout.coors 
    1151         self.networkCurve.vertices = self.vertices 
    1152         self.networkCurve.edges = self.edges 
     1166        self.networkCurve.coors = self.layout.map_to_graph(self.graph) 
     1167        self.networkCurve.vertices = vertices 
     1168        self.networkCurve.edges = edges 
    11531169        self.networkCurve.changed() 
    11541170         
     
    11591175            #print 'minEdgeWeight',self.minEdgeWeight 
    11601176            k = (self.maxEdgeSize - 1) / (self.maxEdgeWeight - self.minEdgeWeight) 
    1161             for edge in self.edges: 
     1177            for edge in self.networkCurve.edges: 
    11621178                if edge.weight == None: 
    11631179                    size = 1 
     
    11721188                    edge.pen.setCapStyle(Qt.RoundCap) 
    11731189        else: 
    1174             for edge in self.edges: 
     1190            for edge in self.networkCurve.edges: 
    11751191                edge.pen = QPen(edge.pen.color(), 1) 
    11761192                edge.pen.setCapStyle(Qt.RoundCap) 
     
    12051221                  
    12061222            if inverted: 
    1207                 for vertex in self.vertices: 
     1223                for key, vertex in self.networkCurve.vertices.iteritems(): 
    12081224                    if column in self.graph.items().domain: 
    12091225                        vertex.size = self.maxVertexSize - ((getValue(self.graph.items()[vertex.index][column]) - minVertexWeight) * k) 
     
    12141230                    vertex.pen.setWidthF(1 + float(vertex.size) / 20) 
    12151231            else: 
    1216                 for vertex in self.vertices: 
     1232                for key, vertex in self.networkCurve.vertices.iteritems(): 
    12171233                    if column in self.graph.items().domain: 
    12181234                        vertex.size = (getValue(self.graph.items()[vertex.index][column]) - minVertexWeight) * k + self.minVertexSize 
     
    12231239                    vertex.pen.setWidthF(1 + float(vertex.size) / 20) 
    12241240        else: 
    1225             for vertex in self.vertices: 
     1241            for key, vertex in self.networkCurve.vertices.iteritems(): 
    12261242                vertex.size = self.maxVertexSize 
    12271243                vertex.pen.setWidthF(1 + float(vertex.size) / 20) 
     
    12391255         
    12401256    def zoomSelection(self): 
    1241         selection = self.networkCurve.getSelectedVertices() 
     1257        selection = self.networkCurve.get_selected_nodes() 
    12421258        if len(selection) > 0:  
    1243             x = [self.layout.coors[0][v] for v in selection] 
    1244             y = [self.layout.coors[1][v] for v in selection] 
     1259            x = [self.networkCurve.coors[v][0] for v in selection] 
     1260            y = [self.networkCurve.coors[v][1] for v in selection] 
    12451261     
    12461262            oldXMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue() 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r8061 r8081  
    4545        OWWidget.__init__(self, parent, signalManager, name) 
    4646        #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    47         self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default),  
     47        self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
     48                       ("Nx View", Orange.network.NxView, self.set_network_view), 
    4849                       ("Items", Orange.data.Table, self.setItems), 
    4950                       ("Items to Mark", Orange.data.Table, self.markItems),  
     
    116117        self.number_of_nodes_label = -1 
    117118        self.number_of_edges_label = -1 
     119        self._items = None 
     120        self._links = None 
    118121        self.loadSettings() 
    119122         
     123        self._network_view = None 
    120124        self.layout = Orange.network.GraphLayout() 
    121125        self.graph = None 
     
    12161220            self.number_of_nodes_label = -1 
    12171221            self.number_of_edges_label = -1 
    1218             return 
     1222            self._items = None 
     1223            self._links = None 
     1224            return 
     1225         
     1226        self._items = graph.items() 
     1227        self._links = graph.links() 
     1228         
     1229        if self._network_view is not None: 
     1230            graph = self._network_view.init_network(graph) 
     1231         
    12191232         
    12201233        #print "OWNetwork/setGraph: new visualizer..." 
    12211234        self.graph = graph 
    12221235         
    1223         if graph.items() is not None and 'x' in graph.items().domain and 'y' in graph.items().domain: 
    1224             positions = [(ex['x'].value, ex['y'].value) for ex in graph.items() if ex['x'].value != '?' and ex['y'].value != '?'] 
     1236        if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
     1237            positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
     1238                         for node in sorted(graph) if self._items[node]['x'].value != '?' \ 
     1239                         and self._items[node]['y'].value != '?'] 
    12251240            self.layout.set_graph(graph, positions) 
    12261241        else: 
     
    13181333        self.graph_layout()         
    13191334        self.information(0) 
    1320         #self.controlArea.setEnabled(True) 
    1321         self.networkCanvas.updateCanvas() 
     1335        #self.networkCanvas.updateCanvas() 
     1336         
     1337    def set_network_view(self, nxView): 
     1338        self._network_view = nxView 
     1339        self.set_graph(self.graph) 
    13221340         
    13231341    def setItems(self, items=None): 
     
    13361354        self.networkCanvas.showIndexes = self.showIndexes 
    13371355        self.networkCanvas.showWeights = self.showWeights 
    1338         self.networkCanvas.showEdgeLabels = self.showEdgeLabels  
     1356        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    13391357        self.setCombos() 
    13401358        self.networkCanvas.updateData() 
     
    14831501             
    14841502        self.optButton.setChecked(False) 
     1503        self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    14851504        self.networkCanvas.updateCanvas() 
    14861505        qApp.processEvents() 
     
    15481567                iteration += 1 
    15491568                qApp.processEvents() 
     1569                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15501570                self.networkCanvas.updateCanvas() 
    15511571             
     
    15551575            initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
    15561576            qApp.processEvents() 
     1577            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15571578            self.networkCanvas.updateCanvas() 
    15581579        else: 
     
    15641585                iteration += 1 
    15651586                qApp.processEvents() 
     1587                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    15661588                self.networkCanvas.updateCanvas() 
    15671589                 
     
    16701692            return 
    16711693         
    1672         self.networkCanvas.setVertexColor(self.colorCombo.currentText()) 
     1694        self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
    16731695        self.lastColorColumn = self.colorCombo.currentText() 
    16741696        self.networkCanvas.updateData() 
     
    16791701            return 
    16801702         
    1681         self.networkCanvas.setEdgeColor(self.edgeColorCombo.currentText()) 
     1703        self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
    16821704        self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    16831705        self.networkCanvas.updateData() 
Note: See TracChangeset for help on using the changeset viewer.