source: orange/orange/OrangeWidgets/Unsupervised/OWModelMapQt.py @ 9258:62a8139b3d2b

Revision 9258:62a8139b3d2b, 25.6 KB checked in by miha <miha.stajdohar@…>, 2 years ago (diff)

Moved to Unsupervised.

Line 
1"""
2<name>Model Map</name>
3<description>Visualization and analysis of prediction models.</description>
4<icon>icons/Network.png</icon>
5<contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact> 
6<priority>6520</priority>
7"""
8
9import scipy.stats
10
11import Orange
12import orange
13import orngVizRank
14import orngStat
15
16import OWToolbars
17import OWColorPalette
18import OWNxCanvasQt
19
20from orngScaleLinProjData import *
21from OWNxExplorerQt import *
22from OWkNNOptimization import OWVizRank
23from OWNxHist import *
24from OWDistributions import OWDistributionGraph
25
26dir = os.path.dirname(__file__) + "/../"
27
28ICON_PATHS = [("TREE",              "Classify/icons/ClassificationTree"),
29              ("SCATTERPLOT",       "Visualize/icons/ScatterPlot"),
30              ("SCATTTERPLOT",      "Visualize/icons/ScatterPlot"),
31              ("LINEAR_PROJECTION", "Visualize/icons/LinearProjection"),
32              ("SPCA",              "Visualize/icons/LinearProjection"),
33              ("RADVIZ",            "Visualize/icons/Radviz"),
34              ("POLYVIZ",           "Visualize/icons/Polyviz"),
35              ("BAYES",             "Classify/icons/NaiveBayes"),
36              ("KNN",               "Classify/icons/kNearestNeighbours"),
37              ("SVM",               "Classify/icons/BasicSVM")]
38
39ICON_SIZES = ["16", "32", "40", "48", "60"]
40
41MODEL_IMAGES = {"MISSING": "%sicons/Unknown.png" % dir}
42
43PIXMAP_CACHE = {}
44
45for size in ICON_SIZES:
46    for model, path in ICON_PATHS:
47        MODEL_IMAGES[model + size] = "%s%s_%s.png" % (dir, path, size)
48
49dir = os.path.dirname(__file__) + "/../icons/"
50dlg_mark2sel   = dir + "Dlg_Mark2Sel.png"
51dlg_sel2mark   = dir + "Dlg_Sel2Mark.png"
52dlg_selIsmark  = dir + "Dlg_SelisMark.png"
53dlg_selected   = dir + "Dlg_SelectedNodes.png"
54dlg_unselected = dir + "Dlg_UnselectedNodes.png"
55dlg_showall    = dir + "Dlg_clear.png"
56
57class ModelItem(orangeqt.ModelItem):
58    def __init__(self, index, x=None, y=None, parent=None):
59        orangeqt.ModelItem.__init__(self, index, OWPoint.Ellipse, Qt.blue, 5, parent)
60        if x is not None:
61            self.set_x(x)
62        if y is not None:
63            self.set_y(y)
64
65class ModelCurve(NetworkCurve):
66    def __init__(self, parent=None, pen=QPen(Qt.black), xData=None, yData=None):
67        NetworkCurve.__init__(self, parent, pen=QPen(Qt.black), xData=None, yData=None)
68       
69    def draw(self, painter, xMap, yMap, rect):
70        for edge in self.edges:
71            if edge.u.show and edge.v.show:
72                painter.setPen(edge.pen)
73   
74                px1 = xMap.transform(self.coors[0][edge.u.index])   #ali pa tudi self.x1, itd
75                py1 = yMap.transform(self.coors[1][edge.u.index])
76                px2 = xMap.transform(self.coors[0][edge.v.index])
77                py2 = yMap.transform(self.coors[1][edge.v.index])
78               
79                painter.drawLine(px1, py1, px2, py2)
80               
81                d = 12
82                #painter.setPen(QPen(Qt.lightGray, 1))
83                painter.setBrush(Qt.lightGray)
84                if edge.arrowu:
85                    x = px1 - px2
86                    y = py1 - py2
87                   
88                    fi = math.atan2(y, x) * 180 * 16 / math.pi
89       
90                    if not fi is None:
91                        # (180*16) - fi - (20*16), (40*16)
92                        painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640)
93                       
94                if edge.arrowv:
95                    x = px1 - px2
96                    y = py1 - py2
97                   
98                    fi = math.atan2(y, x) * 180 * 16 / math.pi
99                    if not fi is None:
100                        # (180*16) - fi - (20*16), (40*16)
101                        painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640)
102                       
103                if self.showEdgeLabels and len(edge.label) > 0:
104                    lbl = ', '.join(edge.label)
105                    x = (px1 + px2) / 2
106                    y = (py1 + py2) / 2
107                   
108                    th = painter.fontMetrics().height()
109                    tw = painter.fontMetrics().width(lbl)
110                    r = QRect(x - tw / 2, y - th / 2, tw, th)
111                    painter.fillRect(r, QBrush(Qt.white))
112                    painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl)
113   
114        for vertex in self.vertices:
115            if vertex.show:
116                pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer)
117                pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa
118                style = (1 - vertex.style) * 2 * 100
119                #print style
120                #style=-50
121                #if vertex.highlight:
122                #    painter.setPen(QPen(QBrush(QColor(255,   0,   0, 192)), 1, Qt.SolidLine, Qt.RoundCap))
123                #else:
124                #    #oldcolor = QColor(125, 162, 206, 192)
125                painter.setPen(QPen(QBrush(vertex.color), 1, Qt.SolidLine, Qt.RoundCap))
126               
127                if vertex.selected:
128                    size = int(vertex.size) + 5
129                    brushColor = QColor(Qt.yellow)
130                    brushColor.setAlpha(150)
131                    gradient = QRadialGradient(QPointF(pX, pY), size)
132                    gradient.setColorAt(0., brushColor)
133                    gradient.setColorAt(1., QColor(255, 255, 255, 0))
134                    painter.setBrush(QBrush(gradient))
135                    painter.drawRoundedRect(pX - size/2, pY - size/2, size, size, style, style, Qt.RelativeSize)
136                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size)
137                elif vertex.marked:
138                    size = int(vertex.size) + 5
139                    brushColor = QColor(Qt.cyan)
140                    brushColor.setAlpha(80)
141                    gradient = QRadialGradient(QPointF(pX, pY), size)
142                    gradient.setColorAt(0., brushColor)
143                    gradient.setColorAt(1., QColor(255, 255, 255, 0))
144                    painter.setBrush(QBrush(gradient))
145                    painter.drawRoundedRect(pX - size/2, pY - size/2, size, size, style, style, Qt.RelativeSize)
146                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size)
147                else:
148                    size = int(vertex.size) + 5
149                    gradient = QRadialGradient(QPointF(pX, pY), size)
150                    #gradient.setColorAt(0., QColor(217, 232, 252, 192))
151                    gradient.setColorAt(0., vertex.color)
152                    gradient.setColorAt(1., QColor(255, 255, 255, 0))
153                    painter.setBrush(QBrush(gradient))
154                    painter.drawRoundedRect(pX - size/2, pY - size/2, size, size, style, style, Qt.RelativeSize)
155                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size)
156   
157        for vertex in self.vertices:
158            if vertex.show:               
159                pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer)
160                pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa
161#               
162                if vertex.image:
163                    size = vertex.image.size().width()
164                    painter.drawImage(QRect(pX - size/2, pY - size/2, size, size), vertex.image)
165                   
166class OWModelMapCanvas(OWNxCanvasQt.OWNxCanvas):
167   
168    def __init__(self, master, parent=None, name="None"):
169        OWNxCanvasQt.OWNxCanvas.__init__(self, master, parent, name)
170        self.networkCurve = ModelCurve()
171        self.NodeItem = ModelItem
172       
173        self.selectionNeighbours = 1
174        self.tooltipNeighbours = 1
175        self.plotAccuracy = None
176        self.vizAttributes = None
177        self.radius = 100
178       
179#    def mouseMoveEvent(self, event):
180#        if self.graph is None or self.layout is None:
181#          return
182#       
183#        if self.plotAccuracy or self.vizAttributes:
184#            px = self.invTransform(QwtPlot.xBottom, event.x())
185#            py = self.invTransform(QwtPlot.yLeft, event.y())
186#            ndx, mind = self.layout.closest_vertex(px, py)
187#           
188#            dX = self.transform(QwtPlot.xBottom, self.layout.coors[0][ndx]) - event.x()
189#            dY = self.transform(QwtPlot.yLeft,   self.layout.coors[1][ndx]) - event.y()
190#            # transform to pixel distance
191#            distance = math.sqrt(dX**2 + dY**2)
192#            if ndx != -1 and distance <= (self.vertices[ndx].size + 5) / 2:
193#                toMark = set(self.getNeighboursUpTo(ndx, self.tooltipNeighbours))
194#                toMark = list(toMark)
195#                self.networkCurve.setMarkedVertices(toMark)
196#                if self.plotAccuracy:
197#                    self.plotAccuracy(toMark)
198#                if self.vizAttributes:
199#                    self.vizAttributes(toMark)
200#                self.drawPlotItems()
201#            else:
202#                vd = sorted(self.layout.vertex_distances(px, py))[:10]
203#                vd = [(math.sqrt((self.transform(QwtPlot.xBottom, self.layout.coors[0][v]) - event.x())**2 + \
204#                                 (self.transform(QwtPlot.yLeft,   self.layout.coors[1][v]) - event.y())**2), v) for d,v in vd]
205#                vd = [v for d,v in vd if d < self.radius]
206#                self.networkCurve.setMarkedVertices(vd)
207#                if self.plotAccuracy:
208#                    self.plotAccuracy(vd)
209#                if self.vizAttributes:
210#                    self.vizAttributes(vd)
211#                self.drawPlotItems()
212#        else:
213#            OWNxCanvas.mouseMoveEvent(self, event)
214       
215    def set_tooltip_attributes(self, attributes):
216        if self.graph is None or self.items is None or \
217           not isinstance(self.items, orange.ExampleTable):
218            return
219       
220        attributes = ["Cluster CA", "label", "CA", "attributes"]
221       
222#        lbl  = "%s\n" % self.graph.items()[vertex.index]["label"].value
223#        lbl += "CA: %.4g\n" % self.graph.items()[vertex.index]["CA"].value
224#        #lbl += "AUC: %.4g\n" % self.graph.items()[vertex.index]["AUC"].value
225#        #lbl += "CA best: %s\n" % clusterCA
226#        lbl += "Attributes: %d\n" % len(self.graph.items()[vertex.index]["attributes"].value.split(", "))
227#        lbl += ", ".join(sorted(self.graph.items()[vertex.index]["attributes"].value.split(", ")))
228       
229        tooltip_attributes = [self.items.domain[att] for att in \
230                                 attributes if att in self.items.domain]
231        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \
232                   self.items[node][att]) for att in tooltip_attributes)) \
233                                                        for node in self.graph))
234           
235    def loadIcons(self):
236        items = self.graph.items()
237        maxsize = str(max(map(int, ICON_SIZES)))
238        minsize = min(map(int, ICON_SIZES))
239        for v in self.networkCurve.nodes().itervalues():
240            size = str(minsize) if v.size() <= minsize else maxsize
241           
242            for i in range(len(ICON_SIZES) - 1):
243                if int(ICON_SIZES[i]) < v.size() <= int(ICON_SIZES[i+1]):
244                    size = ICON_SIZES[i]
245            imageKey = items[v.index()]['model'].value + size
246            if imageKey not in MODEL_IMAGES:
247                imageKey = "MISSING"
248           
249            fn = MODEL_IMAGES[imageKey]
250            if not fn in PIXMAP_CACHE:
251                PIXMAP_CACHE[fn] = QPixmap(fn)
252            v.set_image(PIXMAP_CACHE[fn])
253
254class OWModelMapQt(OWNxExplorerQt, OWNxHist):
255    settingsList = ["vertexSize", "lastSizeAttribute", "lastColorAttribute", 
256                    "maxVertexSize", "minVertexSize", "tabIndex", 
257                    "colorSettings", "selectedSchemaIndex", "iterations", 
258                    "radius", "vizAccurancy", "vizAttributes", 
259                    "autoSendSelection", "spinExplicit", "spinPercentage",
260                    "maxLinkSize", "renderAntialiased", "labelsOnMarkedOnly",
261                    "invertSize", "optMethod", "lastVertexSizeColumn", 
262                    "lastColorColumn", "lastNameComponentAttribute", 
263                    "lastLabelColumns", "lastTooltipColumns", "showWeights",
264                    "showIndexes",  "showEdgeLabels", "edgeColorSettings", 
265                    "selectedEdgeSchemaIndex", "showMissingValues", "fontSize", 
266                    "mdsTorgerson", "mdsAvgLinkage", "mdsSteps", "mdsRefresh", 
267                    "mdsStressDelta", "organism","showTextMiningInfo", 
268                    "toolbarSelection", "minComponentEdgeWidth", 
269                    "maxComponentEdgeWidth", "mdsFromCurrentPos"]
270   
271    def __init__(self, parent=None, signalManager=None, name="Model Map"):
272        OWNxExplorerQt.__init__(self, parent, signalManager, name, 
273                               NetworkCanvas=OWModelMapCanvas)
274       
275        self.inputs = [("Distance Matrix", orange.SymMatrix, self.setMatrix, Default),
276                       ("Model Subset", orange.ExampleTable, self.setSubsetModels)]
277        self.outputs = [("Model", orange.Example),
278                        ("Classifier", orange.Classifier),
279                        ("Selected Models", orange.ExampleTable)]
280       
281        self.vertexSize = 32
282        self.autoSendSelection = False
283        self.minVertexSize = 16
284        self.maxVertexSize = 16
285        self.lastColorAttribute = ""
286        self.lastSizeAttribute = ""
287        self.vizAccurancy = False
288        self.vizAttributes = False
289        self.radius = 100
290        self.attrIntersection = []
291        self.attrIntersectionList = []
292        self.attrDifference = []
293        self.attrDifferenceList = []
294       
295        self.loadSettings()
296       
297        self.matrixTab = OWGUI.widgetBox(self.tabs, addToLayout = 0, margin = 4)
298        self.modelTab = OWGUI.widgetBox(self.tabs, addToLayout = 0, margin = 4)
299        self.tabs.insertTab(0, self.matrixTab, "Matrix")
300        self.tabs.insertTab(1, self.modelTab, "Model Info")
301
302        self.networkCanvas.appendToSelection = 0
303        self.networkCanvas.minVertexSize = self.minVertexSize
304        self.networkCanvas.maxVertexSize = self.maxVertexSize
305        self.networkCanvas.invertEdgeSize = 1
306       
307        # MARTIX CONTROLS
308        self.addHistogramControls(self.matrixTab)
309        self.kNN = 1
310        boxHistogram = OWGUI.widgetBox(self.matrixTab, box = "Distance histogram")
311        self.histogram = OWHist(self, boxHistogram)
312        boxHistogram.layout().addWidget(self.histogram)
313       
314        # VISUALIZATION CONTROLS
315        vizPredAcc = OWGUI.widgetBox(self.modelTab, "Prediction Accuracy", orientation = "vertical")
316        OWGUI.checkBox(vizPredAcc, self, "vizAccurancy", "Visualize prediction accurancy", callback=self.visualizeInfo)
317        OWGUI.spin(vizPredAcc, self, "radius", 10, 300, 1, label="Radius: ", callback = self.visualizeInfo)
318        self.predGraph = OWDistributionGraph(self, vizPredAcc)
319        self.predGraph.setMaximumSize(QSize(300, 300))
320        self.predGraph.setYRlabels(None)
321        self.predGraph.setAxisScale(QwtPlot.xBottom, 0.0, 1.0, 0.1)
322        self.predGraph.numberOfBars = 2
323        self.predGraph.barSize = 200 / (self.predGraph.numberOfBars + 1)
324        vizPredAcc.layout().addWidget(self.predGraph)
325       
326        vizPredAcc = OWGUI.widgetBox(self.modelTab, "Attribute lists", orientation = "vertical")
327        OWGUI.checkBox(vizPredAcc, self, "vizAttributes", "Display attribute lists", callback = self.visualizeInfo)
328        self.attrIntersectionBox = OWGUI.listBox(vizPredAcc, self, "attrIntersection", "attrIntersectionList", "Attribute intersection", selectionMode=QListWidget.NoSelection)
329        self.attrDifferenceBox = OWGUI.listBox(vizPredAcc, self, "attrDifference", "attrDifferenceList", "Attribute difference", selectionMode=QListWidget.NoSelection)
330       
331        self.attBox.setVisible(0)
332        self.visualizeInfo()
333       
334        QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.node_selection_changed)
335       
336        self.matrixTab.layout().addStretch(1)
337        self.modelTab.layout().addStretch(1)
338        self.setMinimumWidth(900)
339        self.controlArea.setMinimumWidth(378)
340       
341    def plotAccuracy(self, vertices=None):
342        self.predGraph.tips.removeAll()
343        self.predGraph.clear()
344        #self.predGraph.setAxisScale(QwtPlot.yRight, 0.0, 1.0, 0.2)
345        self.predGraph.setAxisScale(QwtPlot.xBottom,  0.0, 1.0, 0.2)
346       
347        if not vertices:
348            self.predGraph.replot()
349            return
350       
351        self.predGraph.setAxisScale(QwtPlot.yLeft, -0.5, len(self.matrix.originalData.domain.classVar.values) - 0.5, 1)
352       
353        scores = [[float(ca) for ca in ex["CA by class"].value.split(", ")] for ex in self.graph.items().getitems(vertices)]
354        scores = [sum(score) / len(score) for score in zip(*scores)]
355       
356        currentBarsHeight = [0] * len(scores)
357        for cn, score in enumerate(scores):
358            subBarHeight = score
359            ckey = PolygonCurve(pen = QPen(self.predGraph.discPalette[cn]), brush = QBrush(self.predGraph.discPalette[cn]))
360            ckey.attach(self.predGraph)
361            ckey.setRenderHint(QwtPlotItem.RenderAntialiased, self.predGraph.useAntialiasing)
362       
363            tmpx = cn - (self.predGraph.barSize/2.0)/100.0
364            tmpx2 = cn + (self.predGraph.barSize/2.0)/100.0
365            ckey.setData([currentBarsHeight[cn], currentBarsHeight[cn] + subBarHeight, currentBarsHeight[cn] + subBarHeight, currentBarsHeight[cn]], [tmpx, tmpx, tmpx2, tmpx2])
366            currentBarsHeight[cn] += subBarHeight
367           
368        self.predGraph.replot()
369       
370    def displayAttributeInfo(self, vertices=None):
371        self.attrIntersectionList = []
372        self.attrDifferenceList = []
373       
374        if vertices is None or len(vertices) == 0:
375            return
376       
377        attrList = [self.graph.items()[v]["attributes"].value.split(", ") for v in vertices]
378       
379        attrIntersection = set(attrList[0])
380        attrUnion = set()
381        for attrs in attrList:
382            attrIntersection = attrIntersection.intersection(attrs)
383            attrUnion = attrUnion.union(attrs)
384           
385        self.attrIntersectionList = attrIntersection
386        self.attrDifferenceList = attrUnion.difference(attrIntersection)
387           
388    def visualizeInfo(self):
389        self.networkCanvas.radius = self.radius
390       
391        if self.vizAccurancy:
392            self.networkCanvas.plotAccuracy = self.plotAccuracy
393        else:
394            self.networkCanvas.plotAccuracy = None
395            self.plotAccuracy(None)
396           
397        if self.vizAttributes:
398            self.networkCanvas.vizAttributes = self.displayAttributeInfo
399        else:
400            self.networkCanvas.vizAttributes = None
401            self.displayAttributeInfo(None)
402           
403    def setSubsetModels(self, subsetData):
404        self.info()
405       
406        if "uuid" not in subsetData.domain:
407            self.info("Invalid subset data. Data domain must contain 'uuid' attribute.")
408            return
409       
410        uuids = set([ex["uuid"].value for ex in subsetData])
411        for v in self.vertices:
412            v.highlight = 1 if v.uuid in uuids else 0
413               
414    def setMatrix(self, matrix):
415        self.warning()
416       
417        if matrix is None:
418            self.warning("Data matrix is None.")
419            return
420       
421        if not hasattr(matrix, "items") or not hasattr(matrix, "results") or not hasattr(matrix, "originalData"):
422            self.warning("Data matrix does not have required data for items, results and originalData.")
423            return
424       
425        requiredAttrs = set(["CA", "AUC", "attributes", "uuid"])
426        attrs = [attr.name for attr in matrix.items.domain] 
427        if len(requiredAttrs.intersection(attrs)) != len(requiredAttrs):
428            self.warning("Items ExampleTable does not contain required attributes: %s." % ", ".join(requiredAttrs))
429            return
430           
431        for ex in matrix.items:
432            ex["attributes"] = ", ".join(sorted(ex["attributes"].value.split(", ")))
433           
434        OWNxHist.setMatrix(self, matrix)
435       
436    def set_node_sizes(self):
437        OWNxExplorerQt.set_node_sizes(self)
438        self.networkCanvas.loadIcons()
439        self.networkCanvas.replot()
440       
441    def set_node_styles(self):
442        #for v in self.networkCanvas.networkCurve.nodes().itervalues():
443        #    #auc = self.graph.items()[v.index()]
444        #    v.style = 1 #auc
445        pass           
446       
447    def node_selection_changed(self):
448        self.warning()
449       
450        if self.graph is None or self.graph.items() is None or self.graph_matrix is None:
451            self.send("Model", None)
452            self.send("Selected Models", None)
453            return
454       
455        if self.graph.number_of_nodes() != self.graph_matrix.dim:
456            self.warning('Network items and matrix results not of equal length.')
457            self.send("Model", None)
458            self.send("Selected Models", None)
459            return
460                   
461        selection = self.networkCanvas.selected_nodes()
462       
463        if len(selection) == 1:
464            modelInstance = self.graph.items()[selection[0]]
465            # modelInfo - Python Dict; keys: method, classifier, probabilities,
466            # results, XAnchors, YAnchors, attributes
467            modelInfo = self.graph_matrix.results[modelInstance['uuid'].value]
468           
469            #uuid = modelInstance["uuid"].value
470            #method, vizr_result, projection_points, classifier, attrs = self.matrix.results[uuid]
471           
472            if 'YAnchors' in modelInfo and 'XAnchors' in modelInfo:
473                if not modelInstance.domain.hasmeta('anchors'):
474                    modelInstance.domain.addmeta(orange.newmetaid(), orange.PythonVariable('anchors'))
475                modelInstance['anchors'] = (modelInfo['XAnchors'], modelInfo['YAnchors'])
476               
477            if 'classifier' in modelInfo and modelInfo['classifier'] is not None:
478                if not modelInstance.domain.hasmeta('classifier'):
479                    modelInstance.domain.addmeta(orange.newmetaid(), orange.PythonVariable('classifier'))
480                modelInstance['classifier'] = modelInfo['classifier']
481                self.send('Classifier', modelInfo['classifier'])
482               
483            self.send('Model', modelInstance)
484            self.send('Selected Models', self.graph.items().getitems(selection))
485        elif len(selection) > 1: 
486            self.send('Model', None)
487            self.send('Selected Models', self.graph.items().getitems(selection))
488        else:
489            self.send('Model', None)
490            self.send('Selected Models', None)
491           
492    def setColors(self):
493        dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
494        if dlg.exec_():
495            self.colorSettings = dlg.getColorSchemas()
496            self.selectedSchemaIndex = dlg.selectedSchemaIndex
497            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
498            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
499           
500            self.set_node_colors()
501           
502    def set_node_colors(self):
503        if self.graph is None:
504            return
505       
506        self.networkCanvas.set_node_colors(self.colorCombo.currentText())
507        self.lastColorAttribute = self.colorCombo.currentText()
508        #self.networkCanvas.updateData()
509        #self.networkCanvas.replot()
510           
511    def sendSignals(self):
512        if self.graph is None or self.graph_matrix is None:
513            return
514       
515        self.set_graph(self.graph, ModelCurve)
516        self.set_items_distance_matrix(self.graph_matrix)
517        # TODO clickedAttLstBox -> setLabelText(["attributes"]
518       
519        nodes = self.networkCanvas.networkCurve.nodes()
520        for i, ex in enumerate(self.graph.items()):
521            nodes[i].uuid = ex["uuid"].value
522       
523        self.set_node_sizes()
524        self.set_node_styles()
525        self.set_node_colors()
526       
527        labels = self.matrix.originalData.domain.classVar.values.native()
528        self.predGraph.numberOfBars = len(labels)
529        self.predGraph.barSize = 200 / (self.predGraph.numberOfBars + 1)
530        self.predGraph.setYLlabels(labels)
531        #self.predGraph.setShowMainTitle(self.showMainTitle)
532        #self.predGraph.setYLaxisTitle(self.matrix.originalData.domain.classVar.name)
533        #self.predGraph.setShowYLaxisTitle(True)
534        self.predGraph.setAxisScale(QwtPlot.xBottom,  0.0, 1.0, 0.2)
535        self.predGraph.setAxisScale(QwtPlot.yLeft, -0.5, len(self.matrix.originalData.domain.classVar.values) - 0.5, 1)
536   
537        self.predGraph.enableYRaxis(0)
538        self.predGraph.setYRaxisTitle("")
539        self.predGraph.setXaxisTitle("CA")
540        self.predGraph.setShowXaxisTitle(True)
541        self.predGraph.replot()
542       
543        self.visualizeInfo()
544
545if __name__=="__main__":   
546    import OWModelFile
547    import pickle
548    modelName = 'zoo-168'
549    root = 'c:\\Users\\miha\\Projects\\res\\metamining\\'
550   
551    appl = QApplication(sys.argv)
552    ow = OWModelMap()
553    ow.show()
554    mroot = '%snew\\' % root
555    matrix,labels,data = OWModelFile.readMatrix('%s%s.npy' % (mroot,modelName))
556    if os.path.exists('%s%s.tab' % (mroot, modelName)):
557        matrix.items = orange.ExampleTable('%s%s.tab' % (mroot, modelName))
558    else:
559        print 'ExampleTable %s not found!\n' % ('%s%s.tab' % (mroot,modelName))
560    if os.path.exists('%s%s.res' % (mroot, modelName)):
561        matrix.results = pickle.load(open('%s%s.res' % \
562                                               (mroot, modelName), 'rb'))
563    else:
564        print 'Results pickle %s not found!\n' % \
565              ('%s%s.res' % (mroot, modelName))
566   
567    matrix.originalData = Orange.data.Table('%stab\\zoo.tab' % root)
568    ow.setMatrix(matrix)
569    appl.exec_()
570   
571   
Note: See TracBrowser for help on using the repository browser.