Changeset 3481:31683ac517a1 in orange


Ignore:
Timestamp:
04/04/07 13:18:25 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
610e7db9817f93e2c0a16be7d08c703088125f95
Message:

* empty log message *

Location:
orange/OrangeWidgets/Data
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Data/OWContinuize.py

    r3261 r3481  
    33<description>Turns discrete attributes into continuous and, optionally, normalizes the continuous values.</description> 
    44<icon>icons/Continuize.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>2110</priority> 
    77""" 
     
    1818    settingsList = ["multinomialTreatment", "classTreatment", "zeroBased", "continuousTreatment", "autosend"] 
    1919    contextHandlers = {"": ClassValuesContextHandler("", ["targetValue"])} 
    20      
     20 
    2121    multinomialTreats = (("Target or First value as base", orange.DomainContinuizer.LowestIsBase), 
    2222                         ("Most frequent value as base", orange.DomainContinuizer.FrequentIsBase), 
     
    3030                        ("Normalize by span", orange.DomainContinuizer.NormalizeBySpan), 
    3131                        ("Normalize by variance", orange.DomainContinuizer.NormalizeByVariance)) 
    32      
     32 
    3333    classTreats = (("Leave as is", orange.DomainContinuizer.Ignore), 
    3434                   ("Treat as ordinal", orange.DomainContinuizer.AsOrdinal), 
     
    3838    def __init__(self,parent=None, signalManager = None, name = "Continuizer"): 
    3939        OWWidget.__init__(self, parent, signalManager, name) 
    40          
    41         self.inputs = [("Examples", ExampleTable, self.examples)] 
    42         self.outputs = [("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass)] 
     40 
     41        self.inputs = [("Examples", ExampleTable, self.setData)] 
     42        self.outputs = [("Examples", ExampleTable)] 
    4343 
    4444        self.multinomialTreatment = 0 
     
    6969        QWidget(self.controlArea).setFixedSize(19, 8) 
    7070 
    71         zbbox = QVButtonGroup("Value range", self.controlArea)  
     71        zbbox = QVButtonGroup("Value range", self.controlArea) 
    7272        OWGUI.radioButtonsInBox(zbbox, self, "zeroBased", btnLabels=["from -1 to 1", "from 0 to 1"], callback=self.sendDataIf) 
    7373 
     
    8484        self.sendDataIf() 
    8585 
    86     def examples(self,data): 
     86    def setData(self,data): 
    8787        self.closeContext() 
    88          
     88 
    8989        if not data: 
    9090            self.data = None 
     
    9292            self.openContext("", self.data) 
    9393            self.send("Examples", None) 
    94             self.send("Classified Examples", None) 
    9594        else: 
    9695            if not self.data or data.domain.classVar != self.data.domain.classVar: 
     
    104103                    self.ctreat.setDisabled(True) 
    105104            self.data = data 
    106             self.openContext("", self.data)             
     105            self.openContext("", self.data) 
    107106            self.sendData() 
    108107 
     
    115114        if self.dataChanged: 
    116115            self.sendData() 
    117              
     116 
    118117    def sendData(self): 
    119118        if self.data: 
     
    127126                conzer.classTreatment = self.classTreats[self.classTreatment][1] 
    128127                domain = conzer(self.data) 
    129             data = orange.ExampleTable(domain, self.data) 
    130             self.send("Examples", data) 
    131             self.send("Classified Examples", data.domain.classVar and data or None) 
     128            self.send("Examples", orange.ExampleTable(domain, self.data)) 
    132129        self.dataChanged = False 
    133      
     130 
    134131if __name__ == "__main__": 
    135132    a = QApplication(sys.argv) 
    136133    ow = OWContinuize() 
    137134    data = orange.ExampleTable("d:\\ai\\orange\\test\\iris") 
    138     ow.examples(data) 
     135    ow.setData(data) 
    139136    a.setMainWidget(ow) 
    140137    ow.show() 
  • orange/OrangeWidgets/Data/OWDataDomain.py

    r2802 r3481  
    2828        OWWidget.__init__(self, parent, signalManager, "Data Domain") #initialize base class 
    2929 
    30         self.inputs = [("Examples", ExampleTable, self.onDataInput), ("Attribute Subset", AttributeList, self.onAttributeList)] 
    31         self.outputs = [("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass)] 
     30        self.inputs = [("Examples", ExampleTable, self.setData), ("Attribute Subset", AttributeList, self.setAttributeList)] 
     31        self.outputs = [("Examples", ExampleTable)] 
    3232 
    3333        buttonWidth = 50 
     
    4747 
    4848        self.loadSettings() 
    49          
     49 
    5050        self.mainArea.setFixedWidth(0) 
    5151        ca = QFrame(self.controlArea) 
     
    6363        self.attributesButtonUp = OWGUI.button(vbAttr, self, "Up", self.onAttributesButtonUpClick) 
    6464        self.attributesButtonUp.setMaximumWidth(buttonWidth) 
    65         self.attributesButton = OWGUI.button(vbAttr, self, ">",self.onAttributesButtonClicked)         
     65        self.attributesButton = OWGUI.button(vbAttr, self, ">",self.onAttributesButtonClicked) 
    6666        self.attributesButton.setMaximumWidth(buttonWidth) 
    6767        self.attributesButtonDown = OWGUI.button(vbAttr, self, "Down", self.onAttributesButtonDownClick) 
    6868        self.attributesButtonDown.setMaximumWidth(buttonWidth) 
    69          
     69 
    7070        boxAttr = QVGroupBox(ca) 
    7171        boxAttr.setTitle('Attributes') 
     
    8181        gl.addWidget(boxClass, 1,2) 
    8282        self.classList = OWGUI.listBox(boxClass, self, "selectedClass", "classAttribute", callback = self.onSelectionChange, selectionMode = QListBox.Extended) 
    83          
     83 
    8484        vbMeta = QVBox(ca) 
    8585        gl.addWidget(vbMeta, 2,1) 
     
    9494        gl.addWidget(boxMeta, 2,2) 
    9595        self.metaList = OWGUI.listBox(boxMeta, self, "selectedMeta", "metaAttributes", callback = self.onSelectionChange, selectionMode = QListBox.Extended) 
    96          
     96 
    9797        boxApply = QHBox(ca) 
    9898        gl.addMultiCellWidget(boxApply, 3,3,0,2) 
     
    106106 
    107107        self.inChange = False 
    108         self.resize(400,480)        
    109  
    110  
    111     def onAttributeList(self, attrList): 
     108        self.resize(400,480) 
     109 
     110 
     111    def setAttributeList(self, attrList): 
    112112        self.receivedAttrList = attrList 
    113         self.onDataInput(self.data) 
     113        self.setData(self.data) 
    114114 
    115115    def onSelectionChange(self): 
     
    124124            self.inChange = False 
    125125 
    126         self.updateInterfaceState()             
    127  
    128  
    129     def onDataInput(self, data): 
     126        self.updateInterfaceState() 
     127 
     128 
     129    def setData(self, data): 
    130130        if self.data and data and self.data.checksum() == data.checksum(): 
    131131            return   # we received the same dataset again 
    132132 
    133133        self.closeContext() 
    134          
     134 
    135135        self.data = data 
    136136        self.attributes = {} 
    137          
     137 
    138138        if data: 
    139139            domain = data.domain 
    140              
     140 
    141141            if domain.classVar: 
    142142                self.classAttribute = [(domain.classVar.name, domain.classVar.varType)] 
     
    170170        self.updateInterfaceState() 
    171171 
    172          
     172 
    173173    def setOutput(self): 
    174174        if self.data: 
     
    184184            newdata.name = self.data.name 
    185185            self.send("Examples", newdata) 
    186  
    187             if classVar: 
    188                 self.send("Classified Examples", newdata) 
    189             else: 
    190                 self.send("Classified Examples", None) 
    191  
    192186        else: 
    193187            self.send("Examples", None) 
    194             self.send("Classified Examples", None) 
    195  
    196          
     188 
     189 
    197190    def reset(self): 
    198191        data = self.data 
    199192        self.data = None 
    200         self.onDataInput(data) 
    201  
    202          
     193        self.setData(data) 
     194 
     195 
    203196    def disableButtons(self, *arg): 
    204197        for b in arg: 
     
    209202        button.setEnabled(True) 
    210203 
    211          
     204 
    212205    def updateInterfaceState(self): 
    213206        if self.selectedInput: 
     
    220213            else: 
    221214                self.classButton.setEnabled(False) 
    222              
     215 
    223216        elif self.selectedChosen: 
    224217            self.setButton(self.attributesButton, "<") 
     
    280273        self.setInputAttributes() 
    281274 
    282         
     275 
    283276    def onAttributesButtonClicked(self): 
    284277        if self.selectedInput: 
     
    308301 
    309302        self.updateInterfaceState() 
    310         self.applyButton.setEnabled(True)         
     303        self.applyButton.setEnabled(True) 
    311304 
    312305 
     
    342335    def onMetaButtonDownClick(self): 
    343336        self.moveSelection("metaAttributes", "selectedMeta", 1) 
    344          
     337 
    345338    def onAttributesButtonUpClick(self): 
    346339        self.moveSelection("chosenAttributes", "selectedChosen", -1) 
    347          
     340 
    348341    def onAttributesButtonDownClick(self): 
    349342        self.moveSelection("chosenAttributes", "selectedChosen", 1) 
    350          
     343 
    351344 
    352345if __name__=="__main__": 
     
    362355    a.setMainWidget(ow) 
    363356    ow.show() 
    364     ow.onDataInput(data) 
     357    ow.setData(data) 
    365358    a.exec_loop() 
    366359    ow.saveSettings() 
  • orange/OrangeWidgets/Data/OWDiscretize.py

    r3420 r3481  
    4343        self.setCursor(Qt.arrowCursor) 
    4444        self.canvas().setCursor(Qt.arrowCursor) 
    45          
     45 
    4646        self.data = self.attr = self.contingency = None 
    4747        self.minVal = self.maxVal = 0 
    4848        self.curCutPoints=[] 
    49          
    50      
     49 
     50 
    5151    def computeAddedScore(self, spoints): 
    5252        candidateSplits = [x for x in frange(self.minVal, self.maxVal, self.resolution) if x not in spoints] 
     
    6363        return candidateSplits, score 
    6464 
    65          
     65 
    6666    def invalidateBaseScore(self): 
    6767        self.baseCurveX = self.baseCurveY = None 
    68          
     68 
    6969 
    7070    def computeLookaheadScore(self, split): 
     
    8383            self.removeCurve(self.baseCurveKey) 
    8484            self.baseCurveKey = None 
    85          
     85 
    8686        if self.lookaheadCurveKey: 
    8787            self.removeCurve(self.lookaheadCurveKey) 
     
    9595            self.removeCurve(c) 
    9696        self.cutLineKeys = [] 
    97          
     97 
    9898        for m in self.cutMarkerKeys: 
    9999            self.removeMarker(m) 
    100100        self.cutMarkerKeys = [] 
    101          
     101 
    102102        self.update() 
    103          
    104          
     103 
     104 
    105105    def setData(self, attr, data): 
    106106        self.clearAll() 
     
    118118            try: 
    119119                self.condProb = orange.ConditionalProbabilityEstimatorConstructor_loess( 
    120                    self.contingency,  
     120                   self.contingency, 
    121121                   nPoints=50) 
    122122            except: 
    123123                self.condProb = None 
    124124            self.probDist = None 
    125             attrValues = self.contingency.keys()         
     125            attrValues = self.contingency.keys() 
    126126        else: 
    127127            self.condProb = self.contingency = None 
     
    138138        else: 
    139139            self.snapDecimals = 1 
    140          
     140 
    141141        self.baseCurveX = None 
    142142 
     
    166166            else: 
    167167                return 
    168              
     168 
    169169            if freqhigh: 
    170170                maxf = max([f[1] for f in freqhigh]) 
     
    175175            else: 
    176176                return 
    177              
     177 
    178178            freqfac = maxf > 1e-6 and .1 / maxf or 1 
    179179 
    180             for val, freq in freqhigh:         
     180            for val, freq in freqhigh: 
    181181                c = self.addCurve("", Qt.gray, Qt.gray, 1, style = QwtCurve.Lines, symbol = QwtSymbol.None, xData = [val, val], yData = [1.0, 1.0 - max(.02, freqfac * freq)]) 
    182182                self.setCurveYAxis(c, QwtPlot.yRight) 
    183183                self.rugKeys.append(c) 
    184184 
    185             for val, freq in freqlow:         
     185            for val, freq in freqlow: 
    186186                c = self.addCurve("", Qt.gray, Qt.gray, 1, style = QwtCurve.Lines, symbol = QwtSymbol.None, xData = [val, val], yData = [0.04, 0.04 + max(.02, freqfac * freq)]) 
    187187                self.setCurveYAxis(c, QwtPlot.yRight) 
     
    189189 
    190190        if not noUpdate: 
    191             self.update()             
     191            self.update() 
    192192 
    193193 
     
    200200            if not self.baseCurveX: 
    201201                self.baseCurveX, self.baseCurveY = self.computeAddedScore(list(self.curCutPoints)) 
    202                  
     202 
    203203            self.setAxisOptions(QwtPlot.yLeft, self.master.measure == 3 and QwtAutoScale.Inverted or QwtAutoScale.None) 
    204204            self.baseCurveKey = self.addCurve("", Qt.black, Qt.black, 1, style = QwtCurve.Lines, symbol = QwtSymbol.None, xData = self.baseCurveX, yData = self.baseCurveY, lineWidth = 2) 
    205205            self.setCurveYAxis(self.baseCurveKey, QwtPlot.yLeft) 
    206206 
    207         if not noUpdate:                 
     207        if not noUpdate: 
    208208            self.update() 
    209209 
    210          
     210 
    211211    def plotLookaheadCurve(self, noUpdate = False): 
    212212        if self.lookaheadCurveKey: 
    213213            self.removeCurve(self.lookaheadCurveKey) 
    214214            self.lookaheadCurveKey = None 
    215                          
     215 
    216216        if self.lookaheadCurveX and self.master.showLookaheadLine: 
    217217            self.setAxisOptions(QwtPlot.yLeft, self.master.measure == 3 and QwtAutoScale.Inverted or QwtAutoScale.None) 
     
    220220            self.curve(self.lookaheadCurveKey).setEnabled(1) 
    221221 
    222         if not noUpdate:             
     222        if not noUpdate: 
    223223            self.update() 
    224224 
     
    228228            self.removeCurve(self.probCurveKey) 
    229229            self.probCurveKey = None 
    230              
    231         if self.contingency and self.condProb and self.master.showTargetClassProb:             
     230 
     231        if self.contingency and self.condProb and self.master.showTargetClassProb: 
    232232            xData = self.contingency.keys()[1:-1] 
    233233            self.probCurveKey = self.addCurve("", Qt.gray, Qt.gray, 1, style = QwtCurve.Lines, symbol = QwtSymbol.None, xData = xData, yData = [self.condProb(x)[self.master.targetClass] for x in xData], lineWidth = 2) 
     
    237237            self.update() 
    238238 
    239          
     239 
    240240    def plotCutLines(self): 
    241241        attr = self.data.domain[self.master.continuousIndices[self.master.selectedAttr]] 
     
    243243            self.removeCurve(c) 
    244244        self.cutLineKeys = [] 
    245          
     245 
    246246        for m in self.cutMarkerKeys: 
    247247            self.removeMarker(m) 
     
    276276            self.plotBaseCurve() 
    277277            self.plotCutLines() 
    278              
     278 
    279279 
    280280    def addCutPoint(self, cut): 
     
    284284        self.cutLineKeys.append(c) 
    285285        curve = self.curve(c) 
    286         curve.curveInd = len(self.cutLineKeys) - 1         
     286        curve.curveInd = len(self.cutLineKeys) - 1 
    287287        return curve 
    288288 
    289      
     289 
    290290    def onMousePressed(self, e): 
    291291        if not self.data: 
    292292            return 
    293          
     293 
    294294        self.mouseCurrentlyPressed = 1 
    295          
     295 
    296296        cut = self.invTransform(QwtPlot.xBottom, e.x()) 
    297297        curve = self.getCutCurve(cut) 
    298298        if not curve and self.master.snap: 
    299299            curve = self.getCutCurve(round(cut, self.snapDecimals)) 
    300              
     300 
    301301        if curve: 
    302302            if e.button() == Qt.RightButton: 
     
    320320        if not self.data: 
    321321            return 
    322          
     322 
    323323        if self.mouseCurrentlyPressed: 
    324324            if self.selectedCutPoint: 
     
    335335                    self.mouseCurrentlyPressed = 0 
    336336                    return 
    337                  
     337 
    338338                self.curCutPoints[self.selectedCutPoint.curveInd] = pos 
    339339                self.selectedCutPoint.setData([pos, pos], [.9, 0.1]) 
     
    344344 
    345345                self.master.synchronizeIf() 
    346                  
    347                  
     346 
     347 
    348348        elif self.getCutCurve(self.invTransform(QwtPlot.xBottom, e.x())): 
    349349            self.canvas().setCursor(Qt.sizeHorCursor) 
     
    351351            self.canvas().setCursor(Qt.arrowCursor) 
    352352 
    353                                    
     353 
    354354    def onMouseReleased(self, e): 
    355355        if not self.data: 
    356356            return 
    357          
     357 
    358358        self.mouseCurrentlyPressed = 0 
    359359        self.selectedCutPoint = None 
     
    379379        self.master = master 
    380380        self.labelIdx = labelIdx 
    381          
     381 
    382382 
    383383    def paint(self, painter): 
     
    390390class OWDiscretize(OWWidget): 
    391391    settingsList=["autoApply", "measure", "showBaseLine", "showLookaheadLine", "showTargetClassProb", "showRug", "snap", "autoSynchronize"] 
    392     contextHandlers = {"": DomainContextHandler("", ["targetClass", "discretization", "classDiscretization",  
    393                                                      "indiDiscretization", "intervals", "classIntervals", "indiIntervals",  
    394                                                      "outputOriginalClass", "indiData", "indiLabels", "resetIndividuals",  
     392    contextHandlers = {"": DomainContextHandler("", ["targetClass", "discretization", "classDiscretization", 
     393                                                     "indiDiscretization", "intervals", "classIntervals", "indiIntervals", 
     394                                                     "outputOriginalClass", "indiData", "indiLabels", "resetIndividuals", 
    395395                                                     "selectedAttr", "customSplits", "customClassSplits"], False, False, False, False)} 
    396396 
    397397    callbackDeposit=[] 
    398      
     398 
    399399    D_N_METHODS = 5 
    400400    D_LEAVE, D_ENTROPY, D_FREQUENCY, D_WIDTH, D_REMOVE = range(5) 
    401401    D_NEED_N_INTERVALS = [2, 3] 
    402      
     402 
    403403    def __init__(self, parent=None, signalManager=None, name="Interactive Discretization"): 
    404404        OWWidget.__init__(self, parent, signalManager, name) 
     
    417417        self.resetIndividuals = 0 
    418418        self.customClassSplits = "" 
    419          
     419 
    420420        self.selectedAttr = 0 
    421421        self.customSplits = ["", "", ""] 
     
    431431 
    432432        self.loadSettings() 
    433          
    434         self.inputs=[("Examples", ExampleTable, self.cdata)] 
    435         self.outputs=[("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass)] 
    436         self.measures=[("Information gain", orange.MeasureAttribute_info()),  
     433 
     434        self.inputs=[("Examples", ExampleTable, self.setData)] 
     435        self.outputs=[("Examples", ExampleTable)] 
     436        self.measures=[("Information gain", orange.MeasureAttribute_info()), 
    437437                       #("Gain ratio", orange.MeasureAttribute_gainRatio), 
    438                        ("Gini", orange.MeasureAttribute_gini()),  
    439                        ("chi-square", orange.MeasureAttribute_chiSquare()),  
    440                        ("chi-square prob.", orange.MeasureAttribute_chiSquare(computeProbabilities=1)),  
    441                        ("Relevance", orange.MeasureAttribute_relevance()),  
     438                       ("Gini", orange.MeasureAttribute_gini()), 
     439                       ("chi-square", orange.MeasureAttribute_chiSquare()), 
     440                       ("chi-square prob.", orange.MeasureAttribute_chiSquare(computeProbabilities=1)), 
     441                       ("Relevance", orange.MeasureAttribute_relevance()), 
    442442                       ("ReliefF", orange.MeasureAttribute_relief())] 
    443443        self.discretizationMethods=["Leave continuous", "Entropy-MDL discretization", "Equal-frequency discretization", "Equal-width discretization", "Remove continuous attributes"] 
     
    467467        for c in range(1, 4): 
    468468            OWGUI.appendRadioButton(ribg, self, "resetIndividuals", "Custom %i" % c, insertInto = hcustbox) 
    469          
     469 
    470470        OWGUI.separator(vbox) 
    471          
     471 
    472472        box = self.classDiscBox = OWGUI.radioButtonsInBox(vbox, self, "classDiscretization", self.classDiscretizationMethods, "Class discretization", callback=[self.clearLineEditFocus, self.classMethodChanged]) 
    473473        cinterBox = OWGUI.widgetBox(box) 
     
    499499        self.mainBox = OWGUI.widgetBox(self.mainIABox, orientation=0) 
    500500        OWGUI.separator(self.mainIABox)#, height=30) 
    501          
    502          
     501 
     502 
    503503        graphBox = OWGUI.widgetBox(self.mainIABox, "", orientation=0) 
    504504#        self.needsDiscrete.append(graphBox) 
     
    564564 
    565565 
    566     def cdata(self, data=None): 
     566    def setData(self, data=None): 
    567567        self.closeContext() 
    568          
     568 
    569569        self.indiData = [] 
    570570        self.attrList.clear() 
     
    592592            if not self.continuousIndices: 
    593593                self.data = None 
    594              
     594 
    595595        self.classDiscBox.setEnabled(not data or continuousClass) 
    596596        if self.data: 
     
    629629 
    630630#        self.graph.setData(self.data) 
    631          
    632         self.makeConsistent()         
    633          
     631 
     632        self.makeConsistent() 
     633 
    634634        # this should be here because 'resetIndividuals' is a context setting 
    635635        self.showHideIndividual() 
     
    643643        if not self.data or not self.data.domain.classVar: 
    644644            return 
    645          
     645 
    646646        domain = self.data.domain 
    647647        for v in domain.classVar.values: 
     
    667667            if self.classCustomLineEdit.hasFocus(): 
    668668                self.classCustomLineEdit.clearFocus() 
    669              
    670  
    671                  
     669 
     670 
     671 
    672672    def individualSelected(self, i): 
    673673        if not self.data: 
     
    675675 
    676676        self.selectedAttr = i 
    677         attrIndex = self.continuousIndices[i]         
     677        attrIndex = self.continuousIndices[i] 
    678678        attr = self.data.domain[attrIndex] 
    679679        indiData = self.indiData[attrIndex] 
     
    691691            self.graph.plotBaseCurve(False) 
    692692 
    693      
     693 
    694694    def computeDiscretizers(self): 
    695695        self.discretizers = [] 
    696          
     696 
    697697        if not self.data: 
    698698            return 
     
    702702            self.computeDiscretizer(i, idx) 
    703703 
    704         self.commitIf()             
     704        self.commitIf() 
    705705 
    706706 
     
    709709        self.indiInterBox.setEnabled(self.indiDiscretization-1 in self.D_NEED_N_INTERVALS) 
    710710 
    711      
     711 
    712712    def defaultMethodChanged(self): 
    713713        self.interBox.setEnabled(self.discretization in self.D_NEED_N_INTERVALS) 
     
    719719            self.computeDiscretizer(i, idx, True) 
    720720 
    721         self.commitIf()             
     721        self.commitIf() 
    722722 
    723723    def classMethodChanged(self): 
    724724        if not self.data: 
    725725            return 
    726          
     726 
    727727        self.discretizeClass() 
    728728        self.classChanged() 
     
    757757                self.computeDiscretizer(i, idx) 
    758758 
    759             self.commitIf()             
     759            self.commitIf() 
    760760 
    761761 
     
    767767            self.indiMethodChanged() 
    768768 
    769      
     769 
    770770    def showHideIndividual(self): 
    771771        if not self.resetIndividuals: 
     
    780780 
    781781    def setAllIndividuals(self): 
    782         self.showHideIndividual()     
    783  
    784         if not self.data: 
    785             return 
    786          
     782        self.showHideIndividual() 
     783 
     784        if not self.data: 
     785            return 
     786 
    787787        self.clearLineEditFocus() 
    788788        method = self.resetIndividuals 
     
    828828        self.computeDiscretizer(self.selectedAttr, self.continuousIndices[self.selectedAttr]) 
    829829        self.commitIf() 
    830                  
     830 
    831831 
    832832    def copyToCustom(self, which): 
     
    846846            valid = False 
    847847 
    848         if not valid:         
     848        if not valid: 
    849849            attr = self.data.domain[idx] 
    850850            splits = list(self.discretizers[idx] and self.discretizers[idx].getValueFrom.transformer.points or []) 
     
    855855#        self.customSelected(which) 
    856856 
    857      
     857 
    858858    shortDiscNames = ("", " (leave continuous)", " (entropy)", " (equal frequency)", " (equal width)", " (removed)", " (custom 1)", " (custom 2)", " (custom 3)") 
    859859 
     
    877877            except: 
    878878                customs = [] 
    879                  
     879 
    880880            if not customs: 
    881881                discType = self.discretization+1 
     
    886886        if onlyDefaults and not defaultUsed: 
    887887            return 
    888          
     888 
    889889        discType -= 1 
    890890        try: 
     
    917917            discInts = points and (": " + ", ".join([str(attr(x)) for x in points])) or ": <removed>" 
    918918        self.indiLabels[i] = discInts + discName 
    919                          
     919 
    920920        self.attrList.triggerUpdate(0) 
    921921 
     
    929929            discType = self.classDiscretization 
    930930            classVar = self.originalData.domain.classVar 
    931              
     931 
    932932            if discType == 2: 
    933933                try: 
     
    953953                    self.data = self.discClassData 
    954954                # else, the data has no continuous attributes other then the class 
    955              
     955 
    956956                self.classIntervalsLabel.setText("Current splits: " + ", ".join([str(classVar(x)) for x in discretizer.getValueFrom.transformer.points])) 
    957957                self.error(0) 
     
    963963                    self.error(0, "Cannot discretize the class") 
    964964                self.classIntervalsLabel.setText("") 
    965          
     965 
    966966 
    967967    def classCustomChanged(self): 
     
    973973            self.classMethodChanged() 
    974974            self.classCustomLineEdit.setFocus() 
    975              
     975 
    976976    def discretize(self): 
    977977        if not self.data: 
     
    992992        if not self.data: 
    993993            return 
    994          
     994 
    995995        slot = self.indiDiscretization - self.D_N_METHODS - 1 
    996996        if slot < 0: 
     
    10271027        else: 
    10281028            self.dataChanged = True 
    1029              
     1029 
    10301030    def commit(self): 
    10311031        self.clearLineEditFocus() 
    1032          
     1032 
    10331033        if self.data: 
    10341034            newattrs=[] 
     
    10501050            newdata = orange.ExampleTable(newdomain, self.originalData) 
    10511051            self.send("Examples", newdata) 
    1052             if self.data.domain.classVar: 
    1053                 self.send("Classified Examples", newdata) 
    1054             else: 
    1055                 self.send("Classified Examples", None) 
    1056  
    10571052        elif self.discClassData: 
    10581053            self.send("Examples", self.discClassData) 
    1059             self.send("Classified Examples", self.discClassData) 
    1060              
    10611054        elif self.originalData:  # no continuous attributes... 
    10621055            self.send("Examples", self.originalData) 
    1063             if self.originalData.domain.classVar: 
    1064                 self.send("Classified Examples", self.originalData) 
    1065             else: 
    1066                 self.send("Classified Examples", None) 
    1067                  
    10681056        else: 
    10691057            self.send("Examples", None) 
    1070             self.send("Classified Examples", None) 
    1071  
    1072         dataChanged = False             
     1058 
     1059        dataChanged = False 
    10731060 
    10741061 
     
    10821069#    d=orange.ExampleTable("../../doc/datasets/auto-mpg.tab") 
    10831070    d = orange.ExampleTable("../../doc/datasets/iris.tab") 
    1084     w.cdata(d) 
    1085     w.cdata(None) 
    1086     w.cdata(d) 
     1071    w.setData(d) 
     1072    w.setData(None) 
     1073    w.setData(d) 
    10871074    app.exec_loop() 
    10881075    w.saveSettings() 
  • orange/OrangeWidgets/Data/OWExtendedFile.py

    r1970 r3481  
    44<icon>icons/ExtendedFile.png</icon> 
    55<priority>11</priority> 
    6 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     6<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    77""" 
    88 
     
    1919 
    2020        self.inputs = [("Attribute Definitions", orange.Domain, self.setDomain)] 
    21         self.outputs = [("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass), ("Attribute Definitions", orange.Domain)] 
    22      
     21        self.outputs = [("Examples", ExampleTable), ("Attribute Definitions", orange.Domain)] 
     22 
    2323        #set default settings 
    2424        self.recentFiles=["(none)"] 
     
    2929        #get settings from the ini file, if they exist 
    3030        self.loadSettings() 
    31          
     31 
    3232        #GUI 
    3333        self.box = QHGroupBox("Data File", self.controlArea) 
     
    4646        self.infoa = QLabel('No data loaded.', box) 
    4747        self.infob = QLabel('', box) 
    48              
     48 
    4949        self.rbox = QHGroupBox("Reload", self.controlArea) 
    5050        self.reloadBtn = OWGUI.button(self.rbox, self, "Reload File", callback = self.reload) 
     
    5858        domainChanged = self.domain != domain 
    5959        self.domain = domain 
    60          
     60 
    6161        if self.domain: 
    6262            self.resetDomainCb.setDisabled(1) 
    6363        else: 
    6464            self.resetDomainCb.setDisabled(0) 
    65              
     65 
    6666        if domainChanged and len(self.recentFiles) > 0 and os.path.exists(self.recentFiles[0]): 
    6767            self.resetDomain = 1 
    6868            self.openFile(self.recentFiles[0], 1) 
    69              
     69 
    7070 
    7171    def reload(self): 
     
    9494    def openFile(self,fn, throughReload = 0): 
    9595        self.openFileBase(fn, throughReload=throughReload, DK=self.symbolDK, DC=self.symbolDC) 
    96          
     96 
    9797 
    9898if __name__ == "__main__": 
     
    105105    ow.openFile(r"C:\Documents and Settings\peterjuv\My Documents\STEROLTALK\array-pro\experiments\Tadeja 2nd image analysis\10vs10mg original data\0449.txt") 
    106106    a.exec_loop() 
    107     #save settings  
     107    #save settings 
    108108    ow.saveSettings() 
  • orange/OrangeWidgets/Data/OWFile.py

    r3334 r3481  
    33<description>Reads data from a file.</description> 
    44<icon>icons/File.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>10</priority> 
    77""" 
     
    2727        OWSubFile.allFileWidgets.remove(self) 
    2828        OWWidget.destroy(self, destroyWindow, destroySubWindows) 
    29                   
     29 
    3030    def activateLoadedSettings(self): 
    3131        # remove missing data set names 
    3232        self.recentFiles=filter(os.path.exists,self.recentFiles) 
    3333        self.setFileList() 
    34          
     34 
    3535        if len(self.recentFiles) > 0 and os.path.exists(self.recentFiles[0]): 
    3636            self.openFile(self.recentFiles[0]) 
    37              
     37 
    3838        # connecting GUI to code 
    3939        self.connect(self.filecombo, SIGNAL('activated(int)'), self.selectFile) 
     
    4747        elif n: 
    4848            self.browseFile(1) 
    49              
     49 
    5050        if len(self.recentFiles) > 0: 
    5151            self.setFileList() 
     
    6464            except: 
    6565                startfile = "" 
    66                  
     66 
    6767            if not startfile or not os.path.exists(startfile): 
    6868                d = OWGUI.__file__ 
     
    8181                    startfile = d+"doc/datasets" 
    8282 
    83             if not os.path.exists(startfile):                     
     83            if not os.path.exists(startfile): 
    8484                QMessageBox.information( None, "File", "Cannot find the directory with example data sets", QMessageBox.Ok + QMessageBox.Default) 
    8585                return 
     
    8989            else: 
    9090                startfile=self.recentFiles[0] 
    91                  
     91 
    9292        filename = str(QFileDialog.getOpenFileName(startfile, 
    9393        'Tab-delimited files (*.tab *.txt)\nC4.5 files (*.data)\nAssistant files (*.dat)\nRetis files (*.rda *.rdo)\nAll files(*.*)', 
    9494        None,'Open Orange Data File')) 
    95      
     95 
    9696        if filename == "": return 
    9797        if filename in self.recentFiles: self.recentFiles.remove(filename) 
     
    102102    def setInfo(self, info): 
    103103        for (i, s) in enumerate(info): 
    104             self.info[i].setText(s)             
     104            self.info[i].setText(s) 
    105105 
    106106    # checks whether any file widget knows of any variable from the current domain 
     
    147147 
    148148            self.dataDomain = data.domain 
    149              
     149 
    150150            # update data info 
    151151            def sp(l): 
     
    174174            self.send("Examples", data) 
    175175            self.send("Attribute Definitions", data.domain) 
    176             self.send("Classified Examples", data.domain.classVar and data or None) 
    177176        else: 
    178             self.send("Classified Examples", None) 
    179177            self.send("Examples", None) 
    180178            self.send("Attribute Definitions", None) 
    181179 
    182          
    183      
     180 
     181 
    184182class OWFile(OWSubFile): 
    185183    def __init__(self,parent=None, signalManager = None): 
     
    187185 
    188186        self.inputs = [] 
    189         self.outputs = [("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass), ("Attribute Definitions", orange.Domain)] 
    190      
     187        self.outputs = [("Examples", ExampleTable), ("Attribute Definitions", orange.Domain)] 
     188 
    191189        #set default settings 
    192190        self.recentFiles=["(none)"] 
     
    194192        #get settings from the ini file, if they exist 
    195193        self.loadSettings() 
    196          
     194 
    197195        #GUI 
    198196        self.box = QHGroupBox("Data File", self.controlArea) 
     
    206204        self.infoa = QLabel('No data loaded.', box) 
    207205        self.infob = QLabel('', box) 
    208              
     206 
    209207        self.resize(150,100) 
    210208 
     
    228226 
    229227 
    230      
     228 
    231229if __name__ == "__main__": 
    232230    a=QApplication(sys.argv) 
  • orange/OrangeWidgets/Data/OWImpute.py

    r3447 r3481  
    66<contact>Janez Demsar</contact> 
    77""" 
    8   
     8 
    99import OWGUI 
    1010from OWWidget import * 
     
    4040    def __init__(self,parent=None, signalManager = None, name = "Impute"): 
    4141        OWWidget.__init__(self, parent, signalManager, name) 
    42          
    43         self.inputs = [("Examples", ExampleTable, self.cdata, Default), ("Learner for Imputation", orange.Learner, self.setModel)] 
    44         self.outputs = [("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass), ("Imputer", orange.ImputerConstructor)] 
     42 
     43        self.inputs = [("Examples", ExampleTable, self.setData, Default), ("Learner for Imputation", orange.Learner, self.setModel)] 
     44        self.outputs = [("Examples", ExampleTable), ("Imputer", orange.ImputerConstructor)] 
    4545 
    4646        self.attrIcons = self.createAttributeIconDict() 
    47          
     47 
    4848        self.defaultMethod = 0 
    4949        self.selectedAttr = 0 
     
    5353        self.methods = {} 
    5454        self.dataChanged = False 
    55          
     55 
    5656        self.model = self.data = None 
    5757 
     
    6767        self.indibox = OWGUI.widgetBox(self.controlArea, "Individual attribute settings", "horizontal") 
    6868 
    69         attrListBox = QVBox(self.indibox)         
     69        attrListBox = QVBox(self.indibox) 
    7070        self.attrList = QListBox(attrListBox) 
    7171        self.attrList.setFixedWidth(220) 
    7272        self.connect(self.attrList, SIGNAL("highlighted ( int )"), self.individualSelected) 
    7373 
    74         indiMethBox = QVBox(self.indibox)        
     74        indiMethBox = QVBox(self.indibox) 
    7575        self.indiButtons = OWGUI.radioButtonsInBox(indiMethBox, self, "indiType", ["Default (above)", "Don't impute", "Avg/Most frequent", "Model-based", "Random", "Value"], 1, callback=self.indiMethodChanged) 
    7676        self.indiValueCtrlBox = OWGUI.indentedBox(self.indiButtons) 
     
    8787        self.btAllToDefault = OWGUI.button(indiMethBox, self, "Set All to Default", callback = self.allToDefault) 
    8888 
    89         OWGUI.separator(self.controlArea, 19, 8)         
     89        OWGUI.separator(self.controlArea, 19, 8) 
    9090 
    9191        box = OWGUI.widgetBox(self.controlArea, "Settings") 
    9292        self.cbImputeClass = OWGUI.checkBox(box, self, "imputeClass", "Impute class values", callback=self.sendIf) 
    93          
    94         OWGUI.separator(self.controlArea, 19, 8)         
     93 
     94        OWGUI.separator(self.controlArea, 19, 8) 
    9595 
    9696        snbox = OWGUI.widgetBox(self.controlArea, self, "Send data and imputer") 
    9797        self.btApply = OWGUI.button(snbox, self, "Apply", callback=self.sendDataAndImputer) 
    9898        OWGUI.checkBox(snbox, self, "autosend", "Send automatically", callback=self.enableAuto, disables = [(-1, self.btApply)]) 
    99         
    100         self.activateLoadedSettings()         
     99 
     100        self.activateLoadedSettings() 
    101101        self.adjustSize() 
    102102 
     
    130130            else: 
    131131                self.indiType = 0 
    132          
     132 
    133133    def individualSelected(self, i): 
    134134        if self.data: 
     
    152152            self.indiValueLineEdit.show() 
    153153            self.indiValueComboBox.hide() 
    154              
     154 
    155155        self.indiValueCtrlBox.update() 
    156156 
     
    199199 
    200200 
    201     def cdata(self,data): 
     201    def setData(self,data): 
    202202        self.closeContext() 
    203          
     203 
    204204        self.methods = {} 
    205205        if not data: 
    206206            self.indibox.setDisabled(True) 
    207             self.attrList.clear()                 
     207            self.attrList.clear() 
    208208            self.data = None 
    209             self.send("Classified Examples", None) 
    210209            self.send("Examples", None) 
    211210        else: 
     
    220219                    pass 
    221220 
    222                 self.attrList.clear()                 
     221                self.attrList.clear() 
    223222                for i, attr in enumerate(self.data.domain): 
    224223                    self.attrList.insertItem(ImputeListboxItem(self.attrIcons[attr.varType], attr.name, self)) 
     
    238237        self.model = model 
    239238        self.sendIf() 
    240          
     239 
    241240 
    242241    def constructImputer(self, *a): 
     
    271270                    probabilities = orange.GaussianDistribution(basstat.avg, basstat.dev) 
    272271                return orange.RandomClassifier(classVar = self.attr, probabilities = probabilities) 
    273                 
     272 
    274273        class AttrModelLearner: 
    275274            def __init__(self, attr, model): 
     
    281280                newdata = orange.Filter_hasClassValue(newdata) 
    282281                return self.model(newdata, weight) 
    283                      
     282 
    284283        classVar = self.data.domain.classVar 
    285284        imputeClass = self.imputeClass or classVar and self.methods.get(classVar.name, (0, None))[0] 
     
    316315                msg = "The imputed values for some attributes (%s, ...) are not specified." % ", ".join(missingValues[:3]) 
    317316            self.warning(0, msg + "\nAverages and/or majority values are used instead.") 
    318              
     317 
    319318        if classVar and not imputeClass: 
    320319            imputerModels.append(lambda e, wei=0: None) 
     
    322321        self.imputer = lambda ex, wei=0, ic=imputerModels: orange.Imputer_model(models=[i(ex, wei) for i in ic]) 
    323322 
    324          
     323 
    325324    def sendIf(self): 
    326325        if self.autosend: 
     
    348347                data = None 
    349348            self.send("Examples", data) 
    350             self.send("Classified Examples", self.data.domain.classVar and data or None) 
    351349        else: 
    352350            self.dataChanged = False 
     
    360358    a.setMainWidget(ow) 
    361359    ow.show() 
    362     ow.cdata(data) 
     360    ow.setData(data) 
    363361    a.exec_loop() 
    364     ow.cdata(None) 
     362    ow.setData(None) 
    365363    ow.saveSettings() 
  • orange/OrangeWidgets/Data/OWPurgeDomain.py

    r3368 r3481  
    33<description>Removes redundant values and attributes, sorts values.</description> 
    44<icon>icons/PurgeDomain.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>1105</priority> 
    77""" 
     
    1010 
    1111class OWPurgeDomain(OWWidget): 
    12      
     12 
    1313    def __init__(self, parent=None, signalManager=None): 
    1414        OWWidget.__init__(self, parent, signalManager, 'PurgeDomain') 
    1515        self.settingsList=["removeValues", "removeAttributes", "removeClassAttribute", "removeClasses", "autoSend", "sortValues", "sortClasses"] 
    16          
    17         self.inputs = [("Examples", ExampleTable, self.cdata)] 
    18         self.outputs = [("Examples", ExampleTable), ("Classified Examples", ExampleTableWithClass)] 
     16 
     17        self.inputs = [("Examples", ExampleTable, self.setData)] 
     18        self.outputs = [("Examples", ExampleTable)] 
    1919 
    2020        self.data = None 
    21          
     21 
    2222        self.preRemoveValues = self.removeValues = 1 
    2323        self.removeAttributes = 1 
     
    3232 
    3333        self.removedAttrs = self.reducedAttrs = self.resortedAttrs = self.classAttr = "-" 
    34          
     34 
    3535        boxAt = OWGUI.widgetBox(self.controlArea, "Attributes") 
    3636        OWGUI.checkBox(boxAt, self, 'sortValues', 'Sort attribute values', callback = self.optionsChanged) 
     
    4040        ruv = OWGUI.checkBox(boxH, self, "removeValues", "Remove unused attribute values", callback = self.optionsChanged) 
    4141        rua.disables = [ruv] 
    42          
     42 
    4343        OWGUI.separator(self.controlArea) 
    4444 
     
    5757 
    5858        OWGUI.setStopper(self, btSend, cbAutoSend, "dataChanged", self.process) 
    59          
     59 
    6060        OWGUI.separator(self.controlArea, height=24) 
    6161 
     
    6666        OWGUI.label(box3, self, "Class attribute: %(classAttr)s") 
    6767 
    68         self.adjustSize()         
    69  
    70     def cdata(self, dataset): 
     68        self.adjustSize() 
     69 
     70    def setData(self, dataset): 
    7171        if dataset: 
    7272            self.data = dataset 
     
    7575            self.reducedAttrs = self.removedAttrs = self.resortedAttrs = self.classAttr = "" 
    7676            self.send("Examples", None) 
    77             self.send("Classified Examples", None) 
    7877            self.data = None 
    7978        self.dataChanged = False 
     
    8685            self.removeValues = self.preRemoveValues 
    8786        self.optionsChanged() 
    88              
     87 
    8988    def removeClassesChanged(self): 
    9089        if not self.removeClassAttribute: 
     
    109108        if newvalues == list(interattr.values): 
    110109            return interattr 
    111          
     110 
    112111        newattr = orange.EnumVariable(interattr.name, values=newvalues) 
    113112        newattr.getValueFrom = orange.ClassifierByLookupTable(newattr, attr) 
     
    141140                        self.removedAttrs += 1 
    142141                        continue 
    143                      
     142 
    144143                    if newattr != attr: 
    145144                        self.reducedAttrs += 1 
    146145                else: 
    147146                    newattr = attr 
    148                      
     147 
    149148                if self.removeValues and len(newattr.values) < 2: 
    150149                    self.removedAttrs += 1 
     
    156155                        self.resortedAttrs += 1 
    157156                        newattr = newnewattr 
    158                      
     157 
    159158                newattrs.append(newattr) 
    160159        else: 
     
    175174        else: 
    176175            self.classAttr = "" 
    177              
     176 
    178177            if self.removeClasses: 
    179178                newclass = orange.RemoveUnusedValues(klass, self.data) 
    180179            else: 
    181180                newclass = klass 
    182                  
     181 
    183182            if not newclass or self.removeClassAttribute and len(newclass.values) < 2: 
    184183                newclass = None 
     
    204203        else: 
    205204            newData = self.data 
    206              
     205 
    207206        self.send("Examples", newData) 
    208         if newclass: 
    209             self.send("Classified Examples", newData) 
    210         else: 
    211             self.send("Classified Examples", None) 
    212  
    213         self.dataChanged = False             
     207 
     208        self.dataChanged = False 
    214209 
    215210 
     
    221216    data = orange.ExampleTable('..\\..\\doc\\datasets\\car.tab') 
    222217    data.domain.attributes[3].values.append("X") 
    223     ow.cdata(data) 
     218    ow.setData(data) 
    224219    ow.show() 
    225220    appl.exec_loop() 
  • orange/OrangeWidgets/Data/OWRank.py

    r3420 r3481  
    33<description>Ranks and filters attributes by their relevance.</description> 
    44<icon>icons/Rank.png</icon> 
    5 <contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact>  
     5<contact>Janez Demsar (janez.demsar(@at@)fri.uni-lj.si)</contact> 
    66<priority>1102</priority> 
    77""" 
     
    1818    estimators        = [orange.MeasureAttribute_relief, orange.MeasureAttribute_info, orange.MeasureAttribute_gainRatio, orange.MeasureAttribute_gini] 
    1919    handlesContinuous = [True, False, False, False] 
    20      
     20 
    2121    def __init__(self,parent=None, signalManager = None): 
    2222        OWWidget.__init__(self, parent, signalManager, "Rank") 
    23          
    24         self.inputs = [("Classified Examples", ExampleTableWithClass, self.cdata)] 
    25         self.outputs = [("Reduced Example Table", ExampleTableWithClass, Default + Single), ("ExampleTable Attributes", ExampleTable, NonDefault)] 
     23 
     24        self.inputs = [("Examples", ExampleTable, self.setData)] 
     25        self.outputs = [("Reduced Example Table", ExampleTable, Default + Single), ("ExampleTable Attributes", ExampleTable, NonDefault)] 
    2626 
    2727        self.settingsList += self.measuresAttrs 
    28          
     28 
    2929        self.nDecimals = 3 
    3030        self.reliefK = 10 
     
    3838        for meas in self.measuresAttrs: 
    3939            setattr(self, meas, True) 
    40              
     40 
    4141        self.loadSettings() 
    4242 
    43         labelWidth = 80         
     43        labelWidth = 80 
    4444 
    4545        box = OWGUI.widgetBox(self.controlArea, "Measures", addSpace=True) 
     
    5757        box = OWGUI.widgetBox(self.controlArea, "Discretization", addSpace=True) 
    5858        OWGUI.spin(box, self, "nIntervals", 2, 20, label="Intervals", labelWidth=labelWidth, orientation=0, callback=self.discretizationChanged, callbackOnReturn = True) 
    59          
     59 
    6060        box = OWGUI.widgetBox(self.controlArea, "Precision", addSpace=True) 
    6161        OWGUI.spin(box, self, "nDecimals", 1, 6, label="No. of decimals", labelWidth=labelWidth, orientation=0, callback=self.decimalsChanged) 
    6262 
    63         OWGUI.rubber(self.controlArea)         
     63        OWGUI.rubber(self.controlArea) 
    6464 
    6565        selMethBox = OWGUI.radioButtonsInBox(self.controlArea, self, "selectMethod", ["None", "All", "Manual", "Best ranked"], box="Select attributes", callback=self.selectMethodChanged) 
    6666        OWGUI.spin(OWGUI.indentedBox(selMethBox), self, "nSelected", 1, 100, label="No. selected"+"  ", orientation=0, callback=self.nSelectedChanged) 
    67          
     67 
    6868        OWGUI.separator(selMethBox) 
    6969 
     
    7171        autoApplyCB = OWGUI.checkBox(selMethBox, self, "autoApply", "Commit automatically") 
    7272        OWGUI.setStopper(self, applyButton, autoApplyCB, "dataChanged", self.apply) 
    73          
     73 
    7474        self.layout=QVBoxLayout(self.mainArea) 
    7575        box = OWGUI.widgetBox(self.mainArea, orientation=0) 
     
    104104        self.adjustCol0 = True 
    105105        self.lastSentAttrs = None 
    106          
     106 
    107107        self.table.setNumRows(0) 
    108108        self.table.adjustSize() 
    109109 
    110          
     110 
    111111    def selectMethodChanged(self): 
    112112        if self.selectMethod == 0: 
     
    135135        self.send("ExampleTable Attributes", orange.ExampleTable(orange.Domain(attrs, self.data.domain.classVar), self.data)) 
    136136 
    137          
    138     def cdata(self,data): 
     137 
     138    def setData(self,data): 
    139139        self.resetInternals() 
    140          
    141         self.data = data 
     140 
     141        self.data = self.isDataWithClass(data, orange.VarTypes.Discrete) and data or None 
    142142        if self.data: 
    143143            self.adjustCol0 = True 
     
    146146            self.reprint() 
    147147            self.table.adjustSize() 
    148              
     148 
    149149        self.resendAttributes() 
    150150        self.applyIf() 
     
    153153    def discretizationChanged(self): 
    154154        self.discretizedData = None 
    155          
     155 
    156156        removed = False 
    157157        for meas, cont in zip(self.measuresAttrs, self.handlesContinuous): 
     
    198198            self.table.setColumnWidth(col+2, 80) 
    199199 
    200          
     200 
    201201    def measuresChanged(self): 
    202202        self.setMeasures() 
     
    219219        self.reprint(True) 
    220220 
    221          
     221 
    222222    def getMeasure(self, meas_idx): 
    223223        measAttr = self.measuresAttrs[meas_idx] 
     
    264264        return mdict 
    265265 
    266          
     266 
    267267    def reprint(self, noSort = False): 
    268268        if not self.data: 
    269269            return 
    270          
     270 
    271271        prec = " %%.%df" % self.nDecimals 
    272272 
    273273        if not noSort: 
    274274            self.resort() 
    275          
     275 
    276276        for row, attr in enumerate(self.attributeOrder): 
    277277            self.table.setText(row, 0, attr.name) 
     
    288288            for row, attr in enumerate(self.attributeOrder): 
    289289                self.table.setText(row, col+2, mdict[attr] != None and prec % mdict[attr] or "NA") 
    290                  
     290 
    291291        self.reselect() 
    292292 
     
    314314 
    315315        self.send("ExampleTable Attributes", attrData) 
    316                                
     316 
    317317 
    318318    def selectRow(self, i, *foo): 
    319319        if i < 0: 
    320320            return 
    321          
     321 
    322322        attr = self.attributeOrder[i] 
    323323        if attr in self.selected: 
     
    376376        else: 
    377377            self.dataChanged = True 
    378              
     378 
    379379    def apply(self): 
    380380        if not self.data or not self.selected: 
     
    385385                self.send("Reduced Example Table", orange.ExampleTable(orange.Domain(self.selected, self.data.domain.classVar), self.data)) 
    386386                self.lastSentAttrs = self.selected[:] 
    387              
     387 
    388388        self.dataChanged = False 
    389      
     389 
    390390 
    391391if __name__=="__main__": 
     
    393393    ow=OWRank() 
    394394    a.setMainWidget(ow) 
    395     ow.cdata(orange.ExampleTable("../../doc/datasets/iris.tab")) 
     395    ow.setData(orange.ExampleTable("../../doc/datasets/iris.tab")) 
    396396    ow.show() 
    397397    a.exec_loop() 
    398      
     398 
    399399    ow.saveSettings() 
    400400 
  • orange/OrangeWidgets/Data/OWSelectData.py

    r3371 r3481  
    2424 
    2525        # set channels 
    26         self.inputs = [("Examples", ExampleTable, self.onDataInput)] 
    27         self.outputs = [("Matching Examples", ExampleTable, Default), ("Non-Matching Examples", ExampleTable), ("Matching Classified Examples", ExampleTableWithClass, Default), ("Non-Matching Classified Examples", ExampleTableWithClass)] 
     26        self.inputs = [("Examples", ExampleTable, self.setData)] 
     27        self.outputs = [("Matching Examples", ExampleTable, Default), ("Non-Matching Examples", ExampleTable)] 
    2828 
    2929        # manually set member variables 
     
    5252        self.loadedConditions = [] 
    5353        self.loadSettings() 
    54          
     54 
    5555        # GUI 
    5656        self.mainArea.setFixedWidth(0) 
     
    146146        self.btnNew = OWGUI.button(self.boxButtons, self, "Add", self.OnNewCondition) 
    147147        self.btnUpdate = OWGUI.button(self.boxButtons, self, "Update", self.OnUpdateCondition) 
    148         self.btnRemove = OWGUI.button(self.boxButtons, self, "Remove", self.OnRemoveCondition)         
    149         self.btnOR = OWGUI.button(self.boxButtons, self, "OR", self.OnDisjunction)         
    150         self.btnMoveUp = OWGUI.button(self.boxButtons, self, "Move Up", self.btnMoveUpClicked)         
     148        self.btnRemove = OWGUI.button(self.boxButtons, self, "Remove", self.OnRemoveCondition) 
     149        self.btnOR = OWGUI.button(self.boxButtons, self, "OR", self.OnDisjunction) 
     150        self.btnMoveUp = OWGUI.button(self.boxButtons, self, "Move Up", self.btnMoveUpClicked) 
    151151        self.btnMoveDown = OWGUI.button(self.boxButtons, self, "Move Down", self.btnMoveDownClicked) 
    152152        self.btnRemove.setEnabled(False) 
     
    183183        boxDataOut = QVGroupBox(ca) 
    184184        boxDataOut.setTitle('Data Out') 
    185         gl.addWidget(boxDataOut, 3,1)         
     185        gl.addWidget(boxDataOut, 3,1) 
    186186        self.dataOutExamplesLabel = OWGUI.widgetLabel(boxDataOut, "num examples") 
    187187        self.dataOutAttributesLabel = OWGUI.widgetLabel(boxDataOut, "num attributes") 
     
    198198        # icons 
    199199        self.icons = self.createAttributeIconDict() 
    200         self.onDataInput(None) 
     200        self.setData(None) 
    201201        self.lbOperatorsD.setCurrentItem(0) 
    202202        self.lbOperatorsC.setCurrentItem(0) 
     
    209209    ############################################################################################################################################################ 
    210210 
    211     def onDataInput(self, data): 
     211    def setData(self, data): 
    212212        """Loads stored conditions (if we have a similar domain), updates list boxes and data in info, sends out data. 
    213213        """ 
     
    304304                if newDomain != matchingOutput.domain: 
    305305                    matchingOutput = orange.ExampleTable(newDomain, matchingOutput) 
    306                      
     306 
    307307                newDomain = remover(nonMatchingOutput, 0, True, self.purgeClasses) 
    308308                if newDomain != nonMatchingOutput.domain: 
     
    312312        self.send("Non-Matching Examples", nonMatchingOutput) 
    313313 
    314         if hasClass: 
    315             self.send("Matching Classified Examples", matchingOutput) 
    316             self.send("Non-Matching Classified Examples", nonMatchingOutput) 
    317         else: 
    318             self.send("Matching Classified Examples", None) 
    319             self.send("Non-Matching Classified Examples", None) 
    320314        self.updateInfoOut(matchingOutput) 
    321315 
     
    400394        self.btnUpdate.setEnabled(True) 
    401395        self.btnRemove.setEnabled(True) 
    402         # send out new data  
     396        # send out new data 
    403397        if self.updateOnChange: 
    404398            self.setOutput() 
     
    416410                self.oldPurgeClasses = self.purgeClasses 
    417411                self.purgeClasses = False 
    418                  
     412 
    419413        if self.updateOnChange: 
    420414            self.setOutput() 
    421              
     415 
    422416    def OnUpdateCondition(self): 
    423417        """Calls remove and insert. 
     
    439433        # send out new data 
    440434        if self.updateOnChange: 
    441             self.setOutput()         
     435            self.setOutput() 
    442436        self.leSelect.clear() 
    443437 
     
    471465            self.btnUpdate.setEnabled(False) 
    472466            self.btnRemove.setEnabled(False) 
    473         # send out new data  
     467        # send out new data 
    474468        if self.updateOnChange: 
    475             self.setOutput()         
     469            self.setOutput() 
    476470 
    477471 
     
    491485        self.btnUpdate.setEnabled(True) 
    492486        self.btnRemove.setEnabled(True) 
    493         # send out new data  
     487        # send out new data 
    494488        if self.updateOnChange: 
    495             self.setOutput()         
    496          
     489            self.setOutput() 
     490 
    497491 
    498492    def btnMoveUpClicked(self): 
     
    512506        self.updateFilteredDataLens() 
    513507        self.updateMoveButtons() 
    514         # send out new data  
     508        # send out new data 
    515509        if self.updateOnChange: 
    516             self.setOutput()         
    517  
    518          
     510            self.setOutput() 
     511 
     512 
    519513    def btnMoveDownClicked(self): 
    520514        """Moves the selected condition one row down. 
     
    533527        self.updateFilteredDataLens() 
    534528        self.updateMoveButtons() 
    535         # send out new data  
     529        # send out new data 
    536530        if self.updateOnChange: 
    537             self.setOutput()         
     531            self.setOutput() 
    538532 
    539533 
     
    588582        # send out new data 
    589583        if self.updateOnChange: 
    590             self.setOutput()         
     584            self.setOutput() 
    591585 
    592586 
     
    709703        else: 
    710704            self.valuesStack.raiseWidget(0) 
    711              
     705 
    712706 
    713707    def insertCriteriaTableRow(self, cond, row): 
     
    723717        self.criteriaTable.setCurrentCell(row,1) 
    724718 
    725          
     719 
    726720    def getCondtionFromSelection(self): 
    727721        """Returns a condition according to the currently selected attribute / operator / values. 
     
    837831            self.dataInExamplesLabel.setText("No examples.") 
    838832            self.dataInAttributesLabel.setText("No attributes.") 
    839              
    840                          
     833 
     834 
    841835    def updateInfoOut(self, data): 
    842836        """Updates data out info box. 
     
    860854        n = len(l) 
    861855        if n == 0: 
    862             if capitalize:                     
     856            if capitalize: 
    863857                return "No", "s" 
    864858            else: 
     
    882876                int(cond.negated),str(cond.val1),str(cond.val2),int(cond.caseSensitive)) 
    883877 
    884          
     878 
    885879class Condition: 
    886880    def __init__(self, enabled, type, attribute = None, operator = None, negate = False, value1 = None, value2 = None, caseSensitive = False): 
     
    901895    operatorDef = staticmethod("is defined") 
    902896    getOperators = staticmethod(lambda: Operator.operatorsD + Operator.operatorsS + [Operator.operatorDef]) 
    903      
     897 
    904898    _operFilter = {"=":orange.Filter_values.Equal, 
    905899                   "<":orange.Filter_values.Less, 
     
    912906                   "begins with":orange.Filter_values.BeginsWith, 
    913907                   "ends with":orange.Filter_values.EndsWith} 
    914      
     908 
    915909    def __init__(self, operator, varType): 
    916910        """Members: operator, varType, isInterval. 
     
    986980    a.setMainWidget(ow) 
    987981    ow.show() 
    988     ow.onDataInput(data) 
     982    ow.setData(data) 
    989983    a.exec_loop() 
    990984 
Note: See TracChangeset for help on using the changeset viewer.