Changeset 9420:207aad17cca3 in orange


Ignore:
Timestamp:
12/29/11 09:36:01 (2 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
1427511e0f5c465fdfb5fd191a2abb3da96fde90
Message:

Added show/hide nodes feature.

Location:
orange/OrangeWidgets/Unsupervised
Files:
2 edited

Legend:

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

    r9364 r9420  
    201201                                    self.fragviz_callback(a, b, mds, mdsRefresh, components, progress_callback)) 
    202202         
    203         self.mds_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
     203        self.fragviz_callback(mds.avgStress, 0, mds, mdsRefresh, components, progress_callback) 
    204204         
    205205        if progress_callback != None: 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r9395 r9420  
    1919from OWWidget import * 
    2020from operator import itemgetter 
    21  
    22 dir = os.path.dirname(__file__) + "/../icons/" 
    23 dlg_mark2sel = dir + "Dlg_Mark2Sel.png" 
    24 dlg_sel2mark = dir + "Dlg_Sel2Mark.png" 
    25 dlg_selIsmark = dir + "Dlg_SelisMark.png" 
    26 dlg_selected = dir + "Dlg_SelectedNodes.png" 
    27 dlg_unselected = dir + "Dlg_UnselectedNodes.png" 
    28 dlg_showall = dir + "Dlg_clear.png" 
    2921 
    3022try: 
     
    5648            self.inputs = [("Nx View", Orange.network.NxView, self.set_network_view), 
    5749                           ("Network", Orange.network.Graph, self.set_graph, Default), 
    58                            ("Items", Orange.data.Table, self.setItems), 
    59                            ("Items to Mark", Orange.data.Table, self.markItems),  
    60                            ("Items Subset", Orange.data.Table, self.setExampleSubset),  
     50                           ("Items", Orange.data.Table, self.set_items), 
     51                           ("Items to Mark", Orange.data.Table, self.mark_items),  
     52                           ("Items Subset", Orange.data.Table, self.set_feature_subset),  
    6153                           ("Items Distance Matrix", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
    6254             
     
    182174            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.set_node_colors) 
    183175            self.colorCombo.addItem("(same color)") 
    184             OWGUI.button(colorBox, self, "Set node color palette", self.setColors, tooltip = "Set node color palette", debuggingEnabled = 0) 
     176            OWGUI.button(colorBox, self, "Set node color palette", self._set_colors, tooltip = "Set node color palette", debuggingEnabled = 0) 
    185177             
    186178            ib = OWGUI.widgetBox(self.verticesTab, "Node size attribute", orientation="vertical", addSpace = False) 
     
    194186            self.attBox = OWGUI.widgetBox(self.verticesTab, "Node labels | tooltips", orientation="vertical", addSpace = False) 
    195187            hb = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False) 
    196             self.attListBox = OWGUI.listBox(hb, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
    197             self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox)         
    198             OWGUI.spin(self.attBox, self, "networkCanvas.trim_label_words", 0, 5, 1, label='Trim label words to', callback=self.clickedAttLstBox) 
     188            self.attListBox = OWGUI.listBox(hb, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_att_lstbox) 
     189            self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_tooltip_lstbox)         
     190            OWGUI.spin(self.attBox, self, "networkCanvas.trim_label_words", 0, 5, 1, label='Trim label words to', callback=self._clicked_att_lstbox) 
    199191             
    200192            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
     
    208200            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.set_edge_colors) 
    209201            self.edgeColorCombo.addItem("(same color)") 
    210             OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip = "Set edge color palette", debuggingEnabled = 0) 
     202            OWGUI.button(colorBox, self, "Set edge color palette", self._set_edge_color_palette, tooltip = "Set edge color palette", debuggingEnabled = 0) 
    211203             
    212204            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False) 
    213             self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox) 
     205            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_edge_label_listbox) 
    214206            #self.edgeLabelBox.setEnabled(False) 
    215207             
     
    230222            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.set_mark_mode) 
    231223            OWGUI.appendRadioButton(ribg, self, "hubs", "Search", callback = self.set_mark_mode) 
    232             self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
     224            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self._set_search_string_timer, callbackOnType=True) 
    233225            self.searchStringTimer = QTimer(self) 
    234226            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.set_mark_mode) 
     
    267259                [ 
    268260                    G.Spacing, 
    269                     ("buttonM2S", "marked to selection", None, None, "marked_to_selected", 'Dlg_Mark2Sel'), 
    270                     ("buttonS2M", "selection to marked", None, None, "selected_to_marked", 'Dlg_Sel2Mark'), 
    271                     #("buttonSEL", "Hide selected", None, None, "hideSelectedVertices", 'Dlg_UnselectedNodes'), 
     261                    ("buttonM2S", "Marked to selection", None, None, "marked_to_selected", 'Dlg_Mark2Sel'), 
     262                    ("buttonS2M", "Selection to marked", None, None, "selected_to_marked", 'Dlg_Sel2Mark'), 
     263                    ("buttonHSEL", "Hide selection", None, None, "hide_selection", 'Dlg_HideSelection'), 
     264                    ("buttonSSEL", "Show all nodes", None, None, "show_selection", 'Dlg_ShowSelection'), 
    272265                    #("buttonUN", "Hide unselected", None, None, "hideUnSelectedVertices", 'Dlg_SelectedNodes'), 
    273266                    #("buttonSW", "Show all nodes", None, None, "showAllVertices", 'Dlg_clear'), 
     
    275268            self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_data) 
    276269            self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_marked_nodes) 
     270            self.zoomSelectToolbar.buttons[("buttonHSEL", "Hide selection", None, None, "hide_selection", 'Dlg_HideSelection')].clicked.connect(self.hide_selection) 
     271            self.zoomSelectToolbar.buttons[("buttonSSEL", "Show all nodes", None, None, "show_selection", 'Dlg_ShowSelection')].clicked.connect(self.show_selection) 
    277272            #self.zoomSelectToolbar.buttons[G.SendSelection].hide() 
    278273            self.zoomSelectToolbar.select_selection_behaviour(prevselbeh) 
    279274            self.zoomSelectToolbar.select_state(prevstate) 
    280              
    281             self.reportButton = OWGUI.button(self.toolbar, self, "&Report", self.reportAndFinish, debuggingEnabled=0) 
    282             self.reportButton.setAutoDefault(0) 
    283275             
    284276            ib = OWGUI.widgetBox(self.infoTab, "General") 
     
    292284            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
    293285             
    294             OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False) 
    295             OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False) 
    296             OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
     286            OWGUI.button(ib, self, "Degree dist", callback=self.show_degree_dist, width=84, debuggingEnabled=False) 
     287            OWGUI.button(ib, self, "Save net", callback=self.save_network, width=84, debuggingEnabled=False) 
     288            OWGUI.button(ib, self, "Save img", callback=self.networkCanvas.saveToFile, width=84, debuggingEnabled=False) 
     289            self.reportButton = OWGUI.button(ib, self, "&Report", self.reportAndFinish, width=84, debuggingEnabled=0) 
     290            self.reportButton.setAutoDefault(0) 
    297291             
    298292            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
     
    321315             
    322316            #OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
    323             OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
    324             OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
     317            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.set_component_edge_width(changedMin))) 
     318            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.set_component_edge_width(changedMin))) 
    325319             
    326320            self.attSelectionAttribute = 0 
     
    341335            self.performanceTab.layout().addStretch(1) 
    342336             
    343             dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
     337            dlg = self._create_color_dialog(self.colorSettings, self.selectedSchemaIndex) 
    344338            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    345339            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    346340             
    347             dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     341            dlg = self._create_color_dialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    348342            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    349343            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
     
    358352            self.connect(self.networkCanvas, SIGNAL("selection_changed()"), self.send_data) 
    359353             
    360              
    361         def setComponentEdgeWidth(self, changedMin=True): 
    362             if self.networkCanvas is None: 
    363                 return 
    364              
    365             canvas = self.networkCanvas 
    366             if changedMin: 
    367                 if self.maxComponentEdgeWidth < self.minComponentEdgeWidth: 
    368                     self.maxComponentEdgeWidth = self.minComponentEdgeWidth 
    369             else: 
    370                 if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
    371                     self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
    372              
    373             canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    374             canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    375             self.networkCanvas.updateCanvas() 
    376          
    377         def setAutoSendAttributes(self): 
    378             print 'TODO setAutoSendAttributes' 
    379             #if self.autoSendAttributes: 
    380             #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
    381             #else: 
    382             #    self.networkCanvas.callbackSelectVertex = None 
    383      
    384         def sendAttSelectionList(self): 
    385             if not self.graph is None: 
    386                 vars = [x.name for x in self.graph_base.links_vars()] 
    387                 if not self.comboAttSelection.currentText() in vars: 
    388                     return 
    389                 att = str(self.comboAttSelection.currentText()) 
    390                 vertices = self.networkCanvas.selected_nodes() 
    391                  
    392                 if len(vertices) != 1: 
    393                     return 
    394                  
    395                 attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    396             else: 
    397                 attributes = None 
    398             self.send("Attribute Selection List", attributes) 
     354        def hide_selection(self): 
     355            nodes = set(self.graph.nodes()).difference(self.networkCanvas.selected_nodes()) 
     356            self.change_graph(Orange.network.nx.Graph.subgraph(self.graph, nodes)) 
     357 
     358        def show_selection(self): 
     359            self.change_graph(self.graph_base) 
    399360             
    400361        def edit(self): 
     
    450411                    self.optButton.setChecked(True) 
    451412                    self.graph_layout() 
    452          
    453         def send_marked_nodes(self): 
    454             if self.checkSendMarkedNodes and \ 
    455                 len(self.signalManager.getLinks(self, None, \ 
    456                                                 "Marked Items", None)) > 0: 
    457                 # signal connected 
    458                 markedNodes = self.networkCanvas.marked_nodes() 
    459                  
    460                 if len(markedNodes) > 0 and self.graph is not None and\ 
    461                                          self.graph_base.items() is not None: 
    462                      
    463                     items = self.graph_base.items().getitems(markedNodes) 
    464                     self.send("Marked Items", items) 
    465                 else: 
    466                     self.send("Marked Items", None) 
    467                          
    468         def showComponents(self): 
    469             if self.graph is None or self.graph_base.items() is None: 
    470                 return 
    471              
    472             vars = [x.name for x in self.graph_base.items_vars()] 
    473              
    474             if not self.showComponentCombo.currentText() in vars: 
    475                 self.networkCanvas.showComponentAttribute = None 
    476                 self.lastNameComponentAttribute = '' 
    477             else: 
    478                 self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
    479              
    480             self.networkCanvas.drawComponentKeywords() 
    481              
    482         def nameComponents(self): 
    483             """Names connected components of genes according to GO terms.""" 
    484             self.progressBarFinished() 
    485             self.lastNameComponentAttribute = None 
    486              
    487             if self.graph is None or self.graph_base.items() is None: 
    488                 return 
    489              
    490             vars = [x.name for x in self.graph_base.items_vars()] 
    491             if not self.nameComponentCombo.currentText() in vars: 
    492                 return 
    493              
    494             self.progressBarInit() 
    495             components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    496             if 'component name' in self.graph_base.items().domain: 
    497                 keyword_table = self.graph_base.items() 
    498             else: 
    499                 keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    500                  
    501             import obiGO  
    502             ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
    503             annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    504      
    505             allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    506             foundGenesets = False 
    507             if len(annotations.geneNames & allGenes) < 1: 
    508                 allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    509                 if len(annotations.geneNames & allGenes) < 1:             
    510                     self.warning('no genes found') 
    511                     return 
    512                 else: 
    513                     foundGenesets = True 
    514                  
    515             def rank(a, j, reverse=False):                     
    516                 if len(a) <= 0: return 
    517                  
    518                 if reverse:                 
    519                     a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
    520                     top_value = a[0][j] 
    521                     top_rank = len(a) 
    522                     max_rank = float(len(a)) 
    523                     int_ndx = 0 
    524                     for k in range(len(a)): 
    525                         if top_value < a[k][j]: 
    526                             top_value = a[k][j]  
    527                             if k - int_ndx > 1: 
    528                                 avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    529                                 for l in range(int_ndx, k): 
    530                                     a[l][j] = avg_rank 
    531                              
    532                             int_ndx = k 
    533      
    534                         a[k][j] = top_rank / max_rank 
    535                         top_rank -= 1 
    536                      
    537                     k += 1 
    538                     if k - int_ndx > 1: 
    539                         avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    540                         for l in range(int_ndx, k): 
    541                             a[l][j] = avg_rank     
    542                      
    543                 else: 
    544                     a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
    545                     top_value = a[0][j] 
    546                     top_rank = len(a) 
    547                     max_rank = float(len(a)) 
    548                     int_ndx = 0 
    549                     for k in range(len(a)): 
    550                         if top_value > a[k][j]: 
    551                             top_value = a[k][j]  
    552                             if k - int_ndx > 1: 
    553                                 avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    554                                 for l in range(int_ndx, k): 
    555                                     a[l][j] = avg_rank 
    556                              
    557                             int_ndx = k 
    558      
    559                         a[k][j] = top_rank / max_rank 
    560                         top_rank -= 1 
    561                      
    562                     k += 1 
    563                     if k - int_ndx > 1: 
    564                         avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    565                         for l in range(int_ndx, k): 
    566                             a[l][j] = avg_rank 
    567              
    568             for i in range(len(components)): 
    569                 component = components[i] 
    570                 if len(component) <= 1: 
    571                     continue 
    572                  
    573                 if foundGenesets: 
    574                     genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    575                 else: 
    576                     genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    577                          
    578                 res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    579                 res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
    580                 res = res1.items() + res2.items() 
    581                 #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] 
    582                 #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] 
    583                  
    584                 namingScore = [[len(g), ref, p_value, ontology[GOId].name, len(g), ref, p_value] for GOId, (g, p_value, ref) in res if p_value < 0.1] 
    585                 if len(namingScore) == 0: 
    586                     continue 
    587                  
    588                 annotated_genes = max([a[0] for a in namingScore]) 
    589                  
    590                 rank(namingScore, 1, reverse=True) 
    591                 rank(namingScore, 2, reverse=True) 
    592                 rank(namingScore, 0) 
    593                  
    594                 namingScore = [[10 * rank_genes + 0.5 * rank_ref + rank_p_value, name, g, ref, p_value] for rank_genes, rank_ref, rank_p_value, name, g, ref, p_value in namingScore] 
    595                 namingScore.sort(reverse=True) 
    596                  
    597                 if len(namingScore) < 1: 
    598                     print "warning. no annotations found for group of genes: " + ", ".join(genes) 
    599                     continue 
    600                 elif len(namingScore[0]) < 2: 
    601                     print "warning. error computing score for group of genes: " + ", ".join(genes) 
    602                     continue 
    603                  
    604                 for v in component: 
    605                     name = str(namingScore[0][1]) 
    606                     attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4]) 
    607                     info = '' 
    608                     if self.showTextMiningInfo: 
    609                         info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
    610                     keyword_table[v]['component name'] = name + info 
    611                  
    612                 self.progressBarSet(i*100.0/len(components)) 
    613                      
    614             self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    615             self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    616             self.progressBarFinished()    
    617                 
     413                                    
    618414        def _set_canvas_attr(self, attr, value): 
    619415            setattr(self.networkCanvas, attr, value) 
     
    624420            self.networkCanvas.updateCanvas() 
    625421                     
    626         def setSearchStringTimer(self): 
     422        def _set_search_string_timer(self): 
    627423            self.hubs = 1 
    628424            self.searchStringTimer.stop() 
     
    716512             
    717513            self.nMarked = len(self.networkCanvas.marked_nodes()) 
    718             #self.send_marked_nodes() 
    719             
    720         def testRefresh(self): 
    721             start = time.time() 
    722             self.networkCanvas.replot() 
    723             stop = time.time()     
    724             print "replot in " + str(stop - start) 
    725514             
    726515        def save_network(self): 
     
    779568                matrix = None if self.items_matrix is None else self.items_matrix.getitems(selected_nodes) 
    780569                self.send("Selected Items Distance Matrix", matrix) 
    781                      
    782         def setCombos(self): 
     570         
     571        def send_marked_nodes(self): 
     572            if self.checkSendMarkedNodes and \ 
     573                len(self.signalManager.getLinks(self, None, \ 
     574                                                "Marked Items", None)) > 0: 
     575                # signal connected 
     576                markedNodes = self.networkCanvas.marked_nodes() 
     577                 
     578                if len(markedNodes) > 0 and self.graph is not None and\ 
     579                                         self.graph_base.items() is not None: 
     580                     
     581                    items = self.graph_base.items().getitems(markedNodes) 
     582                    self.send("Marked Items", items) 
     583                else: 
     584                    self.send("Marked Items", None) 
     585            
     586        def _set_combos(self): 
    783587            vars = self.graph_base.items_vars() 
    784588            edgeVars = self.graph_base.links_vars() 
     
    786590            lastTooltipColumns = self.lastTooltipColumns 
    787591             
    788             self.clearCombos() 
     592            self._clear_combos() 
    789593             
    790594            self.attributes = [(var.name, var.varType) for var in vars] 
     
    843647            self.lastTooltipColumns = lastTooltipColumns 
    844648             
    845         def clearCombos(self): 
     649        def _clear_combos(self): 
    846650            self.attributes = [] 
    847651            self.edgeAttributes = [] 
     
    937741            self.set_edge_colors() 
    938742                 
    939             self.clickedAttLstBox() 
    940             self.clickedTooltipLstBox() 
    941             self.clickedEdgeLabelListBox() 
     743            self._clicked_att_lstbox() 
     744            self._clicked_tooltip_lstbox() 
     745            self._clicked_edge_label_listbox() 
    942746             
    943747            self.networkCanvas.replot() 
     
    951755            self.graph = None 
    952756            self.graph_base = None 
    953             self.clearCombos() 
     757            self._clear_combos() 
    954758            self.number_of_nodes_label = -1 
    955759            self.number_of_edges_label = -1 
     
    1010814             
    1011815            self.compute_network_info() 
    1012             self.setCombos() 
     816            self._set_combos() 
    1013817                 
    1014818            lastNameComponentAttributeFound = False 
     
    1050854            self.set_edge_colors() 
    1051855                 
    1052             self.clickedAttLstBox() 
    1053             self.clickedTooltipLstBox() 
    1054             self.clickedEdgeLabelListBox() 
     856            self._clicked_att_lstbox() 
     857            self._clicked_tooltip_lstbox() 
     858            self._clicked_edge_label_listbox() 
    1055859             
    1056860            self.optButton.setChecked(1) 
     
    1078882                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
    1079883             
    1080         def setItems(self, items=None): 
     884        def set_items(self, items=None): 
    1081885            self.error() 
    1082886            self.warning() 
     
    1097901            self.networkCanvas.showWeights = self.showWeights 
    1098902            self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    1099             self.setCombos() 
     903            self._set_combos() 
    1100904            #self.networkCanvas.updateData() 
    1101905             
    1102         def markItems(self, items): 
     906        def mark_items(self, items): 
    1103907            self.markInputCombo.clear() 
    1104908            self.markInputRadioButton.setEnabled(False) 
     
    1129933                            self.set_mark_mode(9) 
    1130934                   
    1131         def setExampleSubset(self, subset): 
     935        def set_feature_subset(self, subset): 
    1132936            print "TODO: not yet implemented" 
    1133937            if self.graph is None: 
     
    1154958                    self.warning('"index" attribute does not exist in "items" table.') 
    1155959                         
    1156         def showDegreeDistribution(self): 
     960        def show_degree_dist(self): 
    1157961            if self.graph is None: 
    1158962                return 
     
    1174978             
    1175979            p.show() 
    1176              
    1177         def setColors(self): 
    1178             dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    1179             if dlg.exec_(): 
    1180                 self.colorSettings = dlg.getColorSchemas() 
    1181                 self.selectedSchemaIndex = dlg.selectedSchemaIndex 
    1182                 self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    1183                 self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    1184                  
    1185                 self.set_node_colors() 
    1186                  
    1187         def setEdgeColorPalette(self): 
    1188             dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    1189             if dlg.exec_(): 
    1190                 self.edgeColorSettings = dlg.getColorSchemas() 
    1191                 self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex 
    1192                 self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    1193                 self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    1194                  
    1195                 self.set_edge_colors() 
    1196980         
    1197         def createColorDialog(self, colorSettings, selectedSchemaIndex): 
    1198             c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
    1199             c.createDiscretePalette("discPalette", "Discrete Palette") 
    1200             c.createContinuousPalette("contPalette", "Continuous Palette") 
    1201             c.setColorSchemas(colorSettings, selectedSchemaIndex) 
    1202             return c 
    1203          
    1204         """ 
    1205         Layout Optimization 
    1206         """ 
     981        ####################################################################### 
     982        ### Layout Optimization                                             ### 
     983        ####################################################################### 
    1207984         
    1208985        def graph_layout(self): 
     
    12861063             
    12871064         
    1288         def mdsProgress(self, avgStress, stepCount):     
     1065        def mds_progress(self, avgStress, stepCount):     
    12891066            #self.drawForce() 
    12901067     
     
    13251102                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
    13261103             
    1327             self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mdsProgress, self.opt_from_curr) 
     1104            self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mds_progress, self.opt_from_curr) 
    13281105     
    13291106            self.optButton.setChecked(False) 
     
    13621139                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
    13631140             
    1364             self.networkCanvas.networkCurve.layout_mds(self.frSteps, matrix, self.mdsProgress, self.opt_from_curr) 
     1141            self.networkCanvas.networkCurve.layout_mds(self.frSteps, matrix, self.mds_progress, self.opt_from_curr) 
    13651142     
    13661143            self.optButton.setChecked(False) 
     
    14431220            self.networkCanvas.update_canvas() 
    14441221     
    1445         """ 
    1446         Network Visualization 
    1447         """ 
    1448         def clickedAttLstBox(self): 
     1222        ####################################################################### 
     1223        ### Network Visualization                                           ### 
     1224        ####################################################################### 
     1225             
     1226        def _set_colors(self): 
     1227            dlg = self._create_color_dialog(self.colorSettings, self.selectedSchemaIndex) 
     1228            if dlg.exec_(): 
     1229                self.colorSettings = dlg.getColorSchemas() 
     1230                self.selectedSchemaIndex = dlg.selectedSchemaIndex 
     1231                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
     1232                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
     1233                 
     1234                self.set_node_colors() 
     1235                 
     1236        def _set_edge_color_palette(self): 
     1237            dlg = self._create_color_dialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     1238            if dlg.exec_(): 
     1239                self.edgeColorSettings = dlg.getColorSchemas() 
     1240                self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex 
     1241                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
     1242                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
     1243                 
     1244                self.set_edge_colors() 
     1245         
     1246        def _create_color_dialog(self, colorSettings, selectedSchemaIndex): 
     1247            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
     1248            c.createDiscretePalette("discPalette", "Discrete Palette") 
     1249            c.createContinuousPalette("contPalette", "Continuous Palette") 
     1250            c.setColorSchemas(colorSettings, selectedSchemaIndex) 
     1251            return c 
     1252         
     1253        def _clicked_att_lstbox(self): 
    14491254            if self.graph is None: 
    14501255                return 
     
    14541259            self.networkCanvas.replot() 
    14551260       
    1456         def clickedTooltipLstBox(self): 
     1261        def _clicked_tooltip_lstbox(self): 
    14571262            if self.graph is None: 
    14581263                return 
     
    14621267            self.networkCanvas.replot() 
    14631268             
    1464         def clickedEdgeLabelListBox(self): 
     1269        def _clicked_edge_label_listbox(self): 
    14651270            if self.graph is None: 
    14661271                return 
     
    15601365            self.reportSection("Graph") 
    15611366            self.reportImage(self.networkCanvas.saveToFileDirect)         
     1367         
     1368        ####################################################################### 
     1369        ### PROTOTYPE                                                       ###  
     1370        ####################################################################### 
     1371         
     1372        def set_component_edge_width(self, changedMin=True): 
     1373            if self.networkCanvas is None: 
     1374                return 
     1375             
     1376            canvas = self.networkCanvas 
     1377            if changedMin: 
     1378                if self.maxComponentEdgeWidth < self.minComponentEdgeWidth: 
     1379                    self.maxComponentEdgeWidth = self.minComponentEdgeWidth 
     1380            else: 
     1381                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
     1382                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
     1383             
     1384            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     1385            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
     1386            self.networkCanvas.updateCanvas() 
     1387         
     1388        def showComponents(self): 
     1389            if self.graph is None or self.graph_base.items() is None: 
     1390                return 
     1391             
     1392            vars = [x.name for x in self.graph_base.items_vars()] 
     1393             
     1394            if not self.showComponentCombo.currentText() in vars: 
     1395                self.networkCanvas.showComponentAttribute = None 
     1396                self.lastNameComponentAttribute = '' 
     1397            else: 
     1398                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
     1399             
     1400            self.networkCanvas.drawComponentKeywords() 
     1401             
     1402        def nameComponents(self): 
     1403            """Names connected components of genes according to GO terms.""" 
     1404            self.progressBarFinished() 
     1405            self.lastNameComponentAttribute = None 
     1406             
     1407            if self.graph is None or self.graph_base.items() is None: 
     1408                return 
     1409             
     1410            vars = [x.name for x in self.graph_base.items_vars()] 
     1411            if not self.nameComponentCombo.currentText() in vars: 
     1412                return 
     1413             
     1414            self.progressBarInit() 
     1415            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     1416            if 'component name' in self.graph_base.items().domain: 
     1417                keyword_table = self.graph_base.items() 
     1418            else: 
     1419                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
     1420                 
     1421            import obiGO  
     1422            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
     1423            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
     1424     
     1425            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
     1426            foundGenesets = False 
     1427            if len(annotations.geneNames & allGenes) < 1: 
     1428                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
     1429                if len(annotations.geneNames & allGenes) < 1:             
     1430                    self.warning('no genes found') 
     1431                    return 
     1432                else: 
     1433                    foundGenesets = True 
     1434                 
     1435            def rank(a, j, reverse=False):                     
     1436                if len(a) <= 0: return 
     1437                 
     1438                if reverse:                 
     1439                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
     1440                    top_value = a[0][j] 
     1441                    top_rank = len(a) 
     1442                    max_rank = float(len(a)) 
     1443                    int_ndx = 0 
     1444                    for k in range(len(a)): 
     1445                        if top_value < a[k][j]: 
     1446                            top_value = a[k][j]  
     1447                            if k - int_ndx > 1: 
     1448                                avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1449                                for l in range(int_ndx, k): 
     1450                                    a[l][j] = avg_rank 
     1451                             
     1452                            int_ndx = k 
     1453     
     1454                        a[k][j] = top_rank / max_rank 
     1455                        top_rank -= 1 
     1456                     
     1457                    k += 1 
     1458                    if k - int_ndx > 1: 
     1459                        avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1460                        for l in range(int_ndx, k): 
     1461                            a[l][j] = avg_rank     
     1462                     
     1463                else: 
     1464                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
     1465                    top_value = a[0][j] 
     1466                    top_rank = len(a) 
     1467                    max_rank = float(len(a)) 
     1468                    int_ndx = 0 
     1469                    for k in range(len(a)): 
     1470                        if top_value > a[k][j]: 
     1471                            top_value = a[k][j]  
     1472                            if k - int_ndx > 1: 
     1473                                avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1474                                for l in range(int_ndx, k): 
     1475                                    a[l][j] = avg_rank 
     1476                             
     1477                            int_ndx = k 
     1478     
     1479                        a[k][j] = top_rank / max_rank 
     1480                        top_rank -= 1 
     1481                     
     1482                    k += 1 
     1483                    if k - int_ndx > 1: 
     1484                        avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1485                        for l in range(int_ndx, k): 
     1486                            a[l][j] = avg_rank 
     1487             
     1488            for i in range(len(components)): 
     1489                component = components[i] 
     1490                if len(component) <= 1: 
     1491                    continue 
     1492                 
     1493                if foundGenesets: 
     1494                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
     1495                else: 
     1496                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
     1497                         
     1498                res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
     1499                res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
     1500                res = res1.items() + res2.items() 
     1501                #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] 
     1502                #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] 
     1503                 
     1504                namingScore = [[len(g), ref, p_value, ontology[GOId].name, len(g), ref, p_value] for GOId, (g, p_value, ref) in res if p_value < 0.1] 
     1505                if len(namingScore) == 0: 
     1506                    continue 
     1507                 
     1508                annotated_genes = max([a[0] for a in namingScore]) 
     1509                 
     1510                rank(namingScore, 1, reverse=True) 
     1511                rank(namingScore, 2, reverse=True) 
     1512                rank(namingScore, 0) 
     1513                 
     1514                namingScore = [[10 * rank_genes + 0.5 * rank_ref + rank_p_value, name, g, ref, p_value] for rank_genes, rank_ref, rank_p_value, name, g, ref, p_value in namingScore] 
     1515                namingScore.sort(reverse=True) 
     1516                 
     1517                if len(namingScore) < 1: 
     1518                    print "warning. no annotations found for group of genes: " + ", ".join(genes) 
     1519                    continue 
     1520                elif len(namingScore[0]) < 2: 
     1521                    print "warning. error computing score for group of genes: " + ", ".join(genes) 
     1522                    continue 
     1523                 
     1524                for v in component: 
     1525                    name = str(namingScore[0][1]) 
     1526                    attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4]) 
     1527                    info = '' 
     1528                    if self.showTextMiningInfo: 
     1529                        info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
     1530                    keyword_table[v]['component name'] = name + info 
     1531                 
     1532                self.progressBarSet(i*100.0/len(components)) 
     1533                     
     1534            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
     1535            self.set_items(Orange.data.Table([self.graph_base.items(), keyword_table])) 
     1536            self.progressBarFinished()    
     1537     
     1538         
     1539        def setAutoSendAttributes(self): 
     1540            print 'TODO setAutoSendAttributes' 
     1541            #if self.autoSendAttributes: 
     1542            #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
     1543            #else: 
     1544            #    self.networkCanvas.callbackSelectVertex = None 
     1545     
     1546        def sendAttSelectionList(self): 
     1547            if not self.graph is None: 
     1548                vars = [x.name for x in self.graph_base.links_vars()] 
     1549                if not self.comboAttSelection.currentText() in vars: 
     1550                    return 
     1551                att = str(self.comboAttSelection.currentText()) 
     1552                vertices = self.networkCanvas.selected_nodes() 
     1553                 
     1554                if len(vertices) != 1: 
     1555                    return 
     1556                 
     1557                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
     1558            else: 
     1559                attributes = None 
     1560            self.send("Attribute Selection List", attributes) 
     1561         
    15621562             
    15631563except ImportError as err: 
     
    15671567        # if Qwt is also not installed throw could not import orangeqt error 
    15681568        raise err  
     1569     
     1570     
     1571    dir = os.path.dirname(__file__) + "/../icons/" 
     1572    dlg_mark2sel = dir + "Dlg_Mark2Sel.png" 
     1573    dlg_sel2mark = dir + "Dlg_Sel2Mark.png" 
     1574    dlg_selIsmark = dir + "Dlg_SelisMark.png" 
     1575    dlg_selected = dir + "Dlg_HideSelection.png" 
     1576    dlg_unselected = dir + "Dlg_UnselectedNodes.png" 
     1577    dlg_showall = dir + "Dlg_clear.png" 
     1578 
    15691579     
    15701580    class OWNxExplorer(OWWidget): 
Note: See TracChangeset for help on using the changeset viewer.