source: orange/Orange/OrangeWidgets/Unsupervised/OWNetExplorer.py @ 10466:b52f4c49e735

Revision 10466:b52f4c49e735, 78.1 KB checked in by Ales Erjavec <ales.erjavec@…>, 2 years ago (diff)

Added unicode filename support for the rest of save/load widget dialogs.

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