source: orange/orange/OrangeWidgets/Unsupervised/OWNetExplorer.py @ 9546:2b6cc6f397fe

Revision 9546:2b6cc6f397fe, 78.0 KB checked in by ales_erjavec <ales.erjavec@…>, 2 years ago (diff)

Renamed widget channel names in line with the new naming rules/convention.
Added backwards compatibility in orngDoc loadDocument to enable loading of schemas saved before the change.

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 Itenms", 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        if filename:
1109            fn = ""
1110            head, tail = os.path.splitext(str(filename))
1111            if not tail:
1112                fn = head + ".net"
1113            else:
1114                fn = str(filename)
1115           
1116            self.optimization.graph.save(fn)
1117                   
1118    def sendData(self):
1119        graph = self.networkCanvas.getSelectedGraph()
1120        vertices = self.networkCanvas.getSelectedVertices()
1121       
1122        if graph != None:
1123            if graph.items != None:
1124                self.send("Selected Data", graph.items)
1125            else:
1126                self.send("Selected Data", self.networkCanvas.getSelectedExamples())
1127           
1128            #print "sendData:", self.visualize.graph.items.domain
1129            self.send("Other Data", self.networkCanvas.getUnselectedExamples())   
1130            self.send("Selected Network", graph)
1131        else:
1132            items = self.networkCanvas.getSelectedExamples()
1133            self.send("Selected Data", items)
1134               
1135            items = self.networkCanvas.getUnselectedExamples()
1136            self.send("Other Data", items)
1137       
1138        matrix = None
1139        if self.vertexDistance != None:
1140            matrix = self.vertexDistance.getitems(vertices)
1141
1142        self.send("Selected Distance Matrix", matrix)
1143               
1144    def setCombos(self):
1145        vars = self.optimization.getVars()
1146        edgeVars = self.optimization.getEdgeVars()
1147        lastLabelColumns = self.lastLabelColumns
1148        lastTooltipColumns = self.lastTooltipColumns
1149       
1150        self.clearCombos()
1151       
1152        self.attributes = [(var.name, var.varType) for var in vars]
1153        self.edgeAttributes = [(var.name, var.varType) for var in edgeVars]
1154       
1155        for var in vars:
1156            if var.varType in [orange.VarTypes.Discrete, orange.VarTypes.Continuous]:
1157                self.colorCombo.addItem(self.icons[var.varType], unicode(var.name))
1158               
1159            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:
1160               
1161                value = self.optimization.graph.items[0][var].value
1162               
1163                # can value be a list?
1164                try:
1165                    if type(eval(value)) == type([]):
1166                        self.vertexSizeCombo.addItem(self.icons[var.varType], unicode(var.name))
1167                        continue
1168                except:
1169                    pass
1170               
1171                if len(value.split(',')) > 1:
1172                    self.vertexSizeCombo.addItem(self.icons[var.varType], "num of " + unicode(var.name))
1173               
1174            elif var.varType in [orange.VarTypes.Continuous]:
1175                self.vertexSizeCombo.addItem(self.icons[var.varType], unicode(var.name))
1176
1177            self.nameComponentCombo.addItem(self.icons[var.varType], unicode(var.name))
1178            self.showComponentCombo.addItem(self.icons[var.varType], unicode(var.name))
1179            self.editCombo.addItem(self.icons[var.varType], unicode(var.name))
1180            self.comboAttSelection.addItem(self.icons[var.varType], unicode(var.name))
1181       
1182        for var in edgeVars:
1183            if var.varType in [orange.VarTypes.Discrete, orange.VarTypes.Continuous]:
1184                self.edgeColorCombo.addItem(self.icons[var.varType], unicode(var.name))
1185               
1186        for i in range(self.vertexSizeCombo.count()):
1187            if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i):
1188                self.vertexSize = i
1189                break
1190           
1191        for i in range(self.colorCombo.count()):
1192            if self.lastColorColumn == self.colorCombo.itemText(i):
1193                self.color = i
1194                break
1195
1196        for i in range(self.attListBox.count()):
1197            if str(self.attListBox.item(i).text()) in lastLabelColumns:
1198                self.attListBox.item(i).setSelected(1)
1199               
1200        for i in range(self.tooltipListBox.count()):
1201            if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns:
1202                self.tooltipListBox.item(i).setSelected(1)
1203           
1204        self.lastLabelColumns = lastLabelColumns
1205        self.lastTooltipColumns = lastTooltipColumns
1206       
1207    def clearCombos(self):
1208        self.attributes = []
1209        self.edgeAttributes = []
1210       
1211        self.colorCombo.clear()
1212        self.vertexSizeCombo.clear()
1213        self.nameComponentCombo.clear()
1214        self.showComponentCombo.clear()
1215        self.edgeColorCombo.clear()
1216        self.editCombo.clear()
1217        self.comboAttSelection.clear()
1218       
1219        self.colorCombo.addItem("(same color)")
1220        self.edgeColorCombo.addItem("(same color)")
1221        self.vertexSizeCombo.addItem("(same size)")
1222        self.nameComponentCombo.addItem("Select attribute")
1223        self.showComponentCombo.addItem("Select attribute")
1224        self.editCombo.addItem("Select attribute")
1225        self.comboAttSelection.addItem("Select attribute")
1226     
1227    def setGraph(self, graph):     
1228        if graph is None:
1229            self.optimization = None
1230            self.networkCanvas.addVisualizer(self.optimization)
1231            self.clearCombos()
1232            return
1233       
1234        #print "OWNetwork/setGraph: new visualizer..."
1235        self.optimization = orngNetwork.NetworkOptimization(graph)
1236        self.networkCanvas.addVisualizer(self.optimization)
1237        self.networkCanvas.renderAntialiased = self.renderAntialiased
1238        self.networkCanvas.showEdgeLabels = self.showEdgeLabels
1239        self.networkCanvas.minVertexSize = self.minVertexSize
1240        self.networkCanvas.maxVertexSize = self.maxVertexSize
1241        self.networkCanvas.maxEdgeSize = self.maxLinkSize
1242        self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
1243        self.lastColorColumn = self.colorCombo.currentText()
1244        self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth
1245        self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
1246       
1247       
1248
1249        #for i in range(graph.nVertices):
1250        #    print "x:", graph.coors[0][i], " y:", graph.coors[1][i]
1251
1252        self.nVertices = graph.nVertices
1253        self.nShown = graph.nVertices
1254       
1255        if graph.directed:
1256            self.nEdges = len(graph.getEdges())
1257        else:
1258            self.nEdges = len(graph.getEdges()) / 2
1259       
1260        if self.nEdges > 0:
1261            self.verticesPerEdge = float(self.nVertices) / float(self.nEdges)
1262        else:
1263            self.verticesPerEdge = 0
1264           
1265        if self.nVertices > 0:
1266            self.edgesPerVertex = float(self.nEdges) / float(self.nVertices)
1267        else:
1268            self.edgesPerVertex = 0
1269           
1270        self.diameter = graph.getDiameter()
1271        self.clustering_coefficient = graph.getClusteringCoefficient() * 100
1272       
1273        self.setCombos()
1274       
1275        lastNameComponentAttributeFound = False
1276        for i in range(self.nameComponentCombo.count()):
1277            if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i):
1278                lastNameComponentAttributeFound = True
1279                self.nameComponentAttribute = i
1280                self.nameComponents()
1281                self.showComponentAttribute = self.showComponentCombo.count() - 1
1282                self.showComponents()
1283                break
1284           
1285        if not lastNameComponentAttributeFound:
1286            self.lastNameComponentAttribute = ''
1287       
1288        self.showComponentAttribute = None
1289
1290        k = 1.13850193174e-008
1291        nodes = self.optimization.nVertices()
1292        t = k * nodes * nodes
1293        self.frSteps = int(5.0 / t)
1294        if self.frSteps <   1: self.frSteps = 1;
1295        if self.frSteps > 1500: self.frSteps = 1500;
1296       
1297        self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly
1298        self.networkCanvas.showWeights = self.showWeights
1299        self.networkCanvas.showIndexes = self.showIndexes
1300        # if graph is large, set random layout, min vertex size, min edge size
1301        if self.frSteps < 10:
1302            self.renderAntialiased = 0
1303            self.minVertexSize = 5
1304            self.maxVertexSize = 5
1305            self.maxLinkSize = 1
1306            self.optMethod = 0
1307            self.setOptMethod()           
1308           
1309        if self.vertexSize > 0:
1310            self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize)
1311        else:
1312            self.networkCanvas.setVerticesSize()
1313           
1314        self.setVertexColor()
1315        self.setEdgeColor()
1316           
1317        self.networkCanvas.setEdgesSize()
1318        self.clickedAttLstBox()
1319        self.clickedTooltipLstBox()
1320        self.clickedEdgeLabelListBox()
1321       
1322        self.optButton.setChecked(1)
1323        self.optLayout()       
1324        self.information(0)
1325        #self.controlArea.setEnabled(True)
1326        self.updateCanvas()
1327       
1328    def setItems(self, items=None):
1329        self.error('')
1330       
1331        if self.optimization is None or self.optimization.graph is None or items is None:
1332            return
1333       
1334        if len(items) != self.optimization.graph.nVertices:
1335            self.error('ExampleTable items must have one example for each vertex.')
1336            return
1337       
1338        self.optimization.graph.setattr("items", items)
1339       
1340        self.setVertexSize()
1341        self.showIndexLabels()
1342        self.showWeightLabels()
1343        self.showEdgeLabelsClick()
1344       
1345        self.setCombos()
1346        self.networkCanvas.updateData()
1347       
1348    def setMarkInput(self):
1349        var = str(self.markInputCombo.currentText())
1350        #print 'combo:',self.markInputCombo.currentText()
1351        if self.markInputItems != None and len(self.markInputItems) > 0:
1352            values = [str(x[var]).strip().upper() for x in self.markInputItems]
1353            toMark = [i for (i,x) in enumerate(self.optimization.graph.items) if str(x[var]).strip().upper() in values]
1354            #print "mark:", toMark
1355            self.networkCanvas.setMarkedVertices(list(toMark))
1356            self.networkCanvas.replot()
1357           
1358        else:
1359            self.networkCanvas.setMarkedVertices([])
1360            self.networkCanvas.replot()           
1361   
1362    def markItems(self, items):
1363        self.markInputCombo.clear()
1364        self.markInputRadioButton.setEnabled(False)
1365        self.markInputItems = items
1366       
1367        if self.optimization is None or self.optimization.graph is None or self.optimization.graph.items is None or items is None:
1368            return
1369       
1370        if len(items) > 0:
1371            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()]
1372            lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()]
1373            commonVars = set(lstNewDomain) & set(lstOrgDomain)
1374
1375            if len(commonVars) > 0:
1376                for var in commonVars:
1377                    orgVar = self.optimization.graph.items.domain[var]
1378                    mrkVar = items.domain[var]
1379
1380                    if orgVar.varType == mrkVar.varType and orgVar.varType == orange.VarTypes.String:
1381                        self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name))
1382                        self.markInputRadioButton.setEnabled(True)
1383               
1384                        self.setMarkMode(9)
1385             
1386    def setExampleSubset(self, subset):
1387        if self.networkCanvas is None:
1388            return
1389       
1390        self.warning('')
1391        hiddenNodes = []
1392       
1393        if subset != None:
1394            try:
1395                expected = 1
1396                for row in subset:
1397                    index = int(row['index'].value)
1398                    if expected != index:
1399                        hiddenNodes += range(expected-1, index-1)
1400                        expected = index + 1
1401                    else:
1402                        expected += 1
1403                       
1404                hiddenNodes += range(expected-1, self.networkCanvas.nVertices)
1405               
1406                self.networkCanvas.setHiddenNodes(hiddenNodes)
1407            except:
1408                self.warning('"index" attribute does not exist in "items" table.')
1409                           
1410    def updateCanvas(self):
1411        # if network exists
1412        if self.optimization != None:
1413            self.networkCanvas.updateCanvas()
1414
1415    def showDegreeDistribution(self):
1416        if self.optimization is None:
1417            return
1418       
1419        from matplotlib import rcParams
1420        import pylab as p
1421       
1422        x = self.optimization.graph.getDegrees()
1423        nbins = len(set(x))
1424        if nbins > 500:
1425          bbins = 500
1426        #print len(x)
1427        print x
1428        # the histogram of the data
1429        n, bins, patches = p.hist(x, nbins)
1430       
1431        p.xlabel('Degree')
1432        p.ylabel('No. of nodes')
1433        p.title(r'Degree distribution')
1434       
1435        p.show()
1436       
1437    def setColors(self):
1438        dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
1439        if dlg.exec_():
1440            self.colorSettings = dlg.getColorSchemas()
1441            self.selectedSchemaIndex = dlg.selectedSchemaIndex
1442            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
1443            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
1444           
1445            self.setVertexColor()
1446           
1447    def setEdgeColorPalette(self):
1448        dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
1449        if dlg.exec_():
1450            self.edgeColorSettings = dlg.getColorSchemas()
1451            self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex
1452            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
1453            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
1454           
1455            self.setEdgeColor()
1456   
1457    def createColorDialog(self, colorSettings, selectedSchemaIndex):
1458        c = OWColorPalette.ColorPaletteDlg(self, "Color Palette")
1459        c.createDiscretePalette("discPalette", "Discrete Palette")
1460        c.createContinuousPalette("contPalette", "Continuous Palette")
1461        c.setColorSchemas(colorSettings, selectedSchemaIndex)
1462        return c
1463    """
1464    Layout Optimization
1465    """
1466    def optLayout(self):
1467        if self.optimization is None:   #grafa se ni
1468            self.optButton.setChecked(False)
1469            return
1470       
1471        if not self.optButton.isChecked():
1472            self.optButton.setChecked(False)
1473            return
1474       
1475        qApp.processEvents()
1476           
1477        if self.optMethod == 1:
1478            self.random()
1479        elif self.optMethod == 2:
1480            self.fr(False)
1481        elif self.optMethod == 3:
1482            self.fr(True)
1483        elif self.optMethod == 4:
1484            self.frRadial()
1485        elif self.optMethod == 5:
1486            self.circularCrossingReduction()
1487        elif self.optMethod == 6:
1488            self.circularOriginal()
1489        elif self.optMethod == 7:
1490            self.circularRandom()
1491        elif self.optMethod == 8:
1492            self.pivotMDS()
1493           
1494        self.optButton.setChecked(False)
1495        qApp.processEvents()
1496       
1497    def setOptMethod(self, method=None):
1498        self.stepsSpin.label.setText('Iterations: ')
1499       
1500        if method != None:
1501            self.optMethod = method
1502           
1503        if str(self.optMethod) == '0':
1504            self.optButton.setEnabled(False)
1505        else:
1506            self.optButton.setEnabled(True)
1507           
1508        if str(self.optMethod) in ['2', '3', '4']:
1509            self.stepsSpin.setEnabled(True)
1510        elif str(self.optMethod) == '8':
1511            self.stepsSpin.label.setText('Pivots: ')
1512            self.stepsSpin.setEnabled(True)
1513        else:
1514            self.stepsSpin.setEnabled(False)
1515            self.optButton.setChecked(True)
1516            self.optLayout()
1517
1518    def random(self):
1519        #print "OWNetwork/random.."
1520        if self.optimization is None:   #grafa se ni
1521            return   
1522           
1523        self.optimization.random()
1524        #print self.optimization.coors
1525        #print "OWNetwork/random: updating canvas..."
1526        self.updateCanvas();
1527       
1528    def fr(self, weighted):
1529        if self.optimization is None:   #grafa se ni
1530            return
1531             
1532        if not self.optButton.isChecked():
1533          #print "not"
1534          self.stopOptimization = 1
1535          self.optButton.setChecked(False)
1536          self.optButton.setText("Optimize layout")
1537          return
1538       
1539        self.optButton.setText("Stop")
1540        qApp.processEvents()
1541        self.stopOptimization = 0
1542        tolerance = 5
1543        initTemp = 1000
1544        breakpoints = 6
1545        k = int(self.frSteps / breakpoints)
1546        o = self.frSteps % breakpoints
1547        iteration = 0
1548        coolFactor = math.exp(math.log(10.0/10000.0) / self.frSteps)
1549
1550        if k > 0:
1551            while iteration < breakpoints:
1552                #print "iteration, initTemp: " + str(initTemp)
1553                if self.stopOptimization:
1554                    return
1555                initTemp = self.optimization.fruchtermanReingold(k, initTemp, coolFactor, self.networkCanvas.hiddenNodes, weighted)
1556                iteration += 1
1557                qApp.processEvents()
1558                self.updateCanvas()
1559           
1560            #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp)
1561            if self.stopOptimization:
1562                    return
1563            initTemp = self.optimization.fruchtermanReingold(o, initTemp, coolFactor, self.networkCanvas.hiddenNodes, weighted)
1564            qApp.processEvents()
1565            self.updateCanvas()
1566        else:
1567            while iteration < o:
1568                #print "iteration ostanek, initTemp: " + str(initTemp)
1569                if self.stopOptimization:
1570                    return
1571                initTemp = self.optimization.fruchtermanReingold(1, initTemp, coolFactor, self.networkCanvas.hiddenNodes, weighted)
1572                iteration += 1
1573                qApp.processEvents()
1574                self.updateCanvas()
1575               
1576        self.optButton.setChecked(False)
1577        self.optButton.setText("Optimize layout")
1578       
1579    def frSpecial(self):
1580        if self.optimization is None:   #grafa se ni
1581            return
1582       
1583        steps = 100
1584        initTemp = 1000
1585        coolFactor = math.exp(math.log(10.0/10000.0) / steps)
1586        oldXY = []
1587        for rec in self.optimization.network.coors:
1588            oldXY.append([rec[0], rec[1]])
1589        #print oldXY
1590        initTemp = self.optimization.fruchtermanReingold(steps, initTemp, coolFactor, self.networkCanvas.hiddenNodes)
1591        #print oldXY
1592        self.networkCanvas.updateDataSpecial(oldXY)
1593        self.networkCanvas.replot()
1594               
1595    def frRadial(self):
1596        if self.optimization is None:   #grafa se ni
1597            return
1598       
1599        #print "F-R Radial"
1600        k = 1.13850193174e-008
1601        nodes = self.optimization.nVertices()
1602        t = k * nodes * nodes
1603        refreshRate = int(5.0 / t)
1604        if refreshRate <    1: refreshRate = 1;
1605        if refreshRate > 1500: refreshRate = 1500;
1606        #print "refreshRate: " + str(refreshRate)
1607       
1608        tolerance = 5
1609        initTemp = 100
1610        centerNdx = 0
1611       
1612        selection = self.networkCanvas.getSelection()
1613        if len(selection) > 0:
1614            centerNdx = selection[0]
1615           
1616        #print "center ndx: " + str(centerNdx)
1617        initTemp = self.optimization.radialFruchtermanReingold(centerNdx, refreshRate, initTemp)
1618        self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5]
1619        #self.networkCanvas.circles = [100, 200, 300]
1620        self.updateCanvas()
1621        self.networkCanvas.circles = []
1622       
1623    def circularOriginal(self):
1624        #print "Circular Original"
1625        if self.optimization != None:
1626            self.optimization.circularOriginal()
1627            self.updateCanvas()
1628           
1629    def circularRandom(self):
1630        #print "Circular Random"
1631        if self.optimization != None:
1632            self.optimization.circularRandom()
1633            self.updateCanvas()
1634
1635    def circularCrossingReduction(self):
1636        #print "Circular Crossing Reduction"
1637        if self.optimization != None:
1638            self.optimization.circularCrossingReduction()
1639            self.updateCanvas()
1640           
1641    def pivotMDS(self):
1642        if self.vertexDistance is None:
1643            self.information('Set distance matrix to input signal')
1644            return
1645       
1646        if self.optimization is None:
1647            self.information('No network found')
1648            return
1649       
1650        if self.vertexDistance.dim != self.optimization.graph.nVertices:
1651            self.error('Distance matrix dimensionality must equal number of vertices')
1652            return
1653       
1654        self.frSteps = min(self.frSteps, self.vertexDistance.dim)
1655        qApp.processEvents()
1656        mds = orngMDS.PivotMDS(self.vertexDistance, self.frSteps)
1657        x,y = mds.optimize()
1658        self.optimization.graph.coors[0] = x
1659        self.optimization.graph.coors[1] = y
1660        self.updateCanvas()
1661   
1662     
1663    """
1664    Network Visualization
1665    """
1666       
1667    def clickedAttLstBox(self):
1668        if self.optimization is None:
1669            return
1670       
1671        self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes])
1672        self.networkCanvas.setLabelText(self.lastLabelColumns)
1673        self.networkCanvas.updateData()
1674        self.networkCanvas.replot()
1675 
1676    def clickedTooltipLstBox(self):
1677        if self.optimization is None:
1678            return
1679       
1680        self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes])
1681        self.networkCanvas.setTooltipText(self.lastTooltipColumns)
1682        self.networkCanvas.updateData()
1683        self.networkCanvas.replot()
1684       
1685    def clickedEdgeLabelListBox(self):
1686        if self.optimization is None:
1687            return
1688       
1689        self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes])
1690        self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes)
1691        self.networkCanvas.updateData()
1692        self.networkCanvas.replot()
1693
1694    def setVertexColor(self):
1695        if self.optimization is None:
1696            return
1697       
1698        self.networkCanvas.setVertexColor(self.colorCombo.currentText())
1699        self.lastColorColumn = self.colorCombo.currentText()
1700        self.networkCanvas.updateData()
1701        self.networkCanvas.replot()
1702       
1703    def setEdgeColor(self):
1704        if self.optimization is None:
1705            return
1706       
1707        self.networkCanvas.setEdgeColor(self.edgeColorCombo.currentText())
1708        self.lastEdgeColorColumn = self.edgeColorCombo.currentText()
1709        self.networkCanvas.updateData()
1710        self.networkCanvas.replot()
1711                 
1712    def setGraphGrid(self):
1713        self.networkCanvas.enableGridY(self.networkCanvasShowGrid)
1714        self.networkCanvas.enableGridX(self.networkCanvasShowGrid)
1715   
1716    def selectAllConnectedNodes(self):
1717        self.networkCanvas.selectConnectedNodes(1000000)
1718       
1719    def setShowMissingValues(self):
1720        self.networkCanvas.showMissingValues = self.showMissingValues
1721        self.networkCanvas.updateData()
1722        self.networkCanvas.replot()
1723       
1724    def setMaxLinkSize(self):
1725        if self.optimization is None:
1726            return
1727       
1728        self.networkCanvas.maxEdgeSize = self.maxLinkSize
1729        self.networkCanvas.setEdgesSize()
1730        self.networkCanvas.replot()
1731   
1732    def setVertexSize(self):
1733        if self.optimization is None or self.networkCanvas is None:
1734            return
1735       
1736        if self.minVertexSize > self.maxVertexSize:
1737            self.maxVertexSize = self.minVertexSize
1738       
1739        self.networkCanvas.minVertexSize = self.minVertexSize
1740        self.networkCanvas.maxVertexSize = self.maxVertexSize
1741        self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
1742       
1743        if self.vertexSize > 0:
1744            self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize)
1745        else:
1746            self.networkCanvas.setVerticesSize()
1747           
1748        self.networkCanvas.replot()
1749       
1750    def setFontSize(self):
1751        if self.networkCanvas is None:
1752            return
1753       
1754        self.networkCanvas.fontSize = self.fontSize
1755        self.networkCanvas.drawPlotItems()
1756       
1757    def setRenderAntialiased(self):
1758        self.networkCanvas.renderAntialiased = self.renderAntialiased
1759        self.networkCanvas.updateData()
1760        self.networkCanvas.replot()
1761       
1762    def sendReport(self):
1763        self.reportSettings("Graph data",
1764                            [("Number of vertices", self.nVertices),
1765                             ("Number of edges", self.nEdges),
1766                             ("Vertices per edge", "%.3f" % self.verticesPerEdge),
1767                             ("Edges per vertex", "%.3f" % self.edgesPerVertex),
1768                             ("Diameter", self.diameter),
1769                             ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient)
1770                             ])
1771        if self.color or self.vertexSize or self.markerAttributes or self.edgeColor:
1772            self.reportSettings("Visual settings",
1773                                [self.color and ("Vertex color", self.colorCombo.currentText()),
1774                                 self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""),
1775                                 self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)),
1776                                 self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()),
1777                                ])
1778        self.reportSettings("Optimization",
1779                            [("Method", self.optCombo.currentText()),
1780                             ("Iterations", self.frSteps)])
1781        self.reportSection("Graph")
1782        self.reportImage(self.networkCanvas.saveToFileDirect)       
1783       
1784       
1785if __name__=="__main__":   
1786    appl = QApplication(sys.argv)
1787    ow = OWNetExplorer()
1788    ow.show()
1789    appl.exec_()
1790   
Note: See TracBrowser for help on using the repository browser.