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

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