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

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

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

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