source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 9518:f1e3b2a3757b

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