Ignore:
Timestamp:
04/20/12 10:25:50 (2 years ago)
Author:
mstajdohar
Branch:
default
rebase_source:
2fd504cd0a9cc2ff0dafa958c020d3c6d2093782
Message:

New model.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Unsupervised/OWModelMapQt.py

    r9671 r10829  
    2626dir = os.path.dirname(__file__) + "/../" 
    2727 
    28 ICON_PATHS = [("TREE",              "Classify/icons/ClassificationTree"), 
    29               ("SCATTERPLOT",       "Visualize/icons/ScatterPlot"), 
    30               ("SCATTTERPLOT",      "Visualize/icons/ScatterPlot"), 
     28ICON_PATHS = [("TREE", "Classify/icons/ClassificationTree"), 
     29              ("SCATTERPLOT", "Visualize/icons/ScatterPlot"), 
     30              ("SCATTTERPLOT", "Visualize/icons/ScatterPlot"), 
    3131              ("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")] 
     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")] 
    4040 
    4141ICON_SIZES = ["16", "32", "40", "48", "60"] 
     
    6060    def __init__(self, parent=None, pen=QPen(Qt.black), xData=None, yData=None): 
    6161        NetworkCurve.__init__(self, parent, pen=QPen(Qt.black), xData=None, yData=None) 
    62          
     62 
    6363    def draw(self, painter, xMap, yMap, rect): 
    6464        for edge in self.edges: 
    6565            if edge.u.show and edge.v.show: 
    6666                painter.setPen(edge.pen) 
    67      
     67 
    6868                px1 = xMap.transform(self.coors[0][edge.u.index])   #ali pa tudi self.x1, itd 
    6969                py1 = yMap.transform(self.coors[1][edge.u.index]) 
    7070                px2 = xMap.transform(self.coors[0][edge.v.index]) 
    7171                py2 = yMap.transform(self.coors[1][edge.v.index]) 
    72                  
     72 
    7373                painter.drawLine(px1, py1, px2, py2) 
    74                  
     74 
    7575                d = 12 
    7676                #painter.setPen(QPen(Qt.lightGray, 1)) 
     
    7979                    x = px1 - px2 
    8080                    y = py1 - py2 
    81                      
    82                     fi = math.atan2(y, x) * 180 * 16 / math.pi  
    83          
     81 
     82                    fi = math.atan2(y, x) * 180 * 16 / math.pi 
     83 
    8484                    if not fi is None: 
    8585                        # (180*16) - fi - (20*16), (40*16) 
    8686                        painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640) 
    87                          
     87 
    8888                if edge.arrowv: 
    8989                    x = px1 - px2 
    9090                    y = py1 - py2 
    91                      
    92                     fi = math.atan2(y, x) * 180 * 16 / math.pi  
     91 
     92                    fi = math.atan2(y, x) * 180 * 16 / math.pi 
    9393                    if not fi is None: 
    9494                        # (180*16) - fi - (20*16), (40*16) 
    9595                        painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640) 
    96                          
     96 
    9797                if self.showEdgeLabels and len(edge.label) > 0: 
    9898                    lbl = ', '.join(edge.label) 
    9999                    x = (px1 + px2) / 2 
    100100                    y = (py1 + py2) / 2 
    101                      
     101 
    102102                    th = painter.fontMetrics().height() 
    103103                    tw = painter.fontMetrics().width(lbl) 
     
    105105                    painter.fillRect(r, QBrush(Qt.white)) 
    106106                    painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl) 
    107      
     107 
    108108        for vertex in self.vertices: 
    109109            if vertex.show: 
     
    118118                #    #oldcolor = QColor(125, 162, 206, 192) 
    119119                painter.setPen(QPen(QBrush(vertex.color), 1, Qt.SolidLine, Qt.RoundCap)) 
    120                  
     120 
    121121                if vertex.selected: 
    122122                    size = int(vertex.size) + 5 
     
    127127                    gradient.setColorAt(1., QColor(255, 255, 255, 0)) 
    128128                    painter.setBrush(QBrush(gradient)) 
    129                     painter.drawRoundedRect(pX - size/2, pY - size/2, size, size, style, style, Qt.RelativeSize) 
     129                    painter.drawRoundedRect(pX - size / 2, pY - size / 2, size, size, style, style, Qt.RelativeSize) 
    130130                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size) 
    131131                elif vertex.marked: 
     
    137137                    gradient.setColorAt(1., QColor(255, 255, 255, 0)) 
    138138                    painter.setBrush(QBrush(gradient)) 
    139                     painter.drawRoundedRect(pX - size/2, pY - size/2, size, size, style, style, Qt.RelativeSize) 
     139                    painter.drawRoundedRect(pX - size / 2, pY - size / 2, size, size, style, style, Qt.RelativeSize) 
    140140                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size) 
    141141                else: 
     
    146146                    gradient.setColorAt(1., QColor(255, 255, 255, 0)) 
    147147                    painter.setBrush(QBrush(gradient)) 
    148                     painter.drawRoundedRect(pX - size/2, pY - size/2, size, size, style, style, Qt.RelativeSize) 
     148                    painter.drawRoundedRect(pX - size / 2, pY - size / 2, size, size, style, style, Qt.RelativeSize) 
    149149                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size) 
    150      
     150 
    151151        for vertex in self.vertices: 
    152             if vertex.show:                 
     152            if vertex.show: 
    153153                pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer) 
    154154                pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa 
     
    156156                if vertex.image: 
    157157                    size = vertex.image.size().width() 
    158                     painter.drawImage(QRect(pX - size/2, pY - size/2, size, size), vertex.image) 
    159                      
     158                    painter.drawImage(QRect(pX - size / 2, pY - size / 2, size, size), vertex.image) 
     159 
    160160class OWModelMapCanvas(OWNxCanvasQt.OWNxCanvas): 
    161      
     161 
    162162    def __init__(self, master, parent=None, name="None"): 
    163163        OWNxCanvasQt.OWNxCanvas.__init__(self, master, parent, name) 
    164164        self.networkCurve = ModelCurve() 
    165165        self.NodeItem = ModelItem 
    166          
     166 
    167167        self.selectionNeighbours = 1 
    168168        self.tooltipNeighbours = 1 
     
    170170        self.vizAttributes = None 
    171171        self.radius = 100 
    172          
     172 
    173173#    def mouseMoveEvent(self, event): 
    174174#        if self.graph is None or self.layout is None: 
     
    206206#        else: 
    207207#            OWNxCanvas.mouseMoveEvent(self, event) 
    208          
     208 
    209209    def set_tooltip_attributes(self, attributes): 
    210210        if self.graph is None or self.items is None or \ 
    211211           not isinstance(self.items, orange.ExampleTable): 
    212212            return 
    213          
     213 
    214214        attributes = ["Cluster CA", "label", "CA", "attributes"] 
    215          
     215 
    216216#        lbl  = "%s\n" % self.graph.items()[vertex.index]["label"].value 
    217217#        lbl += "CA: %.4g\n" % self.graph.items()[vertex.index]["CA"].value 
     
    220220#        lbl += "Attributes: %d\n" % len(self.graph.items()[vertex.index]["attributes"].value.split(", ")) 
    221221#        lbl += ", ".join(sorted(self.graph.items()[vertex.index]["attributes"].value.split(", "))) 
    222          
     222 
    223223        tooltip_attributes = [self.items.domain[att] for att in \ 
    224224                                 attributes if att in self.items.domain] 
    225         self.networkCurve.set_node_tooltips(dict((node, ', '.join(str( \ 
     225        self.networkCurve.set_node_tooltips(dict((node, ', '.join(str(\ 
    226226                   self.items[node][att]) for att in tooltip_attributes)) \ 
    227227                                                        for node in self.graph)) 
    228              
     228 
    229229    def loadIcons(self): 
    230230        items = self.graph.items() 
     
    233233        for v in self.networkCurve.nodes().itervalues(): 
    234234            size = str(minsize) if v.size() <= minsize else maxsize 
    235              
     235 
    236236            for i in range(len(ICON_SIZES) - 1): 
    237                 if int(ICON_SIZES[i]) < v.size() <= int(ICON_SIZES[i+1]): 
     237                if int(ICON_SIZES[i]) < v.size() <= int(ICON_SIZES[i + 1]): 
    238238                    size = ICON_SIZES[i] 
    239239            imageKey = items[v.index()]['model'].value + size 
    240240            if imageKey not in MODEL_IMAGES: 
    241241                imageKey = "MISSING" 
    242              
     242 
    243243            fn = MODEL_IMAGES[imageKey] 
    244244            if not fn in PIXMAP_CACHE: 
     
    265265    settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage", 
    266266        "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",  
     267        "networkCanvas.animate_points", "networkCanvas.antialias_plot", 
     268        "networkCanvas.antialias_points", "networkCanvas.antialias_lines", 
     269        "networkCanvas.auto_adjust_performance", "invertSize", "optMethod", 
    270270        "lastVertexSizeColumn", "lastColorColumn", "networkCanvas.show_indices", "networkCanvas.show_weights", 
    271271        "lastNameComponentAttribute", "lastLabelColumns", "lastTooltipColumns", 
    272         "showWeights", "showEdgeLabels", "colorSettings",  
     272        "showWeights", "showEdgeLabels", "colorSettings", 
    273273        "selectedSchemaIndex", "edgeColorSettings", "selectedEdgeSchemaIndex", 
    274274        "showMissingValues", "fontSize", "mdsTorgerson", "mdsAvgLinkage", 
    275         "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism","showTextMiningInfo",  
     275        "mdsSteps", "mdsRefresh", "mdsStressDelta", "organism", "showTextMiningInfo", 
    276276        "toolbarSelection", "minComponentEdgeWidth", "maxComponentEdgeWidth", 
    277         "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",  
     277        "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex", 
    278278        "networkCanvas.trim_label_words", "opt_from_curr", "networkCanvas.explore_distances", 
    279279        "networkCanvas.show_component_distances", "fontWeight", "networkCanvas.state", 
    280         "networkCanvas.selection_behavior"]  
    281      
     280        "networkCanvas.selection_behavior"] 
     281 
    282282    def __init__(self, parent=None, signalManager=None, name="Model Map"): 
    283         OWNxExplorer.__init__(self, parent, signalManager, name,  
     283        OWNxExplorer.__init__(self, parent, signalManager, name, 
    284284                               NetworkCanvas=OWModelMapCanvas) 
    285          
     285 
    286286        self.inputs = [("Distances", orange.SymMatrix, self.setMatrix, Default), 
    287287                       ("Model Subset", orange.ExampleTable, self.setSubsetModels)] 
     
    289289                        ("Classifier", orange.Classifier), 
    290290                        ("Selected Models", orange.ExampleTable)] 
    291          
     291 
    292292        self.vertexSize = 32 
    293293        self.autoSendSelection = False 
     
    303303        self.attrDifference = [] 
    304304        self.attrDifferenceList = [] 
    305          
     305 
    306306        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) 
     307 
     308        self.matrixTab = OWGUI.widgetBox(self.tabs, addToLayout=0, margin=4) 
     309        self.modelTab = OWGUI.widgetBox(self.tabs, addToLayout=0, margin=4) 
    310310        self.tabs.insertTab(0, self.matrixTab, "Matrix") 
    311311        self.tabs.insertTab(1, self.modelTab, "Model Info") 
    312312        self.tabs.setCurrentIndex(self.tabIndex) 
    313          
     313 
    314314        self.networkCanvas.appendToSelection = 0 
    315315        self.networkCanvas.minVertexSize = self.minVertexSize 
    316316        self.networkCanvas.maxVertexSize = self.maxVertexSize 
    317317        self.networkCanvas.invertEdgeSize = 1 
    318          
     318 
    319319        # MARTIX CONTROLS 
    320320        self.addHistogramControls(self.matrixTab) 
    321321        self.kNN = 1 
    322         boxHistogram = OWGUI.widgetBox(self.matrixTab, box = "Distance histogram") 
     322        boxHistogram = OWGUI.widgetBox(self.matrixTab, box="Distance histogram") 
    323323        self.histogram = OWHist(self, boxHistogram) 
    324324        boxHistogram.layout().addWidget(self.histogram) 
    325          
     325 
    326326        # VISUALIZATION CONTROLS 
    327         vizPredAcc = OWGUI.widgetBox(self.modelTab, "Prediction Accuracy", orientation = "vertical") 
     327        vizPredAcc = OWGUI.widgetBox(self.modelTab, "Prediction Accuracy", orientation="vertical") 
    328328        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) 
     329        OWGUI.spin(vizPredAcc, self, "radius", 10, 300, 1, label="Radius: ", callback=self.visualizeInfo) 
    330330        self.predGraph = OWDistributionGraph(self, vizPredAcc) 
    331331        self.predGraph.setMaximumSize(QSize(300, 300)) 
     
    335335        self.predGraph.barSize = 200 / (self.predGraph.numberOfBars + 1) 
    336336        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) 
     337 
     338        vizPredAcc = OWGUI.widgetBox(self.modelTab, "Attribute lists", orientation="vertical") 
     339        OWGUI.checkBox(vizPredAcc, self, "vizAttributes", "Display attribute lists", callback=self.visualizeInfo) 
    340340        self.attrIntersectionBox = OWGUI.listBox(vizPredAcc, self, "attrIntersection", "attrIntersectionList", "Attribute intersection", selectionMode=QListWidget.NoSelection) 
    341341        self.attrDifferenceBox = OWGUI.listBox(vizPredAcc, self, "attrDifference", "attrDifferenceList", "Attribute difference", selectionMode=QListWidget.NoSelection) 
    342          
     342 
    343343        self.attBox.hide() 
    344344        self.visualizeInfo() 
    345          
     345 
    346346        QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.node_selection_changed) 
    347          
     347 
    348348        self.matrixTab.layout().addStretch(1) 
    349349        self.modelTab.layout().addStretch(1) 
    350          
     350 
    351351    def plotAccuracy(self, vertices=None): 
    352352        self.predGraph.tips.removeAll() 
    353353        self.predGraph.clear() 
    354354        #self.predGraph.setAxisScale(QwtPlot.yRight, 0.0, 1.0, 0.2) 
    355         self.predGraph.setAxisScale(QwtPlot.xBottom,  0.0, 1.0, 0.2) 
    356          
     355        self.predGraph.setAxisScale(QwtPlot.xBottom, 0.0, 1.0, 0.2) 
     356 
    357357        if not vertices: 
    358358            self.predGraph.replot() 
    359359            return 
    360          
     360 
    361361        self.predGraph.setAxisScale(QwtPlot.yLeft, -0.5, len(self.matrix.originalData.domain.classVar.values) - 0.5, 1) 
    362          
     362 
    363363        scores = [[float(ca) for ca in ex["CA by class"].value.split(", ")] for ex in self.graph.items().getitems(vertices)] 
    364364        scores = [sum(score) / len(score) for score in zip(*scores)] 
    365          
     365 
    366366        currentBarsHeight = [0] * len(scores) 
    367367        for cn, score in enumerate(scores): 
    368368            subBarHeight = score 
    369             ckey = PolygonCurve(pen = QPen(self.predGraph.discPalette[cn]), brush = QBrush(self.predGraph.discPalette[cn])) 
     369            ckey = PolygonCurve(pen=QPen(self.predGraph.discPalette[cn]), brush=QBrush(self.predGraph.discPalette[cn])) 
    370370            ckey.attach(self.predGraph) 
    371371            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 
     372 
     373            tmpx = cn - (self.predGraph.barSize / 2.0) / 100.0 
     374            tmpx2 = cn + (self.predGraph.barSize / 2.0) / 100.0 
    375375            ckey.setData([currentBarsHeight[cn], currentBarsHeight[cn] + subBarHeight, currentBarsHeight[cn] + subBarHeight, currentBarsHeight[cn]], [tmpx, tmpx, tmpx2, tmpx2]) 
    376376            currentBarsHeight[cn] += subBarHeight 
    377              
     377 
    378378        self.predGraph.replot() 
    379          
     379 
    380380    def displayAttributeInfo(self, vertices=None): 
    381381        self.attrIntersectionList = [] 
    382382        self.attrDifferenceList = [] 
    383          
     383 
    384384        if vertices is None or len(vertices) == 0: 
    385385            return 
    386          
     386 
    387387        attrList = [self.graph.items()[v]["attributes"].value.split(", ") for v in vertices] 
    388          
     388 
    389389        attrIntersection = set(attrList[0]) 
    390390        attrUnion = set() 
     
    392392            attrIntersection = attrIntersection.intersection(attrs) 
    393393            attrUnion = attrUnion.union(attrs) 
    394              
     394 
    395395        self.attrIntersectionList = attrIntersection 
    396396        self.attrDifferenceList = attrUnion.difference(attrIntersection) 
    397              
     397 
    398398    def visualizeInfo(self): 
    399399        self.networkCanvas.radius = self.radius 
    400          
     400 
    401401        if self.vizAccurancy: 
    402402            self.networkCanvas.plotAccuracy = self.plotAccuracy 
     
    404404            self.networkCanvas.plotAccuracy = None 
    405405            self.plotAccuracy(None) 
    406              
     406 
    407407        if self.vizAttributes: 
    408408            self.networkCanvas.vizAttributes = self.displayAttributeInfo 
     
    410410            self.networkCanvas.vizAttributes = None 
    411411            self.displayAttributeInfo(None) 
    412              
     412 
    413413    def setSubsetModels(self, subsetData): 
    414414        self.info() 
    415          
     415 
    416416        if "uuid" not in subsetData.domain: 
    417417            self.info("Invalid subset data. Data domain must contain 'uuid' attribute.") 
    418418            return 
    419          
     419 
    420420        uuids = set([ex["uuid"].value for ex in subsetData]) 
    421421        for v in self.vertices: 
    422422            v.highlight = 1 if v.uuid in uuids else 0 
    423                  
     423 
    424424    def setMatrix(self, matrix): 
    425425        self.warning() 
    426          
     426 
    427427        if matrix is None: 
    428428            self.warning("Data matrix is None.") 
    429429            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          
     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 
    435435        requiredAttrs = set(["CA", "AUC", "attributes", "uuid"]) 
    436         attrs = [attr.name for attr in matrix.items.domain]  
     436        attrs = [attr.name for attr in matrix.items.domain] 
    437437        if len(requiredAttrs.intersection(attrs)) != len(requiredAttrs): 
    438             self.warning("Items ExampleTable does not contain required attributes: %s." % ", ".join(requiredAttrs)) 
    439             return 
    440              
     438            self.warning("Items Orange.data.Table does not contain required attributes: %s." % ", ".join(requiredAttrs)) 
     439            return 
     440 
    441441        for ex in matrix.items: 
    442442            ex["attributes"] = ", ".join(sorted(ex["attributes"].value.split(", "))) 
    443              
     443 
    444444        OWNxHist.setMatrix(self, matrix) 
    445          
     445 
    446446    def set_node_sizes(self): 
    447447        OWNxExplorer.set_node_sizes(self) 
    448448        self.networkCanvas.loadIcons() 
    449449        self.networkCanvas.replot() 
    450          
     450 
    451451    def set_node_styles(self): 
    452452        #for v in self.networkCanvas.networkCurve.nodes().itervalues(): 
    453453        #    #auc = self.graph.items()[v.index()] 
    454454        #    v.style = 1 #auc 
    455         pass             
    456          
     455        pass 
     456 
    457457    def node_selection_changed(self): 
    458458        self.warning() 
    459          
     459 
    460460        if self.graph is None or self.graph.items() is None or self.graph_matrix is None: 
    461461            self.send("Model", None) 
    462462            self.send("Selected Models", None) 
    463463            return 
    464          
     464 
    465465        if self.graph.number_of_nodes() != self.graph_matrix.dim: 
    466466            self.warning('Network items and matrix results not of equal length.') 
     
    468468            self.send("Selected Models", None) 
    469469            return 
    470                      
     470 
    471471        selection = self.networkCanvas.selected_nodes() 
    472          
     472 
    473473        if len(selection) == 1: 
    474474            modelInstance = self.graph.items()[selection[0]] 
     
    476476            # results, XAnchors, YAnchors, attributes 
    477477            modelInfo = self.graph_matrix.results[modelInstance['uuid'].value] 
    478              
     478 
    479479            #uuid = modelInstance["uuid"].value 
    480480            #method, vizr_result, projection_points, classifier, attrs = self.matrix.results[uuid] 
    481              
     481 
    482482            if 'YAnchors' in modelInfo and 'XAnchors' in modelInfo: 
    483483                if not modelInstance.domain.hasmeta('anchors'): 
    484484                    modelInstance.domain.addmeta(orange.newmetaid(), orange.PythonVariable('anchors')) 
    485485                modelInstance['anchors'] = (modelInfo['XAnchors'], modelInfo['YAnchors']) 
    486                  
     486 
    487487            if 'classifier' in modelInfo and modelInfo['classifier'] is not None: 
    488488                if not modelInstance.domain.hasmeta('classifier'): 
     
    490490                modelInstance['classifier'] = modelInfo['classifier'] 
    491491                self.send('Classifier', modelInfo['classifier']) 
    492                  
     492 
    493493            self.send('Model', modelInstance) 
    494494            self.send('Selected Models', self.graph.items().getitems(selection)) 
    495         elif len(selection) > 1:  
     495        elif len(selection) > 1: 
    496496            self.send('Model', None) 
    497497            self.send('Selected Models', self.graph.items().getitems(selection)) 
     
    499499            self.send('Model', None) 
    500500            self.send('Selected Models', None) 
    501              
     501 
    502502    def setColors(self): 
    503503        dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex) 
     
    507507            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette") 
    508508            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette") 
    509              
     509 
    510510            self.set_node_colors() 
    511              
     511 
    512512    def set_node_colors(self): 
    513513        if self.graph is None: 
    514514            return 
    515          
     515 
    516516        self.networkCanvas.set_node_colors(self.colorCombo.currentText()) 
    517517        self.lastColorAttribute = self.colorCombo.currentText() 
    518518        #self.networkCanvas.updateData() 
    519519        #self.networkCanvas.replot() 
    520              
     520 
    521521    def sendSignals(self): 
    522522        if self.graph is None or self.graph_matrix is None: 
    523523            return 
    524          
     524 
    525525        self.set_graph(self.graph, ModelCurve) 
    526526        self.set_items_distance_matrix(self.graph_matrix) 
    527527        # TODO clickedAttLstBox -> setLabelText(["attributes"] 
    528          
     528 
    529529        nodes = self.networkCanvas.networkCurve.nodes() 
    530530        for i, ex in enumerate(self.graph.items()): 
    531531            nodes[i].uuid = ex["uuid"].value 
    532          
     532 
    533533        self.set_node_sizes() 
    534534        self.set_node_styles() 
    535535        self.set_node_colors() 
    536          
     536 
    537537        labels = self.matrix.originalData.domain.classVar.values.native() 
    538538        self.predGraph.numberOfBars = len(labels) 
     
    542542        #self.predGraph.setYLaxisTitle(self.matrix.originalData.domain.classVar.name) 
    543543        #self.predGraph.setShowYLaxisTitle(True) 
    544         self.predGraph.setAxisScale(QwtPlot.xBottom,  0.0, 1.0, 0.2) 
     544        self.predGraph.setAxisScale(QwtPlot.xBottom, 0.0, 1.0, 0.2) 
    545545        self.predGraph.setAxisScale(QwtPlot.yLeft, -0.5, len(self.matrix.originalData.domain.classVar.values) - 0.5, 1) 
    546      
     546 
    547547        self.predGraph.enableYRaxis(0) 
    548548        self.predGraph.setYRaxisTitle("") 
     
    550550        self.predGraph.setShowXaxisTitle(True) 
    551551        self.predGraph.replot() 
    552          
     552 
    553553        self.visualizeInfo() 
    554554 
    555 if __name__=="__main__":     
     555if __name__ == "__main__": 
    556556    import OWModelFile 
    557557    import pickle 
    558558    modelName = 'zoo-168' 
    559559    root = 'c:\\Users\\miha\\Projects\\res\\metamining\\' 
    560      
     560 
    561561    appl = QApplication(sys.argv) 
    562562    ow = OWModelMap() 
    563563    ow.show() 
    564564    mroot = '%snew\\' % root 
    565     matrix,labels,data = OWModelFile.readMatrix('%s%s.npy' % (mroot,modelName)) 
     565    matrix, labels, data = OWModelFile.readMatrix('%s%s.npy' % (mroot, modelName)) 
    566566    if os.path.exists('%s%s.tab' % (mroot, modelName)): 
    567567        matrix.items = orange.ExampleTable('%s%s.tab' % (mroot, modelName)) 
    568568    else: 
    569         print 'ExampleTable %s not found!\n' % ('%s%s.tab' % (mroot,modelName)) 
     569        print 'ExampleTable %s not found!\n' % ('%s%s.tab' % (mroot, modelName)) 
    570570    if os.path.exists('%s%s.res' % (mroot, modelName)): 
    571571        matrix.results = pickle.load(open('%s%s.res' % \ 
     
    574574        print 'Results pickle %s not found!\n' % \ 
    575575              ('%s%s.res' % (mroot, modelName)) 
    576      
     576 
    577577    matrix.originalData = Orange.data.Table('%stab\\zoo.tab' % root) 
    578578    ow.setMatrix(matrix) 
    579579    appl.exec_() 
    580      
    581      
     580 
Note: See TracChangeset for help on using the changeset viewer.