source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorerQwt.py @ 9624:2bb996b0beed

Revision 9624:2bb996b0beed, 79.1 KB checked in by Miha Stajdohar <miha.stajdohar@…>, 2 years ago (diff)

Moved old NetExplorer class to seperate file.

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