source: orange/orange/OrangeWidgets/Unsupervised/OWNxExplorer.py @ 9588:a97bb6f03bc5

Revision 9588:a97bb6f03bc5, 166.1 KB checked in by Lan Zagar <lan.zagar@…>, 2 years ago (diff)

Added .hgeol and converted some line endings.

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