source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorerQwt.py @ 9625:b851627239ef

Revision 9625:b851627239ef, 79.2 KB checked in by Miha Stajdohar <miha.stajdohar@…>, 2 years ago (diff)

Fixed a bug in FragViz on one component only. Crazy, I know.

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