Changeset 8420:74d3135b86b2 in orange


Ignore:
Timestamp:
07/23/11 10:33:19 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
6503e4811f33b6eeee0f069e4cb2646ca5dab839
Message:
 
Location:
orange/OrangeWidgets/Prototypes
Files:
2 edited

Legend:

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

    r8385 r8420  
    1010 
    1111import Orange 
     12import random  
    1213 
    1314from numpy import * 
     
    3536        self.size = 5 
    3637        self.style = 1 
     38         
     39        self.x = random.random() 
     40        self.y = random.random() 
    3741     
    3842class EdgeItem(orangeplot.EdgeItem): 
     
    6468         
    6569  def get_edges(self): 
     70      return self.edges 
     71   
     72  def get_nodes_2(self): 
     73      return self.nodes 
     74         
     75  def get_edges_2(self): 
    6676      return self.edges 
    6777 
     
    150160  def changed(self): 
    151161      self.itemChanged() 
    152  
    153   def draw(self, painter, xMap, yMap, rect): 
    154     for edge in self.edges: 
    155       if edge.u.show and edge.v.show: 
    156         painter.setPen(edge.pen) 
    157  
    158         px1 = xMap.transform(self.coors[edge.u.index][0])   #ali pa tudi self.x1, itd 
    159         py1 = yMap.transform(self.coors[edge.u.index][1]) 
    160         px2 = xMap.transform(self.coors[edge.v.index][0]) 
    161         py2 = yMap.transform(self.coors[edge.v.index][1]) 
    162          
    163         painter.drawLine(px1, py1, px2, py2) 
    164          
    165         d = 12 
    166         #painter.setPen(QPen(Qt.lightGray, 1)) 
    167         painter.setBrush(Qt.lightGray) 
    168         if edge.arrowu: 
    169             x = px2 - px1 
    170             y = py2 - py1 
    171              
    172             fi = math.atan2(y, x) * 180 * 16 / math.pi  
    173  
    174             if not fi is None: 
    175                 # (180*16) - fi - (20*16), (40*16) 
    176                 rect = QRectF(px2 - d, py2 - d, 2 * d, 2 * d) 
    177                 painter.drawPie(rect, 2560 - fi, 640) 
    178                  
    179         if edge.arrowv: 
    180             x = px2 - px1 
    181             y = py2 - py1 
    182              
    183             fi = math.atan2(y, x) * 180 * 16 / math.pi  
    184             if not fi is None: 
    185                 # (180*16) - fi - (20*16), (40*16) 
    186                 rect = QRectF(px2 - d, py2 - d, 2 * d, 2 * d) 
    187                 painter.drawPie(rect, 2560 - fi, 640) 
    188                  
    189         if self.showEdgeLabels and len(edge.label) > 0: 
    190             lbl = ', '.join(edge.label) 
    191             x = (px1 + px2) / 2 
    192             y = (py1 + py2) / 2 
    193              
    194             th = painter.fontMetrics().height() 
    195             tw = painter.fontMetrics().width(lbl) 
    196             r = QRect(x - tw / 2, y - th / 2, tw, th) 
    197             painter.fillRect(r, QBrush(Qt.white)) 
    198             painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl) 
    199      
    200     for key, vertex in self.vertices.iteritems(): 
    201       if vertex.show: 
    202         pX = xMap.transform(self.coors[vertex.index][0])   #dobimo koordinati v pikslih (tipa integer) 
    203         pY = yMap.transform(self.coors[vertex.index][1])   #ki se stejeta od zgornjega levega kota canvasa 
    204         if vertex.selected:     
    205           painter.setPen(QPen(Qt.yellow, 3)) 
    206           painter.setBrush(vertex.color) 
    207           rect = QRectF(pX - (vertex.size + 4) / 2, pY - (vertex.size + 4) / 2, vertex.size + 4, vertex.size + 4) 
    208           painter.drawEllipse(rect) 
    209         elif vertex.marked: 
    210           painter.setPen(vertex.pen) 
    211           painter.setBrush(vertex.color) 
    212           rect = QRectF(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size) 
    213           painter.drawEllipse(rect) 
    214         else: 
    215           painter.setPen(vertex.pen) 
    216           painter.setBrush(vertex.nocolor) 
    217           rect = QRectF(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size) 
    218           painter.drawEllipse(rect) 
     162# 
     163#  def draw(self, painter, xMap, yMap, rect): 
     164#    for edge in self.edges: 
     165#      if edge.u.show and edge.v.show: 
     166#        painter.setPen(edge.pen) 
     167# 
     168#        px1 = xMap.transform(self.coors[edge.u.index][0])   #ali pa tudi self.x1, itd 
     169#        py1 = yMap.transform(self.coors[edge.u.index][1]) 
     170#        px2 = xMap.transform(self.coors[edge.v.index][0]) 
     171#        py2 = yMap.transform(self.coors[edge.v.index][1]) 
     172#         
     173#        painter.drawLine(px1, py1, px2, py2) 
     174#         
     175#        d = 12 
     176#        #painter.setPen(QPen(Qt.lightGray, 1)) 
     177#        painter.setBrush(Qt.lightGray) 
     178#        if edge.arrowu: 
     179#            x = px2 - px1 
     180#            y = py2 - py1 
     181#             
     182#            fi = math.atan2(y, x) * 180 * 16 / math.pi  
     183# 
     184#            if not fi is None: 
     185#                # (180*16) - fi - (20*16), (40*16) 
     186#                rect = QRectF(px2 - d, py2 - d, 2 * d, 2 * d) 
     187#                painter.drawPie(rect, 2560 - fi, 640) 
     188#                 
     189#        if edge.arrowv: 
     190#            x = px2 - px1 
     191#            y = py2 - py1 
     192#             
     193#            fi = math.atan2(y, x) * 180 * 16 / math.pi  
     194#            if not fi is None: 
     195#                # (180*16) - fi - (20*16), (40*16) 
     196#                rect = QRectF(px2 - d, py2 - d, 2 * d, 2 * d) 
     197#                painter.drawPie(rect, 2560 - fi, 640) 
     198#                 
     199#        if self.showEdgeLabels and len(edge.label) > 0: 
     200#            lbl = ', '.join(edge.label) 
     201#            x = (px1 + px2) / 2 
     202#            y = (py1 + py2) / 2 
     203#             
     204#            th = painter.fontMetrics().height() 
     205#            tw = painter.fontMetrics().width(lbl) 
     206#            r = QRect(x - tw / 2, y - th / 2, tw, th) 
     207#            painter.fillRect(r, QBrush(Qt.white)) 
     208#            painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl) 
     209#     
     210#    for key, vertex in self.vertices.iteritems(): 
     211#      if vertex.show: 
     212#        pX = xMap.transform(self.coors[vertex.index][0])   #dobimo koordinati v pikslih (tipa integer) 
     213#        pY = yMap.transform(self.coors[vertex.index][1])   #ki se stejeta od zgornjega levega kota canvasa 
     214#        if vertex.selected:     
     215#          painter.setPen(QPen(Qt.yellow, 3)) 
     216#          painter.setBrush(vertex.color) 
     217#          rect = QRectF(pX - (vertex.size + 4) / 2, pY - (vertex.size + 4) / 2, vertex.size + 4, vertex.size + 4) 
     218#          painter.drawEllipse(rect) 
     219#        elif vertex.marked: 
     220#          painter.setPen(vertex.pen) 
     221#          painter.setBrush(vertex.color) 
     222#          rect = QRectF(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size) 
     223#          painter.drawEllipse(rect) 
     224#        else: 
     225#          painter.setPen(vertex.pen) 
     226#          painter.setBrush(vertex.nocolor) 
     227#          rect = QRectF(pX - vertex.size / 2, pY - vertex.size / 2, vertex.size, vertex.size) 
     228#          painter.drawEllipse(rect) 
    219229         
    220230  def closest_node(self, px, py): 
     
    438448    def activateMoveSelection(self): 
    439449        self.state = MOVE_SELECTION 
    440      
    441     def mouseMoveEvent(self, event): 
    442         if not self.graph: 
    443           return 
    444            
    445         if self.mouseCurrentlyPressed and self.state == MOVE_SELECTION and self.GMmouseMoveEvent != None: 
    446             newX = self.invTransform(2, event.pos().x()) 
    447             newY = self.invTransform(0, event.pos().y()) 
    448              
    449             dx = newX - self.invTransform(2, self.GMmouseMoveEvent.x()) 
    450             dy = newY - self.invTransform(0, self.GMmouseMoveEvent.y()) 
    451             movedVertices = self.networkCurve.move_selected_nodes(dx, dy) 
    452              
    453             self.GMmouseMoveEvent.setX(event.pos().x())  #zacetni dogodek postane trenutni 
    454             self.GMmouseMoveEvent.setY(event.pos().y()) 
    455              
    456             self.drawPlotItems(replot=1, vertices=movedVertices) 
    457             if self.callbackMoveVertex: 
    458                 self.callbackMoveVertex() 
    459         else: 
    460             OWPlot.mouseMoveEvent(self, event) 
    461                  
    462         if not self.freezeNeighbours and self.tooltipNeighbours: 
    463             px = self.invTransform(2, event.x()) 
    464             py = self.invTransform(0, event.y())    
    465             ndx, mind = self.networkCurve.closest_node(px, py) 
    466             dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - event.x() 
    467             dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - event.y() 
    468             # transform to pixel distance 
    469             distance = math.sqrt(dX**2 + dY**2)  
    470                
    471             if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    472                 toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours)) 
    473                 self.networkCurve.set_marked_nodes(toMark) 
    474                 self.drawPlotItems() 
    475                  
    476                 if self.sendMarkedNodes != None: 
    477                     self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    478             else: 
    479                 self.networkCurve.unmark() 
    480                 self.drawPlotItems() 
    481                  
    482                 if self.sendMarkedNodes != None: 
    483                     self.sendMarkedNodes([]) 
    484          
    485         if self.showDistances: 
    486             selection = self.networkCurve.get_selected_nodes() 
    487             if len(selection) > 0: 
    488                 px = self.invTransform(2, event.x()) 
    489                 py = self.invTransform(0, event.y())   
    490                   
    491                 v, mind = self.networkCurve.closest_node(px, py) 
    492                 dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[v][0]) - event.x() 
    493                 dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[v][1]) - event.y() 
    494                 # transform to pixel distance 
    495                 distance = math.sqrt(dX**2 + dY**2)                
    496                 if v != -1 and distance <= self.networkCurve.vertices[v].size: 
    497                     if self.items_matrix == None: 
    498                         dst = 'vertex distance signal not set' 
    499                     else: 
    500                         dst = 0 
    501                         for u in selection: 
    502                             dst += self.items_matrix[u, v] 
    503                         dst = dst / len(selection) 
    504                          
    505                     self.showTip(event.pos().x(), event.pos().y(), str(dst)) 
    506                     self.replot() 
    507      
    508     def mousePressEvent(self, event): 
    509       if self.graph is None: 
    510           return 
    511            
    512       #self.grabKeyboard() 
    513       self.mouseSelectedVertex = 0 
    514       self.GMmouseMoveEvent = None 
    515        
    516       if self.state == MOVE_SELECTION: 
    517         self.mouseCurrentlyPressed = 1 
    518         #if self.isPointSelected(self.invTransform(self.xBottom, event.pos().x()), self.invTransform(self.yLeft, event.pos().y())) and self.selection != []: 
    519         #  self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
    520         #else: 
    521           # button pressed outside selected area or there is no area 
    522         self.selectVertex(event.pos()) 
    523         self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
    524         self.replot() 
    525       elif self.state == SELECT_RECTANGLE: 
    526           self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
    527            
    528           if self.clickedSelectedOnVertex(event.pos()): 
    529               self.mouseSelectedVertex = 1 
    530               self.mouseCurrentlyPressed = 1 
    531               self.state = MOVE_SELECTION 
    532               self.GMmouseMoveEvent = QPoint(event.pos().x(), event.pos().y()) 
    533           elif self.clickedOnVertex(event.pos()): 
    534               self.mouseSelectedVertex = 1 
    535               self.mouseCurrentlyPressed = 1 
    536           else: 
    537               OWPlot.mousePressEvent(self, event)   
    538       else: 
    539           OWPlot.mousePressEvent(self, event)      
    540      
    541     def mouseReleaseEvent(self, event):   
    542         if self.graph is None: 
    543           return 
    544            
    545         #self.releaseKeyboard() 
    546         if self.state == MOVE_SELECTION: 
    547             self.state = SELECT_RECTANGLE 
    548             self.mouseCurrentlyPressed = 0 
    549              
    550             self.moveGroup = False 
    551             #self.GMmouseStartEvent=None 
    552              
    553         if self.state == SELECT_RECTANGLE: 
    554             x1 = self.invTransform(2, self.GMmouseStartEvent.x()) 
    555             y1 = self.invTransform(0, self.GMmouseStartEvent.y()) 
    556              
    557             x2 = self.invTransform(2, event.pos().x()) 
    558             y2 = self.invTransform(0, event.pos().y()) 
    559              
    560              
    561             if self.mouseSelectedVertex == 1 and x1 == x2 and y1 == y2 and self.selectVertex(self.GMmouseStartEvent): 
    562                 QwtPlot.mouseReleaseEvent(self, event) 
    563             elif self.mouseSelectedVertex == 0: 
    564                   
    565                 selection = self.networkCurve.get_nodes_in_rect(x1, y1, x2, y2) 
    566      
    567                 def selectVertex(ndx): 
    568                     if self.networkCurve.vertices[ndx].show: 
    569                         self.networkCurve.vertices[ndx].selected = True 
    570                          
    571                 map(selectVertex, selection) 
    572                  
    573                 if len(selection) == 0 and x1 == x2 and y1 == y2: 
    574                     self.removeSelection() 
    575                     self.unmark() 
    576              
    577                 self.markSelectionNeighbours() 
    578                 OWPlot.mouseReleaseEvent(self, event) 
    579                 self.removeAllSelections() 
    580      
    581         elif self.state == SELECT_POLYGON: 
    582                 OWPlot.mouseReleaseEvent(self, event) 
    583                 if self.tempSelectionCurve == None:   #if OWVisGraph closed polygon 
    584                     self.selectVertices() 
    585         else: 
    586             OWPlot.mouseReleaseEvent(self, event) 
    587              
    588         self.mouseCurrentlyPressed = 0 
    589         self.moveGroup = False 
    590              
    591         if self.callbackSelectVertex != None: 
    592             self.callbackSelectVertex() 
    593      
    594     def keyPressEvent(self, e): 
    595         if self.graph is None: 
    596           return 
    597            
    598         if e.key() == 87 or e.key() == 81: 
    599             selection = [v.index for v in self.networkCurve.vertices.itervalues() if v.selected] 
    600             if len(selection) > 0: 
    601                 phi = [math.pi / -180 if e.key() == 87 else math.pi / 180] 
    602                 self.layout.rotate_vertices([selection], phi) 
    603                 self.drawPlotItems(replot=1) 
    604              
    605         if e.key() == Qt.Key_Control: 
    606             self.controlPressed = True 
    607          
    608         elif e.key() == Qt.Key_Alt: 
    609             self.altPressed = True 
    610              
    611         if e.text() == "f": 
    612             self.graph.freezeNeighbours = not self.graph.freezeNeighbours 
    613          
    614         OWPlot.keyPressEvent(self, e) 
    615              
    616     def keyReleaseEvent(self, e): 
    617         if e.key() == Qt.Key_Control: 
    618             self.controlPressed = False 
    619          
    620         elif e.key() == Qt.Key_Alt: 
    621             self.altPressed = False 
    622          
    623         OWPlot.keyReleaseEvent(self, e) 
    624          
    625     def clickedSelectedOnVertex(self, pos): 
    626         min = 1000000 
    627         ndx = -1 
    628      
    629         px = self.invTransform(2, pos.x()) 
    630         py = self.invTransform(0, pos.y())    
    631      
    632         ndx, min = self.networkCurve.closest_node(px, py) 
    633         dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
    634         dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    635         # transform to pixel distance 
    636         distance = math.sqrt(dX**2 + dY**2) 
    637          
    638         #self.networkCurve 
    639          
    640         if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    641             return self.networkCurve.vertices[ndx].selected 
    642         else: 
    643             return False 
    644          
     450#     
     451#    def mouseMoveEvent(self, event): 
     452#        if not self.graph: 
     453#          return 
     454#           
     455#        if self.mouseCurrentlyPressed and self.state == MOVE_SELECTION and self.GMmouseMoveEvent != None: 
     456#            newX = self.invTransform(2, event.pos().x()) 
     457#            newY = self.invTransform(0, event.pos().y()) 
     458#             
     459#            dx = newX - self.invTransform(2, self.GMmouseMoveEvent.x()) 
     460#            dy = newY - self.invTransform(0, self.GMmouseMoveEvent.y()) 
     461#            movedVertices = self.networkCurve.move_selected_nodes(dx, dy) 
     462#             
     463#            self.GMmouseMoveEvent.setX(event.pos().x())  #zacetni dogodek postane trenutni 
     464#            self.GMmouseMoveEvent.setY(event.pos().y()) 
     465#             
     466#            self.drawPlotItems(replot=1, vertices=movedVertices) 
     467#            if self.callbackMoveVertex: 
     468#                self.callbackMoveVertex() 
     469#        else: 
     470#            OWPlot.mouseMoveEvent(self, event) 
     471#                 
     472#        if not self.freezeNeighbours and self.tooltipNeighbours: 
     473#            px = self.invTransform(2, event.x()) 
     474#            py = self.invTransform(0, event.y())    
     475#            ndx, mind = self.networkCurve.closest_node(px, py) 
     476#            dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - event.x() 
     477#            dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - event.y() 
     478#            # transform to pixel distance 
     479#            distance = math.sqrt(dX**2 + dY**2)  
     480#               
     481#            if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
     482#                toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours)) 
     483#                self.networkCurve.set_marked_nodes(toMark) 
     484#                self.drawPlotItems() 
     485#                 
     486#                if self.sendMarkedNodes != None: 
     487#                    self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
     488#            else: 
     489#                self.networkCurve.unmark() 
     490#                self.drawPlotItems() 
     491#                 
     492#                if self.sendMarkedNodes != None: 
     493#                    self.sendMarkedNodes([]) 
     494#         
     495#        if self.showDistances: 
     496#            selection = self.networkCurve.get_selected_nodes() 
     497#            if len(selection) > 0: 
     498#                px = self.invTransform(2, event.x()) 
     499#                py = self.invTransform(0, event.y())   
     500#                  
     501#                v, mind = self.networkCurve.closest_node(px, py) 
     502#                dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[v][0]) - event.x() 
     503#                dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[v][1]) - event.y() 
     504#                # transform to pixel distance 
     505#                distance = math.sqrt(dX**2 + dY**2)                
     506#                if v != -1 and distance <= self.networkCurve.vertices[v].size: 
     507#                    if self.items_matrix == None: 
     508#                        dst = 'vertex distance signal not set' 
     509#                    else: 
     510#                        dst = 0 
     511#                        for u in selection: 
     512#                            dst += self.items_matrix[u, v] 
     513#                        dst = dst / len(selection) 
     514#                         
     515#                    self.showTip(event.pos().x(), event.pos().y(), str(dst)) 
     516#                    self.replot() 
     517#     
     518#    def mousePressEvent(self, event): 
     519#      if self.graph is None: 
     520#          return 
     521#           
     522#      #self.grabKeyboard() 
     523#      self.mouseSelectedVertex = 0 
     524#      self.GMmouseMoveEvent = None 
     525#       
     526#      if self.state == MOVE_SELECTION: 
     527#        self.mouseCurrentlyPressed = 1 
     528#        #if self.isPointSelected(self.invTransform(self.xBottom, event.pos().x()), self.invTransform(self.yLeft, event.pos().y())) and self.selection != []: 
     529#        #  self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
     530#        #else: 
     531#          # button pressed outside selected area or there is no area 
     532#        self.selectVertex(event.pos()) 
     533#        self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
     534#        self.replot() 
     535#      elif self.state == SELECT_RECTANGLE: 
     536#          self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
     537#           
     538#          if self.clickedSelectedOnVertex(event.pos()): 
     539#              self.mouseSelectedVertex = 1 
     540#              self.mouseCurrentlyPressed = 1 
     541#              self.state = MOVE_SELECTION 
     542#              self.GMmouseMoveEvent = QPoint(event.pos().x(), event.pos().y()) 
     543#          elif self.clickedOnVertex(event.pos()): 
     544#              self.mouseSelectedVertex = 1 
     545#              self.mouseCurrentlyPressed = 1 
     546#          else: 
     547#              OWPlot.mousePressEvent(self, event)   
     548#      else: 
     549#          OWPlot.mousePressEvent(self, event)      
     550#     
     551#    def mouseReleaseEvent(self, event):   
     552#        if self.graph is None: 
     553#          return 
     554#           
     555#        #self.releaseKeyboard() 
     556#        if self.state == MOVE_SELECTION: 
     557#            self.state = SELECT_RECTANGLE 
     558#            self.mouseCurrentlyPressed = 0 
     559#             
     560#            self.moveGroup = False 
     561#            #self.GMmouseStartEvent=None 
     562#             
     563#        if self.state == SELECT_RECTANGLE: 
     564#            x1 = self.invTransform(2, self.GMmouseStartEvent.x()) 
     565#            y1 = self.invTransform(0, self.GMmouseStartEvent.y()) 
     566#             
     567#            x2 = self.invTransform(2, event.pos().x()) 
     568#            y2 = self.invTransform(0, event.pos().y()) 
     569#             
     570#             
     571#            if self.mouseSelectedVertex == 1 and x1 == x2 and y1 == y2 and self.selectVertex(self.GMmouseStartEvent): 
     572#                QwtPlot.mouseReleaseEvent(self, event) 
     573#            elif self.mouseSelectedVertex == 0: 
     574#                  
     575#                selection = self.networkCurve.get_nodes_in_rect(x1, y1, x2, y2) 
     576#     
     577#                def selectVertex(ndx): 
     578#                    if self.networkCurve.vertices[ndx].show: 
     579#                        self.networkCurve.vertices[ndx].selected = True 
     580#                         
     581#                map(selectVertex, selection) 
     582#                 
     583#                if len(selection) == 0 and x1 == x2 and y1 == y2: 
     584#                    self.removeSelection() 
     585#                    self.unmark() 
     586#             
     587#                self.markSelectionNeighbours() 
     588#                OWPlot.mouseReleaseEvent(self, event) 
     589#                self.removeAllSelections() 
     590#     
     591#        elif self.state == SELECT_POLYGON: 
     592#                OWPlot.mouseReleaseEvent(self, event) 
     593#                if self.tempSelectionCurve == None:   #if OWVisGraph closed polygon 
     594#                    self.selectVertices() 
     595#        else: 
     596#            OWPlot.mouseReleaseEvent(self, event) 
     597#             
     598#        self.mouseCurrentlyPressed = 0 
     599#        self.moveGroup = False 
     600#             
     601#        if self.callbackSelectVertex != None: 
     602#            self.callbackSelectVertex() 
     603#     
     604#    def keyPressEvent(self, e): 
     605#        if self.graph is None: 
     606#          return 
     607#           
     608#        if e.key() == 87 or e.key() == 81: 
     609#            selection = [v.index for v in self.networkCurve.vertices.itervalues() if v.selected] 
     610#            if len(selection) > 0: 
     611#                phi = [math.pi / -180 if e.key() == 87 else math.pi / 180] 
     612#                self.layout.rotate_vertices([selection], phi) 
     613#                self.drawPlotItems(replot=1) 
     614#             
     615#        if e.key() == Qt.Key_Control: 
     616#            self.controlPressed = True 
     617#         
     618#        elif e.key() == Qt.Key_Alt: 
     619#            self.altPressed = True 
     620#             
     621#        if e.text() == "f": 
     622#            self.graph.freezeNeighbours = not self.graph.freezeNeighbours 
     623#         
     624#        OWPlot.keyPressEvent(self, e) 
     625#             
     626#    def keyReleaseEvent(self, e): 
     627#        if e.key() == Qt.Key_Control: 
     628#            self.controlPressed = False 
     629#         
     630#        elif e.key() == Qt.Key_Alt: 
     631#            self.altPressed = False 
     632#         
     633#        OWPlot.keyReleaseEvent(self, e) 
     634#         
     635#    def clickedSelectedOnVertex(self, pos): 
     636#        min = 1000000 
     637#        ndx = -1 
     638#     
     639#        px = self.invTransform(2, pos.x()) 
     640#        py = self.invTransform(0, pos.y())    
     641#     
     642#        ndx, min = self.networkCurve.closest_node(px, py) 
     643#        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
     644#        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
     645#        # transform to pixel distance 
     646#        distance = math.sqrt(dX**2 + dY**2) 
     647#         
     648#        #self.networkCurve 
     649#         
     650#        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
     651#            return self.networkCurve.vertices[ndx].selected 
     652#        else: 
     653#            return False 
     654#         
    645655    def clickedOnVertex(self, pos): 
    646656        min = 1000000 
     
    697707            return 
    698708         
    699         self.removeDrawingCurves(removeLegendItems=0) 
    700         self.tips.removeAll() 
    701          
    702         if self.items_matrix and self.minComponentEdgeWidth > 0 and self.maxComponentEdgeWidth > 0:           
    703             components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    704             matrix = self.items_matrix.avgLinkage(components) 
    705              
    706             edges = set() 
    707             for u in range(matrix.dim): 
    708                 neighbours = matrix.getKNN(u, 2) 
    709                 for v in neighbours: 
    710                     if v < u: 
    711                         edges.add((v, u)) 
    712                     else: 
    713                         edges.add((u, v)) 
    714             edges = list(edges) 
     709#        self.removeDrawingCurves(removeLegendItems=0) 
     710#        self.tips.removeAll() 
     711#         
     712#        if self.items_matrix and self.minComponentEdgeWidth > 0 and self.maxComponentEdgeWidth > 0:           
     713#            components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
     714#            matrix = self.items_matrix.avgLinkage(components) 
     715#             
     716#            edges = set() 
     717#            for u in range(matrix.dim): 
     718#                neighbours = matrix.getKNN(u, 2) 
     719#                for v in neighbours: 
     720#                    if v < u: 
     721#                        edges.add((v, u)) 
     722#                    else: 
     723#                        edges.add((u, v)) 
     724#            edges = list(edges) 
    715725    # show 2n strongest edges 
    716726    #          vals = matrix.getValues() 
     
    729739    #          edges = [(ind / matrix.dim, ind % matrix.dim) for v, ind in vals] 
    730740    #          print "number of component edges:", len(edges), "number of components:", len(components) 
    731             components_c = [(sum(self.networkCurve.coors[c][0]) / len(c), sum(self.networkCurve.coors[c][1]) / len(c)) for c in components] 
    732             weights = [1 - matrix[u,v] for u,v in edges] 
    733              
    734             max_weight = max(weights) 
    735             min_weight = min(weights) 
    736             span_weights = max_weight - min_weight 
    737            
    738         self.networkCurve.updateProperties() 
     741#            components_c = [(sum(self.networkCurve.coors[c][0]) / len(c), sum(self.networkCurve.coors[c][1]) / len(c)) for c in components] 
     742#            weights = [1 - matrix[u,v] for u,v in edges] 
     743#             
     744#            max_weight = max(weights) 
     745#            min_weight = min(weights) 
     746#            span_weights = max_weight - min_weight 
     747#           
     748#        self.networkCurve.updateProperties() 
    739749         
    740750        if self.insideview == 1: 
     
    778788         
    779789    def drawPlotItems(self, replot=1, vertices=[]): 
    780         if len(vertices) > 0: 
    781             for vertex in vertices: 
    782                 x1 = float(self.networkCurve.coors[vertex][0]) 
    783                 y1 = float(self.networkCurve.coors[vertex][1]) 
    784                  
    785                 if vertex in self.markerKeys: 
    786                     mkey = self.markerKeys[vertex] 
    787                     mkey.setValue(x1, y1) 
    788                
    789                 if 'index ' + str(vertex) in self.markerKeys: 
    790                     mkey = self.markerKeys['index ' + str(vertex)] 
    791                     mkey.setValue(x1, y1) 
    792                  
    793                 if vertex in self.tooltipKeys: 
    794                     tkey = self.tooltipKeys[vertex] 
    795                     self.tips.positions[tkey] = (x1, y1, 0, 0) 
    796         else: 
    797             self.markerKeys = {} 
    798             self.removeMarkers() 
    799             self.drawLabels() 
    800             self.drawToolTips() 
    801             self.drawWeights() 
    802             self.drawIndexes() 
    803             self.drawComponentKeywords() 
    804          
    805         if replot: 
     790#        if len(vertices) > 0: 
     791#            for vertex in vertices: 
     792#                x1 = float(self.networkCurve.coors[vertex][0]) 
     793#                y1 = float(self.networkCurve.coors[vertex][1]) 
     794#                 
     795#                if vertex in self.markerKeys: 
     796#                    mkey = self.markerKeys[vertex] 
     797#                    mkey.setValue(x1, y1) 
     798#               
     799#                if 'index ' + str(vertex) in self.markerKeys: 
     800#                    mkey = self.markerKeys['index ' + str(vertex)] 
     801#                    mkey.setValue(x1, y1) 
     802#                 
     803#                if vertex in self.tooltipKeys: 
     804#                    tkey = self.tooltipKeys[vertex] 
     805#                    self.tips.positions[tkey] = (x1, y1, 0, 0) 
     806#        else: 
     807#            self.markerKeys = {} 
     808#            self.removeMarkers() 
     809#            self.drawLabels() 
     810#            self.drawToolTips() 
     811#            self.drawWeights() 
     812#            self.drawIndexes() 
     813#            self.drawComponentKeywords() 
     814#         
     815#        if replot: 
    806816            self.replot() 
    807817             
     
    9991009     
    10001010    def set_node_color(self, attribute, nodes=None): 
    1001         if self.graph is None: 
    1002             return 
    1003          
    1004         if nodes is None: 
    1005             nodes = self.networkCurve.vertices.itervalues() 
    1006         else: 
    1007             nodes = (self.networkCurve.vertices[nodes] for node in nodes)  
    1008              
    1009         colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
    1010      
    1011         if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    1012             for vertex in nodes: 
    1013                 v = vertex.index 
    1014                 newColor = self.discPalette[0] 
    1015                  
    1016                 if str(self.items[v][colorIndex]) != "?": 
    1017                     if maxValue == minValue: 
    1018                         newColor = self.discPalette[0] 
    1019                     else: 
    1020                         value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
    1021                         newColor = self.contPalette[value] 
    1022                      
    1023                 self.networkCurve.set_node_color(v, newColor) 
    1024                  
    1025         elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    1026             for vertex in nodes: 
    1027                 v = vertex.index 
    1028                 newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
    1029                 self.networkCurve.set_node_color(v, newColor) 
    1030         else: 
    1031             self.networkCurve.set_nodes_color(nodes, self.discPalette[0]) 
    1032              
     1011#        if self.graph is None: 
     1012#            return 
     1013#         
     1014#        if nodes is None: 
     1015#            nodes = self.networkCurve.vertices.itervalues() 
     1016#        else: 
     1017#            nodes = (self.networkCurve.vertices[nodes] for node in nodes)  
     1018#             
     1019#        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
     1020#     
     1021#        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     1022#            for vertex in nodes: 
     1023#                v = vertex.index 
     1024#                newColor = self.discPalette[0] 
     1025#                 
     1026#                if str(self.items[v][colorIndex]) != "?": 
     1027#                    if maxValue == minValue: 
     1028#                        newColor = self.discPalette[0] 
     1029#                    else: 
     1030#                        value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
     1031#                        newColor = self.contPalette[value] 
     1032#                     
     1033#                self.networkCurve.set_node_color(v, newColor) 
     1034#                 
     1035#        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     1036#            for vertex in nodes: 
     1037#                v = vertex.index 
     1038#                newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
     1039#                self.networkCurve.set_node_color(v, newColor) 
     1040#        else: 
     1041#            self.networkCurve.set_nodes_color(nodes, self.discPalette[0]) 
     1042#             
    10331043        self.replot() 
    10341044         
     
    11291139        self.networkCurve.edges = edges 
    11301140        self.networkCurve.changed() 
     1141         
     1142    def set_graph(self, graph, curve=None, items=None, links=None): 
     1143        self.clear() 
     1144        self.vertexDegree = [] 
     1145        #self.vertices_old = {} 
     1146        #self.vertices = [] 
     1147        #self.edges_old = {} 
     1148        #self.edges = [] 
     1149        self.minEdgeWeight = sys.maxint 
     1150        self.maxEdgeWeight = 0 
     1151         
     1152        if graph is None: 
     1153            self.graph = None 
     1154            #self.layout = None 
     1155            self.networkCurve = None 
     1156            self.items = None 
     1157            self.links = None 
     1158            xMin = -1.0 
     1159            xMax = 1.0 
     1160            yMin = -1.0 
     1161            yMax = 1.0 
     1162            self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.fontSize) 
     1163            self.tooltipNeighbours = 0 
     1164            self.replot() 
     1165            return 
     1166         
     1167        self.graph = graph 
     1168        #self.layout = layout 
     1169        self.networkCurve = NetworkCurve() if curve is None else curve 
     1170        self.items = items if items is not None else self.graph.items() 
     1171        self.links = links if links is not None else self.graph.links() 
     1172         
     1173        #add nodes 
     1174        #self.vertices_old = [(None, []) for v in self.graph] 
     1175        vertices = dict((v, NodeItem(v)) for v in self.graph) 
     1176         
     1177        self.networkCurve.nodes.clear() 
     1178        self.networkCurve.nodes.update(vertices) 
     1179                 
     1180        #build edge index 
     1181        row_ind = {} 
     1182        if self.links is not None and len(self.links) > 0: 
     1183          for i, r in enumerate(self.links): 
     1184              u = int(r['u'].value) 
     1185              v = int(r['v'].value) 
     1186              if u in self.graph and v in self.graph: 
     1187                  u_dict = row_ind.get(u, {}) 
     1188                  v_dict = row_ind.get(v, {}) 
     1189                  u_dict[v] = i 
     1190                  v_dict[u] = i 
     1191                  row_ind[u] = u_dict 
     1192                  row_ind[v] = v_dict 
     1193               
     1194        #add edges 
     1195        if self.links is not None and len(self.links) > 0: 
     1196            links = self.links 
     1197            links_indices = (row_ind[i + 1][j + 1] for (i, j) in self.graph.edges()) 
     1198            labels = ([str(row[r].value) for r in range(2, len(row))] for row in (links[links_index] for links_index in links_indices)) 
     1199             
     1200            if self.graph.is_directed(): 
     1201                edges = [EdgeItem(vertices[i], vertices[j], 
     1202                    graph[i][j].get('weight', 1), 0, 1, links_index, label) for \ 
     1203                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
     1204                                                        links_indices, labels)] 
     1205            else: 
     1206                edges = [EdgeItem(vertices[i], vertices[j], 
     1207                    graph[i][j].get('weight', 1), links_index, label) for \ 
     1208                    ((i, j), links_index, label) in zip(self.graph.edges(), \ 
     1209                                                        links_indices, labels)] 
     1210        elif self.graph.is_directed(): 
     1211            edges = [EdgeItem(vertices[i], vertices[j], 
     1212                                      graph[i][j].get('weight', 1), 0, 1) for (i, j) in self.graph.edges()] 
     1213        else: 
     1214            edges = [EdgeItem(vertices[i], vertices[j], 
     1215                                      graph[i][j].get('weight', 1)) for (i, j) in self.graph.edges()] 
     1216             
     1217        self.networkCurve.edges = edges 
     1218        self.networkCurve.updateProperties() 
     1219        self.replot() 
     1220#         
     1221#        self.minEdgeWeight = min(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1222#        self.maxEdgeWeight = max(edge.weight for edge in edges) if len(edges) > 0 else 0 
     1223#         
     1224#        if self.minEdgeWeight is None:  
     1225#            self.minEdgeWeight = 0  
     1226#         
     1227#        if self.maxEdgeWeight is None:  
     1228#            self.maxEdgeWeight = 0  
     1229#                           
     1230#        self.maxEdgeSize = 10 
     1231#             
     1232#        self.setEdgesSize() 
     1233#        self.setVerticesSize() 
     1234#         
     1235#        self.networkCurve.coors = self.layout.map_to_graph(self.graph) 
     1236#        self.networkCurve.vertices = vertices 
     1237#        self.networkCurve.edges = edges 
     1238#        self.networkCurve.changed() 
    11311239         
    11321240    def set_graph_layout(self, graph, layout, curve=None, items=None, links=None): 
  • orange/OrangeWidgets/Prototypes/OWNxExplorerQt.py

    r8384 r8420  
    1818 
    1919from OWWidget import * 
    20 from OWNxCanvas import * 
     20from OWNxCanvasQt import * 
    2121from operator import itemgetter 
    2222 
     
    286286         
    287287        ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
    288          
     288        ib.setVisible(False) 
    289289        #ib = OWGUI.widgetBox(ibProto, "Name components") 
    290290        OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
     
    13231323        self.number_of_edges_label = self.graph.number_of_edges() 
    13241324         
    1325         self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
     1325        #self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
     1326        self.networkCanvas.set_graph(self.graph, items=self.graph_base.items(), links=self.graph_base.links()) 
    13261327        self.networkCanvas.renderAntialiased = self.renderAntialiased 
    13271328        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     
    16261627        qApp.processEvents() 
    16271628        self.stopOptimization = 0 
    1628         tolerance = 5 
    1629         initTemp = 1000 
    1630         breakpoints = 6 
    1631         k = int(self.frSteps / breakpoints) 
    1632         o = self.frSteps % breakpoints 
    1633         iteration = 0 
    1634         coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps) 
    1635  
    1636         if k > 0: 
    1637             while iteration < breakpoints: 
    1638                 #print "iteration, initTemp: " + str(initTemp) 
    1639                 if self.stopOptimization: 
    1640                     return 
    1641                 initTemp = self.layout.fr(k, initTemp, coolFactor, weighted) 
    1642                 iteration += 1 
    1643                 qApp.processEvents() 
    1644                 self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    1645                 self.networkCanvas.updateCanvas() 
    1646              
    1647             #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp) 
    1648             if self.stopOptimization: 
    1649                     return 
    1650             initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
    1651             qApp.processEvents() 
    1652             self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    1653             self.networkCanvas.updateCanvas() 
    1654         else: 
    1655             while iteration < o: 
    1656                 #print "iteration ostanek, initTemp: " + str(initTemp) 
    1657                 if self.stopOptimization: 
    1658                     return 
    1659                 initTemp = self.layout.fr(1, initTemp, coolFactor, weighted) 
    1660                 iteration += 1 
    1661                 qApp.processEvents() 
    1662                 self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    1663                 self.networkCanvas.updateCanvas() 
     1629        cooling = math.exp(math.log(10.0/10000.0) / self.frSteps) 
     1630        self.networkCanvas.networkCurve.fr(10, False, 1000, cooling) 
     1631        self.networkCanvas.networkCurve.updateProperties() 
     1632        self.networkCanvas.replot() 
     1633#        tolerance = 5 
     1634#        initTemp = 1000 
     1635#        breakpoints = 6 
     1636#        k = int(self.frSteps / breakpoints) 
     1637#        o = self.frSteps % breakpoints 
     1638#        iteration = 0 
     1639#        coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps) 
     1640# 
     1641#        if k > 0: 
     1642#            while iteration < breakpoints: 
     1643#                #print "iteration, initTemp: " + str(initTemp) 
     1644#                if self.stopOptimization: 
     1645#                    return 
     1646#                initTemp = self.layout.fr(k, initTemp, coolFactor, weighted) 
     1647#                iteration += 1 
     1648#                qApp.processEvents() 
     1649#                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     1650#                self.networkCanvas.updateCanvas() 
     1651#             
     1652#            #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp) 
     1653#            if self.stopOptimization: 
     1654#                    return 
     1655#            initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
     1656#            qApp.processEvents() 
     1657#            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     1658#            self.networkCanvas.updateCanvas() 
     1659#        else: 
     1660#            while iteration < o: 
     1661#                #print "iteration ostanek, initTemp: " + str(initTemp) 
     1662#                if self.stopOptimization: 
     1663#                    return 
     1664#                initTemp = self.layout.fr(1, initTemp, coolFactor, weighted) 
     1665#                iteration += 1 
     1666#                qApp.processEvents() 
     1667#                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     1668#                self.networkCanvas.updateCanvas() 
    16641669                 
    16651670        self.optButton.setChecked(False) 
Note: See TracChangeset for help on using the changeset viewer.