source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 8081:922aa219574d

Revision 8081:922aa219574d, 79.2 KB checked in by miha <miha.stajdohar@…>, 23 months ago (diff)

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