source: orange/Orange/OrangeWidgets/Unsupervised/OWModelMapQt.py @ 10829:8fd074ecd2e9

Revision 10829:8fd074ecd2e9, 25.6 KB checked in by mstajdohar, 2 years ago (diff)

New model.

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