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

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

Added .hgeol and converted some line endings.

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, "results") or not hasattr(matrix, "originalData"):
432            self.warning("Data matrix does not have required data for items, results and originalData.")
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 ExampleTable 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   
581   
Note: See TracBrowser for help on using the repository browser.