Ignore:
Timestamp:
02/02/12 10:43:26 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
f0e0a60889ac2ac84cbe485c9cb5f634e93ccb9d
Message:

Moved old NetExplorer class to seperate file.

File:
1 edited

Legend:

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

    r9622 r9624  
    44<icon>icons/Network.png</icon> 
    55<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact>  
    6 <priority>6421</priorbity> 
     6<priority>6420</priorbity> 
    77""" 
    88import math 
     
    1414import OWGUI 
    1515import OWColorPalette 
    16 import OWToolbars 
     16#import OWToolbars 
    1717import orngMDS 
    1818 
     
    15341534        raise err 
    15351535 
    1536  
    1537     dir = os.path.dirname(__file__) + "/../icons/" 
    1538     dlg_mark2sel = dir + "Dlg_Mark2Sel.png" 
    1539     dlg_sel2mark = dir + "Dlg_Sel2Mark.png" 
    1540     dlg_selIsmark = dir + "Dlg_SelisMark.png" 
    1541     dlg_selected = dir + "Dlg_HideSelection.png" 
    1542     dlg_unselected = dir + "Dlg_UnselectedNodes.png" 
    1543     dlg_showall = dir + "Dlg_clear.png" 
    1544  
    1545  
    1546     class OWNxExplorer(OWWidget): 
    1547         settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    1548         "maxLinkSize", "minVertexSize", "maxVertexSize", "renderAntialiased", 
    1549         "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn", 
    1550         "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    1551         "showWeights", "showIndexes", "showEdgeLabels", "colorSettings", 
    1552         "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
    1553         "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
    1554         "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism", "showTextMiningInfo", 
    1555         "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
    1556         "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"] 
    1557  
    1558         def __init__(self, parent=None, signalManager=None, name='Net Explorer (Qwt)', 
    1559                      NetworkCanvas=OWNxCanvas): 
    1560             OWWidget.__init__(self, parent, signalManager, name) 
    1561             #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])} 
    1562             self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default), 
    1563                            ("Nx View", Orange.network.NxView, self.set_network_view), 
    1564                            ("Items", Orange.data.Table, self.setItems), 
    1565                            ("Marked Items", Orange.data.Table, self.markItems), 
    1566                            ("Item Subset", Orange.data.Table, self.setExampleSubset), 
    1567                            ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix)] 
    1568  
    1569             self.outputs = [("Selected Network", Orange.network.Graph), 
    1570                             ("Distance Matrix", Orange.core.SymMatrix), 
    1571                             ("Selected Items", Orange.data.Table), 
    1572                             ("Other Items", Orange.data.Table), 
    1573                             ("Marked Items", Orange.data.Table), 
    1574                             ("Features", AttributeList)] 
    1575  
    1576             self.markerAttributes = [] 
    1577             self.tooltipAttributes = [] 
    1578             self.edgeLabelAttributes = [] 
    1579             self.attributes = [] 
    1580             self.edgeAttributes = [] 
    1581             self.autoSendSelection = False 
    1582             self.graphShowGrid = 1  # show gridlines in the graph 
    1583  
    1584             self.markNConnections = 2 
    1585             self.markNumber = 0 
    1586             self.markProportion = 0 
    1587             self.markSearchString = "" 
    1588             self.markDistance = 2 
    1589             self.frSteps = 1 
    1590             self.hubs = 0 
    1591             self.color = 0 
    1592             self.edgeColor = 0 
    1593             self.vertexSize = 0 
    1594             self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = self.diameter = self.clustering_coefficient = 0 
    1595             self.optimizeWhat = 1 
    1596             self.stopOptimization = 0 
    1597             self.maxLinkSize = 3 
    1598             self.maxVertexSize = 5 
    1599             self.minVertexSize = 5 
    1600             self.renderAntialiased = 1 
    1601             self.labelsOnMarkedOnly = 0 
    1602             self.invertSize = 0 
    1603             self.optMethod = 0 
    1604             self.lastVertexSizeColumn = '' 
    1605             self.lastColorColumn = '' 
    1606             self.lastNameComponentAttribute = '' 
    1607             self.lastLabelColumns = set() 
    1608             self.lastTooltipColumns = set() 
    1609             self.showWeights = 0 
    1610             self.showIndexes = 0 
    1611             self.showEdgeLabels = 0 
    1612             self.colorSettings = None 
    1613             self.selectedSchemaIndex = 0 
    1614             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)])]])] 
    1615             self.selectedEdgeSchemaIndex = 0 
    1616             self.items_matrix = None 
    1617             self.showDistances = 0 
    1618             self.showMissingValues = 0 
    1619             self.fontSize = 12 
    1620             self.mdsTorgerson = 0 
    1621             self.mdsAvgLinkage = 1 
    1622             self.mdsSteps = 10000 
    1623             self.mdsRefresh = 50 
    1624             self.mdsStressDelta = 0.0000001 
    1625             self.organism = 'goa_human' 
    1626             self.showTextMiningInfo = 0 
    1627             self.toolbarSelection = 0 
    1628             self.minComponentEdgeWidth = 10 
    1629             self.maxComponentEdgeWidth = 70 
    1630             self.mdsFromCurrentPos = 0 
    1631             self.tabIndex = 0 
    1632             self.number_of_nodes_label = -1 
    1633             self.number_of_edges_label = -1 
    1634  
    1635             self.checkSendMarkedNodes = True 
    1636             self.checkSendSelectedNodes = True 
    1637  
    1638             self.loadSettings() 
    1639  
    1640             self._network_view = None 
    1641             self.layout = Orange.network.GraphLayout() 
    1642             self.graph = None 
    1643             self.graph_base = None 
    1644             self.markInputItems = None 
    1645  
    1646             self.mainArea.layout().setContentsMargins(0, 4, 4, 4) 
    1647             self.controlArea.layout().setContentsMargins(4, 4, 0, 4) 
    1648  
    1649             self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer") 
    1650             self.networkCanvas.showMissingValues = self.showMissingValues 
    1651             self.mainArea.layout().addWidget(self.networkCanvas) 
    1652  
    1653             self.networkCanvas.maxLinkSize = self.maxLinkSize 
    1654             self.networkCanvas.minVertexSize = self.minVertexSize 
    1655             self.networkCanvas.maxVertexSize = self.maxVertexSize 
    1656  
    1657             self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal') 
    1658  
    1659             self.tabs = OWGUI.tabWidget(self.hcontroArea) 
    1660  
    1661             self.verticesTab = OWGUI.createTabPage(self.tabs, "Vertices") 
    1662             self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges") 
    1663             self.markTab = OWGUI.createTabPage(self.tabs, "Mark") 
    1664             self.infoTab = OWGUI.createTabPage(self.tabs, "Info") 
    1665             #self.editTab = OWGUI.createTabPage(self.tabs, "Edit") 
    1666  
    1667             self.tabs.setCurrentIndex(self.tabIndex) 
    1668             self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index)) 
    1669  
    1670             self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False) 
    1671  
    1672             self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method) 
    1673             self.optCombo.addItem("No optimization") 
    1674             self.optCombo.addItem("Random") 
    1675             self.optCombo.addItem("Fruchterman Reingold") 
    1676             self.optCombo.addItem("Fruchterman Reingold Weighted") 
    1677             self.optCombo.addItem("Fruchterman Reingold Radial") 
    1678             self.optCombo.addItem("Circular Crossing Reduction") 
    1679             self.optCombo.addItem("Circular Original") 
    1680             self.optCombo.addItem("Circular Random") 
    1681             self.optCombo.addItem("Pivot MDS") 
    1682             self.optCombo.setCurrentIndex(self.optMethod) 
    1683             self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ") 
    1684             self.stepsSpin.setEnabled(False) 
    1685  
    1686             self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1) 
    1687  
    1688             colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace=False) 
    1689             self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.setVertexColor) 
    1690             self.colorCombo.addItem("(same color)") 
    1691             OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip="Set vertex color palette", debuggingEnabled=0) 
    1692  
    1693             self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box="Vertex size attribute", callback=self.setVertexSize) 
    1694             self.vertexSizeCombo.addItem("(none)") 
    1695  
    1696             OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize) 
    1697             OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize) 
    1698             OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback=self.setVertexSize) 
    1699  
    1700             colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace=False) 
    1701             self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.setEdgeColor) 
    1702             self.edgeColorCombo.addItem("(same color)") 
    1703             OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip="Set edge color palette", debuggingEnabled=0) 
    1704  
    1705             self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace=False) 
    1706             OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback=self.setFontSize) 
    1707  
    1708             self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace=False) 
    1709             self.attListBox = OWGUI.listBox(self.attBox, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox) 
    1710             self.tooltipListBox = OWGUI.listBox(self.attBox, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox) 
    1711  
    1712             self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace=False) 
    1713             self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox) 
    1714             self.edgeLabelBox.setEnabled(False) 
    1715  
    1716             ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical") 
    1717             OWGUI.checkBox(ib, self, 'showWeights', 'Show weights', callback=(lambda: self._set_canvas_attr('showWeights', self.showWeights))) 
    1718             OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels))) 
    1719             OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback=self.setMaxLinkSize) 
    1720             self.showDistancesCheckBox = OWGUI.checkBox(ib, self, 'showDistances', 'Explore vertex distances', callback=(lambda: self._set_canvas_attr('showDistances', self.showDistances)), disabled=1) 
    1721  
    1722             ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical") 
    1723             OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes))) 
    1724             OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly))) 
    1725             OWGUI.checkBox(ib, self, 'renderAntialiased', 'Render antialiased', callback=(lambda: self._set_canvas_attr('renderAntialiased', self.renderAntialiased))) 
    1726             self.insideView = 0 
    1727             self.insideViewNeighbours = 2 
    1728             OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked="insideView", checkCallback=self.insideview, callback=self.insideviewneighbours) 
    1729             OWGUI.checkBox(ib, self, 'showMissingValues', 'Show missing values', callback=(lambda: self._set_canvas_attr('showMissingValues', self.showMissingValues))) 
    1730  
    1731             ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical") 
    1732             OWGUI.label(ib, self, "Vertices (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)") 
    1733             OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i") 
    1734  
    1735             ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback=self.setMarkMode) 
    1736             OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback=self.setMarkMode) 
    1737             OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback=self.setMarkMode) 
    1738             self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True) 
    1739             self.searchStringTimer = QTimer(self) 
    1740             self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode) 
    1741  
    1742             OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback=self.setMarkMode) 
    1743             OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback=self.setMarkMode) 
    1744             ib = OWGUI.indentedBox(ribg, orientation=0) 
    1745             self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h))) 
    1746             #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True) 
    1747             OWGUI.widgetLabel(ribg, "Mark  vertices with ...") 
    1748             OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback=self.setMarkMode) 
    1749             OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback=self.setMarkMode) 
    1750             self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h))) 
    1751             OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback=self.setMarkMode) 
    1752             OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback=self.setMarkMode) 
    1753             OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback=self.setMarkMode) 
    1754             ib = OWGUI.indentedBox(ribg) 
    1755             self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h))) 
    1756             OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)") 
    1757             self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback=self.setMarkMode) 
    1758             ib = OWGUI.indentedBox(ribg) 
    1759             self.markInput = 0 
    1760             self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h))) 
    1761             self.markInputRadioButton.setEnabled(False) 
    1762  
    1763             ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical") 
    1764             OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback=self.setSendMarkedNodes, disabled=0) 
    1765  
    1766             T = OWToolbars.NavigateSelectToolbar 
    1767             self.zoomSelectToolbar = T(self, self.hcontroArea, self.networkCanvas, self.autoSendSelection, 
    1768                                       buttons=(T.IconZoom, 
    1769                                                  T.IconZoomExtent, 
    1770                                                  T.IconZoomSelection, 
    1771                                                  T.IconPan, 
    1772                                                  ("", "", "", None, None, 0), 
    1773                                                  #("Move selection", "buttonMoveSelection", "activateMoveSelection", QIcon(OWToolbars.dlg_select), Qt.ArrowCursor, 1), 
    1774                                                  T.IconRectangle, 
    1775                                                  #T.IconPolygon,   
    1776                                                  T.IconSendSelection, 
    1777                                                  ("", "", "", None, None, 0, "select"), 
    1778                                                  ("Add marked to selection", "buttonM2S", "markedToSelection", QIcon(dlg_mark2sel), Qt.ArrowCursor, 0), 
    1779                                                  ("Add selection to marked", "buttonS2M", "selectionToMarked", QIcon(dlg_sel2mark), Qt.ArrowCursor, 0), 
    1780                                                  ("Remove selection", "buttonRMS", "removeSelection", QIcon(dlg_selIsmark), Qt.ArrowCursor, 0), 
    1781                                                  ("", "", "", None, None, 0, "select"), 
    1782                                                  ("Hide selected", "buttonSEL", "hideSelectedVertices", QIcon(dlg_selected), Qt.ArrowCursor, 0), 
    1783                                                  ("Hide unselected", "buttonUN", "hideUnSelectedVertices", QIcon(dlg_unselected), Qt.ArrowCursor, 0), 
    1784                                                  ("Show all nodes", "buttonSW", "showAllVertices", QIcon(dlg_showall), Qt.ArrowCursor, 0))) 
    1785  
    1786             OWGUI.rubber(self.zoomSelectToolbar) 
    1787  
    1788             ib = OWGUI.widgetBox(self.infoTab, "General") 
    1789             OWGUI.label(ib, self, "Number of vertices: %(number_of_nodes_label)i") 
    1790             OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i") 
    1791             OWGUI.label(ib, self, "Vertices per edge: %(verticesPerEdge).2f") 
    1792             OWGUI.label(ib, self, "Edges per vertex: %(edgesPerVertex).2f") 
    1793             OWGUI.label(ib, self, "Diameter: %(diameter)i") 
    1794             OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%") 
    1795  
    1796             ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal") 
    1797  
    1798             OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False) 
    1799             OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False) 
    1800             OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False) 
    1801  
    1802             #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering) 
    1803  
    1804             ib = OWGUI.widgetBox(self.infoTab, "Prototype") 
    1805  
    1806             #ib = OWGUI.widgetBox(ibProto, "Name components") 
    1807             OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal') 
    1808  
    1809             self.nameComponentAttribute = 0 
    1810             self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal") 
    1811             self.nameComponentCombo.addItem("Select attribute") 
    1812  
    1813             self.showComponentAttribute = 0 
    1814             self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal") 
    1815             self.showComponentCombo.addItem("Select attribute") 
    1816             OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info") 
    1817  
    1818             #ib = OWGUI.widgetBox(ibProto, "Distance Matrix") 
    1819             ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    1820             self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1) 
    1821             self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1) 
    1822             self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1) 
    1823             ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    1824             self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1) 
    1825             self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1) 
    1826             self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1) 
    1827             self.scalingRatio = 0 
    1828             OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ") 
    1829             OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ") 
    1830             OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ") 
    1831             OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ") 
    1832             ibs = OWGUI.widgetBox(ib, orientation="horizontal") 
    1833             OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation") 
    1834             OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage") 
    1835             OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions") 
    1836             self.mdsInfoA = OWGUI.widgetLabel(ib, "Avg. stress:") 
    1837             self.mdsInfoB = OWGUI.widgetLabel(ib, "Num. steps:") 
    1838             self.rotateSteps = 100 
    1839  
    1840             OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ") 
    1841             OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin))) 
    1842             OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin))) 
    1843  
    1844             self.attSelectionAttribute = 0 
    1845             self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList) 
    1846             self.comboAttSelection.addItem("Select attribute") 
    1847             self.autoSendAttributes = 0 
    1848             OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes) 
    1849  
    1850             self.icons = self.createAttributeIconDict() 
    1851             self.setMarkMode() 
    1852  
    1853             self.editAttribute = 0 
    1854             self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal") 
    1855             self.editCombo.addItem("Select attribute") 
    1856             self.editValue = '' 
    1857             OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal') 
    1858             OWGUI.button(self.infoTab, self, "Edit", callback=self.edit) 
    1859  
    1860             self.verticesTab.layout().addStretch(1) 
    1861             self.edgesTab.layout().addStretch(1) 
    1862             self.markTab.layout().addStretch(1) 
    1863             self.infoTab.layout().addStretch(1) 
    1864  
    1865             dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    1866             self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    1867             self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    1868  
    1869             dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    1870             self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    1871             self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    1872  
    1873             self.graph_layout_method() 
    1874             self.setFontSize() 
    1875             self.set_graph(None) 
    1876             self.setMinimumWidth(900) 
    1877  
    1878  
    1879  
    1880             #self.resize(1000, 600) 
    1881             #self.controlArea.setEnabled(False) 
    1882  
    1883         def setComponentEdgeWidth(self, changedMin=True): 
    1884             if self.networkCanvas is None: 
    1885                 return 
    1886  
    1887             canvas = self.networkCanvas 
    1888             if changedMin: 
    1889                 if self.maxComponentEdgeWidth < self.minComponentEdgeWidth: 
    1890                     self.maxComponentEdgeWidth = self.minComponentEdgeWidth 
    1891             else: 
    1892                 if self.minComponentEdgeWidth > self.maxComponentEdgeWidth: 
    1893                     self.minComponentEdgeWidth = self.maxComponentEdgeWidth 
    1894  
    1895             canvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    1896             canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    1897             self.networkCanvas.updateCanvas() 
    1898  
    1899         def setAutoSendAttributes(self): 
    1900             print 'TODO setAutoSendAttributes' 
    1901             #if self.autoSendAttributes: 
    1902             #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList 
    1903             #else: 
    1904             #    self.networkCanvas.callbackSelectVertex = None 
    1905  
    1906         def sendAttSelectionList(self): 
    1907             if not self.graph is None: 
    1908                 vars = [x.name for x in self.graph_base.links_vars()] 
    1909                 if not self.comboAttSelection.currentText() in vars: 
    1910                     return 
    1911                 att = str(self.comboAttSelection.currentText()) 
    1912                 vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    1913  
    1914                 if len(vertices) != 1: 
    1915                     return 
    1916  
    1917                 attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ') 
    1918             else: 
    1919                 attributes = None 
    1920             self.send("Features", attributes) 
    1921  
    1922         def edit(self): 
    1923             if self.graph is None: 
    1924                 return 
    1925  
    1926             vars = [x.name for x in self.graph_base.items_vars()] 
    1927             if not self.editCombo.currentText() in vars: 
    1928                 return 
    1929             att = str(self.editCombo.currentText()) 
    1930             vertices = self.networkCanvas.networkCurve.get_selected_vertices() 
    1931  
    1932             if len(vertices) == 0: 
    1933                 return 
    1934  
    1935             if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous: 
    1936                 for v in vertices: 
    1937                     self.graph_base.items()[v][att] = float(self.editValue) 
    1938             else: 
    1939                 for v in vertices: 
    1940                     self.graph_base.items()[v][att] = str(self.editValue) 
    1941  
    1942             self.setItems(self.graph_base.items()) 
    1943  
    1944         def drawForce(self): 
    1945             if self.btnForce.isChecked() and self.graph is not None: 
    1946                 self.networkCanvas.forceVectors = self.layout._computeForces() 
    1947             else: 
    1948                 self.networkCanvas.forceVectors = None 
    1949  
    1950             self.networkCanvas.updateCanvas() 
    1951  
    1952         def rotateProgress(self, curr, max): 
    1953             self.progressBarSet(int(curr * 100 / max)) 
    1954             qApp.processEvents() 
    1955  
    1956         def rotateComponentsMDS(self): 
    1957             print "rotate" 
    1958             if self.items_matrix is None: 
    1959                 self.information('Set distance matrix to input signal') 
    1960                 self.btnRotateMDS.setChecked(False) 
    1961                 return 
    1962  
    1963             if self.graph is None: 
    1964                 self.information('No network found') 
    1965                 self.btnRotateMDS.setChecked(False) 
    1966                 return 
    1967             if self.items_matrix.dim != self.graph.number_of_nodes(): 
    1968                 self.error('Distance matrix dimensionality must equal number of vertices') 
    1969                 self.btnRotateMDS.setChecked(False) 
    1970                 return 
    1971  
    1972             if not self.btnRotateMDS.isChecked(): 
    1973               self.layout.stopMDS = 1 
    1974               #self.btnMDS.setChecked(False) 
    1975               #self.btnMDS.setText("MDS on graph components") 
    1976               return 
    1977  
    1978             self.btnRotateMDS.setText("Stop") 
    1979             qApp.processEvents() 
    1980  
    1981             self.layout.items_matrix = self.items_matrix 
    1982             self.progressBarInit() 
    1983  
    1984             self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos) 
    1985  
    1986             self.btnRotateMDS.setChecked(False) 
    1987             self.btnRotateMDS.setText("Rotate graph components (MDS)") 
    1988             self.progressBarFinished() 
    1989  
    1990         def rotateComponents(self): 
    1991             if self.items_matrix is None: 
    1992                 self.information('Set distance matrix to input signal') 
    1993                 self.btnRotate.setChecked(False) 
    1994                 return 
    1995  
    1996             if self.graph is None: 
    1997                 self.information('No network found') 
    1998                 self.btnRotate.setChecked(False) 
    1999                 return 
    2000  
    2001             if self.items_matrix.dim != self.graph.number_of_nodes(): 
    2002                 self.error('Distance matrix dimensionality must equal number of vertices') 
    2003                 self.btnRotate.setChecked(False) 
    2004                 return 
    2005  
    2006             if not self.btnRotate.isChecked(): 
    2007               self.layout.stopRotate = 1 
    2008               return 
    2009  
    2010             self.btnRotate.setText("Stop") 
    2011             qApp.processEvents() 
    2012  
    2013             self.layout.items_matrix = self.items_matrix 
    2014             self.progressBarInit() 
    2015             self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas) 
    2016             self.btnRotate.setChecked(False) 
    2017             self.btnRotate.setText("Rotate graph components") 
    2018             self.progressBarFinished() 
    2019  
    2020         def mdsProgress(self, avgStress, stepCount): 
    2021             self.drawForce() 
    2022  
    2023             self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress) 
    2024             self.mdsInfoB.setText("Num. steps: %i" % stepCount) 
    2025             self.progressBarSet(int(stepCount * 100 / self.mdsSteps)) 
    2026             qApp.processEvents() 
    2027  
    2028         def mds_components(self, mdsType=Orange.network.MdsType.componentMDS): 
    2029             if mdsType == Orange.network.MdsType.componentMDS: 
    2030                 btn = self.btnMDS 
    2031             elif mdsType == Orange.network.MdsType.exactSimulation: 
    2032                 btn = self.btnESIM 
    2033             elif mdsType == Orange.network.MdsType.MDS: 
    2034                 btn = self.btnMDSv 
    2035  
    2036             btnCaption = btn.text() 
    2037  
    2038             if self.items_matrix is None: 
    2039                 self.information('Set distance matrix to input signal') 
    2040                 btn.setChecked(False) 
    2041                 return 
    2042  
    2043             if self.layout is None: 
    2044                 self.information('No network found') 
    2045                 btn.setChecked(False) 
    2046                 return 
    2047  
    2048             if self.items_matrix.dim != self.graph.number_of_nodes(): 
    2049                 self.error('Distance matrix dimensionality must equal number of vertices') 
    2050                 btn.setChecked(False) 
    2051                 return 
    2052  
    2053             if not btn.isChecked(): 
    2054                 self.layout.stopMDS = 1 
    2055                 btn.setChecked(False) 
    2056                 btn.setText(btnCaption) 
    2057                 return 
    2058  
    2059             btn.setText("Stop") 
    2060             qApp.processEvents() 
    2061  
    2062             self.layout.items_matrix = self.items_matrix 
    2063             self.progressBarInit() 
    2064  
    2065             if self.mdsAvgLinkage: 
    2066                 self.layout.mds_components_avg_linkage(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
    2067             else: 
    2068                 self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.networkCanvas.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, mdsType=mdsType, scalingRatio=self.scalingRatio, mdsFromCurrentPos=self.mdsFromCurrentPos) 
    2069  
    2070             btn.setChecked(False) 
    2071             btn.setText(btnCaption) 
    2072             self.progressBarFinished() 
    2073  
    2074         def set_items_distance_matrix(self, matrix): 
    2075             self.error('') 
    2076             self.information('') 
    2077             self.showDistancesCheckBox.setEnabled(0) 
    2078  
    2079             if matrix is None or self.graph is None: 
    2080                 self.items_matrix = None 
    2081                 self.layout.items_matrix = None 
    2082                 if self.networkCanvas: self.networkCanvas.items_matrix = None 
    2083                 return 
    2084  
    2085             if matrix.dim != self.graph.number_of_nodes(): 
    2086                 self.error('Distance matrix dimensionality must equal number of vertices') 
    2087                 self.items_matrix = None 
    2088                 self.layout.items_matrix = None 
    2089                 if self.networkCanvas: self.networkCanvas.items_matrix = None 
    2090                 return 
    2091  
    2092             self.items_matrix = matrix 
    2093             self.layout.items_matrix = matrix 
    2094             if self.networkCanvas: self.networkCanvas.items_matrix = matrix 
    2095             self.showDistancesCheckBox.setEnabled(1) 
    2096  
    2097             self.networkCanvas.updateCanvas() 
    2098  
    2099         def setSendMarkedNodes(self): 
    2100             if self.checkSendMarkedNodes: 
    2101                 self.networkCanvas.sendMarkedNodes = self.sendMarkedNodes 
    2102                 self.sendMarkedNodes(self.networkCanvas.getMarkedVertices()) 
    2103             else: 
    2104                 self.send("Marked Items", None) 
    2105                 self.networkCanvas.sendMarkedNodes = None 
    2106  
    2107         def sendMarkedNodes(self, markedNodes): 
    2108             if len(markedNodes) == 0: 
    2109                 self.send("Marked Items", None) 
    2110                 return 
    2111  
    2112             if self.graph is not None and self.graph_base.items() is not None: 
    2113                 items = self.graph_base.items().getitems(markedNodes) 
    2114                 self.send("Marked Items", items) 
    2115                 return 
    2116  
    2117             self.send("Marked Items", None) 
    2118  
    2119         def insideviewneighbours(self): 
    2120             if self.networkCanvas.insideview == 1: 
    2121                 self.networkCanvas.insideviewNeighbours = self.insideViewNeighbours 
    2122                 self.optButton.setChecked(True) 
    2123                 self.graph_layout_fr(False) 
    2124  
    2125         def insideview(self): 
    2126             print self.networkCanvas.getSelectedVertices() 
    2127             if len(self.networkCanvas.getSelectedVertices()) == 1: 
    2128                 if self.networkCanvas.insideview == 1: 
    2129                     print "insideview: 1" 
    2130                     self.networkCanvas.insideview = 0 
    2131                     self.networkCanvas.showAllVertices() 
    2132                     self.networkCanvas.updateCanvas() 
    2133                 else: 
    2134                     print "insideview: 0" 
    2135                     self.networkCanvas.insideview = 1 
    2136                     self.networkCanvas.insideviewNeighbors = self.insideViewNeighbours 
    2137                     self.optButton.setChecked(True) 
    2138                     self.graph_layout_fr(False) 
    2139  
    2140             else: 
    2141                 print "One node must be selected!" 
    2142  
    2143         def showComponents(self): 
    2144             if self.graph is None or self.graph_base.items() is None: 
    2145                 return 
    2146  
    2147             vars = [x.name for x in self.graph_base.items_vars()] 
    2148  
    2149             if not self.showComponentCombo.currentText() in vars: 
    2150                 self.networkCanvas.showComponentAttribute = None 
    2151                 self.lastNameComponentAttribute = '' 
    2152             else: 
    2153                 self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText() 
    2154  
    2155             self.networkCanvas.drawPlotItems() 
    2156  
    2157         def nameComponents(self): 
    2158             """Names connected components of genes according to GO terms.""" 
    2159             self.progressBarFinished() 
    2160             self.lastNameComponentAttribute = None 
    2161  
    2162             if self.graph is None or self.graph_base.items() is None: 
    2163                 return 
    2164  
    2165             vars = [x.name for x in self.graph_base.items_vars()] 
    2166             if not self.nameComponentCombo.currentText() in vars: 
    2167                 return 
    2168  
    2169             self.progressBarInit() 
    2170             components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1] 
    2171             if 'component name' in self.graph_base.items().domain: 
    2172                 keyword_table = self.graph_base.items() 
    2173             else: 
    2174                 keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
    2175  
    2176             import obiGO 
    2177             ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet) 
    2178             annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet) 
    2179  
    2180             allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()]) 
    2181             foundGenesets = False 
    2182             if len(annotations.geneNames & allGenes) < 1: 
    2183                 allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()])) 
    2184                 if len(annotations.geneNames & allGenes) < 1: 
    2185                     self.warning('no genes found') 
    2186                     return 
    2187                 else: 
    2188                     foundGenesets = True 
    2189  
    2190             def rank(a, j, reverse=False): 
    2191                 if len(a) <= 0: return 
    2192  
    2193                 if reverse: 
    2194                     a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0) 
    2195                     top_value = a[0][j] 
    2196                     top_rank = len(a) 
    2197                     max_rank = float(len(a)) 
    2198                     int_ndx = 0 
    2199                     for k in range(len(a)): 
    2200                         if top_value < a[k][j]: 
    2201                             top_value = a[k][j] 
    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                             int_ndx = k 
    2208  
    2209                         a[k][j] = top_rank / max_rank 
    2210                         top_rank -= 1 
    2211  
    2212                     k += 1 
    2213                     if k - int_ndx > 1: 
    2214                         avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    2215                         for l in range(int_ndx, k): 
    2216                             a[l][j] = avg_rank 
    2217  
    2218                 else: 
    2219                     a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0) 
    2220                     top_value = a[0][j] 
    2221                     top_rank = len(a) 
    2222                     max_rank = float(len(a)) 
    2223                     int_ndx = 0 
    2224                     for k in range(len(a)): 
    2225                         if top_value > a[k][j]: 
    2226                             top_value = a[k][j] 
    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                             int_ndx = k 
    2233  
    2234                         a[k][j] = top_rank / max_rank 
    2235                         top_rank -= 1 
    2236  
    2237                     k += 1 
    2238                     if k - int_ndx > 1: 
    2239                         avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2 
    2240                         for l in range(int_ndx, k): 
    2241                             a[l][j] = avg_rank 
    2242  
    2243             for i in range(len(components)): 
    2244                 component = components[i] 
    2245                 if len(component) <= 1: 
    2246                     continue 
    2247  
    2248                 if foundGenesets: 
    2249                     genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component]) 
    2250                 else: 
    2251                     genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component] 
    2252  
    2253                 res1 = annotations.GetEnrichedTerms(genes, aspect="P") 
    2254                 res2 = annotations.GetEnrichedTerms(genes, aspect="F") 
    2255                 res = res1_base.items() + res2.items() 
    2256                 #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] 
    2257                 #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] 
    2258  
    2259                 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] 
    2260                 if len(namingScore) == 0: 
    2261                     continue 
    2262  
    2263                 annotated_genes = max([a[0] for a in namingScore]) 
    2264  
    2265                 rank(namingScore, 1, reverse=True) 
    2266                 rank(namingScore, 2, reverse=True) 
    2267                 rank(namingScore, 0) 
    2268  
    2269                 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] 
    2270                 namingScore.sort(reverse=True) 
    2271  
    2272                 if len(namingScore) < 1: 
    2273                     print "warning. no annotations found for group of genes: " + ", ".join(genes) 
    2274                     continue 
    2275                 elif len(namingScore[0]) < 2: 
    2276                     print "warning. error computing score for group of genes: " + ", ".join(genes) 
    2277                     continue 
    2278  
    2279                 for v in component: 
    2280                     name = str(namingScore[0][1]) 
    2281                     attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4]) 
    2282                     info = '' 
    2283                     if self.showTextMiningInfo: 
    2284                         info = "\n" + attrs + "\n" + str(namingScore[0][0]) 
    2285                     keyword_table[v]['component name'] = name + info 
    2286  
    2287                 self.progressBarSet(i * 100.0 / len(components)) 
    2288  
    2289             self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    2290             self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table])) 
    2291             self.progressBarFinished() 
    2292  
    2293         def nameComponents_old(self): 
    2294             if self.graph is None or self.graph_base.items() is None: 
    2295                 return 
    2296  
    2297             vars = [x.name for x in self.graph_base.items_vars()] 
    2298  
    2299             if not self.nameComponentCombo.currentText() in vars: 
    2300                 return 
    2301  
    2302             components = Orange.network.nx.algorithms.components.connected_components(self.graph) 
    2303             keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
    2304  
    2305             excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"] 
    2306             excludePart = ["HSA"] 
    2307             keywords = set() 
    2308             sameKeywords = set() 
    2309  
    2310             for component in components: 
    2311                 words = [] 
    2312                 all_values = [] 
    2313                 for vertex in component: 
    2314                     values = [] 
    2315                     value = str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    2316  
    2317                     value = value.replace(" ", ",") 
    2318                     value_top = value.split(",") 
    2319  
    2320                     for value in value_top: 
    2321                         if len(value) > 0: 
    2322                             tmp = value.split("_") 
    2323                             tmp = [value.strip() for value in tmp if len(value) > 0] 
    2324                             all_values.append(tmp) 
    2325                             values.extend(tmp) 
    2326  
    2327                     values = [value.strip() for value in values if len(value) > 0] 
    2328                     words.extend(values) 
    2329  
    2330  
    2331                     #value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    2332                     #value = value.replace(" ", "_") 
    2333                     #value = value.replace(",", "_") 
    2334                     #values = value.split("_") 
    2335                     #values = [value.strip() for value in values if len(value) > 0] 
    2336                     #print "values:", values 
    2337                     #all_values.append(values) 
    2338  
    2339                     #words.extend(values) 
    2340                 #print "all_values:", all_values 
    2341                 toExclude = [] 
    2342  
    2343                 words = [word for word in words if not word.upper() in excludeWord] 
    2344                 toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
    2345  
    2346                 for word in toExclude: 
    2347                     try: 
    2348                         while True: 
    2349                             words.remove(word) 
    2350                     except: 
    2351                         pass 
    2352  
    2353                 counted_words = {} 
    2354                 for word in words: 
    2355                     if word in counted_words: 
    2356                         count = counted_words[word] 
    2357                         counted_words[word] = count + 1 
    2358                     else: 
    2359                         counted_words[word] = 1 
    2360  
    2361                 words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
    2362                 keyword = "" 
    2363                 keyword_words = [] 
    2364                 max_count = 0 
    2365                 i = 0 
    2366  
    2367                 while i < len(words) and words[i][1] >= max_count: 
    2368                     max_count = words[i][1] 
    2369                     keyword += words[i][0] + " " 
    2370                     keyword_words.append(words[i][0]) 
    2371                     i += 1 
    2372  
    2373                 if len(keyword_words) > 1: 
    2374                     new_all_values = [] 
    2375                     for values in all_values: 
    2376                         new_values = [value for value in values if value in keyword_words] 
    2377                         new_all_values.append(new_values) 
    2378  
    2379                     #print new_all_values 
    2380                     word_position = [] 
    2381  
    2382                     for word in keyword_words: 
    2383                         sum = 0 
    2384                         for v in new_all_values: 
    2385                             if word in v: 
    2386                                 sum += v.index(word) 
    2387  
    2388                         word_position.append((word, sum)) 
    2389  
    2390                     words = sorted(word_position, key=itemgetter(1)) 
    2391                     #print "words:", words 
    2392                     #print all_values 
    2393                     #print new_all_values 
    2394  
    2395                     keyword = "" 
    2396                     for word in words: 
    2397                         keyword += word[0] + " " 
    2398  
    2399                 keyword = keyword.strip() 
    2400  
    2401                 for vertex in component: 
    2402                     keyword_table[vertex]['component name'] = keyword 
    2403  
    2404                 if keyword in keywords: 
    2405                     sameKeywords.add(keyword) 
    2406                 else: 
    2407                     keywords.add(keyword) 
    2408             #print "sameKeywords:", sameKeywords        
    2409             sameComponents = [component for component in components if str(keyword_table[component[0]]['component name']) in sameKeywords] 
    2410             #print "same components:", sameComponents 
    2411  
    2412             for component in sameComponents: 
    2413                 words = [] 
    2414                 all_values = [] 
    2415                 for vertex in component: 
    2416                     values = [] 
    2417                     value = str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())]) 
    2418  
    2419                     value = value.replace(" ", ",") 
    2420                     value_top = value.split(",") 
    2421  
    2422                     for value in value_top: 
    2423                         if len(value) > 0: 
    2424                             tmp = value.split("_") 
    2425                             tmp = [value.strip() for value in tmp if len(value) > 0] 
    2426                             all_values.append(tmp) 
    2427                             values.extend(tmp) 
    2428  
    2429                     values = [value.strip() for value in values if len(value) > 0] 
    2430                     words.extend(values) 
    2431  
    2432                 toExclude = [] 
    2433  
    2434                 words = [word for word in words if not word.upper() in excludeWord] 
    2435                 toExclude = [word for word in words for part in excludePart if word.find(part) != -1] 
    2436  
    2437                 for word in toExclude: 
    2438                     try: 
    2439                         while True: 
    2440                             words.remove(word) 
    2441                     except: 
    2442                         pass 
    2443  
    2444                 counted_words = {} 
    2445                 for word in words: 
    2446                     if word in counted_words: 
    2447                         count = counted_words[word] 
    2448                         counted_words[word] = count + 1 
    2449                     else: 
    2450                         counted_words[word] = 1 
    2451  
    2452                 words = sorted(counted_words.items(), key=itemgetter(1), reverse=True) 
    2453                 keyword = "" 
    2454                 counts = [int(word[1]) for word in words] 
    2455                 max_count = max(counts) 
    2456  
    2457                 try: 
    2458                     while True and len(counts) > 1: 
    2459                         counts.remove(max_count) 
    2460                 except: 
    2461                     pass 
    2462                 max_count = max(counts) 
    2463                 i = 0 
    2464                 keyword_words = [] 
    2465                 while i < len(words) and words[i][1] >= max_count: 
    2466                     keyword += words[i][0] + " " 
    2467                     keyword_words.append(words[i][0]) 
    2468                     i += 1 
    2469  
    2470                 if len(keyword_words) > 1: 
    2471                     new_all_values = [] 
    2472                     for values in all_values: 
    2473                         new_values = [value for value in values if value in keyword_words] 
    2474                         new_all_values.append(new_values) 
    2475  
    2476                     #print new_all_values 
    2477                     word_position = [] 
    2478  
    2479                     for word in keyword_words: 
    2480                         sum = 0 
    2481                         for v in new_all_values: 
    2482                             if word in v: 
    2483                                 sum += v.index(word) 
    2484  
    2485                         word_position.append((word, sum)) 
    2486  
    2487                     words = sorted(word_position, key=itemgetter(1)) 
    2488                     #print "words:", words 
    2489                     #print all_values 
    2490                     #print new_all_values 
    2491  
    2492                     keyword = "" 
    2493                     for word in words: 
    2494                         keyword += word[0] + " " 
    2495  
    2496                 keyword = keyword.strip() 
    2497                 for vertex in component: 
    2498                     keyword_table[vertex]['component name'] = keyword 
    2499  
    2500             self.lastNameComponentAttribute = self.nameComponentCombo.currentText() 
    2501             #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute 
    2502             items = Orange.data.Table([self.graph_base.items(), keyword_table]) 
    2503             self.setItems(items) 
    2504  
    2505             #for item in items: 
    2506             #    print item 
    2507  
    2508         def _set_canvas_attr(self, attr, value): 
    2509             setattr(self.networkCanvas, attr, value) 
    2510             self.networkCanvas.updateCanvas() 
    2511  
    2512         def setSearchStringTimer(self): 
    2513             self.hubs = 1 
    2514             self.searchStringTimer.stop() 
    2515             self.searchStringTimer.start(1000) 
    2516  
    2517         def setMarkMode(self, i=None): 
    2518             self.searchStringTimer.stop() 
    2519             if not i is None: 
    2520                 self.hubs = i 
    2521  
    2522             #print self.hubs 
    2523             self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0 
    2524             self.networkCanvas.markWithRed = False 
    2525  
    2526             if self.graph is None: 
    2527                 return 
    2528  
    2529             hubs = self.hubs 
    2530             if hubs == 0: 
    2531                 self.networkCanvas.setMarkedVertices([]) 
    2532                 self.networkCanvas.replot() 
    2533                 return 
    2534  
    2535             elif hubs == 1: 
    2536                 #print "mark on given label" 
    2537                 txt = self.markSearchString 
    2538                 labelText = self.networkCanvas.labelText 
    2539                 self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200 
    2540  
    2541                 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()])] 
    2542                 self.networkCanvas.setMarkedVertices(toMark) 
    2543                 self.networkCanvas.replot() 
    2544                 return 
    2545  
    2546             elif hubs == 2: 
    2547                 #print "mark on focus" 
    2548                 self.networkCanvas.unmark() 
    2549                 self.networkCanvas.tooltipNeighbours = self.markDistance 
    2550                 return 
    2551  
    2552             elif hubs == 3: 
    2553                 #print "mark selected" 
    2554                 self.networkCanvas.unmark() 
    2555                 self.networkCanvas.selectionNeighbours = self.markDistance 
    2556                 self.networkCanvas.markSelectionNeighbours() 
    2557                 return 
    2558  
    2559             self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0 
    2560             powers = self.graph.degree() 
    2561             powers = [powers[key] for key in sorted(powers.keys())] 
    2562  
    2563             if hubs == 4: # at least N connections 
    2564                 #print "mark at least N connections" 
    2565                 N = self.markNConnections 
    2566                 self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power >= N]) 
    2567                 self.networkCanvas.replot() 
    2568             elif hubs == 5: 
    2569                 #print "mark at most N connections" 
    2570                 N = self.markNConnections 
    2571                 self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power <= N]) 
    2572                 self.networkCanvas.replot() 
    2573             elif hubs == 6: 
    2574                 #print "mark more than any" 
    2575                 self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0] + [powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    2576                 self.networkCanvas.replot() 
    2577             elif hubs == 7: 
    2578                 #print "mark more than avg" 
    2579                 self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0] + [powers[nn] for nn in self.graph.getNeighbours(i)])]) 
    2580                 self.networkCanvas.replot() 
    2581             elif hubs == 8: 
    2582                 #print "mark most" 
    2583                 sortedIdx = range(len(powers)) 
    2584                 sortedIdx.sort(lambda x, y:-cmp(powers[x], powers[y])) 
    2585                 cutP = self.markNumber - 1 
    2586                 cutPower = powers[sortedIdx[cutP]] 
    2587                 while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower: 
    2588                     cutP += 1 
    2589                 self.networkCanvas.setMarkedVertices(sortedIdx[:cutP]) 
    2590                 self.networkCanvas.replot() 
    2591             elif hubs == 9: 
    2592                 self.setMarkInput() 
    2593  
    2594         def testRefresh(self): 
    2595             start = time.time() 
    2596             self.networkCanvas.replot() 
    2597             stop = time.time() 
    2598             print "replot in " + str(stop - start) 
    2599  
    2600         def save_network(self): 
    2601             if self.networkCanvas is None or self.graph is None: 
    2602                 return 
    2603  
    2604             filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)') 
    2605             if filename: 
    2606                 fn = "" 
    2607                 head, tail = os.path.splitext(str(filename)) 
    2608                 if not tail: 
    2609                     fn = head + ".net" 
    2610                 else: 
    2611                     fn = str(filename) 
    2612  
    2613                 for i in range(self.graph.number_of_nodes()): 
    2614                     node = self.graph.node[i] 
    2615                     node['x'] = self.layout.coors[0][i] 
    2616                     node['y'] = self.layout.coors[1][i] 
    2617  
    2618                 Orange.network.readwrite.write(self.graph, fn) 
    2619  
    2620         def sendData(self): 
    2621             if len(self.signalManager.getLinks(self, None, \ 
    2622                     "Selected Items", None)) > 0 or \ 
    2623                         len(self.signalManager.getLinks(self, None, \ 
    2624                                                 "Unselected Items", None)) > 0: 
    2625                 # signal connected 
    2626                 graph = self.networkCanvas.getSelectedGraph() 
    2627                 vertices = self.networkCanvas.getSelectedVertices() 
    2628  
    2629                 if graph is not None: 
    2630                     if graph.items() is not None: 
    2631                         self.send("Selected Items", graph.items()) 
    2632                     else: 
    2633                         nodes = self.networkCanvas.getSelectedExamples() 
    2634  
    2635                         if len(nodes) > 0 and self.graph_base.items() is not None: 
    2636                             self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
    2637                         else: 
    2638                             self.send("Selected Items", None) 
    2639  
    2640                     nodes = self.networkCanvas.getUnselectedExamples() 
    2641                     if len(nodes) > 0 and self.graph_base.items() is not None: 
    2642                         self.send("Other Items", self.graph_base.items().getitems(nodes)) 
    2643                     else: 
    2644                         self.send("Other Items", None) 
    2645  
    2646                     self.send("Selected Network", graph) 
    2647                 else: 
    2648                     nodes = self.networkCanvas.getSelectedExamples() 
    2649                     if len(nodes) > 0 and self.graph_base.items() is not None: 
    2650                         self.send("Selected Items", self.graph_base.items().getitems(nodes)) 
    2651                     else: 
    2652                         self.send("Selected Items", None) 
    2653  
    2654                     nodes = self.networkCanvas.getUnselectedExamples() 
    2655                     if len(nodes) > 0 and self.graph_base.items() is not None: 
    2656                         self.send("Other Items", self.graph_base.items().getitems(nodes)) 
    2657                     else: 
    2658                         self.send("Other Items", None) 
    2659  
    2660             if len(self.signalManager.getLinks(self, None, \ 
    2661                                 "Selected Items Distance Matrix", None)) > 0: 
    2662                 # signal connected 
    2663                 matrix = None 
    2664                 if self.items_matrix is not None: 
    2665                     matrix = self.items_matrix.getitems(vertices) 
    2666  
    2667                 self.send("Distance Matrix", matrix) 
    2668  
    2669         def setCombos(self): 
    2670             vars = self.graph_base.items_vars() 
    2671             edgeVars = self.graph_base.links_vars() 
    2672             lastLabelColumns = self.lastLabelColumns 
    2673             lastTooltipColumns = self.lastTooltipColumns 
    2674  
    2675             self.clearCombos() 
    2676  
    2677             self.attributes = [(var.name, var.varType) for var in vars] 
    2678             self.edgeAttributes = [(var.name, var.varType) for var in edgeVars] 
    2679  
    2680             for var in vars: 
    2681                 if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    2682                     self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2683  
    2684                 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: 
    2685  
    2686                     value = self.graph_base.items()[0][var].value 
    2687  
    2688                     # can value be a list? 
    2689                     try: 
    2690                         if type(eval(value)) == type([]): 
    2691                             self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2692                             continue 
    2693                     except: 
    2694                         pass 
    2695  
    2696                     if len(value.split(',')) > 1: 
    2697                         self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name)) 
    2698  
    2699                 elif var.varType in [Orange.data.Type.Continuous]: 
    2700                     self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2701  
    2702                 self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2703                 self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2704                 self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2705                 self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2706  
    2707             for var in edgeVars: 
    2708                 if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]: 
    2709                     self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name)) 
    2710  
    2711             for i in range(self.vertexSizeCombo.count()): 
    2712                 if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i): 
    2713                     self.vertexSize = i 
    2714                     break 
    2715  
    2716             for i in range(self.colorCombo.count()): 
    2717                 if self.lastColorColumn == self.colorCombo.itemText(i): 
    2718                     self.color = i 
    2719                     break 
    2720  
    2721             for i in range(self.attListBox.count()): 
    2722                 if str(self.attListBox.item(i).text()) in lastLabelColumns: 
    2723                     self.attListBox.item(i).setSelected(1) 
    2724  
    2725             for i in range(self.tooltipListBox.count()): 
    2726                 if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns: 
    2727                     self.tooltipListBox.item(i).setSelected(1) 
    2728  
    2729             self.lastLabelColumns = lastLabelColumns 
    2730             self.lastTooltipColumns = lastTooltipColumns 
    2731  
    2732         def clearCombos(self): 
    2733             self.attributes = [] 
    2734             self.edgeAttributes = [] 
    2735  
    2736             self.colorCombo.clear() 
    2737             self.vertexSizeCombo.clear() 
    2738             self.nameComponentCombo.clear() 
    2739             self.showComponentCombo.clear() 
    2740             self.edgeColorCombo.clear() 
    2741             self.editCombo.clear() 
    2742             self.comboAttSelection.clear() 
    2743  
    2744             self.colorCombo.addItem("(same color)") 
    2745             self.edgeColorCombo.addItem("(same color)") 
    2746             self.vertexSizeCombo.addItem("(same size)") 
    2747             self.nameComponentCombo.addItem("Select attribute") 
    2748             self.showComponentCombo.addItem("Select attribute") 
    2749             self.editCombo.addItem("Select attribute") 
    2750             self.comboAttSelection.addItem("Select attribute") 
    2751  
    2752         def change_graph(self, newgraph): 
    2753             old_nodes = set(self.graph.nodes_iter()) 
    2754             new_nodes = set(newgraph.nodes_iter()) 
    2755             inter_nodes = old_nodes.intersection(new_nodes) 
    2756             remove_nodes = old_nodes.difference(inter_nodes) 
    2757             add_nodes = new_nodes.difference(inter_nodes) 
    2758  
    2759             [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes] 
    2760             self.networkCanvas.networkCurve.coors.update((node, (0, 0)) for node in add_nodes) 
    2761             positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())] 
    2762             self.layout.set_graph(newgraph, positions) 
    2763  
    2764             self.graph = newgraph 
    2765             self.number_of_nodes_label = self.graph.number_of_nodes() 
    2766             self.number_of_edges_label = self.graph.number_of_edges() 
    2767  
    2768             self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes) 
    2769  
    2770     #        self.nShown = self.graph.number_of_nodes() 
    2771     #         
    2772     #        if self.graph.number_of_edges() > 0: 
    2773     #            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    2774     #        else: 
    2775     #            self.verticesPerEdge = 0 
    2776     #             
    2777     #        if self.graph.number_of_nodes() > 0: 
    2778     #            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    2779     #        else: 
    2780     #            self.edgesPerVertex = 0 
    2781     #         
    2782     #        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    2783     #        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    2784     #        if len(components) > 1: 
    2785     #            self.diameter = -1 
    2786     #        else: 
    2787     #            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    2788     #        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    2789  
    2790             k = 1.13850193174e-008 
    2791             nodes = self.graph.number_of_nodes() 
    2792             t = k * nodes * nodes 
    2793             self.frSteps = int(5.0 / t) 
    2794             if self.frSteps < 1: self.frSteps = 1; 
    2795             if self.frSteps > 3000: self.frSteps = 3000; 
    2796  
    2797             if self.frSteps < 10: 
    2798                 self.renderAntialiased = 0 
    2799                 self.minVertexSize = 5 
    2800                 self.maxVertexSize = 5 
    2801                 self.maxLinkSize = 1 
    2802                 self.optMethod = 0 
    2803                 self.graph_layout_method() 
    2804  
    2805             #self.setVertexColor() 
    2806             #self.setEdgeColor() 
    2807             #self.networkCanvas.setEdgesSize() 
    2808  
    2809             #self.clickedAttLstBox() 
    2810             #self.clickedTooltipLstBox() 
    2811             #self.clickedEdgeLabelListBox() 
    2812  
    2813             self.optButton.setChecked(1) 
    2814             self.graph_layout() 
    2815             self.information(0) 
    2816  
    2817         def set_graph(self, graph): 
    2818             self.set_items_distance_matrix(None) 
    2819  
    2820             if graph is None: 
    2821                 self.graph = None 
    2822                 self.graph_base = None 
    2823                 self.layout.set_graph(None) 
    2824                 self.networkCanvas.set_graph_layout(None, None) 
    2825                 self.clearCombos() 
    2826                 self.number_of_nodes_label = -1 
    2827                 self.number_of_edges_label = -1 
    2828                 self._items = None 
    2829                 self._links = None 
    2830                 return 
    2831  
    2832             self.graph_base = graph 
    2833  
    2834             if self._network_view is not None: 
    2835                 graph = self._network_view.init_network(graph) 
    2836  
    2837  
    2838             #print "OWNetwork/setGraph: new visualizer..." 
    2839             self.graph = graph 
    2840  
    2841             if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain: 
    2842                 positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \ 
    2843                              for node in sorted(self.graph) if self._items[node]['x'].value != '?' \ 
    2844                              and self._items[node]['y'].value != '?'] 
    2845                 self.layout.set_graph(self.graph, positions) 
    2846             else: 
    2847                 self.layout.set_graph(self.graph) 
    2848  
    2849             self.number_of_nodes_label = self.graph.number_of_nodes() 
    2850             self.number_of_edges_label = self.graph.number_of_edges() 
    2851  
    2852             self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links()) 
    2853             self.networkCanvas.renderAntialiased = self.renderAntialiased 
    2854             self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    2855             self.networkCanvas.minVertexSize = self.minVertexSize 
    2856             self.networkCanvas.maxVertexSize = self.maxVertexSize 
    2857             self.networkCanvas.maxEdgeSize = self.maxLinkSize 
    2858             self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth 
    2859             self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth 
    2860             self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    2861             self.lastColorColumn = self.colorCombo.currentText() 
    2862  
    2863             self.nShown = self.graph.number_of_nodes() 
    2864  
    2865             if self.graph.number_of_edges() > 0: 
    2866                 self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges()) 
    2867             else: 
    2868                 self.verticesPerEdge = 0 
    2869  
    2870             if self.graph.number_of_nodes() > 0: 
    2871                 self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes()) 
    2872             else: 
    2873                 self.edgesPerVertex = 0 
    2874  
    2875             undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph 
    2876             components = Orange.network.nx.algorithms.components.connected_components(undirected_graph) 
    2877             if len(components) > 1: 
    2878                 self.diameter = -1 
    2879             else: 
    2880                 self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph) 
    2881  
    2882             if self.graph.is_multigraph(): 
    2883                 self.clustering_coefficient = -1 
    2884             else: 
    2885                 self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100 
    2886  
    2887             self.setCombos() 
    2888  
    2889             lastNameComponentAttributeFound = False 
    2890             for i in range(self.nameComponentCombo.count()): 
    2891                 if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i): 
    2892                     lastNameComponentAttributeFound = True 
    2893                     self.nameComponentAttribute = i 
    2894                     self.nameComponents() 
    2895                     self.showComponentAttribute = self.showComponentCombo.count() - 1 
    2896                     self.showComponents() 
    2897                     break 
    2898  
    2899             if not lastNameComponentAttributeFound: 
    2900                 self.lastNameComponentAttribute = '' 
    2901  
    2902             self.showComponentAttribute = None 
    2903  
    2904             k = 1.13850193174e-008 
    2905             nodes = self.graph.number_of_nodes() 
    2906             t = k * nodes * nodes 
    2907             self.frSteps = int(5.0 / t) 
    2908             if self.frSteps < 1: self.frSteps = 1; 
    2909             if self.frSteps > 3000: self.frSteps = 3000; 
    2910  
    2911             self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly 
    2912             self.networkCanvas.showWeights = self.showWeights 
    2913             self.networkCanvas.showIndexes = self.showIndexes 
    2914             # if graph is large, set random layout, min vertex size, min edge size 
    2915             if self.frSteps < 10: 
    2916                 self.renderAntialiased = 0 
    2917                 self.minVertexSize = 5 
    2918                 self.maxVertexSize = 5 
    2919                 self.maxLinkSize = 1 
    2920                 self.optMethod = 0 
    2921                 self.graph_layout_method() 
    2922  
    2923             if self.vertexSize > 0: 
    2924                 self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize) 
    2925             else: 
    2926                 self.networkCanvas.setVerticesSize() 
    2927  
    2928             self.setVertexColor() 
    2929             self.setEdgeColor() 
    2930  
    2931             self.networkCanvas.setEdgesSize() 
    2932             self.clickedAttLstBox() 
    2933             self.clickedTooltipLstBox() 
    2934             self.clickedEdgeLabelListBox() 
    2935  
    2936             self.optButton.setChecked(1) 
    2937             self.graph_layout() 
    2938             self.information(0) 
    2939             #self.networkCanvas.updateCanvas() 
    2940  
    2941         def set_network_view(self, nxView): 
    2942             self._network_view = nxView 
    2943             self._network_view.set_nx_explorer(self) 
    2944             self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected 
    2945             self.set_graph(self.graph_base) 
    2946  
    2947         def setItems(self, items=None): 
    2948             self.error('') 
    2949  
    2950             if self.graph is None or items is None: 
    2951                 return 
    2952  
    2953             if len(items) != self.graph_base.number_of_nodes(): 
    2954                 self.error('ExampleTable items must have one example for each vertex.') 
    2955                 return 
    2956  
    2957             self.graph_base.set_items(items) 
    2958  
    2959             self.setVertexSize() 
    2960             self.networkCanvas.showIndexes = self.showIndexes 
    2961             self.networkCanvas.showWeights = self.showWeights 
    2962             self.networkCanvas.showEdgeLabels = self.showEdgeLabels 
    2963             self.setCombos() 
    2964             self.networkCanvas.updateData() 
    2965  
    2966         def setMarkInput(self): 
    2967             var = str(self.markInputCombo.currentText()) 
    2968             #print 'combo:',self.markInputCombo.currentText() 
    2969             if self.markInputItems is not None and len(self.markInputItems) > 0: 
    2970                 values = [str(x[var]).strip().upper() for x in self.markInputItems] 
    2971                 toMark = [i for (i, x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values] 
    2972                 #print "mark:", toMark 
    2973                 self.networkCanvas.setMarkedVertices(list(toMark)) 
    2974                 self.networkCanvas.replot() 
    2975  
    2976             else: 
    2977                 self.networkCanvas.setMarkedVertices([]) 
    2978                 self.networkCanvas.replot() 
    2979  
    2980         def markItems(self, items): 
    2981             self.markInputCombo.clear() 
    2982             self.markInputRadioButton.setEnabled(False) 
    2983             self.markInputItems = items 
    2984  
    2985             if self.graph is None or self.graph_base.items() is None or items is None: 
    2986                 return 
    2987  
    2988             if len(items) > 0: 
    2989                 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()] 
    2990                 lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()] 
    2991                 commonVars = set(lstNewDomain) & set(lstOrgDomain) 
    2992  
    2993                 if len(commonVars) > 0: 
    2994                     for var in commonVars: 
    2995                         orgVar = self.graph_base.items().domain[var] 
    2996                         mrkVar = items.domain[var] 
    2997  
    2998                         if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String: 
    2999                             self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name)) 
    3000                             self.markInputRadioButton.setEnabled(True) 
    3001  
    3002                             self.setMarkMode(9) 
    3003  
    3004         def setExampleSubset(self, subset): 
    3005             if self.networkCanvas is None: 
    3006                 return 
    3007  
    3008             self.warning('') 
    3009             hiddenNodes = [] 
    3010  
    3011             if subset is not None: 
    3012                 try: 
    3013                     expected = 1 
    3014                     for row in subset: 
    3015                         index = int(row['index'].value) 
    3016                         if expected != index: 
    3017                             hiddenNodes += range(expected - 1, index - 1) 
    3018                             expected = index + 1 
    3019                         else: 
    3020                             expected += 1 
    3021  
    3022                     hiddenNodes += range(expected - 1, self.graph.number_of_nodes()) 
    3023  
    3024                     self.networkCanvas.setHiddenNodes(hiddenNodes) 
    3025                 except: 
    3026                     self.warning('"index" attribute does not exist in "items" table.') 
    3027  
    3028         def showDegreeDistribution(self): 
    3029             if self.graph is None: 
    3030                 return 
    3031  
    3032             from matplotlib import rcParams 
    3033             import pylab as p 
    3034  
    3035             x = self.graph.degree().values() 
    3036             nbins = len(set(x)) 
    3037             if nbins > 500: 
    3038               bbins = 500 
    3039  
    3040             # the histogram of the data 
    3041             n, bins, patches = p.hist(x, nbins) 
    3042  
    3043             p.xlabel('Degree') 
    3044             p.ylabel('No. of nodes') 
    3045             p.title(r'Degree distribution') 
    3046  
    3047             p.show() 
    3048  
    3049         def setColors(self): 
    3050             dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
    3051             if dlg.exec_(): 
    3052                 self.colorSettings = dlg.getColorSchemas() 
    3053                 self.selectedSchemaIndex = dlg.selectedSchemaIndex 
    3054                 self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    3055                 self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    3056  
    3057                 self.setVertexColor() 
    3058  
    3059         def setEdgeColorPalette(self): 
    3060             dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex) 
    3061             if dlg.exec_(): 
    3062                 self.edgeColorSettings = dlg.getColorSchemas() 
    3063                 self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex 
    3064                 self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette") 
    3065                 self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette") 
    3066  
    3067                 self.setEdgeColor() 
    3068  
    3069         def createColorDialog(self, colorSettings, selectedSchemaIndex): 
    3070             c = OWColorPalette.ColorPaletteDlg(self, "Color Palette") 
    3071             c.createDiscretePalette("discPalette", "Discrete Palette") 
    3072             c.createContinuousPalette("contPalette", "Continuous Palette") 
    3073             c.setColorSchemas(colorSettings, selectedSchemaIndex) 
    3074             return c 
    3075  
    3076         """ 
    3077         Layout Optimization 
    3078         """ 
    3079  
    3080         def graph_layout(self): 
    3081             if self.graph is None:   #grafa se ni 
    3082                 self.optButton.setChecked(False) 
    3083                 return 
    3084  
    3085             if not self.optButton.isChecked(): 
    3086                 self.optButton.setChecked(False) 
    3087                 return 
    3088  
    3089             qApp.processEvents() 
    3090  
    3091             if self.optMethod == 1: 
    3092                 self.layout.random() 
    3093             elif self.optMethod == 2: 
    3094                 self.graph_layout_fr(False) 
    3095             elif self.optMethod == 3: 
    3096                 self.graph_layout_fr(True) 
    3097             elif self.optMethod == 4: 
    3098                 self.graph_layout_fr_radial() 
    3099             elif self.optMethod == 5: 
    3100                 self.layout.circular_crossing_reduction() 
    3101             elif self.optMethod == 6: 
    3102                 self.layout.circular_original() 
    3103             elif self.optMethod == 7: 
    3104                 self.layout.circular_random() 
    3105             elif self.optMethod == 8: 
    3106                 self.graph_layout_pivot_mds() 
    3107  
    3108             self.optButton.setChecked(False) 
    3109             self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    3110             self.networkCanvas.updateCanvas() 
    3111             qApp.processEvents() 
    3112  
    3113         def graph_layout_method(self, method=None): 
    3114             self.information() 
    3115             self.stepsSpin.label.setText('Iterations: ') 
    3116  
    3117             if method is not None: 
    3118                 self.optMethod = method 
    3119  
    3120             if str(self.optMethod) == '0': 
    3121                 self.optButton.setEnabled(False) 
    3122             else: 
    3123                 self.optButton.setEnabled(True) 
    3124  
    3125             if str(self.optMethod) in ['2', '3', '4']: 
    3126                 self.stepsSpin.setEnabled(True) 
    3127             elif str(self.optMethod) == '8': 
    3128                 self.stepsSpin.label.setText('Pivots: ') 
    3129                 self.stepsSpin.setEnabled(True) 
    3130  
    3131                 if self.items_matrix is None: 
    3132                     self.information('Set distance matrix to input signal') 
    3133                     return 
    3134                 if self.graph is None: 
    3135                     self.information('No network found') 
    3136                     return 
    3137                 if self.items_matrix.dim != self.graph.number_of_nodes(): 
    3138                     self.error('Distance matrix dimensionality must equal number of vertices') 
    3139                     return 
    3140             else: 
    3141                 self.stepsSpin.setEnabled(False) 
    3142                 self.optButton.setChecked(True) 
    3143                 self.graph_layout() 
    3144  
    3145         def graph_layout_fr(self, weighted): 
    3146             if self.graph is None:   #grafa se ni 
    3147                 return 
    3148  
    3149             if not self.optButton.isChecked(): 
    3150               #print "not" 
    3151               self.stopOptimization = 1 
    3152               self.optButton.setChecked(False) 
    3153               self.optButton.setText("Optimize layout") 
    3154               return 
    3155  
    3156             self.optButton.setText("Stop") 
    3157             qApp.processEvents() 
    3158             self.stopOptimization = 0 
    3159             tolerance = 5 
    3160             initTemp = 1000 
    3161             breakpoints = 6 
    3162             k = int(self.frSteps / breakpoints) 
    3163             o = self.frSteps % breakpoints 
    3164             iteration = 0 
    3165             coolFactor = math.exp(math.log(10.0 / 10000.0) / self.frSteps) 
    3166  
    3167             if k > 0: 
    3168                 while iteration < breakpoints: 
    3169                     #print "iteration, initTemp: " + str(initTemp) 
    3170                     if self.stopOptimization: 
    3171                         return 
    3172                     initTemp = self.layout.fr(k, initTemp, coolFactor, weighted) 
    3173                     iteration += 1 
    3174                     qApp.processEvents() 
    3175                     self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    3176                     self.networkCanvas.updateCanvas() 
    3177  
    3178                 #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp) 
    3179                 if self.stopOptimization: 
    3180                         return 
    3181                 initTemp = self.layout.fr(o, initTemp, coolFactor, weighted) 
    3182                 qApp.processEvents() 
    3183                 self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    3184                 self.networkCanvas.updateCanvas() 
    3185             else: 
    3186                 while iteration < o: 
    3187                     #print "iteration ostanek, initTemp: " + str(initTemp) 
    3188                     if self.stopOptimization: 
    3189                         return 
    3190                     initTemp = self.layout.fr(1, initTemp, coolFactor, weighted) 
    3191                     iteration += 1 
    3192                     qApp.processEvents() 
    3193                     self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
    3194                     self.networkCanvas.updateCanvas() 
    3195  
    3196             self.optButton.setChecked(False) 
    3197             self.optButton.setText("Optimize layout") 
    3198  
    3199         def graph_layout_fr_special(self): 
    3200             if self.graph is None:   #grafa se ni 
    3201                 return 
    3202  
    3203             steps = 100 
    3204             initTemp = 1000 
    3205             coolFactor = math.exp(math.log(10.0 / 10000.0) / steps) 
    3206             oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())] 
    3207             #print oldXY 
    3208             initTemp = self.layout.fr(steps, initTemp, coolFactor) 
    3209             #print oldXY 
    3210             self.networkCanvas.updateDataSpecial(oldXY) 
    3211             self.networkCanvas.replot() 
    3212  
    3213         def graph_layout_fr_radial(self): 
    3214             if self.graph is None:   #grafa se ni 
    3215                 return 
    3216  
    3217             #print "F-R Radial" 
    3218             k = 1.13850193174e-008 
    3219             nodes = self.graph.number_of_nodes() 
    3220             t = k * nodes * nodes 
    3221             refreshRate = int(5.0 / t) 
    3222             if refreshRate < 1: refreshRate = 1; 
    3223             if refreshRate > 1500: refreshRate = 1500; 
    3224             #print "refreshRate: " + str(refreshRate) 
    3225  
    3226             tolerance = 5 
    3227             initTemp = 100 
    3228             centerNdx = 0 
    3229  
    3230             selection = self.networkCanvas.getSelection() 
    3231             if len(selection) > 0: 
    3232                 centerNdx = selection[0] 
    3233  
    3234             #print "center ndx: " + str(centerNdx) 
    3235             initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp) 
    3236             self.networkCanvas.circles = [10000 / 12, 10000 / 12 * 2, 10000 / 12 * 3]#, 10000/12*4, 10000/12*5] 
    3237             #self.networkCanvas.circles = [100, 200, 300] 
    3238             self.networkCanvas.updateCanvas() 
    3239             self.networkCanvas.circles = [] 
    3240  
    3241         def graph_layout_pivot_mds(self): 
    3242             self.information() 
    3243  
    3244             if self.items_matrix is None: 
    3245                 self.information('Set distance matrix to input signal') 
    3246                 return 
    3247  
    3248             if self.graph is None: 
    3249                 self.information('No network found') 
    3250                 return 
    3251  
    3252             if self.items_matrix.dim != self.graph.number_of_nodes(): 
    3253                 self.error('Distance matrix dimensionality must equal number of vertices') 
    3254                 return 
    3255  
    3256             self.frSteps = min(self.frSteps, self.items_matrix.dim) 
    3257             qApp.processEvents() 
    3258             mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps) 
    3259             x, y = mds.optimize() 
    3260             self.layout.coors[0] = x 
    3261             self.layout.coors[1] = y 
    3262             self.networkCanvas.updateCanvas() 
    3263  
    3264  
    3265         """ 
    3266         Network Visualization 
    3267         """ 
    3268  
    3269         def clickedAttLstBox(self): 
    3270             if self.graph is None: 
    3271                 return 
    3272  
    3273             self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes]) 
    3274             self.networkCanvas.setLabelText(self.lastLabelColumns) 
    3275             self.networkCanvas.updateData() 
    3276             self.networkCanvas.replot() 
    3277  
    3278         def clickedTooltipLstBox(self): 
    3279             if self.graph is None: 
    3280                 return 
    3281  
    3282             self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes]) 
    3283             self.networkCanvas.setTooltipText(self.lastTooltipColumns) 
    3284             self.networkCanvas.updateData() 
    3285             self.networkCanvas.replot() 
    3286  
    3287         def clickedEdgeLabelListBox(self): 
    3288             if self.graph is None: 
    3289                 return 
    3290  
    3291             self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes]) 
    3292             self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes) 
    3293             self.networkCanvas.updateData() 
    3294             self.networkCanvas.replot() 
    3295  
    3296         def setVertexColor(self): 
    3297             if self.graph is None: 
    3298                 return 
    3299  
    3300             self.networkCanvas.set_node_color(self.colorCombo.currentText()) 
    3301             self.lastColorColumn = self.colorCombo.currentText() 
    3302             self.networkCanvas.updateData() 
    3303             self.networkCanvas.replot() 
    3304  
    3305         def setEdgeColor(self): 
    3306             if self.graph is None: 
    3307                 return 
    3308  
    3309             self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText()) 
    3310             self.lastEdgeColorColumn = self.edgeColorCombo.currentText() 
    3311             self.networkCanvas.updateData() 
    3312             self.networkCanvas.replot() 
    3313  
    3314         def setGraphGrid(self): 
    3315             self.networkCanvas.enableGridY(self.networkCanvasShowGrid) 
    3316             self.networkCanvas.enableGridX(self.networkCanvasShowGrid) 
    3317  
    3318         def selectAllConnectedNodes(self): 
    3319             self.networkCanvas.selectConnectedNodes(1000000) 
    3320  
    3321         def setMaxLinkSize(self): 
    3322             if self.graph is None: 
    3323                 return 
    3324  
    3325             self.networkCanvas.maxEdgeSize = self.maxLinkSize 
    3326             self.networkCanvas.setEdgesSize() 
    3327             self.networkCanvas.replot() 
    3328  
    3329         def setVertexSize(self): 
    3330             if self.graph is None or self.networkCanvas is None: 
    3331                 return 
    3332  
    3333             if self.minVertexSize > self.maxVertexSize: 
    3334                 self.maxVertexSize = self.minVertexSize 
    3335  
    3336             self.networkCanvas.minVertexSize = self.minVertexSize 
    3337             self.networkCanvas.maxVertexSize = self.maxVertexSize 
    3338             self.lastVertexSizeColumn = self.vertexSizeCombo.currentText() 
    3339  
    3340             if self.vertexSize > 0: 
    3341                 self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize) 
    3342             else: 
    3343                 self.networkCanvas.setVerticesSize() 
    3344  
    3345             self.networkCanvas.replot() 
    3346  
    3347         def setFontSize(self): 
    3348             if self.networkCanvas is None: 
    3349                 return 
    3350  
    3351             self.networkCanvas.fontSize = self.fontSize 
    3352             self.networkCanvas.drawPlotItems() 
    3353  
    3354         def sendReport(self): 
    3355             self.reportSettings("Graph data", 
    3356                                 [("Number of vertices", self.graph.number_of_nodes()), 
    3357                                  ("Number of edges", self.graph.number_of_edges()), 
    3358                                  ("Vertices per edge", "%.3f" % self.verticesPerEdge), 
    3359                                  ("Edges per vertex", "%.3f" % self.edgesPerVertex), 
    3360                                  ("Diameter", self.diameter), 
    3361                                  ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient) 
    3362                                  ]) 
    3363             if self.color or self.vertexSize or self.markerAttributes or self.edgeColor: 
    3364                 self.reportSettings("Visual settings", 
    3365                                     [self.color and ("Vertex color", self.colorCombo.currentText()), 
    3366                                      self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""), 
    3367                                      self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)), 
    3368                                      self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()), 
    3369                                     ]) 
    3370             self.reportSettings("Optimization", 
    3371                                 [("Method", self.optCombo.currentText()), 
    3372                                  ("Iterations", self.frSteps)]) 
    3373             self.reportSection("Graph") 
    3374             self.reportImage(self.networkCanvas.saveToFileDirect) 
    3375  
     1536    from OWNxExplorerQwt import OWNxExplorerQwt as OWNxExplorer 
    33761537 
    33771538if __name__ == "__main__": 
     
    33791540    ow = OWNxExplorer() 
    33801541    ow.show() 
     1542 
    33811543    def setNetwork(signal, data, id=None): 
    33821544        if signal == 'Network': 
Note: See TracChangeset for help on using the changeset viewer.