source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 9505:4b798678cd3d

Revision 9505:4b798678cd3d, 167.9 KB checked in by matija <matija.polajnar@…>, 2 years ago (diff)

Merge in the (heavily modified) MLC code from GSOC 2011 (modules, documentation, evaluation code, regression test). Widgets will be merged in a little bit later, which will finally close ticket #992.

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