source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 9516:c5e64efb27ef

Revision 9516:c5e64efb27ef, 165.9 KB checked in by miha <miha.stajdohar@…>, 2 years ago (diff)

Fixed InsideView initialization error.

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