Changeset 3774:5c97b5cc29bb in orange


Ignore:
Timestamp:
07/13/07 01:35:54 (7 years ago)
Author:
janezd <janez.demsar@…>
Branch:
default
Convert:
2ca2254e6555ff5fdbfd2d12f46a8759b915c322
Message:
  • rewrote the user interface
Location:
orange/OrangeWidgets/Prototypes
Files:
2 edited

Legend:

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

    r3749 r3774  
    77SELECT_RECTANGLE = 2 
    88SELECT_POLYGON = 3 
    9 MOVE_SELECTION = 4 
     9MOVE_SELECTION = 100 
    1010 
    1111import copy 
     
    1717 
    1818class OWGraphDrawerCanvas(OWGraph): 
    19     def __init__(self, graphDrawWidget, parent = None, name = "None"): 
     19    def __init__(self, master, parent = None, name = "None"): 
    2020        OWGraph.__init__(self, parent, name) 
     21        self.master = master 
    2122        self.parent = parent 
    2223        self.labelText = [] 
     
    2627        self.indexPairs = {}       # slovar oblike CurveKey: orngIndex   (za vozlisca) 
    2728        self.selection = []        # seznam izbranih vozlisc (njihovih indeksov) 
     29        self.tooltipped = []       # seznam oznacenih vozlisc 
    2830        self.selectionStyles = {}  # slovar stilov izbranih vozlisc 
    2931        self.colorIndex = -1 
     
    3941        self.state = NOTHING  #default je rocno premikanje 
    4042        self.hiddenNodes = [] 
     43        self.markedNodes = [] 
     44         
     45        self.tooltipNeighbours = 2 
     46        self.selectionNeighbours = 2 
     47        self.freezeNeighbours = False 
     48 
    4149         
    4250    def setHiddenNodes(self, nodes): 
     
    4553        self.updateCanvas() 
    4654         
    47     def addSelection(self, ndx): 
     55        
     56    def addSelection(self, ndx, replot = True): 
    4857        #print("add selection") 
    49         if isinstance(ndx, list): 
    50             change = False 
     58        change = False 
     59        if hasattr(ndx, "__iter__"): 
    5160            for v in ndx: 
    5261                if not v in self.selection and not v in self.hiddenNodes: 
     
    5766                    self.selection.append(v); 
    5867                    change = True 
    59             if change: 
    60                 self.replot() 
    61                 return True 
    6268        else: 
    6369            if not ndx in self.selection and not ndx in self.hiddenNodes: 
     
    6874                self.selection.append(ndx); 
    6975                #self.visualizer.filter[ndx] = True 
     76                change = True 
     77 
     78        if change: 
     79            if replot: 
    7080                self.replot() 
    71                 return True 
    72          
    73         return False 
    74  
    75              
    76     def removeSelection(self): 
    77         #print("remove selection") 
    78         for v in self.selection: 
     81            self.markSelectionNeighbours() 
     82         
     83        return change 
     84 
     85         
     86    def removeVertex(self, v): 
     87        if v in self.selection: 
    7988            (key, neighbours) = self.vertices[v] 
    8089            newSymbol = QwtSymbol(QwtSymbol.Ellipse, QBrush(QColor(self.selectionStyles[v])), QPen(QColor(self.selectionStyles[v])), QSize(6, 6)) 
    8190            self.setCurveSymbol(key, newSymbol) 
    82              
    83         self.selection = [] 
    84         #self.visualizer.unselectAll() 
    85         self.selectionStyles = {} 
    86         self.replot() 
    87          
    88     def generateVertexPower(self): 
    89         # init vertexPower 
    90         for i in range(self.nVertices): 
    91             self.vertexDegree.append((i,0)) 
    92              
    93         # calculate vertex power 
    94         for e in range(self.nEdges): 
    95             (key,i,j) = self.edges[e] 
    96             (v_i,power_i) = self.vertexDegree[i] 
    97             (v_j,power_j) = self.vertexDegree[j] 
    98              
    99             self.vertexDegree[i] = (v_i, power_i + 1) 
    100             self.vertexDegree[j] = (v_j, power_j + 1) 
     91            selection.remove(v) 
     92            del self.selectionStyles[v] 
     93            return True 
     94        return False 
     95         
     96    def removeSelection(self, ndx = None, replot = True): 
     97        #print("remove selection") 
     98        change = False 
     99        if ndx is None: 
     100            for v in self.selection: 
     101                (key, neighbours) = self.vertices[v] 
     102                newSymbol = QwtSymbol(QwtSymbol.Ellipse, QBrush(QColor(self.selectionStyles[v])), QPen(QColor(self.selectionStyles[v])), QSize(6, 6)) 
     103                self.setCurveSymbol(key, newSymbol) 
     104                self.selection = [] 
     105                #self.visualizer.unselectAll() 
     106                self.selectionStyles = {} 
     107                change = True 
     108             
     109        elif isinstance(ndx, list): 
     110            for v in ndx: 
     111                change = self.removeVertex(v) or change 
    101112                     
    102         # sort ascending by power 
    103         for i in range(self.nVertices - 1): 
    104             for j in range(i, self.nVertices): 
    105                 (v_i,power_i) = self.vertexDegree[i] 
    106                 (v_j,power_j) = self.vertexDegree[j] 
    107                  
    108                 if power_j > power_i: 
    109                     self.vertexDegree[i] = (v_j,power_j) 
    110                     self.vertexDegree[j] = (v_i,power_i) 
    111          
    112     def selectHubs(self, no): 
    113         #print "get hubs..." 
    114         hubs = self.visualizer.getHubs(no) 
    115         #print hubs 
    116         #print "start selecting..." 
    117         self.addSelection(hubs) 
    118         #print "done." 
     113        else: 
     114            change = self.removeVertex(ndx) 
     115         
     116        if change: 
     117            if replot: 
     118                self.replot() 
     119            self.markSelectionNeighbours() 
     120         
    119121             
    120122    def selectConnectedNodes(self, distance): 
     
    235237        self.setCurveData(self.edgesKey, edgesCurve.xData, edgesCurve.yData) 
    236238     
     239    def getNeighboursUpTo(self, ndx, dist): 
     240        newNeighbours = neighbours = set([ndx]) 
     241        for d in range(dist): 
     242            tNewNeighbours = set() 
     243            for v in newNeighbours: 
     244                tNewNeighbours |= set(self.visualizer.graph.getNeighbours(v)) 
     245            newNeighbours = tNewNeighbours - neighbours 
     246            neighbours |= newNeighbours 
     247        return neighbours 
     248      
    237249    def onMouseMoved(self, event): 
    238250        if self.mouseCurrentlyPressed and self.state == MOVE_SELECTION: 
     
    280292                self.GMmouseStartEvent.setY(event.pos().y()) 
    281293                self.replot() 
    282  
    283294        else: 
    284295            OWGraph.onMouseMoved(self, event) 
     296 
     297        if not self.freezeNeighbours and self.tooltipNeighbours: 
     298            px = self.invTransform(2, event.x()) 
     299            py = self.invTransform(0, event.y())    
     300            ndx, mind = self.visualizer.closestVertex(px, py) 
     301            if ndx != -1 and mind < 50: 
     302                self.setMarkedNodes(self.getNeighboursUpTo(ndx, self.tooltipNeighbours)) 
     303            else: 
     304                self.setMarkedNodes([]) 
     305         
     306         
     307    def markSelectionNeighbours(self): 
     308        if not self.freezeNeighbours and self.selectionNeighbours: 
     309            toMark = set() 
     310            for ndx in self.selection: 
     311                toMark |= self.getNeighboursUpTo(ndx, self.selectionNeighbours) 
     312            toMark -= set(self.selection) 
     313            self.setMarkedNodes(toMark) 
     314         
     315    def setMarkedNodes(self, marked): 
     316        for m in self.markedNodes: 
     317            (key, neighbours) = self.vertices[m] 
     318            newSymbol = QwtSymbol(QwtSymbol.Ellipse, QBrush(QColor(self.selectionStyles[m])), QPen(QColor(self.selectionStyles[m])), QSize(6, 6)) 
     319            self.setCurveSymbol(key, newSymbol) 
     320 
     321        self.markedNodes = marked 
     322         
     323        for m in marked: 
     324            (key, neighbours) = self.vertices[m] 
     325            self.selectionStyles[m] = self.curve(key).symbol().brush().color().name() 
     326            newSymbol = QwtSymbol(QwtSymbol.Ellipse, QBrush(QColor(self.selectionStyles[m])), QPen(Qt.green, 3), QSize(10, 10)) 
     327            self.setCurveSymbol(key, newSymbol) 
     328            self.tooltipped.append(m); 
     329             
     330        self.master.nMarked = len(self.markedNodes) 
     331        self.replot() 
     332         
     333 
     334    def activateMoveSelection(self): 
     335        self.state = MOVE_SELECTION 
    285336 
    286337 
     
    331382             
    332383            if self.isPointSelected(vObj.x(0), vObj.y(0)): 
    333                 self.addSelection(self.indexPairs[vertexKey]) 
     384                self.addSelection(self.indexPairs[vertexKey], False) 
     385        self.replot() 
    334386                 
    335387    def selectVertex(self, pos): 
     
    347399        #print "ndx: " + str(ndx) + " min: " + str(min) 
    348400        if min < 50 and ndx != -1: 
    349             self.addSelection(ndx) 
     401            self.addSelection(ndx) # do not replot if we replot later anyway 
    350402        else: 
    351403            self.removeSelection() 
    352404             
     405                 
    353406    def dist(self, s1, s2): 
    354407        return math.sqrt((s1[0]-s2[0])**2 + (s1[1]-s2[1])**2) 
     
    463516                y1 = self.visualizer.coors[v][1] 
    464517                lbl = "" 
    465                 for ndx in self.labelText: 
    466                     values = self.visualizer.graph.items[v] 
    467                     lbl = lbl + str(values[ndx]) + " " 
    468          
    469                 if lbl != '': 
     518                values = self.visualizer.graph.items[v] 
     519                lbl = " ".join([str(values[ndx]) for ndx in self.labelText]) 
     520                if lbl: 
    470521                    mkey = self.insertMarker(lbl) 
    471522                    self.marker(mkey).setXValue(float(x1)) 
  • orange/OrangeWidgets/Prototypes/OWNetwork.py

    r3755 r3774  
    1414from orngNetwork import *  
    1515from time import * 
     16import OWToolbars 
     17from statc import mean 
    1618 
    1719#ta razred je potreben, da lahko narisemo pixmap z painterjem 
     
    8284 
    8385class OWNetwork(OWWidget): 
     86    settingsList=["autoSendSelection", "spinExplicit", "spinPercentage"] 
     87    contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), 
     88                                                     ContextField("attributes", selected="tooltipAttributes"), 
     89                                                     "color"])} 
     90 
     91 
    8492    def __init__(self, parent=None, signalManager=None): 
    8593        OWWidget.__init__(self, parent, signalManager, 'Network') 
     
    8896        self.outputs=[("Selected Examples", ExampleTable), ("Selected Graph", orange.Graph)] 
    8997         
     98        self.markerAttributes = [] 
     99        self.tooltipAttributes = [] 
     100        self.attributes = [] 
     101        self.autoSendSelection = False 
    90102        self.graphShowGrid = 1  # show gridlines in the graph 
    91  
    92         # GUI        
    93         self.optimizeBox = QVGroupBox("Optimize", self.controlArea) 
    94         OWGUI.button(self.optimizeBox, self, "Random", callback=self.random) 
    95         OWGUI.button(self.optimizeBox, self, "F-R", callback=self.ff) 
    96         OWGUI.button(self.optimizeBox, self, "Circular", callback=self.circular) 
    97          
    98         self.styleBox = QVGroupBox("Style", self.controlArea) 
    99         QLabel("Color Attribute", self.styleBox) 
    100         self.colorCombo = OWGUI.comboBox(self.styleBox, self, "color", callback=self.setVertexColor) 
    101         self.colorCombo.insertItem("(none)") 
    102          
    103         QLabel("Select Marker Attributes", self.styleBox) 
    104         self.attListBox = QListBox(self.styleBox, "markerAttributes") 
    105         self.attListBox.setMultiSelection(True) 
    106         self.styleBox.connect(self.attListBox, SIGNAL("clicked( QListBoxItem * )"), self.clickedAttLstBox) 
    107          
    108         QLabel("Select ToolTip Attributes", self.styleBox) 
    109         self.tooltipListBox = QListBox(self.styleBox, "tooltipAttributes") 
    110         self.tooltipListBox.setMultiSelection(True) 
    111         self.styleBox.connect(self.tooltipListBox, SIGNAL("clicked( QListBoxItem * )"), self.clickedTooltipLstBox) 
    112          
    113         self.selectBox = QVGroupBox("Select", self.controlArea) 
    114         QLabel("Select Hubs", self.selectBox) 
    115         self.spinExplicit = 0 
    116         self.spinPercentage = 0 
    117         OWGUI.spin(self.selectBox, self, "spinPercentage", 0, 100, 1, label="Percentage:", callback=self.selectHubsPercentage) 
    118         OWGUI.spin(self.selectBox, self, "spinExplicit", 0, 1000000, 1, label="Explicit value:", callback=self.selectHubsExplicit) 
    119  
    120         QLabel("Select Connected Nodes", self.selectBox) 
    121         self.connectDistance = 0 
    122         OWGUI.spin(self.selectBox, self, "connectDistance", 0, 100, 1, label="Distance:", callback=self.selectConnectedNodes) 
    123   
    124         OWGUI.button(self.selectBox, self, "Select all Connected Nodes", callback=self.selectAllConnectedNodes) 
    125          
    126         self.hideBox = QVGroupBox("Hide", self.controlArea) 
    127         OWGUI.button(self.hideBox, self, "Hide selected", callback=self.hideSelected) 
    128         OWGUI.button(self.hideBox, self, "Hide all but selected", callback=self.hideAllButSelected) 
    129         OWGUI.button(self.hideBox, self, "Show all", callback=self.showAllNodes) 
    130          
    131         pics=pixmaps() 
    132          
    133         self.cgb = QHGroupBox(self.controlArea) 
    134         self.btnZomm = OWGUI.button(self.cgb, self, "", callback=self.btnZommClicked) 
    135         self.btnZomm.setToggleButton(1) 
    136         self.btnZomm.setPixmap(QPixmap(pics.LOOKG)) 
    137          
    138         self.btnMpos = OWGUI.button(self.cgb, self, "", callback=self.btnMposClicked) 
    139         self.btnMpos.setToggleButton(1) 
    140         self.btnMpos.setPixmap(QPixmap(pics.HAND)) 
    141          
    142         self.btnRctSel = OWGUI.button(self.cgb, self, "", callback=self.btnRctSelClicked) 
    143         self.btnRctSel.setToggleButton(1) 
    144         self.btnRctSel.setPixmap(QPixmap(pics.RECTG)) 
    145          
    146         self.btnPolySel = OWGUI.button(self.cgb, self, "", callback=self.btnPolySelClicked) 
    147         self.btnPolySel.setToggleButton(1) 
    148         self.btnPolySel.setPixmap(QPixmap(pics.POLYG)) 
    149          
    150         OWGUI.button(self.controlArea, self, "Save network", callback=self.saveNetwork) 
    151         OWGUI.button(self.controlArea, self, "Send", callback=self.sendData) 
    152         OWGUI.button(self.controlArea, self, "test replot", callback=self.testRefresh) 
    153          
    154         self.graph = OWGraphDrawerCanvas(self, self.mainArea, "ScatterPlot") 
     103         
     104        self.markNConnections = 2 
     105        self.markNumber = 0 
     106        self.markProportion = 0 
     107        self.markSearchString = "" 
     108        self.markDistance = 2 
     109        self.hubs = 0 
     110        self.color = 0 
     111        self.nVertices = self.nMarked = self.nSelected = self.nHidden = self.nShown = 0 
     112        self.optimizeWhat = 1 
     113         
     114        self.loadSettings() 
     115 
     116        self.visualize = None 
     117 
     118        self.graph = OWGraphDrawerCanvas(self, self.mainArea, "Network") 
    155119        #self.optimize = OWGraphDrawingOptimize(parent=self); 
    156120        #start of content (right) area 
    157121        self.box = QVBoxLayout(self.mainArea) 
    158122        self.box.addWidget(self.graph) 
    159      
     123 
     124        self.tabs = QTabWidget(self.controlArea) 
     125#        self.mainTab = QVGroupBox(self) 
     126        self.displayTab = QVGroupBox(self) 
     127        self.mainTab = self.displayTab 
     128        self.markTab = QVGroupBox(self) 
     129#        self.tabs.insertTab(self.mainTab, "Main") 
     130        self.tabs.insertTab(self.displayTab, "Display") 
     131        self.tabs.insertTab(self.markTab, "Mark") 
     132        OWGUI.separator(self.controlArea) 
     133 
     134 
     135        self.optimizeBox = OWGUI.radioButtonsInBox(self.mainTab, self, "optimizeWhat", [], "Optimize", addSpace=True) 
     136        OWGUI.button(self.optimizeBox, self, "Random", callback=self.random) 
     137        OWGUI.button(self.optimizeBox, self, "F-R", callback=self.ff) 
     138        OWGUI.button(self.optimizeBox, self, "Circular", callback=self.circular) 
     139        OWGUI.separator(self.optimizeBox) 
     140        OWGUI.widgetLabel("Optimize") 
     141        ib = OWGUI.indentedBox(self.optimizeBox) 
     142        for wh in ("All points", "Shown points", "Selected points"): 
     143            OWGUI.appendRadioButton(self.optimizeBox, self, "optimizeWhat", wh, insertInto=ib) 
     144         
     145        self.colorCombo = OWGUI.comboBox(self.displayTab, self, "color", box = "Color attribute", callback=self.setVertexColor) 
     146        self.colorCombo.insertItem("(none)") 
     147         
     148        self.attListBox = OWGUI.listBox(self.displayTab, self, "markerAttributes", "attributes", box = "Labels", selectionMode=QListBox.Multi, callback=self.clickedAttLstBox) 
     149         
     150        self.tooltipBox = OWGUI.widgetBox(self.mainTab, "Tooltips", addSpace = True) 
     151        self.tooltipListBox = OWGUI.listBox(self.tooltipBox, self, "tooltipAttributes", "attributes", selectionMode=QListBox.Multi, callback=self.clickedTooltipLstBox) 
     152 
     153         
     154        ib = OWGUI.widgetBox(self.markTab, "Info", addSpace = True) 
     155        OWGUI.label(ib, self, "Number of vertices: %(nVertices)i") 
     156        OWGUI.label(ib, self, "Shown/Hidden vertices: %(nShown)i/%(nHidden)i") 
     157        OWGUI.label(ib, self, "Selected vertices: %(nSelected)i") 
     158        OWGUI.label(ib, self, "Marked vertices: %(nMarked)i") 
     159         
     160        ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setHubs, addSpace = True) 
     161        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal") 
     162        OWGUI.separator(ribg) 
     163        OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices which label contain") 
     164        self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
     165        self.searchStringTimer = QTimer(self) 
     166        self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setHubs) 
     167         
     168        OWGUI.separator(ribg) 
     169        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertex") 
     170        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices") 
     171        ib = OWGUI.indentedBox(ribg, orientation = 0) 
     172        self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setHubs(h))) 
     173        OWGUI.separator(ib, 4, 4) 
     174        self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
     175        OWGUI.separator(ribg) 
     176        OWGUI.widgetLabel(ribg, "Mark  vertices with ...") 
     177        OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections") 
     178        OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections") 
     179        self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setHubs(h))) 
     180        OWGUI.separator(ribg) 
     181        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour") 
     182        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour") 
     183        OWGUI.separator(ribg) 
     184        OWGUI.appendRadioButton(ribg, self, "hubs", "most connections") 
     185        ib = OWGUI.indentedBox(ribg) 
     186        self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setHubs(h))) 
     187        OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)") 
     188#        self.ctrlMarkProportion = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markProportion", 0, 100, 1, label="Percentage" + ": ", callback=self.setHubs) 
     189         
     190        ib = OWGUI.widgetBox(self.markTab, "Selection", addSpace = True) 
     191        OWGUI.button(ib, self, "Add Marked to Selection", callback = self.markedToSelection) 
     192        OWGUI.button(ib, self, "Remove Marked from Selection",callback = self.markedFromSelection) 
     193        OWGUI.button(ib, self, "Set Selection to Marked", callback = self.setSelectionToMarked) 
     194 
     195        self.hideBox = QVGroupBox("Hide", self.markTab) 
     196        OWGUI.button(self.hideBox, self, "Hide selected", callback=self.hideSelected) 
     197        OWGUI.button(self.hideBox, self, "Hide unselected", callback=self.hideAllButSelected) 
     198        OWGUI.button(self.hideBox, self, "Show all", callback=self.showAllNodes) 
     199         
     200        pics=pixmaps() 
     201         
     202        T = OWToolbars.ZoomSelectToolbar 
     203        self.zoomSelectToolbar = OWToolbars.ZoomSelectToolbar(self, self.controlArea, self.graph, self.autoSendSelection, 
     204                                                              buttons = (T.IconZoom, T.IconPan, None, 
     205                                                                         ("Move selection", "buttonMoveSelection", "activateMoveSelection", QPixmap(OWToolbars.dlg_zoom), Qt.sizeAllCursor, 1), 
     206                                                                         T.IconRectangle, T.IconPolygon,  
     207                                                                         T.IconSendSelection)) 
     208         
     209        OWGUI.button(self.controlArea, self, "Save network", callback=self.saveNetwork) 
     210        OWGUI.button(self.controlArea, self, "test replot", callback=self.testRefresh) 
     211 
     212        self.icons = self.createAttributeIconDict() 
     213        self.setHubs() 
     214         
     215        self.resize(850, 700)     
     216     
     217    def setSearchStringTimer(self): 
     218        self.hubs = 1 
     219        self.searchStringTimer.stop() 
     220        self.searchStringTimer.start(750, True) 
     221          
     222    def setHubs(self, i = None): 
     223        if not i is None: 
     224            self.hubs = i 
     225             
     226        self.graph.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0 
     227 
     228        if not self.visualize or not self.visualize.graph: 
     229            return 
     230         
     231        hubs = self.hubs 
     232        vgraph = self.visualize.graph 
     233 
     234        if hubs == 0: 
     235            return 
     236         
     237        elif hubs == 1: 
     238            txt = self.markSearchString 
     239            labelText = self.graph.labelText 
     240            self.graph.setMarkedNodes([i for i, values in enumerate(vgraph.items) if txt in " ".join([str(values[ndx]) for ndx in labelText])]) 
     241            return 
     242         
     243        elif hubs == 2: 
     244            self.graph.setMarkedNodes([]) 
     245            self.graph.tooltipNeighbours = self.markDistance 
     246            return 
     247 
     248        elif hubs == 3: 
     249            self.graph.setMarkedNodes([]) 
     250            self.graph.selectionNeighbours = self.markDistance 
     251            self.graph.markSelectionNeighbours() 
     252            return 
     253         
     254        self.graph.tooltipNeighbours = self.graph.selectionNeighbours = 0 
     255        powers = vgraph.getDegrees() 
     256         
     257        if hubs == 4: # at least N connections 
     258            N = self.markNConnections 
     259            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power >= N]) 
     260        elif hubs == 5: 
     261            N = self.markNConnections 
     262            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power <= N]) 
     263        elif hubs == 6: 
     264            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])]) 
     265        elif hubs == 7: 
     266            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power > mean([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])]) 
     267        elif hubs == 8: 
     268            sortedIdx = range(len(powers)) 
     269            sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y])) 
     270            cutP = self.markNumber 
     271            cutPower = powers[sortedIdx[cutP]] 
     272            while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower: 
     273                cutP += 1 
     274            self.graph.setMarkedNodes(sortedIdx[:cutP-1]) 
     275             
     276         
     277    def clickedAttLstBox(self): 
     278        self.graph.setLabelText([self.attributes[i][0] for i in self.markerAttributes]) 
     279        self.updateCanvas() 
     280     
     281         
     282    def clickedTooltipLstBox(self): 
     283        self.graph.setTooltipText([self.attributes[i][0] for i in self.tooltipAttributes]) 
     284        self.updateCanvas() 
     285     
     286 
    160287    def testRefresh(self): 
    161288        start = time() 
     
    182309        self.graph.selectConnectedNodes(1000000) 
    183310             
    184     def selectHubsExplicit(self): 
    185         if self.spinExplicit > self.visualize.nVertices(): 
    186             self.spinExplicit = self.visualize.nVertices() 
    187              
    188         self.spinPercentage = 100 * self.spinExplicit / self.visualize.nVertices() 
    189         self.graph.selectHubs(self.spinExplicit) 
    190      
    191     def selectHubsPercentage(self): 
    192         self.spinExplicit = self.spinPercentage * self.visualize.nVertices() / 100 
    193         self.graph.selectHubs(self.spinExplicit) 
    194311     
    195312    def sendData(self): 
     
    209326            self.send("Selected Graph", None) 
    210327    
    211     def btnZommClicked(self): 
    212         self.btnZomm.setOn(1) 
    213         self.btnMpos.setOn(0) 
    214         self.btnRctSel.setOn(0) 
    215         self.btnPolySel.setOn(0) 
    216         self.graph.state = ZOOMING 
    217         self.graph.canvas().setCursor(Qt.crossCursor) 
    218      
    219     def btnMposClicked(self): 
    220         self.btnZomm.setOn(0) 
    221         self.btnMpos.setOn(1) 
    222         self.btnRctSel.setOn(0) 
    223         self.btnPolySel.setOn(0) 
    224         self.graph.state = MOVE_SELECTION 
    225         self.graph.canvas().setCursor(Qt.pointingHandCursor) 
    226          
    227     def btnRctSelClicked(self): 
    228         self.btnZomm.setOn(0) 
    229         self.btnMpos.setOn(0) 
    230         self.btnRctSel.setOn(1) 
    231         self.btnPolySel.setOn(0) 
    232         self.graph.state = SELECT_RECTANGLE 
    233         self.graph.canvas().setCursor(Qt.arrowCursor) 
    234      
    235     def btnPolySelClicked(self): 
    236         self.btnZomm.setOn(0) 
    237         self.btnMpos.setOn(0) 
    238         self.btnRctSel.setOn(0) 
    239         self.btnPolySel.setOn(1) 
    240         self.graph.state = SELECT_POLYGON 
    241         self.graph.canvas().setCursor(Qt.arrowCursor) 
    242      
    243     def clickedAttLstBox(self, item): 
    244         attributes = [] 
    245         i = self.attListBox.firstItem() 
    246         while i: 
    247             if self.attListBox.isSelected(i): 
    248                 attributes.append(str(i.text())) 
    249             i = i.next() 
    250         
    251         self.graph.setLabelText(attributes) 
    252         self.updateCanvas() 
    253          
    254     def clickedTooltipLstBox(self, item): 
    255         attributes = [] 
    256         i = self.tooltipListBox.firstItem() 
    257         while i: 
    258             if self.tooltipListBox.isSelected(i): 
    259                 attributes.append(str(i.text())) 
    260             i = i.next() 
    261         
    262         self.graph.setTooltipText(attributes) 
    263         self.updateCanvas() 
     328     
    264329     
    265330    def setGraph(self, graph): 
     
    268333        print "OWNetwork/setGraph: new visualizer..." 
    269334        self.visualize = NetworkVisualizer(graph, self) 
     335        self.nVertices = len(graph) 
    270336        print "done." 
     337        vars = self.visualize.getVars() 
     338        self.attributes = [(var.name, var.varType) for var in vars] 
     339 
    271340        self.colorCombo.clear() 
    272         self.attListBox.clear() 
    273         self.tooltipListBox.clear() 
    274341        self.colorCombo.insertItem("(one color)") 
    275          
    276         for var in self.visualize.getVars(): 
    277             self.colorCombo.insertItem(unicode(var.name)) 
    278             self.attListBox.insertItem(unicode(var.name)) 
    279             self.tooltipListBox.insertItem(unicode(var.name)) 
     342        for var in vars: 
     343            if var.varType in [orange.VarTypes.Discrete, orange.VarTypes.Continuous]: 
     344                self.colorCombo.insertItem(self.icons[var.varType], unicode(var.name)) 
    280345 
    281346        print "OWNetwork/setGraph: add visualizer..." 
     
    394459            self.graph.updateCanvas()#self.visualize.xCoors, self.visualize.yCoors) 
    395460         
     461    def keyPressEvent(self, e): 
     462        if e.text() == "f": 
     463            self.graph.freezeNeighbours = not self.graph.freezeNeighbours 
     464        else: 
     465            OWWidget.keyPressEvent(self, e) 
     466 
     467    def markedToSelection(self): 
     468        self.graph.addSelection(self.graph.markedNodes) 
     469     
     470    def markedFromSelection(self): 
     471        self.graph.removeSelection(self.graph.markedNodes) 
     472     
     473    def setSelectionToMarked(self): 
     474        self.graph.removeSelection(None, False) 
     475        self.graph.addSelection(self.graph.markedNodes) 
     476 
    396477if __name__=="__main__":     
    397478    appl = QApplication(sys.argv) 
Note: See TracChangeset for help on using the changeset viewer.