Changeset 9622:3f0d63a65934 in orange


Ignore:
Timestamp:
02/02/12 10:08:01 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
64b509f547ce3d644d686d670add70e6cb63e328
Message:

Fixed signal names.

Location:
orange/OrangeWidgets/Unsupervised
Files:
2 edited

Legend:

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

    r8156 r9622  
    1313from OWWidget import * 
    1414 
     15 
    1516class OWNxClustering(OWWidget): 
    16      
     17 
    1718    settingsList = ['method', 'iterationHistory', 'autoApply', 'iterations', 'hop_attenuation'] 
    18      
     19 
    1920    def __init__(self, parent=None, signalManager=None): 
    2021        OWWidget.__init__(self, parent, signalManager, 'Nx Clustering') 
    21          
     22 
    2223        self.inputs = [("Network", Orange.network.Graph, self.setNetwork, Default)] 
    2324        self.outputs = [("Network", Orange.network.Graph)] 
    24          
     25 
    2526        self.net = None 
    2627        self.method = 0 
     
    3031        self.hop_attenuation = 0.1 
    3132        self.loadSettings() 
    32          
     33 
    3334        OWGUI.spin(self.controlArea, self, "iterations", 1, 100000, 1, label="Iterations: ") 
    34         ribg = OWGUI.radioButtonsInBox(self.controlArea, self, "method", [], "Method", callback = self.cluster) 
    35         OWGUI.appendRadioButton(ribg, self, "method", "Label propagation clustering (Raghavan et al., 2007)", callback = self.cluster) 
    36          
    37         OWGUI.appendRadioButton(ribg, self, "method", "Label propagation clustering (Loung et al., 2009)", callback = self.cluster) 
     35        ribg = OWGUI.radioButtonsInBox(self.controlArea, self, "method", [], "Method", callback=self.cluster) 
     36        OWGUI.appendRadioButton(ribg, self, "method", "Label propagation clustering (Raghavan et al., 2007)", callback=self.cluster) 
     37 
     38        OWGUI.appendRadioButton(ribg, self, "method", "Label propagation clustering (Leung et al., 2009)", callback=self.cluster) 
    3839        OWGUI.doubleSpin(OWGUI.indentedBox(ribg), self, "hop_attenuation", 0, 1, 0.01, label="Hop attenuation (delta): ") 
    39          
    40          
     40 
     41 
    4142        self.info = OWGUI.widgetLabel(self.controlArea, ' ') 
    4243        OWGUI.checkBox(self.controlArea, self, "iterationHistory", "Append clustering data on each iteration") 
    4344        autoApplyCB = OWGUI.checkBox(self.controlArea, self, "autoApply", "Commit automatically") 
    4445        OWGUI.button(self.controlArea, self, "Commit", callback=self.cluster) 
    45          
     46 
    4647    def setNetwork(self, net): 
    4748        self.net = net 
    4849        if self.autoApply: 
    4950            self.cluster() 
    50          
     51 
    5152    def cluster(self): 
    5253        self.info.setText(' ') 
    53          
     54 
    5455        if self.net is None: 
    5556            self.send("Network", None) 
    5657            return 
    57          
     58 
    5859        if self.method == 0: 
    59             labels = cd.label_propagation(self.net, results2items=1,  
    60                                     resultHistory2items=self.iterationHistory,  
     60            labels = cd.label_propagation(self.net, results2items=1, 
     61                                    resultHistory2items=self.iterationHistory, 
    6162                                    iterations=self.iterations) 
    6263        if self.method == 1: 
    6364            labels = cd.label_propagation_hop_attenuation( 
    64                                     self.net,  
    65                                     results2items=1,  
    66                                     resultHistory2items=self.iterationHistory,  
     65                                    self.net, 
     66                                    results2items=1, 
     67                                    resultHistory2items=self.iterationHistory, 
    6768                                    iterations=self.iterations, 
    6869                                    delta=self.hop_attenuation) 
    69          
    70         self.info.setText('%d clusters found' % len(set(labels.items())))         
     70 
     71        self.info.setText('%d clusters found' % len(set(labels.items()))) 
    7172        self.send("Network", self.net) 
  • orange/OrangeWidgets/Unsupervised/OWNxExplorer.py

    r9588 r9622  
    44<icon>icons/Network.png</icon> 
    55<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact>  
    6 <priority>6420</priorbity> 
     6<priority>6421</priorbity> 
    77""" 
    88import math 
     
    2424 
    2525    class OWNxExplorer(OWWidget): 
    26          
     26 
    2727        settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    2828        "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.animate_plot", 
    29         "networkCanvas.animate_points", "networkCanvas.antialias_plot",  
    30         "networkCanvas.antialias_points", "networkCanvas.antialias_lines",  
    31         "networkCanvas.auto_adjust_performance", "invertSize", "optMethod",  
     29        "networkCanvas.animate_points", "networkCanvas.antialias_plot", 
     30        "networkCanvas.antialias_points", "networkCanvas.antialias_lines", 
     31        "networkCanvas.auto_adjust_performance", "invertSize", "optMethod", 
    3232        "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices", "networkCanvas.show_weights", 
    3333        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    34         "showWeights", "showEdgeLabels", "colorSettings",  
     34        "showWeights", "showEdgeLabels", "colorSettings", 
    3535        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
    3636        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
    37         "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
     37        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism", "showTextMiningInfo", 
    3838        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
    39         "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",  
     39        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex", 
    4040        "networkCanvas.trim_label_words", "opt_from_curr", "networkCanvas.explore_distances", 
    4141        "networkCanvas.show_component_distances", "fontWeight", "networkCanvas.state", 
    42         "networkCanvas.selection_behavior"]  
    43          
    44         def __init__(self, parent=None, signalManager=None, name = 'Net Explorer',  
     42        "networkCanvas.selection_behavior"] 
     43 
     44        def __init__(self, parent=None, signalManager=None, name='Net Explorer', 
    4545                     NetworkCanvas=OWNxCanvas): 
    4646            OWWidget.__init__(self, parent, signalManager, name, noReport=True) 
    4747            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    48             self.inputs = [("Nx View", Orange.network.NxView, self.set_network_view), 
    49                            ("Network", Orange.network.Graph, self.set_graph, Default), 
     48            self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
    5049                           ("Items", Orange.data.Table, self.set_items), 
    51                            ("Item Subset", Orange.data.Table, self.mark_items),  
    52                            ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
    53              
     50                           ("Item Subset", Orange.data.Table, self.mark_items), 
     51                           ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix), 
     52                           ("Net View", Orange.network.NxView, self.set_network_view)] 
     53 
    5454            self.outputs = [("Selected Network", Orange.network.Graph), 
    5555                            ("Distance Matrix", Orange.core.SymMatrix), 
    56                             ("Selected Items", Orange.data.Table),  
    57                             ("Other Items", Orange.data.Table),  
    58                             ("Marked Items", Orange.data.Table)] 
     56                            ("Marked Items", Orange.data.Table), 
     57                            ("Selected Items", Orange.data.Table), 
     58                            ("Other Items", Orange.data.Table)] 
    5959                            #("Attribute Selection List", AttributeList)] 
    60              
     60 
    6161            self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
    62              
     62 
    6363            self.markerAttributes = [] 
    6464            self.tooltipAttributes = [] 
     
    117117            self.number_of_edges_label = -1 
    118118            self.opt_from_curr = False 
    119              
     119 
    120120            self.checkSendMarkedNodes = True 
    121121            self.checkSendSelectedNodes = True 
    122122            self.explore_distances = False 
    123              
     123 
    124124            self.loadSettings() 
    125              
     125 
    126126            self._network_view = None 
    127127            self.graph = None 
    128128            self.graph_base = None 
    129129            self.markInputItems = None 
    130              
     130 
    131131            # if optimization method is set to FragViz, set it to FR 
    132132            if self.optMethod == 9: 
    133133                self.optMethod = 3 
    134              
     134 
    135135            self.networkCanvas.showMissingValues = self.showMissingValues 
    136136            self.mainArea.layout().addWidget(self.networkCanvas) 
    137              
     137 
    138138            self.networkCanvas.maxLinkSize = self.maxLinkSize 
    139              
     139 
    140140            self.tabs = OWGUI.tabWidget(self.controlArea) 
    141              
     141 
    142142            self.verticesTab = OWGUI.createTabPage(self.tabs, "Nodes") 
    143143            self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges") 
     
    145145            self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
    146146            self.performanceTab = OWGUI.createTabPage(self.tabs, "Performance") 
    147              
     147 
    148148            self.tabs.setCurrentIndex(self.tabIndex) 
    149149            self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index)) 
    150              
     150 
    151151            self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False) 
    152              
     152 
    153153            self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method) 
    154154            self.optCombo.addItem("No optimization") 
     
    160160            self.optCombo.addItem("Circular Original") 
    161161            self.optCombo.addItem("Circular Random") 
    162             self.optCombo.addItem("Pivot MDS") 
    163162            self.optCombo.addItem("FragViz") 
    164163            self.optCombo.addItem("MDS") 
     164            self.optCombo.addItem("Pivot MDS") 
    165165            self.optCombo.setCurrentIndex(self.optMethod) 
    166166            self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
     
    168168            self.cb_opt_from_curr.setEnabled(False) 
    169169            self.stepsSpin.setEnabled(False) 
    170              
     170 
    171171            self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1) 
    172              
    173             colorBox = OWGUI.widgetBox(self.verticesTab, "Node color attribute", orientation="horizontal", addSpace = False) 
     172 
     173            colorBox = OWGUI.widgetBox(self.verticesTab, "Node color attribute", orientation="horizontal", addSpace=False) 
    174174            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.set_node_colors) 
    175175            self.colorCombo.addItem("(same color)") 
    176             OWGUI.button(colorBox, self, "palette", self._set_colors, tooltip = "Set node color palette", width=60, debuggingEnabled = 0) 
    177              
    178             ib = OWGUI.widgetBox(self.verticesTab, "Node size attribute", orientation="vertical", addSpace = False) 
    179             hb = OWGUI.widgetBox(ib, orientation="horizontal", addSpace = False) 
    180             OWGUI.checkBox(hb, self, "invertSize", "Invert size", callback = self.set_node_sizes) 
     176            OWGUI.button(colorBox, self, "palette", self._set_colors, tooltip="Set node color palette", width=60, debuggingEnabled=0) 
     177 
     178            ib = OWGUI.widgetBox(self.verticesTab, "Node size attribute", orientation="vertical", addSpace=False) 
     179            hb = OWGUI.widgetBox(ib, orientation="horizontal", addSpace=False) 
     180            OWGUI.checkBox(hb, self, "invertSize", "Invert size", callback=self.set_node_sizes) 
    181181            OWGUI.spin(hb, self, "minVertexSize", 5, 200, 1, label="Min:", callback=self.set_node_sizes) 
    182182            OWGUI.spin(hb, self, "maxVertexSize", 5, 200, 1, label="Max:", callback=self.set_node_sizes) 
    183183            self.vertexSizeCombo = OWGUI.comboBox(ib, self, "vertexSize", callback=self.set_node_sizes) 
    184184            self.vertexSizeCombo.addItem("(none)") 
    185              
    186             self.attBox = OWGUI.widgetBox(self.verticesTab, "Node labels | tooltips", orientation="vertical", addSpace = False) 
    187             hb = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False) 
     185 
     186            self.attBox = OWGUI.widgetBox(self.verticesTab, "Node labels | tooltips", orientation="vertical", addSpace=False) 
     187            hb = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace=False) 
    188188            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)         
     189            self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_tooltip_lstbox) 
    190190            OWGUI.spin(self.attBox, self, "networkCanvas.trim_label_words", 0, 5, 1, label='Trim label words to', callback=self._clicked_att_lstbox) 
    191              
     191 
    192192            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
    193193            OWGUI.checkBox(ib, self, 'networkCanvas.show_weights', 'Show weights', callback=self.networkCanvas.set_edge_labels) 
    194194            #OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
    195             OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.set_edge_sizes) 
     195            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback=self.set_edge_sizes) 
    196196            self.cb_show_distances = OWGUI.checkBox(ib, self, 'explore_distances', 'Explore node distances', callback=self.set_explore_distances, disabled=1) 
    197197            self.cb_show_component_distances = OWGUI.checkBox(ib, self, 'networkCanvas.show_component_distances', 'Show component distances', callback=self.networkCanvas.set_show_component_distances, disabled=1) 
    198              
    199             colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace = False) 
     198 
     199            colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace=False) 
    200200            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.set_edge_colors) 
    201201            self.edgeColorCombo.addItem("(same color)") 
    202             OWGUI.button(colorBox, self, "palette", self._set_edge_color_palette, tooltip = "Set edge color palette", width=60, debuggingEnabled = 0) 
    203              
    204             self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False) 
     202            OWGUI.button(colorBox, self, "palette", self._set_edge_color_palette, tooltip="Set edge color palette", width=60, debuggingEnabled=0) 
     203 
     204            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace=False) 
    205205            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_edge_label_listbox) 
    206206            #self.edgeLabelBox.setEnabled(False) 
    207              
     207 
    208208            ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
    209209            OWGUI.checkBox(ib, self, 'networkCanvas.show_indices', 'Show indices', callback=self.networkCanvas.set_node_labels) 
    210210            OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked nodes only', callback=(lambda: self.networkCanvas.set_labels_on_marked(self.labelsOnMarkedOnly))) 
    211             OWGUI.spin(ib, self, "fontSize", 4, 30, 1, label="Font size:", callback = self.set_font) 
     211            OWGUI.spin(ib, self, "fontSize", 4, 30, 1, label="Font size:", callback=self.set_font) 
    212212            self.comboFontWeight = OWGUI.comboBox(ib, self, "fontWeight", label='Font weight:', orientation='horizontal', callback=self.set_font) 
    213213            self.comboFontWeight.addItem("Normal") 
    214214            self.comboFontWeight.addItem("Bold") 
    215215            self.comboFontWeight.setCurrentIndex(self.fontWeight) 
    216              
     216 
    217217            ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical") 
    218218            OWGUI.label(ib, self, "Nodes (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)") 
    219219            OWGUI.label(ib, self, "Selected: %(nSelected)i, marked: %(nMarked)i") 
    220              
    221             ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Mark", callback = self.set_mark_mode) 
    222             OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.set_mark_mode) 
    223             OWGUI.appendRadioButton(ribg, self, "hubs", "Search", callback = self.set_mark_mode) 
     220 
     221            ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Mark", callback=self.set_mark_mode) 
     222            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback=self.set_mark_mode) 
     223            OWGUI.appendRadioButton(ribg, self, "hubs", "Search", callback=self.set_mark_mode) 
    224224            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self._set_search_string_timer, callbackOnType=True) 
    225225            self.searchStringTimer = QTimer(self) 
    226226            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.set_mark_mode) 
    227              
    228             OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbors of focused", callback = self.set_mark_mode) 
    229             OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbours of selected", callback = self.set_mark_mode) 
    230             ib = OWGUI.indentedBox(ribg, orientation = 0) 
     227 
     228            OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbors of focused", callback=self.set_mark_mode) 
     229            OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbours of selected", callback=self.set_mark_mode) 
     230            ib = OWGUI.indentedBox(ribg, orientation=0) 
    231231            self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.set_mark_mode(h))) 
    232232            #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
    233233            OWGUI.widgetLabel(ribg, "Mark nodes with ...") 
    234             OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.set_mark_mode) 
    235             OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.set_mark_mode) 
     234            OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback=self.set_mark_mode) 
     235            OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback=self.set_mark_mode) 
    236236            self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.set_mark_mode(h))) 
    237             OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.set_mark_mode) 
    238             OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.set_mark_mode) 
    239             OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.set_mark_mode) 
     237            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback=self.set_mark_mode) 
     238            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback=self.set_mark_mode) 
     239            OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback=self.set_mark_mode) 
    240240            ib = OWGUI.indentedBox(ribg) 
    241241            self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of nodes:", callback=(lambda h=8: self.set_mark_mode(h))) 
    242242            OWGUI.widgetLabel(ib, "(More nodes are marked in case of ties)") 
    243             self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark nodes given in the input signal", callback = self.set_mark_mode) 
     243            self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark nodes given in the input signal", callback=self.set_mark_mode) 
    244244            ib = OWGUI.indentedBox(ribg) 
    245245            self.markInput = 0 
    246246            self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.set_mark_mode(h))) 
    247247            self.markInputRadioButton.setEnabled(False) 
    248              
     248 
    249249            #ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
    250250            #self.checkSendMarkedNodes = True 
    251251            #OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked nodes', callback = self.send_marked_nodes, disabled=0) 
    252              
     252 
    253253            self.toolbar = OWGUI.widgetBox(self.controlArea, orientation='horizontal') 
    254254            prevstate = self.networkCanvas.state 
    255255            prevselbeh = self.networkCanvas.selection_behavior 
    256256            G = self.networkCanvas.gui 
    257             self.zoomSelectToolbar = G.zoom_select_toolbar(self.toolbar, nomargin=True, buttons =  
    258                 G.default_zoom_select_buttons +  
     257            self.zoomSelectToolbar = G.zoom_select_toolbar(self.toolbar, nomargin=True, buttons= 
     258                G.default_zoom_select_buttons + 
    259259                [ 
    260260                    G.Spacing, 
     
    273273            self.zoomSelectToolbar.select_selection_behaviour(prevselbeh) 
    274274            self.zoomSelectToolbar.select_state(prevstate) 
    275              
     275 
    276276            ib = OWGUI.widgetBox(self.infoTab, "General") 
    277277            OWGUI.label(ib, self, "Number of nodes: %(number_of_nodes_label)i") 
     
    279279            OWGUI.label(ib, self, "Nodes per edge: %(verticesPerEdge).2f") 
    280280            OWGUI.label(ib, self, "Edges per node: %(edgesPerVertex).2f") 
    281              
     281 
    282282            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
    283              
     283 
    284284            OWGUI.button(ib, self, "Save net", callback=self.save_network, debuggingEnabled=False) 
    285285            OWGUI.button(ib, self, "Save img", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
    286286            self.reportButton = OWGUI.button(ib, self, "&Report", self.reportAndFinish, debuggingEnabled=0) 
    287287            self.reportButton.setAutoDefault(0) 
    288              
     288 
    289289            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
    290290            ib = OWGUI.widgetBox(self.infoTab, "Edit") 
     
    296296            OWGUI.lineEdit(hb, self, "editValue", "Value:", orientation='horizontal') 
    297297            OWGUI.button(hb, self, "Set", callback=self.edit) 
    298              
     298 
    299299            ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
    300300            ib.setVisible(True) 
    301              
     301 
    302302            OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
    303              
     303 
    304304            self.nameComponentAttribute = 0 
    305305            self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal") 
    306306            self.nameComponentCombo.addItem("Select attribute") 
    307              
     307 
    308308            self.showComponentAttribute = 0 
    309309            self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal") 
    310310            self.showComponentCombo.addItem("Select attribute") 
    311311            OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info") 
    312              
     312 
    313313            #OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
    314314            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.set_component_edge_width(changedMin))) 
    315315            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.set_component_edge_width(changedMin))) 
    316              
     316 
    317317            self.attSelectionAttribute = 0 
    318318            self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList) 
     
    320320            self.autoSendAttributes = 0 
    321321            OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes) 
    322              
     322 
    323323            self.icons = self.createAttributeIconDict() 
    324324            self.set_mark_mode() 
    325              
     325 
    326326            self.networkCanvas.gui.effects_box(self.performanceTab) 
    327              
     327 
    328328            self.verticesTab.layout().addStretch(1) 
    329329            self.edgesTab.layout().addStretch(1) 
     
    331331            self.infoTab.layout().addStretch(1) 
    332332            self.performanceTab.layout().addStretch(1) 
    333              
     333 
    334334            dlg = self._create_color_dialog(self.colorSettings, self.selectedSchemaIndex) 
    335335            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    336336            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    337              
     337 
    338338            dlg = self._create_color_dialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    339339            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    340340            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    341              
     341 
    342342            self.graph_layout_method() 
    343343            self.set_font() 
    344344            self.set_graph(None) 
    345              
     345 
    346346            self.setMinimumWidth(900) 
    347347 
    348348            self.connect(self.networkCanvas, SIGNAL("marked_points_changed()"), self.send_marked_nodes) 
    349349            self.connect(self.networkCanvas, SIGNAL("selection_changed()"), self.send_data) 
    350              
     350 
    351351        def hide_selection(self): 
    352352            nodes = set(self.graph.nodes()).difference(self.networkCanvas.selected_nodes()) 
     
    355355        def show_selection(self): 
    356356            self.change_graph(self.graph_base) 
    357              
     357 
    358358        def edit(self): 
    359359            if self.graph is None: 
    360360                return 
    361              
     361 
    362362            vars = [x.name for x in self.graph_base.items_vars()] 
    363363            if not self.editCombo.currentText() in vars: 
     
    365365            att = str(self.editCombo.currentText()) 
    366366            vertices = self.networkCanvas.selected_nodes() 
    367              
     367 
    368368            if len(vertices) == 0: 
    369369                return 
    370              
     370 
    371371            items = self.graph_base.items() 
    372372            if items.domain[att].var_type == Orange.data.Type.Continuous: 
     
    376376                for v in vertices: 
    377377                    items[v][att] = str(self.editValue) 
    378          
     378 
    379379        def set_items_distance_matrix(self, matrix): 
    380380            self.error() 
    381381            self.warning() 
    382382            self.information() 
    383              
     383 
    384384            self.cb_show_distances.setEnabled(0) 
    385385            self.cb_show_component_distances.setEnabled(0) 
    386              
     386 
    387387            if matrix is None or self.graph_base is None: 
    388388                self.items_matrix = None 
     
    390390                self.information('No graph found!') 
    391391                return 
    392      
     392 
    393393            if matrix.dim != self.graph_base.number_of_nodes(): 
    394394                self.error('The number of vertices does not match matrix size.') 
     
    396396                self.networkCanvas.items_matrix = None 
    397397                return 
    398              
     398 
    399399            self.items_matrix = matrix 
    400400            self.networkCanvas.items_matrix = matrix 
    401401            self.cb_show_distances.setEnabled(1) 
    402402            self.cb_show_component_distances.setEnabled(1) 
    403              
     403 
    404404            if str(self.optMethod) in ['8', '9', '10']: 
    405405                if self.items_matrix is not None and self.graph is not None and \ 
     
    408408                    self.optButton.setChecked(True) 
    409409                    self.graph_layout() 
    410                                     
     410 
    411411        def _set_canvas_attr(self, attr, value): 
    412412            setattr(self.networkCanvas, attr, value) 
    413413            self.networkCanvas.updateCanvas() 
    414          
     414 
    415415        def _set_curve_attr(self, attr, value): 
    416416            setattr(self.networkCanvas.networkCurve, attr, value) 
    417417            self.networkCanvas.updateCanvas() 
    418                      
     418 
    419419        def _set_search_string_timer(self): 
    420420            self.hubs = 1 
    421421            self.searchStringTimer.stop() 
    422422            self.searchStringTimer.start(1000) 
    423               
     423 
    424424        def set_mark_mode(self, i=None): 
    425425            self.searchStringTimer.stop() 
    426426            if not i is None: 
    427427                self.hubs = i 
    428              
     428 
    429429            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed) 
    430430            QObject.disconnect(self.networkCanvas, SIGNAL('point_hovered(Point*)'), self.networkCanvas.mark_on_focus_changed) 
    431              
     431 
    432432            if self.graph is None: 
    433433                return 
    434              
     434 
    435435            hubs = self.hubs 
    436              
    437             if hubs in [0,1,2,3]: 
     436 
     437            if hubs in [0, 1, 2, 3]: 
    438438                if hubs == 0: 
    439439                    self.networkCanvas.networkCurve.clear_node_marks() 
     
    441441                    #print "mark on given label" 
    442442                    txt = self.markSearchString 
    443                      
     443 
    444444                    toMark = set(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()])) 
    445445                    toMark = toMark.intersection(self.graph.nodes()) 
     
    455455                    QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed) 
    456456                    self.networkCanvas.mark_on_selection_changed() 
    457                      
    458             elif hubs in [4,5,6,7,8,9]: 
    459                  
     457 
     458            elif hubs in [4, 5, 6, 7, 8, 9]: 
     459 
    460460                powers = sorted(self.graph.degree_iter(), key=itemgetter(1), reverse=True) 
    461                  
     461 
    462462                if hubs == 4: 
    463463                    #print "mark at least N connections" 
     
    473473                    #print "mark more than any" 
    474474                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
    475                         d > max([0]+self.graph.degree(self.graph.neighbors(i)).values()) \ 
    476                         else (i, False) for i,d in powers )) 
     475                        d > max([0] + self.graph.degree(self.graph.neighbors(i)).values()) \ 
     476                        else (i, False) for i, d in powers)) 
    477477                elif hubs == 7: 
    478478                    #print "mark more than avg" 
    479479                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
    480                         d > statc.mean([0]+self.graph.degree(self.graph.neighbors(i)).values()) \ 
    481                         else (i, False) for i,d in powers )) 
     480                        d > statc.mean([0] + self.graph.degree(self.graph.neighbors(i)).values()) \ 
     481                        else (i, False) for i, d in powers)) 
    482482                    self.networkCanvas.replot() 
    483483                elif hubs == 8: 
    484484                    #print "mark most" 
    485485                    self.networkCanvas.networkCurve.clear_node_marks() 
    486                      
     486 
    487487                    if self.markNumber < 1: 
    488488                        return 
    489                      
     489 
    490490                    cut = self.markNumber 
    491                     cutPower = powers[cut-1][1] 
     491                    cutPower = powers[cut - 1][1] 
    492492                    while cut < len(powers) and powers[cut][1] == cutPower: 
    493493                        cut += 1 
    494          
     494 
    495495                    self.networkCanvas.networkCurve.clear_node_marks() 
    496496                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for \ 
    497                         i,d in powers[:cut])) 
    498                      
     497                        i, d in powers[:cut])) 
     498 
    499499                elif hubs == 9: 
    500500                    var = str(self.markInputCombo.currentText()) 
     
    508508                        self.networkCanvas.networkCurve.clear_node_marks() 
    509509                        self.networkCanvas.networkCurve.set_node_marks(tomark) 
    510                          
     510 
    511511                    else: 
    512                         self.networkCanvas.networkCurve.clear_node_marks()       
    513              
     512                        self.networkCanvas.networkCurve.clear_node_marks() 
     513 
    514514            self.nMarked = len(self.networkCanvas.marked_nodes()) 
    515              
     515 
    516516        def save_network(self): 
    517517    #        if self.networkCanvas is None or self.graph is None: 
     
    534534    #            Orange.network.readwrite.write(self.graph, fn) 
    535535            pass 
    536                  
     536 
    537537        def send_data(self): 
    538538            if len(self.signalManager.getLinks(self, None, \ 
     
    542542                            len(self.signalManager.getLinks(self, None, \ 
    543543                                "Selected Network", None)) > 0: 
    544                  
     544 
    545545                # signal connected 
    546546                selected_nodes = self.networkCanvas.selected_nodes() 
    547547                graph = self.graph_base.subgraph(selected_nodes) 
    548                  
     548 
    549549                if graph is not None: 
    550550                    self.send("Selected Items", graph.items()) 
    551                      
     551 
    552552                    if len(self.signalManager.getLinks(self, None, \ 
    553553                                                "Unselected Items", None)) > 0: 
     
    557557                        else: 
    558558                            self.send("Other Items", None) 
    559                          
     559 
    560560                    self.send("Selected Network", graph) 
    561561                else: 
     
    563563                    self.send("Other Items", None) 
    564564                    self.send("Selected Network", None) 
    565                      
     565 
    566566            if len(self.signalManager.getLinks(self, None, \ 
    567567                                "Selected Items Distance Matrix", None)) > 0: 
     
    569569                matrix = None if self.items_matrix is None else self.items_matrix.getitems(selected_nodes) 
    570570                self.send("Distance Matrix", matrix) 
    571          
     571 
    572572        def send_marked_nodes(self): 
    573573            if self.checkSendMarkedNodes and \ 
     
    576576                # signal connected 
    577577                markedNodes = self.networkCanvas.marked_nodes() 
    578                  
     578 
    579579                if len(markedNodes) > 0 and self.graph is not None and\ 
    580580                                         self.graph_base.items() is not None: 
    581                      
     581 
    582582                    items = self.graph_base.items().getitems(markedNodes) 
    583583                    self.send("Marked Items", items) 
    584584                else: 
    585585                    self.send("Marked Items", None) 
    586             
     586 
    587587        def _set_combos(self): 
    588588            vars = self.graph_base.items_vars() 
     
    590590            lastLabelColumns = self.lastLabelColumns 
    591591            lastTooltipColumns = self.lastTooltipColumns 
    592              
     592 
    593593            self._clear_combos() 
    594              
     594 
    595595            self.attributes = [(var.name, var.varType) for var in vars] 
    596596            self.edgeAttributes = [(var.name, var.varType) for var in edgeVars] 
    597              
     597 
    598598            for var in vars: 
    599599                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    600600                    self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    601                      
     601 
    602602                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: 
    603                      
     603 
    604604                    value = self.graph_base.items()[0][var].value 
    605                      
     605 
    606606                    # can value be a list? 
    607607                    try: 
     
    611611                    except: 
    612612                        pass 
    613                      
     613 
    614614                    if len(value.split(',')) > 1: 
    615615                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    616                      
     616 
    617617                elif var.varType in [Orange.data.Type.Continuous]: 
    618618                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    619      
     619 
    620620                self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    621621                self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    622622                self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    623623                self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    624              
     624 
    625625            for var in edgeVars: 
    626626                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    627627                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    628                      
     628 
    629629            for i in range(self.vertexSizeCombo.count()): 
    630630                if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i): 
    631631                    self.vertexSize = i 
    632632                    break 
    633                  
     633 
    634634            for i in range(self.colorCombo.count()): 
    635635                if self.lastColorColumn == self.colorCombo.itemText(i): 
    636636                    self.color = i 
    637637                    break 
    638      
     638 
    639639            for i in range(self.attListBox.count()): 
    640640                if str(self.attListBox.item(i).text()) in lastLabelColumns: 
    641641                    self.attListBox.item(i).setSelected(1) 
    642                      
     642 
    643643            for i in range(self.tooltipListBox.count()): 
    644644                if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns: 
    645645                    self.tooltipListBox.item(i).setSelected(1) 
    646                  
     646 
    647647            self.lastLabelColumns = lastLabelColumns 
    648648            self.lastTooltipColumns = lastTooltipColumns 
    649              
     649 
    650650        def _clear_combos(self): 
    651651            self.attributes = [] 
    652652            self.edgeAttributes = [] 
    653              
     653 
    654654            self.colorCombo.clear() 
    655655            self.vertexSizeCombo.clear() 
     
    659659            self.editCombo.clear() 
    660660            self.comboAttSelection.clear() 
    661              
     661 
    662662            self.colorCombo.addItem("(same color)") 
    663663            self.edgeColorCombo.addItem("(same color)") 
     
    667667            self.editCombo.addItem("Select attribute") 
    668668            self.comboAttSelection.addItem("Select attribute") 
    669            
     669 
    670670        def compute_network_info(self): 
    671671            self.nShown = self.graph.number_of_nodes() 
    672              
     672 
    673673            if self.graph.number_of_edges() > 0: 
    674674                self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    675675            else: 
    676676                self.verticesPerEdge = 0 
    677                  
     677 
    678678            if self.graph.number_of_nodes() > 0: 
    679679                self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    680680            else: 
    681681                self.edgesPerVertex = 0 
    682            
     682 
    683683        def change_graph(self, newgraph): 
    684684            self.information() 
    685              
     685 
    686686            # if graph has more nodes and edges than pixels in 1600x1200 display,  
    687687            # it is too big to visualize! 
     
    689689                self.information('New graph is too big to visualize. Keeping the old graph.') 
    690690                return 
    691              
     691 
    692692            self.graph = newgraph 
    693              
     693 
    694694            self.number_of_nodes_label = self.graph.number_of_nodes() 
    695695            self.number_of_edges_label = self.graph.number_of_edges() 
    696              
     696 
    697697            if not self.networkCanvas.change_graph(self.graph): 
    698698                return 
    699              
     699 
    700700            self.compute_network_info() 
    701              
     701 
    702702            if self.graph.number_of_nodes() > 0: 
    703                 t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
     703                t = 1.13850193174e-008 * (self.graph.number_of_nodes() ** 2 + self.graph.number_of_edges()) 
    704704                self.frSteps = int(2.0 / t) 
    705                 if self.frSteps <   1: self.frSteps = 1 
     705                if self.frSteps < 1: self.frSteps = 1 
    706706                if self.frSteps > 100: self.frSteps = 100 
    707707    #         
     
    714714    #            self.optMethod = 0 
    715715    #            self.graph_layout_method() 
    716              
     716 
    717717            animation_enabled = self.networkCanvas.animate_points; 
    718718            self.networkCanvas.animate_points = False; 
    719              
     719 
    720720            self.set_node_sizes() 
    721721            self.set_node_colors() 
    722722            self.set_edge_sizes() 
    723723            self.set_edge_colors() 
    724                  
     724 
    725725            self._clicked_att_lstbox() 
    726726            self._clicked_tooltip_lstbox() 
    727727            self._clicked_edge_label_listbox() 
    728              
     728 
    729729            self.networkCanvas.replot() 
    730              
     730 
    731731            self.networkCanvas.animate_points = animation_enabled 
    732732            qApp.processEvents() 
    733733            self.networkCanvas.networkCurve.layout_fr(100, weighted=False, smooth_cooling=True) 
    734             self.networkCanvas.update_canvas()         
    735      
     734            self.networkCanvas.update_canvas() 
     735 
    736736        def set_graph_none(self): 
    737737            self.graph = None 
     
    744744            self.set_items_distance_matrix(None) 
    745745            self.networkCanvas.set_graph(None) 
    746      
     746 
    747747        def set_graph(self, graph, curve=None): 
    748748            self.information() 
    749749            self.warning() 
    750750            self.error() 
    751              
     751 
    752752            if graph is None: 
    753753                self.set_graph_none() 
    754754                return 
    755              
     755 
    756756            if graph.number_of_nodes() < 2: 
    757757                self.set_graph_none() 
    758758                self.information('I\'m not really in a mood to visualize just one node. Try again tomorrow.') 
    759759                return 
    760              
     760 
    761761            if graph == self.graph_base and self.graph is not None and self._network_view is None: 
    762762                self.set_items(graph.items()) 
    763763                return 
    764              
     764 
    765765            self.graph_base = graph 
    766              
     766 
    767767            if self._network_view is not None: 
    768768                graph = self._network_view.init_network(graph) 
    769              
     769 
    770770            self.graph = graph 
    771              
     771 
    772772            # if graph has more nodes and edges than pixels in 1600x1200 display,  
    773773            # it is too big to visualize! 
     
    776776                self.error('Graph is too big to visualize. Try using one of the network views.') 
    777777                return 
    778              
     778 
    779779            if self.items_matrix is not None and self.items_matrix.dim != self.graph_base.number_of_nodes(): 
    780780                self.set_items_distance_matrix(None) 
    781              
     781 
    782782            self.number_of_nodes_label = self.graph.number_of_nodes() 
    783783            self.number_of_edges_label = self.graph.number_of_edges() 
    784              
     784 
    785785            self.networkCanvas.set_graph(self.graph, curve, items=self.graph_base.items(), links=self.graph_base.links()) 
    786              
     786 
    787787            if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
    788788                positions = dict((node, (self._items[node]['x'].value, self._items[node]['y'].value)) \ 
    789789                             for node in self.graph if self._items[node]['x'].value != '?' \ 
    790790                             and self._items[node]['y'].value != '?') 
    791                  
     791 
    792792                self.networkCanvas.networkCurve.set_node_coordinates(positions) 
    793      
    794              
     793 
     794 
    795795            self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    796796            self.networkCanvas.maxEdgeSize = self.maxLinkSize 
     
    798798            self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    799799            self.networkCanvas.set_labels_on_marked(self.labelsOnMarkedOnly) 
    800              
     800 
    801801            self.compute_network_info() 
    802802            self._set_combos() 
    803                  
     803 
    804804            lastNameComponentAttributeFound = False 
    805805            for i in range(self.nameComponentCombo.count()): 
     
    811811                    self.showComponents() 
    812812                    break 
    813                  
     813 
    814814            if not lastNameComponentAttributeFound: 
    815815                self.lastNameComponentAttribute = '' 
    816              
     816 
    817817            self.showComponentAttribute = None 
    818      
    819             t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
     818 
     819            t = 1.13850193174e-008 * (self.graph.number_of_nodes() ** 2 + self.graph.number_of_edges()) 
    820820            self.frSteps = int(2.0 / t) 
    821             if self.frSteps <   1: self.frSteps = 1 
     821            if self.frSteps < 1: self.frSteps = 1 
    822822            if self.frSteps > 100: self.frSteps = 100 
    823              
     823 
    824824            # if graph is large, set random layout, min vertex size, min edge size 
    825825            if self.frSteps < 10: 
     
    830830                self.maxLinkSize = 1 
    831831                self.optMethod = 0 
    832                 self.graph_layout_method()             
    833              
     832                self.graph_layout_method() 
     833 
    834834            self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
    835835            self.networkCanvas.showWeights = self.showWeights 
    836                  
     836 
    837837            self.set_node_sizes() 
    838838            self.set_node_colors() 
    839839            self.set_edge_sizes() 
    840840            self.set_edge_colors() 
    841                  
     841 
    842842            self._clicked_att_lstbox() 
    843843            self._clicked_tooltip_lstbox() 
    844844            self._clicked_edge_label_listbox() 
    845              
     845 
    846846            self.optButton.setChecked(1) 
    847             self.graph_layout()         
    848              
     847            self.graph_layout() 
     848 
    849849        def set_network_view(self, nxView): 
    850850            self.error() 
    851851            self.warning() 
    852852            self.information() 
    853              
     853 
    854854            if self.graph is None: 
    855855                self.information('Do not forget to add a graph!') 
    856                  
     856 
    857857            if self._network_view is not None: 
    858858                QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
    859                  
     859 
    860860            self._network_view = nxView 
    861              
     861 
    862862            if self._network_view is not None: 
    863863                self._network_view.set_nx_explorer(self) 
    864              
     864 
    865865            self.set_graph(self.graph_base) 
    866              
     866 
    867867            if self._network_view is not None: 
    868868                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
    869              
     869 
    870870        def set_items(self, items=None): 
    871871            self.error() 
    872872            self.warning() 
    873873            self.information() 
    874              
     874 
    875875            if items is None: 
    876876                return 
    877              
     877 
    878878            if self.graph is None: 
    879879                self.warning('No graph found!') 
    880880                return 
    881              
     881 
    882882            if len(items) != self.graph_base.number_of_nodes(): 
    883883                self.error('ExampleTable items must have one example for each vertex.') 
    884884                return 
    885              
     885 
    886886            self.graph_base.set_items(items) 
    887              
     887 
    888888            self.set_node_sizes() 
    889889            self.networkCanvas.items = items 
     
    892892            self._set_combos() 
    893893            #self.networkCanvas.updateData() 
    894              
     894 
    895895        def mark_items(self, items): 
    896896            self.markInputCombo.clear() 
    897897            self.markInputRadioButton.setEnabled(False) 
    898898            self.markInputItems = items 
    899              
     899 
    900900            self.error() 
    901901            self.warning() 
    902902            self.information() 
    903              
     903 
    904904            if items is None: 
    905905                return 
    906              
     906 
    907907            if self.graph is None or self.graph_base.items() is None or items is None: 
    908908                self.warning('No graph found or no items attached to the graph.') 
    909909                return 
    910              
     910 
    911911            if len(items) > 0: 
    912912                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()] 
    913913                lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
    914914                commonVars = set(lstNewDomain) & set(lstOrgDomain) 
    915      
     915 
    916916                self.markInputCombo.addItem(self.icons[Orange.data.Type.Discrete], unicode("ID")) 
    917                  
     917 
    918918                if len(commonVars) > 0: 
    919919                    for var in commonVars: 
    920920                        orgVar = self.graph_base.items().domain[var] 
    921921                        mrkVar = items.domain[var] 
    922      
     922 
    923923                        if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String: 
    924924                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
    925                  
     925 
    926926                self.markInputRadioButton.setEnabled(True) 
    927927                self.set_mark_mode(9) 
    928          
     928 
    929929        def set_explore_distances(self): 
    930930            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.explore_focused) 
     
    932932            if self.explore_distances: 
    933933                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.explore_focused) 
    934                  
     934 
    935935        def explore_focused(self): 
    936936            sel = self.networkCanvas.selected_nodes() 
     
    942942            else: 
    943943                self.networkCanvas.label_distances = None 
    944                  
     944 
    945945            self.networkCanvas.set_node_labels(self.lastLabelColumns) 
    946             self.networkCanvas.replot()   
    947        
     946            self.networkCanvas.replot() 
     947 
    948948        ####################################################################### 
    949949        ### Layout Optimization                                             ### 
    950950        ####################################################################### 
    951          
     951 
    952952        def graph_layout(self): 
    953953            if self.graph is None or self.graph.number_of_nodes <= 0:   #grafa se ni 
    954954                self.optButton.setChecked(False) 
    955955                return 
    956              
    957             if not self.optButton.isChecked() and not self.optMethod in [2,3,9,10]: 
     956 
     957            if not self.optButton.isChecked() and not self.optMethod in [2, 3, 9, 10]: 
    958958                self.optButton.setChecked(False) 
    959959                return 
    960              
     960 
    961961            qApp.processEvents() 
    962              
     962 
    963963            if self.optMethod == 1: 
    964964                self.networkCanvas.networkCurve.random() 
     
    970970                self.graph_layout_fr_radial() 
    971971            elif self.optMethod == 5: 
    972                 self.networkCanvas.networkCurve.circular(NetworkCurve.circular_crossing) 
     972                self.networkCanvas.networkCurve.circular(\ 
     973                                            NetworkCurve.circular_crossing) 
    973974            elif self.optMethod == 6: 
    974                 self.networkCanvas.networkCurve.circular(NetworkCurve.circular_original) 
     975                self.networkCanvas.networkCurve.circular(\ 
     976                                            NetworkCurve.circular_original) 
    975977            elif self.optMethod == 7: 
    976                 self.networkCanvas.networkCurve.circular(NetworkCurve.circular_random) 
     978                self.networkCanvas.networkCurve.circular(\ 
     979                                            NetworkCurve.circular_random) 
    977980            elif self.optMethod == 8: 
     981                self.graph_layout_fragviz() 
     982            elif self.optMethod == 9: 
     983                self.graph_layout_mds() 
     984            elif self.optMethod == 10: 
    978985                self.graph_layout_pivot_mds() 
    979             elif self.optMethod == 9: 
    980                 self.graph_layout_fragviz() 
    981             elif self.optMethod == 10:  
    982                 self.graph_layout_mds() 
    983                  
     986 
    984987            self.optButton.setChecked(False) 
    985988            self.networkCanvas.update_canvas() 
    986              
     989 
    987990        def graph_layout_method(self, method=None): 
    988991            self.information() 
     
    990993            self.optButton.setEnabled(True) 
    991994            self.cb_opt_from_curr.setEnabled(False) 
    992              
     995 
    993996            if method is not None: 
    994997                self.optMethod = method 
    995                  
     998 
    996999            if str(self.optMethod) == '0': 
    9971000                self.optButton.setEnabled(False) 
    9981001            else: 
    9991002                self.optButton.setEnabled(True) 
    1000                  
     1003 
    10011004            if str(self.optMethod) in ['2', '3', '4']: 
    10021005                self.stepsSpin.setEnabled(True) 
    1003                  
     1006 
    10041007            elif str(self.optMethod) in ['8', '9', '10']: 
    1005                 if str(self.optMethod) == '8':  
     1008                if str(self.optMethod) == '8': 
    10061009                    self.stepsSpin.label.setText('Pivots: ') 
    1007                  
    1008                 if str(self.optMethod) in ['9', '10']:  
     1010 
     1011                if str(self.optMethod) in ['9', '10']: 
    10091012                    self.cb_opt_from_curr.setEnabled(True) 
    1010                      
     1013 
    10111014                self.stepsSpin.setEnabled(True) 
    1012                  
     1015 
    10131016                if self.items_matrix is None: 
    10141017                    self.information('Set distance matrix to input signal') 
     
    10271030                self.optButton.setChecked(True) 
    10281031                self.graph_layout() 
    1029              
    1030          
    1031         def mds_progress(self, avgStress, stepCount):     
     1032 
     1033        def mds_progress(self, avgStress, stepCount): 
    10321034            #self.drawForce() 
    1033      
     1035 
    10341036            #self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
    10351037            #self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
    10361038            self.progressBarSet(int(stepCount * 100 / self.frSteps)) 
    10371039            qApp.processEvents() 
    1038              
     1040 
    10391041        def graph_layout_fragviz(self): 
    10401042            if self.items_matrix is None: 
     
    10421044                self.optButton.setChecked(False) 
    10431045                return 
    1044              
     1046 
    10451047            if self.layout is None: 
    10461048                self.information('No network found') 
    10471049                self.optButton.setChecked(False) 
    10481050                return 
    1049              
     1051 
    10501052            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    10511053                self.error('Distance matrix dimensionality must equal number of vertices') 
    10521054                self.optButton.setChecked(False) 
    10531055                return 
    1054              
     1056 
    10551057            if not self.optButton.isChecked(): 
    10561058                self.networkCanvas.networkCurve.stopMDS = True 
     
    10581060                self.optButton.setText("Optimize layout") 
    10591061                return 
    1060              
     1062 
    10611063            self.optButton.setText("Stop") 
    10621064            self.progressBarInit() 
    10631065            qApp.processEvents() 
    1064      
     1066 
    10651067            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
    10661068                matrix = self.items_matrix 
    10671069            else: 
    10681070                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
    1069              
     1071 
    10701072            self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mds_progress, self.opt_from_curr) 
    1071      
     1073 
    10721074            self.optButton.setChecked(False) 
    10731075            self.optButton.setText("Optimize layout") 
    10741076            self.progressBarFinished() 
    1075              
     1077 
    10761078        def graph_layout_mds(self): 
    10771079            if self.items_matrix is None: 
     
    10791081                self.optButton.setChecked(False) 
    10801082                return 
    1081              
     1083 
    10821084            if self.layout is None: 
    10831085                self.information('No network found') 
    10841086                self.optButton.setChecked(False) 
    10851087                return 
    1086              
     1088 
    10871089            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    10881090                self.error('Distance matrix dimensionality must equal number of vertices') 
    10891091                self.optButton.setChecked(False) 
    10901092                return 
    1091              
     1093 
    10921094            if not self.optButton.isChecked(): 
    10931095                self.networkCanvas.networkCurve.stopMDS = True 
     
    10951097                self.optButton.setText("Optimize layout") 
    10961098                return 
    1097              
     1099 
    10981100            self.optButton.setText("Stop") 
    10991101            self.progressBarInit() 
    11001102            qApp.processEvents() 
    1101              
     1103 
    11021104            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
    11031105                matrix = self.items_matrix 
    11041106            else: 
    11051107                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
    1106              
     1108 
    11071109            self.networkCanvas.networkCurve.layout_mds(self.frSteps, matrix, self.mds_progress, self.opt_from_curr) 
    1108      
     1110 
    11091111            self.optButton.setChecked(False) 
    11101112            self.optButton.setText("Optimize layout") 
    11111113            self.progressBarFinished() 
    1112              
     1114 
    11131115        def graph_layout_fr(self, weighted): 
    11141116            if self.graph is None: 
    11151117                return 
    1116                    
     1118 
    11171119            if not self.optButton.isChecked(): 
    11181120                self.networkCanvas.networkCurve.stop_optimization() 
     
    11201122                self.optButton.setText("Optimize layout") 
    11211123                return 
    1122              
     1124 
    11231125            self.optButton.setText("Stop") 
    11241126            qApp.processEvents() 
     
    11271129            self.optButton.setChecked(False) 
    11281130            self.optButton.setText("Optimize layout") 
    1129                      
     1131 
    11301132        def graph_layout_fr_radial(self): 
    11311133            if self.graph is None:   #grafa se ni 
    11321134                return 
    1133              
     1135 
    11341136    #        #print "F-R Radial" 
    11351137    #        k = 1.13850193174e-008 
     
    11551157    #        self.networkCanvas.updateCanvas() 
    11561158    #        self.networkCanvas.circles = [] 
    1157                  
     1159 
    11581160        def graph_layout_pivot_mds(self): 
    11591161            self.information() 
    1160              
     1162 
    11611163            if self.items_matrix is None: 
    11621164                self.information('Set distance matrix to input signal') 
    11631165                return 
    1164              
     1166 
    11651167            if self.graph_base is None: 
    11661168                self.information('No network found') 
    11671169                return 
    1168              
     1170 
    11691171            if self.items_matrix.dim != self.graph_base.number_of_nodes(): 
    11701172                self.error('The number of vertices does not match matrix size.') 
    11711173                return 
    1172              
     1174 
    11731175            self.frSteps = min(self.frSteps, self.graph.number_of_nodes()) 
    11741176            qApp.processEvents() 
    1175              
     1177 
    11761178            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
    11771179                matrix = self.items_matrix 
    11781180            else: 
    11791181                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
    1180              
     1182 
    11811183            mds = orngMDS.PivotMDS(matrix, self.frSteps) 
    1182             x,y = mds.optimize() 
     1184            x, y = mds.optimize() 
    11831185            xy = zip(list(x), list(y)) 
    11841186            coors = dict(zip(sorted(self.graph.nodes()), xy)) 
    11851187            self.networkCanvas.networkCurve.set_node_coordinates(coors) 
    11861188            self.networkCanvas.update_canvas() 
    1187      
     1189 
    11881190        ####################################################################### 
    11891191        ### Network Visualization                                           ### 
    11901192        ####################################################################### 
    1191              
     1193 
    11921194        def _set_colors(self): 
    11931195            dlg = self._create_color_dialog(self.colorSettings, self.selectedSchemaIndex) 
     
    11971199                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    11981200                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    1199                  
     1201 
    12001202                self.set_node_colors() 
    1201                  
     1203 
    12021204        def _set_edge_color_palette(self): 
    12031205            dlg = self._create_color_dialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     
    12071209                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    12081210                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    1209                  
     1211 
    12101212                self.set_edge_colors() 
    1211          
     1213 
    12121214        def _create_color_dialog(self, colorSettings, selectedSchemaIndex): 
    12131215            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
     
    12161218            c.setColorSchemas(colorSettings, selectedSchemaIndex) 
    12171219            return c 
    1218          
     1220 
    12191221        def _clicked_att_lstbox(self): 
    12201222            if self.graph is None: 
    12211223                return 
    1222              
     1224 
    12231225            self.lastLabelColumns = [self.attributes[i][0] for i in self.markerAttributes] 
    12241226            self.networkCanvas.set_node_labels(self.lastLabelColumns) 
    12251227            self.networkCanvas.replot() 
    1226        
     1228 
    12271229        def _clicked_tooltip_lstbox(self): 
    12281230            if self.graph is None: 
    12291231                return 
    1230              
     1232 
    12311233            self.lastTooltipColumns = [self.attributes[i][0] for i in self.tooltipAttributes] 
    12321234            self.networkCanvas.set_tooltip_attributes(self.lastTooltipColumns) 
    12331235            self.networkCanvas.replot() 
    1234              
     1236 
    12351237        def _clicked_edge_label_listbox(self): 
    12361238            if self.graph is None: 
    12371239                return 
    1238              
     1240 
    12391241            self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
    12401242            self.networkCanvas.set_edge_labels(self.lastEdgeLabelAttributes) 
    12411243            self.networkCanvas.replot() 
    1242      
     1244 
    12431245        def set_node_colors(self): 
    12441246            if self.graph is None: 
    12451247                return 
    1246              
     1248 
    12471249            self.networkCanvas.set_node_colors(self.colorCombo.currentText()) 
    12481250            self.lastColorColumn = self.colorCombo.currentText() 
    1249              
     1251 
    12501252        def set_edge_colors(self): 
    12511253            if self.graph is None: 
    12521254                return 
    1253              
     1255 
    12541256            self.networkCanvas.set_edge_colors(self.edgeColorCombo.currentText()) 
    12551257            self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    1256                        
     1258 
    12571259        def set_edge_sizes(self): 
    12581260            if self.graph is None: 
    12591261                return 
    1260              
     1262 
    12611263            self.networkCanvas.networkCurve.set_edge_sizes(self.maxLinkSize) 
    12621264            self.networkCanvas.replot() 
    1263          
     1265 
    12641266        def set_node_sizes(self): 
    12651267            if self.graph is None or self.networkCanvas is None: 
    12661268                return 
    1267              
     1269 
    12681270            if self.minVertexSize > self.maxVertexSize: 
    12691271                self.maxVertexSize = self.minVertexSize 
    1270              
     1272 
    12711273            items = self.graph_base.items() 
    1272              
     1274 
    12731275            if items is None: 
    12741276                self.networkCanvas.networkCurve.set_node_sizes({}, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
    12751277                return 
    1276              
     1278 
    12771279            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    12781280            column = str(self.vertexSizeCombo.currentText()) 
    1279              
     1281 
    12801282            values = {} 
    12811283            if column in items.domain or (column.startswith("num of ") and column.replace("num of ", "") in items.domain): 
     
    12841286                else: 
    12851287                    values = dict((x, len(items[x][column.replace("num of ", "")].value.split(','))) for x in self.graph) 
    1286              
     1288 
    12871289            if len(values) == 0: 
    12881290                values = dict((node, 1.) for node in self.graph) 
    1289                  
     1291 
    12901292            if self.invertSize: 
    12911293                maxval = max(values.itervalues()) 
    1292                 values.update((key, maxval-val) for key, val in values.iteritems()) 
     1294                values.update((key, maxval - val) for key, val in values.iteritems()) 
    12931295                self.networkCanvas.networkCurve.set_node_sizes(values, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
    12941296            else: 
    12951297                self.networkCanvas.networkCurve.set_node_sizes(values, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
    1296              
     1298 
    12971299            self.networkCanvas.replot() 
    1298              
     1300 
    12991301        def set_font(self): 
    13001302            if self.networkCanvas is None: 
    13011303                return 
    1302              
     1304 
    13031305            weights = {0: 50, 1: 80} 
    1304              
     1306 
    13051307            font = self.networkCanvas.font() 
    13061308            font.setPointSize(self.fontSize) 
     
    13081310            self.networkCanvas.setFont(font) 
    13091311            self.networkCanvas.fontSize = font 
    1310             self.networkCanvas.set_node_labels()  
    1311                      
     1312            self.networkCanvas.set_node_labels() 
     1313 
    13121314        def sendReport(self): 
    13131315            self.reportSettings("Graph data", 
     
    13281330                                 ("Iterations", self.frSteps)]) 
    13291331            self.reportSection("Graph") 
    1330             self.reportImage(self.networkCanvas.saveToFileDirect)         
    1331          
     1332            self.reportImage(self.networkCanvas.saveToFileDirect) 
     1333 
    13321334        ####################################################################### 
    13331335        ### PROTOTYPE                                                       ###  
    13341336        ####################################################################### 
    1335          
     1337 
    13361338        def set_component_edge_width(self, changedMin=True): 
    13371339            if self.networkCanvas is None: 
    13381340                return 
    1339              
     1341 
    13401342            canvas = self.networkCanvas 
    13411343            if changedMin: 
     
    13451347                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
    13461348                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
    1347              
     1349 
    13481350            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    13491351            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    13501352            self.networkCanvas.updateCanvas() 
    1351          
     1353 
    13521354        def showComponents(self): 
    13531355            if self.graph is None or self.graph_base.items() is None: 
    13541356                return 
    1355              
     1357 
    13561358            vars = [x.name for x in self.graph_base.items_vars()] 
    1357              
     1359 
    13581360            if not self.showComponentCombo.currentText() in vars: 
    13591361                self.networkCanvas.showComponentAttribute = None 
    13601362                self.lastNameComponentAttribute = '' 
    13611363            else: 
    1362                 self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
    1363              
     1364                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText() 
     1365 
    13641366            self.networkCanvas.drawComponentKeywords() 
    1365              
     1367 
    13661368        def nameComponents(self): 
    13671369            """Names connected components of genes according to GO terms.""" 
    13681370            self.progressBarFinished() 
    13691371            self.lastNameComponentAttribute = None 
    1370              
     1372 
    13711373            if self.graph is None or self.graph_base.items() is None: 
    13721374                return 
    1373              
     1375 
    13741376            vars = [x.name for x in self.graph_base.items_vars()] 
    13751377            if not self.nameComponentCombo.currentText() in vars: 
    13761378                return 
    1377              
     1379 
    13781380            self.progressBarInit() 
    13791381            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     
    13811383                keyword_table = self.graph_base.items() 
    13821384            else: 
    1383                 keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    1384                  
    1385             import obiGO  
    1386             ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
     1385                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
     1386 
     1387            import obiGO 
     1388            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet) 
    13871389            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    1388      
     1390 
    13891391            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    13901392            foundGenesets = False 
    13911393            if len(annotations.geneNames & allGenes) < 1: 
    13921394                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    1393                 if len(annotations.geneNames & allGenes) < 1:             
     1395                if len(annotations.geneNames & allGenes) < 1: 
    13941396                    self.warning('no genes found') 
    13951397                    return 
    13961398                else: 
    13971399                    foundGenesets = True 
    1398                  
    1399             def rank(a, j, reverse=False):                     
     1400 
     1401            def rank(a, j, reverse=False): 
    14001402                if len(a) <= 0: return 
    1401                  
    1402                 if reverse:                 
     1403 
     1404                if reverse: 
    14031405                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
    14041406                    top_value = a[0][j] 
     
    14081410                    for k in range(len(a)): 
    14091411                        if top_value < a[k][j]: 
    1410                             top_value = a[k][j]  
     1412                            top_value = a[k][j] 
    14111413                            if k - int_ndx > 1: 
    1412                                 avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1414                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    14131415                                for l in range(int_ndx, k): 
    14141416                                    a[l][j] = avg_rank 
    1415                              
     1417 
    14161418                            int_ndx = k 
    1417      
     1419 
    14181420                        a[k][j] = top_rank / max_rank 
    14191421                        top_rank -= 1 
    1420                      
     1422 
    14211423                    k += 1 
    14221424                    if k - int_ndx > 1: 
    1423                         avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1425                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    14241426                        for l in range(int_ndx, k): 
    1425                             a[l][j] = avg_rank     
    1426                      
     1427                            a[l][j] = avg_rank 
     1428 
    14271429                else: 
    14281430                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
     
    14331435                    for k in range(len(a)): 
    14341436                        if top_value > a[k][j]: 
    1435                             top_value = a[k][j]  
     1437                            top_value = a[k][j] 
    14361438                            if k - int_ndx > 1: 
    1437                                 avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1439                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    14381440                                for l in range(int_ndx, k): 
    14391441                                    a[l][j] = avg_rank 
    1440                              
     1442 
    14411443                            int_ndx = k 
    1442      
     1444 
    14431445                        a[k][j] = top_rank / max_rank 
    14441446                        top_rank -= 1 
    1445                      
     1447 
    14461448                    k += 1 
    14471449                    if k - int_ndx > 1: 
    1448                         avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     1450                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    14491451                        for l in range(int_ndx, k): 
    14501452                            a[l][j] = avg_rank 
    1451              
     1453 
    14521454            for i in range(len(components)): 
    14531455                component = components[i] 
    14541456                if len(component) <= 1: 
    14551457                    continue 
    1456                  
     1458 
    14571459                if foundGenesets: 
    14581460                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    14591461                else: 
    14601462                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    1461                          
     1463 
    14621464                res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    14631465                res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
     
    14651467                #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] 
    14661468                #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] 
    1467                  
     1469 
    14681470                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] 
    14691471                if len(namingScore) == 0: 
    14701472                    continue 
    1471                  
     1473 
    14721474                annotated_genes = max([a[0] for a in namingScore]) 
    1473                  
     1475 
    14741476                rank(namingScore, 1, reverse=True) 
    14751477                rank(namingScore, 2, reverse=True) 
    14761478                rank(namingScore, 0) 
    1477                  
     1479 
    14781480                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] 
    14791481                namingScore.sort(reverse=True) 
    1480                  
     1482 
    14811483                if len(namingScore) < 1: 
    14821484                    print "warning. no annotations found for group of genes: " + ", ".join(genes) 
     
    14851487                    print "warning. error computing score for group of genes: " + ", ".join(genes) 
    14861488                    continue 
    1487                  
     1489 
    14881490                for v in component: 
    14891491                    name = str(namingScore[0][1]) 
     
    14931495                        info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
    14941496                    keyword_table[v]['component name'] = name + info 
    1495                  
    1496                 self.progressBarSet(i*100.0/len(components)) 
    1497                      
     1497 
     1498                self.progressBarSet(i * 100.0 / len(components)) 
     1499 
    14981500            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    14991501            self.set_items(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    1500             self.progressBarFinished()    
    1501      
    1502          
     1502            self.progressBarFinished() 
     1503 
     1504 
    15031505        def setAutoSendAttributes(self): 
    15041506            print 'TODO setAutoSendAttributes' 
     
    15071509            #else: 
    15081510            #    self.networkCanvas.callbackSelectVertex = None 
    1509      
     1511 
    15101512        def sendAttSelectionList(self): 
    15111513            if not self.graph is None: 
     
    15151517                att = str(self.comboAttSelection.currentText()) 
    15161518                vertices = self.networkCanvas.selected_nodes() 
    1517                  
     1519 
    15181520                if len(vertices) != 1: 
    15191521                    return 
    1520                  
     1522 
    15211523                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    15221524            else: 
    15231525                attributes = None 
    15241526            self.send("Features", attributes) 
    1525          
    1526              
     1527 
     1528 
    15271529except ImportError as err: 
    15281530    try: 
     
    15301532    except: 
    15311533        # if Qwt is also not installed throw could not import orangeqt error 
    1532         raise err  
    1533      
    1534      
     1534        raise err 
     1535 
     1536 
    15351537    dir = os.path.dirname(__file__) + "/../icons/" 
    15361538    dlg_mark2sel = dir + "Dlg_Mark2Sel.png" 
     
    15411543    dlg_showall = dir + "Dlg_clear.png" 
    15421544 
    1543      
     1545 
    15441546    class OWNxExplorer(OWWidget): 
    15451547        settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
     
    15471549        "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", 
    15481550        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    1549         "showWeights", "showIndexes",  "showEdgeLabels", "colorSettings",  
     1551        "showWeights", "showIndexes", "showEdgeLabels", "colorSettings", 
    15501552        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
    15511553        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
    1552         "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
     1554        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism", "showTextMiningInfo", 
    15531555        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
    1554         "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"]  
    1555          
    1556         def __init__(self, parent=None, signalManager=None, name = 'Net Explorer (Qwt)',  
     1556        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"] 
     1557 
     1558        def __init__(self, parent=None, signalManager=None, name='Net Explorer (Qwt)', 
    15571559                     NetworkCanvas=OWNxCanvas): 
    15581560            OWWidget.__init__(self, parent, signalManager, name) 
     
    15611563                           ("Nx View", Orange.network.NxView, self.set_network_view), 
    15621564                           ("Items", Orange.data.Table, self.setItems), 
    1563                            ("Marked Items", Orange.data.Table, self.markItems),  
    1564                            ("Item Subset", Orange.data.Table, self.setExampleSubset),  
     1565                           ("Marked Items", Orange.data.Table, self.markItems), 
     1566                           ("Item Subset", Orange.data.Table, self.setExampleSubset), 
    15651567                           ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
    1566              
     1568 
    15671569            self.outputs = [("Selected Network", Orange.network.Graph), 
    15681570                            ("Distance Matrix", Orange.core.SymMatrix), 
    1569                             ("Selected Items", Orange.data.Table),  
    1570                             ("Other Items", Orange.data.Table),  
     1571                            ("Selected Items", Orange.data.Table), 
     1572                            ("Other Items", Orange.data.Table), 
    15711573                            ("Marked Items", Orange.data.Table), 
    15721574                            ("Features", AttributeList)] 
    1573              
     1575 
    15741576            self.markerAttributes = [] 
    15751577            self.tooltipAttributes = [] 
     
    15791581            self.autoSendSelection = False 
    15801582            self.graphShowGrid = 1  # show gridlines in the graph 
    1581              
     1583 
    15821584            self.markNConnections = 2 
    15831585            self.markNumber = 0 
     
    16301632            self.number_of_nodes_label = -1 
    16311633            self.number_of_edges_label = -1 
    1632              
     1634 
    16331635            self.checkSendMarkedNodes = True 
    16341636            self.checkSendSelectedNodes = True 
    1635              
     1637 
    16361638            self.loadSettings() 
    1637              
     1639 
    16381640            self._network_view = None 
    16391641            self.layout = Orange.network.GraphLayout() 
     
    16411643            self.graph_base = None 
    16421644            self.markInputItems = None 
    1643              
    1644             self.mainArea.layout().setContentsMargins(0,4,4,4) 
    1645             self.controlArea.layout().setContentsMargins(4,4,0,4) 
    1646              
     1645 
     1646            self.mainArea.layout().setContentsMargins(0, 4, 4, 4) 
     1647            self.controlArea.layout().setContentsMargins(4, 4, 0, 4) 
     1648 
    16471649            self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
    16481650            self.networkCanvas.showMissingValues = self.showMissingValues 
    16491651            self.mainArea.layout().addWidget(self.networkCanvas) 
    1650              
     1652 
    16511653            self.networkCanvas.maxLinkSize = self.maxLinkSize 
    16521654            self.networkCanvas.minVertexSize = self.minVertexSize 
    16531655            self.networkCanvas.maxVertexSize = self.maxVertexSize 
    1654              
     1656 
    16551657            self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal') 
    1656              
     1658 
    16571659            self.tabs = OWGUI.tabWidget(self.hcontroArea) 
    1658              
     1660 
    16591661            self.verticesTab = OWGUI.createTabPage(self.tabs, "Vertices") 
    16601662            self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges") 
     
    16621664            self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
    16631665            #self.editTab = OWGUI.createTabPage(self.tabs, "Edit") 
    1664              
     1666 
    16651667            self.tabs.setCurrentIndex(self.tabIndex) 
    16661668            self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index)) 
    1667              
     1669 
    16681670            self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False) 
    1669              
     1671 
    16701672            self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method) 
    16711673            self.optCombo.addItem("No optimization") 
     
    16811683            self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
    16821684            self.stepsSpin.setEnabled(False) 
    1683              
     1685 
    16841686            self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1) 
    1685              
    1686             colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace = False) 
     1687 
     1688            colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace=False) 
    16871689            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.setVertexColor) 
    16881690            self.colorCombo.addItem("(same color)") 
    1689             OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip = "Set vertex color palette", debuggingEnabled = 0) 
    1690              
    1691             self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box = "Vertex size attribute", callback=self.setVertexSize) 
     1691            OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip="Set vertex color palette", debuggingEnabled=0) 
     1692 
     1693            self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box="Vertex size attribute", callback=self.setVertexSize) 
    16921694            self.vertexSizeCombo.addItem("(none)") 
    1693              
     1695 
    16941696            OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize) 
    16951697            OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize) 
    1696             OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback = self.setVertexSize) 
    1697              
    1698             colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace = False) 
     1698            OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback=self.setVertexSize) 
     1699 
     1700            colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace=False) 
    16991701            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.setEdgeColor) 
    17001702            self.edgeColorCombo.addItem("(same color)") 
    1701             OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip = "Set edge color palette", debuggingEnabled = 0) 
    1702              
    1703             self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace = False) 
    1704             OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback = self.setFontSize) 
    1705              
    1706             self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False) 
     1703            OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip="Set edge color palette", debuggingEnabled=0) 
     1704 
     1705            self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace=False) 
     1706            OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback=self.setFontSize) 
     1707 
     1708            self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace=False) 
    17071709            self.attListBox = OWGUI.listBox(self.attBox, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
    17081710            self.tooltipListBox = OWGUI.listBox(self.attBox, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox) 
    1709              
    1710             self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False) 
     1711 
     1712            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace=False) 
    17111713            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox) 
    17121714            self.edgeLabelBox.setEnabled(False) 
    1713              
     1715 
    17141716            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
    17151717            OWGUI.checkBox(ib, self, 'showWeights', 'Show weights', callback=(lambda: self._set_canvas_attr('showWeights', self.showWeights))) 
    17161718            OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
    1717             OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.setMaxLinkSize) 
     1719            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback=self.setMaxLinkSize) 
    17181720            self.showDistancesCheckBox = OWGUI.checkBox(ib, self, 'showDistances', 'Explore vertex distances', callback=(lambda: self._set_canvas_attr('showDistances', self.showDistances)), disabled=1) 
    1719              
     1721 
    17201722            ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
    17211723            OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes))) 
     
    17241726            self.insideView = 0 
    17251727            self.insideViewNeighbours = 2 
    1726             OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked = "insideView", checkCallback = self.insideview, callback = self.insideviewneighbours) 
     1728            OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked="insideView", checkCallback=self.insideview, callback=self.insideviewneighbours) 
    17271729            OWGUI.checkBox(ib, self, 'showMissingValues', 'Show missing values', callback=(lambda: self._set_canvas_attr('showMissingValues', self.showMissingValues))) 
    1728              
     1730 
    17291731            ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical") 
    17301732            OWGUI.label(ib, self, "Vertices (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)") 
    17311733            OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i") 
    1732              
    1733             ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setMarkMode) 
    1734             OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.setMarkMode) 
    1735             OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback = self.setMarkMode) 
     1734 
     1735            ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback=self.setMarkMode) 
     1736            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback=self.setMarkMode) 
     1737            OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback=self.setMarkMode) 
    17361738            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
    17371739            self.searchStringTimer = QTimer(self) 
    17381740            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode) 
    1739              
    1740             OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback = self.setMarkMode) 
    1741             OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback = self.setMarkMode) 
    1742             ib = OWGUI.indentedBox(ribg, orientation = 0) 
     1741 
     1742            OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback=self.setMarkMode) 
     1743            OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback=self.setMarkMode) 
     1744            ib = OWGUI.indentedBox(ribg, orientation=0) 
    17431745            self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h))) 
    17441746            #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
    17451747            OWGUI.widgetLabel(ribg, "Mark  vertices with ...") 
    1746             OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.setMarkMode) 
    1747             OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.setMarkMode) 
     1748            OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback=self.setMarkMode) 
     1749            OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback=self.setMarkMode) 
    17481750            self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h))) 
    1749             OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.setMarkMode) 
    1750             OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.setMarkMode) 
    1751             OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.setMarkMode) 
     1751            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback=self.setMarkMode) 
     1752            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback=self.setMarkMode) 
     1753            OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback=self.setMarkMode) 
    17521754            ib = OWGUI.indentedBox(ribg) 
    17531755            self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h))) 
    17541756            OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)") 
    1755             self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback = self.setMarkMode) 
     1757            self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback=self.setMarkMode) 
    17561758            ib = OWGUI.indentedBox(ribg) 
    17571759            self.markInput = 0 
    17581760            self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h))) 
    17591761            self.markInputRadioButton.setEnabled(False) 
    1760              
     1762 
    17611763            ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
    1762             OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback = self.setSendMarkedNodes, disabled=0) 
    1763              
     1764            OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback=self.setSendMarkedNodes, disabled=0) 
     1765 
    17641766            T = OWToolbars.NavigateSelectToolbar 
    17651767            self.zoomSelectToolbar = T(self, self.hcontroArea, self.networkCanvas, self.autoSendSelection, 
    1766                                       buttons = (T.IconZoom,  
    1767                                                  T.IconZoomExtent,  
    1768                                                  T.IconZoomSelection,  
    1769                                                  T.IconPan,  
     1768                                      buttons=(T.IconZoom, 
     1769                                                 T.IconZoomExtent, 
     1770                                                 T.IconZoomSelection, 
     1771                                                 T.IconPan, 
    17701772                                                 ("", "", "", None, None, 0), 
    17711773                                                 #("Move selection", "buttonMoveSelection", "activateMoveSelection", QIcon(OWToolbars.dlg_select), Qt.ArrowCursor, 1), 
    1772                                                  T.IconRectangle,  
     1774                                                 T.IconRectangle, 
    17731775                                                 #T.IconPolygon,   
    17741776                                                 T.IconSendSelection, 
     
    17811783                                                 ("Hide unselected", "buttonUN", "hideUnSelectedVertices", QIcon(dlg_unselected), Qt.ArrowCursor, 0), 
    17821784                                                 ("Show all nodes", "buttonSW", "showAllVertices", QIcon(dlg_showall), Qt.ArrowCursor, 0))) 
    1783                              
     1785 
    17841786            OWGUI.rubber(self.zoomSelectToolbar) 
    1785              
     1787 
    17861788            ib = OWGUI.widgetBox(self.infoTab, "General") 
    17871789            OWGUI.label(ib, self, "Number of vertices: %(number_of_nodes_label)i") 
     
    17911793            OWGUI.label(ib, self, "Diameter: %(diameter)i") 
    17921794            OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%") 
    1793              
     1795 
    17941796            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
    1795              
     1797 
    17961798            OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False) 
    17971799            OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False) 
    17981800            OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
    1799              
     1801 
    18001802            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
    1801              
     1803 
    18021804            ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
    1803              
     1805 
    18041806            #ib = OWGUI.widgetBox(ibProto, "Name components") 
    18051807            OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
    1806              
     1808 
    18071809            self.nameComponentAttribute = 0 
    18081810            self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal") 
    18091811            self.nameComponentCombo.addItem("Select attribute") 
    1810              
     1812 
    18111813            self.showComponentAttribute = 0 
    18121814            self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal") 
    18131815            self.showComponentCombo.addItem("Select attribute") 
    18141816            OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info") 
    1815              
     1817 
    18161818            #ib = OWGUI.widgetBox(ibProto, "Distance Matrix") 
    18171819            ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     
    18321834            OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage") 
    18331835            OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions") 
    1834             self.mdsInfoA=OWGUI.widgetLabel(ib, "Avg. stress:") 
    1835             self.mdsInfoB=OWGUI.widgetLabel(ib, "Num. steps:") 
     1836            self.mdsInfoA = OWGUI.widgetLabel(ib, "Avg. stress:") 
     1837            self.mdsInfoB = OWGUI.widgetLabel(ib, "Num. steps:") 
    18361838            self.rotateSteps = 100 
    1837              
     1839 
    18381840            OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
    18391841            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
    18401842            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
    1841              
     1843 
    18421844            self.attSelectionAttribute = 0 
    18431845            self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList) 
     
    18451847            self.autoSendAttributes = 0 
    18461848            OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes) 
    1847              
     1849 
    18481850            self.icons = self.createAttributeIconDict() 
    18491851            self.setMarkMode() 
    1850              
     1852 
    18511853            self.editAttribute = 0 
    18521854            self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
     
    18551857            OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal') 
    18561858            OWGUI.button(self.infoTab, self, "Edit", callback=self.edit) 
    1857              
     1859 
    18581860            self.verticesTab.layout().addStretch(1) 
    18591861            self.edgesTab.layout().addStretch(1) 
    18601862            self.markTab.layout().addStretch(1) 
    18611863            self.infoTab.layout().addStretch(1) 
    1862              
     1864 
    18631865            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    18641866            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    18651867            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    1866              
     1868 
    18671869            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    18681870            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    18691871            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    1870              
     1872 
    18711873            self.graph_layout_method() 
    18721874            self.setFontSize() 
    18731875            self.set_graph(None) 
    18741876            self.setMinimumWidth(900) 
    1875              
    1876              
    1877              
     1877 
     1878 
     1879 
    18781880            #self.resize(1000, 600) 
    18791881            #self.controlArea.setEnabled(False) 
    1880              
     1882 
    18811883        def setComponentEdgeWidth(self, changedMin=True): 
    18821884            if self.networkCanvas is None: 
    18831885                return 
    1884              
     1886 
    18851887            canvas = self.networkCanvas 
    18861888            if changedMin: 
     
    18901892                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
    18911893                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
    1892              
     1894 
    18931895            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    18941896            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    18951897            self.networkCanvas.updateCanvas() 
    1896          
     1898 
    18971899        def setAutoSendAttributes(self): 
    18981900            print 'TODO setAutoSendAttributes' 
     
    19011903            #else: 
    19021904            #    self.networkCanvas.callbackSelectVertex = None 
    1903      
     1905 
    19041906        def sendAttSelectionList(self): 
    19051907            if not self.graph is None: 
     
    19091911                att = str(self.comboAttSelection.currentText()) 
    19101912                vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    1911                  
     1913 
    19121914                if len(vertices) != 1: 
    19131915                    return 
    1914                  
     1916 
    19151917                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    19161918            else: 
    19171919                attributes = None 
    19181920            self.send("Features", attributes) 
    1919              
     1921 
    19201922        def edit(self): 
    19211923            if self.graph is None: 
    19221924                return 
    1923              
     1925 
    19241926            vars = [x.name for x in self.graph_base.items_vars()] 
    19251927            if not self.editCombo.currentText() in vars: 
     
    19271929            att = str(self.editCombo.currentText()) 
    19281930            vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    1929              
     1931 
    19301932            if len(vertices) == 0: 
    19311933                return 
    1932              
     1934 
    19331935            if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous: 
    19341936                for v in vertices: 
     
    19371939                for v in vertices: 
    19381940                    self.graph_base.items()[v][att] = str(self.editValue) 
    1939              
     1941 
    19401942            self.setItems(self.graph_base.items()) 
    1941              
     1943 
    19421944        def drawForce(self): 
    19431945            if self.btnForce.isChecked() and self.graph is not None: 
    1944                 self.networkCanvas.forceVectors = self.layout._computeForces()  
     1946                self.networkCanvas.forceVectors = self.layout._computeForces() 
    19451947            else: 
    19461948                self.networkCanvas.forceVectors = None 
    1947                  
     1949 
    19481950            self.networkCanvas.updateCanvas() 
    1949              
     1951 
    19501952        def rotateProgress(self, curr, max): 
    19511953            self.progressBarSet(int(curr * 100 / max)) 
    19521954            qApp.processEvents() 
    1953              
     1955 
    19541956        def rotateComponentsMDS(self): 
    19551957            print "rotate" 
     
    19581960                self.btnRotateMDS.setChecked(False) 
    19591961                return 
    1960              
     1962 
    19611963            if self.graph is None: 
    19621964                self.information('No network found') 
     
    19671969                self.btnRotateMDS.setChecked(False) 
    19681970                return 
    1969              
     1971 
    19701972            if not self.btnRotateMDS.isChecked(): 
    19711973              self.layout.stopMDS = 1 
     
    19731975              #self.btnMDS.setText("MDS on graph components") 
    19741976              return 
    1975              
     1977 
    19761978            self.btnRotateMDS.setText("Stop") 
    19771979            qApp.processEvents() 
    1978              
     1980 
    19791981            self.layout.items_matrix = self.items_matrix 
    19801982            self.progressBarInit() 
    1981              
    1982             self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)             
    1983                  
     1983 
     1984            self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos) 
     1985 
    19841986            self.btnRotateMDS.setChecked(False) 
    19851987            self.btnRotateMDS.setText("Rotate graph components (MDS)") 
    19861988            self.progressBarFinished() 
    1987          
     1989 
    19881990        def rotateComponents(self): 
    19891991            if self.items_matrix is None: 
     
    19911993                self.btnRotate.setChecked(False) 
    19921994                return 
    1993              
     1995 
    19941996            if self.graph is None: 
    19951997                self.information('No network found') 
    19961998                self.btnRotate.setChecked(False) 
    19971999                return 
    1998              
     2000 
    19992001            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    20002002                self.error('Distance matrix dimensionality must equal number of vertices') 
    20012003                self.btnRotate.setChecked(False) 
    20022004                return 
    2003              
     2005 
    20042006            if not self.btnRotate.isChecked(): 
    20052007              self.layout.stopRotate = 1 
    20062008              return 
    2007            
     2009 
    20082010            self.btnRotate.setText("Stop") 
    20092011            qApp.processEvents() 
    2010              
     2012 
    20112013            self.layout.items_matrix = self.items_matrix 
    20122014            self.progressBarInit() 
     
    20152017            self.btnRotate.setText("Rotate graph components") 
    20162018            self.progressBarFinished() 
    2017              
    2018         def mdsProgress(self, avgStress, stepCount):     
     2019 
     2020        def mdsProgress(self, avgStress, stepCount): 
    20192021            self.drawForce() 
    2020      
     2022 
    20212023            self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
    20222024            self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
    20232025            self.progressBarSet(int(stepCount * 100 / self.mdsSteps)) 
    20242026            qApp.processEvents() 
    2025              
     2027 
    20262028        def mds_components(self, mdsType=Orange.network.MdsType.componentMDS): 
    20272029            if mdsType == Orange.network.MdsType.componentMDS: 
     
    20312033            elif mdsType == Orange.network.MdsType.MDS: 
    20322034                btn = self.btnMDSv 
    2033              
     2035 
    20342036            btnCaption = btn.text() 
    2035              
     2037 
    20362038            if self.items_matrix is None: 
    20372039                self.information('Set distance matrix to input signal') 
    20382040                btn.setChecked(False) 
    20392041                return 
    2040              
     2042 
    20412043            if self.layout is None: 
    20422044                self.information('No network found') 
    20432045                btn.setChecked(False) 
    20442046                return 
    2045              
     2047 
    20462048            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    20472049                self.error('Distance matrix dimensionality must equal number of vertices') 
    20482050                btn.setChecked(False) 
    20492051                return 
    2050              
     2052 
    20512053            if not btn.isChecked(): 
    20522054                self.layout.stopMDS = 1 
     
    20542056                btn.setText(btnCaption) 
    20552057                return 
    2056              
     2058 
    20572059            btn.setText("Stop") 
    20582060            qApp.processEvents() 
    2059              
     2061 
    20602062            self.layout.items_matrix = self.items_matrix 
    20612063            self.progressBarInit() 
    2062              
     2064 
    20632065            if self.mdsAvgLinkage: 
    2064                 self.layout.mds_components_avg_linkage(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, scalingRatio = self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
     2066                self.layout.mds_components_avg_linkage(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
    20652067            else: 
    2066                 self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, mdsType=mdsType, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos)             
    2067              
     2068                self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, mdsType=mdsType, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
     2069 
    20682070            btn.setChecked(False) 
    20692071            btn.setText(btnCaption) 
    20702072            self.progressBarFinished() 
    2071              
     2073 
    20722074        def set_items_distance_matrix(self, matrix): 
    20732075            self.error('') 
    20742076            self.information('') 
    20752077            self.showDistancesCheckBox.setEnabled(0) 
    2076              
     2078 
    20772079            if matrix is None or self.graph is None: 
    20782080                self.items_matrix = None 
     
    20802082                if self.networkCanvas: self.networkCanvas.items_matrix = None 
    20812083                return 
    2082      
     2084 
    20832085            if matrix.dim != self.graph.number_of_nodes(): 
    20842086                self.error('Distance matrix dimensionality must equal number of vertices') 
     
    20872089                if self.networkCanvas: self.networkCanvas.items_matrix = None 
    20882090                return 
    2089              
     2091 
    20902092            self.items_matrix = matrix 
    20912093            self.layout.items_matrix = matrix 
    20922094            if self.networkCanvas: self.networkCanvas.items_matrix = matrix 
    20932095            self.showDistancesCheckBox.setEnabled(1) 
    2094              
     2096 
    20952097            self.networkCanvas.updateCanvas() 
    2096                  
     2098 
    20972099        def setSendMarkedNodes(self): 
    20982100            if self.checkSendMarkedNodes: 
     
    21022104                self.send("Marked Items", None) 
    21032105                self.networkCanvas.sendMarkedNodes = None 
    2104              
    2105         def sendMarkedNodes(self, markedNodes):         
     2106 
     2107        def sendMarkedNodes(self, markedNodes): 
    21062108            if len(markedNodes) == 0: 
    21072109                self.send("Marked Items", None) 
    21082110                return 
    2109              
     2111 
    21102112            if self.graph is not None and self.graph_base.items() is not None: 
    21112113                items = self.graph_base.items().getitems(markedNodes) 
    21122114                self.send("Marked Items", items) 
    21132115                return 
    2114              
     2116 
    21152117            self.send("Marked Items", None) 
    2116              
     2118 
    21172119        def insideviewneighbours(self): 
    21182120            if self.networkCanvas.insideview == 1: 
     
    21202122                self.optButton.setChecked(True) 
    21212123                self.graph_layout_fr(False) 
    2122              
     2124 
    21232125        def insideview(self): 
    21242126            print self.networkCanvas.getSelectedVertices() 
     
    21352137                    self.optButton.setChecked(True) 
    21362138                    self.graph_layout_fr(False) 
    2137          
     2139 
    21382140            else: 
    21392141                print "One node must be selected!" 
    2140              
     2142 
    21412143        def showComponents(self): 
    21422144            if self.graph is None or self.graph_base.items() is None: 
    21432145                return 
    2144              
     2146 
    21452147            vars = [x.name for x in self.graph_base.items_vars()] 
    2146              
     2148 
    21472149            if not self.showComponentCombo.currentText() in vars: 
    21482150                self.networkCanvas.showComponentAttribute = None 
    21492151                self.lastNameComponentAttribute = '' 
    21502152            else: 
    2151                 self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
    2152                  
     2153                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText() 
     2154 
    21532155            self.networkCanvas.drawPlotItems() 
    2154              
     2156 
    21552157        def nameComponents(self): 
    21562158            """Names connected components of genes according to GO terms.""" 
    21572159            self.progressBarFinished() 
    21582160            self.lastNameComponentAttribute = None 
    2159              
     2161 
    21602162            if self.graph is None or self.graph_base.items() is None: 
    21612163                return 
    2162              
     2164 
    21632165            vars = [x.name for x in self.graph_base.items_vars()] 
    21642166            if not self.nameComponentCombo.currentText() in vars: 
    21652167                return 
    2166              
     2168 
    21672169            self.progressBarInit() 
    21682170            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     
    21702172                keyword_table = self.graph_base.items() 
    21712173            else: 
    2172                 keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    2173              
    2174             import obiGO  
    2175             ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
     2174                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
     2175 
     2176            import obiGO 
     2177            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet) 
    21762178            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    2177      
     2179 
    21782180            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    21792181            foundGenesets = False 
    21802182            if len(annotations.geneNames & allGenes) < 1: 
    21812183                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    2182                 if len(annotations.geneNames & allGenes) < 1:             
     2184                if len(annotations.geneNames & allGenes) < 1: 
    21832185                    self.warning('no genes found') 
    21842186                    return 
    21852187                else: 
    21862188                    foundGenesets = True 
    2187                  
    2188             def rank(a, j, reverse=False):                     
     2189 
     2190            def rank(a, j, reverse=False): 
    21892191                if len(a) <= 0: return 
    2190                  
    2191                 if reverse:                 
     2192 
     2193                if reverse: 
    21922194                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
    21932195                    top_value = a[0][j] 
     
    21972199                    for k in range(len(a)): 
    21982200                        if top_value < a[k][j]: 
    2199                             top_value = a[k][j]  
     2201                            top_value = a[k][j] 
    22002202                            if k - int_ndx > 1: 
    2201                                 avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2203                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    22022204                                for l in range(int_ndx, k): 
    22032205                                    a[l][j] = avg_rank 
    2204                              
     2206 
    22052207                            int_ndx = k 
    2206      
     2208 
    22072209                        a[k][j] = top_rank / max_rank 
    22082210                        top_rank -= 1 
    2209                      
     2211 
    22102212                    k += 1 
    22112213                    if k - int_ndx > 1: 
    2212                         avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2214                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    22132215                        for l in range(int_ndx, k): 
    2214                             a[l][j] = avg_rank     
    2215                      
     2216                            a[l][j] = avg_rank 
     2217 
    22162218                else: 
    22172219                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
     
    22222224                    for k in range(len(a)): 
    22232225                        if top_value > a[k][j]: 
    2224                             top_value = a[k][j]  
     2226                            top_value = a[k][j] 
    22252227                            if k - int_ndx > 1: 
    2226                                 avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2228                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    22272229                                for l in range(int_ndx, k): 
    22282230                                    a[l][j] = avg_rank 
    2229                              
     2231 
    22302232                            int_ndx = k 
    2231      
     2233 
    22322234                        a[k][j] = top_rank / max_rank 
    22332235                        top_rank -= 1 
    2234                      
     2236 
    22352237                    k += 1 
    22362238                    if k - int_ndx > 1: 
    2237                         avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2239                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    22382240                        for l in range(int_ndx, k): 
    22392241                            a[l][j] = avg_rank 
    2240              
     2242 
    22412243            for i in range(len(components)): 
    22422244                component = components[i] 
    22432245                if len(component) <= 1: 
    22442246                    continue 
    2245                  
     2247 
    22462248                if foundGenesets: 
    22472249                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    22482250                else: 
    22492251                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    2250                          
     2252 
    22512253                res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    22522254                res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
     
    22542256                #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] 
    22552257                #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] 
    2256                  
     2258 
    22572259                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] 
    22582260                if len(namingScore) == 0: 
    22592261                    continue 
    2260                  
     2262 
    22612263                annotated_genes = max([a[0] for a in namingScore]) 
    2262                  
     2264 
    22632265                rank(namingScore, 1, reverse=True) 
    22642266                rank(namingScore, 2, reverse=True) 
    22652267                rank(namingScore, 0) 
    2266                  
     2268 
    22672269                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] 
    22682270                namingScore.sort(reverse=True) 
    2269                  
     2271 
    22702272                if len(namingScore) < 1: 
    22712273                    print "warning. no annotations found for group of genes: " + ", ".join(genes) 
     
    22742276                    print "warning. error computing score for group of genes: " + ", ".join(genes) 
    22752277                    continue 
    2276                  
     2278 
    22772279                for v in component: 
    22782280                    name = str(namingScore[0][1]) 
     
    22822284                        info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
    22832285                    keyword_table[v]['component name'] = name + info 
    2284                  
    2285                 self.progressBarSet(i*100.0/len(components)) 
    2286                      
     2286 
     2287                self.progressBarSet(i * 100.0 / len(components)) 
     2288 
    22872289            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    22882290            self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    2289             self.progressBarFinished()    
    2290              
     2291            self.progressBarFinished() 
     2292 
    22912293        def nameComponents_old(self): 
    22922294            if self.graph is None or self.graph_base.items() is None: 
    22932295                return 
    2294              
     2296 
    22952297            vars = [x.name for x in self.graph_base.items_vars()] 
    2296              
     2298 
    22972299            if not self.nameComponentCombo.currentText() in vars: 
    22982300                return 
    2299              
     2301 
    23002302            components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    2301             keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    2302              
     2303            keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
     2304 
    23032305            excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"] 
    23042306            excludePart = ["HSA"] 
    23052307            keywords = set() 
    23062308            sameKeywords = set() 
    2307              
     2309 
    23082310            for component in components: 
    23092311                words = [] 
     
    23112313                for vertex in component: 
    23122314                    values = [] 
    2313                     value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    2314                      
     2315                    value = str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     2316 
    23152317                    value = value.replace(" ", ",") 
    23162318                    value_top = value.split(",") 
    2317                      
     2319 
    23182320                    for value in value_top: 
    23192321                        if len(value) > 0: 
     
    23222324                            all_values.append(tmp) 
    23232325                            values.extend(tmp) 
    2324                                      
     2326 
    23252327                    values = [value.strip() for value in values if len(value) > 0] 
    23262328                    words.extend(values) 
    2327                      
    2328                      
     2329 
     2330 
    23292331                    #value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    23302332                    #value = value.replace(" ", "_") 
     
    23342336                    #print "values:", values 
    23352337                    #all_values.append(values) 
    2336                      
     2338 
    23372339                    #words.extend(values) 
    23382340                #print "all_values:", all_values 
    23392341                toExclude = [] 
    2340                  
     2342 
    23412343                words = [word for word in words if not word.upper() in excludeWord] 
    23422344                toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
    2343                  
     2345 
    23442346                for word in toExclude: 
    23452347                    try: 
     
    23482350                    except: 
    23492351                        pass 
    2350                  
     2352 
    23512353                counted_words = {} 
    23522354                for word in words: 
     
    23562358                    else: 
    23572359                        counted_words[word] = 1 
    2358                  
     2360 
    23592361                words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
    23602362                keyword = "" 
     
    23622364                max_count = 0 
    23632365                i = 0 
    2364                  
     2366 
    23652367                while i < len(words) and words[i][1] >= max_count: 
    23662368                    max_count = words[i][1] 
     
    23682370                    keyword_words.append(words[i][0]) 
    23692371                    i += 1 
    2370                  
     2372 
    23712373                if len(keyword_words) > 1: 
    23722374                    new_all_values = [] 
    23732375                    for values in all_values: 
    23742376                        new_values = [value for value in values if value in keyword_words] 
    2375                         new_all_values.append(new_values)  
    2376                           
     2377                        new_all_values.append(new_values) 
     2378 
    23772379                    #print new_all_values 
    23782380                    word_position = [] 
    2379                      
     2381 
    23802382                    for word in keyword_words: 
    23812383                        sum = 0 
     
    23832385                            if word in v: 
    23842386                                sum += v.index(word) 
    2385                                  
     2387 
    23862388                        word_position.append((word, sum)) 
    2387                       
     2389 
    23882390                    words = sorted(word_position, key=itemgetter(1)) 
    23892391                    #print "words:", words 
    23902392                    #print all_values 
    23912393                    #print new_all_values 
    2392                      
     2394 
    23932395                    keyword = "" 
    23942396                    for word in words: 
    23952397                        keyword += word[0] + " " 
    2396                          
     2398 
    23972399                keyword = keyword.strip() 
    2398                  
     2400 
    23992401                for vertex in component: 
    24002402                    keyword_table[vertex]['component name'] = keyword 
    2401                      
     2403 
    24022404                if keyword in keywords: 
    24032405                    sameKeywords.add(keyword) 
     
    24072409            sameComponents = [component for component in components if str(keyword_table[component[0]]['component name']) in sameKeywords] 
    24082410            #print "same components:", sameComponents 
    2409              
     2411 
    24102412            for component in sameComponents: 
    24112413                words = [] 
     
    24132415                for vertex in component: 
    24142416                    values = [] 
    2415                     value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    2416                      
     2417                    value = str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     2418 
    24172419                    value = value.replace(" ", ",") 
    24182420                    value_top = value.split(",") 
    2419                      
     2421 
    24202422                    for value in value_top: 
    24212423                        if len(value) > 0: 
     
    24242426                            all_values.append(tmp) 
    24252427                            values.extend(tmp) 
    2426                                      
     2428 
    24272429                    values = [value.strip() for value in values if len(value) > 0] 
    24282430                    words.extend(values) 
    2429                  
     2431 
    24302432                toExclude = [] 
    2431                  
     2433 
    24322434                words = [word for word in words if not word.upper() in excludeWord] 
    24332435                toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
    2434                  
     2436 
    24352437                for word in toExclude: 
    24362438                    try: 
     
    24392441                    except: 
    24402442                        pass 
    2441                  
     2443 
    24422444                counted_words = {} 
    24432445                for word in words: 
     
    24472449                    else: 
    24482450                        counted_words[word] = 1 
    2449                  
     2451 
    24502452                words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
    24512453                keyword = "" 
    2452                 counts = [int(word[1]) for word in words]  
     2454                counts = [int(word[1]) for word in words] 
    24532455                max_count = max(counts) 
    2454                  
     2456 
    24552457                try: 
    24562458                    while True and len(counts) > 1: 
     
    24652467                    keyword_words.append(words[i][0]) 
    24662468                    i += 1 
    2467                      
     2469 
    24682470                if len(keyword_words) > 1: 
    24692471                    new_all_values = [] 
    24702472                    for values in all_values: 
    24712473                        new_values = [value for value in values if value in keyword_words] 
    2472                         new_all_values.append(new_values)  
    2473                           
     2474                        new_all_values.append(new_values) 
     2475 
    24742476                    #print new_all_values 
    24752477                    word_position = [] 
    2476                      
     2478 
    24772479                    for word in keyword_words: 
    24782480                        sum = 0 
     
    24802482                            if word in v: 
    24812483                                sum += v.index(word) 
    2482                                  
     2484 
    24832485                        word_position.append((word, sum)) 
    2484                       
     2486 
    24852487                    words = sorted(word_position, key=itemgetter(1)) 
    24862488                    #print "words:", words 
    24872489                    #print all_values 
    24882490                    #print new_all_values 
    2489                      
     2491 
    24902492                    keyword = "" 
    24912493                    for word in words: 
    24922494                        keyword += word[0] + " " 
    2493                       
     2495 
    24942496                keyword = keyword.strip() 
    24952497                for vertex in component: 
    24962498                    keyword_table[vertex]['component name'] = keyword 
    2497              
     2499 
    24982500            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    24992501            #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute 
    25002502            items = Orange.data.Table([self.graph_base.items(), keyword_table]) 
    25012503            self.setItems(items) 
    2502              
     2504 
    25032505            #for item in items: 
    25042506            #    print item 
    2505                              
     2507 
    25062508        def _set_canvas_attr(self, attr, value): 
    25072509            setattr(self.networkCanvas, attr, value) 
    25082510            self.networkCanvas.updateCanvas() 
    2509                      
     2511 
    25102512        def setSearchStringTimer(self): 
    25112513            self.hubs = 1 
    25122514            self.searchStringTimer.stop() 
    25132515            self.searchStringTimer.start(1000) 
    2514               
    2515         def setMarkMode(self, i = None): 
     2516 
     2517        def setMarkMode(self, i=None): 
    25162518            self.searchStringTimer.stop() 
    25172519            if not i is None: 
    25182520                self.hubs = i 
    2519              
     2521 
    25202522            #print self.hubs 
    25212523            self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0 
    25222524            self.networkCanvas.markWithRed = False 
    2523      
     2525 
    25242526            if self.graph is None: 
    25252527                return 
    2526              
     2528 
    25272529            hubs = self.hubs 
    25282530            if hubs == 0: 
     
    25302532                self.networkCanvas.replot() 
    25312533                return 
    2532              
     2534 
    25332535            elif hubs == 1: 
    25342536                #print "mark on given label" 
     
    25362538                labelText = self.networkCanvas.labelText 
    25372539                self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
    2538                  
     2540 
    25392541                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()])] 
    25402542                self.networkCanvas.setMarkedVertices(toMark) 
    25412543                self.networkCanvas.replot() 
    25422544                return 
    2543              
     2545 
    25442546            elif hubs == 2: 
    25452547                #print "mark on focus" 
     
    25472549                self.networkCanvas.tooltipNeighbours = self.markDistance 
    25482550                return 
    2549      
     2551 
    25502552            elif hubs == 3: 
    25512553                #print "mark selected" 
     
    25542556                self.networkCanvas.markSelectionNeighbours() 
    25552557                return 
    2556              
     2558 
    25572559            self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
    25582560            powers = self.graph.degree() 
    25592561            powers = [powers[key] for key in sorted(powers.keys())] 
    2560              
     2562 
    25612563            if hubs == 4: # at least N connections 
    25622564                #print "mark at least N connections" 
     
    25712573            elif hubs == 6: 
    25722574                #print "mark more than any" 
    2573                 self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
     2575                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0] + [powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    25742576                self.networkCanvas.replot() 
    25752577            elif hubs == 7: 
    25762578                #print "mark more than avg" 
    2577                 self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
     2579                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0] + [powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    25782580                self.networkCanvas.replot() 
    25792581            elif hubs == 8: 
    25802582                #print "mark most" 
    25812583                sortedIdx = range(len(powers)) 
    2582                 sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y])) 
     2584                sortedIdx.sort(lambda x, y:-cmp(powers[x], powers[y])) 
    25832585                cutP = self.markNumber - 1 
    25842586                cutPower = powers[sortedIdx[cutP]] 
     
    25892591            elif hubs == 9: 
    25902592                self.setMarkInput() 
    2591             
     2593 
    25922594        def testRefresh(self): 
    25932595            start = time.time() 
    25942596            self.networkCanvas.replot() 
    2595             stop = time.time()     
     2597            stop = time.time() 
    25962598            print "replot in " + str(stop - start) 
    2597              
     2599 
    25982600        def save_network(self): 
    25992601            if self.networkCanvas is None or self.graph is None: 
    26002602                return 
    2601              
     2603 
    26022604            filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
    26032605            if filename: 
     
    26082610                else: 
    26092611                    fn = str(filename) 
    2610                  
     2612 
    26112613                for i in range(self.graph.number_of_nodes()): 
    26122614                    node = self.graph.node[i] 
    26132615                    node['x'] = self.layout.coors[0][i] 
    26142616                    node['y'] = self.layout.coors[1][i] 
    2615      
     2617 
    26162618                Orange.network.readwrite.write(self.graph, fn) 
    2617                  
     2619 
    26182620        def sendData(self): 
    26192621            if len(self.signalManager.getLinks(self, None, \ 
     
    26242626                graph = self.networkCanvas.getSelectedGraph() 
    26252627                vertices = self.networkCanvas.getSelectedVertices() 
    2626                  
     2628 
    26272629                if graph is not None: 
    26282630                    if graph.items() is not None: 
     
    26302632                    else: 
    26312633                        nodes = self.networkCanvas.getSelectedExamples() 
    2632                          
     2634 
    26332635                        if len(nodes) > 0 and self.graph_base.items() is not None: 
    26342636                            self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
    26352637                        else: 
    26362638                            self.send("Selected Items", None) 
    2637                          
     2639 
    26382640                    nodes = self.networkCanvas.getUnselectedExamples() 
    26392641                    if len(nodes) > 0 and self.graph_base.items() is not None: 
     
    26412643                    else: 
    26422644                        self.send("Other Items", None) 
    2643                          
     2645 
    26442646                    self.send("Selected Network", graph) 
    26452647                else: 
     
    26492651                    else: 
    26502652                        self.send("Selected Items", None) 
    2651                          
     2653 
    26522654                    nodes = self.networkCanvas.getUnselectedExamples() 
    26532655                    if len(nodes) > 0 and self.graph_base.items() is not None: 
     
    26552657                    else: 
    26562658                        self.send("Other Items", None) 
    2657                  
     2659 
    26582660            if len(self.signalManager.getLinks(self, None, \ 
    26592661                                "Selected Items Distance Matrix", None)) > 0: 
     
    26622664                if self.items_matrix is not None: 
    26632665                    matrix = self.items_matrix.getitems(vertices) 
    2664          
     2666 
    26652667                self.send("Distance Matrix", matrix) 
    2666                      
     2668 
    26672669        def setCombos(self): 
    26682670            vars = self.graph_base.items_vars() 
     
    26702672            lastLabelColumns = self.lastLabelColumns 
    26712673            lastTooltipColumns = self.lastTooltipColumns 
    2672              
     2674 
    26732675            self.clearCombos() 
    2674              
     2676 
    26752677            self.attributes = [(var.name, var.varType) for var in vars] 
    26762678            self.edgeAttributes = [(var.name, var.varType) for var in edgeVars] 
    2677              
     2679 
    26782680            for var in vars: 
    26792681                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    26802682                    self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2681                      
     2683 
    26822684                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: 
    2683                      
     2685 
    26842686                    value = self.graph_base.items()[0][var].value 
    2685                      
     2687 
    26862688                    # can value be a list? 
    26872689                    try: 
     
    26912693                    except: 
    26922694                        pass 
    2693                      
     2695 
    26942696                    if len(value.split(',')) > 1: 
    26952697                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    2696                      
     2698 
    26972699                elif var.varType in [Orange.data.Type.Continuous]: 
    26982700                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2699      
     2701 
    27002702                self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    27012703                self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    27022704                self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    27032705                self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2704              
     2706 
    27052707            for var in edgeVars: 
    27062708                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    27072709                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2708                      
     2710 
    27092711            for i in range(self.vertexSizeCombo.count()): 
    27102712                if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i): 
    27112713                    self.vertexSize = i 
    27122714                    break 
    2713                  
     2715 
    27142716            for i in range(self.colorCombo.count()): 
    27152717                if self.lastColorColumn == self.colorCombo.itemText(i): 
    27162718                    self.color = i 
    27172719                    break 
    2718      
     2720 
    27192721            for i in range(self.attListBox.count()): 
    27202722                if str(self.attListBox.item(i).text()) in lastLabelColumns: 
    27212723                    self.attListBox.item(i).setSelected(1) 
    2722                      
     2724 
    27232725            for i in range(self.tooltipListBox.count()): 
    27242726                if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns: 
    27252727                    self.tooltipListBox.item(i).setSelected(1) 
    2726                  
     2728 
    27272729            self.lastLabelColumns = lastLabelColumns 
    27282730            self.lastTooltipColumns = lastTooltipColumns 
    2729              
     2731 
    27302732        def clearCombos(self): 
    27312733            self.attributes = [] 
    27322734            self.edgeAttributes = [] 
    2733              
     2735 
    27342736            self.colorCombo.clear() 
    27352737            self.vertexSizeCombo.clear() 
     
    27392741            self.editCombo.clear() 
    27402742            self.comboAttSelection.clear() 
    2741              
     2743 
    27422744            self.colorCombo.addItem("(same color)") 
    27432745            self.edgeColorCombo.addItem("(same color)") 
     
    27472749            self.editCombo.addItem("Select attribute") 
    27482750            self.comboAttSelection.addItem("Select attribute") 
    2749            
     2751 
    27502752        def change_graph(self, newgraph): 
    27512753            old_nodes = set(self.graph.nodes_iter()) 
     
    27542756            remove_nodes = old_nodes.difference(inter_nodes) 
    27552757            add_nodes = new_nodes.difference(inter_nodes) 
    2756              
     2758 
    27572759            [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes] 
    2758             self.networkCanvas.networkCurve.coors.update((node, (0,0)) for node in add_nodes) 
     2760            self.networkCanvas.networkCurve.coors.update((node, (0, 0)) for node in add_nodes) 
    27592761            positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
    27602762            self.layout.set_graph(newgraph, positions) 
    2761              
     2763 
    27622764            self.graph = newgraph 
    27632765            self.number_of_nodes_label = self.graph.number_of_nodes() 
    27642766            self.number_of_edges_label = self.graph.number_of_edges() 
    2765              
     2767 
    27662768            self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes) 
    2767              
     2769 
    27682770    #        self.nShown = self.graph.number_of_nodes() 
    27692771    #         
     
    27852787    #            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    27862788    #        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    2787              
     2789 
    27882790            k = 1.13850193174e-008 
    27892791            nodes = self.graph.number_of_nodes() 
    27902792            t = k * nodes * nodes 
    27912793            self.frSteps = int(5.0 / t) 
    2792             if self.frSteps <   1: self.frSteps = 1; 
     2794            if self.frSteps < 1: self.frSteps = 1; 
    27932795            if self.frSteps > 3000: self.frSteps = 3000; 
    2794              
     2796 
    27952797            if self.frSteps < 10: 
    27962798                self.renderAntialiased = 0 
     
    27992801                self.maxLinkSize = 1 
    28002802                self.optMethod = 0 
    2801                 self.graph_layout_method()             
    2802                  
     2803                self.graph_layout_method() 
     2804 
    28032805            #self.setVertexColor() 
    28042806            #self.setEdgeColor() 
    28052807            #self.networkCanvas.setEdgesSize() 
    2806              
     2808 
    28072809            #self.clickedAttLstBox() 
    28082810            #self.clickedTooltipLstBox() 
    28092811            #self.clickedEdgeLabelListBox() 
    2810              
     2812 
    28112813            self.optButton.setChecked(1) 
    2812             self.graph_layout()         
     2814            self.graph_layout() 
    28132815            self.information(0) 
    2814              
     2816 
    28152817        def set_graph(self, graph): 
    28162818            self.set_items_distance_matrix(None) 
    2817                   
     2819 
    28182820            if graph is None: 
    28192821                self.graph = None 
     
    28272829                self._links = None 
    28282830                return 
    2829              
     2831 
    28302832            self.graph_base = graph 
    2831              
     2833 
    28322834            if self._network_view is not None: 
    28332835                graph = self._network_view.init_network(graph) 
    2834              
    2835              
     2836 
     2837 
    28362838            #print "OWNetwork/setGraph: new visualizer..." 
    28372839            self.graph = graph 
    2838              
     2840 
    28392841            if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
    28402842                positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
     
    28442846            else: 
    28452847                self.layout.set_graph(self.graph) 
    2846              
     2848 
    28472849            self.number_of_nodes_label = self.graph.number_of_nodes() 
    28482850            self.number_of_edges_label = self.graph.number_of_edges() 
    2849              
     2851 
    28502852            self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
    28512853            self.networkCanvas.renderAntialiased = self.renderAntialiased 
     
    28582860            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    28592861            self.lastColorColumn = self.colorCombo.currentText() 
    2860              
     2862 
    28612863            self.nShown = self.graph.number_of_nodes() 
    2862              
     2864 
    28632865            if self.graph.number_of_edges() > 0: 
    28642866                self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    28652867            else: 
    28662868                self.verticesPerEdge = 0 
    2867                  
     2869 
    28682870            if self.graph.number_of_nodes() > 0: 
    28692871                self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    28702872            else: 
    28712873                self.edgesPerVertex = 0 
    2872              
     2874 
    28732875            undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    28742876            components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     
    28772879            else: 
    28782880                self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    2879              
     2881 
    28802882            if self.graph.is_multigraph(): 
    28812883                self.clustering_coefficient = -1 
    28822884            else: 
    28832885                self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    2884              
     2886 
    28852887            self.setCombos() 
    2886                  
     2888 
    28872889            lastNameComponentAttributeFound = False 
    28882890            for i in range(self.nameComponentCombo.count()): 
     
    28942896                    self.showComponents() 
    28952897                    break 
    2896                  
     2898 
    28972899            if not lastNameComponentAttributeFound: 
    28982900                self.lastNameComponentAttribute = '' 
    2899              
     2901 
    29002902            self.showComponentAttribute = None 
    2901      
     2903 
    29022904            k = 1.13850193174e-008 
    29032905            nodes = self.graph.number_of_nodes() 
    29042906            t = k * nodes * nodes 
    29052907            self.frSteps = int(5.0 / t) 
    2906             if self.frSteps <   1: self.frSteps = 1; 
     2908            if self.frSteps < 1: self.frSteps = 1; 
    29072909            if self.frSteps > 3000: self.frSteps = 3000; 
    2908              
     2910 
    29092911            self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
    29102912            self.networkCanvas.showWeights = self.showWeights 
     
    29172919                self.maxLinkSize = 1 
    29182920                self.optMethod = 0 
    2919                 self.graph_layout_method()             
    2920                  
     2921                self.graph_layout_method() 
     2922 
    29212923            if self.vertexSize > 0: 
    29222924                self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize) 
    29232925            else: 
    29242926                self.networkCanvas.setVerticesSize() 
    2925                  
     2927 
    29262928            self.setVertexColor() 
    29272929            self.setEdgeColor() 
    2928                  
     2930 
    29292931            self.networkCanvas.setEdgesSize() 
    29302932            self.clickedAttLstBox() 
    29312933            self.clickedTooltipLstBox() 
    29322934            self.clickedEdgeLabelListBox() 
    2933              
     2935 
    29342936            self.optButton.setChecked(1) 
    2935             self.graph_layout()         
     2937            self.graph_layout() 
    29362938            self.information(0) 
    29372939            #self.networkCanvas.updateCanvas() 
    2938              
     2940 
    29392941        def set_network_view(self, nxView): 
    29402942            self._network_view = nxView 
     
    29422944            self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected 
    29432945            self.set_graph(self.graph_base) 
    2944              
     2946 
    29452947        def setItems(self, items=None): 
    29462948            self.error('') 
    2947              
     2949 
    29482950            if self.graph is None or items is None: 
    29492951                return 
    2950              
     2952 
    29512953            if len(items) != self.graph_base.number_of_nodes(): 
    29522954                self.error('ExampleTable items must have one example for each vertex.') 
    29532955                return 
    2954              
     2956 
    29552957            self.graph_base.set_items(items) 
    2956              
     2958 
    29572959            self.setVertexSize() 
    29582960            self.networkCanvas.showIndexes = self.showIndexes 
     
    29612963            self.setCombos() 
    29622964            self.networkCanvas.updateData() 
    2963              
     2965 
    29642966        def setMarkInput(self): 
    29652967            var = str(self.markInputCombo.currentText()) 
     
    29672969            if self.markInputItems is not None and len(self.markInputItems) > 0: 
    29682970                values = [str(x[var]).strip().upper() for x in self.markInputItems] 
    2969                 toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
     2971                toMark = [i for (i, x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
    29702972                #print "mark:", toMark 
    29712973                self.networkCanvas.setMarkedVertices(list(toMark)) 
    29722974                self.networkCanvas.replot() 
    2973                  
     2975 
    29742976            else: 
    29752977                self.networkCanvas.setMarkedVertices([]) 
    2976                 self.networkCanvas.replot()             
    2977          
     2978                self.networkCanvas.replot() 
     2979 
    29782980        def markItems(self, items): 
    29792981            self.markInputCombo.clear() 
    29802982            self.markInputRadioButton.setEnabled(False) 
    29812983            self.markInputItems = items 
    2982              
     2984 
    29832985            if self.graph is None or self.graph_base.items() is None or items is None: 
    29842986                return 
    2985              
     2987 
    29862988            if len(items) > 0: 
    29872989                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()] 
    29882990                lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
    29892991                commonVars = set(lstNewDomain) & set(lstOrgDomain) 
    2990      
     2992 
    29912993                if len(commonVars) > 0: 
    29922994                    for var in commonVars: 
    29932995                        orgVar = self.graph_base.items().domain[var] 
    29942996                        mrkVar = items.domain[var] 
    2995      
     2997 
    29962998                        if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String: 
    29972999                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
    29983000                            self.markInputRadioButton.setEnabled(True) 
    2999                      
     3001 
    30003002                            self.setMarkMode(9) 
    3001                    
     3003 
    30023004        def setExampleSubset(self, subset): 
    30033005            if self.networkCanvas is None: 
    30043006                return 
    3005              
     3007 
    30063008            self.warning('') 
    30073009            hiddenNodes = [] 
    3008              
     3010 
    30093011            if subset is not None: 
    30103012                try: 
     
    30133015                        index = int(row['index'].value) 
    30143016                        if expected != index: 
    3015                             hiddenNodes += range(expected-1, index-1) 
     3017                            hiddenNodes += range(expected - 1, index - 1) 
    30163018                            expected = index + 1 
    30173019                        else: 
    30183020                            expected += 1 
    3019                              
    3020                     hiddenNodes += range(expected-1, self.graph.number_of_nodes()) 
    3021                      
     3021 
     3022                    hiddenNodes += range(expected - 1, self.graph.number_of_nodes()) 
     3023 
    30223024                    self.networkCanvas.setHiddenNodes(hiddenNodes) 
    30233025                except: 
    30243026                    self.warning('"index" attribute does not exist in "items" table.') 
    3025                          
     3027 
    30263028        def showDegreeDistribution(self): 
    30273029            if self.graph is None: 
    30283030                return 
    3029              
     3031 
    30303032            from matplotlib import rcParams 
    30313033            import pylab as p 
    3032              
     3034 
    30333035            x = self.graph.degree().values() 
    30343036            nbins = len(set(x)) 
    30353037            if nbins > 500: 
    30363038              bbins = 500 
    3037              
     3039 
    30383040            # the histogram of the data 
    30393041            n, bins, patches = p.hist(x, nbins) 
    3040              
     3042 
    30413043            p.xlabel('Degree') 
    30423044            p.ylabel('No. of nodes') 
    30433045            p.title(r'Degree distribution') 
    3044              
     3046 
    30453047            p.show() 
    3046              
     3048 
    30473049        def setColors(self): 
    30483050            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
     
    30523054                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    30533055                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    3054                  
     3056 
    30553057                self.setVertexColor() 
    3056                  
     3058 
    30573059        def setEdgeColorPalette(self): 
    30583060            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     
    30623064                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    30633065                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    3064                  
     3066 
    30653067                self.setEdgeColor() 
    3066          
     3068 
    30673069        def createColorDialog(self, colorSettings, selectedSchemaIndex): 
    30683070            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
     
    30713073            c.setColorSchemas(colorSettings, selectedSchemaIndex) 
    30723074            return c 
    3073          
     3075 
    30743076        """ 
    30753077        Layout Optimization 
    30763078        """ 
    3077          
     3079 
    30783080        def graph_layout(self): 
    30793081            if self.graph is None:   #grafa se ni 
    30803082                self.optButton.setChecked(False) 
    30813083                return 
    3082              
     3084 
    30833085            if not self.optButton.isChecked(): 
    30843086                self.optButton.setChecked(False) 
    30853087                return 
    3086              
     3088 
    30873089            qApp.processEvents() 
    3088                  
     3090 
    30893091            if self.optMethod == 1: 
    30903092                self.layout.random() 
     
    31033105            elif self.optMethod == 8: 
    31043106                self.graph_layout_pivot_mds() 
    3105                  
     3107 
    31063108            self.optButton.setChecked(False) 
    3107             self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3109            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    31083110            self.networkCanvas.updateCanvas() 
    31093111            qApp.processEvents() 
    3110              
     3112 
    31113113        def graph_layout_method(self, method=None): 
    31123114            self.information() 
    31133115            self.stepsSpin.label.setText('Iterations: ') 
    3114              
     3116 
    31153117            if method is not None: 
    31163118                self.optMethod = method 
    3117                  
     3119 
    31183120            if str(self.optMethod) == '0': 
    31193121                self.optButton.setEnabled(False) 
    31203122            else: 
    31213123                self.optButton.setEnabled(True) 
    3122                  
     3124 
    31233125            if str(self.optMethod) in ['2', '3', '4']: 
    31243126                self.stepsSpin.setEnabled(True) 
     
    31263128                self.stepsSpin.label.setText('Pivots: ') 
    31273129                self.stepsSpin.setEnabled(True) 
    3128                  
     3130 
    31293131                if self.items_matrix is None: 
    31303132                    self.information('Set distance matrix to input signal') 
     
    31403142                self.optButton.setChecked(True) 
    31413143                self.graph_layout() 
    3142              
     3144 
    31433145        def graph_layout_fr(self, weighted): 
    31443146            if self.graph is None:   #grafa se ni 
    31453147                return 
    3146                    
     3148 
    31473149            if not self.optButton.isChecked(): 
    31483150              #print "not" 
     
    31513153              self.optButton.setText("Optimize layout") 
    31523154              return 
    3153              
     3155 
    31543156            self.optButton.setText("Stop") 
    31553157            qApp.processEvents() 
     
    31613163            o = self.frSteps % breakpoints 
    31623164            iteration = 0 
    3163             coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps) 
    3164      
     3165            coolFactor = math.exp(math.log(10.0 / 10000.0) / self.frSteps) 
     3166 
    31653167            if k > 0: 
    31663168                while iteration < breakpoints: 
     
    31713173                    iteration += 1 
    31723174                    qApp.processEvents() 
    3173                     self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3175                    self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    31743176                    self.networkCanvas.updateCanvas() 
    3175                  
     3177 
    31763178                #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp) 
    31773179                if self.stopOptimization: 
     
    31793181                initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
    31803182                qApp.processEvents() 
    3181                 self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3183                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    31823184                self.networkCanvas.updateCanvas() 
    31833185            else: 
     
    31893191                    iteration += 1 
    31903192                    qApp.processEvents() 
    3191                     self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3193                    self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    31923194                    self.networkCanvas.updateCanvas() 
    3193                      
     3195 
    31943196            self.optButton.setChecked(False) 
    31953197            self.optButton.setText("Optimize layout") 
    3196              
     3198 
    31973199        def graph_layout_fr_special(self): 
    31983200            if self.graph is None:   #grafa se ni 
    31993201                return 
    3200              
     3202 
    32013203            steps = 100 
    32023204            initTemp = 1000 
    3203             coolFactor = math.exp(math.log(10.0/10000.0) / steps) 
     3205            coolFactor = math.exp(math.log(10.0 / 10000.0) / steps) 
    32043206            oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())] 
    32053207            #print oldXY 
     
    32083210            self.networkCanvas.updateDataSpecial(oldXY) 
    32093211            self.networkCanvas.replot() 
    3210                      
     3212 
    32113213        def graph_layout_fr_radial(self): 
    32123214            if self.graph is None:   #grafa se ni 
    32133215                return 
    3214              
     3216 
    32153217            #print "F-R Radial" 
    32163218            k = 1.13850193174e-008 
     
    32183220            t = k * nodes * nodes 
    32193221            refreshRate = int(5.0 / t) 
    3220             if refreshRate <    1: refreshRate = 1; 
     3222            if refreshRate < 1: refreshRate = 1; 
    32213223            if refreshRate > 1500: refreshRate = 1500; 
    32223224            #print "refreshRate: " + str(refreshRate) 
    3223              
     3225 
    32243226            tolerance = 5 
    32253227            initTemp = 100 
    32263228            centerNdx = 0 
    3227              
     3229 
    32283230            selection = self.networkCanvas.getSelection() 
    32293231            if len(selection) > 0: 
    32303232                centerNdx = selection[0] 
    3231                  
     3233 
    32323234            #print "center ndx: " + str(centerNdx) 
    32333235            initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
    3234             self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5] 
     3236            self.networkCanvas.circles = [10000 / 12, 10000 / 12 * 2, 10000 / 12 * 3]#, 10000/12*4, 10000/12*5] 
    32353237            #self.networkCanvas.circles = [100, 200, 300] 
    32363238            self.networkCanvas.updateCanvas() 
    32373239            self.networkCanvas.circles = [] 
    3238                  
     3240 
    32393241        def graph_layout_pivot_mds(self): 
    32403242            self.information() 
    3241              
     3243 
    32423244            if self.items_matrix is None: 
    32433245                self.information('Set distance matrix to input signal') 
    32443246                return 
    3245              
     3247 
    32463248            if self.graph is None: 
    32473249                self.information('No network found') 
    32483250                return 
    3249              
     3251 
    32503252            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    32513253                self.error('Distance matrix dimensionality must equal number of vertices') 
    32523254                return 
    3253              
     3255 
    32543256            self.frSteps = min(self.frSteps, self.items_matrix.dim) 
    32553257            qApp.processEvents() 
    32563258            mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps) 
    3257             x,y = mds.optimize() 
     3259            x, y = mds.optimize() 
    32583260            self.layout.coors[0] = x 
    32593261            self.layout.coors[1] = y 
    32603262            self.networkCanvas.updateCanvas() 
    3261          
    3262            
     3263 
     3264 
    32633265        """ 
    32643266        Network Visualization 
    32653267        """ 
    3266             
     3268 
    32673269        def clickedAttLstBox(self): 
    32683270            if self.graph is None: 
    32693271                return 
    3270              
     3272 
    32713273            self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes]) 
    32723274            self.networkCanvas.setLabelText(self.lastLabelColumns) 
    32733275            self.networkCanvas.updateData() 
    32743276            self.networkCanvas.replot() 
    3275        
     3277 
    32763278        def clickedTooltipLstBox(self): 
    32773279            if self.graph is None: 
    32783280                return 
    3279              
     3281 
    32803282            self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes]) 
    32813283            self.networkCanvas.setTooltipText(self.lastTooltipColumns) 
    32823284            self.networkCanvas.updateData() 
    32833285            self.networkCanvas.replot() 
    3284              
     3286 
    32853287        def clickedEdgeLabelListBox(self): 
    32863288            if self.graph is None: 
    32873289                return 
    3288              
     3290 
    32893291            self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
    32903292            self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes) 
    32913293            self.networkCanvas.updateData() 
    32923294            self.networkCanvas.replot() 
    3293      
     3295 
    32943296        def setVertexColor(self): 
    32953297            if self.graph is None: 
    32963298                return 
    3297              
     3299 
    32983300            self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
    32993301            self.lastColorColumn = self.colorCombo.currentText() 
    33003302            self.networkCanvas.updateData() 
    33013303            self.networkCanvas.replot() 
    3302              
     3304 
    33033305        def setEdgeColor(self): 
    33043306            if self.graph is None: 
    33053307                return 
    3306              
     3308 
    33073309            self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
    33083310            self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    33093311            self.networkCanvas.updateData() 
    33103312            self.networkCanvas.replot() 
    3311                        
     3313 
    33123314        def setGraphGrid(self): 
    33133315            self.networkCanvas.enableGridY(self.networkCanvasShowGrid) 
    33143316            self.networkCanvas.enableGridX(self.networkCanvasShowGrid) 
    3315          
     3317 
    33163318        def selectAllConnectedNodes(self): 
    33173319            self.networkCanvas.selectConnectedNodes(1000000) 
    3318                      
     3320 
    33193321        def setMaxLinkSize(self): 
    33203322            if self.graph is None: 
    33213323                return 
    3322              
     3324 
    33233325            self.networkCanvas.maxEdgeSize = self.maxLinkSize 
    33243326            self.networkCanvas.setEdgesSize() 
    33253327            self.networkCanvas.replot() 
    3326          
     3328 
    33273329        def setVertexSize(self): 
    33283330            if self.graph is None or self.networkCanvas is None: 
    33293331                return 
    3330              
     3332 
    33313333            if self.minVertexSize > self.maxVertexSize: 
    33323334                self.maxVertexSize = self.minVertexSize 
    3333              
     3335 
    33343336            self.networkCanvas.minVertexSize = self.minVertexSize 
    33353337            self.networkCanvas.maxVertexSize = self.maxVertexSize 
    33363338            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    3337              
     3339 
    33383340            if self.vertexSize > 0: 
    33393341                self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize) 
    33403342            else: 
    33413343                self.networkCanvas.setVerticesSize() 
    3342                  
     3344 
    33433345            self.networkCanvas.replot() 
    3344              
     3346 
    33453347        def setFontSize(self): 
    33463348            if self.networkCanvas is None: 
    33473349                return 
    3348              
     3350 
    33493351            self.networkCanvas.fontSize = self.fontSize 
    33503352            self.networkCanvas.drawPlotItems() 
    3351                      
     3353 
    33523354        def sendReport(self): 
    33533355            self.reportSettings("Graph data", 
     
    33703372                                 ("Iterations", self.frSteps)]) 
    33713373            self.reportSection("Graph") 
    3372             self.reportImage(self.networkCanvas.saveToFileDirect)         
    3373              
    3374          
    3375 if __name__=="__main__": 
    3376     a=QApplication(sys.argv) 
    3377     ow=OWNxExplorer() 
     3374            self.reportImage(self.networkCanvas.saveToFileDirect) 
     3375 
     3376 
     3377if __name__ == "__main__": 
     3378    a = QApplication(sys.argv) 
     3379    ow = OWNxExplorer() 
    33783380    ow.show() 
    33793381    def setNetwork(signal, data, id=None): 
     
    33823384        #if signal == 'Items': 
    33833385        #    ow.set_items(data) 
    3384          
     3386 
    33853387    import OWNxFile 
    33863388    owFile = OWNxFile.OWNxFile() 
     
    33883390    owFile.show() 
    33893391    owFile.selectNetFile(0) 
    3390      
     3392 
    33913393    a.exec_() 
    33923394    ow.saveSettings() 
    33933395    owFile.saveSettings() 
    3394      
Note: See TracChangeset for help on using the changeset viewer.