Changeset 8083:87f639728674 in orange


Ignore:
Timestamp:
07/06/11 13:09:58 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
1fd3888af3837b8cde626e018f78bc5558ea8571
Message:

New visualization architecture.

Location:
orange/OrangeWidgets/Unsupervised
Files:
2 edited

Legend:

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

    r8081 r8083  
    205205          painter.drawEllipse(rect) 
    206206         
    207  
    208207  def closest_node(self, px, py): 
    209208    ndx = min(self.coors, key=lambda x: abs(self.coors[x][0]-px) + abs(self.coors[x][1]-py)) 
     
    286285        self.controlPressed = False 
    287286        self.altPressed = False 
     287        self.items = None 
     288        self.links = None 
    288289         
    289290        self.setFocusPolicy(Qt.StrongFocus) 
     
    368369         
    369370    def getSelectedExamples(self): 
    370         selection = self.networkCurve.get_selected_nodes() 
    371          
    372         if len(selection) == 0: 
    373             return None 
    374          
    375         if self.graph.items() is not None: 
    376             return self.graph.items().getitems(selection) 
    377         else: 
    378             return None 
    379          
    380     def getunselectedExamples(self): 
    381         unselection = self.networkCurve.get_unselected_nodes() 
    382          
    383         if len(unselection) == 0: 
    384             return None 
    385          
    386         if self.graph.items() is not None: 
    387             return self.graph.items().getitems(unselection) 
    388         else: 
    389             return None 
     371        return self.networkCurve.get_selected_nodes() 
     372         
     373    def getUnselectedExamples(self): 
     374        return self.networkCurve.get_unselected_nodes() 
    390375     
    391376    def getSelectedGraph(self): 
     
    629614        OWGraph.keyReleaseEvent(self, e) 
    630615         
    631      
    632616    def clickedSelectedOnVertex(self, pos): 
    633617        min = 1000000 
     
    828812            return 
    829813         
    830         if self.layout is None or self.graph is None or self.graph.items() is None: 
     814        if self.layout is None or self.graph is None or self.items is None: 
    831815            return 
    832816         
    833         if str(self.showComponentAttribute) not in self.graph.items().domain: 
     817        if str(self.showComponentAttribute) not in self.items.domain: 
    834818            self.showComponentAttribute = None 
    835819            return 
     
    852836            y1 = sum(yes) / len(yes) 
    853837             
    854             lbl = str(self.graph.items()[component[0]][str(self.showComponentAttribute)]) 
     838            lbl = str(self.items[component[0]][str(self.showComponentAttribute)]) 
    855839             
    856840            mkey = self.addMarker(lbl, float(x1), float(y1), alignment=Qt.AlignCenter, size=self.fontSize) 
     
    869853          y1 = self.networkCurve.coors[vertex.index][1] 
    870854          lbl = "" 
    871           values = self.graph.items()[vertex.index] 
     855          values = self.items[vertex.index] 
    872856          for ndx in self.tooltipText: 
    873               if not ndx in self.graph.items().domain: 
     857              if not ndx in self.items.domain: 
    874858                  continue 
    875859               
     
    900884                y1 = self.networkCurve.coors[vertex.index][1] 
    901885                lbl = "" 
    902                 values = self.graph.items()[vertex.index] 
     886                values = self.items[vertex.index] 
    903887                if self.showMissingValues: 
    904888                    lbl = ", ".join([str(values[ndx]) for ndx in self.labelText]) 
     
    984968            return 
    985969         
    986         colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.graph.links(), attribute, self.discEdgePalette) 
     970        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.links, attribute, self.discEdgePalette) 
    987971     
    988972        for index in range(len(self.networkCurve.edges)): 
     
    992976                    continue 
    993977                 
    994                 if self.graph.links().domain[colorIndex].varType == orange.VarTypes.Continuous: 
     978                if self.links.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    995979                    newColor = self.discEdgePalette[0] 
    996                     if str(self.graph.links()[links_index][colorIndex]) != "?": 
     980                    if str(self.links[links_index][colorIndex]) != "?": 
    997981                        if maxValue == minValue: 
    998982                            newColor = self.discEdgePalette[0] 
    999983                        else: 
    1000                             value = (float(self.graph.links()[links_index][colorIndex].value) - minValue) / (maxValue - minValue) 
     984                            value = (float(self.links[links_index][colorIndex].value) - minValue) / (maxValue - minValue) 
    1001985                            newColor = self.contEdgePalette[value] 
    1002986                         
    1003987                    self.networkCurve.set_edge_color(index, newColor) 
    1004988                     
    1005                 elif self.graph.links().domain[colorIndex].varType == orange.VarTypes.Discrete: 
    1006                     newColor = self.discEdgePalette[colorIndices[self.graph.links()[links_index][colorIndex].value]] 
    1007                     if self.graph.links()[links_index][colorIndex].value == "0": 
     989                elif self.links.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     990                    newColor = self.discEdgePalette[colorIndices[self.links[links_index][colorIndex].value]] 
     991                    if self.links[links_index][colorIndex].value == "0": 
    1008992                      self.networkCurve.set_edge_color(index, newColor, nocolor=1) 
    1009993                    else: 
     
    10201004            return 
    10211005         
    1022         colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.graph.items(), attribute, self.discPalette) 
     1006        colorIndices, colorIndex, minValue, maxValue = self.getColorIndeces(self.items, attribute, self.discPalette) 
    10231007     
    10241008        for key, vertex in self.networkCurve.vertices.iteritems(): 
    10251009            v = vertex.index 
    10261010            if colorIndex != None:     
    1027                 if self.graph.items().domain[colorIndex].varType == orange.VarTypes.Continuous: 
     1011                if self.items.domain[colorIndex].varType == orange.VarTypes.Continuous: 
    10281012                    newColor = self.discPalette[0] 
    10291013                     
    1030                     if str(self.graph.items()[v][colorIndex]) != "?": 
     1014                    if str(self.items[v][colorIndex]) != "?": 
    10311015                        if maxValue == minValue: 
    10321016                            newColor = self.discPalette[0] 
    10331017                        else: 
    1034                             value = (float(self.graph.items()[v][colorIndex].value) - minValue) / (maxValue - minValue) 
     1018                            value = (float(self.items[v][colorIndex].value) - minValue) / (maxValue - minValue) 
    10351019                            newColor = self.contPalette[value] 
    10361020                         
    10371021                    self.networkCurve.set_node_color(v, newColor) 
    10381022                     
    1039                 elif self.graph.items().domain[colorIndex].varType == orange.VarTypes.Discrete: 
    1040                     newColor = self.discPalette[colorIndices[self.graph.items()[v][colorIndex].value]] 
     1023                elif self.items.domain[colorIndex].varType == orange.VarTypes.Discrete: 
     1024                    newColor = self.discPalette[colorIndices[self.items[v][colorIndex].value]] 
    10411025                    #print newColor 
    10421026                    self.networkCurve.set_node_color(v, newColor) 
     
    10501034    def setLabelText(self, attributes): 
    10511035        self.labelText = [] 
    1052         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1036        if self.layout is None or self.graph is None or self.items is None: 
    10531037            return 
    10541038         
    1055         if isinstance(self.graph.items(), orange.ExampleTable): 
    1056             data = self.graph.items() 
     1039        if isinstance(self.items, orange.ExampleTable): 
     1040            data = self.items 
    10571041            for att in attributes: 
    10581042                for i in range(len(data.domain)): 
     
    10601044                        self.labelText.append(i) 
    10611045                         
    1062                 if self.graph.items().domain.hasmeta(att): 
    1063                         self.labelText.append(self.graph.items().domain.metaid(att)) 
     1046                if self.items.domain.hasmeta(att): 
     1047                        self.labelText.append(self.items.domain.metaid(att)) 
    10641048     
    10651049    def setTooltipText(self, attributes): 
    10661050        self.tooltipText = [] 
    1067         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1051        if self.layout is None or self.graph is None or self.items is None: 
    10681052            return 
    10691053         
    1070         if isinstance(self.graph.items(), orange.ExampleTable): 
    1071             data = self.graph.items() 
     1054        if isinstance(self.items, orange.ExampleTable): 
     1055            data = self.items 
    10721056            for att in attributes: 
    10731057                for i in range(len(data.domain)): 
     
    10751059                        self.tooltipText.append(i) 
    10761060                         
    1077                 if self.graph.items().domain.hasmeta(att): 
    1078                         self.tooltipText.append(self.graph.items().domain.metaid(att)) 
     1061                if self.items.domain.hasmeta(att): 
     1062                        self.tooltipText.append(self.items.domain.metaid(att)) 
    10791063                         
    10801064    def setEdgeLabelText(self, attributes): 
    10811065        self.edgeLabelText = [] 
    1082         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1066        if self.layout is None or self.graph is None or self.items is None: 
    10831067            return 
    10841068         
    1085     def set_graph_layout(self, graph, layout, curve=None): 
     1069    def set_graph_layout(self, graph, layout, curve=None, items=None, links=None): 
    10861070        self.clear() 
    10871071        self.vertexDegree = [] 
     
    10971081            self.layout = None 
    10981082            self.networkCurve = None 
     1083            self.items = None 
     1084            self.links = None 
    10991085            xMin = self.axisScaleDiv(QwtPlot.xBottom).interval().minValue() 
    11001086            xMax = self.axisScaleDiv(QwtPlot.xBottom).interval().maxValue() 
     
    11091095        self.layout = layout 
    11101096        self.networkCurve = NetworkCurve(self) if curve is None else curve 
     1097        self.items = items if items is not None else self.graph.items() 
     1098        self.links = links if links is not None else self.graph.links() 
    11111099         
    11121100        #add nodes 
     
    11161104        #build edge index 
    11171105        row_ind = {} 
    1118         if self.graph.links() is not None and len(self.graph.links()) > 0: 
    1119           for i, r in enumerate(self.graph.links()): 
     1106        if self.links is not None and len(self.links) > 0: 
     1107          for i, r in enumerate(self.links): 
    11201108              u = int(r['u'].value) 
    11211109              v = int(r['v'].value) 
    1122               u_dict = row_ind.get(u, {}) 
    1123               v_dict = row_ind.get(v, {}) 
    1124               u_dict[v] = i 
    1125               v_dict[u] = i 
    1126               row_ind[u] = u_dict 
    1127               row_ind[v] = v_dict 
     1110              if u in self.graph and v in self.graph: 
     1111                  u_dict = row_ind.get(u, {}) 
     1112                  v_dict = row_ind.get(v, {}) 
     1113                  u_dict[v] = i 
     1114                  v_dict[u] = i 
     1115                  row_ind[u] = u_dict 
     1116                  row_ind[v] = v_dict 
    11281117               
    11291118        #add edges 
    1130         if self.graph.links() is not None and len(self.graph.links()) > 0: 
    1131             links = self.graph.links() 
     1119        if self.links is not None and len(self.links) > 0: 
     1120            links = self.links 
    11321121            links_indices = (row_ind[i + 1][j + 1] for (i, j) in self.graph.edges()) 
    11331122            labels = ([str(row[r].value) for r in range(2, len(row))] for row in (links[links_index] for links_index in links_indices)) 
     
    11931182                 
    11941183    def setVerticesSize(self, column=None, inverted=0): 
    1195         if self.layout is None or self.graph is None or self.graph.items() is None: 
     1184        if self.layout is None or self.graph is None or self.items is None: 
    11961185            return 
    11971186         
    11981187        column = str(column) 
    11991188         
    1200         if column in self.graph.items().domain or (column.startswith("num of ") and column.replace("num of ", "") in self.graph.items().domain): 
     1189        if column in self.items.domain or (column.startswith("num of ") and column.replace("num of ", "") in self.items.domain): 
    12011190            values = [] 
    12021191             
    1203             if column in self.graph.items().domain: 
    1204                 values = [x[column].value for x in self.graph.items() if not x[column].isSpecial()] 
     1192            if column in self.items.domain: 
     1193                values = [self.items[x][column].value for x in self.graph if not self.items[x][column].isSpecial()] 
    12051194            else: 
    1206                 values = [len(x[column.replace("num of ", "")].value.split(',')) for x in self.graph.items()] 
     1195                values = [len(self.items[x][column.replace("num of ", "")].value.split(',')) for x in self.graph] 
    12071196           
    12081197            minVertexWeight = float(min(values or [0])) 
     
    12221211            if inverted: 
    12231212                for key, vertex in self.networkCurve.vertices.iteritems(): 
    1224                     if column in self.graph.items().domain: 
    1225                         vertex.size = self.maxVertexSize - ((getValue(self.graph.items()[vertex.index][column]) - minVertexWeight) * k) 
     1213                    if column in self.items.domain: 
     1214                        vertex.size = self.maxVertexSize - ((getValue(self.items[vertex.index][column]) - minVertexWeight) * k) 
    12261215                    else: 
    1227                         vertex.size = self.maxVertexSize - ((len(self.graph.items()[vertex.index][column.replace("num of ", "")].value.split(',')) - minVertexWeight) * k) 
     1216                        vertex.size = self.maxVertexSize - ((len(self.items[vertex.index][column.replace("num of ", "")].value.split(',')) - minVertexWeight) * k) 
    12281217                     
    12291218                     
     
    12311220            else: 
    12321221                for key, vertex in self.networkCurve.vertices.iteritems(): 
    1233                     if column in self.graph.items().domain: 
    1234                         vertex.size = (getValue(self.graph.items()[vertex.index][column]) - minVertexWeight) * k + self.minVertexSize 
     1222                    if column in self.items.domain: 
     1223                        vertex.size = (getValue(self.items[vertex.index][column]) - minVertexWeight) * k + self.minVertexSize 
    12351224                    else: 
    1236                         vertex.size = (float(len(self.graph.items()[vertex.index][column.replace("num of ", "")].value.split(','))) - minVertexWeight) * k + self.minVertexSize 
     1225                        vertex.size = (float(len(self.items[vertex.index][column.replace("num of ", "")].value.split(','))) - minVertexWeight) * k + self.minVertexSize 
    12371226                         
    12381227                    #print vertex.size 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r8081 r8083  
    117117        self.number_of_nodes_label = -1 
    118118        self.number_of_edges_label = -1 
    119         self._items = None 
    120         self._links = None 
    121119        self.loadSettings() 
    122120         
     
    124122        self.layout = Orange.network.GraphLayout() 
    125123        self.graph = None 
     124        self.graph_base = None 
    126125        self.markInputItems = None 
    127126         
     
    387386    def sendAttSelectionList(self): 
    388387        if not self.graph is None: 
    389             vars = [x.name for x in self.graph.items_vars()] 
     388            vars = [x.name for x in self.graph_base.links_vars()] 
    390389            if not self.comboAttSelection.currentText() in vars: 
    391390                return 
    392391            att = str(self.comboAttSelection.currentText()) 
    393             vertices = self.networkCanvas.networkCurve.getSelectedVertices() 
     392            vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    394393             
    395394            if len(vertices) != 1: 
    396395                return 
    397396             
    398             attributes = str(self.graph.items()[vertices[0]][att]).split(', ') 
     397            attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    399398        else: 
    400399            attributes = None 
     
    405404            return 
    406405         
    407         vars = [x.name for x in self.graph.items_vars()] 
     406        vars = [x.name for x in self.graph_base.items_vars()] 
    408407        if not self.editCombo.currentText() in vars: 
    409408            return 
    410409        att = str(self.editCombo.currentText()) 
    411         vertices = self.networkCanvas.networkCurve.getSelectedVertices() 
     410        vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    412411         
    413412        if len(vertices) == 0: 
    414413            return 
    415414         
    416         if self.graph.items().domain[att].var_type == Orange.data.Type.Continuous: 
     415        if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous: 
    417416            for v in vertices: 
    418                 self.graph.items()[v][att] = float(self.editValue) 
     417                self.graph_base.items()[v][att] = float(self.editValue) 
    419418        else: 
    420419            for v in vertices: 
    421                 self.graph.items()[v][att] = str(self.editValue) 
    422          
    423         self.setItems(self.graph.items()) 
     420                self.graph_base.items()[v][att] = str(self.editValue) 
     421         
     422        self.setItems(self.graph_base.items()) 
    424423         
    425424    def drawForce(self): 
     
    591590            return 
    592591         
    593         if self.graph is not None and self.graph.items() is not None: 
    594             items = self.graph.items().getitems(markedNodes) 
     592        if self.graph is not None and self.graph_base.items() is not None: 
     593            items = self.graph_base.items().getitems(markedNodes) 
    595594            self.send("Marked Items", items) 
    596595            return 
     
    623622         
    624623    def showComponents(self): 
    625         if self.graph is None or self.graph.items() is None: 
    626             return 
    627          
    628         vars = [x.name for x in self.graph.items_vars()] 
     624        if self.graph is None or self.graph_base.items() is None: 
     625            return 
     626         
     627        vars = [x.name for x in self.graph_base.items_vars()] 
    629628         
    630629        if not self.showComponentCombo.currentText() in vars: 
     
    641640        self.lastNameComponentAttribute = None 
    642641         
    643         if self.graph is None or self.graph.items() is None: 
    644             return 
    645          
    646         vars = [x.name for x in self.graph.items_vars()] 
     642        if self.graph is None or self.graph_base.items() is None: 
     643            return 
     644         
     645        vars = [x.name for x in self.graph_base.items_vars()] 
    647646        if not self.nameComponentCombo.currentText() in vars: 
    648647            return 
     
    650649        self.progressBarInit() 
    651650        components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    652         if 'component name' in self.graph.items().domain: 
    653             keyword_table = self.graph.items() 
    654         else: 
    655             keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph.items()))])  
     651        if 'component name' in self.graph_base.items().domain: 
     652            keyword_table = self.graph_base.items() 
     653        else: 
     654            keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    656655         
    657656        import obiGO  
     
    659658        annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    660659 
    661         allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph.items()]) 
     660        allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    662661        foundGenesets = False 
    663662        if len(annotations.geneNames & allGenes) < 1: 
    664             allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph.items()])) 
     663            allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    665664            if len(annotations.geneNames & allGenes) < 1:             
    666665                self.warning('no genes found') 
     
    728727             
    729728            if foundGenesets: 
    730                 genes = reduce(operator.add, [self.graph.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
     729                genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    731730            else: 
    732                 genes = [self.graph.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
     731                genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    733732                     
    734733            res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    735734            res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
    736             res = res1.items() + res2.items() 
     735            res = res1_base.items() + res2.items() 
    737736            #namingScore = [[(1-p_value) * (float(len(g)) / len(genes)) / (float(ref) / len(annotations.geneNames)), ontology.terms[GOId].name, len(g), ref, p_value] for GOId, (g, p_value, ref) in res.items() if p_value < 0.1] 
    738737            #namingScore = [[(1-p_value) * len(g) / ref, ontology.terms[GOId].name, len(g), ref, p_value] for GOId, (g, p_value, ref) in res.items() if p_value < 0.1] 
     
    769768                 
    770769        self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    771         self.setItems(Orange.data.Table([self.graph.items(), keyword_table])) 
     770        self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    772771        self.progressBarFinished()    
    773772         
    774773    def nameComponents_old(self): 
    775         if self.graph is None or self.graph.items() is None: 
    776             return 
    777          
    778         vars = [x.name for x in self.graph.items_vars()] 
     774        if self.graph is None or self.graph_base.items() is None: 
     775            return 
     776         
     777        vars = [x.name for x in self.graph_base.items_vars()] 
    779778         
    780779        if not self.nameComponentCombo.currentText() in vars: 
     
    782781         
    783782        components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    784         keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph.items()))])  
     783        keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    785784         
    786785        excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"] 
     
    794793            for vertex in component: 
    795794                values = [] 
    796                 value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     795                value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    797796                 
    798797                value = value.replace(" ", ",") 
     
    896895            for vertex in component: 
    897896                values = [] 
    898                 value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     897                value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    899898                 
    900899                value = value.replace(" ", ",") 
     
    981980        self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    982981        #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute 
    983         items = Orange.data.Table([self.graph.items(), keyword_table]) 
     982        items = Orange.data.Table([self.graph_base.items(), keyword_table]) 
    984983        self.setItems(items) 
    985984         
     
    10091008         
    10101009        hubs = self.hubs 
    1011         vgraph = self.graph 
    1012  
    10131010        if hubs == 0: 
    10141011            self.networkCanvas.setMarkedVertices([]) 
     
    10221019            self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
    10231020             
    1024             toMark = [i for i, values in enumerate(vgraph.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(vgraph.items().domain)) + vgraph.items().domain.getmetas().keys()])] 
     1021            toMark = [i for i, values in enumerate(self.graph_base.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(self.graph_base.items().domain)) + self.graph_base.items().domain.getmetas().keys()])] 
    10251022            self.networkCanvas.setMarkedVertices(toMark) 
    10261023            self.networkCanvas.replot() 
     
    10291026        elif hubs == 2: 
    10301027            #print "mark on focus" 
    1031             self.networkCanvas.unMark() 
     1028            self.networkCanvas.unmark() 
    10321029            self.networkCanvas.tooltipNeighbours = self.markDistance 
    10331030            return 
     
    10351032        elif hubs == 3: 
    10361033            #print "mark selected" 
    1037             self.networkCanvas.unMark() 
     1034            self.networkCanvas.unmark() 
    10381035            self.networkCanvas.selectionNeighbours = self.markDistance 
    10391036            self.networkCanvas.markSelectionNeighbours() 
     
    10411038         
    10421039        self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
    1043         powers = vgraph.degree() 
     1040        powers = self.graph.degree() 
    10441041        powers = [powers[key] for key in sorted(powers.keys())] 
    10451042         
     
    10561053        elif hubs == 6: 
    10571054            #print "mark more than any" 
    1058             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])]) 
     1055            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    10591056            self.networkCanvas.replot() 
    10601057        elif hubs == 7: 
    10611058            #print "mark more than avg" 
    1062             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])]) 
     1059            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    10631060            self.networkCanvas.replot() 
    10641061        elif hubs == 8: 
     
    11091106                self.send("Selected Items", graph.items()) 
    11101107            else: 
    1111                 self.send("Selected Items", self.networkCanvas.getSelectedExamples()) 
    1112              
    1113             #print "sendData:", self.visualize.graph.items().domain 
    1114             self.send("Unselected Items", self.networkCanvas.getUnselectedExamples())     
     1108                nodes = self.networkCanvas.getSelectedExamples() 
     1109                 
     1110                if len(nodes) > 0 and self.graph_base.items() is not None: 
     1111                    self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
     1112                else: 
     1113                    self.send("Selected Items", None) 
     1114                 
     1115            nodes = self.networkCanvas.getUnselectedExamples() 
     1116            if len(nodes) > 0 and self.graph_base.items() is not None: 
     1117                self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     1118            else: 
     1119                self.send("Unselected Items", None) 
     1120                 
    11151121            self.send("Selected Network", graph) 
    11161122        else: 
    1117             items = self.networkCanvas.getSelectedExamples() 
    1118             self.send("Selected Items", items) 
    1119                  
    1120             items = self.networkCanvas.getUnselectedExamples() 
    1121             self.send("Unselected Items", items) 
     1123            nodes = self.networkCanvas.getSelectedExamples() 
     1124            if len(nodes) > 0 and self.graph_base.items() is not None: 
     1125                self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
     1126            else: 
     1127                self.send("Selected Items", None) 
     1128                 
     1129            nodes = self.networkCanvas.getUnselectedExamples() 
     1130            if len(nodes) > 0 and self.graph_base.items() is not None: 
     1131                self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     1132            else: 
     1133                self.send("Unselected Items", None) 
    11221134         
    11231135        matrix = None 
     
    11281140                 
    11291141    def setCombos(self): 
    1130         vars = self.graph.items_vars() 
    1131         edgeVars = self.graph.links_vars() 
     1142        vars = self.graph_base.items_vars() 
     1143        edgeVars = self.graph_base.links_vars() 
    11321144        lastLabelColumns = self.lastLabelColumns 
    11331145        lastTooltipColumns = self.lastTooltipColumns 
     
    11421154                self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    11431155                 
    1144             if var.varType in [Orange.data.Type.String] and hasattr(self.graph, 'items') and self.graph.items() is not None and len(self.graph.items()) > 0: 
    1145                  
    1146                 value = self.graph.items()[0][var].value 
     1156            if var.varType in [Orange.data.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0: 
     1157                 
     1158                value = self.graph_base.items()[0][var].value 
    11471159                 
    11481160                # can value be a list? 
     
    12151227        if graph is None: 
    12161228            self.graph = None 
     1229            self.graph_base = None 
    12171230            self.layout.set_graph(None) 
    12181231            self.networkCanvas.set_graph_layout(None, None) 
     
    12241237            return 
    12251238         
    1226         self._items = graph.items() 
    1227         self._links = graph.links() 
     1239        self.graph_base = graph 
    12281240         
    12291241        if self._network_view is not None: 
     
    12451257        self.number_of_edges_label = self.graph.number_of_edges() 
    12461258         
    1247         self.networkCanvas.set_graph_layout(self.graph, self.layout) 
     1259        self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
    12481260        self.networkCanvas.renderAntialiased = self.renderAntialiased 
    12491261        self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     
    13371349    def set_network_view(self, nxView): 
    13381350        self._network_view = nxView 
    1339         self.set_graph(self.graph) 
     1351        self.set_graph(self.graph_base) 
    13401352         
    13411353    def setItems(self, items=None): 
     
    13451357            return 
    13461358         
    1347         if len(items) != self.graph.number_of_nodes(): 
     1359        if len(items) != self.graph_base.number_of_nodes(): 
    13481360            self.error('ExampleTable items must have one example for each vertex.') 
    13491361            return 
    13501362         
    1351         self.graph.set_items(items) 
     1363        self.graph_base.set_items(items) 
    13521364         
    13531365        self.setVertexSize() 
     
    13631375        if self.markInputItems is not None and len(self.markInputItems) > 0: 
    13641376            values = [str(x[var]).strip().upper() for x in self.markInputItems] 
    1365             toMark = [i for (i,x) in enumerate(self.graph.items()) if str(x[var]).strip().upper() in values] 
     1377            toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
    13661378            #print "mark:", toMark 
    13671379            self.networkCanvas.setMarkedVertices(list(toMark)) 
     
    13771389        self.markInputItems = items 
    13781390         
    1379         if self.graph is None or self.graph.items() is None or items is None: 
     1391        if self.graph is None or self.graph_base.items() is None or items is None: 
    13801392            return 
    13811393         
    13821394        if len(items) > 0: 
    1383             lstOrgDomain = [x.name for x in self.graph.items().domain] + [self.graph.items().domain[x].name for x in self.graph.items().domain.getmetas()] 
     1395            lstOrgDomain = [x.name for x in self.graph_base.items().domain] + [self.graph_base.items().domain[x].name for x in self.graph_base.items().domain.getmetas()] 
    13841396            lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
    13851397            commonVars = set(lstNewDomain) & set(lstOrgDomain) 
     
    13871399            if len(commonVars) > 0: 
    13881400                for var in commonVars: 
    1389                     orgVar = self.graph.items().domain[var] 
     1401                    orgVar = self.graph_base.items().domain[var] 
    13901402                    mrkVar = items.domain[var] 
    13911403 
Note: See TracChangeset for help on using the changeset viewer.