source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 8083:87f639728674

Revision 8083:87f639728674, 80.2 KB checked in by miha <miha.stajdohar@…>, 23 months ago (diff)

New visualization architecture.
Line 
1"""
2<name>Nx Explorer</name>
3<description>Orange widget for network exploration.</description>
4<icon>icons/Network.png</icon>
5<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact> 
6<priority>6430</priority>
7"""
8import math
9import operator
10import statc
11import time
12
13import Orange
14import OWGUI
15import OWColorPalette
16import OWToolbars
17import orngMDS
18
19from OWWidget import *
20from OWNxCanvas import *
21from operator import itemgetter
22
23dir = os.path.dirname(__file__) + "/../icons/"
24dlg_mark2sel = dir + "Dlg_Mark2Sel.png"
25dlg_sel2mark = dir + "Dlg_Sel2Mark.png"
26dlg_selIsmark = dir + "Dlg_SelisMark.png"
27dlg_selected = dir + "Dlg_SelectedNodes.png"
28dlg_unselected = dir + "Dlg_UnselectedNodes.png"
29dlg_showall = dir + "Dlg_clear.png"
30
31class OWNxExplorer(OWWidget):
32    settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage",
33    "maxLinkSize", "minVertexSize", "maxVertexSize", "renderAntialiased",
34    "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn",
35    "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns",
36    "showWeights", "showIndexes",  "showEdgeLabels", "colorSettings", 
37    "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex",
38    "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage",
39    "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo", 
40    "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth",
41    "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"] 
42   
43    def __init__(self, parent=None, signalManager=None, name = 'Nx Explorer', 
44                 NetworkCanvas=OWNxCanvas):
45        OWWidget.__init__(self, parent, signalManager, name)
46        #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])}
47        self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default),
48                       ("Nx View", Orange.network.NxView, self.set_network_view),
49                       ("Items", Orange.data.Table, self.setItems),
50                       ("Items to Mark", Orange.data.Table, self.markItems), 
51                       ("Items Subset", Orange.data.Table, self.setExampleSubset), 
52                       ("Items Distance Matrix", Orange.core.SymMatrix, self.set_items_distance_matrix)]
53       
54        self.outputs = [("Selected Network", Orange.network.Graph),
55                        ("Selected Items Distance Matrix", Orange.core.SymMatrix),
56                        ("Selected Items", Orange.data.Table), 
57                        ("Unselected Items", Orange.data.Table), 
58                        ("Marked Items", Orange.data.Table),
59                        ("Attribute Selection List", AttributeList)]
60       
61        self.markerAttributes = []
62        self.tooltipAttributes = []
63        self.edgeLabelAttributes = []
64        self.attributes = []
65        self.edgeAttributes = []
66        self.autoSendSelection = False
67        self.graphShowGrid = 1  # show gridlines in the graph
68       
69        self.markNConnections = 2
70        self.markNumber = 0
71        self.markProportion = 0
72        self.markSearchString = ""
73        self.markDistance = 2
74        self.frSteps = 1
75        self.hubs = 0
76        self.color = 0
77        self.edgeColor = 0
78        self.vertexSize = 0
79        self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = self.diameter = self.clustering_coefficient = 0
80        self.optimizeWhat = 1
81        self.stopOptimization = 0
82        self.maxLinkSize = 3
83        self.maxVertexSize = 5
84        self.minVertexSize = 5
85        self.renderAntialiased = 1
86        self.labelsOnMarkedOnly = 0
87        self.invertSize = 0
88        self.optMethod = 0
89        self.lastVertexSizeColumn = ''
90        self.lastColorColumn = ''
91        self.lastNameComponentAttribute = ''
92        self.lastLabelColumns = set()
93        self.lastTooltipColumns = set()
94        self.showWeights = 0
95        self.showIndexes = 0
96        self.showEdgeLabels = 0
97        self.colorSettings = None
98        self.selectedSchemaIndex = 0
99        self.edgeColorSettings = [('net_edges', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(204, 204, 204), (179, 226, 205), (253, 205, 172), (203, 213, 232), (244, 202, 228), (230, 245, 201), (255, 242, 174), (241, 226, 204)])]]), ('Default', [[], [('contPalette', (4294967295L, 4278190080L, 0))], [('discPalette', [(0, 0, 255), (255, 0, 0), (0, 255, 0), (255, 128, 0), (255, 255, 0), (255, 0, 255), (0, 255, 255), (128, 0, 255), (0, 128, 255), (255, 223, 128), (127, 111, 64), (92, 46, 0), (0, 84, 0), (192, 192, 0), (0, 127, 127), (128, 0, 0), (127, 0, 127)])]])]
100        self.selectedEdgeSchemaIndex = 0
101        self.items_matrix = None
102        self.showDistances = 0
103        self.showMissingValues = 0
104        self.fontSize = 12
105        self.mdsTorgerson = 0
106        self.mdsAvgLinkage = 1
107        self.mdsSteps = 10000
108        self.mdsRefresh = 50
109        self.mdsStressDelta = 0.0000001
110        self.organism = 'goa_human'
111        self.showTextMiningInfo = 0
112        self.toolbarSelection = 0
113        self.minComponentEdgeWidth = 10
114        self.maxComponentEdgeWidth = 70
115        self.mdsFromCurrentPos = 0
116        self.tabIndex = 0
117        self.number_of_nodes_label = -1
118        self.number_of_edges_label = -1
119        self.loadSettings()
120       
121        self._network_view = None
122        self.layout = Orange.network.GraphLayout()
123        self.graph = None
124        self.graph_base = None
125        self.markInputItems = None
126       
127        self.mainArea.layout().setContentsMargins(0,4,4,4)
128        self.controlArea.layout().setContentsMargins(4,4,0,4)
129       
130        self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer")
131        self.networkCanvas.showMissingValues = self.showMissingValues
132        self.mainArea.layout().addWidget(self.networkCanvas)
133       
134        self.networkCanvas.maxLinkSize = self.maxLinkSize
135        self.networkCanvas.minVertexSize = self.minVertexSize
136        self.networkCanvas.maxVertexSize = self.maxVertexSize
137       
138        self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal')
139       
140        self.tabs = OWGUI.tabWidget(self.hcontroArea)
141       
142        self.verticesTab = OWGUI.createTabPage(self.tabs, "Vertices")
143        self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges")
144        self.markTab = OWGUI.createTabPage(self.tabs, "Mark")
145        self.infoTab = OWGUI.createTabPage(self.tabs, "Info")
146        #self.editTab = OWGUI.createTabPage(self.tabs, "Edit")
147       
148        self.tabs.setCurrentIndex(self.tabIndex)
149        self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index))
150       
151        self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False)
152       
153        self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method)
154        self.optCombo.addItem("No optimization")
155        self.optCombo.addItem("Random")
156        self.optCombo.addItem("Fruchterman Reingold")
157        self.optCombo.addItem("Fruchterman Reingold Weighted")
158        self.optCombo.addItem("Fruchterman Reingold Radial")
159        self.optCombo.addItem("Circular Crossing Reduction")
160        self.optCombo.addItem("Circular Original")
161        self.optCombo.addItem("Circular Random")
162        self.optCombo.addItem("Pivot MDS")
163        self.optCombo.setCurrentIndex(self.optMethod)
164        self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ")
165        self.stepsSpin.setEnabled(False)
166       
167        self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1)
168       
169        colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace = False)
170        self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.setVertexColor)
171        self.colorCombo.addItem("(same color)")
172        OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip = "Set vertex color palette", debuggingEnabled = 0)
173       
174        self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box = "Vertex size attribute", callback=self.setVertexSize)
175        self.vertexSizeCombo.addItem("(none)")
176       
177        OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback = self.setVertexSize)
178        OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback = self.setVertexSize)
179        OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback = self.setVertexSize)
180       
181        colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace = False)
182        self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.setEdgeColor)
183        self.edgeColorCombo.addItem("(same color)")
184        OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip = "Set edge color palette", debuggingEnabled = 0)
185       
186        self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace = False)
187        OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback = self.setFontSize)
188       
189        self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace = False)
190        self.attListBox = OWGUI.listBox(self.attBox, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox)
191        self.tooltipListBox = OWGUI.listBox(self.attBox, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox)
192       
193        self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace = False)
194        self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox)
195        self.edgeLabelBox.setEnabled(False)
196       
197        ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical")
198        OWGUI.checkBox(ib, self, 'showWeights', 'Show weights', callback=(lambda: self._set_canvas_attr('showWeights', self.showWeights)))
199        OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels)))
200        OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback = self.setMaxLinkSize)
201        self.showDistancesCheckBox = OWGUI.checkBox(ib, self, 'showDistances', 'Explore vertex distances', callback=(lambda: self._set_canvas_attr('showDistances', self.showDistances)), disabled=1)
202       
203        ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical")
204        OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes)))
205        OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly)))
206        OWGUI.checkBox(ib, self, 'renderAntialiased', 'Render antialiased', callback=(lambda: self._set_canvas_attr('renderAntialiased', self.renderAntialiased)))
207        self.insideView = 0
208        self.insideViewNeighbours = 2
209        OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked = "insideView", checkCallback = self.insideview, callback = self.insideviewneighbours)
210        OWGUI.checkBox(ib, self, 'showMissingValues', 'Show missing values', callback=(lambda: self._set_canvas_attr('showMissingValues', self.showMissingValues)))
211       
212        ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical")
213        OWGUI.label(ib, self, "Vertices (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)")
214        OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i")
215       
216        ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setMarkMode)
217        OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback = self.setMarkMode)
218        OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback = self.setMarkMode)
219        self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True)
220        self.searchStringTimer = QTimer(self)
221        self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode)
222       
223        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback = self.setMarkMode)
224        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback = self.setMarkMode)
225        ib = OWGUI.indentedBox(ribg, orientation = 0)
226        self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h)))
227        #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True)
228        OWGUI.widgetLabel(ribg, "Mark  vertices with ...")
229        OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback = self.setMarkMode)
230        OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback = self.setMarkMode)
231        self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h)))
232        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback = self.setMarkMode)
233        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback = self.setMarkMode)
234        OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback = self.setMarkMode)
235        ib = OWGUI.indentedBox(ribg)
236        self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h)))
237        OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)")
238        self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback = self.setMarkMode)
239        ib = OWGUI.indentedBox(ribg)
240        self.markInput = 0
241        self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h)))
242        self.markInputRadioButton.setEnabled(False)
243       
244        ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical")
245        self.checkSendMarkedNodes = 0
246        OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback = self.setSendMarkedNodes, disabled=0)
247       
248       
249        T = OWToolbars.NavigateSelectToolbar
250        self.zoomSelectToolbar = T(self, self.hcontroArea, self.networkCanvas, self.autoSendSelection,
251                                  buttons = (T.IconZoom, 
252                                             T.IconZoomExtent, 
253                                             T.IconZoomSelection, 
254                                             T.IconPan, 
255                                             ("", "", "", None, None, 0),
256                                             #("Move selection", "buttonMoveSelection", "activateMoveSelection", QIcon(OWToolbars.dlg_select), Qt.ArrowCursor, 1),
257                                             T.IconRectangle, 
258                                             #T.IconPolygon, 
259                                             T.IconSendSelection,
260                                             ("", "", "", None, None, 0, "select"),
261                                             ("Add marked to selection", "buttonM2S", "markedToSelection", QIcon(dlg_mark2sel), Qt.ArrowCursor, 0),
262                                             ("Add selection to marked", "buttonS2M", "selectionToMarked", QIcon(dlg_sel2mark), Qt.ArrowCursor, 0),
263                                             ("Remove selection", "buttonRMS", "removeSelection", QIcon(dlg_selIsmark), Qt.ArrowCursor, 0),
264                                             ("", "", "", None, None, 0, "select"),
265                                             ("Hide selected", "buttonSEL", "hideSelectedVertices", QIcon(dlg_selected), Qt.ArrowCursor, 0),
266                                             ("Hide unselected", "buttonUN", "hideUnSelectedVertices", QIcon(dlg_unselected), Qt.ArrowCursor, 0),
267                                             ("Show all nodes", "buttonSW", "showAllVertices", QIcon(dlg_showall), Qt.ArrowCursor, 0)))
268                       
269        OWGUI.rubber(self.zoomSelectToolbar)
270       
271        ib = OWGUI.widgetBox(self.infoTab, "General")
272        OWGUI.label(ib, self, "Number of vertices: %(number_of_nodes_label)i")
273        OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i")
274        OWGUI.label(ib, self, "Vertices per edge: %(verticesPerEdge).2f")
275        OWGUI.label(ib, self, "Edges per vertex: %(edgesPerVertex).2f")
276        OWGUI.label(ib, self, "Diameter: %(diameter)i")
277        OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%")
278       
279        ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal")
280       
281        OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False)
282        OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False)
283        OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False)
284       
285        #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering)
286       
287        ib = OWGUI.widgetBox(self.infoTab, "Prototype")
288       
289        #ib = OWGUI.widgetBox(ibProto, "Name components")
290        OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal')
291       
292        self.nameComponentAttribute = 0
293        self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal")
294        self.nameComponentCombo.addItem("Select attribute")
295       
296        self.showComponentAttribute = 0
297        self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal")
298        self.showComponentCombo.addItem("Select attribute")
299        OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info")
300       
301        #ib = OWGUI.widgetBox(ibProto, "Distance Matrix")
302        ibs = OWGUI.widgetBox(ib, orientation="horizontal")
303        self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1)
304        self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1)
305        self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1)
306        ibs = OWGUI.widgetBox(ib, orientation="horizontal")
307        self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1)
308        self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1)
309        self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1)
310        self.scalingRatio = 0
311        OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ")
312        OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ")
313        OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ")
314        OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ")
315        ibs = OWGUI.widgetBox(ib, orientation="horizontal")
316        OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation")
317        OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage")
318        OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions")
319        self.mdsInfoA=OWGUI.widgetLabel(ib, "Avg. stress:")
320        self.mdsInfoB=OWGUI.widgetLabel(ib, "Num. steps:")
321        self.rotateSteps = 100
322       
323        OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ")
324        OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin)))
325        OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin)))
326       
327        self.attSelectionAttribute = 0
328        self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList)
329        self.comboAttSelection.addItem("Select attribute")
330        self.autoSendAttributes = 0
331        OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes)
332       
333        self.icons = self.createAttributeIconDict()
334        self.setMarkMode()
335       
336        self.editAttribute = 0
337        self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal")
338        self.editCombo.addItem("Select attribute")
339        self.editValue = ''
340        OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal')
341        OWGUI.button(self.infoTab, self, "Edit", callback=self.edit)
342       
343        self.verticesTab.layout().addStretch(1)
344        self.edgesTab.layout().addStretch(1)
345        self.markTab.layout().addStretch(1)
346        self.infoTab.layout().addStretch(1)
347       
348        dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
349        self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
350        self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
351       
352        dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
353        self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
354        self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
355       
356        self.graph_layout_method()
357        self.setFontSize()
358        self.set_graph(None)
359        self.setMinimumWidth(900)
360       
361        #self.resize(1000, 600)
362        #self.controlArea.setEnabled(False)
363       
364    def setComponentEdgeWidth(self, changedMin=True):
365        if self.networkCanvas is None:
366            return
367       
368        canvas = self.networkCanvas
369        if changedMin:
370            if self.maxComponentEdgeWidth < self.minComponentEdgeWidth:
371                self.maxComponentEdgeWidth = self.minComponentEdgeWidth
372        else:
373            if self.minComponentEdgeWidth > self.maxComponentEdgeWidth:
374                self.minComponentEdgeWidth = self.maxComponentEdgeWidth
375       
376        canvas.minComponentEdgeWidth = self.minComponentEdgeWidth
377        canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
378        self.networkCanvas.updateCanvas()
379   
380    def setAutoSendAttributes(self):
381        if self.autoSendAttributes:
382            self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList
383        else:
384            self.networkCanvas.callbackSelectVertex = None
385
386    def sendAttSelectionList(self):
387        if not self.graph is None:
388            vars = [x.name for x in self.graph_base.links_vars()]
389            if not self.comboAttSelection.currentText() in vars:
390                return
391            att = str(self.comboAttSelection.currentText())
392            vertices = self.networkCanvas.networkCurve.get_selected_vertices()
393           
394            if len(vertices) != 1:
395                return
396           
397            attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ')
398        else:
399            attributes = None
400        self.send("Attribute Selection List", attributes)
401       
402    def edit(self):
403        if self.graph is None:
404            return
405       
406        vars = [x.name for x in self.graph_base.items_vars()]
407        if not self.editCombo.currentText() in vars:
408            return
409        att = str(self.editCombo.currentText())
410        vertices = self.networkCanvas.networkCurve.get_selected_vertices()
411       
412        if len(vertices) == 0:
413            return
414       
415        if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous:
416            for v in vertices:
417                self.graph_base.items()[v][att] = float(self.editValue)
418        else:
419            for v in vertices:
420                self.graph_base.items()[v][att] = str(self.editValue)
421       
422        self.setItems(self.graph_base.items())
423       
424    def drawForce(self):
425        if self.btnForce.isChecked() and self.graph is not None:
426            self.networkCanvas.forceVectors = self.layout._computeForces() 
427        else:
428            self.networkCanvas.forceVectors = None
429           
430        self.networkCanvas.updateCanvas()
431       
432    def rotateProgress(self, curr, max):
433        self.progressBarSet(int(curr * 100 / max))
434        qApp.processEvents()
435       
436    def rotateComponentsMDS(self):
437        print "rotate"
438        if self.items_matrix is None:
439            self.information('Set distance matrix to input signal')
440            self.btnRotateMDS.setChecked(False)
441            return
442       
443        if self.graph is None:
444            self.information('No network found')
445            self.btnRotateMDS.setChecked(False)
446            return
447        if self.items_matrix.dim != self.graph.number_of_nodes():
448            self.error('Distance matrix dimensionality must equal number of vertices')
449            self.btnRotateMDS.setChecked(False)
450            return
451       
452        if not self.btnRotateMDS.isChecked():
453          self.layout.stopMDS = 1
454          #self.btnMDS.setChecked(False)
455          #self.btnMDS.setText("MDS on graph components")
456          return
457       
458        self.btnRotateMDS.setText("Stop")
459        qApp.processEvents()
460       
461        self.layout.items_matrix = self.items_matrix
462        self.progressBarInit()
463       
464        self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)           
465           
466        self.btnRotateMDS.setChecked(False)
467        self.btnRotateMDS.setText("Rotate graph components (MDS)")
468        self.progressBarFinished()
469   
470    def rotateComponents(self):
471        if self.items_matrix is None:
472            self.information('Set distance matrix to input signal')
473            self.btnRotate.setChecked(False)
474            return
475       
476        if self.graph is None:
477            self.information('No network found')
478            self.btnRotate.setChecked(False)
479            return
480       
481        if self.items_matrix.dim != self.graph.number_of_nodes():
482            self.error('Distance matrix dimensionality must equal number of vertices')
483            self.btnRotate.setChecked(False)
484            return
485       
486        if not self.btnRotate.isChecked():
487          self.layout.stopRotate = 1
488          return
489     
490        self.btnRotate.setText("Stop")
491        qApp.processEvents()
492       
493        self.layout.items_matrix = self.items_matrix
494        self.progressBarInit()
495        self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas)
496        self.btnRotate.setChecked(False)
497        self.btnRotate.setText("Rotate graph components")
498        self.progressBarFinished()
499       
500    def mdsProgress(self, avgStress, stepCount):   
501        self.drawForce()
502
503        self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress)
504        self.mdsInfoB.setText("Num. steps: %i" % stepCount)
505        self.progressBarSet(int(stepCount * 100 / self.mdsSteps))
506        qApp.processEvents()
507       
508    def mds_components(self, mdsType=Orange.network.MdsType.componentMDS):
509        if mdsType == Orange.network.MdsType.componentMDS:
510            btn = self.btnMDS
511        elif mdsType == Orange.network.MdsType.exactSimulation:
512            btn = self.btnESIM
513        elif mdsType == Orange.network.MdsType.MDS:
514            btn = self.btnMDSv
515       
516        btnCaption = btn.text()
517       
518        if self.items_matrix is None:
519            self.information('Set distance matrix to input signal')
520            btn.setChecked(False)
521            return
522       
523        if self.layout is None:
524            self.information('No network found')
525            btn.setChecked(False)
526            return
527       
528        if self.items_matrix.dim != self.graph.number_of_nodes():
529            self.error('Distance matrix dimensionality must equal number of vertices')
530            btn.setChecked(False)
531            return
532       
533        if not btn.isChecked():
534            self.layout.stopMDS = 1
535            btn.setChecked(False)
536            btn.setText(btnCaption)
537            return
538       
539        btn.setText("Stop")
540        qApp.processEvents()
541       
542        self.layout.items_matrix = self.items_matrix
543        self.progressBarInit()
544       
545        if self.mdsAvgLinkage:
546            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)
547        else:
548            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)           
549       
550        btn.setChecked(False)
551        btn.setText(btnCaption)
552        self.progressBarFinished()
553       
554    def set_items_distance_matrix(self, matrix):
555        self.error('')
556        self.information('')
557        self.showDistancesCheckBox.setEnabled(0)
558       
559        if matrix is None or self.graph is None:
560            self.items_matrix = None
561            self.layout.items_matrix = None
562            if self.networkCanvas: self.networkCanvas.items_matrix = None
563            return
564
565        if matrix.dim != self.graph.number_of_nodes():
566            self.error('Distance matrix dimensionality must equal number of vertices')
567            self.items_matrix = None
568            self.layout.items_matrix = None
569            if self.networkCanvas: self.networkCanvas.items_matrix = None
570            return
571       
572        self.items_matrix = matrix
573        self.layout.items_matrix = matrix
574        if self.networkCanvas: self.networkCanvas.items_matrix = matrix
575        self.showDistancesCheckBox.setEnabled(1)
576       
577        self.networkCanvas.updateCanvas()
578           
579    def setSendMarkedNodes(self):
580        if self.checkSendMarkedNodes:
581            self.networkCanvas.sendMarkedNodes = self.sendMarkedNodes
582            self.sendMarkedNodes(self.networkCanvas.getMarkedVertices())
583        else:
584            self.send("Marked Items", None)
585            self.networkCanvas.sendMarkedNodes = None
586       
587    def sendMarkedNodes(self, markedNodes):       
588        if len(markedNodes) == 0:
589            self.send("Marked Items", None)
590            return
591       
592        if self.graph is not None and self.graph_base.items() is not None:
593            items = self.graph_base.items().getitems(markedNodes)
594            self.send("Marked Items", items)
595            return
596       
597        self.send("Marked Items", None)
598       
599    def insideviewneighbours(self):
600        if self.networkCanvas.insideview == 1:
601            self.networkCanvas.insideviewNeighbours = self.insideViewNeighbours
602            self.optButton.setChecked(True)
603            self.graph_layout_fr(False)
604       
605    def insideview(self):
606        print self.networkCanvas.getSelectedVertices()
607        if len(self.networkCanvas.getSelectedVertices()) == 1:
608            if self.networkCanvas.insideview == 1:
609                print "insideview: 1"
610                self.networkCanvas.insideview = 0
611                self.networkCanvas.showAllVertices()
612                self.networkCanvas.updateCanvas()
613            else:
614                print "insideview: 0"
615                self.networkCanvas.insideview = 1
616                self.networkCanvas.insideviewNeighbors = self.insideViewNeighbours
617                self.optButton.setChecked(True)
618                self.graph_layout_fr(False)
619   
620        else:
621            print "One node must be selected!"
622       
623    def showComponents(self):
624        if self.graph is None or self.graph_base.items() is None:
625            return
626       
627        vars = [x.name for x in self.graph_base.items_vars()]
628       
629        if not self.showComponentCombo.currentText() in vars:
630            self.networkCanvas.showComponentAttribute = None
631            self.lastNameComponentAttribute = ''
632        else:
633            self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()     
634           
635        self.networkCanvas.drawPlotItems()
636       
637    def nameComponents(self):
638        """Names connected components of genes according to GO terms."""
639        self.progressBarFinished()
640        self.lastNameComponentAttribute = None
641       
642        if self.graph is None or self.graph_base.items() is None:
643            return
644       
645        vars = [x.name for x in self.graph_base.items_vars()]
646        if not self.nameComponentCombo.currentText() in vars:
647            return
648       
649        self.progressBarInit()
650        components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1]
651        if 'component name' in self.graph_base.items().domain:
652            keyword_table = self.graph_base.items()
653        else:
654            keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
655       
656        import obiGO 
657        ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet) 
658        annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet)
659
660        allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()])
661        foundGenesets = False
662        if len(annotations.geneNames & allGenes) < 1:
663            allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()]))
664            if len(annotations.geneNames & allGenes) < 1:           
665                self.warning('no genes found')
666                return
667            else:
668                foundGenesets = True
669           
670        def rank(a, j, reverse=False):                   
671            if len(a) <= 0: return
672           
673            if reverse:               
674                a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0)
675                top_value = a[0][j]
676                top_rank = len(a)
677                max_rank = float(len(a))
678                int_ndx = 0
679                for k in range(len(a)):
680                    if top_value < a[k][j]:
681                        top_value = a[k][j] 
682                        if k - int_ndx > 1:
683                            avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2
684                            for l in range(int_ndx, k):
685                                a[l][j] = avg_rank
686                       
687                        int_ndx = k
688
689                    a[k][j] = top_rank / max_rank
690                    top_rank -= 1
691               
692                k += 1
693                if k - int_ndx > 1:
694                    avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2
695                    for l in range(int_ndx, k):
696                        a[l][j] = avg_rank   
697               
698            else:
699                a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0)
700                top_value = a[0][j]
701                top_rank = len(a)
702                max_rank = float(len(a))
703                int_ndx = 0
704                for k in range(len(a)):
705                    if top_value > a[k][j]:
706                        top_value = a[k][j] 
707                        if k - int_ndx > 1:
708                            avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2
709                            for l in range(int_ndx, k):
710                                a[l][j] = avg_rank
711                       
712                        int_ndx = k
713
714                    a[k][j] = top_rank / max_rank
715                    top_rank -= 1
716               
717                k += 1
718                if k - int_ndx > 1:
719                    avg_rank = (a[int_ndx][j] + a[k-1][j]) / 2
720                    for l in range(int_ndx, k):
721                        a[l][j] = avg_rank
722       
723        for i in range(len(components)):
724            component = components[i]
725            if len(component) <= 1:
726                continue
727           
728            if foundGenesets:
729                genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component])
730            else:
731                genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component]
732                   
733            res1 = annotations.GetEnrichedTerms(genes, aspect="P")
734            res2 = annotations.GetEnrichedTerms(genes, aspect="F")
735            res = res1_base.items() + res2.items()
736            #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]
737            #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]
738           
739            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]
740            if len(namingScore) == 0:
741                continue
742           
743            annotated_genes = max([a[0] for a in namingScore])
744           
745            rank(namingScore, 1, reverse=True)
746            rank(namingScore, 2, reverse=True)
747            rank(namingScore, 0)
748           
749            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]
750            namingScore.sort(reverse=True)
751           
752            if len(namingScore) < 1:
753                print "warning. no annotations found for group of genes: " + ", ".join(genes)
754                continue
755            elif len(namingScore[0]) < 2:
756                print "warning. error computing score for group of genes: " + ", ".join(genes)
757                continue
758           
759            for v in component:
760                name = str(namingScore[0][1])
761                attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4])
762                info = ''
763                if self.showTextMiningInfo:
764                    info = "\n" + attrs + "\n" + str(namingScore[0][0])
765                keyword_table[v]['component name'] = name + info
766           
767            self.progressBarSet(i*100.0/len(components))
768               
769        self.lastNameComponentAttribute = self.nameComponentCombo.currentText()
770        self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table]))
771        self.progressBarFinished()   
772       
773    def nameComponents_old(self):
774        if self.graph is None or self.graph_base.items() is None:
775            return
776       
777        vars = [x.name for x in self.graph_base.items_vars()]
778       
779        if not self.nameComponentCombo.currentText() in vars:
780            return
781       
782        components = Orange.network.nx.algorithms.components.connected_components(self.graph)
783        keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))]) 
784       
785        excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"]
786        excludePart = ["HSA"]
787        keywords = set()
788        sameKeywords = set()
789       
790        for component in components:
791            words = []
792            all_values = []
793            for vertex in component:
794                values = []
795                value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())])
796               
797                value = value.replace(" ", ",")
798                value_top = value.split(",")
799               
800                for value in value_top:
801                    if len(value) > 0:
802                        tmp = value.split("_")
803                        tmp = [value.strip() for value in tmp if len(value) > 0]
804                        all_values.append(tmp)
805                        values.extend(tmp)
806                               
807                values = [value.strip() for value in values if len(value) > 0]
808                words.extend(values)
809               
810               
811                #value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())])
812                #value = value.replace(" ", "_")
813                #value = value.replace(",", "_")
814                #values = value.split("_")
815                #values = [value.strip() for value in values if len(value) > 0]
816                #print "values:", values
817                #all_values.append(values)
818               
819                #words.extend(values)
820            #print "all_values:", all_values
821            toExclude = []
822           
823            words = [word for word in words if not word.upper() in excludeWord]
824            toExclude = [word for word in words for part in excludePart if word.find(part) != -1]
825           
826            for word in toExclude:
827                try:
828                    while True:
829                        words.remove(word)
830                except:
831                    pass
832           
833            counted_words = {}
834            for word in words:
835                if word in counted_words:
836                    count = counted_words[word]
837                    counted_words[word] = count + 1
838                else:
839                    counted_words[word] = 1
840           
841            words = sorted(counted_words.items(), key=itemgetter(1), reverse=True)
842            keyword = ""
843            keyword_words = []
844            max_count = 0
845            i = 0
846           
847            while i < len(words) and words[i][1] >= max_count:
848                max_count = words[i][1]
849                keyword += words[i][0] + " "
850                keyword_words.append(words[i][0])
851                i += 1
852           
853            if len(keyword_words) > 1:
854                new_all_values = []
855                for values in all_values:
856                    new_values = [value for value in values if value in keyword_words]
857                    new_all_values.append(new_values) 
858                     
859                #print new_all_values
860                word_position = []
861               
862                for word in keyword_words:
863                    sum = 0
864                    for v in new_all_values:
865                        if word in v:
866                            sum += v.index(word)
867                           
868                    word_position.append((word, sum))
869                 
870                words = sorted(word_position, key=itemgetter(1))
871                #print "words:", words
872                #print all_values
873                #print new_all_values
874               
875                keyword = ""
876                for word in words:
877                    keyword += word[0] + " "
878                   
879            keyword = keyword.strip()
880           
881            for vertex in component:
882                keyword_table[vertex]['component name'] = keyword
883               
884            if keyword in keywords:
885                sameKeywords.add(keyword)
886            else:
887                keywords.add(keyword)
888        #print "sameKeywords:", sameKeywords       
889        sameComponents = [component for component in components if str(keyword_table[component[0]]['component name']) in sameKeywords]
890        #print "same components:", sameComponents
891       
892        for component in sameComponents:
893            words = []
894            all_values = []
895            for vertex in component:
896                values = []
897                value =  str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())])
898               
899                value = value.replace(" ", ",")
900                value_top = value.split(",")
901               
902                for value in value_top:
903                    if len(value) > 0:
904                        tmp = value.split("_")
905                        tmp = [value.strip() for value in tmp if len(value) > 0]
906                        all_values.append(tmp)
907                        values.extend(tmp)
908                               
909                values = [value.strip() for value in values if len(value) > 0]
910                words.extend(values)
911           
912            toExclude = []
913           
914            words = [word for word in words if not word.upper() in excludeWord]
915            toExclude = [word for word in words for part in excludePart if word.find(part) != -1]
916           
917            for word in toExclude:
918                try:
919                    while True:
920                        words.remove(word)
921                except:
922                    pass
923           
924            counted_words = {}
925            for word in words:
926                if word in counted_words:
927                    count = counted_words[word]
928                    counted_words[word] = count + 1
929                else:
930                    counted_words[word] = 1
931           
932            words = sorted(counted_words.items(), key=itemgetter(1), reverse=True)
933            keyword = ""
934            counts = [int(word[1]) for word in words] 
935            max_count = max(counts)
936           
937            try:
938                while True and len(counts) > 1:
939                    counts.remove(max_count)
940            except:
941                pass
942            max_count = max(counts)
943            i = 0
944            keyword_words = []
945            while i < len(words) and words[i][1] >= max_count:
946                keyword += words[i][0] + " "
947                keyword_words.append(words[i][0])
948                i += 1
949               
950            if len(keyword_words) > 1:
951                new_all_values = []
952                for values in all_values:
953                    new_values = [value for value in values if value in keyword_words]
954                    new_all_values.append(new_values) 
955                     
956                #print new_all_values
957                word_position = []
958               
959                for word in keyword_words:
960                    sum = 0
961                    for v in new_all_values:
962                        if word in v:
963                            sum += v.index(word)
964                           
965                    word_position.append((word, sum))
966                 
967                words = sorted(word_position, key=itemgetter(1))
968                #print "words:", words
969                #print all_values
970                #print new_all_values
971               
972                keyword = ""
973                for word in words:
974                    keyword += word[0] + " "
975                 
976            keyword = keyword.strip()
977            for vertex in component:
978                keyword_table[vertex]['component name'] = keyword
979       
980        self.lastNameComponentAttribute = self.nameComponentCombo.currentText()
981        #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute
982        items = Orange.data.Table([self.graph_base.items(), keyword_table])
983        self.setItems(items)
984       
985        #for item in items:
986        #    print item
987                       
988    def _set_canvas_attr(self, attr, value):
989        setattr(self.networkCanvas, attr, value)
990        self.networkCanvas.updateCanvas()
991               
992    def setSearchStringTimer(self):
993        self.hubs = 1
994        self.searchStringTimer.stop()
995        self.searchStringTimer.start(1000)
996         
997    def setMarkMode(self, i = None):
998        self.searchStringTimer.stop()
999        if not i is None:
1000            self.hubs = i
1001       
1002        #print self.hubs
1003        self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0
1004        self.networkCanvas.markWithRed = False
1005
1006        if self.graph is None:
1007            return
1008       
1009        hubs = self.hubs
1010        if hubs == 0:
1011            self.networkCanvas.setMarkedVertices([])
1012            self.networkCanvas.replot()
1013            return
1014       
1015        elif hubs == 1:
1016            #print "mark on given label"
1017            txt = self.markSearchString
1018            labelText = self.networkCanvas.labelText
1019            self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200
1020           
1021            toMark = [i for i, values in enumerate(self.graph_base.items()) if txt.lower() in " ".join([str(values[ndx]).decode("ascii", "ignore").lower() for ndx in range(len(self.graph_base.items().domain)) + self.graph_base.items().domain.getmetas().keys()])]
1022            self.networkCanvas.setMarkedVertices(toMark)
1023            self.networkCanvas.replot()
1024            return
1025       
1026        elif hubs == 2:
1027            #print "mark on focus"
1028            self.networkCanvas.unmark()
1029            self.networkCanvas.tooltipNeighbours = self.markDistance
1030            return
1031
1032        elif hubs == 3:
1033            #print "mark selected"
1034            self.networkCanvas.unmark()
1035            self.networkCanvas.selectionNeighbours = self.markDistance
1036            self.networkCanvas.markSelectionNeighbours()
1037            return
1038       
1039        self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0
1040        powers = self.graph.degree()
1041        powers = [powers[key] for key in sorted(powers.keys())]
1042       
1043        if hubs == 4: # at least N connections
1044            #print "mark at least N connections"
1045            N = self.markNConnections
1046            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power >= N])
1047            self.networkCanvas.replot()
1048        elif hubs == 5:
1049            #print "mark at most N connections"
1050            N = self.markNConnections
1051            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power <= N])
1052            self.networkCanvas.replot()
1053        elif hubs == 6:
1054            #print "mark more than any"
1055            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])])
1056            self.networkCanvas.replot()
1057        elif hubs == 7:
1058            #print "mark more than avg"
1059            self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0]+[powers[nn] for nn in self.graph.getNeighbours(i)])])
1060            self.networkCanvas.replot()
1061        elif hubs == 8:
1062            #print "mark most"
1063            sortedIdx = range(len(powers))
1064            sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y]))
1065            cutP = self.markNumber - 1
1066            cutPower = powers[sortedIdx[cutP]]
1067            while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower:
1068                cutP += 1
1069            self.networkCanvas.setMarkedVertices(sortedIdx[:cutP])
1070            self.networkCanvas.replot()
1071        elif hubs == 9:
1072            self.setMarkInput()
1073       
1074    def testRefresh(self):
1075        start = time.time()
1076        self.networkCanvas.replot()
1077        stop = time.time()   
1078        print "replot in " + str(stop - start)
1079       
1080    def save_network(self):
1081        if self.networkCanvas is None or self.graph is None:
1082            return
1083       
1084        filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)')
1085        if filename:
1086            fn = ""
1087            head, tail = os.path.splitext(str(filename))
1088            if not tail:
1089                fn = head + ".net"
1090            else:
1091                fn = str(filename)
1092           
1093            for i in range(self.graph.number_of_nodes()):
1094                node = self.graph.node[i]
1095                node['x'] = self.layout.coors[0][i]
1096                node['y'] = self.layout.coors[1][i]
1097
1098            Orange.network.readwrite.write(self.graph, fn)
1099           
1100    def sendData(self):
1101        graph = self.networkCanvas.getSelectedGraph()
1102        vertices = self.networkCanvas.getSelectedVertices()
1103       
1104        if graph is not None:
1105            if graph.items() is not None:
1106                self.send("Selected Items", graph.items())
1107            else:
1108                nodes = self.networkCanvas.getSelectedExamples()
1109               
1110                if len(nodes) > 0 and self.graph_base.items() is not None:
1111                    self.send("Selected Items", self.graph_base.items().getitems(nodes))
1112                else:
1113                    self.send("Selected Items", None)
1114               
1115            nodes = self.networkCanvas.getUnselectedExamples()
1116            if len(nodes) > 0 and self.graph_base.items() is not None:
1117                self.send("Unselected Items", self.graph_base.items().getitems(nodes))
1118            else:
1119                self.send("Unselected Items", None)
1120               
1121            self.send("Selected Network", graph)
1122        else:
1123            nodes = self.networkCanvas.getSelectedExamples()
1124            if len(nodes) > 0 and self.graph_base.items() is not None:
1125                self.send("Selected Items", self.graph_base.items().getitems(nodes))
1126            else:
1127                self.send("Selected Items", None)
1128               
1129            nodes = self.networkCanvas.getUnselectedExamples()
1130            if len(nodes) > 0 and self.graph_base.items() is not None:
1131                self.send("Unselected Items", self.graph_base.items().getitems(nodes))
1132            else:
1133                self.send("Unselected Items", None)
1134       
1135        matrix = None
1136        if self.items_matrix is not None:
1137            matrix = self.items_matrix.getitems(vertices)
1138
1139        self.send("Selected Items Distance Matrix", matrix)
1140               
1141    def setCombos(self):
1142        vars = self.graph_base.items_vars()
1143        edgeVars = self.graph_base.links_vars()
1144        lastLabelColumns = self.lastLabelColumns
1145        lastTooltipColumns = self.lastTooltipColumns
1146       
1147        self.clearCombos()
1148       
1149        self.attributes = [(var.name, var.varType) for var in vars]
1150        self.edgeAttributes = [(var.name, var.varType) for var in edgeVars]
1151       
1152        for var in vars:
1153            if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]:
1154                self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1155               
1156            if var.varType in [Orange.data.Type.String] and hasattr(self.graph, 'items') and self.graph_base.items() is not None and len(self.graph_base.items()) > 0:
1157               
1158                value = self.graph_base.items()[0][var].value
1159               
1160                # can value be a list?
1161                try:
1162                    if type(eval(value)) == type([]):
1163                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1164                        continue
1165                except:
1166                    pass
1167               
1168                if len(value.split(',')) > 1:
1169                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name))
1170               
1171            elif var.varType in [Orange.data.Type.Continuous]:
1172                self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1173
1174            self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1175            self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1176            self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1177            self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1178       
1179        for var in edgeVars:
1180            if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]:
1181                self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
1182               
1183        for i in range(self.vertexSizeCombo.count()):
1184            if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i):
1185                self.vertexSize = i
1186                break
1187           
1188        for i in range(self.colorCombo.count()):
1189            if self.lastColorColumn == self.colorCombo.itemText(i):
1190                self.color = i
1191                break
1192
1193        for i in range(self.attListBox.count()):
1194            if str(self.attListBox.item(i).text()) in lastLabelColumns:
1195                self.attListBox.item(i).setSelected(1)
1196               
1197        for i in range(self.tooltipListBox.count()):
1198            if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns:
1199                self.tooltipListBox.item(i).setSelected(1)
1200           
1201        self.lastLabelColumns = lastLabelColumns
1202        self.lastTooltipColumns = lastTooltipColumns
1203       
1204    def clearCombos(self):
1205        self.attributes = []
1206        self.edgeAttributes = []
1207       
1208        self.colorCombo.clear()
1209        self.vertexSizeCombo.clear()
1210        self.nameComponentCombo.clear()
1211        self.showComponentCombo.clear()
1212        self.edgeColorCombo.clear()
1213        self.editCombo.clear()
1214        self.comboAttSelection.clear()
1215       
1216        self.colorCombo.addItem("(same color)")
1217        self.edgeColorCombo.addItem("(same color)")
1218        self.vertexSizeCombo.addItem("(same size)")
1219        self.nameComponentCombo.addItem("Select attribute")
1220        self.showComponentCombo.addItem("Select attribute")
1221        self.editCombo.addItem("Select attribute")
1222        self.comboAttSelection.addItem("Select attribute")
1223     
1224    def set_graph(self, graph):
1225        self.set_items_distance_matrix(None)
1226             
1227        if graph is None:
1228            self.graph = None
1229            self.graph_base = None
1230            self.layout.set_graph(None)
1231            self.networkCanvas.set_graph_layout(None, None)
1232            self.clearCombos()
1233            self.number_of_nodes_label = -1
1234            self.number_of_edges_label = -1
1235            self._items = None
1236            self._links = None
1237            return
1238       
1239        self.graph_base = graph
1240       
1241        if self._network_view is not None:
1242            graph = self._network_view.init_network(graph)
1243       
1244       
1245        #print "OWNetwork/setGraph: new visualizer..."
1246        self.graph = graph
1247       
1248        if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain:
1249            positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \
1250                         for node in sorted(graph) if self._items[node]['x'].value != '?' \
1251                         and self._items[node]['y'].value != '?']
1252            self.layout.set_graph(graph, positions)
1253        else:
1254            self.layout.set_graph(graph)
1255       
1256        self.number_of_nodes_label = self.graph.number_of_nodes()
1257        self.number_of_edges_label = self.graph.number_of_edges()
1258       
1259        self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links())
1260        self.networkCanvas.renderAntialiased = self.renderAntialiased
1261        self.networkCanvas.showEdgeLabels = self.showEdgeLabels
1262        self.networkCanvas.minVertexSize = self.minVertexSize
1263        self.networkCanvas.maxVertexSize = self.maxVertexSize
1264        self.networkCanvas.maxEdgeSize = self.maxLinkSize
1265        self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
1266        self.lastColorColumn = self.colorCombo.currentText()
1267        self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth
1268        self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
1269       
1270       
1271
1272        #for i in range(graph.nVertices):
1273        #    print "x:", graph.coors[0][i], " y:", graph.coors[1][i]
1274
1275        self.nShown = graph.number_of_nodes()
1276       
1277        if self.graph.number_of_edges() > 0:
1278            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges())
1279        else:
1280            self.verticesPerEdge = 0
1281           
1282        if self.graph.number_of_nodes() > 0:
1283            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes())
1284        else:
1285            self.edgesPerVertex = 0
1286       
1287        undirected_graph = graph.to_undirected() if graph.is_directed() else graph
1288        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph)
1289        if len(components) > 1:
1290            self.diameter = -1
1291        else:
1292            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(graph)
1293        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100
1294       
1295        self.setCombos()
1296           
1297        lastNameComponentAttributeFound = False
1298        for i in range(self.nameComponentCombo.count()):
1299            if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i):
1300                lastNameComponentAttributeFound = True
1301                self.nameComponentAttribute = i
1302                self.nameComponents()
1303                self.showComponentAttribute = self.showComponentCombo.count() - 1
1304                self.showComponents()
1305                break
1306           
1307        if not lastNameComponentAttributeFound:
1308            self.lastNameComponentAttribute = ''
1309       
1310        self.showComponentAttribute = None
1311
1312        k = 1.13850193174e-008
1313        nodes = self.graph.number_of_nodes()
1314        t = k * nodes * nodes
1315        self.frSteps = int(5.0 / t)
1316        if self.frSteps <   1: self.frSteps = 1;
1317        if self.frSteps > 3000: self.frSteps = 3000;
1318       
1319        self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly
1320        self.networkCanvas.showWeights = self.showWeights
1321        self.networkCanvas.showIndexes = self.showIndexes
1322        # if graph is large, set random layout, min vertex size, min edge size
1323        if self.frSteps < 10:
1324            self.renderAntialiased = 0
1325            self.minVertexSize = 5
1326            self.maxVertexSize = 5
1327            self.maxLinkSize = 1
1328            self.optMethod = 0
1329            self.graph_layout_method()           
1330           
1331        if self.vertexSize > 0:
1332            self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize)
1333        else:
1334            self.networkCanvas.setVerticesSize()
1335           
1336        self.setVertexColor()
1337        self.setEdgeColor()
1338           
1339        self.networkCanvas.setEdgesSize()
1340        self.clickedAttLstBox()
1341        self.clickedTooltipLstBox()
1342        self.clickedEdgeLabelListBox()
1343       
1344        self.optButton.setChecked(1)
1345        self.graph_layout()       
1346        self.information(0)
1347        #self.networkCanvas.updateCanvas()
1348       
1349    def set_network_view(self, nxView):
1350        self._network_view = nxView
1351        self.set_graph(self.graph_base)
1352       
1353    def setItems(self, items=None):
1354        self.error('')
1355       
1356        if self.graph is None or items is None:
1357            return
1358       
1359        if len(items) != self.graph_base.number_of_nodes():
1360            self.error('ExampleTable items must have one example for each vertex.')
1361            return
1362       
1363        self.graph_base.set_items(items)
1364       
1365        self.setVertexSize()
1366        self.networkCanvas.showIndexes = self.showIndexes
1367        self.networkCanvas.showWeights = self.showWeights
1368        self.networkCanvas.showEdgeLabels = self.showEdgeLabels
1369        self.setCombos()
1370        self.networkCanvas.updateData()
1371       
1372    def setMarkInput(self):
1373        var = str(self.markInputCombo.currentText())
1374        #print 'combo:',self.markInputCombo.currentText()
1375        if self.markInputItems is not None and len(self.markInputItems) > 0:
1376            values = [str(x[var]).strip().upper() for x in self.markInputItems]
1377            toMark = [i for (i,x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values]
1378            #print "mark:", toMark
1379            self.networkCanvas.setMarkedVertices(list(toMark))
1380            self.networkCanvas.replot()
1381           
1382        else:
1383            self.networkCanvas.setMarkedVertices([])
1384            self.networkCanvas.replot()           
1385   
1386    def markItems(self, items):
1387        self.markInputCombo.clear()
1388        self.markInputRadioButton.setEnabled(False)
1389        self.markInputItems = items
1390       
1391        if self.graph is None or self.graph_base.items() is None or items is None:
1392            return
1393       
1394        if len(items) > 0:
1395            lstOrgDomain = [x.name for x in self.graph_base.items().domain] + [self.graph_base.items().domain[x].name for x in self.graph_base.items().domain.getmetas()]
1396            lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()]
1397            commonVars = set(lstNewDomain) & set(lstOrgDomain)
1398
1399            if len(commonVars) > 0:
1400                for var in commonVars:
1401                    orgVar = self.graph_base.items().domain[var]
1402                    mrkVar = items.domain[var]
1403
1404                    if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String:
1405                        self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name))
1406                        self.markInputRadioButton.setEnabled(True)
1407               
1408                        self.setMarkMode(9)
1409             
1410    def setExampleSubset(self, subset):
1411        if self.networkCanvas is None:
1412            return
1413       
1414        self.warning('')
1415        hiddenNodes = []
1416       
1417        if subset is not None:
1418            try:
1419                expected = 1
1420                for row in subset:
1421                    index = int(row['index'].value)
1422                    if expected != index:
1423                        hiddenNodes += range(expected-1, index-1)
1424                        expected = index + 1
1425                    else:
1426                        expected += 1
1427                       
1428                hiddenNodes += range(expected-1, self.graph.number_of_nodes())
1429               
1430                self.networkCanvas.setHiddenNodes(hiddenNodes)
1431            except:
1432                self.warning('"index" attribute does not exist in "items" table.')
1433                   
1434    def showDegreeDistribution(self):
1435        if self.graph is None:
1436            return
1437       
1438        from matplotlib import rcParams
1439        import pylab as p
1440       
1441        x = self.graph.degree().values()
1442        nbins = len(set(x))
1443        if nbins > 500:
1444          bbins = 500
1445       
1446        # the histogram of the data
1447        n, bins, patches = p.hist(x, nbins)
1448       
1449        p.xlabel('Degree')
1450        p.ylabel('No. of nodes')
1451        p.title(r'Degree distribution')
1452       
1453        p.show()
1454       
1455    def setColors(self):
1456        dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
1457        if dlg.exec_():
1458            self.colorSettings = dlg.getColorSchemas()
1459            self.selectedSchemaIndex = dlg.selectedSchemaIndex
1460            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
1461            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
1462           
1463            self.setVertexColor()
1464           
1465    def setEdgeColorPalette(self):
1466        dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
1467        if dlg.exec_():
1468            self.edgeColorSettings = dlg.getColorSchemas()
1469            self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex
1470            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
1471            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
1472           
1473            self.setEdgeColor()
1474   
1475    def createColorDialog(self, colorSettings, selectedSchemaIndex):
1476        c = OWColorPalette.ColorPaletteDlg(self, "Color Palette")
1477        c.createDiscretePalette("discPalette", "Discrete Palette")
1478        c.createContinuousPalette("contPalette", "Continuous Palette")
1479        c.setColorSchemas(colorSettings, selectedSchemaIndex)
1480        return c
1481   
1482    """
1483    Layout Optimization
1484    """
1485   
1486    def graph_layout(self):
1487        if self.graph is None:   #grafa se ni
1488            self.optButton.setChecked(False)
1489            return
1490       
1491        if not self.optButton.isChecked():
1492            self.optButton.setChecked(False)
1493            return
1494       
1495        qApp.processEvents()
1496           
1497        if self.optMethod == 1:
1498            self.layout.random()
1499        elif self.optMethod == 2:
1500            self.graph_layout_fr(False)
1501        elif self.optMethod == 3:
1502            self.graph_layout_fr(True)
1503        elif self.optMethod == 4:
1504            self.graph_layout_fr_radial()
1505        elif self.optMethod == 5:
1506            self.layout.circular_crossing_reduction()
1507        elif self.optMethod == 6:
1508            self.layout.circular_original()
1509        elif self.optMethod == 7:
1510            self.layout.circular_random()
1511        elif self.optMethod == 8:
1512            self.graph_layout_pivot_mds()
1513           
1514        self.optButton.setChecked(False)
1515        self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
1516        self.networkCanvas.updateCanvas()
1517        qApp.processEvents()
1518       
1519    def graph_layout_method(self, method=None):
1520        self.information()
1521        self.stepsSpin.label.setText('Iterations: ')
1522       
1523        if method is not None:
1524            self.optMethod = method
1525           
1526        if str(self.optMethod) == '0':
1527            self.optButton.setEnabled(False)
1528        else:
1529            self.optButton.setEnabled(True)
1530           
1531        if str(self.optMethod) in ['2', '3', '4']:
1532            self.stepsSpin.setEnabled(True)
1533        elif str(self.optMethod) == '8':
1534            self.stepsSpin.label.setText('Pivots: ')
1535            self.stepsSpin.setEnabled(True)
1536           
1537            if self.items_matrix is None:
1538                self.information('Set distance matrix to input signal')
1539                return
1540            if self.graph is None:
1541                self.information('No network found')
1542                return
1543            if self.items_matrix.dim != self.graph.number_of_nodes():
1544                self.error('Distance matrix dimensionality must equal number of vertices')
1545                return
1546        else:
1547            self.stepsSpin.setEnabled(False)
1548            self.optButton.setChecked(True)
1549            self.graph_layout()
1550       
1551    def graph_layout_fr(self, weighted):
1552        if self.graph is None:   #grafa se ni
1553            return
1554             
1555        if not self.optButton.isChecked():
1556          #print "not"
1557          self.stopOptimization = 1
1558          self.optButton.setChecked(False)
1559          self.optButton.setText("Optimize layout")
1560          return
1561       
1562        self.optButton.setText("Stop")
1563        qApp.processEvents()
1564        self.stopOptimization = 0
1565        tolerance = 5
1566        initTemp = 1000
1567        breakpoints = 6
1568        k = int(self.frSteps / breakpoints)
1569        o = self.frSteps % breakpoints
1570        iteration = 0
1571        coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps)
1572
1573        if k > 0:
1574            while iteration < breakpoints:
1575                #print "iteration, initTemp: " + str(initTemp)
1576                if self.stopOptimization:
1577                    return
1578                initTemp = self.layout.fr(k, initTemp, coolFactor, weighted)
1579                iteration += 1
1580                qApp.processEvents()
1581                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
1582                self.networkCanvas.updateCanvas()
1583           
1584            #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp)
1585            if self.stopOptimization:
1586                    return
1587            initTemp = self.layout.fr(o, initTemp, coolFactor, weighted)
1588            qApp.processEvents()
1589            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
1590            self.networkCanvas.updateCanvas()
1591        else:
1592            while iteration < o:
1593                #print "iteration ostanek, initTemp: " + str(initTemp)
1594                if self.stopOptimization:
1595                    return
1596                initTemp = self.layout.fr(1, initTemp, coolFactor, weighted)
1597                iteration += 1
1598                qApp.processEvents()
1599                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph) 
1600                self.networkCanvas.updateCanvas()
1601               
1602        self.optButton.setChecked(False)
1603        self.optButton.setText("Optimize layout")
1604       
1605    def graph_layout_fr_special(self):
1606        if self.graph is None:   #grafa se ni
1607            return
1608       
1609        steps = 100
1610        initTemp = 1000
1611        coolFactor = math.exp(math.log(10.0/10000.0) / steps)
1612        oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())]
1613        #print oldXY
1614        initTemp = self.layout.fr(steps, initTemp, coolFactor)
1615        #print oldXY
1616        self.networkCanvas.updateDataSpecial(oldXY)
1617        self.networkCanvas.replot()
1618               
1619    def graph_layout_fr_radial(self):
1620        if self.graph is None:   #grafa se ni
1621            return
1622       
1623        #print "F-R Radial"
1624        k = 1.13850193174e-008
1625        nodes = self.graph.number_of_nodes()
1626        t = k * nodes * nodes
1627        refreshRate = int(5.0 / t)
1628        if refreshRate <    1: refreshRate = 1;
1629        if refreshRate > 1500: refreshRate = 1500;
1630        #print "refreshRate: " + str(refreshRate)
1631       
1632        tolerance = 5
1633        initTemp = 100
1634        centerNdx = 0
1635       
1636        selection = self.networkCanvas.getSelection()
1637        if len(selection) > 0:
1638            centerNdx = selection[0]
1639           
1640        #print "center ndx: " + str(centerNdx)
1641        initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp)
1642        self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5]
1643        #self.networkCanvas.circles = [100, 200, 300]
1644        self.networkCanvas.updateCanvas()
1645        self.networkCanvas.circles = []
1646           
1647    def graph_layout_pivot_mds(self):
1648        self.information()
1649       
1650        if self.items_matrix is None:
1651            self.information('Set distance matrix to input signal')
1652            return
1653       
1654        if self.graph is None:
1655            self.information('No network found')
1656            return
1657       
1658        if self.items_matrix.dim != self.graph.number_of_nodes():
1659            self.error('Distance matrix dimensionality must equal number of vertices')
1660            return
1661       
1662        self.frSteps = min(self.frSteps, self.items_matrix.dim)
1663        qApp.processEvents()
1664        mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps)
1665        x,y = mds.optimize()
1666        self.layout.coors[0] = x
1667        self.layout.coors[1] = y
1668        self.networkCanvas.updateCanvas()
1669   
1670     
1671    """
1672    Network Visualization
1673    """
1674       
1675    def clickedAttLstBox(self):
1676        if self.graph is None:
1677            return
1678       
1679        self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes])
1680        self.networkCanvas.setLabelText(self.lastLabelColumns)
1681        self.networkCanvas.updateData()
1682        self.networkCanvas.replot()
1683 
1684    def clickedTooltipLstBox(self):
1685        if self.graph is None:
1686            return
1687       
1688        self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes])
1689        self.networkCanvas.setTooltipText(self.lastTooltipColumns)
1690        self.networkCanvas.updateData()
1691        self.networkCanvas.replot()
1692       
1693    def clickedEdgeLabelListBox(self):
1694        if self.graph is None:
1695            return
1696       
1697        self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes])
1698        self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes)
1699        self.networkCanvas.updateData()
1700        self.networkCanvas.replot()
1701
1702    def setVertexColor(self):
1703        if self.graph is None:
1704            return
1705       
1706        self.networkCanvas.set_node_color(self.colorCombo.currentText())
1707        self.lastColorColumn = self.colorCombo.currentText()
1708        self.networkCanvas.updateData()
1709        self.networkCanvas.replot()
1710       
1711    def setEdgeColor(self):
1712        if self.graph is None:
1713            return
1714       
1715        self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText())
1716        self.lastEdgeColorColumn = self.edgeColorCombo.currentText()
1717        self.networkCanvas.updateData()
1718        self.networkCanvas.replot()
1719                 
1720    def setGraphGrid(self):
1721        self.networkCanvas.enableGridY(self.networkCanvasShowGrid)
1722        self.networkCanvas.enableGridX(self.networkCanvasShowGrid)
1723   
1724    def selectAllConnectedNodes(self):
1725        self.networkCanvas.selectConnectedNodes(1000000)
1726               
1727    def setMaxLinkSize(self):
1728        if self.graph is None:
1729            return
1730       
1731        self.networkCanvas.maxEdgeSize = self.maxLinkSize
1732        self.networkCanvas.setEdgesSize()
1733        self.networkCanvas.replot()
1734   
1735    def setVertexSize(self):
1736        if self.graph is None or self.networkCanvas is None:
1737            return
1738       
1739        if self.minVertexSize > self.maxVertexSize:
1740            self.maxVertexSize = self.minVertexSize
1741       
1742        self.networkCanvas.minVertexSize = self.minVertexSize
1743        self.networkCanvas.maxVertexSize = self.maxVertexSize
1744        self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
1745       
1746        if self.vertexSize > 0:
1747            self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize)
1748        else:
1749            self.networkCanvas.setVerticesSize()
1750           
1751        self.networkCanvas.replot()
1752       
1753    def setFontSize(self):
1754        if self.networkCanvas is None:
1755            return
1756       
1757        self.networkCanvas.fontSize = self.fontSize
1758        self.networkCanvas.drawPlotItems()
1759               
1760    def sendReport(self):
1761        self.reportSettings("Graph data",
1762                            [("Number of vertices", self.graph.number_of_nodes()),
1763                             ("Number of edges", self.graph.number_of_edges()),
1764                             ("Vertices per edge", "%.3f" % self.verticesPerEdge),
1765                             ("Edges per vertex", "%.3f" % self.edgesPerVertex),
1766                             ("Diameter", self.diameter),
1767                             ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient)
1768                             ])
1769        if self.color or self.vertexSize or self.markerAttributes or self.edgeColor:
1770            self.reportSettings("Visual settings",
1771                                [self.color and ("Vertex color", self.colorCombo.currentText()),
1772                                 self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""),
1773                                 self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)),
1774                                 self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()),
1775                                ])
1776        self.reportSettings("Optimization",
1777                            [("Method", self.optCombo.currentText()),
1778                             ("Iterations", self.frSteps)])
1779        self.reportSection("Graph")
1780        self.reportImage(self.networkCanvas.saveToFileDirect)       
1781       
1782       
1783if __name__=="__main__":   
1784    a=QApplication(sys.argv)
1785    ow=OWNxExplorer()
1786    ow.show()
1787    root = 'c:\\Users\\miha\\Projects\\res\\Orange\\test\\'
1788    #net = Orange.network.readwrite.read(root + 'airlines_4.net')
1789    #net.set_items(Orange.data.Table(root + 'airlines_4.tab'))
1790    #net = Orange.network.readwrite.read(root + 'K4K2.net')
1791    net = Orange.network.readwrite.read(root + 'K4K4K5_.net')
1792    ow.set_graph(net)
1793    #ow.handleNewSignals()
1794    #import OWNetExplorer
1795    #ow1=OWNetExplorer.OWNetExplorer()
1796    #ow1.show()
1797    #net1 = Orange.network.Network.read(root + 'K4K4K5_.net')
1798    #ow1.setGraph(net1)
1799    a.exec_()
1800    #save settings
1801    ow.saveSettings()
1802    #ow1.saveSettings()
1803   
1804   
1805   
Note: See TracBrowser for help on using the repository browser.