Changeset 8485:314e77a56faf in orange


Ignore:
Timestamp:
07/27/11 15:46:52 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
a65734391bfa2bedd503fb7caecd1da35d400da7
Message:
 
Location:
orange/OrangeWidgets/Prototypes
Files:
2 edited

Legend:

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

    r8474 r8485  
    5151    self.update_properties() 
    5252    return selected 
    53        
    54   def set_edge_color(self, index, color, nocolor=0): 
    55       pen = self.edges[index].pen 
    56       if nocolor: 
    57         color.setAlpha(0) 
    58       self.edges[index].pen = QPen(color, pen.width()) 
    59       self.edges[index].pen.setCapStyle(Qt.RoundCap) 
    6053   
    6154  def get_selected_nodes(self): 
     
    262255        self.links = None 
    263256         
     257        self.axis_margin = 0 
     258        self.title_margin = 0 
     259        self.graph_margin = 1 
     260        self._legend_margin = QRectF(0, 0, 0, 0) 
     261         
    264262        self.setFocusPolicy(Qt.StrongFocus) 
    265263         
    266264    def update_canvas(self): 
    267265        self.networkCurve.update_properties() 
    268         #rect = self.networkCurve.dataRect() 
    269         #self.set_axis_scale(xBottom, min, max) 
    270         #self.set_axis_scale(yLeft, min, max) 
    271         self.set_dirty() 
    272         self.replot() 
    273266         
    274267    def getSelection(self): 
     
    293286      self.drawPlotItems() 
    294287       
    295     def optimize(self, frSteps): 
    296         qApp.processEvents() 
    297         tolerance = 5 
    298         initTemp = 100 
    299         breakpoints = 20 
    300         k = int(frSteps / breakpoints) 
    301         o = frSteps % breakpoints 
    302         iteration = 0 
    303         coolFactor = exp(log(10.0 / 10000.0) / frSteps) 
    304         #print coolFactor 
    305         if k > 0: 
    306             while iteration < breakpoints: 
    307                 initTemp = self.layout.fruchtermanReingold(k, initTemp, coolFactor, self.hiddenNodes) 
    308                 iteration += 1 
    309                 qApp.processEvents() 
    310                 self.updateCanvas() 
    311      
    312             initTemp = self.layout.fruchtermanReingold(o, initTemp, coolFactor, self.hiddenNodes) 
    313             qApp.processEvents() 
    314             self.updateCanvas() 
    315         else: 
    316             while iteration < o: 
    317                 initTemp = self.layout.fruchtermanReingold(1, initTemp, coolFactor, self.hiddenNodes) 
    318                 iteration += 1 
    319                 qApp.processEvents() 
    320                 self.updateCanvas() 
     288#    def optimize(self, frSteps): 
     289#        qApp.processEvents() 
     290#        tolerance = 5 
     291#        initTemp = 100 
     292#        breakpoints = 20 
     293#        k = int(frSteps / breakpoints) 
     294#        o = frSteps % breakpoints 
     295#        iteration = 0 
     296#        coolFactor = exp(log(10.0 / 10000.0) / frSteps) 
     297#        #print coolFactor 
     298#        if k > 0: 
     299#            while iteration < breakpoints: 
     300#                initTemp = self.layout.fruchtermanReingold(k, initTemp, coolFactor, self.hiddenNodes) 
     301#                iteration += 1 
     302#                qApp.processEvents() 
     303#                self.updateCanvas() 
     304#     
     305#            initTemp = self.layout.fruchtermanReingold(o, initTemp, coolFactor, self.hiddenNodes) 
     306#            qApp.processEvents() 
     307#            self.updateCanvas() 
     308#        else: 
     309#            while iteration < o: 
     310#                initTemp = self.layout.fruchtermanReingold(1, initTemp, coolFactor, self.hiddenNodes) 
     311#                iteration += 1 
     312#                qApp.processEvents() 
     313#                self.updateCanvas() 
    321314                 
    322315    def markedToSelection(self): 
     
    405398      if self.sendMarkedNodes != None: 
    406399            self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    407          
    408     def activateMoveSelection(self): 
    409         self.state = MOVE_SELECTION 
    410 #     
    411 #    def mouseMoveEvent(self, event): 
    412 #        if not self.graph: 
    413 #          return 
    414 #           
    415 #        if self.mouseCurrentlyPressed and self.state == MOVE_SELECTION and self.GMmouseMoveEvent != None: 
    416 #            newX = self.invTransform(2, event.pos().x()) 
    417 #            newY = self.invTransform(0, event.pos().y()) 
    418 #             
    419 #            dx = newX - self.invTransform(2, self.GMmouseMoveEvent.x()) 
    420 #            dy = newY - self.invTransform(0, self.GMmouseMoveEvent.y()) 
    421 #            movedVertices = self.networkCurve.move_selected_nodes(dx, dy) 
    422 #             
    423 #            self.GMmouseMoveEvent.setX(event.pos().x())  #zacetni dogodek postane trenutni 
    424 #            self.GMmouseMoveEvent.setY(event.pos().y()) 
    425 #             
    426 #            self.drawPlotItems(replot=1, vertices=movedVertices) 
    427 #            if self.callbackMoveVertex: 
    428 #                self.callbackMoveVertex() 
    429 #        else: 
    430 #            OWPlot.mouseMoveEvent(self, event) 
    431 #                 
    432 #        if not self.freezeNeighbours and self.tooltipNeighbours: 
    433 #            px = self.invTransform(2, event.x()) 
    434 #            py = self.invTransform(0, event.y())    
    435 #            ndx, mind = self.networkCurve.closest_node(px, py) 
    436 #            dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - event.x() 
    437 #            dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - event.y() 
    438 #            # transform to pixel distance 
    439 #            distance = math.sqrt(dX**2 + dY**2)  
    440 #               
    441 #            if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    442 #                toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours)) 
    443 #                self.networkCurve.set_marked_nodes(toMark) 
    444 #                self.drawPlotItems() 
    445 #                 
    446 #                if self.sendMarkedNodes != None: 
    447 #                    self.sendMarkedNodes(self.networkCurve.get_marked_nodes()) 
    448 #            else: 
    449 #                self.networkCurve.unmark() 
    450 #                self.drawPlotItems() 
    451 #                 
    452 #                if self.sendMarkedNodes != None: 
    453 #                    self.sendMarkedNodes([]) 
    454 #         
    455 #        if self.showDistances: 
    456 #            selection = self.networkCurve.get_selected_nodes() 
    457 #            if len(selection) > 0: 
    458 #                px = self.invTransform(2, event.x()) 
    459 #                py = self.invTransform(0, event.y())   
    460 #                  
    461 #                v, mind = self.networkCurve.closest_node(px, py) 
    462 #                dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[v][0]) - event.x() 
    463 #                dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[v][1]) - event.y() 
    464 #                # transform to pixel distance 
    465 #                distance = math.sqrt(dX**2 + dY**2)                
    466 #                if v != -1 and distance <= self.networkCurve.vertices[v].size: 
    467 #                    if self.items_matrix == None: 
    468 #                        dst = 'vertex distance signal not set' 
    469 #                    else: 
    470 #                        dst = 0 
    471 #                        for u in selection: 
    472 #                            dst += self.items_matrix[u, v] 
    473 #                        dst = dst / len(selection) 
    474 #                         
    475 #                    self.showTip(event.pos().x(), event.pos().y(), str(dst)) 
    476 #                    self.replot() 
    477 #     
    478 #    def mousePressEvent(self, event): 
    479 #      if self.graph is None: 
    480 #          return 
    481 #           
    482 #      #self.grabKeyboard() 
    483 #      self.mouseSelectedVertex = 0 
    484 #      self.GMmouseMoveEvent = None 
    485 #       
    486 #      if self.state == MOVE_SELECTION: 
    487 #        self.mouseCurrentlyPressed = 1 
    488 #        #if self.isPointSelected(self.invTransform(self.xBottom, event.pos().x()), self.invTransform(self.yLeft, event.pos().y())) and self.selection != []: 
    489 #        #  self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
    490 #        #else: 
    491 #          # button pressed outside selected area or there is no area 
    492 #        self.selectVertex(event.pos()) 
    493 #        self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
    494 #        self.replot() 
    495 #      elif self.state == SELECT_RECTANGLE: 
    496 #          self.GMmouseStartEvent = QPoint(event.pos().x(), event.pos().y()) 
    497 #           
    498 #          if self.clickedSelectedOnVertex(event.pos()): 
    499 #              self.mouseSelectedVertex = 1 
    500 #              self.mouseCurrentlyPressed = 1 
    501 #              self.state = MOVE_SELECTION 
    502 #              self.GMmouseMoveEvent = QPoint(event.pos().x(), event.pos().y()) 
    503 #          elif self.clickedOnVertex(event.pos()): 
    504 #              self.mouseSelectedVertex = 1 
    505 #              self.mouseCurrentlyPressed = 1 
    506 #          else: 
    507 #              OWPlot.mousePressEvent(self, event)   
    508 #      else: 
    509 #          OWPlot.mousePressEvent(self, event)      
    510 #     
    511 #    def mouseReleaseEvent(self, event):   
    512 #        if self.graph is None: 
    513 #          return 
    514 #           
    515 #        #self.releaseKeyboard() 
    516 #        if self.state == MOVE_SELECTION: 
    517 #            self.state = SELECT_RECTANGLE 
    518 #            self.mouseCurrentlyPressed = 0 
    519 #             
    520 #            self.moveGroup = False 
    521 #            #self.GMmouseStartEvent=None 
    522 #             
    523 #        if self.state == SELECT_RECTANGLE: 
    524 #            x1 = self.invTransform(2, self.GMmouseStartEvent.x()) 
    525 #            y1 = self.invTransform(0, self.GMmouseStartEvent.y()) 
    526 #             
    527 #            x2 = self.invTransform(2, event.pos().x()) 
    528 #            y2 = self.invTransform(0, event.pos().y()) 
    529 #             
    530 #             
    531 #            if self.mouseSelectedVertex == 1 and x1 == x2 and y1 == y2 and self.selectVertex(self.GMmouseStartEvent): 
    532 #                QwtPlot.mouseReleaseEvent(self, event) 
    533 #            elif self.mouseSelectedVertex == 0: 
    534 #                  
    535 #                selection = self.networkCurve.get_nodes_in_rect(x1, y1, x2, y2) 
    536 #     
    537 #                def selectVertex(ndx): 
    538 #                    if self.networkCurve.vertices[ndx].show: 
    539 #                        self.networkCurve.vertices[ndx].selected = True 
    540 #                         
    541 #                map(selectVertex, selection) 
    542 #                 
    543 #                if len(selection) == 0 and x1 == x2 and y1 == y2: 
    544 #                    self.removeSelection() 
    545 #                    self.unmark() 
    546 #             
    547 #                self.markSelectionNeighbours() 
    548 #                OWPlot.mouseReleaseEvent(self, event) 
    549 #                self.removeAllSelections() 
    550 #     
    551 #        elif self.state == SELECT_POLYGON: 
    552 #                OWPlot.mouseReleaseEvent(self, event) 
    553 #                if self.tempSelectionCurve == None:   #if OWVisGraph closed polygon 
    554 #                    self.selectVertices() 
    555 #        else: 
    556 #            OWPlot.mouseReleaseEvent(self, event) 
    557 #             
    558 #        self.mouseCurrentlyPressed = 0 
    559 #        self.moveGroup = False 
    560 #             
    561 #        if self.callbackSelectVertex != None: 
    562 #            self.callbackSelectVertex() 
    563 #     
    564 #    def keyPressEvent(self, e): 
    565 #        if self.graph is None: 
    566 #          return 
    567 #           
    568 #        if e.key() == 87 or e.key() == 81: 
    569 #            selection = [v.index for v in self.networkCurve.vertices.itervalues() if v.selected] 
    570 #            if len(selection) > 0: 
    571 #                phi = [math.pi / -180 if e.key() == 87 else math.pi / 180] 
    572 #                self.layout.rotate_vertices([selection], phi) 
    573 #                self.drawPlotItems(replot=1) 
    574 #             
    575 #        if e.key() == Qt.Key_Control: 
    576 #            self.controlPressed = True 
    577 #         
    578 #        elif e.key() == Qt.Key_Alt: 
    579 #            self.altPressed = True 
    580 #             
    581 #        if e.text() == "f": 
    582 #            self.graph.freezeNeighbours = not self.graph.freezeNeighbours 
    583 #         
    584 #        OWPlot.keyPressEvent(self, e) 
    585 #             
    586 #    def keyReleaseEvent(self, e): 
    587 #        if e.key() == Qt.Key_Control: 
    588 #            self.controlPressed = False 
    589 #         
    590 #        elif e.key() == Qt.Key_Alt: 
    591 #            self.altPressed = False 
    592 #         
    593 #        OWPlot.keyReleaseEvent(self, e) 
    594 #         
    595 #    def clickedSelectedOnVertex(self, pos): 
    596 #        min = 1000000 
    597 #        ndx = -1 
    598 #     
    599 #        px = self.invTransform(2, pos.x()) 
    600 #        py = self.invTransform(0, pos.y())    
    601 #     
    602 #        ndx, min = self.networkCurve.closest_node(px, py) 
    603 #        dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
    604 #        dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    605 #        # transform to pixel distance 
    606 #        distance = math.sqrt(dX**2 + dY**2) 
    607 #         
    608 #        #self.networkCurve 
    609 #         
    610 #        if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    611 #            return self.networkCurve.vertices[ndx].selected 
    612 #        else: 
    613 #            return False 
    614 #         
    615     def clickedOnVertex(self, pos): 
    616         min = 1000000 
    617         ndx = -1 
    618      
    619         px = self.invTransform(2, pos.x()) 
    620         py = self.invTransform(0, pos.y())    
    621      
    622         ndx, min = self.networkCurve.closest_node(px, py) 
    623         dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
    624         dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    625         # transform to pixel distance 
    626         distance = math.sqrt(dX**2 + dY**2) 
    627         if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    628             return True 
    629         else: 
    630             return False 
    631                  
    632     def selectVertex(self, pos): 
    633         min = 1000000 
    634         ndx = -1 
    635      
    636         px = self.invTransform(2, pos.x()) 
    637         py = self.invTransform(0, pos.y())    
    638      
    639         ndx, min = self.networkCurve.closest_node(px, py) 
    640          
    641         dX = self.transform(QwtPlot.xBottom, self.networkCurve.coors[ndx][0]) - pos.x() 
    642         dY = self.transform(QwtPlot.yLeft,   self.networkCurve.coors[ndx][1]) - pos.y() 
    643         # transform to pixel distance 
    644         distance = math.sqrt(dX**2 + dY**2) 
    645         if ndx != -1 and distance <= self.networkCurve.vertices[ndx].size: 
    646             if not self.appendToSelection and not self.controlPressed: 
    647                 self.removeSelection() 
    648                        
    649             if self.insideview: 
    650                 self.networkCurve.unselect() 
    651                 self.networkCurve.vertices[ndx].selected = not self.networkCurve.vertices[ndx].selected 
    652                 self.optimize(100) 
    653                  
    654                 self.markSelectionNeighbours() 
    655             else: 
    656                 self.networkCurve.vertices[ndx].selected = not self.networkCurve.vertices[ndx].selected 
    657                 self.markSelectionNeighbours() 
    658              
    659             return True   
    660         else: 
    661             return False 
    662             self.removeSelection() 
    663             self.unmark() 
    664400     
    665401    def updateData(self): 
     
    667403            return 
    668404         
    669 #        self.removeDrawingCurves(removeLegendItems=0) 
    670 #        self.tips.removeAll() 
     405        self.clear() 
     406        self.tooltipData = [] 
    671407#         
    672408#        if self.items_matrix and self.minComponentEdgeWidth > 0 and self.maxComponentEdgeWidth > 0:           
     
    743479        self.networkCurve.showEdgeLabels = self.showEdgeLabels 
    744480        self.networkCurve.attach(self) 
    745         self.drawPlotItems(replot=0) 
    746          
    747         #self.zoomExtent() 
    748          
    749     def drawPlotItems(self, replot=1, vertices=[]): 
    750 #        if len(vertices) > 0: 
    751 #            for vertex in vertices: 
    752 #                x1 = float(self.networkCurve.coors[vertex][0]) 
    753 #                y1 = float(self.networkCurve.coors[vertex][1]) 
    754 #                 
    755 #                if vertex in self.markerKeys: 
    756 #                    mkey = self.markerKeys[vertex] 
    757 #                    mkey.setValue(x1, y1) 
    758 #               
    759 #                if 'index ' + str(vertex) in self.markerKeys: 
    760 #                    mkey = self.markerKeys['index ' + str(vertex)] 
    761 #                    mkey.setValue(x1, y1) 
    762 #                 
    763 #                if vertex in self.tooltipKeys: 
    764 #                    tkey = self.tooltipKeys[vertex] 
    765 #                    self.tips.positions[tkey] = (x1, y1, 0, 0) 
    766 #        else: 
    767 #            self.markerKeys = {} 
    768 #            self.removeMarkers() 
    769 #            self.drawLabels() 
    770 #            self.drawToolTips() 
    771 #            self.drawWeights() 
    772 #            self.drawIndexes() 
    773 #            self.drawComponentKeywords() 
    774 #         
    775 #        if replot: 
    776             self.replot() 
    777481             
    778482    def drawComponentKeywords(self): 
     
    936640            return 
    937641         
    938 #        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discEdgePalette) 
    939 #     
    940 #        for index in range(len(self.networkCurve.edges)): 
    941 #            if colorIndex != None: 
    942 #                links_index = self.networkCurve.edges[index].links_index 
    943 #                if links_index == None: 
    944 #                    continue 
    945 #                 
    946 #                if self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     642        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
     643        colors = [] 
     644         
     645        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
     646            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
     647         
     648        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     649            #colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)])  
     650            #              if str(self.items[v][colorIndex].value) != '?' else  
     651            #              (v, self.discPalette[0]) for v in nodes) 
     652            print "TODO set continuous color" 
     653        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     654            #colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
     655            print "TODO set discrete color" 
     656        else: 
     657            colors = [self.discEdgePalette[0] for edge in self.networkCurve.edge_indices()] 
     658             
     659        self.networkCurve.set_edge_color(colors) 
     660        self.replot() 
     661         
     662#                 if self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    947663#                    newColor = self.discEdgePalette[0] 
    948 #                    if str(self.links[links_index][colorIndex]) != "?": 
    949 #                        if maxValue == minValue: 
    950 #                            newColor = self.discEdgePalette[0] 
    951664#                        else: 
    952665#                            value = (float(self.links[links_index][colorIndex].value) - minValue) / (maxValue - minValue) 
    953666#                            newColor = self.contEdgePalette[value] 
    954 #                         
    955 #                    self.networkCurve.set_edge_color(index, newColor) 
    956 #                     
    957667#                elif self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    958668#                    newColor = self.discEdgePalette[colorIndices[self.links[links_index][colorIndex].value]] 
     
    961671#                    else: 
    962672#                      self.networkCurve.set_edge_color(index, newColor) 
    963 #                     
    964 #            else: 
    965 #                newColor = self.discEdgePalette[0] 
    966 #                self.networkCurve.set_edge_color(index, newColor) 
    967 #         
    968 #        self.replot() 
    969673     
    970674    def set_node_color(self, attribute, nodes=None): 
     
    978682            nodes = self.graph.nodes() 
    979683         
    980         if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    981             for v in nodes: 
    982                 newColor = self.discPalette[0] 
    983                  
    984                 if str(self.items[v][colorIndex]) != "?": 
    985                     if maxValue == minValue: 
    986                         newColor = self.discPalette[0] 
    987                     else: 
    988                         value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
    989                         newColor = self.contPalette[value] 
    990                      
    991                 colors[v] = newColor 
    992                  
     684        if colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous and minValue == maxValue: 
     685            colors.update((node, self.discPalette[0]) for node in nodes) 
     686         
     687        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
     688            colors.update((v, self.contPalette[(float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue)])  
     689                          if str(self.items[v][colorIndex].value) != '?' else  
     690                          (v, self.discPalette[0]) for v in nodes) 
     691 
    993692        elif colorIndex is not None and self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
    994             for v in nodes: 
    995                 newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
    996                 colors[v] = newColor 
     693            colors.update((v, self.discPalette[colorIndices[self.items[v][colorIndex].value]]) for v in nodes) 
     694             
    997695        else: 
    998696            colors.update((node, self.discPalette[0]) for node in nodes) 
     
    1132830        #self.vertices_old = [(None, []) for v in self.graph] 
    1133831        vertices = dict((v, NodeItem(v, parent=self.networkCurve)) for v in self.graph) 
    1134          
     832        self.networkCurve.set_nodes(vertices) 
     833                 
    1135834        #build edge index 
    1136835        row_ind = {} 
     
    1171870             
    1172871        self.networkCurve.set_edges(edges) 
    1173         self.networkCurve.set_nodes(vertices) 
    1174872        self.networkCurve.update_properties() 
    1175873        self.replot() 
     
    1193891#        self.networkCurve.edges = edges 
    1194892#        self.networkCurve.changed() 
    1195          
    1196     def set_graph_layout(self, graph, layout, curve=None, items=None, links=None): 
    1197         self.clear() 
    1198         self.vertexDegree = [] 
    1199         #self.vertices_old = {} 
    1200         #self.vertices = [] 
    1201         #self.edges_old = {} 
    1202         #self.edges = [] 
    1203         self.minEdgeWeight = sys.maxint 
    1204         self.maxEdgeWeight = 0 
    1205          
    1206         if graph is None or layout is None: 
    1207             self.graph = None 
    1208             self.layout = None 
    1209             self.networkCurve = None 
    1210             self.items = None 
    1211             self.links = None 
    1212             xMin = -1.0 
    1213             xMax = 1.0 
    1214             yMin = -1.0 
    1215             yMax = 1.0 
    1216             self.addMarker("no network", (xMax - xMin) / 2, (yMax - yMin) / 2, alignment=Qt.AlignCenter, size=self.fontSize) 
    1217             self.tooltipNeighbours = 0 
    1218             self.replot() 
    1219             return 
    1220          
    1221         self.graph = graph 
    1222         self.layout = layout 
    1223         self.networkCurve = NetworkCurve(self) if curve is None else curve 
    1224         self.items = items if items is not None else self.graph.items() 
    1225         self.links = links if links is not None else self.graph.links() 
    1226          
    1227         #add nodes 
    1228         #self.vertices_old = [(None, []) for v in self.graph] 
    1229         vertices = dict((v, NodeItem(v)) for v in self.graph) 
    1230          
    1231         #build edge index 
    1232         row_ind = {} 
    1233         if self.links is not None and len(self.links) > 0: 
    1234           for i, r in enumerate(self.links): 
    1235               u = int(r['u'].value) 
    1236               v = int(r['v'].value) 
    1237               if u in self.graph and v in self.graph: 
    1238                   u_dict = row_ind.get(u, {}) 
    1239                   v_dict = row_ind.get(v, {}) 
    1240                   u_dict[v] = i 
    1241                   v_dict[u] = i 
    1242                   row_ind[u] = u_dict 
    1243                   row_ind[v] = v_dict 
    1244                
    1245         #add edges 
    1246         if self.links is not None and len(self.links) > 0: 
    1247             links = self.links 
    1248             links_indices = (row_ind[i + 1][j + 1] for (i, j) in self.graph.edges()) 
    1249             labels = ([str(row[r].value) for r in range(2, len(row))] for row in (links[links_index] for links_index in links_indices)) 
    1250              
    1251             if self.graph.is_directed(): 
    1252                 edges = [EdgeItem(vertices[i], vertices[j], 
    1253                     graph[i][j].get('weight', 1), 0, 1, links_index, label) for \ 
    1254                     ((i, j), links_index, label) in zip(self.graph.edges(), \ 
    1255                                                         links_indices, labels)] 
    1256             else: 
    1257                 edges = [EdgeItem(vertices[i], vertices[j], 
    1258                     graph[i][j].get('weight', 1), links_index, label) for \ 
    1259                     ((i, j), links_index, label) in zip(self.graph.edges(), \ 
    1260                                                         links_indices, labels)] 
    1261         elif self.graph.is_directed(): 
    1262             edges = [EdgeItem(vertices[i], vertices[j], 
    1263                                       graph[i][j].get('weight', 1), 0, 1) for (i, j) in self.graph.edges()] 
    1264         else: 
    1265             edges = [EdgeItem(vertices[i], vertices[j], 
    1266                                       graph[i][j].get('weight', 1)) for (i, j) in self.graph.edges()] 
    1267          
    1268         self.minEdgeWeight = min(edge.weight for edge in edges) if len(edges) > 0 else 0 
    1269         self.maxEdgeWeight = max(edge.weight for edge in edges) if len(edges) > 0 else 0 
    1270          
    1271         if self.minEdgeWeight is None:  
    1272             self.minEdgeWeight = 0  
    1273          
    1274         if self.maxEdgeWeight is None:  
    1275             self.maxEdgeWeight = 0  
    1276                            
    1277         self.maxEdgeSize = 10 
    1278              
    1279         self.setEdgesSize() 
    1280         self.setVerticesSize() 
    1281          
    1282         self.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    1283         self.networkCurve.vertices = vertices 
    1284         self.networkCurve.edges = edges 
    1285         self.networkCurve.changed() 
    1286893         
    1287894    def setEdgesSize(self): 
     
    1307914#                edge.pen = QPen(edge.pen.color(), 1) 
    1308915#                edge.pen.setCapStyle(Qt.RoundCap) 
    1309         pass 
    1310      
    1311     def updateCanvas(self): 
    1312         self.updateData() 
    1313         self.replot()   
    1314      
    1315     def zoomExtent(self): 
    1316         self.replot() 
    1317          
    1318     def zoomSelection(self): 
    1319         selection = self.networkCurve.get_selected_nodes() 
    1320         if len(selection) > 0:  
    1321             x = [self.networkCurve.coors[v][0] for v in selection] 
    1322             y = [self.networkCurve.coors[v][1] for v in selection] 
    1323      
    1324             oldXMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue() 
    1325             oldXMax = self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() 
    1326             oldYMin = self.axisScaleDiv(QwtPlot.yLeft).interval().minValue() 
    1327             oldYMax = self.axisScaleDiv(QwtPlot.yLeft).interval().maxValue() 
    1328             newXMin = min(x) 
    1329             newXMax = max(x) 
    1330             newYMin = min(y) 
    1331             newYMax = max(y) 
    1332             self.zoomStack.append((oldXMin, oldXMax, oldYMin, oldYMax)) 
    1333             self.setAxisScale(QwtPlot.xBottom, newXMin - 100, newXMax + 100) 
    1334             self.setAxisScale(QwtPlot.yLeft, newYMin - 100, newYMax + 100) 
    1335             self.replot() 
     916        pass     
    1336917                     
     918    def replot(self): 
     919        OWPlot.replot(self) 
     920         
     921        if hasattr(self, 'networkCurve') and self.networkCurve is not None: 
     922            self.networkCurve.update() 
  • orange/OrangeWidgets/Prototypes/OWNxExplorerQt.py

    r8474 r8485  
    3131class OWNxExplorerQt(OWWidget): 
    3232    settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    33     "maxLinkSize", "minVertexSize", "maxVertexSize", "renderAntialiased", 
     33    "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.use_antialiasing", 
    3434    "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", 
    3535    "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
     
    5959                        ("Attribute Selection List", AttributeList)] 
    6060         
     61        self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
     62         
    6163        self.markerAttributes = [] 
    6264        self.tooltipAttributes = [] 
     
    8385        self.maxVertexSize = 5 
    8486        self.minVertexSize = 5 
    85         self.renderAntialiased = 1 
    8687        self.labelsOnMarkedOnly = 0 
    8788        self.invertSize = 0 
     
    128129        self.controlArea.layout().setContentsMargins(4,4,0,4) 
    129130         
    130         self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
    131131        self.networkCanvas.showMissingValues = self.showMissingValues 
    132132        self.mainArea.layout().addWidget(self.networkCanvas) 
     
    204204        OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes))) 
    205205        OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly))) 
    206         OWGUI.checkBox(ib, self, 'renderAntialiased', 'Render antialiased', callback=(lambda: self._set_canvas_attr('renderAntialiased', self.renderAntialiased))) 
     206        self.networkCanvas.gui.antialiasing_check_box(ib) 
    207207        self.insideView = 0 
    208208        self.insideViewNeighbours = 2 
     
    639639            self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
    640640             
    641         self.networkCanvas.drawPlotItems() 
     641#        self.networkCanvas.drawPlotItems() 
    642642         
    643643    def nameComponents(self): 
     
    12761276         
    12771277        if self.frSteps < 10: 
    1278             self.renderAntialiased = 0 
     1278            self.networkCanvas.use_antialiasing = 0 
    12791279            self.minVertexSize = 5 
    12801280            self.maxVertexSize = 5 
     
    12831283            self.graph_layout_method()             
    12841284             
    1285         #self.setVertexColor() 
    1286         #self.setEdgeColor() 
     1285        self.setVertexSize() 
     1286        self.setVertexColor() 
     1287        self.setEdgeColor() 
    12871288        #self.networkCanvas.setEdgesSize() 
    12881289         
     
    13021303            self.graph_base = None 
    13031304#            self.layout.set_graph(None) 
    1304             self.networkCanvas.set_graph_layout(None, None) 
     1305#            self.networkCanvas.set_graph_layout(None, None) 
    13051306            self.clearCombos() 
    13061307            self.number_of_nodes_label = -1 
     
    13321333        #self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
    13331334        self.networkCanvas.set_graph(self.graph, items=self.graph_base.items(), links=self.graph_base.links()) 
    1334         self.networkCanvas.renderAntialiased = self.renderAntialiased 
    13351335        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    13361336        self.networkCanvas.minVertexSize = self.minVertexSize 
     
    13911391        # if graph is large, set random layout, min vertex size, min edge size 
    13921392        if self.frSteps < 10: 
    1393             self.renderAntialiased = 0 
     1393            self.networkCanvas.use_antialiasing = 0 
    13941394            self.minVertexSize = 5 
    13951395            self.maxVertexSize = 5 
     
    15861586        self.optButton.setChecked(False) 
    15871587#        self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    1588         self.networkCanvas.updateCanvas() 
     1588        #self.networkCanvas.updateCanvas() 
    15891589        qApp.processEvents() 
    15901590         
     
    17821782        self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
    17831783        self.lastColorColumn = self.colorCombo.currentText() 
    1784         #self.networkCanvas.updateData() 
    1785         #self.networkCanvas.replot() 
    17861784         
    17871785    def setEdgeColor(self): 
     
    17911789        self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
    17921790        self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    1793         self.networkCanvas.updateData() 
    1794         self.networkCanvas.replot() 
    17951791                   
    17961792    def setGraphGrid(self): 
     
    18351831        else: 
    18361832            self.networkCanvas.networkCurve.set_node_size(values, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
    1837              
    1838         self.networkCanvas.networkCurve.set_dirty() 
     1833         
    18391834        self.networkCanvas.replot() 
    18401835         
     
    18441839         
    18451840        self.networkCanvas.fontSize = self.fontSize 
    1846         self.networkCanvas.drawPlotItems() 
     1841#        self.networkCanvas.drawPlotItems() 
    18471842                 
    18481843    def sendReport(self): 
Note: See TracChangeset for help on using the changeset viewer.