Changeset 4965:db3d5dde346d in orange


Ignore:
Timestamp:
07/14/08 13:43:40 (6 years ago)
Author:
gregor <gregor@…>
Branch:
default
Convert:
2271d95045a78a7e2a0d9f1aa9ecfd1b9defa04b
Message:
  • removed activateLoadedSettings
  • added new constructor to basewidget
  • use of example.id instead of example.reference() in visualizing subset data
Location:
orange/OrangeWidgets/Visualize
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Visualize/OWCorrAnalysis.py

    r4845 r4965  
    3232 
    3333    if not isinstance(data, orange.ExampleTable): 
    34         return False         
     34        return False 
    3535    if len(data.domain.attributes) < 10 and len(data.domain.getmetas(orngText.TEXTMETAID)) > 15: 
    3636        return True 
     
    9797        self.attrRow = "" 
    9898        self.attrRowCombo = OWGUI.comboBox(self.GeneralTab, self, "attrRow", "Row table attribute ", callback = self.updateTables, sendSelectedValue = 1, valueType = str) 
    99         
     99 
    100100        #x principal axis 
    101101        self.attrX = 0 
     
    109109        self.firstAxis = OWGUI.widgetLabel(contribution, 'Axis %d: %f%%' % (1, 10)) 
    110110        self.secondAxis = OWGUI.widgetLabel(contribution, 'Axis %d: %f%%' % (2, 10)) 
    111          
     111 
    112112        sliders = QVGroupBox('Percentage of points', self.GeneralTab) 
    113113        OWGUI.widgetLabel(sliders, 'Row points') 
     
    137137        # point width 
    138138        OWGUI.hSlider(self.SettingsTab, self, 'graph.pointWidth', box=' Point size ', minValue=1, maxValue=20, step=1, callback = self.replotCurves) 
    139          
     139 
    140140        # general graph settings 
    141141        box4 = OWGUI.widgetBox(self.SettingsTab, " General graph settings ") 
     
    176176        OWGUI.listBox(self.resultsTab, self, "chosenWord", "words", box="Suggested words", callback = None) 
    177177 
    178  
    179  
    180         self.activateLoadedSettings() 
     178        dlg = self.createColorDialog() 
     179        self.graph.contPalette = dlg.getContinuousPalette("contPalette") 
     180        self.graph.discPalette = dlg.getDiscretePalette("discPalette") 
     181        self.graph.setCanvasBackground(dlg.getColor("Canvas")) 
     182        self.graph.setGridColor(QPen(dlg.getColor("Grid"))) 
     183 
     184        self.graph.enableGridXB(self.showGridlines) 
     185        self.graph.enableGridYL(self.showGridlines) 
     186 
     187        apply([self.zoomSelectToolbar.actionZooming, self.zoomSelectToolbar.actionRectangleSelection, self.zoomSelectToolbar.actionPolygonSelection, self.zoomSelectToolbar.actionBrowse, self.zoomSelectToolbar.actionBrowseCircle][self.toolbarSelection], []) 
     188 
    181189        self.resize(700, 800) 
    182190 
     
    279287            self.words = [i[0] + '  ' + str(i[1]) for i in tmp] 
    280288 
    281     def activateLoadedSettings(self): 
    282         dlg = self.createColorDialog() 
    283         self.graph.contPalette = dlg.getContinuousPalette("contPalette") 
    284         self.graph.discPalette = dlg.getDiscretePalette("discPalette") 
    285         self.graph.setCanvasBackground(dlg.getColor("Canvas")) 
    286         self.graph.setGridColor(QPen(dlg.getColor("Grid"))) 
    287  
    288         self.graph.enableGridXB(self.showGridlines) 
    289         self.graph.enableGridYL(self.showGridlines) 
    290  
    291         apply([self.zoomSelectToolbar.actionZooming, self.zoomSelectToolbar.actionRectangleSelection, self.zoomSelectToolbar.actionPolygonSelection, self.zoomSelectToolbar.actionBrowse, self.zoomSelectToolbar.actionBrowseCircle][self.toolbarSelection], []) 
    292289 
    293290    def dataset(self, dataset): 
     
    358355                if not hasNameAttribute: 
    359356                    self.tipsR = [ex['text'].value[:35] for ex in data] 
    360                     self.rowCategories = [(ex['text'].value[:35], "Row points") for ex in data]  
     357                    self.rowCategories = [(ex['text'].value[:35], "Row points") for ex in data] 
    361358                    self.catColors = {"Row points": 0} 
    362359                else: 
     
    395392                            col = (col + 1) % len(colors) 
    396393            self.tipsC = [a.name for a in data.domain.getmetas(orngText.TEXTMETAID).values()] 
    397         else:             
     394        else: 
    398395            ca = orange.ContingencyAttrAttr(self.attrRow, self.attrCol, self.data) 
    399396            caList = [[col for col in row] for row in ca] 
  • orange/OrangeWidgets/Visualize/OWDistributions.py

    r4906 r4965  
    7373        self.probCurveUpperCIKey = self.addCurve(QwtPlot.xBottom, QwtPlot.yRight, 0) 
    7474        self.probCurveLowerCIKey = self.addCurve(QwtPlot.xBottom, QwtPlot.yRight, 0) 
    75          
     75 
    7676        self.tooltipManager = TooltipManager(self) 
    7777 
     
    270270        self.probCurveKey = self.addCurve(QwtPlot.xBottom, QwtPlot.yRight) 
    271271        self.probCurveUpperCIKey = self.addCurve(QwtPlot.xBottom, QwtPlot.yRight) 
    272         self.probCurveLowerCIKey = self.addCurve(QwtPlot.xBottom, QwtPlot.yRight)             
     272        self.probCurveLowerCIKey = self.addCurve(QwtPlot.xBottom, QwtPlot.yRight) 
    273273 
    274274        self.replot() 
     
    304304                        ff = "%."+str(self.data.domain[self.attributeName].numberOfDecimals+1)+"f" 
    305305                        text = "N(%s=%s|%s in ("+ff+","+ff+"])=<b>%i</b><br>P(%s=%s|%s in ("+ff+","+ff+"])=<b>%.3f</b><br>" 
    306                         text = text%(str(self.data.domain.classVar.name), str(self.data.domain.classVar[oi]), str(self.attributeName), key, key+self.subIntervalStep, subBarHeight,  
     306                        text = text%(str(self.data.domain.classVar.name), str(self.data.domain.classVar[oi]), str(self.attributeName), key, key+self.subIntervalStep, subBarHeight, 
    307307                                     str(self.data.domain.classVar.name), str(self.data.domain.classVar[oi]), str(self.attributeName), key, key+self.subIntervalStep, float(subBarHeight/sum(self.hdata[key]))) #self.probGraphValues[cn][1][oi]) 
    308308                        self.tips.addToolTip(key+self.subIntervalStep/2.0, currentBarsHeight[cn] + subBarHeight/2.0, text, self.subIntervalStep/2.0, subBarHeight/2.0) 
     
    312312                        ckey.setData([tmpx, tmpx2, tmpx2, tmpx], [currentBarsHeight[cn], currentBarsHeight[cn], currentBarsHeight[cn] + subBarHeight, currentBarsHeight[cn] + subBarHeight]) 
    313313                        text = "N(%s=%s|%s=%s)=<b>%i</b><br>P(%s=%s|%s=%s)=<b>%.3f</b>" 
    314                         text = text%(str(self.data.domain.classVar.name), str(self.data.domain.classVar[oi]), str(self.attributeName), str(key), subBarHeight,  
     314                        text = text%(str(self.data.domain.classVar.name), str(self.data.domain.classVar[oi]), str(self.attributeName), str(key), subBarHeight, 
    315315                                     str(self.data.domain.classVar.name), str(self.data.domain.classVar[oi]), str(self.attributeName), str(key), float(subBarHeight/sum(self.hdata[key]))) 
    316316                        self.tips.addToolTip(cn, currentBarsHeight[cn]+subBarHeight/2.0, text, (self.barSize/2.0)/100.0, subBarHeight/2.0) 
     
    379379                curve.setVisible(en) 
    380380                curve.itemChanged() 
    381                  
     381 
    382382        enableIfExists(self.probCurveKey, self.showProbabilities) 
    383383        enableIfExists(self.probCurveUpperCIKey, self.showConfidenceIntervals and self.showProbabilities) 
    384384        enableIfExists(self.probCurveLowerCIKey, self.showConfidenceIntervals and self.showProbabilities) 
    385         self.replot()         
    386          
     385        self.replot() 
     386 
    387387class OWDistributions(OWWidget): 
    388388    settingsList = ["numberOfBars", "barSize", "showContinuousClassGraph", "showProbabilities", "showConfidenceIntervals", "smoothLines", "lineWidth", "showMainTitle", "showXaxisTitle", "showYaxisTitle", "showYPaxisTitle"] 
     
    422422        self.GeneralTab = OWGUI.createTabPage(self.tabs, "Main") 
    423423        self.SettingsTab = OWGUI.createTabPage(self.tabs, "Settings") 
    424          
     424 
    425425        self.graph = OWDistributionGraph(self, self.mainArea) 
    426426        self.mainArea.layout().addWidget(self.graph) 
     
    460460 
    461461        OWGUI.checkBox(box, self, 'showContinuousClassGraph', 'Show continuous class graph', callback=self.setShowContinuousClassGraph) 
    462          
     462 
    463463        box5 = OWGUI.widgetBox(self.SettingsTab, "Probability plot") 
    464464        self.showProb = OWGUI.checkBox(box5, self, 'showProbabilities', 'Show probabilities', callback = self.setShowProbabilities) 
     
    483483        self.icons = self.createAttributeIconDict() 
    484484 
    485         self.activateLoadedSettings() 
    486  
    487     def activateLoadedSettings(self): 
    488485        self.graph.numberOfBars = self.numberOfBars 
    489486        self.graph.barSize = self.barSize 
  • orange/OrangeWidgets/Visualize/OWLinProj.py

    r4882 r4965  
    201201        self.debugSettings = ["hiddenAttributes", "shownAttributes"] 
    202202 
    203         # add a settings dialog and initialize its values 
    204         self.activateLoadedSettings() 
    205         self.resize(900, 700) 
    206  
    207     def saveToFile(self): 
    208         self.graph.saveToFile([("Save PicTex", self.graph.savePicTeX)]) 
    209  
    210     def activateLoadedSettings(self): 
    211203        dlg = self.createColorDialog() 
    212204        self.graph.contPalette = dlg.getContinuousPalette("contPalette") 
     
    218210        self.cbShowAllAttributes() 
    219211 
     212        self.resize(900, 700) 
     213 
     214    def saveToFile(self): 
     215        self.graph.saveToFile([("Save PicTex", self.graph.savePicTeX)]) 
    220216 
    221217    # ######################### 
     
    281277        if self.data and data and self.data.checksum() == data.checksum(): 
    282278            return    # check if the new data set is the same as the old one 
    283          
    284         self.closeContext()         
     279 
     280        self.closeContext() 
    285281        sameDomain = self.data and data and data.domain.checksum() == self.data.domain.checksum() # preserve attribute choice if the domain is the same 
    286282        self.resetAnchors = not sameDomain 
     
    296292        self.openContext("", self.data) 
    297293        self.resetAttrManipulation() 
    298                  
     294 
    299295 
    300296    def setSubsetData(self, subsetData): 
    301297        self.subsetData = subsetData 
    302298        self.vizrank.clearArguments() 
    303          
     299 
    304300    # attribute selection signal - info about which attributes to show 
    305301    def setShownAttributes(self, attributeSelectionList): 
     
    320316        self.resetAnchors = 0 
    321317 
    322      
     318 
    323319    # visualize the results of the classification 
    324320    def setTestResults(self, results): 
  • orange/OrangeWidgets/Visualize/OWLinProjGraph.py

    r4882 r4965  
    144144        if self.dataHasDiscreteClass: 
    145145            self.discPalette.setNumberOfColors(len(self.dataDomain.classVar.values)) 
    146          
     146 
    147147        useDifferentSymbols = self.useDifferentSymbols and self.dataHasDiscreteClass and len(self.dataDomain.classVar.values) < len(self.curveSymbols) 
    148148        dataSize = len(self.rawData) 
     
    156156        xPointsToAdd = {} 
    157157        yPointsToAdd = {} 
    158          
     158 
    159159 
    160160        if self.showProbabilities and self.haveData and self.dataHasClass: 
     
    217217        elif self.haveSubsetData: 
    218218            shownSubsetCount = 0 
    219             subsetReferencesToDraw = dict([(example.reference(),1) for example in self.rawSubsetData]) 
     219            subsetIdsToDraw = dict([(example.id,1) for example in self.rawSubsetData]) 
    220220 
    221221            # draw the rawData data set. examples that exist also in the subset data draw full, other empty 
    222222            for i in range(dataSize): 
    223223                if not validData[i]: continue 
    224                 if subsetReferencesToDraw.has_key(self.rawData[i].reference()): 
     224                if subsetIdsToDraw.has_key(self.rawData[i].id): 
    225225                    continue 
    226226 
     
    267267                    else: 
    268268                        newColor = self.contPalette.getRGB(self.noJitteringScaledSubsetData[self.dataClassIndex][i]) 
    269                          
     269 
    270270                if self.useDifferentSymbols and self.dataHasDiscreteClass and self.validSubsetDataArray[self.dataClassIndex][i]: 
    271271                    curveSymbol = self.curveSymbols[int(self.originalSubsetData[self.dataClassIndex][i])] 
    272                 else:  
     272                else: 
    273273                    curveSymbol = self.curveSymbols[0] 
    274274 
     
    545545 
    546546        #selIndices, unselIndices = self.getSelectionsAsIndices(attrList, useAnchorData, validData) 
    547         selIndices, unselIndices = self.getSelectedPoints(array.T[0], array.T[1], validData)  
     547        selIndices, unselIndices = self.getSelectedPoints(array.T[0], array.T[1], validData) 
    548548 
    549549        if addProjectedPositions: 
  • orange/OrangeWidgets/Visualize/OWMosaicDisplay.py

    r4882 r4965  
    212212        self.wdChildDialogs = [self.optimizationDlg]        # used when running widget debugging 
    213213 
    214     def activateLoadedSettings(self): 
    215214        self.collapsableWBox.updateControls() 
    216215        dlg = self.createColorDialog() 
    217216        self.colorPalette = dlg.getDiscretePalette("discPalette") 
    218217        self.selectionColorPalette = [QColor(*col) for col in OWColorPalette.defaultRGBColors] 
     218 
     219 
    219220 
    220221    def permutationListToggle(self): 
     
    312313        self.initCombos(self.data) 
    313314        self.openContext("", self.data) 
    314          
     315 
    315316 
    316317        if data and self.unprocessedSubsetData:        # if we first received subset data we now have to call setSubsetData to process it 
     
    875876 
    876877        self.attributeList = OWGUI.listBox(box1, self, selectionMode = QListWidget.ExtendedSelection, enableDragDrop = 1) 
    877         self.attributeList.addItems(valueList)  
     878        self.attributeList.addItems(valueList) 
    878879 
    879880        vbox = OWGUI.widgetBox(box1, "", orientation = "vertical") 
     
    907908                self.attributeList.item(i+2).setSelected(TRUE) 
    908909                self.attributeList.takeItem(i) 
    909                  
     910 
    910911 
    911912#test widget appearance 
     
    913914    a=QApplication(sys.argv) 
    914915    ow = OWMosaicDisplay() 
    915     ow.activateLoadedSettings() 
    916916    ow.show() 
    917917    data = orange.ExampleTable(r"e:\Development\Orange Datasets\UCI\zoo.tab") 
  • orange/OrangeWidgets/Visualize/OWParallelCoordinates.py

    r4882 r4965  
    123123        self.icons = self.createAttributeIconDict() 
    124124 
    125         # add a settings dialog and initialize its values 
    126         self.activateLoadedSettings() 
    127         self.resize(900, 700) 
    128  
    129  
    130     def activateLoadedSettings(self): 
    131125        dlg = self.createColorDialog() 
    132126        self.graph.contPalette = dlg.getContinuousPalette("contPalette") 
     
    135129        apply([self.zoomSelectToolbar.actionZooming, self.zoomSelectToolbar.actionRectangleSelection, self.zoomSelectToolbar.actionPolygonSelection][self.toolbarSelection], []) 
    136130        self.cbShowAllAttributes() 
     131 
     132        self.resize(900, 700) 
    137133 
    138134    def flipAttribute(self, item): 
     
    204200            return    # check if the new data set is the same as the old one 
    205201 
    206         self.closeContext()         
     202        self.closeContext() 
    207203        sameDomain = self.data and data and data.domain.checksum() == self.data.domain.checksum() # preserve attribute choice if the domain is the same 
    208204        self.projections = None 
     
    218214    def setSubsetData(self, subData): 
    219215        self.subsetData = subData 
    220              
     216 
    221217 
    222218    # attribute selection signal - list of attributes to show 
    223219    def setShownAttributes(self, attributeSelectionList): 
    224220        self.attributeSelectionList = attributeSelectionList 
    225          
    226          
     221 
     222 
    227223    # this is called by OWBaseWidget after setData and setSubsetData are called. this way the graph is updated only once 
    228224    def handleNewSignals(self): 
     
    235231        self.updateGraph() 
    236232        self.sendSelections() 
    237         
     233 
    238234 
    239235    def sendShownAttributes(self, attrList = None): 
     
    382378        self.changeProjectionFile() 
    383379        self.updateGUI() 
    384         self.activateLoadedSettings() 
    385  
    386     def activateLoadedSettings(self): 
    387380        if self.orderAllAttributes: self.setAllAttributeRadio() 
    388381        else:                       self.setSubsetAttributeRadio() 
     
    418411        if self.resultList.count() == 0: return None 
    419412        return self.allResults[self.resultList.currentItem()][1] 
    420      
     413 
    421414    # called when optimization is in progress 
    422415    def canContinueOptimization(self): 
  • orange/OrangeWidgets/Visualize/OWParallelGraph.py

    r4882 r4965  
    3535        self.selectedExamples = [] 
    3636        self.unselectedExamples = [] 
    37         self.bottomPixmap = QPixmap(os.path.join(orngOrangeFoldersQt4.directoryNames["widgetDir"], r"icons\upgreenarrow.png"))  
     37        self.bottomPixmap = QPixmap(os.path.join(orngOrangeFoldersQt4.directoryNames["widgetDir"], r"icons\upgreenarrow.png")) 
    3838        self.topPixmap = QPixmap(os.path.join(orngOrangeFoldersQt4.directoryNames["widgetDir"], r"icons\downgreenarrow.png")) 
    39          
     39 
    4040        self.axisScaleDraw(QwtPlot.xBottom).enableComponent(QwtScaleDraw.Backbone, 0) 
    4141        self.axisScaleDraw(QwtPlot.xBottom).enableComponent(QwtScaleDraw.Ticks, 0) 
     
    5454        if attributes != self.visualizedAttributes: 
    5555            self.selectionConditions = {}       # reset selections 
    56                   
     56 
    5757        self.visualizedAttributes = [] 
    5858        self.visualizedMidLabels = [] 
     
    6666        self.visualizedMidLabels = midLabels 
    6767        for name in self.selectionConditions.keys():        # keep only conditions that are related to the currently visualized attributes 
    68             if name not in self.visualizedAttributes:  
     68            if name not in self.visualizedAttributes: 
    6969                self.selectionConditions.pop(name) 
    7070 
     
    8989        self.setAxisMaxMajor(QwtPlot.xBottom, len(attributes)) 
    9090        self.setAxisMaxMinor(QwtPlot.xBottom, 0) 
    91          
     91 
    9292 
    9393        length = len(attributes) 
     
    103103        # draw the data 
    104104        # ############################################ 
    105         subsetReferencesToDraw = self.haveSubsetData and dict([(self.rawSubsetData[i].reference(), 1) for i in self.getValidSubsetIndices(indices)]) or {} 
     105        subsetIdsToDraw = self.haveSubsetData and dict([(self.rawSubsetData[i].id, 1) for i in self.getValidSubsetIndices(indices)]) or {} 
    106106        validData = self.getValidList(indices) 
    107107        mainCurves = {} 
    108108        subCurves = {} 
    109109        conditions = dict([(name, attributes.index(name)) for name in self.selectionConditions.keys()]) 
    110          
     110 
    111111        for i in range(dataSize): 
    112112            if not validData[i]: 
     
    128128                self.unselectedExamples.append(i) 
    129129            # if we have subset data then use alpha2 for main data and alpha for subset data 
    130             elif self.haveSubsetData and not subsetReferencesToDraw.has_key(self.rawData[i].reference()): 
     130            elif self.haveSubsetData and not subsetIdsToDraw.has_key(self.rawData[i].id): 
    131131                alpha = self.alphaValue2 
    132132                curves = subCurves 
     
    136136                curves = mainCurves 
    137137                self.selectedExamples.append(i) 
    138                 if subsetReferencesToDraw.has_key(self.rawData[i].reference()):   
    139                     subsetReferencesToDraw.pop(self.rawData[i].reference()) 
    140                  
     138                if subsetIdsToDraw.has_key(self.rawData[i].id): 
     139                    subsetIdsToDraw.pop(self.rawData[i].id) 
     140 
    141141            newColor += (alpha,) 
    142142 
     
    146146 
    147147        # if we have a data subset that contains examples that don't exist in the original dataset we show them here 
    148         if subsetReferencesToDraw != {}: 
     148        if subsetIdsToDraw != {}: 
    149149            validSubsetData = self.getValidSubsetList(indices) 
    150150 
    151151            for i in range(len(self.rawSubsetData)): 
    152152                if not validSubsetData[i]: continue 
    153                 if not subsetReferencesToDraw.has_key(self.rawSubsetData[i].reference()): continue 
     153                if not subsetIdsToDraw.has_key(self.rawSubsetData[i].id): continue 
    154154 
    155155                data = [self.scaledSubsetData[index][i] for index in indices] 
     
    167167                    newColor += (self.alphaValue,) 
    168168                    curves = mainCurves 
    169                      
     169 
    170170                if not curves.has_key(newColor): 
    171171                    curves[newColor] = [] 
     
    273273            # draw lines with mean/median values 
    274274            classCount = 1 
    275             if not self.dataHasClass or self.dataHasContinuousClass:     
     275            if not self.dataHasClass or self.dataHasContinuousClass: 
    276276                classCount = 1 # no class 
    277277            else: classCount = len(self.dataDomain.classVar.values) 
     
    434434        xFloat = self.invTransform(QwtPlot.xBottom, canvasPos.x()) 
    435435        contact, info = self.testArrowContact(int(round(xFloat)), canvasPos.x(), canvasPos.y()) 
    436                  
     436 
    437437        if contact: 
    438438            self.pressedArrow = info 
    439439        elif self.state in [ZOOMING, PANNING]: 
    440440            OWGraph.mousePressEvent(self, e) 
    441                  
     441 
    442442 
    443443    def mouseMoveEvent(self, e): 
     
    451451            self.selectionConditions[attr.name] = oldCondition 
    452452            self.updateData(self.visualizedAttributes, self.visualizedMidLabels, updateAxisScale = 0) 
    453              
     453 
    454454            if attr.varType == orange.VarTypes.Continuous: 
    455455                val = self.attrValues[attr.name][0] + oldCondition[pos] * (self.attrValues[attr.name][1] - self.attrValues[attr.name][0]) 
     
    458458            if self.sendSelectionOnUpdate and self.autoSendSelectionCallback: 
    459459                self.autoSendSelectionCallback() 
    460                  
     460 
    461461        elif self.state in [ZOOMING, PANNING]: 
    462462            OWGraph.mouseMoveEvent(self, e) 
    463              
     463 
    464464    def mouseReleaseEvent(self, e): 
    465465        if hasattr(self, "pressedArrow"): 
     
    515515        if not self.haveData: 
    516516            return (None, None) 
    517          
     517 
    518518        selected = self.rawData.getitemsref(self.selectedExamples) 
    519519        unselected = self.rawData.getitemsref(self.unselectedExamples) 
     
    521521        if len(selected) == 0: selected = None 
    522522        if len(unselected) == 0: unselected = None 
    523         return (selected, unselected)         
     523        return (selected, unselected) 
    524524 
    525525 
     
    532532        self.setItemAttribute(QwtPlotItem.Legend, 0) 
    533533 
    534         lineCount = len(yData) / attrCount         
     534        lineCount = len(yData) / attrCount 
    535535        self.attrCount = attrCount 
    536536        self.xData = range(attrCount) * lineCount 
  • orange/OrangeWidgets/Visualize/OWScatterPlot.py

    r4882 r4965  
    155155 
    156156        self.debugSettings = ["attrX", "attrY", "attrColor", "attrLabel", "attrShape", "attrSize"] 
    157         self.resize(700, 550) 
    158157        self.wdChildDialogs = [self.vizrank]        # used when running widget debugging 
    159158 
    160  
    161     def activateLoadedSettings(self): 
    162159        dlg = self.createColorDialog() 
    163160        self.graph.contPalette = dlg.getContinuousPalette("contPalette") 
     
    170167 
    171168        apply([self.zoomSelectToolbar.actionZooming, self.zoomSelectToolbar.actionRectangleSelection, self.zoomSelectToolbar.actionPolygonSelection][self.toolbarSelection], []) 
     169 
     170        self.resize(700, 550) 
     171 
    172172 
    173173    def settingsFromWidgetCallback(self, handler, context): 
     
    204204        if self.data and data and self.data.checksum() == data.checksum(): 
    205205            return    # check if the new data set is the same as the old one 
    206          
     206 
    207207        self.closeContext() 
    208208        sameDomain = self.data and data and data.domain.checksum() == self.data.domain.checksum() # preserve attribute choice if the domain is the same 
     
    215215        self.outlierValues = None 
    216216        self.openContext("", self.data) 
    217          
     217 
    218218    # set an example table with a data subset subset of the data. if called by a visual classifier, the update parameter will be 0 
    219219    def setSubsetData(self, subsetData): 
     
    236236    def setShownAttributes(self, list): 
    237237        if list and len(list[:2]) == 2: 
    238             self.attributeSelectionList = list[:2]  
     238            self.attributeSelectionList = list[:2] 
    239239        else: 
    240240            self.attributeSelectionList = None 
  • orange/OrangeWidgets/Visualize/OWScatterPlotGraph.py

    r4882 r4965  
    9595 
    9696        showContinuousColorLegend = self.showLegend and colorIndex != -1 and self.dataDomain[colorIndex].varType == orange.VarTypes.Continuous 
    97          
     97 
    9898        (xVarMin, xVarMax) = self.attrValues[xAttr] 
    9999        (yVarMin, yVarMax) = self.attrValues[yAttr] 
     
    215215            validData = self.getValidList(attrs) 
    216216            if self.haveSubsetData: 
    217                 subsetReferencesToDraw = dict([(example.reference(), 1) for example in self.rawSubsetData]) 
     217                subsetIdsToDraw = dict([(example.id, 1) for example in self.rawSubsetData]) 
    218218                showFilled = 0 
    219219            else: 
    220                 subsetReferencesToDraw ={} 
     220                subsetIdsToDraw ={} 
    221221                showFilled = self.showFilledSymbols 
    222              
     222 
    223223            xPointsToAdd = {} 
    224224            yPointsToAdd = {} 
    225225            for i in range(len(self.rawData)): 
    226226                if not validData[i]: continue 
    227                 if subsetReferencesToDraw.has_key(self.rawData[i].reference()): 
     227                if subsetIdsToDraw.has_key(self.rawData[i].id): 
    228228                    continue 
    229229 
  • orange/OrangeWidgets/Visualize/OWScatterPlotMatrix.py

    r4882 r4965  
    104104        # add a settings dialog and initialize its values 
    105105        self.icons = self.createAttributeIconDict() 
    106         self.activateLoadedSettings() 
    107         self.resize(900, 700) 
    108  
    109  
    110     # ######################### 
    111     # OPTIONS 
    112     # ######################### 
    113     def activateLoadedSettings(self): 
     106 
    114107        dlg = self.createColorDialog() 
    115108        self.contPalette = dlg.getContinuousPalette("contPalette") 
    116109        self.discPalette = dlg.getDiscretePalette("discPalette") 
    117110        self.graphCanvasColor = dlg.getColor("Canvas") 
     111        self.resize(900, 700) 
    118112 
    119113    def createColorDialog(self): 
     
    152146 
    153147        for graph in self.graphs[1:]: 
    154             for attr in ["rawData", "domainDataStat", "scaledData", "scaledSubsetData", "noJitteringScaledData", "noJitteringScaledSubsetData",  
     148            for attr in ["rawData", "domainDataStat", "scaledData", "scaledSubsetData", "noJitteringScaledData", "noJitteringScaledSubsetData", 
    155149                                     "validDataArray", "validSubsetDataArray", "attrValues", "originalData", "originalSubsetData", 
    156150                                     "attributeNames", "domainDataStat", "attributeNameIndex", "dataDomain", "dataHasClass", "dataHasContinuousClass", 
     
    221215                    graph.setData(self.data) 
    222216                else: 
    223                     for attr in ["rawData", "domainDataStat", "scaledData", "scaledSubsetData", "noJitteringScaledData", "noJitteringScaledSubsetData",  
     217                    for attr in ["rawData", "domainDataStat", "scaledData", "scaledSubsetData", "noJitteringScaledData", "noJitteringScaledSubsetData", 
    224218                                 "validDataArray", "validSubsetDataArray", "attrValues", "originalData", "originalSubsetData", 
    225219                                 "attributeNames", "domainDataStat", "attributeNameIndex", "dataDomain", "dataHasClass", "dataHasContinuousClass", 
     
    356350    def setShownAttributes(self, attrList): 
    357351        self.attributeSelectionList = attributeSelectionList 
    358          
     352 
    359353    # this is called by OWBaseWidget after setData and setSubsetData are called. this way the graph is updated only once 
    360354    def handleNewSignals(self): 
     
    366360        self.attributeSelectionList = None 
    367361        self.updateGraph() 
    368              
     362 
    369363 
    370364#    def resizeEvent(self, e): 
  • orange/OrangeWidgets/Visualize/OWSieveMultigram.py

    r4882 r4965  
    5757        #add controls to self.controlArea widget 
    5858        self.createShowHiddenLists(self.GeneralTab, callback = self.interestingSubsetSelection) 
    59          
     59 
    6060        self.interestingButton = QPushButton("Find Interesting Attr.", self.GeneralTab) 
    61         self.connect(self.interestingButton, SIGNAL("clicked()"),self.interestingSubsetSelection)  
     61        self.connect(self.interestingButton, SIGNAL("clicked()"),self.interestingSubsetSelection) 
    6262 
    6363        #connect controls to appropriate functions 
     
    6868        self.connect(self.graphButton, SIGNAL("clicked()"), self.graph.saveToFile) 
    6969 
    70         # add a settings dialog and initialize its values 
    71         self.activateLoadedSettings() 
    72  
    73     # ######################### 
    74     # OPTIONS 
    75     # ######################### 
    76     def activateLoadedSettings(self): 
    7770        # set loaded options settings 
    7871        self.SettingsTab.lineCombo.setCurrentIndex(self.maxLineWidth-1) 
  • orange/OrangeWidgets/Visualize/OWSurveyPlot.py

    r4882 r4965  
    8989        self.icons = self.createAttributeIconDict() 
    9090 
    91         # add a settings dialog and initialize its values 
    92         self.activateLoadedSettings() 
    93         self.resize(750,700) 
    94  
    95  
    96  
    97     # ######################### 
    98     # OPTIONS 
    99     # ######################### 
    100     def activateLoadedSettings(self): 
    10191        dlg = self.createColorDialog() 
    10292        self.graph.contPalette = dlg.getContinuousPalette("contPalette") 
     
    10797        #self.graph.setCanvasBackground(QColor(self.graphCanvasColor)) 
    10898        self.cbShowAllAttributes() 
     99        self.resize(750,700) 
    109100 
    110101    # ##################### 
     
    114105        if items == attrs: 
    115106            return 
    116          
     107 
    117108        self.primaryAttrCombo.clear() 
    118109        self.secondaryAttrCombo.clear() 
     
    155146        sameDomain = self.data and data and data.domain.checksum() == self.data.domain.checksum() # preserve attribute choice if the domain is the same 
    156147        self.data = data 
    157          
     148 
    158149        self.graph.setData(self.data) 
    159150        if self.graph.dataHasDiscreteClass: 
Note: See TracChangeset for help on using the changeset viewer.