Changeset 9261:c01cd9570dae in orange


Ignore:
Timestamp:
11/24/11 10:22:14 (2 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
217f759a7e79faa862e72748b3800e2ddcc3c957
Message:

Merged Qt and Qwt widgets.

File:
1 edited

Legend:

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

    r8735 r9261  
    1818 
    1919from OWWidget import * 
    20 from OWNxCanvas import * 
    2120from operator import itemgetter 
    2221 
     
    2928dlg_showall = dir + "Dlg_clear.png" 
    3029 
    31 class OWNxExplorer(OWWidget): 
    32     settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    33     "maxLinkSize", "minVertexSize", "maxVertexSize", "renderAntialiased", 
    34     "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", 
    35     "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    36     "showWeights", "showIndexes",  "showEdgeLabels", "colorSettings",  
    37     "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
    38     "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
    39     "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
    40     "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
    41     "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"]  
    42      
    43     def __init__(self, parent=None, signalManager=None, name = 'Nx Explorer',  
    44                  NetworkCanvas=OWNxCanvas): 
    45         OWWidget.__init__(self, parent, signalManager, name) 
    46         #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    47         self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
    48                        ("Nx View", Orange.network.NxView, self.set_network_view), 
    49                        ("Items", Orange.data.Table, self.setItems), 
    50                        ("Items to Mark", Orange.data.Table, self.markItems),  
    51                        ("Items Subset", Orange.data.Table, self.setExampleSubset),  
    52                        ("Items Distance Matrix", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
     30try: 
     31    from OWNxCanvasQt import * 
     32     
     33    class OWNxExplorer(OWWidget): 
     34        settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
     35        "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.animate_plot", 
     36        "networkCanvas.animate_points", "networkCanvas.antialias_plot",  
     37        "networkCanvas.antialias_points", "networkCanvas.antialias_lines",  
     38        "networkCanvas.auto_adjust_performance", "invertSize", "optMethod",  
     39        "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices", "networkCanvas.show_weights", 
     40        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
     41        "showWeights", "showEdgeLabels", "colorSettings",  
     42        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
     43        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
     44        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
     45        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
     46        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",  
     47        "networkCanvas.trim_label_words", "opt_from_curr", "networkCanvas.explore_distances", 
     48        "networkCanvas.show_component_distances"]  
    5349         
    54         self.outputs = [("Selected Network", Orange.network.Graph), 
    55                         ("Selected Items Distance Matrix", Orange.core.SymMatrix), 
    56                         ("Selected Items", Orange.data.Table),  
    57                         ("Unselected Items", Orange.data.Table),  
    58                         ("Marked Items", Orange.data.Table), 
    59                         ("Attribute Selection List", AttributeList)] 
    60          
    61         self.markerAttributes = [] 
    62         self.tooltipAttributes = [] 
    63         self.edgeLabelAttributes = [] 
    64         self.attributes = [] 
    65         self.edgeAttributes = [] 
    66         self.autoSendSelection = False 
    67         self.graphShowGrid = 1  # show gridlines in the graph 
    68          
    69         self.markNConnections = 2 
    70         self.markNumber = 0 
    71         self.markProportion = 0 
    72         self.markSearchString = "" 
    73         self.markDistance = 2 
    74         self.frSteps = 1 
    75         self.hubs = 0 
    76         self.color = 0 
    77         self.edgeColor = 0 
    78         self.vertexSize = 0 
    79         self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = self.diameter = self.clustering_coefficient = 0 
    80         self.optimizeWhat = 1 
    81         self.stopOptimization = 0 
    82         self.maxLinkSize = 3 
    83         self.maxVertexSize = 5 
    84         self.minVertexSize = 5 
    85         self.renderAntialiased = 1 
    86         self.labelsOnMarkedOnly = 0 
    87         self.invertSize = 0 
    88         self.optMethod = 0 
    89         self.lastVertexSizeColumn = '' 
    90         self.lastColorColumn = '' 
    91         self.lastNameComponentAttribute = '' 
    92         self.lastLabelColumns = set() 
    93         self.lastTooltipColumns = set() 
    94         self.showWeights = 0 
    95         self.showIndexes = 0 
    96         self.showEdgeLabels = 0 
    97         self.colorSettings = None 
    98         self.selectedSchemaIndex = 0 
    99         self.edgeColorSettings = [('net_edges', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(204, 204, 204), (179, 226, 205), (253, 205, 172), (203, 213, 232), (244, 202, 228), (230, 245, 201), (255, 242, 174), (241, 226, 204)])]]), ('Default', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(0, 0, 255), (255, 0, 0), (0, 255, 0), (255, 128, 0), (255, 255, 0), (255, 0, 255), (0, 255, 255), (128, 0, 255), (0, 128, 255), (255, 223, 128), (127, 111, 64), (92, 46, 0), (0, 84, 0), (192, 192, 0), (0, 127, 127), (128, 0, 0), (127, 0, 127)])]])] 
    100         self.selectedEdgeSchemaIndex = 0 
    101         self.items_matrix = None 
    102         self.showDistances = 0 
    103         self.showMissingValues = 0 
    104         self.fontSize = 12 
    105         self.mdsTorgerson = 0 
    106         self.mdsAvgLinkage = 1 
    107         self.mdsSteps = 10000 
    108         self.mdsRefresh = 50 
    109         self.mdsStressDelta = 0.0000001 
    110         self.organism = 'goa_human' 
    111         self.showTextMiningInfo = 0 
    112         self.toolbarSelection = 0 
    113         self.minComponentEdgeWidth = 10 
    114         self.maxComponentEdgeWidth = 70 
    115         self.mdsFromCurrentPos = 0 
    116         self.tabIndex = 0 
    117         self.number_of_nodes_label = -1 
    118         self.number_of_edges_label = -1 
    119         self.loadSettings() 
    120          
    121         self._network_view = None 
    122         self.layout = Orange.network.GraphLayout() 
    123         self.graph = None 
    124         self.graph_base = None 
    125         self.markInputItems = None 
    126          
    127         self.mainArea.layout().setContentsMargins(0,4,4,4) 
    128         self.controlArea.layout().setContentsMargins(4,4,0,4) 
    129          
    130         self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
    131         self.networkCanvas.showMissingValues = self.showMissingValues 
    132         self.mainArea.layout().addWidget(self.networkCanvas) 
    133          
    134         self.networkCanvas.maxLinkSize = self.maxLinkSize 
    135         self.networkCanvas.minVertexSize = self.minVertexSize 
    136         self.networkCanvas.maxVertexSize = self.maxVertexSize 
    137          
    138         self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal') 
    139          
    140         self.tabs = OWGUI.tabWidget(self.hcontroArea) 
    141          
    142         self.verticesTab = OWGUI.createTabPage(self.tabs, "Vertices") 
    143         self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges") 
    144         self.markTab = OWGUI.createTabPage(self.tabs, "Mark") 
    145         self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
    146         #self.editTab = OWGUI.createTabPage(self.tabs, "Edit") 
    147          
    148         self.tabs.setCurrentIndex(self.tabIndex) 
    149         self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index)) 
    150          
    151         self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False) 
    152          
    153         self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method) 
    154         self.optCombo.addItem("No optimization") 
    155         self.optCombo.addItem("Random") 
    156         self.optCombo.addItem("Fruchterman Reingold") 
    157         self.optCombo.addItem("Fruchterman Reingold Weighted") 
    158         self.optCombo.addItem("Fruchterman Reingold Radial") 
    159         self.optCombo.addItem("Circular Crossing Reduction") 
    160         self.optCombo.addItem("Circular Original") 
    161         self.optCombo.addItem("Circular Random") 
    162         self.optCombo.addItem("Pivot MDS") 
    163         self.optCombo.setCurrentIndex(self.optMethod) 
    164         self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
    165         self.stepsSpin.setEnabled(False) 
    166          
    167         self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1) 
    168          
    169         colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace = False) 
    170         self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.setVertexColor) 
    171         self.colorCombo.addItem("(same color)") 
    172         OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip = "Set vertex color palette", debuggingEnabled = 0) 
    173          
    174         self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box = "Vertex size attribute", callback=self.setVertexSize) 
    175         self.vertexSizeCombo.addItem("(none)") 
    176          
    177         OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize) 
    178         OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize) 
    179         OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback = self.setVertexSize) 
    180          
    181         colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace = False) 
    182         self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.setEdgeColor) 
    183         self.edgeColorCombo.addItem("(same color)") 
    184         OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip = "Set edge color palette", debuggingEnabled = 0) 
    185          
    186         self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace = False) 
    187         OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback = self.setFontSize) 
    188          
    189         self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False) 
    190         self.attListBox = OWGUI.listBox(self.attBox, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
    191         self.tooltipListBox = OWGUI.listBox(self.attBox, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox) 
    192          
    193         self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False) 
    194         self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox) 
    195         self.edgeLabelBox.setEnabled(False) 
    196          
    197         ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
    198         OWGUI.checkBox(ib, self, 'showWeights', 'Show weights', callback=(lambda: self._set_canvas_attr('showWeights', self.showWeights))) 
    199         OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
    200         OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.setMaxLinkSize) 
    201         self.showDistancesCheckBox = OWGUI.checkBox(ib, self, 'showDistances', 'Explore vertex distances', callback=(lambda: self._set_canvas_attr('showDistances', self.showDistances)), disabled=1) 
    202          
    203         ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
    204         OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes))) 
    205         OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly))) 
    206         OWGUI.checkBox(ib, self, 'renderAntialiased', 'Render antialiased', callback=(lambda: self._set_canvas_attr('renderAntialiased', self.renderAntialiased))) 
    207         self.insideView = 0 
    208         self.insideViewNeighbours = 2 
    209         OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked = "insideView", checkCallback = self.insideview, callback = self.insideviewneighbours) 
    210         OWGUI.checkBox(ib, self, 'showMissingValues', 'Show missing values', callback=(lambda: self._set_canvas_attr('showMissingValues', self.showMissingValues))) 
    211          
    212         ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical") 
    213         OWGUI.label(ib, self, "Vertices (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)") 
    214         OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i") 
    215          
    216         ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setMarkMode) 
    217         OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.setMarkMode) 
    218         OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback = self.setMarkMode) 
    219         self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
    220         self.searchStringTimer = QTimer(self) 
    221         self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode) 
    222          
    223         OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback = self.setMarkMode) 
    224         OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback = self.setMarkMode) 
    225         ib = OWGUI.indentedBox(ribg, orientation = 0) 
    226         self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h))) 
    227         #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
    228         OWGUI.widgetLabel(ribg, "Mark  vertices with ...") 
    229         OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.setMarkMode) 
    230         OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.setMarkMode) 
    231         self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h))) 
    232         OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.setMarkMode) 
    233         OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.setMarkMode) 
    234         OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.setMarkMode) 
    235         ib = OWGUI.indentedBox(ribg) 
    236         self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h))) 
    237         OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)") 
    238         self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback = self.setMarkMode) 
    239         ib = OWGUI.indentedBox(ribg) 
    240         self.markInput = 0 
    241         self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h))) 
    242         self.markInputRadioButton.setEnabled(False) 
    243          
    244         ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
    245         self.checkSendMarkedNodes = 0 
    246         OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback = self.setSendMarkedNodes, disabled=0) 
    247          
    248          
    249         T = OWToolbars.NavigateSelectToolbar 
    250         self.zoomSelectToolbar = T(self, self.hcontroArea, self.networkCanvas, self.autoSendSelection, 
    251                                   buttons = (T.IconZoom,  
    252                                              T.IconZoomExtent,  
    253                                              T.IconZoomSelection,  
    254                                              T.IconPan,  
    255                                              ("", "", "", None, None, 0), 
    256                                              #("Move selection", "buttonMoveSelection", "activateMoveSelection", QIcon(OWToolbars.dlg_select), Qt.ArrowCursor, 1), 
    257                                              T.IconRectangle,  
    258                                              #T.IconPolygon,   
    259                                              T.IconSendSelection, 
    260                                              ("", "", "", None, None, 0, "select"), 
    261                                              ("Add marked to selection", "buttonM2S", "markedToSelection", QIcon(dlg_mark2sel), Qt.ArrowCursor, 0), 
    262                                              ("Add selection to marked", "buttonS2M", "selectionToMarked", QIcon(dlg_sel2mark), Qt.ArrowCursor, 0), 
    263                                              ("Remove selection", "buttonRMS", "removeSelection", QIcon(dlg_selIsmark), Qt.ArrowCursor, 0), 
    264                                              ("", "", "", None, None, 0, "select"), 
    265                                              ("Hide selected", "buttonSEL", "hideSelectedVertices", QIcon(dlg_selected), Qt.ArrowCursor, 0), 
    266                                              ("Hide unselected", "buttonUN", "hideUnSelectedVertices", QIcon(dlg_unselected), Qt.ArrowCursor, 0), 
    267                                              ("Show all nodes", "buttonSW", "showAllVertices", QIcon(dlg_showall), Qt.ArrowCursor, 0))) 
    268                          
    269         OWGUI.rubber(self.zoomSelectToolbar) 
    270          
    271         ib = OWGUI.widgetBox(self.infoTab, "General") 
    272         OWGUI.label(ib, self, "Number of vertices: %(number_of_nodes_label)i") 
    273         OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i") 
    274         OWGUI.label(ib, self, "Vertices per edge: %(verticesPerEdge).2f") 
    275         OWGUI.label(ib, self, "Edges per vertex: %(edgesPerVertex).2f") 
    276         OWGUI.label(ib, self, "Diameter: %(diameter)i") 
    277         OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%") 
    278          
    279         ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
    280          
    281         OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False) 
    282         OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False) 
    283         OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
    284          
    285         #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
    286          
    287         ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
    288          
    289         #ib = OWGUI.widgetBox(ibProto, "Name components") 
    290         OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
    291          
    292         self.nameComponentAttribute = 0 
    293         self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal") 
    294         self.nameComponentCombo.addItem("Select attribute") 
    295          
    296         self.showComponentAttribute = 0 
    297         self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal") 
    298         self.showComponentCombo.addItem("Select attribute") 
    299         OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info") 
    300          
    301         #ib = OWGUI.widgetBox(ibProto, "Distance Matrix") 
    302         ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    303         self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1) 
    304         self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1) 
    305         self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1) 
    306         ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    307         self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1) 
    308         self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1) 
    309         self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1) 
    310         self.scalingRatio = 0 
    311         OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ") 
    312         OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ") 
    313         OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ") 
    314         OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ") 
    315         ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    316         OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation") 
    317         OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage") 
    318         OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions") 
    319         self.mdsInfoA=OWGUI.widgetLabel(ib, "Avg. stress:") 
    320         self.mdsInfoB=OWGUI.widgetLabel(ib, "Num. steps:") 
    321         self.rotateSteps = 100 
    322          
    323         OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
    324         OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
    325         OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
    326          
    327         self.attSelectionAttribute = 0 
    328         self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList) 
    329         self.comboAttSelection.addItem("Select attribute") 
    330         self.autoSendAttributes = 0 
    331         OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes) 
    332          
    333         self.icons = self.createAttributeIconDict() 
    334         self.setMarkMode() 
    335          
    336         self.editAttribute = 0 
    337         self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
    338         self.editCombo.addItem("Select attribute") 
    339         self.editValue = '' 
    340         OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal') 
    341         OWGUI.button(self.infoTab, self, "Edit", callback=self.edit) 
    342          
    343         self.verticesTab.layout().addStretch(1) 
    344         self.edgesTab.layout().addStretch(1) 
    345         self.markTab.layout().addStretch(1) 
    346         self.infoTab.layout().addStretch(1) 
    347          
    348         dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    349         self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    350         self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    351          
    352         dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    353         self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    354         self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    355          
    356         self.graph_layout_method() 
    357         self.setFontSize() 
    358         self.set_graph(None) 
    359         self.setMinimumWidth(900) 
    360          
    361         #self.resize(1000, 600) 
    362         #self.controlArea.setEnabled(False) 
    363          
    364     def setComponentEdgeWidth(self, changedMin=True): 
    365         if self.networkCanvas is None: 
    366             return 
    367          
    368         canvas = self.networkCanvas 
    369         if changedMin: 
    370             if self.maxComponentEdgeWidth < self.minComponentEdgeWidth: 
    371                 self.maxComponentEdgeWidth = self.minComponentEdgeWidth 
    372         else: 
    373             if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
    374                 self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
    375          
    376         canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    377         canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    378         self.networkCanvas.updateCanvas() 
    379      
    380     def setAutoSendAttributes(self): 
    381         print 'TODO setAutoSendAttributes' 
    382         #if self.autoSendAttributes: 
    383         #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
    384         #else: 
    385         #    self.networkCanvas.callbackSelectVertex = None 
    386  
    387     def sendAttSelectionList(self): 
    388         if not self.graph is None: 
    389             vars = [x.name for x in self.graph_base.links_vars()] 
    390             if not self.comboAttSelection.currentText() in vars: 
    391                 return 
    392             att = str(self.comboAttSelection.currentText()) 
    393             vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    394              
    395             if len(vertices) != 1: 
    396                 return 
    397              
    398             attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    399         else: 
    400             attributes = None 
    401         self.send("Attribute Selection List", attributes) 
    402          
    403     def edit(self): 
    404         if self.graph is None: 
    405             return 
    406          
    407         vars = [x.name for x in self.graph_base.items_vars()] 
    408         if not self.editCombo.currentText() in vars: 
    409             return 
    410         att = str(self.editCombo.currentText()) 
    411         vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    412          
    413         if len(vertices) == 0: 
    414             return 
    415          
    416         if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous: 
    417             for v in vertices: 
    418                 self.graph_base.items()[v][att] = float(self.editValue) 
    419         else: 
    420             for v in vertices: 
    421                 self.graph_base.items()[v][att] = str(self.editValue) 
    422          
    423         self.setItems(self.graph_base.items()) 
    424          
    425     def drawForce(self): 
    426         if self.btnForce.isChecked() and self.graph is not None: 
    427             self.networkCanvas.forceVectors = self.layout._computeForces()  
    428         else: 
    429             self.networkCanvas.forceVectors = None 
    430              
    431         self.networkCanvas.updateCanvas() 
    432          
    433     def rotateProgress(self, curr, max): 
    434         self.progressBarSet(int(curr * 100 / max)) 
    435         qApp.processEvents() 
    436          
    437     def rotateComponentsMDS(self): 
    438         print "rotate" 
    439         if self.items_matrix is None: 
    440             self.information('Set distance matrix to input signal') 
    441             self.btnRotateMDS.setChecked(False) 
    442             return 
    443          
    444         if self.graph is None: 
    445             self.information('No network found') 
    446             self.btnRotateMDS.setChecked(False) 
    447             return 
    448         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    449             self.error('Distance matrix dimensionality must equal number of vertices') 
    450             self.btnRotateMDS.setChecked(False) 
    451             return 
    452          
    453         if not self.btnRotateMDS.isChecked(): 
    454           self.layout.stopMDS = 1 
    455           #self.btnMDS.setChecked(False) 
    456           #self.btnMDS.setText("MDS on graph components") 
    457           return 
    458          
    459         self.btnRotateMDS.setText("Stop") 
    460         qApp.processEvents() 
    461          
    462         self.layout.items_matrix = self.items_matrix 
    463         self.progressBarInit() 
    464          
    465         self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)             
    466              
    467         self.btnRotateMDS.setChecked(False) 
    468         self.btnRotateMDS.setText("Rotate graph components (MDS)") 
    469         self.progressBarFinished() 
    470      
    471     def rotateComponents(self): 
    472         if self.items_matrix is None: 
    473             self.information('Set distance matrix to input signal') 
    474             self.btnRotate.setChecked(False) 
    475             return 
    476          
    477         if self.graph is None: 
    478             self.information('No network found') 
    479             self.btnRotate.setChecked(False) 
    480             return 
    481          
    482         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    483             self.error('Distance matrix dimensionality must equal number of vertices') 
    484             self.btnRotate.setChecked(False) 
    485             return 
    486          
    487         if not self.btnRotate.isChecked(): 
    488           self.layout.stopRotate = 1 
    489           return 
    490        
    491         self.btnRotate.setText("Stop") 
    492         qApp.processEvents() 
    493          
    494         self.layout.items_matrix = self.items_matrix 
    495         self.progressBarInit() 
    496         self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas) 
    497         self.btnRotate.setChecked(False) 
    498         self.btnRotate.setText("Rotate graph components") 
    499         self.progressBarFinished() 
    500          
    501     def mdsProgress(self, avgStress, stepCount):     
    502         self.drawForce() 
    503  
    504         self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
    505         self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
    506         self.progressBarSet(int(stepCount * 100 / self.mdsSteps)) 
    507         qApp.processEvents() 
    508          
    509     def mds_components(self, mdsType=Orange.network.MdsType.componentMDS): 
    510         if mdsType == Orange.network.MdsType.componentMDS: 
    511             btn = self.btnMDS 
    512         elif mdsType == Orange.network.MdsType.exactSimulation: 
    513             btn = self.btnESIM 
    514         elif mdsType == Orange.network.MdsType.MDS: 
    515             btn = self.btnMDSv 
    516          
    517         btnCaption = btn.text() 
    518          
    519         if self.items_matrix is None: 
    520             self.information('Set distance matrix to input signal') 
    521             btn.setChecked(False) 
    522             return 
    523          
    524         if self.layout is None: 
    525             self.information('No network found') 
    526             btn.setChecked(False) 
    527             return 
    528          
    529         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    530             self.error('Distance matrix dimensionality must equal number of vertices') 
    531             btn.setChecked(False) 
    532             return 
    533          
    534         if not btn.isChecked(): 
    535             self.layout.stopMDS = 1 
    536             btn.setChecked(False) 
    537             btn.setText(btnCaption) 
    538             return 
    539          
    540         btn.setText("Stop") 
    541         qApp.processEvents() 
    542          
    543         self.layout.items_matrix = self.items_matrix 
    544         self.progressBarInit() 
    545          
    546         if self.mdsAvgLinkage: 
    547             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) 
    548         else: 
    549             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)             
    550          
    551         btn.setChecked(False) 
    552         btn.setText(btnCaption) 
    553         self.progressBarFinished() 
    554          
    555     def set_items_distance_matrix(self, matrix): 
    556         self.error('') 
    557         self.information('') 
    558         self.showDistancesCheckBox.setEnabled(0) 
    559          
    560         if matrix is None or self.graph is None: 
     50        def __init__(self, parent=None, signalManager=None, name = 'Net Explorer',  
     51                     NetworkCanvas=OWNxCanvas): 
     52            OWWidget.__init__(self, parent, signalManager, name) 
     53            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
     54            self.inputs = [("Nx View", Orange.network.NxView, self.set_network_view), 
     55                           ("Network", Orange.network.Graph, self.set_graph, Default), 
     56                           ("Items", Orange.data.Table, self.setItems), 
     57                           ("Items to Mark", Orange.data.Table, self.markItems),  
     58                           ("Items Subset", Orange.data.Table, self.setExampleSubset),  
     59                           ("Items Distance Matrix", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
     60             
     61            self.outputs = [("Selected Network", Orange.network.Graph), 
     62                            ("Selected Items Distance Matrix", Orange.core.SymMatrix), 
     63                            ("Selected Items", Orange.data.Table),  
     64                            ("Unselected Items", Orange.data.Table),  
     65                            ("Marked Items", Orange.data.Table), 
     66                            ("Attribute Selection List", AttributeList)] 
     67             
     68            self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
     69             
     70            self.markerAttributes = [] 
     71            self.tooltipAttributes = [] 
     72            self.edgeLabelAttributes = [] 
     73            self.attributes = [] 
     74            self.edgeAttributes = [] 
     75            self.autoSendSelection = False 
     76            self.graphShowGrid = 1  # show gridlines in the graph 
     77             
     78            self.markNConnections = 2 
     79            self.markNumber = 0 
     80            self.markProportion = 0 
     81            self.markSearchString = "" 
     82            self.markDistance = 2 
     83            self.frSteps = 1 
     84            self.hubs = 0 
     85            self.color = 0 
     86            self.edgeColor = 0 
     87            self.vertexSize = 0 
     88            self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = self.diameter = self.clustering_coefficient = 0 
     89            self.optimizeWhat = 1 
     90            self.maxLinkSize = 3 
     91            self.maxVertexSize = 5 
     92            self.minVertexSize = 5 
     93            self.labelsOnMarkedOnly = 0 
     94            self.invertSize = 0 
     95            self.optMethod = 0 
     96            self.lastVertexSizeColumn = '' 
     97            self.lastColorColumn = '' 
     98            self.lastNameComponentAttribute = '' 
     99            self.lastLabelColumns = set() 
     100            self.lastTooltipColumns = set() 
     101            self.showWeights = 0 
     102            self.showEdgeLabels = 0 
     103            self.colorSettings = None 
     104            self.selectedSchemaIndex = 0 
     105            self.edgeColorSettings = [('net_edges', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(204, 204, 204), (179, 226, 205), (253, 205, 172), (203, 213, 232), (244, 202, 228), (230, 245, 201), (255, 242, 174), (241, 226, 204)])]]), ('Default', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(0, 0, 255), (255, 0, 0), (0, 255, 0), (255, 128, 0), (255, 255, 0), (255, 0, 255), (0, 255, 255), (128, 0, 255), (0, 128, 255), (255, 223, 128), (127, 111, 64), (92, 46, 0), (0, 84, 0), (192, 192, 0), (0, 127, 127), (128, 0, 0), (127, 0, 127)])]])] 
     106            self.selectedEdgeSchemaIndex = 0 
    561107            self.items_matrix = None 
    562             self.layout.items_matrix = None 
    563             if self.networkCanvas: self.networkCanvas.items_matrix = None 
    564             return 
    565  
    566         if matrix.dim != self.graph.number_of_nodes(): 
    567             self.error('Distance matrix dimensionality must equal number of vertices') 
    568             self.items_matrix = None 
    569             self.layout.items_matrix = None 
    570             if self.networkCanvas: self.networkCanvas.items_matrix = None 
    571             return 
    572          
    573         self.items_matrix = matrix 
    574         self.layout.items_matrix = matrix 
    575         if self.networkCanvas: self.networkCanvas.items_matrix = matrix 
    576         self.showDistancesCheckBox.setEnabled(1) 
    577          
    578         self.networkCanvas.updateCanvas() 
    579              
    580     def setSendMarkedNodes(self): 
    581         if self.checkSendMarkedNodes: 
    582             self.networkCanvas.sendMarkedNodes = self.sendMarkedNodes 
    583             self.sendMarkedNodes(self.networkCanvas.getMarkedVertices()) 
    584         else: 
    585             self.send("Marked Items", None) 
    586             self.networkCanvas.sendMarkedNodes = None 
    587          
    588     def sendMarkedNodes(self, markedNodes):         
    589         if len(markedNodes) == 0: 
    590             self.send("Marked Items", None) 
    591             return 
    592          
    593         if self.graph is not None and self.graph_base.items() is not None: 
    594             items = self.graph_base.items().getitems(markedNodes) 
    595             self.send("Marked Items", items) 
    596             return 
    597          
    598         self.send("Marked Items", None) 
    599          
    600     def insideviewneighbours(self): 
    601         if self.networkCanvas.insideview == 1: 
    602             self.networkCanvas.insideviewNeighbours = self.insideViewNeighbours 
    603             self.optButton.setChecked(True) 
    604             self.graph_layout_fr(False) 
    605          
    606     def insideview(self): 
    607         print self.networkCanvas.getSelectedVertices() 
    608         if len(self.networkCanvas.getSelectedVertices()) == 1: 
    609             if self.networkCanvas.insideview == 1: 
    610                 print "insideview: 1" 
    611                 self.networkCanvas.insideview = 0 
    612                 self.networkCanvas.showAllVertices() 
    613                 self.networkCanvas.updateCanvas() 
    614             else: 
    615                 print "insideview: 0" 
    616                 self.networkCanvas.insideview = 1 
    617                 self.networkCanvas.insideviewNeighbors = self.insideViewNeighbours 
    618                 self.optButton.setChecked(True) 
    619                 self.graph_layout_fr(False) 
    620      
    621         else: 
    622             print "One node must be selected!" 
    623          
    624     def showComponents(self): 
    625         if self.graph is None or self.graph_base.items() is None: 
    626             return 
    627          
    628         vars = [x.name for x in self.graph_base.items_vars()] 
    629          
    630         if not self.showComponentCombo.currentText() in vars: 
    631             self.networkCanvas.showComponentAttribute = None 
    632             self.lastNameComponentAttribute = '' 
    633         else: 
    634             self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
    635              
    636         self.networkCanvas.drawPlotItems() 
    637          
    638     def nameComponents(self): 
    639         """Names connected components of genes according to GO terms.""" 
    640         self.progressBarFinished() 
    641         self.lastNameComponentAttribute = None 
    642          
    643         if self.graph is None or self.graph_base.items() is None: 
    644             return 
    645          
    646         vars = [x.name for x in self.graph_base.items_vars()] 
    647         if not self.nameComponentCombo.currentText() in vars: 
    648             return 
    649          
    650         self.progressBarInit() 
    651         components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    652         if 'component name' in self.graph_base.items().domain: 
    653             keyword_table = self.graph_base.items() 
    654         else: 
    655             keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    656          
    657         import obiGO  
    658         ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
    659         annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    660  
    661         allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    662         foundGenesets = False 
    663         if len(annotations.geneNames & allGenes) < 1: 
    664             allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    665             if len(annotations.geneNames & allGenes) < 1:             
    666                 self.warning('no genes found') 
    667                 return 
    668             else: 
    669                 foundGenesets = True 
    670              
    671         def rank(a, j, reverse=False):                     
    672             if len(a) <= 0: return 
    673              
    674             if reverse:                 
    675                 a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
    676                 top_value = a[0][j] 
    677                 top_rank = len(a) 
    678                 max_rank = float(len(a)) 
    679                 int_ndx = 0 
    680                 for k in range(len(a)): 
    681                     if top_value < a[k][j]: 
    682                         top_value = a[k][j]  
    683                         if k - int_ndx > 1: 
    684                             avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    685                             for l in range(int_ndx, k): 
    686                                 a[l][j] = avg_rank 
    687                          
    688                         int_ndx = k 
    689  
    690                     a[k][j] = top_rank / max_rank 
    691                     top_rank -= 1 
    692                  
    693                 k += 1 
    694                 if k - int_ndx > 1: 
    695                     avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    696                     for l in range(int_ndx, k): 
    697                         a[l][j] = avg_rank     
    698                  
    699             else: 
    700                 a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
    701                 top_value = a[0][j] 
    702                 top_rank = len(a) 
    703                 max_rank = float(len(a)) 
    704                 int_ndx = 0 
    705                 for k in range(len(a)): 
    706                     if top_value > a[k][j]: 
    707                         top_value = a[k][j]  
    708                         if k - int_ndx > 1: 
    709                             avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    710                             for l in range(int_ndx, k): 
    711                                 a[l][j] = avg_rank 
    712                          
    713                         int_ndx = k 
    714  
    715                     a[k][j] = top_rank / max_rank 
    716                     top_rank -= 1 
    717                  
    718                 k += 1 
    719                 if k - int_ndx > 1: 
    720                     avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
    721                     for l in range(int_ndx, k): 
    722                         a[l][j] = avg_rank 
    723          
    724         for i in range(len(components)): 
    725             component = components[i] 
    726             if len(component) <= 1: 
    727                 continue 
    728              
    729             if foundGenesets: 
    730                 genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    731             else: 
    732                 genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    733                      
    734             res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    735             res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
    736             res = res1_base.items() + res2.items() 
    737             #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] 
    738             #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] 
    739              
    740             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] 
    741             if len(namingScore) == 0: 
    742                 continue 
    743              
    744             annotated_genes = max([a[0] for a in namingScore]) 
    745              
    746             rank(namingScore, 1, reverse=True) 
    747             rank(namingScore, 2, reverse=True) 
    748             rank(namingScore, 0) 
    749              
    750             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] 
    751             namingScore.sort(reverse=True) 
    752              
    753             if len(namingScore) < 1: 
    754                 print "warning. no annotations found for group of genes: " + ", ".join(genes) 
    755                 continue 
    756             elif len(namingScore[0]) < 2: 
    757                 print "warning. error computing score for group of genes: " + ", ".join(genes) 
    758                 continue 
    759              
    760             for v in component: 
    761                 name = str(namingScore[0][1]) 
    762                 attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4]) 
    763                 info = '' 
    764                 if self.showTextMiningInfo: 
    765                     info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
    766                 keyword_table[v]['component name'] = name + info 
    767              
    768             self.progressBarSet(i*100.0/len(components)) 
    769                  
    770         self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    771         self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    772         self.progressBarFinished()    
    773          
    774     def nameComponents_old(self): 
    775         if self.graph is None or self.graph_base.items() is None: 
    776             return 
    777          
    778         vars = [x.name for x in self.graph_base.items_vars()] 
    779          
    780         if not self.nameComponentCombo.currentText() in vars: 
    781             return 
    782          
    783         components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    784         keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
    785          
    786         excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"] 
    787         excludePart = ["HSA"] 
    788         keywords = set() 
    789         sameKeywords = set() 
    790          
    791         for component in components: 
    792             words = [] 
    793             all_values = [] 
    794             for vertex in component: 
    795                 values = [] 
    796                 value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    797                  
    798                 value = value.replace(" ", ",") 
    799                 value_top = value.split(",") 
    800                  
    801                 for value in value_top: 
    802                     if len(value) > 0: 
    803                         tmp = value.split("_") 
    804                         tmp = [value.strip() for value in tmp if len(value) > 0] 
    805                         all_values.append(tmp) 
    806                         values.extend(tmp) 
    807                                  
    808                 values = [value.strip() for value in values if len(value) > 0] 
    809                 words.extend(values) 
    810                  
    811                  
    812                 #value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    813                 #value = value.replace(" ", "_") 
    814                 #value = value.replace(",", "_") 
    815                 #values = value.split("_") 
    816                 #values = [value.strip() for value in values if len(value) > 0] 
    817                 #print "values:", values 
    818                 #all_values.append(values) 
    819                  
    820                 #words.extend(values) 
    821             #print "all_values:", all_values 
    822             toExclude = [] 
    823              
    824             words = [word for word in words if not word.upper() in excludeWord] 
    825             toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
    826              
    827             for word in toExclude: 
    828                 try: 
    829                     while True: 
    830                         words.remove(word) 
    831                 except: 
    832                     pass 
    833              
    834             counted_words = {} 
    835             for word in words: 
    836                 if word in counted_words: 
    837                     count = counted_words[word] 
    838                     counted_words[word] = count + 1 
    839                 else: 
    840                     counted_words[word] = 1 
    841              
    842             words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
    843             keyword = "" 
    844             keyword_words = [] 
    845             max_count = 0 
    846             i = 0 
    847              
    848             while i < len(words) and words[i][1] >= max_count: 
    849                 max_count = words[i][1] 
    850                 keyword += words[i][0] + " " 
    851                 keyword_words.append(words[i][0]) 
    852                 i += 1 
    853              
    854             if len(keyword_words) > 1: 
    855                 new_all_values = [] 
    856                 for values in all_values: 
    857                     new_values = [value for value in values if value in keyword_words] 
    858                     new_all_values.append(new_values)  
    859                       
    860                 #print new_all_values 
    861                 word_position = [] 
    862                  
    863                 for word in keyword_words: 
    864                     sum = 0 
    865                     for v in new_all_values: 
    866                         if word in v: 
    867                             sum += v.index(word) 
    868                              
    869                     word_position.append((word, sum)) 
    870                   
    871                 words = sorted(word_position, key=itemgetter(1)) 
    872                 #print "words:", words 
    873                 #print all_values 
    874                 #print new_all_values 
    875                  
    876                 keyword = "" 
    877                 for word in words: 
    878                     keyword += word[0] + " " 
    879                      
    880             keyword = keyword.strip() 
    881              
    882             for vertex in component: 
    883                 keyword_table[vertex]['component name'] = keyword 
    884                  
    885             if keyword in keywords: 
    886                 sameKeywords.add(keyword) 
    887             else: 
    888                 keywords.add(keyword) 
    889         #print "sameKeywords:", sameKeywords        
    890         sameComponents = [component for component in components if str(keyword_table[component[0]]['component name']) in sameKeywords] 
    891         #print "same components:", sameComponents 
    892          
    893         for component in sameComponents: 
    894             words = [] 
    895             all_values = [] 
    896             for vertex in component: 
    897                 values = [] 
    898                 value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    899                  
    900                 value = value.replace(" ", ",") 
    901                 value_top = value.split(",") 
    902                  
    903                 for value in value_top: 
    904                     if len(value) > 0: 
    905                         tmp = value.split("_") 
    906                         tmp = [value.strip() for value in tmp if len(value) > 0] 
    907                         all_values.append(tmp) 
    908                         values.extend(tmp) 
    909                                  
    910                 values = [value.strip() for value in values if len(value) > 0] 
    911                 words.extend(values) 
    912              
    913             toExclude = [] 
    914              
    915             words = [word for word in words if not word.upper() in excludeWord] 
    916             toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
    917              
    918             for word in toExclude: 
    919                 try: 
    920                     while True: 
    921                         words.remove(word) 
    922                 except: 
    923                     pass 
    924              
    925             counted_words = {} 
    926             for word in words: 
    927                 if word in counted_words: 
    928                     count = counted_words[word] 
    929                     counted_words[word] = count + 1 
    930                 else: 
    931                     counted_words[word] = 1 
    932              
    933             words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
    934             keyword = "" 
    935             counts = [int(word[1]) for word in words]  
    936             max_count = max(counts) 
    937              
    938             try: 
    939                 while True and len(counts) > 1: 
    940                     counts.remove(max_count) 
    941             except: 
    942                 pass 
    943             max_count = max(counts) 
    944             i = 0 
    945             keyword_words = [] 
    946             while i < len(words) and words[i][1] >= max_count: 
    947                 keyword += words[i][0] + " " 
    948                 keyword_words.append(words[i][0]) 
    949                 i += 1 
    950                  
    951             if len(keyword_words) > 1: 
    952                 new_all_values = [] 
    953                 for values in all_values: 
    954                     new_values = [value for value in values if value in keyword_words] 
    955                     new_all_values.append(new_values)  
    956                       
    957                 #print new_all_values 
    958                 word_position = [] 
    959                  
    960                 for word in keyword_words: 
    961                     sum = 0 
    962                     for v in new_all_values: 
    963                         if word in v: 
    964                             sum += v.index(word) 
    965                              
    966                     word_position.append((word, sum)) 
    967                   
    968                 words = sorted(word_position, key=itemgetter(1)) 
    969                 #print "words:", words 
    970                 #print all_values 
    971                 #print new_all_values 
    972                  
    973                 keyword = "" 
    974                 for word in words: 
    975                     keyword += word[0] + " " 
    976                   
    977             keyword = keyword.strip() 
    978             for vertex in component: 
    979                 keyword_table[vertex]['component name'] = keyword 
    980          
    981         self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    982         #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute 
    983         items = Orange.data.Table([self.graph_base.items(), keyword_table]) 
    984         self.setItems(items) 
    985          
    986         #for item in items: 
    987         #    print item 
    988                          
    989     def _set_canvas_attr(self, attr, value): 
    990         setattr(self.networkCanvas, attr, value) 
    991         self.networkCanvas.updateCanvas() 
    992                  
    993     def setSearchStringTimer(self): 
    994         self.hubs = 1 
    995         self.searchStringTimer.stop() 
    996         self.searchStringTimer.start(1000) 
    997           
    998     def setMarkMode(self, i = None): 
    999         self.searchStringTimer.stop() 
    1000         if not i is None: 
    1001             self.hubs = i 
    1002          
    1003         #print self.hubs 
    1004         self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0 
    1005         self.networkCanvas.markWithRed = False 
    1006  
    1007         if self.graph is None: 
    1008             return 
    1009          
    1010         hubs = self.hubs 
    1011         if hubs == 0: 
    1012             self.networkCanvas.setMarkedVertices([]) 
    1013             self.networkCanvas.replot() 
    1014             return 
    1015          
    1016         elif hubs == 1: 
    1017             #print "mark on given label" 
    1018             txt = self.markSearchString 
    1019             labelText = self.networkCanvas.labelText 
    1020             self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
    1021              
    1022             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()])] 
    1023             self.networkCanvas.setMarkedVertices(toMark) 
    1024             self.networkCanvas.replot() 
    1025             return 
    1026          
    1027         elif hubs == 2: 
    1028             #print "mark on focus" 
    1029             self.networkCanvas.unmark() 
    1030             self.networkCanvas.tooltipNeighbours = self.markDistance 
    1031             return 
    1032  
    1033         elif hubs == 3: 
    1034             #print "mark selected" 
    1035             self.networkCanvas.unmark() 
    1036             self.networkCanvas.selectionNeighbours = self.markDistance 
    1037             self.networkCanvas.markSelectionNeighbours() 
    1038             return 
    1039          
    1040         self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
    1041         powers = self.graph.degree() 
    1042         powers = [powers[key] for key in sorted(powers.keys())] 
    1043          
    1044         if hubs == 4: # at least N connections 
    1045             #print "mark at least N connections" 
    1046             N = self.markNConnections 
    1047             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power >= N]) 
    1048             self.networkCanvas.replot() 
    1049         elif hubs == 5: 
    1050             #print "mark at most N connections" 
    1051             N = self.markNConnections 
    1052             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power <= N]) 
    1053             self.networkCanvas.replot() 
    1054         elif hubs == 6: 
    1055             #print "mark more than any" 
    1056             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    1057             self.networkCanvas.replot() 
    1058         elif hubs == 7: 
    1059             #print "mark more than avg" 
    1060             self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    1061             self.networkCanvas.replot() 
    1062         elif hubs == 8: 
    1063             #print "mark most" 
    1064             sortedIdx = range(len(powers)) 
    1065             sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y])) 
    1066             cutP = self.markNumber - 1 
    1067             cutPower = powers[sortedIdx[cutP]] 
    1068             while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower: 
    1069                 cutP += 1 
    1070             self.networkCanvas.setMarkedVertices(sortedIdx[:cutP]) 
    1071             self.networkCanvas.replot() 
    1072         elif hubs == 9: 
    1073             self.setMarkInput() 
    1074         
    1075     def testRefresh(self): 
    1076         start = time.time() 
    1077         self.networkCanvas.replot() 
    1078         stop = time.time()     
    1079         print "replot in " + str(stop - start) 
    1080          
    1081     def save_network(self): 
    1082         if self.networkCanvas is None or self.graph is None: 
    1083             return 
    1084          
    1085         filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
    1086         if filename: 
    1087             fn = "" 
    1088             head, tail = os.path.splitext(str(filename)) 
    1089             if not tail: 
    1090                 fn = head + ".net" 
    1091             else: 
    1092                 fn = str(filename) 
    1093              
    1094             for i in range(self.graph.number_of_nodes()): 
    1095                 node = self.graph.node[i] 
    1096                 node['x'] = self.layout.coors[0][i] 
    1097                 node['y'] = self.layout.coors[1][i] 
    1098  
    1099             Orange.network.readwrite.write(self.graph, fn) 
    1100              
    1101     def sendData(self): 
    1102         graph = self.networkCanvas.getSelectedGraph() 
    1103         vertices = self.networkCanvas.getSelectedVertices() 
    1104          
    1105         if graph is not None: 
    1106             if graph.items() is not None: 
    1107                 self.send("Selected Items", graph.items()) 
    1108             else: 
    1109                 nodes = self.networkCanvas.getSelectedExamples() 
    1110                  
    1111                 if len(nodes) > 0 and self.graph_base.items() is not None: 
    1112                     self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
    1113                 else: 
    1114                     self.send("Selected Items", None) 
    1115                  
    1116             nodes = self.networkCanvas.getUnselectedExamples() 
    1117             if len(nodes) > 0 and self.graph_base.items() is not None: 
    1118                 self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
    1119             else: 
    1120                 self.send("Unselected Items", None) 
    1121                  
    1122             self.send("Selected Network", graph) 
    1123         else: 
    1124             nodes = self.networkCanvas.getSelectedExamples() 
    1125             if len(nodes) > 0 and self.graph_base.items() is not None: 
    1126                 self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
    1127             else: 
    1128                 self.send("Selected Items", None) 
    1129                  
    1130             nodes = self.networkCanvas.getUnselectedExamples() 
    1131             if len(nodes) > 0 and self.graph_base.items() is not None: 
    1132                 self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
    1133             else: 
    1134                 self.send("Unselected Items", None) 
    1135          
    1136         matrix = None 
    1137         if self.items_matrix is not None: 
    1138             matrix = self.items_matrix.getitems(vertices) 
    1139  
    1140         self.send("Selected Items Distance Matrix", matrix) 
    1141                  
    1142     def setCombos(self): 
    1143         vars = self.graph_base.items_vars() 
    1144         edgeVars = self.graph_base.links_vars() 
    1145         lastLabelColumns = self.lastLabelColumns 
    1146         lastTooltipColumns = self.lastTooltipColumns 
    1147          
    1148         self.clearCombos() 
    1149          
    1150         self.attributes = [(var.name, var.varType) for var in vars] 
    1151         self.edgeAttributes = [(var.name, var.varType) for var in edgeVars] 
    1152          
    1153         for var in vars: 
    1154             if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    1155                 self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1156                  
    1157             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: 
    1158                  
    1159                 value = self.graph_base.items()[0][var].value 
    1160                  
    1161                 # can value be a list? 
    1162                 try: 
    1163                     if type(eval(value)) == type([]): 
    1164                         self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1165                         continue 
    1166                 except: 
    1167                     pass 
    1168                  
    1169                 if len(value.split(',')) > 1: 
    1170                     self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    1171                  
    1172             elif var.varType in [Orange.data.Type.Continuous]: 
    1173                 self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1174  
    1175             self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1176             self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1177             self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1178             self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1179          
    1180         for var in edgeVars: 
    1181             if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    1182                 self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    1183                  
    1184         for i in range(self.vertexSizeCombo.count()): 
    1185             if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i): 
    1186                 self.vertexSize = i 
    1187                 break 
    1188              
    1189         for i in range(self.colorCombo.count()): 
    1190             if self.lastColorColumn == self.colorCombo.itemText(i): 
    1191                 self.color = i 
    1192                 break 
    1193  
    1194         for i in range(self.attListBox.count()): 
    1195             if str(self.attListBox.item(i).text()) in lastLabelColumns: 
    1196                 self.attListBox.item(i).setSelected(1) 
    1197                  
    1198         for i in range(self.tooltipListBox.count()): 
    1199             if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns: 
    1200                 self.tooltipListBox.item(i).setSelected(1) 
    1201              
    1202         self.lastLabelColumns = lastLabelColumns 
    1203         self.lastTooltipColumns = lastTooltipColumns 
    1204          
    1205     def clearCombos(self): 
    1206         self.attributes = [] 
    1207         self.edgeAttributes = [] 
    1208          
    1209         self.colorCombo.clear() 
    1210         self.vertexSizeCombo.clear() 
    1211         self.nameComponentCombo.clear() 
    1212         self.showComponentCombo.clear() 
    1213         self.edgeColorCombo.clear() 
    1214         self.editCombo.clear() 
    1215         self.comboAttSelection.clear() 
    1216          
    1217         self.colorCombo.addItem("(same color)") 
    1218         self.edgeColorCombo.addItem("(same color)") 
    1219         self.vertexSizeCombo.addItem("(same size)") 
    1220         self.nameComponentCombo.addItem("Select attribute") 
    1221         self.showComponentCombo.addItem("Select attribute") 
    1222         self.editCombo.addItem("Select attribute") 
    1223         self.comboAttSelection.addItem("Select attribute") 
    1224        
    1225     def change_graph(self, newgraph): 
    1226         old_nodes = set(self.graph.nodes_iter()) 
    1227         new_nodes = set(newgraph.nodes_iter()) 
    1228         inter_nodes = old_nodes.intersection(new_nodes) 
    1229         remove_nodes = old_nodes.difference(inter_nodes) 
    1230         add_nodes = new_nodes.difference(inter_nodes) 
    1231          
    1232         [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes] 
    1233         self.networkCanvas.networkCurve.coors.update((node, (0,0)) for node in add_nodes) 
    1234         positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
    1235         self.layout.set_graph(newgraph, positions) 
    1236          
    1237         self.graph = newgraph 
    1238         self.number_of_nodes_label = self.graph.number_of_nodes() 
    1239         self.number_of_edges_label = self.graph.number_of_edges() 
    1240          
    1241         self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes) 
    1242          
    1243 #        self.nShown = self.graph.number_of_nodes() 
    1244 #         
    1245 #        if self.graph.number_of_edges() > 0: 
    1246 #            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    1247 #        else: 
    1248 #            self.verticesPerEdge = 0 
    1249 #             
    1250 #        if self.graph.number_of_nodes() > 0: 
    1251 #            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    1252 #        else: 
    1253 #            self.edgesPerVertex = 0 
    1254 #         
    1255 #        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    1256 #        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    1257 #        if len(components) > 1: 
    1258 #            self.diameter = -1 
    1259 #        else: 
    1260 #            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    1261 #        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    1262          
    1263         k = 1.13850193174e-008 
    1264         nodes = self.graph.number_of_nodes() 
    1265         t = k * nodes * nodes 
    1266         self.frSteps = int(5.0 / t) 
    1267         if self.frSteps <   1: self.frSteps = 1; 
    1268         if self.frSteps > 3000: self.frSteps = 3000; 
    1269          
    1270         if self.frSteps < 10: 
    1271             self.renderAntialiased = 0 
    1272             self.minVertexSize = 5 
    1273             self.maxVertexSize = 5 
    1274             self.maxLinkSize = 1 
    1275             self.optMethod = 0 
    1276             self.graph_layout_method()             
    1277              
    1278         #self.setVertexColor() 
    1279         #self.setEdgeColor() 
    1280         #self.networkCanvas.setEdgesSize() 
    1281          
    1282         #self.clickedAttLstBox() 
    1283         #self.clickedTooltipLstBox() 
    1284         #self.clickedEdgeLabelListBox() 
    1285          
    1286         self.optButton.setChecked(1) 
    1287         self.graph_layout()         
    1288         self.information(0) 
    1289          
    1290     def set_graph(self, graph): 
    1291         self.set_items_distance_matrix(None) 
    1292               
    1293         if graph is None: 
     108            self.showDistances = 0 
     109            self.showMissingValues = 0 
     110            self.fontSize = 12 
     111            self.mdsTorgerson = 0 
     112            self.mdsAvgLinkage = 1 
     113            self.mdsSteps = 10000 
     114            self.mdsRefresh = 50 
     115            self.mdsStressDelta = 0.0000001 
     116            self.organism = 'goa_human' 
     117            self.showTextMiningInfo = 0 
     118            self.toolbarSelection = 0 
     119            self.minComponentEdgeWidth = 10 
     120            self.maxComponentEdgeWidth = 70 
     121            self.mdsFromCurrentPos = 0 
     122            self.tabIndex = 0 
     123            self.number_of_nodes_label = -1 
     124            self.number_of_edges_label = -1 
     125            self.opt_from_curr = False 
     126             
     127            self.loadSettings() 
     128             
     129            self._network_view = None 
    1294130            self.graph = None 
    1295131            self.graph_base = None 
    1296             self.layout.set_graph(None) 
    1297             self.networkCanvas.set_graph_layout(None, None) 
     132            self.markInputItems = None 
     133             
     134            # if optimization method is set to FragViz, set it to FR 
     135            if self.optMethod == 9: 
     136                self.optMethod = 3 
     137             
     138            self.mainArea.layout().setContentsMargins(0,4,4,4) 
     139            self.controlArea.layout().setContentsMargins(4,4,0,4) 
     140             
     141            self.networkCanvas.showMissingValues = self.showMissingValues 
     142            self.mainArea.layout().addWidget(self.networkCanvas) 
     143             
     144            self.networkCanvas.maxLinkSize = self.maxLinkSize 
     145             
     146            self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal') 
     147             
     148            self.tabs = OWGUI.tabWidget(self.hcontroArea) 
     149             
     150            self.verticesTab = OWGUI.createTabPage(self.tabs, "Nodes") 
     151            self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges") 
     152            self.markTab = OWGUI.createTabPage(self.tabs, "Mark") 
     153            self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
     154            self.performanceTab = OWGUI.createTabPage(self.tabs, "Performance") 
     155             
     156            self.tabs.setCurrentIndex(self.tabIndex) 
     157            self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index)) 
     158             
     159            self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False) 
     160             
     161            self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method) 
     162            self.optCombo.addItem("No optimization") 
     163            self.optCombo.addItem("Random") 
     164            self.optCombo.addItem("Fruchterman Reingold") 
     165            self.optCombo.addItem("Fruchterman Reingold Weighted") 
     166            self.optCombo.addItem("Fruchterman Reingold Radial") 
     167            self.optCombo.addItem("Circular Crossing Reduction") 
     168            self.optCombo.addItem("Circular Original") 
     169            self.optCombo.addItem("Circular Random") 
     170            self.optCombo.addItem("Pivot MDS") 
     171            self.optCombo.addItem("FragViz") 
     172            self.optCombo.addItem("MDS") 
     173            self.optCombo.setCurrentIndex(self.optMethod) 
     174            self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
     175            self.cb_opt_from_curr = OWGUI.checkBox(self.optimizeBox, self, "opt_from_curr", label="Optimize from current positions") 
     176            self.cb_opt_from_curr.setEnabled(False) 
     177            self.stepsSpin.setEnabled(False) 
     178             
     179            self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1) 
     180             
     181            colorBox = OWGUI.widgetBox(self.verticesTab, "Node color attribute", orientation="horizontal", addSpace = False) 
     182            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.set_node_colors) 
     183            self.colorCombo.addItem("(same color)") 
     184            OWGUI.button(colorBox, self, "Set node color palette", self.setColors, tooltip = "Set node color palette", debuggingEnabled = 0) 
     185             
     186            ib = OWGUI.widgetBox(self.verticesTab, "Node size attribute", orientation="vertical", addSpace = False) 
     187            hb = OWGUI.widgetBox(ib, orientation="horizontal", addSpace = False) 
     188            OWGUI.checkBox(hb, self, "invertSize", "Invert size", callback = self.set_node_sizes) 
     189            OWGUI.spin(hb, self, "minVertexSize", 5, 200, 1, label="Min:", callback=self.set_node_sizes) 
     190            OWGUI.spin(hb, self, "maxVertexSize", 5, 200, 1, label="Max:", callback=self.set_node_sizes) 
     191            self.vertexSizeCombo = OWGUI.comboBox(ib, self, "vertexSize", callback=self.set_node_sizes) 
     192            self.vertexSizeCombo.addItem("(none)") 
     193             
     194            self.attBox = OWGUI.widgetBox(self.verticesTab, "Node labels | tooltips", orientation="vertical", addSpace = False) 
     195            OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback = self.set_font_size) 
     196            hb = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False) 
     197            self.attListBox = OWGUI.listBox(hb, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
     198            self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox)         
     199            OWGUI.spin(self.attBox, self, "networkCanvas.trim_label_words", 0, 5, 1, label='Trim label words to', callback=self.clickedAttLstBox) 
     200             
     201            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
     202            OWGUI.checkBox(ib, self, 'networkCanvas.show_weights', 'Show weights', callback=self.networkCanvas.set_edge_labels) 
     203            #OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
     204            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.set_edge_sizes) 
     205            self.cb_show_distances = OWGUI.checkBox(ib, self, 'networkCanvas.explore_distances', 'Explore node distances', callback=None, disabled=1) 
     206            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) 
     207             
     208            colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace = False) 
     209            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.set_edge_colors) 
     210            self.edgeColorCombo.addItem("(same color)") 
     211            OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip = "Set edge color palette", debuggingEnabled = 0) 
     212             
     213            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False) 
     214            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox) 
     215            #self.edgeLabelBox.setEnabled(False) 
     216             
     217            ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
     218            OWGUI.checkBox(ib, self, 'networkCanvas.show_indices', 'Show indices', callback=self.networkCanvas.set_node_labels) 
     219            OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked nodes only', callback=(lambda: self.networkCanvas.set_labels_on_marked_only(self.labelsOnMarkedOnly))) 
     220             
     221            ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical") 
     222            OWGUI.label(ib, self, "Nodes (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)") 
     223            OWGUI.label(ib, self, "Selected: %(nSelected)i, marked: %(nMarked)i") 
     224             
     225            ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Mark", callback = self.set_mark_mode) 
     226            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.set_mark_mode) 
     227            OWGUI.appendRadioButton(ribg, self, "hubs", "Search", callback = self.set_mark_mode) 
     228            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
     229            self.searchStringTimer = QTimer(self) 
     230            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.set_mark_mode) 
     231             
     232            OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbors of focused", callback = self.set_mark_mode) 
     233            OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbours of selected", callback = self.set_mark_mode) 
     234            ib = OWGUI.indentedBox(ribg, orientation = 0) 
     235            self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.set_mark_mode(h))) 
     236            #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
     237            OWGUI.widgetLabel(ribg, "Mark nodes with ...") 
     238            OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.set_mark_mode) 
     239            OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.set_mark_mode) 
     240            self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.set_mark_mode(h))) 
     241            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.set_mark_mode) 
     242            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.set_mark_mode) 
     243            OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.set_mark_mode) 
     244            ib = OWGUI.indentedBox(ribg) 
     245            self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of nodes:", callback=(lambda h=8: self.set_mark_mode(h))) 
     246            OWGUI.widgetLabel(ib, "(More nodes are marked in case of ties)") 
     247            self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark nodes given in the input signal", callback = self.set_mark_mode) 
     248            ib = OWGUI.indentedBox(ribg) 
     249            self.markInput = 0 
     250            self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.set_mark_mode(h))) 
     251            self.markInputRadioButton.setEnabled(False) 
     252             
     253            ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
     254            self.checkSendMarkedNodes = 0 
     255            OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked nodes', callback = self.send_marked_nodes, disabled=0) 
     256             
     257            G = self.networkCanvas.gui 
     258             
     259            self.zoomSelectToolbar = G.zoom_select_toolbar(self.hcontroArea, orientation = Qt.Vertical, 
     260                buttons =  
     261                    [G.Spacing] * 2 +  
     262                    G.default_zoom_select_buttons +  
     263                    [ 
     264                        G.Spacing, 
     265                        ("buttonM2S", "Add marked to selection", None, None, "marked_to_selected", 'Dlg_Mark2Sel'), 
     266                        ("buttonS2M", "Add selection to marked", None, None, "selected_to_marked", 'Dlg_Sel2Mark'), 
     267                        G.Spacing, 
     268                        ("buttonSEL", "Hide selected", None, None, "hideSelectedVertices", 'Dlg_UnselectedNodes'), 
     269                        ("buttonUN", "Hide unselected", None, None, "hideUnSelectedVertices", 'Dlg_SelectedNodes'), 
     270                        ("buttonSW", "Show all nodes", None, None, "showAllVertices", 'Dlg_clear'), 
     271                    ]) 
     272            self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_data) 
     273            OWGUI.rubber(self.zoomSelectToolbar) 
     274             
     275            ib = OWGUI.widgetBox(self.infoTab, "General") 
     276            OWGUI.label(ib, self, "Number of nodes: %(number_of_nodes_label)i") 
     277            OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i") 
     278            OWGUI.label(ib, self, "Nodes per edge: %(verticesPerEdge).2f") 
     279            OWGUI.label(ib, self, "Edges per node: %(edgesPerVertex).2f") 
     280            OWGUI.label(ib, self, "Diameter: %(diameter).0f") 
     281            OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%") 
     282             
     283            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
     284             
     285            OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False) 
     286            OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False) 
     287            OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
     288             
     289            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
     290            ib = OWGUI.widgetBox(self.infoTab, "Edit") 
     291            self.editAttribute = 0 
     292            self.editCombo = OWGUI.comboBox(ib, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
     293            self.editCombo.addItem("Select attribute") 
     294            self.editValue = '' 
     295            hb = OWGUI.widgetBox(ib, orientation="horizontal") 
     296            OWGUI.lineEdit(hb, self, "editValue", "Value:", orientation='horizontal') 
     297            OWGUI.button(hb, self, "Set", callback=self.edit) 
     298             
     299            ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
     300            ib.setVisible(True) 
     301             
     302            OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
     303             
     304            self.nameComponentAttribute = 0 
     305            self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal") 
     306            self.nameComponentCombo.addItem("Select attribute") 
     307             
     308            self.showComponentAttribute = 0 
     309            self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal") 
     310            self.showComponentCombo.addItem("Select attribute") 
     311            OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info") 
     312             
     313            #OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
     314            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
     315            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
     316             
     317            self.attSelectionAttribute = 0 
     318            self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList) 
     319            self.comboAttSelection.addItem("Select attribute") 
     320            self.autoSendAttributes = 0 
     321            OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes) 
     322             
     323            self.icons = self.createAttributeIconDict() 
     324            self.set_mark_mode() 
     325             
     326            self.networkCanvas.gui.effects_box(self.performanceTab) 
     327             
     328            self.verticesTab.layout().addStretch(1) 
     329            self.edgesTab.layout().addStretch(1) 
     330            self.markTab.layout().addStretch(1) 
     331            self.infoTab.layout().addStretch(1) 
     332            self.performanceTab.layout().addStretch(1) 
     333             
     334            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
     335            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
     336            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
     337             
     338            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     339            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
     340            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
     341             
     342            self.graph_layout_method() 
     343            self.set_font_size() 
     344            self.set_graph(None) 
     345            self.setMinimumWidth(900) 
     346             
     347        def setComponentEdgeWidth(self, changedMin=True): 
     348            if self.networkCanvas is None: 
     349                return 
     350             
     351            canvas = self.networkCanvas 
     352            if changedMin: 
     353                if self.maxComponentEdgeWidth < self.minComponentEdgeWidth: 
     354                    self.maxComponentEdgeWidth = self.minComponentEdgeWidth 
     355            else: 
     356                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
     357                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
     358             
     359            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     360            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
     361            self.networkCanvas.updateCanvas() 
     362         
     363        def setAutoSendAttributes(self): 
     364            print 'TODO setAutoSendAttributes' 
     365            #if self.autoSendAttributes: 
     366            #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
     367            #else: 
     368            #    self.networkCanvas.callbackSelectVertex = None 
     369     
     370        def sendAttSelectionList(self): 
     371            if not self.graph is None: 
     372                vars = [x.name for x in self.graph_base.links_vars()] 
     373                if not self.comboAttSelection.currentText() in vars: 
     374                    return 
     375                att = str(self.comboAttSelection.currentText()) 
     376                vertices = self.networkCanvas.selected_nodes() 
     377                 
     378                if len(vertices) != 1: 
     379                    return 
     380                 
     381                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
     382            else: 
     383                attributes = None 
     384            self.send("Attribute Selection List", attributes) 
     385             
     386        def edit(self): 
     387            if self.graph is None: 
     388                return 
     389             
     390            vars = [x.name for x in self.graph_base.items_vars()] 
     391            if not self.editCombo.currentText() in vars: 
     392                return 
     393            att = str(self.editCombo.currentText()) 
     394            vertices = self.networkCanvas.selected_nodes() 
     395             
     396            if len(vertices) == 0: 
     397                return 
     398             
     399            items = self.graph_base.items() 
     400            if items.domain[att].var_type == Orange.data.Type.Continuous: 
     401                for v in vertices: 
     402                    items[v][att] = float(self.editValue) 
     403            else: 
     404                for v in vertices: 
     405                    items[v][att] = str(self.editValue) 
     406         
     407        def set_items_distance_matrix(self, matrix): 
     408            self.error() 
     409            self.warning() 
     410            self.information() 
     411             
     412            self.cb_show_distances.setEnabled(0) 
     413            self.cb_show_component_distances.setEnabled(0) 
     414             
     415            if matrix is None or self.graph_base is None: 
     416                self.items_matrix = None 
     417                self.networkCanvas.items_matrix = None 
     418                self.information('No graph found!') 
     419                return 
     420     
     421            if matrix.dim != self.graph_base.number_of_nodes(): 
     422                self.error('The number of vertices does not match matrix size.') 
     423                self.items_matrix = None 
     424                self.networkCanvas.items_matrix = None 
     425                return 
     426             
     427            self.items_matrix = matrix 
     428            self.networkCanvas.items_matrix = matrix 
     429            self.cb_show_distances.setEnabled(1) 
     430            self.cb_show_component_distances.setEnabled(1) 
     431             
     432            if str(self.optMethod) in ['8', '9', '10']: 
     433                if self.items_matrix is not None and self.graph is not None and \ 
     434                self.items_matrix.dim == self.graph.number_of_nodes(): 
     435                    self.optButton.setEnabled(True) 
     436                    self.optButton.setChecked(True) 
     437                    self.graph_layout() 
     438         
     439        def send_marked_nodes(self): 
     440            if self.checkSendMarkedNodes: 
     441                markedNodes = self.networkCanvas.marked_nodes() 
     442                 
     443                if len(markedNodes) == 0: 
     444                    self.send("Marked Items", None) 
     445                    return 
     446                 
     447                if self.graph is not None and self.graph_base.items() is not None: 
     448                    items = self.graph_base.items().getitems(markedNodes) 
     449                    self.send("Marked Items", items) 
     450                    return 
     451                 
     452                self.send("Marked Items", None) 
     453            else: 
     454                self.networkCanvas.send_marked_nodes = None 
     455                self.send("Marked Items", None) 
     456                 
     457        def showComponents(self): 
     458            if self.graph is None or self.graph_base.items() is None: 
     459                return 
     460             
     461            vars = [x.name for x in self.graph_base.items_vars()] 
     462             
     463            if not self.showComponentCombo.currentText() in vars: 
     464                self.networkCanvas.showComponentAttribute = None 
     465                self.lastNameComponentAttribute = '' 
     466            else: 
     467                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
     468             
     469            self.networkCanvas.drawComponentKeywords() 
     470             
     471        def nameComponents(self): 
     472            """Names connected components of genes according to GO terms.""" 
     473            self.progressBarFinished() 
     474            self.lastNameComponentAttribute = None 
     475             
     476            if self.graph is None or self.graph_base.items() is None: 
     477                return 
     478             
     479            vars = [x.name for x in self.graph_base.items_vars()] 
     480            if not self.nameComponentCombo.currentText() in vars: 
     481                return 
     482             
     483            self.progressBarInit() 
     484            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     485            if 'component name' in self.graph_base.items().domain: 
     486                keyword_table = self.graph_base.items() 
     487            else: 
     488                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
     489                 
     490            import obiGO  
     491            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
     492            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
     493     
     494            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
     495            foundGenesets = False 
     496            if len(annotations.geneNames & allGenes) < 1: 
     497                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
     498                if len(annotations.geneNames & allGenes) < 1:             
     499                    self.warning('no genes found') 
     500                    return 
     501                else: 
     502                    foundGenesets = True 
     503                 
     504            def rank(a, j, reverse=False):                     
     505                if len(a) <= 0: return 
     506                 
     507                if reverse:                 
     508                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
     509                    top_value = a[0][j] 
     510                    top_rank = len(a) 
     511                    max_rank = float(len(a)) 
     512                    int_ndx = 0 
     513                    for k in range(len(a)): 
     514                        if top_value < a[k][j]: 
     515                            top_value = a[k][j]  
     516                            if k - int_ndx > 1: 
     517                                avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     518                                for l in range(int_ndx, k): 
     519                                    a[l][j] = avg_rank 
     520                             
     521                            int_ndx = k 
     522     
     523                        a[k][j] = top_rank / max_rank 
     524                        top_rank -= 1 
     525                     
     526                    k += 1 
     527                    if k - int_ndx > 1: 
     528                        avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     529                        for l in range(int_ndx, k): 
     530                            a[l][j] = avg_rank     
     531                     
     532                else: 
     533                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
     534                    top_value = a[0][j] 
     535                    top_rank = len(a) 
     536                    max_rank = float(len(a)) 
     537                    int_ndx = 0 
     538                    for k in range(len(a)): 
     539                        if top_value > a[k][j]: 
     540                            top_value = a[k][j]  
     541                            if k - int_ndx > 1: 
     542                                avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     543                                for l in range(int_ndx, k): 
     544                                    a[l][j] = avg_rank 
     545                             
     546                            int_ndx = k 
     547     
     548                        a[k][j] = top_rank / max_rank 
     549                        top_rank -= 1 
     550                     
     551                    k += 1 
     552                    if k - int_ndx > 1: 
     553                        avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     554                        for l in range(int_ndx, k): 
     555                            a[l][j] = avg_rank 
     556             
     557            for i in range(len(components)): 
     558                component = components[i] 
     559                if len(component) <= 1: 
     560                    continue 
     561                 
     562                if foundGenesets: 
     563                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
     564                else: 
     565                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
     566                         
     567                res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
     568                res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
     569                res = res1.items() + res2.items() 
     570                #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] 
     571                #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] 
     572                 
     573                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] 
     574                if len(namingScore) == 0: 
     575                    continue 
     576                 
     577                annotated_genes = max([a[0] for a in namingScore]) 
     578                 
     579                rank(namingScore, 1, reverse=True) 
     580                rank(namingScore, 2, reverse=True) 
     581                rank(namingScore, 0) 
     582                 
     583                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] 
     584                namingScore.sort(reverse=True) 
     585                 
     586                if len(namingScore) < 1: 
     587                    print "warning. no annotations found for group of genes: " + ", ".join(genes) 
     588                    continue 
     589                elif len(namingScore[0]) < 2: 
     590                    print "warning. error computing score for group of genes: " + ", ".join(genes) 
     591                    continue 
     592                 
     593                for v in component: 
     594                    name = str(namingScore[0][1]) 
     595                    attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4]) 
     596                    info = '' 
     597                    if self.showTextMiningInfo: 
     598                        info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
     599                    keyword_table[v]['component name'] = name + info 
     600                 
     601                self.progressBarSet(i*100.0/len(components)) 
     602                     
     603            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
     604            self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
     605            self.progressBarFinished()    
     606                
     607        def _set_canvas_attr(self, attr, value): 
     608            setattr(self.networkCanvas, attr, value) 
     609            self.networkCanvas.updateCanvas() 
     610         
     611        def _set_curve_attr(self, attr, value): 
     612            setattr(self.networkCanvas.networkCurve, attr, value) 
     613            self.networkCanvas.updateCanvas() 
     614                     
     615        def setSearchStringTimer(self): 
     616            self.hubs = 1 
     617            self.searchStringTimer.stop() 
     618            self.searchStringTimer.start(1000) 
     619              
     620        def set_mark_mode(self, i=None): 
     621            self.searchStringTimer.stop() 
     622            if not i is None: 
     623                self.hubs = i 
     624             
     625            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed) 
     626            QObject.disconnect(self.networkCanvas, SIGNAL('point_hovered(Point*)'), self.networkCanvas.mark_on_focus_changed) 
     627             
     628            if self.graph is None: 
     629                return 
     630             
     631            hubs = self.hubs 
     632             
     633            if hubs in [0,1,2,3]: 
     634                if hubs == 0: 
     635                    self.networkCanvas.networkCurve.clear_node_marks() 
     636                elif hubs == 1: 
     637                    #print "mark on given label" 
     638                    txt = self.markSearchString 
     639                     
     640                    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()])) 
     641                    toMark = toMark.intersection(self.graph.nodes()) 
     642                    self.networkCanvas.networkCurve.clear_node_marks() 
     643                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for i in toMark)) 
     644                elif hubs == 2: 
     645                    #print "mark on focus" 
     646                    self.networkCanvas.mark_neighbors = self.markDistance 
     647                    QObject.connect(self.networkCanvas, SIGNAL('point_hovered(Point*)'), self.networkCanvas.mark_on_focus_changed) 
     648                elif hubs == 3: 
     649                    #print "mark selected" 
     650                    self.networkCanvas.mark_neighbors = self.markDistance 
     651                    QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed) 
     652                    self.networkCanvas.mark_on_selection_changed() 
     653                     
     654            elif hubs in [4,5,6,7,8,9]: 
     655                 
     656                powers = sorted(self.graph.degree_iter(), key=itemgetter(1), reverse=True) 
     657                 
     658                if hubs == 4: 
     659                    #print "mark at least N connections" 
     660                    N = self.markNConnections 
     661                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     662                        d >= N else (i, False) for i, d in powers)) 
     663                elif hubs == 5: 
     664                    #print "mark at most N connections" 
     665                    N = self.markNConnections 
     666                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     667                        d <= N else (i, False) for i, d in powers)) 
     668                elif hubs == 6: 
     669                    #print "mark more than any" 
     670                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     671                        d > max([0]+self.graph.degree(self.graph.neighbors(i)).values()) \ 
     672                        else (i, False) for i,d in powers )) 
     673                elif hubs == 7: 
     674                    #print "mark more than avg" 
     675                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \ 
     676                        d > statc.mean([0]+self.graph.degree(self.graph.neighbors(i)).values()) \ 
     677                        else (i, False) for i,d in powers )) 
     678                    self.networkCanvas.replot() 
     679                elif hubs == 8: 
     680                    #print "mark most" 
     681                    self.networkCanvas.networkCurve.clear_node_marks() 
     682                     
     683                    if self.markNumber < 1: 
     684                        return 
     685                     
     686                    cut = self.markNumber 
     687                    cutPower = powers[cut-1][1] 
     688                    while cut < len(powers) and powers[cut][1] == cutPower: 
     689                        cut += 1 
     690         
     691                    self.networkCanvas.networkCurve.clear_node_marks() 
     692                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for \ 
     693                        i,d in powers[:cut])) 
     694                     
     695                elif hubs == 9: 
     696                    var = str(self.markInputCombo.currentText()) 
     697                    if self.markInputItems is not None and len(self.markInputItems) > 0: 
     698                        values = [str(x[var]).strip().upper() for x in self.markInputItems] 
     699                        tomark = dict((x, True) for x in self.graph.nodes() if str(self.graph_base.items()[x][var]).strip().upper() in values) 
     700                        self.networkCanvas.networkCurve.clear_node_marks() 
     701                        self.networkCanvas.networkCurve.set_node_marks(tomark) 
     702                         
     703                    else: 
     704                        self.networkCanvas.networkCurve.clear_node_marks()       
     705             
     706            self.nMarked = len(self.networkCanvas.marked_nodes()) 
     707            self.send_marked_nodes() 
     708            
     709        def testRefresh(self): 
     710            start = time.time() 
     711            self.networkCanvas.replot() 
     712            stop = time.time()     
     713            print "replot in " + str(stop - start) 
     714             
     715        def save_network(self): 
     716    #        if self.networkCanvas is None or self.graph is None: 
     717    #            return 
     718    #         
     719    #        filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
     720    #        if filename: 
     721    #            fn = "" 
     722    #            head, tail = os.path.splitext(str(filename)) 
     723    #            if not tail: 
     724    #                fn = head + ".net" 
     725    #            else: 
     726    #                fn = str(filename) 
     727    #             
     728    #            for i in range(self.graph.number_of_nodes()): 
     729    #                node = self.graph.node[i] 
     730    #                node['x'] = self.layout.coors[0][i] 
     731    #                node['y'] = self.layout.coors[1][i] 
     732    # 
     733    #            Orange.network.readwrite.write(self.graph, fn) 
     734            pass 
     735                 
     736        def send_data(self): 
     737            selected_nodes = self.networkCanvas.selected_nodes() 
     738            graph = self.graph_base.subgraph(selected_nodes) 
     739             
     740            if graph is not None: 
     741                self.send("Selected Items", graph.items()) 
     742                 
     743                nodes = self.networkCanvas.not_selected_nodes() 
     744                if len(nodes) > 0 and self.graph_base.items() is not None: 
     745                    self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     746                else: 
     747                    self.send("Unselected Items", None) 
     748                     
     749                self.send("Selected Network", graph) 
     750            else: 
     751                self.send("Selected Items", None) 
     752                self.send("Unselected Items", None) 
     753                self.send("Selected Network", None) 
     754                 
     755            matrix = None if self.items_matrix is None else self.items_matrix.getitems(selected_nodes) 
     756            self.send("Selected Items Distance Matrix", matrix) 
     757                     
     758        def setCombos(self): 
     759            vars = self.graph_base.items_vars() 
     760            edgeVars = self.graph_base.links_vars() 
     761            lastLabelColumns = self.lastLabelColumns 
     762            lastTooltipColumns = self.lastTooltipColumns 
     763             
     764            self.clearCombos() 
     765             
     766            self.attributes = [(var.name, var.varType) for var in vars] 
     767            self.edgeAttributes = [(var.name, var.varType) for var in edgeVars] 
     768             
     769            for var in vars: 
     770                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
     771                    self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     772                     
     773                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: 
     774                     
     775                    value = self.graph_base.items()[0][var].value 
     776                     
     777                    # can value be a list? 
     778                    try: 
     779                        if type(eval(value)) == type([]): 
     780                            self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     781                            continue 
     782                    except: 
     783                        pass 
     784                     
     785                    if len(value.split(',')) > 1: 
     786                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
     787                     
     788                elif var.varType in [Orange.data.Type.Continuous]: 
     789                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     790     
     791                self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     792                self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     793                self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     794                self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     795             
     796            for var in edgeVars: 
     797                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
     798                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     799                     
     800            for i in range(self.vertexSizeCombo.count()): 
     801                if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i): 
     802                    self.vertexSize = i 
     803                    break 
     804                 
     805            for i in range(self.colorCombo.count()): 
     806                if self.lastColorColumn == self.colorCombo.itemText(i): 
     807                    self.color = i 
     808                    break 
     809     
     810            for i in range(self.attListBox.count()): 
     811                if str(self.attListBox.item(i).text()) in lastLabelColumns: 
     812                    self.attListBox.item(i).setSelected(1) 
     813                     
     814            for i in range(self.tooltipListBox.count()): 
     815                if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns: 
     816                    self.tooltipListBox.item(i).setSelected(1) 
     817                 
     818            self.lastLabelColumns = lastLabelColumns 
     819            self.lastTooltipColumns = lastTooltipColumns 
     820             
     821        def clearCombos(self): 
     822            self.attributes = [] 
     823            self.edgeAttributes = [] 
     824             
     825            self.colorCombo.clear() 
     826            self.vertexSizeCombo.clear() 
     827            self.nameComponentCombo.clear() 
     828            self.showComponentCombo.clear() 
     829            self.edgeColorCombo.clear() 
     830            self.editCombo.clear() 
     831            self.comboAttSelection.clear() 
     832             
     833            self.colorCombo.addItem("(same color)") 
     834            self.edgeColorCombo.addItem("(same color)") 
     835            self.vertexSizeCombo.addItem("(same size)") 
     836            self.nameComponentCombo.addItem("Select attribute") 
     837            self.showComponentCombo.addItem("Select attribute") 
     838            self.editCombo.addItem("Select attribute") 
     839            self.comboAttSelection.addItem("Select attribute") 
     840           
     841        def compute_network_info(self): 
     842            self.nShown = self.graph.number_of_nodes() 
     843             
     844            if self.graph.number_of_edges() > 0: 
     845                self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
     846            else: 
     847                self.verticesPerEdge = 0 
     848                 
     849            if self.graph.number_of_nodes() > 0: 
     850                self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
     851            else: 
     852                self.edgesPerVertex = 0 
     853             
     854            undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
     855            components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     856            if len(components) > 1: 
     857                self.diameter = float('nan') 
     858            else: 
     859                try: 
     860                    if self.graph.number_of_nodes() > 1: 
     861                        self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
     862                    else: 
     863                        self.diameter = -1 
     864                except Orange.network.nx.NetworkXError as err: 
     865                    if 'infinite path length' in err.message: 
     866                        self.diameter = float('inf') 
     867                    else: 
     868                        raise err  
     869            if self.graph.is_multigraph(): 
     870                self.clustering_coefficient = -1 
     871            else: 
     872                self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     873           
     874        def change_graph(self, newgraph): 
     875            self.information() 
     876             
     877            # if graph has more nodes and edges than pixels in 1600x1200 display,  
     878            # it is too big to visualize! 
     879            if newgraph.number_of_nodes() + newgraph.number_of_edges() > 50000: 
     880                self.information('New graph is too big to visualize. Keeping the old graph.') 
     881                return 
     882             
     883            self.graph = newgraph 
     884             
     885            self.number_of_nodes_label = self.graph.number_of_nodes() 
     886            self.number_of_edges_label = self.graph.number_of_edges() 
     887             
     888            if not self.networkCanvas.change_graph(self.graph): 
     889                return 
     890             
     891            self.compute_network_info() 
     892             
     893            t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
     894            self.frSteps = int(2.0 / t) 
     895            if self.frSteps <   1: self.frSteps = 1 
     896            if self.frSteps > 100: self.frSteps = 100 
     897    #         
     898    #        if self.frSteps < 10: 
     899    #            self.networkCanvas.use_antialiasing = 0 
     900    #            self.networkCanvas.use_animations = 0 
     901    #            self.minVertexSize = 5 
     902    #            self.maxVertexSize = 5 
     903    #            self.maxLinkSize = 1 
     904    #            self.optMethod = 0 
     905    #            self.graph_layout_method() 
     906             
     907            animation_enabled = self.networkCanvas.animate_points; 
     908            self.networkCanvas.animate_points = False; 
     909             
     910            self.set_node_sizes() 
     911            self.set_node_colors() 
     912            self.set_edge_sizes() 
     913            self.set_edge_colors() 
     914                 
     915            self.clickedAttLstBox() 
     916            self.clickedTooltipLstBox() 
     917            self.clickedEdgeLabelListBox() 
     918             
     919            self.networkCanvas.replot() 
     920             
     921            self.networkCanvas.animate_points = animation_enabled 
     922            qApp.processEvents() 
     923            self.networkCanvas.networkCurve.layout_fr(100, weighted=False, smooth_cooling=True) 
     924            self.networkCanvas.update_canvas()         
     925     
     926        def set_graph_none(self): 
     927            self.graph = None 
     928            self.graph_base = None 
    1298929            self.clearCombos() 
    1299930            self.number_of_nodes_label = -1 
     
    1301932            self._items = None 
    1302933            self._links = None 
    1303             return 
     934            self.set_items_distance_matrix(None) 
     935            self.networkCanvas.set_graph(None) 
     936     
     937        def set_graph(self, graph, curve=None): 
     938            self.information() 
     939            self.warning() 
     940            self.error() 
     941             
     942            if graph is None: 
     943                self.set_graph_none() 
     944                return 
     945             
     946            if graph.number_of_nodes() < 2: 
     947                self.set_graph_none() 
     948                self.information('I\'m not really in a mood to visualize just one node. Try again tomorrow.') 
     949                return 
     950             
     951            self.graph_base = graph 
     952             
     953            if self._network_view is not None: 
     954                graph = self._network_view.init_network(graph) 
     955             
     956            self.graph = graph 
     957             
     958            # if graph has more nodes and edges than pixels in 1600x1200 display,  
     959            # it is too big to visualize! 
     960            if self.graph.number_of_nodes() + self.graph.number_of_edges() > 50000: 
     961                self.set_graph_none() 
     962                self.error('Graph is too big to visualize. Try using one of the network views.') 
     963                return 
     964             
     965            if self.items_matrix is not None and self.items_matrix.dim != self.graph_base.number_of_nodes(): 
     966                self.set_items_distance_matrix(None) 
     967             
     968            self.number_of_nodes_label = self.graph.number_of_nodes() 
     969            self.number_of_edges_label = self.graph.number_of_edges() 
     970             
     971            self.networkCanvas.set_graph(self.graph, curve, items=self.graph_base.items(), links=self.graph_base.links()) 
     972             
     973            if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
     974                positions = dict((node, (self._items[node]['x'].value, self._items[node]['y'].value)) \ 
     975                             for node in self.graph if self._items[node]['x'].value != '?' \ 
     976                             and self._items[node]['y'].value != '?') 
     977                 
     978                self.networkCanvas.networkCurve.set_node_coordinates(positions) 
     979     
     980             
     981            self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     982            self.networkCanvas.maxEdgeSize = self.maxLinkSize 
     983            self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     984            self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
     985            self.networkCanvas.set_labels_on_marked_only(self.labelsOnMarkedOnly) 
     986             
     987            self.compute_network_info() 
     988            self.setCombos() 
     989                 
     990            lastNameComponentAttributeFound = False 
     991            for i in range(self.nameComponentCombo.count()): 
     992                if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i): 
     993                    lastNameComponentAttributeFound = True 
     994                    self.nameComponentAttribute = i 
     995                    self.nameComponents() 
     996                    self.showComponentAttribute = self.showComponentCombo.count() - 1 
     997                    self.showComponents() 
     998                    break 
     999                 
     1000            if not lastNameComponentAttributeFound: 
     1001                self.lastNameComponentAttribute = '' 
     1002             
     1003            self.showComponentAttribute = None 
     1004     
     1005            t = 1.13850193174e-008 * (self.graph.number_of_nodes()**2 + self.graph.number_of_edges()) 
     1006            self.frSteps = int(2.0 / t) 
     1007            if self.frSteps <   1: self.frSteps = 1 
     1008            if self.frSteps > 100: self.frSteps = 100 
     1009             
     1010            # if graph is large, set random layout, min vertex size, min edge size 
     1011            if self.frSteps < 10: 
     1012                self.networkCanvas.update_antialiasing(False) 
     1013                self.networkCanvas.update_animations(False) 
     1014                self.minVertexSize = 5 
     1015                self.maxVertexSize = 5 
     1016                self.maxLinkSize = 1 
     1017                self.optMethod = 0 
     1018                self.graph_layout_method()             
     1019             
     1020            self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
     1021            self.networkCanvas.showWeights = self.showWeights 
     1022                 
     1023            self.set_node_sizes() 
     1024            self.set_node_colors() 
     1025            self.set_edge_sizes() 
     1026            self.set_edge_colors() 
     1027                 
     1028            self.clickedAttLstBox() 
     1029            self.clickedTooltipLstBox() 
     1030            self.clickedEdgeLabelListBox() 
     1031             
     1032            self.optButton.setChecked(1) 
     1033            self.graph_layout()         
     1034             
     1035        def set_network_view(self, nxView): 
     1036            self.error() 
     1037            self.warning() 
     1038            self.information() 
     1039             
     1040            if self.graph is None: 
     1041                self.information('Do not forget to add a graph!') 
     1042                 
     1043            if self._network_view is not None: 
     1044                QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
     1045                 
     1046            self._network_view = nxView 
     1047             
     1048            if self._network_view is not None: 
     1049                self._network_view.set_nx_explorer(self) 
     1050             
     1051            self.set_graph(self.graph_base) 
     1052             
     1053            if self._network_view is not None: 
     1054                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed) 
     1055             
     1056        def setItems(self, items=None): 
     1057            self.error() 
     1058            self.warning() 
     1059            self.information() 
     1060             
     1061            if self.graph is None or items is None: 
     1062                self.warning('No graph found!') 
     1063                return 
     1064             
     1065            if len(items) != self.graph_base.number_of_nodes(): 
     1066                self.error('ExampleTable items must have one example for each vertex.') 
     1067                return 
     1068             
     1069            self.graph_base.set_items(items) 
     1070             
     1071            self.set_node_sizes() 
     1072            self.networkCanvas.items = items 
     1073            self.networkCanvas.showWeights = self.showWeights 
     1074            self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     1075            self.setCombos() 
     1076            #self.networkCanvas.updateData() 
     1077             
     1078        def markItems(self, items): 
     1079            self.markInputCombo.clear() 
     1080            self.markInputRadioButton.setEnabled(False) 
     1081            self.markInputItems = items 
     1082             
     1083            self.error() 
     1084            self.warning() 
     1085            self.information() 
     1086             
     1087            if self.graph is None or self.graph_base.items() is None or items is None: 
     1088                self.warning('No graph found or no items attached to the graph.') 
     1089                return 
     1090             
     1091            if len(items) > 0: 
     1092                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()] 
     1093                lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
     1094                commonVars = set(lstNewDomain) & set(lstOrgDomain) 
     1095     
     1096                if len(commonVars) > 0: 
     1097                    for var in commonVars: 
     1098                        orgVar = self.graph_base.items().domain[var] 
     1099                        mrkVar = items.domain[var] 
     1100     
     1101                        if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String: 
     1102                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
     1103                            self.markInputRadioButton.setEnabled(True) 
     1104                     
     1105                            self.set_mark_mode(9) 
     1106                   
     1107        def setExampleSubset(self, subset): 
     1108            print "TODO: not yet implemented" 
     1109            if self.graph is None: 
     1110                return 
     1111             
     1112            self.warning('') 
     1113            hiddenNodes = [] 
     1114             
     1115            if subset is not None: 
     1116                try: 
     1117                    expected = 1 
     1118                    for row in subset: 
     1119                        index = int(row['index'].value) 
     1120                        if expected != index: 
     1121                            hiddenNodes += range(expected-1, index-1) 
     1122                            expected = index + 1 
     1123                        else: 
     1124                            expected += 1 
     1125                             
     1126                    hiddenNodes += range(expected-1, self.graph.number_of_nodes()) 
     1127                     
     1128                    self.networkCanvas.setHiddenNodes(hiddenNodes) 
     1129                except: 
     1130                    self.warning('"index" attribute does not exist in "items" table.') 
     1131                         
     1132        def showDegreeDistribution(self): 
     1133            if self.graph is None: 
     1134                return 
     1135             
     1136            from matplotlib import rcParams 
     1137            import pylab as p 
     1138             
     1139            x = self.graph.degree().values() 
     1140            nbins = len(set(x)) 
     1141            if nbins > 500: 
     1142              bbins = 500 
     1143             
     1144            # the histogram of the data 
     1145            n, bins, patches = p.hist(x, nbins) 
     1146             
     1147            p.xlabel('Degree') 
     1148            p.ylabel('No. of nodes') 
     1149            p.title(r'Degree distribution') 
     1150             
     1151            p.show() 
     1152             
     1153        def setColors(self): 
     1154            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
     1155            if dlg.exec_(): 
     1156                self.colorSettings = dlg.getColorSchemas() 
     1157                self.selectedSchemaIndex = dlg.selectedSchemaIndex 
     1158                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
     1159                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
     1160                 
     1161                self.set_node_colors() 
     1162                 
     1163        def setEdgeColorPalette(self): 
     1164            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     1165            if dlg.exec_(): 
     1166                self.edgeColorSettings = dlg.getColorSchemas() 
     1167                self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex 
     1168                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
     1169                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
     1170                 
     1171                self.set_edge_colors() 
    13041172         
    1305         self.graph_base = graph 
     1173        def createColorDialog(self, colorSettings, selectedSchemaIndex): 
     1174            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
     1175            c.createDiscretePalette("discPalette", "Discrete Palette") 
     1176            c.createContinuousPalette("contPalette", "Continuous Palette") 
     1177            c.setColorSchemas(colorSettings, selectedSchemaIndex) 
     1178            return c 
    13061179         
    1307         if self._network_view is not None: 
    1308             graph = self._network_view.init_network(graph) 
     1180        """ 
     1181        Layout Optimization 
     1182        """ 
    13091183         
     1184        def graph_layout(self): 
     1185            if self.graph is None:   #grafa se ni 
     1186                self.optButton.setChecked(False) 
     1187                return 
     1188             
     1189            if not self.optButton.isChecked() and not self.optMethod in [2,3,9,10]: 
     1190                self.optButton.setChecked(False) 
     1191                return 
     1192             
     1193            qApp.processEvents() 
     1194             
     1195            if self.optMethod == 1: 
     1196                self.networkCanvas.networkCurve.random() 
     1197            elif self.optMethod == 2: 
     1198                self.graph_layout_fr(False) 
     1199            elif self.optMethod == 3: 
     1200                self.graph_layout_fr(True) 
     1201            elif self.optMethod == 4: 
     1202                self.graph_layout_fr_radial() 
     1203            elif self.optMethod == 5: 
     1204                self.networkCanvas.networkCurve.circular(NetworkCurve.circular_crossing) 
     1205            elif self.optMethod == 6: 
     1206                self.networkCanvas.networkCurve.circular(NetworkCurve.circular_original) 
     1207            elif self.optMethod == 7: 
     1208                self.networkCanvas.networkCurve.circular(NetworkCurve.circular_random) 
     1209            elif self.optMethod == 8: 
     1210                self.graph_layout_pivot_mds() 
     1211            elif self.optMethod == 9: 
     1212                self.graph_layout_fragviz() 
     1213            elif self.optMethod == 10:  
     1214                self.graph_layout_mds() 
     1215                 
     1216            self.optButton.setChecked(False) 
     1217            self.networkCanvas.update_canvas() 
     1218            qApp.processEvents() 
     1219             
     1220        def graph_layout_method(self, method=None): 
     1221            self.information() 
     1222            self.stepsSpin.label.setText('Iterations: ') 
     1223            self.optButton.setEnabled(True) 
     1224            self.cb_opt_from_curr.setEnabled(False) 
     1225             
     1226            if method is not None: 
     1227                self.optMethod = method 
     1228                 
     1229            if str(self.optMethod) == '0': 
     1230                self.optButton.setEnabled(False) 
     1231            else: 
     1232                self.optButton.setEnabled(True) 
     1233                 
     1234            if str(self.optMethod) in ['2', '3', '4']: 
     1235                self.stepsSpin.setEnabled(True) 
     1236                 
     1237            elif str(self.optMethod) in ['8', '9', '10']: 
     1238                if str(self.optMethod) == '8':  
     1239                    self.stepsSpin.label.setText('Pivots: ') 
     1240                 
     1241                if str(self.optMethod) in ['9', '10']:  
     1242                    self.cb_opt_from_curr.setEnabled(True) 
     1243                     
     1244                self.stepsSpin.setEnabled(True) 
     1245                 
     1246                if self.items_matrix is None: 
     1247                    self.information('Set distance matrix to input signal') 
     1248                    self.optButton.setEnabled(False) 
     1249                    return 
     1250                if self.graph is None: 
     1251                    self.information('No network found') 
     1252                    self.optButton.setEnabled(False) 
     1253                    return 
     1254                if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1255                    self.error('Distance matrix dimensionality must equal number of vertices') 
     1256                    self.optButton.setEnabled(False) 
     1257                    return 
     1258            else: 
     1259                self.stepsSpin.setEnabled(False) 
     1260                self.optButton.setChecked(True) 
     1261                self.graph_layout() 
     1262             
    13101263         
    1311         #print "OWNetwork/setGraph: new visualizer..." 
    1312         self.graph = graph 
     1264        def mdsProgress(self, avgStress, stepCount):     
     1265            #self.drawForce() 
     1266     
     1267            #self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
     1268            #self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
     1269            self.progressBarSet(int(stepCount * 100 / self.frSteps)) 
     1270            qApp.processEvents() 
     1271             
     1272        def graph_layout_fragviz(self): 
     1273            if self.items_matrix is None: 
     1274                self.information('Set distance matrix to input signal') 
     1275                self.optButton.setChecked(False) 
     1276                return 
     1277             
     1278            if self.layout is None: 
     1279                self.information('No network found') 
     1280                self.optButton.setChecked(False) 
     1281                return 
     1282             
     1283            if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1284                self.error('Distance matrix dimensionality must equal number of vertices') 
     1285                self.optButton.setChecked(False) 
     1286                return 
     1287             
     1288            if not self.optButton.isChecked(): 
     1289                self.networkCanvas.networkCurve.stopMDS = True 
     1290                self.optButton.setChecked(False) 
     1291                self.optButton.setText("Optimize layout") 
     1292                return 
     1293             
     1294            self.optButton.setText("Stop") 
     1295            self.progressBarInit() 
     1296            qApp.processEvents() 
     1297     
     1298            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
     1299                matrix = self.items_matrix 
     1300            else: 
     1301                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
     1302             
     1303            self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mdsProgress, self.opt_from_curr) 
     1304     
     1305            self.optButton.setChecked(False) 
     1306            self.optButton.setText("Optimize layout") 
     1307            self.progressBarFinished() 
     1308             
     1309        def graph_layout_mds(self): 
     1310            if self.items_matrix is None: 
     1311                self.information('Set distance matrix to input signal') 
     1312                self.optButton.setChecked(False) 
     1313                return 
     1314             
     1315            if self.layout is None: 
     1316                self.information('No network found') 
     1317                self.optButton.setChecked(False) 
     1318                return 
     1319             
     1320            if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1321                self.error('Distance matrix dimensionality must equal number of vertices') 
     1322                self.optButton.setChecked(False) 
     1323                return 
     1324             
     1325            if not self.optButton.isChecked(): 
     1326                self.networkCanvas.networkCurve.stopMDS = True 
     1327                self.optButton.setChecked(False) 
     1328                self.optButton.setText("Optimize layout") 
     1329                return 
     1330             
     1331            self.optButton.setText("Stop") 
     1332            self.progressBarInit() 
     1333            qApp.processEvents() 
     1334             
     1335            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
     1336                matrix = self.items_matrix 
     1337            else: 
     1338                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
     1339             
     1340            self.networkCanvas.networkCurve.layout_mds(self.frSteps, matrix, self.mdsProgress, self.opt_from_curr) 
     1341     
     1342            self.optButton.setChecked(False) 
     1343            self.optButton.setText("Optimize layout") 
     1344            self.progressBarFinished() 
     1345             
     1346        def graph_layout_fr(self, weighted): 
     1347            if self.graph is None: 
     1348                return 
     1349                   
     1350            if not self.optButton.isChecked(): 
     1351                self.networkCanvas.networkCurve.stop_optimization() 
     1352                self.optButton.setChecked(False) 
     1353                self.optButton.setText("Optimize layout") 
     1354                return 
     1355             
     1356            self.optButton.setText("Stop") 
     1357            qApp.processEvents() 
     1358            self.networkCanvas.networkCurve.layout_fr(self.frSteps, False) 
     1359            self.networkCanvas.update_canvas() 
     1360            self.optButton.setChecked(False) 
     1361            self.optButton.setText("Optimize layout") 
     1362                     
     1363        def graph_layout_fr_radial(self): 
     1364            if self.graph is None:   #grafa se ni 
     1365                return 
     1366             
     1367    #        #print "F-R Radial" 
     1368    #        k = 1.13850193174e-008 
     1369    #        nodes = self.graph.number_of_nodes() 
     1370    #        t = k * nodes * nodes 
     1371    #        refreshRate = int(5.0 / t) 
     1372    #        if refreshRate <    1: refreshRate = 1 
     1373    #        if refreshRate > 1500: refreshRate = 1500 
     1374    #        #print "refreshRate: " + str(refreshRate) 
     1375    #         
     1376    #        tolerance = 5 
     1377    #        initTemp = 100 
     1378    #        centerNdx = 0 
     1379    #         
     1380    #        selection = self.networkCanvas.getSelection() 
     1381    #        if len(selection) > 0: 
     1382    #            centerNdx = selection[0] 
     1383    #             
     1384    #        #print "center ndx: " + str(centerNdx) 
     1385    #        initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
     1386    #        self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5] 
     1387    #        #self.networkCanvas.circles = [100, 200, 300] 
     1388    #        self.networkCanvas.updateCanvas() 
     1389    #        self.networkCanvas.circles = [] 
     1390                 
     1391        def graph_layout_pivot_mds(self): 
     1392            self.information() 
     1393             
     1394            if self.items_matrix is None: 
     1395                self.information('Set distance matrix to input signal') 
     1396                return 
     1397             
     1398            if self.graph_base is None: 
     1399                self.information('No network found') 
     1400                return 
     1401             
     1402            if self.items_matrix.dim != self.graph_base.number_of_nodes(): 
     1403                self.error('The number of vertices does not match matrix size.') 
     1404                return 
     1405             
     1406            self.frSteps = min(self.frSteps, self.graph.number_of_nodes()) 
     1407            qApp.processEvents() 
     1408             
     1409            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes(): 
     1410                matrix = self.items_matrix 
     1411            else: 
     1412                matrix = self.items_matrix.get_items(sorted(self.graph.nodes())) 
     1413             
     1414            mds = orngMDS.PivotMDS(matrix, self.frSteps) 
     1415            x,y = mds.optimize() 
     1416            xy = zip(list(x), list(y)) 
     1417            coors = dict(zip(sorted(self.graph.nodes()), xy)) 
     1418            self.networkCanvas.networkCurve.set_node_coordinates(coors) 
     1419            self.networkCanvas.update_canvas() 
     1420     
     1421        """ 
     1422        Network Visualization 
     1423        """ 
     1424        def clickedAttLstBox(self): 
     1425            if self.graph is None: 
     1426                return 
     1427             
     1428            self.lastLabelColumns = [self.attributes[i][0] for i in self.markerAttributes] 
     1429            self.networkCanvas.set_node_labels(self.lastLabelColumns) 
     1430            self.networkCanvas.replot() 
     1431       
     1432        def clickedTooltipLstBox(self): 
     1433            if self.graph is None: 
     1434                return 
     1435             
     1436            self.lastTooltipColumns = [self.attributes[i][0] for i in self.tooltipAttributes] 
     1437            self.networkCanvas.set_tooltip_attributes(self.lastTooltipColumns) 
     1438            self.networkCanvas.replot() 
     1439             
     1440        def clickedEdgeLabelListBox(self): 
     1441            if self.graph is None: 
     1442                return 
     1443             
     1444            self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
     1445            self.networkCanvas.set_edge_labels(self.lastEdgeLabelAttributes) 
     1446            self.networkCanvas.replot() 
     1447     
     1448        def set_node_colors(self): 
     1449            if self.graph is None: 
     1450                return 
     1451             
     1452            self.networkCanvas.set_node_colors(self.colorCombo.currentText()) 
     1453            self.lastColorColumn = self.colorCombo.currentText() 
     1454             
     1455        def set_edge_colors(self): 
     1456            if self.graph is None: 
     1457                return 
     1458             
     1459            self.networkCanvas.set_edge_colors(self.edgeColorCombo.currentText()) 
     1460            self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
     1461                       
     1462        def set_edge_sizes(self): 
     1463            if self.graph is None: 
     1464                return 
     1465             
     1466            self.networkCanvas.networkCurve.set_edge_sizes(self.maxLinkSize) 
     1467            self.networkCanvas.replot() 
    13131468         
    1314         if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
    1315             positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
    1316                          for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
    1317                          and self._items[node]['y'].value != '?'] 
    1318             self.layout.set_graph(self.graph, positions) 
    1319         else: 
    1320             self.layout.set_graph(self.graph) 
     1469        def set_node_sizes(self): 
     1470            if self.graph is None or self.networkCanvas is None: 
     1471                return 
     1472             
     1473            if self.minVertexSize > self.maxVertexSize: 
     1474                self.maxVertexSize = self.minVertexSize 
     1475             
     1476            items = self.graph_base.items() 
     1477             
     1478            if items is None: 
     1479                self.networkCanvas.networkCurve.set_node_sizes({}, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
     1480                return 
     1481             
     1482            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
     1483            column = str(self.vertexSizeCombo.currentText()) 
     1484             
     1485            values = {} 
     1486            if column in items.domain or (column.startswith("num of ") and column.replace("num of ", "") in items.domain): 
     1487                if column in items.domain: 
     1488                    values = dict((x, items[x][column].value) for x in self.graph if not items[x][column].isSpecial()) 
     1489                else: 
     1490                    values = dict((x, len(items[x][column.replace("num of ", "")].value.split(','))) for x in self.graph) 
     1491             
     1492            if len(values) == 0: 
     1493                values = dict((node, 1.) for node in self.graph) 
     1494                 
     1495            if self.invertSize: 
     1496                maxval = max(values.itervalues()) 
     1497                values.update((key, maxval-val) for key, val in values.iteritems()) 
     1498                self.networkCanvas.networkCurve.set_node_sizes(values, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
     1499            else: 
     1500                self.networkCanvas.networkCurve.set_node_sizes(values, min_size=self.minVertexSize, max_size=self.maxVertexSize) 
     1501             
     1502            self.networkCanvas.replot() 
     1503             
     1504        def set_font_size(self): 
     1505            if self.networkCanvas is None: 
     1506                return 
     1507             
     1508            font = self.networkCanvas.font() 
     1509            font.setPointSize(self.fontSize) 
     1510            self.networkCanvas.setFont(font) 
     1511            self.networkCanvas.fontSize = font  
     1512             
     1513                     
     1514        def sendReport(self): 
     1515            self.reportSettings("Graph data", 
     1516                                [("Number of vertices", self.graph.number_of_nodes()), 
     1517                                 ("Number of edges", self.graph.number_of_edges()), 
     1518                                 ("Vertices per edge", "%.3f" % self.verticesPerEdge), 
     1519                                 ("Edges per vertex", "%.3f" % self.edgesPerVertex), 
     1520                                 ("Diameter", self.diameter), 
     1521                                 ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient) 
     1522                                 ]) 
     1523            if self.color or self.vertexSize or self.markerAttributes or self.edgeColor: 
     1524                self.reportSettings("Visual settings", 
     1525                                    [self.color and ("Vertex color", self.colorCombo.currentText()), 
     1526                                     self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""), 
     1527                                     self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)), 
     1528                                     self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()), 
     1529                                    ]) 
     1530            self.reportSettings("Optimization", 
     1531                                [("Method", self.optCombo.currentText()), 
     1532                                 ("Iterations", self.frSteps)]) 
     1533            self.reportSection("Graph") 
     1534            self.reportImage(self.networkCanvas.saveToFileDirect)         
     1535             
     1536except: 
     1537    from OWNxCanvas import * 
     1538     
     1539    class OWNxExplorer(OWWidget): 
     1540        settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
     1541        "maxLinkSize", "minVertexSize", "maxVertexSize", "renderAntialiased", 
     1542        "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", 
     1543        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
     1544        "showWeights", "showIndexes",  "showEdgeLabels", "colorSettings",  
     1545        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
     1546        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
     1547        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
     1548        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
     1549        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"]  
    13211550         
    1322         self.number_of_nodes_label = self.graph.number_of_nodes() 
    1323         self.number_of_edges_label = self.graph.number_of_edges() 
    1324          
    1325         self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
    1326         self.networkCanvas.renderAntialiased = self.renderAntialiased 
    1327         self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    1328         self.networkCanvas.minVertexSize = self.minVertexSize 
    1329         self.networkCanvas.maxVertexSize = self.maxVertexSize 
    1330         self.networkCanvas.maxEdgeSize = self.maxLinkSize 
    1331         self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    1332         self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    1333         self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    1334         self.lastColorColumn = self.colorCombo.currentText() 
    1335          
    1336         self.nShown = self.graph.number_of_nodes() 
    1337          
    1338         if self.graph.number_of_edges() > 0: 
    1339             self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    1340         else: 
    1341             self.verticesPerEdge = 0 
    1342              
    1343         if self.graph.number_of_nodes() > 0: 
    1344             self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    1345         else: 
    1346             self.edgesPerVertex = 0 
    1347          
    1348         undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    1349         components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    1350         if len(components) > 1: 
    1351             self.diameter = -1 
    1352         else: 
    1353             self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    1354          
    1355         if self.graph.is_multigraph(): 
    1356             self.clustering_coefficient = -1 
    1357         else: 
    1358             self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    1359          
    1360         self.setCombos() 
    1361              
    1362         lastNameComponentAttributeFound = False 
    1363         for i in range(self.nameComponentCombo.count()): 
    1364             if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i): 
    1365                 lastNameComponentAttributeFound = True 
    1366                 self.nameComponentAttribute = i 
    1367                 self.nameComponents() 
    1368                 self.showComponentAttribute = self.showComponentCombo.count() - 1 
    1369                 self.showComponents() 
    1370                 break 
    1371              
    1372         if not lastNameComponentAttributeFound: 
     1551        def __init__(self, parent=None, signalManager=None, name = 'Net Explorer (Qwt)',  
     1552                     NetworkCanvas=OWNxCanvas): 
     1553            OWWidget.__init__(self, parent, signalManager, name) 
     1554            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
     1555            self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
     1556                           ("Nx View", Orange.network.NxView, self.set_network_view), 
     1557                           ("Items", Orange.data.Table, self.setItems), 
     1558                           ("Items to Mark", Orange.data.Table, self.markItems),  
     1559                           ("Items Subset", Orange.data.Table, self.setExampleSubset),  
     1560                           ("Items Distance Matrix", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
     1561             
     1562            self.outputs = [("Selected Network", Orange.network.Graph), 
     1563                            ("Selected Items Distance Matrix", Orange.core.SymMatrix), 
     1564                            ("Selected Items", Orange.data.Table),  
     1565                            ("Unselected Items", Orange.data.Table),  
     1566                            ("Marked Items", Orange.data.Table), 
     1567                            ("Attribute Selection List", AttributeList)] 
     1568             
     1569            self.markerAttributes = [] 
     1570            self.tooltipAttributes = [] 
     1571            self.edgeLabelAttributes = [] 
     1572            self.attributes = [] 
     1573            self.edgeAttributes = [] 
     1574            self.autoSendSelection = False 
     1575            self.graphShowGrid = 1  # show gridlines in the graph 
     1576             
     1577            self.markNConnections = 2 
     1578            self.markNumber = 0 
     1579            self.markProportion = 0 
     1580            self.markSearchString = "" 
     1581            self.markDistance = 2 
     1582            self.frSteps = 1 
     1583            self.hubs = 0 
     1584            self.color = 0 
     1585            self.edgeColor = 0 
     1586            self.vertexSize = 0 
     1587            self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = self.diameter = self.clustering_coefficient = 0 
     1588            self.optimizeWhat = 1 
     1589            self.stopOptimization = 0 
     1590            self.maxLinkSize = 3 
     1591            self.maxVertexSize = 5 
     1592            self.minVertexSize = 5 
     1593            self.renderAntialiased = 1 
     1594            self.labelsOnMarkedOnly = 0 
     1595            self.invertSize = 0 
     1596            self.optMethod = 0 
     1597            self.lastVertexSizeColumn = '' 
     1598            self.lastColorColumn = '' 
    13731599            self.lastNameComponentAttribute = '' 
    1374          
    1375         self.showComponentAttribute = None 
    1376  
    1377         k = 1.13850193174e-008 
    1378         nodes = self.graph.number_of_nodes() 
    1379         t = k * nodes * nodes 
    1380         self.frSteps = int(5.0 / t) 
    1381         if self.frSteps <   1: self.frSteps = 1; 
    1382         if self.frSteps > 3000: self.frSteps = 3000; 
    1383          
    1384         self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
    1385         self.networkCanvas.showWeights = self.showWeights 
    1386         self.networkCanvas.showIndexes = self.showIndexes 
    1387         # if graph is large, set random layout, min vertex size, min edge size 
    1388         if self.frSteps < 10: 
    1389             self.renderAntialiased = 0 
    1390             self.minVertexSize = 5 
    1391             self.maxVertexSize = 5 
    1392             self.maxLinkSize = 1 
    1393             self.optMethod = 0 
    1394             self.graph_layout_method()             
    1395              
    1396         if self.vertexSize > 0: 
    1397             self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize) 
    1398         else: 
    1399             self.networkCanvas.setVerticesSize() 
    1400              
    1401         self.setVertexColor() 
    1402         self.setEdgeColor() 
    1403              
    1404         self.networkCanvas.setEdgesSize() 
    1405         self.clickedAttLstBox() 
    1406         self.clickedTooltipLstBox() 
    1407         self.clickedEdgeLabelListBox() 
    1408          
    1409         self.optButton.setChecked(1) 
    1410         self.graph_layout()         
    1411         self.information(0) 
    1412         #self.networkCanvas.updateCanvas() 
    1413          
    1414     def set_network_view(self, nxView): 
    1415         self._network_view = nxView 
    1416         self._network_view.set_nx_explorer(self) 
    1417         self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected 
    1418         self.set_graph(self.graph_base) 
    1419          
    1420     def setItems(self, items=None): 
    1421         self.error('') 
    1422          
    1423         if self.graph is None or items is None: 
    1424             return 
    1425          
    1426         if len(items) != self.graph_base.number_of_nodes(): 
    1427             self.error('ExampleTable items must have one example for each vertex.') 
    1428             return 
    1429          
    1430         self.graph_base.set_items(items) 
    1431          
    1432         self.setVertexSize() 
    1433         self.networkCanvas.showIndexes = self.showIndexes 
    1434         self.networkCanvas.showWeights = self.showWeights 
    1435         self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    1436         self.setCombos() 
    1437         self.networkCanvas.updateData() 
    1438          
    1439     def setMarkInput(self): 
    1440         var = str(self.markInputCombo.currentText()) 
    1441         #print 'combo:',self.markInputCombo.currentText() 
    1442         if self.markInputItems is not None and len(self.markInputItems) > 0: 
    1443             values = [str(x[var]).strip().upper() for x in self.markInputItems] 
    1444             toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
    1445             #print "mark:", toMark 
    1446             self.networkCanvas.setMarkedVertices(list(toMark)) 
    1447             self.networkCanvas.replot() 
    1448              
    1449         else: 
    1450             self.networkCanvas.setMarkedVertices([]) 
    1451             self.networkCanvas.replot()             
    1452      
    1453     def markItems(self, items): 
    1454         self.markInputCombo.clear() 
    1455         self.markInputRadioButton.setEnabled(False) 
    1456         self.markInputItems = items 
    1457          
    1458         if self.graph is None or self.graph_base.items() is None or items is None: 
    1459             return 
    1460          
    1461         if len(items) > 0: 
    1462             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()] 
    1463             lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
    1464             commonVars = set(lstNewDomain) & set(lstOrgDomain) 
    1465  
    1466             if len(commonVars) > 0: 
    1467                 for var in commonVars: 
    1468                     orgVar = self.graph_base.items().domain[var] 
    1469                     mrkVar = items.domain[var] 
    1470  
    1471                     if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String: 
    1472                         self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
    1473                         self.markInputRadioButton.setEnabled(True) 
    1474                  
    1475                         self.setMarkMode(9) 
    1476                
    1477     def setExampleSubset(self, subset): 
    1478         if self.networkCanvas is None: 
    1479             return 
    1480          
    1481         self.warning('') 
    1482         hiddenNodes = [] 
    1483          
    1484         if subset is not None: 
    1485             try: 
    1486                 expected = 1 
    1487                 for row in subset: 
    1488                     index = int(row['index'].value) 
    1489                     if expected != index: 
    1490                         hiddenNodes += range(expected-1, index-1) 
    1491                         expected = index + 1 
    1492                     else: 
    1493                         expected += 1 
    1494                          
    1495                 hiddenNodes += range(expected-1, self.graph.number_of_nodes()) 
    1496                  
    1497                 self.networkCanvas.setHiddenNodes(hiddenNodes) 
    1498             except: 
    1499                 self.warning('"index" attribute does not exist in "items" table.') 
    1500                      
    1501     def showDegreeDistribution(self): 
    1502         if self.graph is None: 
    1503             return 
    1504          
    1505         from matplotlib import rcParams 
    1506         import pylab as p 
    1507          
    1508         x = self.graph.degree().values() 
    1509         nbins = len(set(x)) 
    1510         if nbins > 500: 
    1511           bbins = 500 
    1512          
    1513         # the histogram of the data 
    1514         n, bins, patches = p.hist(x, nbins) 
    1515          
    1516         p.xlabel('Degree') 
    1517         p.ylabel('No. of nodes') 
    1518         p.title(r'Degree distribution') 
    1519          
    1520         p.show() 
    1521          
    1522     def setColors(self): 
    1523         dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    1524         if dlg.exec_(): 
    1525             self.colorSettings = dlg.getColorSchemas() 
    1526             self.selectedSchemaIndex = dlg.selectedSchemaIndex 
     1600            self.lastLabelColumns = set() 
     1601            self.lastTooltipColumns = set() 
     1602            self.showWeights = 0 
     1603            self.showIndexes = 0 
     1604            self.showEdgeLabels = 0 
     1605            self.colorSettings = None 
     1606            self.selectedSchemaIndex = 0 
     1607            self.edgeColorSettings = [('net_edges', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(204, 204, 204), (179, 226, 205), (253, 205, 172), (203, 213, 232), (244, 202, 228), (230, 245, 201), (255, 242, 174), (241, 226, 204)])]]), ('Default', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(0, 0, 255), (255, 0, 0), (0, 255, 0), (255, 128, 0), (255, 255, 0), (255, 0, 255), (0, 255, 255), (128, 0, 255), (0, 128, 255), (255, 223, 128), (127, 111, 64), (92, 46, 0), (0, 84, 0), (192, 192, 0), (0, 127, 127), (128, 0, 0), (127, 0, 127)])]])] 
     1608            self.selectedEdgeSchemaIndex = 0 
     1609            self.items_matrix = None 
     1610            self.showDistances = 0 
     1611            self.showMissingValues = 0 
     1612            self.fontSize = 12 
     1613            self.mdsTorgerson = 0 
     1614            self.mdsAvgLinkage = 1 
     1615            self.mdsSteps = 10000 
     1616            self.mdsRefresh = 50 
     1617            self.mdsStressDelta = 0.0000001 
     1618            self.organism = 'goa_human' 
     1619            self.showTextMiningInfo = 0 
     1620            self.toolbarSelection = 0 
     1621            self.minComponentEdgeWidth = 10 
     1622            self.maxComponentEdgeWidth = 70 
     1623            self.mdsFromCurrentPos = 0 
     1624            self.tabIndex = 0 
     1625            self.number_of_nodes_label = -1 
     1626            self.number_of_edges_label = -1 
     1627            self.loadSettings() 
     1628             
     1629            self._network_view = None 
     1630            self.layout = Orange.network.GraphLayout() 
     1631            self.graph = None 
     1632            self.graph_base = None 
     1633            self.markInputItems = None 
     1634             
     1635            self.mainArea.layout().setContentsMargins(0,4,4,4) 
     1636            self.controlArea.layout().setContentsMargins(4,4,0,4) 
     1637             
     1638            self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
     1639            self.networkCanvas.showMissingValues = self.showMissingValues 
     1640            self.mainArea.layout().addWidget(self.networkCanvas) 
     1641             
     1642            self.networkCanvas.maxLinkSize = self.maxLinkSize 
     1643            self.networkCanvas.minVertexSize = self.minVertexSize 
     1644            self.networkCanvas.maxVertexSize = self.maxVertexSize 
     1645             
     1646            self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal') 
     1647             
     1648            self.tabs = OWGUI.tabWidget(self.hcontroArea) 
     1649             
     1650            self.verticesTab = OWGUI.createTabPage(self.tabs, "Vertices") 
     1651            self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges") 
     1652            self.markTab = OWGUI.createTabPage(self.tabs, "Mark") 
     1653            self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
     1654            #self.editTab = OWGUI.createTabPage(self.tabs, "Edit") 
     1655             
     1656            self.tabs.setCurrentIndex(self.tabIndex) 
     1657            self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index)) 
     1658             
     1659            self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False) 
     1660             
     1661            self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method) 
     1662            self.optCombo.addItem("No optimization") 
     1663            self.optCombo.addItem("Random") 
     1664            self.optCombo.addItem("Fruchterman Reingold") 
     1665            self.optCombo.addItem("Fruchterman Reingold Weighted") 
     1666            self.optCombo.addItem("Fruchterman Reingold Radial") 
     1667            self.optCombo.addItem("Circular Crossing Reduction") 
     1668            self.optCombo.addItem("Circular Original") 
     1669            self.optCombo.addItem("Circular Random") 
     1670            self.optCombo.addItem("Pivot MDS") 
     1671            self.optCombo.setCurrentIndex(self.optMethod) 
     1672            self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
     1673            self.stepsSpin.setEnabled(False) 
     1674             
     1675            self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1) 
     1676             
     1677            colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace = False) 
     1678            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.setVertexColor) 
     1679            self.colorCombo.addItem("(same color)") 
     1680            OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip = "Set vertex color palette", debuggingEnabled = 0) 
     1681             
     1682            self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box = "Vertex size attribute", callback=self.setVertexSize) 
     1683            self.vertexSizeCombo.addItem("(none)") 
     1684             
     1685            OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize) 
     1686            OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize) 
     1687            OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback = self.setVertexSize) 
     1688             
     1689            colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace = False) 
     1690            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.setEdgeColor) 
     1691            self.edgeColorCombo.addItem("(same color)") 
     1692            OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip = "Set edge color palette", debuggingEnabled = 0) 
     1693             
     1694            self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace = False) 
     1695            OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback = self.setFontSize) 
     1696             
     1697            self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False) 
     1698            self.attListBox = OWGUI.listBox(self.attBox, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
     1699            self.tooltipListBox = OWGUI.listBox(self.attBox, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox) 
     1700             
     1701            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False) 
     1702            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox) 
     1703            self.edgeLabelBox.setEnabled(False) 
     1704             
     1705            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
     1706            OWGUI.checkBox(ib, self, 'showWeights', 'Show weights', callback=(lambda: self._set_canvas_attr('showWeights', self.showWeights))) 
     1707            OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
     1708            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.setMaxLinkSize) 
     1709            self.showDistancesCheckBox = OWGUI.checkBox(ib, self, 'showDistances', 'Explore vertex distances', callback=(lambda: self._set_canvas_attr('showDistances', self.showDistances)), disabled=1) 
     1710             
     1711            ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
     1712            OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes))) 
     1713            OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly))) 
     1714            OWGUI.checkBox(ib, self, 'renderAntialiased', 'Render antialiased', callback=(lambda: self._set_canvas_attr('renderAntialiased', self.renderAntialiased))) 
     1715            self.insideView = 0 
     1716            self.insideViewNeighbours = 2 
     1717            OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked = "insideView", checkCallback = self.insideview, callback = self.insideviewneighbours) 
     1718            OWGUI.checkBox(ib, self, 'showMissingValues', 'Show missing values', callback=(lambda: self._set_canvas_attr('showMissingValues', self.showMissingValues))) 
     1719             
     1720            ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical") 
     1721            OWGUI.label(ib, self, "Vertices (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)") 
     1722            OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i") 
     1723             
     1724            ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setMarkMode) 
     1725            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.setMarkMode) 
     1726            OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback = self.setMarkMode) 
     1727            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
     1728            self.searchStringTimer = QTimer(self) 
     1729            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode) 
     1730             
     1731            OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback = self.setMarkMode) 
     1732            OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback = self.setMarkMode) 
     1733            ib = OWGUI.indentedBox(ribg, orientation = 0) 
     1734            self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h))) 
     1735            #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
     1736            OWGUI.widgetLabel(ribg, "Mark  vertices with ...") 
     1737            OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.setMarkMode) 
     1738            OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.setMarkMode) 
     1739            self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h))) 
     1740            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.setMarkMode) 
     1741            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.setMarkMode) 
     1742            OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.setMarkMode) 
     1743            ib = OWGUI.indentedBox(ribg) 
     1744            self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h))) 
     1745            OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)") 
     1746            self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback = self.setMarkMode) 
     1747            ib = OWGUI.indentedBox(ribg) 
     1748            self.markInput = 0 
     1749            self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h))) 
     1750            self.markInputRadioButton.setEnabled(False) 
     1751             
     1752            ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
     1753            self.checkSendMarkedNodes = 0 
     1754            OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback = self.setSendMarkedNodes, disabled=0) 
     1755             
     1756             
     1757            T = OWToolbars.NavigateSelectToolbar 
     1758            self.zoomSelectToolbar = T(self, self.hcontroArea, self.networkCanvas, self.autoSendSelection, 
     1759                                      buttons = (T.IconZoom,  
     1760                                                 T.IconZoomExtent,  
     1761                                                 T.IconZoomSelection,  
     1762                                                 T.IconPan,  
     1763                                                 ("", "", "", None, None, 0), 
     1764                                                 #("Move selection", "buttonMoveSelection", "activateMoveSelection", QIcon(OWToolbars.dlg_select), Qt.ArrowCursor, 1), 
     1765                                                 T.IconRectangle,  
     1766                                                 #T.IconPolygon,   
     1767                                                 T.IconSendSelection, 
     1768                                                 ("", "", "", None, None, 0, "select"), 
     1769                                                 ("Add marked to selection", "buttonM2S", "markedToSelection", QIcon(dlg_mark2sel), Qt.ArrowCursor, 0), 
     1770                                                 ("Add selection to marked", "buttonS2M", "selectionToMarked", QIcon(dlg_sel2mark), Qt.ArrowCursor, 0), 
     1771                                                 ("Remove selection", "buttonRMS", "removeSelection", QIcon(dlg_selIsmark), Qt.ArrowCursor, 0), 
     1772                                                 ("", "", "", None, None, 0, "select"), 
     1773                                                 ("Hide selected", "buttonSEL", "hideSelectedVertices", QIcon(dlg_selected), Qt.ArrowCursor, 0), 
     1774                                                 ("Hide unselected", "buttonUN", "hideUnSelectedVertices", QIcon(dlg_unselected), Qt.ArrowCursor, 0), 
     1775                                                 ("Show all nodes", "buttonSW", "showAllVertices", QIcon(dlg_showall), Qt.ArrowCursor, 0))) 
     1776                             
     1777            OWGUI.rubber(self.zoomSelectToolbar) 
     1778             
     1779            ib = OWGUI.widgetBox(self.infoTab, "General") 
     1780            OWGUI.label(ib, self, "Number of vertices: %(number_of_nodes_label)i") 
     1781            OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i") 
     1782            OWGUI.label(ib, self, "Vertices per edge: %(verticesPerEdge).2f") 
     1783            OWGUI.label(ib, self, "Edges per vertex: %(edgesPerVertex).2f") 
     1784            OWGUI.label(ib, self, "Diameter: %(diameter)i") 
     1785            OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%") 
     1786             
     1787            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
     1788             
     1789            OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False) 
     1790            OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False) 
     1791            OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
     1792             
     1793            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
     1794             
     1795            ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
     1796             
     1797            #ib = OWGUI.widgetBox(ibProto, "Name components") 
     1798            OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
     1799             
     1800            self.nameComponentAttribute = 0 
     1801            self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal") 
     1802            self.nameComponentCombo.addItem("Select attribute") 
     1803             
     1804            self.showComponentAttribute = 0 
     1805            self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal") 
     1806            self.showComponentCombo.addItem("Select attribute") 
     1807            OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info") 
     1808             
     1809            #ib = OWGUI.widgetBox(ibProto, "Distance Matrix") 
     1810            ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     1811            self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1) 
     1812            self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1) 
     1813            self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1) 
     1814            ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     1815            self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1) 
     1816            self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1) 
     1817            self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1) 
     1818            self.scalingRatio = 0 
     1819            OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ") 
     1820            OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ") 
     1821            OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ") 
     1822            OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ") 
     1823            ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
     1824            OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation") 
     1825            OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage") 
     1826            OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions") 
     1827            self.mdsInfoA=OWGUI.widgetLabel(ib, "Avg. stress:") 
     1828            self.mdsInfoB=OWGUI.widgetLabel(ib, "Num. steps:") 
     1829            self.rotateSteps = 100 
     1830             
     1831            OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
     1832            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
     1833            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
     1834             
     1835            self.attSelectionAttribute = 0 
     1836            self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList) 
     1837            self.comboAttSelection.addItem("Select attribute") 
     1838            self.autoSendAttributes = 0 
     1839            OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes) 
     1840             
     1841            self.icons = self.createAttributeIconDict() 
     1842            self.setMarkMode() 
     1843             
     1844            self.editAttribute = 0 
     1845            self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
     1846            self.editCombo.addItem("Select attribute") 
     1847            self.editValue = '' 
     1848            OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal') 
     1849            OWGUI.button(self.infoTab, self, "Edit", callback=self.edit) 
     1850             
     1851            self.verticesTab.layout().addStretch(1) 
     1852            self.edgesTab.layout().addStretch(1) 
     1853            self.markTab.layout().addStretch(1) 
     1854            self.infoTab.layout().addStretch(1) 
     1855             
     1856            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    15271857            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    15281858            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    15291859             
    1530             self.setVertexColor() 
    1531              
    1532     def setEdgeColorPalette(self): 
    1533         dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    1534         if dlg.exec_(): 
    1535             self.edgeColorSettings = dlg.getColorSchemas() 
    1536             self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex 
     1860            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    15371861            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    15381862            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    15391863             
    1540             self.setEdgeColor() 
    1541      
    1542     def createColorDialog(self, colorSettings, selectedSchemaIndex): 
    1543         c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
    1544         c.createDiscretePalette("discPalette", "Discrete Palette") 
    1545         c.createContinuousPalette("contPalette", "Continuous Palette") 
    1546         c.setColorSchemas(colorSettings, selectedSchemaIndex) 
    1547         return c 
    1548      
    1549     """ 
    1550     Layout Optimization 
    1551     """ 
    1552      
    1553     def graph_layout(self): 
    1554         if self.graph is None:   #grafa se ni 
    1555             self.optButton.setChecked(False) 
    1556             return 
     1864            self.graph_layout_method() 
     1865            self.setFontSize() 
     1866            self.set_graph(None) 
     1867            self.setMinimumWidth(900) 
     1868             
     1869            #self.resize(1000, 600) 
     1870            #self.controlArea.setEnabled(False) 
     1871             
     1872        def setComponentEdgeWidth(self, changedMin=True): 
     1873            if self.networkCanvas is None: 
     1874                return 
     1875             
     1876            canvas = self.networkCanvas 
     1877            if changedMin: 
     1878                if self.maxComponentEdgeWidth < self.minComponentEdgeWidth: 
     1879                    self.maxComponentEdgeWidth = self.minComponentEdgeWidth 
     1880            else: 
     1881                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
     1882                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
     1883             
     1884            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     1885            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
     1886            self.networkCanvas.updateCanvas() 
    15571887         
    1558         if not self.optButton.isChecked(): 
    1559             self.optButton.setChecked(False) 
    1560             return 
    1561          
    1562         qApp.processEvents() 
    1563              
    1564         if self.optMethod == 1: 
    1565             self.layout.random() 
    1566         elif self.optMethod == 2: 
    1567             self.graph_layout_fr(False) 
    1568         elif self.optMethod == 3: 
    1569             self.graph_layout_fr(True) 
    1570         elif self.optMethod == 4: 
    1571             self.graph_layout_fr_radial() 
    1572         elif self.optMethod == 5: 
    1573             self.layout.circular_crossing_reduction() 
    1574         elif self.optMethod == 6: 
    1575             self.layout.circular_original() 
    1576         elif self.optMethod == 7: 
    1577             self.layout.circular_random() 
    1578         elif self.optMethod == 8: 
    1579             self.graph_layout_pivot_mds() 
    1580              
    1581         self.optButton.setChecked(False) 
    1582         self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    1583         self.networkCanvas.updateCanvas() 
    1584         qApp.processEvents() 
    1585          
    1586     def graph_layout_method(self, method=None): 
    1587         self.information() 
    1588         self.stepsSpin.label.setText('Iterations: ') 
    1589          
    1590         if method is not None: 
    1591             self.optMethod = method 
    1592              
    1593         if str(self.optMethod) == '0': 
    1594             self.optButton.setEnabled(False) 
    1595         else: 
    1596             self.optButton.setEnabled(True) 
    1597              
    1598         if str(self.optMethod) in ['2', '3', '4']: 
    1599             self.stepsSpin.setEnabled(True) 
    1600         elif str(self.optMethod) == '8': 
    1601             self.stepsSpin.label.setText('Pivots: ') 
    1602             self.stepsSpin.setEnabled(True) 
    1603              
     1888        def setAutoSendAttributes(self): 
     1889            print 'TODO setAutoSendAttributes' 
     1890            #if self.autoSendAttributes: 
     1891            #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
     1892            #else: 
     1893            #    self.networkCanvas.callbackSelectVertex = None 
     1894     
     1895        def sendAttSelectionList(self): 
     1896            if not self.graph is None: 
     1897                vars = [x.name for x in self.graph_base.links_vars()] 
     1898                if not self.comboAttSelection.currentText() in vars: 
     1899                    return 
     1900                att = str(self.comboAttSelection.currentText()) 
     1901                vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
     1902                 
     1903                if len(vertices) != 1: 
     1904                    return 
     1905                 
     1906                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
     1907            else: 
     1908                attributes = None 
     1909            self.send("Attribute Selection List", attributes) 
     1910             
     1911        def edit(self): 
     1912            if self.graph is None: 
     1913                return 
     1914             
     1915            vars = [x.name for x in self.graph_base.items_vars()] 
     1916            if not self.editCombo.currentText() in vars: 
     1917                return 
     1918            att = str(self.editCombo.currentText()) 
     1919            vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
     1920             
     1921            if len(vertices) == 0: 
     1922                return 
     1923             
     1924            if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous: 
     1925                for v in vertices: 
     1926                    self.graph_base.items()[v][att] = float(self.editValue) 
     1927            else: 
     1928                for v in vertices: 
     1929                    self.graph_base.items()[v][att] = str(self.editValue) 
     1930             
     1931            self.setItems(self.graph_base.items()) 
     1932             
     1933        def drawForce(self): 
     1934            if self.btnForce.isChecked() and self.graph is not None: 
     1935                self.networkCanvas.forceVectors = self.layout._computeForces()  
     1936            else: 
     1937                self.networkCanvas.forceVectors = None 
     1938                 
     1939            self.networkCanvas.updateCanvas() 
     1940             
     1941        def rotateProgress(self, curr, max): 
     1942            self.progressBarSet(int(curr * 100 / max)) 
     1943            qApp.processEvents() 
     1944             
     1945        def rotateComponentsMDS(self): 
     1946            print "rotate" 
    16041947            if self.items_matrix is None: 
    16051948                self.information('Set distance matrix to input signal') 
    1606                 return 
     1949                self.btnRotateMDS.setChecked(False) 
     1950                return 
     1951             
    16071952            if self.graph is None: 
    16081953                self.information('No network found') 
     1954                self.btnRotateMDS.setChecked(False) 
    16091955                return 
    16101956            if self.items_matrix.dim != self.graph.number_of_nodes(): 
    16111957                self.error('Distance matrix dimensionality must equal number of vertices') 
    1612                 return 
    1613         else: 
    1614             self.stepsSpin.setEnabled(False) 
    1615             self.optButton.setChecked(True) 
    1616             self.graph_layout() 
     1958                self.btnRotateMDS.setChecked(False) 
     1959                return 
     1960             
     1961            if not self.btnRotateMDS.isChecked(): 
     1962              self.layout.stopMDS = 1 
     1963              #self.btnMDS.setChecked(False) 
     1964              #self.btnMDS.setText("MDS on graph components") 
     1965              return 
     1966             
     1967            self.btnRotateMDS.setText("Stop") 
     1968            qApp.processEvents() 
     1969             
     1970            self.layout.items_matrix = self.items_matrix 
     1971            self.progressBarInit() 
     1972             
     1973            self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)             
     1974                 
     1975            self.btnRotateMDS.setChecked(False) 
     1976            self.btnRotateMDS.setText("Rotate graph components (MDS)") 
     1977            self.progressBarFinished() 
    16171978         
    1618     def graph_layout_fr(self, weighted): 
    1619         if self.graph is None:   #grafa se ni 
    1620             return 
    1621                
    1622         if not self.optButton.isChecked(): 
    1623           #print "not" 
    1624           self.stopOptimization = 1 
    1625           self.optButton.setChecked(False) 
    1626           self.optButton.setText("Optimize layout") 
    1627           return 
     1979        def rotateComponents(self): 
     1980            if self.items_matrix is None: 
     1981                self.information('Set distance matrix to input signal') 
     1982                self.btnRotate.setChecked(False) 
     1983                return 
     1984             
     1985            if self.graph is None: 
     1986                self.information('No network found') 
     1987                self.btnRotate.setChecked(False) 
     1988                return 
     1989             
     1990            if self.items_matrix.dim != self.graph.number_of_nodes(): 
     1991                self.error('Distance matrix dimensionality must equal number of vertices') 
     1992                self.btnRotate.setChecked(False) 
     1993                return 
     1994             
     1995            if not self.btnRotate.isChecked(): 
     1996              self.layout.stopRotate = 1 
     1997              return 
     1998           
     1999            self.btnRotate.setText("Stop") 
     2000            qApp.processEvents() 
     2001             
     2002            self.layout.items_matrix = self.items_matrix 
     2003            self.progressBarInit() 
     2004            self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas) 
     2005            self.btnRotate.setChecked(False) 
     2006            self.btnRotate.setText("Rotate graph components") 
     2007            self.progressBarFinished() 
     2008             
     2009        def mdsProgress(self, avgStress, stepCount):     
     2010            self.drawForce() 
     2011     
     2012            self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
     2013            self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
     2014            self.progressBarSet(int(stepCount * 100 / self.mdsSteps)) 
     2015            qApp.processEvents() 
     2016             
     2017        def mds_components(self, mdsType=Orange.network.MdsType.componentMDS): 
     2018            if mdsType == Orange.network.MdsType.componentMDS: 
     2019                btn = self.btnMDS 
     2020            elif mdsType == Orange.network.MdsType.exactSimulation: 
     2021                btn = self.btnESIM 
     2022            elif mdsType == Orange.network.MdsType.MDS: 
     2023                btn = self.btnMDSv 
     2024             
     2025            btnCaption = btn.text() 
     2026             
     2027            if self.items_matrix is None: 
     2028                self.information('Set distance matrix to input signal') 
     2029                btn.setChecked(False) 
     2030                return 
     2031             
     2032            if self.layout is None: 
     2033                self.information('No network found') 
     2034                btn.setChecked(False) 
     2035                return 
     2036             
     2037            if self.items_matrix.dim != self.graph.number_of_nodes(): 
     2038                self.error('Distance matrix dimensionality must equal number of vertices') 
     2039                btn.setChecked(False) 
     2040                return 
     2041             
     2042            if not btn.isChecked(): 
     2043                self.layout.stopMDS = 1 
     2044                btn.setChecked(False) 
     2045                btn.setText(btnCaption) 
     2046                return 
     2047             
     2048            btn.setText("Stop") 
     2049            qApp.processEvents() 
     2050             
     2051            self.layout.items_matrix = self.items_matrix 
     2052            self.progressBarInit() 
     2053             
     2054            if self.mdsAvgLinkage: 
     2055                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) 
     2056            else: 
     2057                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)             
     2058             
     2059            btn.setChecked(False) 
     2060            btn.setText(btnCaption) 
     2061            self.progressBarFinished() 
     2062             
     2063        def set_items_distance_matrix(self, matrix): 
     2064            self.error('') 
     2065            self.information('') 
     2066            self.showDistancesCheckBox.setEnabled(0) 
     2067             
     2068            if matrix is None or self.graph is None: 
     2069                self.items_matrix = None 
     2070                self.layout.items_matrix = None 
     2071                if self.networkCanvas: self.networkCanvas.items_matrix = None 
     2072                return 
     2073     
     2074            if matrix.dim != self.graph.number_of_nodes(): 
     2075                self.error('Distance matrix dimensionality must equal number of vertices') 
     2076                self.items_matrix = None 
     2077                self.layout.items_matrix = None 
     2078                if self.networkCanvas: self.networkCanvas.items_matrix = None 
     2079                return 
     2080             
     2081            self.items_matrix = matrix 
     2082            self.layout.items_matrix = matrix 
     2083            if self.networkCanvas: self.networkCanvas.items_matrix = matrix 
     2084            self.showDistancesCheckBox.setEnabled(1) 
     2085             
     2086            self.networkCanvas.updateCanvas() 
     2087                 
     2088        def setSendMarkedNodes(self): 
     2089            if self.checkSendMarkedNodes: 
     2090                self.networkCanvas.sendMarkedNodes = self.sendMarkedNodes 
     2091                self.sendMarkedNodes(self.networkCanvas.getMarkedVertices()) 
     2092            else: 
     2093                self.send("Marked Items", None) 
     2094                self.networkCanvas.sendMarkedNodes = None 
     2095             
     2096        def sendMarkedNodes(self, markedNodes):         
     2097            if len(markedNodes) == 0: 
     2098                self.send("Marked Items", None) 
     2099                return 
     2100             
     2101            if self.graph is not None and self.graph_base.items() is not None: 
     2102                items = self.graph_base.items().getitems(markedNodes) 
     2103                self.send("Marked Items", items) 
     2104                return 
     2105             
     2106            self.send("Marked Items", None) 
     2107             
     2108        def insideviewneighbours(self): 
     2109            if self.networkCanvas.insideview == 1: 
     2110                self.networkCanvas.insideviewNeighbours = self.insideViewNeighbours 
     2111                self.optButton.setChecked(True) 
     2112                self.graph_layout_fr(False) 
     2113             
     2114        def insideview(self): 
     2115            print self.networkCanvas.getSelectedVertices() 
     2116            if len(self.networkCanvas.getSelectedVertices()) == 1: 
     2117                if self.networkCanvas.insideview == 1: 
     2118                    print "insideview: 1" 
     2119                    self.networkCanvas.insideview = 0 
     2120                    self.networkCanvas.showAllVertices() 
     2121                    self.networkCanvas.updateCanvas() 
     2122                else: 
     2123                    print "insideview: 0" 
     2124                    self.networkCanvas.insideview = 1 
     2125                    self.networkCanvas.insideviewNeighbors = self.insideViewNeighbours 
     2126                    self.optButton.setChecked(True) 
     2127                    self.graph_layout_fr(False) 
    16282128         
    1629         self.optButton.setText("Stop") 
    1630         qApp.processEvents() 
    1631         self.stopOptimization = 0 
    1632         tolerance = 5 
    1633         initTemp = 1000 
    1634         breakpoints = 6 
    1635         k = int(self.frSteps / breakpoints) 
    1636         o = self.frSteps % breakpoints 
    1637         iteration = 0 
    1638         coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps) 
    1639  
    1640         if k > 0: 
    1641             while iteration < breakpoints: 
    1642                 #print "iteration, initTemp: " + str(initTemp) 
     2129            else: 
     2130                print "One node must be selected!" 
     2131             
     2132        def showComponents(self): 
     2133            if self.graph is None or self.graph_base.items() is None: 
     2134                return 
     2135             
     2136            vars = [x.name for x in self.graph_base.items_vars()] 
     2137             
     2138            if not self.showComponentCombo.currentText() in vars: 
     2139                self.networkCanvas.showComponentAttribute = None 
     2140                self.lastNameComponentAttribute = '' 
     2141            else: 
     2142                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()      
     2143                 
     2144            self.networkCanvas.drawPlotItems() 
     2145             
     2146        def nameComponents(self): 
     2147            """Names connected components of genes according to GO terms.""" 
     2148            self.progressBarFinished() 
     2149            self.lastNameComponentAttribute = None 
     2150             
     2151            if self.graph is None or self.graph_base.items() is None: 
     2152                return 
     2153             
     2154            vars = [x.name for x in self.graph_base.items_vars()] 
     2155            if not self.nameComponentCombo.currentText() in vars: 
     2156                return 
     2157             
     2158            self.progressBarInit() 
     2159            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
     2160            if 'component name' in self.graph_base.items().domain: 
     2161                keyword_table = self.graph_base.items() 
     2162            else: 
     2163                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
     2164             
     2165            import obiGO  
     2166            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)  
     2167            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
     2168     
     2169            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
     2170            foundGenesets = False 
     2171            if len(annotations.geneNames & allGenes) < 1: 
     2172                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
     2173                if len(annotations.geneNames & allGenes) < 1:             
     2174                    self.warning('no genes found') 
     2175                    return 
     2176                else: 
     2177                    foundGenesets = True 
     2178                 
     2179            def rank(a, j, reverse=False):                     
     2180                if len(a) <= 0: return 
     2181                 
     2182                if reverse:                 
     2183                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
     2184                    top_value = a[0][j] 
     2185                    top_rank = len(a) 
     2186                    max_rank = float(len(a)) 
     2187                    int_ndx = 0 
     2188                    for k in range(len(a)): 
     2189                        if top_value < a[k][j]: 
     2190                            top_value = a[k][j]  
     2191                            if k - int_ndx > 1: 
     2192                                avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2193                                for l in range(int_ndx, k): 
     2194                                    a[l][j] = avg_rank 
     2195                             
     2196                            int_ndx = k 
     2197     
     2198                        a[k][j] = top_rank / max_rank 
     2199                        top_rank -= 1 
     2200                     
     2201                    k += 1 
     2202                    if k - int_ndx > 1: 
     2203                        avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2204                        for l in range(int_ndx, k): 
     2205                            a[l][j] = avg_rank     
     2206                     
     2207                else: 
     2208                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
     2209                    top_value = a[0][j] 
     2210                    top_rank = len(a) 
     2211                    max_rank = float(len(a)) 
     2212                    int_ndx = 0 
     2213                    for k in range(len(a)): 
     2214                        if top_value > a[k][j]: 
     2215                            top_value = a[k][j]  
     2216                            if k - int_ndx > 1: 
     2217                                avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2218                                for l in range(int_ndx, k): 
     2219                                    a[l][j] = avg_rank 
     2220                             
     2221                            int_ndx = k 
     2222     
     2223                        a[k][j] = top_rank / max_rank 
     2224                        top_rank -= 1 
     2225                     
     2226                    k += 1 
     2227                    if k - int_ndx > 1: 
     2228                        avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2 
     2229                        for l in range(int_ndx, k): 
     2230                            a[l][j] = avg_rank 
     2231             
     2232            for i in range(len(components)): 
     2233                component = components[i] 
     2234                if len(component) <= 1: 
     2235                    continue 
     2236                 
     2237                if foundGenesets: 
     2238                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
     2239                else: 
     2240                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
     2241                         
     2242                res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
     2243                res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
     2244                res = res1_base.items() + res2.items() 
     2245                #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] 
     2246                #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] 
     2247                 
     2248                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] 
     2249                if len(namingScore) == 0: 
     2250                    continue 
     2251                 
     2252                annotated_genes = max([a[0] for a in namingScore]) 
     2253                 
     2254                rank(namingScore, 1, reverse=True) 
     2255                rank(namingScore, 2, reverse=True) 
     2256                rank(namingScore, 0) 
     2257                 
     2258                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] 
     2259                namingScore.sort(reverse=True) 
     2260                 
     2261                if len(namingScore) < 1: 
     2262                    print "warning. no annotations found for group of genes: " + ", ".join(genes) 
     2263                    continue 
     2264                elif len(namingScore[0]) < 2: 
     2265                    print "warning. error computing score for group of genes: " + ", ".join(genes) 
     2266                    continue 
     2267                 
     2268                for v in component: 
     2269                    name = str(namingScore[0][1]) 
     2270                    attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4]) 
     2271                    info = '' 
     2272                    if self.showTextMiningInfo: 
     2273                        info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
     2274                    keyword_table[v]['component name'] = name + info 
     2275                 
     2276                self.progressBarSet(i*100.0/len(components)) 
     2277                     
     2278            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
     2279            self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
     2280            self.progressBarFinished()    
     2281             
     2282        def nameComponents_old(self): 
     2283            if self.graph is None or self.graph_base.items() is None: 
     2284                return 
     2285             
     2286            vars = [x.name for x in self.graph_base.items_vars()] 
     2287             
     2288            if not self.nameComponentCombo.currentText() in vars: 
     2289                return 
     2290             
     2291            components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
     2292            keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))])  
     2293             
     2294            excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"] 
     2295            excludePart = ["HSA"] 
     2296            keywords = set() 
     2297            sameKeywords = set() 
     2298             
     2299            for component in components: 
     2300                words = [] 
     2301                all_values = [] 
     2302                for vertex in component: 
     2303                    values = [] 
     2304                    value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     2305                     
     2306                    value = value.replace(" ", ",") 
     2307                    value_top = value.split(",") 
     2308                     
     2309                    for value in value_top: 
     2310                        if len(value) > 0: 
     2311                            tmp = value.split("_") 
     2312                            tmp = [value.strip() for value in tmp if len(value) > 0] 
     2313                            all_values.append(tmp) 
     2314                            values.extend(tmp) 
     2315                                     
     2316                    values = [value.strip() for value in values if len(value) > 0] 
     2317                    words.extend(values) 
     2318                     
     2319                     
     2320                    #value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     2321                    #value = value.replace(" ", "_") 
     2322                    #value = value.replace(",", "_") 
     2323                    #values = value.split("_") 
     2324                    #values = [value.strip() for value in values if len(value) > 0] 
     2325                    #print "values:", values 
     2326                    #all_values.append(values) 
     2327                     
     2328                    #words.extend(values) 
     2329                #print "all_values:", all_values 
     2330                toExclude = [] 
     2331                 
     2332                words = [word for word in words if not word.upper() in excludeWord] 
     2333                toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
     2334                 
     2335                for word in toExclude: 
     2336                    try: 
     2337                        while True: 
     2338                            words.remove(word) 
     2339                    except: 
     2340                        pass 
     2341                 
     2342                counted_words = {} 
     2343                for word in words: 
     2344                    if word in counted_words: 
     2345                        count = counted_words[word] 
     2346                        counted_words[word] = count + 1 
     2347                    else: 
     2348                        counted_words[word] = 1 
     2349                 
     2350                words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
     2351                keyword = "" 
     2352                keyword_words = [] 
     2353                max_count = 0 
     2354                i = 0 
     2355                 
     2356                while i < len(words) and words[i][1] >= max_count: 
     2357                    max_count = words[i][1] 
     2358                    keyword += words[i][0] + " " 
     2359                    keyword_words.append(words[i][0]) 
     2360                    i += 1 
     2361                 
     2362                if len(keyword_words) > 1: 
     2363                    new_all_values = [] 
     2364                    for values in all_values: 
     2365                        new_values = [value for value in values if value in keyword_words] 
     2366                        new_all_values.append(new_values)  
     2367                          
     2368                    #print new_all_values 
     2369                    word_position = [] 
     2370                     
     2371                    for word in keyword_words: 
     2372                        sum = 0 
     2373                        for v in new_all_values: 
     2374                            if word in v: 
     2375                                sum += v.index(word) 
     2376                                 
     2377                        word_position.append((word, sum)) 
     2378                      
     2379                    words = sorted(word_position, key=itemgetter(1)) 
     2380                    #print "words:", words 
     2381                    #print all_values 
     2382                    #print new_all_values 
     2383                     
     2384                    keyword = "" 
     2385                    for word in words: 
     2386                        keyword += word[0] + " " 
     2387                         
     2388                keyword = keyword.strip() 
     2389                 
     2390                for vertex in component: 
     2391                    keyword_table[vertex]['component name'] = keyword 
     2392                     
     2393                if keyword in keywords: 
     2394                    sameKeywords.add(keyword) 
     2395                else: 
     2396                    keywords.add(keyword) 
     2397            #print "sameKeywords:", sameKeywords        
     2398            sameComponents = [component for component in components if str(keyword_table[component[0]]['component name']) in sameKeywords] 
     2399            #print "same components:", sameComponents 
     2400             
     2401            for component in sameComponents: 
     2402                words = [] 
     2403                all_values = [] 
     2404                for vertex in component: 
     2405                    values = [] 
     2406                    value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
     2407                     
     2408                    value = value.replace(" ", ",") 
     2409                    value_top = value.split(",") 
     2410                     
     2411                    for value in value_top: 
     2412                        if len(value) > 0: 
     2413                            tmp = value.split("_") 
     2414                            tmp = [value.strip() for value in tmp if len(value) > 0] 
     2415                            all_values.append(tmp) 
     2416                            values.extend(tmp) 
     2417                                     
     2418                    values = [value.strip() for value in values if len(value) > 0] 
     2419                    words.extend(values) 
     2420                 
     2421                toExclude = [] 
     2422                 
     2423                words = [word for word in words if not word.upper() in excludeWord] 
     2424                toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
     2425                 
     2426                for word in toExclude: 
     2427                    try: 
     2428                        while True: 
     2429                            words.remove(word) 
     2430                    except: 
     2431                        pass 
     2432                 
     2433                counted_words = {} 
     2434                for word in words: 
     2435                    if word in counted_words: 
     2436                        count = counted_words[word] 
     2437                        counted_words[word] = count + 1 
     2438                    else: 
     2439                        counted_words[word] = 1 
     2440                 
     2441                words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
     2442                keyword = "" 
     2443                counts = [int(word[1]) for word in words]  
     2444                max_count = max(counts) 
     2445                 
     2446                try: 
     2447                    while True and len(counts) > 1: 
     2448                        counts.remove(max_count) 
     2449                except: 
     2450                    pass 
     2451                max_count = max(counts) 
     2452                i = 0 
     2453                keyword_words = [] 
     2454                while i < len(words) and words[i][1] >= max_count: 
     2455                    keyword += words[i][0] + " " 
     2456                    keyword_words.append(words[i][0]) 
     2457                    i += 1 
     2458                     
     2459                if len(keyword_words) > 1: 
     2460                    new_all_values = [] 
     2461                    for values in all_values: 
     2462                        new_values = [value for value in values if value in keyword_words] 
     2463                        new_all_values.append(new_values)  
     2464                          
     2465                    #print new_all_values 
     2466                    word_position = [] 
     2467                     
     2468                    for word in keyword_words: 
     2469                        sum = 0 
     2470                        for v in new_all_values: 
     2471                            if word in v: 
     2472                                sum += v.index(word) 
     2473                                 
     2474                        word_position.append((word, sum)) 
     2475                      
     2476                    words = sorted(word_position, key=itemgetter(1)) 
     2477                    #print "words:", words 
     2478                    #print all_values 
     2479                    #print new_all_values 
     2480                     
     2481                    keyword = "" 
     2482                    for word in words: 
     2483                        keyword += word[0] + " " 
     2484                      
     2485                keyword = keyword.strip() 
     2486                for vertex in component: 
     2487                    keyword_table[vertex]['component name'] = keyword 
     2488             
     2489            self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
     2490            #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute 
     2491            items = Orange.data.Table([self.graph_base.items(), keyword_table]) 
     2492            self.setItems(items) 
     2493             
     2494            #for item in items: 
     2495            #    print item 
     2496                             
     2497        def _set_canvas_attr(self, attr, value): 
     2498            setattr(self.networkCanvas, attr, value) 
     2499            self.networkCanvas.updateCanvas() 
     2500                     
     2501        def setSearchStringTimer(self): 
     2502            self.hubs = 1 
     2503            self.searchStringTimer.stop() 
     2504            self.searchStringTimer.start(1000) 
     2505              
     2506        def setMarkMode(self, i = None): 
     2507            self.searchStringTimer.stop() 
     2508            if not i is None: 
     2509                self.hubs = i 
     2510             
     2511            #print self.hubs 
     2512            self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0 
     2513            self.networkCanvas.markWithRed = False 
     2514     
     2515            if self.graph is None: 
     2516                return 
     2517             
     2518            hubs = self.hubs 
     2519            if hubs == 0: 
     2520                self.networkCanvas.setMarkedVertices([]) 
     2521                self.networkCanvas.replot() 
     2522                return 
     2523             
     2524            elif hubs == 1: 
     2525                #print "mark on given label" 
     2526                txt = self.markSearchString 
     2527                labelText = self.networkCanvas.labelText 
     2528                self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
     2529                 
     2530                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()])] 
     2531                self.networkCanvas.setMarkedVertices(toMark) 
     2532                self.networkCanvas.replot() 
     2533                return 
     2534             
     2535            elif hubs == 2: 
     2536                #print "mark on focus" 
     2537                self.networkCanvas.unmark() 
     2538                self.networkCanvas.tooltipNeighbours = self.markDistance 
     2539                return 
     2540     
     2541            elif hubs == 3: 
     2542                #print "mark selected" 
     2543                self.networkCanvas.unmark() 
     2544                self.networkCanvas.selectionNeighbours = self.markDistance 
     2545                self.networkCanvas.markSelectionNeighbours() 
     2546                return 
     2547             
     2548            self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
     2549            powers = self.graph.degree() 
     2550            powers = [powers[key] for key in sorted(powers.keys())] 
     2551             
     2552            if hubs == 4: # at least N connections 
     2553                #print "mark at least N connections" 
     2554                N = self.markNConnections 
     2555                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power >= N]) 
     2556                self.networkCanvas.replot() 
     2557            elif hubs == 5: 
     2558                #print "mark at most N connections" 
     2559                N = self.markNConnections 
     2560                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power <= N]) 
     2561                self.networkCanvas.replot() 
     2562            elif hubs == 6: 
     2563                #print "mark more than any" 
     2564                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
     2565                self.networkCanvas.replot() 
     2566            elif hubs == 7: 
     2567                #print "mark more than avg" 
     2568                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])]) 
     2569                self.networkCanvas.replot() 
     2570            elif hubs == 8: 
     2571                #print "mark most" 
     2572                sortedIdx = range(len(powers)) 
     2573                sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y])) 
     2574                cutP = self.markNumber - 1 
     2575                cutPower = powers[sortedIdx[cutP]] 
     2576                while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower: 
     2577                    cutP += 1 
     2578                self.networkCanvas.setMarkedVertices(sortedIdx[:cutP]) 
     2579                self.networkCanvas.replot() 
     2580            elif hubs == 9: 
     2581                self.setMarkInput() 
     2582            
     2583        def testRefresh(self): 
     2584            start = time.time() 
     2585            self.networkCanvas.replot() 
     2586            stop = time.time()     
     2587            print "replot in " + str(stop - start) 
     2588             
     2589        def save_network(self): 
     2590            if self.networkCanvas is None or self.graph is None: 
     2591                return 
     2592             
     2593            filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
     2594            if filename: 
     2595                fn = "" 
     2596                head, tail = os.path.splitext(str(filename)) 
     2597                if not tail: 
     2598                    fn = head + ".net" 
     2599                else: 
     2600                    fn = str(filename) 
     2601                 
     2602                for i in range(self.graph.number_of_nodes()): 
     2603                    node = self.graph.node[i] 
     2604                    node['x'] = self.layout.coors[0][i] 
     2605                    node['y'] = self.layout.coors[1][i] 
     2606     
     2607                Orange.network.readwrite.write(self.graph, fn) 
     2608                 
     2609        def sendData(self): 
     2610            graph = self.networkCanvas.getSelectedGraph() 
     2611            vertices = self.networkCanvas.getSelectedVertices() 
     2612             
     2613            if graph is not None: 
     2614                if graph.items() is not None: 
     2615                    self.send("Selected Items", graph.items()) 
     2616                else: 
     2617                    nodes = self.networkCanvas.getSelectedExamples() 
     2618                     
     2619                    if len(nodes) > 0 and self.graph_base.items() is not None: 
     2620                        self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
     2621                    else: 
     2622                        self.send("Selected Items", None) 
     2623                     
     2624                nodes = self.networkCanvas.getUnselectedExamples() 
     2625                if len(nodes) > 0 and self.graph_base.items() is not None: 
     2626                    self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     2627                else: 
     2628                    self.send("Unselected Items", None) 
     2629                     
     2630                self.send("Selected Network", graph) 
     2631            else: 
     2632                nodes = self.networkCanvas.getSelectedExamples() 
     2633                if len(nodes) > 0 and self.graph_base.items() is not None: 
     2634                    self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
     2635                else: 
     2636                    self.send("Selected Items", None) 
     2637                     
     2638                nodes = self.networkCanvas.getUnselectedExamples() 
     2639                if len(nodes) > 0 and self.graph_base.items() is not None: 
     2640                    self.send("Unselected Items", self.graph_base.items().getitems(nodes)) 
     2641                else: 
     2642                    self.send("Unselected Items", None) 
     2643             
     2644            matrix = None 
     2645            if self.items_matrix is not None: 
     2646                matrix = self.items_matrix.getitems(vertices) 
     2647     
     2648            self.send("Selected Items Distance Matrix", matrix) 
     2649                     
     2650        def setCombos(self): 
     2651            vars = self.graph_base.items_vars() 
     2652            edgeVars = self.graph_base.links_vars() 
     2653            lastLabelColumns = self.lastLabelColumns 
     2654            lastTooltipColumns = self.lastTooltipColumns 
     2655             
     2656            self.clearCombos() 
     2657             
     2658            self.attributes = [(var.name, var.varType) for var in vars] 
     2659            self.edgeAttributes = [(var.name, var.varType) for var in edgeVars] 
     2660             
     2661            for var in vars: 
     2662                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
     2663                    self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2664                     
     2665                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: 
     2666                     
     2667                    value = self.graph_base.items()[0][var].value 
     2668                     
     2669                    # can value be a list? 
     2670                    try: 
     2671                        if type(eval(value)) == type([]): 
     2672                            self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2673                            continue 
     2674                    except: 
     2675                        pass 
     2676                     
     2677                    if len(value.split(',')) > 1: 
     2678                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
     2679                     
     2680                elif var.varType in [Orange.data.Type.Continuous]: 
     2681                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2682     
     2683                self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2684                self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2685                self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2686                self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2687             
     2688            for var in edgeVars: 
     2689                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
     2690                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
     2691                     
     2692            for i in range(self.vertexSizeCombo.count()): 
     2693                if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i): 
     2694                    self.vertexSize = i 
     2695                    break 
     2696                 
     2697            for i in range(self.colorCombo.count()): 
     2698                if self.lastColorColumn == self.colorCombo.itemText(i): 
     2699                    self.color = i 
     2700                    break 
     2701     
     2702            for i in range(self.attListBox.count()): 
     2703                if str(self.attListBox.item(i).text()) in lastLabelColumns: 
     2704                    self.attListBox.item(i).setSelected(1) 
     2705                     
     2706            for i in range(self.tooltipListBox.count()): 
     2707                if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns: 
     2708                    self.tooltipListBox.item(i).setSelected(1) 
     2709                 
     2710            self.lastLabelColumns = lastLabelColumns 
     2711            self.lastTooltipColumns = lastTooltipColumns 
     2712             
     2713        def clearCombos(self): 
     2714            self.attributes = [] 
     2715            self.edgeAttributes = [] 
     2716             
     2717            self.colorCombo.clear() 
     2718            self.vertexSizeCombo.clear() 
     2719            self.nameComponentCombo.clear() 
     2720            self.showComponentCombo.clear() 
     2721            self.edgeColorCombo.clear() 
     2722            self.editCombo.clear() 
     2723            self.comboAttSelection.clear() 
     2724             
     2725            self.colorCombo.addItem("(same color)") 
     2726            self.edgeColorCombo.addItem("(same color)") 
     2727            self.vertexSizeCombo.addItem("(same size)") 
     2728            self.nameComponentCombo.addItem("Select attribute") 
     2729            self.showComponentCombo.addItem("Select attribute") 
     2730            self.editCombo.addItem("Select attribute") 
     2731            self.comboAttSelection.addItem("Select attribute") 
     2732           
     2733        def change_graph(self, newgraph): 
     2734            old_nodes = set(self.graph.nodes_iter()) 
     2735            new_nodes = set(newgraph.nodes_iter()) 
     2736            inter_nodes = old_nodes.intersection(new_nodes) 
     2737            remove_nodes = old_nodes.difference(inter_nodes) 
     2738            add_nodes = new_nodes.difference(inter_nodes) 
     2739             
     2740            [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes] 
     2741            self.networkCanvas.networkCurve.coors.update((node, (0,0)) for node in add_nodes) 
     2742            positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
     2743            self.layout.set_graph(newgraph, positions) 
     2744             
     2745            self.graph = newgraph 
     2746            self.number_of_nodes_label = self.graph.number_of_nodes() 
     2747            self.number_of_edges_label = self.graph.number_of_edges() 
     2748             
     2749            self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes) 
     2750             
     2751    #        self.nShown = self.graph.number_of_nodes() 
     2752    #         
     2753    #        if self.graph.number_of_edges() > 0: 
     2754    #            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
     2755    #        else: 
     2756    #            self.verticesPerEdge = 0 
     2757    #             
     2758    #        if self.graph.number_of_nodes() > 0: 
     2759    #            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
     2760    #        else: 
     2761    #            self.edgesPerVertex = 0 
     2762    #         
     2763    #        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
     2764    #        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     2765    #        if len(components) > 1: 
     2766    #            self.diameter = -1 
     2767    #        else: 
     2768    #            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
     2769    #        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     2770             
     2771            k = 1.13850193174e-008 
     2772            nodes = self.graph.number_of_nodes() 
     2773            t = k * nodes * nodes 
     2774            self.frSteps = int(5.0 / t) 
     2775            if self.frSteps <   1: self.frSteps = 1; 
     2776            if self.frSteps > 3000: self.frSteps = 3000; 
     2777             
     2778            if self.frSteps < 10: 
     2779                self.renderAntialiased = 0 
     2780                self.minVertexSize = 5 
     2781                self.maxVertexSize = 5 
     2782                self.maxLinkSize = 1 
     2783                self.optMethod = 0 
     2784                self.graph_layout_method()             
     2785                 
     2786            #self.setVertexColor() 
     2787            #self.setEdgeColor() 
     2788            #self.networkCanvas.setEdgesSize() 
     2789             
     2790            #self.clickedAttLstBox() 
     2791            #self.clickedTooltipLstBox() 
     2792            #self.clickedEdgeLabelListBox() 
     2793             
     2794            self.optButton.setChecked(1) 
     2795            self.graph_layout()         
     2796            self.information(0) 
     2797             
     2798        def set_graph(self, graph): 
     2799            self.set_items_distance_matrix(None) 
     2800                  
     2801            if graph is None: 
     2802                self.graph = None 
     2803                self.graph_base = None 
     2804                self.layout.set_graph(None) 
     2805                self.networkCanvas.set_graph_layout(None, None) 
     2806                self.clearCombos() 
     2807                self.number_of_nodes_label = -1 
     2808                self.number_of_edges_label = -1 
     2809                self._items = None 
     2810                self._links = None 
     2811                return 
     2812             
     2813            self.graph_base = graph 
     2814             
     2815            if self._network_view is not None: 
     2816                graph = self._network_view.init_network(graph) 
     2817             
     2818             
     2819            #print "OWNetwork/setGraph: new visualizer..." 
     2820            self.graph = graph 
     2821             
     2822            if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
     2823                positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
     2824                             for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
     2825                             and self._items[node]['y'].value != '?'] 
     2826                self.layout.set_graph(self.graph, positions) 
     2827            else: 
     2828                self.layout.set_graph(self.graph) 
     2829             
     2830            self.number_of_nodes_label = self.graph.number_of_nodes() 
     2831            self.number_of_edges_label = self.graph.number_of_edges() 
     2832             
     2833            self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
     2834            self.networkCanvas.renderAntialiased = self.renderAntialiased 
     2835            self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     2836            self.networkCanvas.minVertexSize = self.minVertexSize 
     2837            self.networkCanvas.maxVertexSize = self.maxVertexSize 
     2838            self.networkCanvas.maxEdgeSize = self.maxLinkSize 
     2839            self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
     2840            self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
     2841            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
     2842            self.lastColorColumn = self.colorCombo.currentText() 
     2843             
     2844            self.nShown = self.graph.number_of_nodes() 
     2845             
     2846            if self.graph.number_of_edges() > 0: 
     2847                self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
     2848            else: 
     2849                self.verticesPerEdge = 0 
     2850                 
     2851            if self.graph.number_of_nodes() > 0: 
     2852                self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
     2853            else: 
     2854                self.edgesPerVertex = 0 
     2855             
     2856            undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
     2857            components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
     2858            if len(components) > 1: 
     2859                self.diameter = -1 
     2860            else: 
     2861                self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
     2862             
     2863            if self.graph.is_multigraph(): 
     2864                self.clustering_coefficient = -1 
     2865            else: 
     2866                self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
     2867             
     2868            self.setCombos() 
     2869                 
     2870            lastNameComponentAttributeFound = False 
     2871            for i in range(self.nameComponentCombo.count()): 
     2872                if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i): 
     2873                    lastNameComponentAttributeFound = True 
     2874                    self.nameComponentAttribute = i 
     2875                    self.nameComponents() 
     2876                    self.showComponentAttribute = self.showComponentCombo.count() - 1 
     2877                    self.showComponents() 
     2878                    break 
     2879                 
     2880            if not lastNameComponentAttributeFound: 
     2881                self.lastNameComponentAttribute = '' 
     2882             
     2883            self.showComponentAttribute = None 
     2884     
     2885            k = 1.13850193174e-008 
     2886            nodes = self.graph.number_of_nodes() 
     2887            t = k * nodes * nodes 
     2888            self.frSteps = int(5.0 / t) 
     2889            if self.frSteps <   1: self.frSteps = 1; 
     2890            if self.frSteps > 3000: self.frSteps = 3000; 
     2891             
     2892            self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
     2893            self.networkCanvas.showWeights = self.showWeights 
     2894            self.networkCanvas.showIndexes = self.showIndexes 
     2895            # if graph is large, set random layout, min vertex size, min edge size 
     2896            if self.frSteps < 10: 
     2897                self.renderAntialiased = 0 
     2898                self.minVertexSize = 5 
     2899                self.maxVertexSize = 5 
     2900                self.maxLinkSize = 1 
     2901                self.optMethod = 0 
     2902                self.graph_layout_method()             
     2903                 
     2904            if self.vertexSize > 0: 
     2905                self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize) 
     2906            else: 
     2907                self.networkCanvas.setVerticesSize() 
     2908                 
     2909            self.setVertexColor() 
     2910            self.setEdgeColor() 
     2911                 
     2912            self.networkCanvas.setEdgesSize() 
     2913            self.clickedAttLstBox() 
     2914            self.clickedTooltipLstBox() 
     2915            self.clickedEdgeLabelListBox() 
     2916             
     2917            self.optButton.setChecked(1) 
     2918            self.graph_layout()         
     2919            self.information(0) 
     2920            #self.networkCanvas.updateCanvas() 
     2921             
     2922        def set_network_view(self, nxView): 
     2923            self._network_view = nxView 
     2924            self._network_view.set_nx_explorer(self) 
     2925            self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected 
     2926            self.set_graph(self.graph_base) 
     2927             
     2928        def setItems(self, items=None): 
     2929            self.error('') 
     2930             
     2931            if self.graph is None or items is None: 
     2932                return 
     2933             
     2934            if len(items) != self.graph_base.number_of_nodes(): 
     2935                self.error('ExampleTable items must have one example for each vertex.') 
     2936                return 
     2937             
     2938            self.graph_base.set_items(items) 
     2939             
     2940            self.setVertexSize() 
     2941            self.networkCanvas.showIndexes = self.showIndexes 
     2942            self.networkCanvas.showWeights = self.showWeights 
     2943            self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
     2944            self.setCombos() 
     2945            self.networkCanvas.updateData() 
     2946             
     2947        def setMarkInput(self): 
     2948            var = str(self.markInputCombo.currentText()) 
     2949            #print 'combo:',self.markInputCombo.currentText() 
     2950            if self.markInputItems is not None and len(self.markInputItems) > 0: 
     2951                values = [str(x[var]).strip().upper() for x in self.markInputItems] 
     2952                toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
     2953                #print "mark:", toMark 
     2954                self.networkCanvas.setMarkedVertices(list(toMark)) 
     2955                self.networkCanvas.replot() 
     2956                 
     2957            else: 
     2958                self.networkCanvas.setMarkedVertices([]) 
     2959                self.networkCanvas.replot()             
     2960         
     2961        def markItems(self, items): 
     2962            self.markInputCombo.clear() 
     2963            self.markInputRadioButton.setEnabled(False) 
     2964            self.markInputItems = items 
     2965             
     2966            if self.graph is None or self.graph_base.items() is None or items is None: 
     2967                return 
     2968             
     2969            if len(items) > 0: 
     2970                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()] 
     2971                lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
     2972                commonVars = set(lstNewDomain) & set(lstOrgDomain) 
     2973     
     2974                if len(commonVars) > 0: 
     2975                    for var in commonVars: 
     2976                        orgVar = self.graph_base.items().domain[var] 
     2977                        mrkVar = items.domain[var] 
     2978     
     2979                        if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String: 
     2980                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
     2981                            self.markInputRadioButton.setEnabled(True) 
     2982                     
     2983                            self.setMarkMode(9) 
     2984                   
     2985        def setExampleSubset(self, subset): 
     2986            if self.networkCanvas is None: 
     2987                return 
     2988             
     2989            self.warning('') 
     2990            hiddenNodes = [] 
     2991             
     2992            if subset is not None: 
     2993                try: 
     2994                    expected = 1 
     2995                    for row in subset: 
     2996                        index = int(row['index'].value) 
     2997                        if expected != index: 
     2998                            hiddenNodes += range(expected-1, index-1) 
     2999                            expected = index + 1 
     3000                        else: 
     3001                            expected += 1 
     3002                             
     3003                    hiddenNodes += range(expected-1, self.graph.number_of_nodes()) 
     3004                     
     3005                    self.networkCanvas.setHiddenNodes(hiddenNodes) 
     3006                except: 
     3007                    self.warning('"index" attribute does not exist in "items" table.') 
     3008                         
     3009        def showDegreeDistribution(self): 
     3010            if self.graph is None: 
     3011                return 
     3012             
     3013            from matplotlib import rcParams 
     3014            import pylab as p 
     3015             
     3016            x = self.graph.degree().values() 
     3017            nbins = len(set(x)) 
     3018            if nbins > 500: 
     3019              bbins = 500 
     3020             
     3021            # the histogram of the data 
     3022            n, bins, patches = p.hist(x, nbins) 
     3023             
     3024            p.xlabel('Degree') 
     3025            p.ylabel('No. of nodes') 
     3026            p.title(r'Degree distribution') 
     3027             
     3028            p.show() 
     3029             
     3030        def setColors(self): 
     3031            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
     3032            if dlg.exec_(): 
     3033                self.colorSettings = dlg.getColorSchemas() 
     3034                self.selectedSchemaIndex = dlg.selectedSchemaIndex 
     3035                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
     3036                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
     3037                 
     3038                self.setVertexColor() 
     3039                 
     3040        def setEdgeColorPalette(self): 
     3041            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
     3042            if dlg.exec_(): 
     3043                self.edgeColorSettings = dlg.getColorSchemas() 
     3044                self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex 
     3045                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
     3046                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
     3047                 
     3048                self.setEdgeColor() 
     3049         
     3050        def createColorDialog(self, colorSettings, selectedSchemaIndex): 
     3051            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
     3052            c.createDiscretePalette("discPalette", "Discrete Palette") 
     3053            c.createContinuousPalette("contPalette", "Continuous Palette") 
     3054            c.setColorSchemas(colorSettings, selectedSchemaIndex) 
     3055            return c 
     3056         
     3057        """ 
     3058        Layout Optimization 
     3059        """ 
     3060         
     3061        def graph_layout(self): 
     3062            if self.graph is None:   #grafa se ni 
     3063                self.optButton.setChecked(False) 
     3064                return 
     3065             
     3066            if not self.optButton.isChecked(): 
     3067                self.optButton.setChecked(False) 
     3068                return 
     3069             
     3070            qApp.processEvents() 
     3071                 
     3072            if self.optMethod == 1: 
     3073                self.layout.random() 
     3074            elif self.optMethod == 2: 
     3075                self.graph_layout_fr(False) 
     3076            elif self.optMethod == 3: 
     3077                self.graph_layout_fr(True) 
     3078            elif self.optMethod == 4: 
     3079                self.graph_layout_fr_radial() 
     3080            elif self.optMethod == 5: 
     3081                self.layout.circular_crossing_reduction() 
     3082            elif self.optMethod == 6: 
     3083                self.layout.circular_original() 
     3084            elif self.optMethod == 7: 
     3085                self.layout.circular_random() 
     3086            elif self.optMethod == 8: 
     3087                self.graph_layout_pivot_mds() 
     3088                 
     3089            self.optButton.setChecked(False) 
     3090            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3091            self.networkCanvas.updateCanvas() 
     3092            qApp.processEvents() 
     3093             
     3094        def graph_layout_method(self, method=None): 
     3095            self.information() 
     3096            self.stepsSpin.label.setText('Iterations: ') 
     3097             
     3098            if method is not None: 
     3099                self.optMethod = method 
     3100                 
     3101            if str(self.optMethod) == '0': 
     3102                self.optButton.setEnabled(False) 
     3103            else: 
     3104                self.optButton.setEnabled(True) 
     3105                 
     3106            if str(self.optMethod) in ['2', '3', '4']: 
     3107                self.stepsSpin.setEnabled(True) 
     3108            elif str(self.optMethod) == '8': 
     3109                self.stepsSpin.label.setText('Pivots: ') 
     3110                self.stepsSpin.setEnabled(True) 
     3111                 
     3112                if self.items_matrix is None: 
     3113                    self.information('Set distance matrix to input signal') 
     3114                    return 
     3115                if self.graph is None: 
     3116                    self.information('No network found') 
     3117                    return 
     3118                if self.items_matrix.dim != self.graph.number_of_nodes(): 
     3119                    self.error('Distance matrix dimensionality must equal number of vertices') 
     3120                    return 
     3121            else: 
     3122                self.stepsSpin.setEnabled(False) 
     3123                self.optButton.setChecked(True) 
     3124                self.graph_layout() 
     3125             
     3126        def graph_layout_fr(self, weighted): 
     3127            if self.graph is None:   #grafa se ni 
     3128                return 
     3129                   
     3130            if not self.optButton.isChecked(): 
     3131              #print "not" 
     3132              self.stopOptimization = 1 
     3133              self.optButton.setChecked(False) 
     3134              self.optButton.setText("Optimize layout") 
     3135              return 
     3136             
     3137            self.optButton.setText("Stop") 
     3138            qApp.processEvents() 
     3139            self.stopOptimization = 0 
     3140            tolerance = 5 
     3141            initTemp = 1000 
     3142            breakpoints = 6 
     3143            k = int(self.frSteps / breakpoints) 
     3144            o = self.frSteps % breakpoints 
     3145            iteration = 0 
     3146            coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps) 
     3147     
     3148            if k > 0: 
     3149                while iteration < breakpoints: 
     3150                    #print "iteration, initTemp: " + str(initTemp) 
     3151                    if self.stopOptimization: 
     3152                        return 
     3153                    initTemp = self.layout.fr(k, initTemp, coolFactor, weighted) 
     3154                    iteration += 1 
     3155                    qApp.processEvents() 
     3156                    self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3157                    self.networkCanvas.updateCanvas() 
     3158                 
     3159                #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp) 
    16433160                if self.stopOptimization: 
    1644                     return 
    1645                 initTemp = self.layout.fr(k, initTemp, coolFactor, weighted) 
    1646                 iteration += 1 
     3161                        return 
     3162                initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
    16473163                qApp.processEvents() 
    16483164                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    16493165                self.networkCanvas.updateCanvas() 
    1650              
    1651             #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp) 
    1652             if self.stopOptimization: 
    1653                     return 
    1654             initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
     3166            else: 
     3167                while iteration < o: 
     3168                    #print "iteration ostanek, initTemp: " + str(initTemp) 
     3169                    if self.stopOptimization: 
     3170                        return 
     3171                    initTemp = self.layout.fr(1, initTemp, coolFactor, weighted) 
     3172                    iteration += 1 
     3173                    qApp.processEvents() 
     3174                    self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3175                    self.networkCanvas.updateCanvas() 
     3176                     
     3177            self.optButton.setChecked(False) 
     3178            self.optButton.setText("Optimize layout") 
     3179             
     3180        def graph_layout_fr_special(self): 
     3181            if self.graph is None:   #grafa se ni 
     3182                return 
     3183             
     3184            steps = 100 
     3185            initTemp = 1000 
     3186            coolFactor = math.exp(math.log(10.0/10000.0) / steps) 
     3187            oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())] 
     3188            #print oldXY 
     3189            initTemp = self.layout.fr(steps, initTemp, coolFactor) 
     3190            #print oldXY 
     3191            self.networkCanvas.updateDataSpecial(oldXY) 
     3192            self.networkCanvas.replot() 
     3193                     
     3194        def graph_layout_fr_radial(self): 
     3195            if self.graph is None:   #grafa se ni 
     3196                return 
     3197             
     3198            #print "F-R Radial" 
     3199            k = 1.13850193174e-008 
     3200            nodes = self.graph.number_of_nodes() 
     3201            t = k * nodes * nodes 
     3202            refreshRate = int(5.0 / t) 
     3203            if refreshRate <    1: refreshRate = 1; 
     3204            if refreshRate > 1500: refreshRate = 1500; 
     3205            #print "refreshRate: " + str(refreshRate) 
     3206             
     3207            tolerance = 5 
     3208            initTemp = 100 
     3209            centerNdx = 0 
     3210             
     3211            selection = self.networkCanvas.getSelection() 
     3212            if len(selection) > 0: 
     3213                centerNdx = selection[0] 
     3214                 
     3215            #print "center ndx: " + str(centerNdx) 
     3216            initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
     3217            self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5] 
     3218            #self.networkCanvas.circles = [100, 200, 300] 
     3219            self.networkCanvas.updateCanvas() 
     3220            self.networkCanvas.circles = [] 
     3221                 
     3222        def graph_layout_pivot_mds(self): 
     3223            self.information() 
     3224             
     3225            if self.items_matrix is None: 
     3226                self.information('Set distance matrix to input signal') 
     3227                return 
     3228             
     3229            if self.graph is None: 
     3230                self.information('No network found') 
     3231                return 
     3232             
     3233            if self.items_matrix.dim != self.graph.number_of_nodes(): 
     3234                self.error('Distance matrix dimensionality must equal number of vertices') 
     3235                return 
     3236             
     3237            self.frSteps = min(self.frSteps, self.items_matrix.dim) 
    16553238            qApp.processEvents() 
    1656             self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
     3239            mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps) 
     3240            x,y = mds.optimize() 
     3241            self.layout.coors[0] = x 
     3242            self.layout.coors[1] = y 
    16573243            self.networkCanvas.updateCanvas() 
    1658         else: 
    1659             while iteration < o: 
    1660                 #print "iteration ostanek, initTemp: " + str(initTemp) 
    1661                 if self.stopOptimization: 
    1662                     return 
    1663                 initTemp = self.layout.fr(1, initTemp, coolFactor, weighted) 
    1664                 iteration += 1 
    1665                 qApp.processEvents() 
    1666                 self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)  
    1667                 self.networkCanvas.updateCanvas() 
    1668                  
    1669         self.optButton.setChecked(False) 
    1670         self.optButton.setText("Optimize layout") 
    16713244         
    1672     def graph_layout_fr_special(self): 
    1673         if self.graph is None:   #grafa se ni 
    1674             return 
     3245           
     3246        """ 
     3247        Network Visualization 
     3248        """ 
     3249            
     3250        def clickedAttLstBox(self): 
     3251            if self.graph is None: 
     3252                return 
     3253             
     3254            self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes]) 
     3255            self.networkCanvas.setLabelText(self.lastLabelColumns) 
     3256            self.networkCanvas.updateData() 
     3257            self.networkCanvas.replot() 
     3258       
     3259        def clickedTooltipLstBox(self): 
     3260            if self.graph is None: 
     3261                return 
     3262             
     3263            self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes]) 
     3264            self.networkCanvas.setTooltipText(self.lastTooltipColumns) 
     3265            self.networkCanvas.updateData() 
     3266            self.networkCanvas.replot() 
     3267             
     3268        def clickedEdgeLabelListBox(self): 
     3269            if self.graph is None: 
     3270                return 
     3271             
     3272            self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
     3273            self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes) 
     3274            self.networkCanvas.updateData() 
     3275            self.networkCanvas.replot() 
     3276     
     3277        def setVertexColor(self): 
     3278            if self.graph is None: 
     3279                return 
     3280             
     3281            self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
     3282            self.lastColorColumn = self.colorCombo.currentText() 
     3283            self.networkCanvas.updateData() 
     3284            self.networkCanvas.replot() 
     3285             
     3286        def setEdgeColor(self): 
     3287            if self.graph is None: 
     3288                return 
     3289             
     3290            self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
     3291            self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
     3292            self.networkCanvas.updateData() 
     3293            self.networkCanvas.replot() 
     3294                       
     3295        def setGraphGrid(self): 
     3296            self.networkCanvas.enableGridY(self.networkCanvasShowGrid) 
     3297            self.networkCanvas.enableGridX(self.networkCanvasShowGrid) 
    16753298         
    1676         steps = 100 
    1677         initTemp = 1000 
    1678         coolFactor = math.exp(math.log(10.0/10000.0) / steps) 
    1679         oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())] 
    1680         #print oldXY 
    1681         initTemp = self.layout.fr(steps, initTemp, coolFactor) 
    1682         #print oldXY 
    1683         self.networkCanvas.updateDataSpecial(oldXY) 
    1684         self.networkCanvas.replot() 
    1685                  
    1686     def graph_layout_fr_radial(self): 
    1687         if self.graph is None:   #grafa se ni 
    1688             return 
     3299        def selectAllConnectedNodes(self): 
     3300            self.networkCanvas.selectConnectedNodes(1000000) 
     3301                     
     3302        def setMaxLinkSize(self): 
     3303            if self.graph is None: 
     3304                return 
     3305             
     3306            self.networkCanvas.maxEdgeSize = self.maxLinkSize 
     3307            self.networkCanvas.setEdgesSize() 
     3308            self.networkCanvas.replot() 
    16893309         
    1690         #print "F-R Radial" 
    1691         k = 1.13850193174e-008 
    1692         nodes = self.graph.number_of_nodes() 
    1693         t = k * nodes * nodes 
    1694         refreshRate = int(5.0 / t) 
    1695         if refreshRate <    1: refreshRate = 1; 
    1696         if refreshRate > 1500: refreshRate = 1500; 
    1697         #print "refreshRate: " + str(refreshRate) 
    1698          
    1699         tolerance = 5 
    1700         initTemp = 100 
    1701         centerNdx = 0 
    1702          
    1703         selection = self.networkCanvas.getSelection() 
    1704         if len(selection) > 0: 
    1705             centerNdx = selection[0] 
    1706              
    1707         #print "center ndx: " + str(centerNdx) 
    1708         initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
    1709         self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5] 
    1710         #self.networkCanvas.circles = [100, 200, 300] 
    1711         self.networkCanvas.updateCanvas() 
    1712         self.networkCanvas.circles = [] 
    1713              
    1714     def graph_layout_pivot_mds(self): 
    1715         self.information() 
    1716          
    1717         if self.items_matrix is None: 
    1718             self.information('Set distance matrix to input signal') 
    1719             return 
    1720          
    1721         if self.graph is None: 
    1722             self.information('No network found') 
    1723             return 
    1724          
    1725         if self.items_matrix.dim != self.graph.number_of_nodes(): 
    1726             self.error('Distance matrix dimensionality must equal number of vertices') 
    1727             return 
    1728          
    1729         self.frSteps = min(self.frSteps, self.items_matrix.dim) 
    1730         qApp.processEvents() 
    1731         mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps) 
    1732         x,y = mds.optimize() 
    1733         self.layout.coors[0] = x 
    1734         self.layout.coors[1] = y 
    1735         self.networkCanvas.updateCanvas() 
    1736      
    1737        
    1738     """ 
    1739     Network Visualization 
    1740     """ 
    1741         
    1742     def clickedAttLstBox(self): 
    1743         if self.graph is None: 
    1744             return 
    1745          
    1746         self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes]) 
    1747         self.networkCanvas.setLabelText(self.lastLabelColumns) 
    1748         self.networkCanvas.updateData() 
    1749         self.networkCanvas.replot() 
    1750    
    1751     def clickedTooltipLstBox(self): 
    1752         if self.graph is None: 
    1753             return 
    1754          
    1755         self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes]) 
    1756         self.networkCanvas.setTooltipText(self.lastTooltipColumns) 
    1757         self.networkCanvas.updateData() 
    1758         self.networkCanvas.replot() 
    1759          
    1760     def clickedEdgeLabelListBox(self): 
    1761         if self.graph is None: 
    1762             return 
    1763          
    1764         self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
    1765         self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes) 
    1766         self.networkCanvas.updateData() 
    1767         self.networkCanvas.replot() 
    1768  
    1769     def setVertexColor(self): 
    1770         if self.graph is None: 
    1771             return 
    1772          
    1773         self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
    1774         self.lastColorColumn = self.colorCombo.currentText() 
    1775         self.networkCanvas.updateData() 
    1776         self.networkCanvas.replot() 
    1777          
    1778     def setEdgeColor(self): 
    1779         if self.graph is None: 
    1780             return 
    1781          
    1782         self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
    1783         self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    1784         self.networkCanvas.updateData() 
    1785         self.networkCanvas.replot() 
    1786                    
    1787     def setGraphGrid(self): 
    1788         self.networkCanvas.enableGridY(self.networkCanvasShowGrid) 
    1789         self.networkCanvas.enableGridX(self.networkCanvasShowGrid) 
    1790      
    1791     def selectAllConnectedNodes(self): 
    1792         self.networkCanvas.selectConnectedNodes(1000000) 
    1793                  
    1794     def setMaxLinkSize(self): 
    1795         if self.graph is None: 
    1796             return 
    1797          
    1798         self.networkCanvas.maxEdgeSize = self.maxLinkSize 
    1799         self.networkCanvas.setEdgesSize() 
    1800         self.networkCanvas.replot() 
    1801      
    1802     def setVertexSize(self): 
    1803         if self.graph is None or self.networkCanvas is None: 
    1804             return 
    1805          
    1806         if self.minVertexSize > self.maxVertexSize: 
    1807             self.maxVertexSize = self.minVertexSize 
    1808          
    1809         self.networkCanvas.minVertexSize = self.minVertexSize 
    1810         self.networkCanvas.maxVertexSize = self.maxVertexSize 
    1811         self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    1812          
    1813         if self.vertexSize > 0: 
    1814             self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize) 
    1815         else: 
    1816             self.networkCanvas.setVerticesSize() 
    1817              
    1818         self.networkCanvas.replot() 
    1819          
    1820     def setFontSize(self): 
    1821         if self.networkCanvas is None: 
    1822             return 
    1823          
    1824         self.networkCanvas.fontSize = self.fontSize 
    1825         self.networkCanvas.drawPlotItems() 
    1826                  
    1827     def sendReport(self): 
    1828         self.reportSettings("Graph data", 
    1829                             [("Number of vertices", self.graph.number_of_nodes()), 
    1830                              ("Number of edges", self.graph.number_of_edges()), 
    1831                              ("Vertices per edge", "%.3f" % self.verticesPerEdge), 
    1832                              ("Edges per vertex", "%.3f" % self.edgesPerVertex), 
    1833                              ("Diameter", self.diameter), 
    1834                              ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient) 
    1835                              ]) 
    1836         if self.color or self.vertexSize or self.markerAttributes or self.edgeColor: 
    1837             self.reportSettings("Visual settings", 
    1838                                 [self.color and ("Vertex color", self.colorCombo.currentText()), 
    1839                                  self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""), 
    1840                                  self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)), 
    1841                                  self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()), 
    1842                                 ]) 
    1843         self.reportSettings("Optimization", 
    1844                             [("Method", self.optCombo.currentText()), 
    1845                              ("Iterations", self.frSteps)]) 
    1846         self.reportSection("Graph") 
    1847         self.reportImage(self.networkCanvas.saveToFileDirect)         
    1848          
     3310        def setVertexSize(self): 
     3311            if self.graph is None or self.networkCanvas is None: 
     3312                return 
     3313             
     3314            if self.minVertexSize > self.maxVertexSize: 
     3315                self.maxVertexSize = self.minVertexSize 
     3316             
     3317            self.networkCanvas.minVertexSize = self.minVertexSize 
     3318            self.networkCanvas.maxVertexSize = self.maxVertexSize 
     3319            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
     3320             
     3321            if self.vertexSize > 0: 
     3322                self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize) 
     3323            else: 
     3324                self.networkCanvas.setVerticesSize() 
     3325                 
     3326            self.networkCanvas.replot() 
     3327             
     3328        def setFontSize(self): 
     3329            if self.networkCanvas is None: 
     3330                return 
     3331             
     3332            self.networkCanvas.fontSize = self.fontSize 
     3333            self.networkCanvas.drawPlotItems() 
     3334                     
     3335        def sendReport(self): 
     3336            self.reportSettings("Graph data", 
     3337                                [("Number of vertices", self.graph.number_of_nodes()), 
     3338                                 ("Number of edges", self.graph.number_of_edges()), 
     3339                                 ("Vertices per edge", "%.3f" % self.verticesPerEdge), 
     3340                                 ("Edges per vertex", "%.3f" % self.edgesPerVertex), 
     3341                                 ("Diameter", self.diameter), 
     3342                                 ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient) 
     3343                                 ]) 
     3344            if self.color or self.vertexSize or self.markerAttributes or self.edgeColor: 
     3345                self.reportSettings("Visual settings", 
     3346                                    [self.color and ("Vertex color", self.colorCombo.currentText()), 
     3347                                     self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""), 
     3348                                     self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)), 
     3349                                     self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()), 
     3350                                    ]) 
     3351            self.reportSettings("Optimization", 
     3352                                [("Method", self.optCombo.currentText()), 
     3353                                 ("Iterations", self.frSteps)]) 
     3354            self.reportSection("Graph") 
     3355            self.reportImage(self.networkCanvas.saveToFileDirect)         
     3356             
    18493357         
    18503358if __name__=="__main__":     
     
    18693377    #ow1.saveSettings() 
    18703378     
    1871      
    1872      
Note: See TracChangeset for help on using the changeset viewer.