source: orange/orange/OrangeWidgets/Prototypes/OWItemsetViz.py @ 9546:2b6cc6f397fe

Revision 9546:2b6cc6f397fe, 30.4 KB checked in by ales_erjavec <ales.erjavec@…>, 2 years ago (diff)

Renamed widget channel names in line with the new naming rules/convention.
Added backwards compatibility in orngDoc loadDocument to enable loading of schemas saved before the change.

Line 
1"""
2<name>Itemset visualizer</name>
3<description>Itemset visualizer Widget visualizes itemsets.</description>
4<icon>icons/Network.png</icon>
5<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact> 
6<priority>3014</priority>
7"""
8import OWGUI
9
10from OWWidget import *
11from PyQt4.Qwt5 import *
12from OWNetworkCanvas import *
13from orngNetwork import * 
14from time import *
15import OWToolbars
16from statc import mean
17
18dir = os.path.dirname(__file__) + "/../icons/"
19dlg_mark2sel = dir + "Dlg_Mark2Sel.png"
20dlg_sel2mark = dir + "Dlg_Sel2Mark.png"
21dlg_selIsmark = dir + "Dlg_SelisMark.png"
22dlg_selected = dir + "Dlg_SelectedNodes.png"
23dlg_unselected = dir + "Dlg_UnselectedNodes.png"
24
25class UnconnectedArrowsCurve(UnconnectedLinesCurve):
26    def __init__(self, parent, pen = QPen(Qt.black), xData = None, yData = None):
27        UnconnectedLinesCurve.__init__(self, parent, pen, xData, yData) 
28
29    def toPolar(self, x, y):
30        if x > 0 and y >= 0:
31            return math.atan(y/x)
32        elif x > 0 and y < 0:
33            return math.atan(y/x) + 2 * math.pi
34        elif x < 0:
35            return math.atan(y/x) + math.pi
36        elif x == 0 and y > 0:
37            return math.pi / 2
38        elif x == 0 and y < 0:
39            return math.pi * 3 / 2
40        else:
41            return None
42       
43    def drawCurve(self, painter, style, xMap, yMap, start, stop):
44       
45        self.Pen.setWidth(2)
46        painter.setPen(self.Pen)
47       
48        start = max(start + start%2, 0)
49        if stop == -1:
50            stop = self.dataSize()
51        for i in range(start, stop, 2):
52           
53           
54            QwtPlotCurve.drawLines(self, painter, xMap, yMap, i, i+1)
55       
56        painter.setBrush(self.Pen.color())
57        self.Pen.setWidth(1)
58        painter.setPen(self.Pen)
59        d = 12
60
61        start = max(start + start%2, 0)
62        if stop == -1:
63            stop = self.dataSize()
64        for i in range(start, stop, 2):
65            x = self.x(i+1) - self.x(i)
66            y = self.y(i+1) - self.y(i)
67           
68            fi = (self.toPolar(x, y) + math.pi) * 180 / math.pi * 16
69            if not fi is None:
70                x = xMap.transform(self.x(i+1))
71                y = yMap.transform(self.y(i+1))
72               
73                painter.drawPie(x-d, y-d, 2*d, 2*d, fi - 160, 320)
74       
75class OWIntemsetCanvas(OWNetworkCanvas):
76   
77    def __init__(self, master, parent = None, name = "None"):
78        OWNetworkCanvas.__init__(self, master, parent, name)
79       
80    def countWords(self, index):
81        label = str(self.visualizer.graph.items[index]['name'])
82        #print len(label.split(' '))
83        #print label
84        return len(label.split(' '))
85   
86    def getVertexSize(self, index):
87        return self.countWords(index) + 5
88   
89    def updateData(self):
90        #print "OWGraphDrawerCanvas/updateData..."
91        self.removeDrawingCurves(removeLegendItems = 0)
92        self.tips.removeAll()
93       
94        if self.insideview and len(self.selection) == 1:
95            visible = set()
96            visible |= set(self.selection)
97            visible |= self.getNeighboursUpTo(self.selection[0], self.insideviewNeighbours)
98            self.hiddenNodes = set(range(self.nVertices)) - visible
99 
100        edgesCount = 0
101       
102        fillColor = Qt.blue#self.discPalette[classValueIndices[self.rawdata[i].getclass().value], 255*insideData[j]]
103        edgeColor = Qt.blue#self.discPalette[classValueIndices[self.rawdata[i].getclass().value]]
104        emptyFill = Qt.white
105       
106        for r in self.circles:
107            #print "r: " + str(r)
108            step = 2 * pi / 64;
109            fi = 0
110            x = []
111            y = []
112            for i in range(65):
113                x.append(r * cos(fi) + 5000)
114                y.append(r * sin(fi) + 5000)
115                fi += step
116               
117            self.addCurve("radius", fillColor, Qt.green, 1, style = QwtCurve.Lines, xData = x, yData = y, showFilledSymbols = False)
118       
119        xData = []
120        yData = []
121        # draw edges
122        for e in range(self.nEdges):
123            (key,i,j) = self.edges[e]
124           
125            if i in self.hiddenNodes or j in self.hiddenNodes:
126                continue 
127           
128            x1 = self.visualizer.coors[i][0]
129            x2 = self.visualizer.coors[j][0]
130            y1 = self.visualizer.coors[i][1]
131            y2 = self.visualizer.coors[j][1]
132
133            #key = self.addCurve(str(e), fillColor, edgeColor, 0, style = QwtCurve.Lines, xData = [x1, x2], yData = [y1, y2])
134            #self.edges[e] = (key,i,j)
135            xData.append(x1)
136            xData.append(x2)
137            yData.append(y1)
138            yData.append(y2)
139            # append edges to vertex descriptions
140            self.edges[e] = (edgesCount,i,j)
141            (key, neighbours) = self.vertices[i]
142            if edgesCount not in neighbours:
143                neighbours.append(edgesCount)
144            self.vertices[i] = (key, neighbours)
145            (key, neighbours) = self.vertices[j]
146            if edgesCount not in neighbours:
147                neighbours.append(edgesCount)
148            self.vertices[j] = (key, neighbours)
149
150            edgesCount += 1
151       
152        edgesCurveObject = UnconnectedArrowsCurve(self, QPen(QColor(192,192,192)), xData, yData)
153        edgesCurveObject.xData = xData
154        edgesCurveObject.yData = yData
155        self.edgesKey = self.insertCurve(edgesCurveObject)
156       
157        selectionX = []
158        selectionY = []
159        self.nodeColor = []
160
161        # draw vertices
162        for v in range(self.nVertices):
163            if self.colorIndex > -1:
164                if self.visualizer.graph.items.domain[self.colorIndex].varType == orange.VarTypes.Continuous:
165                    newColor = self.contPalette[self.noJitteringScaledData[self.colorIndex][v]]
166                    fillColor = newColor
167                elif self.visualizer.graph.items.domain[self.colorIndex].varType == orange.VarTypes.Discrete:
168                    newColor = self.discPalette[self.colorIndices[self.visualizer.graph.items[v][self.colorIndex].value]]
169                    fillColor = newColor
170                    edgeColor = newColor
171            else: 
172                newcolor = Qt.blue
173                fillColor = newcolor
174               
175            if self.insideview and len(self.selection) == 1:
176                    if not (v in self.visualizer.graph.getNeighbours(self.selection[0]) or v == self.selection[0]):
177                        fillColor = fillColor.light(155)
178           
179            # This works only if there are no hidden vertices!   
180            self.nodeColor.append(fillColor)
181           
182            if v in self.hiddenNodes:
183                continue
184                   
185            x1 = self.visualizer.coors[v][0]
186            y1 = self.visualizer.coors[v][1]
187           
188            selectionX.append(x1)
189            selectionY.append(y1)
190           
191            key = self.addCurve(str(v), fillColor, edgeColor, self.getVertexSize(v), xData = [x1], yData = [y1], showFilledSymbols = False)
192           
193            if v in self.selection:
194                if self.insideview and len(self.selection) == 1:
195                    self.selectionStyles[v] = str(newcolor.name())
196                   
197                selColor = QColor(self.selectionStyles[v])
198                newSymbol = QwtSymbol(QwtSymbol.Ellipse, QBrush(selColor), QPen(Qt.yellow, 3), QSize(10, 10))
199                self.setCurveSymbol(key, newSymbol)
200           
201            (tmp, neighbours) = self.vertices[v]
202            self.vertices[v] = (key, neighbours)
203            self.indexPairs[key] = v
204       
205        #self.addCurve('vertices', fillColor, edgeColor, 6, xData=selectionX, yData=selectionY)
206       
207        # mark nodes
208        redColor = self.markWithRed and Qt.red
209        markedSize = self.markWithRed and 9 or 6
210
211        for m in self.markedNodes:
212            (key, neighbours) = self.vertices[m]
213            newSymbol = QwtSymbol(QwtSymbol.Ellipse, QBrush(redColor or self.nodeColor[m]), QPen(self.nodeColor[m]), QSize(markedSize, markedSize))
214            self.setCurveSymbol(key, newSymbol)       
215       
216        # draw labels
217        self.drawLabels()
218       
219        # add ToolTips
220        self.tooltipData = []
221        self.tooltipKeys = {}
222        self.tips.removeAll()
223        if len(self.tooltipText) > 0:
224            for v in range(self.nVertices):
225                if v in self.hiddenNodes:
226                    continue
227               
228                x1 = self.visualizer.coors[v][0]
229                y1 = self.visualizer.coors[v][1]
230                lbl = ""
231                for ndx in self.tooltipText:
232                    values = self.visualizer.graph.items[v]
233                    lbl = lbl + str(values[ndx]) + "\n"
234       
235                if lbl != '':
236                    lbl = lbl[:-1]
237                    self.tips.addToolTip(x1, y1, lbl)
238                    self.tooltipKeys[v] = len(self.tips.texts) - 1
239
240class OWItemsetViz(OWWidget):
241    settingsList=["autoSendSelection", "spinExplicit", "spinPercentage"]
242    contextHandlers = {"": DomainContextHandler("", [])}
243
244    def __init__(self, parent=None, signalManager=None):
245        OWWidget.__init__(self, parent, signalManager, 'Itemset visualizer')
246
247        self.inputs = [("Graph with Data", orange.Graph, self.setGraph), ("Data Subset", orange.ExampleTable, self.setExampleSubset)]
248        self.outputs=[("Selected Data", ExampleTable), ("Selected Graph", orange.Graph)]
249       
250        self.markerAttributes = []
251        self.tooltipAttributes = []
252        self.attributes = []
253        self.autoSendSelection = False
254        self.graphShowGrid = 1  # show gridlines in the graph
255       
256        self.markNConnections = 2
257        self.markNumber = 0
258        self.markProportion = 0
259        self.markSearchString = ""
260        self.markDistance = 2
261        self.frSteps = 1
262        self.hubs = 0
263        self.color = 0
264        self.nVertices = self.nMarked = self.nSelected = self.nHidden = self.nShown = self.nEdges = self.verticesPerEdge = self.edgesPerVertex = self.diameter = 0
265        self.optimizeWhat = 1
266        self.stopOptimization = 0
267       
268        self.loadSettings()
269
270        self.visualize = None
271
272        self.graph = OWIntemsetCanvas(self, self.mainArea, "Network")
273
274        #start of content (right) area
275        self.box = QVBoxLayout(self.mainArea)
276        self.box.addWidget(self.graph)
277
278        self.tabs = QTabWidget(self.controlArea)
279
280        self.displayTab = QVGroupBox(self)
281        self.mainTab = self.displayTab
282        self.markTab = QVGroupBox(self)
283        self.infoTab = QVGroupBox(self)
284        self.protoTab = QVGroupBox(self)
285
286        self.tabs.insertTab(self.displayTab, "Display")
287        self.tabs.insertTab(self.markTab, "Mark")
288        self.tabs.insertTab(self.infoTab, "Info")
289        self.tabs.insertTab(self.protoTab, "Prototypes")
290        OWGUI.separator(self.controlArea)
291
292
293        self.optimizeBox = OWGUI.radioButtonsInBox(self.mainTab, self, "optimizeWhat", [], "Optimize", addSpace=False)
294        OWGUI.button(self.optimizeBox, self, "Random", callback=self.random)
295        self.frButton = OWGUI.button(self.optimizeBox, self, "Fruchterman Reingold", callback=self.fr, toggleButton=1)
296        OWGUI.spin(self.optimizeBox, self, "frSteps", 1, 10000, 1, label="Iterations: ")
297        OWGUI.button(self.optimizeBox, self, "F-R Radial", callback=self.frRadial)
298        OWGUI.button(self.optimizeBox, self, "Circular Original", callback=self.circularOriginal)
299        OWGUI.button(self.optimizeBox, self, "Circular Crossing Reduction", callback=self.circularCrossingReduction)
300
301        self.showLabels = 0
302        OWGUI.checkBox(self.mainTab, self, 'showLabels', 'Show labels', callback = self.showLabelsClick)
303       
304        self.labelsOnMarkedOnly = 0
305        OWGUI.checkBox(self.mainTab, self, 'labelsOnMarkedOnly', 'Show labels on marked nodes only', callback = self.labelsOnMarked)
306       
307        OWGUI.separator(self.mainTab)
308
309        OWGUI.button(self.mainTab, self, "Show degree distribution", callback=self.showDegreeDistribution)
310        OWGUI.button(self.mainTab, self, "Save network", callback=self.saveNetwork)
311       
312        ib = OWGUI.widgetBox(self.markTab, "Info", addSpace = True)
313        OWGUI.label(ib, self, "Vertices (shown/hidden): %(nVertices)i (%(nShown)i/%(nHidden)i)")
314        OWGUI.label(ib, self, "Selected and marked vertices: %(nSelected)i - %(nMarked)i")
315       
316        ribg = OWGUI.radioButtonsInBox(self.markTab, self, "hubs", [], "Method", callback = self.setHubs, addSpace = True)
317        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark vertices given in the input signal")
318
319        OWGUI.appendRadioButton(ribg, self, "hubs", "Find vertices which label contain")
320        self.ctrlMarkSearchString = OWGUI.lineEdit(OWGUI.indentedBox(ribg), self, "markSearchString", callback=self.setSearchStringTimer, callbackOnType=True)
321        self.searchStringTimer = QTimer(self)
322        self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.setHubs)
323       
324        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of focused vertex")
325        OWGUI.appendRadioButton(ribg, self, "hubs", "Mark neighbours of selected vertices")
326        ib = OWGUI.indentedBox(ribg, orientation = 0)
327        self.ctrlMarkDistance = OWGUI.spin(ib, self, "markDistance", 0, 100, 1, label="Distance ", callback=(lambda h=2: self.setHubs(h)))
328
329        self.ctrlMarkFreeze = OWGUI.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True)
330
331        OWGUI.widgetLabel(ribg, "Mark  vertices with ...")
332        OWGUI.appendRadioButton(ribg, self, "hubs", "at least N connections")
333        OWGUI.appendRadioButton(ribg, self, "hubs", "at most N connections")
334        self.ctrlMarkNConnections = OWGUI.spin(OWGUI.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N ", callback=(lambda h=4: self.setHubs(h)))
335
336        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than any neighbour")
337        OWGUI.appendRadioButton(ribg, self, "hubs", "more connections than avg neighbour")
338
339        OWGUI.appendRadioButton(ribg, self, "hubs", "most connections")
340        ib = OWGUI.indentedBox(ribg)
341        self.ctrlMarkNumber = OWGUI.spin(ib, self, "markNumber", 0, 1000000, 1, label="Number of vertices" + ": ", callback=(lambda h=8: self.setHubs(h)))
342        OWGUI.widgetLabel(ib, "(More vertices are marked in case of ties)")
343
344        ib = QHGroupBox("Selection", self.markTab)
345        btnM2S = OWGUI.button(ib, self, "", callback = self.markedToSelection)
346        btnM2S.setPixmap(QPixmap(dlg_mark2sel))
347        QToolTip.add(btnM2S, "Add Marked to Selection")
348        btnS2M = OWGUI.button(ib, self, "",callback = self.markedFromSelection)
349        btnS2M.setPixmap(QPixmap(dlg_sel2mark))
350        QToolTip.add(btnS2M, "Remove Marked from Selection")
351        btnSIM = OWGUI.button(ib, self, "", callback = self.setSelectionToMarked)
352        btnSIM.setPixmap(QPixmap(dlg_selIsmark))
353        QToolTip.add(btnSIM, "Set Selection to Marked")
354       
355        self.hideBox = QHGroupBox("Hide vertices", self.markTab)
356        btnSEL = OWGUI.button(self.hideBox, self, "", callback=self.hideSelected)
357        btnSEL.setPixmap(QPixmap(dlg_selected))
358        QToolTip.add(btnSEL, "Selected")
359        btnUN = OWGUI.button(self.hideBox, self, "", callback=self.hideAllButSelected)
360        btnUN.setPixmap(QPixmap(dlg_unselected))
361        QToolTip.add(btnUN, "Unselected")
362        OWGUI.button(self.hideBox, self, "Show", callback=self.showAllNodes)
363               
364        T = OWToolbars.NavigateSelectToolbar
365        self.zoomSelectToolbar = OWToolbars.NavigateSelectToolbar(self, self.controlArea, self.graph, self.autoSendSelection,
366                                                              buttons = (T.IconZoom, T.IconZoomExtent, T.IconZoomSelection, ("", "", "", None, None, 0, "navigate"), T.IconPan, 
367                                                                         ("Move selection", "buttonMoveSelection", "activateMoveSelection", QPixmap(OWToolbars.dlg_select), Qt.arrowCursor, 1, "select"),
368                                                                         T.IconRectangle, T.IconPolygon, ("", "", "", None, None, 0, "select"), T.IconSendSelection))
369       
370        ib = OWGUI.widgetBox(self.infoTab, "General", addSpace = True)
371        OWGUI.label(ib, self, "Number of vertices: %(nVertices)i")
372        OWGUI.label(ib, self, "Number of edges: %(nEdges)i")
373        OWGUI.label(ib, self, "Vertices per edge: %(verticesPerEdge).2f")
374        OWGUI.label(ib, self, "Edges per vertex: %(edgesPerVertex).2f")
375        OWGUI.label(ib, self, "Diameter: %(diameter)i")
376       
377        self.insideView = 0
378        self.insideViewNeighbours = 2
379        self.insideSpin = OWGUI.spin(self.protoTab, self, "insideViewNeighbours", 1, 6, 1, label="Inside view (neighbours): ", checked = "insideView", checkCallback = self.insideview, callback = self.insideviewneighbours)
380        #OWGUI.button(self.protoTab, self, "Clustering", callback=self.clustering)
381        OWGUI.button(self.protoTab, self, "Collapse", callback=self._collapse)
382       
383        self.icons = self.createAttributeIconDict()
384        self.setHubs()
385       
386        self.resize(850, 700)   
387
388    def _collapse(self):
389        print "collapse"
390        self.visualize.collapse()
391        self.graph.addVisualizer(self.visualize)
392        #if not nodes is None:
393        #    self.graph.updateData()
394        #    self.graph.addSelection(nodes, False)
395        self.updateCanvas()
396       
397    def clustering(self):
398        print "clustering"
399        self.visualize.graph.getClusters()
400       
401    def insideviewneighbours(self):
402        if self.graph.insideview == 1:
403            self.graph.insideviewNeighbours = self.insideViewNeighbours
404            self.frButton.setOn(True)
405            self.fr()
406       
407    def insideview(self):
408        if len(self.graph.selection) == 1:
409            if self.graph.insideview == 1:
410                self.graph.insideview = 0
411                self.graph.hiddenNodes = []
412                self.updateCanvas()
413            else:
414                self.graph.insideview = 1
415                self.graph.insideviewNeighbors = self.insideViewNeighbours
416                self.frButton.setOn(True)
417                self.fr()
418   
419        else:
420            self.graph.insideview = 0
421            check, spin = self.insideSpin
422            print check
423           
424            check.setCheckable(False)
425            print "One node must be selected!"     
426       
427    def labelsOnMarked(self):
428        self.graph.labelsOnMarkedOnly = self.labelsOnMarkedOnly
429        self.graph.updateData()
430        self.graph.replot()
431   
432    def setSearchStringTimer(self):
433        self.hubs = 1
434        self.searchStringTimer.stop()
435        self.searchStringTimer.start(750, True)
436         
437    def setHubs(self, i = None):
438        if not i is None:
439            self.hubs = i
440           
441        self.graph.tooltipNeighbours = self.hubs == 2 and self.markDistance or 0
442        self.graph.markWithRed = False
443
444        if not self.visualize or not self.visualize.graph:
445            return
446       
447        hubs = self.hubs
448        vgraph = self.visualize.graph
449
450        if hubs == 0:
451            return
452       
453        elif hubs == 1:
454            txt = self.markSearchString
455            labelText = self.graph.labelText
456            self.graph.markWithRed = self.graph.nVertices > 200
457            self.graph.setMarkedNodes([i for i, values in enumerate(vgraph.items) if txt in " ".join([str(values[ndx]) for ndx in labelText])])
458            print [i for i, values in enumerate(vgraph.items) if txt in " ".join([str(values[ndx]) for ndx in labelText])]
459            return
460       
461        elif hubs == 2:
462            self.graph.setMarkedNodes([])
463            self.graph.tooltipNeighbours = self.markDistance
464            return
465
466        elif hubs == 3:
467            self.graph.setMarkedNodes([])
468            self.graph.selectionNeighbours = self.markDistance
469            self.graph.markSelectionNeighbours()
470            return
471       
472        self.graph.tooltipNeighbours = self.graph.selectionNeighbours = 0
473        powers = vgraph.getDegrees()
474       
475        if hubs == 4: # at least N connections
476            N = self.markNConnections
477            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power >= N])
478        elif hubs == 5:
479            N = self.markNConnections
480            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power <= N])
481        elif hubs == 6:
482            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power > max([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])])
483        elif hubs == 7:
484            self.graph.setMarkedNodes([i for i, power in enumerate(powers) if power > mean([0]+[powers[nn] for nn in vgraph.getNeighbours(i)])])
485        elif hubs == 8:
486            sortedIdx = range(len(powers))
487            sortedIdx.sort(lambda x,y: -cmp(powers[x], powers[y]))
488            cutP = self.markNumber
489            cutPower = powers[sortedIdx[cutP]]
490            while cutP < len(powers) and powers[sortedIdx[cutP]] == cutPower:
491                cutP += 1
492            self.graph.setMarkedNodes(sortedIdx[:cutP-1])
493           
494    def showLabelsClick(self):
495        if self.showLabels:
496            self.graph.setLabelText(['name','support'])
497            self.graph.updateData()
498            self.graph.replot()
499        else:
500            self.graph.setLabelText([])
501            self.graph.updateData()
502            self.graph.replot()
503       
504    def saveNetwork(self):
505        filename = QFileDialog.getSaveFileName(QString.null,'PAJEK networks (*.net)')
506        if filename:
507            fn = ""
508            head, tail = os.path.splitext(str(filename))
509            if not tail:
510                fn = head + ".net"
511            else:
512                fn = str(filename)
513           
514            self.graph.visualizer.saveNetwork(fn)
515   
516    def selectConnectedNodes(self):
517        self.graph.selectConnectedNodes(self.connectDistance)
518       
519       
520    def selectAllConnectedNodes(self):
521        self.graph.selectConnectedNodes(1000000)
522           
523   
524    def sendData(self):
525        graph = self.graph.getSelectedGraph()
526       
527        if graph != None:
528            if graph.items != None:
529                self.send("Selected Data", graph.items)
530            else:
531                self.send("Selected Data", self.graph.getSelectedExamples())
532               
533            self.send("Selected Graph", graph)
534        else:
535            items = self.graph.getSelectedExamples()
536            if items != None:
537                self.send("Selected Data", items)
538            self.send("Selected Graph", None)
539   
540   
541    def setGraph(self, graph):
542        if graph == None:
543            return
544
545        self.visualize = NetworkOptimization(graph, self)
546        self.nVertices = len(graph)
547        self.nShown = len(graph)
548        self.nEdges = len(graph.getEdges())
549        if self.nEdges > 0:
550            self.verticesPerEdge = float(self.nVertices) / float(self.nEdges)
551        else:
552            self.verticesPerEdge = 0
553           
554        if self.nVertices > 0:
555            self.edgesPerVertex = float(self.nEdges) / float(self.nVertices)
556        else:
557            self.edgesPerVertex = 0
558        self.diameter = graph.getDiameter()
559
560        vars = self.visualize.getVars()
561        self.attributes = [(var.name, var.varType) for var in vars]
562       
563        self.graph.addVisualizer(self.visualize)
564        self.graph.setTooltipText(['name', 'support'])
565       
566        k = 1.13850193174e-008
567        nodes = self.visualize.nVertices()
568        t = k * nodes * nodes
569        self.frSteps = int(5.0 / t)
570        if self.frSteps <   1: self.frSteps = 1;
571        if self.frSteps > 1500: self.frSteps = 1500;
572       
573        self.random()
574   
575    def setExampleSubset(self, subset):
576        if self.graph == None:
577            return
578       
579        hiddenNodes = []
580       
581        if subset != None:
582            try:
583                expected = 1
584                for row in subset:
585                    index = int(row['index'].value)
586                    if expected != index:
587                        hiddenNodes += range(expected-1, index-1)
588                        expected = index + 1
589                    else:
590                        expected += 1
591                       
592                hiddenNodes += range(expected-1, self.graph.nVertices)
593               
594                self.graph.setHiddenNodes(hiddenNodes)
595            except:
596                print "Error. Index column does not exists."
597       
598    def hideSelected(self):
599        #print self.graph.selection
600        toHide = self.graph.selection + self.graph.hiddenNodes
601        self.nHidden = len(toHide)
602        self.nShown = self.nVertices - self.nHidden
603        self.graph.setHiddenNodes(toHide)
604        self.graph.removeSelection()
605       
606    def hideAllButSelected(self):
607        allNodes = set(range(self.graph.nVertices))
608        allButSelected = list(allNodes - set(self.graph.selection))
609        toHide = allButSelected + self.graph.hiddenNodes
610        self.nHidden = len(toHide)
611        self.nShown = self.nVertices - self.nHidden
612        self.graph.setHiddenNodes(toHide)
613   
614    def showAllNodes(self):
615        self.graph.setHiddenNodes([])
616        self.nHidden = 0
617        self.nShown = self.nVertices
618       
619       
620    def random(self):
621        #print "OWNetwork/random.."
622        if self.visualize == None:   #grafa se ni
623            return   
624           
625        self.visualize.random()
626       
627        #print "OWNetwork/random: updating canvas..."
628        self.updateCanvas();
629        #print "done."
630       
631    def fr(self):
632        from qt import qApp
633        if self.visualize == None:   #grafa se ni
634            return
635             
636        if not self.frButton.isOn():
637            self.stopOptimization = 1
638            self.frButton.setOn(0)
639            self.frButton.setText("Fruchterman Reingold")
640            return
641       
642        self.frButton.setText("Stop")
643        qApp.processEvents()
644        self.stopOptimization = 0
645        tolerance = 5
646        initTemp = 1000
647        breakpoints = 6
648        k = int(self.frSteps / breakpoints)
649        o = self.frSteps % breakpoints
650        iteration = 0
651        coolFactor = exp(log(10.0/10000.0) / self.frSteps)
652
653        if k > 0:
654            while iteration < breakpoints:
655                #print "iteration, initTemp: " + str(initTemp)
656                if self.stopOptimization:
657                    return
658                initTemp = self.visualize.fruchtermanReingold(k, initTemp, coolFactor, self.graph.hiddenNodes)
659                iteration += 1
660                qApp.processEvents()
661                self.updateCanvas()
662           
663            #print "ostanek: " + str(o) + ", initTemp: " + str(initTemp)
664            if self.stopOptimization:
665                    return
666            initTemp = self.visualize.fruchtermanReingold(o, initTemp, coolFactor, self.graph.hiddenNodes)
667            qApp.processEvents()
668            self.updateCanvas()
669        else:
670            while iteration < o:
671                #print "iteration ostanek, initTemp: " + str(initTemp)
672                if self.stopOptimization:
673                    return
674                initTemp = self.visualize.fruchtermanReingold(1, initTemp, coolFactor, self.graph.hiddenNodes)
675                iteration += 1
676                qApp.processEvents()
677                self.updateCanvas()
678               
679        self.frButton.setOn(0)
680        self.frButton.setText("Fruchterman Reingold")
681       
682#    def frSpecial(self):
683#        steps = 100
684#        initTemp = 1000
685#        coolFactor = exp(log(10.0/10000.0) / steps)
686#        oldXY = []
687#        for rec in self.visualize.coors:
688#            oldXY.append([rec[0], rec[1]])
689#        #print oldXY
690#        initTemp = self.visualize.fruchtermanReingold(steps, initTemp, coolFactor, self.graph.hiddenNodes)
691#        #print oldXY
692#        self.graph.updateDataSpecial(oldXY)
693#        self.graph.replot()
694       
695    def frRadial(self):
696        #print "F-R Radial"
697        k = 1.13850193174e-008
698        nodes = self.visualize.nVertices()
699        t = k * nodes * nodes
700        refreshRate = int(5.0 / t)
701        if refreshRate <   1: refreshRate = 1;
702        if refreshRate > 1500: refreshRate = 1500;
703        print "refreshRate: " + str(refreshRate)
704       
705        tolerance = 5
706        initTemp = 100
707        centerNdx = 0
708        if len(self.graph.selection) > 0:
709            centerNdx = self.graph.selection[0]
710           
711        #print "center ndx: " + str(centerNdx)
712        initTemp = self.visualize.radialFruchtermanReingold(centerNdx, refreshRate, initTemp)
713        self.graph.circles = [10000 / 12, 10000/12*2, 10000/12*3]#, 10000/12*4, 10000/12*5]
714        #self.graph.circles = [100, 200, 300]
715        self.updateCanvas()
716        self.graph.circles = []
717       
718    def circularOriginal(self):
719        #print "Circular Original"
720        self.visualize.circularOriginal()
721        self.updateCanvas()
722
723    def circularCrossingReduction(self):
724        #print "Circular Crossing Reduction"
725        self.visualize.circularCrossingReduction()
726        self.updateCanvas()
727       
728    def setGraphGrid(self):
729        self.graph.enableGridY(self.graphShowGrid)
730        self.graph.enableGridX(self.graphShowGrid)
731                   
732    def updateCanvas(self):
733        #ce imamo graf
734        if self.visualize != None:
735            self.graph.updateCanvas()#self.visualize.xCoors, self.visualize.yCoors)
736       
737    def keyPressEvent(self, e):
738        if e.key() == Qt.Key_Control:
739            self.graph.controlPressed = True
740            #print "cp"
741        elif e.key() == Qt.Key_Alt:
742            self.graph.altPressed = True
743        QWidget.keyPressEvent(self, e)
744       
745    def keyReleaseEvent(self, e):
746        if e.key() == Qt.Key_Control:
747            self.graph.controlPressed = False
748        elif e.key() == Qt.Key_Alt:
749            self.graph.altPressed = False
750        QWidget.keyReleaseEvent(self, e)
751
752    def markedToSelection(self):
753        self.graph.addSelection(self.graph.markedNodes)
754   
755    def markedFromSelection(self):
756        self.graph.removeSelection(self.graph.markedNodes)
757   
758    def setSelectionToMarked(self):
759        self.graph.removeSelection(None, False)
760        self.graph.addSelection(self.graph.markedNodes)
761       
762    def showDegreeDistribution(self):
763        from matplotlib import rcParams
764        rcParams['text.fontname'] = 'cmr10'
765        import pylab as p
766       
767        x = self.visualize.graph.getDegrees()
768        #print len(x)
769        #print x
770        # the histogram of the data
771        n, bins, patches = p.hist(x, 500)
772       
773        p.xlabel('No. of nodes')
774        p.ylabel('Degree')
775        p.title(r'Degree distribution')
776       
777        p.show()
778
779
780if __name__=="__main__":   
781    appl = QApplication(sys.argv)
782    ow = OWItemsetViz()
783    appl.setMainWidget(ow)
784    ow.show()
785    appl.exec_loop()
Note: See TracBrowser for help on using the repository browser.