source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 9622:3f0d63a65934

Revision 9622:3f0d63a65934, 157.6 KB checked in by Miha Stajdohar <miha.stajdohar@…>, 2 years ago (diff)

Fixed signal names.

Line 
1"""
2<name>Net Explorer</name>
3<description>Orange widget for network exploration.</description>
4<icon>icons/Network.png</icon>
5<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact> 
6<priority>6421</priorbity>
7"""
8import math
9import operator
10import statc
11import time
12
13import Orange
14import OWGUI
15import OWColorPalette
16import OWToolbars
17import orngMDS
18
19from OWWidget import *
20from operator import itemgetter
21
22try:
23    from OWNxCanvasQt import *
24
25    class OWNxExplorer(OWWidget):
26
27        settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage",
28        "maxLinkSize", "minVertexSize", "maxVertexSize", "networkCanvas.animate_plot",
29        "networkCanvas.animate_points", "networkCanvas.antialias_plot",
30        "networkCanvas.antialias_points", "networkCanvas.antialias_lines",
31        "networkCanvas.auto_adjust_performance", "invertSize", "optMethod",
32        "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices", "networkCanvas.show_weights",
33        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns",
34        "showWeights", "showEdgeLabels", "colorSettings",
35        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex",
36        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage",
37        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism", "showTextMiningInfo",
38        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth",
39        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",
40        "networkCanvas.trim_label_words", "opt_from_curr", "networkCanvas.explore_distances",
41        "networkCanvas.show_component_distances", "fontWeight", "networkCanvas.state",
42        "networkCanvas.selection_behavior"]
43
44        def __init__(self, parent=None, signalManager=None, name='Net Explorer',
45                     NetworkCanvas=OWNxCanvas):
46            OWWidget.__init__(self, parent, signalManager, name, noReport=True)
47            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])}
48            self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default),
49                           ("Items", Orange.data.Table, self.set_items),
50                           ("Item Subset", Orange.data.Table, self.mark_items),
51                           ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix),
52                           ("Net View", Orange.network.NxView, self.set_network_view)]
53
54            self.outputs = [("Selected Network", Orange.network.Graph),
55                            ("Distance Matrix", Orange.core.SymMatrix),
56                            ("Marked Items", Orange.data.Table),
57                            ("Selected Items", Orange.data.Table),
58                            ("Other Items", Orange.data.Table)]
59                            #("Attribute Selection List", AttributeList)]
60
61            self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer")
62
63            self.markerAttributes = []
64            self.tooltipAttributes = []
65            self.edgeLabelAttributes = []
66            self.attributes = []
67            self.edgeAttributes = []
68            self.autoSendSelection = False
69            self.graphShowGrid = 1  # show gridlines in the graph
70            self.markNConnections = 2
71            self.markNumber = 0
72            self.markProportion = 0
73            self.markSearchString = ""
74            self.markDistance = 2
75            self.frSteps = 1
76            self.hubs = 0
77            self.color = 0
78            self.edgeColor = 0
79            self.vertexSize = 0
80            self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = 0
81            self.optimizeWhat = 1
82            self.maxLinkSize = 3
83            self.maxVertexSize = 7
84            self.minVertexSize = 12
85            self.labelsOnMarkedOnly = 0
86            self.invertSize = 0
87            self.optMethod = 0
88            self.lastVertexSizeColumn = ''
89            self.lastColorColumn = ''
90            self.lastNameComponentAttribute = ''
91            self.lastLabelColumns = set()
92            self.lastTooltipColumns = set()
93            self.showWeights = 0
94            self.showEdgeLabels = 0
95            self.colorSettings = None
96            self.selectedSchemaIndex = 0
97            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)])]])]
98            self.selectedEdgeSchemaIndex = 0
99            self.items_matrix = None
100            self.showDistances = 0
101            self.showMissingValues = 0
102            self.fontSize = 12
103            self.fontWeight = 1
104            self.mdsTorgerson = 0
105            self.mdsAvgLinkage = 1
106            self.mdsSteps = 10000
107            self.mdsRefresh = 50
108            self.mdsStressDelta = 0.0000001
109            self.organism = 'goa_human'
110            self.showTextMiningInfo = 0
111            self.toolbarSelection = 0
112            self.minComponentEdgeWidth = 10
113            self.maxComponentEdgeWidth = 70
114            self.mdsFromCurrentPos = 0
115            self.tabIndex = 0
116            self.number_of_nodes_label = -1
117            self.number_of_edges_label = -1
118            self.opt_from_curr = False
119
120            self.checkSendMarkedNodes = True
121            self.checkSendSelectedNodes = True
122            self.explore_distances = False
123
124            self.loadSettings()
125
126            self._network_view = None
127            self.graph = None
128            self.graph_base = None
129            self.markInputItems = None
130
131            # if optimization method is set to FragViz, set it to FR
132            if self.optMethod == 9:
133                self.optMethod = 3
134
135            self.networkCanvas.showMissingValues = self.showMissingValues
136            self.mainArea.layout().addWidget(self.networkCanvas)
137
138            self.networkCanvas.maxLinkSize = self.maxLinkSize
139
140            self.tabs = OWGUI.tabWidget(self.controlArea)
141
142            self.verticesTab = OWGUI.createTabPage(self.tabs, "Nodes")
143            self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges")
144            self.markTab = OWGUI.createTabPage(self.tabs, "Mark")
145            self.infoTab = OWGUI.createTabPage(self.tabs, "Info")
146            self.performanceTab = OWGUI.createTabPage(self.tabs, "Performance")
147
148            self.tabs.setCurrentIndex(self.tabIndex)
149            self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index))
150
151            self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False)
152
153            self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method)
154            self.optCombo.addItem("No optimization")
155            self.optCombo.addItem("Random")
156            self.optCombo.addItem("Fruchterman Reingold")
157            self.optCombo.addItem("Fruchterman Reingold Weighted")
158            self.optCombo.addItem("Fruchterman Reingold Radial")
159            self.optCombo.addItem("Circular Crossing Reduction")
160            self.optCombo.addItem("Circular Original")
161            self.optCombo.addItem("Circular Random")
162            self.optCombo.addItem("FragViz")
163            self.optCombo.addItem("MDS")
164            self.optCombo.addItem("Pivot MDS")
165            self.optCombo.setCurrentIndex(self.optMethod)
166            self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ")
167            self.cb_opt_from_curr = OWGUI.checkBox(self.optimizeBox, self, "opt_from_curr", label="Optimize from current positions")
168            self.cb_opt_from_curr.setEnabled(False)
169            self.stepsSpin.setEnabled(False)
170
171            self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1)
172
173            colorBox = OWGUI.widgetBox(self.verticesTab, "Node color attribute", orientation="horizontal", addSpace=False)
174            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.set_node_colors)
175            self.colorCombo.addItem("(same color)")
176            OWGUI.button(colorBox, self, "palette", self._set_colors, tooltip="Set node color palette", width=60, debuggingEnabled=0)
177
178            ib = OWGUI.widgetBox(self.verticesTab, "Node size attribute", orientation="vertical", addSpace=False)
179            hb = OWGUI.widgetBox(ib, orientation="horizontal", addSpace=False)
180            OWGUI.checkBox(hb, self, "invertSize", "Invert size", callback=self.set_node_sizes)
181            OWGUI.spin(hb, self, "minVertexSize", 5, 200, 1, label="Min:", callback=self.set_node_sizes)
182            OWGUI.spin(hb, self, "maxVertexSize", 5, 200, 1, label="Max:", callback=self.set_node_sizes)
183            self.vertexSizeCombo = OWGUI.comboBox(ib, self, "vertexSize", callback=self.set_node_sizes)
184            self.vertexSizeCombo.addItem("(none)")
185
186            self.attBox = OWGUI.widgetBox(self.verticesTab, "Node labels | tooltips", orientation="vertical", addSpace=False)
187            hb = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace=False)
188            self.attListBox = OWGUI.listBox(hb, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_att_lstbox)
189            self.tooltipListBox = OWGUI.listBox(hb, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_tooltip_lstbox)
190            OWGUI.spin(self.attBox, self, "networkCanvas.trim_label_words", 0, 5, 1, label='Trim label words to', callback=self._clicked_att_lstbox)
191
192            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical")
193            OWGUI.checkBox(ib, self, 'networkCanvas.show_weights', 'Show weights', callback=self.networkCanvas.set_edge_labels)
194            #OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels)))
195            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback=self.set_edge_sizes)
196            self.cb_show_distances = OWGUI.checkBox(ib, self, 'explore_distances', 'Explore node distances', callback=self.set_explore_distances, disabled=1)
197            self.cb_show_component_distances = OWGUI.checkBox(ib, self, 'networkCanvas.show_component_distances', 'Show component distances', callback=self.networkCanvas.set_show_component_distances, disabled=1)
198
199            colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace=False)
200            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.set_edge_colors)
201            self.edgeColorCombo.addItem("(same color)")
202            OWGUI.button(colorBox, self, "palette", self._set_edge_color_palette, tooltip="Set edge color palette", width=60, debuggingEnabled=0)
203
204            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace=False)
205            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self._clicked_edge_label_listbox)
206            #self.edgeLabelBox.setEnabled(False)
207
208            ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical")
209            OWGUI.checkBox(ib, self, 'networkCanvas.show_indices', 'Show indices', callback=self.networkCanvas.set_node_labels)
210            OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked nodes only', callback=(lambda: self.networkCanvas.set_labels_on_marked(self.labelsOnMarkedOnly)))
211            OWGUI.spin(ib, self, "fontSize", 4, 30, 1, label="Font size:", callback=self.set_font)
212            self.comboFontWeight = OWGUI.comboBox(ib, self, "fontWeight", label='Font weight:', orientation='horizontal', callback=self.set_font)
213            self.comboFontWeight.addItem("Normal")
214            self.comboFontWeight.addItem("Bold")
215            self.comboFontWeight.setCurrentIndex(self.fontWeight)
216
217            ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical")
218            OWGUI.label(ib, self, "Nodes (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)")
219            OWGUI.label(ib, self, "Selected: %(nSelected)i, marked: %(nMarked)i")
220
221            ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Mark", callback=self.set_mark_mode)
222            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback=self.set_mark_mode)
223            OWGUI.appendRadioButton(ribg, self, "hubs", "Search", callback=self.set_mark_mode)
224            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self._set_search_string_timer, callbackOnType=True)
225            self.searchStringTimer = QTimer(self)
226            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.set_mark_mode)
227
228            OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbors of focused", callback=self.set_mark_mode)
229            OWGUI.appendRadioButton(ribg, self, "hubs", "Neighbours of selected", callback=self.set_mark_mode)
230            ib = OWGUI.indentedBox(ribg, orientation=0)
231            self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.set_mark_mode(h)))
232            #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True)
233            OWGUI.widgetLabel(ribg, "Mark nodes with ...")
234            OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback=self.set_mark_mode)
235            OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback=self.set_mark_mode)
236            self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.set_mark_mode(h)))
237            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback=self.set_mark_mode)
238            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback=self.set_mark_mode)
239            OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback=self.set_mark_mode)
240            ib = OWGUI.indentedBox(ribg)
241            self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of nodes:", callback=(lambda h=8: self.set_mark_mode(h)))
242            OWGUI.widgetLabel(ib, "(More nodes are marked in case of ties)")
243            self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark nodes given in the input signal", callback=self.set_mark_mode)
244            ib = OWGUI.indentedBox(ribg)
245            self.markInput = 0
246            self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.set_mark_mode(h)))
247            self.markInputRadioButton.setEnabled(False)
248
249            #ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical")
250            #self.checkSendMarkedNodes = True
251            #OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked nodes', callback = self.send_marked_nodes, disabled=0)
252
253            self.toolbar = OWGUI.widgetBox(self.controlArea, orientation='horizontal')
254            prevstate = self.networkCanvas.state
255            prevselbeh = self.networkCanvas.selection_behavior
256            G = self.networkCanvas.gui
257            self.zoomSelectToolbar = G.zoom_select_toolbar(self.toolbar, nomargin=True, buttons=
258                G.default_zoom_select_buttons +
259                [
260                    G.Spacing,
261                    ("buttonM2S", "Marked to selection", None, None, "marked_to_selected", 'Dlg_Mark2Sel'),
262                    ("buttonS2M", "Selection to marked", None, None, "selected_to_marked", 'Dlg_Sel2Mark'),
263                    ("buttonHSEL", "Hide selection", None, None, "hide_selection", 'Dlg_HideSelection'),
264                    ("buttonSSEL", "Show all nodes", None, None, "show_selection", 'Dlg_ShowSelection'),
265                    #("buttonUN", "Hide unselected", None, None, "hideUnSelectedVertices", 'Dlg_SelectedNodes'),
266                    #("buttonSW", "Show all nodes", None, None, "showAllVertices", 'Dlg_clear'),
267                ])
268            self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_data)
269            self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_marked_nodes)
270            self.zoomSelectToolbar.buttons[("buttonHSEL", "Hide selection", None, None, "hide_selection", 'Dlg_HideSelection')].clicked.connect(self.hide_selection)
271            self.zoomSelectToolbar.buttons[("buttonSSEL", "Show all nodes", None, None, "show_selection", 'Dlg_ShowSelection')].clicked.connect(self.show_selection)
272            #self.zoomSelectToolbar.buttons[G.SendSelection].hide()
273            self.zoomSelectToolbar.select_selection_behaviour(prevselbeh)
274            self.zoomSelectToolbar.select_state(prevstate)
275
276            ib = OWGUI.widgetBox(self.infoTab, "General")
277            OWGUI.label(ib, self, "Number of nodes: %(number_of_nodes_label)i")
278            OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i")
279            OWGUI.label(ib, self, "Nodes per edge: %(verticesPerEdge).2f")
280            OWGUI.label(ib, self, "Edges per node: %(edgesPerVertex).2f")
281
282            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal")
283
284            OWGUI.button(ib, self, "Save net", callback=self.save_network, debuggingEnabled=False)
285            OWGUI.button(ib, self, "Save img", callback=self.networkCanvas.saveToFile, debuggingEnabled=False)
286            self.reportButton = OWGUI.button(ib, self, "&Report", self.reportAndFinish, debuggingEnabled=0)
287            self.reportButton.setAutoDefault(0)
288
289            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering)
290            ib = OWGUI.widgetBox(self.infoTab, "Edit")
291            self.editAttribute = 0
292            self.editCombo = OWGUI.comboBox(ib, self, "editAttribute", label="Edit attribute:", orientation="horizontal")
293            self.editCombo.addItem("Select attribute")
294            self.editValue = ''
295            hb = OWGUI.widgetBox(ib, orientation="horizontal")
296            OWGUI.lineEdit(hb, self, "editValue", "Value:", orientation='horizontal')
297            OWGUI.button(hb, self, "Set", callback=self.edit)
298
299            ib = OWGUI.widgetBox(self.infoTab, "Prototype")
300            ib.setVisible(True)
301
302            OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal')
303
304            self.nameComponentAttribute = 0
305            self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal")
306            self.nameComponentCombo.addItem("Select attribute")
307
308            self.showComponentAttribute = 0
309            self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal")
310            self.showComponentCombo.addItem("Select attribute")
311            OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info")
312
313            #OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ")
314            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.set_component_edge_width(changedMin)))
315            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.set_component_edge_width(changedMin)))
316
317            self.attSelectionAttribute = 0
318            self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList)
319            self.comboAttSelection.addItem("Select attribute")
320            self.autoSendAttributes = 0
321            OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes)
322
323            self.icons = self.createAttributeIconDict()
324            self.set_mark_mode()
325
326            self.networkCanvas.gui.effects_box(self.performanceTab)
327
328            self.verticesTab.layout().addStretch(1)
329            self.edgesTab.layout().addStretch(1)
330            self.markTab.layout().addStretch(1)
331            self.infoTab.layout().addStretch(1)
332            self.performanceTab.layout().addStretch(1)
333
334            dlg = self._create_color_dialog(self.colorSettings, self.selectedSchemaIndex)
335            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
336            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
337
338            dlg = self._create_color_dialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
339            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
340            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
341
342            self.graph_layout_method()
343            self.set_font()
344            self.set_graph(None)
345
346            self.setMinimumWidth(900)
347
348            self.connect(self.networkCanvas, SIGNAL("marked_points_changed()"), self.send_marked_nodes)
349            self.connect(self.networkCanvas, SIGNAL("selection_changed()"), self.send_data)
350
351        def hide_selection(self):
352            nodes = set(self.graph.nodes()).difference(self.networkCanvas.selected_nodes())
353            self.change_graph(Orange.network.nx.Graph.subgraph(self.graph, nodes))
354
355        def show_selection(self):
356            self.change_graph(self.graph_base)
357
358        def edit(self):
359            if self.graph is None:
360                return
361
362            vars = [x.name for x in self.graph_base.items_vars()]
363            if not self.editCombo.currentText() in vars:
364                return
365            att = str(self.editCombo.currentText())
366            vertices = self.networkCanvas.selected_nodes()
367
368            if len(vertices) == 0:
369                return
370
371            items = self.graph_base.items()
372            if items.domain[att].var_type == Orange.data.Type.Continuous:
373                for v in vertices:
374                    items[v][att] = float(self.editValue)
375            else:
376                for v in vertices:
377                    items[v][att] = str(self.editValue)
378
379        def set_items_distance_matrix(self, matrix):
380            self.error()
381            self.warning()
382            self.information()
383
384            self.cb_show_distances.setEnabled(0)
385            self.cb_show_component_distances.setEnabled(0)
386
387            if matrix is None or self.graph_base is None:
388                self.items_matrix = None
389                self.networkCanvas.items_matrix = None
390                self.information('No graph found!')
391                return
392
393            if matrix.dim != self.graph_base.number_of_nodes():
394                self.error('The number of vertices does not match matrix size.')
395                self.items_matrix = None
396                self.networkCanvas.items_matrix = None
397                return
398
399            self.items_matrix = matrix
400            self.networkCanvas.items_matrix = matrix
401            self.cb_show_distances.setEnabled(1)
402            self.cb_show_component_distances.setEnabled(1)
403
404            if str(self.optMethod) in ['8', '9', '10']:
405                if self.items_matrix is not None and self.graph is not None and \
406                self.items_matrix.dim == self.graph.number_of_nodes():
407                    self.optButton.setEnabled(True)
408                    self.optButton.setChecked(True)
409                    self.graph_layout()
410
411        def _set_canvas_attr(self, attr, value):
412            setattr(self.networkCanvas, attr, value)
413            self.networkCanvas.updateCanvas()
414
415        def _set_curve_attr(self, attr, value):
416            setattr(self.networkCanvas.networkCurve, attr, value)
417            self.networkCanvas.updateCanvas()
418
419        def _set_search_string_timer(self):
420            self.hubs = 1
421            self.searchStringTimer.stop()
422            self.searchStringTimer.start(1000)
423
424        def set_mark_mode(self, i=None):
425            self.searchStringTimer.stop()
426            if not i is None:
427                self.hubs = i
428
429            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed)
430            QObject.disconnect(self.networkCanvas, SIGNAL('point_hovered(Point*)'), self.networkCanvas.mark_on_focus_changed)
431
432            if self.graph is None:
433                return
434
435            hubs = self.hubs
436
437            if hubs in [0, 1, 2, 3]:
438                if hubs == 0:
439                    self.networkCanvas.networkCurve.clear_node_marks()
440                elif hubs == 1:
441                    #print "mark on given label"
442                    txt = self.markSearchString
443
444                    toMark = set(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()]))
445                    toMark = toMark.intersection(self.graph.nodes())
446                    self.networkCanvas.networkCurve.clear_node_marks()
447                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for i in toMark))
448                elif hubs == 2:
449                    #print "mark on focus"
450                    self.networkCanvas.mark_neighbors = self.markDistance
451                    QObject.connect(self.networkCanvas, SIGNAL('point_hovered(Point*)'), self.networkCanvas.mark_on_focus_changed)
452                elif hubs == 3:
453                    #print "mark selected"
454                    self.networkCanvas.mark_neighbors = self.markDistance
455                    QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.networkCanvas.mark_on_selection_changed)
456                    self.networkCanvas.mark_on_selection_changed()
457
458            elif hubs in [4, 5, 6, 7, 8, 9]:
459
460                powers = sorted(self.graph.degree_iter(), key=itemgetter(1), reverse=True)
461
462                if hubs == 4:
463                    #print "mark at least N connections"
464                    N = self.markNConnections
465                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \
466                        d >= N else (i, False) for i, d in powers))
467                elif hubs == 5:
468                    #print "mark at most N connections"
469                    N = self.markNConnections
470                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \
471                        d <= N else (i, False) for i, d in powers))
472                elif hubs == 6:
473                    #print "mark more than any"
474                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \
475                        d > max([0] + self.graph.degree(self.graph.neighbors(i)).values()) \
476                        else (i, False) for i, d in powers))
477                elif hubs == 7:
478                    #print "mark more than avg"
479                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) if \
480                        d > statc.mean([0] + self.graph.degree(self.graph.neighbors(i)).values()) \
481                        else (i, False) for i, d in powers))
482                    self.networkCanvas.replot()
483                elif hubs == 8:
484                    #print "mark most"
485                    self.networkCanvas.networkCurve.clear_node_marks()
486
487                    if self.markNumber < 1:
488                        return
489
490                    cut = self.markNumber
491                    cutPower = powers[cut - 1][1]
492                    while cut < len(powers) and powers[cut][1] == cutPower:
493                        cut += 1
494
495                    self.networkCanvas.networkCurve.clear_node_marks()
496                    self.networkCanvas.networkCurve.set_node_marks(dict((i, True) for \
497                        i, d in powers[:cut]))
498
499                elif hubs == 9:
500                    var = str(self.markInputCombo.currentText())
501                    if self.markInputItems is not None and len(self.markInputItems) > 0:
502                        if var == 'ID':
503                            values = [x.id for x in self.markInputItems]
504                            tomark = dict((x, True) for x in self.graph.nodes() if self.graph_base.items()[x].id in values)
505                        else:
506                            values = [str(x[var]).strip().upper() for x in self.markInputItems]
507                            tomark = dict((x, True) for x in self.graph.nodes() if str(self.graph_base.items()[x][var]).strip().upper() in values)
508                        self.networkCanvas.networkCurve.clear_node_marks()
509                        self.networkCanvas.networkCurve.set_node_marks(tomark)
510
511                    else:
512                        self.networkCanvas.networkCurve.clear_node_marks()
513
514            self.nMarked = len(self.networkCanvas.marked_nodes())
515
516        def save_network(self):
517    #        if self.networkCanvas is None or self.graph is None:
518    #            return
519    #       
520    #        filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)')
521    #        if filename:
522    #            fn = ""
523    #            head, tail = os.path.splitext(str(filename))
524    #            if not tail:
525    #                fn = head + ".net"
526    #            else:
527    #                fn = str(filename)
528    #           
529    #            for i in range(self.graph.number_of_nodes()):
530    #                node = self.graph.node[i]
531    #                node['x'] = self.layout.coors[0][i]
532    #                node['y'] = self.layout.coors[1][i]
533    #
534    #            Orange.network.readwrite.write(self.graph, fn)
535            pass
536
537        def send_data(self):
538            if len(self.signalManager.getLinks(self, None, \
539                "Selected Items", None)) > 0 or \
540                    len(self.signalManager.getLinks(self, None, \
541                        "Unselected Items", None)) > 0 or \
542                            len(self.signalManager.getLinks(self, None, \
543                                "Selected Network", None)) > 0:
544
545                # signal connected
546                selected_nodes = self.networkCanvas.selected_nodes()
547                graph = self.graph_base.subgraph(selected_nodes)
548
549                if graph is not None:
550                    self.send("Selected Items", graph.items())
551
552                    if len(self.signalManager.getLinks(self, None, \
553                                                "Unselected Items", None)) > 0:
554                        nodes = self.networkCanvas.not_selected_nodes()
555                        if len(nodes) > 0 and self.graph_base.items() is not None:
556                            self.send("Other Items", self.graph_base.items().getitems(nodes))
557                        else:
558                            self.send("Other Items", None)
559
560                    self.send("Selected Network", graph)
561                else:
562                    self.send("Selected Items", None)
563                    self.send("Other Items", None)
564                    self.send("Selected Network", None)
565
566            if len(self.signalManager.getLinks(self, None, \
567                                "Selected Items Distance Matrix", None)) > 0:
568                # signal connected
569                matrix = None if self.items_matrix is None else self.items_matrix.getitems(selected_nodes)
570                self.send("Distance Matrix", matrix)
571
572        def send_marked_nodes(self):
573            if self.checkSendMarkedNodes and \
574                len(self.signalManager.getLinks(self, None, \
575                                                "Marked Items", None)) > 0:
576                # signal connected
577                markedNodes = self.networkCanvas.marked_nodes()
578
579                if len(markedNodes) > 0 and self.graph is not None and\
580                                         self.graph_base.items() is not None:
581
582                    items = self.graph_base.items().getitems(markedNodes)
583                    self.send("Marked Items", items)
584                else:
585                    self.send("Marked Items", None)
586
587        def _set_combos(self):
588            vars = self.graph_base.items_vars()
589            edgeVars = self.graph_base.links_vars()
590            lastLabelColumns = self.lastLabelColumns
591            lastTooltipColumns = self.lastTooltipColumns
592
593            self._clear_combos()
594
595            self.attributes = [(var.name, var.varType) for var in vars]
596            self.edgeAttributes = [(var.name, var.varType) for var in edgeVars]
597
598            for var in vars:
599                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]:
600                    self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
601
602                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:
603
604                    value = self.graph_base.items()[0][var].value
605
606                    # can value be a list?
607                    try:
608                        if type(eval(value)) == type([]):
609                            self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
610                            continue
611                    except:
612                        pass
613
614                    if len(value.split(',')) > 1:
615                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name))
616
617                elif var.varType in [Orange.data.Type.Continuous]:
618                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
619
620                self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
621                self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
622                self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
623                self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
624
625            for var in edgeVars:
626                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]:
627                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
628
629            for i in range(self.vertexSizeCombo.count()):
630                if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i):
631                    self.vertexSize = i
632                    break
633
634            for i in range(self.colorCombo.count()):
635                if self.lastColorColumn == self.colorCombo.itemText(i):
636                    self.color = i
637                    break
638
639            for i in range(self.attListBox.count()):
640                if str(self.attListBox.item(i).text()) in lastLabelColumns:
641                    self.attListBox.item(i).setSelected(1)
642
643            for i in range(self.tooltipListBox.count()):
644                if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns:
645                    self.tooltipListBox.item(i).setSelected(1)
646
647            self.lastLabelColumns = lastLabelColumns
648            self.lastTooltipColumns = lastTooltipColumns
649
650        def _clear_combos(self):
651            self.attributes = []
652            self.edgeAttributes = []
653
654            self.colorCombo.clear()
655            self.vertexSizeCombo.clear()
656            self.nameComponentCombo.clear()
657            self.showComponentCombo.clear()
658            self.edgeColorCombo.clear()
659            self.editCombo.clear()
660            self.comboAttSelection.clear()
661
662            self.colorCombo.addItem("(same color)")
663            self.edgeColorCombo.addItem("(same color)")
664            self.vertexSizeCombo.addItem("(same size)")
665            self.nameComponentCombo.addItem("Select attribute")
666            self.showComponentCombo.addItem("Select attribute")
667            self.editCombo.addItem("Select attribute")
668            self.comboAttSelection.addItem("Select attribute")
669
670        def compute_network_info(self):
671            self.nShown = self.graph.number_of_nodes()
672
673            if self.graph.number_of_edges() > 0:
674                self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges())
675            else:
676                self.verticesPerEdge = 0
677
678            if self.graph.number_of_nodes() > 0:
679                self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes())
680            else:
681                self.edgesPerVertex = 0
682
683        def change_graph(self, newgraph):
684            self.information()
685
686            # if graph has more nodes and edges than pixels in 1600x1200 display,
687            # it is too big to visualize!
688            if newgraph.number_of_nodes() + newgraph.number_of_edges() > 50000:
689                self.information('New graph is too big to visualize. Keeping the old graph.')
690                return
691
692            self.graph = newgraph
693
694            self.number_of_nodes_label = self.graph.number_of_nodes()
695            self.number_of_edges_label = self.graph.number_of_edges()
696
697            if not self.networkCanvas.change_graph(self.graph):
698                return
699
700            self.compute_network_info()
701
702            if self.graph.number_of_nodes() > 0:
703                t = 1.13850193174e-008 * (self.graph.number_of_nodes() ** 2 + self.graph.number_of_edges())
704                self.frSteps = int(2.0 / t)
705                if self.frSteps < 1: self.frSteps = 1
706                if self.frSteps > 100: self.frSteps = 100
707    #       
708    #        if self.frSteps < 10:
709    #            self.networkCanvas.use_antialiasing = 0
710    #            self.networkCanvas.use_animations = 0
711    #            self.minVertexSize = 5
712    #            self.maxVertexSize = 5
713    #            self.maxLinkSize = 1
714    #            self.optMethod = 0
715    #            self.graph_layout_method()
716
717            animation_enabled = self.networkCanvas.animate_points;
718            self.networkCanvas.animate_points = False;
719
720            self.set_node_sizes()
721            self.set_node_colors()
722            self.set_edge_sizes()
723            self.set_edge_colors()
724
725            self._clicked_att_lstbox()
726            self._clicked_tooltip_lstbox()
727            self._clicked_edge_label_listbox()
728
729            self.networkCanvas.replot()
730
731            self.networkCanvas.animate_points = animation_enabled
732            qApp.processEvents()
733            self.networkCanvas.networkCurve.layout_fr(100, weighted=False, smooth_cooling=True)
734            self.networkCanvas.update_canvas()
735
736        def set_graph_none(self):
737            self.graph = None
738            #self.graph_base = None
739            self._clear_combos()
740            self.number_of_nodes_label = -1
741            self.number_of_edges_label = -1
742            self._items = None
743            self._links = None
744            self.set_items_distance_matrix(None)
745            self.networkCanvas.set_graph(None)
746
747        def set_graph(self, graph, curve=None):
748            self.information()
749            self.warning()
750            self.error()
751
752            if graph is None:
753                self.set_graph_none()
754                return
755
756            if graph.number_of_nodes() < 2:
757                self.set_graph_none()
758                self.information('I\'m not really in a mood to visualize just one node. Try again tomorrow.')
759                return
760
761            if graph == self.graph_base and self.graph is not None and self._network_view is None:
762                self.set_items(graph.items())
763                return
764
765            self.graph_base = graph
766
767            if self._network_view is not None:
768                graph = self._network_view.init_network(graph)
769
770            self.graph = graph
771
772            # if graph has more nodes and edges than pixels in 1600x1200 display,
773            # it is too big to visualize!
774            if self.graph.number_of_nodes() + self.graph.number_of_edges() > 50000:
775                self.set_graph_none()
776                self.error('Graph is too big to visualize. Try using one of the network views.')
777                return
778
779            if self.items_matrix is not None and self.items_matrix.dim != self.graph_base.number_of_nodes():
780                self.set_items_distance_matrix(None)
781
782            self.number_of_nodes_label = self.graph.number_of_nodes()
783            self.number_of_edges_label = self.graph.number_of_edges()
784
785            self.networkCanvas.set_graph(self.graph, curve, items=self.graph_base.items(), links=self.graph_base.links())
786
787            if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain:
788                positions = dict((node, (self._items[node]['x'].value, self._items[node]['y'].value)) \
789                             for node in self.graph if self._items[node]['x'].value != '?' \
790                             and self._items[node]['y'].value != '?')
791
792                self.networkCanvas.networkCurve.set_node_coordinates(positions)
793
794
795            self.networkCanvas.showEdgeLabels = self.showEdgeLabels
796            self.networkCanvas.maxEdgeSize = self.maxLinkSize
797            self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth
798            self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
799            self.networkCanvas.set_labels_on_marked(self.labelsOnMarkedOnly)
800
801            self.compute_network_info()
802            self._set_combos()
803
804            lastNameComponentAttributeFound = False
805            for i in range(self.nameComponentCombo.count()):
806                if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i):
807                    lastNameComponentAttributeFound = True
808                    self.nameComponentAttribute = i
809                    self.nameComponents()
810                    self.showComponentAttribute = self.showComponentCombo.count() - 1
811                    self.showComponents()
812                    break
813
814            if not lastNameComponentAttributeFound:
815                self.lastNameComponentAttribute = ''
816
817            self.showComponentAttribute = None
818
819            t = 1.13850193174e-008 * (self.graph.number_of_nodes() ** 2 + self.graph.number_of_edges())
820            self.frSteps = int(2.0 / t)
821            if self.frSteps < 1: self.frSteps = 1
822            if self.frSteps > 100: self.frSteps = 100
823
824            # if graph is large, set random layout, min vertex size, min edge size
825            if self.frSteps < 10:
826                self.networkCanvas.update_antialiasing(False)
827                self.networkCanvas.update_animations(False)
828                self.minVertexSize = 5
829                self.maxVertexSize = 5
830                self.maxLinkSize = 1
831                self.optMethod = 0
832                self.graph_layout_method()
833
834            self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly
835            self.networkCanvas.showWeights = self.showWeights
836
837            self.set_node_sizes()
838            self.set_node_colors()
839            self.set_edge_sizes()
840            self.set_edge_colors()
841
842            self._clicked_att_lstbox()
843            self._clicked_tooltip_lstbox()
844            self._clicked_edge_label_listbox()
845
846            self.optButton.setChecked(1)
847            self.graph_layout()
848
849        def set_network_view(self, nxView):
850            self.error()
851            self.warning()
852            self.information()
853
854            if self.graph is None:
855                self.information('Do not forget to add a graph!')
856
857            if self._network_view is not None:
858                QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed)
859
860            self._network_view = nxView
861
862            if self._network_view is not None:
863                self._network_view.set_nx_explorer(self)
864
865            self.set_graph(self.graph_base)
866
867            if self._network_view is not None:
868                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self._network_view.node_selection_changed)
869
870        def set_items(self, items=None):
871            self.error()
872            self.warning()
873            self.information()
874
875            if items is None:
876                return
877
878            if self.graph is None:
879                self.warning('No graph found!')
880                return
881
882            if len(items) != self.graph_base.number_of_nodes():
883                self.error('ExampleTable items must have one example for each vertex.')
884                return
885
886            self.graph_base.set_items(items)
887
888            self.set_node_sizes()
889            self.networkCanvas.items = items
890            self.networkCanvas.showWeights = self.showWeights
891            self.networkCanvas.showEdgeLabels = self.showEdgeLabels
892            self._set_combos()
893            #self.networkCanvas.updateData()
894
895        def mark_items(self, items):
896            self.markInputCombo.clear()
897            self.markInputRadioButton.setEnabled(False)
898            self.markInputItems = items
899
900            self.error()
901            self.warning()
902            self.information()
903
904            if items is None:
905                return
906
907            if self.graph is None or self.graph_base.items() is None or items is None:
908                self.warning('No graph found or no items attached to the graph.')
909                return
910
911            if len(items) > 0:
912                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()]
913                lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()]
914                commonVars = set(lstNewDomain) & set(lstOrgDomain)
915
916                self.markInputCombo.addItem(self.icons[Orange.data.Type.Discrete], unicode("ID"))
917
918                if len(commonVars) > 0:
919                    for var in commonVars:
920                        orgVar = self.graph_base.items().domain[var]
921                        mrkVar = items.domain[var]
922
923                        if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String:
924                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name))
925
926                self.markInputRadioButton.setEnabled(True)
927                self.set_mark_mode(9)
928
929        def set_explore_distances(self):
930            QObject.disconnect(self.networkCanvas, SIGNAL('selection_changed()'), self.explore_focused)
931
932            if self.explore_distances:
933                QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.explore_focused)
934
935        def explore_focused(self):
936            sel = self.networkCanvas.selected_nodes()
937            if len(sel) == 1:
938                ndx_1 = sel[0]
939                self.networkCanvas.label_distances = [['%.2f' % \
940                                self.items_matrix[ndx_1][ndx_2]] \
941                                for ndx_2 in self.networkCanvas.graph.nodes()]
942            else:
943                self.networkCanvas.label_distances = None
944
945            self.networkCanvas.set_node_labels(self.lastLabelColumns)
946            self.networkCanvas.replot()
947
948        #######################################################################
949        ### Layout Optimization                                             ###
950        #######################################################################
951
952        def graph_layout(self):
953            if self.graph is None or self.graph.number_of_nodes <= 0:   #grafa se ni
954                self.optButton.setChecked(False)
955                return
956
957            if not self.optButton.isChecked() and not self.optMethod in [2, 3, 9, 10]:
958                self.optButton.setChecked(False)
959                return
960
961            qApp.processEvents()
962
963            if self.optMethod == 1:
964                self.networkCanvas.networkCurve.random()
965            elif self.optMethod == 2:
966                self.graph_layout_fr(False)
967            elif self.optMethod == 3:
968                self.graph_layout_fr(True)
969            elif self.optMethod == 4:
970                self.graph_layout_fr_radial()
971            elif self.optMethod == 5:
972                self.networkCanvas.networkCurve.circular(\
973                                            NetworkCurve.circular_crossing)
974            elif self.optMethod == 6:
975                self.networkCanvas.networkCurve.circular(\
976                                            NetworkCurve.circular_original)
977            elif self.optMethod == 7:
978                self.networkCanvas.networkCurve.circular(\
979                                            NetworkCurve.circular_random)
980            elif self.optMethod == 8:
981                self.graph_layout_fragviz()
982            elif self.optMethod == 9:
983                self.graph_layout_mds()
984            elif self.optMethod == 10:
985                self.graph_layout_pivot_mds()
986
987            self.optButton.setChecked(False)
988            self.networkCanvas.update_canvas()
989
990        def graph_layout_method(self, method=None):
991            self.information()
992            self.stepsSpin.label.setText('Iterations: ')
993            self.optButton.setEnabled(True)
994            self.cb_opt_from_curr.setEnabled(False)
995
996            if method is not None:
997                self.optMethod = method
998
999            if str(self.optMethod) == '0':
1000                self.optButton.setEnabled(False)
1001            else:
1002                self.optButton.setEnabled(True)
1003
1004            if str(self.optMethod) in ['2', '3', '4']:
1005                self.stepsSpin.setEnabled(True)
1006
1007            elif str(self.optMethod) in ['8', '9', '10']:
1008                if str(self.optMethod) == '8':
1009                    self.stepsSpin.label.setText('Pivots: ')
1010
1011                if str(self.optMethod) in ['9', '10']:
1012                    self.cb_opt_from_curr.setEnabled(True)
1013
1014                self.stepsSpin.setEnabled(True)
1015
1016                if self.items_matrix is None:
1017                    self.information('Set distance matrix to input signal')
1018                    self.optButton.setEnabled(False)
1019                    return
1020                if self.graph is None:
1021                    self.information('No network found')
1022                    self.optButton.setEnabled(False)
1023                    return
1024                if self.items_matrix.dim != self.graph.number_of_nodes():
1025                    self.error('Distance matrix dimensionality must equal number of vertices')
1026                    self.optButton.setEnabled(False)
1027                    return
1028            else:
1029                self.stepsSpin.setEnabled(False)
1030                self.optButton.setChecked(True)
1031                self.graph_layout()
1032
1033        def mds_progress(self, avgStress, stepCount):
1034            #self.drawForce()
1035
1036            #self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress)
1037            #self.mdsInfoB.setText("Num. steps: %i" % stepCount)
1038            self.progressBarSet(int(stepCount * 100 / self.frSteps))
1039            qApp.processEvents()
1040
1041        def graph_layout_fragviz(self):
1042            if self.items_matrix is None:
1043                self.information('Set distance matrix to input signal')
1044                self.optButton.setChecked(False)
1045                return
1046
1047            if self.layout is None:
1048                self.information('No network found')
1049                self.optButton.setChecked(False)
1050                return
1051
1052            if self.items_matrix.dim != self.graph.number_of_nodes():
1053                self.error('Distance matrix dimensionality must equal number of vertices')
1054                self.optButton.setChecked(False)
1055                return
1056
1057            if not self.optButton.isChecked():
1058                self.networkCanvas.networkCurve.stopMDS = True
1059                self.optButton.setChecked(False)
1060                self.optButton.setText("Optimize layout")
1061                return
1062
1063            self.optButton.setText("Stop")
1064            self.progressBarInit()
1065            qApp.processEvents()
1066
1067            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes():
1068                matrix = self.items_matrix
1069            else:
1070                matrix = self.items_matrix.get_items(sorted(self.graph.nodes()))
1071
1072            self.networkCanvas.networkCurve.layout_fragviz(self.frSteps, matrix, self.graph, self.mds_progress, self.opt_from_curr)
1073
1074            self.optButton.setChecked(False)
1075            self.optButton.setText("Optimize layout")
1076            self.progressBarFinished()
1077
1078        def graph_layout_mds(self):
1079            if self.items_matrix is None:
1080                self.information('Set distance matrix to input signal')
1081                self.optButton.setChecked(False)
1082                return
1083
1084            if self.layout is None:
1085                self.information('No network found')
1086                self.optButton.setChecked(False)
1087                return
1088
1089            if self.items_matrix.dim != self.graph.number_of_nodes():
1090                self.error('Distance matrix dimensionality must equal number of vertices')
1091                self.optButton.setChecked(False)
1092                return
1093
1094            if not self.optButton.isChecked():
1095                self.networkCanvas.networkCurve.stopMDS = True
1096                self.optButton.setChecked(False)
1097                self.optButton.setText("Optimize layout")
1098                return
1099
1100            self.optButton.setText("Stop")
1101            self.progressBarInit()
1102            qApp.processEvents()
1103
1104            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes():
1105                matrix = self.items_matrix
1106            else:
1107                matrix = self.items_matrix.get_items(sorted(self.graph.nodes()))
1108
1109            self.networkCanvas.networkCurve.layout_mds(self.frSteps, matrix, self.mds_progress, self.opt_from_curr)
1110
1111            self.optButton.setChecked(False)
1112            self.optButton.setText("Optimize layout")
1113            self.progressBarFinished()
1114
1115        def graph_layout_fr(self, weighted):
1116            if self.graph is None:
1117                return
1118
1119            if not self.optButton.isChecked():
1120                self.networkCanvas.networkCurve.stop_optimization()
1121                self.optButton.setChecked(False)
1122                self.optButton.setText("Optimize layout")
1123                return
1124
1125            self.optButton.setText("Stop")
1126            qApp.processEvents()
1127            self.networkCanvas.networkCurve.layout_fr(self.frSteps, False)
1128            self.networkCanvas.update_canvas()
1129            self.optButton.setChecked(False)
1130            self.optButton.setText("Optimize layout")
1131
1132        def graph_layout_fr_radial(self):
1133            if self.graph is None:   #grafa se ni
1134                return
1135
1136    #        #print "F-R Radial"
1137    #        k = 1.13850193174e-008
1138    #        nodes = self.graph.number_of_nodes()
1139    #        t = k * nodes * nodes
1140    #        refreshRate = int(5.0 / t)
1141    #        if refreshRate <    1: refreshRate = 1
1142    #        if refreshRate > 1500: refreshRate = 1500
1143    #        #print "refreshRate: " + str(refreshRate)
1144    #       
1145    #        tolerance = 5
1146    #        initTemp = 100
1147    #        centerNdx = 0
1148    #       
1149    #        selection = self.networkCanvas.getSelection()
1150    #        if len(selection) > 0:
1151    #            centerNdx = selection[0]
1152    #           
1153    #        #print "center ndx: " + str(centerNdx)
1154    #        initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp)
1155    #        self.networkCanvas.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5]
1156    #        #self.networkCanvas.circles = [100, 200, 300]
1157    #        self.networkCanvas.updateCanvas()
1158    #        self.networkCanvas.circles = []
1159
1160        def graph_layout_pivot_mds(self):
1161            self.information()
1162
1163            if self.items_matrix is None:
1164                self.information('Set distance matrix to input signal')
1165                return
1166
1167            if self.graph_base is None:
1168                self.information('No network found')
1169                return
1170
1171            if self.items_matrix.dim != self.graph_base.number_of_nodes():
1172                self.error('The number of vertices does not match matrix size.')
1173                return
1174
1175            self.frSteps = min(self.frSteps, self.graph.number_of_nodes())
1176            qApp.processEvents()
1177
1178            if self.graph.number_of_nodes() == self.graph_base.number_of_nodes():
1179                matrix = self.items_matrix
1180            else:
1181                matrix = self.items_matrix.get_items(sorted(self.graph.nodes()))
1182
1183            mds = orngMDS.PivotMDS(matrix, self.frSteps)
1184            x, y = mds.optimize()
1185            xy = zip(list(x), list(y))
1186            coors = dict(zip(sorted(self.graph.nodes()), xy))
1187            self.networkCanvas.networkCurve.set_node_coordinates(coors)
1188            self.networkCanvas.update_canvas()
1189
1190        #######################################################################
1191        ### Network Visualization                                           ###
1192        #######################################################################
1193
1194        def _set_colors(self):
1195            dlg = self._create_color_dialog(self.colorSettings, self.selectedSchemaIndex)
1196            if dlg.exec_():
1197                self.colorSettings = dlg.getColorSchemas()
1198                self.selectedSchemaIndex = dlg.selectedSchemaIndex
1199                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
1200                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
1201
1202                self.set_node_colors()
1203
1204        def _set_edge_color_palette(self):
1205            dlg = self._create_color_dialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
1206            if dlg.exec_():
1207                self.edgeColorSettings = dlg.getColorSchemas()
1208                self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex
1209                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
1210                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
1211
1212                self.set_edge_colors()
1213
1214        def _create_color_dialog(self, colorSettings, selectedSchemaIndex):
1215            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette")
1216            c.createDiscretePalette("discPalette", "Discrete Palette")
1217            c.createContinuousPalette("contPalette", "Continuous Palette")
1218            c.setColorSchemas(colorSettings, selectedSchemaIndex)
1219            return c
1220
1221        def _clicked_att_lstbox(self):
1222            if self.graph is None:
1223                return
1224
1225            self.lastLabelColumns = [self.attributes[i][0] for i in self.markerAttributes]
1226            self.networkCanvas.set_node_labels(self.lastLabelColumns)
1227            self.networkCanvas.replot()
1228
1229        def _clicked_tooltip_lstbox(self):
1230            if self.graph is None:
1231                return
1232
1233            self.lastTooltipColumns = [self.attributes[i][0] for i in self.tooltipAttributes]
1234            self.networkCanvas.set_tooltip_attributes(self.lastTooltipColumns)
1235            self.networkCanvas.replot()
1236
1237        def _clicked_edge_label_listbox(self):
1238            if self.graph is None:
1239                return
1240
1241            self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes])
1242            self.networkCanvas.set_edge_labels(self.lastEdgeLabelAttributes)
1243            self.networkCanvas.replot()
1244
1245        def set_node_colors(self):
1246            if self.graph is None:
1247                return
1248
1249            self.networkCanvas.set_node_colors(self.colorCombo.currentText())
1250            self.lastColorColumn = self.colorCombo.currentText()
1251
1252        def set_edge_colors(self):
1253            if self.graph is None:
1254                return
1255
1256            self.networkCanvas.set_edge_colors(self.edgeColorCombo.currentText())
1257            self.lastEdgeColorColumn = self.edgeColorCombo.currentText()
1258
1259        def set_edge_sizes(self):
1260            if self.graph is None:
1261                return
1262
1263            self.networkCanvas.networkCurve.set_edge_sizes(self.maxLinkSize)
1264            self.networkCanvas.replot()
1265
1266        def set_node_sizes(self):
1267            if self.graph is None or self.networkCanvas is None:
1268                return
1269
1270            if self.minVertexSize > self.maxVertexSize:
1271                self.maxVertexSize = self.minVertexSize
1272
1273            items = self.graph_base.items()
1274
1275            if items is None:
1276                self.networkCanvas.networkCurve.set_node_sizes({}, min_size=self.minVertexSize, max_size=self.maxVertexSize)
1277                return
1278
1279            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
1280            column = str(self.vertexSizeCombo.currentText())
1281
1282            values = {}
1283            if column in items.domain or (column.startswith("num of ") and column.replace("num of ", "") in items.domain):
1284                if column in items.domain:
1285                    values = dict((x, items[x][column].value) for x in self.graph if not items[x][column].isSpecial())
1286                else:
1287                    values = dict((x, len(items[x][column.replace("num of ", "")].value.split(','))) for x in self.graph)
1288
1289            if len(values) == 0:
1290                values = dict((node, 1.) for node in self.graph)
1291
1292            if self.invertSize:
1293                maxval = max(values.itervalues())
1294                values.update((key, maxval - val) for key, val in values.iteritems())
1295                self.networkCanvas.networkCurve.set_node_sizes(values, min_size=self.minVertexSize, max_size=self.maxVertexSize)
1296            else:
1297                self.networkCanvas.networkCurve.set_node_sizes(values, min_size=self.minVertexSize, max_size=self.maxVertexSize)
1298
1299            self.networkCanvas.replot()
1300
1301        def set_font(self):
1302            if self.networkCanvas is None:
1303                return
1304
1305            weights = {0: 50, 1: 80}
1306
1307            font = self.networkCanvas.font()
1308            font.setPointSize(self.fontSize)
1309            font.setWeight(weights[self.fontWeight])
1310            self.networkCanvas.setFont(font)
1311            self.networkCanvas.fontSize = font
1312            self.networkCanvas.set_node_labels()
1313
1314        def sendReport(self):
1315            self.reportSettings("Graph data",
1316                                [("Number of vertices", self.graph.number_of_nodes()),
1317                                 ("Number of edges", self.graph.number_of_edges()),
1318                                 ("Vertices per edge", "%.3f" % self.verticesPerEdge),
1319                                 ("Edges per vertex", "%.3f" % self.edgesPerVertex),
1320                                 ])
1321            if self.color or self.vertexSize or self.markerAttributes or self.edgeColor:
1322                self.reportSettings("Visual settings",
1323                                    [self.color and ("Vertex color", self.colorCombo.currentText()),
1324                                     self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""),
1325                                     self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)),
1326                                     self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()),
1327                                    ])
1328            self.reportSettings("Optimization",
1329                                [("Method", self.optCombo.currentText()),
1330                                 ("Iterations", self.frSteps)])
1331            self.reportSection("Graph")
1332            self.reportImage(self.networkCanvas.saveToFileDirect)
1333
1334        #######################################################################
1335        ### PROTOTYPE                                                       ###
1336        #######################################################################
1337
1338        def set_component_edge_width(self, changedMin=True):
1339            if self.networkCanvas is None:
1340                return
1341
1342            canvas = self.networkCanvas
1343            if changedMin:
1344                if self.maxComponentEdgeWidth < self.minComponentEdgeWidth:
1345                    self.maxComponentEdgeWidth = self.minComponentEdgeWidth
1346            else:
1347                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth:
1348                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth
1349
1350            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth
1351            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
1352            self.networkCanvas.updateCanvas()
1353
1354        def showComponents(self):
1355            if self.graph is None or self.graph_base.items() is None:
1356                return
1357
1358            vars = [x.name for x in self.graph_base.items_vars()]
1359
1360            if not self.showComponentCombo.currentText() in vars:
1361                self.networkCanvas.showComponentAttribute = None
1362                self.lastNameComponentAttribute = ''
1363            else:
1364                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()
1365
1366            self.networkCanvas.drawComponentKeywords()
1367
1368        def nameComponents(self):
1369            """Names connected components of genes according to GO terms."""
1370            self.progressBarFinished()
1371            self.lastNameComponentAttribute = None
1372
1373            if self.graph is None or self.graph_base.items() is None:
1374                return
1375
1376            vars = [x.name for x in self.graph_base.items_vars()]
1377            if not self.nameComponentCombo.currentText() in vars:
1378                return
1379
1380            self.progressBarInit()
1381            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1]
1382            if 'component name' in self.graph_base.items().domain:
1383                keyword_table = self.graph_base.items()
1384            else:
1385                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])
1386
1387            import obiGO
1388            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)
1389            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet)
1390
1391            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()])
1392            foundGenesets = False
1393            if len(annotations.geneNames & allGenes) < 1:
1394                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()]))
1395                if len(annotations.geneNames & allGenes) < 1:
1396                    self.warning('no genes found')
1397                    return
1398                else:
1399                    foundGenesets = True
1400
1401            def rank(a, j, reverse=False):
1402                if len(a) <= 0: return
1403
1404                if reverse:
1405                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0)
1406                    top_value = a[0][j]
1407                    top_rank = len(a)
1408                    max_rank = float(len(a))
1409                    int_ndx = 0
1410                    for k in range(len(a)):
1411                        if top_value < a[k][j]:
1412                            top_value = a[k][j]
1413                            if k - int_ndx > 1:
1414                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
1415                                for l in range(int_ndx, k):
1416                                    a[l][j] = avg_rank
1417
1418                            int_ndx = k
1419
1420                        a[k][j] = top_rank / max_rank
1421                        top_rank -= 1
1422
1423                    k += 1
1424                    if k - int_ndx > 1:
1425                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
1426                        for l in range(int_ndx, k):
1427                            a[l][j] = avg_rank
1428
1429                else:
1430                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0)
1431                    top_value = a[0][j]
1432                    top_rank = len(a)
1433                    max_rank = float(len(a))
1434                    int_ndx = 0
1435                    for k in range(len(a)):
1436                        if top_value > a[k][j]:
1437                            top_value = a[k][j]
1438                            if k - int_ndx > 1:
1439                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
1440                                for l in range(int_ndx, k):
1441                                    a[l][j] = avg_rank
1442
1443                            int_ndx = k
1444
1445                        a[k][j] = top_rank / max_rank
1446                        top_rank -= 1
1447
1448                    k += 1
1449                    if k - int_ndx > 1:
1450                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
1451                        for l in range(int_ndx, k):
1452                            a[l][j] = avg_rank
1453
1454            for i in range(len(components)):
1455                component = components[i]
1456                if len(component) <= 1:
1457                    continue
1458
1459                if foundGenesets:
1460                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component])
1461                else:
1462                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component]
1463
1464                res1 = annotations.GetEnrichedTerms(genes, aspect="P")
1465                res2 = annotations.GetEnrichedTerms(genes, aspect="F")
1466                res = res1.items() + res2.items()
1467                #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]
1468                #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]
1469
1470                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]
1471                if len(namingScore) == 0:
1472                    continue
1473
1474                annotated_genes = max([a[0] for a in namingScore])
1475
1476                rank(namingScore, 1, reverse=True)
1477                rank(namingScore, 2, reverse=True)
1478                rank(namingScore, 0)
1479
1480                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]
1481                namingScore.sort(reverse=True)
1482
1483                if len(namingScore) < 1:
1484                    print "warning. no annotations found for group of genes: " + ", ".join(genes)
1485                    continue
1486                elif len(namingScore[0]) < 2:
1487                    print "warning. error computing score for group of genes: " + ", ".join(genes)
1488                    continue
1489
1490                for v in component:
1491                    name = str(namingScore[0][1])
1492                    attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4])
1493                    info = ''
1494                    if self.showTextMiningInfo:
1495                        info = "\n" + attrs + "\n" + str(namingScore[0][0])
1496                    keyword_table[v]['component name'] = name + info
1497
1498                self.progressBarSet(i * 100.0 / len(components))
1499
1500            self.lastNameComponentAttribute = self.nameComponentCombo.currentText()
1501            self.set_items(Orange.data.Table([self.graph_base.items(), keyword_table]))
1502            self.progressBarFinished()
1503
1504
1505        def setAutoSendAttributes(self):
1506            print 'TODO setAutoSendAttributes'
1507            #if self.autoSendAttributes:
1508            #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList
1509            #else:
1510            #    self.networkCanvas.callbackSelectVertex = None
1511
1512        def sendAttSelectionList(self):
1513            if not self.graph is None:
1514                vars = [x.name for x in self.graph_base.links_vars()]
1515                if not self.comboAttSelection.currentText() in vars:
1516                    return
1517                att = str(self.comboAttSelection.currentText())
1518                vertices = self.networkCanvas.selected_nodes()
1519
1520                if len(vertices) != 1:
1521                    return
1522
1523                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ')
1524            else:
1525                attributes = None
1526            self.send("Features", attributes)
1527
1528
1529except ImportError as err:
1530    try:
1531        from OWNxCanvas import *
1532    except:
1533        # if Qwt is also not installed throw could not import orangeqt error
1534        raise err
1535
1536
1537    dir = os.path.dirname(__file__) + "/../icons/"
1538    dlg_mark2sel = dir + "Dlg_Mark2Sel.png"
1539    dlg_sel2mark = dir + "Dlg_Sel2Mark.png"
1540    dlg_selIsmark = dir + "Dlg_SelisMark.png"
1541    dlg_selected = dir + "Dlg_HideSelection.png"
1542    dlg_unselected = dir + "Dlg_UnselectedNodes.png"
1543    dlg_showall = dir + "Dlg_clear.png"
1544
1545
1546    class OWNxExplorer(OWWidget):
1547        settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage",
1548        "maxLinkSize", "minVertexSize", "maxVertexSize", "renderAntialiased",
1549        "invertSize", "optMethod", "lastVertexSizeColumn", "lastColorColumn",
1550        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns",
1551        "showWeights", "showIndexes", "showEdgeLabels", "colorSettings",
1552        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex",
1553        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage",
1554        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism", "showTextMiningInfo",
1555        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth",
1556        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex"]
1557
1558        def __init__(self, parent=None, signalManager=None, name='Net Explorer (Qwt)',
1559                     NetworkCanvas=OWNxCanvas):
1560            OWWidget.__init__(self, parent, signalManager, name)
1561            #self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="markerAttributes"), ContextField("attributes", selected="tooltipAttributes"), "color"])}
1562            self.inputs = [("Network", Orange.network.Graph, self.set_graph, Default),
1563                           ("Nx View", Orange.network.NxView, self.set_network_view),
1564                           ("Items", Orange.data.Table, self.setItems),
1565                           ("Marked Items", Orange.data.Table, self.markItems),
1566                           ("Item Subset", Orange.data.Table, self.setExampleSubset),
1567                           ("Distances", Orange.core.SymMatrix, self.set_items_distance_matrix)]
1568
1569            self.outputs = [("Selected Network", Orange.network.Graph),
1570                            ("Distance Matrix", Orange.core.SymMatrix),
1571                            ("Selected Items", Orange.data.Table),
1572                            ("Other Items", Orange.data.Table),
1573                            ("Marked Items", Orange.data.Table),
1574                            ("Features", AttributeList)]
1575
1576            self.markerAttributes = []
1577            self.tooltipAttributes = []
1578            self.edgeLabelAttributes = []
1579            self.attributes = []
1580            self.edgeAttributes = []
1581            self.autoSendSelection = False
1582            self.graphShowGrid = 1  # show gridlines in the graph
1583
1584            self.markNConnections = 2
1585            self.markNumber = 0
1586            self.markProportion = 0
1587            self.markSearchString = ""
1588            self.markDistance = 2
1589            self.frSteps = 1
1590            self.hubs = 0
1591            self.color = 0
1592            self.edgeColor = 0
1593            self.vertexSize = 0
1594            self.nShown = self.nHidden = self.nMarked = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = self.diameter = self.clustering_coefficient = 0
1595            self.optimizeWhat = 1
1596            self.stopOptimization = 0
1597            self.maxLinkSize = 3
1598            self.maxVertexSize = 5
1599            self.minVertexSize = 5
1600            self.renderAntialiased = 1
1601            self.labelsOnMarkedOnly = 0
1602            self.invertSize = 0
1603            self.optMethod = 0
1604            self.lastVertexSizeColumn = ''
1605            self.lastColorColumn = ''
1606            self.lastNameComponentAttribute = ''
1607            self.lastLabelColumns = set()
1608            self.lastTooltipColumns = set()
1609            self.showWeights = 0
1610            self.showIndexes = 0
1611            self.showEdgeLabels = 0
1612            self.colorSettings = None
1613            self.selectedSchemaIndex = 0
1614            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)])]])]
1615            self.selectedEdgeSchemaIndex = 0
1616            self.items_matrix = None
1617            self.showDistances = 0
1618            self.showMissingValues = 0
1619            self.fontSize = 12
1620            self.mdsTorgerson = 0
1621            self.mdsAvgLinkage = 1
1622            self.mdsSteps = 10000
1623            self.mdsRefresh = 50
1624            self.mdsStressDelta = 0.0000001
1625            self.organism = 'goa_human'
1626            self.showTextMiningInfo = 0
1627            self.toolbarSelection = 0
1628            self.minComponentEdgeWidth = 10
1629            self.maxComponentEdgeWidth = 70
1630            self.mdsFromCurrentPos = 0
1631            self.tabIndex = 0
1632            self.number_of_nodes_label = -1
1633            self.number_of_edges_label = -1
1634
1635            self.checkSendMarkedNodes = True
1636            self.checkSendSelectedNodes = True
1637
1638            self.loadSettings()
1639
1640            self._network_view = None
1641            self.layout = Orange.network.GraphLayout()
1642            self.graph = None
1643            self.graph_base = None
1644            self.markInputItems = None
1645
1646            self.mainArea.layout().setContentsMargins(0, 4, 4, 4)
1647            self.controlArea.layout().setContentsMargins(4, 4, 0, 4)
1648
1649            self.networkCanvas = NetworkCanvas(self, self.mainArea, "Net Explorer")
1650            self.networkCanvas.showMissingValues = self.showMissingValues
1651            self.mainArea.layout().addWidget(self.networkCanvas)
1652
1653            self.networkCanvas.maxLinkSize = self.maxLinkSize
1654            self.networkCanvas.minVertexSize = self.minVertexSize
1655            self.networkCanvas.maxVertexSize = self.maxVertexSize
1656
1657            self.hcontroArea = OWGUI.widgetBox(self.controlArea, orientation='horizontal')
1658
1659            self.tabs = OWGUI.tabWidget(self.hcontroArea)
1660
1661            self.verticesTab = OWGUI.createTabPage(self.tabs, "Vertices")
1662            self.edgesTab = OWGUI.createTabPage(self.tabs, "Edges")
1663            self.markTab = OWGUI.createTabPage(self.tabs, "Mark")
1664            self.infoTab = OWGUI.createTabPage(self.tabs, "Info")
1665            #self.editTab = OWGUI.createTabPage(self.tabs, "Edit")
1666
1667            self.tabs.setCurrentIndex(self.tabIndex)
1668            self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index))
1669
1670            self.optimizeBox = OWGUI.radioButtonsInBox(self.verticesTab, self, "optimizeWhat", [], "Optimize", addSpace=False)
1671
1672            self.optCombo = OWGUI.comboBox(self.optimizeBox, self, "optMethod", label='Method:     ', orientation='horizontal', callback=self.graph_layout_method)
1673            self.optCombo.addItem("No optimization")
1674            self.optCombo.addItem("Random")
1675            self.optCombo.addItem("Fruchterman Reingold")
1676            self.optCombo.addItem("Fruchterman Reingold Weighted")
1677            self.optCombo.addItem("Fruchterman Reingold Radial")
1678            self.optCombo.addItem("Circular Crossing Reduction")
1679            self.optCombo.addItem("Circular Original")
1680            self.optCombo.addItem("Circular Random")
1681            self.optCombo.addItem("Pivot MDS")
1682            self.optCombo.setCurrentIndex(self.optMethod)
1683            self.stepsSpin = OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 100000, 1, label="Iterations: ")
1684            self.stepsSpin.setEnabled(False)
1685
1686            self.optButton = OWGUI.button(self.optimizeBox, self, "Optimize layout", callback=self.graph_layout, toggleButton=1)
1687
1688            colorBox = OWGUI.widgetBox(self.verticesTab, "Vertex color attribute", orientation="horizontal", addSpace=False)
1689            self.colorCombo = OWGUI.comboBox(colorBox, self, "color", callback=self.setVertexColor)
1690            self.colorCombo.addItem("(same color)")
1691            OWGUI.button(colorBox, self, "Set vertex color palette", self.setColors, tooltip="Set vertex color palette", debuggingEnabled=0)
1692
1693            self.vertexSizeCombo = OWGUI.comboBox(self.verticesTab, self, "vertexSize", box="Vertex size attribute", callback=self.setVertexSize)
1694            self.vertexSizeCombo.addItem("(none)")
1695
1696            OWGUI.spin(self.vertexSizeCombo.box, self, "minVertexSize", 5, 200, 1, label="Min vertex size:", callback=self.setVertexSize)
1697            OWGUI.spin(self.vertexSizeCombo.box, self, "maxVertexSize", 5, 200, 1, label="Max vertex size:", callback=self.setVertexSize)
1698            OWGUI.checkBox(self.vertexSizeCombo.box, self, "invertSize", "Invert vertex size", callback=self.setVertexSize)
1699
1700            colorBox = OWGUI.widgetBox(self.edgesTab, "Edge color attribute", orientation="horizontal", addSpace=False)
1701            self.edgeColorCombo = OWGUI.comboBox(colorBox, self, "edgeColor", callback=self.setEdgeColor)
1702            self.edgeColorCombo.addItem("(same color)")
1703            OWGUI.button(colorBox, self, "Set edge color palette", self.setEdgeColorPalette, tooltip="Set edge color palette", debuggingEnabled=0)
1704
1705            self.attBox = OWGUI.widgetBox(self.verticesTab, "Vertex labels | tooltips", orientation="vertical", addSpace=False)
1706            OWGUI.spin(self.attBox, self, "fontSize", 4, 30, 1, label="Set font size:", callback=self.setFontSize)
1707
1708            self.attBox = OWGUI.widgetBox(self.attBox, orientation="horizontal", addSpace=False)
1709            self.attListBox = OWGUI.listBox(self.attBox, self, "markerAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedAttLstBox)
1710            self.tooltipListBox = OWGUI.listBox(self.attBox, self, "tooltipAttributes", "attributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedTooltipLstBox)
1711
1712            self.edgeLabelBox = OWGUI.widgetBox(self.edgesTab, "Edge labels", addSpace=False)
1713            self.edgeLabelListBox = OWGUI.listBox(self.edgeLabelBox, self, "edgeLabelAttributes", "edgeAttributes", selectionMode=QListWidget.MultiSelection, callback=self.clickedEdgeLabelListBox)
1714            self.edgeLabelBox.setEnabled(False)
1715
1716            ib = OWGUI.widgetBox(self.edgesTab, "General", orientation="vertical")
1717            OWGUI.checkBox(ib, self, 'showWeights', 'Show weights', callback=(lambda: self._set_canvas_attr('showWeights', self.showWeights)))
1718            OWGUI.checkBox(ib, self, 'showEdgeLabels', 'Show labels on edges', callback=(lambda: self._set_canvas_attr('showEdgeLabels', self.showEdgeLabels)))
1719            OWGUI.spin(ib, self, "maxLinkSize", 1, 50, 1, label="Max edge width:", callback=self.setMaxLinkSize)
1720            self.showDistancesCheckBox = OWGUI.checkBox(ib, self, 'showDistances', 'Explore vertex distances', callback=(lambda: self._set_canvas_attr('showDistances', self.showDistances)), disabled=1)
1721
1722            ib = OWGUI.widgetBox(self.verticesTab, "General", orientation="vertical")
1723            OWGUI.checkBox(ib, self, 'showIndexes', 'Show indexes', callback=(lambda: self._set_canvas_attr('showIndexes', self.showIndexes)))
1724            OWGUI.checkBox(ib, self, 'labelsOnMarkedOnly', 'Show labels on marked vertices only', callback=(lambda: self._set_canvas_attr('labelsOnMarkedOnly', self.labelsOnMarkedOnly)))
1725            OWGUI.checkBox(ib, self, 'renderAntialiased', 'Render antialiased', callback=(lambda: self._set_canvas_attr('renderAntialiased', self.renderAntialiased)))
1726            self.insideView = 0
1727            self.insideViewNeighbours = 2
1728            OWGUI.spin(ib, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked="insideView", checkCallback=self.insideview, callback=self.insideviewneighbours)
1729            OWGUI.checkBox(ib, self, 'showMissingValues', 'Show missing values', callback=(lambda: self._set_canvas_attr('showMissingValues', self.showMissingValues)))
1730
1731            ib = OWGUI.widgetBox(self.markTab, "Info", orientation="vertical")
1732            OWGUI.label(ib, self, "Vertices (shown/hidden): %(number_of_nodes_label)i (%(nShown)i/%(nHidden)i)")
1733            OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i")
1734
1735            ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback=self.setMarkMode)
1736            OWGUI.appendRadioButton(ribg, self, "hubs", "None", callback=self.setMarkMode)
1737            OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices", callback=self.setMarkMode)
1738            self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True)
1739            self.searchStringTimer = QTimer(self)
1740            self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setMarkMode)
1741
1742            OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertices", callback=self.setMarkMode)
1743            OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices", callback=self.setMarkMode)
1744            ib = OWGUI.indentedBox(ribg, orientation=0)
1745            self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setMarkMode(h)))
1746            #self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True)
1747            OWGUI.widgetLabel(ribg, "Mark  vertices with ...")
1748            OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections", callback=self.setMarkMode)
1749            OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections", callback=self.setMarkMode)
1750            self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setMarkMode(h)))
1751            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour", callback=self.setMarkMode)
1752            OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour", callback=self.setMarkMode)
1753            OWGUI.appendRadioButton(ribg, self, "hubs", "most connections", callback=self.setMarkMode)
1754            ib = OWGUI.indentedBox(ribg)
1755            self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setMarkMode(h)))
1756            OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)")
1757            self.markInputRadioButton = OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal", callback=self.setMarkMode)
1758            ib = OWGUI.indentedBox(ribg)
1759            self.markInput = 0
1760            self.markInputCombo = OWGUI.comboBox(ib, self, "markInput", callback=(lambda h=9: self.setMarkMode(h)))
1761            self.markInputRadioButton.setEnabled(False)
1762
1763            ib = OWGUI.widgetBox(self.markTab, "General", orientation="vertical")
1764            OWGUI.checkBox(ib, self, 'checkSendMarkedNodes', 'Send marked vertices', callback=self.setSendMarkedNodes, disabled=0)
1765
1766            T = OWToolbars.NavigateSelectToolbar
1767            self.zoomSelectToolbar = T(self, self.hcontroArea, self.networkCanvas, self.autoSendSelection,
1768                                      buttons=(T.IconZoom,
1769                                                 T.IconZoomExtent,
1770                                                 T.IconZoomSelection,
1771                                                 T.IconPan,
1772                                                 ("", "", "", None, None, 0),
1773                                                 #("Move selection", "buttonMoveSelection", "activateMoveSelection", QIcon(OWToolbars.dlg_select), Qt.ArrowCursor, 1),
1774                                                 T.IconRectangle,
1775                                                 #T.IconPolygon, 
1776                                                 T.IconSendSelection,
1777                                                 ("", "", "", None, None, 0, "select"),
1778                                                 ("Add marked to selection", "buttonM2S", "markedToSelection", QIcon(dlg_mark2sel), Qt.ArrowCursor, 0),
1779                                                 ("Add selection to marked", "buttonS2M", "selectionToMarked", QIcon(dlg_sel2mark), Qt.ArrowCursor, 0),
1780                                                 ("Remove selection", "buttonRMS", "removeSelection", QIcon(dlg_selIsmark), Qt.ArrowCursor, 0),
1781                                                 ("", "", "", None, None, 0, "select"),
1782                                                 ("Hide selected", "buttonSEL", "hideSelectedVertices", QIcon(dlg_selected), Qt.ArrowCursor, 0),
1783                                                 ("Hide unselected", "buttonUN", "hideUnSelectedVertices", QIcon(dlg_unselected), Qt.ArrowCursor, 0),
1784                                                 ("Show all nodes", "buttonSW", "showAllVertices", QIcon(dlg_showall), Qt.ArrowCursor, 0)))
1785
1786            OWGUI.rubber(self.zoomSelectToolbar)
1787
1788            ib = OWGUI.widgetBox(self.infoTab, "General")
1789            OWGUI.label(ib, self, "Number of vertices: %(number_of_nodes_label)i")
1790            OWGUI.label(ib, self, "Number of edges: %(number_of_edges_label)i")
1791            OWGUI.label(ib, self, "Vertices per edge: %(verticesPerEdge).2f")
1792            OWGUI.label(ib, self, "Edges per vertex: %(edgesPerVertex).2f")
1793            OWGUI.label(ib, self, "Diameter: %(diameter)i")
1794            OWGUI.label(ib, self, "Clustering Coefficient: %(clustering_coefficient).1f%%")
1795
1796            ib = OWGUI.widgetBox(self.infoTab, orientation="horizontal")
1797
1798            OWGUI.button(ib, self, "Degree distribution", callback=self.showDegreeDistribution, debuggingEnabled=False)
1799            OWGUI.button(ib, self, "Save network", callback=self.save_network, debuggingEnabled=False)
1800            OWGUI.button(ib, self, "Save image", callback=self.networkCanvas.saveToFile, debuggingEnabled=False)
1801
1802            #OWGUI.button(self.edgesTab, self, "Clustering", callback=self.clustering)
1803
1804            ib = OWGUI.widgetBox(self.infoTab, "Prototype")
1805
1806            #ib = OWGUI.widgetBox(ibProto, "Name components")
1807            OWGUI.lineEdit(ib, self, "organism", "Organism:", orientation='horizontal')
1808
1809            self.nameComponentAttribute = 0
1810            self.nameComponentCombo = OWGUI.comboBox(ib, self, "nameComponentAttribute", callback=self.nameComponents, label="Name components:", orientation="horizontal")
1811            self.nameComponentCombo.addItem("Select attribute")
1812
1813            self.showComponentAttribute = 0
1814            self.showComponentCombo = OWGUI.comboBox(ib, self, "showComponentAttribute", callback=self.showComponents, label="Labels on components:", orientation="horizontal")
1815            self.showComponentCombo.addItem("Select attribute")
1816            OWGUI.checkBox(ib, self, 'showTextMiningInfo', "Show text mining info")
1817
1818            #ib = OWGUI.widgetBox(ibProto, "Distance Matrix")
1819            ibs = OWGUI.widgetBox(ib, orientation="horizontal")
1820            self.btnMDS = OWGUI.button(ibs, self, "Fragviz", callback=self.mds_components, toggleButton=1)
1821            self.btnESIM = OWGUI.button(ibs, self, "eSim", callback=(lambda: self.mds_components(Orange.network.MdsType.exactSimulation)), toggleButton=1)
1822            self.btnMDSv = OWGUI.button(ibs, self, "MDS", callback=(lambda: self.mds_components(Orange.network.MdsType.MDS)), toggleButton=1)
1823            ibs = OWGUI.widgetBox(ib, orientation="horizontal")
1824            self.btnRotate = OWGUI.button(ibs, self, "Rotate", callback=self.rotateComponents, toggleButton=1)
1825            self.btnRotateMDS = OWGUI.button(ibs, self, "Rotate (MDS)", callback=self.rotateComponentsMDS, toggleButton=1)
1826            self.btnForce = OWGUI.button(ibs, self, "Draw Force", callback=self.drawForce, toggleButton=1)
1827            self.scalingRatio = 0
1828            OWGUI.spin(ib, self, "scalingRatio", 0, 9, 1, label="Set scalingRatio: ")
1829            OWGUI.doubleSpin(ib, self, "mdsStressDelta", 0, 10, 0.0000000000000001, label="Min stress change: ")
1830            OWGUI.spin(ib, self, "mdsSteps", 1, 100000, 1, label="MDS steps: ")
1831            OWGUI.spin(ib, self, "mdsRefresh", 1, 100000, 1, label="MDS refresh steps: ")
1832            ibs = OWGUI.widgetBox(ib, orientation="horizontal")
1833            OWGUI.checkBox(ibs, self, 'mdsTorgerson', "Torgerson's approximation")
1834            OWGUI.checkBox(ibs, self, 'mdsAvgLinkage', "Use average linkage")
1835            OWGUI.checkBox(ib, self, 'mdsFromCurrentPos', "MDS from current positions")
1836            self.mdsInfoA = OWGUI.widgetLabel(ib, "Avg. stress:")
1837            self.mdsInfoB = OWGUI.widgetLabel(ib, "Num. steps:")
1838            self.rotateSteps = 100
1839
1840            OWGUI.spin(ib, self, "rotateSteps", 1, 10000, 1, label="Rotate max steps: ")
1841            OWGUI.spin(ib, self, "minComponentEdgeWidth", 0, 100, 1, label="Min component edge width: ", callback=(lambda changedMin=1: self.setComponentEdgeWidth(changedMin)))
1842            OWGUI.spin(ib, self, "maxComponentEdgeWidth", 0, 200, 1, label="Max component edge width: ", callback=(lambda changedMin=0: self.setComponentEdgeWidth(changedMin)))
1843
1844            self.attSelectionAttribute = 0
1845            self.comboAttSelection = OWGUI.comboBox(ib, self, "attSelectionAttribute", label='Send attribute selection list:', orientation='horizontal', callback=self.sendAttSelectionList)
1846            self.comboAttSelection.addItem("Select attribute")
1847            self.autoSendAttributes = 0
1848            OWGUI.checkBox(ib, self, 'autoSendAttributes', "auto send attributes", callback=self.setAutoSendAttributes)
1849
1850            self.icons = self.createAttributeIconDict()
1851            self.setMarkMode()
1852
1853            self.editAttribute = 0
1854            self.editCombo = OWGUI.comboBox(self.infoTab, self, "editAttribute", label="Edit attribute:", orientation="horizontal")
1855            self.editCombo.addItem("Select attribute")
1856            self.editValue = ''
1857            OWGUI.lineEdit(self.infoTab, self, "editValue", "Value:", orientation='horizontal')
1858            OWGUI.button(self.infoTab, self, "Edit", callback=self.edit)
1859
1860            self.verticesTab.layout().addStretch(1)
1861            self.edgesTab.layout().addStretch(1)
1862            self.markTab.layout().addStretch(1)
1863            self.infoTab.layout().addStretch(1)
1864
1865            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
1866            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
1867            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
1868
1869            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
1870            self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
1871            self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
1872
1873            self.graph_layout_method()
1874            self.setFontSize()
1875            self.set_graph(None)
1876            self.setMinimumWidth(900)
1877
1878
1879
1880            #self.resize(1000, 600)
1881            #self.controlArea.setEnabled(False)
1882
1883        def setComponentEdgeWidth(self, changedMin=True):
1884            if self.networkCanvas is None:
1885                return
1886
1887            canvas = self.networkCanvas
1888            if changedMin:
1889                if self.maxComponentEdgeWidth < self.minComponentEdgeWidth:
1890                    self.maxComponentEdgeWidth = self.minComponentEdgeWidth
1891            else:
1892                if self.minComponentEdgeWidth > self.maxComponentEdgeWidth:
1893                    self.minComponentEdgeWidth = self.maxComponentEdgeWidth
1894
1895            canvas.minComponentEdgeWidth = self.minComponentEdgeWidth
1896            canvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
1897            self.networkCanvas.updateCanvas()
1898
1899        def setAutoSendAttributes(self):
1900            print 'TODO setAutoSendAttributes'
1901            #if self.autoSendAttributes:
1902            #    self.networkCanvas.callbackSelectVertex = self.sendAttSelectionList
1903            #else:
1904            #    self.networkCanvas.callbackSelectVertex = None
1905
1906        def sendAttSelectionList(self):
1907            if not self.graph is None:
1908                vars = [x.name for x in self.graph_base.links_vars()]
1909                if not self.comboAttSelection.currentText() in vars:
1910                    return
1911                att = str(self.comboAttSelection.currentText())
1912                vertices = self.networkCanvas.networkCurve.get_selected_vertices()
1913
1914                if len(vertices) != 1:
1915                    return
1916
1917                attributes = str(self.graph_base.items()[vertices[0]][att]).split(', ')
1918            else:
1919                attributes = None
1920            self.send("Features", attributes)
1921
1922        def edit(self):
1923            if self.graph is None:
1924                return
1925
1926            vars = [x.name for x in self.graph_base.items_vars()]
1927            if not self.editCombo.currentText() in vars:
1928                return
1929            att = str(self.editCombo.currentText())
1930            vertices = self.networkCanvas.networkCurve.get_selected_vertices()
1931
1932            if len(vertices) == 0:
1933                return
1934
1935            if self.graph_base.items().domain[att].var_type == Orange.data.Type.Continuous:
1936                for v in vertices:
1937                    self.graph_base.items()[v][att] = float(self.editValue)
1938            else:
1939                for v in vertices:
1940                    self.graph_base.items()[v][att] = str(self.editValue)
1941
1942            self.setItems(self.graph_base.items())
1943
1944        def drawForce(self):
1945            if self.btnForce.isChecked() and self.graph is not None:
1946                self.networkCanvas.forceVectors = self.layout._computeForces()
1947            else:
1948                self.networkCanvas.forceVectors = None
1949
1950            self.networkCanvas.updateCanvas()
1951
1952        def rotateProgress(self, curr, max):
1953            self.progressBarSet(int(curr * 100 / max))
1954            qApp.processEvents()
1955
1956        def rotateComponentsMDS(self):
1957            print "rotate"
1958            if self.items_matrix is None:
1959                self.information('Set distance matrix to input signal')
1960                self.btnRotateMDS.setChecked(False)
1961                return
1962
1963            if self.graph is None:
1964                self.information('No network found')
1965                self.btnRotateMDS.setChecked(False)
1966                return
1967            if self.items_matrix.dim != self.graph.number_of_nodes():
1968                self.error('Distance matrix dimensionality must equal number of vertices')
1969                self.btnRotateMDS.setChecked(False)
1970                return
1971
1972            if not self.btnRotateMDS.isChecked():
1973              self.layout.stopMDS = 1
1974              #self.btnMDS.setChecked(False)
1975              #self.btnMDS.setText("MDS on graph components")
1976              return
1977
1978            self.btnRotateMDS.setText("Stop")
1979            qApp.processEvents()
1980
1981            self.layout.items_matrix = self.items_matrix
1982            self.progressBarInit()
1983
1984            self.layout.mds_components(self.mdsSteps, self.mdsRefresh, self.mdsProgress, self.updateCanvas, self.mdsTorgerson, self.mdsStressDelta, rotationOnly=True, mdsFromCurrentPos=self.mdsFromCurrentPos)
1985
1986            self.btnRotateMDS.setChecked(False)
1987            self.btnRotateMDS.setText("Rotate graph components (MDS)")
1988            self.progressBarFinished()
1989
1990        def rotateComponents(self):
1991            if self.items_matrix is None:
1992                self.information('Set distance matrix to input signal')
1993                self.btnRotate.setChecked(False)
1994                return
1995
1996            if self.graph is None:
1997                self.information('No network found')
1998                self.btnRotate.setChecked(False)
1999                return
2000
2001            if self.items_matrix.dim != self.graph.number_of_nodes():
2002                self.error('Distance matrix dimensionality must equal number of vertices')
2003                self.btnRotate.setChecked(False)
2004                return
2005
2006            if not self.btnRotate.isChecked():
2007              self.layout.stopRotate = 1
2008              return
2009
2010            self.btnRotate.setText("Stop")
2011            qApp.processEvents()
2012
2013            self.layout.items_matrix = self.items_matrix
2014            self.progressBarInit()
2015            self.layout.rotateComponents(self.rotateSteps, 0.0001, self.rotateProgress, self.updateCanvas)
2016            self.btnRotate.setChecked(False)
2017            self.btnRotate.setText("Rotate graph components")
2018            self.progressBarFinished()
2019
2020        def mdsProgress(self, avgStress, stepCount):
2021            self.drawForce()
2022
2023            self.mdsInfoA.setText("Avg. Stress: %.20f" % avgStress)
2024            self.mdsInfoB.setText("Num. steps: %i" % stepCount)
2025            self.progressBarSet(int(stepCount * 100 / self.mdsSteps))
2026            qApp.processEvents()
2027
2028        def mds_components(self, mdsType=Orange.network.MdsType.componentMDS):
2029            if mdsType == Orange.network.MdsType.componentMDS:
2030                btn = self.btnMDS
2031            elif mdsType == Orange.network.MdsType.exactSimulation:
2032                btn = self.btnESIM
2033            elif mdsType == Orange.network.MdsType.MDS:
2034                btn = self.btnMDSv
2035
2036            btnCaption = btn.text()
2037
2038            if self.items_matrix is None:
2039                self.information('Set distance matrix to input signal')
2040                btn.setChecked(False)
2041                return
2042
2043            if self.layout is None:
2044                self.information('No network found')
2045                btn.setChecked(False)
2046                return
2047
2048            if self.items_matrix.dim != self.graph.number_of_nodes():
2049                self.error('Distance matrix dimensionality must equal number of vertices')
2050                btn.setChecked(False)
2051                return
2052
2053            if not btn.isChecked():
2054                self.layout.stopMDS = 1
2055                btn.setChecked(False)
2056                btn.setText(btnCaption)
2057                return
2058
2059            btn.setText("Stop")
2060            qApp.processEvents()
2061
2062            self.layout.items_matrix = self.items_matrix
2063            self.progressBarInit()
2064
2065            if self.mdsAvgLinkage:
2066                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)
2067            else:
2068                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)
2069
2070            btn.setChecked(False)
2071            btn.setText(btnCaption)
2072            self.progressBarFinished()
2073
2074        def set_items_distance_matrix(self, matrix):
2075            self.error('')
2076            self.information('')
2077            self.showDistancesCheckBox.setEnabled(0)
2078
2079            if matrix is None or self.graph is None:
2080                self.items_matrix = None
2081                self.layout.items_matrix = None
2082                if self.networkCanvas: self.networkCanvas.items_matrix = None
2083                return
2084
2085            if matrix.dim != self.graph.number_of_nodes():
2086                self.error('Distance matrix dimensionality must equal number of vertices')
2087                self.items_matrix = None
2088                self.layout.items_matrix = None
2089                if self.networkCanvas: self.networkCanvas.items_matrix = None
2090                return
2091
2092            self.items_matrix = matrix
2093            self.layout.items_matrix = matrix
2094            if self.networkCanvas: self.networkCanvas.items_matrix = matrix
2095            self.showDistancesCheckBox.setEnabled(1)
2096
2097            self.networkCanvas.updateCanvas()
2098
2099        def setSendMarkedNodes(self):
2100            if self.checkSendMarkedNodes:
2101                self.networkCanvas.sendMarkedNodes = self.sendMarkedNodes
2102                self.sendMarkedNodes(self.networkCanvas.getMarkedVertices())
2103            else:
2104                self.send("Marked Items", None)
2105                self.networkCanvas.sendMarkedNodes = None
2106
2107        def sendMarkedNodes(self, markedNodes):
2108            if len(markedNodes) == 0:
2109                self.send("Marked Items", None)
2110                return
2111
2112            if self.graph is not None and self.graph_base.items() is not None:
2113                items = self.graph_base.items().getitems(markedNodes)
2114                self.send("Marked Items", items)
2115                return
2116
2117            self.send("Marked Items", None)
2118
2119        def insideviewneighbours(self):
2120            if self.networkCanvas.insideview == 1:
2121                self.networkCanvas.insideviewNeighbours = self.insideViewNeighbours
2122                self.optButton.setChecked(True)
2123                self.graph_layout_fr(False)
2124
2125        def insideview(self):
2126            print self.networkCanvas.getSelectedVertices()
2127            if len(self.networkCanvas.getSelectedVertices()) == 1:
2128                if self.networkCanvas.insideview == 1:
2129                    print "insideview: 1"
2130                    self.networkCanvas.insideview = 0
2131                    self.networkCanvas.showAllVertices()
2132                    self.networkCanvas.updateCanvas()
2133                else:
2134                    print "insideview: 0"
2135                    self.networkCanvas.insideview = 1
2136                    self.networkCanvas.insideviewNeighbors = self.insideViewNeighbours
2137                    self.optButton.setChecked(True)
2138                    self.graph_layout_fr(False)
2139
2140            else:
2141                print "One node must be selected!"
2142
2143        def showComponents(self):
2144            if self.graph is None or self.graph_base.items() is None:
2145                return
2146
2147            vars = [x.name for x in self.graph_base.items_vars()]
2148
2149            if not self.showComponentCombo.currentText() in vars:
2150                self.networkCanvas.showComponentAttribute = None
2151                self.lastNameComponentAttribute = ''
2152            else:
2153                self.networkCanvas.showComponentAttribute = self.showComponentCombo.currentText()
2154
2155            self.networkCanvas.drawPlotItems()
2156
2157        def nameComponents(self):
2158            """Names connected components of genes according to GO terms."""
2159            self.progressBarFinished()
2160            self.lastNameComponentAttribute = None
2161
2162            if self.graph is None or self.graph_base.items() is None:
2163                return
2164
2165            vars = [x.name for x in self.graph_base.items_vars()]
2166            if not self.nameComponentCombo.currentText() in vars:
2167                return
2168
2169            self.progressBarInit()
2170            components = [c for c in Orange.network.nx.algorithms.components.connected_components(self.graph) if len(c) > 1]
2171            if 'component name' in self.graph_base.items().domain:
2172                keyword_table = self.graph_base.items()
2173            else:
2174                keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variable.String('component name')), [[''] for i in range(len(self.graph_base.items()))])
2175
2176            import obiGO
2177            ontology = obiGO.Ontology.Load(progressCallback=self.progressBarSet)
2178            annotations = obiGO.Annotations.Load(self.organism, ontology=ontology, progressCallback=self.progressBarSet)
2179
2180            allGenes = set([e[str(self.nameComponentCombo.currentText())].value for e in self.graph_base.items()])
2181            foundGenesets = False
2182            if len(annotations.geneNames & allGenes) < 1:
2183                allGenes = set(reduce(operator.add, [e[str(self.nameComponentCombo.currentText())].value.split(', ') for e in self.graph_base.items()]))
2184                if len(annotations.geneNames & allGenes) < 1:
2185                    self.warning('no genes found')
2186                    return
2187                else:
2188                    foundGenesets = True
2189
2190            def rank(a, j, reverse=False):
2191                if len(a) <= 0: return
2192
2193                if reverse:
2194                    a.sort(lambda x, y: 1 if x[j] > y[j] else -1 if x[j] < y[j] else 0)
2195                    top_value = a[0][j]
2196                    top_rank = len(a)
2197                    max_rank = float(len(a))
2198                    int_ndx = 0
2199                    for k in range(len(a)):
2200                        if top_value < a[k][j]:
2201                            top_value = a[k][j]
2202                            if k - int_ndx > 1:
2203                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
2204                                for l in range(int_ndx, k):
2205                                    a[l][j] = avg_rank
2206
2207                            int_ndx = k
2208
2209                        a[k][j] = top_rank / max_rank
2210                        top_rank -= 1
2211
2212                    k += 1
2213                    if k - int_ndx > 1:
2214                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
2215                        for l in range(int_ndx, k):
2216                            a[l][j] = avg_rank
2217
2218                else:
2219                    a.sort(lambda x, y: 1 if x[j] < y[j] else -1 if x[j] > y[j] else 0)
2220                    top_value = a[0][j]
2221                    top_rank = len(a)
2222                    max_rank = float(len(a))
2223                    int_ndx = 0
2224                    for k in range(len(a)):
2225                        if top_value > a[k][j]:
2226                            top_value = a[k][j]
2227                            if k - int_ndx > 1:
2228                                avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
2229                                for l in range(int_ndx, k):
2230                                    a[l][j] = avg_rank
2231
2232                            int_ndx = k
2233
2234                        a[k][j] = top_rank / max_rank
2235                        top_rank -= 1
2236
2237                    k += 1
2238                    if k - int_ndx > 1:
2239                        avg_rank = (a[int_ndx][j] + a[k - 1][j]) / 2
2240                        for l in range(int_ndx, k):
2241                            a[l][j] = avg_rank
2242
2243            for i in range(len(components)):
2244                component = components[i]
2245                if len(component) <= 1:
2246                    continue
2247
2248                if foundGenesets:
2249                    genes = reduce(operator.add, [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value.split(', ') for v in component])
2250                else:
2251                    genes = [self.graph_base.items()[v][str(self.nameComponentCombo.currentText())].value for v in component]
2252
2253                res1 = annotations.GetEnrichedTerms(genes, aspect="P")
2254                res2 = annotations.GetEnrichedTerms(genes, aspect="F")
2255                res = res1_base.items() + res2.items()
2256                #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]
2257                #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]
2258
2259                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]
2260                if len(namingScore) == 0:
2261                    continue
2262
2263                annotated_genes = max([a[0] for a in namingScore])
2264
2265                rank(namingScore, 1, reverse=True)
2266                rank(namingScore, 2, reverse=True)
2267                rank(namingScore, 0)
2268
2269                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]
2270                namingScore.sort(reverse=True)
2271
2272                if len(namingScore) < 1:
2273                    print "warning. no annotations found for group of genes: " + ", ".join(genes)
2274                    continue
2275                elif len(namingScore[0]) < 2:
2276                    print "warning. error computing score for group of genes: " + ", ".join(genes)
2277                    continue
2278
2279                for v in component:
2280                    name = str(namingScore[0][1])
2281                    attrs = "%d/%d, %d, %lf" % (namingScore[0][2], annotated_genes, namingScore[0][3], namingScore[0][4])
2282                    info = ''
2283                    if self.showTextMiningInfo:
2284                        info = "\n" + attrs + "\n" + str(namingScore[0][0])
2285                    keyword_table[v]['component name'] = name + info
2286
2287                self.progressBarSet(i * 100.0 / len(components))
2288
2289            self.lastNameComponentAttribute = self.nameComponentCombo.currentText()
2290            self.setItems(Orange.data.Table([self.graph_base.items(), keyword_table]))
2291            self.progressBarFinished()
2292
2293        def nameComponents_old(self):
2294            if self.graph is None or self.graph_base.items() is None:
2295                return
2296
2297            vars = [x.name for x in self.graph_base.items_vars()]
2298
2299            if not self.nameComponentCombo.currentText() in vars:
2300                return
2301
2302            components = Orange.network.nx.algorithms.components.connected_components(self.graph)
2303            keyword_table = Orange.data.Table(Orange.data.Domain(Orange.data.variables.String('component name')), [[''] for i in range(len(self.graph_base.items()))])
2304
2305            excludeWord = ["AND", "OF", "KEGG", "ST", "IN", "SIG"]
2306            excludePart = ["HSA"]
2307            keywords = set()
2308            sameKeywords = set()
2309
2310            for component in components:
2311                words = []
2312                all_values = []
2313                for vertex in component:
2314                    values = []
2315                    value = str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())])
2316
2317                    value = value.replace(" ", ",")
2318                    value_top = value.split(",")
2319
2320                    for value in value_top:
2321                        if len(value) > 0:
2322                            tmp = value.split("_")
2323                            tmp = [value.strip() for value in tmp if len(value) > 0]
2324                            all_values.append(tmp)
2325                            values.extend(tmp)
2326
2327                    values = [value.strip() for value in values if len(value) > 0]
2328                    words.extend(values)
2329
2330
2331                    #value =  str(self.graph.items()[vertex][str(self.nameComponentCombo.currentText())])
2332                    #value = value.replace(" ", "_")
2333                    #value = value.replace(",", "_")
2334                    #values = value.split("_")
2335                    #values = [value.strip() for value in values if len(value) > 0]
2336                    #print "values:", values
2337                    #all_values.append(values)
2338
2339                    #words.extend(values)
2340                #print "all_values:", all_values
2341                toExclude = []
2342
2343                words = [word for word in words if not word.upper() in excludeWord]
2344                toExclude = [word for word in words for part in excludePart if word.find(part) != -1]
2345
2346                for word in toExclude:
2347                    try:
2348                        while True:
2349                            words.remove(word)
2350                    except:
2351                        pass
2352
2353                counted_words = {}
2354                for word in words:
2355                    if word in counted_words:
2356                        count = counted_words[word]
2357                        counted_words[word] = count + 1
2358                    else:
2359                        counted_words[word] = 1
2360
2361                words = sorted(counted_words.items(), key=itemgetter(1), reverse=True)
2362                keyword = ""
2363                keyword_words = []
2364                max_count = 0
2365                i = 0
2366
2367                while i < len(words) and words[i][1] >= max_count:
2368                    max_count = words[i][1]
2369                    keyword += words[i][0] + " "
2370                    keyword_words.append(words[i][0])
2371                    i += 1
2372
2373                if len(keyword_words) > 1:
2374                    new_all_values = []
2375                    for values in all_values:
2376                        new_values = [value for value in values if value in keyword_words]
2377                        new_all_values.append(new_values)
2378
2379                    #print new_all_values
2380                    word_position = []
2381
2382                    for word in keyword_words:
2383                        sum = 0
2384                        for v in new_all_values:
2385                            if word in v:
2386                                sum += v.index(word)
2387
2388                        word_position.append((word, sum))
2389
2390                    words = sorted(word_position, key=itemgetter(1))
2391                    #print "words:", words
2392                    #print all_values
2393                    #print new_all_values
2394
2395                    keyword = ""
2396                    for word in words:
2397                        keyword += word[0] + " "
2398
2399                keyword = keyword.strip()
2400
2401                for vertex in component:
2402                    keyword_table[vertex]['component name'] = keyword
2403
2404                if keyword in keywords:
2405                    sameKeywords.add(keyword)
2406                else:
2407                    keywords.add(keyword)
2408            #print "sameKeywords:", sameKeywords       
2409            sameComponents = [component for component in components if str(keyword_table[component[0]]['component name']) in sameKeywords]
2410            #print "same components:", sameComponents
2411
2412            for component in sameComponents:
2413                words = []
2414                all_values = []
2415                for vertex in component:
2416                    values = []
2417                    value = str(self.graph_base.items()[vertex][str(self.nameComponentCombo.currentText())])
2418
2419                    value = value.replace(" ", ",")
2420                    value_top = value.split(",")
2421
2422                    for value in value_top:
2423                        if len(value) > 0:
2424                            tmp = value.split("_")
2425                            tmp = [value.strip() for value in tmp if len(value) > 0]
2426                            all_values.append(tmp)
2427                            values.extend(tmp)
2428
2429                    values = [value.strip() for value in values if len(value) > 0]
2430                    words.extend(values)
2431
2432                toExclude = []
2433
2434                words = [word for word in words if not word.upper() in excludeWord]
2435                toExclude = [word for word in words for part in excludePart if word.find(part) != -1]
2436
2437                for word in toExclude:
2438                    try:
2439                        while True:
2440                            words.remove(word)
2441                    except:
2442                        pass
2443
2444                counted_words = {}
2445                for word in words:
2446                    if word in counted_words:
2447                        count = counted_words[word]
2448                        counted_words[word] = count + 1
2449                    else:
2450                        counted_words[word] = 1
2451
2452                words = sorted(counted_words.items(), key=itemgetter(1), reverse=True)
2453                keyword = ""
2454                counts = [int(word[1]) for word in words]
2455                max_count = max(counts)
2456
2457                try:
2458                    while True and len(counts) > 1:
2459                        counts.remove(max_count)
2460                except:
2461                    pass
2462                max_count = max(counts)
2463                i = 0
2464                keyword_words = []
2465                while i < len(words) and words[i][1] >= max_count:
2466                    keyword += words[i][0] + " "
2467                    keyword_words.append(words[i][0])
2468                    i += 1
2469
2470                if len(keyword_words) > 1:
2471                    new_all_values = []
2472                    for values in all_values:
2473                        new_values = [value for value in values if value in keyword_words]
2474                        new_all_values.append(new_values)
2475
2476                    #print new_all_values
2477                    word_position = []
2478
2479                    for word in keyword_words:
2480                        sum = 0
2481                        for v in new_all_values:
2482                            if word in v:
2483                                sum += v.index(word)
2484
2485                        word_position.append((word, sum))
2486
2487                    words = sorted(word_position, key=itemgetter(1))
2488                    #print "words:", words
2489                    #print all_values
2490                    #print new_all_values
2491
2492                    keyword = ""
2493                    for word in words:
2494                        keyword += word[0] + " "
2495
2496                keyword = keyword.strip()
2497                for vertex in component:
2498                    keyword_table[vertex]['component name'] = keyword
2499
2500            self.lastNameComponentAttribute = self.nameComponentCombo.currentText()
2501            #print "self.lastNameComponentAttribute:", self.lastNameComponentAttribute
2502            items = Orange.data.Table([self.graph_base.items(), keyword_table])
2503            self.setItems(items)
2504
2505            #for item in items:
2506            #    print item
2507
2508        def _set_canvas_attr(self, attr, value):
2509            setattr(self.networkCanvas, attr, value)
2510            self.networkCanvas.updateCanvas()
2511
2512        def setSearchStringTimer(self):
2513            self.hubs = 1
2514            self.searchStringTimer.stop()
2515            self.searchStringTimer.start(1000)
2516
2517        def setMarkMode(self, i=None):
2518            self.searchStringTimer.stop()
2519            if not i is None:
2520                self.hubs = i
2521
2522            #print self.hubs
2523            self.networkCanvas.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0
2524            self.networkCanvas.markWithRed = False
2525
2526            if self.graph is None:
2527                return
2528
2529            hubs = self.hubs
2530            if hubs == 0:
2531                self.networkCanvas.setMarkedVertices([])
2532                self.networkCanvas.replot()
2533                return
2534
2535            elif hubs == 1:
2536                #print "mark on given label"
2537                txt = self.markSearchString
2538                labelText = self.networkCanvas.labelText
2539                self.networkCanvas.markWithRed = self.graph.number_of_nodes > 200
2540
2541                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()])]
2542                self.networkCanvas.setMarkedVertices(toMark)
2543                self.networkCanvas.replot()
2544                return
2545
2546            elif hubs == 2:
2547                #print "mark on focus"
2548                self.networkCanvas.unmark()
2549                self.networkCanvas.tooltipNeighbours = self.markDistance
2550                return
2551
2552            elif hubs == 3:
2553                #print "mark selected"
2554                self.networkCanvas.unmark()
2555                self.networkCanvas.selectionNeighbours = self.markDistance
2556                self.networkCanvas.markSelectionNeighbours()
2557                return
2558
2559            self.networkCanvas.tooltipNeighbours = self.networkCanvas.selectionNeighbours = 0
2560            powers = self.graph.degree()
2561            powers = [powers[key] for key in sorted(powers.keys())]
2562
2563            if hubs == 4: # at least N connections
2564                #print "mark at least N connections"
2565                N = self.markNConnections
2566                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power >= N])
2567                self.networkCanvas.replot()
2568            elif hubs == 5:
2569                #print "mark at most N connections"
2570                N = self.markNConnections
2571                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power <= N])
2572                self.networkCanvas.replot()
2573            elif hubs == 6:
2574                #print "mark more than any"
2575                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > max([0] + [powers[nn] for nn in self.graph.getNeighbours(i)])])
2576                self.networkCanvas.replot()
2577            elif hubs == 7:
2578                #print "mark more than avg"
2579                self.networkCanvas.setMarkedVertices([i for i, power in enumerate(powers) if power > statc.mean([0] + [powers[nn] for nn in self.graph.getNeighbours(i)])])
2580                self.networkCanvas.replot()
2581            elif hubs == 8:
2582                #print "mark most"
2583                sortedIdx = range(len(powers))
2584                sortedIdx.sort(lambda x, y:-cmp(powers[x], powers[y]))
2585                cutP = self.markNumber - 1
2586                cutPower = powers[sortedIdx[cutP]]
2587                while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower:
2588                    cutP += 1
2589                self.networkCanvas.setMarkedVertices(sortedIdx[:cutP])
2590                self.networkCanvas.replot()
2591            elif hubs == 9:
2592                self.setMarkInput()
2593
2594        def testRefresh(self):
2595            start = time.time()
2596            self.networkCanvas.replot()
2597            stop = time.time()
2598            print "replot in " + str(stop - start)
2599
2600        def save_network(self):
2601            if self.networkCanvas is None or self.graph is None:
2602                return
2603
2604            filename = QFileDialog.getSaveFileName(self, 'Save Network File', '', 'NetworkX graph as Python pickle (*.gpickle)\nPajek network (*.net)\nGML network (*.gml)')
2605            if filename:
2606                fn = ""
2607                head, tail = os.path.splitext(str(filename))
2608                if not tail:
2609                    fn = head + ".net"
2610                else:
2611                    fn = str(filename)
2612
2613                for i in range(self.graph.number_of_nodes()):
2614                    node = self.graph.node[i]
2615                    node['x'] = self.layout.coors[0][i]
2616                    node['y'] = self.layout.coors[1][i]
2617
2618                Orange.network.readwrite.write(self.graph, fn)
2619
2620        def sendData(self):
2621            if len(self.signalManager.getLinks(self, None, \
2622                    "Selected Items", None)) > 0 or \
2623                        len(self.signalManager.getLinks(self, None, \
2624                                                "Unselected Items", None)) > 0:
2625                # signal connected
2626                graph = self.networkCanvas.getSelectedGraph()
2627                vertices = self.networkCanvas.getSelectedVertices()
2628
2629                if graph is not None:
2630                    if graph.items() is not None:
2631                        self.send("Selected Items", graph.items())
2632                    else:
2633                        nodes = self.networkCanvas.getSelectedExamples()
2634
2635                        if len(nodes) > 0 and self.graph_base.items() is not None:
2636                            self.send("Selected Items", self.graph_base.items().getitems(nodes))
2637                        else:
2638                            self.send("Selected Items", None)
2639
2640                    nodes = self.networkCanvas.getUnselectedExamples()
2641                    if len(nodes) > 0 and self.graph_base.items() is not None:
2642                        self.send("Other Items", self.graph_base.items().getitems(nodes))
2643                    else:
2644                        self.send("Other Items", None)
2645
2646                    self.send("Selected Network", graph)
2647                else:
2648                    nodes = self.networkCanvas.getSelectedExamples()
2649                    if len(nodes) > 0 and self.graph_base.items() is not None:
2650                        self.send("Selected Items", self.graph_base.items().getitems(nodes))
2651                    else:
2652                        self.send("Selected Items", None)
2653
2654                    nodes = self.networkCanvas.getUnselectedExamples()
2655                    if len(nodes) > 0 and self.graph_base.items() is not None:
2656                        self.send("Other Items", self.graph_base.items().getitems(nodes))
2657                    else:
2658                        self.send("Other Items", None)
2659
2660            if len(self.signalManager.getLinks(self, None, \
2661                                "Selected Items Distance Matrix", None)) > 0:
2662                # signal connected
2663                matrix = None
2664                if self.items_matrix is not None:
2665                    matrix = self.items_matrix.getitems(vertices)
2666
2667                self.send("Distance Matrix", matrix)
2668
2669        def setCombos(self):
2670            vars = self.graph_base.items_vars()
2671            edgeVars = self.graph_base.links_vars()
2672            lastLabelColumns = self.lastLabelColumns
2673            lastTooltipColumns = self.lastTooltipColumns
2674
2675            self.clearCombos()
2676
2677            self.attributes = [(var.name, var.varType) for var in vars]
2678            self.edgeAttributes = [(var.name, var.varType) for var in edgeVars]
2679
2680            for var in vars:
2681                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]:
2682                    self.colorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2683
2684                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:
2685
2686                    value = self.graph_base.items()[0][var].value
2687
2688                    # can value be a list?
2689                    try:
2690                        if type(eval(value)) == type([]):
2691                            self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2692                            continue
2693                    except:
2694                        pass
2695
2696                    if len(value.split(',')) > 1:
2697                        self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), "num of " + unicode(var.name))
2698
2699                elif var.varType in [Orange.data.Type.Continuous]:
2700                    self.vertexSizeCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2701
2702                self.nameComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2703                self.showComponentCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2704                self.editCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2705                self.comboAttSelection.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2706
2707            for var in edgeVars:
2708                if var.varType in [Orange.data.Type.Discrete, Orange.data.Type.Continuous]:
2709                    self.edgeColorCombo.addItem(self.icons.get(var.varType, self.icons[-1]), unicode(var.name))
2710
2711            for i in range(self.vertexSizeCombo.count()):
2712                if self.lastVertexSizeColumn == self.vertexSizeCombo.itemText(i):
2713                    self.vertexSize = i
2714                    break
2715
2716            for i in range(self.colorCombo.count()):
2717                if self.lastColorColumn == self.colorCombo.itemText(i):
2718                    self.color = i
2719                    break
2720
2721            for i in range(self.attListBox.count()):
2722                if str(self.attListBox.item(i).text()) in lastLabelColumns:
2723                    self.attListBox.item(i).setSelected(1)
2724
2725            for i in range(self.tooltipListBox.count()):
2726                if str(self.tooltipListBox.item(i).text()) in lastTooltipColumns:
2727                    self.tooltipListBox.item(i).setSelected(1)
2728
2729            self.lastLabelColumns = lastLabelColumns
2730            self.lastTooltipColumns = lastTooltipColumns
2731
2732        def clearCombos(self):
2733            self.attributes = []
2734            self.edgeAttributes = []
2735
2736            self.colorCombo.clear()
2737            self.vertexSizeCombo.clear()
2738            self.nameComponentCombo.clear()
2739            self.showComponentCombo.clear()
2740            self.edgeColorCombo.clear()
2741            self.editCombo.clear()
2742            self.comboAttSelection.clear()
2743
2744            self.colorCombo.addItem("(same color)")
2745            self.edgeColorCombo.addItem("(same color)")
2746            self.vertexSizeCombo.addItem("(same size)")
2747            self.nameComponentCombo.addItem("Select attribute")
2748            self.showComponentCombo.addItem("Select attribute")
2749            self.editCombo.addItem("Select attribute")
2750            self.comboAttSelection.addItem("Select attribute")
2751
2752        def change_graph(self, newgraph):
2753            old_nodes = set(self.graph.nodes_iter())
2754            new_nodes = set(newgraph.nodes_iter())
2755            inter_nodes = old_nodes.intersection(new_nodes)
2756            remove_nodes = old_nodes.difference(inter_nodes)
2757            add_nodes = new_nodes.difference(inter_nodes)
2758
2759            [self.networkCanvas.networkCurve.coors.pop(c) for c in remove_nodes]
2760            self.networkCanvas.networkCurve.coors.update((node, (0, 0)) for node in add_nodes)
2761            positions = [self.networkCanvas.networkCurve.coors[key] for key in sorted(self.networkCanvas.networkCurve.coors.iterkeys())]
2762            self.layout.set_graph(newgraph, positions)
2763
2764            self.graph = newgraph
2765            self.number_of_nodes_label = self.graph.number_of_nodes()
2766            self.number_of_edges_label = self.graph.number_of_edges()
2767
2768            self.networkCanvas.change_graph(self.graph, inter_nodes, add_nodes, remove_nodes)
2769
2770    #        self.nShown = self.graph.number_of_nodes()
2771    #       
2772    #        if self.graph.number_of_edges() > 0:
2773    #            self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges())
2774    #        else:
2775    #            self.verticesPerEdge = 0
2776    #           
2777    #        if self.graph.number_of_nodes() > 0:
2778    #            self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes())
2779    #        else:
2780    #            self.edgesPerVertex = 0
2781    #       
2782    #        undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph
2783    #        components = Orange.network.nx.algorithms.components.connected_components(undirected_graph)
2784    #        if len(components) > 1:
2785    #            self.diameter = -1
2786    #        else:
2787    #            self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph)
2788    #        self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100
2789
2790            k = 1.13850193174e-008
2791            nodes = self.graph.number_of_nodes()
2792            t = k * nodes * nodes
2793            self.frSteps = int(5.0 / t)
2794            if self.frSteps < 1: self.frSteps = 1;
2795            if self.frSteps > 3000: self.frSteps = 3000;
2796
2797            if self.frSteps < 10:
2798                self.renderAntialiased = 0
2799                self.minVertexSize = 5
2800                self.maxVertexSize = 5
2801                self.maxLinkSize = 1
2802                self.optMethod = 0
2803                self.graph_layout_method()
2804
2805            #self.setVertexColor()
2806            #self.setEdgeColor()
2807            #self.networkCanvas.setEdgesSize()
2808
2809            #self.clickedAttLstBox()
2810            #self.clickedTooltipLstBox()
2811            #self.clickedEdgeLabelListBox()
2812
2813            self.optButton.setChecked(1)
2814            self.graph_layout()
2815            self.information(0)
2816
2817        def set_graph(self, graph):
2818            self.set_items_distance_matrix(None)
2819
2820            if graph is None:
2821                self.graph = None
2822                self.graph_base = None
2823                self.layout.set_graph(None)
2824                self.networkCanvas.set_graph_layout(None, None)
2825                self.clearCombos()
2826                self.number_of_nodes_label = -1
2827                self.number_of_edges_label = -1
2828                self._items = None
2829                self._links = None
2830                return
2831
2832            self.graph_base = graph
2833
2834            if self._network_view is not None:
2835                graph = self._network_view.init_network(graph)
2836
2837
2838            #print "OWNetwork/setGraph: new visualizer..."
2839            self.graph = graph
2840
2841            if self._items is not None and 'x' in self._items.domain and 'y' in self._items.domain:
2842                positions = [(self._items[node]['x'].value, self._items[node]['y'].value) \
2843                             for node in sorted(self.graph) if self._items[node]['x'].value != '?' \
2844                             and self._items[node]['y'].value != '?']
2845                self.layout.set_graph(self.graph, positions)
2846            else:
2847                self.layout.set_graph(self.graph)
2848
2849            self.number_of_nodes_label = self.graph.number_of_nodes()
2850            self.number_of_edges_label = self.graph.number_of_edges()
2851
2852            self.networkCanvas.set_graph_layout(self.graph, self.layout, items=self.graph_base.items(), links=self.graph_base.links())
2853            self.networkCanvas.renderAntialiased = self.renderAntialiased
2854            self.networkCanvas.showEdgeLabels = self.showEdgeLabels
2855            self.networkCanvas.minVertexSize = self.minVertexSize
2856            self.networkCanvas.maxVertexSize = self.maxVertexSize
2857            self.networkCanvas.maxEdgeSize = self.maxLinkSize
2858            self.networkCanvas.minComponentEdgeWidth = self.minComponentEdgeWidth
2859            self.networkCanvas.maxComponentEdgeWidth = self.maxComponentEdgeWidth
2860            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
2861            self.lastColorColumn = self.colorCombo.currentText()
2862
2863            self.nShown = self.graph.number_of_nodes()
2864
2865            if self.graph.number_of_edges() > 0:
2866                self.verticesPerEdge = float(self.graph.number_of_nodes()) / float(self.graph.number_of_edges())
2867            else:
2868                self.verticesPerEdge = 0
2869
2870            if self.graph.number_of_nodes() > 0:
2871                self.edgesPerVertex = float(self.graph.number_of_edges()) / float(self.graph.number_of_nodes())
2872            else:
2873                self.edgesPerVertex = 0
2874
2875            undirected_graph = self.graph.to_undirected() if self.graph.is_directed() else self.graph
2876            components = Orange.network.nx.algorithms.components.connected_components(undirected_graph)
2877            if len(components) > 1:
2878                self.diameter = -1
2879            else:
2880                self.diameter = Orange.network.nx.algorithms.distance_measures.diameter(self.graph)
2881
2882            if self.graph.is_multigraph():
2883                self.clustering_coefficient = -1
2884            else:
2885                self.clustering_coefficient = Orange.network.nx.algorithms.cluster.average_clustering(undirected_graph) * 100
2886
2887            self.setCombos()
2888
2889            lastNameComponentAttributeFound = False
2890            for i in range(self.nameComponentCombo.count()):
2891                if self.lastNameComponentAttribute == self.nameComponentCombo.itemText(i):
2892                    lastNameComponentAttributeFound = True
2893                    self.nameComponentAttribute = i
2894                    self.nameComponents()
2895                    self.showComponentAttribute = self.showComponentCombo.count() - 1
2896                    self.showComponents()
2897                    break
2898
2899            if not lastNameComponentAttributeFound:
2900                self.lastNameComponentAttribute = ''
2901
2902            self.showComponentAttribute = None
2903
2904            k = 1.13850193174e-008
2905            nodes = self.graph.number_of_nodes()
2906            t = k * nodes * nodes
2907            self.frSteps = int(5.0 / t)
2908            if self.frSteps < 1: self.frSteps = 1;
2909            if self.frSteps > 3000: self.frSteps = 3000;
2910
2911            self.networkCanvas.labelsOnMarkedOnly = self.labelsOnMarkedOnly
2912            self.networkCanvas.showWeights = self.showWeights
2913            self.networkCanvas.showIndexes = self.showIndexes
2914            # if graph is large, set random layout, min vertex size, min edge size
2915            if self.frSteps < 10:
2916                self.renderAntialiased = 0
2917                self.minVertexSize = 5
2918                self.maxVertexSize = 5
2919                self.maxLinkSize = 1
2920                self.optMethod = 0
2921                self.graph_layout_method()
2922
2923            if self.vertexSize > 0:
2924                self.networkCanvas.setVerticesSize(self.vertexSizeCombo.currentText(), self.invertSize)
2925            else:
2926                self.networkCanvas.setVerticesSize()
2927
2928            self.setVertexColor()
2929            self.setEdgeColor()
2930
2931            self.networkCanvas.setEdgesSize()
2932            self.clickedAttLstBox()
2933            self.clickedTooltipLstBox()
2934            self.clickedEdgeLabelListBox()
2935
2936            self.optButton.setChecked(1)
2937            self.graph_layout()
2938            self.information(0)
2939            #self.networkCanvas.updateCanvas()
2940
2941        def set_network_view(self, nxView):
2942            self._network_view = nxView
2943            self._network_view.set_nx_explorer(self)
2944            self.networkCanvas.callbackSelectVertex = self._network_view.nodes_selected
2945            self.set_graph(self.graph_base)
2946
2947        def setItems(self, items=None):
2948            self.error('')
2949
2950            if self.graph is None or items is None:
2951                return
2952
2953            if len(items) != self.graph_base.number_of_nodes():
2954                self.error('ExampleTable items must have one example for each vertex.')
2955                return
2956
2957            self.graph_base.set_items(items)
2958
2959            self.setVertexSize()
2960            self.networkCanvas.showIndexes = self.showIndexes
2961            self.networkCanvas.showWeights = self.showWeights
2962            self.networkCanvas.showEdgeLabels = self.showEdgeLabels
2963            self.setCombos()
2964            self.networkCanvas.updateData()
2965
2966        def setMarkInput(self):
2967            var = str(self.markInputCombo.currentText())
2968            #print 'combo:',self.markInputCombo.currentText()
2969            if self.markInputItems is not None and len(self.markInputItems) > 0:
2970                values = [str(x[var]).strip().upper() for x in self.markInputItems]
2971                toMark = [i for (i, x) in enumerate(self.graph) if str(self.graph_base.items()[x][var]).strip().upper() in values]
2972                #print "mark:", toMark
2973                self.networkCanvas.setMarkedVertices(list(toMark))
2974                self.networkCanvas.replot()
2975
2976            else:
2977                self.networkCanvas.setMarkedVertices([])
2978                self.networkCanvas.replot()
2979
2980        def markItems(self, items):
2981            self.markInputCombo.clear()
2982            self.markInputRadioButton.setEnabled(False)
2983            self.markInputItems = items
2984
2985            if self.graph is None or self.graph_base.items() is None or items is None:
2986                return
2987
2988            if len(items) > 0:
2989                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()]
2990                lstNewDomain = [x.name for x in items.domain] + [items.domain[x].name for x in items.domain.getmetas()]
2991                commonVars = set(lstNewDomain) & set(lstOrgDomain)
2992
2993                if len(commonVars) > 0:
2994                    for var in commonVars:
2995                        orgVar = self.graph_base.items().domain[var]
2996                        mrkVar = items.domain[var]
2997
2998                        if orgVar.varType == mrkVar.varType and orgVar.varType == Orange.data.Type.String:
2999                            self.markInputCombo.addItem(self.icons[orgVar.varType], unicode(orgVar.name))
3000                            self.markInputRadioButton.setEnabled(True)
3001
3002                            self.setMarkMode(9)
3003
3004        def setExampleSubset(self, subset):
3005            if self.networkCanvas is None:
3006                return
3007
3008            self.warning('')
3009            hiddenNodes = []
3010
3011            if subset is not None:
3012                try:
3013                    expected = 1
3014                    for row in subset:
3015                        index = int(row['index'].value)
3016                        if expected != index:
3017                            hiddenNodes += range(expected - 1, index - 1)
3018                            expected = index + 1
3019                        else:
3020                            expected += 1
3021
3022                    hiddenNodes += range(expected - 1, self.graph.number_of_nodes())
3023
3024                    self.networkCanvas.setHiddenNodes(hiddenNodes)
3025                except:
3026                    self.warning('"index" attribute does not exist in "items" table.')
3027
3028        def showDegreeDistribution(self):
3029            if self.graph is None:
3030                return
3031
3032            from matplotlib import rcParams
3033            import pylab as p
3034
3035            x = self.graph.degree().values()
3036            nbins = len(set(x))
3037            if nbins > 500:
3038              bbins = 500
3039
3040            # the histogram of the data
3041            n, bins, patches = p.hist(x, nbins)
3042
3043            p.xlabel('Degree')
3044            p.ylabel('No. of nodes')
3045            p.title(r'Degree distribution')
3046
3047            p.show()
3048
3049        def setColors(self):
3050            dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
3051            if dlg.exec_():
3052                self.colorSettings = dlg.getColorSchemas()
3053                self.selectedSchemaIndex = dlg.selectedSchemaIndex
3054                self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
3055                self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
3056
3057                self.setVertexColor()
3058
3059        def setEdgeColorPalette(self):
3060            dlg = self.createColorDialog(self.edgeColorSettings, self.selectedEdgeSchemaIndex)
3061            if dlg.exec_():
3062                self.edgeColorSettings = dlg.getColorSchemas()
3063                self.selectedEdgeSchemaIndex = dlg.selectedSchemaIndex
3064                self.networkCanvas.contEdgePalette = dlg.getContinuousPalette("contPalette")
3065                self.networkCanvas.discEdgePalette = dlg.getDiscretePalette("discPalette")
3066
3067                self.setEdgeColor()
3068
3069        def createColorDialog(self, colorSettings, selectedSchemaIndex):
3070            c = OWColorPalette.ColorPaletteDlg(self, "Color Palette")
3071            c.createDiscretePalette("discPalette", "Discrete Palette")
3072            c.createContinuousPalette("contPalette", "Continuous Palette")
3073            c.setColorSchemas(colorSettings, selectedSchemaIndex)
3074            return c
3075
3076        """
3077        Layout Optimization
3078        """
3079
3080        def graph_layout(self):
3081            if self.graph is None:   #grafa se ni
3082                self.optButton.setChecked(False)
3083                return
3084
3085            if not self.optButton.isChecked():
3086                self.optButton.setChecked(False)
3087                return
3088
3089            qApp.processEvents()
3090
3091            if self.optMethod == 1:
3092                self.layout.random()
3093            elif self.optMethod == 2:
3094                self.graph_layout_fr(False)
3095            elif self.optMethod == 3:
3096                self.graph_layout_fr(True)
3097            elif self.optMethod == 4:
3098                self.graph_layout_fr_radial()
3099            elif self.optMethod == 5:
3100                self.layout.circular_crossing_reduction()
3101            elif self.optMethod == 6:
3102                self.layout.circular_original()
3103            elif self.optMethod == 7:
3104                self.layout.circular_random()
3105            elif self.optMethod == 8:
3106                self.graph_layout_pivot_mds()
3107
3108            self.optButton.setChecked(False)
3109            self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)
3110            self.networkCanvas.updateCanvas()
3111            qApp.processEvents()
3112
3113        def graph_layout_method(self, method=None):
3114            self.information()
3115            self.stepsSpin.label.setText('Iterations: ')
3116
3117            if method is not None:
3118                self.optMethod = method
3119
3120            if str(self.optMethod) == '0':
3121                self.optButton.setEnabled(False)
3122            else:
3123                self.optButton.setEnabled(True)
3124
3125            if str(self.optMethod) in ['2', '3', '4']:
3126                self.stepsSpin.setEnabled(True)
3127            elif str(self.optMethod) == '8':
3128                self.stepsSpin.label.setText('Pivots: ')
3129                self.stepsSpin.setEnabled(True)
3130
3131                if self.items_matrix is None:
3132                    self.information('Set distance matrix to input signal')
3133                    return
3134                if self.graph is None:
3135                    self.information('No network found')
3136                    return
3137                if self.items_matrix.dim != self.graph.number_of_nodes():
3138                    self.error('Distance matrix dimensionality must equal number of vertices')
3139                    return
3140            else:
3141                self.stepsSpin.setEnabled(False)
3142                self.optButton.setChecked(True)
3143                self.graph_layout()
3144
3145        def graph_layout_fr(self, weighted):
3146            if self.graph is None:   #grafa se ni
3147                return
3148
3149            if not self.optButton.isChecked():
3150              #print "not"
3151              self.stopOptimization = 1
3152              self.optButton.setChecked(False)
3153              self.optButton.setText("Optimize layout")
3154              return
3155
3156            self.optButton.setText("Stop")
3157            qApp.processEvents()
3158            self.stopOptimization = 0
3159            tolerance = 5
3160            initTemp = 1000
3161            breakpoints = 6
3162            k = int(self.frSteps / breakpoints)
3163            o = self.frSteps % breakpoints
3164            iteration = 0
3165            coolFactor = math.exp(math.log(10.0 / 10000.0) / self.frSteps)
3166
3167            if k > 0:
3168                while iteration < breakpoints:
3169                    #print "iteration, initTemp: " + str(initTemp)
3170                    if self.stopOptimization:
3171                        return
3172                    initTemp = self.layout.fr(k, initTemp, coolFactor, weighted)
3173                    iteration += 1
3174                    qApp.processEvents()
3175                    self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)
3176                    self.networkCanvas.updateCanvas()
3177
3178                #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp)
3179                if self.stopOptimization:
3180                        return
3181                initTemp = self.layout.fr(o, initTemp, coolFactor, weighted)
3182                qApp.processEvents()
3183                self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)
3184                self.networkCanvas.updateCanvas()
3185            else:
3186                while iteration < o:
3187                    #print "iteration ostanek, initTemp: " + str(initTemp)
3188                    if self.stopOptimization:
3189                        return
3190                    initTemp = self.layout.fr(1, initTemp, coolFactor, weighted)
3191                    iteration += 1
3192                    qApp.processEvents()
3193                    self.networkCanvas.networkCurve.coors = self.layout.map_to_graph(self.graph)
3194                    self.networkCanvas.updateCanvas()
3195
3196            self.optButton.setChecked(False)
3197            self.optButton.setText("Optimize layout")
3198
3199        def graph_layout_fr_special(self):
3200            if self.graph is None:   #grafa se ni
3201                return
3202
3203            steps = 100
3204            initTemp = 1000
3205            coolFactor = math.exp(math.log(10.0 / 10000.0) / steps)
3206            oldXY = [(self.layout.coors[0][i], self.layout.coors[1][i]) for i in range(self.graph.number_of_nodes())]
3207            #print oldXY
3208            initTemp = self.layout.fr(steps, initTemp, coolFactor)
3209            #print oldXY
3210            self.networkCanvas.updateDataSpecial(oldXY)
3211            self.networkCanvas.replot()
3212
3213        def graph_layout_fr_radial(self):
3214            if self.graph is None:   #grafa se ni
3215                return
3216
3217            #print "F-R Radial"
3218            k = 1.13850193174e-008
3219            nodes = self.graph.number_of_nodes()
3220            t = k * nodes * nodes
3221            refreshRate = int(5.0 / t)
3222            if refreshRate < 1: refreshRate = 1;
3223            if refreshRate > 1500: refreshRate = 1500;
3224            #print "refreshRate: " + str(refreshRate)
3225
3226            tolerance = 5
3227            initTemp = 100
3228            centerNdx = 0
3229
3230            selection = self.networkCanvas.getSelection()
3231            if len(selection) > 0:
3232                centerNdx = selection[0]
3233
3234            #print "center ndx: " + str(centerNdx)
3235            initTemp = self.layout.fr_radial(centerNdx, refreshRate, initTemp)
3236            self.networkCanvas.circles = [10000 / 12, 10000 / 12 * 2, 10000 / 12 * 3]#, 10000/12*4, 10000/12*5]
3237            #self.networkCanvas.circles = [100, 200, 300]
3238            self.networkCanvas.updateCanvas()
3239            self.networkCanvas.circles = []
3240
3241        def graph_layout_pivot_mds(self):
3242            self.information()
3243
3244            if self.items_matrix is None:
3245                self.information('Set distance matrix to input signal')
3246                return
3247
3248            if self.graph is None:
3249                self.information('No network found')
3250                return
3251
3252            if self.items_matrix.dim != self.graph.number_of_nodes():
3253                self.error('Distance matrix dimensionality must equal number of vertices')
3254                return
3255
3256            self.frSteps = min(self.frSteps, self.items_matrix.dim)
3257            qApp.processEvents()
3258            mds = orngMDS.PivotMDS(self.items_matrix, self.frSteps)
3259            x, y = mds.optimize()
3260            self.layout.coors[0] = x
3261            self.layout.coors[1] = y
3262            self.networkCanvas.updateCanvas()
3263
3264
3265        """
3266        Network Visualization
3267        """
3268
3269        def clickedAttLstBox(self):
3270            if self.graph is None:
3271                return
3272
3273            self.lastLabelColumns = set([self.attributes[i][0] for i in self.markerAttributes])
3274            self.networkCanvas.setLabelText(self.lastLabelColumns)
3275            self.networkCanvas.updateData()
3276            self.networkCanvas.replot()
3277
3278        def clickedTooltipLstBox(self):
3279            if self.graph is None:
3280                return
3281
3282            self.lastTooltipColumns = set([self.attributes[i][0] for i in self.tooltipAttributes])
3283            self.networkCanvas.setTooltipText(self.lastTooltipColumns)
3284            self.networkCanvas.updateData()
3285            self.networkCanvas.replot()
3286
3287        def clickedEdgeLabelListBox(self):
3288            if self.graph is None:
3289                return
3290
3291            self.lastEdgeLabelAttributes = set([self.edgeAttributes[i][0] for i in self.edgeLabelAttributes])
3292            self.networkCanvas.setEdgeLabelText(self.lastEdgeLabelAttributes)
3293            self.networkCanvas.updateData()
3294            self.networkCanvas.replot()
3295
3296        def setVertexColor(self):
3297            if self.graph is None:
3298                return
3299
3300            self.networkCanvas.set_node_color(self.colorCombo.currentText())
3301            self.lastColorColumn = self.colorCombo.currentText()
3302            self.networkCanvas.updateData()
3303            self.networkCanvas.replot()
3304
3305        def setEdgeColor(self):
3306            if self.graph is None:
3307                return
3308
3309            self.networkCanvas.set_edge_color(self.edgeColorCombo.currentText())
3310            self.lastEdgeColorColumn = self.edgeColorCombo.currentText()
3311            self.networkCanvas.updateData()
3312            self.networkCanvas.replot()
3313
3314        def setGraphGrid(self):
3315            self.networkCanvas.enableGridY(self.networkCanvasShowGrid)
3316            self.networkCanvas.enableGridX(self.networkCanvasShowGrid)
3317
3318        def selectAllConnectedNodes(self):
3319            self.networkCanvas.selectConnectedNodes(1000000)
3320
3321        def setMaxLinkSize(self):
3322            if self.graph is None:
3323                return
3324
3325            self.networkCanvas.maxEdgeSize = self.maxLinkSize
3326            self.networkCanvas.setEdgesSize()
3327            self.networkCanvas.replot()
3328
3329        def setVertexSize(self):
3330            if self.graph is None or self.networkCanvas is None:
3331                return
3332
3333            if self.minVertexSize > self.maxVertexSize:
3334                self.maxVertexSize = self.minVertexSize
3335
3336            self.networkCanvas.minVertexSize = self.minVertexSize
3337            self.networkCanvas.maxVertexSize = self.maxVertexSize
3338            self.lastVertexSizeColumn = self.vertexSizeCombo.currentText()
3339
3340            if self.vertexSize > 0:
3341                self.networkCanvas.setVerticesSize(self.lastVertexSizeColumn, self.invertSize)
3342            else:
3343                self.networkCanvas.setVerticesSize()
3344
3345            self.networkCanvas.replot()
3346
3347        def setFontSize(self):
3348            if self.networkCanvas is None:
3349                return
3350
3351            self.networkCanvas.fontSize = self.fontSize
3352            self.networkCanvas.drawPlotItems()
3353
3354        def sendReport(self):
3355            self.reportSettings("Graph data",
3356                                [("Number of vertices", self.graph.number_of_nodes()),
3357                                 ("Number of edges", self.graph.number_of_edges()),
3358                                 ("Vertices per edge", "%.3f" % self.verticesPerEdge),
3359                                 ("Edges per vertex", "%.3f" % self.edgesPerVertex),
3360                                 ("Diameter", self.diameter),
3361                                 ("Clustering Coefficient", "%.1f%%" % self.clustering_coefficient)
3362                                 ])
3363            if self.color or self.vertexSize or self.markerAttributes or self.edgeColor:
3364                self.reportSettings("Visual settings",
3365                                    [self.color and ("Vertex color", self.colorCombo.currentText()),
3366                                     self.vertexSize and ("Vertex size", str(self.vertexSizeCombo.currentText()) + " (inverted)" if self.invertSize else ""),
3367                                     self.markerAttributes and ("Labels", ", ".join(self.attributes[i][0] for i in self.markerAttributes)),
3368                                     self.edgeColor and ("Edge colors", self.edgeColorCombo.currentText()),
3369                                    ])
3370            self.reportSettings("Optimization",
3371                                [("Method", self.optCombo.currentText()),
3372                                 ("Iterations", self.frSteps)])
3373            self.reportSection("Graph")
3374            self.reportImage(self.networkCanvas.saveToFileDirect)
3375
3376
3377if __name__ == "__main__":
3378    a = QApplication(sys.argv)
3379    ow = OWNxExplorer()
3380    ow.show()
3381    def setNetwork(signal, data, id=None):
3382        if signal == 'Network':
3383            ow.set_graph(data)
3384        #if signal == 'Items':
3385        #    ow.set_items(data)
3386
3387    import OWNxFile
3388    owFile = OWNxFile.OWNxFile()
3389    owFile.send = setNetwork
3390    owFile.show()
3391    owFile.selectNetFile(0)
3392
3393    a.exec_()
3394    ow.saveSettings()
3395    owFile.saveSettings()
Note: See TracBrowser for help on using the repository browser.